public unsafe void BooleanPeek()
{
byte[] data;
using (MemoryStream ms = new MemoryStream())
{
using (BinaryWriter writer = new BinaryWriter(ms))
for (int count = 16; count < 256; count++)
{
writer.Write(count % 2 == 0);
}
data = ms.ToArray();
}
fixed(byte *pData = data)
{
UnsafeBinaryMemoryReader reader = new UnsafeBinaryMemoryReader(pData);
for (int count = 16; count < 256; count++)
{
Assert.AreEqual(reader.PeekBoolean(), true, "UnsafeBinaryMemoryReader Boolean incompatible to BinaryWriter.");
}
}
}
public unsafe void DoublePeek()
{
byte[] data;
using (MemoryStream ms = new MemoryStream())
{
using (BinaryWriter writer = new BinaryWriter(ms))
for (int count = 16; count < 256; count++)
{
writer.Write((double)count);
}
data = ms.ToArray();
}
fixed(byte *pData = data)
{
UnsafeBinaryMemoryReader reader = new UnsafeBinaryMemoryReader(pData);
for (int count = 16; count < 256; count++)
{
Assert.AreEqual(reader.PeekDouble(), 16.0, "UnsafeBinaryMemoryReader Double incompatible to BinaryWriter.");
}
}
}
public unsafe void CharPeek()
{
byte[] data;
using (MemoryStream ms = new MemoryStream())
{
using (BinaryWriter writer = new BinaryWriter(ms))
for (int count = 0; count < 0xD800; count++)
{
writer.Write((char)count);
}
data = ms.ToArray();
}
fixed(byte *pData = data)
{
UnsafeBinaryMemoryReader reader = new UnsafeBinaryMemoryReader(pData);
for (int count = 0; count < 0xD800; count++)
{
Assert.AreEqual(reader.PeekChar(), (char)count, "UnsafeBinaryMemoryReader Char incompatible to BinaryWriter.");
reader.ReadChar();
}
}
}
public unsafe void SingleRead()
{
byte[] data;
using (MemoryStream ms = new MemoryStream())
{
using (BinaryWriter writer = new BinaryWriter(ms))
for (int count = 0; count < 256; count++)
{
writer.Write((float)count);
}
data = ms.ToArray();
}
fixed(byte *pData = data)
{
UnsafeBinaryMemoryReader reader = new UnsafeBinaryMemoryReader(pData);
for (int count = 0; count < 256; count++)
{
Assert.AreEqual(reader.ReadSingle(), count, "UnsafeBinaryMemoryReader Float incompatible to BinaryWriter.");
}
}
}
public unsafe void UShortPeek()
{
byte[] data;
using (MemoryStream ms = new MemoryStream())
{
using (BinaryWriter writer = new BinaryWriter(ms))
for (int count = 16; count < 256; count++)
{
writer.Write((ushort)count);
}
data = ms.ToArray();
}
fixed(byte *pData = data)
{
UnsafeBinaryMemoryReader reader = new UnsafeBinaryMemoryReader(pData);
for (int count = 16; count < 256; count++)
{
Assert.AreEqual(reader.PeekUInt16(), (ushort)16, "UnsafeBinaryMemoryReader UShort incompatible to BinaryWriter.");
}
}
}
public unsafe void DecimalRead()
{
byte[] data;
using (MemoryStream ms = new MemoryStream())
{
using (BinaryWriter writer = new BinaryWriter(ms))
for (int count = 0; count < 256; count++)
{
writer.Write(count * 12347822345.34m);
}
data = ms.ToArray();
}
fixed(byte *pData = data)
{
UnsafeBinaryMemoryReader reader = new UnsafeBinaryMemoryReader(pData);
for (int count = 0; count < 256; count++)
{
Assert.AreEqual(reader.ReadDecimal(), count * 12347822345.34m, "UnsafeBinaryMemoryReader Decimal incompatible to BinaryWriter.");
}
}
}
public unsafe void MixedRead()
{
byte[] data;
using (MemoryStream ms = new MemoryStream())
{
using (BinaryWriter writer = new BinaryWriter(ms))
{
writer.Write("abcABCäöüÄÖÜßáÁàÀ♥♦♣♠");
writer.Write((byte)66);
writer.Write(0x48484848);
writer.Write(0x84848484U);
writer.Write("abcABCäöüÄÖÜßáÁàÀ♥♦♣♠");
}
data = ms.ToArray();
}
fixed(byte *pData = data)
{
UnsafeBinaryMemoryReader reader = new UnsafeBinaryMemoryReader(pData);
Assert.AreEqual(reader.ReadString(), "abcABCäöüÄÖÜßáÁàÀ♥♦♣♠", "BinaryMemoryReader String incompatible to BinaryReader.");
Assert.AreEqual(reader.ReadByte(), (byte)66, "BinaryMemoryReader Byte incompatible to BinaryReader.");
Assert.AreEqual(reader.ReadInt32(), 0x48484848, "BinaryMemoryReader Int incompatible to BinaryReader.");
Assert.AreEqual(reader.ReadUInt32(), 0x84848484U, "BinaryMemoryReader UInt incompatible to BinaryReader.");
Assert.AreEqual(reader.ReadString(), "abcABCäöüÄÖÜßáÁàÀ♥♦♣♠", "BinaryMemoryReader 2nd String incompatible to BinaryReader.");
}
}
public unsafe void UnsafeBinaryMemoryReader_Initialize()
{
byte[] data = new byte[1];
fixed(byte *pData = data)
{
UnsafeBinaryMemoryReader reader = new UnsafeBinaryMemoryReader(pData);
reader.ReadByte();
}
}
public unsafe void UnsafeBinaryMemoryReader_Strings(byte[] data)
{
fixed(byte *pData = data)
{
UnsafeBinaryMemoryReader reader = new UnsafeBinaryMemoryReader(pData);
for (int count = 0; count < 10240; count++)
{
reader.ReadString();
}
}
}
public unsafe void UnsafeBinaryMemoryReader_Short()
{
byte[] data = new byte[20480];
fixed(byte *pData = data)
{
UnsafeBinaryMemoryReader reader = new UnsafeBinaryMemoryReader(pData);
for (int count = 0; count < 10240; count++)
{
reader.ReadInt16();
}
}
}
public unsafe void UnsafeBinaryMemoryReader_Bytes()
{
byte[] data = new byte[10240];
fixed(byte *pData = data)
{
UnsafeBinaryMemoryReader reader = new UnsafeBinaryMemoryReader(pData);
for (int count = 0; count < 10240; count++)
{
reader.ReadByte();
}
}
}
public unsafe void VanillaStringPeek()
{
foreach (int size in new int[] { 1, 2, 3, 20, 5000 })
{
byte[] data = new byte[size];
for (int i = 0; i < size; i++)
{
data[i] = 65;
fixed(byte *pData = data)
{
UnsafeBinaryMemoryReader reader = new UnsafeBinaryMemoryReader(pData);
Assert.AreEqual(reader.PeekVanillaString(size), new string('A', size), "UnsafeBinaryMemoryReader String incompatible to BinaryReader.");
}
}
}
public unsafe void SevenBitEncoded()
{
byte[] data;
List <KeyValuePair <ulong, int> > pairs = new List <KeyValuePair <ulong, int> >();
pairs.Add(new KeyValuePair <ulong, int>(0L, 1));
for (int d = 1; d < 10; d++)
{
pairs.Add(new KeyValuePair <ulong, int>((1UL << (d * 7)) - 1, d));
pairs.Add(new KeyValuePair <ulong, int>(1UL << (d * 7), d + 1));
}
pairs.Add(new KeyValuePair <ulong, int>(ulong.MaxValue, 10));
foreach (KeyValuePair <ulong, int> pair in pairs)
{
data = new byte[pair.Value * 3];
fixed(byte *pData = data)
{
UnsafeBinaryMemoryWriter writer = new UnsafeBinaryMemoryWriter(pData);
writer.Write7BitEncoded(pair.Key);
writer.Write7BitEncoded(pair.Key);
writer.Write7BitEncoded(pair.Key);
UnsafeBinaryMemoryReader reader = new UnsafeBinaryMemoryReader(pData);
try
{
Assert.AreEqual(pair.Key, reader.Read7BitEncoded(), $"Didn't read what i've wrote with {pair.Key}.");
Assert.AreEqual(pair.Key, reader.Read7BitEncoded(), $"Didn't read what i've wrote with {pair.Key}.");
Assert.AreEqual(pair.Key, reader.Read7BitEncoded(), $"Didn't read what i've wrote with {pair.Key}.");
}
catch
{
Assert.Fail($"Should not have thrown an Exception, but did with {pair.Key}.");
}
}
}
}
public unsafe void StringNonNullPeek()
{
foreach (int size in new int[] { 1, 127, 128, 16383, 16384, 2097151, 2097152, 268435455, 268435456, 300000000 })
{
byte[] data;
using (MemoryStream ms = new MemoryStream())
{
using (BinaryWriter writer = new BinaryWriter(ms))
writer.Write(new string('A', size));
data = ms.ToArray();
}
fixed(byte *pData = data)
{
UnsafeBinaryMemoryReader reader = new UnsafeBinaryMemoryReader(pData);
Assert.AreEqual(reader.PeekStringNonNull(), new string('A', size), "UnsafeBinaryMemoryReader String incompatible to BinaryReader.");
}
}
}
public unsafe void BytesRead()
{
Random rng = new Random();
byte[] src = new byte[1024];
byte[] chk = new byte[1024];
rng.NextBytes(src);
byte[] data;
using (MemoryStream ms = new MemoryStream())
{
using (BinaryWriter writer = new BinaryWriter(ms))
for (int count = 0; count < 256; count++)
{
writer.Write(src);
}
data = ms.ToArray();
}
fixed(byte *pData = data)
{
UnsafeBinaryMemoryReader reader = new UnsafeBinaryMemoryReader(pData);
for (int count = 0; count < 256; count++)
{
reader.ReadBytes(chk, 0, 1024);
for (int position = 0; position < 1024; position++)
{
Assert.AreEqual(chk[position], src[position], $"Invalid content at position {position}.");
}
}
}
}
public unsafe void CompressedTimeSpanRead()
{
int required = 0;
List <long> timeLongs = new List <long>()
{
//Limits 1 Byte -> 3 Byte
0, 1, -1, 0x1F, -0x1F, 0x20, -0x20,
0xFF_FF, -0xFF_FF, 0x01_00_00, -0x01_00_00,
//Limits 3 Byte -> 5 Byte
0x1F_FF_FF, -0x1F_FF_FF, 0x20_00_00, -0x20_00_00,
0x01_00_00_00, -0x01_00_00_00,
0xFF_FF_FF_FF, -0xFF_FF_FF_FF,
0x01_00_00_00_00, -0x01_00_00_00_00,
0x01_01_00_00_00, -0x01_01_00_00_00,
0x01_00_01_00_00, -0x01_00_01_00_00,
0x01_00_00_01_00, -0x01_00_00_01_00,
0x01_00_00_00_01, -0x01_00_00_00_01,
//Limits 5 Byte -> 8 Byte
0x1F_FF_FF_FF_FF, -0x1F_FF_FF_FF_FF, 0x20_00_00_00_00, -0x20_00_00_00_00,
0x01_00_00_00_00, -0x01_00_00_00_00,
0xFF_FF_FF_FF_FF, -0xFF_FF_FF_FF_FF,
0xFF_00_FF_FF_FF, -0xFF_00_FF_FF_FF,
0xFF_FF_00_FF_FF, -0xFF_FF_00_FF_FF,
0xFF_FF_FF_00_FF, -0xFF_FF_FF_00_FF,
0xFF_FF_FF_FF_00, -0xFF_FF_FF_FF_00,
0x01_00_00_00_00_00, -0x01_00_00_00_00_00,
0x01_00_00_01_00_00, -0x01_00_00_01_00_00,
0x01_00_00_00_01_00, -0x01_00_00_00_01_00,
0x01_00_00_00_00_01, -0x01_00_00_00_00_01,
0xFF_FF_FF_FF_FF_FF, -0xFF_FF_FF_FF_FF_FF,
0x01_00_00_00_00_00_00, -0x01_00_00_00_00_00_00,
0x01_00_00_00_00_01_00, -0x01_00_00_00_00_01_00,
0x01_00_00_00_00_00_01, -0x01_00_00_00_00_00_01,
0xFF_FF_FF_FF_FF_FF_FF, -0xFF_FF_FF_FF_FF_FF_FF,
0x01_00_00_00_00_00_00_00, -0x01_00_00_00_00_00_00_00,
0x01_00_00_00_00_00_01_00, -0x01_00_00_00_00_00_01_00,
0x01_00_00_00_00_00_00_01, -0x01_00_00_00_00_00_00_01,
//Limits -> 8 Byte
0x1F_FF_FF_FF_FF_FF_FF_FF, -0x1F_FF_FF_FF_FF_FF_FF_FF
};
foreach (long timeLong in timeLongs)
{
long checkLong = timeLong;
if (checkLong < 0)
{
checkLong = -checkLong;
}
if (checkLong >= 137438953472)
{
required += 8;
}
else if (checkLong >= 2097152)
{
required += 5;
}
else if (checkLong >= 32)
{
required += 3;
}
else
{
required += 1;
}
}
byte[] data = new byte[required];
List <TimeSpan> timeSpans = new List <TimeSpan>();
foreach (long timeLong in timeLongs)
timeSpans.Add(new TimeSpan(timeLong));
fixed(byte *pData = data)
{
UnsafeBinaryMemoryWriter writer = new UnsafeBinaryMemoryWriter(pData);
foreach (TimeSpan timeSpan in timeSpans)
{
writer.WriteCompressed(timeSpan);
}
}
fixed(byte *pData = data)
{
UnsafeBinaryMemoryReader reader = new UnsafeBinaryMemoryReader(pData);
foreach (TimeSpan timeSpan in timeSpans)
{
Assert.AreEqual(timeSpan, reader.ReadCompressedTimeSpan(), "UnsafeBinaryMemoryReader TimeSpan Compressed incompatible to UnsafeBinaryMemoryWriter.");
}
}
}
