public void TestArraySurrogate()
{
var x = new int[] { 1, 3, 5, 7, 9 };
var c = new CSerializationContext();
c.SetConcise();
var helper = new CIntArraySurrogate();
c.RegisterExternalSurrogate(typeof(int[]), helper);
var s = new CSerializer(c);
var doc = s.Serialize(x);
Console.WriteLine("Depth of resulting XML: " + XmlExtensions.Depth(doc));
Console.WriteLine("Length of resulting XML String: " + doc.OuterXml.Length);
Console.WriteLine("Number of resulting XmlElements: " + XmlExtensions.ElementCount(doc));
Print(doc);
var d = new CDeserializer(c);
var y = (int[])d.Deserialize(doc);
Assert.AreEqual(x.Length, y.Length - 1, "Length of resulting array is wrong");
for (var i = 0; i < x.Length; i++)
{
Assert.AreEqual(x[i], y[i], "Invalid element at: " + i);
}
}
public void TestGenericDerived()
{
var src = new CPersonWithObject <CAddress>()
{
SomeObject = new CAddress()
{
m_city = "Spring",
m_street = "Halifax",
m_zip = 37174
}
};
var s = new CSerializer();
var xml = s.Serialize(src);
Print(xml);
var d = new CDeserializer();
var dest = d.Deserialize(xml) as CPersonWithObject <CAddress>;
Assert.AreEqual(src.m_name, dest.m_name, "Name");
Assert.AreEqual(src.SomeObject.m_street, dest.SomeObject.m_street, "Generic Street");
Assert.AreEqual(src.m_address.m_zip, dest.m_address.m_zip, "Zip");
Assert.AreNotEqual(src.SomeObject, dest.SomeObject);
}
public void TestExternalSurrogate()
{
CBigPerson.GenerateData(100);
var c = new CSerializationContext();
c.SetConcise();
var helper = new CFriendSerializer();
c.RegisterExternalSurrogate(typeof(CFriend), helper);
var s = new CSerializer(c);
var doc = s.Serialize(CBigPerson.People);
Console.WriteLine("Depth of resulting XML: " + XmlExtensions.Depth(doc));
Console.WriteLine("Length of resulting XML String: " + doc.OuterXml.Length);
Console.WriteLine("Number of resulting XmlElements: " + XmlExtensions.ElementCount(doc));
Print(doc);
var d = new CDeserializer(c);
var x2 = d.Deserialize <CBigPerson[]>(doc);
helper.FinishDeserializing(x2);
CDeserializeTest.AssertEqualBigPeopleArray(CBigPerson.People, x2);
}
public void TestFieldRenamer()
{
var c = new CSerializationContext
{
FieldRenamer = new CFieldRenamer()
};
var s = new CSerializer(c);
var add = new CAddress();
var doc = s.Serialize(add);
Print(doc);
var root = doc.DocumentElement;
TestSingleRenamedField(add.m_zip, root["INT_Zip"]);
TestSingleRenamedField(add.m_city, root["STRING_City"]);
TestSingleRenamedField(add.m_street, root["STRING_Street"]);
var d = new CDeserializer(c);
var ad2 = d.Deserialize <CAddress>(doc);
Assert.AreEqual(add.m_city, ad2.m_city, "City");
Assert.AreEqual(add.m_street, ad2.m_street, "Street");
Assert.AreEqual(add.m_zip, ad2.m_zip, "Zip");
}
public void TestList()
{
var names = new List <string>
{
"Homer",
"Marge",
"Bart",
"Lisa",
"Maggie"
};
var c = new CSerializationContext();
c.SetVerbose();
var s = new CSerializer(c);
var doc = s.Serialize(names);
Print(doc);
var d = new CDeserializer(c);
var names2 = d.Deserialize <List <string> >(doc);
Assert.AreEqual(names.Count, names2.Count, "The number of list elements is wrong");
for (var i = 0; i < names.Count; i++)
{
Assert.AreEqual(names[i], names2[i], "The name is wrong at index " + i);
}
}
public void TestLinkedList()
{
var list = new LinkedList <int>();
for (var i = 1; i < 1000000; i = (int)((i + 1) * 1.5))
{
list.AddLast(i);
}
var s = new CSerializer();
var doc = s.Serialize(list);
Print(doc);
var d = new CDeserializer();
var list2 = d.Deserialize(doc) as LinkedList <int>;
Assert.AreEqual(list.Count, list2.Count, "Number of resulting elements is wrong.");
var ptr = list2.First;
foreach (var x in list)
{
Assert.AreEqual(x, ptr.Value, "The deserialized value is wrong for initial value: " + x);
ptr = ptr.Next;
}
}
public void TestSortedDictionary()
{
var names = GenerateRandomNames();
var dict = new SortedDictionary <string, CAddress>();
for (var i = 0; i < 26; i++)
{
dict[names[i]] = CAddress.Get();
}
var s = new CSerializer();
var doc = s.Serialize(dict);
Print(doc);
var d = new CDeserializer();
var d2 = (SortedDictionary <string, CAddress>)d.Deserialize(doc);
Assert.AreEqual(dict.Count, d2.Count, "Size of resulting dictionary is wrong");
Assert.AreEqual(dict.Count, doc.DocumentElement.ChildNodes.Count, "The number of XmlNodes for the collection is wrong");
foreach (var key in dict.Keys)
{
CompareCAddresses(dict[key], d2[key]);
}
}
public void TestDictionary()
{
var x = new Dictionary <int, string>
{
[4] = "hello",
[55] = "Katie",
[15834] = "=)",
[324] = "Homer",
[-87] = "Simpson"
};
var c = new CSerializationContext();
c.SetConcise();
var s = new CSerializer(c);
var doc = s.Serialize(x);
Print(doc);
var d = new CDeserializer(c);
var y = (Dictionary <int, string>)d.Deserialize(doc);
Assert.AreEqual(x.Count, y.Count, "Size of resulting hashtable is wrong");
foreach (var key in x.Keys)
{
Assert.AreEqual(x[key], y[key], "Entry at key " + key + " was wrong.");
}
}
public void TestStack()
{
var q = new Stack <CAddress>();
for (var i = 1; i < 11; i++)
{
q.Push(CAddress.Get());
}
var s = new CSerializer();
var doc = s.Serialize(q);
Print(doc);
var d = new CDeserializer();
var q2 = (Stack <CAddress>)d.Deserialize(doc);
Assert.AreEqual(q.Count, q2.Count, "Number of resulting elements is wrong.");
Assert.AreEqual(q.Count,
doc.DocumentElement.ChildNodes.Count,
"The number of child nodes does not equal the number of elements in the Collection.");
while (q.Count > 0)
{
var a1 = q.Pop();
var a2 = q2.Pop();
CompareCAddresses(a1, a2);
}
}
public void TestStringCounter()
{
var x = new CTypeCounter();
var c = new CSerializationContext();
c.SetConcise();
c.RegisterExternalSurrogate(typeof(string), x);
var s = new CSerializer(c);
var doc = s.Serialize(x);
Assert.AreEqual(3, x.Count, "There should have been 3 strings counted.");
Console.WriteLine("Depth of resulting XML: " + XmlExtensions.Depth(doc));
Console.WriteLine("Length of resulting XML String: " + doc.OuterXml.Length);
Console.WriteLine("Number of resulting XmlElements: " + XmlExtensions.ElementCount(doc));
Print(doc);
var d = new CDeserializer(c);
var y = d.Deserialize <CTypeCounter>(doc);
Assert.AreEqual(0, y.Count, "The new object should have no counted strings");
Assert.AreEqual(6, x.Count, "The initial object should have strings counted for 2 actions");
}
public void TestAllArrayLists()
{
CClassWithArrayLists ca = new CClassWithArrayLists();
ca.SimpleArrayList = MakeSampleArrayList();
ca.ReadOnlyArrayList = ArrayList.ReadOnly(ca.SimpleArrayList);
// This is really bad because we shouldn't really hold the ref to the "old" object
// after its been wrapped
ca.SyncArrayList = ArrayList.Synchronized(ca.SimpleArrayList);
// This is really bad because we shouldn't really hold the ref to the "old" object
// after its been wrapped
Assert.AreNotEqual(ca.SimpleArrayList.GetType(),
ca.ReadOnlyArrayList.GetType(),
"The Type of the ArrayList is the SAME as the ReadOnly ArrayList.");
Assert.AreNotEqual(ca.SimpleArrayList.GetType(),
ca.SyncArrayList.GetType(),
"The Type of the ArrayList is the SAME as the SyncArrayList.");
Assert.AreNotEqual(ca.SyncArrayList.GetType(),
ca.ReadOnlyArrayList.GetType(),
"The Type of the SyncArrayList is the SAME as the ReadOnly ArrayList.");
Console.WriteLine(ca.SimpleArrayList.GetType().AssemblyQualifiedName);
Console.WriteLine(ca.ReadOnlyArrayList.GetType().AssemblyQualifiedName);
Console.WriteLine(ca.SyncArrayList.GetType().AssemblyQualifiedName);
CSerializationContext.Global.UseFullUtcDateTimeStrings = true;
CSerializer s = new CSerializer();
XmlDocument doc = s.Serialize(ca);
Print(doc);
CDeserializer d = new CDeserializer();
CClassWithArrayLists ca2 = d.Deserialize <CClassWithArrayLists>(doc);
Assert.AreEqual(ca.SimpleArrayList.GetType(),
ca2.SimpleArrayList.GetType(),
"The Type of the resulting ArrayList is different.");
Assert.AreEqual(ca.ReadOnlyArrayList.GetType(),
ca2.ReadOnlyArrayList.GetType(),
"The Type of the ReadOnly array is different");
Assert.AreEqual(ca.SyncArrayList.GetType(),
ca2.SyncArrayList.GetType(),
"The Type of the Sync array is different");
Assert.AreNotEqual(ca2.SimpleArrayList.GetType(),
ca2.ReadOnlyArrayList.GetType(),
"The Type of the ArrayList is the SAME as the ReadOnly ArrayList.");
Assert.AreNotEqual(ca2.SimpleArrayList.GetType(),
ca2.SyncArrayList.GetType(),
"The Type of the ArrayList is the SAME as the SyncArrayList.");
Assert.AreNotEqual(ca2.SyncArrayList.GetType(),
ca2.ReadOnlyArrayList.GetType(),
"The Type of the SyncArrayList is the SAME as the ReadOnly ArrayList.");
VerifyArrayListContents(ca.SimpleArrayList, ca2.SimpleArrayList);
VerifyArrayListContents(ca.ReadOnlyArrayList, ca2.ReadOnlyArrayList);
VerifyArrayListContents(ca.SyncArrayList, ca2.SyncArrayList);
}
public void TestNullDeserialize()
{
var s = new CDeserializer();
var doc = new XmlDocument();
var o = s.Deserialize(doc);
Assert.IsNull(o, "An XmlDocument with nothing in it should return nothing");
}
public void TestCondensedArrayWithNonPrimitive()
{
var s = new CDeserializer();
var doc = new XmlDocument();
doc.LoadXml("<root _T='Morpheus.Standard.UnitTests.Serialization.CPerson[]'>1,2,3,4,5</root>");
var x = (CPerson[])s.Deserialize(doc);
}
public void TestDeserializeNoType()
{
var s = new CDeserializer();
var doc = new XmlDocument();
doc.LoadXml("<root>45</root>");
s.Deserialize(doc);
}
public void TestNullableValue()
{
int? x, y;
var s = new CSerializer();
var d = new CDeserializer();
XmlDocument doc;
x = 5;
doc = s.Serialize(x);
Print(doc);
y = d.Deserialize <int?>(doc);
Console.WriteLine("Deserialized: {0}", (y == null) ? "<null>" : y.ToString());
x = null;
doc = s.Serialize(x);
Print(doc);
y = d.Deserialize <int?>(doc);
Console.WriteLine("Deserialized: {0}", (y == null) ? "<null>" : y.ToString());
}
public void TestHandwrittenList()
{
var xml =
@"
<_>
<Name>Homer</Name>
<Addresses>
<_><Street>Schroeder Way</Street><City>Sparks</City><Zip>89431</Zip></_>
<_><Street>Shadow Lane</Street><City>Sparks</City><Zip>89434</Zip></_>
<_><Street>Lynnfield Court</Street><City>Reno</City><Zip>89509</Zip></_>
<_ type='Morpheus.Standard.UnitTests.Serialization.CSuperAddress'><Country>Australia</Country><Street>Coast Ave</Street><City>Cronulla</City><Zip>2020</Zip></_>
<_><Street>Plateau Road</Street><City>Reno</City><Zip>89519</Zip></_>
</Addresses>
</_>";
var doc = new XmlDocument();
doc.LoadXml(xml);
Print(doc);
var c = new CSerializationContext
{
TypeAttributeName = "type",
FixM_ = true,
ArrayElementName = "_"
};
var d = new CDeserializer(c);
var cwl = d.Deserialize <CClassWithIList>(doc);
Assert.AreEqual("Homer", cwl.Name, "Name is wrong");
Assert.AreEqual(5, cwl.Addresses.Count, "Number of addresses is wrong");
Assert.AreEqual("Schroeder Way", cwl.Addresses[0].m_street, "[0]- Street");
Assert.AreEqual("Sparks", cwl.Addresses[0].m_city, "[0]- City");
Assert.AreEqual(89431, cwl.Addresses[0].m_zip, "[0]- Zip");
Assert.AreEqual("Shadow Lane", cwl.Addresses[1].m_street, "[1]- Street");
Assert.AreEqual("Sparks", cwl.Addresses[1].m_city, "[1]- City");
Assert.AreEqual(89434, cwl.Addresses[1].m_zip, "[1]- Zip");
Assert.AreEqual("Lynnfield Court", cwl.Addresses[2].m_street, "[2]- Street");
Assert.AreEqual("Reno", cwl.Addresses[2].m_city, "[2]- City");
Assert.AreEqual(89509, cwl.Addresses[2].m_zip, "[2]- Zip");
Assert.AreEqual("Coast Ave", cwl.Addresses[3].m_street, "[3]- Street");
Assert.AreEqual("Cronulla", cwl.Addresses[3].m_city, "[3]- City");
Assert.AreEqual(2020, cwl.Addresses[3].m_zip, "[3]- Zip");
var sa = (CSuperAddress)cwl.Addresses[3];
Assert.AreEqual("Australia", sa.m_country, "[3]- Country");
Assert.AreEqual("Plateau Road", cwl.Addresses[4].m_street, "[4]- Street");
Assert.AreEqual("Reno", cwl.Addresses[4].m_city, "[4]- City");
Assert.AreEqual(89519, cwl.Addresses[4].m_zip, "[4]- Zip");
}
public void TestGenericDeserialize()
{
var s = new CDeserializer();
var doc = new XmlDocument();
doc.LoadXml("<root>45</root>");
var x = s.Deserialize <int>(doc);
Assert.AreEqual(45, x, "Deserialization failed for GenericFunction call");
}
public void TestDeserializeNullAttribute()
{
var s = new CDeserializer();
var doc = new XmlDocument();
doc.LoadXml("<root _T='System.String' _N='1'>45</root>");
var o = s.Deserialize(doc);
Assert.IsNull(o, "The returned object should be null!");
}
public void TestInvalidTypeDeserialization()
{
var s = new CDeserializer();
var doc = new XmlDocument();
doc.LoadXml("<root _T='System.IntPtr'>0</root>");
var x = s.Deserialize(doc);
Assert.IsNull(x, "Invalid type should deserialize to null");
}
public void TestNullableValueError()
{
int?x = null;
var s = new CSerializer();
var doc = s.Serialize(x);
Print(doc);
var d = new CDeserializer();
var y = (int)d.Deserialize(doc); // should throw the error
}
public void TestImplicitSurrogate()
{
var s = new CDeserializer();
var doc = new XmlDocument();
doc.LoadXml("<root _T='Morpheus.Standard.UnitTests.Serialization.CStdImplicitSurrogate' NAME='Michael' AGE='22'/>");
var x = s.Deserialize <CStdBaseObject>(doc);
Assert.AreEqual("Michael", x.Name, "Name is wrong");
Assert.AreEqual(22, x.Age, "Age is wrong");
}
public void TestDeserializePrimitive()
{
var s = new CDeserializer();
var doc = new XmlDocument();
doc.LoadXml("<root _T='System.Int32'>45</root>");
var o = s.Deserialize(doc);
Assert.AreEqual(typeof(int), o.GetType(), "The type of the object returned is wrong");
Assert.AreEqual(45, (int)o, "The value of the object is wrong");
}
public void TestDeserializeString()
{
var s = new CDeserializer();
var doc = new XmlDocument();
doc.LoadXml("<root _T='System.String'>45</root>");
var o = s.Deserialize(doc);
Assert.AreEqual(typeof(string), o.GetType(), "The type of the object returned is wrong");
Assert.AreEqual("45", o.ToString(), "The value of the object is wrong");
}
public void TestCondensedPrimitiveArray()
{
var s = new CDeserializer();
var doc = new XmlDocument();
doc.LoadXml("<root _T='System.Int32[]'>1,2,3,4,5</root>");
var x = (int[])s.Deserialize(doc);
Assert.AreEqual(5, x.Length, "Length of resulting array is wrong");
for (var i = 0; i < x.Length; i++)
{
Assert.AreEqual(i + 1, x[i], "Element " + i + " is wrong");
}
}
public void TestCondensedStringArray()
{
var s = new CDeserializer();
var doc = new XmlDocument();
doc.LoadXml(@"<root _T='System.String[]'>Hello,,to,\_,all</root>");
var x = (string[])s.Deserialize(doc);
Assert.AreEqual(5, x.Length, "Length of resulting array is wrong");
Assert.AreEqual("Hello", x[0], "0");
Assert.AreEqual(null, x[1], "1");
Assert.AreEqual("to", x[2], "2");
Assert.AreEqual("", x[3], "3");
Assert.AreEqual("all", x[4], "4");
}
public void TestExternalSurrogate()
{
var c = new CSerializationContext();
c.RegisterExternalSurrogate(typeof(CStdBaseObject), new CStdExternalSurrogate());
var s = new CDeserializer(c);
var doc = new XmlDocument();
doc.LoadXml("<root NAME='Mike' AGE='11'/>");
var x = s.Deserialize <CStdBaseObject>(doc);
Assert.AreEqual("Mike", x.Name, "Name is wrong");
Assert.AreEqual(11, x.Age, "Age is wrong");
}
public void TestStandardDeserialization()
{
var s = new CDeserializer();
var doc = new XmlDocument();
doc.LoadXml(
"<Babe> " +
" <Name>Alyssa</Name> " +
" <Age>24</Age> " +
" <Sex>Lots</Sex> " +
"</Babe> ");
var x = s.Deserialize <CMySuperStd>(doc);
Assert.AreEqual("Alyssa", x.Name, "Name is wrong");
Assert.AreEqual(24, x.Age, "Age is wrong");
Assert.AreEqual("Lots", x.Sex, "Sex is wrong");
}
public void TestStandardDeserializationBaseSurrogate()
{
var c = new CSerializationContext();
c.RegisterExternalSurrogate(typeof(CStdBaseObject), new CStdExternalSurrogate());
var s = new CDeserializer(c);
var doc = new XmlDocument();
doc.LoadXml(
"<Babe NAME='Alyssa' AGE='24'> " +
" <Sex>Lots</Sex> " +
"</Babe> ");
var x = s.Deserialize <CMySuperStd>(doc);
Assert.AreEqual("Alyssa", x.Name, "Name is wrong");
Assert.AreEqual(24, x.Age, "Age is wrong");
Assert.AreEqual("Lots", x.Sex, "Sex is wrong");
}
public void TestBigPerson()
{
var src = new CBigPerson()
{
Role = CBigPerson.ERole.Parent
};
var ser = new CSerializer();
var doc = ser.Serialize(src);
var deser = new CDeserializer();
var dest = deser.Deserialize <CBigPerson>(doc);
Assert.AreEqual(src.Name, dest.Name, "Name");
Assert.AreEqual(src.Height, dest.Height, "Height");
Assert.AreEqual(src.IsParent, dest.IsParent, "IsParent");
Assert.AreEqual(src.Role, dest.Role, "Role");
}
public void TestCircularRef()
{
var s = new CDeserializer();
var doc = new XmlDocument();
doc.LoadXml(
"<root _ID='1'> " +
" <Data>44</Data> " +
" <Next> " +
" <Data>55</Data> " +
" <Next _RID='1'/> " +
" </Next> " +
"</root> ");
var x = s.Deserialize <CLinkedList>(doc);
Assert.AreEqual(44, x.Data, "Head node Data is wrong");
Assert.AreEqual(55, x.Next.Data, "Head->Next node Data is wrong");
ReferenceEquals(x, x.Next.Next);
}
