int [] data = {0, 1, 2, 3, 4, 5};
int [] result = {3, 4, 5};
- AssertAreSame (result, data.AsReallyParallel ().AsOrdered ().Skip (3).ToArray ());
+ AssertAreSame (result, data.AsParallel ().AsOrdered ().Skip (3).ToArray ());
}
[Test]
int [] data = {0, 1, 2, 3, 4, 5};
int [] result = {3, 4, 5};
- AssertAreSame (result, data.AsReallyParallel ().AsOrdered ().Skip (3));
+ AssertAreSame (result, data.AsParallel ().AsOrdered ().Skip (3));
}
[Test]
int [] data = {0, 1, 2, 3, 4, 5};
int [] result = {3, 4, 5};
- AssertAreSame (result, data.AsReallyParallel ().AsOrdered ().SkipWhile (i => i < 3));
+ AssertAreSame (result, data.AsParallel ().AsOrdered ().SkipWhile (i => i < 3));
}
[Test]
int [] data = {0, 1, 2, 3, 4, 5};
int [] result = {0, 1, 2};
- AssertAreSame (result, data.AsReallyParallel ().AsOrdered ().Take (3));
+ AssertAreSame (result, data.AsParallel ().AsOrdered ().Take (3));
}
[Test]
int [] data = {0, 1, 2, 3, 4, 5};
int [] result = {0, 1, 2};
- AssertAreSame (result, data.AsReallyParallel ().AsOrdered ().TakeWhile (i => i < 3));
+ AssertAreSame (result, data.AsParallel ().AsOrdered ().TakeWhile (i => i < 3));
}
[Test]
IEnumerable<int> expected = initial.SelectMany ((i) => Enumerable.Range (1, i));
ParallelTestHelper.Repeat (() => {
- var actual = initial.AsReallyParallel ().AsOrdered ().SelectMany ((i) => Enumerable.Range (1, i));
+ var actual = initial.AsParallel ().AsOrdered ().SelectMany ((i) => Enumerable.Range (1, i));
AssertAreSame (expected, actual);
});
}
{
int [] data = {1, 2, 3};
- Assert.AreEqual (3, data.AsReallyParallel ().AsOrdered ().Last ());
+ Assert.AreEqual (3, data.AsParallel ().AsOrdered ().Last ());
}
[Test]
{
int [] data = {};
- Assert.AreEqual (default (int), data.AsReallyParallel ().AsOrdered ().LastOrDefault ());
+ Assert.AreEqual (default (int), data.AsParallel ().AsOrdered ().LastOrDefault ());
}
[Test]
{
int [] data = {1, 2, 3};
- Assert.AreEqual (1, data.AsReallyParallel ().AsOrdered ().First ());
+ Assert.AreEqual (1, data.AsParallel ().AsOrdered ().First ());
}
[Test]
{
int [] data = {};
- Assert.AreEqual (default (int), data.AsReallyParallel ().AsOrdered ().FirstOrDefault ());
+ Assert.AreEqual (default (int), data.AsParallel ().AsOrdered ().FirstOrDefault ());
}
[Test]
int [] data = {0, 1, 2, 3, 4};
int [] result = {4, 3, 2, 1, 0};
- AssertAreSame (result, ((IEnumerable<int>)data).Select ((i) => i).AsReallyParallel ().AsOrdered ().Reverse ());
- AssertAreSame (result, ParallelEnumerable.Range (0, 5).AsReallyParallel ().AsOrdered ().Reverse ());
+ AssertAreSame (result, ((IEnumerable<int>)data).Select ((i) => i).AsParallel ().AsOrdered ().Reverse ());
+ AssertAreSame (result, ParallelEnumerable.Range (0, 5).AsParallel ().AsOrdered ().Reverse ());
}
[Test]
public void ElementAtTestCase()
{
//ParallelTestHelper.Repeat (() => {
- Assert.AreEqual(1, baseEnumerable.AsReallyParallel ().AsOrdered ().ElementAt(0), "#1");
- Assert.AreEqual(51, baseEnumerable.AsReallyParallel ().AsOrdered ().ElementAt(50), "#2");
- Assert.AreEqual(489, baseEnumerable.AsReallyParallel ().AsOrdered ().ElementAt(488), "#3");
+ Assert.AreEqual(1, baseEnumerable.AsParallel ().AsOrdered ().ElementAt(0), "#1");
+ Assert.AreEqual(51, baseEnumerable.AsParallel ().AsOrdered ().ElementAt(50), "#2");
+ Assert.AreEqual(489, baseEnumerable.AsParallel ().AsOrdered ().ElementAt(488), "#3");
//});
}
{
var items = new [] { 1, 2, 3 };
var items2 = new [] { 1, 2, 3, 4 };
- var actual = items.AsReallyParallel ().Join (items2.AsReallyParallel (), i => i, i => i, (e1, e2) => e1 + e2);
+ var actual = items.AsReallyParallel ().Join (items2.AsParallel (), i => i, i => i, (e1, e2) => e1 + e2);
AreEquivalent (new[] { 2, 4, 6 }, actual);
}
[Test]
- [Category ("NotWorking")] // Deadlocks randomly
public void TestGroupBy ()
{
int num = 100;
public void TakeTestCase()
{
ParallelTestHelper.Repeat (() => {
- ParallelQuery<int> async_res = baseEnumerable.AsReallyParallel ().AsOrdered ().Take(800);
+ ParallelQuery<int> async_res = baseEnumerable.AsParallel ().AsOrdered ().Take(800);
IEnumerable<int> sync = baseEnumerable.Take(800);
AreEquivalent(sync, async_res);
- async_res = baseEnumerable.AsReallyParallel ().AsOrdered ().Take(100);
+ async_res = baseEnumerable.AsParallel ().AsOrdered ().Take(100);
sync = baseEnumerable.Take(100);
AreEquivalent(sync, async_res);
public void SkipTestCase()
{
ParallelTestHelper.Repeat (() => {
- ParallelQuery<int> async_res = baseEnumerable.AsReallyParallel ().AsOrdered().Skip (800);
+ ParallelQuery<int> async_res = baseEnumerable.AsParallel ().AsOrdered().Skip (800);
IEnumerable<int> sync = baseEnumerable.Skip (800);
AreEquivalent (sync, async_res);
int [] result = {0, 1, 2};
- var array = coll.AsReallyParallel ().AsOrdered().ToArray ();
+ var array = coll.AsParallel ().AsOrdered().ToArray ();
AssertAreSame (result, array);
AssertIsOrdered (array, result.Length);
Assert.AreEqual (typeof (int []), array.GetType ());
- array = Enumerable.Range (1, 100).Select ((i) => i).AsReallyParallel ().AsOrdered().ToArray ();
+ array = Enumerable.Range (1, 100).Select ((i) => i).AsParallel ().AsOrdered().ToArray ();
result = Enumerable.Range (1, 100).ToArray ();
AssertAreSame (result, array);
var data2 = new int[] { 1, 2, 4 };
var data3 = new int[] { 1, 2, 3, 4 };
- Assert.IsTrue (data1.AsReallyParallel ().SequenceEqual (data1.AsReallyParallel ()));
- Assert.IsTrue (data2.AsReallyParallel ().SequenceEqual (data2.AsReallyParallel ()));
- Assert.IsTrue (data3.AsReallyParallel ().SequenceEqual (data3.AsReallyParallel ()));
- Assert.IsFalse (data1.AsReallyParallel ().SequenceEqual (data2.AsReallyParallel ()));
- Assert.IsFalse (data1.AsReallyParallel ().SequenceEqual (data3.AsReallyParallel ()));
- Assert.IsFalse (data2.AsReallyParallel ().SequenceEqual (data3.AsReallyParallel ()));
+ Assert.IsTrue (data1.AsParallel ().SequenceEqual (data1.AsParallel ()));
+ Assert.IsTrue (data2.AsParallel ().SequenceEqual (data2.AsParallel ()));
+ Assert.IsTrue (data3.AsParallel ().SequenceEqual (data3.AsParallel ()));
+ Assert.IsFalse (data1.AsParallel ().SequenceEqual (data2.AsParallel ()));
+ Assert.IsFalse (data1.AsParallel ().SequenceEqual (data3.AsParallel ()));
+ Assert.IsFalse (data2.AsParallel ().SequenceEqual (data3.AsParallel ()));
}
[Test]