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 CountTestCase() { const int numThread = 5; ParallelTestHelper.ParallelAdder(queue, numThread); Assert.AreEqual(10 * numThread, queue.Count, "#1"); int value; queue.TryPeek(out value); ParallelTestHelper.ParallelRemover(queue, numThread, 3); Assert.AreEqual(10 * numThread - 3, queue.Count, "#2"); }
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 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 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 CountTestCase() { const int numThread = 5; ParallelTestHelper.ParallelAdder(stack, numThread); Assert.AreEqual(10 * numThread, stack.Count, "#1"); int value; stack.TryPeek(out value); ParallelTestHelper.ParallelRemover(stack, numThread, 3); Assert.AreEqual(10 * numThread - 3, stack.Count, "#2"); stack.Clear(); Assert.AreEqual(0, stack.Count, "#3"); Assert.IsTrue(stack.IsEmpty, "#4"); }
public void WaitStressTest() { int count = -1; bool[] array = new bool[7]; ParallelTestHelper.ParallelStressTest(sem, delegate(SemaphoreSlim s) { int index = Interlocked.Increment(ref count); s.Wait(); Thread.Sleep(40); s.Release(); array[index] = true; }, 7); bool result = array.Aggregate((acc, e) => acc && e); Assert.IsTrue(result, "#1"); Assert.AreEqual(5, sem.CurrentCount, "#2"); }
public void AddCountSignalStressTestCase() { int count = 0; ParallelTestHelper.ParallelStressTest(evt, delegate(CountdownEvent e) { int num = Interlocked.Increment(ref count); if (num % 2 == 0) { e.AddCount(); } else { e.Signal(); } }, 7); Assert.AreEqual(4, evt.CurrentCount, "#1"); Assert.IsFalse(evt.IsSet, "#2"); }
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"); }); }
public void WaitTestCase() { int count = 0; bool s = false; ParallelTestHelper.ParallelStressTest(evt, delegate(CountdownEvent e) { if (Interlocked.Increment(ref count) % 2 == 0) { Thread.Sleep(100); while (!e.IsSet) { e.Signal(); } } else { e.Wait(); s = true; } }); Assert.IsTrue(s, "#1"); Assert.IsTrue(evt.IsSet, "#2"); }