public void TestPosition()
{
var rnd = new Random();
for (var c = 0; c < count; c++)
{
var memSize = 10_000;
var mem = new byte[memSize * 10];
var answer = new byte[memSize];
for (var i = 0; i < memSize; i++)
{
answer[i] = (byte)rnd.Next(0, 10);
}
var span1 = new MemoryStreamer(mem);
var span2 = new MemoryStreamer(mem);
for (var i = 0; i < memSize; i++)
{
span1.Position += answer[i];
span1.Write(answer[i]);
}
// Ensure span is not zero
for (var i = 0; i < memSize; i++)
{
span2.Position += answer[i];
var r = span2.ReadByte();
Assert.Equal(answer[i], r);
}
}
}
public void TestUInt64()
{
var rnd = new System.Random();
for (var c = 0; c < count; c++)
{
var mem = new byte[sizeof(UInt64) * writeRepeatCount];
var span1 = new MemoryStreamer(mem);
var span2 = new MemoryStreamer(mem);
var a = new UInt64[writeRepeatCount];
for (var i = 0; i < writeRepeatCount; i++)
{
var n = rnd.NextUInt64();
a[i] = n;
span1.Write(n);
}
for (var i = 0; i < writeRepeatCount; i++)
{
var r = span2.ReadUInt64();
Assert.Equal(a[i], r);
}
}
}
public void TestSizedString()
{
var rnd = new Random();
for (var c = 0; c < count; c++)
{
var memSize = rnd.Next(0, 1024);
var mem = new byte[(memSize + 4) * writeRepeatCount * 4];
var answer = new string[writeRepeatCount];
var span1 = new MemoryStreamer(mem);
var span2 = new MemoryStreamer(mem);
for (var i = 0; i < writeRepeatCount; i++)
{
var str = rnd.NextString("abcæøå诶 比西αβγ", memSize);
answer[i] = str;
span1.WriteSized(str);
}
for (var i = 0; i < writeRepeatCount; i++)
{
var r = span2.ReadSizedString(out var len);
Assert.Equal(answer[i], r);
}
}
}
public void TestStreamReadWrite()
{
var rnd = new Random();
for (var c = 0; c < count; c++)
{
var memSize = rnd.Next(1, 10_000);
var mem = new byte[(memSize + 4) * writeRepeatCount];
var answer = new byte[memSize * writeRepeatCount];
rnd.NextBytes(answer);
for (var bc = 1; bc < writeRepeatCount; bc++)
{
for (var offset = 0; offset < bc; offset++)
{
var span1 = new MemoryStreamer(mem);
var span2 = new MemoryStreamer(mem);
span1.Write(answer, offset, bc - offset);
var buffer = new byte[bc + offset];
span2.Read(buffer, offset, bc - offset);
Assert.Equal(new Span <byte>(answer).Slice(offset, bc - offset).ToArray(), new Memory <byte>(buffer).Slice(offset, bc - offset).ToArray());
}
}
Assert.Throws <ArgumentNullException>(() =>
{
var s = new MemoryStreamer(mem);
s.Read(null, 0, 1);
});
}
}
public void TestOtherStreamStuff()
{
var mem = new byte[2];
var ms = new MemoryStreamer(mem);
Assert.Throws <ArgumentOutOfRangeException>(() => ms.SetLength(mem.Length + 1));
ms.Flush();
}
public void TestLength()
{
var mem = new byte[100];
var ss = new MemoryStreamer(mem);
Assert.Equal(100, ss.Length);
Assert.Equal(100, ss.MaxLength);
ss.SetLength(0);
Assert.Equal(0, ss.Length);
ss.Write((UInt32)0);
Assert.Equal(4, ss.Length);
ss.Clear();
Assert.Equal(0, ss.Length);
}
public void TestSize()
{
var rnd = new System.Random();
for (var c = 0; c < count; c++)
{
var mem = new byte[sizeof(UInt32) * writeRepeatCount];
var span1 = new MemoryStreamer(mem);
var span2 = new MemoryStreamer(mem);
var a = new UInt32[writeRepeatCount];
for (var i = 0; i < writeRepeatCount; i++)
{
var sr = rnd.Next(0, 4);
uint n;
switch (sr)
{
case 0:
n = (UInt32)rnd.Next(0, 0b00111111);
break;
case 1:
n = (UInt32)rnd.Next(0b01000000, 0b00111111_11111111);
break;
case 2:
n = (UInt32)rnd.Next(0b01000000_00000000, 0b00111111_11111111_11111111);
break;
//case 3:
default:
n = (UInt32)rnd.Next(0b01000000_00000000_00000000, 0b00111111_11111111_11111111_11111111);
break;
}
a[i] = n;
span1.WriteSize(n);
}
for (var i = 0; i < writeRepeatCount; i++)
{
var r = span2.ReadSize(out var len);
Assert.Equal(span2.MeasureWriteSize(a[i]), len);
Assert.Equal(a[i], r);
}
}
}
public void TestCanReadCanWrite()
{
var mem = new byte[2];
var s = new Memory <byte>(mem);
var ros = new ReadOnlyMemory <byte>(mem);
var ss = new MemoryStreamer(s);
Assert.True(ss.CanRead);
Assert.True(ss.CanWrite);
Assert.True(ss.CanSeek);
var ross = new ReadOnlyMemoryStreamer(ros);
Assert.True(ross.CanRead);
Assert.False(ross.CanWrite);
Assert.True(ross.CanSeek);
}
public void TestPosOverflow()
{
var mem = new byte[2];
{
var s = new Memory <byte>(mem);
var ss = new MemoryStreamer(s);
ss.Position = mem.Length;
Assert.Equal(mem.Length, ss.Position);
ss.Position = 0;
Assert.Equal(0, ss.Position);
}
Assert.Throws <ArgumentOutOfRangeException>(() =>
{
var s = new Memory <byte>(mem);
var ss = new MemoryStreamer(s);
ss.Position = mem.Length + 1;
});
}
public void TestSizedReadWriteSpan()
{
var rnd = new Random();
for (var c = 0; c < count; c++)
{
var memSize = rnd.Next(1, 10_000);
var mem = new byte[(memSize + 4) * writeRepeatCount];
var answer = new byte[memSize * writeRepeatCount];
rnd.NextBytes(answer);
var span1 = new MemoryStreamer(mem);
var span2 = new MemoryStreamer(mem);
span1.WriteSized(new Span <byte>(answer));
span1.Write(1234);
var bytes = span2.ReadSizedBytes(out var length);
Assert.Equal(answer, bytes);
Assert.Equal(1234, span2.ReadInt32());
}
}
public void TestReadOnlyMemory()
{
var rnd = new Random();
for (var c = 0; c < count; c++)
{
var memSize = rnd.Next(1, 10_000);
var mem = new byte[(memSize + 4) * writeRepeatCount];
var answer = new byte[memSize * writeRepeatCount];
rnd.NextBytes(answer);
var span1 = new MemoryStreamer(mem);
var span2 = new MemoryStreamer(mem);
for (var i = 0; i < writeRepeatCount; i++)
{
var a = new Span <byte>(answer).Slice(memSize * i, memSize);
span1.Write(a);
}
// Ensure span is not zero
var ac = 0;
for (var wrc = 0; wrc < writeRepeatCount; wrc++)
{
var r = span2.ReadBytes(memSize);
for (var i = 0; i < r.Length; i++)
{
Assert.Equal(answer[ac++], r[i]);
}
}
Assert.Throws <ArgumentException>(() =>
{
var s = new MemoryStreamer(mem);
s.Write(new Span <byte>(new byte[mem.Length + 1]));
});
}
}
public void TestGuid()
{
for (var c = 0; c < count; c++)
{
var mem = new byte[16 * writeRepeatCount];
var span1 = new MemoryStreamer(mem);
var span2 = new MemoryStreamer(mem);
var a = new Guid[writeRepeatCount];
for (var i = 0; i < writeRepeatCount; i++)
{
var n = Guid.NewGuid();
a[i] = n;
span1.Write(n);
}
for (var i = 0; i < writeRepeatCount; i++)
{
var r = span2.ReadGuid();
Assert.Equal(a[i], r);
}
}
}
public void TestVLQInt32()
{
var rnd = new Random();
for (var c = 0; c < count; c++)
{
var memSize = rnd.Next(1, 10_000);
var mem = new byte[memSize * SpanUtils.MeasureVLQ(UInt32.MaxValue) + 1];
var span1 = new MemoryStreamer(mem);
var span2 = new MemoryStreamer(mem);
var data = new Int32[memSize];
for (var i = 0; i < memSize; i++)
{
data[i] = rnd.NextInt32();
}
for (var i = 0; i < memSize; i++)
{
span1.WriteVLQ(data[i]);
}
for (var i = 0; i < memSize; i++)
{
Assert.Equal(data[i], span2.ReadVLQInt32(out var len));
Assert.Equal(SpanUtils.MeasureVLQ(data[i]), len);
}
// Check overflow
new Span <byte>(mem).Fill(0xFF);
Assert.Throws <OverflowException>(() =>
{
var span3 = new MemoryStreamer(mem);
span3.ReadVLQInt32(out _);
});
}
}
/// <summary>
///
/// </summary>
/// <param name="maxSize">Maximum packet size. 5 bytes is used for header.</param>
public MessageObject(int maxSize)
{
_buffer = new byte[maxSize];
// User writable memory starts after header size
Stream = new MemoryStreamer(new Memory <byte>(_buffer, 4, _buffer.Length - 5));
}
