public void CTorOffsetTest()
{
PtrReader pr = new PtrReader(m_buffer, 10, 15);
Assert.AreEqual(10, pr.Offset);
Assert.AreEqual(15, pr.Length);
}
public void ClearTest()
{
var pr = new PtrReader(m_buffer, 5, 5);
pr.Clear();
Assert.AreEqual(0, pr.Offset);
}
public void SkipBytesTest()
{
var pr = new PtrReader(m_buffer, 10);
Assert.Catch(typeof(InvalidOperationException), () => { pr.SkipBytes(11); });
pr.SkipBytes(10);
Assert.AreEqual(10, pr.Offset);
}
public void TryRead()
{
var br = new PtrReader(m_buffer, 64);
Assert.AreEqual(true, br.TryRead(out int value));
br.SkipBytes(60);
Assert.AreEqual(false, br.TryRead(out int valu2));
}
public void PtrRead()
{
PtrReader reader = new PtrReader(m_ptrBuf, AMOUNT * sizeof(int));
for (int i = 0; i < AMOUNT; i++)
{
int result = reader.Read <int>();
}
}
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 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 CTorTest()
{
byte[] buf = new byte[30];
Assert.Catch(typeof(ArgumentNullException), () =>
{ var pr = new PtrReader(IntPtr.Zero, 64); });
PtrReader reader = new PtrReader(m_buffer, 64);
Assert.AreEqual(64, reader.Length);
Assert.AreEqual(0, reader.Offset);
}
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 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 ReadPtrPtrReaderTest(int value)
{
IntPtr ptr = Alloc(4);
BinaryHelper.Write(ptr, 0, value);
PtrReader pr = new PtrReader(ptr, 4);
IntPtr dest = Alloc(4);
pr.ReadPtr(dest.ToPointer(), 4);
Assert.AreEqual(4, pr.Offset);
Assert.AreEqual(value, BinaryHelper.Read <int>(dest, 0));
Free(ptr);
Free(dest);
}
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>());
}
public void PtrReaderAsPointerTest(double vald, long vall)
{
IntPtr data = Alloc(16);
BinaryHelper.Write(data, 0, vald);
BinaryHelper.Write(data, 8, vall);
PtrReader pr = new PtrReader(data, 16);
var asPointer = pr.AsPointer();
Assert.AreEqual(vald, asPointer->Read <double>());
Assert.AreEqual(vall, asPointer->Read <long>());
Assert.AreEqual(16, asPointer->Offset);
Assert.AreEqual(16, asPointer->Length);
Free(asPointer->Buffer);
Free(asPointer);
}
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>();
}
}
