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);
}
}
/// <summary>
/// Deserialization helper to deserialize XML nodes into a "special" collection.
/// </summary>
/// <remarks>
/// A "special" collection is one of the "hidden" collections that implement Synchronized or ReadOnly
/// behavior for the System.Collections collections.
/// </remarks>
/// <param name="_object">The working object to receive the deserialized values</param>
/// <param name="_node">The XmlNode containing the data for the collection</param>
/// <param name="_deserializer">The deserialization framework performing the overall deserialization</param>
/// <returns>TRUE always</returns>
protected bool SpecialDeserialize(CWorkingObject _object, XmlElement _node, CDeserializer _deserializer)
{
if (!ATreatAsInterface.TreatAsInterface(_deserializer))
{
return(false);
}
// First, get an object to deserialize into
var tmp = new CWorkingObject();
if (_object.WorkingObject != null)
{
tmp.Set(_object.WorkingObject);
}
// Deserialize into the temporary WorkingObject
BasicDeserialize(tmp, _node, _deserializer);
// At this point, IF there was an object set in _object prior to this routine, its contents
// should have been set by the standard collection deserialization and we should be done.
if (_object.IsSet)
{
return(true);
}
// Get the collection object populated so far with information from the Xml
var tmpCollection = tmp.GetWorkingObject <TCollectionType>();
// Using that object, create a new, syncronized version of that ArrayList.
var specialCollection = MakeSpecialCollection(tmpCollection);
// Set this sync'ed version to the _object, and we're done
_object.Set(specialCollection);
return(true);
}
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 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 TestConstructor()
{
var other = new CSerializationContext();
var s = new CDeserializer(other);
ReferenceEquals(other, s.Context);
}
public bool Deserialize(CWorkingObject _workingObject,
XmlElement _parentNode,
CDeserializer _deserializer)
{
Count++;
return(false);
}
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 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 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 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 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 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");
}
/// <summary>
/// Add an Xml ChildNode to the collection being deserialized
/// </summary>
/// <param name="_collection">The collection that's being deserialized</param>
/// <param name="_xmlElement">The XmlElement containing the data for this element</param>
/// <param name="_expectedTypes">The expected Type(s) for this element</param>
/// <param name="_deserializer">The deserialization framework controlling this process</param>
protected override void AddElementFromXml(object _collection,
XmlElement _xmlElement,
Type[] _expectedTypes,
CDeserializer _deserializer)
{
var keyElem = _xmlElement[KEY_ELEMENT_NAME];
if (keyElem == null)
{
throw new XDeserializationError("Could not find the KEY element for the Dictionary<,> entry.");
}
var valueElem = _xmlElement[VALUE_ELEMENT_NAME];
if (valueElem == null)
{
throw new XDeserializationError("Could not find the VALUE element for the Dictionary<,> entry.");
}
var key = _deserializer.FrameworkDeserialize(keyElem, _expectedTypes[0]);
var value = _deserializer.FrameworkDeserialize(valueElem, _expectedTypes[1]);
var collection = (IDictionary)_collection;
collection.Add(key, value);
}
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 TestConstructorNull()
{
var s = new CDeserializer(null);
Assert.AreEqual(CSerializationContext.Global,
s.Context,
"Null constructor parameter should point to Global context");
}
public void TestDeserializeNoType()
{
var s = new CDeserializer();
var doc = new XmlDocument();
doc.LoadXml("<root>45</root>");
s.Deserialize(doc);
}
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);
}
private static bool CreateFromXml(XmlElement _node, CWorkingObject _object, CDeserializer _framework)
{
var x = _object.GetExistingOrCreateNew <CStdImplicitSurrogate>();
x.Name = XmlExtensions.GetAttributeValue(_node, "NAME");
x.Age = int.Parse(XmlExtensions.GetAttributeValue(_node, "AGE"));
STATUS = ETestStatus.IMPLICIT_DESERIALIZER;
return(true);
}
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");
}
/// <summary>
/// Add a single XmlElement to a collection, where that XmlElement is a child of the parent Collection element.
/// </summary>
/// <param name="_collection"></param>
/// <param name="_xmlData"></param>
/// <param name="_expectedTypes"></param>
/// <param name="_deserializer"></param>
protected override void AddElementFromXml(object _collection,
XmlElement _xmlData,
Type[] _expectedTypes,
CDeserializer _deserializer)
{
var o = _deserializer.FrameworkDeserialize(_xmlData, _expectedTypes[0]);
var collection = (IList)_collection;
collection.Add(o);
}
private static void CreateFromXml(XmlElement _node, CWorkingObject _object, CDeserializer _framework)
{
var x = new CVoidImplicitSurrogate();
_object.Set(x);
x.Name = XmlExtensions.GetAttributeValue(_node, "NAME");
x.Age = int.Parse(XmlExtensions.GetAttributeValue(_node, "AGE"));
STATUS = ETestStatus.IMPLICIT_DESERIALIZER_VOID;
}
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 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 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 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");
}
/// <summary>
/// Add a single XmlElement to a collection, where that XmlElement is a child of the
/// parent Collection element.
/// </summary>
/// <param name="_collection"></param>
/// <param name="_xmlData"></param>
/// <param name="_expectedTypes"></param>
/// <param name="_deserializer"></param>
protected override void AddElementFromXml(object _collection,
XmlElement _xmlData,
Type[] _expectedTypes,
CDeserializer _deserializer)
{
var o = _deserializer.FrameworkDeserialize(_xmlData, _expectedTypes[0]);
var ct = _collection.GetType();
var mi = ct.GetMethod("Add", _expectedTypes);
mi.Invoke(_collection, new object[] { o });
}
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");
}