public void SkipTestCaseSmall()
{
ParallelTestHelper.Repeat(() => {
var async_res = baseEnumerable.AsReallyParallel().Skip(100);
var sync = baseEnumerable.Skip(100);
Assert.AreEqual(sync.Count(), async_res.Count());
});
}
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 SkipTestCase()
{
ParallelTestHelper.Repeat(() => {
ParallelQuery <int> async_res = baseEnumerable.AsReallyParallel().AsOrdered().Skip(800);
IEnumerable <int> sync = baseEnumerable.Skip(800);
AreEquivalent(sync, async_res);
});
}
public void CountTestCase()
{
ParallelTestHelper.Repeat(() => {
int sync = baseEnumerable.Count();
int async_res = baseEnumerable.AsParallel().Count();
Assert.AreEqual(sync, async_res, "#1");
});
}
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()));
});
}
public void WhereTestCase()
{
ParallelTestHelper.Repeat(() => {
IEnumerable <int> sync = baseEnumerable.Where(i => i % 2 == 0);
IEnumerable <int> async_res = baseEnumerable.AsParallel().Where(i => i % 2 == 0);
AreEquivalent(sync, async_res);
});
}
public void SelectTestCase()
{
ParallelTestHelper.Repeat(() => {
IEnumerable <int> sync = baseEnumerable.Select(i => i * i);
IEnumerable <int> async_res = baseEnumerable.AsParallel().Select(i => i * i);
AreEquivalent(sync, async_res);
});
}
public void RepeatTestCase()
{
ParallelTestHelper.Repeat(() => {
IEnumerable <int> sync = Enumerable.Repeat(1, 1000);
IEnumerable <int> async_res = ParallelEnumerable.Repeat(1, 1000);
AreEquivalent(sync, async_res);
});
}
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 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 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 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 TestBigUnion()
{
ParallelTestHelper.Repeat(() =>
{
int [] first = Enumerable.Range(1, 10000).ToArray();
int [] second = Enumerable.Range(323, 757).ToArray();
AreEquivalent(first, first.AsReallyParallel().Union(second.AsParallel()), 1);
}, 10);
}
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 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 static void ParallelAdder(IProducerConsumerCollection <int> collection, int numThread)
{
int startIndex = -10;
ParallelTestHelper.ParallelStressTest(collection, delegate(IProducerConsumerCollection <int> c) {
int start = Interlocked.Add(ref startIndex, 10);
for (int i = start; i < start + 10; i++)
{
c.TryAdd(i);
}
}, numThread);
}
public static void ParallelRemover(IProducerConsumerCollection <int> collection, int numThread, int times)
{
int t = -1;
ParallelTestHelper.ParallelStressTest(collection, delegate(IProducerConsumerCollection <int> c) {
int num = Interlocked.Increment(ref t);
int value;
if (num < times)
{
c.TryTake(out value);
}
}, numThread);
}
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 TakeTestCase()
{
ParallelTestHelper.Repeat(() => {
ParallelQuery <int> async = baseEnumerable.AsReallyParallel().AsOrdered().Take(2000);
IEnumerable <int> sync = baseEnumerable.Take(2000);
AreEquivalent(sync, async, 1);
async = baseEnumerable.AsReallyParallel().AsOrdered().Take(100);
sync = baseEnumerable.Take(100);
AreEquivalent(sync, async, 2);
}, 20);
}
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.AsParallel().AsOrdered().Take(800);
IEnumerable <int> sync = baseEnumerable.Take(800);
AreEquivalent(sync, async_res);
async_res = baseEnumerable.AsParallel().AsOrdered().Take(100);
sync = baseEnumerable.Take(100);
AreEquivalent(sync, async_res);
});
}
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);
});
}
