-//\r
-// MonoTests.System.Xml.Serialization.XmlSerializationWriterTests\r
-//\r
-// Author: Erik LeBel <eriklebel@yahoo.ca>\r
-//\r
-// (C) Erik LeBel 2003\r
-// \r
-// FIXME add tests for callbacks\r
-// FIXME add tests for writes that generate namespaces\r
-// FIXME add test that write XmlNode objects\r
-// \r
-\r
-using System;\r
-using System.Globalization;\r
-using System.IO;\r
-using System.Xml;\r
-using System.Xml.Serialization;\r
-\r
-using NUnit.Framework;\r
-\r
-using MonoTests.System.Xml.TestClasses;\r
-\r
-namespace MonoTests.System.XmlSerialization\r
-{\r
- // base, common implementation of XmlSerializationWriter test harness.\r
- // the reason for this is that all auto generated namespace prefixes \r
- // of the form q# are modified by any Write* that defines a new namespace.\r
- // The result of this is that even though we redefine the string results\r
- // to exclude previous tests, the q#s will change depending on number of\r
- // namespace declarations were made prior to the perticual test. This \r
- // means that if the [Test] methods are called out of sequence, they \r
- // all start to fail. For this reason, tests that define and verify \r
- // temporary namespaces should be stored in a seperate class which protects\r
- // itself from accidental pre-definitions.\r
- public class XmlSerializarionWriterTester : XmlSerializationWriter\r
- {\r
- // appease the compiler\r
- protected override void InitCallbacks ()\r
- {\r
- }\r
-\r
- StringWriter sw;\r
- XmlTextWriter writer;\r
- \r
- [SetUp]\r
- public void Reset()\r
- {\r
- sw = new StringWriter ();\r
- writer = new XmlTextWriter (sw);\r
- writer.QuoteChar = '\'';\r
- writer.Formatting = Formatting.None;\r
- Writer = writer;\r
- }\r
-\r
- public string Content\r
- {\r
- get\r
- { \r
- string val = sw.GetStringBuilder().ToString();\r
- return val;\r
- }\r
- }\r
-\r
- public void ExecuteWritePotentiallyReferencingElement (string name, string ns, object o, Type ambientType, bool suppressReference, bool isNullable)\r
- {\r
- WritePotentiallyReferencingElement (name, ns, o, ambientType, suppressReference, isNullable);\r
- }\r
-\r
- public void ExecuteWriteTypedPrimitive (string name, string ns, object o, bool xsiType)\r
- {\r
- WriteTypedPrimitive (name, ns, o, xsiType);\r
- }\r
- }\r
- \r
- // this class tests the methods of the XmlSerializationWriter that\r
- // can be executed out of order.\r
- [TestFixture]\r
- public class XmlSerializationWriterSimpleTests : XmlSerializarionWriterTester\r
- {\r
- const string XmlSchemaNamespace = "http://www.w3.org/2001/XMLSchema";\r
- const string XmlSchemaInstanceNamespace = "http://www.w3.org/2001/XMLSchema-instance";\r
- const string SoapEncodingNamespace = "http://schemas.xmlsoap.org/soap/encoding/";\r
- const string WsdlTypesNamespace = "http://microsoft.com/wsdl/types/";\r
- const string ANamespace = "some:urn";\r
- const string AnotherNamespace = "another:urn";\r
-\r
- // These TestFrom* methods indirectly test the functionality of XmlCustomFormatter\r
-\r
- [Test]\r
- public void TestFromByteArrayBase64()\r
- {\r
- // FIXME\r
- // This should work according to Mono's API, but .NET's FromByteArrayBase64 \r
- // returns a byte array.\r
- // \r
- //string val = this.FromByteArrayBase64(new byte [] {143, 144, 1, 0});\r
- //Assert.AreEqual (FromByteArrayBase64(null), "");\r
- \r
- //val = FromByteArrayBase64(null);\r
- //try/catch or AssertEruals?\r
- }\r
-\r
- [Test]\r
- public void TestFromByteArrayHex()\r
- {\r
- byte [] vals = {143, 144, 1, 0};\r
- Assert.AreEqual ("8F900100", FromByteArrayHex(vals));\r
- Assert.IsNull (FromByteArrayHex (null));\r
- }\r
-\r
- [Test]\r
- public void TestFromChar()\r
- {\r
- Assert.AreEqual ("97", FromChar ('a'));\r
- Assert.AreEqual ("0", FromChar ('\0'));\r
- Assert.AreEqual ("10", FromChar ('\n'));\r
- Assert.AreEqual ("65281", FromChar ('\uFF01'));\r
- }\r
-\r
- [Test]\r
- public void TestFromDate()\r
- {\r
- DateTime d = new DateTime();\r
- Assert.AreEqual ("0001-01-01", FromDate (d));\r
- }\r
-\r
- [Test]\r
- public void TestFromDateTime()\r
- {\r
- DateTime d = new DateTime();\r
- Assert.AreEqual ("0001-01-01T00:00:00.0000000", FromDateTime (d).Substring (0, 27));\r
- }\r
-\r
- [Test] // bug #77500\r
- public void TestFromEnum()\r
- {\r
- long[] ids = {1, 2, 3, 4};\r
- string[] values = {"one", "two", "three"};\r
-\r
- Assert.AreEqual ("one", FromEnum (1, values, ids), "#1");\r
- Assert.AreEqual (string.Empty, FromEnum (0, values, ids), "#2");\r
- Assert.AreEqual ("one two", FromEnum (3, values, ids), "#3");\r
-\r
- try {\r
- string dummy = FromEnum(4, values, ids);\r
- Assert.Fail("#4");\r
- } catch (IndexOutOfRangeException) {\r
- }\r
-\r
- string[] correctValues = {"one", "two", "three", "four"};\r
- Assert.AreEqual ("four", FromEnum (4, correctValues, ids), "#5");\r
- Assert.AreEqual ("one four", FromEnum (5, correctValues, ids), "#6");\r
- Assert.AreEqual ("two four", FromEnum (6, correctValues, ids), "#7");\r
- Assert.AreEqual ("one two three four", FromEnum (7, correctValues, ids), "#8");\r
-\r
- string[] flagValues = {"one", "two", "four", "eight"};\r
- long[] flagIDs = {1, 2, 4, 8};\r
- Assert.AreEqual (string.Empty, FromEnum (0, flagValues, flagIDs), "#9");\r
- Assert.AreEqual ("two", FromEnum (2, flagValues, flagIDs), "#10");\r
- Assert.AreEqual ("four", FromEnum (4, flagValues, flagIDs), "#1");\r
- Assert.AreEqual ("one four", FromEnum (5, flagValues, flagIDs), "#12");\r
- Assert.AreEqual ("two four", FromEnum (6, flagValues, flagIDs), "#13");\r
- Assert.AreEqual ("one two four", FromEnum (7, flagValues, flagIDs), "#14");\r
- Assert.AreEqual ("eight", FromEnum (8, flagValues, flagIDs), "#15");\r
- Assert.AreEqual ("one four eight", FromEnum (13, flagValues, flagIDs), "#16");\r
-\r
- string[] unorderedValues = {"one", "four", "two", "zero"};\r
- long[] unorderedIDs = {1, 4, 2, 0};\r
-\r
- Assert.AreEqual (string.Empty, FromEnum (0, unorderedValues, unorderedIDs), "#17");\r
- Assert.AreEqual ("two", FromEnum (2, unorderedValues, unorderedIDs), "#18");\r
- Assert.AreEqual ("four", FromEnum (4, unorderedValues, unorderedIDs), "#19");\r
- Assert.AreEqual ("one four", FromEnum (5, unorderedValues, unorderedIDs), "#20");\r
- Assert.AreEqual ("four two", FromEnum (6, unorderedValues, unorderedIDs), "#21");\r
- Assert.AreEqual ("one four two", FromEnum (7, unorderedValues, unorderedIDs), "#22");\r
-\r
- string[] zeroValues = {"zero", "ten"};\r
- long[] zeroIDs = {0, 10};\r
-\r
- Assert.AreEqual ("zero", FromEnum (0, zeroValues, zeroIDs), "#9");\r
- Assert.AreEqual ("ten", FromEnum (10, zeroValues, zeroIDs), "#9");\r
-\r
- string[] reverseZeroValues = {"", "zero"};\r
- long[] reverseZeroIDs = {4, 0};\r
- Assert.AreEqual (string.Empty, FromEnum (0, reverseZeroValues, reverseZeroIDs), "#9");\r
- Assert.AreEqual ("zero", FromEnum (4, reverseZeroValues, reverseZeroIDs), "#9");\r
-\r
- string[] emptyValues = { "zero" };\r
- long[] emptyIDs = {0};\r
- Assert.AreEqual ("zero", FromEnum (0, emptyValues, emptyIDs), "#9");\r
- }\r
-\r
- [Test]\r
- public void TestFromEnum_InvalidValue ()\r
- {\r
- long[] ids = {1, 2, 3, 4};\r
- string[] values = {"one", "two", "three", "four"};\r
-\r
-#if NET_2_0\r
- try {\r
- FromEnum (8, values, ids);\r
- Assert.Fail ("#A1");\r
- } catch (InvalidOperationException ex) {\r
- Assert.AreEqual (typeof (InvalidOperationException), ex.GetType (), "#A2");\r
- Assert.IsNotNull (ex.Message, "#A3");\r
- Assert.IsTrue (ex.Message.IndexOf ("'8'") != -1, "#A4");\r
- Assert.IsNull (ex.InnerException, "#A5");\r
- }\r
-#else\r
- Assert.AreEqual ("8", FromEnum (8, values, ids), "#A6");\r
-#endif\r
-\r
-#if NET_2_0\r
- try {\r
- FromEnum (8, values, ids, "Some.Type.Name");\r
- Assert.Fail ("#B1");\r
- } catch (InvalidOperationException ex) {\r
- Assert.AreEqual (typeof (InvalidOperationException), ex.GetType (), "#B2");\r
- Assert.IsNotNull (ex.Message, "#B3");\r
- Assert.IsTrue (ex.Message.IndexOf ("'8'") != -1, "#B4");\r
- Assert.IsTrue (ex.Message.IndexOf ("Some.Type.Name") != -1, "#B5");\r
- Assert.IsNull (ex.InnerException, "#B6");\r
- }\r
-#endif\r
- }\r
-\r
- [Test]\r
- [ExpectedException (typeof (NullReferenceException))]\r
- public void TestFromEnum_Null_Values ()\r
- {\r
- long[] ids = { 1, 2, 3, 4 };\r
- string[] values = { "one", "two", "three", "four" };\r
-\r
- FromEnum (1, (string[]) null, ids);\r
- }\r
-\r
- [Test]\r
- [ExpectedException (typeof (NullReferenceException))]\r
- public void TestFromEnum_Null_IDs ()\r
- {\r
- string[] values = { "one", "two", "three", "four" };\r
-\r
- FromEnum (1, values, (long[]) null);\r
- }\r
-\r
- [Test]\r
- public void TestFromTime()\r
- {\r
- DateTime d = new DateTime();\r
- // Don't include time zone.\r
- Assert.AreEqual ("00:00:00.0000000", FromTime (d).Substring (0, 16));\r
- }\r
-\r
- [Test]\r
- public void TestFromXmlName()\r
- {\r
- Assert.AreEqual ("Hello", FromXmlName ("Hello"));\r
- Assert.AreEqual ("go_x0020_dogs_x0020_go", FromXmlName ("go dogs go"));\r
- Assert.AreEqual ("what_x0027_s_x0020_up", FromXmlName ("what's up"));\r
- Assert.AreEqual ("_x0031_23go", FromXmlName ("123go"));\r
- Assert.AreEqual ("Hello_x0020_what_x0027_s.up", FromXmlName ("Hello what's.up"));\r
- }\r
-\r
- [Test]\r
- public void TestFromXmlNCName()\r
- {\r
- Assert.AreEqual ("Hello", FromXmlNCName ("Hello"));\r
- Assert.AreEqual ("go_x0020_dogs_x0020_go", FromXmlNCName ("go dogs go"));\r
- Assert.AreEqual ("what_x0027_s_x0020_up", FromXmlNCName ("what's up"));\r
- Assert.AreEqual ("_x0031_23go", FromXmlNCName ("123go"));\r
- Assert.AreEqual ("Hello_x0020_what_x0027_s.up", FromXmlNCName ("Hello what's.up"));\r
- }\r
-\r
- [Test]\r
- public void TestFromXmlNmToken()\r
- {\r
- Assert.AreEqual ("Hello", FromXmlNmToken ("Hello"));\r
- Assert.AreEqual ("go_x0020_dogs_x0020_go", FromXmlNmToken ("go dogs go"));\r
- Assert.AreEqual ("what_x0027_s_x0020_up", FromXmlNmToken ("what's up"));\r
- Assert.AreEqual ("123go", FromXmlNmToken ("123go"));\r
- Assert.AreEqual ("Hello_x0020_what_x0027_s.up", FromXmlNmToken ("Hello what's.up"));\r
- }\r
-\r
- [Test]\r
- public void TestFromXmlNmTokens()\r
- {\r
- Assert.AreEqual ("Hello go dogs_go 123go what_x0027_s.up", FromXmlNmTokens ("Hello go dogs_go 123go what's.up"));\r
- }\r
-\r
- [Test]\r
- public void TestWriteAttribute()\r
- {\r
- WriteStartElement("x");\r
- WriteAttribute("a", "b");\r
- WriteEndElement();\r
- Assert.AreEqual ("<x a='b' />", Content);\r
-\r
- Reset();\r
- WriteStartElement("x");\r
- WriteAttribute("a", new byte[] {1, 2, 3});\r
- WriteEndElement();\r
- Assert.AreEqual ("<x a='AQID' />", Content);\r
-\r
- Reset();\r
- WriteStartElement("x");\r
- WriteAttribute("a", "<b");\r
- WriteEndElement();\r
- Assert.AreEqual ("<x a='<b' />", Content);\r
-\r
- Reset();\r
- WriteStartElement("x");\r
- string typedPlaceholder = null;\r
- WriteAttribute("a", typedPlaceholder);\r
- WriteEndElement();\r
- Assert.AreEqual ("<x />", Content);\r
-\r
- Reset();\r
- WriteStartElement("x");\r
- WriteAttribute("a", "\"");\r
- WriteEndElement();\r
- Assert.AreEqual ("<x a='\"' />", Content);\r
-\r
- Reset();\r
- WriteStartElement("x");\r
- WriteAttribute("a", "b\nc");\r
- WriteEndElement();\r
- Assert.AreEqual ("<x a='b
c' />", Content);\r
-\r
- Reset();\r
- WriteStartElement("x");\r
- WriteAttribute("a", ANamespace, "b");\r
- WriteEndElement();\r
- Assert.AreEqual ("<x d1p1:a='b' xmlns:d1p1='some:urn' />", Content);\r
- }\r
-\r
- [Test]\r
- public void TestWriteElementEncoded()\r
- {\r
- // FIXME\r
- // XmlNode related\r
- }\r
-\r
- [Test]\r
- public void TestWriteElementLiteral()\r
- {\r
- // FIXME\r
- // XmlNode related\r
- }\r
-\r
- [Test]\r
- public void TestWriteElementString()\r
- {\r
- WriteElementString("x", "a");\r
- Assert.AreEqual ("<x>a</x>", Content);\r
-\r
- Reset();\r
- WriteElementString("x", "<a");\r
- Assert.AreEqual ("<x><a</x>", Content);\r
- }\r
-\r
- [Test]\r
- public void TestWriteElementStringRaw()\r
- {\r
- byte [] placeHolderArray = null;\r
- WriteElementStringRaw("x", placeHolderArray);\r
- Assert.AreEqual ("", Content);\r
-\r
- Reset();\r
- WriteElementStringRaw("x", new byte[] {0, 2, 4});\r
- Assert.AreEqual ("<x>AAIE</x>", Content);\r
-\r
- Reset();\r
- WriteElementStringRaw("x", new byte[] {});\r
- Assert.AreEqual ("<x />", Content);\r
-\r
- // Note to reader, the output is not valid xml\r
- Reset();\r
- WriteElementStringRaw("x", "a > 13 && a < 19");\r
- Assert.AreEqual ("<x>a > 13 && a < 19</x>", Content);\r
- }\r
-\r
- [Test]\r
- public void TestWriteEmptyTag()\r
- {\r
- WriteEmptyTag("x");\r
- Assert.AreEqual ("<x />", Content);\r
- }\r
-\r
- [Test]\r
- public void TestWriteNamespaceDeclarations()\r
- {\r
- XmlSerializerNamespaces ns = new XmlSerializerNamespaces();\r
-\r
- WriteStartElement("x");\r
- WriteNamespaceDeclarations(ns);\r
- WriteEndElement();\r
- Assert.AreEqual ("<x />", Content);\r
-\r
- Reset();\r
- ns.Add("mypref", ANamespace);\r
- WriteStartElement("x");\r
- WriteNamespaceDeclarations(ns);\r
- WriteEndElement();\r
- Assert.AreEqual (XmlSerializerTests.Infoset("<x xmlns:mypref='some:urn' />"), XmlSerializerTests.Infoset(Content));\r
-\r
- Reset();\r
- ns.Add("ns2", "another:urn");\r
- WriteStartElement("x");\r
- WriteNamespaceDeclarations(ns);\r
- WriteEndElement();\r
- Assert.AreEqual (XmlSerializerTests.Infoset("<x xmlns:ns2='another:urn' xmlns:mypref='some:urn' />"), XmlSerializerTests.Infoset(Content));\r
-\r
- Reset();\r
- ns.Add("ns3", "ya:urn");\r
- WriteStartElement("x");\r
- WriteNamespaceDeclarations(ns);\r
- WriteEndElement();\r
- Assert.AreEqual (XmlSerializerTests.Infoset("<x xmlns:ns3='ya:urn' xmlns:ns2='another:urn' xmlns:mypref='some:urn' />"), XmlSerializerTests.Infoset(Content));\r
- }\r
-\r
- [Test]\r
- public void TestWriteNullableStringLiteral()\r
- {\r
- WriteNullableStringLiteral("x", null, null);\r
- Assert.AreEqual (XmlSerializerTests.Infoset("<x d1p1:nil='true' xmlns:d1p1='http://www.w3.org/2001/XMLSchema-instance' />"), XmlSerializerTests.Infoset(Content));\r
-\r
- Reset();\r
- WriteNullableStringLiteral("x", null, "");\r
- Assert.AreEqual ("<x />", Content);\r
- \r
- Reset();\r
- WriteNullableStringLiteral("x", null, "a<b\'c");\r
- Assert.AreEqual ("<x>a<b\'c</x>", Content);\r
-\r
- Reset();\r
- WriteNullableStringLiteral("x", ANamespace, "b");\r
- Assert.AreEqual ("<x xmlns='some:urn'>b</x>", Content);\r
- }\r
-\r
- [Test]\r
- public void TestWriteNullableStringLiteralRaw()\r
- {\r
- WriteNullableStringLiteralRaw("x", null, new byte[] {1, 2, 244});\r
- Assert.AreEqual ("<x>AQL0</x>", Content);\r
- }\r
-\r
- [Test]\r
- public void TestWriteNullTagEncoded()\r
- {\r
- WriteNullTagEncoded("x");\r
- Assert.AreEqual (XmlSerializerTests.Infoset("<x d1p1:nil='true' xmlns:d1p1='http://www.w3.org/2001/XMLSchema-instance' />"), XmlSerializerTests.Infoset(Content));\r
- }\r
-\r
- [Test]\r
- public void TestWriteNullTagLiteral()\r
- {\r
- WriteNullTagLiteral("x");\r
- Assert.AreEqual (XmlSerializerTests.Infoset("<x d1p1:nil='true' xmlns:d1p1='http://www.w3.org/2001/XMLSchema-instance' />"), XmlSerializerTests.Infoset(Content));\r
- }\r
-\r
- [Test]\r
- [Category ("NotWorking")]\r
- public void TestWritePotentiallyReferencingElement ()\r
- {\r
- XmlSerializarionWriterTester xsw = new XmlSerializarionWriterTester ();\r
- xsw.Reset ();\r
-\r
- xsw.ExecuteWritePotentiallyReferencingElement ("x", ANamespace, EnumDefaultValue.e1, typeof (EnumDefaultValue), true, false);\r
- Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,\r
- "<x xmlns='{0}'>1</x>", ANamespace), xsw.Content, "#1");\r
-\r
- xsw.Reset ();\r
-\r
- xsw.ExecuteWritePotentiallyReferencingElement ("x", ANamespace, (int) 1, typeof (EnumDefaultValue), true, false);\r
- Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,\r
- "<x xmlns:q1='{0}' d1p1:type='q1:int' xmlns:d1p1='{1}' xmlns='{2}'>1</x>",\r
- XmlSchemaNamespace, XmlSchemaInstanceNamespace, ANamespace),\r
- xsw.Content, "#2");\r
-\r
- xsw.Reset ();\r
-\r
- xsw.ExecuteWritePotentiallyReferencingElement ("x", ANamespace, "something", typeof (string), true, false);\r
- Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,\r
- "<x xmlns='{0}'>something</x>", ANamespace), xsw.Content, "#3");\r
-\r
- xsw.Reset ();\r
-\r
- xsw.ExecuteWritePotentiallyReferencingElement ("x", ANamespace, "something", null, true, false);\r
- Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,\r
- "<x xmlns:q2='{0}' d1p1:type='q2:string' xmlns:d1p1='{1}' xmlns='{2}'>something</x>",\r
- XmlSchemaNamespace, XmlSchemaInstanceNamespace, ANamespace),\r
- xsw.Content, "#2");\r
-\r
- xsw.Reset ();\r
-\r
- xsw.ExecuteWritePotentiallyReferencingElement ("x", ANamespace, new string[] { "A", "B" }, typeof (string[]), true, false);\r
- Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,\r
- "<q3:Array id='id1' xmlns:q4='{0}' q3:arrayType='q4:string[2]' xmlns:q3='{1}'>" +\r
- "<Item>A</Item>" +\r
- "<Item>B</Item>" +\r
- "</q3:Array>", XmlSchemaNamespace, SoapEncodingNamespace), xsw.Content, "#5");\r
- }\r
-\r
- [Test]\r
- public void TestWriteSerializable()\r
- {\r
- // FIXME\r
- //Assert.AreEqual (, "");\r
- }\r
-\r
- [Test]\r
- public void TestWriteStartDocument()\r
- {\r
- Assert.AreEqual ("", Content);\r
- \r
- WriteStartDocument();\r
- Assert.AreEqual ("<?xml version='1.0' encoding='utf-16'?>", Content);\r
- }\r
-\r
- [Test]\r
- public void TestWriteStartElement()\r
- {\r
- WriteStartElement("x");\r
- WriteEndElement();\r
- Assert.AreEqual ("<x />", Content);\r
-\r
- Reset();\r
- WriteStartElement("x");\r
- WriteValue("a");\r
- WriteEndElement();\r
- Assert.AreEqual ("<x>a</x>", Content);\r
-\r
- Reset();\r
- WriteStartElement("x");\r
- WriteStartElement("y", "z");\r
- WriteEndElement();\r
- WriteEndElement();\r
- Assert.AreEqual ("<x><y xmlns='z' /></x>", Content);\r
-\r
- Reset();\r
- WriteStartElement("x");\r
- WriteStartElement("y", "z", true);\r
- WriteEndElement();\r
- WriteEndElement();\r
- Assert.AreEqual ("<x><q1:y xmlns:q1='z' /></x>", Content);\r
- }\r
-\r
- [Test]\r
- [Category ("NotWorking")] // #7 fails\r
- public void TestWriteTypedPrimitive_Base64Binary ()\r
- {\r
- byte[] byteArray = new byte[] { 255, 20, 10, 5, 0, 7 };\r
- string expected = "/xQKBQAH";\r
-\r
- XmlSerializarionWriterTester xsw = new XmlSerializarionWriterTester ();\r
- xsw.Reset ();\r
-\r
- xsw.ExecuteWriteTypedPrimitive ("x", ANamespace, byteArray, false);\r
- Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,\r
- "<x xmlns='{0}'>{1}</x>", ANamespace, expected),\r
- xsw.Content, "#1");\r
-\r
- xsw.Reset ();\r
-\r
- xsw.ExecuteWriteTypedPrimitive ("x", string.Empty, byteArray, false);\r
- Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,\r
- "<x>{0}</x>", expected), xsw.Content, "#2");\r
-\r
- xsw.Reset ();\r
-\r
- xsw.ExecuteWriteTypedPrimitive ("x", null, byteArray, false);\r
- Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,\r
- "<x>{0}</x>", expected), xsw.Content, "#3");\r
-\r
- xsw.Reset ();\r
-\r
- xsw.ExecuteWriteTypedPrimitive ("x", XmlSchemaNamespace, byteArray, false);\r
- Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,\r
- "<x xmlns='{0}'>{1}</x>", XmlSchemaNamespace, expected),\r
- xsw.Content, "#4");\r
-\r
- xsw.Reset ();\r
-\r
- xsw.ExecuteWriteTypedPrimitive ("x", XmlSchemaInstanceNamespace, byteArray, false);\r
- Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,\r
- "<x xmlns='{0}'>{1}</x>", XmlSchemaInstanceNamespace, expected),\r
- xsw.Content, "#5");\r
-\r
- xsw.Reset ();\r
-\r
- xsw.ExecuteWriteTypedPrimitive (string.Empty, ANamespace, byteArray, false);\r
- Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,\r
- "< xmlns='{0}'>{1}</>", ANamespace, expected), xsw.Content, "#6");\r
-\r
- xsw.Reset ();\r
-\r
- xsw.ExecuteWriteTypedPrimitive (null, ANamespace, byteArray, false);\r
- Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,\r
- "<base64Binary xmlns='{0}'>{1}</base64Binary>",\r
- XmlSchemaNamespace, expected), xsw.Content, "#7");\r
- }\r
-\r
- [Test]\r
- public void TestWriteTypedPrimitive_Base64Binary_XsiType ()\r
- {\r
- byte[] byteArray = new byte[] { 255, 20, 10, 5, 0, 7 };\r
- string expected = "/xQKBQAH";\r
-\r
- XmlSerializarionWriterTester xsw = new XmlSerializarionWriterTester ();\r
- xsw.Reset ();\r
-\r
- xsw.ExecuteWriteTypedPrimitive ("x", string.Empty, byteArray, true);\r
- Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,\r
- "<x xmlns:q1='{0}' d1p1:type='q1:base64Binary' xmlns:d1p1='{1}'>{2}</x>",\r
- XmlSchemaNamespace, XmlSchemaInstanceNamespace, expected), \r
- xsw.Content, "#1");\r
-\r
- xsw.Reset ();\r
-\r
- xsw.ExecuteWriteTypedPrimitive ("x", null, byteArray, true);\r
- Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,\r
- "<x xmlns:q2='{0}' d1p1:type='q2:base64Binary' xmlns:d1p1='{1}'>{2}</x>",\r
- XmlSchemaNamespace, XmlSchemaInstanceNamespace, expected),\r
- xsw.Content, "#2");\r
- }\r
-\r
- [Test]\r
- [Category ("NotWorking")] // #7 fails\r
- public void TestWriteTypedPrimitive_Boolean ()\r
- {\r
- XmlSerializarionWriterTester xsw = new XmlSerializarionWriterTester ();\r
- xsw.Reset ();\r
-\r
- xsw.ExecuteWriteTypedPrimitive ("x", ANamespace, true, false);\r
- Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,\r
- "<x xmlns='{0}'>true</x>", ANamespace), xsw.Content, "#1");\r
-\r
- xsw.Reset ();\r
-\r
- xsw.ExecuteWriteTypedPrimitive ("x", string.Empty, false, false);\r
- Assert.AreEqual ("<x>false</x>", xsw.Content, "#2");\r
-\r
- xsw.Reset ();\r
-\r
- xsw.ExecuteWriteTypedPrimitive ("x", null, true, false);\r
- Assert.AreEqual ("<x>true</x>", xsw.Content, "#3");\r
-\r
- xsw.Reset ();\r
-\r
- xsw.ExecuteWriteTypedPrimitive ("x", XmlSchemaNamespace, false, false);\r
- Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,\r
- "<x xmlns='{0}'>false</x>", XmlSchemaNamespace), xsw.Content, "#4");\r
-\r
- xsw.Reset ();\r
-\r
- xsw.ExecuteWriteTypedPrimitive ("x", XmlSchemaInstanceNamespace, true, false);\r
- Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,\r
- "<x xmlns='{0}'>true</x>", XmlSchemaInstanceNamespace),\r
- xsw.Content, "#5");\r
-\r
- xsw.Reset ();\r
-\r
- xsw.ExecuteWriteTypedPrimitive (string.Empty, ANamespace, false, false);\r
- Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,\r
- "< xmlns='{0}'>false</>", ANamespace), xsw.Content, "#6");\r
-\r
- xsw.Reset ();\r
-\r
- xsw.ExecuteWriteTypedPrimitive (null, ANamespace, true, false);\r
- Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,\r
- "<boolean xmlns='{0}'>true</boolean>", XmlSchemaNamespace),\r
- xsw.Content, "#7");\r
- }\r
-\r
- [Test]\r
- public void TestWriteTypedPrimitive_Boolean_XsiType ()\r
- {\r
- XmlSerializarionWriterTester xsw = new XmlSerializarionWriterTester ();\r
- xsw.Reset ();\r
-\r
- xsw.ExecuteWriteTypedPrimitive ("x", string.Empty, true, true);\r
- Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,\r
- "<x xmlns:q1='{0}' d1p1:type='q1:boolean' xmlns:d1p1='{1}'>true</x>",\r
- XmlSchemaNamespace, XmlSchemaInstanceNamespace),\r
- xsw.Content, "#1");\r
-\r
- xsw.Reset ();\r
-\r
- xsw.ExecuteWriteTypedPrimitive ("x", null, false, true);\r
- Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,\r
- "<x xmlns:q2='{0}' d1p1:type='q2:boolean' xmlns:d1p1='{1}'>false</x>",\r
- XmlSchemaNamespace, XmlSchemaInstanceNamespace),\r
- xsw.Content, "#2");\r
- }\r
-\r
- [Test]\r
- [Category ("NotWorking")] // #7 fails\r
- public void TestWriteTypedPrimitive_Char ()\r
- {\r
- XmlSerializarionWriterTester xsw = new XmlSerializarionWriterTester ();\r
- xsw.Reset ();\r
-\r
- xsw.ExecuteWriteTypedPrimitive ("x", ANamespace, 'c', false);\r
- Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,\r
- "<x xmlns='{0}'>99</x>", ANamespace), xsw.Content, "#1");\r
-\r
- xsw.Reset ();\r
-\r
- xsw.ExecuteWriteTypedPrimitive ("x", string.Empty, 'a', false);\r
- Assert.AreEqual ("<x>97</x>", xsw.Content, "#2");\r
-\r
- xsw.Reset ();\r
-\r
- xsw.ExecuteWriteTypedPrimitive ("x", null, 'b', false);\r
- Assert.AreEqual ("<x>98</x>", xsw.Content, "#3");\r
-\r
- xsw.Reset ();\r
-\r
- xsw.ExecuteWriteTypedPrimitive ("x", XmlSchemaNamespace, 'd', false);\r
- Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,\r
- "<x xmlns='{0}'>100</x>", XmlSchemaNamespace), xsw.Content, "#4");\r
-\r
- xsw.Reset ();\r
-\r
- xsw.ExecuteWriteTypedPrimitive ("x", XmlSchemaInstanceNamespace, 'e', false);\r
- Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,\r
- "<x xmlns='{0}'>101</x>", XmlSchemaInstanceNamespace),\r
- xsw.Content, "#5");\r
-\r
- xsw.Reset ();\r
-\r
- xsw.ExecuteWriteTypedPrimitive (string.Empty, ANamespace, ' ', false);\r
- Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,\r
- "< xmlns='{0}'>32</>", ANamespace), xsw.Content, "#6");\r
-\r
- xsw.Reset ();\r
-\r
- xsw.ExecuteWriteTypedPrimitive (null, ANamespace, '0', false);\r
- Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,\r
- "<char xmlns='{0}'>48</char>", WsdlTypesNamespace),\r
- xsw.Content, "#7");\r
- }\r
-\r
- [Test]\r
- [Category ("NotWorking")] // namespace should be wsdl types ns\r
- public void TestWriteTypedPrimitive_Char_XsiType ()\r
- {\r
- XmlSerializarionWriterTester xsw = new XmlSerializarionWriterTester ();\r
- xsw.Reset ();\r
-\r
- xsw.ExecuteWriteTypedPrimitive ("x", string.Empty, 'c', true);\r
- Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,\r
- "<x xmlns:q1='{0}' d1p1:type='q1:char' xmlns:d1p1='{1}'>99</x>",\r
- WsdlTypesNamespace, XmlSchemaInstanceNamespace),\r
- xsw.Content, "#1");\r
-\r
- xsw.Reset ();\r
-\r
- xsw.ExecuteWriteTypedPrimitive ("x", null, 'a', true);\r
- Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,\r
- "<x xmlns:q2='{0}' d1p1:type='q2:char' xmlns:d1p1='{1}'>97</x>",\r
- WsdlTypesNamespace, XmlSchemaInstanceNamespace),\r
- xsw.Content, "#2");\r
- }\r
-\r
- [Test]\r
- [Category ("NotWorking")] // #7 fails\r
- public void TestWriteTypedPrimitive_DateTime ()\r
- {\r
- DateTime dateTime = new DateTime (1973, 08, 13);\r
-\r
- XmlSerializarionWriterTester xsw = new XmlSerializarionWriterTester ();\r
- xsw.Reset ();\r
-\r
- xsw.ExecuteWriteTypedPrimitive ("x", ANamespace, dateTime, false);\r
- Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,\r
- "<x xmlns='{0}'>{1}</x>", ANamespace, FromDateTime (dateTime)),\r
- xsw.Content, "#1");\r
-\r
- xsw.Reset ();\r
-\r
- xsw.ExecuteWriteTypedPrimitive ("x", string.Empty, dateTime, false);\r
- Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,\r
- "<x>{0}</x>", FromDateTime (dateTime)), xsw.Content, "#2");\r
-\r
- xsw.Reset ();\r
-\r
- xsw.ExecuteWriteTypedPrimitive ("x", null, dateTime, false);\r
- Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,\r
- "<x>{0}</x>", FromDateTime (dateTime)), xsw.Content, "#3");\r
-\r
- xsw.Reset ();\r
-\r
- xsw.ExecuteWriteTypedPrimitive ("x", XmlSchemaNamespace, dateTime, false);\r
- Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,\r
- "<x xmlns='{0}'>{1}</x>", XmlSchemaNamespace, \r
- FromDateTime (dateTime)), xsw.Content, "#4");\r
-\r
- xsw.Reset ();\r
-\r
- xsw.ExecuteWriteTypedPrimitive ("x", XmlSchemaInstanceNamespace, dateTime, false);\r
- Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,\r
- "<x xmlns='{0}'>{1}</x>", XmlSchemaInstanceNamespace,\r
- FromDateTime (dateTime)), xsw.Content, "#5");\r
-\r
- xsw.Reset ();\r
-\r
- xsw.ExecuteWriteTypedPrimitive (string.Empty, ANamespace, dateTime, false);\r
- Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,\r
- "< xmlns='{0}'>{1}</>", ANamespace, FromDateTime (dateTime)),\r
- xsw.Content, "#6");\r
-\r
- xsw.Reset ();\r
-\r
- xsw.ExecuteWriteTypedPrimitive (null, ANamespace, dateTime, false);\r
- Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,\r
- "<dateTime xmlns='{0}'>{1}</dateTime>", XmlSchemaNamespace,\r
- FromDateTime (dateTime)), xsw.Content, "#7");\r
- }\r
-\r
- [Test]\r
- public void TestWriteTypedPrimitive_DateTime_XsiType ()\r
- {\r
- DateTime dateTime = new DateTime (1973, 08, 13);\r
-\r
- XmlSerializarionWriterTester xsw = new XmlSerializarionWriterTester ();\r
- xsw.Reset ();\r
-\r
- xsw.ExecuteWriteTypedPrimitive ("x", string.Empty, dateTime, true);\r
- Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,\r
- "<x xmlns:q1='{0}' d1p1:type='q1:dateTime' xmlns:d1p1='{1}'>{2}</x>",\r
- XmlSchemaNamespace, XmlSchemaInstanceNamespace, \r
- FromDateTime (dateTime)), xsw.Content, "#1");\r
-\r
- xsw.Reset ();\r
-\r
- xsw.ExecuteWriteTypedPrimitive ("x", null, dateTime, true);\r
- Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,\r
- "<x xmlns:q2='{0}' d1p1:type='q2:dateTime' xmlns:d1p1='{1}'>{2}</x>",\r
- XmlSchemaNamespace, XmlSchemaInstanceNamespace,\r
- FromDateTime (dateTime)), xsw.Content, "#2");\r
- }\r
-\r
- [Test]\r
- [Category ("NotWorking")] // enum name is output instead of integral value\r
- public void TestWriteTypedPrimitive_Enum ()\r
- {\r
- XmlSerializarionWriterTester xsw = new XmlSerializarionWriterTester ();\r
- xsw.Reset ();\r
-\r
- xsw.ExecuteWriteTypedPrimitive ("x", ANamespace, EnumDefaultValue.e1, false);\r
- Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,\r
- "<x xmlns='{0}'>1</x>", ANamespace), xsw.Content, "#1");\r
-\r
- xsw.Reset ();\r
-\r
- xsw.ExecuteWriteTypedPrimitive ("x", string.Empty, EnumDefaultValue.e2, false);\r
- Assert.AreEqual ("<x>2</x>", xsw.Content, "#2");\r
-\r
- xsw.Reset ();\r
-\r
- xsw.ExecuteWriteTypedPrimitive ("x", null, EnumDefaultValue.e3, false);\r
- Assert.AreEqual ("<x>3</x>", xsw.Content, "#3");\r
-\r
- xsw.Reset ();\r
-\r
- xsw.ExecuteWriteTypedPrimitive ("x", XmlSchemaNamespace, EnumDefaultValue.e1, false);\r
- Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,\r
- "<x xmlns='{0}'>1</x>", XmlSchemaNamespace), xsw.Content, "#4");\r
-\r
- xsw.Reset ();\r
-\r
- xsw.ExecuteWriteTypedPrimitive ("x", XmlSchemaInstanceNamespace, EnumDefaultValue.e2, false);\r
- Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,\r
- "<x xmlns='{0}'>2</x>", XmlSchemaInstanceNamespace),\r
- xsw.Content, "#5");\r
-\r
- xsw.Reset ();\r
-\r
- xsw.ExecuteWriteTypedPrimitive (string.Empty, ANamespace, EnumDefaultValue.e3, false);\r
- Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,\r
- "< xmlns='{0}'>3</>", ANamespace), xsw.Content, "#6");\r
-\r
- xsw.Reset ();\r
-\r
- xsw.ExecuteWriteTypedPrimitive (null, ANamespace, EnumDefaultValue.e2, false);\r
- Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,\r
- "<int xmlns='{0}'>2</int>", XmlSchemaNamespace),\r
- xsw.Content, "#7");\r
- }\r
-\r
- [Test]\r
- [Category ("NotWorking")] // InvalidOperationException is thrown\r
- public void TestWriteTypedPrimitive_Enum_XsiType ()\r
- {\r
- XmlSerializarionWriterTester xsw = new XmlSerializarionWriterTester ();\r
- xsw.Reset ();\r
-\r
- xsw.ExecuteWriteTypedPrimitive ("x", string.Empty, EnumDefaultValue.e1, true);\r
- Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,\r
- "<x xmlns:q1='{0}' d1p1:type='q1:int' xmlns:d1p1='{1}'>1</x>",\r
- XmlSchemaNamespace, XmlSchemaInstanceNamespace),\r
- xsw.Content, "#1");\r
-\r
- xsw.Reset ();\r
-\r
- xsw.ExecuteWriteTypedPrimitive ("x", null, EnumDefaultValue.e2, true);\r
- Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,\r
- "<x xmlns:q2='{0}' d1p1:type='q2:int' xmlns:d1p1='{1}'>2</x>",\r
- XmlSchemaNamespace, XmlSchemaInstanceNamespace),\r
- xsw.Content, "#2");\r
- }\r
-\r
- [Test]\r
- [Category ("NotWorking")] // #7 fails\r
- public void TestWriteTypedPrimitive_Guid ()\r
- {\r
- Guid guid = new Guid ("CA761232-ED42-11CE-BACD-00AA0057B223");\r
- string expectedGuid = "ca761232-ed42-11ce-bacd-00aa0057b223";\r
-\r
- XmlSerializarionWriterTester xsw = new XmlSerializarionWriterTester ();\r
- xsw.Reset ();\r
-\r
- xsw.ExecuteWriteTypedPrimitive ("x", ANamespace, guid, false);\r
- Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,\r
- "<x xmlns='{0}'>{1}</x>", ANamespace, expectedGuid), \r
- xsw.Content, "#1");\r
-\r
- xsw.Reset ();\r
-\r
- xsw.ExecuteWriteTypedPrimitive ("x", string.Empty, guid, false);\r
- Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,\r
- "<x>{0}</x>", expectedGuid), xsw.Content, "#2");\r
-\r
- xsw.Reset ();\r
-\r
- xsw.ExecuteWriteTypedPrimitive ("x", null, guid, false);\r
- Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,\r
- "<x>{0}</x>", expectedGuid), xsw.Content, "#3");\r
-\r
- xsw.Reset ();\r
-\r
- xsw.ExecuteWriteTypedPrimitive ("x", XmlSchemaNamespace, guid, false);\r
- Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,\r
- "<x xmlns='{0}'>{1}</x>", XmlSchemaNamespace, expectedGuid),\r
- xsw.Content, "#4");\r
-\r
- xsw.Reset ();\r
-\r
- xsw.ExecuteWriteTypedPrimitive ("x", XmlSchemaInstanceNamespace, guid, false);\r
- Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,\r
- "<x xmlns='{0}'>{1}</x>", XmlSchemaInstanceNamespace, expectedGuid),\r
- xsw.Content, "#5");\r
-\r
- xsw.Reset ();\r
-\r
- xsw.ExecuteWriteTypedPrimitive (string.Empty, ANamespace, guid, false);\r
- Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,\r
- "< xmlns='{0}'>{1}</>", ANamespace, expectedGuid), \r
- xsw.Content, "#6");\r
-\r
- xsw.Reset ();\r
-\r
- xsw.ExecuteWriteTypedPrimitive (null, ANamespace, guid, false);\r
- Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,\r
- "<guid xmlns='{0}'>{1}</guid>", WsdlTypesNamespace, \r
- expectedGuid), xsw.Content, "#7");\r
- }\r
-\r
- [Test]\r
- [Category ("NotWorking")] // namespace should be wsdl types ns\r
- public void TestWriteTypedPrimitive_Guid_XsiType ()\r
- {\r
- Guid guid = new Guid ("CA761232-ED42-11CE-BACD-00AA0057B223");\r
- string expectedGuid = "ca761232-ed42-11ce-bacd-00aa0057b223";\r
-\r
- XmlSerializarionWriterTester xsw = new XmlSerializarionWriterTester ();\r
- xsw.Reset ();\r
-\r
- xsw.ExecuteWriteTypedPrimitive ("x", string.Empty, guid, true);\r
- Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,\r
- "<x xmlns:q1='{0}' d1p1:type='q1:guid' xmlns:d1p1='{1}'>{2}</x>",\r
- WsdlTypesNamespace, XmlSchemaInstanceNamespace, expectedGuid),\r
- xsw.Content, "#1");\r
-\r
- xsw.Reset ();\r
-\r
- xsw.ExecuteWriteTypedPrimitive ("x", null, guid, true);\r
- Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,\r
- "<x xmlns:q2='{0}' d1p1:type='q2:guid' xmlns:d1p1='{1}'>{2}</x>",\r
- WsdlTypesNamespace, XmlSchemaInstanceNamespace, expectedGuid),\r
- xsw.Content, "#2");\r
- }\r
-\r
- [Test]\r
- [Category ("NotWorking")] // #7 fails\r
- public void TestWriteTypedPrimitive_Int ()\r
- {\r
- XmlSerializarionWriterTester xsw = new XmlSerializarionWriterTester ();\r
- xsw.Reset ();\r
-\r
- xsw.ExecuteWriteTypedPrimitive ("x", ANamespace, 76665, false);\r
- Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,\r
- "<x xmlns='{0}'>76665</x>", ANamespace), xsw.Content, "#1");\r
-\r
- xsw.Reset ();\r
-\r
- xsw.ExecuteWriteTypedPrimitive ("x", string.Empty, -5656, false);\r
- Assert.AreEqual ("<x>-5656</x>", xsw.Content, "#2");\r
-\r
- xsw.Reset ();\r
-\r
- xsw.ExecuteWriteTypedPrimitive ("x", null, 0, false);\r
- Assert.AreEqual ("<x>0</x>", xsw.Content, "#3");\r
-\r
- xsw.Reset ();\r
-\r
- xsw.ExecuteWriteTypedPrimitive ("x", XmlSchemaNamespace, 534, false);\r
- Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,\r
- "<x xmlns='{0}'>534</x>", XmlSchemaNamespace), xsw.Content, "#4");\r
-\r
- xsw.Reset ();\r
-\r
- xsw.ExecuteWriteTypedPrimitive ("x", XmlSchemaInstanceNamespace, -6756, false);\r
- Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,\r
- "<x xmlns='{0}'>-6756</x>", XmlSchemaInstanceNamespace),\r
- xsw.Content, "#5");\r
-\r
- xsw.Reset ();\r
-\r
- xsw.ExecuteWriteTypedPrimitive (string.Empty, ANamespace, 434, false);\r
- Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,\r
- "< xmlns='{0}'>434</>", ANamespace), xsw.Content, "#6");\r
-\r
- xsw.Reset ();\r
-\r
- xsw.ExecuteWriteTypedPrimitive (null, ANamespace, 434, false);\r
- Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,\r
- "<int xmlns='{0}'>434</int>", XmlSchemaNamespace),\r
- xsw.Content, "#7");\r
- }\r
-\r
- [Test]\r
- public void TestWriteTypedPrimitive_Int_XsiType ()\r
- {\r
- XmlSerializarionWriterTester xsw = new XmlSerializarionWriterTester ();\r
- xsw.Reset ();\r
-\r
- xsw.ExecuteWriteTypedPrimitive ("x", string.Empty, -6756, true);\r
- Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,\r
- "<x xmlns:q1='{0}' d1p1:type='q1:int' xmlns:d1p1='{1}'>-6756</x>",\r
- XmlSchemaNamespace, XmlSchemaInstanceNamespace),\r
- xsw.Content, "#1");\r
-\r
- xsw.Reset ();\r
-\r
- xsw.ExecuteWriteTypedPrimitive ("x", null, 434, true);\r
- Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,\r
- "<x xmlns:q2='{0}' d1p1:type='q2:int' xmlns:d1p1='{1}'>434</x>",\r
- XmlSchemaNamespace, XmlSchemaInstanceNamespace),\r
- xsw.Content, "#2");\r
- }\r
-\r
- [Test]\r
- [Category ("NotWorking")] // #8 fails\r
- public void TestWriteTypedPrimitive_String ()\r
- {\r
- XmlSerializarionWriterTester xsw = new XmlSerializarionWriterTester ();\r
- xsw.Reset ();\r
-\r
- xsw.ExecuteWriteTypedPrimitive ("x", ANamespace, "hello", false);\r
- Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,\r
- "<x xmlns='{0}'>hello</x>", ANamespace), xsw.Content, "#1");\r
-\r
- xsw.Reset ();\r
-\r
- xsw.ExecuteWriteTypedPrimitive ("x", string.Empty, "hello", false);\r
- Assert.AreEqual ("<x>hello</x>", xsw.Content, "#2");\r
-\r
- xsw.Reset ();\r
-\r
- xsw.ExecuteWriteTypedPrimitive ("x", null, "hello", false);\r
- Assert.AreEqual ("<x>hello</x>", xsw.Content, "#3");\r
-\r
- xsw.Reset ();\r
-\r
- xsw.ExecuteWriteTypedPrimitive ("x", XmlSchemaNamespace, "hello", false);\r
- Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,\r
- "<x xmlns='{0}'>hello</x>", XmlSchemaNamespace),\r
- xsw.Content, "#4");\r
-\r
- xsw.Reset ();\r
-\r
- xsw.ExecuteWriteTypedPrimitive ("x", XmlSchemaInstanceNamespace, "hello", false);\r
- Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,\r
- "<x xmlns='{0}'>hello</x>", XmlSchemaInstanceNamespace),\r
- xsw.Content, "#5");\r
-\r
- xsw.Reset ();\r
-\r
- xsw.ExecuteWriteTypedPrimitive ("x", ANamespace, string.Empty, false);\r
- Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,\r
- "<x xmlns='{0}' />", ANamespace), xsw.Content, "#6");\r
-\r
- xsw.Reset ();\r
-\r
- xsw.ExecuteWriteTypedPrimitive (string.Empty, ANamespace, "<\"te'st\">", false);\r
- Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,\r
- "< xmlns='{0}'><\"te'st\"></>", ANamespace),\r
- xsw.Content, "#7");\r
-\r
- xsw.Reset ();\r
-\r
- xsw.ExecuteWriteTypedPrimitive (null, ANamespace, "hello", false);\r
- Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,\r
- "<string xmlns='{0}'>hello</string>", XmlSchemaNamespace),\r
- xsw.Content, "#8");\r
- }\r
-\r
- [Test]\r
- public void TestWriteTypedPrimitive_String_XsiType ()\r
- {\r
- XmlSerializarionWriterTester xsw = new XmlSerializarionWriterTester ();\r
- xsw.Reset ();\r
-\r
- xsw.ExecuteWriteTypedPrimitive ("x", string.Empty, "hello", true);\r
- Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,\r
- "<x xmlns:q1='{0}' d1p1:type='q1:string' xmlns:d1p1='{1}'>hello</x>",\r
- XmlSchemaNamespace, XmlSchemaInstanceNamespace), \r
- xsw.Content, "#1");\r
-\r
- xsw.Reset ();\r
-\r
- xsw.ExecuteWriteTypedPrimitive ("x", null, "hello", true);\r
- Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,\r
- "<x xmlns:q2='{0}' d1p1:type='q2:string' xmlns:d1p1='{1}'>hello</x>",\r
- XmlSchemaNamespace, XmlSchemaInstanceNamespace),\r
- xsw.Content, "#2");\r
- }\r
-\r
- [Test]\r
- [Category ("NotWorking")] // order of namespace declaration differs from that of MSFT\r
- public void TestWriteTypedPrimitive_String_XsiType_Namespace ()\r
- {\r
- XmlSerializarionWriterTester xsw = new XmlSerializarionWriterTester ();\r
- xsw.Reset ();\r
-\r
- xsw.ExecuteWriteTypedPrimitive ("x", ANamespace, "hello", true);\r
- Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,\r
- "<x xmlns:q1='{0}' d1p1:type='q1:string' xmlns:d1p1='{1}' xmlns='{2}'>hello</x>",\r
- XmlSchemaNamespace, XmlSchemaInstanceNamespace, ANamespace),\r
- xsw.Content, "#1");\r
-\r
- xsw.Reset ();\r
-\r
- xsw.ExecuteWriteTypedPrimitive ("x", XmlSchemaNamespace, "hello", true);\r
- Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,\r
- "<x d1p1:type='string' xmlns:d1p1='{0}' xmlns='{1}'>hello</x>",\r
- XmlSchemaInstanceNamespace, XmlSchemaNamespace),\r
- xsw.Content, "#2");\r
-\r
- xsw.Reset ();\r
-\r
- xsw.ExecuteWriteTypedPrimitive ("x", XmlSchemaInstanceNamespace, "hello", true);\r
- Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,\r
- "<x xmlns:q2='{0}' d1p1:type='q2:string' xmlns:d1p1='{1}' xmlns='{1}'>hello</x>",\r
- XmlSchemaNamespace, XmlSchemaInstanceNamespace), xsw.Content, "#3");\r
-\r
- xsw.Reset ();\r
-\r
- xsw.ExecuteWriteTypedPrimitive ("x", ANamespace, string.Empty, true);\r
- Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,\r
- "<x xmlns:q3='{0}' d1p1:type='q3:string' xmlns:d1p1='{1}' xmlns='{2}' />",\r
- XmlSchemaNamespace, XmlSchemaInstanceNamespace, ANamespace),\r
- xsw.Content, "#4");\r
-\r
- xsw.Reset ();\r
-\r
- xsw.ExecuteWriteTypedPrimitive (string.Empty, ANamespace, "<\"te'st\">", true);\r
- Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,\r
- "< xmlns:q4='{0}' d1p1:type='q4:string' xmlns:d1p1='{1}' xmlns='{2}'><\"te'st\"></>",\r
- XmlSchemaNamespace, XmlSchemaInstanceNamespace, ANamespace),\r
- xsw.Content, "#5");\r
-\r
- xsw.Reset ();\r
-\r
- xsw.ExecuteWriteTypedPrimitive (null, ANamespace, "hello", true);\r
- Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,\r
- "<string d1p1:type='string' xmlns:d1p1='{0}' xmlns='{1}'>hello</string>",\r
- XmlSchemaInstanceNamespace, XmlSchemaNamespace), \r
- xsw.Content, "#6");\r
- }\r
-\r
- [Test]\r
- [Category ("NotWorking")] // #7 fails\r
- public void TestWriteTypedPrimitive_UnsignedByte ()\r
- {\r
- XmlSerializarionWriterTester xsw = new XmlSerializarionWriterTester ();\r
- xsw.Reset ();\r
-\r
- xsw.ExecuteWriteTypedPrimitive ("x", ANamespace, (byte) 5, false);\r
- Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,\r
- "<x xmlns='{0}'>5</x>", ANamespace), xsw.Content, "#1");\r
-\r
- xsw.Reset ();\r
-\r
- xsw.ExecuteWriteTypedPrimitive ("x", string.Empty, (byte) 125, false);\r
- Assert.AreEqual ("<x>125</x>", xsw.Content, "#2");\r
-\r
- xsw.Reset ();\r
-\r
- xsw.ExecuteWriteTypedPrimitive ("x", null, (byte) 0, false);\r
- Assert.AreEqual ("<x>0</x>", xsw.Content, "#3");\r
-\r
- xsw.Reset ();\r
-\r
- xsw.ExecuteWriteTypedPrimitive ("x", XmlSchemaNamespace, (byte) 255, false);\r
- Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,\r
- "<x xmlns='{0}'>255</x>", XmlSchemaNamespace), xsw.Content, "#4");\r
-\r
- xsw.Reset ();\r
-\r
- xsw.ExecuteWriteTypedPrimitive ("x", XmlSchemaInstanceNamespace, (byte) 128, false);\r
- Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,\r
- "<x xmlns='{0}'>128</x>", XmlSchemaInstanceNamespace),\r
- xsw.Content, "#5");\r
-\r
- xsw.Reset ();\r
-\r
- xsw.ExecuteWriteTypedPrimitive (string.Empty, ANamespace, (byte) 1, false);\r
- Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,\r
- "< xmlns='{0}'>1</>", ANamespace), xsw.Content, "#6");\r
-\r
- xsw.Reset ();\r
-\r
- xsw.ExecuteWriteTypedPrimitive (null, ANamespace, (byte) 99, false);\r
- Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,\r
- "<unsignedByte xmlns='{0}'>99</unsignedByte>",\r
- XmlSchemaNamespace), xsw.Content, "#7");\r
- }\r
-\r
- [Test]\r
- public void TestWriteTypedPrimitive_UnsignedByte_XsiType ()\r
- {\r
- XmlSerializarionWriterTester xsw = new XmlSerializarionWriterTester ();\r
- xsw.Reset ();\r
-\r
- xsw.ExecuteWriteTypedPrimitive ("x", string.Empty, (byte) 5, true);\r
- Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,\r
- "<x xmlns:q1='{0}' d1p1:type='q1:unsignedByte' xmlns:d1p1='{1}'>5</x>",\r
- XmlSchemaNamespace, XmlSchemaInstanceNamespace),\r
- xsw.Content, "#1");\r
-\r
- xsw.Reset ();\r
-\r
- xsw.ExecuteWriteTypedPrimitive ("x", null, (byte) 99, true);\r
- Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,\r
- "<x xmlns:q2='{0}' d1p1:type='q2:unsignedByte' xmlns:d1p1='{1}'>99</x>",\r
- XmlSchemaNamespace, XmlSchemaInstanceNamespace),\r
- xsw.Content, "#2");\r
- }\r
-\r
- [Test]\r
- [Category ("NotWorking")] // #A7 fails\r
- public void TestWriteTypedPrimitive_XmlQualifiedName ()\r
- {\r
- XmlQualifiedName qname = new XmlQualifiedName ("something", AnotherNamespace);\r
-\r
- XmlSerializarionWriterTester xsw = new XmlSerializarionWriterTester ();\r
- xsw.Reset ();\r
-\r
- xsw.ExecuteWriteTypedPrimitive ("x", ANamespace, qname, false);\r
- Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,\r
- "<x xmlns:q1='{0}' xmlns='{1}'>q1:something</x>", \r
- AnotherNamespace, ANamespace), xsw.Content, "#A1");\r
-\r
- xsw.Reset ();\r
-\r
- xsw.ExecuteWriteTypedPrimitive ("x", string.Empty, qname, false);\r
- Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,\r
- "<x xmlns:q2='{0}'>q2:something</x>",\r
- AnotherNamespace), xsw.Content, "#A2");\r
-\r
- xsw.Reset ();\r
-\r
- xsw.ExecuteWriteTypedPrimitive ("x", null, qname, false);\r
- Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,\r
- "<x xmlns:q3='{0}'>q3:something</x>", AnotherNamespace), \r
- xsw.Content, "#A3");\r
-\r
- xsw.Reset ();\r
-\r
- xsw.ExecuteWriteTypedPrimitive ("x", XmlSchemaNamespace, qname, false);\r
- Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,\r
- "<x xmlns:q4='{0}' xmlns='{1}'>q4:something</x>", AnotherNamespace, \r
- XmlSchemaNamespace), xsw.Content, "#A4");\r
-\r
- xsw.Reset ();\r
-\r
- xsw.ExecuteWriteTypedPrimitive ("x", XmlSchemaInstanceNamespace, qname, false);\r
- Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,\r
- "<x xmlns:q5='{0}' xmlns='{1}'>q5:something</x>", AnotherNamespace, \r
- XmlSchemaInstanceNamespace), xsw.Content, "#A5");\r
-\r
- xsw.Reset ();\r
-\r
- xsw.ExecuteWriteTypedPrimitive (string.Empty, ANamespace, qname, false);\r
- Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,\r
- "< xmlns:q6='{0}' xmlns='{1}'>q6:something</>", AnotherNamespace,\r
- ANamespace), xsw.Content, "#A6");\r
-\r
- xsw.Reset ();\r
-\r
- xsw.ExecuteWriteTypedPrimitive (null, ANamespace, qname, false);\r
- Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,\r
- "<QName xmlns:q7='{0}' xmlns='{1}'>q7:something</QName>",\r
- AnotherNamespace, XmlSchemaNamespace), xsw.Content, "#A7");\r
-\r
- xsw.Reset ();\r
-\r
- qname = new XmlQualifiedName ("else");\r
-\r
- xsw.ExecuteWriteTypedPrimitive ("x", ANamespace, qname, false);\r
- Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,\r
- "<x xmlns='{0}'>else</x>", ANamespace), xsw.Content, "#B1");\r
-\r
- xsw.Reset ();\r
-\r
- xsw.ExecuteWriteTypedPrimitive ("x", string.Empty, qname, false);\r
- Assert.AreEqual ("<x>else</x>", xsw.Content, "#B2");\r
-\r
- xsw.Reset ();\r
-\r
- xsw.ExecuteWriteTypedPrimitive ("x", null, qname, false);\r
- Assert.AreEqual ("<x>else</x>", xsw.Content, "#B3");\r
-\r
- xsw.Reset ();\r
-\r
- xsw.ExecuteWriteTypedPrimitive ("x", XmlSchemaNamespace, qname, false);\r
- Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,\r
- "<x xmlns='{0}'>else</x>", XmlSchemaNamespace), xsw.Content, "#B4");\r
-\r
- xsw.Reset ();\r
-\r
- xsw.ExecuteWriteTypedPrimitive ("x", XmlSchemaInstanceNamespace, qname, false);\r
- Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,\r
- "<x xmlns='{0}'>else</x>", XmlSchemaInstanceNamespace), \r
- xsw.Content, "#B5");\r
-\r
- xsw.Reset ();\r
-\r
- xsw.ExecuteWriteTypedPrimitive (string.Empty, ANamespace, qname, false);\r
- Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,\r
- "< xmlns='{0}'>else</>", ANamespace), xsw.Content, "#B6");\r
-\r
- xsw.Reset ();\r
-\r
- xsw.ExecuteWriteTypedPrimitive (null, ANamespace, qname, false);\r
- Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,\r
- "<QName xmlns='{0}'>else</QName>", XmlSchemaNamespace), \r
- xsw.Content, "#B7");\r
- }\r
-\r
- [Test]\r
- [ExpectedException (typeof (NullReferenceException))]\r
- public void TestWriteTypedPrimitive_Null_Value()\r
- {\r
- WriteTypedPrimitive("x", ANamespace, null, false);\r
- }\r
-\r
- [Test]\r
- [Category ("NotWorking")] // InvalidOperatinException is not thrown\r
- [ExpectedException (typeof (InvalidOperationException))]\r
- public void TestWriteTypedPrimitive_NonPrimitive ()\r
- {\r
- // The type System.Version was not expected. Use the XmlInclude\r
- // or SoapInclude attribute to specify types that are not known\r
- // statically.\r
- WriteTypedPrimitive ("x", ANamespace, new Version (), false);\r
- }\r
-\r
- [Test]\r
- public void TestWriteValue()\r
- {\r
- WriteValue("");\r
- Assert.AreEqual ("", Content);\r
-\r
- Reset();\r
- WriteValue("hello");\r
- Assert.AreEqual ("hello", Content);\r
-\r
- Reset();\r
- string v = null;\r
- WriteValue(v);\r
- Assert.AreEqual ("", Content);\r
-\r
- Reset();\r
- WriteValue(new byte[] {13, 8, 99});\r
- Assert.AreEqual ("DQhj", Content);\r
- }\r
-\r
- public void TestWriteXmlAttribute()\r
- {\r
- // FIXME\r
- // XmlNode related\r
- }\r
-\r
- [Test]\r
- public void TestWriteXsiType()\r
- {\r
- WriteStartElement("x");\r
- WriteXsiType("pref", null);\r
- WriteEndElement();\r
- Assert.AreEqual (string.Format(CultureInfo.InvariantCulture,\r
- "<x d1p1:type='pref' xmlns:d1p1='{0}' />", XmlSchemaInstanceNamespace),\r
- Content, "#1");\r
-\r
- Reset ();\r
-\r
- WriteStartElement ("x");\r
- WriteXsiType ("int", XmlSchemaNamespace);\r
- WriteEndElement ();\r
- Assert.AreEqual (string.Format(CultureInfo.InvariantCulture,\r
- "<x xmlns:q2='{0}' d1p1:type='q2:int' xmlns:d1p1='{1}' />",\r
- XmlSchemaNamespace, XmlSchemaInstanceNamespace),\r
- Content, "#2");\r
-\r
- Reset ();\r
-\r
- WriteStartElement ("x");\r
- WriteXsiType ("int", ANamespace);\r
- WriteEndElement ();\r
- Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,\r
- "<x xmlns:q3='{0}' d1p1:type='q3:int' xmlns:d1p1='{1}' />",\r
- ANamespace, XmlSchemaInstanceNamespace), Content, "#3");\r
-\r
- Reset ();\r
-\r
- WriteStartElement ("x");\r
- WriteXsiType ("int", XmlSchemaInstanceNamespace);\r
- WriteEndElement ();\r
- Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,\r
- "<x xmlns:q4='{0}' q4:type='q4:int' />",\r
- XmlSchemaInstanceNamespace), Content, "#4");\r
-\r
- Reset ();\r
-\r
- WriteStartElement ("x");\r
- WriteXsiType ("int", string.Empty);\r
- WriteEndElement ();\r
- Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,\r
- "<x d1p1:type='int' xmlns:d1p1='{0}' />", XmlSchemaInstanceNamespace),\r
- Content, "#5");\r
-\r
- Reset ();\r
-\r
- WriteStartElement ("x");\r
- WriteXsiType (string.Empty, null);\r
- WriteEndElement ();\r
- Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,\r
- "<x d1p1:type='' xmlns:d1p1='{0}' />", XmlSchemaInstanceNamespace),\r
- Content, "#6");\r
-\r
- Reset ();\r
-\r
- WriteStartElement ("x");\r
- WriteXsiType (null, null);\r
- WriteEndElement ();\r
- Assert.AreEqual ("<x />", Content, "#7");\r
- }\r
-\r
- [Test]\r
- [Category ("NotWorking")] // order of namespace declaration differs from that of MSFT\r
- public void TestWriteXsiType_Namespace ()\r
- {\r
- WriteStartElement ("x", ANamespace);\r
- WriteXsiType ("pref", null);\r
- WriteEndElement ();\r
- Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,\r
- "<x d1p1:type='pref' xmlns:d1p1='{0}' xmlns='{1}' />", \r
- XmlSchemaInstanceNamespace, ANamespace), Content, "#1");\r
-\r
- Reset ();\r
-\r
- WriteStartElement ("x", ANamespace);\r
- WriteXsiType ("int", XmlSchemaNamespace);\r
- WriteEndElement ();\r
- Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,\r
- "<x xmlns:q5='{0}' d1p1:type='q5:int' xmlns:d1p1='{1}' xmlns='{2}' />",\r
- XmlSchemaNamespace, XmlSchemaInstanceNamespace, ANamespace),\r
- Content, "#2");\r
-\r
- Reset ();\r
-\r
- WriteStartElement ("x", ANamespace);\r
- WriteXsiType ("int", ANamespace);\r
- WriteEndElement ();\r
- Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,\r
- "<x d1p1:type='int' xmlns:d1p1='{1}' xmlns='{2}' />",\r
- ANamespace, XmlSchemaInstanceNamespace, ANamespace), \r
- Content, "#3");\r
-\r
- Reset ();\r
-\r
- WriteStartElement ("x", ANamespace);\r
- WriteXsiType ("int", XmlSchemaInstanceNamespace);\r
- WriteEndElement ();\r
- Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,\r
- "<x xmlns:q6='{0}' q6:type='q6:int' xmlns='{1}' />",\r
- XmlSchemaInstanceNamespace, ANamespace), Content, "#4");\r
-\r
- Reset ();\r
-\r
- WriteStartElement ("x", ANamespace);\r
- WriteXsiType ("int", string.Empty);\r
- WriteEndElement ();\r
- Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,\r
- "<x d1p1:type='int' xmlns:d1p1='{0}' xmlns='{1}' />",\r
- XmlSchemaInstanceNamespace, ANamespace), Content, "#5");\r
-\r
- Reset ();\r
-\r
- WriteStartElement ("x", ANamespace);\r
- WriteXsiType (string.Empty, null);\r
- WriteEndElement ();\r
- Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,\r
- "<x d1p1:type='' xmlns:d1p1='{0}' xmlns='{1}' />",\r
- XmlSchemaInstanceNamespace, ANamespace), Content, "#6");\r
-\r
- Reset ();\r
-\r
- WriteStartElement ("x", ANamespace);\r
- WriteXsiType (null, null);\r
- WriteEndElement ();\r
- Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,\r
- "<x xmlns='{0}' />", ANamespace), Content, "#7");\r
- }\r
-\r
-\r
-#if NET_2_0\r
- [Test]\r
- public void TestFromEnum_Null_TypeName ()\r
- {\r
- string[] values = { "one", "two", "three", "four" };\r
- long[] ids = { 1, 2, 3, 4 };\r
-\r
- Assert.AreEqual ("one", FromEnum (1, values, ids, (string) null));\r
- }\r
-\r
- [Test]\r
- public void TestCreateInvalidEnumValueException ()\r
- {\r
- Exception ex = CreateInvalidEnumValueException("AnInvalidValue", "SomeType");\r
- Assert.IsNotNull (ex, "#1");\r
- Assert.AreEqual (typeof (InvalidOperationException), ex.GetType (), "#2");\r
- Assert.IsNotNull (ex.Message, "#3");\r
- Assert.IsTrue (ex.Message.IndexOf ("AnInvalidValue") != -1, "#4");\r
- Assert.IsTrue (ex.Message.IndexOf ("SomeType") != -1, "#5");\r
- }\r
-#endif\r
- }\r
-}\r
+//
+// MonoTests.System.Xml.Serialization.XmlSerializationWriterTests
+//
+// Author: Erik LeBel <eriklebel@yahoo.ca>
+//
+// (C) Erik LeBel 2003
+//
+// FIXME add tests for callbacks
+// FIXME add tests for writes that generate namespaces
+// FIXME add test that write XmlNode objects
+//
+
+using System;
+using System.Globalization;
+using System.IO;
+using System.Xml;
+using System.Xml.Serialization;
+
+using NUnit.Framework;
+
+using MonoTests.System.Xml.TestClasses;
+
+namespace MonoTests.System.XmlSerialization
+{
+ // base, common implementation of XmlSerializationWriter test harness.
+ // the reason for this is that all auto generated namespace prefixes
+ // of the form q# are modified by any Write* that defines a new namespace.
+ // The result of this is that even though we redefine the string results
+ // to exclude previous tests, the q#s will change depending on number of
+ // namespace declarations were made prior to the perticual test. This
+ // means that if the [Test] methods are called out of sequence, they
+ // all start to fail. For this reason, tests that define and verify
+ // temporary namespaces should be stored in a seperate class which protects
+ // itself from accidental pre-definitions.
+ public class XmlSerializarionWriterTester : XmlSerializationWriter
+ {
+ // appease the compiler
+ protected override void InitCallbacks ()
+ {
+ }
+
+ StringWriter sw;
+ XmlTextWriter writer;
+
+ [SetUp]
+ public void Reset()
+ {
+ sw = new StringWriter ();
+ writer = new XmlTextWriter (sw);
+ writer.QuoteChar = '\'';
+ writer.Formatting = Formatting.None;
+ Writer = writer;
+ }
+
+ public string Content
+ {
+ get
+ {
+ string val = sw.GetStringBuilder().ToString();
+ return val;
+ }
+ }
+
+ public void ExecuteWritePotentiallyReferencingElement (string name, string ns, object o, Type ambientType, bool suppressReference, bool isNullable)
+ {
+ WritePotentiallyReferencingElement (name, ns, o, ambientType, suppressReference, isNullable);
+ }
+
+ public void ExecuteWriteTypedPrimitive (string name, string ns, object o, bool xsiType)
+ {
+ WriteTypedPrimitive (name, ns, o, xsiType);
+ }
+ }
+
+ // this class tests the methods of the XmlSerializationWriter that
+ // can be executed out of order.
+ [TestFixture]
+ public class XmlSerializationWriterSimpleTests : XmlSerializarionWriterTester
+ {
+ const string XmlSchemaNamespace = "http://www.w3.org/2001/XMLSchema";
+ const string XmlSchemaInstanceNamespace = "http://www.w3.org/2001/XMLSchema-instance";
+ const string SoapEncodingNamespace = "http://schemas.xmlsoap.org/soap/encoding/";
+ const string WsdlTypesNamespace = "http://microsoft.com/wsdl/types/";
+ const string ANamespace = "some:urn";
+ const string AnotherNamespace = "another:urn";
+
+ // These TestFrom* methods indirectly test the functionality of XmlCustomFormatter
+
+ [Test]
+ public void TestFromByteArrayBase64()
+ {
+ // FIXME
+ // This should work according to Mono's API, but .NET's FromByteArrayBase64
+ // returns a byte array.
+ //
+ //string val = this.FromByteArrayBase64(new byte [] {143, 144, 1, 0});
+ //Assert.AreEqual (FromByteArrayBase64(null), "");
+
+ //val = FromByteArrayBase64(null);
+ //try/catch or AssertEruals?
+ }
+
+ [Test]
+ public void TestFromByteArrayHex()
+ {
+ byte [] vals = {143, 144, 1, 0};
+ Assert.AreEqual ("8F900100", FromByteArrayHex(vals));
+ Assert.IsNull (FromByteArrayHex (null));
+ }
+
+ [Test]
+ public void TestFromChar()
+ {
+ Assert.AreEqual ("97", FromChar ('a'));
+ Assert.AreEqual ("0", FromChar ('\0'));
+ Assert.AreEqual ("10", FromChar ('\n'));
+ Assert.AreEqual ("65281", FromChar ('\uFF01'));
+ }
+
+ [Test]
+ public void TestFromDate()
+ {
+ DateTime d = new DateTime();
+ Assert.AreEqual ("0001-01-01", FromDate (d));
+ }
+
+ [Test]
+ public void TestFromDateTime()
+ {
+ DateTime d = new DateTime();
+ Assert.AreEqual ("0001-01-01T00:00:00.0000000", FromDateTime (d).Substring (0, 27));
+ }
+
+ [Test] // bug #77500
+ public void TestFromEnum()
+ {
+ long[] ids = {1, 2, 3, 4};
+ string[] values = {"one", "two", "three"};
+
+ Assert.AreEqual ("one", FromEnum (1, values, ids), "#1");
+ Assert.AreEqual (string.Empty, FromEnum (0, values, ids), "#2");
+ Assert.AreEqual ("one two", FromEnum (3, values, ids), "#3");
+
+ try {
+ string dummy = FromEnum(4, values, ids);
+ Assert.Fail("#4");
+ } catch (IndexOutOfRangeException) {
+ }
+
+ string[] correctValues = {"one", "two", "three", "four"};
+ Assert.AreEqual ("four", FromEnum (4, correctValues, ids), "#5");
+ Assert.AreEqual ("one four", FromEnum (5, correctValues, ids), "#6");
+ Assert.AreEqual ("two four", FromEnum (6, correctValues, ids), "#7");
+ Assert.AreEqual ("one two three four", FromEnum (7, correctValues, ids), "#8");
+
+ string[] flagValues = {"one", "two", "four", "eight"};
+ long[] flagIDs = {1, 2, 4, 8};
+ Assert.AreEqual (string.Empty, FromEnum (0, flagValues, flagIDs), "#9");
+ Assert.AreEqual ("two", FromEnum (2, flagValues, flagIDs), "#10");
+ Assert.AreEqual ("four", FromEnum (4, flagValues, flagIDs), "#1");
+ Assert.AreEqual ("one four", FromEnum (5, flagValues, flagIDs), "#12");
+ Assert.AreEqual ("two four", FromEnum (6, flagValues, flagIDs), "#13");
+ Assert.AreEqual ("one two four", FromEnum (7, flagValues, flagIDs), "#14");
+ Assert.AreEqual ("eight", FromEnum (8, flagValues, flagIDs), "#15");
+ Assert.AreEqual ("one four eight", FromEnum (13, flagValues, flagIDs), "#16");
+
+ string[] unorderedValues = {"one", "four", "two", "zero"};
+ long[] unorderedIDs = {1, 4, 2, 0};
+
+ Assert.AreEqual (string.Empty, FromEnum (0, unorderedValues, unorderedIDs), "#17");
+ Assert.AreEqual ("two", FromEnum (2, unorderedValues, unorderedIDs), "#18");
+ Assert.AreEqual ("four", FromEnum (4, unorderedValues, unorderedIDs), "#19");
+ Assert.AreEqual ("one four", FromEnum (5, unorderedValues, unorderedIDs), "#20");
+ Assert.AreEqual ("four two", FromEnum (6, unorderedValues, unorderedIDs), "#21");
+ Assert.AreEqual ("one four two", FromEnum (7, unorderedValues, unorderedIDs), "#22");
+
+ string[] zeroValues = {"zero", "ten"};
+ long[] zeroIDs = {0, 10};
+
+ Assert.AreEqual ("zero", FromEnum (0, zeroValues, zeroIDs), "#9");
+ Assert.AreEqual ("ten", FromEnum (10, zeroValues, zeroIDs), "#9");
+
+ string[] reverseZeroValues = {"", "zero"};
+ long[] reverseZeroIDs = {4, 0};
+ Assert.AreEqual (string.Empty, FromEnum (0, reverseZeroValues, reverseZeroIDs), "#9");
+ Assert.AreEqual ("zero", FromEnum (4, reverseZeroValues, reverseZeroIDs), "#9");
+
+ string[] emptyValues = { "zero" };
+ long[] emptyIDs = {0};
+ Assert.AreEqual ("zero", FromEnum (0, emptyValues, emptyIDs), "#9");
+ }
+
+ [Test]
+ public void TestFromEnum_InvalidValue ()
+ {
+ long[] ids = {1, 2, 3, 4};
+ string[] values = {"one", "two", "three", "four"};
+
+#if NET_2_0
+ try {
+ FromEnum (8, values, ids);
+ Assert.Fail ("#A1");
+ } catch (InvalidOperationException ex) {
+ Assert.AreEqual (typeof (InvalidOperationException), ex.GetType (), "#A2");
+ Assert.IsNotNull (ex.Message, "#A3");
+ Assert.IsTrue (ex.Message.IndexOf ("'8'") != -1, "#A4");
+ Assert.IsNull (ex.InnerException, "#A5");
+ }
+#else
+ Assert.AreEqual ("8", FromEnum (8, values, ids), "#A6");
+#endif
+
+#if NET_2_0
+ try {
+ FromEnum (8, values, ids, "Some.Type.Name");
+ Assert.Fail ("#B1");
+ } catch (InvalidOperationException ex) {
+ Assert.AreEqual (typeof (InvalidOperationException), ex.GetType (), "#B2");
+ Assert.IsNotNull (ex.Message, "#B3");
+ Assert.IsTrue (ex.Message.IndexOf ("'8'") != -1, "#B4");
+ Assert.IsTrue (ex.Message.IndexOf ("Some.Type.Name") != -1, "#B5");
+ Assert.IsNull (ex.InnerException, "#B6");
+ }
+#endif
+ }
+
+ [Test]
+ [ExpectedException (typeof (NullReferenceException))]
+ public void TestFromEnum_Null_Values ()
+ {
+ long[] ids = { 1, 2, 3, 4 };
+ string[] values = { "one", "two", "three", "four" };
+
+ FromEnum (1, (string[]) null, ids);
+ }
+
+ [Test]
+ [ExpectedException (typeof (NullReferenceException))]
+ public void TestFromEnum_Null_IDs ()
+ {
+ string[] values = { "one", "two", "three", "four" };
+
+ FromEnum (1, values, (long[]) null);
+ }
+
+ [Test]
+ public void TestFromTime()
+ {
+ DateTime d = new DateTime();
+ // Don't include time zone.
+ Assert.AreEqual ("00:00:00.0000000", FromTime (d).Substring (0, 16));
+ }
+
+ [Test]
+ public void TestFromXmlName()
+ {
+ Assert.AreEqual ("Hello", FromXmlName ("Hello"));
+ Assert.AreEqual ("go_x0020_dogs_x0020_go", FromXmlName ("go dogs go"));
+ Assert.AreEqual ("what_x0027_s_x0020_up", FromXmlName ("what's up"));
+ Assert.AreEqual ("_x0031_23go", FromXmlName ("123go"));
+ Assert.AreEqual ("Hello_x0020_what_x0027_s.up", FromXmlName ("Hello what's.up"));
+ }
+
+ [Test]
+ public void TestFromXmlNCName()
+ {
+ Assert.AreEqual ("Hello", FromXmlNCName ("Hello"));
+ Assert.AreEqual ("go_x0020_dogs_x0020_go", FromXmlNCName ("go dogs go"));
+ Assert.AreEqual ("what_x0027_s_x0020_up", FromXmlNCName ("what's up"));
+ Assert.AreEqual ("_x0031_23go", FromXmlNCName ("123go"));
+ Assert.AreEqual ("Hello_x0020_what_x0027_s.up", FromXmlNCName ("Hello what's.up"));
+ }
+
+ [Test]
+ public void TestFromXmlNmToken()
+ {
+ Assert.AreEqual ("Hello", FromXmlNmToken ("Hello"));
+ Assert.AreEqual ("go_x0020_dogs_x0020_go", FromXmlNmToken ("go dogs go"));
+ Assert.AreEqual ("what_x0027_s_x0020_up", FromXmlNmToken ("what's up"));
+ Assert.AreEqual ("123go", FromXmlNmToken ("123go"));
+ Assert.AreEqual ("Hello_x0020_what_x0027_s.up", FromXmlNmToken ("Hello what's.up"));
+ }
+
+ [Test]
+ public void TestFromXmlNmTokens()
+ {
+ Assert.AreEqual ("Hello go dogs_go 123go what_x0027_s.up", FromXmlNmTokens ("Hello go dogs_go 123go what's.up"));
+ }
+
+ [Test]
+ public void TestWriteAttribute()
+ {
+ WriteStartElement("x");
+ WriteAttribute("a", "b");
+ WriteEndElement();
+ Assert.AreEqual ("<x a='b' />", Content);
+
+ Reset();
+ WriteStartElement("x");
+ WriteAttribute("a", new byte[] {1, 2, 3});
+ WriteEndElement();
+ Assert.AreEqual ("<x a='AQID' />", Content);
+
+ Reset();
+ WriteStartElement("x");
+ WriteAttribute("a", "<b");
+ WriteEndElement();
+ Assert.AreEqual ("<x a='<b' />", Content);
+
+ Reset();
+ WriteStartElement("x");
+ string typedPlaceholder = null;
+ WriteAttribute("a", typedPlaceholder);
+ WriteEndElement();
+ Assert.AreEqual ("<x />", Content);
+
+ Reset();
+ WriteStartElement("x");
+ WriteAttribute("a", "\"");
+ WriteEndElement();
+ Assert.AreEqual ("<x a='\"' />", Content);
+
+ Reset();
+ WriteStartElement("x");
+ WriteAttribute("a", "b\nc");
+ WriteEndElement();
+ Assert.AreEqual ("<x a='b
c' />", Content);
+
+ Reset();
+ WriteStartElement("x");
+ WriteAttribute("a", ANamespace, "b");
+ WriteEndElement();
+ Assert.AreEqual ("<x d1p1:a='b' xmlns:d1p1='some:urn' />", Content);
+ }
+
+ [Test]
+ public void TestWriteElementEncoded()
+ {
+ // FIXME
+ // XmlNode related
+ }
+
+ [Test]
+ public void TestWriteElementLiteral()
+ {
+ // FIXME
+ // XmlNode related
+ }
+
+ [Test]
+ public void TestWriteElementString()
+ {
+ WriteElementString("x", "a");
+ Assert.AreEqual ("<x>a</x>", Content);
+
+ Reset();
+ WriteElementString("x", "<a");
+ Assert.AreEqual ("<x><a</x>", Content);
+ }
+
+ [Test]
+ public void TestWriteElementStringRaw()
+ {
+ byte [] placeHolderArray = null;
+ WriteElementStringRaw("x", placeHolderArray);
+ Assert.AreEqual ("", Content);
+
+ Reset();
+ WriteElementStringRaw("x", new byte[] {0, 2, 4});
+ Assert.AreEqual ("<x>AAIE</x>", Content);
+
+ Reset();
+ WriteElementStringRaw("x", new byte[] {});
+ Assert.AreEqual ("<x />", Content);
+
+ // Note to reader, the output is not valid xml
+ Reset();
+ WriteElementStringRaw("x", "a > 13 && a < 19");
+ Assert.AreEqual ("<x>a > 13 && a < 19</x>", Content);
+ }
+
+ [Test]
+ public void TestWriteEmptyTag()
+ {
+ WriteEmptyTag("x");
+ Assert.AreEqual ("<x />", Content);
+ }
+
+ [Test]
+ public void TestWriteNamespaceDeclarations()
+ {
+ XmlSerializerNamespaces ns = new XmlSerializerNamespaces();
+
+ WriteStartElement("x");
+ WriteNamespaceDeclarations(ns);
+ WriteEndElement();
+ Assert.AreEqual ("<x />", Content);
+
+ Reset();
+ ns.Add("mypref", ANamespace);
+ WriteStartElement("x");
+ WriteNamespaceDeclarations(ns);
+ WriteEndElement();
+ Assert.AreEqual (XmlSerializerTests.Infoset("<x xmlns:mypref='some:urn' />"), XmlSerializerTests.Infoset(Content));
+
+ Reset();
+ ns.Add("ns2", "another:urn");
+ WriteStartElement("x");
+ WriteNamespaceDeclarations(ns);
+ WriteEndElement();
+ Assert.AreEqual (XmlSerializerTests.Infoset("<x xmlns:ns2='another:urn' xmlns:mypref='some:urn' />"), XmlSerializerTests.Infoset(Content));
+
+ Reset();
+ ns.Add("ns3", "ya:urn");
+ WriteStartElement("x");
+ WriteNamespaceDeclarations(ns);
+ WriteEndElement();
+ Assert.AreEqual (XmlSerializerTests.Infoset("<x xmlns:ns3='ya:urn' xmlns:ns2='another:urn' xmlns:mypref='some:urn' />"), XmlSerializerTests.Infoset(Content));
+ }
+
+ [Test]
+ public void TestWriteNullableStringLiteral()
+ {
+ WriteNullableStringLiteral("x", null, null);
+ Assert.AreEqual (XmlSerializerTests.Infoset("<x d1p1:nil='true' xmlns:d1p1='http://www.w3.org/2001/XMLSchema-instance' />"), XmlSerializerTests.Infoset(Content));
+
+ Reset();
+ WriteNullableStringLiteral("x", null, "");
+ Assert.AreEqual ("<x />", Content);
+
+ Reset();
+ WriteNullableStringLiteral("x", null, "a<b\'c");
+ Assert.AreEqual ("<x>a<b\'c</x>", Content);
+
+ Reset();
+ WriteNullableStringLiteral("x", ANamespace, "b");
+ Assert.AreEqual ("<x xmlns='some:urn'>b</x>", Content);
+ }
+
+ [Test]
+ public void TestWriteNullableStringLiteralRaw()
+ {
+ WriteNullableStringLiteralRaw("x", null, new byte[] {1, 2, 244});
+ Assert.AreEqual ("<x>AQL0</x>", Content);
+ }
+
+ [Test]
+ public void TestWriteNullTagEncoded()
+ {
+ WriteNullTagEncoded("x");
+ Assert.AreEqual (XmlSerializerTests.Infoset("<x d1p1:nil='true' xmlns:d1p1='http://www.w3.org/2001/XMLSchema-instance' />"), XmlSerializerTests.Infoset(Content));
+ }
+
+ [Test]
+ public void TestWriteNullTagLiteral()
+ {
+ WriteNullTagLiteral("x");
+ Assert.AreEqual (XmlSerializerTests.Infoset("<x d1p1:nil='true' xmlns:d1p1='http://www.w3.org/2001/XMLSchema-instance' />"), XmlSerializerTests.Infoset(Content));
+ }
+
+ [Test]
+ [Category ("NotWorking")]
+ public void TestWritePotentiallyReferencingElement ()
+ {
+ XmlSerializarionWriterTester xsw = new XmlSerializarionWriterTester ();
+ xsw.Reset ();
+
+ xsw.ExecuteWritePotentiallyReferencingElement ("x", ANamespace, EnumDefaultValue.e1, typeof (EnumDefaultValue), true, false);
+ Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
+ "<x xmlns='{0}'>1</x>", ANamespace), xsw.Content, "#1");
+
+ xsw.Reset ();
+
+ xsw.ExecuteWritePotentiallyReferencingElement ("x", ANamespace, (int) 1, typeof (EnumDefaultValue), true, false);
+ Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
+ "<x xmlns:q1='{0}' d1p1:type='q1:int' xmlns:d1p1='{1}' xmlns='{2}'>1</x>",
+ XmlSchemaNamespace, XmlSchemaInstanceNamespace, ANamespace),
+ xsw.Content, "#2");
+
+ xsw.Reset ();
+
+ xsw.ExecuteWritePotentiallyReferencingElement ("x", ANamespace, "something", typeof (string), true, false);
+ Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
+ "<x xmlns='{0}'>something</x>", ANamespace), xsw.Content, "#3");
+
+ xsw.Reset ();
+
+ xsw.ExecuteWritePotentiallyReferencingElement ("x", ANamespace, "something", null, true, false);
+ Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
+ "<x xmlns:q2='{0}' d1p1:type='q2:string' xmlns:d1p1='{1}' xmlns='{2}'>something</x>",
+ XmlSchemaNamespace, XmlSchemaInstanceNamespace, ANamespace),
+ xsw.Content, "#2");
+
+ xsw.Reset ();
+
+ xsw.ExecuteWritePotentiallyReferencingElement ("x", ANamespace, new string[] { "A", "B" }, typeof (string[]), true, false);
+ Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
+ "<q3:Array id='id1' xmlns:q4='{0}' q3:arrayType='q4:string[2]' xmlns:q3='{1}'>" +
+ "<Item>A</Item>" +
+ "<Item>B</Item>" +
+ "</q3:Array>", XmlSchemaNamespace, SoapEncodingNamespace), xsw.Content, "#5");
+ }
+
+ [Test]
+ public void TestWriteSerializable()
+ {
+ // FIXME
+ //Assert.AreEqual (, "");
+ }
+
+ [Test]
+ public void TestWriteStartDocument()
+ {
+ Assert.AreEqual ("", Content);
+
+ WriteStartDocument();
+ Assert.AreEqual ("<?xml version='1.0' encoding='utf-16'?>", Content);
+ }
+
+ [Test]
+ public void TestWriteStartElement()
+ {
+ WriteStartElement("x");
+ WriteEndElement();
+ Assert.AreEqual ("<x />", Content);
+
+ Reset();
+ WriteStartElement("x");
+ WriteValue("a");
+ WriteEndElement();
+ Assert.AreEqual ("<x>a</x>", Content);
+
+ Reset();
+ WriteStartElement("x");
+ WriteStartElement("y", "z");
+ WriteEndElement();
+ WriteEndElement();
+ Assert.AreEqual ("<x><y xmlns='z' /></x>", Content);
+
+ Reset();
+ WriteStartElement("x");
+ WriteStartElement("y", "z", true);
+ WriteEndElement();
+ WriteEndElement();
+ Assert.AreEqual ("<x><q1:y xmlns:q1='z' /></x>", Content);
+ }
+
+ [Test]
+ [Category ("NotWorking")] // #7 fails
+ public void TestWriteTypedPrimitive_Base64Binary ()
+ {
+ byte[] byteArray = new byte[] { 255, 20, 10, 5, 0, 7 };
+ string expected = "/xQKBQAH";
+
+ XmlSerializarionWriterTester xsw = new XmlSerializarionWriterTester ();
+ xsw.Reset ();
+
+ xsw.ExecuteWriteTypedPrimitive ("x", ANamespace, byteArray, false);
+ Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
+ "<x xmlns='{0}'>{1}</x>", ANamespace, expected),
+ xsw.Content, "#1");
+
+ xsw.Reset ();
+
+ xsw.ExecuteWriteTypedPrimitive ("x", string.Empty, byteArray, false);
+ Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
+ "<x>{0}</x>", expected), xsw.Content, "#2");
+
+ xsw.Reset ();
+
+ xsw.ExecuteWriteTypedPrimitive ("x", null, byteArray, false);
+ Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
+ "<x>{0}</x>", expected), xsw.Content, "#3");
+
+ xsw.Reset ();
+
+ xsw.ExecuteWriteTypedPrimitive ("x", XmlSchemaNamespace, byteArray, false);
+ Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
+ "<x xmlns='{0}'>{1}</x>", XmlSchemaNamespace, expected),
+ xsw.Content, "#4");
+
+ xsw.Reset ();
+
+ xsw.ExecuteWriteTypedPrimitive ("x", XmlSchemaInstanceNamespace, byteArray, false);
+ Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
+ "<x xmlns='{0}'>{1}</x>", XmlSchemaInstanceNamespace, expected),
+ xsw.Content, "#5");
+
+ xsw.Reset ();
+
+ xsw.ExecuteWriteTypedPrimitive (string.Empty, ANamespace, byteArray, false);
+ Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
+ "< xmlns='{0}'>{1}</>", ANamespace, expected), xsw.Content, "#6");
+
+ xsw.Reset ();
+
+ xsw.ExecuteWriteTypedPrimitive (null, ANamespace, byteArray, false);
+ Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
+ "<base64Binary xmlns='{0}'>{1}</base64Binary>",
+ XmlSchemaNamespace, expected), xsw.Content, "#7");
+ }
+
+ [Test]
+ public void TestWriteTypedPrimitive_Base64Binary_XsiType ()
+ {
+ byte[] byteArray = new byte[] { 255, 20, 10, 5, 0, 7 };
+ string expected = "/xQKBQAH";
+
+ XmlSerializarionWriterTester xsw = new XmlSerializarionWriterTester ();
+ xsw.Reset ();
+
+ xsw.ExecuteWriteTypedPrimitive ("x", string.Empty, byteArray, true);
+ Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
+ "<x xmlns:q1='{0}' d1p1:type='q1:base64Binary' xmlns:d1p1='{1}'>{2}</x>",
+ XmlSchemaNamespace, XmlSchemaInstanceNamespace, expected),
+ xsw.Content, "#1");
+
+ xsw.Reset ();
+
+ xsw.ExecuteWriteTypedPrimitive ("x", null, byteArray, true);
+ Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
+ "<x xmlns:q2='{0}' d1p1:type='q2:base64Binary' xmlns:d1p1='{1}'>{2}</x>",
+ XmlSchemaNamespace, XmlSchemaInstanceNamespace, expected),
+ xsw.Content, "#2");
+ }
+
+ [Test]
+ [Category ("NotWorking")] // #7 fails
+ public void TestWriteTypedPrimitive_Boolean ()
+ {
+ XmlSerializarionWriterTester xsw = new XmlSerializarionWriterTester ();
+ xsw.Reset ();
+
+ xsw.ExecuteWriteTypedPrimitive ("x", ANamespace, true, false);
+ Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
+ "<x xmlns='{0}'>true</x>", ANamespace), xsw.Content, "#1");
+
+ xsw.Reset ();
+
+ xsw.ExecuteWriteTypedPrimitive ("x", string.Empty, false, false);
+ Assert.AreEqual ("<x>false</x>", xsw.Content, "#2");
+
+ xsw.Reset ();
+
+ xsw.ExecuteWriteTypedPrimitive ("x", null, true, false);
+ Assert.AreEqual ("<x>true</x>", xsw.Content, "#3");
+
+ xsw.Reset ();
+
+ xsw.ExecuteWriteTypedPrimitive ("x", XmlSchemaNamespace, false, false);
+ Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
+ "<x xmlns='{0}'>false</x>", XmlSchemaNamespace), xsw.Content, "#4");
+
+ xsw.Reset ();
+
+ xsw.ExecuteWriteTypedPrimitive ("x", XmlSchemaInstanceNamespace, true, false);
+ Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
+ "<x xmlns='{0}'>true</x>", XmlSchemaInstanceNamespace),
+ xsw.Content, "#5");
+
+ xsw.Reset ();
+
+ xsw.ExecuteWriteTypedPrimitive (string.Empty, ANamespace, false, false);
+ Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
+ "< xmlns='{0}'>false</>", ANamespace), xsw.Content, "#6");
+
+ xsw.Reset ();
+
+ xsw.ExecuteWriteTypedPrimitive (null, ANamespace, true, false);
+ Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
+ "<boolean xmlns='{0}'>true</boolean>", XmlSchemaNamespace),
+ xsw.Content, "#7");
+ }
+
+ [Test]
+ public void TestWriteTypedPrimitive_Boolean_XsiType ()
+ {
+ XmlSerializarionWriterTester xsw = new XmlSerializarionWriterTester ();
+ xsw.Reset ();
+
+ xsw.ExecuteWriteTypedPrimitive ("x", string.Empty, true, true);
+ Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
+ "<x xmlns:q1='{0}' d1p1:type='q1:boolean' xmlns:d1p1='{1}'>true</x>",
+ XmlSchemaNamespace, XmlSchemaInstanceNamespace),
+ xsw.Content, "#1");
+
+ xsw.Reset ();
+
+ xsw.ExecuteWriteTypedPrimitive ("x", null, false, true);
+ Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
+ "<x xmlns:q2='{0}' d1p1:type='q2:boolean' xmlns:d1p1='{1}'>false</x>",
+ XmlSchemaNamespace, XmlSchemaInstanceNamespace),
+ xsw.Content, "#2");
+ }
+
+ [Test]
+ [Category ("NotWorking")] // #7 fails
+ public void TestWriteTypedPrimitive_Char ()
+ {
+ XmlSerializarionWriterTester xsw = new XmlSerializarionWriterTester ();
+ xsw.Reset ();
+
+ xsw.ExecuteWriteTypedPrimitive ("x", ANamespace, 'c', false);
+ Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
+ "<x xmlns='{0}'>99</x>", ANamespace), xsw.Content, "#1");
+
+ xsw.Reset ();
+
+ xsw.ExecuteWriteTypedPrimitive ("x", string.Empty, 'a', false);
+ Assert.AreEqual ("<x>97</x>", xsw.Content, "#2");
+
+ xsw.Reset ();
+
+ xsw.ExecuteWriteTypedPrimitive ("x", null, 'b', false);
+ Assert.AreEqual ("<x>98</x>", xsw.Content, "#3");
+
+ xsw.Reset ();
+
+ xsw.ExecuteWriteTypedPrimitive ("x", XmlSchemaNamespace, 'd', false);
+ Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
+ "<x xmlns='{0}'>100</x>", XmlSchemaNamespace), xsw.Content, "#4");
+
+ xsw.Reset ();
+
+ xsw.ExecuteWriteTypedPrimitive ("x", XmlSchemaInstanceNamespace, 'e', false);
+ Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
+ "<x xmlns='{0}'>101</x>", XmlSchemaInstanceNamespace),
+ xsw.Content, "#5");
+
+ xsw.Reset ();
+
+ xsw.ExecuteWriteTypedPrimitive (string.Empty, ANamespace, ' ', false);
+ Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
+ "< xmlns='{0}'>32</>", ANamespace), xsw.Content, "#6");
+
+ xsw.Reset ();
+
+ xsw.ExecuteWriteTypedPrimitive (null, ANamespace, '0', false);
+ Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
+ "<char xmlns='{0}'>48</char>", WsdlTypesNamespace),
+ xsw.Content, "#7");
+ }
+
+ [Test]
+ [Category ("NotWorking")] // namespace should be wsdl types ns
+ public void TestWriteTypedPrimitive_Char_XsiType ()
+ {
+ XmlSerializarionWriterTester xsw = new XmlSerializarionWriterTester ();
+ xsw.Reset ();
+
+ xsw.ExecuteWriteTypedPrimitive ("x", string.Empty, 'c', true);
+ Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
+ "<x xmlns:q1='{0}' d1p1:type='q1:char' xmlns:d1p1='{1}'>99</x>",
+ WsdlTypesNamespace, XmlSchemaInstanceNamespace),
+ xsw.Content, "#1");
+
+ xsw.Reset ();
+
+ xsw.ExecuteWriteTypedPrimitive ("x", null, 'a', true);
+ Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
+ "<x xmlns:q2='{0}' d1p1:type='q2:char' xmlns:d1p1='{1}'>97</x>",
+ WsdlTypesNamespace, XmlSchemaInstanceNamespace),
+ xsw.Content, "#2");
+ }
+
+ [Test]
+ [Category ("NotWorking")] // #7 fails
+ public void TestWriteTypedPrimitive_DateTime ()
+ {
+ DateTime dateTime = new DateTime (1973, 08, 13);
+
+ XmlSerializarionWriterTester xsw = new XmlSerializarionWriterTester ();
+ xsw.Reset ();
+
+ xsw.ExecuteWriteTypedPrimitive ("x", ANamespace, dateTime, false);
+ Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
+ "<x xmlns='{0}'>{1}</x>", ANamespace, FromDateTime (dateTime)),
+ xsw.Content, "#1");
+
+ xsw.Reset ();
+
+ xsw.ExecuteWriteTypedPrimitive ("x", string.Empty, dateTime, false);
+ Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
+ "<x>{0}</x>", FromDateTime (dateTime)), xsw.Content, "#2");
+
+ xsw.Reset ();
+
+ xsw.ExecuteWriteTypedPrimitive ("x", null, dateTime, false);
+ Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
+ "<x>{0}</x>", FromDateTime (dateTime)), xsw.Content, "#3");
+
+ xsw.Reset ();
+
+ xsw.ExecuteWriteTypedPrimitive ("x", XmlSchemaNamespace, dateTime, false);
+ Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
+ "<x xmlns='{0}'>{1}</x>", XmlSchemaNamespace,
+ FromDateTime (dateTime)), xsw.Content, "#4");
+
+ xsw.Reset ();
+
+ xsw.ExecuteWriteTypedPrimitive ("x", XmlSchemaInstanceNamespace, dateTime, false);
+ Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
+ "<x xmlns='{0}'>{1}</x>", XmlSchemaInstanceNamespace,
+ FromDateTime (dateTime)), xsw.Content, "#5");
+
+ xsw.Reset ();
+
+ xsw.ExecuteWriteTypedPrimitive (string.Empty, ANamespace, dateTime, false);
+ Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
+ "< xmlns='{0}'>{1}</>", ANamespace, FromDateTime (dateTime)),
+ xsw.Content, "#6");
+
+ xsw.Reset ();
+
+ xsw.ExecuteWriteTypedPrimitive (null, ANamespace, dateTime, false);
+ Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
+ "<dateTime xmlns='{0}'>{1}</dateTime>", XmlSchemaNamespace,
+ FromDateTime (dateTime)), xsw.Content, "#7");
+ }
+
+ [Test]
+ public void TestWriteTypedPrimitive_DateTime_XsiType ()
+ {
+ DateTime dateTime = new DateTime (1973, 08, 13);
+
+ XmlSerializarionWriterTester xsw = new XmlSerializarionWriterTester ();
+ xsw.Reset ();
+
+ xsw.ExecuteWriteTypedPrimitive ("x", string.Empty, dateTime, true);
+ Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
+ "<x xmlns:q1='{0}' d1p1:type='q1:dateTime' xmlns:d1p1='{1}'>{2}</x>",
+ XmlSchemaNamespace, XmlSchemaInstanceNamespace,
+ FromDateTime (dateTime)), xsw.Content, "#1");
+
+ xsw.Reset ();
+
+ xsw.ExecuteWriteTypedPrimitive ("x", null, dateTime, true);
+ Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
+ "<x xmlns:q2='{0}' d1p1:type='q2:dateTime' xmlns:d1p1='{1}'>{2}</x>",
+ XmlSchemaNamespace, XmlSchemaInstanceNamespace,
+ FromDateTime (dateTime)), xsw.Content, "#2");
+ }
+
+ [Test]
+ [Category ("NotWorking")] // enum name is output instead of integral value
+ public void TestWriteTypedPrimitive_Enum ()
+ {
+ XmlSerializarionWriterTester xsw = new XmlSerializarionWriterTester ();
+ xsw.Reset ();
+
+ xsw.ExecuteWriteTypedPrimitive ("x", ANamespace, EnumDefaultValue.e1, false);
+ Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
+ "<x xmlns='{0}'>1</x>", ANamespace), xsw.Content, "#1");
+
+ xsw.Reset ();
+
+ xsw.ExecuteWriteTypedPrimitive ("x", string.Empty, EnumDefaultValue.e2, false);
+ Assert.AreEqual ("<x>2</x>", xsw.Content, "#2");
+
+ xsw.Reset ();
+
+ xsw.ExecuteWriteTypedPrimitive ("x", null, EnumDefaultValue.e3, false);
+ Assert.AreEqual ("<x>3</x>", xsw.Content, "#3");
+
+ xsw.Reset ();
+
+ xsw.ExecuteWriteTypedPrimitive ("x", XmlSchemaNamespace, EnumDefaultValue.e1, false);
+ Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
+ "<x xmlns='{0}'>1</x>", XmlSchemaNamespace), xsw.Content, "#4");
+
+ xsw.Reset ();
+
+ xsw.ExecuteWriteTypedPrimitive ("x", XmlSchemaInstanceNamespace, EnumDefaultValue.e2, false);
+ Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
+ "<x xmlns='{0}'>2</x>", XmlSchemaInstanceNamespace),
+ xsw.Content, "#5");
+
+ xsw.Reset ();
+
+ xsw.ExecuteWriteTypedPrimitive (string.Empty, ANamespace, EnumDefaultValue.e3, false);
+ Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
+ "< xmlns='{0}'>3</>", ANamespace), xsw.Content, "#6");
+
+ xsw.Reset ();
+
+ xsw.ExecuteWriteTypedPrimitive (null, ANamespace, EnumDefaultValue.e2, false);
+ Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
+ "<int xmlns='{0}'>2</int>", XmlSchemaNamespace),
+ xsw.Content, "#7");
+ }
+
+ [Test]
+ [Category ("NotWorking")] // InvalidOperationException is thrown
+ public void TestWriteTypedPrimitive_Enum_XsiType ()
+ {
+ XmlSerializarionWriterTester xsw = new XmlSerializarionWriterTester ();
+ xsw.Reset ();
+
+ xsw.ExecuteWriteTypedPrimitive ("x", string.Empty, EnumDefaultValue.e1, true);
+ Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
+ "<x xmlns:q1='{0}' d1p1:type='q1:int' xmlns:d1p1='{1}'>1</x>",
+ XmlSchemaNamespace, XmlSchemaInstanceNamespace),
+ xsw.Content, "#1");
+
+ xsw.Reset ();
+
+ xsw.ExecuteWriteTypedPrimitive ("x", null, EnumDefaultValue.e2, true);
+ Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
+ "<x xmlns:q2='{0}' d1p1:type='q2:int' xmlns:d1p1='{1}'>2</x>",
+ XmlSchemaNamespace, XmlSchemaInstanceNamespace),
+ xsw.Content, "#2");
+ }
+
+ [Test]
+ [Category ("NotWorking")] // #7 fails
+ public void TestWriteTypedPrimitive_Guid ()
+ {
+ Guid guid = new Guid ("CA761232-ED42-11CE-BACD-00AA0057B223");
+ string expectedGuid = "ca761232-ed42-11ce-bacd-00aa0057b223";
+
+ XmlSerializarionWriterTester xsw = new XmlSerializarionWriterTester ();
+ xsw.Reset ();
+
+ xsw.ExecuteWriteTypedPrimitive ("x", ANamespace, guid, false);
+ Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
+ "<x xmlns='{0}'>{1}</x>", ANamespace, expectedGuid),
+ xsw.Content, "#1");
+
+ xsw.Reset ();
+
+ xsw.ExecuteWriteTypedPrimitive ("x", string.Empty, guid, false);
+ Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
+ "<x>{0}</x>", expectedGuid), xsw.Content, "#2");
+
+ xsw.Reset ();
+
+ xsw.ExecuteWriteTypedPrimitive ("x", null, guid, false);
+ Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
+ "<x>{0}</x>", expectedGuid), xsw.Content, "#3");
+
+ xsw.Reset ();
+
+ xsw.ExecuteWriteTypedPrimitive ("x", XmlSchemaNamespace, guid, false);
+ Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
+ "<x xmlns='{0}'>{1}</x>", XmlSchemaNamespace, expectedGuid),
+ xsw.Content, "#4");
+
+ xsw.Reset ();
+
+ xsw.ExecuteWriteTypedPrimitive ("x", XmlSchemaInstanceNamespace, guid, false);
+ Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
+ "<x xmlns='{0}'>{1}</x>", XmlSchemaInstanceNamespace, expectedGuid),
+ xsw.Content, "#5");
+
+ xsw.Reset ();
+
+ xsw.ExecuteWriteTypedPrimitive (string.Empty, ANamespace, guid, false);
+ Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
+ "< xmlns='{0}'>{1}</>", ANamespace, expectedGuid),
+ xsw.Content, "#6");
+
+ xsw.Reset ();
+
+ xsw.ExecuteWriteTypedPrimitive (null, ANamespace, guid, false);
+ Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
+ "<guid xmlns='{0}'>{1}</guid>", WsdlTypesNamespace,
+ expectedGuid), xsw.Content, "#7");
+ }
+
+ [Test]
+ [Category ("NotWorking")] // namespace should be wsdl types ns
+ public void TestWriteTypedPrimitive_Guid_XsiType ()
+ {
+ Guid guid = new Guid ("CA761232-ED42-11CE-BACD-00AA0057B223");
+ string expectedGuid = "ca761232-ed42-11ce-bacd-00aa0057b223";
+
+ XmlSerializarionWriterTester xsw = new XmlSerializarionWriterTester ();
+ xsw.Reset ();
+
+ xsw.ExecuteWriteTypedPrimitive ("x", string.Empty, guid, true);
+ Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
+ "<x xmlns:q1='{0}' d1p1:type='q1:guid' xmlns:d1p1='{1}'>{2}</x>",
+ WsdlTypesNamespace, XmlSchemaInstanceNamespace, expectedGuid),
+ xsw.Content, "#1");
+
+ xsw.Reset ();
+
+ xsw.ExecuteWriteTypedPrimitive ("x", null, guid, true);
+ Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
+ "<x xmlns:q2='{0}' d1p1:type='q2:guid' xmlns:d1p1='{1}'>{2}</x>",
+ WsdlTypesNamespace, XmlSchemaInstanceNamespace, expectedGuid),
+ xsw.Content, "#2");
+ }
+
+ [Test]
+ [Category ("NotWorking")] // #7 fails
+ public void TestWriteTypedPrimitive_Int ()
+ {
+ XmlSerializarionWriterTester xsw = new XmlSerializarionWriterTester ();
+ xsw.Reset ();
+
+ xsw.ExecuteWriteTypedPrimitive ("x", ANamespace, 76665, false);
+ Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
+ "<x xmlns='{0}'>76665</x>", ANamespace), xsw.Content, "#1");
+
+ xsw.Reset ();
+
+ xsw.ExecuteWriteTypedPrimitive ("x", string.Empty, -5656, false);
+ Assert.AreEqual ("<x>-5656</x>", xsw.Content, "#2");
+
+ xsw.Reset ();
+
+ xsw.ExecuteWriteTypedPrimitive ("x", null, 0, false);
+ Assert.AreEqual ("<x>0</x>", xsw.Content, "#3");
+
+ xsw.Reset ();
+
+ xsw.ExecuteWriteTypedPrimitive ("x", XmlSchemaNamespace, 534, false);
+ Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
+ "<x xmlns='{0}'>534</x>", XmlSchemaNamespace), xsw.Content, "#4");
+
+ xsw.Reset ();
+
+ xsw.ExecuteWriteTypedPrimitive ("x", XmlSchemaInstanceNamespace, -6756, false);
+ Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
+ "<x xmlns='{0}'>-6756</x>", XmlSchemaInstanceNamespace),
+ xsw.Content, "#5");
+
+ xsw.Reset ();
+
+ xsw.ExecuteWriteTypedPrimitive (string.Empty, ANamespace, 434, false);
+ Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
+ "< xmlns='{0}'>434</>", ANamespace), xsw.Content, "#6");
+
+ xsw.Reset ();
+
+ xsw.ExecuteWriteTypedPrimitive (null, ANamespace, 434, false);
+ Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
+ "<int xmlns='{0}'>434</int>", XmlSchemaNamespace),
+ xsw.Content, "#7");
+ }
+
+ [Test]
+ public void TestWriteTypedPrimitive_Int_XsiType ()
+ {
+ XmlSerializarionWriterTester xsw = new XmlSerializarionWriterTester ();
+ xsw.Reset ();
+
+ xsw.ExecuteWriteTypedPrimitive ("x", string.Empty, -6756, true);
+ Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
+ "<x xmlns:q1='{0}' d1p1:type='q1:int' xmlns:d1p1='{1}'>-6756</x>",
+ XmlSchemaNamespace, XmlSchemaInstanceNamespace),
+ xsw.Content, "#1");
+
+ xsw.Reset ();
+
+ xsw.ExecuteWriteTypedPrimitive ("x", null, 434, true);
+ Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
+ "<x xmlns:q2='{0}' d1p1:type='q2:int' xmlns:d1p1='{1}'>434</x>",
+ XmlSchemaNamespace, XmlSchemaInstanceNamespace),
+ xsw.Content, "#2");
+ }
+
+ [Test]
+ [Category ("NotWorking")] // #8 fails
+ public void TestWriteTypedPrimitive_String ()
+ {
+ XmlSerializarionWriterTester xsw = new XmlSerializarionWriterTester ();
+ xsw.Reset ();
+
+ xsw.ExecuteWriteTypedPrimitive ("x", ANamespace, "hello", false);
+ Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
+ "<x xmlns='{0}'>hello</x>", ANamespace), xsw.Content, "#1");
+
+ xsw.Reset ();
+
+ xsw.ExecuteWriteTypedPrimitive ("x", string.Empty, "hello", false);
+ Assert.AreEqual ("<x>hello</x>", xsw.Content, "#2");
+
+ xsw.Reset ();
+
+ xsw.ExecuteWriteTypedPrimitive ("x", null, "hello", false);
+ Assert.AreEqual ("<x>hello</x>", xsw.Content, "#3");
+
+ xsw.Reset ();
+
+ xsw.ExecuteWriteTypedPrimitive ("x", XmlSchemaNamespace, "hello", false);
+ Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
+ "<x xmlns='{0}'>hello</x>", XmlSchemaNamespace),
+ xsw.Content, "#4");
+
+ xsw.Reset ();
+
+ xsw.ExecuteWriteTypedPrimitive ("x", XmlSchemaInstanceNamespace, "hello", false);
+ Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
+ "<x xmlns='{0}'>hello</x>", XmlSchemaInstanceNamespace),
+ xsw.Content, "#5");
+
+ xsw.Reset ();
+
+ xsw.ExecuteWriteTypedPrimitive ("x", ANamespace, string.Empty, false);
+ Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
+ "<x xmlns='{0}' />", ANamespace), xsw.Content, "#6");
+
+ xsw.Reset ();
+
+ xsw.ExecuteWriteTypedPrimitive (string.Empty, ANamespace, "<\"te'st\">", false);
+ Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
+ "< xmlns='{0}'><\"te'st\"></>", ANamespace),
+ xsw.Content, "#7");
+
+ xsw.Reset ();
+
+ xsw.ExecuteWriteTypedPrimitive (null, ANamespace, "hello", false);
+ Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
+ "<string xmlns='{0}'>hello</string>", XmlSchemaNamespace),
+ xsw.Content, "#8");
+ }
+
+ [Test]
+ public void TestWriteTypedPrimitive_String_XsiType ()
+ {
+ XmlSerializarionWriterTester xsw = new XmlSerializarionWriterTester ();
+ xsw.Reset ();
+
+ xsw.ExecuteWriteTypedPrimitive ("x", string.Empty, "hello", true);
+ Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
+ "<x xmlns:q1='{0}' d1p1:type='q1:string' xmlns:d1p1='{1}'>hello</x>",
+ XmlSchemaNamespace, XmlSchemaInstanceNamespace),
+ xsw.Content, "#1");
+
+ xsw.Reset ();
+
+ xsw.ExecuteWriteTypedPrimitive ("x", null, "hello", true);
+ Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
+ "<x xmlns:q2='{0}' d1p1:type='q2:string' xmlns:d1p1='{1}'>hello</x>",
+ XmlSchemaNamespace, XmlSchemaInstanceNamespace),
+ xsw.Content, "#2");
+ }
+
+ [Test]
+ [Category ("NotWorking")] // order of namespace declaration differs from that of MSFT
+ public void TestWriteTypedPrimitive_String_XsiType_Namespace ()
+ {
+ XmlSerializarionWriterTester xsw = new XmlSerializarionWriterTester ();
+ xsw.Reset ();
+
+ xsw.ExecuteWriteTypedPrimitive ("x", ANamespace, "hello", true);
+ Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
+ "<x xmlns:q1='{0}' d1p1:type='q1:string' xmlns:d1p1='{1}' xmlns='{2}'>hello</x>",
+ XmlSchemaNamespace, XmlSchemaInstanceNamespace, ANamespace),
+ xsw.Content, "#1");
+
+ xsw.Reset ();
+
+ xsw.ExecuteWriteTypedPrimitive ("x", XmlSchemaNamespace, "hello", true);
+ Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
+ "<x d1p1:type='string' xmlns:d1p1='{0}' xmlns='{1}'>hello</x>",
+ XmlSchemaInstanceNamespace, XmlSchemaNamespace),
+ xsw.Content, "#2");
+
+ xsw.Reset ();
+
+ xsw.ExecuteWriteTypedPrimitive ("x", XmlSchemaInstanceNamespace, "hello", true);
+ Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
+ "<x xmlns:q2='{0}' d1p1:type='q2:string' xmlns:d1p1='{1}' xmlns='{1}'>hello</x>",
+ XmlSchemaNamespace, XmlSchemaInstanceNamespace), xsw.Content, "#3");
+
+ xsw.Reset ();
+
+ xsw.ExecuteWriteTypedPrimitive ("x", ANamespace, string.Empty, true);
+ Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
+ "<x xmlns:q3='{0}' d1p1:type='q3:string' xmlns:d1p1='{1}' xmlns='{2}' />",
+ XmlSchemaNamespace, XmlSchemaInstanceNamespace, ANamespace),
+ xsw.Content, "#4");
+
+ xsw.Reset ();
+
+ xsw.ExecuteWriteTypedPrimitive (string.Empty, ANamespace, "<\"te'st\">", true);
+ Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
+ "< xmlns:q4='{0}' d1p1:type='q4:string' xmlns:d1p1='{1}' xmlns='{2}'><\"te'st\"></>",
+ XmlSchemaNamespace, XmlSchemaInstanceNamespace, ANamespace),
+ xsw.Content, "#5");
+
+ xsw.Reset ();
+
+ xsw.ExecuteWriteTypedPrimitive (null, ANamespace, "hello", true);
+ Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
+ "<string d1p1:type='string' xmlns:d1p1='{0}' xmlns='{1}'>hello</string>",
+ XmlSchemaInstanceNamespace, XmlSchemaNamespace),
+ xsw.Content, "#6");
+ }
+
+ [Test]
+ [Category ("NotWorking")] // #7 fails
+ public void TestWriteTypedPrimitive_UnsignedByte ()
+ {
+ XmlSerializarionWriterTester xsw = new XmlSerializarionWriterTester ();
+ xsw.Reset ();
+
+ xsw.ExecuteWriteTypedPrimitive ("x", ANamespace, (byte) 5, false);
+ Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
+ "<x xmlns='{0}'>5</x>", ANamespace), xsw.Content, "#1");
+
+ xsw.Reset ();
+
+ xsw.ExecuteWriteTypedPrimitive ("x", string.Empty, (byte) 125, false);
+ Assert.AreEqual ("<x>125</x>", xsw.Content, "#2");
+
+ xsw.Reset ();
+
+ xsw.ExecuteWriteTypedPrimitive ("x", null, (byte) 0, false);
+ Assert.AreEqual ("<x>0</x>", xsw.Content, "#3");
+
+ xsw.Reset ();
+
+ xsw.ExecuteWriteTypedPrimitive ("x", XmlSchemaNamespace, (byte) 255, false);
+ Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
+ "<x xmlns='{0}'>255</x>", XmlSchemaNamespace), xsw.Content, "#4");
+
+ xsw.Reset ();
+
+ xsw.ExecuteWriteTypedPrimitive ("x", XmlSchemaInstanceNamespace, (byte) 128, false);
+ Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
+ "<x xmlns='{0}'>128</x>", XmlSchemaInstanceNamespace),
+ xsw.Content, "#5");
+
+ xsw.Reset ();
+
+ xsw.ExecuteWriteTypedPrimitive (string.Empty, ANamespace, (byte) 1, false);
+ Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
+ "< xmlns='{0}'>1</>", ANamespace), xsw.Content, "#6");
+
+ xsw.Reset ();
+
+ xsw.ExecuteWriteTypedPrimitive (null, ANamespace, (byte) 99, false);
+ Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
+ "<unsignedByte xmlns='{0}'>99</unsignedByte>",
+ XmlSchemaNamespace), xsw.Content, "#7");
+ }
+
+ [Test]
+ public void TestWriteTypedPrimitive_UnsignedByte_XsiType ()
+ {
+ XmlSerializarionWriterTester xsw = new XmlSerializarionWriterTester ();
+ xsw.Reset ();
+
+ xsw.ExecuteWriteTypedPrimitive ("x", string.Empty, (byte) 5, true);
+ Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
+ "<x xmlns:q1='{0}' d1p1:type='q1:unsignedByte' xmlns:d1p1='{1}'>5</x>",
+ XmlSchemaNamespace, XmlSchemaInstanceNamespace),
+ xsw.Content, "#1");
+
+ xsw.Reset ();
+
+ xsw.ExecuteWriteTypedPrimitive ("x", null, (byte) 99, true);
+ Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
+ "<x xmlns:q2='{0}' d1p1:type='q2:unsignedByte' xmlns:d1p1='{1}'>99</x>",
+ XmlSchemaNamespace, XmlSchemaInstanceNamespace),
+ xsw.Content, "#2");
+ }
+
+ [Test]
+ [Category ("NotWorking")] // #A7 fails
+ public void TestWriteTypedPrimitive_XmlQualifiedName ()
+ {
+ XmlQualifiedName qname = new XmlQualifiedName ("something", AnotherNamespace);
+
+ XmlSerializarionWriterTester xsw = new XmlSerializarionWriterTester ();
+ xsw.Reset ();
+
+ xsw.ExecuteWriteTypedPrimitive ("x", ANamespace, qname, false);
+ Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
+ "<x xmlns:q1='{0}' xmlns='{1}'>q1:something</x>",
+ AnotherNamespace, ANamespace), xsw.Content, "#A1");
+
+ xsw.Reset ();
+
+ xsw.ExecuteWriteTypedPrimitive ("x", string.Empty, qname, false);
+ Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
+ "<x xmlns:q2='{0}'>q2:something</x>",
+ AnotherNamespace), xsw.Content, "#A2");
+
+ xsw.Reset ();
+
+ xsw.ExecuteWriteTypedPrimitive ("x", null, qname, false);
+ Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
+ "<x xmlns:q3='{0}'>q3:something</x>", AnotherNamespace),
+ xsw.Content, "#A3");
+
+ xsw.Reset ();
+
+ xsw.ExecuteWriteTypedPrimitive ("x", XmlSchemaNamespace, qname, false);
+ Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
+ "<x xmlns:q4='{0}' xmlns='{1}'>q4:something</x>", AnotherNamespace,
+ XmlSchemaNamespace), xsw.Content, "#A4");
+
+ xsw.Reset ();
+
+ xsw.ExecuteWriteTypedPrimitive ("x", XmlSchemaInstanceNamespace, qname, false);
+ Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
+ "<x xmlns:q5='{0}' xmlns='{1}'>q5:something</x>", AnotherNamespace,
+ XmlSchemaInstanceNamespace), xsw.Content, "#A5");
+
+ xsw.Reset ();
+
+ xsw.ExecuteWriteTypedPrimitive (string.Empty, ANamespace, qname, false);
+ Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
+ "< xmlns:q6='{0}' xmlns='{1}'>q6:something</>", AnotherNamespace,
+ ANamespace), xsw.Content, "#A6");
+
+ xsw.Reset ();
+
+ xsw.ExecuteWriteTypedPrimitive (null, ANamespace, qname, false);
+ Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
+ "<QName xmlns:q7='{0}' xmlns='{1}'>q7:something</QName>",
+ AnotherNamespace, XmlSchemaNamespace), xsw.Content, "#A7");
+
+ xsw.Reset ();
+
+ qname = new XmlQualifiedName ("else");
+
+ xsw.ExecuteWriteTypedPrimitive ("x", ANamespace, qname, false);
+ Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
+ "<x xmlns='{0}'>else</x>", ANamespace), xsw.Content, "#B1");
+
+ xsw.Reset ();
+
+ xsw.ExecuteWriteTypedPrimitive ("x", string.Empty, qname, false);
+ Assert.AreEqual ("<x>else</x>", xsw.Content, "#B2");
+
+ xsw.Reset ();
+
+ xsw.ExecuteWriteTypedPrimitive ("x", null, qname, false);
+ Assert.AreEqual ("<x>else</x>", xsw.Content, "#B3");
+
+ xsw.Reset ();
+
+ xsw.ExecuteWriteTypedPrimitive ("x", XmlSchemaNamespace, qname, false);
+ Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
+ "<x xmlns='{0}'>else</x>", XmlSchemaNamespace), xsw.Content, "#B4");
+
+ xsw.Reset ();
+
+ xsw.ExecuteWriteTypedPrimitive ("x", XmlSchemaInstanceNamespace, qname, false);
+ Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
+ "<x xmlns='{0}'>else</x>", XmlSchemaInstanceNamespace),
+ xsw.Content, "#B5");
+
+ xsw.Reset ();
+
+ xsw.ExecuteWriteTypedPrimitive (string.Empty, ANamespace, qname, false);
+ Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
+ "< xmlns='{0}'>else</>", ANamespace), xsw.Content, "#B6");
+
+ xsw.Reset ();
+
+ xsw.ExecuteWriteTypedPrimitive (null, ANamespace, qname, false);
+ Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
+ "<QName xmlns='{0}'>else</QName>", XmlSchemaNamespace),
+ xsw.Content, "#B7");
+ }
+
+ [Test]
+ [ExpectedException (typeof (NullReferenceException))]
+ public void TestWriteTypedPrimitive_Null_Value()
+ {
+ WriteTypedPrimitive("x", ANamespace, null, false);
+ }
+
+ [Test]
+ [Category ("NotWorking")] // InvalidOperatinException is not thrown
+ [ExpectedException (typeof (InvalidOperationException))]
+ public void TestWriteTypedPrimitive_NonPrimitive ()
+ {
+ // The type System.Version was not expected. Use the XmlInclude
+ // or SoapInclude attribute to specify types that are not known
+ // statically.
+ WriteTypedPrimitive ("x", ANamespace, new Version (), false);
+ }
+
+ [Test]
+ public void TestWriteValue()
+ {
+ WriteValue("");
+ Assert.AreEqual ("", Content);
+
+ Reset();
+ WriteValue("hello");
+ Assert.AreEqual ("hello", Content);
+
+ Reset();
+ string v = null;
+ WriteValue(v);
+ Assert.AreEqual ("", Content);
+
+ Reset();
+ WriteValue(new byte[] {13, 8, 99});
+ Assert.AreEqual ("DQhj", Content);
+ }
+
+ public void TestWriteXmlAttribute()
+ {
+ // FIXME
+ // XmlNode related
+ }
+
+ [Test]
+ public void TestWriteXsiType()
+ {
+ WriteStartElement("x");
+ WriteXsiType("pref", null);
+ WriteEndElement();
+ Assert.AreEqual (string.Format(CultureInfo.InvariantCulture,
+ "<x d1p1:type='pref' xmlns:d1p1='{0}' />", XmlSchemaInstanceNamespace),
+ Content, "#1");
+
+ Reset ();
+
+ WriteStartElement ("x");
+ WriteXsiType ("int", XmlSchemaNamespace);
+ WriteEndElement ();
+ Assert.AreEqual (string.Format(CultureInfo.InvariantCulture,
+ "<x xmlns:q2='{0}' d1p1:type='q2:int' xmlns:d1p1='{1}' />",
+ XmlSchemaNamespace, XmlSchemaInstanceNamespace),
+ Content, "#2");
+
+ Reset ();
+
+ WriteStartElement ("x");
+ WriteXsiType ("int", ANamespace);
+ WriteEndElement ();
+ Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
+ "<x xmlns:q3='{0}' d1p1:type='q3:int' xmlns:d1p1='{1}' />",
+ ANamespace, XmlSchemaInstanceNamespace), Content, "#3");
+
+ Reset ();
+
+ WriteStartElement ("x");
+ WriteXsiType ("int", XmlSchemaInstanceNamespace);
+ WriteEndElement ();
+ Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
+ "<x xmlns:q4='{0}' q4:type='q4:int' />",
+ XmlSchemaInstanceNamespace), Content, "#4");
+
+ Reset ();
+
+ WriteStartElement ("x");
+ WriteXsiType ("int", string.Empty);
+ WriteEndElement ();
+ Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
+ "<x d1p1:type='int' xmlns:d1p1='{0}' />", XmlSchemaInstanceNamespace),
+ Content, "#5");
+
+ Reset ();
+
+ WriteStartElement ("x");
+ WriteXsiType (string.Empty, null);
+ WriteEndElement ();
+ Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
+ "<x d1p1:type='' xmlns:d1p1='{0}' />", XmlSchemaInstanceNamespace),
+ Content, "#6");
+
+ Reset ();
+
+ WriteStartElement ("x");
+ WriteXsiType (null, null);
+ WriteEndElement ();
+ Assert.AreEqual ("<x />", Content, "#7");
+ }
+
+ [Test]
+ [Category ("NotWorking")] // order of namespace declaration differs from that of MSFT
+ public void TestWriteXsiType_Namespace ()
+ {
+ WriteStartElement ("x", ANamespace);
+ WriteXsiType ("pref", null);
+ WriteEndElement ();
+ Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
+ "<x d1p1:type='pref' xmlns:d1p1='{0}' xmlns='{1}' />",
+ XmlSchemaInstanceNamespace, ANamespace), Content, "#1");
+
+ Reset ();
+
+ WriteStartElement ("x", ANamespace);
+ WriteXsiType ("int", XmlSchemaNamespace);
+ WriteEndElement ();
+ Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
+ "<x xmlns:q5='{0}' d1p1:type='q5:int' xmlns:d1p1='{1}' xmlns='{2}' />",
+ XmlSchemaNamespace, XmlSchemaInstanceNamespace, ANamespace),
+ Content, "#2");
+
+ Reset ();
+
+ WriteStartElement ("x", ANamespace);
+ WriteXsiType ("int", ANamespace);
+ WriteEndElement ();
+ Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
+ "<x d1p1:type='int' xmlns:d1p1='{1}' xmlns='{2}' />",
+ ANamespace, XmlSchemaInstanceNamespace, ANamespace),
+ Content, "#3");
+
+ Reset ();
+
+ WriteStartElement ("x", ANamespace);
+ WriteXsiType ("int", XmlSchemaInstanceNamespace);
+ WriteEndElement ();
+ Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
+ "<x xmlns:q6='{0}' q6:type='q6:int' xmlns='{1}' />",
+ XmlSchemaInstanceNamespace, ANamespace), Content, "#4");
+
+ Reset ();
+
+ WriteStartElement ("x", ANamespace);
+ WriteXsiType ("int", string.Empty);
+ WriteEndElement ();
+ Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
+ "<x d1p1:type='int' xmlns:d1p1='{0}' xmlns='{1}' />",
+ XmlSchemaInstanceNamespace, ANamespace), Content, "#5");
+
+ Reset ();
+
+ WriteStartElement ("x", ANamespace);
+ WriteXsiType (string.Empty, null);
+ WriteEndElement ();
+ Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
+ "<x d1p1:type='' xmlns:d1p1='{0}' xmlns='{1}' />",
+ XmlSchemaInstanceNamespace, ANamespace), Content, "#6");
+
+ Reset ();
+
+ WriteStartElement ("x", ANamespace);
+ WriteXsiType (null, null);
+ WriteEndElement ();
+ Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
+ "<x xmlns='{0}' />", ANamespace), Content, "#7");
+ }
+
+
+#if NET_2_0
+ [Test]
+ public void TestFromEnum_Null_TypeName ()
+ {
+ string[] values = { "one", "two", "three", "four" };
+ long[] ids = { 1, 2, 3, 4 };
+
+ Assert.AreEqual ("one", FromEnum (1, values, ids, (string) null));
+ }
+
+ [Test]
+ public void TestCreateInvalidEnumValueException ()
+ {
+ Exception ex = CreateInvalidEnumValueException("AnInvalidValue", "SomeType");
+ Assert.IsNotNull (ex, "#1");
+ Assert.AreEqual (typeof (InvalidOperationException), ex.GetType (), "#2");
+ Assert.IsNotNull (ex.Message, "#3");
+ Assert.IsTrue (ex.Message.IndexOf ("AnInvalidValue") != -1, "#4");
+ Assert.IsTrue (ex.Message.IndexOf ("SomeType") != -1, "#5");
+ }
+#endif
+ }
+}
projects / mono.git / blobdiff