public WaitPoolTest()
{
MockInnerPool.Setup(inner => inner.Count).Returns(4);
MockInnerPool.Setup(inner => inner.Size).Returns(4);
m_waitPool = new WaitPool <string>(MockInnerPool.Object, 0);
DecoratedPool = m_waitPool;
}
public IdleTimeoutPoolTest()
{
MockInnerPool.Setup(inner => inner.Size).Returns(2);
IdleTimeoutPool = new IdleTimeoutPool2(MockInnerPool.Object,
new Action <PoolItem>(item => m_releaseFactoryCalls++));
DecoratedPool = IdleTimeoutPool;
}
public void RecycleIdled()
{
// Arrange
var current = DateTime.UtcNow;
Assert.False(IdleTimeoutPool.TryIdleOut(new PoolItem("x"), current.AddSeconds(-10)));
Assert.False(IdleTimeoutPool.TryIdleOut("y", current.AddSeconds(-9)));
Assert.False(IdleTimeoutPool.TryIdleOut("z", current.AddSeconds(-9)));
Assert.False(IdleTimeoutPool.TryIdleOut("_", current.AddSeconds(-10)));
var taken = new Queue <string>(new string[] { "x", "y", "z", "_", null });
MockInnerPool.Setup(inner => inner.Count).Returns(4);
MockInnerPool.Setup(inner => inner.Take(null)).Returns(() => taken.Dequeue());
MockInnerPool.Setup(inner => inner.Return(It.IsAny <string>()))
.Callback((string item) => taken.Enqueue(item))
.Returns(() => true);
// Act
lock (MockInnerPool.Object)
{
Assert.Equal(2, IdleTimeoutPool.RecycleIdled(current));
}
// Assert
Assert.Equal(2, m_releaseFactoryCalls);
Assert.Equal("z", IdleTimeoutPool.TakeCurrent(null, current));
Assert.Equal("y", IdleTimeoutPool.TakeCurrent(null, current));
}
protected override void Dispose(bool disposing)
{
if (disposing)
{
MockInnerPool.VerifyAll();
MockDecoratedPool.VerifyAll();
}
}
public EagerPoolTest()
{
var calls = 0;
MockInnerPool.Setup(inner => inner.Size).Returns(2);
MockInnerPool.Setup(inner => inner.Return("x")).Callback(() => calls++).Returns(true);
DecoratedPool = new EagerPool <string>(MockInnerPool.Object, CreateFactory, ReleaseFactory);
Assert.Equal(2, calls);
}
public void Take_Inner_Returned_Null()
{
// Arrange
MockInnerPool.Setup(inner => inner.Take(null)).Returns((string)null);
// Act
var result = DecoratedPool.Take(null);
// Assert
Assert.Null(result);
}
public virtual void Take()
{
// Arrange
MockInnerPool.Setup(inner => inner.Take("state")).Returns("data");
// Act
var result = DecoratedPool.Take("state");
// Assert
Assert.Equal("data", result);
}
public void Return_Inner_Return_False()
{
// Arrange
var item = RandomHelper.NextWord(g_random);
MockInnerPool.Setup(inner => inner.Return(item)).Returns(false);
// Act
var result = DecoratedPool.Return(item);
// Assert
Assert.False(result);
}
public virtual void Clear()
{
// Arrange
var succeed = RandomHelper.NextBoolean(g_random);
MockInnerPool.Setup(inner => inner.Clear()).Returns(succeed);
// Act
var result = DecoratedPool.Clear();
// Assert
Assert.Equal(succeed, result);
}
public void Count()
{
// Arrange
var expected = g_random.Next();
MockInnerPool.Setup(inner => inner.Count).Returns(expected);
// Act
var result = DecoratedPool.Count;
// Assert
Assert.Equal(expected, result);
}
public override void Take()
{
// Arrange
MockInnerPool.Setup(inner => inner.Return("x")).Returns(true);
MockInnerPool.Setup(inner => inner.Take(null)).Returns("x");
m_waitPool.Return("x");
// Act
var result = m_waitPool.Take(null);
// Assert
Assert.Equal("x", result);
}
public virtual void Return_Already_Disposed()
{
// Arrange
MockInnerPool.Setup(inner => inner.Dispose());
MockManagedPool.Setup(managed => managed.Clear()).Returns(true);
DecoratedPool.Dispose();
// Act
var result = DecoratedPool.Return(null);
// Assert
Assert.False(result);
}
public override void Return_Already_Disposed()
{
// Arrange
MockInnerPool.Setup(inner => inner.Take(null)).Returns((string)null);
MockInnerPool.Setup(inner => inner.Count).Returns(0);
MockInnerPool.Setup(inner => inner.Dispose());
DecoratedPool.Dispose();
// Act
var result = DecoratedPool.Return(null);
// Assert
Assert.False(result);
}
public void TakeCurrent_Not_IdledOut()
{
// Arrange
var current = DateTime.UtcNow;
Assert.False(IdleTimeoutPool.TryIdleOut("x", current.AddSeconds(-1)));
MockInnerPool.Setup(inner => inner.Take(null)).Returns("x");
// Act
var result = IdleTimeoutPool.TakeCurrent(null, current);
// Assert
Assert.Equal("x", result);
Assert.Equal(0, m_releaseFactoryCalls);
}
public override void Return_Already_Disposed()
{
// Arrange
var items = new Queue <string>(new string[] { "x", "x", null });
MockInnerPool.Setup(inner => inner.Take(null)).Returns(items.Dequeue);
MockInnerPool.Setup(inner => inner.Count).Returns(0);
MockInnerPool.Setup(inner => inner.Dispose());
DecoratedPool.Dispose();
// Act
var result = DecoratedPool.Return(null);
// Assert
Assert.False(result);
}
public void Clear_Inner_Take_Until_Returns_Null()
{
// Arrange
var items = new Queue <string>(new string[] { "x", "y", null });
MockInnerPool.Setup(inner => inner.Take(null)).Returns(() => items.Dequeue());
MockInnerPool.Setup(inner => inner.Count).Returns(0);
var decoratedPool = new Mock <ManagedPool <string> >(MockInnerPool.Object, new Action <string>(ReleaseFactory));
decoratedPool.CallBase = true;
// Act
var result = decoratedPool.Object.Clear();
// Assert
Assert.True(result);
Assert.Equal(0, items.Count);
}
public void TakeCurrent_IdledOut()
{
// Arrange
var current = DateTime.UtcNow;
Assert.False(IdleTimeoutPool.TryIdleOut("x", current.AddSeconds(-10)));
Assert.False(IdleTimeoutPool.TryIdleOut("y", current.AddSeconds(-10)));
var items = new Queue <string>(new string[] { "x", "y", null });
MockInnerPool.Setup(inner => inner.Take(null)).Returns(() => items.Dequeue());
// Act
var result = IdleTimeoutPool.TakeCurrent(null, current);
// Assert
Assert.Null(result);
Assert.Equal(2, m_releaseFactoryCalls);
}
public void Take_Inner_Take_Returns_Null()
{
// Arrange
int attempt = 0;
MockInnerPool.Setup(inner => inner.Return("x")).Returns(true);
MockInnerPool.Setup(inner => inner.Take(null)).Returns(() => attempt++ == 0 ? (string)null : "x");
while (m_waitPool.Return("x"))
{
}
// Act
var result = m_waitPool.Take(null);
// Assert
Assert.Null(result);
for (int i = 0; i < m_waitPool.Size; i++)
{
Assert.Equal("x", m_waitPool.Take(null));
}
Assert.Null(m_waitPool.Take(null));
}
