internal void BufferTestReadInternal(ref MessageStream buf, string data, int start, int end, string fullData = null)
{
int bytes = data.Length * 2;
string dataCheck;
unsafe
{
fixed(MessageStream *bufPtr = &buf)
{
MessageStreamBuilder messageBuilder = new MessageStreamBuilder(bufPtr);
fixed(char *d = data)
{
messageBuilder.WriteRaw((byte *)d, bytes);
}
}
byte[] arr = buf.ToByteArray(start, end);
fixed(byte *a = arr)
{
dataCheck = new string((char *)a, 0, arr.Length / 2);
}
}
Assert.AreEqual((fullData ?? data).Substring(start / 2, (end - start) / 2), dataCheck);
}
public void BufferTestWriteNullThrows()
{
unsafe
{
MessageStream buf = new MessageStream(16);
MessageStreamBuilder messageBuilder = new MessageStreamBuilder(&buf);
Assert.Throws <System.ArgumentNullException>(() => messageBuilder.WriteRaw(null, 4));
}
}
public void BufferTestWriteNull0()
{
unsafe
{
MessageStream buf = new MessageStream(16);
MessageStreamBuilder messageBuilder = new MessageStreamBuilder(&buf);
messageBuilder.WriteRaw(null, 0);
Assert.AreEqual(0, buf.TotalBytes);
}
}
public void BufferTestWrite0()
{
unsafe
{
MessageStream buf = new MessageStream(16);
MessageStreamBuilder messageBuilder = new MessageStreamBuilder(&buf);
string data = "abcd";
fixed(char *d = data)
{
messageBuilder.WriteRaw((byte *)d, 0);
}
Assert.AreEqual(0, buf.TotalBytes);
}
}
internal unsafe void BufferTestWriteInternal(ref MessageStream buf, string data)
{
int reserve = buf.m_Reserve;
int bytes = data.Length * 2;
int oldHeadBytes = buf.BufferRead->Size;
int oldTotalBytes = buf.TotalBytes;
unsafe
{
fixed(MessageStream *bufPtr = &buf)
{
MessageStreamBuilder messageBuilder = new MessageStreamBuilder(bufPtr);
fixed(char *d = data)
{
messageBuilder.WriteRaw((byte *)d, bytes);
}
}
Assert.AreEqual(oldTotalBytes + bytes, buf.TotalBytes);
if (buf.TotalBytes > reserve)
{
// Read buffer should be unchanged (including if size was 0) once it's exceeded
Assert.AreEqual(oldHeadBytes, buf.BufferRead->Size);
// Write buffer should contain a single data write in a consecutive buffer
Assert.AreEqual(bytes, buf.BufferWrite->Size);
Assert.AreEqual(data, new string((char *)buf.BufferWrite->Buffer, 0, data.Length));
}
else
{
// Read buffer should contain accumulative data writes as long as reserve size is not exceeded
Assert.AreEqual(oldHeadBytes + bytes, buf.BufferRead->Size);
Assert.AreEqual(data, new string((char *)buf.BufferRead->Buffer, oldTotalBytes / 2, data.Length));
// Write buffer should match read buffer as long as we are within reserve size
Assert.AreEqual(oldTotalBytes + bytes, buf.BufferWrite->Size);
Assert.AreEqual(data, new string((char *)buf.BufferWrite->Buffer, oldTotalBytes / 2, data.Length));
Assert.AreEqual(oldHeadBytes, oldTotalBytes);
}
}
}
