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);
        }
Beispiel #2
0
        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 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 RemoveParallelTest()
        {
            ParallelTestHelper.Repeat(delegate
            {
                Setup();
                var index = 0;
                var r1    = false;
                var r2    = false;
                var r3    = false;

                ParallelTestHelper.ParallelStressTest
                (
                    _map,
                    delegate
                {
                    var own = Interlocked.Increment(ref index);
                    switch (own)
                    {
                    case 1:
                        r1 = _map.TryRemove("foo", out _);
                        break;

                    case 2:
                        r2 = _map.TryRemove("bar", out _);
                        break;

                    case 3:
                        r3 = _map.TryRemove("foobar", out _);
                        break;

                    default:
                        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), "#1b " + value.ToString());
                Assert.IsFalse(_map.TryGetValue("bar", out value), "#2b");
                Assert.IsFalse(_map.TryGetValue("foobar", out value), "#3b");
            });
        }
        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");
        }
Beispiel #6
0
        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++)
                {
                    while (!coll.TryAdd(i))
                    {
                        ;
                    }
                }

                bool state = true;
                bool ran   = false;

                Assert.AreEqual((count + delta) * threads, coll.Count, "#0");

                ParallelTestHelper.ParallelStressTest(coll, (q) => {
                    ran    = true;
                    bool s = true;
                    int t;

                    for (int i = 0; i < count; i++)
                    {
                        s &= coll.TryTake(out t);
                        // try again in case it was a transient failure
                        if (!s && coll.TryTake(out t))
                        {
                            s = true;
                        }
                    }

                    if (!s)
                    {
                        state = false;
                    }
                }, threads);

                Assert.IsTrue(ran, "#1-pre");
                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");
                }
            }, 1000);
        }
        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 (var i = 0; i < (Count + Delta) * Threads; i++)
                {
                    while (!coll.TryAdd(i))
                    {
                    }
                }

                var state = true;

                Assert.AreEqual((Count + Delta) * Threads, coll.Count, "#0");

                ParallelTestHelper.ParallelStressTest(coll, (q) =>
                {
                    var s = true;
                    int t;

                    for (var i = 0; i < Count; i++)
                    {
                        s &= coll.TryTake(out t);
                        // try again in case it was a transient failure
                        if (!s && coll.TryTake(out t))
                        {
                            s = true;
                        }
                    }

                    state &= s;
                }, Threads);

                Assert.IsTrue(state, "#1");
                Assert.AreEqual(Delta * Threads, coll.Count, "#2");

                var actual = string.Empty;
                int temp;
                var builder = new StringBuilder();
                builder.Append(actual);
                while (coll.TryTake(out temp))
                {
                    builder.Append(temp.ToString());
                }
                actual = builder.ToString();

                var range = Enumerable.Range(order == CheckOrderingType.Reversed ? 0 : Count * Threads, Delta * Threads);
                if (order == CheckOrderingType.Reversed)
                {
                    range = range.Reverse();
                }

                var expected = range.Aggregate(string.Empty, (acc, v) => acc + v);

                if (order == CheckOrderingType.DontCare)
                {
                    Assert.That(actual, new CollectionEquivalentConstraint(expected), "#3");
                }
                else
                {
                    Assert.AreEqual(expected, actual, "#3");
                }
            }, 10);
        }