mcs/class/System.XML/Test/System.Xml.Serialization/DeserializeTests.cs

   1 //
   2 // System.Xml.DeserializationTests
   3 //
   4 // Author:
   5 //      Atsushi Enomoto <ginga@kit.hi-ho.ne.jp>
   6 //      Hagit Yidov <hagity@mainsoft.com>
   7 //      Andres G. Aragoneses <andres.aragoneses@7digital.com>
   8 //
   9 // (C) 2003 Atsushi Enomoto
  10 // (C) 2005 Mainsoft Corporation (http://www.mainsoft.com)
  11 // (C) 2012 7digital Media Ltd (http://www.7digital.com)
  12 //
  13 //
  14 using System;
  15 using System.Globalization;
  16 using System.IO;
  17 using System.Xml;
  18 using System.Xml.Serialization;
  19 using NUnit.Framework;
  20 using MonoTests.System.Xml.TestClasses;
  21
  22 namespace MonoTests.System.XmlSerialization
  23 {
  24         public class Sample
  25         {
  26                 public string Text;
  27                 public string[] ArrayText;
  28         }
  29
  30         [TestFixture]
  31         public class DeserializationTests
  32         {
  33                 const string XmlSchemaNamespace = "http://www.w3.org/2001/XMLSchema";
  34                 const string XmlSchemaInstanceNamespace = "http://www.w3.org/2001/XMLSchema-instance";
  35                 const string SoapEncodingNamespace = "http://schemas.xmlsoap.org/soap/encoding/";
  36                 const string WsdlTypesNamespace = "http://microsoft.com/wsdl/types/";
  37                 const string ANamespace = "some:urn";
  38                 const string AnotherNamespace = "another:urn";
  39
  40                 object result;
  41
  42                 private object Deserialize (Type t, string xml)
  43                 {
  44                         StringReader sr = new StringReader (xml);
  45                         XmlReader xr = new XmlTextReader (sr);
  46                         return Deserialize (t, xr);
  47                 }
  48
  49                 private object Deserialize (Type t, string xml, string defaultNamespace)
  50                 {
  51                         StringReader sr = new StringReader (xml);
  52                         XmlReader xr = new XmlTextReader (sr);
  53                         return Deserialize (t, xr, defaultNamespace);
  54                 }
  55
  56                 private object Deserialize (Type t, string xml, XmlAttributeOverrides ao)
  57                 {
  58                         StringReader sr = new StringReader (xml);
  59                         XmlReader xr = new XmlTextReader (sr);
  60                         return Deserialize (t, xr, ao);
  61                 }
  62
  63                 private object DeserializeEncoded (Type t, string xml)
  64                 {
  65                         StringReader sr = new StringReader (xml);
  66                         XmlReader xr = new XmlTextReader (sr);
  67                         return DeserializeEncoded (t, xr);
  68                 }
  69
  70                 private object Deserialize (Type t, XmlReader xr)
  71                 {
  72                         XmlSerializer ser = new XmlSerializer (t);
  73                         result = ser.Deserialize (xr);
  74                         return result;
  75                 }
  76
  77                 private object Deserialize (Type t, XmlReader xr, string defaultNamespace)
  78                 {
  79                         XmlSerializer ser = new XmlSerializer (t, defaultNamespace);
  80                         result = ser.Deserialize (xr);
  81                         return result;
  82                 }
  83
  84                 private object Deserialize (Type t, XmlReader xr, XmlAttributeOverrides ao)
  85                 {
  86                         XmlSerializer ser = new XmlSerializer (t, ao);
  87                         result = ser.Deserialize (xr);
  88                         return result;
  89                 }
  90
  91                 private object DeserializeEncoded (Type t, XmlReader xr)
  92                 {
  93                         SoapReflectionImporter im = new SoapReflectionImporter ();
  94                         XmlTypeMapping tm = im.ImportTypeMapping (t);
  95                         XmlSerializer ser = new XmlSerializer (tm);
  96                         result = ser.Deserialize (xr);
  97                         return result;
  98                 }
  99
 100                 [Test]
 101                 public void SimpleDeserialize ()
 102                 {
 103                         Deserialize (typeof (Sample), "<Sample><Text>Test.</Text></Sample>");
 104                         Assert.AreEqual (typeof (Sample), result.GetType ());
 105                         Sample sample = result as Sample;
 106                         Assert.AreEqual ("Test.", sample.Text);
 107                 }
 108
 109                 [Test]
 110                 public void DeserializeInt ()
 111                 {
 112                         Deserialize (typeof (int), "<int>10</int>");
 113                         Assert.AreEqual (typeof (int), result.GetType ());
 114                         Assert.AreEqual (10, result);
 115                 }
 116
 117                 [Test]
 118                 public void DeserializeSimpleArray ()
 119                 {
 120                         Deserialize (typeof (Sample), "<Sample><ArrayText><string>Test1</string><string>Test2</string></ArrayText></Sample>");
 121                         Assert.AreEqual (typeof (Sample), result.GetType ());
 122                         Sample sample = result as Sample;
 123                         Assert.AreEqual ("Test1", sample.ArrayText[0]);
 124                         Assert.AreEqual ("Test2", sample.ArrayText[1]);
 125                 }
 126
 127                 [Test]
 128                 public void DeserializeEmptyEnum ()
 129                 {
 130                         Field f = Deserialize (typeof (Field), "<field modifiers=\"\" />") as Field;
 131                         Assert.AreEqual (MapModifiers.Public, f.Modifiers);
 132                 }
 133
 134                 [Test]
 135                 public void DeserializePrivateCollection ()
 136                 {
 137                         MemoryStream ms = new MemoryStream ();
 138                         Container c = new Container ();
 139                         c.Items.Add (1);
 140
 141                         XmlSerializer serializer = new XmlSerializer (typeof (Container));
 142                         serializer.Serialize (ms, c);
 143
 144                         ms.Position = 0;
 145                         c = (Container) serializer.Deserialize (ms);
 146                         Assert.AreEqual (1, c.Items[0]);
 147                 }
 148
 149                 [Test]
 150                 [Category ("NotDotNet")]
 151                 [ExpectedException (typeof (InvalidOperationException))]
 152                 public void DeserializeEmptyPrivateCollection ()
 153                 {
 154                         MemoryStream ms = new MemoryStream ();
 155                         Container2 c = new Container2 (true);
 156                         c.Items.Add (1);
 157
 158                         XmlSerializer serializer = new XmlSerializer (typeof (Container2));
 159                         serializer.Serialize (ms, c);
 160
 161                         ms.Position = 0;
 162                         c = (Container2) serializer.Deserialize (ms);
 163                 }
 164
 165                 [Test]
 166                 [ExpectedException (typeof (InvalidOperationException))]
 167                 public void DeserializeArrayReferences ()
 168                 {
 169                         string s = "<Sample xmlns:xsi=\"http://www.w3.org/2001/XMLSchema-instance\" xmlns:xsd=\"http://www.w3.org/2001/XMLSchema\">";
 170                         s += "<ArrayText xmlns:n3=\"http://schemas.xmlsoap.org/soap/encoding/\" xsi:type=\"n3:Array\" n3:arrayType=\"xsd:string[2]\">";
 171                         s += "<item href=\"#id-606830706\"></item>";
 172                         s += "<item xsi:type=\"xsd:string\">Hola</item>";
 173                         s += "</ArrayText>";
 174                         s += "<string id=\"id-606830706\" xsi:type=\"xsd:string\">Adeu</string>";
 175                         s += "</Sample>";
 176                         DeserializeEncoded (typeof (Sample), s);
 177                 }
 178
 179
 180                 [Test]
 181                 public void TestDeserializeXmlNodeArray ()
 182                 {
 183                         object ob = Deserialize (typeof (object), "<anyType at=\"1\"><elem1/><elem2/></anyType>");
 184                         Assert.IsTrue (ob is XmlNode[], "Is node array");
 185
 186                         XmlNode[] nods = (XmlNode[]) ob;
 187                         Assert.AreEqual (3, nods.Length, "lengh");
 188                         Assert.IsTrue (nods[0] is XmlAttribute, "#1");
 189                         Assert.AreEqual ("at", ((XmlAttribute) nods[0]).LocalName, "#2");
 190                         Assert.AreEqual ("1", ((XmlAttribute) nods[0]).Value, "#3");
 191                         Assert.IsTrue (nods[1] is XmlElement, "#4");
 192                         Assert.AreEqual ("elem1", ((XmlElement) nods[1]).LocalName, "#5");
 193                         Assert.IsTrue (nods[2] is XmlElement, "#6");
 194                         Assert.AreEqual ("elem2", ((XmlElement) nods[2]).LocalName, "#7");
 195                 }
 196
 197                 [Test]
 198                 public void TestDeserializeXmlElement ()
 199                 {
 200                         object ob = Deserialize (typeof (XmlElement), "<elem/>");
 201                         Assert.IsTrue (ob is XmlElement, "#1");
 202                         Assert.AreEqual ("elem", ((XmlElement) ob).LocalName, "#2");
 203                 }
 204
 205                 [Test]
 206                 public void TestDeserializeXmlCDataSection ()
 207                 {
 208                         CDataContainer c = (CDataContainer) Deserialize (typeof (CDataContainer), "<CDataContainer xmlns:xsd='http://www.w3.org/2001/XMLSchema' xmlns:xsi='http://www.w3.org/2001/XMLSchema-instance'><cdata><![CDATA[data section contents]]></cdata></CDataContainer>");
 209                         Assert.IsNotNull (c.cdata, "#1");
 210                         Assert.AreEqual ("data section contents", c.cdata.Value, "#2");
 211                 }
 212
 213                 [Test]
 214                 public void TestDeserializeXmlNode ()
 215                 {
 216                         NodeContainer c = (NodeContainer) Deserialize (typeof (NodeContainer), "<NodeContainer xmlns:xsd='http://www.w3.org/2001/XMLSchema' xmlns:xsi='http://www.w3.org/2001/XMLSchema-instance'><node>text</node></NodeContainer>");
 217                         Assert.IsTrue (c.node is XmlText, "#1");
 218                         Assert.AreEqual ("text", c.node.Value, "#2");
 219                 }
 220
 221                 [Test]
 222                 public void TestDeserializeChoices ()
 223                 {
 224                         Choices ch = (Choices) Deserialize (typeof (Choices), "<Choices><ChoiceZero>choice text</ChoiceZero></Choices>");
 225                         Assert.AreEqual ("choice text", ch.MyChoice, "#A1");
 226                         Assert.AreEqual (ItemChoiceType.ChoiceZero, ch.ItemType, "#A2");
 227
 228                         ch = (Choices) Deserialize (typeof (Choices), "<Choices><ChoiceOne>choice text</ChoiceOne></Choices>");
 229                         Assert.AreEqual ("choice text", ch.MyChoice, "#B1");
 230                         Assert.AreEqual (ItemChoiceType.StrangeOne, ch.ItemType, "#B2");
 231
 232                         ch = (Choices) Deserialize (typeof (Choices), "<Choices><ChoiceTwo>choice text</ChoiceTwo></Choices>");
 233                         Assert.AreEqual ("choice text", ch.MyChoice, "#C1");
 234                         Assert.AreEqual (ItemChoiceType.ChoiceTwo, ch.ItemType, "#C2");
 235                 }
 236
 237                 [Test]
 238                 public void TestDeserializeNamesWithSpaces ()
 239                 {
 240                         TestSpace ts = (TestSpace) Deserialize (typeof (TestSpace), "<Type_x0020_with_x0020_space xmlns:xsd='http://www.w3.org/2001/XMLSchema' xmlns:xsi='http://www.w3.org/2001/XMLSchema-instance' Attribute_x0020_with_x0020_space='5'><Element_x0020_with_x0020_space>4</Element_x0020_with_x0020_space></Type_x0020_with_x0020_space>");
 241                         Assert.AreEqual (4, ts.elem, "#1");
 242                         Assert.AreEqual (5, ts.attr, "#2");
 243                 }
 244
 245                 [Test]
 246                 public void TestDeserializeDefaults ()
 247                 {
 248                         ListDefaults d2 = (ListDefaults) Deserialize (typeof (ListDefaults), "<root/>");
 249
 250                         Assert.IsNotNull (d2.list2, "#A1");
 251                         Assert.IsNull (d2.list4, "#A3");
 252                         Assert.IsNotNull (d2.list5, "#A4");
 253                         Assert.IsNotNull (d2.ed, "#A5");
 254                         Assert.IsNotNull (d2.str, "#A6");
 255
 256                         d2 = (ListDefaults) Deserialize (typeof (ListDefaults), "<root></root>");
 257
 258                         Assert.IsNotNull (d2.list2, "#B1");
 259                         Assert.IsNull (d2.list4, "#B3");
 260                         Assert.IsNotNull (d2.list5, "#B4");
 261                         Assert.IsNotNull (d2.ed, "#B5");
 262                         Assert.IsNotNull (d2.str, "#B6");
 263                 }
 264
 265                 [Test]
 266                 public void TestDeserializeChoiceArray ()
 267                 {
 268                         CompositeValueType v = (CompositeValueType) Deserialize (typeof (CompositeValueType), "<?xml version=\"1.0\" encoding=\"utf-16\"?><CompositeValueType xmlns:xsd=\"http://www.w3.org/2001/XMLSchema\" xmlns:xsi=\"http://www.w3.org/2001/XMLSchema-instance\"><In>1</In><Es>2</Es></CompositeValueType>");
 269                         Assert.IsNotNull (v.Items, "#1");
 270                         Assert.IsNotNull (v.ItemsElementName, "#2");
 271                         Assert.AreEqual (2, v.Items.Length, "#3");
 272                         Assert.AreEqual (2, v.ItemsElementName.Length, "#4");
 273                         Assert.AreEqual (1, v.Items[0], "#5");
 274                         Assert.AreEqual (2, v.Items[1], "#6");
 275                         Assert.AreEqual (ItemsChoiceType.In, v.ItemsElementName[0], "#7");
 276                         Assert.AreEqual (ItemsChoiceType.Es, v.ItemsElementName[1], "#8");
 277                 }
 278
 279                 #region GenericsDeseralizationTests
 280
 281                 [Test]
 282                 public void TestDeserializeGenSimpleClassString ()
 283                 {
 284                         Deserialize (typeof (GenSimpleClass<string>), "<GenSimpleClassOfString xmlns:xsd='http://www.w3.org/2001/XMLSchema' xmlns:xsi='http://www.w3.org/2001/XMLSchema-instance' />");
 285                         Assert.AreEqual (typeof (GenSimpleClass<string>), result.GetType ());
 286                         Deserialize (typeof (GenSimpleClass<string>), "<GenSimpleClassOfString xmlns:xsd='http://www.w3.org/2001/XMLSchema' xmlns:xsi='http://www.w3.org/2001/XMLSchema-instance'><something>hello</something></GenSimpleClassOfString>");
 287                         GenSimpleClass<string> simple = result as GenSimpleClass<string>;
 288                         Assert.AreEqual ("hello", simple.something);
 289                 }
 290
 291                 [Test]
 292                 public void TestDeserializeGenSimpleClassBool ()
 293                 {
 294                         Deserialize (typeof (GenSimpleClass<bool>), "<GenSimpleClassOfBoolean xmlns:xsd='http://www.w3.org/2001/XMLSchema' xmlns:xsi='http://www.w3.org/2001/XMLSchema-instance'><something>false</something></GenSimpleClassOfBoolean>");
 295                         Assert.AreEqual (typeof (GenSimpleClass<bool>), result.GetType ());
 296                         Deserialize (typeof (GenSimpleClass<bool>), "<GenSimpleClassOfBoolean xmlns:xsd='http://www.w3.org/2001/XMLSchema' xmlns:xsi='http://www.w3.org/2001/XMLSchema-instance'><something>true</something></GenSimpleClassOfBoolean>");
 297                         GenSimpleClass<bool> simple = result as GenSimpleClass<bool>;
 298                         Assert.AreEqual (true, simple.something);
 299                 }
 300
 301                 [Test]
 302                 public void TestDeserializeGenSimpleStructInt ()
 303                 {
 304                         Deserialize (typeof (GenSimpleStruct<int>), "<GenSimpleStructOfInt32 xmlns:xsd='http://www.w3.org/2001/XMLSchema' xmlns:xsi='http://www.w3.org/2001/XMLSchema-instance'><something>0</something></GenSimpleStructOfInt32>");
 305                         Assert.AreEqual (typeof (GenSimpleStruct<int>), result.GetType ());
 306                         Deserialize (typeof (GenSimpleStruct<int>), "<GenSimpleStructOfInt32 xmlns:xsd='http://www.w3.org/2001/XMLSchema' xmlns:xsi='http://www.w3.org/2001/XMLSchema-instance'><something>123</something></GenSimpleStructOfInt32>");
 307                         GenSimpleStruct<int> simple = new GenSimpleStruct<int> (0);
 308                         if (result != null)
 309                                 simple = (GenSimpleStruct<int>) result;
 310                         Assert.AreEqual (123, simple.something);
 311                 }
 312
 313                 [Test]
 314                 public void TestDeserializeGenListClassString ()
 315                 {
 316                         Deserialize (typeof (GenListClass<string>), "<GenListClassOfString xmlns:xsd='http://www.w3.org/2001/XMLSchema' xmlns:xsi='http://www.w3.org/2001/XMLSchema-instance'><somelist></somelist></GenListClassOfString>");
 317                         Assert.AreEqual (typeof (GenListClass<string>), result.GetType ());
 318                         Deserialize (typeof (GenListClass<string>), "<GenListClassOfString xmlns:xsd='http://www.w3.org/2001/XMLSchema' xmlns:xsi='http://www.w3.org/2001/XMLSchema-instance'><somelist><string>Value1</string><string>Value2</string></somelist></GenListClassOfString>");
 319                         GenListClass<string> genlist = result as GenListClass<string>;
 320                         Assert.AreEqual ("Value1", genlist.somelist[0]);
 321                         Assert.AreEqual ("Value2", genlist.somelist[1]);
 322                 }
 323
 324                 [Test]
 325                 public void TestDeserializeGenListClassFloat ()
 326                 {
 327                         Deserialize (typeof (GenListClass<float>), "<GenListClassOfSingle xmlns:xsd='http://www.w3.org/2001/XMLSchema' xmlns:xsi='http://www.w3.org/2001/XMLSchema-instance'><somelist></somelist></GenListClassOfSingle>");
 328                         Assert.AreEqual (typeof (GenListClass<float>), result.GetType ());
 329                         Deserialize (typeof (GenListClass<float>), "<GenListClassOfSingle xmlns:xsd='http://www.w3.org/2001/XMLSchema' xmlns:xsi='http://www.w3.org/2001/XMLSchema-instance'><somelist><float>1</float><float>2.2</float></somelist></GenListClassOfSingle>");
 330                         GenListClass<float> genlist = result as GenListClass<float>;
 331                         Assert.AreEqual (1, genlist.somelist[0]);
 332                         Assert.AreEqual (2.2F, genlist.somelist[1]);
 333                 }
 334
 335                 [Test]
 336                 public void TestDeserializeGenListClassList ()
 337                 {
 338                         Deserialize (typeof (GenListClass<GenListClass<int>>), "<GenListClassOfGenListClassOfInt32 xmlns:xsd='http://www.w3.org/2001/XMLSchema' xmlns:xsi='http://www.w3.org/2001/XMLSchema-instance'><somelist></somelist></GenListClassOfGenListClassOfInt32>");
 339                         Assert.AreEqual (typeof (GenListClass<GenListClass<int>>), result.GetType ());
 340                         Deserialize (typeof (GenListClass<GenListClass<int>>), "<GenListClassOfGenListClassOfInt32 xmlns:xsd='http://www.w3.org/2001/XMLSchema' xmlns:xsi='http://www.w3.org/2001/XMLSchema-instance'><somelist><GenListClassOfInt32><somelist><int>1</int><int>2</int></somelist></GenListClassOfInt32><GenListClassOfInt32><somelist><int>10</int><int>20</int></somelist></GenListClassOfInt32></somelist></GenListClassOfGenListClassOfInt32>");
 341                         GenListClass<GenListClass<int>> genlist = result as GenListClass<GenListClass<int>>;
 342                         Assert.AreEqual (1, genlist.somelist[0].somelist[0]);
 343                         Assert.AreEqual (2, genlist.somelist[0].somelist[1]);
 344                         Assert.AreEqual (10, genlist.somelist[1].somelist[0]);
 345                         Assert.AreEqual (20, genlist.somelist[1].somelist[1]);
 346                 }
 347
 348                 [Test]
 349                 public void TestDeserializeGenListClassArray ()
 350                 {
 351                         Deserialize (typeof (GenListClass<GenArrayClass<char>>), "<GenListClassOfGenArrayClassOfChar xmlns:xsd='http://www.w3.org/2001/XMLSchema' xmlns:xsi='http://www.w3.org/2001/XMLSchema-instance'><somelist></somelist></GenListClassOfGenArrayClassOfChar>");
 352                         Assert.AreEqual (typeof (GenListClass<GenArrayClass<char>>), result.GetType ());
 353                         Deserialize (typeof (GenListClass<GenArrayClass<char>>), "<GenListClassOfGenArrayClassOfChar xmlns:xsd='http://www.w3.org/2001/XMLSchema' xmlns:xsi='http://www.w3.org/2001/XMLSchema-instance'><somelist><GenArrayClassOfChar><arr><char>97</char><char>98</char><char>0</char></arr></GenArrayClassOfChar><GenArrayClassOfChar><arr><char>100</char><char>101</char><char>102</char></arr></GenArrayClassOfChar></somelist></GenListClassOfGenArrayClassOfChar>");
 354                         GenListClass<GenArrayClass<char>> genlist = result as GenListClass<GenArrayClass<char>>;
 355                         Assert.AreEqual ('a', genlist.somelist[0].arr[0]);
 356                         Assert.AreEqual ('b', genlist.somelist[0].arr[1]);
 357                         Assert.AreEqual ('d', genlist.somelist[1].arr[0]);
 358                         Assert.AreEqual ('e', genlist.somelist[1].arr[1]);
 359                         Assert.AreEqual ('f', genlist.somelist[1].arr[2]);
 360                 }
 361
 362                 [Test]
 363                 public void TestDeserializeGenTwoClassCharDouble ()
 364                 {
 365                         Deserialize (typeof (GenTwoClass<char, double>), "<GenTwoClassOfCharDouble xmlns:xsd='http://www.w3.org/2001/XMLSchema' xmlns:xsi='http://www.w3.org/2001/XMLSchema-instance'><something1>0</something1><something2>0</something2></GenTwoClassOfCharDouble>");
 366                         Assert.AreEqual (typeof (GenTwoClass<char, double>), result.GetType ());
 367                         Deserialize (typeof (GenTwoClass<char, double>), "<GenTwoClassOfCharDouble xmlns:xsd='http://www.w3.org/2001/XMLSchema' xmlns:xsi='http://www.w3.org/2001/XMLSchema-instance'><something1>97</something1><something2>2.2</something2></GenTwoClassOfCharDouble>");
 368                         GenTwoClass<char, double> gentwo = result as GenTwoClass<char, double>;
 369                         Assert.AreEqual ('a', gentwo.something1);
 370                         Assert.AreEqual (2.2, gentwo.something2);
 371                 }
 372
 373                 [Test]
 374                 public void TestDeserializeGenDerivedClassDecimalShort ()
 375                 {
 376                         Deserialize (typeof (GenDerivedClass<decimal, short>), "<GenDerivedClassOfDecimalInt16 xmlns:xsd='http://www.w3.org/2001/XMLSchema' xmlns:xsi='http://www.w3.org/2001/XMLSchema-instance'><something2>0</something2><another1>0</another1><another2>0</another2></GenDerivedClassOfDecimalInt16>");
 377                         Assert.AreEqual (typeof (GenDerivedClass<decimal, short>), result.GetType ());
 378                         Deserialize (typeof (GenDerivedClass<decimal, short>), "<GenDerivedClassOfDecimalInt16 xmlns:xsd='http://www.w3.org/2001/XMLSchema' xmlns:xsi='http://www.w3.org/2001/XMLSchema-instance'><something1>Value1</something1><something2>1</something2><another1>1.1</another1><another2>-22</another2></GenDerivedClassOfDecimalInt16>");
 379                         GenDerivedClass<decimal, short> derived = result as GenDerivedClass<decimal, short>;
 380                         Assert.AreEqual ("Value1", derived.something1);
 381                         Assert.AreEqual (1, derived.something2);
 382                         Assert.AreEqual (1.1M, derived.another1);
 383                         Assert.AreEqual (-22, derived.another2);
 384                 }
 385
 386                 [Test]
 387                 public void TestDeserializeGenDerivedSecondClassByteUlong ()
 388                 {
 389                         Deserialize (typeof (GenDerived2Class<byte, ulong>), "<GenDerived2ClassOfByteUInt64 xmlns:xsd='http://www.w3.org/2001/XMLSchema' xmlns:xsi='http://www.w3.org/2001/XMLSchema-instance'><something1>0</something1><something2>0</something2><another1>0</another1><another2>0</another2></GenDerived2ClassOfByteUInt64>");
 390                         Assert.AreEqual (typeof (GenDerived2Class<byte, ulong>), result.GetType ());
 391                         Deserialize (typeof (GenDerived2Class<byte, ulong>), "<GenDerived2ClassOfByteUInt64 xmlns:xsd='http://www.w3.org/2001/XMLSchema' xmlns:xsi='http://www.w3.org/2001/XMLSchema-instance'><something1>1</something1><something2>222</something2><another1>111</another1><another2>222222</another2></GenDerived2ClassOfByteUInt64>");
 392                         GenDerived2Class<byte, ulong> derived2 = result as GenDerived2Class<byte, ulong>;
 393                         Assert.AreEqual (1, derived2.something1);
 394                         Assert.AreEqual (222, derived2.something2);
 395                         Assert.AreEqual (111, derived2.another1);
 396                         Assert.AreEqual (222222, derived2.another2);
 397                 }
 398
 399                 [Test]
 400                 public void TestDeserializeGenNestedClass ()
 401                 {
 402                         Deserialize (typeof (GenNestedClass<string, int>.InnerClass<bool>), "<InnerClassOfStringInt32Boolean xmlns:xsd='http://www.w3.org/2001/XMLSchema' xmlns:xsi='http://www.w3.org/2001/XMLSchema-instance'><inner>0</inner><something>false</something></InnerClassOfStringInt32Boolean>");
 403                         Assert.AreEqual (typeof (GenNestedClass<string, int>.InnerClass<bool>), result.GetType ());
 404                         Deserialize (typeof (GenNestedClass<string, int>.InnerClass<bool>), "<InnerClassOfStringInt32Boolean xmlns:xsd='http://www.w3.org/2001/XMLSchema' xmlns:xsi='http://www.w3.org/2001/XMLSchema-instance'><inner>5</inner><something>true</something></InnerClassOfStringInt32Boolean>");
 405                         GenNestedClass<string, int>.InnerClass<bool> nested = result as GenNestedClass<string, int>.InnerClass<bool>;
 406                         Assert.AreEqual (5, nested.inner);
 407                         Assert.AreEqual (true, nested.something);
 408                 }
 409
 410                 [Test]
 411                 public void TestDeserializeGenListClassListNested ()
 412                 {
 413                         Deserialize (typeof (GenListClass<GenListClass<GenNestedClass<int, int>.InnerClass<string>>>),
 414                                 "<GenListClassOfGenListClassOfInnerClassOfInt32Int32String xmlns:xsd='http://www.w3.org/2001/XMLSchema' xmlns:xsi='http://www.w3.org/2001/XMLSchema-instance'><somelist></somelist></GenListClassOfGenListClassOfInnerClassOfInt32Int32String>");
 415                         Assert.AreEqual (typeof (GenListClass<GenListClass<GenNestedClass<int, int>.InnerClass<string>>>), result.GetType ());
 416                         Deserialize (typeof (GenListClass<GenListClass<GenNestedClass<int, int>.InnerClass<string>>>),
 417                                 "<GenListClassOfGenListClassOfInnerClassOfInt32Int32String xmlns:xsd='http://www.w3.org/2001/XMLSchema' xmlns:xsi='http://www.w3.org/2001/XMLSchema-instance'><somelist><GenListClassOfInnerClassOfInt32Int32String><somelist><InnerClassOfInt32Int32String><inner>1</inner><something>ONE</something></InnerClassOfInt32Int32String><InnerClassOfInt32Int32String><inner>2</inner><something>TWO</something></InnerClassOfInt32Int32String></somelist></GenListClassOfInnerClassOfInt32Int32String><GenListClassOfInnerClassOfInt32Int32String><somelist><InnerClassOfInt32Int32String><inner>30</inner><something>THIRTY</something></InnerClassOfInt32Int32String></somelist></GenListClassOfInnerClassOfInt32Int32String></somelist></GenListClassOfGenListClassOfInnerClassOfInt32Int32String>");
 418                         GenListClass<GenListClass<GenNestedClass<int, int>.InnerClass<string>>> genlist =
 419                                 result as GenListClass<GenListClass<GenNestedClass<int, int>.InnerClass<string>>>;
 420                         Assert.AreEqual (1, genlist.somelist[0].somelist[0].inner);
 421                         Assert.AreEqual ("ONE", genlist.somelist[0].somelist[0].something);
 422                         Assert.AreEqual (2, genlist.somelist[0].somelist[1].inner);
 423                         Assert.AreEqual ("TWO", genlist.somelist[0].somelist[1].something);
 424                         Assert.AreEqual (30, genlist.somelist[1].somelist[0].inner);
 425                         Assert.AreEqual ("THIRTY", genlist.somelist[1].somelist[0].something);
 426                 }
 427
 428                 public enum Myenum { one, two, three, four, five, six };
 429                 [Test]
 430                 public void TestDeserializeGenArrayClassEnum ()
 431                 {
 432                         Deserialize (typeof (GenArrayClass<Myenum>), "<GenArrayClassOfMyenum xmlns:xsd='http://www.w3.org/2001/XMLSchema' xmlns:xsi='http://www.w3.org/2001/XMLSchema-instance'><arr><Myenum>one</Myenum><Myenum>one</Myenum><Myenum>one</Myenum></arr></GenArrayClassOfMyenum>");
 433                         Assert.AreEqual (typeof (GenArrayClass<Myenum>), result.GetType ());
 434                         Deserialize (typeof (GenArrayClass<Myenum>), "<GenArrayClassOfMyenum xmlns:xsd='http://www.w3.org/2001/XMLSchema' xmlns:xsi='http://www.w3.org/2001/XMLSchema-instance'><arr><Myenum>one</Myenum><Myenum>three</Myenum><Myenum>five</Myenum></arr></GenArrayClassOfMyenum>");
 435                         GenArrayClass<Myenum> genarr = result as GenArrayClass<Myenum>;
 436                         Assert.AreEqual (Myenum.one, genarr.arr[0]);
 437                         Assert.AreEqual (Myenum.three, genarr.arr[1]);
 438                         Assert.AreEqual (Myenum.five, genarr.arr[2]);
 439                 }
 440
 441                 [Test]
 442                 public void TestDeserializeGenArrayClassStruct ()
 443                 {
 444                         Deserialize (typeof (GenArrayClass<GenSimpleStruct<uint>>), "<GenArrayClassOfGenSimpleStructOfUInt32 xmlns:xsd='http://www.w3.org/2001/XMLSchema' xmlns:xsi='http://www.w3.org/2001/XMLSchema-instance'><arr><GenSimpleStructOfUInt32>0</GenSimpleStructOfUInt32><GenSimpleStructOfUInt32>0</GenSimpleStructOfUInt32><GenSimpleStructOfUInt32>0</GenSimpleStructOfUInt32></arr></GenArrayClassOfGenSimpleStructOfUInt32>");
 445                         Assert.AreEqual (typeof (GenArrayClass<GenSimpleStruct<uint>>), result.GetType ());
 446                         Deserialize (typeof (GenArrayClass<GenSimpleStruct<uint>>), "<GenArrayClassOfGenSimpleStructOfUInt32 xmlns:xsd='http://www.w3.org/2001/XMLSchema' xmlns:xsi='http://www.w3.org/2001/XMLSchema-instance'><arr><GenSimpleStructOfUInt32><something>111</something></GenSimpleStructOfUInt32><GenSimpleStructOfUInt32><something>222</something></GenSimpleStructOfUInt32><GenSimpleStructOfUInt32><something>333</something></GenSimpleStructOfUInt32></arr></GenArrayClassOfGenSimpleStructOfUInt32>");
 447                         GenArrayClass<GenSimpleStruct<uint>> genarr = result as GenArrayClass<GenSimpleStruct<uint>>;
 448                         Assert.AreEqual (111, genarr.arr[0].something);
 449                         Assert.AreEqual (222, genarr.arr[1].something);
 450                         Assert.AreEqual (333, genarr.arr[2].something);
 451                 }
 452
 453                 [Test]
 454                 public void TestDeserializeGenArrayClassList ()
 455                 {
 456                         Deserialize (typeof (GenArrayClass<GenListClass<string>>), "<GenArrayClassOfGenListClassOfString xmlns:xsd='http://www.w3.org/2001/XMLSchema' xmlns:xsi='http://www.w3.org/2001/XMLSchema-instance'><arr><GenListClassOfString>0</GenListClassOfString><GenListClassOfString>0</GenListClassOfString><GenListClassOfString>0</GenListClassOfString></arr></GenArrayClassOfGenListClassOfString>");
 457                         Assert.AreEqual (typeof (GenArrayClass<GenListClass<string>>), result.GetType ());
 458                         Deserialize (typeof (GenArrayClass<GenListClass<string>>), "<GenArrayClassOfGenListClassOfString xmlns:xsd='http://www.w3.org/2001/XMLSchema' xmlns:xsi='http://www.w3.org/2001/XMLSchema-instance'><arr><GenListClassOfString><somelist><string>list1-val1</string><string>list1-val2</string></somelist></GenListClassOfString><GenListClassOfString><somelist><string>list2-val1</string><string>list2-val2</string><string>list2-val3</string><string>list2-val4</string></somelist></GenListClassOfString><GenListClassOfString><somelist><string>list3val</string></somelist></GenListClassOfString></arr></GenArrayClassOfGenListClassOfString>");
 459                         GenArrayClass<GenListClass<string>> genarr = result as GenArrayClass<GenListClass<string>>;
 460                         Assert.AreEqual ("list1-val1", genarr.arr[0].somelist[0]);
 461                         Assert.AreEqual ("list1-val2", genarr.arr[0].somelist[1]);
 462                         Assert.AreEqual ("list2-val1", genarr.arr[1].somelist[0]);
 463                         Assert.AreEqual ("list2-val2", genarr.arr[1].somelist[1]);
 464                         Assert.AreEqual ("list2-val3", genarr.arr[1].somelist[2]);
 465                         Assert.AreEqual ("list2-val4", genarr.arr[1].somelist[3]);
 466                         Assert.AreEqual ("list3val", genarr.arr[2].somelist[0]);
 467                         // The code below checks for DotNet bug (see corresponding test in XmlSerializerTests).
 468                         Deserialize (typeof (GenArrayClass<GenListClass<string>>), "<GenArrayClassOfGenListClassOfString xmlns:xsd='http://www.w3.org/2001/XMLSchema' xmlns:xsi='http://www.w3.org/2001/XMLSchema-instance'><arr><GenListClassOfString><somelist><string>list1-val1</string><string>list1-val2</string><string>list3val</string></somelist></GenListClassOfString><GenListClassOfString><somelist><string>list2-val1</string><string>list2-val2</string><string>list2-val3</string><string>list2-val4</string></somelist></GenListClassOfString><GenListClassOfString><somelist></somelist></GenListClassOfString></arr></GenArrayClassOfGenListClassOfString>");
 469                         GenArrayClass<GenListClass<string>> genarr2 = result as GenArrayClass<GenListClass<string>>;
 470                         Assert.AreEqual ("list1-val1", genarr2.arr[0].somelist[0]);
 471                         Assert.AreEqual ("list1-val2", genarr2.arr[0].somelist[1]);
 472                         /**/
 473                         Assert.AreEqual ("list3val", genarr2.arr[0].somelist[2]);
 474                         Assert.AreEqual ("list2-val1", genarr2.arr[1].somelist[0]);
 475                         Assert.AreEqual ("list2-val2", genarr2.arr[1].somelist[1]);
 476                         Assert.AreEqual ("list2-val3", genarr2.arr[1].somelist[2]);
 477                         Assert.AreEqual ("list2-val4", genarr2.arr[1].somelist[3]);
 478                         //Assert.AreEqual ("list3val", genarr2.arr[2].somelist[0]);
 479                 }
 480
 481                 [Test]
 482                 public void TestDeserializeGenComplexStruct ()
 483                 {
 484                         Deserialize (typeof (GenComplexStruct<int, string>), "<GenComplexStructOfInt32String xmlns:xsd='http://www.w3.org/2001/XMLSchema' xmlns:xsi='http://www.w3.org/2001/XMLSchema-instance'><something>0</something><simpleclass><something>0</something></simpleclass><simplestruct><something>0</something></simplestruct><listclass><somelist></somelist></listclass><arrayclass><arr><int>0</int><int>0</int><int>0</int></arr></arrayclass><twoclass><something1>0</something1></twoclass><derivedclass><something2>0</something2><another1>0</another1></derivedclass><derived2><something1>0</something1><another1>0</another1></derived2><nestedouter><outer>0</outer></nestedouter><nestedinner><something>0</something></nestedinner></GenComplexStructOfInt32String>");
 485                         Assert.AreEqual (typeof (GenComplexStruct<int, string>), result.GetType ());
 486                         Deserialize (typeof (GenComplexStruct<int, string>), "<GenComplexStructOfInt32String xmlns:xsd='http://www.w3.org/2001/XMLSchema' xmlns:xsi='http://www.w3.org/2001/XMLSchema-instance'><something>123</something><simpleclass><something>456</something></simpleclass><simplestruct><something>789</something></simplestruct><listclass><somelist><int>100</int><int>200</int></somelist></listclass><arrayclass><arr><int>11</int><int>22</int><int>33</int></arr></arrayclass><twoclass><something1>10</something1><something2>Ten</something2></twoclass><derivedclass><something1>two</something1><something2>2</something2><another1>1</another1><another2>one</another2></derivedclass><derived2><something1>4</something1><something2>four</something2><another1>3</another1><another2>three</another2></derived2><nestedouter><outer>5</outer></nestedouter><nestedinner><inner>six</inner><something>6</something></nestedinner></GenComplexStructOfInt32String>");
 487                         GenComplexStruct<int, string> complex = new GenComplexStruct<int, string> (0);
 488                         if (result != null)
 489                                 complex = (GenComplexStruct<int, string>) result;
 490                         Assert.AreEqual (123, complex.something);
 491                         Assert.AreEqual (456, complex.simpleclass.something);
 492                         Assert.AreEqual (789, complex.simplestruct.something);
 493                         Assert.AreEqual (100, complex.listclass.somelist[0]);
 494                         Assert.AreEqual (200, complex.listclass.somelist[1]);
 495                         Assert.AreEqual (11, complex.arrayclass.arr[0]);
 496                         Assert.AreEqual (22, complex.arrayclass.arr[1]);
 497                         Assert.AreEqual (33, complex.arrayclass.arr[2]);
 498                         Assert.AreEqual (10, complex.twoclass.something1);
 499                         Assert.AreEqual ("Ten", complex.twoclass.something2);
 500                         Assert.AreEqual (1, complex.derivedclass.another1);
 501                         Assert.AreEqual ("one", complex.derivedclass.another2);
 502                         Assert.AreEqual ("two", complex.derivedclass.something1);
 503                         Assert.AreEqual (2, complex.derivedclass.something2);
 504                         Assert.AreEqual (3, complex.derived2.another1);
 505                         Assert.AreEqual ("three", complex.derived2.another2);
 506                         Assert.AreEqual (4, complex.derived2.something1);
 507                         Assert.AreEqual ("four", complex.derived2.something2);
 508                         Assert.AreEqual (5, complex.nestedouter.outer);
 509                         Assert.AreEqual ("six", complex.nestedinner.inner);
 510                         Assert.AreEqual (6, complex.nestedinner.something);
 511                 }
 512
 513                 #endregion //GenericsDeseralizationTests
 514
 515                 [Test]
 516                 public void TestDeserializeCollection ()
 517                 {
 518                         string s0 = "";
 519                         s0 += " <ArrayOfEntity xmlns:xsd='http://www.w3.org/2001/XMLSchema' xmlns:xsi='http://www.w3.org/2001/XMLSchema-instance'>";
 520                         s0 += "         <Entity Name='node1'/>";
 521                         s0 += "         <Entity Name='node2'/>";
 522                         s0 += " </ArrayOfEntity>";
 523
 524                         EntityCollection col = (EntityCollection) Deserialize (typeof (EntityCollection), s0);
 525                         Assert.IsNotNull (col, "#1");
 526                         Assert.AreEqual (2, col.Count, "#2");
 527                         Assert.IsNull (col[0].Parent, "#3");
 528                         Assert.IsNull (col[1].Parent, "#4");
 529                 }
 530
 531                 [Test]
 532                 public void TestDeserializeEmptyCollection ()
 533                 {
 534                         string s1 = "";
 535                         s1 += " <ArrayOfEntity xmlns:xsd='http://www.w3.org/2001/XMLSchema' xmlns:xsi='http://www.w3.org/2001/XMLSchema-instance' />";
 536
 537                         EntityCollection col = (EntityCollection) Deserialize (typeof (EntityCollection), s1);
 538                         Assert.IsNotNull (col, "#A1");
 539                         Assert.AreEqual (0, col.Count, "#A2");
 540
 541                         string s1_1 = "";
 542                         s1_1 += "       <ArrayOfEntity xmlns:xsd='http://www.w3.org/2001/XMLSchema' xmlns:xsi='http://www.w3.org/2001/XMLSchema-instance'>";
 543                         s1_1 += "       </ArrayOfEntity>";
 544
 545                         col = (EntityCollection) Deserialize (typeof (EntityCollection), s1_1);
 546                         Assert.IsNotNull (col, "#B1");
 547                         Assert.AreEqual (0, col.Count, "#B2");
 548                 }
 549
 550                 [Test]
 551                 public void TestDeserializeNilCollectionIsNotNull ()
 552                 {
 553                         string s2 = "";
 554                         s2 += " <ArrayOfEntity xmlns:xsd='http://www.w3.org/2001/XMLSchema' xmlns:xsi='http://www.w3.org/2001/XMLSchema-instance' xsi:nil='true'/>";
 555
 556                         EntityCollection col = (EntityCollection) Deserialize (typeof (EntityCollection), s2);
 557                         Assert.IsNotNull (col, "#1");
 558                         Assert.AreEqual (0, col.Count, "#2");
 559                 }
 560
 561                 [Test]
 562                 public void TestDeserializeObjectCollections ()
 563                 {
 564                         string s3 = "";
 565                         s3 += "<Container xmlns:xsd='http://www.w3.org/2001/XMLSchema' xmlns:xsi='http://www.w3.org/2001/XMLSchema-instance'>";
 566                         s3 += " <Collection1 xmlns:xsd='http://www.w3.org/2001/XMLSchema' xmlns:xsi='http://www.w3.org/2001/XMLSchema-instance'>";
 567                         s3 += "         <Entity Name='node1'/>";
 568                         s3 += "         <Entity Name='node2'/>";
 569                         s3 += " </Collection1>";
 570                         s3 += " <Collection2 xmlns:xsd='http://www.w3.org/2001/XMLSchema' xmlns:xsi='http://www.w3.org/2001/XMLSchema-instance'>";
 571                         s3 += "         <Entity Name='node1'/>";
 572                         s3 += "         <Entity Name='node2'/>";
 573                         s3 += " </Collection2>";
 574                         s3 += " <Collection3 xmlns:xsd='http://www.w3.org/2001/XMLSchema' xmlns:xsi='http://www.w3.org/2001/XMLSchema-instance'>";
 575                         s3 += "         <Entity Name='node1'/>";
 576                         s3 += "         <Entity Name='node2'/>";
 577                         s3 += " </Collection3>";
 578                         s3 += " <Collection4 xmlns:xsd='http://www.w3.org/2001/XMLSchema' xmlns:xsi='http://www.w3.org/2001/XMLSchema-instance'>";
 579                         s3 += "         <Entity Name='node1'/>";
 580                         s3 += "         <Entity Name='node2'/>";
 581                         s3 += " </Collection4>";
 582                         s3 += "</Container>";
 583
 584                         EntityContainer cont = (EntityContainer) Deserialize (typeof (EntityContainer), s3);
 585                         Assert.IsNotNull (cont, "#A1");
 586
 587                         Assert.IsNotNull (cont.Collection1, "#B1");
 588                         Assert.AreEqual (2, cont.Collection1.Count, "#B2");
 589                         Assert.AreEqual ("assigned", cont.Collection1.Container, "#B3");
 590                         Assert.AreEqual ("assigned", cont.Collection1[0].Parent, "#B4");
 591                         Assert.AreEqual ("assigned", cont.Collection1[1].Parent, "#B5");
 592
 593                         Assert.IsNotNull (cont.Collection2, "#C1");
 594                         Assert.AreEqual (2, cont.Collection2.Count, "#C2");
 595                         Assert.AreEqual ("assigned", cont.Collection2.Container, "#C3");
 596                         Assert.AreEqual ("assigned", cont.Collection2[0].Parent, "#C4");
 597                         Assert.AreEqual ("assigned", cont.Collection2[1].Parent, "#C5");
 598
 599                         Assert.IsNotNull (cont.Collection3, "#D1");
 600                         Assert.AreEqual (2, cont.Collection3.Count, "#D2");
 601                         Assert.AreEqual ("root", cont.Collection3.Container, "#D3");
 602                         Assert.AreEqual ("root", cont.Collection3[0].Parent, "#D4");
 603                         Assert.AreEqual ("root", cont.Collection3[1].Parent, "#D5");
 604
 605                         Assert.IsNotNull (cont.Collection4, "#E1");
 606                         Assert.AreEqual (2, cont.Collection4.Count, "#E2");
 607                         Assert.AreEqual ("root", cont.Collection4.Container, "#E3");
 608                         Assert.AreEqual ("root", cont.Collection4[0].Parent, "#E4");
 609                         Assert.AreEqual ("root", cont.Collection4[1].Parent, "#E5");
 610                 }
 611
 612                 [Test]
 613                 public void TestDeserializeEmptyObjectCollections ()
 614                 {
 615                         string s4 = "";
 616                         s4 += "<Container xmlns:xsd='http://www.w3.org/2001/XMLSchema' xmlns:xsi='http://www.w3.org/2001/XMLSchema-instance'>";
 617                         s4 += "</Container>";
 618
 619                         EntityContainer cont = (EntityContainer) Deserialize (typeof (EntityContainer), s4);
 620                         Assert.IsNotNull (cont, "#A1");
 621
 622                         Assert.IsNotNull (cont.Collection1, "#B1");
 623                         Assert.AreEqual (0, cont.Collection1.Count, "#B2");
 624                         Assert.AreEqual ("assigned", cont.Collection1.Container, "#B3");
 625
 626                         Assert.IsNotNull (cont.Collection2, "#C1");
 627                         Assert.AreEqual (0, cont.Collection2.Count, "#C2");
 628                         Assert.AreEqual ("assigned", cont.Collection2.Container, "#C3");
 629
 630                         Assert.IsNotNull (cont.Collection3, "#D1");
 631                         Assert.AreEqual (0, cont.Collection3.Count, "#D2");
 632                         Assert.AreEqual ("root", cont.Collection3.Container, "#D3");
 633
 634                         Assert.IsNotNull (cont.Collection4, "#E1");
 635                         Assert.AreEqual (0, cont.Collection4.Count, "#E2");
 636                         Assert.AreEqual ("root", cont.Collection4.Container, "#E3");
 637                 }
 638
 639                 [Test]
 640                 public void TestDeserializeObjectNilCollectionsAreNotNull ()
 641                 {
 642                         string s5 = "";
 643                         s5 += "<Container xmlns:xsd='http://www.w3.org/2001/XMLSchema' xmlns:xsi='http://www.w3.org/2001/XMLSchema-instance'>";
 644                         s5 += " <Collection1 xmlns:xsd='http://www.w3.org/2001/XMLSchema' xmlns:xsi='http://www.w3.org/2001/XMLSchema-instance' xsi:nil='true' />";
 645                         s5 += " <Collection2 xmlns:xsd='http://www.w3.org/2001/XMLSchema' xmlns:xsi='http://www.w3.org/2001/XMLSchema-instance' xsi:nil='true' />";
 646                         s5 += " <Collection3 xmlns:xsd='http://www.w3.org/2001/XMLSchema' xmlns:xsi='http://www.w3.org/2001/XMLSchema-instance' xsi:nil='true' />";
 647                         s5 += " <Collection4 xmlns:xsd='http://www.w3.org/2001/XMLSchema' xmlns:xsi='http://www.w3.org/2001/XMLSchema-instance' xsi:nil='true' />";
 648                         s5 += "</Container>";
 649
 650                         EntityContainer cont = (EntityContainer) Deserialize (typeof (EntityContainer), s5);
 651                         Assert.IsNotNull (cont, "#A1");
 652
 653                         Assert.IsNotNull (cont.Collection1, "#B1");
 654                         Assert.AreEqual (0, cont.Collection1.Count, "#B2");
 655                         Assert.AreEqual ("assigned", cont.Collection1.Container, "#B3");
 656
 657                         Assert.IsNotNull (cont.Collection2, "#C1");
 658                         Assert.AreEqual (0, cont.Collection2.Count, "#C2");
 659                         Assert.AreEqual ("assigned", cont.Collection2.Container, "#C3");
 660
 661                         Assert.IsNotNull (cont.Collection3, "#D1");
 662                         Assert.AreEqual (0, cont.Collection3.Count, "#D2");
 663                         Assert.AreEqual ("root", cont.Collection3.Container, "#D3");
 664
 665                         Assert.IsNotNull (cont.Collection4, "#E1");
 666                         Assert.AreEqual (0, cont.Collection4.Count, "#E2");
 667                         Assert.AreEqual ("root", cont.Collection4.Container, "#E3");
 668                 }
 669
 670                 [Test]
 671                 public void TestDeserializeObjectEmptyCollections ()
 672                 {
 673                         string s6 = "";
 674                         s6 += "<Container xmlns:xsd='http://www.w3.org/2001/XMLSchema' xmlns:xsi='http://www.w3.org/2001/XMLSchema-instance'>";
 675                         s6 += " <Collection1 xmlns:xsd='http://www.w3.org/2001/XMLSchema' xmlns:xsi='http://www.w3.org/2001/XMLSchema-instance' />";
 676                         s6 += " <Collection2 xmlns:xsd='http://www.w3.org/2001/XMLSchema' xmlns:xsi='http://www.w3.org/2001/XMLSchema-instance' />";
 677                         s6 += " <Collection3 xmlns:xsd='http://www.w3.org/2001/XMLSchema' xmlns:xsi='http://www.w3.org/2001/XMLSchema-instance' />";
 678                         s6 += " <Collection4 xmlns:xsd='http://www.w3.org/2001/XMLSchema' xmlns:xsi='http://www.w3.org/2001/XMLSchema-instance' />";
 679                         s6 += "</Container>";
 680
 681                         EntityContainer cont = (EntityContainer) Deserialize (typeof (EntityContainer), s6);
 682                         Assert.IsNotNull (cont, "#A1");
 683
 684                         Assert.IsNotNull (cont.Collection1, "#B1");
 685                         Assert.AreEqual (0, cont.Collection1.Count, "#B2");
 686                         Assert.AreEqual ("assigned", cont.Collection1.Container, "#B3");
 687
 688                         Assert.IsNotNull (cont.Collection2, "#C1");
 689                         Assert.AreEqual (0, cont.Collection2.Count, "#C2");
 690                         Assert.AreEqual ("assigned", cont.Collection2.Container, "#C3");
 691
 692                         Assert.IsNotNull (cont.Collection3, "#D1");
 693                         Assert.AreEqual (0, cont.Collection3.Count, "#D2");
 694                         Assert.AreEqual ("root", cont.Collection3.Container, "#D3");
 695
 696                         Assert.IsNotNull (cont.Collection4, "#E1");
 697                         Assert.AreEqual (0, cont.Collection4.Count, "#E2");
 698                         Assert.AreEqual ("root", cont.Collection4.Container, "#E3");
 699                 }
 700
 701                 [Test]
 702                 public void TestDeserializeObjectEmptyArrays ()
 703                 {
 704                         string s6 = "";
 705                         s6 += "<Container xmlns:xsd='http://www.w3.org/2001/XMLSchema' xmlns:xsi='http://www.w3.org/2001/XMLSchema-instance'>";
 706                         s6 += " <Collection1 xmlns:xsd='http://www.w3.org/2001/XMLSchema' xmlns:xsi='http://www.w3.org/2001/XMLSchema-instance' />";
 707                         s6 += " <Collection2 xmlns:xsd='http://www.w3.org/2001/XMLSchema' xmlns:xsi='http://www.w3.org/2001/XMLSchema-instance' />";
 708                         s6 += " <Collection3 xmlns:xsd='http://www.w3.org/2001/XMLSchema' xmlns:xsi='http://www.w3.org/2001/XMLSchema-instance' />";
 709                         s6 += " <Collection4 xmlns:xsd='http://www.w3.org/2001/XMLSchema' xmlns:xsi='http://www.w3.org/2001/XMLSchema-instance' />";
 710                         s6 += "</Container>";
 711
 712                         ArrayEntityContainer cont = (ArrayEntityContainer) Deserialize (typeof (ArrayEntityContainer), s6);
 713                         Assert.IsNotNull (cont, "#A1");
 714
 715                         Assert.IsNotNull (cont.Collection1, "#B1");
 716                         Assert.AreEqual (0, cont.Collection1.Length, "#B2");
 717
 718                         Assert.IsNotNull (cont.Collection2, "#C1");
 719                         Assert.AreEqual (0, cont.Collection2.Length, "#C2");
 720
 721                         Assert.IsNotNull (cont.Collection3, "#D1");
 722                         Assert.AreEqual (0, cont.Collection3.Length, "#D2");
 723
 724                         Assert.IsNotNull (cont.Collection4, "#E1");
 725                         Assert.AreEqual (0, cont.Collection4.Length, "#E2");
 726                 }
 727
 728                 [Test]
 729                 public void TestDeserializeEmptyObjectArrays ()
 730                 {
 731                         string s4 = "";
 732                         s4 += "<Container xmlns:xsd='http://www.w3.org/2001/XMLSchema' xmlns:xsi='http://www.w3.org/2001/XMLSchema-instance'>";
 733                         s4 += "</Container>";
 734
 735                         ArrayEntityContainer cont = (ArrayEntityContainer) Deserialize (typeof (ArrayEntityContainer), s4);
 736                         Assert.IsNotNull (cont, "#A1");
 737
 738                         Assert.IsNull (cont.Collection1, "#B1");
 739                         Assert.IsNull (cont.Collection2, "#B2");
 740
 741                         Assert.IsNotNull (cont.Collection3, "#C1");
 742                         Assert.AreEqual (0, cont.Collection3.Length, "#C2");
 743
 744                         Assert.IsNotNull (cont.Collection4, "#D1");
 745                         Assert.AreEqual (0, cont.Collection4.Length, "#D2");
 746                 }
 747
 748                 [Test]
 749                 public void TestDeserializeObjectNilArrays ()
 750                 {
 751                         string s5 = "";
 752                         s5 += "<Container xmlns:xsd='http://www.w3.org/2001/XMLSchema' xmlns:xsi='http://www.w3.org/2001/XMLSchema-instance'>";
 753                         s5 += " <Collection1 xmlns:xsd='http://www.w3.org/2001/XMLSchema' xmlns:xsi='http://www.w3.org/2001/XMLSchema-instance' xsi:nil='true' />";
 754                         s5 += " <Collection2 xmlns:xsd='http://www.w3.org/2001/XMLSchema' xmlns:xsi='http://www.w3.org/2001/XMLSchema-instance' xsi:nil='true' />";
 755                         s5 += " <Collection3 xmlns:xsd='http://www.w3.org/2001/XMLSchema' xmlns:xsi='http://www.w3.org/2001/XMLSchema-instance' xsi:nil='true' />";
 756                         s5 += " <Collection4 xmlns:xsd='http://www.w3.org/2001/XMLSchema' xmlns:xsi='http://www.w3.org/2001/XMLSchema-instance' xsi:nil='true' />";
 757                         s5 += "</Container>";
 758
 759                         ArrayEntityContainer cont = (ArrayEntityContainer) Deserialize (typeof (ArrayEntityContainer), s5);
 760                         Assert.IsNotNull (cont, "#A1");
 761
 762                         Assert.IsNull (cont.Collection1, "#B1");
 763                         Assert.IsNull (cont.Collection2, "#B2");
 764                         Assert.IsNull (cont.Collection3, "#B3");
 765
 766                         Assert.IsNotNull (cont.Collection4, "#C1");
 767                         Assert.AreEqual (0, cont.Collection4.Length, "#C2");
 768                 }
 769
 770                 [Test]
 771                 public void TestDeserializeEmptyArray ()
 772                 {
 773                         string s1 = "";
 774                         s1 += "<ArrayOfEntity xmlns:xsd='http://www.w3.org/2001/XMLSchema' xmlns:xsi='http://www.w3.org/2001/XMLSchema-instance' />";
 775
 776                         Entity[] col = (Entity[]) Deserialize (typeof (Entity[]), s1);
 777                         Assert.IsNotNull (col, "#A1");
 778                         Assert.AreEqual (0, col.Length, "#A2");
 779
 780                         string s1_1 = "";
 781                         s1_1 += "       <ArrayOfEntity xmlns:xsd='http://www.w3.org/2001/XMLSchema' xmlns:xsi='http://www.w3.org/2001/XMLSchema-instance'>";
 782                         s1_1 += "       </ArrayOfEntity>";
 783
 784                         col = (Entity[]) Deserialize (typeof (Entity[]), s1_1);
 785                         Assert.IsNotNull (col, "#B1");
 786                         Assert.AreEqual (0, col.Length, "#B2");
 787                 }
 788
 789                 [Test]
 790                 public void TestDeserializeNilArray ()
 791                 {
 792                         string s2 = "";
 793                         s2 += "<ArrayOfEntity xmlns:xsd='http://www.w3.org/2001/XMLSchema' xmlns:xsi='http://www.w3.org/2001/XMLSchema-instance' xsi:nil='true'/>";
 794
 795                         Entity[] col = (Entity[]) Deserialize (typeof (Entity[]), s2);
 796                         Assert.IsNull (col, "#1");
 797                 }
 798
 799                 [Test]
 800                 public void TestDeserializeObjectWithReadonlyCollection ()
 801                 {
 802                         string s3 = "";
 803                         s3 += "<Container xmlns:xsd='http://www.w3.org/2001/XMLSchema' xmlns:xsi='http://www.w3.org/2001/XMLSchema-instance'>";
 804                         s3 += " <Collection1>";
 805                         s3 += "         <Entity Name='node1'/>";
 806                         s3 += "         <Entity Name='node2'/>";
 807                         s3 += " </Collection1>";
 808                         s3 += "</Container>";
 809
 810                         ObjectWithReadonlyCollection cont = (ObjectWithReadonlyCollection) Deserialize (typeof (ObjectWithReadonlyCollection), s3);
 811                         Assert.IsNotNull (cont, "#1");
 812                         Assert.IsNotNull (cont.Collection1, "#2");
 813                         Assert.AreEqual (2, cont.Collection1.Count, "#3");
 814                         Assert.AreEqual ("root", cont.Collection1.Container, "#4");
 815                         Assert.AreEqual ("root", cont.Collection1[0].Parent, "#5");
 816                         Assert.AreEqual ("root", cont.Collection1[1].Parent, "#6");
 817                 }
 818
 819                 [Test]
 820                 public void TestDeserializeObjectWithReadonlyNulCollection ()
 821                 {
 822                         string s3 = "";
 823                         s3 += "<Container xmlns:xsd='http://www.w3.org/2001/XMLSchema' xmlns:xsi='http://www.w3.org/2001/XMLSchema-instance'>";
 824                         s3 += " <Collection1>";
 825                         s3 += "         <Entity Name='node1'/>";
 826                         s3 += "         <Entity Name='node2'/>";
 827                         s3 += " </Collection1>";
 828                         s3 += "</Container>";
 829
 830                         var obj = (ObjectWithReadonlyNulCollection) Deserialize (typeof (ObjectWithReadonlyNulCollection), s3);
 831                         Assert.IsNull (obj.Collection1);
 832                 }
 833
 834                 [Test]
 835                 public void TestDeserializeObjectWithReadonlyArray ()
 836                 {
 837                         string s3 = "";
 838                         s3 += "<Container xmlns:xsd='http://www.w3.org/2001/XMLSchema' xmlns:xsi='http://www.w3.org/2001/XMLSchema-instance'>";
 839                         s3 += " <Collection1>";
 840                         s3 += "         <Entity Name='node1'/>";
 841                         s3 += "         <Entity Name='node2'/>";
 842                         s3 += " </Collection1>";
 843                         s3 += "</Container>";
 844
 845                         ObjectWithReadonlyArray cont = (ObjectWithReadonlyArray) Deserialize (typeof (ObjectWithReadonlyArray), s3);
 846                         Assert.IsNotNull (cont, "#1");
 847                         Assert.IsNotNull (cont.Collection1, "#2");
 848                         Assert.AreEqual (0, cont.Collection1.Length, "#3");
 849                 }
 850
 851                 [Test]
 852                 public void TestDeserialize_EnumDefaultValue ()
 853                 {
 854                         EnumDefaultValue e;
 855
 856                         e = (EnumDefaultValue) Deserialize (typeof (EnumDefaultValue), "<EnumDefaultValue />");
 857                         Assert.AreEqual (0, (int) e, "#1");
 858
 859                         e = (EnumDefaultValue) Deserialize (typeof (EnumDefaultValue), "<EnumDefaultValue> e3</EnumDefaultValue>");
 860                         Assert.AreEqual (EnumDefaultValue.e3, e, "#2");
 861
 862                         e = (EnumDefaultValue) Deserialize (typeof (EnumDefaultValue), "<EnumDefaultValue>e1 e2</EnumDefaultValue>");
 863                         Assert.AreEqual (EnumDefaultValue.e3, e, "#3");
 864
 865                         e = (EnumDefaultValue) Deserialize (typeof (EnumDefaultValue), "<EnumDefaultValue>  e1   e2 </EnumDefaultValue>");
 866                         Assert.AreEqual (EnumDefaultValue.e1 | EnumDefaultValue.e2, e, "#4");
 867                 }
 868
 869                 [Test]
 870                 public void TestDeserialize_EnumDefaultValueNF ()
 871                 {
 872                         EnumDefaultValueNF e;
 873
 874                         e = (EnumDefaultValueNF) Deserialize (typeof (EnumDefaultValueNF), "<EnumDefaultValueNF>e3</EnumDefaultValueNF>");
 875                         Assert.AreEqual (EnumDefaultValueNF.e3, e, "#A1");
 876
 877                         try {
 878                                 Deserialize (typeof (EnumDefaultValueNF), "<EnumDefaultValueNF />");
 879                                 Assert.Fail ("#B1");
 880                         }
 881                         catch (InvalidOperationException ex) {
 882                                 Assert.AreEqual (typeof (InvalidOperationException), ex.GetType (), "#B2");
 883                                 Assert.IsNotNull (ex.InnerException, "#B3");
 884                                 Assert.AreEqual (typeof (InvalidOperationException), ex.InnerException.GetType (), "#B4");
 885                                 Assert.IsNotNull (ex.InnerException.Message, "#B5");
 886                                 Assert.IsTrue (ex.InnerException.Message.IndexOf ("''") != -1, "#B6");
 887                                 Assert.IsTrue (ex.InnerException.Message.IndexOf (typeof (EnumDefaultValueNF).Name) != -1, "#B7");
 888                         }
 889
 890                         try {
 891                                 Deserialize (typeof (EnumDefaultValueNF), "<EnumDefaultValueNF>e1 e3</EnumDefaultValueNF>");
 892                                 Assert.Fail ("#C1");
 893                         }
 894                         catch (InvalidOperationException ex) {
 895                                 Assert.AreEqual (typeof (InvalidOperationException), ex.GetType (), "#C2");
 896                                 Assert.IsNotNull (ex.InnerException, "#C3");
 897                                 Assert.AreEqual (typeof (InvalidOperationException), ex.InnerException.GetType (), "#C4");
 898                                 Assert.IsNotNull (ex.InnerException.Message, "#C5");
 899                                 Assert.IsTrue (ex.InnerException.Message.IndexOf ("'e1 e3'") != -1, "#C6");
 900                                 Assert.IsTrue (ex.InnerException.Message.IndexOf (typeof (EnumDefaultValueNF).Name) != -1, "#C7");
 901                         }
 902
 903                         try {
 904                                 Deserialize (typeof (EnumDefaultValueNF), "<EnumDefaultValueNF> e3</EnumDefaultValueNF>");
 905                                 Assert.Fail ("#D1");
 906                         }
 907                         catch (InvalidOperationException ex) {
 908                                 Assert.AreEqual (typeof (InvalidOperationException), ex.GetType (), "#D2");
 909                                 Assert.IsNotNull (ex.InnerException, "#D3");
 910                                 Assert.AreEqual (typeof (InvalidOperationException), ex.InnerException.GetType (), "#D4");
 911                                 Assert.IsNotNull (ex.InnerException.Message, "#D5");
 912                                 Assert.IsTrue (ex.InnerException.Message.IndexOf ("' e3'") != -1, "#D6");
 913                                 Assert.IsTrue (ex.InnerException.Message.IndexOf (typeof (EnumDefaultValueNF).Name) != -1, "#D7");
 914                         }
 915
 916                         try {
 917                                 Deserialize (typeof (EnumDefaultValueNF), "<EnumDefaultValueNF> </EnumDefaultValueNF>");
 918                                 Assert.Fail ("#E1");
 919                         }
 920                         catch (InvalidOperationException ex) {
 921                                 Assert.AreEqual (typeof (InvalidOperationException), ex.GetType (), "#E2");
 922                                 Assert.IsNotNull (ex.InnerException, "#E3");
 923                                 Assert.AreEqual (typeof (InvalidOperationException), ex.InnerException.GetType (), "#E4");
 924                                 Assert.IsNotNull (ex.InnerException.Message, "#E5");
 925                                 Assert.IsTrue (ex.InnerException.Message.IndexOf ("' '") != -1, "#E6");
 926                                 Assert.IsTrue (ex.InnerException.Message.IndexOf (typeof (EnumDefaultValueNF).Name) != -1, "#E7");
 927                         }
 928
 929                         try {
 930                                 Deserialize (typeof (EnumDefaultValueNF), "<EnumDefaultValueNF>1</EnumDefaultValueNF>");
 931                                 Assert.Fail ("#F1");
 932                         }
 933                         catch (InvalidOperationException ex) {
 934                                 Assert.AreEqual (typeof (InvalidOperationException), ex.GetType (), "#F2");
 935                                 Assert.IsNotNull (ex.InnerException, "#F3");
 936                                 Assert.AreEqual (typeof (InvalidOperationException), ex.InnerException.GetType (), "#F4");
 937                                 Assert.IsNotNull (ex.InnerException.Message, "#F5");
 938                                 Assert.IsTrue (ex.InnerException.Message.IndexOf ("'1'") != -1, "#F6");
 939                                 Assert.IsTrue (ex.InnerException.Message.IndexOf (typeof (EnumDefaultValueNF).Name) != -1, "#F7");
 940                         }
 941                 }
 942
 943                 [Test]
 944                 public void TestDeserialize_Field ()
 945                 {
 946                         Field f = null;
 947
 948                         f = (Field) Deserialize (typeof (Field),
 949                                 string.Format (CultureInfo.InvariantCulture, "<?xml version='1.0' encoding='utf-16'?>" +
 950                                 "<field xmlns:xsd='{0}' xmlns:xsi='{1}' flag1='' flag2='' flag4='' modifiers='public' modifiers2='public' modifiers4='public' />",
 951                                 XmlSchemaNamespace, XmlSchemaInstanceNamespace));
 952                         Assert.AreEqual ((FlagEnum) 0, f.Flags1, "#A1");
 953                         Assert.AreEqual ((FlagEnum) 0, f.Flags2, "#A2");
 954                         Assert.AreEqual ((FlagEnum) 0, f.Flags3, "#A3");
 955                         Assert.AreEqual ((FlagEnum) 0, f.Flags4, "#A4");
 956                         Assert.AreEqual (MapModifiers.Public, f.Modifiers, "#A5");
 957                         Assert.AreEqual (MapModifiers.Public, f.Modifiers2, "#A6");
 958                         Assert.AreEqual (MapModifiers.Public, f.Modifiers3, "#A7");
 959                         Assert.AreEqual (MapModifiers.Public, f.Modifiers4, "#A8");
 960                         Assert.AreEqual (MapModifiers.Public, f.Modifiers5, "#A9");
 961                         Assert.IsNull (f.Names, "#A10");
 962                         Assert.IsNull (f.Street, "#A11");
 963
 964                         f = (Field) Deserialize (typeof (Field),
 965                                 string.Format (CultureInfo.InvariantCulture, "<?xml version='1.0' encoding='utf-16'?>" +
 966                                 "<field xmlns:xsd='{0}' xmlns:xsi='{1}' flag3='two' flag4='' modifiers='protected' modifiers2='public' />",
 967                                 XmlSchemaNamespace, XmlSchemaInstanceNamespace));
 968                         Assert.AreEqual ((FlagEnum) 0, f.Flags1, "#B1");
 969                         Assert.AreEqual ((FlagEnum) 0, f.Flags2, "#B2");
 970                         Assert.AreEqual (FlagEnum.e2, f.Flags3, "#B3");
 971                         Assert.AreEqual ((FlagEnum) 0, f.Flags4, "#B4");
 972                         Assert.AreEqual (MapModifiers.Protected, f.Modifiers, "#B5");
 973                         Assert.AreEqual (MapModifiers.Public, f.Modifiers2, "#B6");
 974                         Assert.AreEqual (MapModifiers.Public, f.Modifiers3, "#B7");
 975                         Assert.AreEqual (MapModifiers.Public, f.Modifiers4, "#B8");
 976                         Assert.AreEqual (MapModifiers.Public, f.Modifiers5, "#B9");
 977                         Assert.IsNull (f.Names, "#B10");
 978                         Assert.IsNull (f.Street, "#B11");
 979
 980                         f = (Field) Deserialize (typeof (Field),
 981                                 string.Format (CultureInfo.InvariantCulture, "<?xml version='1.0' encoding='utf-16'?>" +
 982                                 "<field xmlns:xsd='{0}' xmlns:xsi='{1}' flag1='two' flag2='two' flag4='' modifiers='public' modifiers2='protected' modifiers3='protected' modifiers4='public' modifiers5='protected' />",
 983                                 XmlSchemaNamespace, XmlSchemaInstanceNamespace));
 984                         Assert.AreEqual (FlagEnum.e2, f.Flags1, "#C1");
 985                         Assert.AreEqual (FlagEnum.e2, f.Flags2, "#C2");
 986                         Assert.AreEqual ((FlagEnum) 0, f.Flags3, "#C3");
 987                         Assert.AreEqual ((FlagEnum) 0, f.Flags4, "#C4");
 988                         Assert.AreEqual (MapModifiers.Public, f.Modifiers, "#C5");
 989                         Assert.AreEqual (MapModifiers.Protected, f.Modifiers2, "#C6");
 990                         Assert.AreEqual (MapModifiers.Protected, f.Modifiers3, "#C7");
 991                         Assert.AreEqual (MapModifiers.Public, f.Modifiers4, "#C8");
 992                         Assert.AreEqual (MapModifiers.Protected, f.Modifiers5, "#C9");
 993                         Assert.IsNull (f.Names, "#C10");
 994                         Assert.IsNull (f.Street, "#C11");
 995
 996                         try {
 997                                 f = (Field) Deserialize (typeof (Field),
 998                                         string.Format (CultureInfo.InvariantCulture, "<?xml version='1.0' encoding='utf-16'?>" +
 999                                         "<field xmlns:xsd='{0}' xmlns:xsi='{1}' flag2='444' />",
1000                                         XmlSchemaNamespace, XmlSchemaInstanceNamespace));
1001                                 Assert.Fail ("#D1");
1002                         }
1003                         catch (InvalidOperationException ex) {
1004                                 // There was an error generating the XML document
1005                                 Assert.AreEqual (typeof (InvalidOperationException), ex.GetType (), "#D2");
1006                                 Assert.IsNotNull (ex.Message, "#D3");
1007                                 Assert.IsNotNull (ex.InnerException, "#D4");
1008
1009                                 // '444' is not a valid value for MonoTests.System.Xml.TestClasses.FlagEnum
1010                                 Assert.AreEqual (typeof (InvalidOperationException), ex.InnerException.GetType (), "#D5");
1011                                 Assert.IsNotNull (ex.InnerException.Message, "#D6");
1012                                 Assert.IsTrue (ex.InnerException.Message.IndexOf ("'444'") != -1, "#D7");
1013                                 Assert.IsTrue (ex.InnerException.Message.IndexOf (typeof (FlagEnum).FullName) != -1, "#D8");
1014                                 Assert.IsNull (ex.InnerException.InnerException, "#D9");
1015                         }
1016
1017                         try {
1018                                 f = (Field) Deserialize (typeof (Field),
1019                                         string.Format (CultureInfo.InvariantCulture, "<?xml version='1.0' encoding='utf-16'?>" +
1020                                         "<field xmlns:xsd='{0}' xmlns:xsi='{1}' flag2='Garbage' />",
1021                                         XmlSchemaNamespace, XmlSchemaInstanceNamespace));
1022                                 Assert.Fail ("#E1");
1023                         }
1024                         catch (InvalidOperationException ex) {
1025                                 // There was an error generating the XML document
1026                                 Assert.AreEqual (typeof (InvalidOperationException), ex.GetType (), "#E2");
1027                                 Assert.IsNotNull (ex.Message, "#E3");
1028                                 Assert.IsNotNull (ex.InnerException, "#E4");
1029
1030                                 // 'Garbage' is not a valid value for MonoTests.System.Xml.TestClasses.FlagEnum
1031                                 Assert.AreEqual (typeof (InvalidOperationException), ex.InnerException.GetType (), "#E5");
1032                                 Assert.IsNotNull (ex.InnerException.Message, "#E6");
1033                                 Assert.IsTrue (ex.InnerException.Message.IndexOf ("'Garbage'") != -1, "#E7");
1034                                 Assert.IsTrue (ex.InnerException.Message.IndexOf (typeof (FlagEnum).FullName) != -1, "#E8");
1035                                 Assert.IsNull (ex.InnerException.InnerException, "#E9");
1036                         }
1037
1038                         try {
1039                                 f = (Field) Deserialize (typeof (Field),
1040                                         string.Format (CultureInfo.InvariantCulture, "<?xml version='1.0' encoding='utf-16'?>" +
1041                                         "<field xmlns:xsd='{0}' xmlns:xsi='{1}' flag2='{2}' />",
1042                                         XmlSchemaNamespace, XmlSchemaInstanceNamespace, ((int) FlagEnum.e2).ToString (CultureInfo.InvariantCulture)));
1043                                 Assert.Fail ("#F1");
1044                         }
1045                         catch (InvalidOperationException ex) {
1046                                 // There was an error generating the XML document
1047                                 Assert.AreEqual (typeof (InvalidOperationException), ex.GetType (), "#F2");
1048                                 Assert.IsNotNull (ex.Message, "#F3");
1049                                 Assert.IsNotNull (ex.InnerException, "#F4");
1050
1051                                 // '2' is not a valid value for MonoTests.System.Xml.TestClasses.FlagEnum
1052                                 Assert.AreEqual (typeof (InvalidOperationException), ex.InnerException.GetType (), "#F5");
1053                                 Assert.IsNotNull (ex.InnerException.Message, "#F6");
1054                                 Assert.IsTrue (ex.InnerException.Message.IndexOf ("'2'") != -1, "#F7");
1055                                 Assert.IsTrue (ex.InnerException.Message.IndexOf (typeof (FlagEnum).FullName) != -1, "#F8");
1056                                 Assert.IsNull (ex.InnerException.InnerException, "#F9");
1057                         }
1058                 }
1059
1060                 [Test]
1061                 [Category ("NotWorking")] // MS.NET results in compilation error (probably it generates bogus source.)
1062                 public void TestDeserialize_Field_Encoded ()
1063                 {
1064                         Field_Encoded f = null;
1065
1066                         f = (Field_Encoded) DeserializeEncoded (typeof (Field_Encoded),
1067                                 string.Format (CultureInfo.InvariantCulture, "<?xml version='1.0' encoding='utf-16'?>" +
1068                                 "<q1:field xmlns:xsd='{0}' xmlns:xsi='{1}' id='id1' flag1='' flag2='' flag4='' modifiers='PuBlIc' modifiers2='PuBlIc' modifiers4='PuBlIc' xmlns:q1='{2}' />",
1069                                 XmlSchemaNamespace, XmlSchemaInstanceNamespace, ANamespace));
1070                         Assert.AreEqual ((FlagEnum_Encoded) 0, f.Flags1, "#A1");
1071                         Assert.AreEqual ((FlagEnum_Encoded) 0, f.Flags2, "#A2");
1072                         Assert.AreEqual ((FlagEnum_Encoded) 0, f.Flags3, "#A3");
1073                         Assert.AreEqual ((FlagEnum_Encoded) 0, f.Flags4, "#A4");
1074                         Assert.AreEqual (MapModifiers.Public, f.Modifiers, "#A5");
1075                         Assert.AreEqual (MapModifiers.Public, f.Modifiers2, "#A6");
1076                         Assert.AreEqual (MapModifiers.Public, f.Modifiers3, "#A7");
1077                         Assert.AreEqual (MapModifiers.Public, f.Modifiers4, "#A8");
1078                         Assert.AreEqual (MapModifiers.Public, f.Modifiers5, "#A9");
1079                         Assert.IsNull (f.Names, "#A10");
1080                         Assert.IsNull (f.Street, "#A11");
1081
1082                         f = (Field_Encoded) DeserializeEncoded (typeof (Field_Encoded),
1083                                 string.Format (CultureInfo.InvariantCulture, "<?xml version='1.0' encoding='utf-16'?>" +
1084                                 "<q1:field xmlns:xsd='{0}' xmlns:xsi='{1}' id='id1' flag3='two' flag4='' modifiers='Protected' modifiers2='PuBlIc' xmlns:q1='{2}' />",
1085                                 XmlSchemaNamespace, XmlSchemaInstanceNamespace, ANamespace));
1086                         Assert.AreEqual ((FlagEnum_Encoded) 0, f.Flags1, "#B1");
1087                         Assert.AreEqual ((FlagEnum_Encoded) 0, f.Flags2, "#B2");
1088                         Assert.AreEqual (FlagEnum_Encoded.e2, f.Flags3, "#B3");
1089                         Assert.AreEqual ((FlagEnum_Encoded) 0, f.Flags4, "#B4");
1090                         Assert.AreEqual (MapModifiers.Protected, f.Modifiers, "#B5");
1091                         Assert.AreEqual (MapModifiers.Public, f.Modifiers2, "#B6");
1092                         Assert.AreEqual (MapModifiers.Public, f.Modifiers3, "#B7");
1093                         Assert.AreEqual (MapModifiers.Public, f.Modifiers4, "#B8");
1094                         Assert.AreEqual (MapModifiers.Public, f.Modifiers5, "#B9");
1095                         Assert.IsNull (f.Names, "#B10");
1096                         Assert.IsNull (f.Street, "#B11");
1097
1098                         f = (Field_Encoded) DeserializeEncoded (typeof (Field_Encoded),
1099                                 string.Format (CultureInfo.InvariantCulture, "<?xml version='1.0' encoding='utf-16'?>" +
1100                                 "<q1:field xmlns:xsd='{0}' xmlns:xsi='{1}' id='id1' flag1='two' flag2='two' flag4='' modifiers='PuBlIc' modifiers2='Protected' modifiers3='Protected' modifiers4='PuBlIc' modifiers5='Protected' xmlns:q1='{2}' />",
1101                                 XmlSchemaNamespace, XmlSchemaInstanceNamespace, ANamespace));
1102                         Assert.AreEqual (FlagEnum_Encoded.e2, f.Flags1, "#C1");
1103                         Assert.AreEqual (FlagEnum_Encoded.e2, f.Flags2, "#C2");
1104                         Assert.AreEqual ((FlagEnum_Encoded) 0, f.Flags3, "#C3");
1105                         Assert.AreEqual ((FlagEnum_Encoded) 0, f.Flags4, "#C4");
1106                         Assert.AreEqual (MapModifiers.Public, f.Modifiers, "#C5");
1107                         Assert.AreEqual (MapModifiers.Protected, f.Modifiers2, "#C6");
1108                         Assert.AreEqual (MapModifiers.Protected, f.Modifiers3, "#C7");
1109                         Assert.AreEqual (MapModifiers.Public, f.Modifiers4, "#C8");
1110                         Assert.AreEqual (MapModifiers.Protected, f.Modifiers5, "#C9");
1111                         Assert.IsNull (f.Names, "#C10");
1112                         Assert.IsNull (f.Street, "#C11");
1113
1114                         try {
1115                                 f = (Field_Encoded) DeserializeEncoded (typeof (Field_Encoded),
1116                                         string.Format (CultureInfo.InvariantCulture, "<?xml version='1.0' encoding='utf-16'?>" +
1117                                         "<q1:field xmlns:xsd='{0}' xmlns:xsi='{1}' id='id1' flag2='444' flag3='555' flag4='' modifiers='666' modifiers2='777' modifiers4='888' modifiers5='999' xmlns:q1='{2}' />",
1118                                         XmlSchemaNamespace, XmlSchemaInstanceNamespace, ANamespace));
1119                                 Assert.Fail ("#D1");
1120                         }
1121                         catch (InvalidOperationException ex) {
1122                                 // There was an error generating the XML document
1123                                 Assert.AreEqual (typeof (InvalidOperationException), ex.GetType (), "#D2");
1124                                 Assert.IsNotNull (ex.Message, "#D3");
1125                                 Assert.IsNotNull (ex.InnerException, "#D4");
1126
1127                                 // '444' is not a valid value for MonoTests.System.Xml.TestClasses.FlagEnum_Encoded
1128                                 Assert.AreEqual (typeof (InvalidOperationException), ex.InnerException.GetType (), "#D5");
1129                                 Assert.IsNotNull (ex.InnerException.Message, "#D6");
1130                                 Assert.IsTrue (ex.InnerException.Message.IndexOf ("'444'") != -1, "#D7");
1131                                 Assert.IsTrue (ex.InnerException.Message.IndexOf (typeof (FlagEnum_Encoded).FullName) != -1, "#D8");
1132                                 Assert.IsNull (ex.InnerException.InnerException, "#D9");
1133                         }
1134                 }
1135
1136                 [Test]
1137                 public void TestDeserialize_FlagEnum ()
1138                 {
1139                         FlagEnum e;
1140
1141                         e = (FlagEnum) Deserialize (typeof (FlagEnum), "<FlagEnum />");
1142                         Assert.AreEqual (0, (int) e, "#A1");
1143
1144                         e = (FlagEnum) Deserialize (typeof (FlagEnum), "<FlagEnum>one</FlagEnum>");
1145                         Assert.AreEqual (FlagEnum.e1, e, "#A2");
1146
1147                         e = (FlagEnum) Deserialize (typeof (FlagEnum), "<FlagEnum>one\u200atwo</FlagEnum>");
1148                         Assert.AreEqual (FlagEnum.e1 | FlagEnum.e2, e, "#A3");
1149
1150                         e = (FlagEnum) Deserialize (typeof (FlagEnum), "<FlagEnum>one two four</FlagEnum>");
1151                         Assert.AreEqual (FlagEnum.e1 | FlagEnum.e2 | FlagEnum.e4, e, "#A4");
1152
1153                         e = (FlagEnum) Deserialize (typeof (FlagEnum), "<FlagEnum> two  four </FlagEnum>");
1154                         Assert.AreEqual (FlagEnum.e2 | FlagEnum.e4, e, "#A5");
1155
1156                         e = (FlagEnum) Deserialize (typeof (FlagEnum), "<FlagEnum>two four two</FlagEnum>");
1157                         Assert.AreEqual (FlagEnum.e2 | FlagEnum.e4, e, "#A6");
1158
1159                         e = (FlagEnum) Deserialize (typeof (FlagEnum), "<FlagEnum>two four two\tone\u2002four\rtwo one</FlagEnum>");
1160                         Assert.AreEqual (FlagEnum.e1 | FlagEnum.e2 | FlagEnum.e4, e, "#A7");
1161
1162                         e = (FlagEnum) Deserialize (typeof (FlagEnum), "<FlagEnum></FlagEnum>");
1163                         Assert.AreEqual (0, (int) e, "#A8");
1164
1165                         e = (FlagEnum) Deserialize (typeof (FlagEnum), "<FlagEnum> </FlagEnum>");
1166                         Assert.AreEqual (0, (int) e, "#A9");
1167
1168                         try {
1169                                 Deserialize (typeof (FlagEnum), "<FlagEnum>1</FlagEnum>");
1170                                 Assert.Fail ("#B1");
1171                         }
1172                         catch (InvalidOperationException ex) {
1173                                 Assert.AreEqual (typeof (InvalidOperationException), ex.GetType (), "#B2");
1174                                 Assert.IsNotNull (ex.InnerException, "#B3");
1175                                 Assert.AreEqual (typeof (InvalidOperationException), ex.InnerException.GetType (), "#B4");
1176                                 Assert.IsNotNull (ex.InnerException.Message, "#B5");
1177                                 Assert.IsTrue (ex.InnerException.Message.IndexOf ("'1'") != -1, "#B6");
1178                                 Assert.IsTrue (ex.InnerException.Message.IndexOf (typeof (FlagEnum).FullName) != -1, "#B7");
1179                         }
1180
1181                         try {
1182                                 Deserialize (typeof (FlagEnum), "<FlagEnum>one,two</FlagEnum>");
1183                                 Assert.Fail ("#C1");
1184                         }
1185                         catch (InvalidOperationException ex) {
1186                                 Assert.AreEqual (typeof (InvalidOperationException), ex.GetType (), "#C2");
1187                                 Assert.IsNotNull (ex.InnerException, "#C3");
1188                                 Assert.AreEqual (typeof (InvalidOperationException), ex.InnerException.GetType (), "#C4");
1189                                 Assert.IsNotNull (ex.InnerException.Message, "#C5");
1190                                 Assert.IsTrue (ex.InnerException.Message.IndexOf ("'one,two'") != -1, "#C6");
1191                                 Assert.IsTrue (ex.InnerException.Message.IndexOf (typeof (FlagEnum).FullName) != -1, "#C7");
1192                         }
1193
1194                         try {
1195                                 Deserialize (typeof (FlagEnum), "<FlagEnum>one something</FlagEnum>");
1196                                 Assert.Fail ("#D1");
1197                         }
1198                         catch (InvalidOperationException ex) {
1199                                 Assert.AreEqual (typeof (InvalidOperationException), ex.GetType (), "#D2");
1200                                 Assert.IsNotNull (ex.InnerException, "#D3");
1201                                 Assert.AreEqual (typeof (InvalidOperationException), ex.InnerException.GetType (), "#D4");
1202                                 Assert.IsNotNull (ex.InnerException.Message, "#D5");
1203                                 Assert.IsTrue (ex.InnerException.Message.IndexOf ("'something'") != -1, "#D6");
1204                                 Assert.IsTrue (ex.InnerException.Message.IndexOf (typeof (FlagEnum).FullName) != -1, "#D7");
1205                         }
1206                 }
1207
1208                 [Test]
1209                 public void TestDeserialize_Group ()
1210                 {
1211                         string xml = string.Format (CultureInfo.InvariantCulture,
1212                                 "<Wrapper>" +
1213                                 "<Group xmlns:xsd='{0}' xmlns:xsi='{1}' xmlns:d2p1='http://www.cpandl.com' CreationDate='2002-05-02' d2p1:GroupName='.NET' GroupNumber='ZDI=' id='id1'>" +
1214                                 "<PosInt xsi:type='xsd:nonNegativeInteger'>10000</PosInt>" +
1215                                 "<Grouptype xsi:type='GroupType'>Small</Grouptype>" +
1216                                 "<MyVehicle href='#id2' />" +
1217                                 "</Group>" +
1218                                 "<Car xmlns:d2p1='{1}' id='id2' d2p1:type='Car'>" +
1219                                 "<licenseNumber xmlns:q1='{0}' d2p1:type='q1:string'>1234566</licenseNumber>" +
1220                                 "<makeDate xmlns:q2='{0}' d2p1:type='q2:date'>0001-01-01</makeDate>" +
1221                                 "</Car>" +
1222                                 "</Wrapper>",
1223                                 "http://www.w3.org/2001/XMLSchema", "http://www.w3.org/2001/XMLSchema-instance");
1224
1225                         XmlTextReader xtr = new XmlTextReader (xml, XmlNodeType.Document, null);
1226                         xtr.ReadStartElement ("Wrapper");
1227
1228                         Group group = (Group) DeserializeEncoded (typeof (Group), xtr);
1229
1230                         Assert.AreEqual (new DateTime (2002, 5, 2), group.Today, "#A1");
1231                         Assert.AreEqual (".NET", group.GroupName, "#A2");
1232                         Assert.AreEqual (new byte[] { 0x64, 0x32 }, group.GroupNumber, "#A3");
1233                         Assert.AreEqual (GroupType.A, group.Grouptype, "#A4");
1234                         Assert.AreEqual ("10000", group.PostitiveInt, "#A5");
1235                         Assert.IsFalse (group.IgnoreThis, "#A6");
1236                         Assert.IsNotNull (group.MyVehicle, "#A7");
1237                         Assert.AreEqual (typeof (Car), group.MyVehicle.GetType (), "#A8");
1238                         Assert.AreEqual ("1234566", group.MyVehicle.licenseNumber, "#A9");
1239                         Assert.AreEqual (new DateTime (1, 1, 1), group.MyVehicle.makeDate, "#A10");
1240                         Assert.IsNull (group.MyVehicle.weight, "#A11");
1241
1242                         xml = string.Format (CultureInfo.InvariantCulture,
1243                                 "<Wrapper>" +
1244                                 "<Group xmlns:xsd='{0}' xmlns:xsi='{1}' CreationDate='2002-05-02' GroupNumber='ZDI=' id='id1'>" +
1245                                 "<PosInt xsi:type='xsd:nonNegativeInteger'>10000</PosInt>" +
1246                                 "<Grouptype xsi:type='GroupType'>Large</Grouptype>" +
1247                                 "<MyVehicle href='#id2' />" +
1248                                 "</Group>" +
1249                                 "<Car xmlns:d2p1='{1}' id='id2' d2p1:type='Car'>" +
1250                                 "<weight xmlns:q2='{0}' d2p1:type='q2:string'>450</weight>" +
1251                                 "</Car>" +
1252                                 "</Wrapper>",
1253                                 "http://www.w3.org/2001/XMLSchema", "http://www.w3.org/2001/XMLSchema-instance");
1254
1255                         xtr = new XmlTextReader (xml, XmlNodeType.Document, null);
1256                         xtr.ReadStartElement ("Wrapper");
1257
1258                         group = (Group) DeserializeEncoded (typeof (Group), xtr);
1259
1260                         Assert.AreEqual (new DateTime (2002, 5, 2), group.Today, "#B1");
1261                         Assert.IsNull (group.GroupName, "#B2");
1262                         Assert.AreEqual (new byte[] { 0x64, 0x32 }, group.GroupNumber, "#B3");
1263                         Assert.AreEqual (GroupType.B, group.Grouptype, "#B4");
1264                         Assert.AreEqual ("10000", group.PostitiveInt, "#B5");
1265                         Assert.IsFalse (group.IgnoreThis, "#B6");
1266                         Assert.IsNotNull (group.MyVehicle, "#B7");
1267                         Assert.AreEqual (typeof (Car), group.MyVehicle.GetType (), "#B8");
1268                         Assert.IsNull (group.MyVehicle.licenseNumber, "#B9");
1269                         Assert.AreEqual (DateTime.MinValue, group.MyVehicle.makeDate, "#B10");
1270                         Assert.AreEqual ("450", group.MyVehicle.weight, "#B11");
1271
1272                         xml = string.Format (CultureInfo.InvariantCulture,
1273                                 "<Wrapper>" +
1274                                 "<Group xmlns:xsd='{0}' xmlns:xsi='{1}' id='id1' />" +
1275                                 "</Wrapper>",
1276                                 "http://www.w3.org/2001/XMLSchema", "http://www.w3.org/2001/XMLSchema-instance");
1277
1278                         xtr = new XmlTextReader (xml, XmlNodeType.Document, null);
1279                         xtr.ReadStartElement ("Wrapper");
1280
1281                         group = (Group) DeserializeEncoded (typeof (Group), xtr);
1282
1283                         Assert.AreEqual (DateTime.MinValue, group.Today, "#C1");
1284                         Assert.IsNull (group.GroupName, "#C2");
1285                         Assert.AreEqual (null, group.GroupNumber, "#C3");
1286                         Assert.AreEqual (GroupType.A, group.Grouptype, "#C4");
1287                         Assert.IsNull (group.PostitiveInt, "#C5");
1288                         Assert.IsFalse (group.IgnoreThis, "#C6");
1289                         Assert.IsNull (group.MyVehicle, "#C7");
1290
1291                         xml = string.Format (CultureInfo.InvariantCulture,
1292                                 "<Wrapper>" +
1293                                 "<Group xmlns:xsd='{0}' xmlns:xsi='{1}' id='id1'>" +
1294                                 "<Grouptype xsi:type='GroupType'>666</Grouptype>" +
1295                                 "</Group>" +
1296                                 "</Wrapper>",
1297                                 "http://www.w3.org/2001/XMLSchema", "http://www.w3.org/2001/XMLSchema-instance");
1298
1299                         xtr = new XmlTextReader (xml, XmlNodeType.Document, null);
1300                         xtr.ReadStartElement ("Wrapper");
1301
1302                         try {
1303                                 group = (Group) DeserializeEncoded (typeof (Group), xtr);
1304                                 Assert.Fail ("#D1");
1305                         }
1306                         catch (InvalidOperationException ex) {
1307                                 // There is an error in XML document (1, 174)
1308                                 Assert.AreEqual (typeof (InvalidOperationException), ex.GetType (), "#D2");
1309                                 Assert.IsNotNull (ex.Message, "#D3");
1310                                 Assert.IsNotNull (ex.InnerException, "#D4");
1311
1312                                 // '666' is not a valid value for GroupType
1313                                 Assert.AreEqual (typeof (InvalidOperationException), ex.InnerException.GetType (), "#D5");
1314                                 Assert.IsNotNull (ex.InnerException.Message, "#D6");
1315                                 Assert.IsTrue (ex.InnerException.Message.IndexOf ("'666'") != -1, "#D7");
1316                                 Assert.IsTrue (ex.InnerException.Message.IndexOf (typeof (GroupType).Name) != -1, "#D8");
1317                                 Assert.IsNull (ex.InnerException.InnerException, "#D9");
1318                         }
1319
1320                         xml = string.Format (CultureInfo.InvariantCulture,
1321                                 "<Wrapper>" +
1322                                 "<Group xmlns:xsd='{0}' xmlns:xsi='{1}' id='id1'>" +
1323                                 "<Grouptype xsi:type='GroupType'>Garbage</Grouptype>" +
1324                                 "</Group>" +
1325                                 "</Wrapper>",
1326                                 "http://www.w3.org/2001/XMLSchema", "http://www.w3.org/2001/XMLSchema-instance");
1327
1328                         xtr = new XmlTextReader (xml, XmlNodeType.Document, null);
1329                         xtr.ReadStartElement ("Wrapper");
1330
1331                         try {
1332                                 group = (Group) DeserializeEncoded (typeof (Group), xtr);
1333                                 Assert.Fail ("#E1");
1334                         }
1335                         catch (InvalidOperationException ex) {
1336                                 // There is an error in XML document (1, 178)
1337                                 Assert.AreEqual (typeof (InvalidOperationException), ex.GetType (), "#E2");
1338                                 Assert.IsNotNull (ex.Message, "#E3");
1339                                 Assert.IsNotNull (ex.InnerException, "#E4");
1340
1341                                 // 'Garbage' is not a valid value for GroupType
1342                                 Assert.AreEqual (typeof (InvalidOperationException), ex.InnerException.GetType (), "#E5");
1343                                 Assert.IsNotNull (ex.InnerException.Message, "#E6");
1344                                 Assert.IsTrue (ex.InnerException.Message.IndexOf ("'Garbage'") != -1, "#E7");
1345                                 Assert.IsTrue (ex.InnerException.Message.IndexOf (typeof (GroupType).Name) != -1, "#E8");
1346                                 Assert.IsNull (ex.InnerException.InnerException, "#E9");
1347                         }
1348
1349                         xml = string.Format (CultureInfo.InvariantCulture,
1350                                 "<Wrapper>" +
1351                                 "<Group xmlns:xsd='{0}' xmlns:xsi='{1}' id='id1'>" +
1352                                 "<Grouptype xsi:type='GroupType'>{2}</Grouptype>" +
1353                                 "</Group>" +
1354                                 "</Wrapper>",
1355                                 "http://www.w3.org/2001/XMLSchema", "http://www.w3.org/2001/XMLSchema-instance",
1356                                 ((int) GroupType.B).ToString (CultureInfo.InvariantCulture));
1357
1358                         xtr = new XmlTextReader (xml, XmlNodeType.Document, null);
1359                         xtr.ReadStartElement ("Wrapper");
1360
1361                         try {
1362                                 group = (Group) DeserializeEncoded (typeof (Group), xtr);
1363                                 Assert.Fail ("#F1");
1364                         }
1365                         catch (InvalidOperationException ex) {
1366                                 // There is an error in XML document (1, 172)
1367                                 Assert.AreEqual (typeof (InvalidOperationException), ex.GetType (), "#F2");
1368                                 Assert.IsNotNull (ex.Message, "#F3");
1369                                 Assert.IsNotNull (ex.InnerException, "#F4");
1370
1371                                 // '1' is not a valid value for GroupType
1372                                 Assert.AreEqual (typeof (InvalidOperationException), ex.InnerException.GetType (), "#F5");
1373                                 Assert.IsNotNull (ex.InnerException.Message, "#F6");
1374                                 Assert.IsTrue (ex.InnerException.Message.IndexOf ("'1'") != -1, "#F7");
1375                                 Assert.IsTrue (ex.InnerException.Message.IndexOf (typeof (GroupType).Name) != -1, "#F8");
1376                                 Assert.IsNull (ex.InnerException.InnerException, "#F9");
1377                         }
1378                 }
1379
1380                 [Test]
1381                 public void TestDeserialize_ZeroFlagEnum ()
1382                 {
1383                         ZeroFlagEnum e;
1384
1385                         e = (ZeroFlagEnum) Deserialize (typeof (ZeroFlagEnum), "<ZeroFlagEnum />");
1386                         Assert.AreEqual (ZeroFlagEnum.e0, e, "#A1");
1387                         e = (ZeroFlagEnum) Deserialize (typeof (ZeroFlagEnum), "<ZeroFlagEnum></ZeroFlagEnum>");
1388                         Assert.AreEqual (ZeroFlagEnum.e0, e, "#A2");
1389
1390                         try {
1391                                 Deserialize (typeof (ZeroFlagEnum), "<ZeroFlagEnum>four</ZeroFlagEnum>");
1392                                 Assert.Fail ("#B1");
1393                         }
1394                         catch (InvalidOperationException ex) {
1395                                 Assert.AreEqual (typeof (InvalidOperationException), ex.GetType (), "#B2");
1396                                 Assert.IsNotNull (ex.InnerException, "#B3");
1397                                 Assert.AreEqual (typeof (InvalidOperationException), ex.InnerException.GetType (), "#B4");
1398                                 Assert.IsNotNull (ex.InnerException.Message, "#B5");
1399                                 Assert.IsTrue (ex.InnerException.Message.IndexOf ("'four'") != -1, "#B6");
1400                                 Assert.IsTrue (ex.InnerException.Message.IndexOf (typeof (ZeroFlagEnum).FullName) != -1, "#B7");
1401                         }
1402
1403                         try {
1404                                 Deserialize (typeof (ZeroFlagEnum), "<ZeroFlagEnum> o&lt;n&gt;e  four </ZeroFlagEnum>");
1405                                 Assert.Fail ("#C1");
1406                         }
1407                         catch (InvalidOperationException ex) {
1408                                 Assert.AreEqual (typeof (InvalidOperationException), ex.GetType (), "#C2");
1409                                 Assert.IsNotNull (ex.InnerException, "#C3");
1410                                 Assert.AreEqual (typeof (InvalidOperationException), ex.InnerException.GetType (), "#C4");
1411                                 Assert.IsNotNull (ex.InnerException.Message, "#C5");
1412                                 Assert.IsTrue (ex.InnerException.Message.IndexOf ("'four'") != -1, "#C6");
1413                                 Assert.IsTrue (ex.InnerException.Message.IndexOf (typeof (ZeroFlagEnum).FullName) != -1, "#C7");
1414                         }
1415
1416                         try {
1417                                 Deserialize (typeof (ZeroFlagEnum), "<ZeroFlagEnum>four o&lt;n&gt;e</ZeroFlagEnum>");
1418                                 Assert.Fail ("#D1");
1419                         }
1420                         catch (InvalidOperationException ex) {
1421                                 Assert.AreEqual (typeof (InvalidOperationException), ex.GetType (), "#D2");
1422                                 Assert.IsNotNull (ex.InnerException, "#D3");
1423                                 Assert.AreEqual (typeof (InvalidOperationException), ex.InnerException.GetType (), "#D4");
1424                                 Assert.IsNotNull (ex.InnerException.Message, "#D5");
1425                                 Assert.IsTrue (ex.InnerException.Message.IndexOf ("'four'") != -1, "#D6");
1426                                 Assert.IsTrue (ex.InnerException.Message.IndexOf (typeof (ZeroFlagEnum).FullName) != -1, "#D7");
1427                         }
1428                 }
1429
1430                 [Test]
1431                 public void TestDeserialize_PrimitiveTypesContainer ()
1432                 {
1433                         Deserialize (typeof (PrimitiveTypesContainer), string.Format (CultureInfo.InvariantCulture,
1434                                 "<?xml version='1.0' encoding='utf-16'?>" +
1435                                 "<PrimitiveTypesContainer xmlns:xsd='{0}' xmlns:xsi='{1}' xmlns='{2}'>" +
1436                                 "<Number xsi:type='xsd:int'>2004</Number>" +
1437                                 "<Name xsi:type='xsd:string'>some name</Name>" +
1438                                 "<Index xsi:type='xsd:unsignedByte'>56</Index>" +
1439                                 "<Password xsi:type='xsd:base64Binary'>8w8=</Password>" +
1440                                 "<PathSeparatorCharacter xmlns:q1='{3}' xsi:type='q1:char'>47</PathSeparatorCharacter>" +
1441                                 "</PrimitiveTypesContainer>", XmlSchemaNamespace,
1442                                 XmlSchemaInstanceNamespace, ANamespace, WsdlTypesNamespace));
1443                         Assert.AreEqual (typeof (PrimitiveTypesContainer), result.GetType (), "#A1");
1444
1445                         PrimitiveTypesContainer deserialized = (PrimitiveTypesContainer) result;
1446                         Assert.AreEqual (2004, deserialized.Number, "#A2");
1447                         Assert.AreEqual ("some name", deserialized.Name, "#A3");
1448                         Assert.AreEqual ((byte) 56, deserialized.Index, "#A4");
1449                         Assert.AreEqual (new byte[] { 243, 15 }, deserialized.Password, "#A5");
1450                         Assert.AreEqual ('/', deserialized.PathSeparatorCharacter, "#A6");
1451
1452                         DeserializeEncoded (typeof (PrimitiveTypesContainer), string.Format (CultureInfo.InvariantCulture,
1453                                 "<?xml version='1.0' encoding='utf-16'?>" +
1454                                 "<q1:PrimitiveTypesContainer xmlns:xsd='{0}' xmlns:xsi='{1}' id='id1' xmlns:q1='{2}'>" +
1455                                 "<Number xsi:type='xsd:int'>2004</Number>" +
1456                                 "<Name xsi:type='xsd:string'>some name</Name>" +
1457                                 "<Index xsi:type='xsd:unsignedByte'>56</Index>" +
1458                                 "<Password xsi:type='xsd:base64Binary'>8w8=</Password>" +
1459                                 "<PathSeparatorCharacter xmlns:q1='{3}' xsi:type='q1:char'>47</PathSeparatorCharacter>" +
1460                                 "</q1:PrimitiveTypesContainer>", XmlSchemaNamespace,
1461                                 XmlSchemaInstanceNamespace, AnotherNamespace, WsdlTypesNamespace));
1462                         Assert.AreEqual (typeof (PrimitiveTypesContainer), result.GetType (), "#B1");
1463
1464                         deserialized = (PrimitiveTypesContainer) result;
1465                         Assert.AreEqual (2004, deserialized.Number, "#B2");
1466                         Assert.AreEqual ("some name", deserialized.Name, "#B3");
1467                         Assert.AreEqual ((byte) 56, deserialized.Index, "#B4");
1468                         Assert.AreEqual (new byte[] { 243, 15 }, deserialized.Password, "#B5");
1469                         Assert.AreEqual ('/', deserialized.PathSeparatorCharacter, "#B6");
1470                 }
1471
1472                 [Test] // bug #378696
1473                 public void DoNotFillDefaultValue ()
1474                 {
1475                         XmlSerializer xs = new XmlSerializer (typeof (DefaultDateTimeContainer));
1476                         DefaultDateTimeContainer o = (DefaultDateTimeContainer) xs.Deserialize (new StringReader ("<DefaultDateTimeContainer xmlns='urn:foo' />"));
1477                         // do not fill DefaultValue / do not bork at generating code.
1478                         Assert.AreEqual (DateTime.MinValue, o.FancyDateTime, "#1");
1479                         Assert.AreEqual (0, o.Numeric, "#2");
1480                 }
1481
1482                 [Test] // bug bxc 4367
1483                 public void SpecifiedXmlIgnoreTest ()
1484                 {
1485                         XmlReflectionMember [] out_members = new XmlReflectionMember [2];
1486                         XmlReflectionMember m;
1487
1488                         m = new XmlReflectionMember ();
1489                         m.IsReturnValue = false;
1490                         m.MemberName = "HasPermissionsForUserResult";
1491                         m.MemberType = typeof (bool);
1492                         m.SoapAttributes = new SoapAttributes ();
1493                         m.XmlAttributes = new XmlAttributes ();
1494                         out_members [0] = m;
1495
1496                         m = new XmlReflectionMember ();
1497                         m.IsReturnValue = false;
1498                         m.MemberName = "HasPermissionsForUserResultSpecified";
1499                         m.MemberType = typeof (bool);
1500                         m.SoapAttributes = new SoapAttributes ();
1501                         m.XmlAttributes = new XmlAttributes ();
1502                         m.XmlAttributes.XmlIgnore = true;
1503                         out_members [1] = m;
1504
1505                         XmlReflectionImporter xmlImporter = new XmlReflectionImporter ();
1506                         XmlMembersMapping OutputMembersMapping = xmlImporter.ImportMembersMapping ("HasPermissionsForUserResponse", "http://tempuri.org", out_members, true);
1507                         XmlSerializer xmlSerializer = XmlSerializer.FromMappings (new XmlMapping [] { OutputMembersMapping }) [0];
1508
1509                         Assert.AreEqual (2, OutputMembersMapping.Count, "#count");
1510
1511                         string msg = @"
1512                         <HasPermissionsForUserResponse xmlns=""http://tempuri.org/"">
1513                                 <HasPermissionsForUserResult>true</HasPermissionsForUserResult>
1514                         </HasPermissionsForUserResponse>
1515                         ";
1516
1517                         object res = xmlSerializer.Deserialize (new StringReader (msg));
1518                         Assert.AreEqual (typeof (object[]), res.GetType (), "type");
1519                         Assert.AreEqual (2, ((object[]) res).Length, "length");
1520                 }
1521
1522                 [Test]
1523                 public void InvalidNullableTypeTest ()
1524                 {
1525                         XmlReflectionMember [] out_members = new XmlReflectionMember [1];
1526                         XmlReflectionMember m;
1527
1528                         m = new XmlReflectionMember ();
1529                         m.IsReturnValue = false;
1530                         m.MemberName = "HasPermissionsForUserResultSpecified";
1531                         m.MemberType = typeof (bool);
1532                         m.SoapAttributes = new SoapAttributes ();
1533                         m.XmlAttributes = new XmlAttributes ();
1534                         m.XmlAttributes.XmlIgnore = true;
1535                         m.XmlAttributes.XmlElements.Add (new XmlElementAttribute () { IsNullable = true });
1536                         out_members [0] = m;
1537
1538                         XmlReflectionImporter xmlImporter = new XmlReflectionImporter ();
1539
1540                         try {
1541                                 xmlImporter.ImportMembersMapping ("HasPermissionsForUserResponse", "http://tempuri.org", out_members, true);
1542                                 Assert.Fail ("Expected InvalidOperationException");
1543                         } catch (InvalidOperationException) {
1544                         }
1545                 }
1546
1547                 [Test]
1548                 [Category ("MobileNotWorking")]
1549                 public void NotExactDateParse ()
1550                 {
1551                         XmlSerializer xs = new XmlSerializer (typeof (NotExactDateParseClass));
1552                         NotExactDateParseClass o = (NotExactDateParseClass) xs.Deserialize (new StringReader ("<NotExactDateParseClass xmlns:xsi=\"http://www.w3.org/2001/XMLSchema-instance\" xmlns:xsd=\"http://www.w3.org/2001/XMLSchema\"><SomeDate xsi:type=\"xsd:date\">2012-02-05-09:00</SomeDate></NotExactDateParseClass>"));
1553                         Assert.AreEqual (new DateTime (2012,2,5,9,0,0,DateTimeKind.Utc), o.SomeDate.ToUniversalTime ());
1554                 }
1555
1556
1557                 public class Foo
1558                 {
1559                         public DateTime? Baz { get; set; }
1560                 }
1561
1562                 [Test]
1563                 public void CanDeserializeXsiNil()
1564                 {
1565                         var reader = new StringReader(
1566 @"<Foo xmlns:xsi=""http://www.w3.org/2001/XMLSchema-instance"">
1567         <Baz xsi:nil=""true"" />
1568 </Foo>");
1569
1570                         using (var xmlReader = new XmlTextReader(reader))
1571                         {
1572                                 var serializer = new XmlSerializer(typeof(Foo));
1573                                 var foo = (Foo)serializer.Deserialize(xmlReader);
1574                                 Assert.IsNull(foo.Baz);
1575                         }
1576                 }
1577
1578                 public class Bar
1579                 {
1580                         [XmlElement("baz")]
1581                         public DateTime? Baz { get; set; }
1582                 }
1583
1584                 [Test]
1585                 public void CanDeserializeXsiNilToAPropertyWithXmlElementAttrib()
1586                 {
1587                         var reader = new StringReader(
1588 @"<Bar xmlns:xsi=""http://www.w3.org/2001/XMLSchema-instance"">
1589         <baz xsi:nil=""true"" />
1590 </Bar>");
1591
1592                         using (var xmlReader = new XmlTextReader(reader))
1593                         {
1594                                 var serializer = new XmlSerializer(typeof(Bar));
1595                                 var bar = (Bar)serializer.Deserialize(xmlReader);
1596                                 Assert.IsNull(bar.Baz);
1597                         }
1598                 }
1599
1600                 public class FooBar
1601                 {
1602                         [XmlElement("baz", IsNullable = true)]
1603                         public DateTime? Baz { get; set; }
1604                 }
1605
1606                 [Test]
1607                 public void CanDeserializeXsiNilToAPropertyWithXmlElementAttribAndIsNullableTrue()
1608                 {
1609                         var reader = new StringReader(
1610 @"<FooBar xmlns:xsi=""http://www.w3.org/2001/XMLSchema-instance"">
1611         <baz xsi:nil=""true"" />
1612 </FooBar>");
1613
1614                         using (var xmlReader = new XmlTextReader(reader))
1615                         {
1616                                 var serializer = new XmlSerializer(typeof(FooBar));
1617                                 var foobar = (FooBar)serializer.Deserialize(xmlReader);
1618                                 Assert.IsNull(foobar.Baz);
1619                         }
1620                 }
1621
1622                 [Test] // bug #8468
1623                 public void TestUseSubclassDefaultNamespace ()
1624                 {
1625                         XmlSerializer xs = new XmlSerializer (typeof (Bug8468Subclass));
1626                         string msg = "<Test xmlns=\"http://test-namespace\"><Base>BaseValue</Base><Mid>MidValue</Mid></Test>";
1627                         var res1 = (Bug8468Subclass)xs.Deserialize (new StringReader (msg));
1628                         Assert.IsNotNull (res1);
1629                         Assert.AreEqual ("BaseValue", res1.Base);
1630                         Assert.AreEqual ("MidValue", res1.Mid);
1631
1632                         xs = new XmlSerializer (typeof (Bug8468SubclassNoNamespace), "http://test-namespace");
1633                         var res2 = (Bug8468SubclassNoNamespace)xs.Deserialize (new StringReader (msg));
1634                         Assert.IsNotNull (res2);
1635                         Assert.AreEqual ("BaseValue", res2.Base);
1636                         Assert.AreEqual ("MidValue", res2.Mid);
1637
1638                         xs = new XmlSerializer (typeof (Bug8468SubclassV2));
1639                         var res3 = (Bug8468SubclassV2)xs.Deserialize (new StringReader (msg));
1640                         Assert.IsNotNull (res3);
1641                         Assert.IsNull (res3.Base);
1642                         Assert.AreEqual ("MidValue", res3.Mid);
1643
1644                         xs = new XmlSerializer (typeof (Bug8468SubclassNoNamespaceV2), "http://test-namespace");
1645                         var res4 = (Bug8468SubclassNoNamespaceV2)xs.Deserialize (new StringReader (msg));
1646                         Assert.IsNotNull (res4);
1647                         Assert.IsNull (res4.Base);
1648                         Assert.AreEqual ("MidValue", res4.Mid);
1649
1650                         msg = "<Test xmlns=\"http://test-namespace\"><Base xmlns=\"\">BaseValue</Base><Mid>MidValue</Mid></Test>";
1651
1652                         xs = new XmlSerializer (typeof (Bug8468SubclassV2));
1653                         var res5 = (Bug8468SubclassV2)xs.Deserialize (new StringReader (msg));
1654                         Assert.IsNotNull (res5);
1655                         Assert.AreEqual ("BaseValue", res5.Base);
1656                         Assert.AreEqual ("MidValue", res5.Mid);
1657
1658                         xs = new XmlSerializer (typeof (Bug8468SubclassNoNamespaceV2), "http://test-namespace");
1659                         var res6 = (Bug8468SubclassNoNamespaceV2)xs.Deserialize (new StringReader (msg));
1660                         Assert.IsNotNull (res6);
1661                         Assert.AreEqual ("BaseValue", res6.Base);
1662                         Assert.AreEqual ("MidValue", res6.Mid);
1663                 }
1664
1665                 [Test] // bug #9193
1666                 public void TestOrderedMapWithFlatList ()
1667                 {
1668                         var d = (Bug9193Class) Deserialize (typeof(Bug9193Class), "<Test><Data>One</Data><Data>Two</Data><Data>Three</Data><Extra>a</Extra><Extra>b</Extra></Test>");
1669                         Assert.IsNotNull (d);
1670                         Assert.AreEqual (3, d.Data.Length);
1671                         Assert.AreEqual ("One", d.Data[0]);
1672                         Assert.AreEqual ("Two", d.Data[1]);
1673                         Assert.AreEqual ("Three", d.Data[2]);
1674
1675                         Assert.AreEqual (2, d.Extra.Length);
1676                         Assert.AreEqual ("a", d.Extra[0]);
1677                         Assert.AreEqual ("b", d.Extra[1]);
1678                 }
1679         }
1680 }