public void TestStreamCopy()
{
var inNetworkBuffer = new NetworkBuffer();
var copyNetworkBuffer = new NetworkBuffer();
byte initialValue1 = 56;
byte initialValue2 = 24;
inNetworkBuffer.WriteByte(initialValue1);
inNetworkBuffer.WriteByte(initialValue2);
byte copyValue1 = 27;
byte copyValue2 = 100;
copyNetworkBuffer.WriteByte(copyValue1);
copyNetworkBuffer.WriteByte(copyValue2);
inNetworkBuffer.CopyFrom(copyNetworkBuffer, 2);
var outNetworkBuffer = new NetworkBuffer(inNetworkBuffer.ToArray());
Assert.That(outNetworkBuffer.ReadByte(), Is.EqualTo(initialValue1));
Assert.That(outNetworkBuffer.ReadByte(), Is.EqualTo(initialValue2));
Assert.That(outNetworkBuffer.ReadByte(), Is.EqualTo(copyValue1));
Assert.That(outNetworkBuffer.ReadByte(), Is.EqualTo(copyValue2));
}
public void TestToArray()
{
var inNetworkBuffer = new NetworkBuffer();
inNetworkBuffer.WriteByte(5);
inNetworkBuffer.WriteByte(6);
Assert.That(inNetworkBuffer.ToArray().Length, Is.EqualTo(2));
}
public void CallDecode(Connection connection)
{
while (networkBuffer.Readable)
{
int oldReaderOffset = networkBuffer.ReadOffset;
//try to decode
bool result = Decode(connection);
if (result == false)
{
if (oldReaderOffset == networkBuffer.ReadOffset)
{
// wait to receive more data
break;
}
else
{
// Previous data has been discarded.
// Probably it is reading on.
//never be here -- wind
continue;
}
}
else if (msgCount == 0)
{
throw new InvalidOperationException(
"decode() method must read at least one byte " +
"if it returned a frame ");
}
try
{
if (connection.netHandler != null)
{
connection.netHandler.OnReceived(connection, networkBuffer.ToArray(), msgInitOffset, msgCount);
}
else
{
connection.OnReceived(connection, networkBuffer.ToArray(), msgInitOffset, msgCount);
}
}
finally
{
networkBuffer.ReadOffset = msgInitOffset + msgCount;
networkBuffer.DiscardReadBytes();
}
}
}
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 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 SynchronousIPV4SendSmallBufferTest()
{
try
{
NetworkBuffer buffer = TestData.GetDummyStream();
int sent = ipv4Client.Send(buffer.ToArray());
Assert.AreEqual(buffer.Size, sent, "Not all bytes were sent");
}
catch (Exception ex)
{
Assert.Fail(ex.ToString());
}
}
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 byte[] ToBytes()
{
var buffer = new NetworkBuffer();
var writer = new NetworkWriter(buffer);
writer.WriteUInt16Packed((ushort)Ticks.Length);
for (int i = 0; i < Ticks.Length; i++)
{
Ticks[i].SerializeToStream(buffer);
}
return(buffer.ToArray());
}
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 async Task AsyncTaskIPV4SendSmallBufferTest()
{
try
{
NetworkBuffer buffer = TestData.GetDummyStream();
int bytesSent = await ipv4Client.SendAsync(buffer.ToArray());
var task = ipv4ServerClient.ReceiveAsync();
Assert.AreEqual(buffer.Size, bytesSent, "Not all bytes were sent");
}
catch (Exception ex)
{
Assert.Fail(ex.ToString());
}
}
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 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 AsyncCallbackIPV4SendSmallBufferTest()
{
try
{
ManualResetEventSlim mevent = new ManualResetEventSlim(false);
NetworkBuffer buffer = TestData.GetDummyStream();
int bytesSent = 0;
ipv4Client.SendAsync(buffer.ToArray(), (sent) =>
{
bytesSent += sent;
var task = ipv4ServerClient.ReceiveAsync();
mevent.Set();
});
mevent.Wait(1000);
Assert.AreEqual(buffer.Size, bytesSent, "Not all bytes were sent");
}
catch (Exception ex)
{
Assert.Fail(ex.ToString());
}
}
