public static void Aggregate_AggregateException(LabeledOperation source, LabeledOperation operation)
 {
     Functions.AssertThrowsWrapped<DeliberateTestException>(() => operation.Item(DefaultStart, DefaultSize, source.Item).Aggregate((x, y) => x));
     Functions.AssertThrowsWrapped<DeliberateTestException>(() => operation.Item(DefaultStart, DefaultSize, source.Item).Aggregate(0, (x, y) => x + y));
     Functions.AssertThrowsWrapped<DeliberateTestException>(() => operation.Item(DefaultStart, DefaultSize, source.Item).Aggregate(0, (x, y) => x + y, r => r));
     Functions.AssertThrowsWrapped<DeliberateTestException>(() => operation.Item(DefaultStart, DefaultSize, source.Item).Aggregate(0, (a, x) => a + x, (l, r) => l + r, r => r));
     Functions.AssertThrowsWrapped<DeliberateTestException>(() => operation.Item(DefaultStart, DefaultSize, source.Item).Aggregate(() => 0, (a, x) => a + x, (l, r) => l + r, r => r));
 }
 public static void Concat_Unordered(LabeledOperation source, LabeledOperation operation)
 {
     IntegerRangeSet seen = new IntegerRangeSet(DefaultStart, DefaultSize);
     foreach (int i in operation.Item(DefaultStart, DefaultSize / 2, source.Item)
         .Concat(operation.Item(DefaultStart + DefaultSize / 2, DefaultSize / 2, source.Item)))
     {
         seen.Add(i);
     }
     seen.AssertComplete();
 }
 public static void Concat_Unordered_NotPipelined(LabeledOperation source, LabeledOperation operation)
 {
     IntegerRangeSet seen = new IntegerRangeSet(DefaultStart, DefaultSize);
     Assert.All(
         operation.Item(DefaultStart, DefaultSize / 2, source.Item)
             .Concat(operation.Item(DefaultStart + DefaultSize / 2, DefaultSize / 2, source.Item)).ToList(),
         x => seen.Add(x)
         );
     seen.AssertComplete();
 }
        public static void Count_OperationCanceledException_PreCanceled(LabeledOperation source, LabeledOperation operation)
        {
            CancellationTokenSource cs = new CancellationTokenSource();
            cs.Cancel();

            Functions.AssertIsCanceled(cs, () => operation.Item(DefaultStart, DefaultSize, source.Append(WithCancellation(cs.Token)).Item).Count());
            Functions.AssertIsCanceled(cs, () => operation.Item(DefaultStart, DefaultSize, source.Append(WithCancellation(cs.Token)).Item).LongCount());
            Functions.AssertIsCanceled(cs, () => operation.Item(DefaultStart, DefaultSize, source.Append(WithCancellation(cs.Token)).Item).Count(x => true));
            Functions.AssertIsCanceled(cs, () => operation.Item(DefaultStart, DefaultSize, source.Append(WithCancellation(cs.Token)).Item).LongCount(x => true));
        }
        public static void Aggregate_OperationCanceledException_PreCanceled(LabeledOperation source, LabeledOperation operation)
        {
            CancellationTokenSource cs = new CancellationTokenSource();
            cs.Cancel();

            Functions.AssertIsCanceled(cs, () => operation.Item(DefaultStart, DefaultSize, source.Append(WithCancellation(cs.Token)).Item).Aggregate((x, y) => x));
            Functions.AssertIsCanceled(cs, () => operation.Item(DefaultStart, DefaultSize, source.Append(WithCancellation(cs.Token)).Item).Aggregate(0, (x, y) => x + y));
            Functions.AssertIsCanceled(cs, () => operation.Item(DefaultStart, DefaultSize, source.Append(WithCancellation(cs.Token)).Item).Aggregate(0, (x, y) => x + y, r => r));
            Functions.AssertIsCanceled(cs, () => operation.Item(DefaultStart, DefaultSize, source.Append(WithCancellation(cs.Token)).Item).Aggregate(0, (a, x) => a + x, (l, r) => l + r, r => r));
            Functions.AssertIsCanceled(cs, () => operation.Item(DefaultStart, DefaultSize, source.Append(WithCancellation(cs.Token)).Item).Aggregate(() => 0, (a, x) => a + x, (l, r) => l + r, r => r));
        }
        public static void GetEnumerator_AggregateException(LabeledOperation source, LabeledOperation operation)
        {
            IEnumerator <int> enumerator = operation.Item(DefaultStart, DefaultSize, source.Item).GetEnumerator();

            // Spin until concat hits
            // Union-Left needs to spin more than once rarely.
            if (operation.ToString().StartsWith("Concat") || operation.ToString().StartsWith("Union-Left:ParallelEnumerable"))
            {
                Functions.AssertThrowsWrapped <DeliberateTestException>(() => { while (enumerator.MoveNext())
                                                                                {
                                                                                    ;
                                                                                }
                                                                        });
            }
            else
            {
                Functions.AssertThrowsWrapped <DeliberateTestException>(() => enumerator.MoveNext());
            }

            if (operation.ToString().StartsWith("OrderBy") || operation.ToString().StartsWith("ThenBy"))
            {
                Assert.Throws <InvalidOperationException>(() => enumerator.MoveNext());
            }
            else
            {
                Assert.False(enumerator.MoveNext());
            }
        }
        public static void Select_Unordered_NotPipelined(LabeledOperation source, LabeledOperation operation)
        {
            IntegerRangeSet seen = new IntegerRangeSet(-DefaultStart - DefaultSize + 1, DefaultSize);

            Assert.All(operation.Item(DefaultStart, DefaultSize, source.Item).Select(x => - x).ToList(), x => seen.Add(x));
            seen.AssertComplete();
        }
        public static void Cast_Unordered_NotPipelined(LabeledOperation source, LabeledOperation operation)
        {
            IntegerRangeSet seen = new IntegerRangeSet(DefaultStart, DefaultSize);

            Assert.All(operation.Item(DefaultStart, DefaultSize, source.Item).Cast <int?>().ToList(), x => seen.Add((int)x));
            seen.AssertComplete();
        }
        public static void Where_Indexed_Unordered_NotPipelined(LabeledOperation source, LabeledOperation operation)
        {
            IntegerRangeSet seen = new IntegerRangeSet(DefaultStart, DefaultSize / 2);

            Assert.All(operation.Item(DefaultStart, DefaultSize, source.Item).Where((x, index) => x < DefaultStart + DefaultSize / 2).ToList(), x => seen.Add(x));
            seen.AssertComplete();
        }
        public static void ToArray_Unordered(LabeledOperation source, LabeledOperation operation)
        {
            IntegerRangeSet seen = new IntegerRangeSet(DefaultStart, DefaultSize);

            Assert.All(operation.Item(DefaultStart, DefaultSize, source.Item).ToArray(), x => seen.Add(x));
            seen.AssertComplete();
        }
        public static void SelectMany_ResultSelector_Unordered_NotPipelined(LabeledOperation source, LabeledOperation operation)
        {
            IntegerRangeSet seen = new IntegerRangeSet(-DefaultStart - DefaultSize * 2 + 1, DefaultSize * 2);

            Assert.All(operation.Item(0, DefaultSize, source.Item).SelectMany(x => new[] { 0, -1 }, (x, y) => y + -DefaultStart - 2 * x).ToList(), x => seen.Add(x));
            seen.AssertComplete();
        }
 public static void Distinct_Unordered_NotPipelined(LabeledOperation source, LabeledOperation operation)
 {
     IntegerRangeSet seen = new IntegerRangeSet(DefaultStart, DefaultSize);
     ParallelQuery<int> query = operation.Item(DefaultStart * 2, DefaultSize * 2, source.Item).Select(x => x / 2).Distinct();
     Assert.All(query.ToList(), x => seen.Add((int)x));
     seen.AssertComplete();
 }
        public static void Distinct_Unordered_NotPipelined(LabeledOperation source, LabeledOperation operation)
        {
            IntegerRangeSet     seen  = new IntegerRangeSet(DefaultStart, DefaultSize);
            ParallelQuery <int> query = operation.Item(DefaultStart * 2, DefaultSize * 2, source.Item).Select(x => x / 2).Distinct();

            Assert.All(query.ToList(), x => seen.Add((int)x));
            seen.AssertComplete();
        }
        public static void Contains_OperationCanceledException_PreCanceled(LabeledOperation source, LabeledOperation operation)
        {
            CancellationTokenSource cs = new CancellationTokenSource();

            cs.Cancel();

            Functions.AssertIsCanceled(cs, () => operation.Item(DefaultStart, DefaultSize, source.Append(WithCancellation(cs.Token)).Item).Contains(DefaultStart));
        }
        public static void Take_Unordered_NotPipelined(LabeledOperation source, LabeledOperation operation)
        {
            IntegerRangeSet seen  = new IntegerRangeSet(DefaultStart, DefaultSize);
            int             count = 0;

            Assert.All(operation.Item(DefaultStart, DefaultSize, source.Item).Take(DefaultSize / 2).ToList(), x => { seen.Add(x); count++; });
            Assert.Equal(DefaultSize / 2, count);
        }
        public static void ElementAt_OperationCanceledException_PreCanceled(LabeledOperation source, LabeledOperation operation)
        {
            CancellationTokenSource cs = new CancellationTokenSource();

            cs.Cancel();

            Functions.AssertIsCanceled(cs, () => operation.Item(DefaultStart, DefaultSize, (start, count, ignore) => source.Item(start, count).WithCancellation(cs.Token)).ElementAt(0));
        }
 public static void DefaultIfEmpty_Unordered(LabeledOperation source, LabeledOperation operation)
 {
     IntegerRangeSet seen = new IntegerRangeSet(DefaultStart, DefaultSize);
     foreach (int i in operation.Item(DefaultStart, DefaultSize, source.Item).DefaultIfEmpty())
     {
         seen.Add(i);
     }
     seen.AssertComplete();
 }
        public static void SequenceEqual_OperationCanceledException_PreCanceled(LabeledOperation source, LabeledOperation operation)
        {
            CancellationTokenSource cs = new CancellationTokenSource();

            cs.Cancel();

            Functions.AssertIsCanceled(cs, () => operation.Item(DefaultStart, DefaultSize, source.Append(WithCancellation(cs.Token)).Item).SequenceEqual(ParallelEnumerable.Range(0, 2)));
            Functions.AssertIsCanceled(cs, () => ParallelEnumerable.Range(0, 2).SequenceEqual(operation.Item(DefaultStart, DefaultSize, source.Append(WithCancellation(cs.Token)).Item)));
        }
        public static void SelectMany_Indexed_Unordered_NotPipelined(LabeledOperation source, LabeledOperation operation)
        {
            IntegerRangeSet seen    = new IntegerRangeSet(-DefaultStart - DefaultSize * 2 + 1, DefaultSize * 2);
            IntegerRangeSet indices = new IntegerRangeSet(0, DefaultSize);

            Assert.All(operation.Item(0, DefaultSize, source.Item).SelectMany((x, index) => { indices.Add(index); return(new[] { 0, -1 }.Select(y => y + -DefaultStart - 2 * x)); }).ToList(), x => seen.Add(x));
            seen.AssertComplete();
            indices.AssertComplete();
        }
        public static void Select_Unordered(LabeledOperation source, LabeledOperation operation)
        {
            IntegerRangeSet seen = new IntegerRangeSet(-DefaultStart - DefaultSize + 1, DefaultSize);

            foreach (int i in operation.Item(DefaultStart, DefaultSize, source.Item).Select(x => - x))
            {
                seen.Add(i);
            }
            seen.AssertComplete();
        }
        public static void SelectMany_ResultSelector_Unordered(LabeledOperation source, LabeledOperation operation)
        {
            IntegerRangeSet seen = new IntegerRangeSet(-DefaultStart - DefaultSize * 2 + 1, DefaultSize * 2);

            foreach (int i in operation.Item(0, DefaultSize, source.Item).SelectMany(x => new[] { 0, -1 }, (x, y) => y + -DefaultStart - 2 * x))
            {
                seen.Add(i);
            }
            seen.AssertComplete();
        }
 public static void Cast_Unordered(LabeledOperation source, LabeledOperation operation)
 {
     IntegerRangeSet seen = new IntegerRangeSet(DefaultStart, DefaultSize);
     foreach (int? i in operation.Item(DefaultStart, DefaultSize, source.Item).Cast<int?>())
     {
         Assert.True(i.HasValue);
         seen.Add(i.Value);
     }
     seen.AssertComplete();
 }
        public static void DefaultIfEmpty_Unordered(LabeledOperation source, LabeledOperation operation)
        {
            IntegerRangeSet seen = new IntegerRangeSet(DefaultStart, DefaultSize);

            foreach (int i in operation.Item(DefaultStart, DefaultSize, source.Item).DefaultIfEmpty())
            {
                seen.Add(i);
            }
            seen.AssertComplete();
        }
 public static void Distinct_Unordered(LabeledOperation source, LabeledOperation operation)
 {
     IntegerRangeSet seen = new IntegerRangeSet(DefaultStart, DefaultSize);
     ParallelQuery<int> query = operation.Item(DefaultStart * 2, DefaultSize * 2, source.Item).Select(x => x / 2).Distinct();
     foreach (int i in query)
     {
         seen.Add(i);
     }
     seen.AssertComplete();
 }
        public static void Where_Indexed_Unordered(LabeledOperation source, LabeledOperation operation)
        {
            IntegerRangeSet seen = new IntegerRangeSet(DefaultStart, DefaultSize / 2);

            foreach (int i in operation.Item(DefaultStart, DefaultSize, source.Item).Where((x, index) => x < DefaultStart + DefaultSize / 2))
            {
                seen.Add(i);
            }
            seen.AssertComplete();
        }
        public static void Distinct_Unordered(LabeledOperation source, LabeledOperation operation)
        {
            IntegerRangeSet     seen  = new IntegerRangeSet(DefaultStart, DefaultSize);
            ParallelQuery <int> query = operation.Item(DefaultStart * 2, DefaultSize * 2, source.Item).Select(x => x / 2).Distinct();

            foreach (int i in query)
            {
                seen.Add(i);
            }
            seen.AssertComplete();
        }
        public static void Cast_Unordered(LabeledOperation source, LabeledOperation operation)
        {
            IntegerRangeSet seen = new IntegerRangeSet(DefaultStart, DefaultSize);

            foreach (int?i in operation.Item(DefaultStart, DefaultSize, source.Item).Cast <int?>())
            {
                Assert.True(i.HasValue);
                seen.Add(i.Value);
            }
            seen.AssertComplete();
        }
        public static void Take_Unordered(LabeledOperation source, LabeledOperation operation)
        {
            IntegerRangeSet seen  = new IntegerRangeSet(DefaultStart, DefaultSize);
            int             count = 0;

            foreach (int i in operation.Item(DefaultStart, DefaultSize, source.Item).Take(DefaultSize / 2))
            {
                seen.Add(i);
                count++;
            }
            Assert.Equal(DefaultSize / 2, count);
        }
        public static void Select_Index_Unordered(LabeledOperation source, LabeledOperation operation)
        {
            IntegerRangeSet seen    = new IntegerRangeSet(-DefaultStart - DefaultSize + 1, DefaultSize);
            IntegerRangeSet indices = new IntegerRangeSet(0, DefaultSize);

            foreach (int i in operation.Item(DefaultStart, DefaultSize, source.Item).Select((x, index) => { indices.Add(index); return(-x); }))
            {
                seen.Add(i);
            }
            seen.AssertComplete();
            indices.AssertComplete();
        }
        public static void SelectMany_Indexed_ResultSelector_Unordered(LabeledOperation source, LabeledOperation operation)
        {
            IntegerRangeSet seen    = new IntegerRangeSet(-DefaultStart - DefaultSize * 2 + 1, DefaultSize * 2);
            IntegerRangeSet indices = new IntegerRangeSet(0, DefaultSize);

            foreach (int i in operation.Item(0, DefaultSize, source.Item).SelectMany((x, index) => { indices.Add(index); return(new[] { 0, -1 }); }, (x, y) => y + -DefaultStart - 2 * x))
            {
                seen.Add(i);
            }
            seen.AssertComplete();
            indices.AssertComplete();
        }
        public static void GroupBy_ElementSelector_Unordered_NotPipelined(LabeledOperation source, LabeledOperation operation)
        {
            IntegerRangeSet seenKey = new IntegerRangeSet(DefaultStart / GroupFactor, (DefaultSize + (GroupFactor - 1)) / GroupFactor);

            foreach (IGrouping <int, int> group in operation.Item(DefaultStart, DefaultSize, source.Item).GroupBy(x => x / GroupFactor, y => - y).ToList())
            {
                seenKey.Add(group.Key);
                IntegerRangeSet seenElement = new IntegerRangeSet(1 - Math.Min(DefaultStart + DefaultSize, (group.Key + 1) * GroupFactor), Math.Min(GroupFactor, DefaultSize - (group.Key - 1) * GroupFactor));
                Assert.All(group, x => seenElement.Add(x));
                seenElement.AssertComplete();
            }
            seenKey.AssertComplete();
        }
        public static void GetEnumerator_Unordered(LabeledOperation source, LabeledOperation operation)
        {
            IntegerRangeSet   seen       = new IntegerRangeSet(DefaultStart, DefaultSize);
            IEnumerator <int> enumerator = operation.Item(DefaultStart, DefaultSize, source.Item).GetEnumerator();

            while (enumerator.MoveNext())
            {
                int current = enumerator.Current;
                seen.Add(current);
                Assert.Equal(current, enumerator.Current);
            }
            seen.AssertComplete();

            Assert.Throws <NotSupportedException>(() => enumerator.Reset());
        }
 public static void Join_Unordered_NotPipelined(LabeledOperation source, LabeledOperation operation)
 {
     IntegerRangeSet seen = new IntegerRangeSet(DefaultStart, DefaultSize);
     ParallelQuery<KeyValuePair<int, int>> query = operation.Item(DefaultStart / GroupFactor, DefaultSize / GroupFactor, source.Item)
         .Join(operation.Item(DefaultStart, DefaultSize, source.Item), x => x, y => y / GroupFactor, (x, y) => new KeyValuePair<int, int>(x, y));
     foreach (KeyValuePair<int, int> p in query.ToList())
     {
         Assert.Equal(p.Key, p.Value / GroupFactor);
         seen.Add(p.Value);
     }
     seen.AssertComplete();
 }
 public static void Select_Unordered(LabeledOperation source, LabeledOperation operation)
 {
     IntegerRangeSet seen = new IntegerRangeSet(-DefaultStart - DefaultSize + 1, DefaultSize);
     foreach (int i in operation.Item(DefaultStart, DefaultSize, source.Item).Select(x => -x))
     {
         seen.Add(i);
     }
     seen.AssertComplete();
 }
 public static void Select_Unordered_NotPipelined(LabeledOperation source, LabeledOperation operation)
 {
     IntegerRangeSet seen = new IntegerRangeSet(-DefaultStart - DefaultSize + 1, DefaultSize);
     Assert.All(operation.Item(DefaultStart, DefaultSize, source.Item).Select(x => -x).ToList(), x => seen.Add(x));
     seen.AssertComplete();
 }
 public static void SelectMany_ResultSelector_Unordered(LabeledOperation source, LabeledOperation operation)
 {
     IntegerRangeSet seen = new IntegerRangeSet(-DefaultStart - DefaultSize * 2 + 1, DefaultSize * 2);
     foreach (int i in operation.Item(0, DefaultSize, source.Item).SelectMany(x => new[] { 0, -1 }, (x, y) => y + -DefaultStart - 2 * x))
     {
         seen.Add(i);
     }
     seen.AssertComplete();
 }
 public static void Count_AggregateException(LabeledOperation source, LabeledOperation operation)
 {
     Functions.AssertThrowsWrapped <DeliberateTestException>(() => operation.Item(DefaultStart, DefaultSize, source.Item).Count());
     Functions.AssertThrowsWrapped <DeliberateTestException>(() => operation.Item(DefaultStart, DefaultSize, source.Item).Count(x => true));
 }
 public static void SelectMany_Indexed_ResultSelector_Unordered_NotPipelined(LabeledOperation source, LabeledOperation operation)
 {
     IntegerRangeSet seen = new IntegerRangeSet(-DefaultStart - DefaultSize * 2 + 1, DefaultSize * 2);
     IntegerRangeSet indices = new IntegerRangeSet(0, DefaultSize);
     Assert.All(operation.Item(0, DefaultSize, source.Item).SelectMany((x, index) => { indices.Add(index); return new[] { 0, -1 }; }, (x, y) => y + -DefaultStart - 2 * x).ToList(), x => seen.Add(x));
     seen.AssertComplete();
     indices.AssertComplete();
 }
 public static void ForAll_AggregateException(LabeledOperation source, LabeledOperation operation)
 {
     Functions.AssertThrowsWrapped <DeliberateTestException>(() => operation.Item(DefaultStart, DefaultSize, source.Item).ForAll(x => { }));
 }
 public static void Zip_Unordered(LabeledOperation source, LabeledOperation operation)
 {
     IntegerRangeSet seen = new IntegerRangeSet(DefaultStart, DefaultSize);
     ParallelQuery<int> query = operation.Item(DefaultStart, DefaultSize, source.Item)
         .Zip(operation.Item(0, DefaultSize, source.Item), (x, y) => x);
     foreach (int i in query)
     {
         seen.Add(i);
     }
     seen.AssertComplete();
 }
 public static void Where_Indexed_Unordered_NotPipelined(LabeledOperation source, LabeledOperation operation)
 {
     IntegerRangeSet seen = new IntegerRangeSet(DefaultStart, DefaultSize / 2);
     Assert.All(operation.Item(DefaultStart, DefaultSize, source.Item).Where((x, index) => x < DefaultStart + DefaultSize / 2).ToList(), x => seen.Add(x));
     seen.AssertComplete();
 }
 public static void First_Predicate_None(LabeledOperation source, LabeledOperation operation)
 {
     Assert.Throws <InvalidOperationException>(() => operation.Item(DefaultStart, DefaultSize, source.Item).First(x => false));
 }
 public static void Select_Index_Unordered_NotPipelined(LabeledOperation source, LabeledOperation operation)
 {
     IntegerRangeSet seen = new IntegerRangeSet(-DefaultStart - DefaultSize + 1, DefaultSize);
     IntegerRangeSet indices = new IntegerRangeSet(0, DefaultSize);
     Assert.All(operation.Item(DefaultStart, DefaultSize, source.Item).Select((x, index) => { indices.Add(index); return -x; }).ToList(), x => seen.Add(x));
     seen.AssertComplete();
     indices.AssertComplete();
 }
 public static void ToLookup_AggregateException(LabeledOperation source, LabeledOperation operation)
 {
     Functions.AssertThrowsWrapped <DeliberateTestException>(() => operation.Item(DefaultStart, DefaultSize, source.Item).ToLookup(x => x));
     Functions.AssertThrowsWrapped <DeliberateTestException>(() => operation.Item(DefaultStart, DefaultSize, source.Item).ToLookup(x => x, y => y));
 }
 public static void SequenceEqual_AggregateException(LabeledOperation source, LabeledOperation operation)
 {
     // Sequence equal double wraps queries that throw.
     ThrowsWrapped(() => operation.Item(DefaultStart, DefaultSize, source.Item).SequenceEqual(ParallelEnumerable.Range(DefaultStart, DefaultSize).AsOrdered()));
     ThrowsWrapped(() => ParallelEnumerable.Range(DefaultStart, DefaultSize).AsOrdered().SequenceEqual(operation.Item(DefaultStart, DefaultSize, source.Item)));
 }
 public static void Take_Unordered(LabeledOperation source, LabeledOperation operation)
 {
     IntegerRangeSet seen = new IntegerRangeSet(DefaultStart, DefaultSize);
     int count = 0;
     foreach (int i in operation.Item(DefaultStart, DefaultSize, source.Item).Take(DefaultSize / 2))
     {
         seen.Add(i);
         count++;
     }
     Assert.Equal(DefaultSize / 2, count);
 }
 public static void Intersect_Unordered(LabeledOperation source, LabeledOperation operation)
 {
     IntegerRangeSet seen = new IntegerRangeSet(DefaultStart, DefaultSize);
     ParallelQuery<int> query = operation.Item(DefaultStart - DefaultSize / 2, DefaultSize + DefaultSize / 2, source.Item)
         .Intersect(operation.Item(DefaultStart, DefaultSize + DefaultSize / 2, source.Item));
     foreach (int i in query)
     {
         seen.Add(i);
     }
     seen.AssertComplete();
 }
 public static void GroupJoin_Unordered_NotPipelined(LabeledOperation source, LabeledOperation operation)
 {
     IntegerRangeSet seenKey = new IntegerRangeSet(DefaultStart / GroupFactor, DefaultSize / GroupFactor);
     foreach (KeyValuePair<int, IEnumerable<int>> group in operation.Item(DefaultStart / GroupFactor, DefaultSize / GroupFactor, source.Item)
         .GroupJoin(operation.Item(DefaultStart, DefaultSize, source.Item), x => x, y => y / GroupFactor, (k, g) => new KeyValuePair<int, IEnumerable<int>>(k, g)).ToList())
     {
         Assert.True(seenKey.Add(group.Key));
         IntegerRangeSet seenElement = new IntegerRangeSet(group.Key * GroupFactor, GroupFactor);
         Assert.All(group.Value, x => seenElement.Add(x));
         seenElement.AssertComplete();
     }
     seenKey.AssertComplete();
 }
 public static void Zip_Unordered_NotPipelined(LabeledOperation source, LabeledOperation operation)
 {
     IntegerRangeSet seen = new IntegerRangeSet(DefaultStart, DefaultSize);
     ParallelQuery<int> query = operation.Item(0, DefaultSize, source.Item)
         .Zip(operation.Item(DefaultStart, DefaultSize, source.Item), (x, y) => y);
     Assert.All(query.ToList(), x => seen.Add(x));
     seen.AssertComplete();
 }
        public static void GetEnumerator_Unordered(LabeledOperation source, LabeledOperation operation)
        {
            IntegerRangeSet seen = new IntegerRangeSet(DefaultStart, DefaultSize);
            IEnumerator<int> enumerator = operation.Item(DefaultStart, DefaultSize, source.Item).GetEnumerator();
            while (enumerator.MoveNext())
            {
                int current = enumerator.Current;
                seen.Add(current);
                Assert.Equal(current, enumerator.Current);
            }
            seen.AssertComplete();

            Assert.Throws<NotSupportedException>(() => enumerator.Reset());
        }
 public static void GroupBy_ElementSelector_Unordered_NotPipelined(LabeledOperation source, LabeledOperation operation)
 {
     IntegerRangeSet seenKey = new IntegerRangeSet(DefaultStart / GroupFactor, (DefaultSize + (GroupFactor - 1)) / GroupFactor);
     foreach (IGrouping<int, int> group in operation.Item(DefaultStart, DefaultSize, source.Item).GroupBy(x => x / GroupFactor, y => -y).ToList())
     {
         seenKey.Add(group.Key);
         IntegerRangeSet seenElement = new IntegerRangeSet(1 - Math.Min(DefaultStart + DefaultSize, (group.Key + 1) * GroupFactor), Math.Min(GroupFactor, DefaultSize - (group.Key - 1) * GroupFactor));
         Assert.All(group, x => seenElement.Add(x));
         seenElement.AssertComplete();
     }
     seenKey.AssertComplete();
 }
 public static void Select_Index_Unordered(LabeledOperation source, LabeledOperation operation)
 {
     IntegerRangeSet seen = new IntegerRangeSet(-DefaultStart - DefaultSize + 1, DefaultSize);
     IntegerRangeSet indices = new IntegerRangeSet(0, DefaultSize);
     foreach (int i in operation.Item(DefaultStart, DefaultSize, source.Item).Select((x, index) => { indices.Add(index); return -x; }))
     {
         seen.Add(i);
     }
     seen.AssertComplete();
     indices.AssertComplete();
 }
 public static void DefaultIfEmpty_Unordered_NotPipelined(LabeledOperation source, LabeledOperation operation)
 {
     IntegerRangeSet seen = new IntegerRangeSet(DefaultStart, DefaultSize);
     Assert.All(operation.Item(DefaultStart, DefaultSize, source.Item).DefaultIfEmpty().ToList(), x => seen.Add((int)x));
     seen.AssertComplete();
 }
        public static void LastOrDefault_OperationCanceledException_PreCanceled(LabeledOperation source, LabeledOperation operation)
        {
            CancellationTokenSource cs = new CancellationTokenSource();

            cs.Cancel();

            Functions.AssertIsCanceled(cs, () => operation.Item(DefaultStart, DefaultSize, (start, count, ignore) => source.Item(start, count).WithCancellation(cs.Token)).LastOrDefault());
            Functions.AssertIsCanceled(cs, () => operation.Item(DefaultStart, DefaultSize, source.Append(WithCancellation(cs.Token)).Item).LastOrDefault(x => true));
        }
 public static void Take_Unordered_NotPipelined(LabeledOperation source, LabeledOperation operation)
 {
     IntegerRangeSet seen = new IntegerRangeSet(DefaultStart, DefaultSize);
     int count = 0;
     Assert.All(operation.Item(DefaultStart, DefaultSize, source.Item).Take(DefaultSize / 2).ToList(), x => { seen.Add(x); count++; });
     Assert.Equal(DefaultSize / 2, count);
 }
 public static void SelectMany_Unordered_NotPipelined(LabeledOperation source, LabeledOperation operation)
 {
     IntegerRangeSet seen = new IntegerRangeSet(-DefaultStart - DefaultSize * 2 + 1, DefaultSize * 2);
     Assert.All(operation.Item(0, DefaultSize, source.Item).SelectMany(x => new[] { 0, -1 }.Select(y => y + -DefaultStart - 2 * x)).ToList(), x => seen.Add(x));
     seen.AssertComplete();
 }
 public static void ToArray_Unordered(LabeledOperation source, LabeledOperation operation)
 {
     IntegerRangeSet seen = new IntegerRangeSet(DefaultStart, DefaultSize);
     Assert.All(operation.Item(DefaultStart, DefaultSize, source.Item).ToArray(), x => seen.Add(x));
     seen.AssertComplete();
 }
 public static void Where_Indexed_Unordered(LabeledOperation source, LabeledOperation operation)
 {
     IntegerRangeSet seen = new IntegerRangeSet(DefaultStart, DefaultSize / 2);
     foreach (int i in operation.Item(DefaultStart, DefaultSize, source.Item).Where((x, index) => x < DefaultStart + DefaultSize / 2))
     {
         seen.Add(i);
     }
     seen.AssertComplete();
 }
 public static void SelectMany_Indexed_ResultSelector_Unordered(LabeledOperation source, LabeledOperation operation)
 {
     IntegerRangeSet seen = new IntegerRangeSet(-DefaultStart - DefaultSize * 2 + 1, DefaultSize * 2);
     IntegerRangeSet indices = new IntegerRangeSet(0, DefaultSize);
     foreach (int i in operation.Item(0, DefaultSize, source.Item).SelectMany((x, index) => { indices.Add(index); return new[] { 0, -1 }; }, (x, y) => y + -DefaultStart - 2 * x))
     {
         seen.Add(i);
     }
     seen.AssertComplete();
     indices.AssertComplete();
 }
 public static void ElementAtOrDefault_AggregateException(LabeledOperation source, LabeledOperation operation)
 {
     Functions.AssertThrowsWrapped <DeliberateTestException>(() => operation.Item(DefaultStart, DefaultSize, source.Item).ElementAtOrDefault(DefaultSize - 1));
     Functions.AssertThrowsWrapped <DeliberateTestException>(() => operation.Item(DefaultStart, DefaultSize, source.Item).ElementAtOrDefault(DefaultSize + 1));
 }