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