public void TestString()
{
var stream = new MsgPackStream();
var nullStr = new BufferSegment();
var emptyStr = new BufferSegment(new byte[0]);
var fixStr = CreateUtf8String(FormatRange.MaxFixStringLength);
var smallStr = CreateUtf8String(byte.MaxValue);
var mediumStr = CreateUtf8String(ushort.MaxValue);
var largeStr = CreateUtf8String(ushort.MaxValue + 1);
StreamWriter.WriteUtf8(nullStr, stream);
StreamWriter.WriteUtf8(emptyStr, stream);
StreamWriter.WriteUtf8(fixStr, stream);
StreamWriter.WriteUtf8(smallStr, stream);
StreamWriter.WriteUtf8(mediumStr, stream);
StreamWriter.WriteUtf8(largeStr, stream);
stream.Position = 0;
Assert.AreEqual(nullStr, StreamReader.ReadUtf8(stream));
Assert.AreEqual(emptyStr, StreamReader.ReadUtf8(stream));
Assert.AreEqual(fixStr, StreamReader.ReadUtf8(stream));
Assert.AreEqual(smallStr, StreamReader.ReadUtf8(stream));
Assert.AreEqual(mediumStr, StreamReader.ReadUtf8(stream));
Assert.AreEqual(largeStr, StreamReader.ReadUtf8(stream));
}
public void TestFloat()
{
var stream = new MsgPackStream();
stream.WriteDouble(178.5);
Assert.AreEqual(stream.Position, 8);
stream.WriteSingle(-10.3f);
Assert.AreEqual(stream.Position, 12);
stream.WriteSingle(float.NaN);
stream.WriteSingle(float.NegativeInfinity);
stream.WriteSingle(float.PositiveInfinity);
stream.WriteDouble(double.NaN);
stream.WriteDouble(double.NegativeInfinity);
stream.WriteDouble(double.PositiveInfinity);
stream.Position = 0;
Assert.AreEqual(178.5, stream.ReadDouble());
Assert.AreEqual(-10.3f, stream.ReadSingle());
Assert.IsTrue(float.IsNaN(stream.ReadSingle()));
Assert.IsTrue(float.IsNegativeInfinity(stream.ReadSingle()));
Assert.IsTrue(float.IsPositiveInfinity(stream.ReadSingle()));
Assert.IsTrue(double.IsNaN(stream.ReadDouble()));
Assert.IsTrue(double.IsNegativeInfinity(stream.ReadDouble()));
Assert.IsTrue(double.IsPositiveInfinity(stream.ReadDouble()));
}
DateTime IFormatter <DateTime> .Read(MsgPackStream stream, IContext context)
{
// Reference:
// ExtensionValue value = deserialize_ext_type();
// struct timespec result;
// switch(value.length) {
// case 4:
// uint32_t data32 = value.payload;
// result.tv_nsec = 0;
// result.tv_sec = data32;
// case 8:
// uint64_t data64 = value.payload;
// result.tv_nsec = data64 >> 34;
// result.tv_sec = data64 & 0x00000003ffffffffL;
// case 12:
// uint32_t data32 = value.payload;
// uint64_t data64 = value.payload + 4;
// result.tv_nsec = data32;
// result.tv_sec = data64;
// default:
// // error
// }
var code = stream.Peek();
var header = StreamReader.ReadExtensionHeader(stream);
if (header.TypeCode != TypeCode)
{
throw new MsgPackExtensionException(header.TypeCode, TypeCode);
}
return(Unpack(stream, header.Length));
}
internal static DateTime Unpack(MsgPackStream stream, uint length)
{
long seconds, nanoseconds;
switch (length)
{
case 4:
nanoseconds = 0;
seconds = stream.ReadUInt32();
break;
case 8:
var data64 = stream.ReadUInt64();
nanoseconds = (long)(data64 >> 34);
seconds = (long)(data64 & 0x00000003fffffffful);
break;
case 12:
nanoseconds = stream.ReadUInt32();
seconds = stream.ReadInt64();
break;
default: throw new MsgPackException("Invalid timestemp size {0}", length);
}
return(UnixEpoch.AddSeconds(seconds).AddTicks(nanoseconds / NanosecondsPerTick));
}
public static float ReadSingle(MsgPackStream stream)
{
var code = stream.ReadUInt8();
switch (FormatMask.Match(code))
{
case FormatMask.PositiveFixInt: return(code);
case FormatMask.NegativeFixInt: return(unchecked ((sbyte)code));
}
switch (code)
{
case FormatCode.Float32: return(stream.ReadSingle());
case FormatCode.Int8: return(stream.ReadInt8());
case FormatCode.UInt8: return(stream.ReadUInt8());
case FormatCode.Int16: return(stream.ReadInt16());
case FormatCode.UInt16: return(stream.ReadUInt16());
case FormatCode.Int32: return(stream.ReadInt32());
case FormatCode.UInt32: return(stream.ReadUInt32());
case FormatCode.Int64: return(stream.ReadInt64());
case FormatCode.UInt64: return(stream.ReadUInt64());
default: throw new MsgPackCodeException(code);
}
}
void IFormatter <object> .Write(object value, MsgPackStream stream, IContext context)
{
if (value == null)
{
StreamWriter.WriteNil(stream);
return;
}
var valueType = value.GetType();
var formatter = context.ResolveFormatter(valueType);
var formatterType = formatter.GetType();
var writeMethod = formatterType.GetMethod(
string.Format("Pixonic.MsgPack.IFormatter<{0}>.Write", valueType.FullName),
BindingFlags.Instance | BindingFlags.NonPublic | BindingFlags.Public);
if (writeMethod == null)
{
var signature = new System.Type[] { valueType, typeof(MsgPackStream), typeof(IContext) };
writeMethod = formatterType.GetMethod("Write", signature);
}
if (writeMethod == null)
{
throw new MsgPackException("Unable to resolve serialization method of '{0}'", formatterType.FullName);
}
var parameters = new object[] { value, stream, context };
writeMethod.Invoke(formatter, parameters);
}
private static void SkipElements(MsgPackStream stream, uint count)
{
for (uint i = 0; i < count; ++i)
{
Skip(stream);
}
}
public static ExtensionHeader ReadExtensionHeader(MsgPackStream stream)
{
var code = stream.ReadUInt8();
uint length;
switch (code)
{
case FormatCode.FixExt1: length = 1u; break;
case FormatCode.FixExt2: length = 2u; break;
case FormatCode.FixExt4: length = 4u; break;
case FormatCode.FixExt8: length = 8u; break;
case FormatCode.FixExt16: length = 16u; break;
case FormatCode.Ext8: length = stream.ReadUInt8(); break;
case FormatCode.Ext16: length = stream.ReadUInt16(); break;
case FormatCode.Ext32: length = stream.ReadUInt32(); break;
default: throw new MsgPackCodeException(code);
}
return(new ExtensionHeader(stream.ReadInt8(), length));
}
public void TestIntRanges()
{
var stream = new MsgPackStream();
StreamWriter.WriteUInt64(ulong.MaxValue, stream);
StreamWriter.WriteUInt64(uint.MaxValue, stream);
StreamWriter.WriteUInt64(ushort.MaxValue, stream);
StreamWriter.WriteUInt64(byte.MaxValue, stream);
StreamWriter.WriteUInt64(FormatRange.MaxFixPositiveInt, stream);
StreamWriter.WriteInt64(long.MinValue, stream);
StreamWriter.WriteInt64(int.MinValue, stream);
StreamWriter.WriteInt64(short.MinValue, stream);
StreamWriter.WriteInt64(sbyte.MinValue, stream);
StreamWriter.WriteInt64(FormatRange.MinFixNegativeInt, stream);
stream.Position = 0;
Assert.AreEqual(ulong.MaxValue, StreamReader.ReadUInt64(stream));
Assert.AreEqual(uint.MaxValue, StreamReader.ReadUInt64(stream));
Assert.AreEqual(ushort.MaxValue, StreamReader.ReadUInt64(stream));
Assert.AreEqual(byte.MaxValue, StreamReader.ReadUInt64(stream));
Assert.AreEqual(FormatRange.MaxFixPositiveInt, StreamReader.ReadUInt64(stream));
Assert.AreEqual(long.MinValue, StreamReader.ReadInt64(stream));
Assert.AreEqual(int.MinValue, StreamReader.ReadInt64(stream));
Assert.AreEqual(short.MinValue, StreamReader.ReadInt64(stream));
Assert.AreEqual(sbyte.MinValue, StreamReader.ReadInt64(stream));
Assert.AreEqual(FormatRange.MinFixNegativeInt, StreamReader.ReadInt64(stream));
}
public void TestPrimitive()
{
var stream = new MsgPackStream();
StreamWriter.WriteNil(stream);
StreamWriter.WriteBool(true, stream);
StreamWriter.WriteBool(false, stream);
StreamWriter.WriteInt8(sbyte.MinValue, stream);
StreamWriter.WriteUInt8(byte.MaxValue, stream);
StreamWriter.WriteUInt8(17, stream);
StreamWriter.WriteInt16(short.MaxValue, stream);
StreamWriter.WriteUInt16(ushort.MaxValue, stream);
StreamWriter.WriteInt32(short.MinValue, stream);
StreamWriter.WriteUInt32(0, stream);
StreamWriter.WriteInt64(long.MinValue, stream);
StreamWriter.WriteUInt64(ulong.MaxValue, stream);
stream.Position = 0;
Assert.IsTrue(StreamReader.TryReadNil(stream));
Assert.IsFalse(StreamReader.TryReadNil(stream));
Assert.IsTrue(StreamReader.ReadBool(stream));
Assert.IsFalse(StreamReader.ReadBool(stream));
Assert.AreEqual(sbyte.MinValue, StreamReader.ReadInt8(stream));
Assert.AreEqual(byte.MaxValue, StreamReader.ReadUInt8(stream));
Assert.AreEqual(17, StreamReader.ReadUInt8(stream));
Assert.AreEqual(short.MaxValue, StreamReader.ReadInt16(stream));
Assert.AreEqual(ushort.MaxValue, StreamReader.ReadUInt16(stream));
Assert.AreEqual(short.MinValue, StreamReader.ReadInt32(stream));
Assert.AreEqual(0, StreamReader.ReadUInt32(stream));
Assert.AreEqual(long.MinValue, StreamReader.ReadInt64(stream));
Assert.AreEqual(ulong.MaxValue, StreamReader.ReadUInt64(stream));
}
T? IFormatter <T?> .Read(MsgPackStream stream, IContext context)
{
if (StreamReader.TryReadNil(stream))
{
return(null);
}
return((_underlyingFormatter ?? context.ResolveFormatter <T>()).Read(stream, context));
}
public static bool TryReadNil(MsgPackStream stream)
{
if (stream.Peek() == FormatCode.Nil)
{
stream.Skip(1);
return(true);
}
return(false);
}
public void TestFloat()
{
var stream = new MsgPackStream();
StreamWriter.WriteSingle(-198832.1f, stream);
StreamWriter.WriteDouble(198832.1, stream);
stream.Position = 0;
Assert.AreEqual(-198832.1f, StreamReader.ReadSingle(stream));
Assert.AreEqual(198832.1, StreamReader.ReadDouble(stream));
}
void IFormatter <T?> .Write(T?value, MsgPackStream stream, IContext context)
{
if (value.HasValue)
{
(_underlyingFormatter ?? context.ResolveFormatter <T>()).Write(value.Value, stream, context);
}
else
{
StreamWriter.WriteNil(stream);
}
}
void IFormatter <DateTime> .Write(DateTime value, MsgPackStream stream, IContext context)
{
var secondsSinceBclEpoch = value.Ticks / TimeSpan.TicksPerSecond;
var seconds = secondsSinceBclEpoch - BclSecondsAtUnixEpoch;
var nanoseconds = (value.Ticks % TimeSpan.TicksPerSecond) * NanosecondsPerTick;
// Reference:
// struct timespec {
// long tv_sec; // seconds
// long tv_nsec; // nanoseconds
// } time;
// if ((time.tv_sec >> 34) == 0) {
// uint64_t data64 = (time.tv_nsec << 34) | time.tv_sec;
// if (data64 & 0xffffffff00000000L == 0) {
// // timestamp 32
// uint32_t data32 = data64;
// serialize(0xd6, -1, data32)
// }
// else {
// // timestamp 64
// serialize(0xd7, -1, data64)
// }
// }
// else {
// // timestamp 96
// serialize(0xc7, 12, -1, time.tv_nsec, time.tv_sec)
// }
unchecked
{
if (seconds >> 34 == 0)
{
var data64 = (ulong)((nanoseconds << 34) | seconds);
if ((data64 & 0xffffffff00000000ul) == 0ul)
{
var data32 = (uint)data64;
StreamWriter.WriteExtensionHeader(new ExtensionHeader(TypeCode, 4u), stream);
stream.WriteUInt32(data32);
}
else
{
StreamWriter.WriteExtensionHeader(new ExtensionHeader(TypeCode, 8u), stream);
stream.WriteUInt64(data64);
}
}
else
{
StreamWriter.WriteExtensionHeader(new ExtensionHeader(TypeCode, 12u), stream);
stream.WriteUInt32((uint)nanoseconds);
stream.WriteInt64(seconds);
}
}
}
public void TestString()
{
var stream = new MsgPackStream();
var testString = "Test string";
var length = Encoding.UTF8.GetByteCount(testString);
stream.WriteString(testString);
Assert.AreEqual(stream.Position, length);
stream.Position = 0;
Assert.AreEqual(testString, stream.ReadString(unchecked ((uint)length)));
}
public void TestExtensionHeader()
{
var stream = new MsgPackStream();
StreamWriter.WriteExtensionHeader(new ExtensionHeader(-6, 0), stream);
StreamWriter.WriteExtensionHeader(new ExtensionHeader(-5, 1), stream);
StreamWriter.WriteExtensionHeader(new ExtensionHeader(-4, 2), stream);
StreamWriter.WriteExtensionHeader(new ExtensionHeader(-3, 4), stream);
StreamWriter.WriteExtensionHeader(new ExtensionHeader(-2, 8), stream);
StreamWriter.WriteExtensionHeader(new ExtensionHeader(-1, 16), stream);
StreamWriter.WriteExtensionHeader(new ExtensionHeader(0, byte.MaxValue), stream);
StreamWriter.WriteExtensionHeader(new ExtensionHeader(1, ushort.MaxValue), stream);
StreamWriter.WriteExtensionHeader(new ExtensionHeader(2, uint.MaxValue), stream);
stream.Position = 0;
var ext0 = StreamReader.ReadExtensionHeader(stream);
Assert.AreEqual(-6, ext0.TypeCode);
Assert.AreEqual(0, ext0.Length);
var ext1 = StreamReader.ReadExtensionHeader(stream);
Assert.AreEqual(-5, ext1.TypeCode);
Assert.AreEqual(1, ext1.Length);
var ext2 = StreamReader.ReadExtensionHeader(stream);
Assert.AreEqual(-4, ext2.TypeCode);
Assert.AreEqual(2, ext2.Length);
var ext3 = StreamReader.ReadExtensionHeader(stream);
Assert.AreEqual(-3, ext3.TypeCode);
Assert.AreEqual(4, ext3.Length);
var ext4 = StreamReader.ReadExtensionHeader(stream);
Assert.AreEqual(-2, ext4.TypeCode);
Assert.AreEqual(8, ext4.Length);
var ext5 = StreamReader.ReadExtensionHeader(stream);
Assert.AreEqual(-1, ext5.TypeCode);
Assert.AreEqual(16, ext5.Length);
var ext6 = StreamReader.ReadExtensionHeader(stream);
Assert.AreEqual(0, ext6.TypeCode);
Assert.AreEqual(byte.MaxValue, ext6.Length);
var ext7 = StreamReader.ReadExtensionHeader(stream);
Assert.AreEqual(1, ext7.TypeCode);
Assert.AreEqual(ushort.MaxValue, ext7.Length);
var ext8 = StreamReader.ReadExtensionHeader(stream);
Assert.AreEqual(2, ext8.TypeCode);
Assert.AreEqual(uint.MaxValue, ext8.Length);
}
void IFormatter <TEnum> .Write(TEnum value, MsgPackStream stream, IContext context)
{
var index = System.Array.IndexOf(_values, value);
if (index >= 0)
{
StreamWriter.WriteUtf8(_keyIndexMap[index], stream);
}
else
{
StreamWriter.WriteString(value.ToString(), stream);
}
}
public static bool ReadBool(MsgPackStream stream)
{
var code = stream.ReadUInt8();
switch (code)
{
case FormatCode.False: return(false);
case FormatCode.True: return(true);
default: throw new MsgPackCodeException(code);
}
}
public void TestArrayHeader()
{
var stream = new MsgPackStream();
StreamWriter.WriteArrayHeader(5, stream);
StreamWriter.WriteArrayHeader(150, stream);
StreamWriter.WriteArrayHeader(uint.MaxValue, stream);
stream.Position = 0;
Assert.AreEqual(5, StreamReader.ReadArrayHeader(stream));
Assert.AreEqual(150, StreamReader.ReadArrayHeader(stream));
Assert.AreEqual(uint.MaxValue, StreamReader.ReadArrayHeader(stream));
}
public void TestMapHeader()
{
var stream = new MsgPackStream();
StreamWriter.WriteMapHeader(15, stream);
StreamWriter.WriteMapHeader(16, stream);
StreamWriter.WriteMapHeader(uint.MaxValue, stream);
stream.Position = 0;
Assert.AreEqual(15, StreamReader.ReadMapHeader(stream));
Assert.AreEqual(16, StreamReader.ReadMapHeader(stream));
Assert.AreEqual(uint.MaxValue, StreamReader.ReadMapHeader(stream));
}
public void TestUtf8String()
{
var stream = new MsgPackStream();
var utf8String = new BufferSegment(Encoding.UTF8.GetBytes("utf8 test string"));
StreamWriter.WriteUtf8(utf8String, stream);
StreamWriter.WriteString("test string", stream);
stream.Position = 0;
Assert.AreEqual("utf8 test string", StreamReader.ReadString(stream));
Assert.AreEqual("test string", StreamReader.ReadString(stream));
stream.Position = 0;
Assert.AreEqual(utf8String, StreamReader.ReadUtf8(stream));
Assert.AreEqual(new BufferSegment(Encoding.UTF8.GetBytes("test string")), StreamReader.ReadUtf8(stream));
}
public static byte ReadUInt8(MsgPackStream stream)
{
var code = stream.ReadUInt8();
if (FormatMask.Match(code) == FormatMask.PositiveFixInt)
{
return(code);
}
switch (code)
{
case FormatCode.UInt8: return(stream.ReadUInt8());
default: throw new MsgPackCodeException(code);
}
}
public void TestBytes()
{
var stream = new MsgPackStream();
var bytes = new BufferSegment(new byte[] { 1, 12, 23, 34, 45, 56 });
stream.WriteBytes(bytes);
Assert.AreEqual(stream.Position, bytes.Length);
stream.Position = 0;
Assert.True(
BufferSegment.EqualityComparer.Equals(
bytes,
stream.ReadBytes(unchecked ((uint)bytes.Length))
)
);
}
public static BufferSegment ReadBytes(MsgPackStream stream)
{
var code = stream.ReadUInt8();
switch (code)
{
case FormatCode.Bin8: return(stream.ReadBytes(stream.ReadUInt8()));
case FormatCode.Bin16: return(stream.ReadBytes(stream.ReadUInt16()));
case FormatCode.Bin32: return(stream.ReadBytes(stream.ReadUInt32()));
case FormatCode.Nil: return(new BufferSegment());
default: throw new MsgPackCodeException(code);
}
}
void IFormatter <List <T> > .Write(List <T> value, MsgPackStream stream, IContext context)
{
if (value == null)
{
StreamWriter.WriteNil(stream);
return;
}
var formatter = _itemFormatter ?? context.ResolveFormatter <T>();
var count = unchecked ((uint)value.Count);
StreamWriter.WriteArrayHeader(count, stream);
for (var i = 0; i < count; ++i)
{
formatter.Write(value[i], stream, context);
}
}
void IFormatter <TArray> .Write(TArray value, MsgPackStream stream, IContext context)
{
if (!typeof(TArray).IsValueType && object.Equals(value, default(TArray)))
{
StreamWriter.WriteNil(stream);
return;
}
var formatter = context.ResolveFormatter <TItem>();
var length = GetLength(value);
StreamWriter.WriteArrayHeader(unchecked ((uint)length), stream);
for (var i = 0; i < length; ++i)
{
formatter.Write(GetItem(value, i), stream, context);
}
}
void IFormatter <T[]> .Write(T[] value, MsgPackStream stream, IContext context)
{
if (value == null)
{
StreamWriter.WriteNil(stream);
return;
}
var formatter = _itemFormatter ?? context.ResolveFormatter <T>();
var count = value.LongLength;
StreamWriter.WriteArrayHeader(unchecked ((uint)count), stream);
for (var i = 0; i < count; ++i)
{
formatter.Write(value[i], stream, context);
}
}
T[] IFormatter <T[]> .Read(MsgPackStream stream, IContext context)
{
if (StreamReader.TryReadNil(stream))
{
return(null);
}
var formatter = _itemFormatter ?? context.ResolveFormatter <T>();
var count = StreamReader.ReadArrayHeader(stream);
var array = new T[count];
for (var i = 0; i < count; ++i)
{
array[i] = formatter.Read(stream, context);
}
return(array);
}
public static uint ReadMapHeader(MsgPackStream stream)
{
var code = stream.ReadUInt8();
if (FormatMask.Match(code) == FormatMask.FixMap)
{
return(code & 0xfu);
}
switch (code)
{
case FormatCode.Map16: return(stream.ReadUInt16());
case FormatCode.Map32: return(stream.ReadUInt32());
default: throw new MsgPackCodeException(code);
}
}
