public void ResetPositionTest2()
{
MemoryStream bytesRead = new MemoryStream();
var buffer = new NetworkBuffer(BIG_BUFFER_DATA.Length, BIG_BUFFER_DATA);
byte[] read = buffer.Read(BIG_BUFFER_DATA.Length);
try
{
buffer.Read(1);
Assert.Fail("An exception should have been thrown when reading a fully read buffer.");
}catch (Exception)
{
}
buffer.ResetPosition();
try
{
read = buffer.Read(1);
Assert.AreEqual <byte>(BIG_BUFFER_DATA[0], read[0]);
}
catch (Exception)
{
Assert.Fail("Reset position should have allowed for the buffer to be readable again.");
}
finally
{
buffer.Dispose();
}
}
public void NetworkBufferTest1()
{
var buffer = new NetworkBuffer(100);
Assert.AreEqual <int>(0, buffer.Received, "Received obtain a value without data"); //An impossible test case
Assert.AreEqual <int>(100, buffer.Size, "Size was not assign the right value."); //An impossible test case
buffer.Dispose();
}
public void NetworkBufferTest3()
{
var buffer = new NetworkBuffer(5, new byte[] { 0, 1, 2, 3, 4 });
Assert.AreEqual <int>(5, buffer.Received, "Received was not the right size."); //An impossible test case
Assert.AreEqual <int>(5, buffer.Size, "Size was not assign the right value."); //An impossible test case
Assert.IsTrue(buffer.Completed, "Completed should be true."); //An impossible test case
buffer.Dispose();
}
public void ResizeTest1()
{
var buffer = new NetworkBuffer(BIG_BUFFER_DATA.Length, BIG_BUFFER_DATA);
buffer.Resize(1000);
byte[] read = buffer.ToArray();
Assert.AreEqual <int>(1000, read.Length, "The resized buffer should contain 1000 bytes.");
buffer.Dispose();
}
public void CloneTest()
{
var buffer = new NetworkBuffer(BIG_BUFFER_DATA.Length, BIG_BUFFER_DATA);
var copy = buffer.Clone();
Assert.AreEqual <int>(buffer.Size, copy.Size, "Cloned buffer should have the same size.");
Assert.AreEqual <int>(buffer.Received, copy.Received, "Cloned buffer should have the same received number of bytes.");
buffer.Dispose();
(copy as NetworkBuffer).Dispose();
}
public void AppendFillBuffer()
{
var buffer = new NetworkBuffer(10);
buffer.Append(new byte[] { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 });
Assert.AreEqual <int>(10, buffer.Received, "Received was not the right size."); //An impossible test case
Assert.AreEqual <int>(10, buffer.Size, "Size was not assign the right value."); //An impossible test case
Assert.IsTrue(buffer.Completed, "Completed should be true."); //An impossible test case
buffer.Dispose();
}
public void ResizeTest2()
{
var buffer = new NetworkBuffer(BIG_BUFFER_DATA.Length, BIG_BUFFER_DATA);
buffer.Resize(5000);
byte[] data = buffer.ToArray();
Assert.AreEqual <int>(BIG_BUFFER_DATA.Length, data.Length, "The internal buffer size should not have changed when expanding the buffer.");
Assert.AreEqual <byte>(BIG_BUFFER_DATA[5], data[5], "Buffer data should be the same after resizing.");
Assert.AreEqual <byte>(BIG_BUFFER_DATA[1024], data[1024], "Buffer data should be the same after resizing.");
buffer.Dispose();
}
public void GetBufferAfterOneAppend()
{
var buffer = new NetworkBuffer(10);
buffer.Append(new byte[] { 0, 1, 2, 3, 4, 5, 6, 7 });
byte[] data = buffer.ToArray();
Assert.AreEqual <int>(8, buffer.Received, "Received was not the right size."); //An impossible test case
Assert.AreEqual <int>(10, buffer.Size, "Size was not assign the right value."); //An impossible test case
Assert.AreEqual <int>(buffer.Received, data.Length, "Received and length should be the same size.");
Assert.IsFalse(buffer.Completed, "Completed should be false."); //An impossible test case
buffer.Dispose();
}
public void AppendConstrainedTest1()
{
var buffer = new NetworkBuffer(10);
var data = new byte[] { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 };
buffer.AppendConstrained(data, 2, 5);
Assert.AreEqual <int>(5, buffer.Received);
var received = buffer.ToArray();
Assert.AreEqual <byte>(2, received[0]);
Assert.AreEqual <byte>(6, received[4]);
buffer.Dispose();
}
public void AppendHugeBuffer()
{
var buffer = new NetworkBuffer(HUGE_BUFFER_DATA.Length);
buffer.Append(HUGE_BUFFER_DATA);
byte[] data = buffer.ToArray();
Assert.AreEqual <int>(HUGE_BUFFER_DATA.Length, buffer.Received, "Received was not the right size."); //An impossible test case
Assert.AreEqual <int>(HUGE_BUFFER_DATA.Length, buffer.Size, "Size was not assign the right value."); //An impossible test case
Assert.AreEqual <int>(buffer.Received, data.Length, "Received and length should be the same size.");
Assert.AreEqual <byte>(HUGE_BUFFER_DATA[5], data[5], "First byte in buffer should be zero.");
Assert.AreEqual <byte>(HUGE_BUFFER_DATA[1024], data[1024], "Eight byte in buffer should be seven.");
Assert.IsTrue(buffer.Completed, "Completed should be true.");//An impossible test case
buffer.Dispose();
}
public void DisposeTest()
{
var buffer = new NetworkBuffer(BIG_BUFFER_DATA.Length, BIG_BUFFER_DATA);
buffer.Dispose();
try
{
buffer.Read(1);
Assert.Fail("Any buffer operation after the buffer is disposed should result in an object disposed exception.");
}
catch (Exception ex)
{
Assert.IsTrue(ex is ObjectDisposedException, "Any buffer operation after the buffer is disposed should result in an object disposed exception. (Error was not Object Disposed Exception)");
}
}
public void AppendConstrainedTest4()
{
var buffer = new NetworkBuffer(20, new byte[] { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 });
var data = new byte[] { 10, 121, 55, 32, 44, 56, 31, 46, 71, 88 };
buffer.AppendConstrained(data, 2, 5);
Assert.AreEqual <int>(15, buffer.Received);
var received = buffer.ToArray();
Assert.AreEqual <byte>(0, received[0]);
Assert.AreEqual <byte>(4, received[4]);
Assert.AreEqual <byte>(55, received[10]);
Assert.AreEqual <byte>(31, received[14]);
buffer.Dispose();
}
public void GetBufferAfterMultipleAppend()
{
var buffer = new NetworkBuffer(8);
buffer.Append(new byte[] { 0, 1, 2, 3 });
buffer.Append(new byte[] { 4, 5, 6, 7 });
byte[] data = buffer.ToArray();
Assert.AreEqual <int>(8, buffer.Received, "Received was not the right size."); //An impossible test case
Assert.AreEqual <int>(8, buffer.Size, "Size was not assign the right value."); //An impossible test case
Assert.AreEqual <int>(buffer.Received, data.Length, "Received and length should be the same size.");
Assert.AreEqual <byte>(0, data[0], "First byte in buffer should be zero.");
Assert.AreEqual <byte>(7, data[7], "Eight byte in buffer should be seven.");
Assert.IsTrue(buffer.Completed, "Completed should be true.");//An impossible test case
buffer.Dispose();
}
public void ReadTest3()
{
MemoryStream bytesRead = new MemoryStream();
var buffer = new NetworkBuffer(BIG_BUFFER_DATA.Length, BIG_BUFFER_DATA);
for (int i = 0; i < BIG_BUFFER_DATA.Length; i += 1024)
{
byte[] read = buffer.Read(1024);
if (read != null)
{
bytesRead.Write(read, 0, read.Length);
}
}
Assert.AreEqual <long>(bytesRead.Position, BIG_BUFFER_DATA.LongLength, "Bytes written should be equal to bytes read");
buffer.Dispose();
}
public void ReadTest1()
{
var buffer = new NetworkBuffer(20, new byte[] { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 });
try
{
buffer.Read(5);
Assert.Fail("An exception should have been thrown when attempting to read this buffer.");
}
catch (Exception)
{
Assert.IsTrue(true);
}
finally
{
buffer.Dispose();
}
}
public void AppendConstrainedTest3()
{
var buffer = new NetworkBuffer(10, new byte[] { 0, 1, 2, 3, 4, 5, 6 });
try
{
buffer.AppendConstrained(new byte[] { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 }, 2, 8);
Assert.Fail("An exception should be thrown");
}
catch (Exception ex)
{
Assert.IsTrue(ex is ArgumentOutOfRangeException, "The exception thrown should be an \"Argument Out Of Range Exception\".");
}
finally
{
buffer.Dispose();
}
}
public void AppendConstrainedTest2()
{
var buffer = new NetworkBuffer(10);
try
{
buffer.AppendConstrained(null, 2, 5);
Assert.Fail("An exception should be thrown");
}
catch (Exception ex)
{
Assert.IsTrue(ex is ArgumentNullException, "The exception thrown should be an \"Argument Null Exception\".");
}
finally
{
buffer.Dispose();
}
}
public void ReadTest2()
{
var buffer = new NetworkBuffer(10, new byte[] { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 });
try
{
var bytes = buffer.Read(5);
Assert.IsNotNull(bytes, "Byte array should not be null.");
Assert.AreEqual <int>(5, bytes.Length, "Byte array read should contain five elements.");
}
catch (Exception ex)
{
Assert.Fail($"No exception should be thrown. Exception: ${ex.ToString()}");
}
finally
{
buffer.Dispose();
}
}
public void AppendBigBufferInChunks()
{
var buffer = new NetworkBuffer(BIG_BUFFER_DATA.Length);
for (int i = 0; i < 3000; i += 100)
{
byte[] copy = new byte[100];
Array.ConstrainedCopy(BIG_BUFFER_DATA, i, copy, 0, 100);
buffer.Append(copy);
}
byte[] data = buffer.ToArray();
Assert.AreEqual <int>(BIG_BUFFER_DATA.Length, buffer.Received, "Received was not the right size."); //An impossible test case
Assert.AreEqual <int>(BIG_BUFFER_DATA.Length, buffer.Size, "Size was not assign the right value."); //An impossible test case
Assert.AreEqual <int>(buffer.Received, data.Length, "Received and length should be the same size.");
Assert.AreEqual <byte>(BIG_BUFFER_DATA[5], data[5], "First byte in buffer should be zero.");
Assert.AreEqual <byte>(BIG_BUFFER_DATA[1024], data[1024], "Eight byte in buffer should be seven.");
Assert.IsTrue(buffer.Completed, "Completed should be true.");//An impossible test case
buffer.Dispose();
}
public void AppendAfterCompletedBuffer()
{
var buffer = new NetworkBuffer(10);
buffer.Append(new byte[] { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 });
try
{
buffer.Append(new byte[] { 0 });
Assert.Fail("Argument out of range exception should be thrown.");
}
catch (ArgumentOutOfRangeException)
{
}
catch (Exception)
{
Assert.Fail("Nothing other than argument out of range exception should be thrown.");
}
Assert.AreEqual <int>(10, buffer.Received, "Received was not the right size."); //An impossible test case
Assert.AreEqual <int>(10, buffer.Size, "Size was not assign the right value."); //An impossible test case
Assert.IsTrue(buffer.Completed, "Completed should be true."); //An impossible test case
buffer.Dispose();
}
