public void TestElementDestroyedAfterDispose() { RentedElementMonitor <TestPoolElem> elementMonitor = default(RentedElementMonitor <TestPoolElem>); TestPoolElem elem = null; try { using (TestDynamicPool testInst = new TestDynamicPool(0, 10)) { elementMonitor = testInst.Rent(); elem = elementMonitor.Element; } Assert.IsTrue(elementMonitor.IsValid); Assert.IsFalse(elem.IsDestroyed); } finally { if (!object.ReferenceEquals(elementMonitor, null)) { elementMonitor.Dispose(); } } Assert.IsTrue(elem.IsDestroyed); }
public void TestElementDestroyedOnDispose() { List <TestPoolElem> elements = new List <TestPoolElem>(); using (TestDynamicPool testInst = new TestDynamicPool(0, 100)) { List <RentedElementMonitor <TestPoolElem> > rented = new List <RentedElementMonitor <TestPoolElem> >(); for (int i = 0; i < 100; i++) { var rentedItem = testInst.Rent(); rented.Add(rentedItem); elements.Add(rentedItem.Element); Assert.AreEqual(i + 1, testInst.ElementCount); } for (int i = 0; i < rented.Count; i++) { rented[i].Dispose(); Assert.AreEqual(i + 1, testInst.FreeElementCount); } Assert.IsTrue(testInst.ElementCount > 0); Assert.AreEqual(testInst.ElementCount, testInst.FreeElementCount); } foreach (var item in elements) { Assert.IsTrue(item.IsDestroyed); } }
public void TestIsBetterCreateNew() { using (TestDynamicPool testInst = new TestDynamicPool(0, 10)) { testInst.FillPoolUpTo(1); Assert.AreEqual(1, testInst.ElementCount); testInst.AlwaysCreateNew = true; for (int i = 1; i < 10; i++) { using (var item = testInst.Rent()) { Assert.IsTrue(item.IsValid); } Assert.AreEqual(i + 1, testInst.ElementCount); } for (int i = 0; i < 10; i++) { using (var item = testInst.Rent()) { Assert.IsTrue(item.IsValid); } Assert.AreEqual(10, testInst.ElementCount); } } }
public void TestRentInOrder() { using (TestDynamicPool testInst = new TestDynamicPool(0, 1000)) { testInst.FillPoolUpTo(1000); List <RentedElementMonitor <TestPoolElem> > rented = new List <RentedElementMonitor <TestPoolElem> >(); for (int i = 0; i < 1000; i++) { rented.Add(testInst.Rent()); } for (int i = 0; i < rented.Count - 1; i++) { Assert.IsTrue(rented[i].Element.Value > rented[i + 1].Element.Value); } for (int i = 0; i < rented.Count; i++) { rented[i].Dispose(); Assert.AreEqual(i + 1, testInst.FreeElementCount); } } }
public void ComplexTest2() { using (TestDynamicPool testInst = new TestDynamicPool(20, 100)) { RunComplexTest(testInst, 1, 100000, 3, false); RunComplexTest(testInst, Environment.ProcessorCount, 2000000, 3, false); RunComplexTest(testInst, Environment.ProcessorCount, 1000000, 12, false); } }
private void RunFinalizerTest() { TestDynamicPool testInst = new TestDynamicPool(0, 10); using (var item = testInst.Rent(false)) { Assert.IsTrue(item.IsValid); } }
public void ComplexTest() { using (TestDynamicPool testInst = new TestDynamicPool(0, 100)) { RunComplexTest(testInst, 1, 100000, 4, true); RunComplexTest(testInst, Environment.ProcessorCount, 2000000, 4, true); RunComplexTest(testInst, Environment.ProcessorCount, 1000000, 12, true); RunComplexTest(testInst, Environment.ProcessorCount, 100000, 500, true); } }
public void TestRentOnDisposedPoolThrowsException() { using (TestDynamicPool testInst = new TestDynamicPool(0, 1)) { testInst.Dispose(); using (var item = testInst.Rent(true)) { Assert.IsFalse(item.IsValid); } } }
public void TestDoubleReleaseNotThrow() { using (TestDynamicPool testInst = new TestDynamicPool(0, 10)) { using (var item = testInst.Rent()) { item.Dispose(); item.Dispose(); } } }
public void TestRentOnDisposedPoolWithoutThrowOnUnavail() { using (TestDynamicPool testInst = new TestDynamicPool(0, 1)) { testInst.Dispose(); using (var item = testInst.Rent(false)) { Assert.IsFalse(item.IsValid); } } }
public void TestRentTimeout() { using (TestDynamicPool testInst = new TestDynamicPool(0, 1)) { using (var item1 = testInst.Rent(100)) { using (var item2 = testInst.Rent(100)) { } } } }
public void ComplexTest2() { using (TestDynamicPool testInst = new TestDynamicPool(20, 100)) { RunComplexTest(testInst, 1, 100000, 4, false); RunComplexTest(testInst, Environment.ProcessorCount, 2000000, 4, false); RunComplexTest(testInst, Environment.ProcessorCount, 1000000, 12, false); testInst.Dispose(); Assert.AreEqual(testInst.ElementsCreated, testInst.ElementsDestroyed, "ElementsCreated != ElementsDestroyed"); } }
public void WaitForElementReleaseNotBlockAfterStop() { using (TestDynamicPool testInst = new TestDynamicPool(0, 10)) { using (var item = testInst.Rent()) { Assert.IsTrue(item.IsValid); } testInst.Dispose(DisposeFlags.WaitForElementsRelease); } }
public void TestRentTimeoutWithoutException() { using (TestDynamicPool testInst = new TestDynamicPool(0, 1)) { using (var item1 = testInst.Rent(100, false)) { using (var item2 = testInst.Rent(100, false)) { Assert.IsFalse(item2.IsValid); } } } }
public void TestFillUpToWork() { using (TestDynamicPool testInst = new TestDynamicPool(0, 10)) { Assert.AreEqual(0, testInst.ElementCount); testInst.FillPoolUpTo(5); Assert.AreEqual(5, testInst.ElementCount); testInst.FillPoolUpTo(10); Assert.AreEqual(10, testInst.ElementCount); testInst.FillPoolUpTo(100); Assert.AreEqual(10, testInst.ElementCount); } }
public void TestRentWait() { using (TestDynamicPool testInst = new TestDynamicPool(0, 1)) { var item = testInst.Rent(); Task.Delay(500).ContinueWith(t => item.Dispose()); using (var item2 = testInst.Rent()) { Assert.IsTrue(item2.IsValid); } } }
public void TestDisposeCancelWaiters() { using (TestDynamicPool testInst = new TestDynamicPool(0, 1)) { Task.Delay(400).ContinueWith(t => testInst.Dispose()); using (var item1 = testInst.Rent()) { using (var item2 = testInst.Rent()) { } } } }
public void ComplexConcurrentUseWithTimeout() { using (TestDynamicPool testInst = new TestDynamicPool(0, 1)) { RunConcurrentUseWithTimeout(testInst, 2, 2000, 1, 1, 1000, true); RunConcurrentUseWithTimeout(testInst, Environment.ProcessorCount, 2000, 2, 1, 1000, true); RunConcurrentUseWithTimeout(testInst, 2 * Environment.ProcessorCount, 3000, 2, 1, 1000, true); RunConcurrentUseWithTimeout(testInst, 4 * Environment.ProcessorCount, 4000, 2, 1, 1000, true); RunConcurrentUseWithTimeout(testInst, 4 * Environment.ProcessorCount, 2000, 4, 4, 4, true); testInst.Dispose(); Assert.AreEqual(testInst.ElementsCreated, testInst.ElementsDestroyed, "ElementsCreated != ElementsDestroyed"); } }
private void RunComplexTest(TestDynamicPool testInst, int threadCount, int opCount, int pauseSpin, bool faultElements) { Thread[] threads = new Thread[threadCount]; Barrier startBar = new Barrier(threadCount + 1); int opCountPerThread = opCount / threadCount; Action thAct = () => { Random localRand = new Random(Thread.CurrentThread.ManagedThreadId + Environment.TickCount); int pasueDiff = (int)Math.Ceiling(pauseSpin / 4.0); startBar.SignalAndWait(); int execOp = 0; while (execOp++ < opCountPerThread) { using (var el = testInst.Rent()) { if (faultElements && localRand.Next(10) == 0) { el.Element.MakeInvalid(); } int spinCount = localRand.Next(pauseSpin - pasueDiff, pauseSpin + pasueDiff); SpinWaitHelper.SpinWait(spinCount); } } }; for (int i = 0; i < threads.Length; i++) { threads[i] = new Thread(new ThreadStart(thAct)); } for (int i = 0; i < threads.Length; i++) { threads[i].Start(); } startBar.SignalAndWait(); for (int i = 0; i < threads.Length; i++) { threads[i].Join(); } Assert.AreEqual(testInst.ElementCount, testInst.FreeElementCount); }
public void TestRecreateElementIfFaulted() { using (TestDynamicPool testInst = new TestDynamicPool(0, 10)) { for (int i = 0; i < 100; i++) { using (var item = testInst.Rent()) { Assert.IsTrue(item.IsValid); item.Element.MakeInvalid(); Assert.IsFalse(item.IsValid); } } } }
public void TestRentCancelled() { CancellationTokenSource tokSrc = new CancellationTokenSource(); Task.Delay(200).ContinueWith(t => tokSrc.Cancel()); using (TestDynamicPool testInst = new TestDynamicPool(0, 1)) { using (var item1 = testInst.Rent(tokSrc.Token)) { using (var item2 = testInst.Rent(tokSrc.Token)) { } } } }
public void TestDisposeCancelWaitersWithoutException() { using (TestDynamicPool testInst = new TestDynamicPool(0, 1)) { Task.Delay(400).ContinueWith(t => testInst.Dispose()); using (var item1 = testInst.Rent(false)) { using (var item2 = testInst.Rent(false)) { Assert.IsTrue(item1.IsValid); Assert.IsFalse(item2.IsValid); } } } }
public void TestRentCancelledWithoutException() { CancellationTokenSource tokSrc = new CancellationTokenSource(); Task.Delay(200).ContinueWith(t => tokSrc.Cancel()); using (TestDynamicPool testInst = new TestDynamicPool(0, 1)) { using (var item1 = testInst.Rent(tokSrc.Token, false)) { using (var item2 = testInst.Rent(tokSrc.Token, false)) { Assert.IsFalse(item2.IsValid); } } } }
public void TestFaultedElementDestroyed() { using (TestDynamicPool testInst = new TestDynamicPool(0, 10)) { Assert.AreEqual(0, testInst.ElementCount); Assert.AreEqual(0, testInst.FreeElementCount); TestPoolElem rentedEl = null; using (var el = testInst.Rent()) { Assert.IsTrue(el.IsValid); rentedEl = el.Element; rentedEl.MakeInvalid(); } Assert.IsTrue(rentedEl.IsDestroyed); } }
public void TestRentWaitWithRecreation() { using (TestDynamicPool testInst = new TestDynamicPool(0, 1)) { var item = testInst.Rent(); Task.Delay(500).ContinueWith(t => { item.Element.MakeInvalid(); item.Dispose(); }); using (var item2 = testInst.Rent()) { Assert.IsTrue(item2.IsValid); } } }
public void TestSimpleRentRelease() { using (TestDynamicPool testInst = new TestDynamicPool(0, 10)) { Assert.AreEqual(0, testInst.ElementCount); Assert.AreEqual(0, testInst.FreeElementCount); for (int i = 0; i < 1000; i++) { using (var el = testInst.Rent()) { Assert.IsTrue(el.IsValid); } } Assert.IsTrue(testInst.ElementCount > 0); Assert.AreEqual(testInst.ElementCount, testInst.FreeElementCount); } }
public void TestWaitWhenCreatingNotPossible() { using (TestDynamicPool testInst = new TestDynamicPool(0, 10)) { testInst.CanCreateElement = false; using (var item = testInst.Rent(1, false)) { Assert.IsFalse(item.IsValid); } Task.Delay(1000).ContinueWith(t => { testInst.CanCreateElement = true; }); using (var item = testInst.Rent()) { Assert.IsTrue(item.IsValid); } } }
public void TestTrimWork() { using (TestDynamicPool testInst = new TestDynamicPool(0, 10, 1000)) { testInst.FillPoolUpTo(10); Assert.AreEqual(10, testInst.ElementCount); Stopwatch sw = Stopwatch.StartNew(); while (sw.ElapsedMilliseconds < 1500) { using (var item = testInst.Rent()) { Assert.IsTrue(item.IsValid); } } Assert.AreEqual(1, testInst.ElementCount); } }
public void WaitForElementReleaseWaits() { using (TestDynamicPool testInst = new TestDynamicPool(0, 10)) { int elementRented = 0; int elementReleased = 0; Task.Run(() => { using (var item = testInst.Rent()) { Interlocked.Increment(ref elementRented); Thread.Sleep(250); } Interlocked.Increment(ref elementReleased); }); SpinWait.SpinUntil(() => Volatile.Read(ref elementRented) == 1); testInst.Dispose(DisposeFlags.WaitForElementsRelease); TimingAssert.AreEqual(10000, 1, () => Volatile.Read(ref elementReleased)); } }
public void TestRentReleaseMany() { using (TestDynamicPool testInst = new TestDynamicPool(0, 10)) { List <RentedElementMonitor <TestPoolElem> > rented = new List <RentedElementMonitor <TestPoolElem> >(); for (int i = 0; i < 10; i++) { rented.Add(testInst.Rent()); Assert.AreEqual(i + 1, testInst.ElementCount); } for (int i = 0; i < rented.Count; i++) { rented[i].Dispose(); Assert.AreEqual(i + 1, testInst.FreeElementCount); } Assert.IsTrue(testInst.ElementCount > 0); Assert.AreEqual(testInst.ElementCount, testInst.FreeElementCount); } }