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

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