public void CannotSeekBeyondStart()
{
using (var stream = new RingMemoryStream(SmallBufferSize))
{
stream.Seek(-1, SeekOrigin.Current);
}
}
public void CanWriteNulLength()
{
using (var stream = new RingMemoryStream(SmallBufferSize))
{
stream.Write(new byte[0], 0, 0);
}
}
public void CanSeekFromEnd()
{
using (var stream = new RingMemoryStream(SmallBufferSize))
{
stream.Seek(0, SeekOrigin.End);
}
}
public void CannotDecreaseBeyondPosition()
{
using (var stream = new RingMemoryStream(SmallBufferSize))
{
stream.WriteByte(0);
stream.SetLength(0);
}
}
protected TcpConnection(TcpClient tcpClient)
{
Require.NotNull(tcpClient, "tcpClient");
SyncRoot = new object();
_sendStream = new RingMemoryStream(Constants.RingBufferBlockSize);
_receiveStream = new RingMemoryStream(Constants.RingBufferBlockSize);
_tcpClient = tcpClient;
_tcpClient.Client.SetSocketOption(SocketOptionLevel.Tcp, SocketOptionName.NoDelay, true);
_stream = _tcpClient.GetStream();
}
public void BasicReadTest()
{
var result = new byte[TestData.Length];
using (var stream = new ProtoChannel.Util.RingMemoryStream(SmallBufferSize))
{
stream.Write(TestData, 0, TestData.Length);
stream.Position = 0;
stream.Read(result, 0, result.Length);
Assert.AreEqual(TestData, result);
Assert.AreEqual(TestData.Length, stream.Position);
Assert.AreEqual(TestData.Length, stream.Length);
Assert.AreEqual(7, stream.PagesAllocated);
Assert.AreEqual(28, stream.Capacity);
}
}
public void WriteInBytes()
{
using (var stream = new RingMemoryStream(SmallBufferSize))
{
foreach (byte b in TestData)
{
stream.WriteByte(b);
}
stream.Position = 0;
byte[] buffer = new byte[TestData.Length];
stream.Read(buffer, 0, buffer.Length);
Assert.AreEqual(TestData, buffer);
}
}
public void Set_large_length()
{
using (var stream = new RingMemoryStream(SmallBufferSize))
{
stream.SetLength(SmallBufferSize * 100);
Assert.AreEqual(SmallBufferSize * 100, stream.Capacity);
Assert.AreEqual(0, stream.Position);
Assert.AreEqual(0, stream.Head);
Assert.AreEqual(SmallBufferSize * 100, stream.Length);
}
}
public void VerifyDisposed()
{
var stream = new RingMemoryStream(SmallBufferSize);
stream.Dispose();
stream.SetLength(0);
}
public void ReadBeyondEnd()
{
using (var stream = new RingMemoryStream(SmallBufferSize))
{
stream.ReadByte();
}
}
public void ReadByte()
{
using (var stream = new RingMemoryStream(SmallBufferSize))
{
stream.Write(TestData, 0, TestData.Length);
stream.Position = 0;
for (int i = 0; i < TestData.Length; i++)
{
Assert.AreEqual(TestData[i], stream.ReadByte());
Assert.AreEqual(i + 1, stream.Position);
}
}
}
public void GetPageWithoutCapacity()
{
using (var stream = new RingMemoryStream(SmallBufferSize))
{
stream.GetPage(0, SmallBufferSize);
}
}
public void PageValidity()
{
using (var stream = new RingMemoryStream(SmallBufferSize))
{
stream.Write(TestData, 0, TestData.Length);
var pages = stream.GetPages(0, stream.Length);
Assert.AreEqual(7, pages.Length);
byte[] block;
for (int i = 0; i < 6; i++)
{
Assert.AreEqual(0, pages[i].Offset);
Assert.AreEqual(SmallBufferSize, pages[i].Count);
Assert.AreEqual(SmallBufferSize, pages[i].Buffer.Length);
block = new byte[SmallBufferSize];
Array.Copy(TestData, i * SmallBufferSize, block, 0, SmallBufferSize);
Assert.AreEqual(block, pages[i].Buffer);
}
Assert.AreEqual(0, pages[6].Offset);
Assert.AreEqual(2, pages[6].Count);
block = new byte[2];
var pagePart = new byte[2];
Array.Copy(TestData, 6 * SmallBufferSize, block, 0, 2);
Array.Copy(pages[6].Buffer, 0, pagePart, 0, 2);
Assert.AreEqual(block, pagePart);
}
}
public void Enlarge_pages_array()
{
using (var stream = new RingMemoryStream(SmallBufferSize))
{
for (int i = 0; i < 10; i++)
{
stream.Write(TestData, 0, TestData.Length);
}
}
}
public void NulLengthReadReturnsNul()
{
using (var stream = new RingMemoryStream(SmallBufferSize))
{
Assert.AreEqual(0, stream.Read(new byte[0], 0, 0));
}
}
public void HeadWithOneMoreBlockSize()
{
using (var stream = new RingMemoryStream(SmallBufferSize))
{
stream.Capacity++;
stream.Capacity++;
stream.SetLength(SmallBufferSize + 1);
stream.Position = stream.Length;
stream.Head = stream.Length;
Assert.AreEqual(1, stream.PagesAllocated);
}
}
public void GetCorrectSinglePage()
{
using (var stream = new RingMemoryStream(SmallBufferSize))
{
stream.Capacity++;
var page = stream.GetPage(0, SmallBufferSize);
Assert.AreEqual(0, page.Offset);
Assert.AreEqual(SmallBufferSize, page.Count);
}
}
public void HeadWithBlockSizeIncrement()
{
using (var stream = new RingMemoryStream(SmallBufferSize))
{
stream.Capacity++;
stream.SetLength(stream.Capacity);
stream.Position = stream.Length;
stream.Head = stream.Length;
Assert.AreEqual(0, stream.PagesAllocated);
}
}
public void GetWriteBufferAfterWrite()
{
using (var stream = new RingMemoryStream(SmallBufferSize))
{
stream.WriteByte(0);
var page = stream.GetWriteBuffer();
Assert.AreEqual(1, stream.PagesAllocated);
Assert.AreEqual(page.Offset, 1);
Assert.AreEqual(page.Count, SmallBufferSize - 1);
}
}
public void GetTooLargeSinglePage()
{
using (var stream = new RingMemoryStream(SmallBufferSize))
{
stream.Capacity = SmallBufferSize * 2;
stream.GetPage(0, SmallBufferSize * 2);
}
}
public void CorrectReadWhenNotOnPageBoundary()
{
using (var stream = new RingMemoryStream(SmallBufferSize))
{
stream.Write(TestData, 0, TestData.Length);
stream.Position = 1;
var readBuffer = new byte[2];
stream.Read(readBuffer, 0, 2);
}
}
public void PageReUse()
{
using (var stream = new RingMemoryStream(SmallBufferSize))
{
stream.Write(TestData, 0, TestData.Length);
stream.Head = stream.Position;
Assert.AreEqual(1, stream.PagesAllocated);
stream.Write(TestData, 0, TestData.Length);
Assert.AreEqual(7, stream.PagesAllocated);
}
}
public void ManualWrite()
{
using (var stream = new RingMemoryStream(SmallBufferSize))
{
stream.Capacity++;
var pages = stream.GetPages(0, stream.Capacity);
Array.Copy(TestData, pages[0].Buffer, SmallBufferSize);
stream.SetLength(SmallBufferSize);
var readBuffer = new byte[SmallBufferSize];
stream.Read(readBuffer, 0, readBuffer.Length);
var validateBuffer = new byte[SmallBufferSize];
Array.Copy(TestData, validateBuffer, SmallBufferSize);
Assert.AreEqual(validateBuffer, readBuffer);
}
}
public void GetPagesBeyondLength()
{
using (var stream = new RingMemoryStream(SmallBufferSize))
{
stream.Capacity++;
var pages = stream.GetPages(0, stream.Capacity);
Assert.AreEqual(1, pages.Length);
Assert.AreEqual(0, pages[0].Offset);
Assert.AreEqual(SmallBufferSize, pages[0].Count);
}
}
public void CapacityRounded()
{
using (var stream = new RingMemoryStream(SmallBufferSize))
{
stream.SetLength(1);
Assert.AreEqual(1, stream.Length);
Assert.AreEqual(SmallBufferSize, stream.Capacity);
}
}
protected virtual void Dispose(bool disposing)
{
lock (SyncRoot)
{
if (!IsDisposed && disposing)
{
if (_tcpClient != null)
{
_tcpClient.Close();
_tcpClient = null;
}
if (_sslStream != null)
{
_sslStream.Dispose();
_sslStream = null;
// When we have an SslStream, _stream is set to the same
// stream.
_stream = null;
}
if (_stream != null)
{
_stream.Dispose();
_stream = null;
}
if (_receiveStream != null)
{
_receiveStream.Dispose();
_receiveStream = null;
}
if (_sendStream != null)
{
_sendStream.Dispose();
_sendStream = null;
}
IsDisposed = true;
}
}
}
