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                 [Category ("NotDotNet")]
 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.list3, "#A2");
 252                         Assert.IsNull (d2.list4, "#A3");
 253                         Assert.IsNotNull (d2.list5, "#A4");
 254                         Assert.IsNotNull (d2.ed, "#A5");
 255                         Assert.IsNotNull (d2.str, "#A6");
 256
 257                         d2 = (ListDefaults) Deserialize (typeof (ListDefaults), "<root></root>");
 258
 259                         Assert.IsNotNull (d2.list2, "#B1");
 260                         Assert.IsNull (d2.list3, "#B2");
 261                         Assert.IsNull (d2.list4, "#B3");
 262                         Assert.IsNotNull (d2.list5, "#B4");
 263                         Assert.IsNotNull (d2.ed, "#B5");
 264                         Assert.IsNotNull (d2.str, "#B6");
 265                 }
 266
 267                 [Test]
 268                 public void TestDeserializeChoiceArray ()
 269                 {
 270                         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>");
 271                         Assert.IsNotNull (v.Items, "#1");
 272                         Assert.IsNotNull (v.ItemsElementName, "#2");
 273                         Assert.AreEqual (2, v.Items.Length, "#3");
 274                         Assert.AreEqual (2, v.ItemsElementName.Length, "#4");
 275                         Assert.AreEqual (1, v.Items[0], "#5");
 276                         Assert.AreEqual (2, v.Items[1], "#6");
 277                         Assert.AreEqual (ItemsChoiceType.In, v.ItemsElementName[0], "#7");
 278                         Assert.AreEqual (ItemsChoiceType.Es, v.ItemsElementName[1], "#8");
 279                 }
 280
 281                 #region GenericsDeseralizationTests
 282
 283 #if NET_2_0
 284                 [Test]
 285                 public void TestDeserializeGenSimpleClassString ()
 286                 {
 287                         Deserialize (typeof (GenSimpleClass<string>), "<GenSimpleClassOfString xmlns:xsd='http://www.w3.org/2001/XMLSchema' xmlns:xsi='http://www.w3.org/2001/XMLSchema-instance' />");
 288                         Assert.AreEqual (typeof (GenSimpleClass<string>), result.GetType ());
 289                         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>");
 290                         GenSimpleClass<string> simple = result as GenSimpleClass<string>;
 291                         Assert.AreEqual ("hello", simple.something);
 292                 }
 293
 294                 [Test]
 295                 public void TestDeserializeGenSimpleClassBool ()
 296                 {
 297                         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>");
 298                         Assert.AreEqual (typeof (GenSimpleClass<bool>), result.GetType ());
 299                         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>");
 300                         GenSimpleClass<bool> simple = result as GenSimpleClass<bool>;
 301                         Assert.AreEqual (true, simple.something);
 302                 }
 303
 304                 [Test]
 305                 public void TestDeserializeGenSimpleStructInt ()
 306                 {
 307                         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>");
 308                         Assert.AreEqual (typeof (GenSimpleStruct<int>), result.GetType ());
 309                         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>");
 310                         GenSimpleStruct<int> simple = new GenSimpleStruct<int> (0);
 311                         if (result != null)
 312                                 simple = (GenSimpleStruct<int>) result;
 313                         Assert.AreEqual (123, simple.something);
 314                 }
 315
 316                 [Test]
 317                 public void TestDeserializeGenListClassString ()
 318                 {
 319                         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>");
 320                         Assert.AreEqual (typeof (GenListClass<string>), result.GetType ());
 321                         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>");
 322                         GenListClass<string> genlist = result as GenListClass<string>;
 323                         Assert.AreEqual ("Value1", genlist.somelist[0]);
 324                         Assert.AreEqual ("Value2", genlist.somelist[1]);
 325                 }
 326
 327                 [Test]
 328                 public void TestDeserializeGenListClassFloat ()
 329                 {
 330                         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>");
 331                         Assert.AreEqual (typeof (GenListClass<float>), result.GetType ());
 332                         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>");
 333                         GenListClass<float> genlist = result as GenListClass<float>;
 334                         Assert.AreEqual (1, genlist.somelist[0]);
 335                         Assert.AreEqual (2.2F, genlist.somelist[1]);
 336                 }
 337
 338                 [Test]
 339                 public void TestDeserializeGenListClassList ()
 340                 {
 341                         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>");
 342                         Assert.AreEqual (typeof (GenListClass<GenListClass<int>>), result.GetType ());
 343                         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>");
 344                         GenListClass<GenListClass<int>> genlist = result as GenListClass<GenListClass<int>>;
 345                         Assert.AreEqual (1, genlist.somelist[0].somelist[0]);
 346                         Assert.AreEqual (2, genlist.somelist[0].somelist[1]);
 347                         Assert.AreEqual (10, genlist.somelist[1].somelist[0]);
 348                         Assert.AreEqual (20, genlist.somelist[1].somelist[1]);
 349                 }
 350
 351                 [Test]
 352                 public void TestDeserializeGenListClassArray ()
 353                 {
 354                         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>");
 355                         Assert.AreEqual (typeof (GenListClass<GenArrayClass<char>>), result.GetType ());
 356                         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>");
 357                         GenListClass<GenArrayClass<char>> genlist = result as GenListClass<GenArrayClass<char>>;
 358                         Assert.AreEqual ('a', genlist.somelist[0].arr[0]);
 359                         Assert.AreEqual ('b', genlist.somelist[0].arr[1]);
 360                         Assert.AreEqual ('d', genlist.somelist[1].arr[0]);
 361                         Assert.AreEqual ('e', genlist.somelist[1].arr[1]);
 362                         Assert.AreEqual ('f', genlist.somelist[1].arr[2]);
 363                 }
 364
 365                 [Test]
 366                 public void TestDeserializeGenTwoClassCharDouble ()
 367                 {
 368                         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>");
 369                         Assert.AreEqual (typeof (GenTwoClass<char, double>), result.GetType ());
 370                         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>");
 371                         GenTwoClass<char, double> gentwo = result as GenTwoClass<char, double>;
 372                         Assert.AreEqual ('a', gentwo.something1);
 373                         Assert.AreEqual (2.2, gentwo.something2);
 374                 }
 375
 376                 [Test]
 377                 public void TestDeserializeGenDerivedClassDecimalShort ()
 378                 {
 379                         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>");
 380                         Assert.AreEqual (typeof (GenDerivedClass<decimal, short>), result.GetType ());
 381                         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>");
 382                         GenDerivedClass<decimal, short> derived = result as GenDerivedClass<decimal, short>;
 383                         Assert.AreEqual ("Value1", derived.something1);
 384                         Assert.AreEqual (1, derived.something2);
 385                         Assert.AreEqual (1.1M, derived.another1);
 386                         Assert.AreEqual (-22, derived.another2);
 387                 }
 388
 389                 [Test]
 390                 public void TestDeserializeGenDerivedSecondClassByteUlong ()
 391                 {
 392                         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>");
 393                         Assert.AreEqual (typeof (GenDerived2Class<byte, ulong>), result.GetType ());
 394                         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>");
 395                         GenDerived2Class<byte, ulong> derived2 = result as GenDerived2Class<byte, ulong>;
 396                         Assert.AreEqual (1, derived2.something1);
 397                         Assert.AreEqual (222, derived2.something2);
 398                         Assert.AreEqual (111, derived2.another1);
 399                         Assert.AreEqual (222222, derived2.another2);
 400                 }
 401
 402                 [Test]
 403                 public void TestDeserializeGenNestedClass ()
 404                 {
 405                         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>");
 406                         Assert.AreEqual (typeof (GenNestedClass<string, int>.InnerClass<bool>), result.GetType ());
 407                         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>");
 408                         GenNestedClass<string, int>.InnerClass<bool> nested = result as GenNestedClass<string, int>.InnerClass<bool>;
 409                         Assert.AreEqual (5, nested.inner);
 410                         Assert.AreEqual (true, nested.something);
 411                 }
 412
 413                 [Test]
 414                 public void TestDeserializeGenListClassListNested ()
 415                 {
 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></somelist></GenListClassOfGenListClassOfInnerClassOfInt32Int32String>");
 418                         Assert.AreEqual (typeof (GenListClass<GenListClass<GenNestedClass<int, int>.InnerClass<string>>>), result.GetType ());
 419                         Deserialize (typeof (GenListClass<GenListClass<GenNestedClass<int, int>.InnerClass<string>>>),
 420                                 "<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>");
 421                         GenListClass<GenListClass<GenNestedClass<int, int>.InnerClass<string>>> genlist =
 422                                 result as GenListClass<GenListClass<GenNestedClass<int, int>.InnerClass<string>>>;
 423                         Assert.AreEqual (1, genlist.somelist[0].somelist[0].inner);
 424                         Assert.AreEqual ("ONE", genlist.somelist[0].somelist[0].something);
 425                         Assert.AreEqual (2, genlist.somelist[0].somelist[1].inner);
 426                         Assert.AreEqual ("TWO", genlist.somelist[0].somelist[1].something);
 427                         Assert.AreEqual (30, genlist.somelist[1].somelist[0].inner);
 428                         Assert.AreEqual ("THIRTY", genlist.somelist[1].somelist[0].something);
 429                 }
 430
 431                 public enum Myenum { one, two, three, four, five, six };
 432                 [Test]
 433                 public void TestDeserializeGenArrayClassEnum ()
 434                 {
 435                         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>");
 436                         Assert.AreEqual (typeof (GenArrayClass<Myenum>), result.GetType ());
 437                         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>");
 438                         GenArrayClass<Myenum> genarr = result as GenArrayClass<Myenum>;
 439                         Assert.AreEqual (Myenum.one, genarr.arr[0]);
 440                         Assert.AreEqual (Myenum.three, genarr.arr[1]);
 441                         Assert.AreEqual (Myenum.five, genarr.arr[2]);
 442                 }
 443
 444                 [Test]
 445                 public void TestDeserializeGenArrayClassStruct ()
 446                 {
 447                         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>");
 448                         Assert.AreEqual (typeof (GenArrayClass<GenSimpleStruct<uint>>), result.GetType ());
 449                         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>");
 450                         GenArrayClass<GenSimpleStruct<uint>> genarr = result as GenArrayClass<GenSimpleStruct<uint>>;
 451                         Assert.AreEqual (111, genarr.arr[0].something);
 452                         Assert.AreEqual (222, genarr.arr[1].something);
 453                         Assert.AreEqual (333, genarr.arr[2].something);
 454                 }
 455
 456                 [Test]
 457                 public void TestDeserializeGenArrayClassList ()
 458                 {
 459                         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>");
 460                         Assert.AreEqual (typeof (GenArrayClass<GenListClass<string>>), result.GetType ());
 461                         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>");
 462                         GenArrayClass<GenListClass<string>> genarr = result as GenArrayClass<GenListClass<string>>;
 463                         Assert.AreEqual ("list1-val1", genarr.arr[0].somelist[0]);
 464                         Assert.AreEqual ("list1-val2", genarr.arr[0].somelist[1]);
 465                         Assert.AreEqual ("list2-val1", genarr.arr[1].somelist[0]);
 466                         Assert.AreEqual ("list2-val2", genarr.arr[1].somelist[1]);
 467                         Assert.AreEqual ("list2-val3", genarr.arr[1].somelist[2]);
 468                         Assert.AreEqual ("list2-val4", genarr.arr[1].somelist[3]);
 469                         Assert.AreEqual ("list3val", genarr.arr[2].somelist[0]);
 470                         // The code below checks for DotNet bug (see corresponding test in XmlSerializerTests).
 471                         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>");
 472                         GenArrayClass<GenListClass<string>> genarr2 = result as GenArrayClass<GenListClass<string>>;
 473                         Assert.AreEqual ("list1-val1", genarr2.arr[0].somelist[0]);
 474                         Assert.AreEqual ("list1-val2", genarr2.arr[0].somelist[1]);
 475                         /**/
 476                         Assert.AreEqual ("list3val", genarr2.arr[0].somelist[2]);
 477                         Assert.AreEqual ("list2-val1", genarr2.arr[1].somelist[0]);
 478                         Assert.AreEqual ("list2-val2", genarr2.arr[1].somelist[1]);
 479                         Assert.AreEqual ("list2-val3", genarr2.arr[1].somelist[2]);
 480                         Assert.AreEqual ("list2-val4", genarr2.arr[1].somelist[3]);
 481                         //Assert.AreEqual ("list3val", genarr2.arr[2].somelist[0]);
 482                 }
 483
 484                 [Test]
 485                 public void TestDeserializeGenComplexStruct ()
 486                 {
 487                         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>");
 488                         Assert.AreEqual (typeof (GenComplexStruct<int, string>), result.GetType ());
 489                         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>");
 490                         GenComplexStruct<int, string> complex = new GenComplexStruct<int, string> (0);
 491                         if (result != null)
 492                                 complex = (GenComplexStruct<int, string>) result;
 493                         Assert.AreEqual (123, complex.something);
 494                         Assert.AreEqual (456, complex.simpleclass.something);
 495                         Assert.AreEqual (789, complex.simplestruct.something);
 496                         Assert.AreEqual (100, complex.listclass.somelist[0]);
 497                         Assert.AreEqual (200, complex.listclass.somelist[1]);
 498                         Assert.AreEqual (11, complex.arrayclass.arr[0]);
 499                         Assert.AreEqual (22, complex.arrayclass.arr[1]);
 500                         Assert.AreEqual (33, complex.arrayclass.arr[2]);
 501                         Assert.AreEqual (10, complex.twoclass.something1);
 502                         Assert.AreEqual ("Ten", complex.twoclass.something2);
 503                         Assert.AreEqual (1, complex.derivedclass.another1);
 504                         Assert.AreEqual ("one", complex.derivedclass.another2);
 505                         Assert.AreEqual ("two", complex.derivedclass.something1);
 506                         Assert.AreEqual (2, complex.derivedclass.something2);
 507                         Assert.AreEqual (3, complex.derived2.another1);
 508                         Assert.AreEqual ("three", complex.derived2.another2);
 509                         Assert.AreEqual (4, complex.derived2.something1);
 510                         Assert.AreEqual ("four", complex.derived2.something2);
 511                         Assert.AreEqual (5, complex.nestedouter.outer);
 512                         Assert.AreEqual ("six", complex.nestedinner.inner);
 513                         Assert.AreEqual (6, complex.nestedinner.something);
 514                 }
 515 #endif
 516
 517                 #endregion //GenericsDeseralizationTests
 518
 519                 [Test]
 520                 public void TestDeserializeCollection ()
 521                 {
 522                         string s0 = "";
 523                         s0 += " <ArrayOfEntity xmlns:xsd='http://www.w3.org/2001/XMLSchema' xmlns:xsi='http://www.w3.org/2001/XMLSchema-instance'>";
 524                         s0 += "         <Entity Name='node1'/>";
 525                         s0 += "         <Entity Name='node2'/>";
 526                         s0 += " </ArrayOfEntity>";
 527
 528                         EntityCollection col = (EntityCollection) Deserialize (typeof (EntityCollection), s0);
 529                         Assert.IsNotNull (col, "#1");
 530                         Assert.AreEqual (2, col.Count, "#2");
 531                         Assert.IsNull (col[0].Parent, "#3");
 532                         Assert.IsNull (col[1].Parent, "#4");
 533                 }
 534
 535                 [Test]
 536                 public void TestDeserializeEmptyCollection ()
 537                 {
 538                         string s1 = "";
 539                         s1 += " <ArrayOfEntity xmlns:xsd='http://www.w3.org/2001/XMLSchema' xmlns:xsi='http://www.w3.org/2001/XMLSchema-instance' />";
 540
 541                         EntityCollection col = (EntityCollection) Deserialize (typeof (EntityCollection), s1);
 542                         Assert.IsNotNull (col, "#A1");
 543                         Assert.AreEqual (0, col.Count, "#A2");
 544
 545                         string s1_1 = "";
 546                         s1_1 += "       <ArrayOfEntity xmlns:xsd='http://www.w3.org/2001/XMLSchema' xmlns:xsi='http://www.w3.org/2001/XMLSchema-instance'>";
 547                         s1_1 += "       </ArrayOfEntity>";
 548
 549                         col = (EntityCollection) Deserialize (typeof (EntityCollection), s1_1);
 550                         Assert.IsNotNull (col, "#B1");
 551                         Assert.AreEqual (0, col.Count, "#B2");
 552                 }
 553
 554                 [Test]
 555                 public void TestDeserializeNilCollectionIsNotNull ()
 556                 {
 557                         string s2 = "";
 558                         s2 += " <ArrayOfEntity xmlns:xsd='http://www.w3.org/2001/XMLSchema' xmlns:xsi='http://www.w3.org/2001/XMLSchema-instance' xsi:nil='true'/>";
 559
 560                         EntityCollection col = (EntityCollection) Deserialize (typeof (EntityCollection), s2);
 561                         Assert.IsNotNull (col, "#1");
 562                         Assert.AreEqual (0, col.Count, "#2");
 563                 }
 564
 565                 [Test]
 566                 public void TestDeserializeObjectCollections ()
 567                 {
 568                         string s3 = "";
 569                         s3 += "<Container xmlns:xsd='http://www.w3.org/2001/XMLSchema' xmlns:xsi='http://www.w3.org/2001/XMLSchema-instance'>";
 570                         s3 += " <Collection1 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 += " </Collection1>";
 574                         s3 += " <Collection2 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 += " </Collection2>";
 578                         s3 += " <Collection3 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 += " </Collection3>";
 582                         s3 += " <Collection4 xmlns:xsd='http://www.w3.org/2001/XMLSchema' xmlns:xsi='http://www.w3.org/2001/XMLSchema-instance'>";
 583                         s3 += "         <Entity Name='node1'/>";
 584                         s3 += "         <Entity Name='node2'/>";
 585                         s3 += " </Collection4>";
 586                         s3 += "</Container>";
 587
 588                         EntityContainer cont = (EntityContainer) Deserialize (typeof (EntityContainer), s3);
 589                         Assert.IsNotNull (cont, "#A1");
 590
 591                         Assert.IsNotNull (cont.Collection1, "#B1");
 592                         Assert.AreEqual (2, cont.Collection1.Count, "#B2");
 593                         Assert.AreEqual ("assigned", cont.Collection1.Container, "#B3");
 594                         Assert.AreEqual ("assigned", cont.Collection1[0].Parent, "#B4");
 595                         Assert.AreEqual ("assigned", cont.Collection1[1].Parent, "#B5");
 596
 597                         Assert.IsNotNull (cont.Collection2, "#C1");
 598                         Assert.AreEqual (2, cont.Collection2.Count, "#C2");
 599                         Assert.AreEqual ("assigned", cont.Collection2.Container, "#C3");
 600                         Assert.AreEqual ("assigned", cont.Collection2[0].Parent, "#C4");
 601                         Assert.AreEqual ("assigned", cont.Collection2[1].Parent, "#C5");
 602
 603                         Assert.IsNotNull (cont.Collection3, "#D1");
 604                         Assert.AreEqual (2, cont.Collection3.Count, "#D2");
 605                         Assert.AreEqual ("root", cont.Collection3.Container, "#D3");
 606                         Assert.AreEqual ("root", cont.Collection3[0].Parent, "#D4");
 607                         Assert.AreEqual ("root", cont.Collection3[1].Parent, "#D5");
 608
 609                         Assert.IsNotNull (cont.Collection4, "#E1");
 610                         Assert.AreEqual (2, cont.Collection4.Count, "#E2");
 611                         Assert.AreEqual ("root", cont.Collection4.Container, "#E3");
 612                         Assert.AreEqual ("root", cont.Collection4[0].Parent, "#E4");
 613                         Assert.AreEqual ("root", cont.Collection4[1].Parent, "#E5");
 614                 }
 615
 616                 [Test]
 617                 public void TestDeserializeEmptyObjectCollections ()
 618                 {
 619                         string s4 = "";
 620                         s4 += "<Container xmlns:xsd='http://www.w3.org/2001/XMLSchema' xmlns:xsi='http://www.w3.org/2001/XMLSchema-instance'>";
 621                         s4 += "</Container>";
 622
 623                         EntityContainer cont = (EntityContainer) Deserialize (typeof (EntityContainer), s4);
 624                         Assert.IsNotNull (cont, "#A1");
 625
 626                         Assert.IsNotNull (cont.Collection1, "#B1");
 627                         Assert.AreEqual (0, cont.Collection1.Count, "#B2");
 628                         Assert.AreEqual ("assigned", cont.Collection1.Container, "#B3");
 629
 630                         Assert.IsNotNull (cont.Collection2, "#C1");
 631                         Assert.AreEqual (0, cont.Collection2.Count, "#C2");
 632                         Assert.AreEqual ("assigned", cont.Collection2.Container, "#C3");
 633
 634                         Assert.IsNotNull (cont.Collection3, "#D1");
 635                         Assert.AreEqual (0, cont.Collection3.Count, "#D2");
 636                         Assert.AreEqual ("root", cont.Collection3.Container, "#D3");
 637
 638                         Assert.IsNotNull (cont.Collection4, "#E1");
 639                         Assert.AreEqual (0, cont.Collection4.Count, "#E2");
 640                         Assert.AreEqual ("root", cont.Collection4.Container, "#E3");
 641                 }
 642
 643                 [Test]
 644                 public void TestDeserializeObjectNilCollectionsAreNotNull ()
 645                 {
 646                         string s5 = "";
 647                         s5 += "<Container xmlns:xsd='http://www.w3.org/2001/XMLSchema' xmlns:xsi='http://www.w3.org/2001/XMLSchema-instance'>";
 648                         s5 += " <Collection1 xmlns:xsd='http://www.w3.org/2001/XMLSchema' xmlns:xsi='http://www.w3.org/2001/XMLSchema-instance' xsi:nil='true' />";
 649                         s5 += " <Collection2 xmlns:xsd='http://www.w3.org/2001/XMLSchema' xmlns:xsi='http://www.w3.org/2001/XMLSchema-instance' xsi:nil='true' />";
 650                         s5 += " <Collection3 xmlns:xsd='http://www.w3.org/2001/XMLSchema' xmlns:xsi='http://www.w3.org/2001/XMLSchema-instance' xsi:nil='true' />";
 651                         s5 += " <Collection4 xmlns:xsd='http://www.w3.org/2001/XMLSchema' xmlns:xsi='http://www.w3.org/2001/XMLSchema-instance' xsi:nil='true' />";
 652                         s5 += "</Container>";
 653
 654                         EntityContainer cont = (EntityContainer) Deserialize (typeof (EntityContainer), s5);
 655                         Assert.IsNotNull (cont, "#A1");
 656
 657                         Assert.IsNotNull (cont.Collection1, "#B1");
 658                         Assert.AreEqual (0, cont.Collection1.Count, "#B2");
 659                         Assert.AreEqual ("assigned", cont.Collection1.Container, "#B3");
 660
 661                         Assert.IsNotNull (cont.Collection2, "#C1");
 662                         Assert.AreEqual (0, cont.Collection2.Count, "#C2");
 663                         Assert.AreEqual ("assigned", cont.Collection2.Container, "#C3");
 664
 665                         Assert.IsNotNull (cont.Collection3, "#D1");
 666                         Assert.AreEqual (0, cont.Collection3.Count, "#D2");
 667                         Assert.AreEqual ("root", cont.Collection3.Container, "#D3");
 668
 669                         Assert.IsNotNull (cont.Collection4, "#E1");
 670                         Assert.AreEqual (0, cont.Collection4.Count, "#E2");
 671                         Assert.AreEqual ("root", cont.Collection4.Container, "#E3");
 672                 }
 673
 674                 [Test]
 675                 public void TestDeserializeObjectEmptyCollections ()
 676                 {
 677                         string s6 = "";
 678                         s6 += "<Container xmlns:xsd='http://www.w3.org/2001/XMLSchema' xmlns:xsi='http://www.w3.org/2001/XMLSchema-instance'>";
 679                         s6 += " <Collection1 xmlns:xsd='http://www.w3.org/2001/XMLSchema' xmlns:xsi='http://www.w3.org/2001/XMLSchema-instance' />";
 680                         s6 += " <Collection2 xmlns:xsd='http://www.w3.org/2001/XMLSchema' xmlns:xsi='http://www.w3.org/2001/XMLSchema-instance' />";
 681                         s6 += " <Collection3 xmlns:xsd='http://www.w3.org/2001/XMLSchema' xmlns:xsi='http://www.w3.org/2001/XMLSchema-instance' />";
 682                         s6 += " <Collection4 xmlns:xsd='http://www.w3.org/2001/XMLSchema' xmlns:xsi='http://www.w3.org/2001/XMLSchema-instance' />";
 683                         s6 += "</Container>";
 684
 685                         EntityContainer cont = (EntityContainer) Deserialize (typeof (EntityContainer), s6);
 686                         Assert.IsNotNull (cont, "#A1");
 687
 688                         Assert.IsNotNull (cont.Collection1, "#B1");
 689                         Assert.AreEqual (0, cont.Collection1.Count, "#B2");
 690                         Assert.AreEqual ("assigned", cont.Collection1.Container, "#B3");
 691
 692                         Assert.IsNotNull (cont.Collection2, "#C1");
 693                         Assert.AreEqual (0, cont.Collection2.Count, "#C2");
 694                         Assert.AreEqual ("assigned", cont.Collection2.Container, "#C3");
 695
 696                         Assert.IsNotNull (cont.Collection3, "#D1");
 697                         Assert.AreEqual (0, cont.Collection3.Count, "#D2");
 698                         Assert.AreEqual ("root", cont.Collection3.Container, "#D3");
 699
 700                         Assert.IsNotNull (cont.Collection4, "#E1");
 701                         Assert.AreEqual (0, cont.Collection4.Count, "#E2");
 702                         Assert.AreEqual ("root", cont.Collection4.Container, "#E3");
 703                 }
 704
 705                 [Test]
 706                 public void TestDeserializeObjectEmptyArrays ()
 707                 {
 708                         string s6 = "";
 709                         s6 += "<Container xmlns:xsd='http://www.w3.org/2001/XMLSchema' xmlns:xsi='http://www.w3.org/2001/XMLSchema-instance'>";
 710                         s6 += " <Collection1 xmlns:xsd='http://www.w3.org/2001/XMLSchema' xmlns:xsi='http://www.w3.org/2001/XMLSchema-instance' />";
 711                         s6 += " <Collection2 xmlns:xsd='http://www.w3.org/2001/XMLSchema' xmlns:xsi='http://www.w3.org/2001/XMLSchema-instance' />";
 712                         s6 += " <Collection3 xmlns:xsd='http://www.w3.org/2001/XMLSchema' xmlns:xsi='http://www.w3.org/2001/XMLSchema-instance' />";
 713                         s6 += " <Collection4 xmlns:xsd='http://www.w3.org/2001/XMLSchema' xmlns:xsi='http://www.w3.org/2001/XMLSchema-instance' />";
 714                         s6 += "</Container>";
 715
 716                         ArrayEntityContainer cont = (ArrayEntityContainer) Deserialize (typeof (ArrayEntityContainer), s6);
 717                         Assert.IsNotNull (cont, "#A1");
 718
 719                         Assert.IsNotNull (cont.Collection1, "#B1");
 720                         Assert.AreEqual (0, cont.Collection1.Length, "#B2");
 721
 722                         Assert.IsNotNull (cont.Collection2, "#C1");
 723                         Assert.AreEqual (0, cont.Collection2.Length, "#C2");
 724
 725                         Assert.IsNotNull (cont.Collection3, "#D1");
 726                         Assert.AreEqual (0, cont.Collection3.Length, "#D2");
 727
 728                         Assert.IsNotNull (cont.Collection4, "#E1");
 729                         Assert.AreEqual (0, cont.Collection4.Length, "#E2");
 730                 }
 731
 732                 [Test]
 733                 public void TestDeserializeEmptyObjectArrays ()
 734                 {
 735                         string s4 = "";
 736                         s4 += "<Container xmlns:xsd='http://www.w3.org/2001/XMLSchema' xmlns:xsi='http://www.w3.org/2001/XMLSchema-instance'>";
 737                         s4 += "</Container>";
 738
 739                         ArrayEntityContainer cont = (ArrayEntityContainer) Deserialize (typeof (ArrayEntityContainer), s4);
 740                         Assert.IsNotNull (cont, "#A1");
 741
 742                         Assert.IsNull (cont.Collection1, "#B1");
 743                         Assert.IsNull (cont.Collection2, "#B2");
 744
 745                         Assert.IsNotNull (cont.Collection3, "#C1");
 746                         Assert.AreEqual (0, cont.Collection3.Length, "#C2");
 747
 748                         Assert.IsNotNull (cont.Collection4, "#D1");
 749                         Assert.AreEqual (0, cont.Collection4.Length, "#D2");
 750                 }
 751
 752                 [Test]
 753                 public void TestDeserializeObjectNilArrays ()
 754                 {
 755                         string s5 = "";
 756                         s5 += "<Container xmlns:xsd='http://www.w3.org/2001/XMLSchema' xmlns:xsi='http://www.w3.org/2001/XMLSchema-instance'>";
 757                         s5 += " <Collection1 xmlns:xsd='http://www.w3.org/2001/XMLSchema' xmlns:xsi='http://www.w3.org/2001/XMLSchema-instance' xsi:nil='true' />";
 758                         s5 += " <Collection2 xmlns:xsd='http://www.w3.org/2001/XMLSchema' xmlns:xsi='http://www.w3.org/2001/XMLSchema-instance' xsi:nil='true' />";
 759                         s5 += " <Collection3 xmlns:xsd='http://www.w3.org/2001/XMLSchema' xmlns:xsi='http://www.w3.org/2001/XMLSchema-instance' xsi:nil='true' />";
 760                         s5 += " <Collection4 xmlns:xsd='http://www.w3.org/2001/XMLSchema' xmlns:xsi='http://www.w3.org/2001/XMLSchema-instance' xsi:nil='true' />";
 761                         s5 += "</Container>";
 762
 763                         ArrayEntityContainer cont = (ArrayEntityContainer) Deserialize (typeof (ArrayEntityContainer), s5);
 764                         Assert.IsNotNull (cont, "#A1");
 765
 766                         Assert.IsNull (cont.Collection1, "#B1");
 767                         Assert.IsNull (cont.Collection2, "#B2");
 768                         Assert.IsNull (cont.Collection3, "#B3");
 769
 770                         Assert.IsNotNull (cont.Collection4, "#C1");
 771                         Assert.AreEqual (0, cont.Collection4.Length, "#C2");
 772                 }
 773
 774                 [Test]
 775                 public void TestDeserializeEmptyArray ()
 776                 {
 777                         string s1 = "";
 778                         s1 += "<ArrayOfEntity xmlns:xsd='http://www.w3.org/2001/XMLSchema' xmlns:xsi='http://www.w3.org/2001/XMLSchema-instance' />";
 779
 780                         Entity[] col = (Entity[]) Deserialize (typeof (Entity[]), s1);
 781                         Assert.IsNotNull (col, "#A1");
 782                         Assert.AreEqual (0, col.Length, "#A2");
 783
 784                         string s1_1 = "";
 785                         s1_1 += "       <ArrayOfEntity xmlns:xsd='http://www.w3.org/2001/XMLSchema' xmlns:xsi='http://www.w3.org/2001/XMLSchema-instance'>";
 786                         s1_1 += "       </ArrayOfEntity>";
 787
 788                         col = (Entity[]) Deserialize (typeof (Entity[]), s1_1);
 789                         Assert.IsNotNull (col, "#B1");
 790                         Assert.AreEqual (0, col.Length, "#B2");
 791                 }
 792
 793                 [Test]
 794                 public void TestDeserializeNilArray ()
 795                 {
 796                         string s2 = "";
 797                         s2 += "<ArrayOfEntity xmlns:xsd='http://www.w3.org/2001/XMLSchema' xmlns:xsi='http://www.w3.org/2001/XMLSchema-instance' xsi:nil='true'/>";
 798
 799                         Entity[] col = (Entity[]) Deserialize (typeof (Entity[]), s2);
 800                         Assert.IsNull (col, "#1");
 801                 }
 802
 803                 [Test]
 804                 public void TestDeserializeObjectWithReadonlyCollection ()
 805                 {
 806                         string s3 = "";
 807                         s3 += "<Container xmlns:xsd='http://www.w3.org/2001/XMLSchema' xmlns:xsi='http://www.w3.org/2001/XMLSchema-instance'>";
 808                         s3 += " <Collection1>";
 809                         s3 += "         <Entity Name='node1'/>";
 810                         s3 += "         <Entity Name='node2'/>";
 811                         s3 += " </Collection1>";
 812                         s3 += "</Container>";
 813
 814                         ObjectWithReadonlyCollection cont = (ObjectWithReadonlyCollection) Deserialize (typeof (ObjectWithReadonlyCollection), s3);
 815                         Assert.IsNotNull (cont, "#1");
 816                         Assert.IsNotNull (cont.Collection1, "#2");
 817                         Assert.AreEqual (2, cont.Collection1.Count, "#3");
 818                         Assert.AreEqual ("root", cont.Collection1.Container, "#4");
 819                         Assert.AreEqual ("root", cont.Collection1[0].Parent, "#5");
 820                         Assert.AreEqual ("root", cont.Collection1[1].Parent, "#6");
 821                 }
 822
 823                 [Test]
 824                 [ExpectedException (typeof (InvalidOperationException))]
 825                 public void TestDeserializeObjectWithReadonlyNulCollection ()
 826                 {
 827                         string s3 = "";
 828                         s3 += "<Container xmlns:xsd='http://www.w3.org/2001/XMLSchema' xmlns:xsi='http://www.w3.org/2001/XMLSchema-instance'>";
 829                         s3 += " <Collection1>";
 830                         s3 += "         <Entity Name='node1'/>";
 831                         s3 += "         <Entity Name='node2'/>";
 832                         s3 += " </Collection1>";
 833                         s3 += "</Container>";
 834
 835                         Deserialize (typeof (ObjectWithReadonlyNulCollection), s3);
 836                 }
 837
 838                 [Test]
 839                 public void TestDeserializeObjectWithReadonlyArray ()
 840                 {
 841                         string s3 = "";
 842                         s3 += "<Container xmlns:xsd='http://www.w3.org/2001/XMLSchema' xmlns:xsi='http://www.w3.org/2001/XMLSchema-instance'>";
 843                         s3 += " <Collection1>";
 844                         s3 += "         <Entity Name='node1'/>";
 845                         s3 += "         <Entity Name='node2'/>";
 846                         s3 += " </Collection1>";
 847                         s3 += "</Container>";
 848
 849                         ObjectWithReadonlyArray cont = (ObjectWithReadonlyArray) Deserialize (typeof (ObjectWithReadonlyArray), s3);
 850                         Assert.IsNotNull (cont, "#1");
 851                         Assert.IsNotNull (cont.Collection1, "#2");
 852                         Assert.AreEqual (0, cont.Collection1.Length, "#3");
 853                 }
 854
 855                 [Test]
 856                 public void TestDeserialize_EnumDefaultValue ()
 857                 {
 858                         EnumDefaultValue e;
 859
 860                         e = (EnumDefaultValue) Deserialize (typeof (EnumDefaultValue), "<EnumDefaultValue />");
 861                         Assert.AreEqual (0, (int) e, "#1");
 862
 863                         e = (EnumDefaultValue) Deserialize (typeof (EnumDefaultValue), "<EnumDefaultValue> e3</EnumDefaultValue>");
 864                         Assert.AreEqual (EnumDefaultValue.e3, e, "#2");
 865
 866                         e = (EnumDefaultValue) Deserialize (typeof (EnumDefaultValue), "<EnumDefaultValue>e1 e2</EnumDefaultValue>");
 867                         Assert.AreEqual (EnumDefaultValue.e3, e, "#3");
 868
 869                         e = (EnumDefaultValue) Deserialize (typeof (EnumDefaultValue), "<EnumDefaultValue>  e1   e2 </EnumDefaultValue>");
 870                         Assert.AreEqual (EnumDefaultValue.e1 | EnumDefaultValue.e2, e, "#4");
 871                 }
 872
 873                 [Test]
 874                 public void TestDeserialize_EnumDefaultValueNF ()
 875                 {
 876                         EnumDefaultValueNF e;
 877
 878                         e = (EnumDefaultValueNF) Deserialize (typeof (EnumDefaultValueNF), "<EnumDefaultValueNF>e3</EnumDefaultValueNF>");
 879                         Assert.AreEqual (EnumDefaultValueNF.e3, e, "#A1");
 880
 881                         try {
 882                                 Deserialize (typeof (EnumDefaultValueNF), "<EnumDefaultValueNF />");
 883                                 Assert.Fail ("#B1");
 884                         }
 885                         catch (InvalidOperationException ex) {
 886                                 Assert.AreEqual (typeof (InvalidOperationException), ex.GetType (), "#B2");
 887                                 Assert.IsNotNull (ex.InnerException, "#B3");
 888                                 Assert.AreEqual (typeof (InvalidOperationException), ex.InnerException.GetType (), "#B4");
 889                                 Assert.IsNotNull (ex.InnerException.Message, "#B5");
 890                                 Assert.IsTrue (ex.InnerException.Message.IndexOf ("''") != -1, "#B6");
 891                                 Assert.IsTrue (ex.InnerException.Message.IndexOf (typeof (EnumDefaultValueNF).Name) != -1, "#B7");
 892                         }
 893
 894                         try {
 895                                 Deserialize (typeof (EnumDefaultValueNF), "<EnumDefaultValueNF>e1 e3</EnumDefaultValueNF>");
 896                                 Assert.Fail ("#C1");
 897                         }
 898                         catch (InvalidOperationException ex) {
 899                                 Assert.AreEqual (typeof (InvalidOperationException), ex.GetType (), "#C2");
 900                                 Assert.IsNotNull (ex.InnerException, "#C3");
 901                                 Assert.AreEqual (typeof (InvalidOperationException), ex.InnerException.GetType (), "#C4");
 902                                 Assert.IsNotNull (ex.InnerException.Message, "#C5");
 903                                 Assert.IsTrue (ex.InnerException.Message.IndexOf ("'e1 e3'") != -1, "#C6");
 904                                 Assert.IsTrue (ex.InnerException.Message.IndexOf (typeof (EnumDefaultValueNF).Name) != -1, "#C7");
 905                         }
 906
 907                         try {
 908                                 Deserialize (typeof (EnumDefaultValueNF), "<EnumDefaultValueNF> e3</EnumDefaultValueNF>");
 909                                 Assert.Fail ("#D1");
 910                         }
 911                         catch (InvalidOperationException ex) {
 912                                 Assert.AreEqual (typeof (InvalidOperationException), ex.GetType (), "#D2");
 913                                 Assert.IsNotNull (ex.InnerException, "#D3");
 914                                 Assert.AreEqual (typeof (InvalidOperationException), ex.InnerException.GetType (), "#D4");
 915                                 Assert.IsNotNull (ex.InnerException.Message, "#D5");
 916                                 Assert.IsTrue (ex.InnerException.Message.IndexOf ("' e3'") != -1, "#D6");
 917                                 Assert.IsTrue (ex.InnerException.Message.IndexOf (typeof (EnumDefaultValueNF).Name) != -1, "#D7");
 918                         }
 919
 920                         try {
 921                                 Deserialize (typeof (EnumDefaultValueNF), "<EnumDefaultValueNF> </EnumDefaultValueNF>");
 922                                 Assert.Fail ("#E1");
 923                         }
 924                         catch (InvalidOperationException ex) {
 925                                 Assert.AreEqual (typeof (InvalidOperationException), ex.GetType (), "#E2");
 926                                 Assert.IsNotNull (ex.InnerException, "#E3");
 927                                 Assert.AreEqual (typeof (InvalidOperationException), ex.InnerException.GetType (), "#E4");
 928                                 Assert.IsNotNull (ex.InnerException.Message, "#E5");
 929                                 Assert.IsTrue (ex.InnerException.Message.IndexOf ("' '") != -1, "#E6");
 930                                 Assert.IsTrue (ex.InnerException.Message.IndexOf (typeof (EnumDefaultValueNF).Name) != -1, "#E7");
 931                         }
 932
 933                         try {
 934                                 Deserialize (typeof (EnumDefaultValueNF), "<EnumDefaultValueNF>1</EnumDefaultValueNF>");
 935                                 Assert.Fail ("#F1");
 936                         }
 937                         catch (InvalidOperationException ex) {
 938                                 Assert.AreEqual (typeof (InvalidOperationException), ex.GetType (), "#F2");
 939                                 Assert.IsNotNull (ex.InnerException, "#F3");
 940                                 Assert.AreEqual (typeof (InvalidOperationException), ex.InnerException.GetType (), "#F4");
 941                                 Assert.IsNotNull (ex.InnerException.Message, "#F5");
 942                                 Assert.IsTrue (ex.InnerException.Message.IndexOf ("'1'") != -1, "#F6");
 943                                 Assert.IsTrue (ex.InnerException.Message.IndexOf (typeof (EnumDefaultValueNF).Name) != -1, "#F7");
 944                         }
 945                 }
 946
 947                 [Test]
 948                 public void TestDeserialize_Field ()
 949                 {
 950                         Field f = null;
 951
 952                         f = (Field) Deserialize (typeof (Field),
 953                                 string.Format (CultureInfo.InvariantCulture, "<?xml version='1.0' encoding='utf-16'?>" +
 954                                 "<field xmlns:xsd='{0}' xmlns:xsi='{1}' flag1='' flag2='' flag4='' modifiers='public' modifiers2='public' modifiers4='public' />",
 955                                 XmlSchemaNamespace, XmlSchemaInstanceNamespace));
 956                         Assert.AreEqual ((FlagEnum) 0, f.Flags1, "#A1");
 957                         Assert.AreEqual ((FlagEnum) 0, f.Flags2, "#A2");
 958                         Assert.AreEqual ((FlagEnum) 0, f.Flags3, "#A3");
 959                         Assert.AreEqual ((FlagEnum) 0, f.Flags4, "#A4");
 960                         Assert.AreEqual (MapModifiers.Public, f.Modifiers, "#A5");
 961                         Assert.AreEqual (MapModifiers.Public, f.Modifiers2, "#A6");
 962                         Assert.AreEqual (MapModifiers.Public, f.Modifiers3, "#A7");
 963                         Assert.AreEqual (MapModifiers.Public, f.Modifiers4, "#A8");
 964                         Assert.AreEqual (MapModifiers.Public, f.Modifiers5, "#A9");
 965                         Assert.IsNull (f.Names, "#A10");
 966                         Assert.IsNull (f.Street, "#A11");
 967
 968                         f = (Field) Deserialize (typeof (Field),
 969                                 string.Format (CultureInfo.InvariantCulture, "<?xml version='1.0' encoding='utf-16'?>" +
 970                                 "<field xmlns:xsd='{0}' xmlns:xsi='{1}' flag3='two' flag4='' modifiers='protected' modifiers2='public' />",
 971                                 XmlSchemaNamespace, XmlSchemaInstanceNamespace));
 972                         Assert.AreEqual ((FlagEnum) 0, f.Flags1, "#B1");
 973                         Assert.AreEqual ((FlagEnum) 0, f.Flags2, "#B2");
 974                         Assert.AreEqual (FlagEnum.e2, f.Flags3, "#B3");
 975                         Assert.AreEqual ((FlagEnum) 0, f.Flags4, "#B4");
 976                         Assert.AreEqual (MapModifiers.Protected, f.Modifiers, "#B5");
 977                         Assert.AreEqual (MapModifiers.Public, f.Modifiers2, "#B6");
 978                         Assert.AreEqual (MapModifiers.Public, f.Modifiers3, "#B7");
 979                         Assert.AreEqual (MapModifiers.Public, f.Modifiers4, "#B8");
 980                         Assert.AreEqual (MapModifiers.Public, f.Modifiers5, "#B9");
 981                         Assert.IsNull (f.Names, "#B10");
 982                         Assert.IsNull (f.Street, "#B11");
 983
 984                         f = (Field) Deserialize (typeof (Field),
 985                                 string.Format (CultureInfo.InvariantCulture, "<?xml version='1.0' encoding='utf-16'?>" +
 986                                 "<field xmlns:xsd='{0}' xmlns:xsi='{1}' flag1='two' flag2='two' flag4='' modifiers='public' modifiers2='protected' modifiers3='protected' modifiers4='public' modifiers5='protected' />",
 987                                 XmlSchemaNamespace, XmlSchemaInstanceNamespace));
 988                         Assert.AreEqual (FlagEnum.e2, f.Flags1, "#C1");
 989                         Assert.AreEqual (FlagEnum.e2, f.Flags2, "#C2");
 990                         Assert.AreEqual ((FlagEnum) 0, f.Flags3, "#C3");
 991                         Assert.AreEqual ((FlagEnum) 0, f.Flags4, "#C4");
 992                         Assert.AreEqual (MapModifiers.Public, f.Modifiers, "#C5");
 993                         Assert.AreEqual (MapModifiers.Protected, f.Modifiers2, "#C6");
 994                         Assert.AreEqual (MapModifiers.Protected, f.Modifiers3, "#C7");
 995                         Assert.AreEqual (MapModifiers.Public, f.Modifiers4, "#C8");
 996                         Assert.AreEqual (MapModifiers.Protected, f.Modifiers5, "#C9");
 997                         Assert.IsNull (f.Names, "#C10");
 998                         Assert.IsNull (f.Street, "#C11");
 999
1000                         try {
1001                                 f = (Field) Deserialize (typeof (Field),
1002                                         string.Format (CultureInfo.InvariantCulture, "<?xml version='1.0' encoding='utf-16'?>" +
1003                                         "<field xmlns:xsd='{0}' xmlns:xsi='{1}' flag2='444' />",
1004                                         XmlSchemaNamespace, XmlSchemaInstanceNamespace));
1005                                 Assert.Fail ("#D1");
1006                         }
1007                         catch (InvalidOperationException ex) {
1008                                 // There was an error generating the XML document
1009                                 Assert.AreEqual (typeof (InvalidOperationException), ex.GetType (), "#D2");
1010                                 Assert.IsNotNull (ex.Message, "#D3");
1011                                 Assert.IsNotNull (ex.InnerException, "#D4");
1012
1013                                 // '444' is not a valid value for MonoTests.System.Xml.TestClasses.FlagEnum
1014                                 Assert.AreEqual (typeof (InvalidOperationException), ex.InnerException.GetType (), "#D5");
1015                                 Assert.IsNotNull (ex.InnerException.Message, "#D6");
1016                                 Assert.IsTrue (ex.InnerException.Message.IndexOf ("'444'") != -1, "#D7");
1017                                 Assert.IsTrue (ex.InnerException.Message.IndexOf (typeof (FlagEnum).FullName) != -1, "#D8");
1018                                 Assert.IsNull (ex.InnerException.InnerException, "#D9");
1019                         }
1020
1021                         try {
1022                                 f = (Field) Deserialize (typeof (Field),
1023                                         string.Format (CultureInfo.InvariantCulture, "<?xml version='1.0' encoding='utf-16'?>" +
1024                                         "<field xmlns:xsd='{0}' xmlns:xsi='{1}' flag2='Garbage' />",
1025                                         XmlSchemaNamespace, XmlSchemaInstanceNamespace));
1026                                 Assert.Fail ("#E1");
1027                         }
1028                         catch (InvalidOperationException ex) {
1029                                 // There was an error generating the XML document
1030                                 Assert.AreEqual (typeof (InvalidOperationException), ex.GetType (), "#E2");
1031                                 Assert.IsNotNull (ex.Message, "#E3");
1032                                 Assert.IsNotNull (ex.InnerException, "#E4");
1033
1034                                 // 'Garbage' is not a valid value for MonoTests.System.Xml.TestClasses.FlagEnum
1035                                 Assert.AreEqual (typeof (InvalidOperationException), ex.InnerException.GetType (), "#E5");
1036                                 Assert.IsNotNull (ex.InnerException.Message, "#E6");
1037                                 Assert.IsTrue (ex.InnerException.Message.IndexOf ("'Garbage'") != -1, "#E7");
1038                                 Assert.IsTrue (ex.InnerException.Message.IndexOf (typeof (FlagEnum).FullName) != -1, "#E8");
1039                                 Assert.IsNull (ex.InnerException.InnerException, "#E9");
1040                         }
1041
1042                         try {
1043                                 f = (Field) Deserialize (typeof (Field),
1044                                         string.Format (CultureInfo.InvariantCulture, "<?xml version='1.0' encoding='utf-16'?>" +
1045                                         "<field xmlns:xsd='{0}' xmlns:xsi='{1}' flag2='{2}' />",
1046                                         XmlSchemaNamespace, XmlSchemaInstanceNamespace, ((int) FlagEnum.e2).ToString (CultureInfo.InvariantCulture)));
1047                                 Assert.Fail ("#F1");
1048                         }
1049                         catch (InvalidOperationException ex) {
1050                                 // There was an error generating the XML document
1051                                 Assert.AreEqual (typeof (InvalidOperationException), ex.GetType (), "#F2");
1052                                 Assert.IsNotNull (ex.Message, "#F3");
1053                                 Assert.IsNotNull (ex.InnerException, "#F4");
1054
1055                                 // '2' is not a valid value for MonoTests.System.Xml.TestClasses.FlagEnum
1056                                 Assert.AreEqual (typeof (InvalidOperationException), ex.InnerException.GetType (), "#F5");
1057                                 Assert.IsNotNull (ex.InnerException.Message, "#F6");
1058                                 Assert.IsTrue (ex.InnerException.Message.IndexOf ("'2'") != -1, "#F7");
1059                                 Assert.IsTrue (ex.InnerException.Message.IndexOf (typeof (FlagEnum).FullName) != -1, "#F8");
1060                                 Assert.IsNull (ex.InnerException.InnerException, "#F9");
1061                         }
1062                 }
1063
1064                 [Test]
1065                 [Category ("NotDotNet")] // MS.NET results in compilation error (probably it generates bogus source.)
1066                 public void TestDeserialize_Field_Encoded ()
1067                 {
1068                         Field_Encoded f = null;
1069
1070                         f = (Field_Encoded) DeserializeEncoded (typeof (Field_Encoded),
1071                                 string.Format (CultureInfo.InvariantCulture, "<?xml version='1.0' encoding='utf-16'?>" +
1072                                 "<q1:field xmlns:xsd='{0}' xmlns:xsi='{1}' id='id1' flag1='' flag2='' flag4='' modifiers='PuBlIc' modifiers2='PuBlIc' modifiers4='PuBlIc' xmlns:q1='{2}' />",
1073                                 XmlSchemaNamespace, XmlSchemaInstanceNamespace, ANamespace));
1074                         Assert.AreEqual ((FlagEnum_Encoded) 0, f.Flags1, "#A1");
1075                         Assert.AreEqual ((FlagEnum_Encoded) 0, f.Flags2, "#A2");
1076                         Assert.AreEqual ((FlagEnum_Encoded) 0, f.Flags3, "#A3");
1077                         Assert.AreEqual ((FlagEnum_Encoded) 0, f.Flags4, "#A4");
1078                         Assert.AreEqual (MapModifiers.Public, f.Modifiers, "#A5");
1079                         Assert.AreEqual (MapModifiers.Public, f.Modifiers2, "#A6");
1080                         Assert.AreEqual (MapModifiers.Public, f.Modifiers3, "#A7");
1081                         Assert.AreEqual (MapModifiers.Public, f.Modifiers4, "#A8");
1082                         Assert.AreEqual (MapModifiers.Public, f.Modifiers5, "#A9");
1083                         Assert.IsNull (f.Names, "#A10");
1084                         Assert.IsNull (f.Street, "#A11");
1085
1086                         f = (Field_Encoded) DeserializeEncoded (typeof (Field_Encoded),
1087                                 string.Format (CultureInfo.InvariantCulture, "<?xml version='1.0' encoding='utf-16'?>" +
1088                                 "<q1:field xmlns:xsd='{0}' xmlns:xsi='{1}' id='id1' flag3='two' flag4='' modifiers='Protected' modifiers2='PuBlIc' xmlns:q1='{2}' />",
1089                                 XmlSchemaNamespace, XmlSchemaInstanceNamespace, ANamespace));
1090                         Assert.AreEqual ((FlagEnum_Encoded) 0, f.Flags1, "#B1");
1091                         Assert.AreEqual ((FlagEnum_Encoded) 0, f.Flags2, "#B2");
1092                         Assert.AreEqual (FlagEnum_Encoded.e2, f.Flags3, "#B3");
1093                         Assert.AreEqual ((FlagEnum_Encoded) 0, f.Flags4, "#B4");
1094                         Assert.AreEqual (MapModifiers.Protected, f.Modifiers, "#B5");
1095                         Assert.AreEqual (MapModifiers.Public, f.Modifiers2, "#B6");
1096                         Assert.AreEqual (MapModifiers.Public, f.Modifiers3, "#B7");
1097                         Assert.AreEqual (MapModifiers.Public, f.Modifiers4, "#B8");
1098                         Assert.AreEqual (MapModifiers.Public, f.Modifiers5, "#B9");
1099                         Assert.IsNull (f.Names, "#B10");
1100                         Assert.IsNull (f.Street, "#B11");
1101
1102                         f = (Field_Encoded) DeserializeEncoded (typeof (Field_Encoded),
1103                                 string.Format (CultureInfo.InvariantCulture, "<?xml version='1.0' encoding='utf-16'?>" +
1104                                 "<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}' />",
1105                                 XmlSchemaNamespace, XmlSchemaInstanceNamespace, ANamespace));
1106                         Assert.AreEqual (FlagEnum_Encoded.e2, f.Flags1, "#C1");
1107                         Assert.AreEqual (FlagEnum_Encoded.e2, f.Flags2, "#C2");
1108                         Assert.AreEqual ((FlagEnum_Encoded) 0, f.Flags3, "#C3");
1109                         Assert.AreEqual ((FlagEnum_Encoded) 0, f.Flags4, "#C4");
1110                         Assert.AreEqual (MapModifiers.Public, f.Modifiers, "#C5");
1111                         Assert.AreEqual (MapModifiers.Protected, f.Modifiers2, "#C6");
1112                         Assert.AreEqual (MapModifiers.Protected, f.Modifiers3, "#C7");
1113                         Assert.AreEqual (MapModifiers.Public, f.Modifiers4, "#C8");
1114                         Assert.AreEqual (MapModifiers.Protected, f.Modifiers5, "#C9");
1115                         Assert.IsNull (f.Names, "#C10");
1116                         Assert.IsNull (f.Street, "#C11");
1117
1118                         try {
1119                                 f = (Field_Encoded) DeserializeEncoded (typeof (Field_Encoded),
1120                                         string.Format (CultureInfo.InvariantCulture, "<?xml version='1.0' encoding='utf-16'?>" +
1121                                         "<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}' />",
1122                                         XmlSchemaNamespace, XmlSchemaInstanceNamespace, ANamespace));
1123                                 Assert.Fail ("#D1");
1124                         }
1125                         catch (InvalidOperationException ex) {
1126                                 // There was an error generating the XML document
1127                                 Assert.AreEqual (typeof (InvalidOperationException), ex.GetType (), "#D2");
1128                                 Assert.IsNotNull (ex.Message, "#D3");
1129                                 Assert.IsNotNull (ex.InnerException, "#D4");
1130
1131                                 // '444' is not a valid value for MonoTests.System.Xml.TestClasses.FlagEnum_Encoded
1132                                 Assert.AreEqual (typeof (InvalidOperationException), ex.InnerException.GetType (), "#D5");
1133                                 Assert.IsNotNull (ex.InnerException.Message, "#D6");
1134                                 Assert.IsTrue (ex.InnerException.Message.IndexOf ("'444'") != -1, "#D7");
1135                                 Assert.IsTrue (ex.InnerException.Message.IndexOf (typeof (FlagEnum_Encoded).FullName) != -1, "#D8");
1136                                 Assert.IsNull (ex.InnerException.InnerException, "#D9");
1137                         }
1138                 }
1139
1140                 [Test]
1141                 public void TestDeserialize_FlagEnum ()
1142                 {
1143                         FlagEnum e;
1144
1145                         e = (FlagEnum) Deserialize (typeof (FlagEnum), "<FlagEnum />");
1146                         Assert.AreEqual (0, (int) e, "#A1");
1147
1148                         e = (FlagEnum) Deserialize (typeof (FlagEnum), "<FlagEnum>one</FlagEnum>");
1149                         Assert.AreEqual (FlagEnum.e1, e, "#A2");
1150
1151                         e = (FlagEnum) Deserialize (typeof (FlagEnum), "<FlagEnum>one\u200atwo</FlagEnum>");
1152                         Assert.AreEqual (FlagEnum.e1 | FlagEnum.e2, e, "#A3");
1153
1154                         e = (FlagEnum) Deserialize (typeof (FlagEnum), "<FlagEnum>one two four</FlagEnum>");
1155                         Assert.AreEqual (FlagEnum.e1 | FlagEnum.e2 | FlagEnum.e4, e, "#A4");
1156
1157                         e = (FlagEnum) Deserialize (typeof (FlagEnum), "<FlagEnum> two  four </FlagEnum>");
1158                         Assert.AreEqual (FlagEnum.e2 | FlagEnum.e4, e, "#A5");
1159
1160                         e = (FlagEnum) Deserialize (typeof (FlagEnum), "<FlagEnum>two four two</FlagEnum>");
1161                         Assert.AreEqual (FlagEnum.e2 | FlagEnum.e4, e, "#A6");
1162
1163                         e = (FlagEnum) Deserialize (typeof (FlagEnum), "<FlagEnum>two four two\tone\u2002four\rtwo one</FlagEnum>");
1164                         Assert.AreEqual (FlagEnum.e1 | FlagEnum.e2 | FlagEnum.e4, e, "#A7");
1165
1166                         e = (FlagEnum) Deserialize (typeof (FlagEnum), "<FlagEnum></FlagEnum>");
1167                         Assert.AreEqual (0, (int) e, "#A8");
1168
1169                         e = (FlagEnum) Deserialize (typeof (FlagEnum), "<FlagEnum> </FlagEnum>");
1170                         Assert.AreEqual (0, (int) e, "#A9");
1171
1172                         try {
1173                                 Deserialize (typeof (FlagEnum), "<FlagEnum>1</FlagEnum>");
1174                                 Assert.Fail ("#B1");
1175                         }
1176                         catch (InvalidOperationException ex) {
1177                                 Assert.AreEqual (typeof (InvalidOperationException), ex.GetType (), "#B2");
1178                                 Assert.IsNotNull (ex.InnerException, "#B3");
1179                                 Assert.AreEqual (typeof (InvalidOperationException), ex.InnerException.GetType (), "#B4");
1180                                 Assert.IsNotNull (ex.InnerException.Message, "#B5");
1181                                 Assert.IsTrue (ex.InnerException.Message.IndexOf ("'1'") != -1, "#B6");
1182                                 Assert.IsTrue (ex.InnerException.Message.IndexOf (typeof (FlagEnum).FullName) != -1, "#B7");
1183                         }
1184
1185                         try {
1186                                 Deserialize (typeof (FlagEnum), "<FlagEnum>one,two</FlagEnum>");
1187                                 Assert.Fail ("#C1");
1188                         }
1189                         catch (InvalidOperationException ex) {
1190                                 Assert.AreEqual (typeof (InvalidOperationException), ex.GetType (), "#C2");
1191                                 Assert.IsNotNull (ex.InnerException, "#C3");
1192                                 Assert.AreEqual (typeof (InvalidOperationException), ex.InnerException.GetType (), "#C4");
1193                                 Assert.IsNotNull (ex.InnerException.Message, "#C5");
1194                                 Assert.IsTrue (ex.InnerException.Message.IndexOf ("'one,two'") != -1, "#C6");
1195                                 Assert.IsTrue (ex.InnerException.Message.IndexOf (typeof (FlagEnum).FullName) != -1, "#C7");
1196                         }
1197
1198                         try {
1199                                 Deserialize (typeof (FlagEnum), "<FlagEnum>one something</FlagEnum>");
1200                                 Assert.Fail ("#D1");
1201                         }
1202                         catch (InvalidOperationException ex) {
1203                                 Assert.AreEqual (typeof (InvalidOperationException), ex.GetType (), "#D2");
1204                                 Assert.IsNotNull (ex.InnerException, "#D3");
1205                                 Assert.AreEqual (typeof (InvalidOperationException), ex.InnerException.GetType (), "#D4");
1206                                 Assert.IsNotNull (ex.InnerException.Message, "#D5");
1207                                 Assert.IsTrue (ex.InnerException.Message.IndexOf ("'something'") != -1, "#D6");
1208                                 Assert.IsTrue (ex.InnerException.Message.IndexOf (typeof (FlagEnum).FullName) != -1, "#D7");
1209                         }
1210                 }
1211
1212                 [Test]
1213                 public void TestDeserialize_Group ()
1214                 {
1215                         string xml = string.Format (CultureInfo.InvariantCulture,
1216                                 "<Wrapper>" +
1217                                 "<Group xmlns:xsd='{0}' xmlns:xsi='{1}' xmlns:d2p1='http://www.cpandl.com' CreationDate='2002-05-02' d2p1:GroupName='.NET' GroupNumber='ZDI=' id='id1'>" +
1218                                 "<PosInt xsi:type='xsd:nonNegativeInteger'>10000</PosInt>" +
1219                                 "<Grouptype xsi:type='GroupType'>Small</Grouptype>" +
1220                                 "<MyVehicle href='#id2' />" +
1221                                 "</Group>" +
1222                                 "<Car xmlns:d2p1='{1}' id='id2' d2p1:type='Car'>" +
1223                                 "<licenseNumber xmlns:q1='{0}' d2p1:type='q1:string'>1234566</licenseNumber>" +
1224                                 "<makeDate xmlns:q2='{0}' d2p1:type='q2:date'>0001-01-01</makeDate>" +
1225                                 "</Car>" +
1226                                 "</Wrapper>",
1227                                 "http://www.w3.org/2001/XMLSchema", "http://www.w3.org/2001/XMLSchema-instance");
1228
1229                         XmlTextReader xtr = new XmlTextReader (xml, XmlNodeType.Document, null);
1230                         xtr.ReadStartElement ("Wrapper");
1231
1232                         Group group = (Group) DeserializeEncoded (typeof (Group), xtr);
1233
1234                         Assert.AreEqual (new DateTime (2002, 5, 2), group.Today, "#A1");
1235                         Assert.AreEqual (".NET", group.GroupName, "#A2");
1236                         Assert.AreEqual (new byte[] { 0x64, 0x32 }, group.GroupNumber, "#A3");
1237                         Assert.AreEqual (GroupType.A, group.Grouptype, "#A4");
1238                         Assert.AreEqual ("10000", group.PostitiveInt, "#A5");
1239                         Assert.IsFalse (group.IgnoreThis, "#A6");
1240                         Assert.IsNotNull (group.MyVehicle, "#A7");
1241                         Assert.AreEqual (typeof (Car), group.MyVehicle.GetType (), "#A8");
1242                         Assert.AreEqual ("1234566", group.MyVehicle.licenseNumber, "#A9");
1243                         Assert.AreEqual (new DateTime (1, 1, 1), group.MyVehicle.makeDate, "#A10");
1244                         Assert.IsNull (group.MyVehicle.weight, "#A11");
1245
1246                         xml = string.Format (CultureInfo.InvariantCulture,
1247                                 "<Wrapper>" +
1248                                 "<Group xmlns:xsd='{0}' xmlns:xsi='{1}' CreationDate='2002-05-02' GroupNumber='ZDI=' id='id1'>" +
1249                                 "<PosInt xsi:type='xsd:nonNegativeInteger'>10000</PosInt>" +
1250                                 "<Grouptype xsi:type='GroupType'>Large</Grouptype>" +
1251                                 "<MyVehicle href='#id2' />" +
1252                                 "</Group>" +
1253                                 "<Car xmlns:d2p1='{1}' id='id2' d2p1:type='Car'>" +
1254                                 "<weight xmlns:q2='{0}' d2p1:type='q2:string'>450</weight>" +
1255                                 "</Car>" +
1256                                 "</Wrapper>",
1257                                 "http://www.w3.org/2001/XMLSchema", "http://www.w3.org/2001/XMLSchema-instance");
1258
1259                         xtr = new XmlTextReader (xml, XmlNodeType.Document, null);
1260                         xtr.ReadStartElement ("Wrapper");
1261
1262                         group = (Group) DeserializeEncoded (typeof (Group), xtr);
1263
1264                         Assert.AreEqual (new DateTime (2002, 5, 2), group.Today, "#B1");
1265                         Assert.IsNull (group.GroupName, "#B2");
1266                         Assert.AreEqual (new byte[] { 0x64, 0x32 }, group.GroupNumber, "#B3");
1267                         Assert.AreEqual (GroupType.B, group.Grouptype, "#B4");
1268                         Assert.AreEqual ("10000", group.PostitiveInt, "#B5");
1269                         Assert.IsFalse (group.IgnoreThis, "#B6");
1270                         Assert.IsNotNull (group.MyVehicle, "#B7");
1271                         Assert.AreEqual (typeof (Car), group.MyVehicle.GetType (), "#B8");
1272                         Assert.IsNull (group.MyVehicle.licenseNumber, "#B9");
1273                         Assert.AreEqual (DateTime.MinValue, group.MyVehicle.makeDate, "#B10");
1274                         Assert.AreEqual ("450", group.MyVehicle.weight, "#B11");
1275
1276                         xml = string.Format (CultureInfo.InvariantCulture,
1277                                 "<Wrapper>" +
1278                                 "<Group xmlns:xsd='{0}' xmlns:xsi='{1}' id='id1' />" +
1279                                 "</Wrapper>",
1280                                 "http://www.w3.org/2001/XMLSchema", "http://www.w3.org/2001/XMLSchema-instance");
1281
1282                         xtr = new XmlTextReader (xml, XmlNodeType.Document, null);
1283                         xtr.ReadStartElement ("Wrapper");
1284
1285                         group = (Group) DeserializeEncoded (typeof (Group), xtr);
1286
1287                         Assert.AreEqual (DateTime.MinValue, group.Today, "#C1");
1288                         Assert.IsNull (group.GroupName, "#C2");
1289                         Assert.AreEqual (null, group.GroupNumber, "#C3");
1290                         Assert.AreEqual (GroupType.A, group.Grouptype, "#C4");
1291                         Assert.IsNull (group.PostitiveInt, "#C5");
1292                         Assert.IsFalse (group.IgnoreThis, "#C6");
1293                         Assert.IsNull (group.MyVehicle, "#C7");
1294
1295                         xml = string.Format (CultureInfo.InvariantCulture,
1296                                 "<Wrapper>" +
1297                                 "<Group xmlns:xsd='{0}' xmlns:xsi='{1}' id='id1'>" +
1298                                 "<Grouptype xsi:type='GroupType'>666</Grouptype>" +
1299                                 "</Group>" +
1300                                 "</Wrapper>",
1301                                 "http://www.w3.org/2001/XMLSchema", "http://www.w3.org/2001/XMLSchema-instance");
1302
1303                         xtr = new XmlTextReader (xml, XmlNodeType.Document, null);
1304                         xtr.ReadStartElement ("Wrapper");
1305
1306                         try {
1307                                 group = (Group) DeserializeEncoded (typeof (Group), xtr);
1308                                 Assert.Fail ("#D1");
1309                         }
1310                         catch (InvalidOperationException ex) {
1311                                 // There is an error in XML document (1, 174)
1312                                 Assert.AreEqual (typeof (InvalidOperationException), ex.GetType (), "#D2");
1313                                 Assert.IsNotNull (ex.Message, "#D3");
1314                                 Assert.IsNotNull (ex.InnerException, "#D4");
1315
1316                                 // '666' is not a valid value for GroupType
1317                                 Assert.AreEqual (typeof (InvalidOperationException), ex.InnerException.GetType (), "#D5");
1318                                 Assert.IsNotNull (ex.InnerException.Message, "#D6");
1319                                 Assert.IsTrue (ex.InnerException.Message.IndexOf ("'666'") != -1, "#D7");
1320                                 Assert.IsTrue (ex.InnerException.Message.IndexOf (typeof (GroupType).Name) != -1, "#D8");
1321                                 Assert.IsNull (ex.InnerException.InnerException, "#D9");
1322                         }
1323
1324                         xml = string.Format (CultureInfo.InvariantCulture,
1325                                 "<Wrapper>" +
1326                                 "<Group xmlns:xsd='{0}' xmlns:xsi='{1}' id='id1'>" +
1327                                 "<Grouptype xsi:type='GroupType'>Garbage</Grouptype>" +
1328                                 "</Group>" +
1329                                 "</Wrapper>",
1330                                 "http://www.w3.org/2001/XMLSchema", "http://www.w3.org/2001/XMLSchema-instance");
1331
1332                         xtr = new XmlTextReader (xml, XmlNodeType.Document, null);
1333                         xtr.ReadStartElement ("Wrapper");
1334
1335                         try {
1336                                 group = (Group) DeserializeEncoded (typeof (Group), xtr);
1337                                 Assert.Fail ("#E1");
1338                         }
1339                         catch (InvalidOperationException ex) {
1340                                 // There is an error in XML document (1, 178)
1341                                 Assert.AreEqual (typeof (InvalidOperationException), ex.GetType (), "#E2");
1342                                 Assert.IsNotNull (ex.Message, "#E3");
1343                                 Assert.IsNotNull (ex.InnerException, "#E4");
1344
1345                                 // 'Garbage' is not a valid value for GroupType
1346                                 Assert.AreEqual (typeof (InvalidOperationException), ex.InnerException.GetType (), "#E5");
1347                                 Assert.IsNotNull (ex.InnerException.Message, "#E6");
1348                                 Assert.IsTrue (ex.InnerException.Message.IndexOf ("'Garbage'") != -1, "#E7");
1349                                 Assert.IsTrue (ex.InnerException.Message.IndexOf (typeof (GroupType).Name) != -1, "#E8");
1350                                 Assert.IsNull (ex.InnerException.InnerException, "#E9");
1351                         }
1352
1353                         xml = string.Format (CultureInfo.InvariantCulture,
1354                                 "<Wrapper>" +
1355                                 "<Group xmlns:xsd='{0}' xmlns:xsi='{1}' id='id1'>" +
1356                                 "<Grouptype xsi:type='GroupType'>{2}</Grouptype>" +
1357                                 "</Group>" +
1358                                 "</Wrapper>",
1359                                 "http://www.w3.org/2001/XMLSchema", "http://www.w3.org/2001/XMLSchema-instance",
1360                                 ((int) GroupType.B).ToString (CultureInfo.InvariantCulture));
1361
1362                         xtr = new XmlTextReader (xml, XmlNodeType.Document, null);
1363                         xtr.ReadStartElement ("Wrapper");
1364
1365                         try {
1366                                 group = (Group) DeserializeEncoded (typeof (Group), xtr);
1367                                 Assert.Fail ("#F1");
1368                         }
1369                         catch (InvalidOperationException ex) {
1370                                 // There is an error in XML document (1, 172)
1371                                 Assert.AreEqual (typeof (InvalidOperationException), ex.GetType (), "#F2");
1372                                 Assert.IsNotNull (ex.Message, "#F3");
1373                                 Assert.IsNotNull (ex.InnerException, "#F4");
1374
1375                                 // '1' is not a valid value for GroupType
1376                                 Assert.AreEqual (typeof (InvalidOperationException), ex.InnerException.GetType (), "#F5");
1377                                 Assert.IsNotNull (ex.InnerException.Message, "#F6");
1378                                 Assert.IsTrue (ex.InnerException.Message.IndexOf ("'1'") != -1, "#F7");
1379                                 Assert.IsTrue (ex.InnerException.Message.IndexOf (typeof (GroupType).Name) != -1, "#F8");
1380                                 Assert.IsNull (ex.InnerException.InnerException, "#F9");
1381                         }
1382                 }
1383
1384                 [Test]
1385                 public void TestDeserialize_ZeroFlagEnum ()
1386                 {
1387                         ZeroFlagEnum e;
1388
1389                         e = (ZeroFlagEnum) Deserialize (typeof (ZeroFlagEnum), "<ZeroFlagEnum />");
1390                         Assert.AreEqual (ZeroFlagEnum.e0, e, "#A1");
1391                         e = (ZeroFlagEnum) Deserialize (typeof (ZeroFlagEnum), "<ZeroFlagEnum></ZeroFlagEnum>");
1392                         Assert.AreEqual (ZeroFlagEnum.e0, e, "#A2");
1393
1394                         try {
1395                                 Deserialize (typeof (ZeroFlagEnum), "<ZeroFlagEnum>four</ZeroFlagEnum>");
1396                                 Assert.Fail ("#B1");
1397                         }
1398                         catch (InvalidOperationException ex) {
1399                                 Assert.AreEqual (typeof (InvalidOperationException), ex.GetType (), "#B2");
1400                                 Assert.IsNotNull (ex.InnerException, "#B3");
1401                                 Assert.AreEqual (typeof (InvalidOperationException), ex.InnerException.GetType (), "#B4");
1402                                 Assert.IsNotNull (ex.InnerException.Message, "#B5");
1403                                 Assert.IsTrue (ex.InnerException.Message.IndexOf ("'four'") != -1, "#B6");
1404                                 Assert.IsTrue (ex.InnerException.Message.IndexOf (typeof (ZeroFlagEnum).FullName) != -1, "#B7");
1405                         }
1406
1407                         try {
1408                                 Deserialize (typeof (ZeroFlagEnum), "<ZeroFlagEnum> o&lt;n&gt;e  four </ZeroFlagEnum>");
1409                                 Assert.Fail ("#C1");
1410                         }
1411                         catch (InvalidOperationException ex) {
1412                                 Assert.AreEqual (typeof (InvalidOperationException), ex.GetType (), "#C2");
1413                                 Assert.IsNotNull (ex.InnerException, "#C3");
1414                                 Assert.AreEqual (typeof (InvalidOperationException), ex.InnerException.GetType (), "#C4");
1415                                 Assert.IsNotNull (ex.InnerException.Message, "#C5");
1416                                 Assert.IsTrue (ex.InnerException.Message.IndexOf ("'four'") != -1, "#C6");
1417                                 Assert.IsTrue (ex.InnerException.Message.IndexOf (typeof (ZeroFlagEnum).FullName) != -1, "#C7");
1418                         }
1419
1420                         try {
1421                                 Deserialize (typeof (ZeroFlagEnum), "<ZeroFlagEnum>four o&lt;n&gt;e</ZeroFlagEnum>");
1422                                 Assert.Fail ("#D1");
1423                         }
1424                         catch (InvalidOperationException ex) {
1425                                 Assert.AreEqual (typeof (InvalidOperationException), ex.GetType (), "#D2");
1426                                 Assert.IsNotNull (ex.InnerException, "#D3");
1427                                 Assert.AreEqual (typeof (InvalidOperationException), ex.InnerException.GetType (), "#D4");
1428                                 Assert.IsNotNull (ex.InnerException.Message, "#D5");
1429                                 Assert.IsTrue (ex.InnerException.Message.IndexOf ("'four'") != -1, "#D6");
1430                                 Assert.IsTrue (ex.InnerException.Message.IndexOf (typeof (ZeroFlagEnum).FullName) != -1, "#D7");
1431                         }
1432                 }
1433
1434                 [Test]
1435                 public void TestDeserialize_PrimitiveTypesContainer ()
1436                 {
1437                         Deserialize (typeof (PrimitiveTypesContainer), string.Format (CultureInfo.InvariantCulture,
1438                                 "<?xml version='1.0' encoding='utf-16'?>" +
1439                                 "<PrimitiveTypesContainer xmlns:xsd='{0}' xmlns:xsi='{1}' xmlns='{2}'>" +
1440                                 "<Number xsi:type='xsd:int'>2004</Number>" +
1441                                 "<Name xsi:type='xsd:string'>some name</Name>" +
1442                                 "<Index xsi:type='xsd:unsignedByte'>56</Index>" +
1443                                 "<Password xsi:type='xsd:base64Binary'>8w8=</Password>" +
1444                                 "<PathSeparatorCharacter xmlns:q1='{3}' xsi:type='q1:char'>47</PathSeparatorCharacter>" +
1445                                 "</PrimitiveTypesContainer>", XmlSchemaNamespace,
1446                                 XmlSchemaInstanceNamespace, ANamespace, WsdlTypesNamespace));
1447                         Assert.AreEqual (typeof (PrimitiveTypesContainer), result.GetType (), "#A1");
1448
1449                         PrimitiveTypesContainer deserialized = (PrimitiveTypesContainer) result;
1450                         Assert.AreEqual (2004, deserialized.Number, "#A2");
1451                         Assert.AreEqual ("some name", deserialized.Name, "#A3");
1452                         Assert.AreEqual ((byte) 56, deserialized.Index, "#A4");
1453                         Assert.AreEqual (new byte[] { 243, 15 }, deserialized.Password, "#A5");
1454                         Assert.AreEqual ('/', deserialized.PathSeparatorCharacter, "#A6");
1455
1456                         DeserializeEncoded (typeof (PrimitiveTypesContainer), string.Format (CultureInfo.InvariantCulture,
1457                                 "<?xml version='1.0' encoding='utf-16'?>" +
1458                                 "<q1:PrimitiveTypesContainer xmlns:xsd='{0}' xmlns:xsi='{1}' id='id1' xmlns:q1='{2}'>" +
1459                                 "<Number xsi:type='xsd:int'>2004</Number>" +
1460                                 "<Name xsi:type='xsd:string'>some name</Name>" +
1461                                 "<Index xsi:type='xsd:unsignedByte'>56</Index>" +
1462                                 "<Password xsi:type='xsd:base64Binary'>8w8=</Password>" +
1463                                 "<PathSeparatorCharacter xmlns:q1='{3}' xsi:type='q1:char'>47</PathSeparatorCharacter>" +
1464                                 "</q1:PrimitiveTypesContainer>", XmlSchemaNamespace,
1465                                 XmlSchemaInstanceNamespace, AnotherNamespace, WsdlTypesNamespace));
1466                         Assert.AreEqual (typeof (PrimitiveTypesContainer), result.GetType (), "#B1");
1467
1468                         deserialized = (PrimitiveTypesContainer) result;
1469                         Assert.AreEqual (2004, deserialized.Number, "#B2");
1470                         Assert.AreEqual ("some name", deserialized.Name, "#B3");
1471                         Assert.AreEqual ((byte) 56, deserialized.Index, "#B4");
1472                         Assert.AreEqual (new byte[] { 243, 15 }, deserialized.Password, "#B5");
1473                         Assert.AreEqual ('/', deserialized.PathSeparatorCharacter, "#B6");
1474                 }
1475
1476                 [Test] // bug #378696
1477                 public void DoNotFillDefaultValue ()
1478                 {
1479                         XmlSerializer xs = new XmlSerializer (typeof (DefaultDateTimeContainer));
1480                         DefaultDateTimeContainer o = (DefaultDateTimeContainer) xs.Deserialize (new StringReader ("<DefaultDateTimeContainer xmlns='urn:foo' />"));
1481                         // do not fill DefaultValue / do not bork at generating code.
1482                         Assert.AreEqual (DateTime.MinValue, o.FancyDateTime, "#1");
1483                         Assert.AreEqual (0, o.Numeric, "#2");
1484                 }
1485
1486                 [Test] // bug bxc 4367
1487                 public void SpecifiedXmlIgnoreTest ()
1488                 {
1489                         XmlReflectionMember [] out_members = new XmlReflectionMember [2];
1490                         XmlReflectionMember m;
1491
1492                         m = new XmlReflectionMember ();
1493                         m.IsReturnValue = false;
1494                         m.MemberName = "HasPermissionsForUserResult";
1495                         m.MemberType = typeof (bool);
1496                         m.SoapAttributes = new SoapAttributes ();
1497                         m.XmlAttributes = new XmlAttributes ();
1498                         out_members [0] = m;
1499
1500                         m = new XmlReflectionMember ();
1501                         m.IsReturnValue = false;
1502                         m.MemberName = "HasPermissionsForUserResultSpecified";
1503                         m.MemberType = typeof (bool);
1504                         m.SoapAttributes = new SoapAttributes ();
1505                         m.XmlAttributes = new XmlAttributes ();
1506                         m.XmlAttributes.XmlIgnore = true;
1507                         out_members [1] = m;
1508
1509                         XmlReflectionImporter xmlImporter = new XmlReflectionImporter ();
1510                         XmlMembersMapping OutputMembersMapping = xmlImporter.ImportMembersMapping ("HasPermissionsForUserResponse", "http://tempuri.org", out_members, true);
1511                         XmlSerializer xmlSerializer = XmlSerializer.FromMappings (new XmlMapping [] { OutputMembersMapping }) [0];
1512
1513                         Assert.AreEqual (2, OutputMembersMapping.Count, "#count");
1514
1515                         string msg = @"
1516                         <HasPermissionsForUserResponse xmlns=""http://tempuri.org/"">
1517                                 <HasPermissionsForUserResult>true</HasPermissionsForUserResult>
1518                         </HasPermissionsForUserResponse>
1519                         ";
1520
1521                         object res = xmlSerializer.Deserialize (new StringReader (msg));
1522                         Assert.AreEqual (typeof (object[]), res.GetType (), "type");
1523                         Assert.AreEqual (2, ((object[]) res).Length, "length");
1524                 }
1525
1526                 [Test]
1527                 public void InvalidNullableTypeTest ()
1528                 {
1529                         XmlReflectionMember [] out_members = new XmlReflectionMember [1];
1530                         XmlReflectionMember m;
1531
1532                         m = new XmlReflectionMember ();
1533                         m.IsReturnValue = false;
1534                         m.MemberName = "HasPermissionsForUserResultSpecified";
1535                         m.MemberType = typeof (bool);
1536                         m.SoapAttributes = new SoapAttributes ();
1537                         m.XmlAttributes = new XmlAttributes ();
1538                         m.XmlAttributes.XmlIgnore = true;
1539                         m.XmlAttributes.XmlElements.Add (new XmlElementAttribute () { IsNullable = true });
1540                         out_members [0] = m;
1541
1542                         XmlReflectionImporter xmlImporter = new XmlReflectionImporter ();
1543
1544                         try {
1545                                 xmlImporter.ImportMembersMapping ("HasPermissionsForUserResponse", "http://tempuri.org", out_members, true);
1546                                 Assert.Fail ("Expected InvalidOperationException");
1547                         } catch (InvalidOperationException) {
1548                         }
1549                 }
1550
1551                 [Test]
1552                 public void NotExactDateParse ()
1553                 {
1554                         XmlSerializer xs = new XmlSerializer (typeof (NotExactDateParseClass));
1555                         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>"));
1556                         Assert.AreEqual (new DateTime (2012,2,5), o.SomeDate);
1557                 }
1558
1559
1560                 public class Foo
1561                 {
1562                         public DateTime? Baz { get; set; }
1563                 }
1564
1565                 [Test]
1566                 public void CanDeserializeXsiNil()
1567                 {
1568                         var reader = new StringReader(
1569 @"<Foo xmlns:xsi=""http://www.w3.org/2001/XMLSchema-instance"">
1570         <Baz xsi:nil=""true"" />
1571 </Foo>");
1572
1573                         using (var xmlReader = new XmlTextReader(reader))
1574                         {
1575                                 var serializer = new XmlSerializer(typeof(Foo));
1576                                 var foo = (Foo)serializer.Deserialize(xmlReader);
1577                                 Assert.IsNull(foo.Baz);
1578                         }
1579                 }
1580
1581                 public class Bar
1582                 {
1583                         [XmlElement("baz")]
1584                         public DateTime? Baz { get; set; }
1585                 }
1586
1587                 [Test]
1588                 public void CanDeserializeXsiNilToAPropertyWithXmlElementAttrib()
1589                 {
1590                         var reader = new StringReader(
1591 @"<Bar xmlns:xsi=""http://www.w3.org/2001/XMLSchema-instance"">
1592         <baz xsi:nil=""true"" />
1593 </Bar>");
1594
1595                         using (var xmlReader = new XmlTextReader(reader))
1596                         {
1597                                 var serializer = new XmlSerializer(typeof(Bar));
1598                                 var bar = (Bar)serializer.Deserialize(xmlReader);
1599                                 Assert.IsNull(bar.Baz);
1600                         }
1601                 }
1602
1603                 public class FooBar
1604                 {
1605                         [XmlElement("baz", IsNullable = true)]
1606                         public DateTime? Baz { get; set; }
1607                 }
1608
1609                 [Test]
1610                 public void CanDeserializeXsiNilToAPropertyWithXmlElementAttribAndIsNullableTrue()
1611                 {
1612                         var reader = new StringReader(
1613 @"<FooBar xmlns:xsi=""http://www.w3.org/2001/XMLSchema-instance"">
1614         <baz xsi:nil=""true"" />
1615 </FooBar>");
1616
1617                         using (var xmlReader = new XmlTextReader(reader))
1618                         {
1619                                 var serializer = new XmlSerializer(typeof(FooBar));
1620                                 var foobar = (FooBar)serializer.Deserialize(xmlReader);
1621                                 Assert.IsNull(foobar.Baz);
1622                         }
1623                 }
1624         }
1625 }