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);
}
}
