public static void Reverse_Unordered_NotPipelined(Labeled<ParallelQuery<int>> labeled, int count) { ParallelQuery<int> query = labeled.Item; IntegerRangeSet seen = new IntegerRangeSet(0, count); Assert.All(query.Reverse().ToList(), x => seen.Add(x)); seen.AssertComplete(); }
public static void ToDictionary(int count) { IntegerRangeSet seen = new IntegerRangeSet(0, count); Assert.All(UnorderedSources.Default(count).ToDictionary(x => x * 2), p => { seen.Add(p.Key / 2); Assert.Equal(p.Key, p.Value * 2); }); seen.AssertComplete(); }
public static void ToDictionary_ElementSelector_CustomComparator(int count) { IntegerRangeSet seen = new IntegerRangeSet(0, count); Assert.All(UnorderedSources.Default(count).ToDictionary(x => x, y => y * 2, new ModularCongruenceComparer(count)), p => { seen.Add(p.Key); Assert.Equal(p.Key * 2, p.Value); }); seen.AssertComplete(); }
public static void Cast_Unordered_Valid_NotPipelined(Labeled<ParallelQuery<int>> labeled, int count) { ParallelQuery<int> query = labeled.Item; IntegerRangeSet seen = new IntegerRangeSet(0, count); Assert.All(query.Select(x => (object)x).Cast<int>().ToList(), x => seen.Add(x)); seen.AssertComplete(); }
public static void GetEnumerator_Unordered(Labeled<ParallelQuery<int>> labeled, int count) { IntegerRangeSet seen = new IntegerRangeSet(0, count); IEnumerator<int> enumerator = labeled.Item.GetEnumerator(); if (count == 0 && labeled.ToString().Contains("Array")) { Assert.Same(enumerator, labeled.Item.GetEnumerator()); } else { Assert.NotSame(enumerator, labeled.Item.GetEnumerator()); } while (enumerator.MoveNext()) { int current = enumerator.Current; seen.Add(current); Assert.Equal(current, enumerator.Current); } seen.AssertComplete(); if (labeled.ToString().StartsWith("Enumerable.Range") || labeled.ToString().StartsWith("Partitioner")) { Assert.Throws<NotSupportedException>(() => enumerator.Reset()); } else { enumerator.Reset(); seen = new IntegerRangeSet(0, count); while (enumerator.MoveNext()) { Assert.True(seen.Add(enumerator.Current)); } 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 Single_NoMatch(Labeled<ParallelQuery<int>> labeled, int count, int element) { ParallelQuery<int> query = labeled.Item; IntegerRangeSet seen = new IntegerRangeSet(0, count); Assert.Throws<InvalidOperationException>(() => query.Single(x => !seen.Add(x))); seen.AssertComplete(); }
public static void ForAll(Labeled<ParallelQuery<int>> labeled, int count) { ParallelQuery<int> query = labeled.Item; IntegerRangeSet seen = new IntegerRangeSet(0, count); query.ForAll<int>(x => seen.Add(x)); seen.AssertComplete(); }
public static void ToArray_Unordered(Labeled<ParallelQuery<int>> labeled, int count) { ParallelQuery<int> query = labeled.Item; IntegerRangeSet seen = new IntegerRangeSet(0, count); Assert.All(query.ToArray(), x => seen.Add(x)); seen.AssertComplete(); }
public static void Where_Unordered_NotPipelined(Labeled<ParallelQuery<int>> labeled, int count) { ParallelQuery<int> query = labeled.Item; IntegerRangeSet seen = new IntegerRangeSet(0, (count + 1) / 2); Assert.All(query.Where(x => x % 2 == 0).ToList(), x => seen.Add(x / 2)); seen.AssertComplete(); }
public static void Select_Unordered_NotPipelined(int count) { IntegerRangeSet seen = new IntegerRangeSet(0, count); Assert.All(UnorderedSources.Default(count).Select(x => KeyValuePair.Create(x, x * x)).ToList(), p => { seen.Add(p.Key); Assert.Equal(p.Key * p.Key, p.Value); }); seen.AssertComplete(); }
public static void AsSequential_Unordered(Labeled<ParallelQuery<int>> labeled, int count) { IntegerRangeSet seen = new IntegerRangeSet(0, count); IEnumerable<int> seq = labeled.Item.AsSequential(); Assert.All(seq, x => seen.Add(x)); seen.AssertComplete(); }
public static void Any_AllFalse(Labeled<ParallelQuery<int>> labeled, int count) { ParallelQuery<int> query = labeled.Item; IntegerRangeSet seen = new IntegerRangeSet(0, count); Assert.False(query.Any(x => !seen.Add(x))); seen.AssertComplete(); }
public static void ToDictionary(Labeled<ParallelQuery<int>> labeled, int count) { ParallelQuery<int> query = labeled.Item; IntegerRangeSet seen = new IntegerRangeSet(0, count); Assert.All(query.ToDictionary(x => x * 2), p => { seen.Add(p.Key / 2); Assert.Equal(p.Key, p.Value * 2); }); seen.AssertComplete(); }
public static void Skip_Unordered_NotPipelined(int count, int skip) { // For unordered collections, which elements are skipped isn't actually guaranteed, but an effect of the implementation. // If this test starts failing it should be updated, and possibly mentioned in release notes. IntegerRangeSet seen = new IntegerRangeSet(Math.Max(skip, 0), Math.Min(count, Math.Max(0, count - skip))); Assert.All(UnorderedSources.Default(count).Skip(skip).ToList(), x => seen.Add(x)); seen.AssertComplete(); }
public static void Concat_Unordered_NotPipelined(Labeled<ParallelQuery<int>> left, int leftCount, Labeled<ParallelQuery<int>> right, int rightCount) { ParallelQuery<int> leftQuery = left.Item; ParallelQuery<int> rightQuery = right.Item; IntegerRangeSet seen = new IntegerRangeSet(0, leftCount + rightCount); Assert.All(leftQuery.Concat(rightQuery).ToList(), x => seen.Add(x)); seen.AssertComplete(); }
public static void ToDictionary_ElementSelector_CustomComparator(Labeled<ParallelQuery<int>> labeled, int count) { ParallelQuery<int> query = labeled.Item; IntegerRangeSet seen = new IntegerRangeSet(0, count); Assert.All(query.ToDictionary(x => x, y => y * 2, new ModularCongruenceComparer(count)), p => { seen.Add(p.Key); Assert.Equal(p.Key * 2, p.Value); }); seen.AssertComplete(); }
public static void Select_Unordered_NotPipelined(Labeled<ParallelQuery<int>> labeled, int count) { ParallelQuery<int> query = labeled.Item; IntegerRangeSet seen = new IntegerRangeSet(0, count); Assert.All(query.Select(x => KeyValuePair.Create(x, x * x)).ToList(), p => { seen.Add(p.Key); Assert.Equal(p.Key * p.Key, p.Value); }); seen.AssertComplete(); }
public static void Reverse_Unordered(int count) { IntegerRangeSet seen = new IntegerRangeSet(0, count); foreach (int i in UnorderedSources.Default(count).Reverse()) { seen.Add(i); } seen.AssertComplete(); }
public static void Join_Unordered_NotPipelined(Labeled<ParallelQuery<int>> left, int leftCount, Labeled<ParallelQuery<int>> right, int rightCount) { ParallelQuery<int> leftQuery = left.Item; ParallelQuery<int> rightQuery = right.Item; IntegerRangeSet seen = new IntegerRangeSet(0, Math.Min(leftCount, (rightCount + (KeyFactor - 1)) / KeyFactor)); Assert.All(leftQuery.Join(rightQuery, x => x * KeyFactor, y => y, (x, y) => KeyValuePair.Create(x, y)).ToList(), p => { Assert.Equal(p.Key * KeyFactor, p.Value); seen.Add(p.Key); }); seen.AssertComplete(); }
public static void OfType_Unordered_AllValid(int count) { IntegerRangeSet seen = new IntegerRangeSet(0, count); foreach (int i in UnorderedSources.Default(count).Select(x => (object)x).OfType<int>()) { seen.Add(i); } seen.AssertComplete(); }
public static void Distinct_Unordered(int count, int uniqueCount) { IntegerRangeSet seen = new IntegerRangeSet(0, uniqueCount); foreach (int i in UnorderedSources.Default(count).Distinct(new ModularCongruenceComparer(uniqueCount))) { seen.Add(i % uniqueCount); } seen.AssertComplete(); }
public static void Take_Unordered_NotPipelined(Labeled<ParallelQuery<int>> labeled, int count, int take) { ParallelQuery<int> query = labeled.Item; // For unordered collections, which elements (if any) are taken isn't actually guaranteed, but an effect of the implementation. // If this test starts failing it should be updated, and possibly mentioned in release notes. IntegerRangeSet seen = new IntegerRangeSet(0, Math.Min(count, Math.Max(0, take))); Assert.All(query.Take(take).ToList(), x => seen.Add(x)); seen.AssertComplete(); }
public static void ToLookup_ElementSelector(int count) { IntegerRangeSet seen = new IntegerRangeSet(0, count); ILookup<int, int> lookup = UnorderedSources.Default(count).ToLookup(x => x, y => y * 2); Assert.All(lookup, group => { seen.Add(group.Key); Assert.Equal(group.Key * 2, Assert.Single(group)); }); seen.AssertComplete(); Assert.Empty(lookup[-1]); }
public static void Concat_Unordered(int leftCount, int rightCount) { IntegerRangeSet seen = new IntegerRangeSet(0, leftCount + rightCount); foreach (int i in UnorderedSources.Default(0, leftCount).Concat(UnorderedSources.Default(leftCount, rightCount))) { seen.Add(i); } 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 ToLookup_ElementSelector(Labeled<ParallelQuery<int>> labeled, int count) { ParallelQuery<int> query = labeled.Item; IntegerRangeSet seen = new IntegerRangeSet(0, count); ILookup<int, int> lookup = query.ToLookup(x => x, y => y * 2); Assert.All(lookup, group => { seen.Add(group.Key); Assert.Equal(group.Key * 2, Assert.Single(group)); }); seen.AssertComplete(); Assert.Empty(lookup[-1]); }
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 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(); }