public void TestNonFixedArrayTryRead()
{
var tests = new[]
{
1, 2, 3, 4, 5,
1, 2, 3, 4, 5,
1, 2, 3, 4, 5,
1, 2, 3, 4, 5,
};
Span <byte> bytes = new byte[]
{
0xdc,
0x00,
0x14,
0x01, 0x02, 0x03, 0x04, 0x05,
0x01, 0x02, 0x03, 0x04, 0x05,
0x01, 0x02, 0x03, 0x04, 0x05,
0x01, 0x02, 0x03, 0x04, 0x05,
};
MsgPackSpec.TryReadArrayHeader(bytes, out var length, out var readSize).ShouldBeTrue();
length.ShouldBe(tests.Length);
var actual = new int[length];
for (var i = 0; i < length; i++)
{
actual[i] = MsgPackSpec.ReadInt32(bytes.Slice(readSize), out var temp);
readSize += temp;
}
actual.ShouldBe(tests);
}
public void TryReadNull()
{
var buffer = new [] { DataCodes.Nil };
MsgPackSpec.TryReadNil(buffer.ToMultipleSegments(), out var readSize).ShouldBeTrue();
readSize.ShouldBe(buffer.Length);
}
public void BadTryReadNull()
{
var buffer = new [] { DataCodes.Int8 };
MsgPackSpec.TryReadNil(buffer.ToSingleSegment(), out var readSize).ShouldBeFalse();
readSize.ShouldBe(buffer.Length);
}
public void TestNonFixedArray()
{
var tests = new[]
{
1, 2, 3, 4, 5,
1, 2, 3, 4, 5,
1, 2, 3, 4, 5,
1, 2, 3, 4, 5,
};
var bytes = new byte[]
{
0xdc,
0x00,
0x14,
0x01, 0x02, 0x03, 0x04, 0x05,
0x01, 0x02, 0x03, 0x04, 0x05,
0x01, 0x02, 0x03, 0x04, 0x05,
0x01, 0x02, 0x03, 0x04, 0x05,
};
using (var buffer = MemoryPool <byte> .Shared.Rent(bytes.Length))
{
var span = buffer.Memory.Span;
var wroteSize = MsgPackSpec.WriteArrayHeader(span, tests.Length);
foreach (var test in tests)
{
wroteSize += MsgPackSpec.WriteInt32(span.Slice(wroteSize), test);
}
wroteSize.ShouldBe(bytes.Length);
span.Slice(0, wroteSize).ToArray().ShouldBe(bytes);
}
}
public void EmptyRead()
{
var e = Should.Throw <ArgumentOutOfRangeException>(() => MsgPackSpec.ReadToken(System.Array.Empty <byte>()));
e.Message.ShouldBe($"EOF: Buffer is empty.{Environment.NewLine}Parameter name: buffer");
e.ParamName.ShouldBe("buffer");
}
public void SimpleArrayRead()
{
var tests = new[]
{
"a",
"b",
"c",
"d",
"e"
};
Span <byte> bytes = new byte[]
{
149,
161, 97,
161, 98,
161, 99,
161, 100,
161, 101
};
var length = MsgPackSpec.ReadArrayHeader(bytes, out var readSize);
length.ShouldBe(tests.Length);
var actual = new string[length];
for (var i = 0; i < length; i++)
{
actual[i] = MsgPackSpec.ReadString(bytes.Slice(readSize), out var temp);
readSize += temp;
}
actual.ShouldBe(tests);
}
private static void TestTryReadDictionary(byte[] bytes, Dictionary <int, string> test)
{
var sequence = bytes.ToSingleSegment();
MsgPackSpec.TryReadMapHeader(sequence, out var length, out var readSize).ShouldBeTrue();
ReadDictionary(test, length, sequence, readSize);
}
public void TryRead(long seconds, uint nanoSeconds, byte[] data)
{
MsgPackSpec.TryReadTimestamp(data, out var x, out var readSize).ShouldBeTrue();
readSize.ShouldBe(data.Length);
x.Seconds.ShouldBe(seconds);
x.NanoSeconds.ShouldBe(nanoSeconds);
}
public void EmptyRead()
{
var e = Should.Throw <ArgumentOutOfRangeException>(() => MsgPackSpec.ReadToken(System.Array.Empty <byte>().ToSingleSegment()));
e.Message.ShouldBe($"EOF: Sequence is empty.{Environment.NewLine}Parameter name: sequence");
e.ParamName.ShouldBe("sequence");
}
public void ReadNull()
{
var buffer = new [] { DataCodes.Nil };
MsgPackSpec.ReadNil(buffer.ToSingleSegment(), out var readSize);
readSize.ShouldBe(buffer.Length);
}
private static void TestReadDictionary(byte[] bytes, Dictionary <int, string> test)
{
var sequence = bytes.ToSingleSegment();
var length = (int)MsgPackSpec.ReadMapHeader(sequence, out var readSize);
ReadDictionary(test, length, sequence, readSize);
}
public void BadReadNull()
{
var buffer = new [] { DataCodes.True };
var e = Should.Throw <InvalidOperationException>(() => MsgPackSpec.ReadNil(buffer.ToSingleSegment(), out _));
e.Message.ShouldBe("Wrong data code: 0xc3. Expected: 0xc0.");
}
public void ReadNull()
{
var buffer = new[] { DataCodes.NeverUsed };
MsgPackSpec.WriteNil(buffer).ShouldBe(1);
buffer[0].ShouldBe(DataCodes.Nil);
}
public void NeverUsedRead()
{
var e = Should.Throw <ArgumentOutOfRangeException>(() => MsgPackSpec.ReadToken(new [] { DataCodes.NeverUsed }.ToSingleSegment()));
e.Message.ShouldBe($"Data code at sequence[0] is 0xc1 and it is invalid data code.{Environment.NewLine}Parameter name: sequence");
e.ParamName.ShouldBe("sequence");
}
public void TestStringPack(string s, byte[] data)
{
using (var buffer = MemoryPool <byte> .Shared.Rent(data.Length))
{
MsgPackSpec.TryWriteString(buffer.Memory.Span, s.AsSpan(), out var wroteSize).ShouldBeTrue();
buffer.Memory.Slice(0, wroteSize).ToArray().ShouldBe(data);
}
}
public void Test(bool value, byte[] data)
{
var buffer = new Span <byte>(ArrayPool <byte> .Shared.Rent(10));
var length = MsgPackSpec.WriteBoolean(buffer, value);
length.ShouldBe(data.Length);
buffer.Slice(0, length).ToArray().ShouldBe(data);
}
public void TestUnsignedLong(ulong number, byte[] data)
{
var buffer = new Span <byte>(ArrayPool <byte> .Shared.Rent(10));
var length = MsgPackSpec.WriteUInt64(buffer, number);
length.ShouldBe(data.Length);
buffer.Slice(0, length).ToArray().ShouldBe(data);
}
public void TestSignedByte(sbyte number, byte[] data)
{
var buffer = new Span <byte>(ArrayPool <byte> .Shared.Rent(10));
var length = MsgPackSpec.WriteInt8(buffer, number);
length.ShouldBe(data.Length);
buffer.Slice(0, length).ToArray().ShouldBe(data);
}
public void Test(byte[] value, byte[] data)
{
var buffer = new Span <byte>(ArrayPool <byte> .Shared.Rent(data.Length));
MsgPackSpec.TryWriteBinary(buffer, value, out var wroteSize).ShouldBeTrue();
wroteSize.ShouldBe(data.Length);
buffer.Slice(0, wroteSize).ToArray().ShouldBe(data);
}
public void Read(long seconds, uint nanoSeconds, byte[] data)
{
var x = MsgPackSpec.ReadTimestamp(data.ToSingleSegment(), out var readSize);
readSize.ShouldBe(data.Length);
x.Seconds.ShouldBe(seconds);
x.NanoSeconds.ShouldBe(nanoSeconds);
}
public void Read(byte[] value, byte[] data)
{
using (var owner = MsgPackSpec.ReadBinary(data.ToSingleSegment(), out var readSize))
{
readSize.ShouldBe(data.Length);
owner.Memory.ToArray().ShouldBe(value);
}
}
public void Test(long seconds, uint nanoSeconds, byte[] data)
{
using (var buffer = MemoryPool <byte> .Shared.Rent(data.Length))
{
var x = MsgPackSpec.WriteTimestamp(buffer.Memory.Span, new MsgPack.Timestamp(seconds, nanoSeconds));
x.ShouldBe(data.Length);
buffer.Memory.Slice(0, x).ToArray().ShouldBe(data);
}
}
public void TryRead(byte[] value, byte[] data)
{
MsgPackSpec.TryReadBinary(data.ToSingleSegment(), out var owner, out var readSize).ShouldBeTrue();
using (owner)
{
readSize.ShouldBe(data.Length);
owner.Memory.ToArray().ShouldBe(value);
}
}
public void NonEmptyRead(byte[] data, int objectsCount)
{
var buffer = data.ToSingleSegment();
for (var i = 0; i < objectsCount; i++)
{
buffer = buffer.Slice(MsgPackSpec.ReadToken(buffer).Length);
}
buffer.IsEmpty.ShouldBeTrue();
}
public void NonEmptyRead(byte[] data, int objectsCount)
{
ReadOnlySpan <byte> buffer = data;
for (var i = 0; i < objectsCount; i++)
{
buffer = buffer.Slice(MsgPackSpec.ReadToken(buffer).Length);
}
buffer.IsEmpty.ShouldBeTrue();
}
public int SpanConst()
{
var buffer = _buffer.AsSpan();
var i = 0;
for (; i < length; i++)
{
baseInt -= 1000u;
MsgPackSpec.WriteUInt32(buffer.Slice(5 * i), length);
}
return(i);
}
private static void ReadDictionary(Dictionary <int, string> test, int length, ReadOnlySequence <byte> span, int readSize)
{
length.ShouldBe(test.Count);
var dictionary = new Dictionary <int, string>(length);
for (var i = 0; i < length; i++)
{
span = span.Slice(readSize);
var key = MsgPackSpec.ReadInt32(span, out readSize);
span = span.Slice(readSize);
dictionary[key] = MsgPackSpec.ReadString(span, out readSize);
}
dictionary.ShouldBe(test, true);
}
public void DeepStack(int depth)
{
var buffer = new byte[depth];
var span = buffer.AsSpan();
while (span.Length > 1)
{
span = span.Slice(MsgPackSpec.WriteFixArrayHeader(span, 1));
}
MsgPackSpec.WritePositiveFixInt(span, 1);
var token = MsgPackSpec.ReadToken(buffer.ToSingleSegment());
token.Length.ShouldBe(buffer.Length);
}
public void NonEmptyRead(byte[] data, int objectsCount)
{
var readTokenBytes = new List <byte>();
ReadOnlySpan <byte> buffer = data;
for (var i = 0; i < objectsCount; i++)
{
using (var tokenBytes = MsgPackSpec.CopyToken(buffer))
{
buffer = buffer.Slice(tokenBytes.Memory.Length);
readTokenBytes.AddRange(tokenBytes.Memory.ToArray());
}
}
buffer.IsEmpty.ShouldBeTrue();
readTokenBytes.ShouldBe(data);
}
public void Read(string s, byte[] data)
{
MsgPackSpec.ReadString(data.ToSingleSegment(), out var readSize).ShouldBe(s);
readSize.ShouldBe(data.Length);
}
