private void TestGenericList <T> (T entry1, T entry2)
{
List <T> objList = new List <T>();
objList.Add(entry1);
objList.Add(entry2);
string logHeader = string.Format("List<{0}>: ", typeof(T).ToString());
var msg = MsgPackSerializer.SerializeObject(objList);
var desizList = MsgPackSerializer.Deserialize <List <T> >(msg);
Assert.That(desizList != null, logHeader + "null desiz");
Assert.That(typeof(List <T>) == desizList.GetType(), logHeader + "different types");
if (entry1 == null)
{
Assert.That(objList[0] == null);
}
else
{
Assert.That(desizList[0].Equals(entry1), logHeader + "value lost 1: " + entry1.ToString());
}
if (entry2 == null)
{
Assert.That(objList[1] == null);
}
else
{
Assert.That(desizList[1].Equals(entry2), logHeader + "value lost 2: " + entry2.ToString());
}
}
public static byte[] ToMsgPack(this object o)
{
if (o == null)
{
throw new ArgumentException("Can't serialize null references", "o");
}
return(MsgPackSerializer.SerializeObject(o));
}
private static void TestMsgPackSharp()
{
for (int i = 0; i < numMessagesToTest; i++)
{
byte[] buffer = MsgPackSerializer.SerializeObject(testMsg);
#pragma warning disable 0219
var deserialized = MsgPackSerializer.Deserialize <AnimalMessage>(buffer);
#pragma warning restore 0219
}
}
public NetworkMessage Clone()
{
MsgPackSerializer.SerializeObject(this, cloneBuffer, 0);
var result = (NetworkMessage)(GetType().GetConstructor(Type.EmptyTypes).Invoke(emptyArgs));
MsgPackSerializer.DeserializeObject(result, cloneBuffer, 0);
result.SequenceNumber = SequenceNumber;
result.Source = Source;
result.Id = Id;
return(result);
}
public int Write(byte[] buffer)
{
int offset = 1;
buffer[0] = Id;
if (IsGuaranteed)
{
buffer[1] = (byte)(SequenceNumber & 0x00FF);
buffer[2] = (byte)((SequenceNumber & 0xFF00) >> 8);
offset = 3;
}
return(MsgPackSerializer.SerializeObject(this, buffer, offset));
}
public void TestMixedTypeDictionaryRoundTrip()
{
MsgPackSerializer.DefaultContext.SerializationMethod = SerializationMethod.Array;
var obj = new Dictionary <string, object> {
{ "Boolean", false },
{ "String", "string" },
{ "Float", 1.0f },
{ "Null", null }
};
var msg = MsgPackSerializer.SerializeObject(obj);
var deserializedDictionary = MsgPackSerializer.Deserialize <Dictionary <string, object> > (msg);
Assert.That(deserializedDictionary.ContainsValue(false));
}
public void TestNestedObject()
{
MsgPackSerializer.DefaultContext.SerializationMethod = SerializationMethod.Array;
var obj = new SerializationTestObject();
byte[] msg = MsgPackSerializer.SerializeObject(obj);
var desiz = MsgPackSerializer.Deserialize <SerializationTestObject>(msg);
Assert.That(desiz != null, "No Nesting: null desiz");
Assert.That(desiz.Equals(obj), "No Nesting: not equal");
obj.AddChild();
msg = MsgPackSerializer.SerializeObject(obj);
desiz = MsgPackSerializer.Deserialize <SerializationTestObject>(msg);
Assert.That(desiz != null, "Nesting: null desiz");
Assert.That(desiz.Equals(obj), "Nesting: not equal");
}
public void TestDeserializationOfMixedTypeDictionary()
{
MsgPackSerializer.DefaultContext.SerializationMethod = SerializationMethod.Array;
var obj = new Dictionary <string, object> {
{ "Boolean", false },
{ "String", "string" },
{ "Float", 1.0f },
{ "Null", null }
};
var msg = MsgPackSerializer.SerializeObject(obj);
var deserializedDictionary = MsgPackSerializer.Deserialize <Dictionary <string, object> >(msg);
object value = null;
deserializedDictionary.TryGetValue("Boolean", out value);
Assert.That(value.Equals(false));
}
private void BuildInstances(Assembly messageAssembly)
{
Type networkMsgType = typeof(NetworkMessage);
foreach (Type t in messageAssembly.GetTypes())
{
if (t.IsSubclassOf(networkMsgType) && !messagesByType.ContainsKey(t))
{
if (messages.Count == Byte.MaxValue)
{
throw new ApplicationException("The maximum number of network messages has been reached - you need to use fewer message types in this project");
}
var msg = (NetworkMessage)t.GetConstructor(Type.EmptyTypes).Invoke(Utility.emptyArgs);
MsgPackSerializer.SerializeObject(msg, NetworkMessage.cloneBuffer, 0);
MsgPackSerializer.DeserializeObject(msg, NetworkMessage.cloneBuffer, 0);
msg.Id = (byte)messages.Count;
messages[msg.Id] = msg;
messagesByType[msg.GetType()] = msg;
NeutrinoConfig.Log("Registered message type " + msg.GetType() + " as Id " + msg.Id);
}
}
}
private void TestGenericDictionary <Key, Value> (Key testKey, Value testValue)
{
Dictionary <Key, Value> intDict = new Dictionary <Key, Value>();
intDict.Add(testKey, testValue);
var msg = MsgPackSerializer.SerializeObject(intDict);
var desizDict = MsgPackSerializer.Deserialize <Dictionary <Key, Value> >(msg);
string logHeader = string.Format("Dictionary<{0}, {1}>: ", typeof(Key).ToString(), typeof(Value).ToString());
Assert.That(desizDict != null, logHeader + "null desiz");
Assert.That(typeof(Dictionary <Key, Value>) == desizDict.GetType(), logHeader + "different types");
if (testValue == null)
{
Assert.That(desizDict[testKey] == null);
}
else
{
Assert.That(desizDict.ContainsKey(testKey) && desizDict[testKey].Equals(testValue), logHeader + "key value lost");
}
}
public void write(NetOutgoingMessage packet, LimeMessage msg)
{
packet.Write(msg.id);
packet.Write(MsgPackSerializer.SerializeObject(msg));
}
