public unsafe void BytesWrite()
{
Random rng = new Random();
byte[] src = new byte[1024];
byte[] chk;
rng.NextBytes(src);
ManagedBinaryMemoryWriter writer = new ManagedBinaryMemoryWriter();
for (int count = 1; count < 1024; count++)
{
writer.WriteBytes(src, 0, 1024 - count);
}
using (MemoryStream ms = new MemoryStream(writer.ToArray()))
{
using (BinaryReader reader = new BinaryReader(ms))
for (int count = 1; count < 1024; count++)
{
chk = reader.ReadBytes(1024 - count);
for (int position = 0; position < 1024 - count; position++)
{
Assert.AreEqual(chk[position], src[position], $"Invalid content at position {position}.");
}
}
}
}
/// <summary>
/// Shoots into the backward direction.
/// </summary>
/// <param name="kind">The kind of shot.</param>
/// <param name="time">The amount of ticks when the produced shot shall explode.</param>
/// <returns>The name of the shot.</returns>
public async Task <string> ShootAft(FlattiverseResourceKind kind, int time)
{
using (Session session = server.connection.NewSession())
{
Packet packet = session.Request;
packet.Command = 0xB9;
packet.SubAddress = ID;
ManagedBinaryMemoryWriter writer = packet.Write();
writer.Write((byte)kind);
writer.Write((ushort)time);
server.connection.Send(packet);
server.connection.Flush();
Packet responsePacket = await session.Wait().ConfigureAwait(false);
BinaryMemoryReader reader = responsePacket.Read();
if (reader.Size < 11)
{
throw new InvalidOperationException("Couldn't create Shot.");
}
return(reader.ReadString());
}
}
public unsafe void ManagedBinaryMemoryWriter_Strings()
{
ManagedBinaryMemoryWriter writer = new ManagedBinaryMemoryWriter();
for (int count = 0; count < 10240; count++)
{
writer.Write("ABCDEFGHI");
}
}
public unsafe void ManagedBinaryMemoryWriter_Short()
{
ManagedBinaryMemoryWriter writer = new ManagedBinaryMemoryWriter();
for (int count = 0; count < 10240; count++)
{
writer.Write((short)0x5AA5);
}
}
public unsafe void ManagedBinaryMemoryWriter_Bytes()
{
ManagedBinaryMemoryWriter writer = new ManagedBinaryMemoryWriter();
for (int count = 0; count < 10240; count++)
{
writer.Write((byte)0x5A);
}
}
public unsafe void StringWrite()
{
foreach (int size in new int[] { 1, 127, 128, 16383, 16384, 2097151, 2097152, 268435455, 268435456, 300000000 })
{
ManagedBinaryMemoryWriter writer = new ManagedBinaryMemoryWriter();
writer.Write(new string('A', size));
using (MemoryStream ms = new MemoryStream(writer.ToArray()))
using (BinaryReader reader = new BinaryReader(ms))
Assert.AreEqual(reader.ReadString(), new string('A', size), "BinaryMemoryWriter String incompatible to BinaryWriter.");
}
}
public unsafe void InsertionPointAndLength()
{
ManagedBinaryMemoryWriter writer = new ManagedBinaryMemoryWriter();
Assert.AreEqual(writer.Length, 0, "Wrong size.");
writer.Write(0x55555555);
Assert.AreEqual(writer.Length, 4, "Wrong size.");
ManagedBinaryMemoryWriterSegment segment = writer.MakeInsertionpoint(2);
Assert.AreEqual(writer.Length, 4, "Wrong size.");
writer.Write(0xAAAAAAAA);
writer.Write(0xAAAAAAAA);
Assert.AreEqual(writer.Length, 12, "Wrong size.");
writer.Flush();
Assert.AreEqual(writer.Length, 12, "Wrong size.");
writer.Write(0xAAAAAAAA);
writer.Write(0xAAAAAAAA);
Assert.AreEqual(writer.Length, 20, "Wrong size.");
segment.Write((ushort)0x55AA);
Assert.AreEqual(writer.Length, 20, "Wrong size.");
segment.Finish();
Assert.AreEqual(writer.Length, 22, "Wrong size.");
writer.Flush();
Assert.AreEqual(writer.Length, 22, "Wrong size.");
byte[] data = writer.ToArray();
Assert.AreEqual(data.Length, 22, "Wrong result size.");
byte[] shouldBe = new byte[] { 0x55, 0x55, 0x55, 0x55, 0xAA, 0x55, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA };
for (int position = 0; position < data.Length; position++)
{
Assert.AreEqual(data[position], shouldBe[position], $"Value at position {position} is wrong.");
}
}
public unsafe void DoubleWrite()
{
ManagedBinaryMemoryWriter writer = new ManagedBinaryMemoryWriter();
for (int count = 0; count < 256; count++)
{
writer.Write((double)count);
}
using (MemoryStream ms = new MemoryStream(writer.ToArray()))
using (BinaryReader reader = new BinaryReader(ms))
for (int count = 0; count < 256; count++)
{
Assert.AreEqual(reader.ReadDouble(), (double)count, "BinaryMemoryWriter Double incompatible to BinaryWriter.");
}
}
public unsafe void DecimalWrite()
{
ManagedBinaryMemoryWriter writer = new ManagedBinaryMemoryWriter();
for (int count = 0; count < 256; count++)
{
writer.Write(count * 12347822345.34m);
}
using (MemoryStream ms = new MemoryStream(writer.ToArray()))
using (BinaryReader reader = new BinaryReader(ms))
for (int count = 0; count < 256; count++)
{
Assert.AreEqual(reader.ReadDecimal(), count * 12347822345.34m, "UnsafeBinaryMemoryWriter Decimal incompatible to BinaryWriter.");
}
}
public unsafe void BooleanWrite()
{
ManagedBinaryMemoryWriter writer = new ManagedBinaryMemoryWriter();
for (int count = 0; count < 256; count++)
{
writer.Write(count % 2 == 0);
}
using (MemoryStream ms = new MemoryStream(writer.ToArray()))
using (BinaryReader reader = new BinaryReader(ms))
for (int count = 0; count < 256; count++)
{
Assert.AreEqual(reader.ReadBoolean(), count % 2 == 0, "BinaryMemoryWriter Boolean incompatible to BinaryWriter.");
}
}
public unsafe void CharWrite()
{
ManagedBinaryMemoryWriter writer = new ManagedBinaryMemoryWriter();
for (int count = 0; count < 0xD800; count++)
{
writer.Write((char)count);
}
using (MemoryStream ms = new MemoryStream(writer.ToArray()))
using (BinaryReader reader = new BinaryReader(ms))
for (int count = 0; count < 0xD800; count++)
{
char c = reader.ReadChar();
Assert.AreEqual(c, (char)count, $"BinaryMemoryWriter Char incompatible to BinaryWriter: 0x{count:X04} != 0x{(int)c:X04}.");
}
}
public void ToArrayNew()
{
ManagedBinaryMemoryWriter writer = new ManagedBinaryMemoryWriter();
for (int i = 0; i < 20000000; i++)
{
writer.Write((byte)0xAA);
}
byte[] data = writer.ToArray();
Assert.AreEqual(data.Length, 20000000, "Wrong length of generated data.");
foreach (byte b in data)
{
Assert.AreEqual(b, 0xAA, "Wrong Byte in data.");
}
}
public unsafe void MixedWrite()
{
ManagedBinaryMemoryWriter writer = new ManagedBinaryMemoryWriter();
writer.Write("abcABCäöüÄÖÜßáÁàÀ♥♦♣♠");
writer.Write((byte)66);
writer.Write(0x48484848);
writer.Write(0x84848484U);
writer.Write("abcABCäöüÄÖÜßáÁàÀ♥♦♣♠");
using (MemoryStream ms = new MemoryStream(writer.ToArray()))
using (BinaryReader reader = new BinaryReader(ms))
{
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.");
}
}
internal void Write(ManagedBinaryMemoryWriter writer)
{
writer.Write(ID);
writer.Write(Name);
if (Team == null)
{
writer.Write((byte)0xFF);
}
else
{
writer.Write(Team.ID);
}
writer.Write(Left);
writer.Write(Top);
writer.Write(Right);
writer.Write(Bottom);
writer.Write(Spawn);
}
public void ToArrayExisting()
{
byte[] data = new byte[40000000];
ManagedBinaryMemoryWriter writer = new ManagedBinaryMemoryWriter();
for (int i = 0; i < 20000000; i++)
{
writer.Write((byte)0xAA);
}
int size = writer.ToArray(data, 0);
Assert.AreEqual(20000000, size, "Wrong length of generated data.");
for (int position = 0; position < size; position++)
{
Assert.AreEqual(data[position], 0xAA, "Wrong Byte in data.");
}
}
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));
ManagedBinaryMemoryWriter writer = new ManagedBinaryMemoryWriter();
for (int c = 0; c < 40; c++)
{
foreach (KeyValuePair <ulong, int> pair in pairs)
{
writer.Write7BitEncoded(pair.Key);
}
}
data = writer.ToArray();
fixed(byte *pData = data)
{
BinaryMemoryReader reader = new BinaryMemoryReader(pData, data.Length);
for (int c = 0; c < 40; c++)
{
foreach (KeyValuePair <ulong, int> pair in pairs)
{
Assert.AreEqual(pair.Key, reader.Read7BitEncoded(), $"Didn't read what i've wrote with {pair.Key}, turn {c}.");
}
}
}
}
public void ToStream()
{
ManagedBinaryMemoryWriter writer = new ManagedBinaryMemoryWriter();
for (int i = 0; i < 20000000; i++)
{
writer.Write((byte)0xAA);
}
MemoryStream stream = new MemoryStream();
int size = (int)writer.ToStream(stream);
Assert.AreEqual(size, 20000000, "Wrong length of generated data.");
Assert.AreEqual(stream.Position, 20000000, "Wrong length of generated data.");
foreach (byte b in stream.ToArray())
{
Assert.AreEqual(b, 0xAA, "Wrong Byte in data.");
}
}
public unsafe void ToPointer()
{
ManagedBinaryMemoryWriter writer = new ManagedBinaryMemoryWriter();
for (int i = 0; i < 20000000; i++)
{
writer.Write((byte)0xAA);
}
byte[] data = new byte[20000000];
int size;
fixed(byte *pData = data)
size = (int)writer.ToPointer(pData);
Assert.AreEqual(size, 20000000, "Wrong length of generated data.");
foreach (byte b in data)
{
Assert.AreEqual(b, 0xAA, "Wrong Byte in data.");
}
}
public unsafe void InsertionPointFail()
{
ManagedBinaryMemoryWriter writer = new ManagedBinaryMemoryWriter();
Assert.AreEqual(writer.Length, 0, "Wrong size.");
writer.Write(0x55555555);
Assert.AreEqual(writer.Length, 4, "Wrong size.");
ManagedBinaryMemoryWriterSegment segment = writer.MakeInsertionpoint(2);
Assert.AreEqual(writer.Length, 4, "Wrong size.");
writer.Write(0xAAAAAAAA);
writer.Write(0xAAAAAAAA);
Assert.AreEqual(writer.Length, 12, "Wrong size.");
writer.Flush();
Assert.AreEqual(writer.Length, 12, "Wrong size.");
writer.Write(0xAAAAAAAA);
writer.Write(0xAAAAAAAA);
Assert.AreEqual(writer.Length, 20, "Wrong size.");
try
{
segment.Write(0x55AA55AA);
Assert.Fail("Should have thrown an exception.");
}
catch (Exception exception)
{
Assert.IsTrue(exception is InvalidOperationException, "Wrong exception kind.");
Assert.AreEqual(exception.Message, "An insertionpoint can't increase in size.", "Wrong exception message.");
}
Assert.AreEqual(writer.Length, 20, "Wrong size.");
segment.Write((ushort)0x55AA);
Assert.AreEqual(writer.Length, 20, "Wrong size.");
segment.Finish();
Assert.AreEqual(writer.Length, 22, "Wrong size.");
writer.Flush();
Assert.AreEqual(writer.Length, 22, "Wrong size.");
byte[] data = writer.ToArray();
Assert.AreEqual(data.Length, 22, "Wrong result size.");
byte[] shouldBe = new byte[] { 0x55, 0x55, 0x55, 0x55, 0xAA, 0x55, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA };
for (int position = 0; position < data.Length; position++)
{
Assert.AreEqual(data[position], shouldBe[position], $"Value at position {position} is wrong.");
}
}
public unsafe void ManagedBinaryMemoryWriter_Initialize()
{
ManagedBinaryMemoryWriter writer = new ManagedBinaryMemoryWriter();
writer.Write((byte)0x5A);
}
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;
}
}
List <TimeSpan> timeSpans = new List <TimeSpan>();
foreach (long timeLong in timeLongs)
{
timeSpans.Add(new TimeSpan(timeLong));
}
ManagedBinaryMemoryWriter writer = new ManagedBinaryMemoryWriter();
foreach (TimeSpan timeSpan in timeSpans)
{
writer.WriteCompressed(timeSpan);
}
byte[] data = writer.ToArray();
Assert.AreEqual(required, data.Length, "The created array has the wrong size.");
fixed(byte *pData = data)
{
UnsafeBinaryMemoryReader reader = new UnsafeBinaryMemoryReader(pData);
foreach (TimeSpan timeSpan in timeSpans)
{
Assert.AreEqual(timeSpan, reader.ReadCompressedTimeSpan(), "BinaryMemoryReader TimeSpan Compressed incompatible to BinaryMemoryWriter.");
}
}
}
internal void Write(ManagedBinaryMemoryWriter writer)
{
writer.Write(x);
writer.Write(y);
}
