public void CTorTest()
{
PtrWriter writer = new PtrWriter(m_buffer, 64);
Assert.AreEqual(64, writer.Length);
Assert.AreEqual(0, writer.Offset);
}
public void ClearTest()
{
var pw = new PtrWriter(m_buffer, 5, 64);
pw.Clear();
Assert.AreEqual(0, pw.Offset);
}
public void SkipBytesTest()
{
var pw = new PtrWriter(m_buffer, 10);
Assert.Catch(typeof(InvalidOperationException), () => { pw.SkipBytes(11); });
pw.SkipBytes(10);
Assert.AreEqual(10, pw.Offset);
}
public void TryWrite()
{
var bw = new PtrWriter(m_buffer, 64);
Assert.AreEqual(true, bw.TryWrite(123));
bw.SkipBytes(60);
Assert.AreEqual(false, bw.TryWrite(123));
}
public void PtrWrite()
{
PtrWriter writer = new PtrWriter(m_ptrBuf, AMOUNT * sizeof(int));
for (int i = 0; i < AMOUNT; i++)
{
writer.Write(i);
}
}
public void UTF16Test(string value)
{
var pw = new PtrWriter(m_buffer, 64);
pw.WriteUTF16(value, true);
var pr = new PtrReader(m_buffer, 64);
Assert.AreEqual(value, pr.ReadUTF16());
Assert.AreEqual(pr.Offset, pw.Offset);
}
public void CopyToBytesTest(int value)
{
byte[] buf = new byte[8];
BinaryHelper.Write(m_buffer, 4, value);
var pw = new PtrWriter(m_buffer, 64);
pw.CopyTo(buf, 0, 8);
Assert.AreEqual(value, BinaryHelper.Read <int>(buf, 4));
}
public void CopyToPtrTest(int value)
{
BinaryHelper.Write(m_buffer, 4, value);
var pw = new PtrWriter(m_buffer, 64);
var newBuf = Marshal.AllocHGlobal(8);
pw.CopyTo(newBuf, 0, 8);
Assert.AreEqual(value, BinaryHelper.Read <int>(newBuf, 4));
Marshal.FreeHGlobal(newBuf);
}
public void ANSITestLen(string value)
{
var pw = new PtrWriter(m_buffer, 64);
pw.WriteANSI(value);
var pr = new PtrReader(m_buffer, 64);
Assert.AreEqual(value, pr.ReadANSI(value.Length));
Assert.AreEqual(pr.Offset, pw.Offset);
Assert.AreEqual(value.Length, pw.Offset);
}
public void UTF16TestLen(string value)
{
var pw = new PtrWriter(m_buffer, 64);
pw.WriteUTF16(value);
var pr = new PtrReader(m_buffer, 64);
Assert.AreEqual(value, pr.ReadUTF16(value.Length));
Assert.AreEqual(pr.Offset, pw.Offset);
Assert.AreEqual(value.Length * sizeof(char), pw.Offset);
}
public void CTorFaultTest()
{
PtrWriter pw;
Assert.Catch(typeof(ArgumentNullException), () =>
{ pw = new PtrWriter(IntPtr.Zero, 64); });
Assert.Catch(typeof(ArgumentOutOfRangeException), () =>
{ pw = new PtrWriter(m_buffer, -1, -1); });
Assert.Catch(typeof(ArgumentOutOfRangeException), () =>
{ pw = new PtrWriter(m_buffer, 0, -1); });
Assert.Catch(typeof(ArgumentException), () =>
{ pw = new PtrWriter(m_buffer, 25, 6); });
}
public void ValueTest(int iVal, float fVal, double dVal)
{
var pw = new PtrWriter(m_buffer, 64);
pw.Write(iVal); pw.Write(fVal); pw.Write(dVal);
var pr = new PtrReader(m_buffer, 64);
Assert.AreEqual(iVal, pr.Read <int>());
Assert.AreEqual(fVal, pr.Read <float>());
Assert.AreEqual(dVal, pr.Read <double>());
Assert.AreEqual(16, pw.Offset);
Assert.AreEqual(pr.Offset, pw.Offset);
}
public void PtrWriterAsPointerTest(double vald, long vall)
{
PtrWriter pw = new PtrWriter(Alloc(16), 16);
var asPointer = pw.AsPointer();
asPointer->Write(vald);
asPointer->Write(vall);
Assert.AreEqual(16, asPointer->Offset);
Assert.AreEqual(16, asPointer->Length);
Assert.AreEqual(vald, BinaryHelper.Read <double>(pw.Buffer, 0));
Assert.AreEqual(vall, BinaryHelper.Read <long>(pw.Buffer, 8));
Free(asPointer->Buffer);
Free(asPointer);
}
public void BytesTest()
{
byte[] val = new byte[4] {
1, 2, 3, 4
};
var pw = new PtrWriter(m_buffer, 64);
pw.WriteBytes(val);
var pr = new PtrReader(m_buffer, 64);
var returnVal = pr.ReadBytes(4);
Assert.AreEqual(val, returnVal);
Assert.AreEqual(4, pr.Offset);
Assert.AreEqual(pw.Offset, pr.Offset);
}
public void WritePtrPtrWriterTest()
{
var pw = new PtrWriter(Alloc(32), 32);
byte *ptr = stackalloc byte[4] {
1, 2, 3, 4
};
pw.WritePtr(ptr, 4);
Assert.AreEqual(4, pw.Offset);
for (int i = 0; i < 4; i++)
{
BinaryHelper.Read <byte>(pw.Buffer, i);
}
Free(pw.Buffer);
}
public void PtrWrite()
{
PtrWriter writer = new PtrWriter(m_ptrBuf, SIZE);
for (int i = 0; i < AMOUNT / 2; i++)
{
writer.Write(i % 2 == 0);
writer.Write(i);
}
PtrReader reader = new PtrReader(m_ptrBuf, SIZE);
for (int i = 0; i < AMOUNT / 2; i++)
{
bool b = reader.Read <bool>();
int num = reader.Read <int>();
}
}
public void SizePrefixTest()
{
PtrWriter bw = new PtrWriter(m_buffer, 16);
bw.ReserveSizePrefix();
bw.Write(1);
bw.Write(2);
bw.Write(3);
Assert.AreEqual(16, bw.Offset);
Assert.AreEqual(16, bw.Length);
Assert.AreEqual(16, bw.PrefixSize());
PtrReader br = new PtrReader(bw.Buffer, 16);
Assert.AreEqual(16, br.Read <int>());
}
