public void ParallelForSmallRangeTest()
{
ParallelTestHelper.Repeat(() => {
int test = -1;
Parallel.For(0, 1, (i) => test = i);
Assert.AreEqual(0, test, "#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 void NestedFutureTest()
{
ParallelTestHelper.Repeat(delegate {
var t = CreateNestedFuture(10);
var t2 = CreateNestedFuture(100);
var t3 = CreateNestedFuture(100);
Assert.AreEqual(11, t.Result);
Assert.AreEqual(101, t2.Result);
Assert.AreEqual(101, t3.Result);
}, 50);
}
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 WaitAllTest()
{
ParallelTestHelper.Repeat(delegate
{
int achieved = 0;
InitWithDelegate(delegate
{
Interlocked.Increment(ref achieved);
});
Task.WaitAll(tasks);
Assert.AreEqual(max, achieved, "#1");
});
}
public void ParallelForTestCase()
{
int[] expected = Enumerable.Range(1, 1000).Select((e) => e * 2).ToArray();
ParallelTestHelper.Repeat(() => {
int[] actual = Enumerable.Range(1, 1000).ToArray();
SpinWait sw = new SpinWait();
Parallel.For(0, actual.Length, (i) => { actual[i] *= 2; sw.SpinOnce(); });
CollectionAssert.AreEquivalent(expected, actual, "#1, same");
CollectionAssert.AreEqual(expected, actual, "#2, in order");
});
}
public void ParallelForEachTestCase()
{
ParallelTestHelper.Repeat(() => {
IEnumerable <int> e = Enumerable.Repeat(1, 500);
ConcurrentQueue <int> queue = new ConcurrentQueue <int> ();
SpinWait sw = new SpinWait();
int count = 0;
Parallel.ForEach(e, (element) => { Interlocked.Increment(ref count); queue.Enqueue(element); sw.SpinOnce(); });
Assert.AreEqual(500, count, "#1");
CollectionAssert.AreEquivalent(e, queue, "#2");
});
}
public void ContinueWithOnAnyTestCase()
{
ParallelTestHelper.Repeat(delegate {
bool result = false;
Task t = Task.Factory.StartNew(delegate { });
Task cont = t.ContinueWith(delegate { result = true; }, TaskContinuationOptions.None);
Assert.IsTrue(t.Wait(2000), "First wait, (status, {0})", t.Status);
Assert.IsTrue(cont.Wait(2000), "Cont wait, (result, {0}) (parent status, {2}) (status, {1})", result, cont.Status, t.Status);
Assert.IsNull(cont.Exception, "#1");
Assert.IsNotNull(cont, "#2");
Assert.IsTrue(result, "#3");
});
}
public void ContinueWithOnFailedTestCase()
{
ParallelTestHelper.Repeat(delegate {
bool result = false;
Task t = Task.Factory.StartNew(delegate { throw new Exception("foo"); });
Task cont = t.ContinueWith(delegate { result = true; }, TaskContinuationOptions.OnlyOnFaulted);
Assert.IsTrue(cont.Wait(1000), "#0");
Assert.IsNotNull(t.Exception, "#1");
Assert.IsNotNull(cont, "#2");
Assert.IsTrue(result, "#3");
});
}
public void ContinueWithOnCompletedSuccessfullyTestCase()
{
ParallelTestHelper.Repeat(delegate {
bool result = false;
Task t = Task.Factory.StartNew(delegate { });
Task cont = t.ContinueWith(delegate { result = true; }, TaskContinuationOptions.OnlyOnRanToCompletion);
Assert.IsTrue(t.Wait(1000), "#4");
Assert.IsTrue(cont.Wait(1000), "#5");
Assert.IsNull(cont.Exception, "#1");
Assert.IsNotNull(cont, "#2");
Assert.IsTrue(result, "#3");
});
}
public void ContinueWithChildren()
{
ParallelTestHelper.Repeat(delegate {
bool result = false;
var t = Task.Factory.StartNew(() => Task.Factory.StartNew(() => Thread.Sleep(100), TaskCreationOptions.AttachedToParent));
t.ContinueWith(_ => result = true);
while (!t.IsCompleted)
{
Thread.Sleep(200);
}
Assert.IsTrue(result);
}, 2);
}
public void ContinueWithOnFailedTestCase()
{
ParallelTestHelper.Repeat
(
() =>
{
var result = false;
var t = Task.Factory.StartNew(() => { throw new Exception("foo"); });
var cont = t.ContinueWith(_ => result = true, TaskContinuationOptions.OnlyOnFaulted);
Assert.IsTrue(cont.Wait(1000), "#0");
Assert.IsNotNull(t.Exception, "#1");
Assert.IsNotNull(cont, "#2");
Assert.IsTrue(result, "#3");
}
);
}
public void ContinueWithChildren()
{
ParallelTestHelper.Repeat(delegate {
bool result = false;
var t = Task.Factory.StartNew(() => Task.Factory.StartNew(() => { }, TaskCreationOptions.AttachedToParent));
var mre = new ManualResetEvent(false);
t.ContinueWith(l => {
result = true;
mre.Set();
});
Assert.IsTrue(mre.WaitOne(1000), "#1");
Assert.IsTrue(result, "#2");
}, 2);
}
public void DoubleWaitTest ()
{
ParallelTestHelper.Repeat (delegate {
var evt = new ManualResetEventSlim ();
var t = Task.Factory.StartNew (() => evt.Wait (5000));
var cntd = new CountdownEvent (2);
var cntd2 = new CountdownEvent (2);
bool r1 = false, r2 = false;
ThreadPool.QueueUserWorkItem (delegate { cntd.Signal (); r1 = t.Wait (1000) && t.Result; cntd2.Signal (); });
ThreadPool.QueueUserWorkItem (delegate { cntd.Signal (); r2 = t.Wait (1000) && t.Result; cntd2.Signal (); });
Assert.IsTrue (cntd.Wait (2000), "#1");
evt.Set ();
Assert.IsTrue (cntd2.Wait (2000), "#2");
Assert.IsTrue (r1, "r1");
Assert.IsTrue (r2, "r2");
}, 10);
}
public void DoubleWaitTest()
{
ParallelTestHelper.Repeat(delegate {
Console.WriteLine("run");
var evt = new ManualResetEventSlim();
var t = Task.Factory.StartNew(() => evt.Wait(2000));
var cntd = new CountdownEvent(2);
bool r1 = false, r2 = false;
ThreadPool.QueueUserWorkItem(delegate { cntd.Signal(); r1 = t.Wait(1000); Console.WriteLine("out 1 {0}", r1); cntd.Signal(); });
ThreadPool.QueueUserWorkItem(delegate { cntd.Signal(); r2 = t.Wait(1000); Console.WriteLine("out 2 {0}", r2); cntd.Signal(); });
cntd.Wait(2000);
cntd.Reset();
evt.Set();
cntd.Wait(2000);
Assert.IsTrue(r1);
Assert.IsTrue(r2);
}, 5);
}
public void WaitAnyTest()
{
ParallelTestHelper.Repeat (delegate {
int flag = 0;
int finished = 0;
InitWithDelegate(delegate {
int times = Interlocked.Exchange (ref flag, 1);
if (times == 1) {
SpinWait sw = new SpinWait ();
while (finished == 0) sw.SpinOnce ();
} else {
Interlocked.Increment (ref finished);
}
});
int index = Task.WaitAny(tasks, 1000);
Assert.AreNotEqual (-1, index, "#3");
Assert.AreEqual (1, flag, "#1");
Assert.AreEqual (1, finished, "#2");
});
}
public void MultipleTasks()
{
ParallelTestHelper.Repeat(delegate {
bool r1 = false, r2 = false, r3 = false;
Task t1 = Task.Factory.StartNew(delegate {
r1 = true;
});
Task t2 = Task.Factory.StartNew(delegate {
r2 = true;
});
Task t3 = Task.Factory.StartNew(delegate {
r3 = true;
});
t1.Wait(2000);
t2.Wait(2000);
t3.Wait(2000);
Assert.IsTrue(r1, "#1");
Assert.IsTrue(r2, "#2");
Assert.IsTrue(r3, "#3");
}, 100);
}
public void DoubleWaitTest()
{
ParallelTestHelper.Repeat(delegate {
var evt = new ManualResetEventSlim();
var monitor = new object();
int finished = 0;
var t = Task.Factory.StartNew(delegate {
var r = evt.Wait(5000);
lock (monitor)
{
finished++;
Monitor.Pulse(monitor);
}
return(r ? 1 : 10); //1 -> ok, 10 -> evt wait failed
});
var cntd = new CountdownEvent(2);
var cntd2 = new CountdownEvent(2);
int r1 = 0, r2 = 0;
ThreadPool.QueueUserWorkItem(delegate {
cntd.Signal();
if (!t.Wait(1000))
{
r1 = 20; // 20 -> task wait failed
}
else if (t.Result != 1)
{
r1 = 30 + t.Result; // 30 -> task result is bad
}
else
{
r1 = 2; //2 -> ok
}
cntd2.Signal();
lock (monitor)
{
finished++;
Monitor.Pulse(monitor);
}
});
ThreadPool.QueueUserWorkItem(delegate {
cntd.Signal();
if (!t.Wait(1000))
{
r2 = 40; // 40 -> task wait failed
}
else if (t.Result != 1)
{
r2 = 50 + t.Result; // 50 -> task result is bad
}
else
{
r2 = 3; //3 -> ok
}
cntd2.Signal();
lock (monitor)
{
finished++;
Monitor.Pulse(monitor);
}
});
Assert.IsTrue(cntd.Wait(2000), "#1");
evt.Set();
Assert.IsTrue(cntd2.Wait(2000), "#2");
Assert.AreEqual(2, r1, "r1");
Assert.AreEqual(3, r2, "r2");
// Wait for everything to finish to avoid overloading the tpool
lock (monitor)
{
while (true)
{
if (finished == 3)
{
break;
}
else
{
Monitor.Wait(monitor);
}
}
}
}, 10);
}
