public void TestGroupBy() { int num = 100; Tuple <int, int>[] source = Enumerable.Range(0, num).Select((i) => Tuple.Create(i / 10, i)).ToArray(); ParallelTestHelper.Repeat(() => { ParallelQuery <IGrouping <int, int> > actual = source.AsReallyParallel().GroupBy((e) => e.Item1, (e) => e.Item2, EqualityComparer <int> .Default); foreach (var group in actual) { Assert.GreaterOrEqual(group.Key, 0); Assert.Less(group.Key, num / 10); int count = 0; foreach (var e in group) { count++; Assert.GreaterOrEqual(e, group.Key * 10); Assert.Less(e, (group.Key + 1) * 10); } Assert.AreEqual(10, count, "count"); } }); }
public void TestBigIntersect() { ParallelTestHelper.Repeat(() => { int [] first = Enumerable.Range(1, 10000).ToArray(); int [] second = Enumerable.Range(323, 757).ToArray(); AreEquivalent(second, first.AsReallyParallel().Intersect(second.AsParallel()), 1); }, 10); }
public void SkipTestCase() { ParallelTestHelper.Repeat(() => { ParallelQuery <int> async_res = baseEnumerable.AsParallel().AsOrdered().Skip(800); IEnumerable <int> sync = baseEnumerable.Skip(800); AreEquivalent(sync, async_res); }); }
public void TestOrderBy() { ParallelTestHelper.Repeat(() => { int [] array = { 14, 53, 3, 9, 11, 14, 5, 32, 2 }; var q = array.AsReallyParallel().OrderBy((i) => i); AssertIsOrdered(q, array.Length); }); }
public void CountTestCase() { ParallelTestHelper.Repeat(() => { int sync = baseEnumerable.Count(); int async = baseEnumerable.AsParallel().Count(); Assert.AreEqual(sync, async, "#1"); }); }
public void WhereTestCase() { ParallelTestHelper.Repeat(() => { IEnumerable <int> sync = baseEnumerable.Where(i => i % 2 == 0); IEnumerable <int> async = baseEnumerable.AsParallel().Where(i => i % 2 == 0); AreEquivalent(sync, async, 1); }); }
public void SelectTestCase() { ParallelTestHelper.Repeat(() => { IEnumerable <int> sync = baseEnumerable.Select(i => i * i); IEnumerable <int> async = baseEnumerable.AsParallel().Select(i => i * i); AreEquivalent(sync, async, 1); }); }
public void TestBigUnion() { ParallelTestHelper.Repeat(() => { int [] first = Enumerable.Range(1, 10000).ToArray(); int [] second = Enumerable.Range(323, 757).ToArray(); AreEquivalent(first, first.AsReallyParallel().Union(second.AsParallel())); }); }
public void SkipTestCase() { ParallelTestHelper.Repeat(() => { ParallelQuery <int> async = baseEnumerable.AsReallyParallel().AsOrdered().Skip(2000); IEnumerable <int> sync = baseEnumerable.Skip(2000); AreEquivalent(sync, async, 1); }, 20); }
public void Range_StartOffset() { ParallelTestHelper.Repeat(() => { IEnumerable <int> sync = Enumerable.Range(30, 10); IEnumerable <int> async_res = ParallelEnumerable.Range(30, 10); AreEquivalent(sync, async_res); }); }
public void SkipTestCaseSmall() { ParallelTestHelper.Repeat(() => { var async = baseEnumerable.AsReallyParallel().Skip(100); var sync = baseEnumerable.Skip(100); Assert.AreEqual(sync.Count(), async.Count()); }, 20); }
public void RepeatTestCase() { ParallelTestHelper.Repeat(() => { IEnumerable <int> sync = Enumerable.Repeat(1, 1000); IEnumerable <int> async = ParallelEnumerable.Repeat(1, 1000); AreEquivalent(sync, async, 1); }); }
public void SelectManyTest() { IEnumerable <int> initial = Enumerable.Range(1, 50); IEnumerable <int> expected = initial.SelectMany((i) => Enumerable.Range(1, i)); ParallelTestHelper.Repeat(() => { var actual = initial.AsReallyParallel().SelectMany((i) => Enumerable.Range(1, i)); AreEquivalent(expected, actual, 1); }); }
public void ZipTestCase() { ParallelTestHelper.Repeat(() => { ParallelQuery <int> async_res1 = ParallelEnumerable.Range(0, 10000); ParallelQuery <int> async_res2 = ParallelEnumerable.Repeat(1, 10000).Zip(async_res1, (e1, e2) => e1 + e2); int[] expected = Enumerable.Range(1, 10000).ToArray(); AreEquivalent(expected, Enumerable.ToArray(async_res2)); }); }
public void SelectManyOrderedTest() { IEnumerable <int> initial = Enumerable.Range(1, 50); IEnumerable <int> expected = initial.SelectMany((i) => Enumerable.Range(1, i)); ParallelTestHelper.Repeat(() => { var actual = initial.AsReallyParallel().AsOrdered().SelectMany((i) => Enumerable.Range(1, i)); AssertAreSame(expected, actual); }); }
public void TestSimpleUnion() { ParallelTestHelper.Repeat(() => { int [] first = { 0, 1, 2, 3, 4, 5 }; int [] second = { 2, 4, 6 }; int [] result = { 0, 1, 2, 3, 4, 5, 6 }; AreEquivalent(result, first.AsReallyParallel().Union(second.AsParallel()), 1); }); }
public void ZipTestCase() { ParallelTestHelper.Repeat(() => { ParallelQuery <int> async1 = ParallelEnumerable.Range(0, 10000); ParallelQuery <int> async2 = ParallelEnumerable.Repeat(1, 10000).Zip(async1, (e1, e2) => e1 + e2); int[] expected = Enumerable.Range(1, 10000).ToArray(); CollectionAssert.AreEquivalent(expected, Enumerable.ToArray(async2), "#1"); }); }
public void AggregateTestCase() { ParallelTestHelper.Repeat(() => { ParallelQuery <int> range = ParallelEnumerable.Repeat(5, 2643); double average = range.Aggregate(() => new double[2], (acc, elem) => { acc[0] += elem; acc[1]++; return(acc); }, (acc1, acc2) => { acc1[0] += acc2[0]; acc1[1] += acc2[1]; return(acc1); }, acc => acc[0] / acc[1]); Assert.AreEqual(5.0, average, "#1"); }); }
public void TestBigUnion() { ParallelTestHelper.Repeat(() => { int [] first = Enumerable.Range(1, 10000).ToArray(); int [] second = Enumerable.Range(323, 757).ToArray(); var expected = first; var actual = first.AsReallyParallel().Union(second.AsParallel()).ToArray(); // Work around quadratic behavior in NUnitLite's CollectionTally class Array.Sort(expected); Array.Sort(actual); AreEquivalent(expected, actual); }); }
public void ZipTestCase() { ParallelTestHelper.Repeat(() => { ParallelQuery <int> async_res1 = ParallelEnumerable.Range(0, 10000); ParallelQuery <int> async_res2 = ParallelEnumerable.Repeat(1, 10000).Zip(async_res1, (e1, e2) => e1 + e2); int[] expected = Enumerable.Range(1, 10000).ToArray(); var actual = Enumerable.ToArray(async_res2); // Work around quadratic behavior in NUnitLite's CollectionTally class Array.Sort(expected); Array.Sort(actual); AreEquivalent(expected, actual); }); }
public void TakeTestCase() { ParallelTestHelper.Repeat(() => { ParallelQuery <int> async_res = baseEnumerable.AsReallyParallel().AsOrdered().Take(800); IEnumerable <int> sync = baseEnumerable.Take(800); AreEquivalent(sync, async_res, 1); async_res = baseEnumerable.AsReallyParallel().AsOrdered().Take(100); sync = baseEnumerable.Take(100); AreEquivalent(sync, async_res, 2); }); }
public void UnorderedTakeTestCase() { ParallelTestHelper.Repeat(() => { ParallelQuery <int> async = baseEnumerable.AsReallyParallel().Take(2000); IEnumerable <int> sync = baseEnumerable.Take(2000); Assert.AreEqual(sync.Count(), async.Count(), "#1"); async = baseEnumerable.AsReallyParallel().Take(100); sync = baseEnumerable.Take(100); Assert.AreEqual(sync.Count(), async.Count(), "#2"); }, 20); }
public void TestJoin() { int num = 100; Tuple <int, int>[] outer = Enumerable.Range(1, 50).Select((i) => Tuple.Create(i, num - 2 * i)).ToArray(); Tuple <int, int>[] inner = Enumerable.Range(1, 50).Reverse().Select((i) => Tuple.Create(i, 2 * i)).ToArray(); IEnumerable <int> expected = outer.Join(inner, (e) => e.Item1, (e) => e.Item1, (e1, e2) => e1.Item2 + e2.Item2, EqualityComparer <int> .Default); ParallelTestHelper.Repeat(() => { ParallelQuery <int> actual = outer.AsReallyParallel().Join(inner.AsParallel(), (e) => e.Item1, (e) => e.Item1, (e1, e2) => e1.Item2 + e2.Item2, EqualityComparer <int> .Default); AreEquivalent(expected, actual, 1); }); }
public void TestOrderByIdDescendingThenByNameAscending() { ParallelTestHelper.Repeat(() => { var q = from d in CreateData().AsReallyParallel() orderby d.ID descending, d.Name ascending select d; var list = new List <Data> (q); Assert.AreEqual("Ab", list [0].Name); Assert.AreEqual("Abcd", list [1].Name); Assert.AreEqual("bcd", list [2].Name); Assert.AreEqual("Zyx", list [3].Name); }); }
public void TestOrderByAgeAscendingTheByNameDescending() { ParallelTestHelper.Repeat(() => { var q = from b in CreateBazCollection().AsReallyParallel() orderby b.Age ascending, b.Name descending select b; var expected = new [] { new Baz("jb", 7), new Baz("ana", 20), new Baz("ro", 25), new Baz("jb", 25), new Baz("reg", 28), }; AssertAreSame(expected, q); }); }