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 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 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 TestClearingFlags()
{
var c1 = new CSerializationContext
{
FixM_ = true,
RemoveNullValuesFromXml = true
};
var c2 = new CSerializationContext(c1)
{
FixM_ = false
};
Assert.AreEqual(false, CSerializationContext.Global.FixM_, "Global FixM");
Assert.AreEqual(false, CSerializationContext.Global.RemoveNullValuesFromXml, "Global Remove Nulls");
Assert.AreEqual(true, c1.FixM_, "C1 FixM");
Assert.AreEqual(true, c1.RemoveNullValuesFromXml, "C1 Remove Nulls");
Assert.AreEqual(false, c2.FixM_, "C2 FixM");
Assert.AreEqual(true, c2.RemoveNullValuesFromXml, "C2 Remove Nulls");
c2.ClearFlag(CSerializationContext.EContextFields.FIX_M_);
Assert.AreEqual(true, c2.FixM_, "PassThrough of Global's FixM");
CSerializationContext.Global.FixM_ = true;
CSerializationContext.Global.ClearFlag(CSerializationContext.EContextFields.FIX_M_);
Assert.AreEqual(true, CSerializationContext.Global.FixM_, "Global FixM after clear");
}
public void TestConstructor()
{
var other = new CSerializationContext();
var s = new CSerializer(other);
ReferenceEquals(other, s.Context);
}
public void TestExternalSurrogate()
{
var x = new CStdBaseObject
{
Name = "Alyssa",
Age = 21
};
var c = new CSerializationContext();
var s = new CSerializer(c);
var doc = s.Serialize(x);
Print(doc);
var elem = doc.DocumentElement;
Assert.AreEqual(2, elem.ChildNodes.Count, "Child Node Count is wrong");
Assert.AreEqual(x.Name, XmlExtensions.GetElementValue(elem, "Name"), "Name");
Assert.AreEqual(x.Age.ToString(), XmlExtensions.GetElementValue(elem, "Age"), "Age");
Console.WriteLine(
"\r\n\r\n-----------------------------------------------------------------------------\r\n\r\n");
c.RegisterExternalSurrogate(typeof(CStdBaseObject), new CStdExternalSurrogate());
doc = s.Serialize(x);
Print(doc);
elem = doc.DocumentElement;
Assert.AreEqual(0, elem.ChildNodes.Count, "Child Node Count is wrong");
Assert.AreEqual(x.Name, XmlExtensions.GetAttributeValue(elem, "NAME"), "Name");
Assert.AreEqual(x.Age.ToString(), XmlExtensions.GetAttributeValue(elem, "AGE"), "Age");
}
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 TestSpecificParent_Constructor()
{
var c1 = new CSerializationContext
{
ArrayElementsIncludeIndicies = true
};
Assert.AreEqual(false,
CSerializationContext.Global.ArrayElementsIncludeIndicies,
"The Global should still be false");
Assert.AreEqual(true, c1.ArrayElementsIncludeIndicies, "The instance should be TRUE");
var c2 = new CSerializationContext(c1);
Assert.AreEqual(true,
c2.ArrayElementsIncludeIndicies,
"Even though the instance default is false, the inherited context should be TRUE like its parent.");
Assert.AreEqual(false,
CSerializationContext.Global.ArrayElementsIncludeIndicies,
"The Global should still be false");
c2.ArrayElementsIncludeIndicies = false;
Assert.AreEqual(false, c2.ArrayElementsIncludeIndicies, "The instance should override the parent");
Assert.AreEqual(true, c1.ArrayElementsIncludeIndicies, "The parent should still be true");
Assert.AreEqual(false,
CSerializationContext.Global.ArrayElementsIncludeIndicies,
"The Global should still be false");
}
public void TestMultidimStringArray()
{
string[,] x;
x = (string[, ])Array.CreateInstance(typeof(string), new int[] { 2, 2 }, new int[] { 5, 9 });
x[5, 9] = "first";
x[5, 10] = "second";
x[6, 9] = "third";
x[6, 10] = "fourth";
var c = new CSerializationContext();
c.SetConcise();
var s = new CSerializer(c);
var doc = s.Serialize(x);
Print(doc);
var elem = doc.DocumentElement;
Assert.AreEqual(1, elem.ChildNodes.Count, "Should be one child (an XmlText node)");
Assert.AreEqual("2,2",
XmlExtensions.GetAttributeValue(elem, c.ArrayAttributeName),
"Array Lengths are wrong");
Assert.AreEqual("5,9",
XmlExtensions.GetAttributeValue(elem, c.ArrayLowerBoundAttribute),
"Array Lowerbounds are wrong");
Assert.AreEqual("first,second,third,fourth", elem.InnerText, "The text for the multidim array is wrong");
}
public void TestExternalSurrogates()
{
var c = new CSerializationContext();
var type1 = typeof(CSerializationContextTest);
// its unimportant WHAT type to use- the surrogate is never called anyway
var type2 = typeof(CMyFieldRenamer);
Assert.IsNull(CSerializationContext.Global.GetExternalSurrogate(type1));
Assert.IsNull(c.GetExternalSurrogate(type1));
IExternalSurrogate surrogate = new CMyExternalSurrogate();
CSerializationContext.Global.RegisterExternalSurrogate(type1, surrogate);
Assert.AreEqual(surrogate, CSerializationContext.Global.GetExternalSurrogate(type1), "message");
Assert.AreEqual(surrogate, c.GetExternalSurrogate(type1), "message");
c.RegisterExternalSurrogate(type2, surrogate);
Assert.IsNull(CSerializationContext.Global.GetExternalSurrogate(type2));
Assert.AreEqual(surrogate, c.GetExternalSurrogate(type2), "message");
CSerializationContext.Global.RemoveExternalSurrogate(type1);
Assert.IsNull(CSerializationContext.Global.GetExternalSurrogate(type1));
Assert.IsNull(c.GetExternalSurrogate(type1));
}
public void TestDuplicateReferences()
{
var arr = new object[10];
var p = new CPerson();
var p2 = new CPerson();
arr[1] = p;
arr[2] = p2;
arr[5] = p2;
arr[8] = p;
arr[9] = p;
object x = arr;
var c = new CSerializationContext();
c.SetConcise();
c.FixM_ = true;
c.ArrayElementsIncludeIndicies = true;
var s = new CSerializer(c);
var doc = s.Serialize(x);
Print(doc);
var elem = doc.DocumentElement;
AssureCorrectReference(elem, 1, 8);
AssureCorrectReference(elem, 1, 9);
AssureCorrectReference(elem, 2, 5);
}
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 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 TestExternalBaseSurrogate()
{
var x = new CMySuperStd
{
Name = "Alyssa",
Age = 21,
Sex = "Yes"
};
var c = new CSerializationContext();
var s = new CSerializer(c);
var doc = s.Serialize(x);
Print(doc);
var elem = doc.DocumentElement;
Assert.AreEqual(3, elem.ChildNodes.Count, "Child Node Count is wrong");
Assert.AreEqual(x.Name, XmlExtensions.GetElementValue(elem, "Name"), "Name");
Assert.AreEqual(x.Age.ToString(), XmlExtensions.GetElementValue(elem, "Age"), "Age");
Assert.AreEqual(x.Sex, XmlExtensions.GetElementValue(elem, "Sex"), "Sex");
PrintLine();
c.RegisterExternalSurrogate(typeof(CStdBaseObject), new CStdExternalSurrogate());
doc = s.Serialize(x);
Print(doc);
elem = doc.DocumentElement;
Assert.AreEqual(1, elem.ChildNodes.Count, "Child Node Count is wrong");
Assert.AreEqual(x.Name, XmlExtensions.GetAttributeValue(elem, "NAME"), "Name");
Assert.AreEqual(x.Age.ToString(), XmlExtensions.GetAttributeValue(elem, "AGE"), "Age");
Assert.AreEqual(x.Sex, XmlExtensions.GetElementValue(elem, "Sex"), "Sex");
}
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 TestUtcStringProperty()
{
// The default global property is FALSE for UTC strings.
Assert.IsFalse(CSerializationContext.Global.UseFullUtcDateTimeStrings,
"The default global value of UtcStrings is FALSE.");
var c = new CSerializationContext();
Assert.IsFalse(c.UseFullUtcDateTimeStrings,
"Inheriting from the default global context should not use UtcStrings");
CSerializationContext.Global.UseFullUtcDateTimeStrings = true;
Assert.IsTrue(CSerializationContext.Global.UseFullUtcDateTimeStrings,
"The After setting the global context to Use Utc Strings, the prop should be TRUE.");
Assert.IsTrue(c.UseFullUtcDateTimeStrings,
"Because the global context changed, the dependant context should also change.");
c.UseFullUtcDateTimeStrings = false;
Assert.IsFalse(c.UseFullUtcDateTimeStrings,
"Setting the dependant context to FALSE should be reflected in the prop-Getter");
Assert.IsTrue(CSerializationContext.Global.UseFullUtcDateTimeStrings,
"Changing the Dependant context should not modify the Global context.");
c.UseFullUtcDateTimeStrings = true; // This explicitly means that the dependant context should use strings.
Assert.IsTrue(c.UseFullUtcDateTimeStrings,
"Setting the dependant context to TRUE should be reflected in the prop-Getter");
CSerializationContext.Global.UseFullUtcDateTimeStrings = false;
Assert.IsFalse(CSerializationContext.Global.UseFullUtcDateTimeStrings,
"Make sure that the GLOBAL property is set to FALSE");
Assert.IsTrue(c.UseFullUtcDateTimeStrings,
"Make sure that the dependant context's override survives the modification of the Global value");
var d = new DateTime(2000, 7, 5, 1, 2, 3);
var expected = d.ToString(CUtcDateTimeSurrogate.UTC_COMPLETE_DATE_TIME_FORMAT);
var sur = new CUtcDateTimeSurrogate();
var doc = new XmlDocument();
doc.LoadXml("<root />");
var retval = sur.Serialize(d, d.GetType(), doc.DocumentElement, null);
Assert.AreEqual(expected,
doc.DocumentElement.InnerText,
"The UTC serialization didn't yield the correct string.");
Assert.IsTrue(retval, "The surrogate should always indicate that it completely processed the object");
var w = new CWorkingObject();
retval = sur.Deserialize(w, doc.DocumentElement, null);
Assert.AreEqual(d, w.WorkingObject, "The deserialized DateTime is incorrect.");
Assert.IsTrue(retval, "The surrogate should always indicate that it completely processed the object");
}
public void TestNameProperties()
{
var c = new CSerializationContext();
Assert.AreEqual(CSerializationContext.Global.ArrayAttributeName, c.ArrayAttributeName, "ArrayAttributeName");
c.ArrayAttributeName = "1";
Assert.AreEqual("1", c.ArrayAttributeName, "New ArrayAttributeName");
Assert.AreEqual(CSerializationContext.Global.ArrayElementName, c.ArrayElementName, "ArrayElementName");
c.ArrayElementName = "2";
Assert.AreEqual("2", c.ArrayElementName, "New ArrayElementName");
Assert.AreEqual(CSerializationContext.Global.ArrayLowerBoundAttribute,
c.ArrayLowerBoundAttribute,
"ArrayLowerBoundAttribute");
c.ArrayLowerBoundAttribute = "3";
Assert.AreEqual("3", c.ArrayLowerBoundAttribute, "New ArrayLowerBoundAttribute");
Assert.AreEqual(CSerializationContext.Global.NullAttributeName, c.NullAttributeName, "NullAttributeName");
c.NullAttributeName = "4";
Assert.AreEqual("4", c.NullAttributeName, "New NullAttributeName");
Assert.AreEqual(CSerializationContext.Global.NullAttributeValue, c.NullAttributeValue, "NullAttributeValue");
c.NullAttributeValue = "5";
Assert.AreEqual("5", c.NullAttributeValue, "New NullAttributeValue");
Assert.AreEqual(CSerializationContext.Global.RootElementName, c.RootElementName, "RootElementName");
c.RootElementName = "6";
Assert.AreEqual("6", c.RootElementName, "New RootElementName");
Assert.AreEqual(CSerializationContext.Global.TypeAttributeName, c.TypeAttributeName, "TypeAttributeName");
c.TypeAttributeName = "7";
Assert.AreEqual("7", c.TypeAttributeName, "New TypeAttributeName");
Assert.AreEqual(CSerializationContext.Global.ArrayIndexAttributeName,
c.ArrayIndexAttributeName,
"ArrayIndexAttributeName");
c.ArrayIndexAttributeName = "8";
Assert.AreEqual("8", c.ArrayIndexAttributeName, "New ArrayIndexAttributeName");
Assert.AreEqual(CSerializationContext.Global.ReferenceIdAttributeName,
c.ReferenceIdAttributeName,
"ReferenceIdAttributeName");
c.ReferenceIdAttributeName = "9";
Assert.AreEqual("9", c.ReferenceIdAttributeName, "New ReferenceIdAttributeName");
Assert.AreEqual(CSerializationContext.Global.ReferToAttributeName,
c.ReferToAttributeName,
"ReferToAttributeName");
c.ReferToAttributeName = "A";
Assert.AreEqual("A", c.ReferToAttributeName, "New ReferToAttributeName");
}
public void TestCPersonExplicitArrays()
{
var x = new CPerson();
var c = new CSerializationContext
{
FixM_ = true,
AllArraysHaveExplicitElements = true,
ArrayElementsIncludeIndicies = true
};
var s = new CSerializer(c);
var doc = s.Serialize(x);
Print(doc);
var elem = doc.DocumentElement;
Assert.AreEqual(x.m_name, XmlExtensions.GetElementValue(elem, "Name"), "Name");
Assert.AreEqual(x.m_age.ToString(), XmlExtensions.GetElementValue(elem, "Age"), "Age");
var e = (XmlElement)elem.SelectSingleNode("KidsNames");
Assert.IsNotNull(e, "Missing KidsNames element");
Assert.AreEqual("3", XmlExtensions.GetAttributeValue(e, s.Context.ArrayAttributeName), "Kids Array Count");
for (var i = 0; i < x.m_kidsNames.Length; i++)
{
Assert.AreEqual(x.m_kidsNames[i], e.ChildNodes[i].InnerText, "Kid " + i);
Assert.AreEqual(i.ToString(),
XmlExtensions.GetAttributeValue(e.ChildNodes[i], s.Context.ArrayIndexAttributeName),
"Array Index " + i);
}
e = (XmlElement)elem.SelectSingleNode("ANullValue");
Assert.IsNotNull(e, "Missing ANullValue element");
Assert.AreEqual(s.Context.NullAttributeValue,
XmlExtensions.GetAttributeValue(e, s.Context.NullAttributeName),
"Null Attribute Error");
e = (XmlElement)elem.SelectSingleNode("Address");
Assert.IsNotNull(e, "Missing Address element");
Assert.AreEqual(x.m_address.m_city, XmlExtensions.GetElementValue(e, "City"), "Address-City");
Assert.AreEqual(x.m_address.m_street, XmlExtensions.GetElementValue(e, "Street"), "Address-Street");
Assert.AreEqual(x.m_address.m_zip.ToString(), XmlExtensions.GetElementValue(e, "Zip"), "Address-Zip");
e = (XmlElement)elem.SelectSingleNode("OtherAddress");
Assert.IsNotNull(e, "Other Address Missing");
var sa = x.m_otherAddress as CSuperAddress;
Assert.AreEqual(sa.m_country, XmlExtensions.GetElementValue(e, "Country"), "OtherAddress-Country");
Assert.AreEqual(sa.m_city, XmlExtensions.GetElementValue(e, "City"), "Address-City");
Assert.AreEqual(sa.m_street, XmlExtensions.GetElementValue(e, "Street"), "Address-Street");
Assert.AreEqual(sa.m_zip.ToString(), XmlExtensions.GetElementValue(e, "Zip"), "Address-Zip");
}
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 TestPointersEtc()
{
var x = new NoGoodStuff();
var c = new CSerializationContext();
c.SetVerbose();
var s = new CSerializer(c);
var doc = s.Serialize(x);
var elem = doc.DocumentElement;
Print(doc);
Assert.AreEqual(0, elem.ChildNodes.Count, "Should have no fields serialized");
Assert.AreEqual(1, elem.Attributes.Count, "Should have one (the _Type) attribute");
}
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 TestMultidimArray()
{
var x = new int[3, 3, 5];
for (var j = 0; j < 3; j++)
{
for (var k = 0; k < 3; k++)
{
for (var l = 0; l < 5; l++)
{
x[j, k, l] = j * 100 + k * 10 + l;
}
}
}
var c = new CSerializationContext();
c.SetVerbose();
var s = new CSerializer(c);
var doc = s.Serialize(x);
Print(doc);
var elem = doc.DocumentElement;
Assert.AreEqual(3 * 3 * 5, elem.ChildNodes.Count, "Child node count is wrong");
Assert.AreEqual("3,3,5",
XmlExtensions.GetAttributeValue(elem, c.ArrayAttributeName),
"Array Lengths are wrong");
Assert.AreEqual("0,0,0",
XmlExtensions.GetAttributeValue(elem, c.ArrayLowerBoundAttribute),
"Array lower-bounds are wrong");
PrintLine();
c.SetConcise();
doc = s.Serialize(x);
Print(doc);
elem = doc.DocumentElement;
Assert.AreEqual(1, elem.ChildNodes.Count, "Child node count is wrong");
Assert.IsTrue(elem.InnerText.StartsWith("0,1,2,3,4,10,11,12"), "The inner text doesn't look right");
}
public void TestSparseArray()
{
var x = new string[100];
x[5] = "Something";
x[49] = "Else";
x[50] = "?";
x[75] = "";
var c = new CSerializationContext
{
AllArraysHaveExplicitElements = true,
RemoveNullValuesFromXml = true
};
var s = new CSerializer(c);
var doc = s.Serialize(x);
Print(doc);
var elem = doc.DocumentElement;
Assert.AreEqual(4, elem.ChildNodes.Count, "Child node count is wrong");
Assert.AreEqual(x.Length.ToString(),
XmlExtensions.GetAttributeValue(elem, c.ArrayAttributeName),
"Array Length value is wrong");
Assert.AreEqual("5",
XmlExtensions.GetAttributeValue(elem.ChildNodes[0], c.ArrayIndexAttributeName),
"Index for element 0 is wrong");
Assert.AreEqual("49",
XmlExtensions.GetAttributeValue(elem.ChildNodes[1], c.ArrayIndexAttributeName),
"Index for element 1 is wrong");
Assert.IsNull(XmlExtensions.GetAttributeValue(elem.ChildNodes[2], c.ArrayIndexAttributeName),
"Should have no index attribute on consecutive elements");
Assert.AreEqual("75",
XmlExtensions.GetAttributeValue(elem.ChildNodes[3], c.ArrayIndexAttributeName),
"Index for element 3 is wrong");
Assert.AreEqual(x[5], elem.ChildNodes[0].InnerText, "Value of child 0 incorrect");
Assert.AreEqual(x[49], elem.ChildNodes[1].InnerText, "Value of child 1 incorrect");
Assert.AreEqual(x[50], elem.ChildNodes[2].InnerText, "Value of child 2 incorrect");
Assert.AreEqual(x[75], elem.ChildNodes[3].InnerText, "Value of child 3 incorrect");
}
public void TestSparseMultidimArray()
{
object[,,] x;
x = (object[, , ])Array.CreateInstance(typeof(object), new int[] { 3, 4, 5 }, new int[] { 3, 2, 1 });
x[3, 5, 3] = Guid.NewGuid();
x[4, 4, 1] = "hello";
x[4, 4, 2] = "Good Bye";
x[4, 4, 3] = "he" + "llo"; // interns to "hello", and shared with the "hello" at [4,4,1]
x[5, 2, 5] = 678;
var c = new CSerializationContext();
c.SetConcise();
var s = new CSerializer(c);
var doc = s.Serialize(x);
Print(doc);
var elem = doc.DocumentElement;
Assert.AreEqual(5, elem.ChildNodes.Count, "Number of elements is wrong");
Assert.AreEqual("3,4,5",
XmlExtensions.GetAttributeValue(elem, c.ArrayAttributeName),
"Array Lengths are wrong");
Assert.AreEqual("3,2,1",
XmlExtensions.GetAttributeValue(elem, c.ArrayLowerBoundAttribute),
"Array Lowerbounds are wrong");
Assert.AreEqual("3,5,3",
XmlExtensions.GetAttributeValue(elem.ChildNodes[0], c.ArrayIndexAttributeName),
"Index value is wrong");
Assert.AreEqual("4,4,1",
XmlExtensions.GetAttributeValue(elem.ChildNodes[1], c.ArrayIndexAttributeName),
"Index value is wrong");
Assert.AreEqual("5,2,5",
XmlExtensions.GetAttributeValue(elem.ChildNodes[4], c.ArrayIndexAttributeName),
"Index value is wrong");
Assert.IsNull(XmlExtensions.GetAttributeValue(elem.ChildNodes[2], c.ArrayIndexAttributeName),
"Should be no index attribute for sequential element");
Assert.IsNull(XmlExtensions.GetAttributeValue(elem.ChildNodes[3], c.ArrayIndexAttributeName),
"Should be no index attribute for sequential element");
}
public void TestRenamedArrayElements()
{
const string DEFAULT_NAME = "default";
var o = new CClassWithRenamedArrayElements();
var c = new CSerializationContext
{
ArrayElementsIncludeIndicies = true,
AllArraysHaveExplicitElements = true,
ArrayElementName = DEFAULT_NAME
};
var s = new CSerializer(c);
var doc = s.Serialize(o);
Print(doc);
var e = doc.DocumentElement["m_defaultNames"];
Assert.IsNotNull(e, "Expected to find an element for default element names");
for (var i = 0; i < o.m_defaultNames.Length; i++)
{
var expected = o.m_defaultNames[i];
var child = (XmlElement)e.ChildNodes[i];
Assert.AreEqual(c.ArrayElementName, child.Name, "The name of the XML element is wrong on default elements");
Assert.AreEqual(expected, int.Parse(child.InnerText), "The value found at index " + i + " was wrong on default elements.");
}
e = doc.DocumentElement["m_myNames"];
Assert.IsNotNull(e, "Expected to find an element for 'my' element names");
for (var i = 0; i < o.m_myNames.Length; i++)
{
var expected = o.m_myNames[i];
var child = (XmlElement)e.ChildNodes[i];
Assert.AreEqual(CClassWithRenamedArrayElements.MY_ELEM_NAME, child.Name, "The name of the XML element is wrong on 'my' elements");
Assert.AreEqual(expected, int.Parse(child.InnerText), "The value found at index " + i + " was wrong on 'my' elements.");
}
}
public void TestPeople()
{
CBigPerson.GenerateData(100);
var c = new CSerializationContext();
c.SetConcise();
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));
var d = new CDeserializer(c);
var x2 = d.Deserialize <CBigPerson[]>(doc);
var x1 = CBigPerson.People;
AssertEqualBigPeopleArray(x1, x2);
}
public void TestExplicitContext()
{
CSerializationContext.Global.AllArraysHaveExplicitElements = true; // change the "GLobal" value
var c = new CSerializationContext
{
AllArraysHaveExplicitElements = false
};
Assert.AreEqual(true,
CSerializationContext.Global.AllArraysHaveExplicitElements,
"global should be true still");
Assert.AreEqual(false, c.AllArraysHaveExplicitElements, "Instance should be false");
var c2 = new CSerializationContext();
Assert.AreEqual(true, c2.AllArraysHaveExplicitElements, "c2 should inherit Global's TRUE");
Assert.AreEqual(true, c2.GetFlag(CSerializationContext.EContextFields.ARRAYS_WITH_EXPLICIT_ELEMENTS), "GetFlag(default) should use global");
}
public void TestArray_String()
{
var a = new string[] { "hello,", "homer", "", "!", null, "what?" };
var context = new CSerializationContext();
var s = new CSerializer(context);
var doc = s.Serialize(a);
Print(doc);
var e = doc.DocumentElement;
Assert.AreEqual(a.GetType().AssemblyQualifiedName,
XmlExtensions.GetAttributeValue(e, s.Context.TypeAttributeName),
"The Type attribute is wrong");
Assert.AreEqual(int.Parse(XmlExtensions.GetAttributeValue(e, s.Context.ArrayAttributeName)),
a.Length,
"Array Attribute has wrong length value");
Assert.AreEqual(@"hello\`,homer,\_,!,,what?", e.InnerText, "Comma-Separated List is wrong.");
}
public void TestBasicOperation()
{
// Default construction inherits from Global
var c = new CSerializationContext();
c.SetShortNames();
CSerializationContext.Global.FixM_ = true;
Assert.AreEqual(true, c.FixM_, "Make sure instance inherits Global");
c.FixM_ = false;
Assert.AreEqual(false, c.FixM_, "Make sure stuff set on the instance overrides global");
Assert.AreEqual(true, CSerializationContext.Global.FixM_, "The Global value should still be true");
Assert.AreEqual(false,
CSerializationContext.Global.RemoveNullValuesFromXml,
"The default for all properties is false");
Assert.AreEqual(false, c.RemoveNullValuesFromXml, "The default for all properties is false");
CSerializationContext.Global.RemoveNullValuesFromXml = true;
Assert.AreEqual(true, CSerializationContext.Global.RemoveNullValuesFromXml, "Setting Global value");
Assert.AreEqual(true, c.RemoveNullValuesFromXml, "Settting global value should bubble-up");
}
public void TestFieldRenamerAccess()
{
Assert.IsNull(CSerializationContext.Global.FieldRenamer, "There should be no default field renamer");
var c = new CSerializationContext();
Assert.IsNull(c.FieldRenamer, "There should be no default field renamer");
var myNamer = new CMyFieldRenamer();
CSerializationContext.Global.FieldRenamer = myNamer;
ReferenceEquals(myNamer, c.FieldRenamer);
var myOtherNamer = new CMyFieldRenamer();
c.FieldRenamer = myOtherNamer;
Assert.AreEqual(myNamer, CSerializationContext.Global.FieldRenamer, "Global should not change");
Assert.AreEqual(myOtherNamer, c.FieldRenamer, "Instance should be new");
var c2 = new CSerializationContext();
Assert.AreEqual(myNamer, c2.FieldRenamer, "Newly constructed contexts should keep the Global reference");
}
