public void ShouldDeserializeStructsWithDataContracts()
{
MessagePackSerializer <TestStruct> serializer = MessagePackSerializer.Get <TestStruct>();
byte[] bytes = serializer.PackSingleObject(new TestStruct(123));
TestStruct result = serializer.UnpackSingleObject(bytes);
Assert.That(result.Field, Is.EqualTo(123));
}
public void TestIssue92_EmptyAsMpo()
{
var bytes = new byte[] { 0x82, 0xA1, 0x74, 0x81, 0xA1, 0x74, 0x04, 0xA4, 0x64, 0x61, 0x74, 0x61, 0x80 };
using (var buffer = new MemoryStream(bytes))
{
var serializer = MessagePackSerializer.Get <Dictionary <string, MessagePackObject> >(new SerializationContext());
var d = serializer.Unpack(buffer);
}
}
public void TestGet_WithContext_SameTypeAsGet1()
{
var context = new SerializationContext();
var first = MessagePackSerializer.Get(typeof(Image), context);
Assert.That(first, Is.Not.Null);
var second = MessagePackSerializer.Get <Image>(context);
Assert.That(second, Is.Not.Null);
Assert.That(first.GetType(), Is.EqualTo(second.GetType()));
}
public void TestIssue13_StringListMapAsMpoDictionary()
{
var target = MessagePackSerializer.Get <Dictionary <MessagePackObject, MessagePackObject> >(SerializationContext.Default, PolymorphismSchema.Default);
using (var buffer = new MemoryStream(Convert.FromBase64String("gadyZXN1bHRzkss/8AAAAAAAAMtAAAAAAAAAAA==")))
{
var result = target.Unpack(buffer);
Assert.That(result.Count, Is.EqualTo(1));
Assert.That(result.First().Key == "results", "{0}.Key != results", result.First().Key);
Assert.That(result.First().Value.IsList, "{0}.Value is not list", result.First().Value.UnderlyingType);
}
}
public void TestIssue152()
{
var serializer = MessagePackSerializer.Get <Issue152>(new SerializationContext());
using (var buffer = new MemoryStream())
{
var target = new Issue152();
target.SetItems(new List <int> {
1, 2, 3
});
serializer.Pack(buffer, target);
buffer.Position = 0;
var result = serializer.Unpack(buffer);
Assert.That(result.GetItems(), Is.EqualTo(target.GetItems()));
}
}
public void TestIssue92_EmptyAsCollection()
{
var value = new int[][] { new[] { 1, 2 }, new int[0] };
var serializer = MessagePackSerializer.Get <int[][]>(new SerializationContext());
using (var buffer = new MemoryStream())
{
serializer.Pack(buffer, value);
buffer.Position = 0;
var a = serializer.Unpack(buffer);
Assert.That(a.Length, Is.EqualTo(2));
Assert.That(a[0].Length, Is.EqualTo(2));
Assert.That(a[0][0], Is.EqualTo(1));
Assert.That(a[0][1], Is.EqualTo(2));
Assert.That(a[1].Length, Is.EqualTo(0));
}
}
public void TestIssue269()
{
var input = new MessagePackObject(Timestamp.UtcNow.Encode());
var target = MessagePackSerializer.UnpackMessagePackObject(MessagePackSerializer.Get <MessagePackObject>().PackSingleObject(input));
Assert.That(target.UnderlyingType, Is.EqualTo(typeof(MessagePackExtendedTypeObject)));
Assert.That(target.IsTypeOf <byte[]>(), Is.False);
Assert.That(target.IsTypeOf <MessagePackExtendedTypeObject>(), Is.True);
var forBinary = Assert.Throws <InvalidOperationException>(() => target.AsBinary());
Assert.That(forBinary.Message, Is.EqualTo("Do not convert MsgPack.MessagePackExtendedTypeObject MessagePackObject to System.Byte[]."));
var forString = Assert.Throws <InvalidOperationException>(() => target.AsString());
Assert.That(forString.Message, Is.EqualTo("Do not convert MsgPack.MessagePackExtendedTypeObject MessagePackObject to System.String."));
}
public void TestIssue41()
{
using (var buffer = new MemoryStream(new byte[] { 0x84, 0x01, 0x81, 0x0a, 0x14, 0x02, 0x93, 0x14, 0x1e, 0x28, 0x03, MessagePackCode.NilValue, 0x04, 0x0 }))
//using ( var unpacker = Unpacker.Create( buffer ) )
{
//unpacker.Read();
var serializer = MessagePackSerializer.Get <MessagePackObjectDictionary>();
//var result = serializer.UnpackFrom( unpacker );
var result = serializer.Unpack(buffer);
Assert.That(result.Count, Is.EqualTo(4));
Assert.That(result[1].AsDictionary().Count, Is.EqualTo(1));
Assert.That(result[1].AsDictionary()[10], Is.EqualTo(( MessagePackObject )0x14));
Assert.That(result[2].AsList().Count, Is.EqualTo(3));
Assert.That(result[2].AsList()[0], Is.EqualTo(( MessagePackObject )0x14));
Assert.That(result[2].AsList()[1], Is.EqualTo(( MessagePackObject )0x1E));
Assert.That(result[2].AsList()[2], Is.EqualTo(( MessagePackObject )0x28));
Assert.That(result[3].IsNil);
Assert.That(result[4], Is.EqualTo(( MessagePackObject )0x0));
}
}
public void TestIssue73()
{
var original = SerializationContext.ConfigureClassic();
try
{
var value =
new Dictionary <string, object> {
{ "1", new object() }, { "2", new object() }
};
var serializer = MessagePackSerializer.Get <Dictionary <string, object> >(new SerializationContext());
using (var buffer = new MemoryStream())
{
Assert.Throws <SerializationException>(() => serializer.Pack(buffer, value));
}
}
finally
{
SerializationContext.Default = original;
}
}
public void TestIssue70()
{
var serializer = MessagePackSerializer.Get <DBNull>(new SerializationContext());
#if !UNITY
// Should not be created dynamically.
Assert.That(serializer, Is.TypeOf(typeof(DefaultSerializers.System_DBNullMessagePackSerializer)));
#endif // !UNITY
using (var buffer = new MemoryStream())
{
serializer.Pack(buffer, DBNull.Value);
buffer.Position = 0;
var packed = Unpacking.UnpackObject(buffer);
Assert.That(packed.IsNil, packed.ToString());
buffer.Position = 0;
var unpacked = serializer.Unpack(buffer);
Assert.That(Object.ReferenceEquals(unpacked, null), Is.False);
Assert.That(unpacked, Is.SameAs(DBNull.Value));
}
}
public void Issue143()
{
var array =
new object[]
{
"111",
32432,
new int[] { 9, 8 },
909
};
var serializer = MessagePackSerializer.Get <object>(new SerializationContext());
var packedBinary = serializer.PackSingleObject(array);
var unpacked = serializer.UnpackSingleObject(packedBinary);
var unpackedList = (( MessagePackObject )unpacked).AsList();
Assert.That(unpackedList.Count, Is.EqualTo(4));
Assert.That(unpackedList[0] == "111");
Assert.That(unpackedList[1] == 32432);
Assert.That(unpackedList[2].IsList);
Assert.That(unpackedList[2].AsList().Count, Is.EqualTo(2));
Assert.That(unpackedList[2].AsList()[0] == 9);
Assert.That(unpackedList[2].AsList()[1] == 8);
Assert.That(unpackedList[3] == 909);
}
public void TestIssue99_HoGyuLee_AotForEnumKeyDictionary()
{
MessagePackSerializer.PrepareType <FileMode>();
using (var buffer = new MemoryStream(new byte[] { 0x81, 0x01, 0x00 }))
{
var serializer =
MessagePackSerializer.Get <Dictionary <FileMode, int> >(
PreGeneratedSerializerActivator.CreateContext(
SerializationMethod.Array,
PackerCompatibilityOptions.None
)
);
var result = serializer.Unpack(buffer);
Assert.That(result.Count, Is.EqualTo(1));
var singleResult = default(KeyValuePair <FileMode, int>);
foreach (var kv in result)
{
singleResult = kv;
}
Assert.That(singleResult.Key, Is.EqualTo(( FileMode )1));
Assert.That(singleResult.Value, Is.EqualTo(0));
}
}
public void TestGet_WithContext_ContextIsNull_Fail()
{
Assert.Throws <ArgumentNullException>(() => MessagePackSerializer.Get(typeof(Image), null));
}
public void TestGet_WithContext_TypeIsNull_Fail()
{
Assert.Throws <ArgumentNullException>(() => MessagePackSerializer.Get(null, new SerializationContext()));
}
public void TestGet_WithoutContext_Ok()
{
var instance = MessagePackSerializer.Get(typeof(Image));
Assert.That(instance, Is.Not.Null);
}
public void TestGet1_WithContext_Null_Fail()
{
Assert.Throws <ArgumentNullException>(() => MessagePackSerializer.Get <Image>(null));
}
