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