public void StressZeroTest()
{
ParallelTestHelper.Repeat(delegate {
int times = 0;
ParallelTestHelper.ParallelStressTest(snzi, (s) => {
int t = Interlocked.Increment(ref times);
for (int i = 0; i < 20; i++)
{
if (i % 2 == 0)
{
snzi.Increment();
}
else
{
snzi.Decrement();
}
if (i % (3 * t) == 0)
{
Thread.Sleep(0);
}
}
});
Assert.IsTrue(snzi.IsSet, "#1");
});
}
public void WaitChildTestCase()
{
ParallelTestHelper.Repeat(delegate {
bool r1 = false, r2 = false, r3 = false;
Task t = Task.Factory.StartNew(delegate {
Task.Factory.StartNew(delegate {
Thread.Sleep(50);
r1 = true;
//Console.WriteLine("finishing 1");
});
Task.Factory.StartNew(delegate {
Thread.Sleep(300);
r2 = true;
//Console.WriteLine("finishing 2");
});
Task.Factory.StartNew(delegate {
Thread.Sleep(150);
r3 = true;
//Console.WriteLine("finishing 3");
});
});
t.Wait();
Assert.IsTrue(r2, "#1");
Assert.IsTrue(r3, "#2");
Assert.IsTrue(r1, "#3");
Assert.AreEqual(TaskStatus.RanToCompletion, t.Status, "#4");
}, 10);
}
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);
Assert.IsTrue(flag == 1, "#1");
Assert.AreEqual(1, finished, "#2");
Assert.AreNotEqual(-1, index, "#3");
Task.WaitAll(tasks);
});
}
public static void AddStressTest(IProducerConsumerCollection <int> coll)
{
ParallelTestHelper.Repeat(delegate {
int amount = -1;
const int count = 10;
const int threads = 5;
ParallelTestHelper.ParallelStressTest(coll, (q) => {
int t = Interlocked.Increment(ref amount);
for (int i = 0; i < count; i++)
{
coll.TryAdd(t);
}
}, threads);
Assert.AreEqual(threads * count, coll.Count, "#-1");
int[] values = new int[threads];
int temp;
while (coll.TryTake(out temp))
{
values[temp]++;
}
for (int i = 0; i < threads; i++)
{
Assert.AreEqual(count, values[i], "#" + i);
}
});
}
public void ParallelForSmallRangeTest()
{
ParallelTestHelper.Repeat(() => {
int test = -1;
Parallel.For(0, 1, (i) => test = i);
Assert.AreEqual(0, test, "#1");
});
}
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()
{
ParallelTestHelper.Repeat(() => {
int[] expected = Enumerable.Range(1, 1000).Select((e) => e * 2).ToArray();
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 pixels");
CollectionAssert.AreEqual(expected, actual, "#2, pixels 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 static void RemoveStressTest(IProducerConsumerCollection <int> coll, CheckOrderingType order)
{
ParallelTestHelper.Repeat(delegate {
const int count = 10;
const int threads = 5;
const int delta = 5;
for (int i = 0; i < (count + delta) * threads; i++)
{
coll.TryAdd(i);
}
bool state = true;
ParallelTestHelper.ParallelStressTest(coll, (q) => {
int t;
for (int i = 0; i < count; i++)
{
state &= coll.TryTake(out t);
}
}, threads);
Assert.IsTrue(state, "#1");
Assert.AreEqual(delta * threads, coll.Count, "#2");
string actual = string.Empty;
int temp;
while (coll.TryTake(out temp))
{
actual += temp.ToString();;
}
IEnumerable <int> range = Enumerable.Range(order == CheckOrderingType.Reversed ? 0 : count * threads, delta * threads);
if (order == CheckOrderingType.Reversed)
{
range = range.Reverse();
}
string expected = range.Aggregate(string.Empty, (acc, v) => acc + v);
if (order == CheckOrderingType.DontCare)
{
CollectionAssert.AreEquivalent(expected, actual, "#3");
}
else
{
Assert.AreEqual(expected, actual, "#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);
t.Wait();
cont.Wait();
Assert.IsNull(cont.Exception, "#1");
Assert.IsNotNull(cont, "#2");
Assert.IsTrue(result, "#3");
});
}
public void StressNonZeroTest()
{
ParallelTestHelper.Repeat(delegate {
ParallelTestHelper.ParallelStressTest(snzi, (s) => {
snzi.Increment();
for (int i = 0; i < 1; i++)
{
if (i % 2 == 0)
{
snzi.Increment();
}
else
{
snzi.Decrement();
}
}
});
Assert.IsFalse(snzi.IsSet, "#1");
});
}
public void CancelTestCase()
{
int count = 1;
ParallelTestHelper.Repeat(delegate {
bool result = false;
Task t = new Task(delegate {
result = true;
});
t.Cancel();
Assert.IsTrue(t.IsCancellationRequested, "#-1");
t.Start();
t.Wait();
Assert.IsInstanceOfType(typeof(TaskCanceledException), t.Exception, "#1 : " + count++);
TaskCanceledException ex = (TaskCanceledException)t.Exception;
Assert.AreEqual(t, ex.Task, "#2");
Assert.IsFalse(result, "#3");
});
}
public void RemoveParallelTest()
{
ParallelTestHelper.Repeat(delegate {
Setup();
int index = 0;
bool r1 = false, r2 = false, r3 = false;
int val;
ParallelTestHelper.ParallelStressTest(map, delegate {
int own = Interlocked.Increment(ref index);
switch (own)
{
case 1:
r1 = map.TryRemove("foo", out val);
break;
case 2:
r2 = map.TryRemove("bar", out val);
break;
case 3:
r3 = map.TryRemove("foobar", out val);
break;
}
}, 3);
Assert.AreEqual(0, map.Count);
int value;
Assert.IsTrue(r1, "1");
Assert.IsTrue(r2, "2");
Assert.IsTrue(r3, "3");
Assert.IsFalse(map.TryGetValue("foo", out value), "#1");
Assert.IsFalse(map.TryGetValue("bar", out value), "#2");
Assert.IsFalse(map.TryGetValue("foobar", out value), "#3");
});
}
public void MultipleTaskTestCase()
{
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();
t2.Wait();
t3.Wait();
Assert.IsTrue(r1, "#1");
Assert.IsTrue(r2, "#2");
Assert.IsTrue(r3, "#3");
});
}
public void ContinueWithOnAbortedTestCase()
{
ParallelTestHelper.Repeat(delegate {
bool result = false;
bool taskResult = false;
Task t = new Task(delegate { taskResult = true; });
t.Cancel();
Task cont = t.ContinueWith(delegate { result = true; }, TaskContinuationOptions.OnlyOnCanceled);
t.Start();
t.Wait();
cont.Wait();
Assert.IsFalse(taskResult, "#-1");
Assert.AreEqual(TaskStatus.Canceled, t.Status, "#0");
Assert.IsTrue(t.IsCanceled, "#0bis");
Assert.IsNull(cont.Exception, "#1");
Assert.IsNotNull(cont, "#2");
Assert.IsTrue(result, "#3");
});
}
