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); }
public void StringTest() { var shortStr = new string(new char[31]); var str8 = new string(new char[byte.MaxValue - 10]); var str16 = new string(new char[ushort.MaxValue - 10]); var str32 = new string(new char[ushort.MaxValue + 10]); using var buffer = new MessagePackBuffer(); var serializer = MessagePackSerializersRepository.Get <string>(); serializer.Serialize(null, buffer); serializer.Serialize("", buffer); serializer.Serialize(shortStr, buffer); serializer.Serialize(str8, buffer); serializer.Serialize(str16, buffer); serializer.Serialize(str32, buffer); buffer.ResetPosition(); Assert.Equal(null, serializer.Deserialize(buffer)); Assert.Equal("", serializer.Deserialize(buffer)); var str = serializer.Deserialize(buffer); var count = str.Length; var count2 = shortStr.Length; Assert.Equal(shortStr, str); Assert.Equal(str8, serializer.Deserialize(buffer)); Assert.Equal(str16, serializer.Deserialize(buffer)); Assert.Equal(str32, serializer.Deserialize(buffer)); }
public void SignedNumbersTest() { using var buffer = new MessagePackBuffer(); var intSerializer = MessagePackSerializersRepository.Get <int>(); var sbyteSerializer = MessagePackSerializersRepository.Get <sbyte>(); var shortSerializer = MessagePackSerializersRepository.Get <short>(); var longSerializer = MessagePackSerializersRepository.Get <long>(); intSerializer.Serialize(-1, buffer); intSerializer.Serialize(1, buffer); sbyteSerializer.Serialize(sbyte.MinValue, buffer); sbyteSerializer.Serialize(sbyte.MaxValue, buffer); shortSerializer.Serialize(short.MinValue, buffer); shortSerializer.Serialize(short.MaxValue, buffer); intSerializer.Serialize(int.MinValue, buffer); intSerializer.Serialize(int.MaxValue, buffer); longSerializer.Serialize(long.MinValue, buffer); longSerializer.Serialize(long.MaxValue, buffer); buffer.ResetPosition(); Assert.Equal(-1, intSerializer.Deserialize(buffer)); Assert.Equal(1, intSerializer.Deserialize(buffer)); Assert.Equal(sbyte.MinValue, sbyteSerializer.Deserialize(buffer)); Assert.Equal(sbyte.MaxValue, sbyteSerializer.Deserialize(buffer)); Assert.Equal(short.MinValue, shortSerializer.Deserialize(buffer)); Assert.Equal(short.MaxValue, shortSerializer.Deserialize(buffer)); Assert.Equal(int.MinValue, intSerializer.Deserialize(buffer)); Assert.Equal(int.MaxValue, intSerializer.Deserialize(buffer)); Assert.Equal(long.MinValue, longSerializer.Deserialize(buffer)); Assert.Equal(long.MaxValue, longSerializer.Deserialize(buffer)); }
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 BoolTest() { using var buffer = new MessagePackBuffer(2); var serializer = MessagePackSerializersRepository.Get <bool>(); serializer.Serialize(false, buffer); serializer.Serialize(true, buffer); var data = buffer.GetAll(); Assert.Equal(2, data.Length); Assert.Equal(0xc2, data[0]); Assert.Equal(0xc3, data[1]); }
public void NullStringTest() { var capacity = 1; using var buffer = new MessagePackBuffer(capacity); var serializer = MessagePackSerializersRepository.Get <string>(); serializer.Serialize(null, buffer); Assert.Equal(buffer.Length, capacity); var data = buffer.GetAll(); Assert.Equal(data[0], 192); }
public void DateTimeTest() { var dateTimeZero = new DateTime(1970, 1, 1); var dateTime = new DateTime(2020, 1, 1, 1, 1, 1, 1); using var buffer = new MessagePackBuffer(); var serializer = MessagePackSerializersRepository.Get <DateTime>(); serializer.Serialize(dateTimeZero, buffer); serializer.Serialize(dateTime, buffer); buffer.ResetPosition(); Assert.Equal(dateTimeZero, serializer.Deserialize(buffer)); Assert.Equal(dateTime, serializer.Deserialize(buffer)); }
public void ByteBoundaryTest() { var capacity = 2; using var buffer = new MessagePackBuffer(capacity); var serializer = MessagePackSerializersRepository.Get <byte>(); serializer.Serialize(byte.MaxValue, buffer); Assert.Equal(buffer.Length, capacity); var data = buffer.GetAll(); Assert.Equal(data[0], 204); Assert.Equal(data[1], 255); }
public void UshortBoundaryTest() { var capacity = 3; using var buffer = new MessagePackBuffer(capacity); var serializer = MessagePackSerializersRepository.Get <ushort>(); serializer.Serialize(ushort.MaxValue, buffer); Assert.Equal(buffer.Length, capacity); var data = buffer.GetAll(); Assert.Equal(data[0], 205); Assert.Equal(data[1], 255); Assert.Equal(data[2], 255); }
public void TestCustomSerialization() { using var buffer = new MessagePackBuffer(); var writer = new MessagePackWriter(buffer); var value = new TestSerializable(0x1); var serializer = MessagePackSerializersRepository.Get <TestSerializable>(); serializer.Serialize(value, writer); buffer.ResetPosition(); var reader = new MessagePackReader(buffer); var deserializedValue = serializer.Deserialize(reader); Assert.Equal(value.Value, deserializedValue.Value); }
public void FloatingPointNumbersTest() { using var buffer = new MessagePackBuffer(); var floatSerializer = MessagePackSerializersRepository.Get <float>(); var doubleSerializer = MessagePackSerializersRepository.Get <double>(); floatSerializer.Serialize(float.MaxValue, buffer); floatSerializer.Serialize(float.MinValue, buffer); doubleSerializer.Serialize(double.MaxValue, buffer); doubleSerializer.Serialize(double.MinValue, buffer); buffer.ResetPosition(); Assert.Equal(float.MaxValue, floatSerializer.Deserialize(buffer)); Assert.Equal(float.MinValue, floatSerializer.Deserialize(buffer)); Assert.Equal(double.MaxValue, doubleSerializer.Deserialize(buffer)); Assert.Equal(double.MinValue, doubleSerializer.Deserialize(buffer)); }
public void BinaryTest() { var binaryData8 = new byte[byte.MaxValue - 1]; var binaryData16 = new byte[ushort.MaxValue - 1]; var binaryData32 = new byte[ushort.MaxValue + 1]; using var buffer = new MessagePackBuffer(); var serializer = MessagePackSerializersRepository.Get <byte[]>(); serializer.Serialize(binaryData8, buffer); serializer.Serialize(binaryData16, buffer); serializer.Serialize(binaryData32, buffer); buffer.ResetPosition(); Assert.Equal(binaryData8, serializer.Deserialize(buffer)); Assert.Equal(binaryData16, serializer.Deserialize(buffer)); Assert.Equal(binaryData32, serializer.Deserialize(buffer)); }
public void SbyteBoundaryTest() { var capacity = 3; using var buffer = new MessagePackBuffer(capacity); var sbyteSerializer = MessagePackSerializersRepository.Get <sbyte>(); sbyteSerializer.Serialize(sbyte.MinValue, buffer); sbyteSerializer.Serialize(sbyte.MaxValue, buffer); Assert.Equal(buffer.Length, capacity); var data = buffer.GetAll(); Assert.Equal(data[0], 208); Assert.Equal(data[1], 128); Assert.Equal(data[2], 127); }
private void TestCompatibility <T>(T[] values) { using var buffer = new MessagePackBuffer(); using var packer = Packer.Create(buffer); var cliSerializer = MessagePackSerializer.Get <T>(); var sekougiSerializer = MessagePackSerializersRepository.Get <T>(); foreach (var value in values) { cliSerializer.PackTo(packer, value); } buffer.ResetPosition(); foreach (var value in values) { var deserializedValue = sekougiSerializer.Deserialize(buffer); Assert.Equal(value, deserializedValue); } }
public void UnsignedNumbersTest() { using var buffer = new MessagePackBuffer(); var uintSerializer = MessagePackSerializersRepository.Get <uint>(); var byteSerializer = MessagePackSerializersRepository.Get <byte>(); var ushortSerializer = MessagePackSerializersRepository.Get <ushort>(); var ulongSerializer = MessagePackSerializersRepository.Get <ulong>(); byteSerializer.Serialize(byte.MaxValue, buffer); ushortSerializer.Serialize(ushort.MaxValue, buffer); uintSerializer.Serialize(uint.MaxValue, buffer); ulongSerializer.Serialize(ulong.MaxValue, buffer); buffer.ResetPosition(); Assert.Equal(byte.MaxValue, byteSerializer.Deserialize(buffer)); Assert.Equal(ushort.MaxValue, ushortSerializer.Deserialize(buffer)); Assert.Equal(uint.MaxValue, uintSerializer.Deserialize(buffer)); Assert.Equal(ulong.MaxValue, ulongSerializer.Deserialize(buffer)); }
public void ArrayTest() { var arrayEmpty = new string[0]; var array1 = new string[1]; var array16 = new string[ushort.MaxValue - 1]; var array32 = new string[ushort.MaxValue + 1]; using var buffer = new MessagePackBuffer(); var serializer = MessagePackSerializersRepository.Get <string[]>(); serializer.Serialize(arrayEmpty, buffer); serializer.Serialize(array1, buffer); serializer.Serialize(array16, buffer); serializer.Serialize(array32, buffer); buffer.ResetPosition(); Assert.Equal(arrayEmpty, serializer.Deserialize(buffer)); Assert.Equal(array1, serializer.Deserialize(buffer)); Assert.Equal(array16, serializer.Deserialize(buffer)); Assert.Equal(array32, serializer.Deserialize(buffer)); }
public void TimeStamp32Test() { var capacity = 6; using var buffer = new MessagePackBuffer(6); var serializer = MessagePackSerializersRepository.Get <DateTime>(); var date = new DateTime(1970, 1, 1); serializer.Serialize(date, buffer); Assert.Equal(buffer.Length, capacity); var data = buffer.GetAll(); Assert.Equal(data[0], 214); Assert.Equal(data[1], 255); Assert.Equal(data[2], 0); Assert.Equal(data[3], 0); Assert.Equal(data[4], 0); Assert.Equal(data[5], 0); }
public void ValueTuple1Test() { using var buffer = new MessagePackBuffer(); var serializer1 = MessagePackSerializersRepository.Get <ValueTuple <int> >(); var serializer2 = MessagePackSerializersRepository.Get <ValueTuple <int, byte> >(); var serializer3 = MessagePackSerializersRepository.Get <ValueTuple <int, byte, sbyte> >(); var serializer4 = MessagePackSerializersRepository.Get <ValueTuple <int, byte, sbyte, double> >(); var serializer5 = MessagePackSerializersRepository.Get <ValueTuple <int, byte, sbyte, uint, short> >(); var serializer6 = MessagePackSerializersRepository.Get <ValueTuple <int, byte, sbyte, uint, short, float> >(); var serializer7 = MessagePackSerializersRepository.Get <ValueTuple <int, byte, sbyte, uint, short, float, double> >(); var serializer8 = MessagePackSerializersRepository.Get <ValueTuple <string, int, int, int, int, int, int, ValueTuple <int> > >(); var tuple1 = new ValueTuple <int>(1); var tuple2 = (1, (byte)1); var tuple3 = (1, (byte)1, (sbyte)1); var tuple4 = (1, (byte)1, (sbyte)1, 1d); var tuple5 = (1, (byte)1, (sbyte)1, (uint)1, (short)1); var tuple6 = (1, (byte)1, (sbyte)1, (uint)1, (short)1, 1f); var tuple7 = (1, (byte)1, (sbyte)1, (uint)1, (short)1, 1f, 1d); var tuple8 = new ValueTuple <string, int, int, int, int, int, int, ValueTuple <int> >("test", 1, 1, 1, 1, 1, 1, tuple1); serializer1.Serialize(tuple1, buffer); serializer2.Serialize(tuple2, buffer); serializer3.Serialize(tuple3, buffer); serializer4.Serialize(tuple4, buffer); serializer5.Serialize(tuple5, buffer); serializer6.Serialize(tuple6, buffer); serializer7.Serialize(tuple7, buffer); serializer8.Serialize(tuple8, buffer); buffer.ResetPosition(); Assert.Equal(tuple1, serializer1.Deserialize(buffer)); Assert.Equal(tuple2, serializer2.Deserialize(buffer)); Assert.Equal(tuple3, serializer3.Deserialize(buffer)); Assert.Equal(tuple4, serializer4.Deserialize(buffer)); Assert.Equal(tuple5, serializer5.Deserialize(buffer)); Assert.Equal(tuple6, serializer6.Deserialize(buffer)); Assert.Equal(tuple7, serializer7.Deserialize(buffer)); Assert.Equal(tuple8, serializer8.Deserialize(buffer)); }
public void UlongBoundaryTest() { var capacity = 9; using var buffer = new MessagePackBuffer(capacity); var serializer = MessagePackSerializersRepository.Get <ulong>(); serializer.Serialize(ulong.MaxValue, buffer); Assert.Equal(buffer.Length, capacity); var data = buffer.GetAll(); Assert.Equal(data[0], 207); Assert.Equal(data[1], 255); Assert.Equal(data[2], 255); Assert.Equal(data[3], 255); Assert.Equal(data[4], 255); Assert.Equal(data[5], 255); Assert.Equal(data[6], 255); Assert.Equal(data[7], 255); Assert.Equal(data[8], 255); }
public void IterationSetup() { const int BUFFER_CAPACITY = 1024000; SetupSekougi(); SetupCli(); void SetupSekougi() { _sekougiBuffer = new MessagePackBuffer(BUFFER_CAPACITY); _writerSekougi = new MessagePackWriter(_sekougiBuffer); _readerIntArraySekougi = new MessagePackReader(_sekougiDeserializationBufferIntArray); _readerIntSekougi = new MessagePackReader(_sekougiDeserializationBufferInt); _readerFloatSekougi = new MessagePackReader(_sekougiDeserializationBufferFloat); _readerStringSekougi = new MessagePackReader(_sekougiDeserializationBufferString); _readerTupleSekougi = new MessagePackReader(_sekougiDeserializationBufferTuple); _sekougiDeserializationBufferIntArray.Position = 0; _sekougiDeserializationBufferString.Position = 0; _sekougiDeserializationBufferFloat.Position = 0; _sekougiDeserializationBufferInt.Position = 0; _sekougiDeserializationBufferTuple.Position = 0; } void SetupCli() { _cliStream = new MemoryStream(BUFFER_CAPACITY); _packerCli = Packer.Create(_cliStream); _streamCliInt.Position = 0; _streamCliFloat.Position = 0; _streamCliString.Position = 0; _streamCliArrayInt.Position = 0; _streamCliTuple.Position = 0; } }
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); }
public RequestWriter(Stream destination) { _serializationBuffer = new MessagePackBuffer(); _writer = new MessagePackWriter(_serializationBuffer); _destination = destination; }
public void Setup() { var size = 100000; _shortString = new string(new char[10]); _averageString = new string(new char[10000]); _largeString = new string(new char[int.MaxValue / 10]); _tuple = (int.MaxValue, double.MaxValue, int.MaxValue); _intArray = new int[size]; _tuples = new List <TupleData>(size); for (var i = 0; i < size; i++) { var tuple = new TupleData(Int32.MaxValue - i, double.MaxValue - i, long.MaxValue - 1); _tuples.Add(tuple); } _serializerIntCli = MessagePackSerializer.Get <int>(); _serializerDoubleCli = MessagePackSerializer.Get <double>(); _serializerFloatCli = MessagePackSerializer.Get <float>(); _serializerStringCli = MessagePackSerializer.Get <string>(); _serializerArrayIntCli = MessagePackSerializer.Get <int[]>(); _serializerTupleArrayCli = MessagePackSerializer.Get <List <TupleData> >(); _serializerTupleCli = MessagePackSerializer.Get <TupleData>(); _serializerIntSekougi = MessagePackSerializersRepository.Get <int>(); _serializerDoubleSekougi = MessagePackSerializersRepository.Get <double>(); _serializerFloatSekougi = MessagePackSerializersRepository.Get <float>(); _serializerStringSekougi = MessagePackSerializersRepository.Get <string>(); _serializerArrayIntSekougi = MessagePackSerializersRepository.Get <int[]>(); _serializerTupleArraySekougi = MessagePackSerializersRepository.Get <List <TupleData> >(); _serializerTupleSekougi = MessagePackSerializersRepository.Get <TupleData>(); var stringToSerialize = new string(new char[size]); var intArrayToSerialize = new int[size]; _streamCliTuple = new MemoryStream(); _serializerTupleCli.Pack(_streamCliTuple, _tuple); _streamCliInt = new MemoryStream(); _serializerIntCli.Pack(_streamCliInt, int.MaxValue); _streamCliFloat = new MemoryStream(); _serializerFloatCli.Pack(_streamCliFloat, float.MaxValue); _streamCliString = new MemoryStream(); _serializerStringCli.Pack(_streamCliString, new string(stringToSerialize)); _streamCliArrayInt = new MemoryStream(); _serializerArrayIntCli.Pack(_streamCliArrayInt, intArrayToSerialize); _sekougiDeserializationBufferIntArray = new MessagePackBuffer(); var writer = new MessagePackWriter(_sekougiDeserializationBufferIntArray); _serializerArrayIntSekougi.Serialize(intArrayToSerialize, writer); _sekougiDeserializationBufferTuple = new MessagePackBuffer(); writer = new MessagePackWriter(_sekougiDeserializationBufferTuple); _serializerTupleSekougi.Serialize(_tuple, writer); _sekougiDeserializationBufferInt = new MessagePackBuffer(); writer = new MessagePackWriter(_sekougiDeserializationBufferInt); _serializerIntSekougi.Serialize(int.MaxValue, writer); _sekougiDeserializationBufferFloat = new MessagePackBuffer(); writer = new MessagePackWriter(_sekougiDeserializationBufferFloat); _serializerFloatSekougi.Serialize(float.MaxValue, writer); _sekougiDeserializationBufferString = new MessagePackBuffer(); writer = new MessagePackWriter(_sekougiDeserializationBufferString); _serializerStringSekougi.Serialize(new string(stringToSerialize), writer); }