public void ResetShouldAllowStreamReuse()
{
int initialOffset = 0;
var manager = new BufferManageMock();
using (var stream = new BufferManagerStream(manager, initialOffset, 4, 1024))
{
stream.Write(_input, 0, 4);
manager.ReturnBuffer(stream.GetArrayAndClear().Array);
manager.AssertEverythingIsReturned();
initialOffset = 1;
stream.Reset(manager, initialOffset, 4);
Assert.AreEqual(stream.Position, 0, "Position should be 0 after reset");
byte[] otherInput = new byte[] { 3, 2, 1 };
stream.Write(otherInput, 0, otherInput.Length);
var array = stream.GetArrayAndClear();
VerifyBufferContents(array, initialOffset, new ArraySegment <byte>(otherInput));
manager.ReturnBuffer(array.Array);
manager.AssertEverythingIsReturned();
}
}
public void ShouldHandleThrowingAllocationWithoutMemoryLeak()
{
bool shouldTrow = false;
Func <int, int> getBufferSize = size =>
{
if (shouldTrow)
{
throw new InsufficientMemoryException();
}
else
{
return(size);
}
};
var manager = new BufferManageMock(getBufferSize);
using (var stream = new BufferManagerStream(manager, 0, 4, 1024))
{
stream.Write(_input, 0, 2); // Write some into first buffer
shouldTrow = true;
ExceptionHelper.ExpectException <InsufficientMemoryException>(() =>
stream.Write(_input, 2, 10)
);
}
manager.AssertEverythingIsReturned();
}
public void ReuseLastBufferIfPossible()
{
int initialOffset = 0, initalBufferSize = 4;
int buffer2Size = initalBufferSize * 2;
int buffer3Size = initalBufferSize + buffer2Size;
var manager = new BufferManageMock();
using (var stream = new BufferManagerStream(manager, initialOffset, initalBufferSize, 1024))
{
// Fill first and second buffers full
stream.Write(_input, 0, initalBufferSize);
stream.Write(_input, initalBufferSize, buffer2Size);
Assert.AreEqual(buffer2Size, manager.Allocated[1].Length, "This test assumed allocation size was wrong");
// Write next one up just a little so that everyhing should fit in the 3rd
int streamOffsetLastBuffer = (int)stream.Position;
stream.Write(_input, streamOffsetLastBuffer, streamOffsetLastBuffer);
Assert.AreEqual(3, manager.Allocated.Count, "Test assumes 3 buffers");
Assert.AreEqual((int)stream.Position, manager.Allocated[2].Length, "This test assumes allocation size is enough");
var buffer = VerifyStreamContents(stream, initialOffset, streamOffsetLastBuffer * 2, manager);
Assert.AreSame(manager.Allocated[2], buffer.Array);
}
}
public void LargeWrite(int offset)
{
var manager = new BufferManageMock();
using (var stream = new BufferManagerStream(manager, offset, 4, 1024))
{
stream.Write(_input, 0, 40);
VerifyStreamContents(stream, offset, 40, manager);
Assert.IsTrue(manager.Allocated.Count > 2, "Multiple buffers should have been used");
}
}
public void SmallWriteFullBuffer()
{
int initialOffset = 0, minBufferSize = 4;
var manager = new BufferManageMock();
using (var stream = new BufferManagerStream(manager, initialOffset, minBufferSize, 1024))
{
stream.Write(_input, 0, minBufferSize);
var buffer = VerifyStreamContents(stream, initialOffset, minBufferSize, manager);
Assert.AreEqual(1, manager.Allocated.Count, "Should only have allocated a single buffer");
Assert.AreSame(manager.Allocated[0], buffer.Array, "Should reuse initial array");
}
}
public void SmallWrite(int offset)
{
var manager = new BufferManageMock();
using (var stream = new BufferManagerStream(manager, offset, 4, 1024))
{
stream.Write(_input, 0, 2);
var buffer = VerifyStreamContents(stream, offset, 2, manager);
Assert.AreEqual(1, manager.Allocated.Count, "Should only have allocated a single buffer");
Assert.AreSame(manager.Allocated[0], buffer.Array, "Should reuse initial array");
}
}
public void MultipleWrites()
{
int initialOffset = 0;
var manager = new BufferManageMock();
using (var stream = new BufferManagerStream(manager, initialOffset, 4, 1024))
{
stream.Write(_input, 0, 2); // Write partial buffer
stream.Write(_input, 2, 2); // Fill next buffer, next shoul be 4
stream.Write(_input, 4, 2);
stream.Write(_input, 6, manager.Allocated[1].Length); // Write past buffer into next one
VerifyStreamContents(stream, initialOffset, 6 + manager.Allocated[1].Length, manager);
Assert.IsTrue(manager.Allocated.Count > 2, "Multiple buffers should have been used");
}
}
private ArraySegment <byte> VerifyStreamContents(BufferManagerStream stream, int expectedOffset, int count, BufferManageMock manager, byte[] expectedContents = null)
{
Assert.AreEqual(count, stream.Position, "Stream position should equal count");
var buffer = stream.GetArrayAndClear();
VerifyBufferContents(buffer, expectedOffset, new ArraySegment <byte>(expectedContents ?? _input, 0, count));
// By returning buffer we also ensure that it was allocated through the buffer manager
manager.ReturnBuffer(buffer.Array);
manager.AssertEverythingIsReturned();
return(buffer);
}
