public void ComplexDictionary()
{
var tests = new Dictionary <object, object>
{
{
"array1",
new object[]
{
"array1_value1",
"array1_value2",
"array1_value3"
}
},
{ "bool1", true },
{ "double1", 50.5 },
{ "double2", 15.2 },
{ "int1", 50505 },
{ "int2", 50 },
{ 3.14f, 3.14 },
{ 42, 42 },
{ new Dictionary <int, int> {
{ 1, 2 }
}, null },
{ new[] { 1, 2 }, null }
};
var data = new byte[]
{
138,
166, 97, 114, 114, 97, 121, 49,
147,
173, 97, 114, 114, 97, 121, 49, 95, 118, 97, 108, 117, 101, 49,
173, 97, 114, 114, 97, 121, 49, 95, 118, 97, 108, 117, 101, 50,
173, 97, 114, 114, 97, 121, 49, 95, 118, 97, 108, 117, 101, 51,
165, 98, 111, 111, 108, 49, 195,
167, 100, 111, 117, 98, 108, 101, 49, 203, 64, 73, 64, 0, 0, 0, 0, 0,
167, 100, 111, 117, 98, 108, 101, 50, 203, 64, 46, 102, 102, 102, 102, 102, 102,
164, 105, 110, 116, 49, 205, 197, 73,
164, 105, 110, 116, 50, 50,
202, 64, 72, 245, 195, 203, 64, 9, 30, 184, 81, 235, 133, 31,
42, 42,
129, 1, 2, 192,
146, 1, 2, 192
};
var settings = new MsgPackContext();
settings.RegisterConverter(new TestReflectionConverter());
MsgPackConverter.Serialize(tests, settings).ShouldBe(data);
}
public void TestDateTime()
{
var tests = new List <KeyValuePair <byte[], System.DateTime> >()
{
new KeyValuePair <byte[], DateTime>(new byte[] { 211, 247, 96, 128, 10, 8, 74, 128, 0, }, new DateTime(1, 1, 1, 0, 0, 0, 0, DateTimeKind.Utc)),
new KeyValuePair <byte[], DateTime>(new byte[] { 211, 35, 42, 168, 127, 252, 129, 152, 240, }, new DateTime(9999, 12, 31, 23, 59, 59, 999, DateTimeKind.Utc)),
new KeyValuePair <byte[], DateTime>(new byte[] { 211, 0, 51, 110, 236, 17, 171, 0, 0, }, new DateTime(2015, 11, 17, 0, 0, 0, 0, DateTimeKind.Utc)),
new KeyValuePair <byte[], DateTime>(new byte[] { 211, 247, 96, 154, 26, 189, 97, 197, 0, }, new DateTime(1, 2, 3, 4, 5, 6, DateTimeKind.Utc)),
};
foreach (var test in tests)
{
MsgPackConverter.Deserialize <System.DateTime>(test.Key).ShouldBe(test.Value);
}
}
public void TestDateTimeOffset()
{
var tests = new List <KeyValuePair <byte[], System.DateTimeOffset> >()
{
new KeyValuePair <byte[], DateTimeOffset>(new byte[] { 211, 247, 96, 128, 10, 8, 74, 128, 0, }, DateTimeOffset.MinValue),
new KeyValuePair <byte[], DateTimeOffset>(new byte[] { 211, 35, 42, 168, 127, 252, 129, 191, 255, }, DateTimeOffset.MaxValue),
new KeyValuePair <byte[], DateTimeOffset>(new byte[] { 211, 0, 51, 110, 236, 17, 171, 0, 0, }, new DateTimeOffset(2015, 11, 17, 0, 0, 0, TimeSpan.Zero)),
new KeyValuePair <byte[], DateTimeOffset>(new byte[] { 211, 247, 96, 154, 26, 189, 97, 197, 0, }, new DateTimeOffset(1, 2, 3, 4, 5, 6, TimeSpan.Zero)),
new KeyValuePair <byte[], DateTimeOffset>(new byte[] { 211, 247, 96, 153, 182, 40, 44, 229, 0, }, new DateTimeOffset(1, 2, 3, 4, 5, 6, TimeSpan.FromHours(12))),
new KeyValuePair <byte[], DateTimeOffset>(new byte[] { 211, 247, 96, 153, 232, 79, 4, 15, 0, }, new DateTimeOffset(1, 2, 3, 4, 5, 6, TimeSpan.FromMinutes(361))),
};
foreach (var test in tests)
{
MsgPackConverter.Deserialize <System.DateTimeOffset>(test.Key).ShouldBe(test.Value);
}
}
public void SimpleDictionary()
{
var test = new Dictionary <int, string>
{
{ 1, "a" },
{ 2, "b" },
{ 3, "c" },
{ 4, "d" },
{ 5, "e" }
};
var bytes = new byte[]
{
133,
1, 161, 97,
2, 161, 98,
3, 161, 99,
4, 161, 100,
5, 161, 101
};
MsgPackConverter.Deserialize <Dictionary <int, string> >(bytes).ShouldBe(test);
}
public void SimpleArray()
{
var tests = new[]
{
"a",
"b",
"c",
"d",
"e"
};
var bytes = new byte[]
{
149,
161, 97,
161, 98,
161, 99,
161, 100,
161, 101
};
MsgPackConverter.Serialize(tests).ShouldBe(bytes);
}
public void TestArrayPack()
{
var expected = new object[]
{
0,
50505,
float.NaN,
float.MaxValue,
new[] { true, false, true },
null,
new Dictionary <object, object> {
{ "Ball", "Soccer" }
}
};
var data = new byte[]
{
151,
0,
205, 197, 73,
202, 255, 192, 0, 0,
202, 127, 127, 255, 255,
147,
195,
194,
195,
192,
129,
164, 66, 97, 108, 108, 166, 83, 111, 99, 99, 101, 114
};
var settings = new MsgPackContext();
settings.RegisterConverter(new TestReflectionConverter());
MsgPackConverter.Deserialize <object[]>(data, settings).ShouldBe(expected);
}
public void TestNonFixedArray()
{
var array = 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,
};
MsgPackConverter.Deserialize <int[]>(bytes).ShouldBe(array);
}
public void TestSignedLong(long number, byte[] data)
{
MsgPackConverter.Serialize((long?)number).ShouldBe(data);
}
public void NonFixedDictionary()
{
var bytes = new byte[]
{
0xde,
0x00,
0x14,
0x01, 0xa1, 0x61,
0x02, 0xa1, 0x62,
0x03, 0xa1, 0x63,
0x04, 0xa1, 0x64,
0x05, 0xa1, 0x65,
0x0b, 0xa1, 0x61,
0x0c, 0xa1, 0x62,
0x0d, 0xa1, 0x63,
0x0e, 0xa1, 0x64,
0x0f, 0xa1, 0x65,
0x15, 0xa1, 0x61,
0x16, 0xa1, 0x62,
0x17, 0xa1, 0x63,
0x18, 0xa1, 0x64,
0x19, 0xa1, 0x65,
0x1f, 0xa1, 0x61,
0x20, 0xa1, 0x62,
0x21, 0xa1, 0x63,
0x22, 0xa1, 0x64,
0x23, 0xa1, 0x65,
};
var test = new Dictionary <int, string>
{
{ 1, "a" },
{ 2, "b" },
{ 3, "c" },
{ 4, "d" },
{ 5, "e" },
{ 11, "a" },
{ 12, "b" },
{ 13, "c" },
{ 14, "d" },
{ 15, "e" },
{ 21, "a" },
{ 22, "b" },
{ 23, "c" },
{ 24, "d" },
{ 25, "e" },
{ 31, "a" },
{ 32, "b" },
{ 33, "c" },
{ 34, "d" },
{ 35, "e" },
};
MsgPackConverter.Deserialize <Dictionary <int, string> >(bytes).ShouldBe(test);
}
public void WriteNullByteArray()
{
MsgPackConverter.Serialize((byte[])null).ShouldBe(new[] { (byte)DataTypes.Null });
}
public void ReadNullString()
{
MsgPackConverter.Deserialize <string>(new[] { (byte)DataTypes.Null }).ShouldBe(null);
}
public void ReadNullByteArray()
{
MsgPackConverter.Deserialize <byte[]>(new[] { (byte)DataTypes.Null }).ShouldBe(null);
}
public void TetsUnsignedLong(ulong number, byte[] data)
{
MsgPackConverter.Serialize(number).ShouldBe(data);
}
public void TestFloat(float value, byte[] bytes)
{
MsgPackConverter.Serialize((float?)value).ShouldBe(bytes);
}
public void TestDouble(double value, byte[] bytes)
{
MsgPackConverter.Serialize((double?)value).ShouldBe(bytes);
}
public void Test(byte[] value, byte[] data)
{
MsgPackConverter.Deserialize <byte[]>(data).ShouldBe(value);
}
public void WriteNullString()
{
MsgPackConverter.Serialize((string)null).ShouldBe(new[] { (byte)DataTypes.Null });
}
public void WriteNullMap()
{
MsgPackConverter.Serialize((IDictionary <int, int>)null).ShouldBe(new[] { (byte)DataTypes.Null });
}
public void TestSignedByte(sbyte number, byte[] data)
{
MsgPackConverter.Serialize(number).ShouldBe(data);
}
public void TestSignedShort(short number, byte[] data)
{
MsgPackConverter.Serialize((short?)number).ShouldBe(data);
}
public void TetsUnsignedShort(ushort number, byte[] data)
{
MsgPackConverter.Serialize(number).ShouldBe(data);
}
public void TetsUnsignedInt(uint number, byte[] data)
{
MsgPackConverter.Serialize((uint?)number).ShouldBe(data);
}
public void ReadNullMap()
{
MsgPackConverter.Deserialize <Dictionary <int, int> >(new[] { (byte)DataTypes.Null }).ShouldBe(null);
}
public void TetsUnsignedByte(byte number, byte[] data)
{
MsgPackConverter.Serialize((byte?)number).ShouldBe(data);
}
public void TestStringPack(string s, byte[] data)
{
MsgPackConverter.Deserialize <string>(data).ShouldBe(s);
}
public void WriteNullAsNullableUlong()
{
MsgPackConverter.Serialize(default(ulong?)).ShouldBe(new[] { (byte)DataTypes.Null });
}
public void False()
{
MsgPackConverter.Serialize((bool?)false).ShouldBe(new[] { (byte)DataTypes.False });
}
public void True()
{
MsgPackConverter.Serialize((bool?)true).ShouldBe(new[] { (byte)DataTypes.True });
}
public void TestStringPack(string s, byte[] data)
{
MsgPackConverter.Serialize(s).ShouldBe(data);
}
public void TestFloat(float value, byte[] bytes)
{
MsgPackConverter.Deserialize <float>(bytes).ShouldBe(value);
}
