public void DoubleBoundaryTest()
{
var capacity = 18;
using var buffer = new MessagePackBuffer(capacity);
var serializer = MessagePackSerializersRepository.Get <double>();
serializer.Serialize(double.MinValue, buffer);
serializer.Serialize(double.MaxValue, buffer);
Assert.Equal(buffer.Length, capacity);
var firstValue = buffer.GetPart(0, 9);
Assert.Equal(firstValue[0], 203);
Assert.Equal(firstValue[1], 255);
Assert.Equal(firstValue[2], 239);
Assert.Equal(firstValue[3], 255);
Assert.Equal(firstValue[4], 255);
Assert.Equal(firstValue[5], 255);
Assert.Equal(firstValue[6], 255);
Assert.Equal(firstValue[7], 255);
Assert.Equal(firstValue[8], 255);
var secondValue = buffer.GetPart(9, 9);
Assert.Equal(secondValue[0], 203);
Assert.Equal(secondValue[1], 127);
Assert.Equal(secondValue[2], 239);
Assert.Equal(secondValue[3], 255);
Assert.Equal(secondValue[4], 255);
Assert.Equal(secondValue[5], 255);
Assert.Equal(secondValue[6], 255);
Assert.Equal(secondValue[7], 255);
Assert.Equal(secondValue[8], 255);
}
public void FloatBoundaryTest()
{
var capacity = 10;
using var buffer = new MessagePackBuffer(capacity);
var serializer = MessagePackSerializersRepository.Get <float>();
serializer.Serialize(float.MaxValue, buffer);
serializer.Serialize(float.MinValue, buffer);
Assert.Equal(buffer.Length, capacity);
var firstValue = buffer.GetPart(0, 5);
Assert.Equal(firstValue[0], 202);
Assert.Equal(firstValue[1], 127);
Assert.Equal(firstValue[2], 127);
Assert.Equal(firstValue[3], 255);
Assert.Equal(firstValue[4], 255);
var secondValue = buffer.GetPart(5, 5);
Assert.Equal(secondValue[0], 202);
Assert.Equal(secondValue[1], 255);
Assert.Equal(secondValue[2], 127);
Assert.Equal(secondValue[3], 255);
Assert.Equal(secondValue[4], 255);
}
private ReadOnlySpan <byte> SerializeRequest(RequestBase request)
{
_serializationBuffer.Clear();
_serializationBuffer.Seek(LENGTH_OFFSET, SeekOrigin.Begin);
request.Serialize(_writer);
var requestLength = _serializationBuffer.Length - LENGTH_OFFSET;
_serializationBuffer.Seek(0, SeekOrigin.Begin);
_writer.Write((uint)requestLength, false);
return(_serializationBuffer.GetPart(0, _serializationBuffer.Length));
}
public void ShortBoundaryTest()
{
var capacity = 6;
using var buffer = new MessagePackBuffer(capacity);
var serializer = MessagePackSerializersRepository.Get <short>();
serializer.Serialize(short.MinValue, buffer);
serializer.Serialize(short.MaxValue, buffer);
Assert.Equal(buffer.Length, capacity);
var firstValue = buffer.GetPart(0, 3);
Assert.Equal(firstValue[0], 209);
Assert.Equal(firstValue[1], 128);
Assert.Equal(firstValue[2], 0);
var secondValue = buffer.GetPart(3, 3);
Assert.Equal(secondValue[0], 209);
Assert.Equal(secondValue[1], 127);
Assert.Equal(secondValue[2], 255);
}
public void FixNumsTest()
{
var capacity = 39;
using var buffer = new MessagePackBuffer(capacity);
var byteSerializer = MessagePackSerializersRepository.Get <byte>();
var sbyteSerializer = MessagePackSerializersRepository.Get <sbyte>();
var shortSerializer = MessagePackSerializersRepository.Get <short>();
var ushortSerializer = MessagePackSerializersRepository.Get <ushort>();
var intSerializer = MessagePackSerializersRepository.Get <int>();
var uintSerializer = MessagePackSerializersRepository.Get <uint>();
var longSerializer = MessagePackSerializersRepository.Get <long>();
var ulongSerializer = MessagePackSerializersRepository.Get <ulong>();
byteSerializer.Serialize(0, buffer);
sbyteSerializer.Serialize(0, buffer);
shortSerializer.Serialize(0, buffer);
ushortSerializer.Serialize(0, buffer);
intSerializer.Serialize(0, buffer);
uintSerializer.Serialize(0, buffer);
longSerializer.Serialize(0, buffer);
ulongSerializer.Serialize(0, buffer);
byteSerializer.Serialize(64, buffer);
sbyteSerializer.Serialize(64, buffer);
shortSerializer.Serialize(64, buffer);
ushortSerializer.Serialize(64, buffer);
intSerializer.Serialize(64, buffer);
uintSerializer.Serialize(64, buffer);
longSerializer.Serialize(64, buffer);
ulongSerializer.Serialize(64, buffer);
byteSerializer.Serialize(127, buffer);
sbyteSerializer.Serialize(127, buffer);
shortSerializer.Serialize(127, buffer);
ushortSerializer.Serialize(127, buffer);
intSerializer.Serialize(127, buffer);
uintSerializer.Serialize(127, buffer);
longSerializer.Serialize(127, buffer);
ulongSerializer.Serialize(127, buffer);
sbyteSerializer.Serialize(-1, buffer);
shortSerializer.Serialize(-1, buffer);
intSerializer.Serialize(-1, buffer);
longSerializer.Serialize(-1, buffer);
sbyteSerializer.Serialize(-16, buffer);
shortSerializer.Serialize(-16, buffer);
intSerializer.Serialize(-16, buffer);
longSerializer.Serialize(-16, buffer);
sbyteSerializer.Serialize(-32, buffer);
shortSerializer.Serialize(-32, buffer);
intSerializer.Serialize(-32, buffer);
longSerializer.Serialize(-32, buffer);
longSerializer.Serialize(1, buffer);
longSerializer.Serialize(-33, buffer);
Assert.Equal(buffer.Length, capacity);
var data0 = buffer.GetPart(0, 8);
foreach (var value in data0)
{
Assert.Equal(value, 0x00);
}
var data64 = buffer.GetPart(8, 8);
foreach (var value in data64)
{
Assert.Equal(value, 0x40);
}
var data127 = buffer.GetPart(16, 8);
foreach (var value in data127)
{
Assert.Equal(value, 0x7f);
}
var dataNegative1 = buffer.GetPart(24, 4);
foreach (var value in dataNegative1)
{
Assert.Equal(value, 0xff);
}
var dataNegative16 = buffer.GetPart(28, 4);
foreach (var value in dataNegative16)
{
Assert.Equal(value, 0xf0);
}
var dataNegative32 = buffer.GetPart(32, 4);
foreach (var value in dataNegative32)
{
Assert.Equal(value, 0xe0);
}
var outOfBoundsValues = buffer.GetPart(36, 3);
Assert.Equal(outOfBoundsValues[0], 1);
Assert.Equal(outOfBoundsValues[1], 208);
Assert.Equal(outOfBoundsValues[2], 223);
}
