public void RoundTripTest(bool dynamicallyCompact, int expectedLength, params object[] items)
{
MpRoot root = MsgPackItem.PackMultiple(dynamicallyCompact, items);
byte[] bytes = root.ToBytes();
Assert.AreEqual(expectedLength, bytes.Length, string.Concat("Expected ", expectedLength, " serialized bytes items but got ", bytes.Length, " bytes."));
MpRoot result = MsgPackItem.UnpackMultiple(bytes, dynamicallyCompact);
Assert.AreEqual(items.Length, result.Count, string.Concat("Expected ", items.Length, " items but got ", result.Count, " items after round trip."));
for (int t = 0; t < result.Count; t++)
{
object expected = items[t];
object actual = result[t].Value;
if (!dynamicallyCompact && !(expected is null))
{
Type expectedType = expected.GetType();
Type foundType = actual.GetType();
Assert.True(foundType == expectedType, string.Concat("Expected type of ", expectedType.ToString(), " but received the type ", foundType.ToString()));
}
Assert.AreEqual(expected, actual, "The returned value ", actual, " differs from the input value ", expected);
}
}
public void AssortedMix(bool preserveTypes, int expectedLength)
{
KeyValuePair <object, object>[] items = new KeyValuePair <object, object>[] {
new KeyValuePair <object, object>(true, true),
new KeyValuePair <object, object>(false, false),
new KeyValuePair <object, object>(null, null),
new KeyValuePair <object, object>(int.MinValue, uint.MaxValue),
new KeyValuePair <object, object>((byte)1, 5.2d),
new KeyValuePair <object, object>((byte)2, 900.1f),
new KeyValuePair <object, object>("Hallo!", "Hallo!"),
};
if (preserveTypes)
{
MsgPackTests.DynamicallyCompactValue = false;
}
try {
MsgPackItem item = MsgPackTests.RoundTripTest <MpMap, KeyValuePair <object, object>[]>(items, expectedLength, MsgPackTypeId.MpMap4);
KeyValuePair <object, object>[] ret = item.GetTypedValue <KeyValuePair <object, object>[]>();
Assert.AreEqual(items.Length, ret.Length, string.Concat("Expected ", items.Length, " items but got ", ret.Length, " items in the array."));
for (int t = ret.Length - 1; t >= 0; t--)
{
if (preserveTypes && t != 2)
{
Assert.IsTrue(items[t].GetType() == ret[t].GetType(), string.Concat("Expected type ", items[t].GetType(), " items but got ", ret[t].GetType(), "."));
}
Assert.AreEqual(items[t], ret[t], string.Concat("Expected ", items[t], " but got ", ret[t], " at index ", t));
}
} finally {
MsgPackTests.DynamicallyCompactValue = true;
}
}
public void SlidingTackle(string directory)
{
KeyValuePair <object, object>[] items = new KeyValuePair <object, object>[] {
new KeyValuePair <object, object>(true, false),
new KeyValuePair <object, object>(null, "Maps are quite flexible!"),
new KeyValuePair <object, object>(true, "Double!"),
new KeyValuePair <object, object>(new KeyValuePair <object, object> [0], new object[0]),
new KeyValuePair <object, object>(new object[0], new KeyValuePair <object, object> [0])
};
File.WriteAllBytes(Path.Combine(directory, "SlidingTackle.MsgPack"), MsgPackItem.Pack(items).ToBytes());
}
public void EnumDictionaryUse()
{
Dictionary <myEnum, object> objectProps = new Dictionary <myEnum, object>();
objectProps.Add(myEnum.SomeString, "Hallo!");
objectProps.Add(myEnum.SomeInt, 5);
objectProps.Add(myEnum.SomeBool, true);
objectProps.Add(myEnum.SomeNothing, null);
objectProps.Add(myEnum.SomeFloat, 3.5f);
MsgPackItem item = MsgPackTests.RoundTripTest <MpMap, Dictionary <myEnum, object> >(objectProps, 21, MsgPackTypeId.MpMap4);
}
public void TypicalDictionaryUse()
{
Dictionary <string, object> objectProps = new Dictionary <string, object>();
objectProps.Add("string", "Hallo!");
objectProps.Add("int", 5);
objectProps.Add("bool", true);
objectProps.Add("nothing", null);
objectProps.Add("float", 3.5f);
MsgPackItem item = MsgPackTests.RoundTripTest <MpMap, Dictionary <string, object> >(objectProps, 46, MsgPackTypeId.MpMap4);
}
public void Example(string directory)
{
MyClass message = new MyClass()
{
Name = "TestMessage",
Quantity = 35,
Anything = new List <object>(new object[] { "First", 2, false, null, 5.5d, "last", DateTime.Now })
};
byte[] bytes = MsgPackItem.Pack(message).ToBytes();
File.WriteAllBytes(Path.Combine(directory, "Example.MsgPack"), bytes);
}
private int GetIconFor(MsgPackItem item)
{
if (ReferenceEquals(item, null))
{
return(0);
}
Type typ = item.GetType();
if (typ == typeof(MpBool))
{
return(1);
}
if (typ == typeof(MpInt))
{
return(2);
}
if (typ == typeof(MpFloat))
{
return(3);
}
if (typ == typeof(MpBin))
{
return(4);
}
if (typ == typeof(MpString))
{
return(5);
}
if (typ == typeof(MpArray))
{
return(6);
}
if (typ == typeof(MpMap))
{
return(7);
}
if (typ == typeof(MpExt))
{
return(10);
}
if (typ == typeof(MpError))
{
return(11);
}
if (typ == typeof(MpRoot))
{
return(12);
}
return(-1);
}
public static MsgPackItem RoundTripTest <Typ, T>(T value, int expectedLength, MsgPackTypeId expectedMsgPackType, sbyte extensionType = 0) where Typ : MsgPackItem
{
bool preservingType = !DynamicallyCompactValue;
MsgPackItem item;
if (typeof(Typ) == typeof(MpExt))
{
item = new MpExt()
{
Value = value,
TypeSpecifier = extensionType
};
}
else
{
item = MsgPackItem.Pack(value, new MsgPackSettings()
{
DynamicallyCompact = DynamicallyCompactValue,
PreservePackages = false,
ContinueProcessingOnBreakingError = false
});
}
byte[] buffer = item.ToBytes();
Type expectedType = typeof(Typ);
Type foundType = item.GetType();
MsgPackTypeId resultType = preservingType && item is MpInt ? ((MpInt)item).PreservedType : item.TypeId;
bool typesAreEqual = (expectedMsgPackType & resultType) == expectedMsgPackType;
Assert.IsTrue(typesAreEqual, string.Concat("Expected packed type of ", expectedMsgPackType, " but received the type ", resultType));
Assert.True(foundType == expectedType, string.Concat("Expected type of ", expectedType.ToString(), " but received the type ", foundType.ToString()));
if (expectedLength >= 0)
{
Assert.AreEqual(expectedLength, buffer.Length, string.Concat("Expected a packed length of ", expectedLength.ToString(), " bytes but got ", buffer.Length.ToString(), " bytes."));
}
MsgPackItem recreate = MsgPackItem.Unpack(new MemoryStream(buffer));
resultType = preservingType && item is MpInt ? ((MpInt)recreate).PreservedType : recreate.TypeId;
typesAreEqual = (expectedMsgPackType & resultType) == expectedMsgPackType;
Assert.IsTrue(typesAreEqual, string.Concat("Expected unpacked type of ", expectedMsgPackType, " but received the type ", resultType));
T ret = recreate.GetTypedValue <T>();
Assert.AreEqual(value, ret, "The returned value ", ret, " differs from the input value ", value);
return(recreate);
}
// [TestCase(0x7FEFFFF9, 0x7FEFFFF9 + 6, MsgPackTypeId.MpArray32)] // Out of memory on my machine
public void ArrayLengths(int length, int expectedBytes, MsgPackTypeId expedctedType)
{
object[] test = new object[length];
int additionalBytes = FillArrayWithRandomNumbers(test);
additionalBytes -= test.Length;
MsgPackItem item = MsgPackTests.RoundTripTest <MpArray, object[]>(test, expectedBytes + additionalBytes, expedctedType);
object[] ret = item.GetTypedValue <object[]>();
Assert.AreEqual(length, ret.Length, string.Concat("Expected ", length, " items but got ", ret.Length, " items in the array."));
for (int t = ret.Length - 1; t >= 0; t--)
{
Assert.AreEqual(test[t], ret[t], string.Concat("Expected ", test[t], " but got ", ret[t], " at index ", t));
}
}
// [TestCase(0x7FEFFFF9, 0x7FEFFFF9 + 6, MsgPackTypeId.MpMap32)] // Out of memory on my machine
public void MapLengths(int length, int expectedBytes, MsgPackTypeId expedctedType)
{
KeyValuePair <object, object>[] test = new KeyValuePair <object, object> [length];
for (int t = test.Length - 1; t >= 0; t--)
{
test[t] = new KeyValuePair <object, object>(null, null);
}
int additionalBytes = test.Length;
MsgPackItem item = MsgPackTests.RoundTripTest <MpMap, KeyValuePair <object, object>[]>(test, expectedBytes + additionalBytes, expedctedType);
KeyValuePair <object, object>[] ret = item.GetTypedValue <KeyValuePair <object, object>[]>();
Assert.AreEqual(length, ret.Length, string.Concat("Expected ", length, " items but got ", ret.Length, " items in the map."));
for (int t = ret.Length - 1; t >= 0; t--)
{
Assert.AreEqual(test[t], ret[t], string.Concat("Expected ", test[t], " but got ", ret[t], " at index ", t));
}
}
private void treeView1_AfterSelect(object sender, TreeViewEventArgs e)
{
if (ReferenceEquals(e.Node, null))
{
propertyGrid1.SelectedObject = null;
ColorSelectedNodeInHexView(null);
ClearValidationSelection();
}
else
{
propertyGrid1.SelectedObject = e.Node.Tag;
propertyGrid1.ExpandAllGridItems();
MsgPackItem item = e.Node.Tag as MsgPackItem;
if (ReferenceEquals(item, null))
{
statusOffset.Text = "0 (0x00)";
ColorSelectedNodeInHexView(null);
}
else
{
statusOffset.Text = string.Concat(item.StoredOffset, " (0x", item.StoredOffset.ToString("X"), ")");
EditorMetaData meta = item.Tag as EditorMetaData;
ColorSelectedNodeInHexView(meta);
}
if (!lvSelecting)
{
lvSelecting = true;
try {
for (int t = listView1.Items.Count - 1; t >= 0; t--)
{
bool select = listView1.Items[t].Tag == e.Node;
listView1.Items[t].Selected = select;
}
} finally {
lvSelecting = false;
errorDetails.Visible = false;
splitter4.Visible = false;
}
}
}
}
private TreeNode GetTreeNodeFor(MsgPackItem item)
{
int imgIdx = GetIconFor(item);
string text = ReferenceEquals(item, null) ? "NULL" : item.ToString();
int pos = text.IndexOfAny(new char[] { '\r', '\n' });
if (pos > 0)
{
text = text.Substring(0, pos - 1);
}
TreeNode node = new TreeNode(text, imgIdx, imgIdx);
if (ReferenceEquals(item, null) || item.IsBestGuess)
{
node.ForeColor = Color.DarkGray;
}
node.Tag = item;
return(node);
}
public static MsgPackItem RoundTripTest <Typ, T>(T value, int expectedLength, MsgPackTypeId expectedMsgPackType, sbyte extensionType = 0) where Typ : MsgPackItem
{
MsgPackItem item;
if (typeof(Typ) == typeof(MpExt))
{
item = new MpExt()
{
Value = value,
TypeSpecifier = extensionType
};
}
else
{
item = MsgPackItem.Pack(value);
}
byte[] buffer = item.ToBytes();
Type expectedType = typeof(Typ);
Type foundType = item.GetType();
MsgPackTypeId resultType = item.TypeId;
bool typesAreEqual = (expectedMsgPackType & resultType) == expectedMsgPackType;
Assert.IsTrue(typesAreEqual, string.Concat("Expected packed type of ", expectedMsgPackType, " but received the type ", resultType));
Assert.True(foundType == expectedType, string.Concat("Expected type of ", expectedType.ToString(), " but received the type ", foundType.ToString()));
if (expectedLength >= 0)
{
Assert.AreEqual(expectedLength, buffer.Length, string.Concat("Expected a packed length of ", expectedLength.ToString(), " bytes but got ", buffer.Length.ToString(), " bytes."));
}
MsgPackItem recreate = MsgPackItem.Unpack(new MemoryStream(buffer));
resultType = recreate.TypeId;
typesAreEqual = (expectedMsgPackType & resultType) == expectedMsgPackType;
Assert.IsTrue(typesAreEqual, string.Concat("Expected unpacked type of ", expectedMsgPackType, " but received the type ", resultType));
T ret = recreate.GetTypedValue <T>();
Assert.AreEqual(value, ret, "The returned value ", ret, " differs from the input value ", value);
return(recreate);
}
public void RoundTripTest(int expectedLength, params object[] items)
{
MpRoot root = MsgPackItem.PackMultiple(items);
byte[] bytes = root.ToBytes();
Assert.AreEqual(expectedLength, bytes.Length, string.Concat("Expected ", expectedLength, " serialized bytes items but got ", bytes.Length, " bytes."));
MpRoot result = MsgPackItem.UnpackMultiple(bytes);
Assert.AreEqual(items.Length, result.Count, string.Concat("Expected ", items.Length, " items but got ", result.Count, " items after round trip."));
for (int t = 0; t < result.Count; t++)
{
object expected = items[t];
object actual = result[t].Value;
Assert.AreEqual(expected, actual, "The returned value ", actual, " differs from the input value ", expected);
}
}
public void AssortedMix(int expectedLength)
{
KeyValuePair <object, object>[] items = new KeyValuePair <object, object>[] {
new KeyValuePair <object, object>(true, true),
new KeyValuePair <object, object>(false, false),
new KeyValuePair <object, object>(null, null),
new KeyValuePair <object, object>(int.MinValue, uint.MaxValue),
new KeyValuePair <object, object>((byte)1, 5.2d),
new KeyValuePair <object, object>((byte)2, 900.1f),
new KeyValuePair <object, object>("Hallo!", "Hallo!"),
};
MsgPackItem item = MsgPackTests.RoundTripTest <MpMap, KeyValuePair <object, object>[]>(items, expectedLength, MsgPackTypeId.MpMap4);
KeyValuePair <object, object>[] ret = item.GetTypedValue <KeyValuePair <object, object>[]>();
Assert.AreEqual(items.Length, ret.Length, string.Concat("Expected ", items.Length, " items but got ", ret.Length, " items in the array."));
for (int t = ret.Length - 1; t >= 0; t--)
{
Assert.AreEqual(items[t], ret[t], string.Concat("Expected ", items[t], " but got ", ret[t], " at index ", t));
}
}
public void AssortedMix(int expectedLength)
{
object[] items = new object[] {
true,
false,
null,
128,
-30,
5.2d,
900.1f,
"Hallo!",
new byte[] { 1, 2, 3 },
new object[] { true, null, "yes" }
};
MsgPackItem item = MsgPackTests.RoundTripTest <MpArray, object[]>(items, expectedLength, MsgPackTypeId.MpArray4);
object[] ret = item.GetTypedValue <object[]>();
Assert.AreEqual(items.Length, ret.Length, string.Concat("Expected ", items.Length, " items but got ", ret.Length, " items in the array."));
for (int t = ret.Length - 1; t >= 0; t--)
{
Assert.AreEqual(items[t], ret[t], string.Concat("Expected ", items[t], " but got ", ret[t], " at index ", t));
}
}
public void AssortedMix(bool preserveTypes, int expectedLength)
{
object[] items = new object[] {
true,
false,
null,
128,
-30,
5.2d,
900.1f,
"Hallo!",
new byte[] { 1, 2, 3 },
new object[] { true, null, "yes" }
};
if (preserveTypes)
{
MsgPackTests.DynamicallyCompactValue = false;
}
try {
MsgPackItem item = MsgPackTests.RoundTripTest <MpArray, object[]>(items, expectedLength, MsgPackTypeId.MpArray4);
object[] ret = item.GetTypedValue <object[]>();
Assert.AreEqual(items.Length, ret.Length, string.Concat("Expected ", items.Length, " items but got ", ret.Length, " items in the array."));
for (int t = ret.Length - 1; t >= 0; t--)
{
if (preserveTypes && t != 2)
{
Assert.IsTrue(items[t].GetType() == ret[t].GetType(), string.Concat("Expected type ", items[t].GetType(), " items but got ", ret[t].GetType(), "."));
}
Assert.AreEqual(items[t], ret[t], string.Concat("Expected ", items[t], " but got ", ret[t], " at index ", t));
}
} finally {
MsgPackTests.DynamicallyCompactValue = true;
}
}
public void SomeBadChoices(string directory)
{
object[] items = new object[] {
"Wrongfully signed types",
(sbyte)50,
(int)128,
(short)129,
(int)129,
(long)129,
(int)1234,
short.MaxValue,
int.MaxValue,
long.MaxValue,
"Uncompressed integers",
(ulong)1,
(ulong)127,
(ulong)128,
(ulong)255,
(ulong)256,
(ulong)ushort.MaxValue,
(ulong)ushort.MaxValue + 1,
(ulong)uint.MaxValue,
(uint)1,
(uint)127,
(uint)128,
(uint)255,
(uint)256,
(uint)ushort.MaxValue,
(ushort)1,
(ushort)127,
(ushort)128,
(ushort)255,
(byte)1,
(byte)127,
(long)-1,
(long)-31,
(long)-32,
(long)-128,
(long)-129,
(long)short.MinValue,
((long)short.MinValue) - 1,
(long)int.MinValue,
(int)-1,
(int)-31,
(int)-32,
(int)-128,
(int)-129,
(int)short.MinValue,
(short)-1,
(short)-31,
(short)-32,
(short)-128,
};
File.WriteAllBytes(Path.Combine(directory, "SomeBadChoices.MsgPack"), MsgPackItem.Pack(items, false).ToBytes());
}
private void Traverse(TreeNode node, MsgPackItem item)
{
if (ReferenceEquals(item, null))
{
return;
}
Type typ = item.GetType();
if (typ == typeof(MpBool))
{
return;
}
if (typ == typeof(MpInt))
{
return;
}
if (typ == typeof(MpFloat))
{
return;
}
if (typ == typeof(MpBin))
{
return;
}
if (typ == typeof(MpString))
{
return;
}
if (typ == typeof(MpArray))
{
MpArray arr = (MpArray)item;
MsgPackItem[] children = arr.PackedValues;
for (int t = 0; t < children.Length; t++)
{
TreeNode child = GetTreeNodeFor(children[t]);
node.Nodes.Add(child);
Traverse(child, children[t]);
}
}
if (typ == typeof(MpMap))
{
MpMap map = (MpMap)item;
KeyValuePair <MsgPackItem, MsgPackItem>[] children = map.PackedValues;
for (int t = 0; t < children.Length; t++)
{
TreeNode child = GetTreeNodeFor(children[t].Key);
child.StateImageIndex = 8; // Key
node.Nodes.Add(child);
Traverse(child, children[t].Key);
TreeNode childVal = GetTreeNodeFor(children[t].Value);
childVal.StateImageIndex = 9; // Value
child.Nodes.Add(childVal);
Traverse(childVal, children[t].Value);
}
}
if (typ == typeof(MpError))
{
MpError err = (MpError)item;
if (!ReferenceEquals(err.PartialItem, null))
{
if (!(err.PartialItem is MpError))
{
node.StateImageIndex = GetIconFor(err.PartialItem);
}
TreeNode child = GetTreeNodeFor(err.PartialItem);
node.Nodes.Add(child);
Traverse(child, err.PartialItem);
}
}
}
private int AddParts(string[] hex, TreeNode node, int byteOffset, StringBuilder sb, ref EditorMetaData previousMeta)
{
MsgPackItem item = (MsgPackItem)node.Tag;
if (ReferenceEquals(item, null))
{
return(byteOffset);
}
int additionalBytes = 0;
while (item.StoredOffset > byteOffset)
{
sb.Append(hex[byteOffset]).Append(' ');
byteOffset++;
additionalBytes++;
}
if (additionalBytes > 0)
{
previousMeta.Length += additionalBytes;
TreeNode parent = previousMeta.Node.Parent;
while (!ReferenceEquals(parent, null))
{
((EditorMetaData)((MsgPackItem)parent.Tag).Tag).Length += additionalBytes;
parent = parent.Parent;
}
}
EditorMetaData meta = new EditorMetaData()
{
CharOffset = byteOffset * 3,
Node = node,
Item = item
};
lineairList.Add(meta);
item.Tag = meta;
previousMeta = meta;
if (!ReferenceEquals(item, null) && !(item is MpError && !ReferenceEquals(((MpError)item).PartialItem, null)) && byteOffset < hex.Length)
{
sb.Append("\\cf1 "); // red
sb.Append(hex[byteOffset]).Append(' ');
byteOffset++;
}
if (item is MsgPackVarLen)
{
int lengthBytes = 0;
switch (item.TypeId)
{
case MsgPackTypeId.MpBin8: lengthBytes = 1; break;
case MsgPackTypeId.MpBin16: lengthBytes = 2; break;
case MsgPackTypeId.MpBin32: lengthBytes = 4; break;
case MsgPackTypeId.MpStr8: lengthBytes = 1; break;
case MsgPackTypeId.MpStr16: lengthBytes = 2; break;
case MsgPackTypeId.MpStr32: lengthBytes = 4; break;
case MsgPackTypeId.MpMap16: lengthBytes = 2; break;
case MsgPackTypeId.MpMap32: lengthBytes = 4; break;
case MsgPackTypeId.MpArray16: lengthBytes = 2; break;
case MsgPackTypeId.MpArray32: lengthBytes = 4; break;
case MsgPackTypeId.MpExt8: lengthBytes = 1; break;
case MsgPackTypeId.MpExt16: lengthBytes = 2; break;
case MsgPackTypeId.MpExt32: lengthBytes = 4; break;
}
if (lengthBytes > 0)
{
sb.Append("\\cf2 "); // blue
for (int t = lengthBytes - 1; t >= 0; t--)
{
sb.Append(hex[byteOffset]).Append(' ');
byteOffset++;
}
}
}
sb.Append("\\cf0 "); // black
for (int t = 0; t < node.Nodes.Count; t++)
{
byteOffset = AddParts(hex, node.Nodes[t], byteOffset, sb, ref previousMeta);
}
ValidateItem(meta);
meta.Length = (byteOffset - (int)item.StoredOffset);
return(byteOffset);
}
public static MsgPackItem RoundTripTest <Typ, T>(T value, int expectedLength, MsgPackTypeId expectedMsgPackType, sbyte extensionType = 0) where Typ : MsgPackItem
{
MsgPackItem item;
if (typeof(Typ) == typeof(MpExt))
{
item = new MpExt()
{
Value = value,
TypeSpecifier = extensionType
};
}
else
{
item = MsgPackItem.Pack(value);
}
byte[] buffer = item.ToBytes();
Type expectedType = typeof(Typ);
Type foundType = item.GetType();
MsgPackTypeId resultType = item.TypeId;
bool typesAreEqual = (expectedMsgPackType & resultType) == expectedMsgPackType;
Assert.IsTrue(typesAreEqual, string.Concat("Expected packed type of ", expectedMsgPackType, " but received the type ", resultType));
Assert.True(foundType == expectedType, string.Concat("Expected type of ", expectedType.ToString(), " but received the type ", foundType.ToString()));
if (expectedLength >= 0)
{
Assert.AreEqual(expectedLength, buffer.Length, string.Concat("Expected a packed length of ", expectedLength.ToString(), " bytes but got ", buffer.Length.ToString(), " bytes."));
}
MsgPackItem recreate = MsgPackItem.Unpack(new MemoryStream(buffer));
resultType = recreate.TypeId;
typesAreEqual = (expectedMsgPackType & resultType) == expectedMsgPackType;
Assert.IsTrue(typesAreEqual, string.Concat("Expected unpacked type of ", expectedMsgPackType, " but received the type ", resultType));
T ret = recreate.GetTypedValue <T>();
// Correct Local / UTC differences before comparing final result
if (ret is DateTime)
{
DateTime idt = (DateTime)(object)value;
DateTime odt = (DateTime)(object)ret;
if (idt.Kind != odt.Kind)
{
if (idt.Kind == DateTimeKind.Utc)
{
ret = (T)(object)odt.ToUniversalTime();
}
else
{
ret = (T)(object)odt.ToLocalTime();
}
}
}
Assert.AreEqual(value, ret, "The returned value ", ret, " differs from the input value ", value);
return(recreate);
}
public void AllSmallTypes(string directory)
{
Dictionary <string, int> simpleMap = new Dictionary <string, int>();
simpleMap.Add("Black", 0);
simpleMap.Add("Brown", 1);
simpleMap.Add("Red", 2);
simpleMap.Add("Orange", 3);
simpleMap.Add("Yellow", 4);
simpleMap.Add("Green", 5);
simpleMap.Add("Blue", 6);
simpleMap.Add("Violet", 7);
simpleMap.Add("Gray", 8);
simpleMap.Add("White", 9);
object[] items = new object[] {
"Null type:",
null,
"Bool types:",
true,
false,
"Float types:",
float.Epsilon,
float.MaxValue,
float.MinValue,
float.NaN,
float.NegativeInfinity,
float.PositiveInfinity,
double.Epsilon,
double.MaxValue,
double.MinValue,
double.NaN,
double.NegativeInfinity,
double.PositiveInfinity,
"Integer types:",
0,
1,
65,
127,
-1,
-15,
-31,
128,
200,
255,
-32,
-100,
-128,
256,
1000,
ushort.MaxValue,
-129,
-1000,
short.MinValue,
ushort.MaxValue + 1,
int.MaxValue,
uint.MaxValue,
short.MinValue - 1,
short.MinValue - 1000,
int.MinValue,
((ulong)uint.MaxValue) + 1,
long.MaxValue,
ulong.MaxValue,
((long)int.MinValue) - 1,
((long)int.MinValue) - 1000,
long.MinValue,
"Map:",
simpleMap,
"Binary bytes blob:",
new byte[] { 1, 2, 3, 4, 5, 6, 7, 8, 9, 0 },
"Extension (type 5)",
new MpExt()
{
Value = new byte[] { 0, 9, 8, 7, 6, 5, 4, 3, 2, 1 },
TypeSpecifier = 5
}
};
File.WriteAllBytes(Path.Combine(directory, "AllSmallTypes.MsgPack"), MsgPackItem.Pack(items, true).ToBytes());
}
public static MsgPackItem RoundTripTest <Typ, T>(T value, int expectedLength, MsgPackTypeId expectedMsgPackType, sbyte extensionType = 0) where Typ : MsgPackItem
{
bool preservingType = !DynamicallyCompactValue;
MsgPackItem item;
if (typeof(Typ) == typeof(MpExt))
{
item = new MpExt()
{
Value = value,
TypeSpecifier = extensionType
};
}
else
{
item = MsgPackItem.Pack(value, new MsgPackSettings()
{
DynamicallyCompact = DynamicallyCompactValue,
PreservePackages = false,
ContinueProcessingOnBreakingError = false
});
}
byte[] buffer = item.ToBytes();
Type expectedType = typeof(Typ);
Type foundType = item.GetType();
MsgPackTypeId resultType = preservingType && item is MpInt ? ((MpInt)item).PreservedType : item.TypeId;
bool typesAreEqual = (expectedMsgPackType & resultType) == expectedMsgPackType;
Assert.IsTrue(typesAreEqual, string.Concat("Expected packed type of ", expectedMsgPackType, " but received the type ", resultType));
Assert.True(foundType == expectedType, string.Concat("Expected type of ", expectedType.ToString(), " but received the type ", foundType.ToString()));
if (expectedLength >= 0)
{
Assert.AreEqual(expectedLength, buffer.Length, string.Concat("Expected a packed length of ", expectedLength.ToString(), " bytes but got ", buffer.Length.ToString(), " bytes."));
}
MsgPackItem recreate = MsgPackItem.Unpack(new MemoryStream(buffer));
MpError err = recreate as MpError;
if (!(err is null))
{
throw new Exception(err.ToString());
}
resultType = preservingType && item is MpInt ? ((MpInt)recreate).PreservedType : recreate.TypeId;
typesAreEqual = (expectedMsgPackType & resultType) == expectedMsgPackType;
Assert.IsTrue(typesAreEqual, string.Concat("Expected unpacked type of ", expectedMsgPackType, " but received the type ", resultType));
T ret = recreate.GetTypedValue <T>();
// Correct Local / UTC differences before comparing final result
if (ret is DateTime)
{
DateTime idt = (DateTime)(object)value;
DateTime odt = (DateTime)(object)ret;
if (idt.Kind != odt.Kind)
{
if (idt.Kind == DateTimeKind.Utc)
{
ret = (T)(object)odt.ToUniversalTime();
}
else
{
ret = (T)(object)odt.ToLocalTime();
}
}
}
Assert.AreEqual(value, ret, "The returned value ", ret, " differs from the input value ", value);
return(recreate);
}