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 DeserializeEncoded (Type t, string xml)\r
  46                 {\r
  47                         StringReader sr = new StringReader (xml);\r
  48                         XmlReader xr = new XmlTextReader (sr);\r
  49                         return DeserializeEncoded (t, xr);\r
  50                 }\r
  51 \r
  52                 private object Deserialize (Type t, XmlReader xr)\r
  53                 {\r
  54                         XmlSerializer ser = new XmlSerializer (t);\r
  55                         result = ser.Deserialize (xr);\r
  56                         return result;\r
  57                 }\r
  58 \r
  59                 private object DeserializeEncoded (Type t, XmlReader xr)\r
  60                 {\r
  61                         SoapReflectionImporter im = new SoapReflectionImporter ();\r
  62                         XmlTypeMapping tm = im.ImportTypeMapping (t);\r
  63                         XmlSerializer ser = new XmlSerializer (tm);\r
  64                         result = ser.Deserialize (xr);\r
  65                         return result;\r
  66                 }\r
  67 \r
  68                 [Test]\r
  69                 public void SimpleDeserialize ()\r
  70                 {\r
  71                         Deserialize (typeof (Sample), "<Sample><Text>Test.</Text></Sample>");\r
  72                         Assert.AreEqual (typeof (Sample), result.GetType ());\r
  73                         Sample sample = result as Sample;\r
  74                         Assert.AreEqual ("Test.", sample.Text);\r
  75                 }\r
  76 \r
  77                 [Test]\r
  78                 public void DeserializeInt ()\r
  79                 {\r
  80                         Deserialize (typeof (int), "<int>10</int>");\r
  81                         Assert.AreEqual (typeof (int), result.GetType ());\r
  82                         Assert.AreEqual (10, result);\r
  83                 }\r
  84 \r
  85                 [Test]\r
  86                 public void DeserializeSimpleArray ()\r
  87                 {\r
  88                         Deserialize (typeof (Sample), "<Sample><ArrayText><string>Test1</string><string>Test2</string></ArrayText></Sample>");\r
  89                         Assert.AreEqual (typeof (Sample), result.GetType ());\r
  90                         Sample sample = result as Sample;\r
  91                         Assert.AreEqual ("Test1", sample.ArrayText[0]);\r
  92                         Assert.AreEqual ("Test2", sample.ArrayText[1]);\r
  93                 }\r
  94 \r
  95                 [Test]\r
  96                 public void DeserializeEmptyEnum ()\r
  97                 {\r
  98                         Field f = Deserialize (typeof (Field), "<field modifiers=\"\" />") as Field;\r
  99                         Assert.AreEqual (MapModifiers.Public, f.Modifiers);\r
 100                 }\r
 101                 \r
 102                 [Test]\r
 103                 public void DeserializePrivateCollection ()\r
 104                 {\r
 105                         MemoryStream ms = new MemoryStream ();\r
 106                         Container c = new Container();\r
 107                         c.Items.Add(1);\r
 108                         \r
 109                         XmlSerializer serializer = new XmlSerializer(typeof(Container));\r
 110                         serializer.Serialize(ms, c);\r
 111                         \r
 112                         ms.Position = 0;\r
 113                         c = (Container) serializer.Deserialize (ms);\r
 114                         Assert.AreEqual (1, c.Items[0]);\r
 115                 }\r
 116                 \r
 117                 [Test]\r
 118                 [Category("NotDotNet")]\r
 119                 [ExpectedException (typeof (InvalidOperationException))]\r
 120                 public void DeserializeEmptyPrivateCollection ()\r
 121                 {\r
 122                         MemoryStream ms = new MemoryStream ();\r
 123                         Container2 c = new Container2(true);\r
 124                         c.Items.Add(1);\r
 125                         \r
 126                         XmlSerializer serializer = new XmlSerializer(typeof(Container2));\r
 127                         serializer.Serialize(ms, c);\r
 128                         \r
 129                         ms.Position = 0;\r
 130                         c = (Container2) serializer.Deserialize (ms);\r
 131                 }\r
 132                 \r
 133                 [Test]\r
 134                 [Category("NotDotNet")]\r
 135                 public void DeserializeArrayReferences ()\r
 136                 {\r
 137                         string s = "<Sample xmlns:xsi=\"http://www.w3.org/2001/XMLSchema-instance\" xmlns:xsd=\"http://www.w3.org/2001/XMLSchema\">";\r
 138                         s += "<ArrayText xmlns:n3=\"http://schemas.xmlsoap.org/soap/encoding/\" xsi:type=\"n3:Array\" n3:arrayType=\"xsd:string[2]\">";\r
 139                         s += "<item href=\"#id-606830706\"></item>";\r
 140                         s += "<item xsi:type=\"xsd:string\">Hola</item>";\r
 141                         s += "</ArrayText>";\r
 142                         s += "<string id=\"id-606830706\" xsi:type=\"xsd:string\">Adeu</string>";\r
 143                         s += "</Sample>";\r
 144                         DeserializeEncoded (typeof(Sample), s);\r
 145                 }\r
 146                 \r
 147                 \r
 148                 [Test]\r
 149                 public void TestDeserializeXmlNodeArray ()\r
 150                 {\r
 151                         object ob = Deserialize (typeof(object), "<anyType at=\"1\"><elem1/><elem2/></anyType>");\r
 152                         Assert.IsTrue (ob is XmlNode[], "Is node array");\r
 153                         \r
 154                         XmlNode[] nods = (XmlNode[]) ob;\r
 155                         Assert.AreEqual (3, nods.Length, "lengh");\r
 156                         Assert.IsTrue (nods[0] is XmlAttribute, "#1");\r
 157                         Assert.AreEqual ("at", ((XmlAttribute) nods[0]).LocalName, "#2");\r
 158                         Assert.AreEqual ("1", ((XmlAttribute) nods[0]).Value, "#3");\r
 159                         Assert.IsTrue (nods[1] is XmlElement, "#4");\r
 160                         Assert.AreEqual ("elem1", ((XmlElement) nods[1]).LocalName, "#5");\r
 161                         Assert.IsTrue (nods[2] is XmlElement, "#6");\r
 162                         Assert.AreEqual ("elem2", ((XmlElement) nods[2]).LocalName, "#7");\r
 163                 }\r
 164                 \r
 165                 [Test]\r
 166                 public void TestDeserializeXmlElement ()\r
 167                 {\r
 168                         object ob = Deserialize (typeof(XmlElement), "<elem/>");\r
 169                         Assert.IsTrue (ob is XmlElement, "#1");\r
 170                         Assert.AreEqual ("elem", ((XmlElement) ob).LocalName, "#2");\r
 171                 }\r
 172                 \r
 173                 [Test]\r
 174                 public void TestDeserializeXmlCDataSection ()\r
 175                 {\r
 176                         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
 177                         Assert.IsNotNull (c.cdata, "#1");\r
 178                         Assert.AreEqual ("data section contents", c.cdata.Value, "#2");\r
 179                 }\r
 180                 \r
 181                 [Test]\r
 182                 public void TestDeserializeXmlNode ()\r
 183                 {\r
 184                         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
 185                         Assert.IsTrue (c.node is XmlText, "#1");\r
 186                         Assert.AreEqual ("text", c.node.Value, "#2");\r
 187                 }\r
 188                 \r
 189                 [Test]\r
 190                 public void TestDeserializeChoices ()\r
 191                 {\r
 192                         Choices ch = (Choices) Deserialize (typeof(Choices), "<Choices><ChoiceZero>choice text</ChoiceZero></Choices>");\r
 193                         Assert.AreEqual ("choice text", ch.MyChoice, "#A1");\r
 194                         Assert.AreEqual (ItemChoiceType.ChoiceZero, ch.ItemType, "#A2");\r
 195                         \r
 196                         ch = (Choices) Deserialize (typeof(Choices), "<Choices><ChoiceOne>choice text</ChoiceOne></Choices>");\r
 197                         Assert.AreEqual ("choice text", ch.MyChoice, "#B1");\r
 198                         Assert.AreEqual (ItemChoiceType.StrangeOne, ch.ItemType, "#B2");\r
 199                         \r
 200                         ch = (Choices) Deserialize (typeof(Choices), "<Choices><ChoiceTwo>choice text</ChoiceTwo></Choices>");\r
 201                         Assert.AreEqual ("choice text", ch.MyChoice, "#C1");\r
 202                         Assert.AreEqual (ItemChoiceType.ChoiceTwo, ch.ItemType, "#C2");\r
 203                 }\r
 204                 \r
 205                 [Test]\r
 206                 public void TestDeserializeNamesWithSpaces ()\r
 207                 {\r
 208                         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
 209                         Assert.AreEqual (4, ts.elem, "#1");\r
 210                         Assert.AreEqual (5, ts.attr, "#2");\r
 211                 }\r
 212                 \r
 213                 [Test]\r
 214                 public void TestDeserializeDefaults ()\r
 215                 {\r
 216                         ListDefaults d2 = (ListDefaults) Deserialize (typeof(ListDefaults), "<root/>");\r
 217 \r
 218                         Assert.IsNotNull (d2.list2, "#A1");\r
 219                         Assert.IsNull (d2.list3, "#A2");\r
 220                         Assert.IsNull (d2.list4, "#A3");\r
 221                         Assert.IsNotNull (d2.list5, "#A4");\r
 222                         Assert.IsNotNull (d2.ed, "#A5");\r
 223                         Assert.IsNotNull (d2.str, "#A6");\r
 224 \r
 225                         d2 = (ListDefaults) Deserialize (typeof(ListDefaults), "<root></root>");\r
 226 \r
 227                         Assert.IsNotNull (d2.list2, "#B1");\r
 228                         Assert.IsNull (d2.list3, "#B2");\r
 229                         Assert.IsNull (d2.list4, "#B3");\r
 230                         Assert.IsNotNull (d2.list5, "#B4");\r
 231                         Assert.IsNotNull (d2.ed, "#B5");\r
 232                         Assert.IsNotNull (d2.str, "#B6");\r
 233                 }\r
 234                 \r
 235                 [Test]\r
 236                 public void TestDeserializeChoiceArray ()\r
 237                 {\r
 238                         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
 239                         Assert.IsNotNull (v.Items, "#1");\r
 240                         Assert.IsNotNull (v.ItemsElementName, "#2");\r
 241                         Assert.AreEqual (2, v.Items.Length, "#3");\r
 242                         Assert.AreEqual (2, v.ItemsElementName.Length, "#4");\r
 243                         Assert.AreEqual (1, v.Items[0], "#5");\r
 244                         Assert.AreEqual (2, v.Items[1], "#6");\r
 245                         Assert.AreEqual (ItemsChoiceType.In, v.ItemsElementName[0], "#7");\r
 246                         Assert.AreEqual (ItemsChoiceType.Es, v.ItemsElementName[1], "#8");\r
 247                 }\r
 248                 \r
 249                 [Test]\r
 250                 public void TestDeserializeCollection ()\r
 251                 {\r
 252                         string s0 = "";\r
 253                         s0+="   <ArrayOfEntity xmlns:xsd='http://www.w3.org/2001/XMLSchema' xmlns:xsi='http://www.w3.org/2001/XMLSchema-instance'>";\r
 254                         s0+="           <Entity Name='node1'/>";\r
 255                         s0+="           <Entity Name='node2'/>";\r
 256                         s0+="   </ArrayOfEntity>";\r
 257                         \r
 258                         EntityCollection col = (EntityCollection) Deserialize (typeof(EntityCollection), s0);\r
 259                         Assert.IsNotNull (col, "#1");\r
 260                         Assert.AreEqual (2, col.Count, "#2");\r
 261                         Assert.IsNull (col[0].Parent, "#3");\r
 262                         Assert.IsNull (col[1].Parent, "#4");\r
 263                 }\r
 264                 \r
 265                 [Test]\r
 266                 public void TestDeserializeEmptyCollection ()\r
 267                 {\r
 268                         string s1 = "";\r
 269                         s1+="   <ArrayOfEntity xmlns:xsd='http://www.w3.org/2001/XMLSchema' xmlns:xsi='http://www.w3.org/2001/XMLSchema-instance' />";\r
 270                         \r
 271                         EntityCollection col = (EntityCollection) Deserialize (typeof(EntityCollection), s1);\r
 272                         Assert.IsNotNull (col, "#A1");\r
 273                         Assert.AreEqual (0, col.Count, "#A2");\r
 274                         \r
 275                         string s1_1 = "";\r
 276                         s1_1+=" <ArrayOfEntity xmlns:xsd='http://www.w3.org/2001/XMLSchema' xmlns:xsi='http://www.w3.org/2001/XMLSchema-instance'>";\r
 277                         s1_1+=" </ArrayOfEntity>";\r
 278                         \r
 279                         col = (EntityCollection) Deserialize (typeof(EntityCollection), s1_1);\r
 280                         Assert.IsNotNull (col, "#B1");\r
 281                         Assert.AreEqual (0, col.Count, "#B2");\r
 282                 }\r
 283                 \r
 284                 [Test]\r
 285                 public void TestDeserializeNilCollectionIsNotNull ()\r
 286                 {\r
 287                         string s2 = "";\r
 288                         s2+="   <ArrayOfEntity xmlns:xsd='http://www.w3.org/2001/XMLSchema' xmlns:xsi='http://www.w3.org/2001/XMLSchema-instance' xsi:nil='true'/>";\r
 289                         \r
 290                         EntityCollection col = (EntityCollection) Deserialize (typeof(EntityCollection), s2);\r
 291                         Assert.IsNotNull (col, "#1");\r
 292                         Assert.AreEqual (0, col.Count, "#2");\r
 293                 }\r
 294                 \r
 295                 [Test]\r
 296                 public void TestDeserializeObjectCollections ()\r
 297                 {\r
 298                         string s3 = "";\r
 299                         s3+="<Container xmlns:xsd='http://www.w3.org/2001/XMLSchema' xmlns:xsi='http://www.w3.org/2001/XMLSchema-instance'>";\r
 300                         s3+="   <Collection1 xmlns:xsd='http://www.w3.org/2001/XMLSchema' xmlns:xsi='http://www.w3.org/2001/XMLSchema-instance'>";\r
 301                         s3+="           <Entity Name='node1'/>";\r
 302                         s3+="           <Entity Name='node2'/>";\r
 303                         s3+="   </Collection1>";\r
 304                         s3+="   <Collection2 xmlns:xsd='http://www.w3.org/2001/XMLSchema' xmlns:xsi='http://www.w3.org/2001/XMLSchema-instance'>";\r
 305                         s3+="           <Entity Name='node1'/>";\r
 306                         s3+="           <Entity Name='node2'/>";\r
 307                         s3+="   </Collection2>";\r
 308                         s3+="   <Collection3 xmlns:xsd='http://www.w3.org/2001/XMLSchema' xmlns:xsi='http://www.w3.org/2001/XMLSchema-instance'>";\r
 309                         s3+="           <Entity Name='node1'/>";\r
 310                         s3+="           <Entity Name='node2'/>";\r
 311                         s3+="   </Collection3>";\r
 312                         s3+="   <Collection4 xmlns:xsd='http://www.w3.org/2001/XMLSchema' xmlns:xsi='http://www.w3.org/2001/XMLSchema-instance'>";\r
 313                         s3+="           <Entity Name='node1'/>";\r
 314                         s3+="           <Entity Name='node2'/>";\r
 315                         s3+="   </Collection4>";\r
 316                         s3+="</Container>";\r
 317                         \r
 318                         EntityContainer cont = (EntityContainer) Deserialize (typeof(EntityContainer), s3);\r
 319                         Assert.IsNotNull (cont, "#A1");\r
 320 \r
 321                         Assert.IsNotNull (cont.Collection1, "#B1");\r
 322                         Assert.AreEqual (2, cont.Collection1.Count, "#B2");\r
 323                         Assert.AreEqual ("assigned", cont.Collection1.Container, "#B3");\r
 324                         Assert.AreEqual ("assigned", cont.Collection1[0].Parent, "#B4");\r
 325                         Assert.AreEqual ("assigned", cont.Collection1[1].Parent, "#B5");\r
 326 \r
 327                         Assert.IsNotNull (cont.Collection2, "#C1");\r
 328                         Assert.AreEqual (2, cont.Collection2.Count, "#C2");\r
 329                         Assert.AreEqual ("assigned", cont.Collection2.Container, "#C3");\r
 330                         Assert.AreEqual ("assigned", cont.Collection2[0].Parent, "#C4");\r
 331                         Assert.AreEqual ("assigned", cont.Collection2[1].Parent, "#C5");\r
 332 \r
 333                         Assert.IsNotNull (cont.Collection3, "#D1");\r
 334                         Assert.AreEqual (2, cont.Collection3.Count, "#D2");\r
 335                         Assert.AreEqual ("root", cont.Collection3.Container, "#D3");\r
 336                         Assert.AreEqual ("root", cont.Collection3[0].Parent, "#D4");\r
 337                         Assert.AreEqual ("root", cont.Collection3[1].Parent, "#D5");\r
 338 \r
 339                         Assert.IsNotNull (cont.Collection4, "#E1");\r
 340                         Assert.AreEqual (2, cont.Collection4.Count, "#E2");\r
 341                         Assert.AreEqual ("root", cont.Collection4.Container, "#E3");\r
 342                         Assert.AreEqual ("root", cont.Collection4[0].Parent, "#E4");\r
 343                         Assert.AreEqual ("root", cont.Collection4[1].Parent, "#E5");\r
 344                 }\r
 345                 \r
 346                 [Test]\r
 347                 public void TestDeserializeEmptyObjectCollections ()\r
 348                 {\r
 349                         string s4 = "";\r
 350                         s4+="<Container xmlns:xsd='http://www.w3.org/2001/XMLSchema' xmlns:xsi='http://www.w3.org/2001/XMLSchema-instance'>";\r
 351                         s4+="</Container>";\r
 352                         \r
 353                         EntityContainer cont = (EntityContainer) Deserialize (typeof(EntityContainer), s4);\r
 354                         Assert.IsNotNull (cont, "#A1");\r
 355 \r
 356                         Assert.IsNotNull (cont.Collection1, "#B1");\r
 357                         Assert.AreEqual (0, cont.Collection1.Count, "#B2");\r
 358                         Assert.AreEqual ("assigned", cont.Collection1.Container, "#B3");\r
 359 \r
 360                         Assert.IsNotNull (cont.Collection2, "#C1");\r
 361                         Assert.AreEqual (0, cont.Collection2.Count, "#C2");\r
 362                         Assert.AreEqual ("assigned", cont.Collection2.Container, "#C3");\r
 363 \r
 364                         Assert.IsNotNull (cont.Collection3, "#D1");\r
 365                         Assert.AreEqual (0, cont.Collection3.Count, "#D2");\r
 366                         Assert.AreEqual ("root", cont.Collection3.Container, "#D3");\r
 367 \r
 368                         Assert.IsNotNull (cont.Collection4, "#E1");\r
 369                         Assert.AreEqual (0, cont.Collection4.Count, "#E2");\r
 370                         Assert.AreEqual ("root", cont.Collection4.Container, "#E3");\r
 371                 }\r
 372                 \r
 373                 [Test]\r
 374                 public void TestDeserializeObjectNilCollectionsAreNotNull ()\r
 375                 {\r
 376                         string s5 = "";\r
 377                         s5+="<Container xmlns:xsd='http://www.w3.org/2001/XMLSchema' xmlns:xsi='http://www.w3.org/2001/XMLSchema-instance'>";\r
 378                         s5+="   <Collection1 xmlns:xsd='http://www.w3.org/2001/XMLSchema' xmlns:xsi='http://www.w3.org/2001/XMLSchema-instance' xsi:nil='true' />";\r
 379                         s5+="   <Collection2 xmlns:xsd='http://www.w3.org/2001/XMLSchema' xmlns:xsi='http://www.w3.org/2001/XMLSchema-instance' xsi:nil='true' />";\r
 380                         s5+="   <Collection3 xmlns:xsd='http://www.w3.org/2001/XMLSchema' xmlns:xsi='http://www.w3.org/2001/XMLSchema-instance' xsi:nil='true' />";\r
 381                         s5+="   <Collection4 xmlns:xsd='http://www.w3.org/2001/XMLSchema' xmlns:xsi='http://www.w3.org/2001/XMLSchema-instance' xsi:nil='true' />";\r
 382                         s5+="</Container>";\r
 383                         \r
 384                         EntityContainer cont = (EntityContainer) Deserialize (typeof(EntityContainer), s5);\r
 385                         Assert.IsNotNull (cont, "#A1");\r
 386 \r
 387                         Assert.IsNotNull (cont.Collection1, "#B1");\r
 388                         Assert.AreEqual (0, cont.Collection1.Count, "#B2");\r
 389                         Assert.AreEqual ("assigned", cont.Collection1.Container, "#B3");\r
 390 \r
 391                         Assert.IsNotNull (cont.Collection2, "#C1");\r
 392                         Assert.AreEqual (0, cont.Collection2.Count, "#C2");\r
 393                         Assert.AreEqual ("assigned", cont.Collection2.Container, "#C3");\r
 394 \r
 395                         Assert.IsNotNull (cont.Collection3, "#D1");\r
 396                         Assert.AreEqual (0, cont.Collection3.Count, "#D2");\r
 397                         Assert.AreEqual ("root", cont.Collection3.Container, "#D3");\r
 398 \r
 399                         Assert.IsNotNull (cont.Collection4, "#E1");\r
 400                         Assert.AreEqual (0, cont.Collection4.Count, "#E2");\r
 401                         Assert.AreEqual ("root", cont.Collection4.Container, "#E3");\r
 402                 }\r
 403                 \r
 404                 [Test]\r
 405                 public void TestDeserializeObjectEmptyCollections ()\r
 406                 {\r
 407                         string s6 = "";\r
 408                         s6+="<Container xmlns:xsd='http://www.w3.org/2001/XMLSchema' xmlns:xsi='http://www.w3.org/2001/XMLSchema-instance'>";\r
 409                         s6+="   <Collection1 xmlns:xsd='http://www.w3.org/2001/XMLSchema' xmlns:xsi='http://www.w3.org/2001/XMLSchema-instance' />";\r
 410                         s6+="   <Collection2 xmlns:xsd='http://www.w3.org/2001/XMLSchema' xmlns:xsi='http://www.w3.org/2001/XMLSchema-instance' />";\r
 411                         s6+="   <Collection3 xmlns:xsd='http://www.w3.org/2001/XMLSchema' xmlns:xsi='http://www.w3.org/2001/XMLSchema-instance' />";\r
 412                         s6+="   <Collection4 xmlns:xsd='http://www.w3.org/2001/XMLSchema' xmlns:xsi='http://www.w3.org/2001/XMLSchema-instance' />";\r
 413                         s6+="</Container>";\r
 414                         \r
 415                         EntityContainer cont = (EntityContainer) Deserialize (typeof(EntityContainer), s6);\r
 416                         Assert.IsNotNull (cont, "#A1");\r
 417 \r
 418                         Assert.IsNotNull (cont.Collection1, "#B1");\r
 419                         Assert.AreEqual (0, cont.Collection1.Count, "#B2");\r
 420                         Assert.AreEqual ("assigned", cont.Collection1.Container, "#B3");\r
 421 \r
 422                         Assert.IsNotNull (cont.Collection2, "#C1");\r
 423                         Assert.AreEqual (0, cont.Collection2.Count, "#C2");\r
 424                         Assert.AreEqual ("assigned", cont.Collection2.Container, "#C3");\r
 425 \r
 426                         Assert.IsNotNull (cont.Collection3, "#D1");\r
 427                         Assert.AreEqual (0, cont.Collection3.Count, "#D2");\r
 428                         Assert.AreEqual ("root", cont.Collection3.Container, "#D3");\r
 429 \r
 430                         Assert.IsNotNull (cont.Collection4, "#E1");\r
 431                         Assert.AreEqual (0, cont.Collection4.Count, "#E2");\r
 432                         Assert.AreEqual ("root", cont.Collection4.Container, "#E3");\r
 433                 }\r
 434                 \r
 435                 [Test]\r
 436                 public void TestDeserializeObjectEmptyArrays ()\r
 437                 {\r
 438                         string s6 = "";\r
 439                         s6+="<Container xmlns:xsd='http://www.w3.org/2001/XMLSchema' xmlns:xsi='http://www.w3.org/2001/XMLSchema-instance'>";\r
 440                         s6+="   <Collection1 xmlns:xsd='http://www.w3.org/2001/XMLSchema' xmlns:xsi='http://www.w3.org/2001/XMLSchema-instance' />";\r
 441                         s6+="   <Collection2 xmlns:xsd='http://www.w3.org/2001/XMLSchema' xmlns:xsi='http://www.w3.org/2001/XMLSchema-instance' />";\r
 442                         s6+="   <Collection3 xmlns:xsd='http://www.w3.org/2001/XMLSchema' xmlns:xsi='http://www.w3.org/2001/XMLSchema-instance' />";\r
 443                         s6+="   <Collection4 xmlns:xsd='http://www.w3.org/2001/XMLSchema' xmlns:xsi='http://www.w3.org/2001/XMLSchema-instance' />";\r
 444                         s6+="</Container>";\r
 445                         \r
 446                         ArrayEntityContainer cont = (ArrayEntityContainer) Deserialize (typeof(ArrayEntityContainer), s6);\r
 447                         Assert.IsNotNull (cont, "#A1");\r
 448 \r
 449                         Assert.IsNotNull (cont.Collection1, "#B1");\r
 450                         Assert.AreEqual (0, cont.Collection1.Length, "#B2");\r
 451 \r
 452                         Assert.IsNotNull (cont.Collection2, "#C1");\r
 453                         Assert.AreEqual (0, cont.Collection2.Length, "#C2");\r
 454 \r
 455                         Assert.IsNotNull (cont.Collection3, "#D1");\r
 456                         Assert.AreEqual (0, cont.Collection3.Length, "#D2");\r
 457 \r
 458                         Assert.IsNotNull (cont.Collection4, "#E1");\r
 459                         Assert.AreEqual (0, cont.Collection4.Length, "#E2");\r
 460                 }\r
 461                 \r
 462                 [Test]\r
 463                 public void TestDeserializeEmptyObjectArrays ()\r
 464                 {\r
 465                         string s4 = "";\r
 466                         s4+="<Container xmlns:xsd='http://www.w3.org/2001/XMLSchema' xmlns:xsi='http://www.w3.org/2001/XMLSchema-instance'>";\r
 467                         s4+="</Container>";\r
 468                         \r
 469                         ArrayEntityContainer cont = (ArrayEntityContainer) Deserialize (typeof(ArrayEntityContainer), s4);\r
 470                         Assert.IsNotNull (cont, "#A1");\r
 471 \r
 472                         Assert.IsNull (cont.Collection1, "#B1");\r
 473                         Assert.IsNull (cont.Collection2, "#B2");\r
 474 \r
 475                         Assert.IsNotNull (cont.Collection3, "#C1");\r
 476                         Assert.AreEqual (0, cont.Collection3.Length, "#C2");\r
 477 \r
 478                         Assert.IsNotNull (cont.Collection4, "#D1");\r
 479                         Assert.AreEqual (0, cont.Collection4.Length, "#D2");\r
 480                 }\r
 481                 \r
 482                 [Test]\r
 483                 public void TestDeserializeObjectNilArrays ()\r
 484                 {\r
 485                         string s5 = "";\r
 486                         s5+="<Container xmlns:xsd='http://www.w3.org/2001/XMLSchema' xmlns:xsi='http://www.w3.org/2001/XMLSchema-instance'>";\r
 487                         s5+="   <Collection1 xmlns:xsd='http://www.w3.org/2001/XMLSchema' xmlns:xsi='http://www.w3.org/2001/XMLSchema-instance' xsi:nil='true' />";\r
 488                         s5+="   <Collection2 xmlns:xsd='http://www.w3.org/2001/XMLSchema' xmlns:xsi='http://www.w3.org/2001/XMLSchema-instance' xsi:nil='true' />";\r
 489                         s5+="   <Collection3 xmlns:xsd='http://www.w3.org/2001/XMLSchema' xmlns:xsi='http://www.w3.org/2001/XMLSchema-instance' xsi:nil='true' />";\r
 490                         s5+="   <Collection4 xmlns:xsd='http://www.w3.org/2001/XMLSchema' xmlns:xsi='http://www.w3.org/2001/XMLSchema-instance' xsi:nil='true' />";\r
 491                         s5+="</Container>";\r
 492                         \r
 493                         ArrayEntityContainer cont = (ArrayEntityContainer) Deserialize (typeof(ArrayEntityContainer), s5);\r
 494                         Assert.IsNotNull (cont, "#A1");\r
 495 \r
 496                         Assert.IsNull (cont.Collection1, "#B1");\r
 497                         Assert.IsNull (cont.Collection2, "#B2");\r
 498                         Assert.IsNull (cont.Collection3, "#B3");\r
 499 \r
 500                         Assert.IsNotNull (cont.Collection4, "#C1");\r
 501                         Assert.AreEqual (0, cont.Collection4.Length, "#C2");\r
 502                 }\r
 503                 \r
 504                 [Test]\r
 505                 public void TestDeserializeEmptyArray ()\r
 506                 {\r
 507                         string s1 = "";\r
 508                         s1+="<ArrayOfEntity xmlns:xsd='http://www.w3.org/2001/XMLSchema' xmlns:xsi='http://www.w3.org/2001/XMLSchema-instance' />";\r
 509                         \r
 510                         Entity[] col = (Entity[]) Deserialize (typeof(Entity[]), s1);\r
 511                         Assert.IsNotNull (col, "#A1");\r
 512                         Assert.AreEqual (0, col.Length, "#A2");\r
 513                         \r
 514                         string s1_1 = "";\r
 515                         s1_1+=" <ArrayOfEntity xmlns:xsd='http://www.w3.org/2001/XMLSchema' xmlns:xsi='http://www.w3.org/2001/XMLSchema-instance'>";\r
 516                         s1_1+=" </ArrayOfEntity>";\r
 517                         \r
 518                         col = (Entity[]) Deserialize (typeof(Entity[]), s1_1);\r
 519                         Assert.IsNotNull (col, "#B1");\r
 520                         Assert.AreEqual (0, col.Length, "#B2");\r
 521                 }\r
 522                 \r
 523                 [Test]\r
 524                 public void TestDeserializeNilArray ()\r
 525                 {\r
 526                         string s2 = "";\r
 527                         s2 += "<ArrayOfEntity xmlns:xsd='http://www.w3.org/2001/XMLSchema' xmlns:xsi='http://www.w3.org/2001/XMLSchema-instance' xsi:nil='true'/>";\r
 528                         \r
 529                         Entity[] col = (Entity[]) Deserialize (typeof(Entity[]), s2);\r
 530                         Assert.IsNull (col, "#1");\r
 531                 }\r
 532                 \r
 533                 [Test]\r
 534                 public void TestDeserializeObjectWithReadonlyCollection ()\r
 535                 {\r
 536                         string s3 = "";\r
 537                         s3+="<Container xmlns:xsd='http://www.w3.org/2001/XMLSchema' xmlns:xsi='http://www.w3.org/2001/XMLSchema-instance'>";\r
 538                         s3+="   <Collection1>";\r
 539                         s3+="           <Entity Name='node1'/>";\r
 540                         s3+="           <Entity Name='node2'/>";\r
 541                         s3+="   </Collection1>";\r
 542                         s3+="</Container>";\r
 543                         \r
 544                         ObjectWithReadonlyCollection cont = (ObjectWithReadonlyCollection) Deserialize (typeof(ObjectWithReadonlyCollection), s3);\r
 545                         Assert.IsNotNull (cont, "#1");\r
 546                         Assert.IsNotNull (cont.Collection1, "#2");\r
 547                         Assert.AreEqual (2, cont.Collection1.Count, "#3");\r
 548                         Assert.AreEqual ("root", cont.Collection1.Container, "#4");\r
 549                         Assert.AreEqual ("root", cont.Collection1[0].Parent, "#5");\r
 550                         Assert.AreEqual ("root", cont.Collection1[1].Parent, "#6");\r
 551                 }\r
 552                 \r
 553                 [Test]\r
 554                 [ExpectedException (typeof(InvalidOperationException))]\r
 555                 public void TestDeserializeObjectWithReadonlyNulCollection ()\r
 556                 {\r
 557                         string s3 = "";\r
 558                         s3+="<Container xmlns:xsd='http://www.w3.org/2001/XMLSchema' xmlns:xsi='http://www.w3.org/2001/XMLSchema-instance'>";\r
 559                         s3+="   <Collection1>";\r
 560                         s3+="           <Entity Name='node1'/>";\r
 561                         s3+="           <Entity Name='node2'/>";\r
 562                         s3+="   </Collection1>";\r
 563                         s3+="</Container>";\r
 564                         \r
 565                         Deserialize (typeof(ObjectWithReadonlyNulCollection), s3);\r
 566                 }\r
 567                 \r
 568                 [Test]\r
 569                 public void TestDeserializeObjectWithReadonlyArray ()\r
 570                 {\r
 571                         string s3 = "";\r
 572                         s3+="<Container xmlns:xsd='http://www.w3.org/2001/XMLSchema' xmlns:xsi='http://www.w3.org/2001/XMLSchema-instance'>";\r
 573                         s3+="   <Collection1>";\r
 574                         s3+="           <Entity Name='node1'/>";\r
 575                         s3+="           <Entity Name='node2'/>";\r
 576                         s3+="   </Collection1>";\r
 577                         s3+="</Container>";\r
 578                         \r
 579                         ObjectWithReadonlyArray cont = (ObjectWithReadonlyArray) Deserialize (typeof(ObjectWithReadonlyArray), s3);\r
 580                         Assert.IsNotNull (cont, "#1");\r
 581                         Assert.IsNotNull (cont.Collection1, "#2");\r
 582                         Assert.AreEqual (0, cont.Collection1.Length, "#3");\r
 583                 }\r
 584 \r
 585                 [Test]\r
 586                 public void TestDeserialize_EnumDefaultValue ()\r
 587                 {\r
 588                         EnumDefaultValue e;\r
 589 \r
 590                         e = (EnumDefaultValue) Deserialize (typeof (EnumDefaultValue), "<EnumDefaultValue />");\r
 591                         Assert.AreEqual (0, (int) e, "#1");\r
 592 \r
 593                         e = (EnumDefaultValue) Deserialize (typeof (EnumDefaultValue), "<EnumDefaultValue> e3</EnumDefaultValue>");\r
 594                         Assert.AreEqual (EnumDefaultValue.e3, e, "#2");\r
 595 \r
 596                         e = (EnumDefaultValue) Deserialize (typeof (EnumDefaultValue), "<EnumDefaultValue>e1 e2</EnumDefaultValue>");\r
 597                         Assert.AreEqual (EnumDefaultValue.e3, e, "#3");\r
 598 \r
 599                         e = (EnumDefaultValue) Deserialize (typeof (EnumDefaultValue), "<EnumDefaultValue>  e1   e2 </EnumDefaultValue>");\r
 600                         Assert.AreEqual (EnumDefaultValue.e1 | EnumDefaultValue.e2, e, "#4");\r
 601                 }\r
 602 \r
 603                 [Test]\r
 604                 public void TestDeserialize_EnumDefaultValueNF ()\r
 605                 {\r
 606                         EnumDefaultValueNF e;\r
 607 \r
 608                         e = (EnumDefaultValueNF) Deserialize (typeof (EnumDefaultValueNF), "<EnumDefaultValueNF>e3</EnumDefaultValueNF>");\r
 609                         Assert.AreEqual (EnumDefaultValueNF.e3, e, "#A1");\r
 610 \r
 611                         try {\r
 612                                 Deserialize (typeof (EnumDefaultValueNF), "<EnumDefaultValueNF />");\r
 613                                 Assert.Fail ("#B1");\r
 614                         } catch (InvalidOperationException ex) {\r
 615                                 Assert.AreEqual (typeof (InvalidOperationException), ex.GetType (), "#B2");\r
 616                                 Assert.IsNotNull (ex.InnerException, "#B3");\r
 617                                 Assert.AreEqual (typeof (InvalidOperationException), ex.InnerException.GetType (), "#B4");\r
 618                                 Assert.IsNotNull (ex.InnerException.Message, "#B5");\r
 619                                 Assert.IsTrue (ex.InnerException.Message.IndexOf ("''") != -1, "#B6");\r
 620                                 Assert.IsTrue (ex.InnerException.Message.IndexOf (typeof (EnumDefaultValueNF).Name) != -1, "#B7");\r
 621                         }\r
 622 \r
 623                         try {\r
 624                                 Deserialize (typeof (EnumDefaultValueNF), "<EnumDefaultValueNF>e1 e3</EnumDefaultValueNF>");\r
 625                                 Assert.Fail ("#C1");\r
 626                         } catch (InvalidOperationException ex) {\r
 627                                 Assert.AreEqual (typeof (InvalidOperationException), ex.GetType (), "#C2");\r
 628                                 Assert.IsNotNull (ex.InnerException, "#C3");\r
 629                                 Assert.AreEqual (typeof (InvalidOperationException), ex.InnerException.GetType (), "#C4");\r
 630                                 Assert.IsNotNull (ex.InnerException.Message, "#C5");\r
 631                                 Assert.IsTrue (ex.InnerException.Message.IndexOf ("'e1 e3'") != -1, "#C6");\r
 632                                 Assert.IsTrue (ex.InnerException.Message.IndexOf (typeof (EnumDefaultValueNF).Name) != -1, "#C7");\r
 633                         }\r
 634 \r
 635                         try {\r
 636                                 Deserialize (typeof (EnumDefaultValueNF), "<EnumDefaultValueNF> e3</EnumDefaultValueNF>");\r
 637                                 Assert.Fail ("#D1");\r
 638                         } catch (InvalidOperationException ex) {\r
 639                                 Assert.AreEqual (typeof (InvalidOperationException), ex.GetType (), "#D2");\r
 640                                 Assert.IsNotNull (ex.InnerException, "#D3");\r
 641                                 Assert.AreEqual (typeof (InvalidOperationException), ex.InnerException.GetType (), "#D4");\r
 642                                 Assert.IsNotNull (ex.InnerException.Message, "#D5");\r
 643                                 Assert.IsTrue (ex.InnerException.Message.IndexOf ("' e3'") != -1, "#D6");\r
 644                                 Assert.IsTrue (ex.InnerException.Message.IndexOf (typeof (EnumDefaultValueNF).Name) != -1, "#D7");\r
 645                         }\r
 646 \r
 647                         try {\r
 648                                 Deserialize (typeof (EnumDefaultValueNF), "<EnumDefaultValueNF> </EnumDefaultValueNF>");\r
 649                                 Assert.Fail ("#E1");\r
 650                         } catch (InvalidOperationException ex) {\r
 651                                 Assert.AreEqual (typeof (InvalidOperationException), ex.GetType (), "#E2");\r
 652                                 Assert.IsNotNull (ex.InnerException, "#E3");\r
 653                                 Assert.AreEqual (typeof (InvalidOperationException), ex.InnerException.GetType (), "#E4");\r
 654                                 Assert.IsNotNull (ex.InnerException.Message, "#E5");\r
 655                                 Assert.IsTrue (ex.InnerException.Message.IndexOf ("' '") != -1, "#E6");\r
 656                                 Assert.IsTrue (ex.InnerException.Message.IndexOf (typeof (EnumDefaultValueNF).Name) != -1, "#E7");\r
 657                         }\r
 658 \r
 659                         try {\r
 660                                 Deserialize (typeof (EnumDefaultValueNF), "<EnumDefaultValueNF>1</EnumDefaultValueNF>");\r
 661                                 Assert.Fail ("#F1");\r
 662                         } catch (InvalidOperationException ex) {\r
 663                                 Assert.AreEqual (typeof (InvalidOperationException), ex.GetType (), "#F2");\r
 664                                 Assert.IsNotNull (ex.InnerException, "#F3");\r
 665                                 Assert.AreEqual (typeof (InvalidOperationException), ex.InnerException.GetType (), "#F4");\r
 666                                 Assert.IsNotNull (ex.InnerException.Message, "#F5");\r
 667                                 Assert.IsTrue (ex.InnerException.Message.IndexOf ("'1'") != -1, "#F6");\r
 668                                 Assert.IsTrue (ex.InnerException.Message.IndexOf (typeof (EnumDefaultValueNF).Name) != -1, "#F7");\r
 669                         }\r
 670                 }\r
 671 \r
 672                 [Test]\r
 673                 public void TestDeserialize_FlagEnum ()\r
 674                 {\r
 675                         FlagEnum e;\r
 676 \r
 677                         e = (FlagEnum) Deserialize (typeof (FlagEnum), "<FlagEnum />");\r
 678                         Assert.AreEqual (0, (int) e, "#A1");\r
 679 \r
 680                         e = (FlagEnum) Deserialize (typeof (FlagEnum), "<FlagEnum>one</FlagEnum>");\r
 681                         Assert.AreEqual (FlagEnum.e1, e, "#A2");\r
 682 \r
 683                         e = (FlagEnum) Deserialize (typeof (FlagEnum), "<FlagEnum>one two</FlagEnum>");\r
 684                         Assert.AreEqual (FlagEnum.e1 | FlagEnum.e2, e, "#A3");\r
 685 \r
 686                         e = (FlagEnum) Deserialize (typeof (FlagEnum), "<FlagEnum>one two four</FlagEnum>");\r
 687                         Assert.AreEqual (FlagEnum.e1 | FlagEnum.e2 | FlagEnum.e4, e, "#A4");\r
 688 \r
 689                         e = (FlagEnum) Deserialize (typeof (FlagEnum), "<FlagEnum> two  four </FlagEnum>");\r
 690                         Assert.AreEqual (FlagEnum.e2 | FlagEnum.e4, e, "#A5");\r
 691 \r
 692                         e = (FlagEnum) Deserialize (typeof (FlagEnum), "<FlagEnum>two four two</FlagEnum>");\r
 693                         Assert.AreEqual (FlagEnum.e2 | FlagEnum.e4, e, "#A6");\r
 694 \r
 695                         e = (FlagEnum) Deserialize (typeof (FlagEnum), "<FlagEnum>two four two one four two one</FlagEnum>");\r
 696                         Assert.AreEqual (FlagEnum.e1 | FlagEnum.e2 | FlagEnum.e4, e, "#A7");\r
 697 \r
 698                         e = (FlagEnum) Deserialize (typeof (FlagEnum), "<FlagEnum></FlagEnum>");\r
 699                         Assert.AreEqual (0, (int) e, "#A8");\r
 700 \r
 701                         e = (FlagEnum) Deserialize (typeof (FlagEnum), "<FlagEnum> </FlagEnum>");\r
 702                         Assert.AreEqual (0, (int) e, "#A9");\r
 703 \r
 704                         try {\r
 705                                 Deserialize (typeof (FlagEnum), "<FlagEnum>1</FlagEnum>");\r
 706                                 Assert.Fail ("#B1");\r
 707                         } catch (InvalidOperationException ex) {\r
 708                                 Assert.AreEqual (typeof (InvalidOperationException), ex.GetType (), "#B2");\r
 709                                 Assert.IsNotNull (ex.InnerException, "#B3");\r
 710                                 Assert.AreEqual (typeof (InvalidOperationException), ex.InnerException.GetType (), "#B4");\r
 711                                 Assert.IsNotNull (ex.InnerException.Message, "#B5");\r
 712                                 Assert.IsTrue (ex.InnerException.Message.IndexOf ("'1'") != -1, "#B6");\r
 713                                 Assert.IsTrue (ex.InnerException.Message.IndexOf (typeof (FlagEnum).FullName) != -1, "#B7");\r
 714                         }\r
 715 \r
 716                         try {\r
 717                                 Deserialize (typeof (FlagEnum), "<FlagEnum>one,two</FlagEnum>");\r
 718                                 Assert.Fail ("#C1");\r
 719                         } catch (InvalidOperationException ex) {\r
 720                                 Assert.AreEqual (typeof (InvalidOperationException), ex.GetType (), "#C2");\r
 721                                 Assert.IsNotNull (ex.InnerException, "#C3");\r
 722                                 Assert.AreEqual (typeof (InvalidOperationException), ex.InnerException.GetType (), "#C4");\r
 723                                 Assert.IsNotNull (ex.InnerException.Message, "#C5");\r
 724                                 Assert.IsTrue (ex.InnerException.Message.IndexOf ("'one,two'") != -1, "#C6");\r
 725                                 Assert.IsTrue (ex.InnerException.Message.IndexOf (typeof (FlagEnum).FullName) != -1, "#C7");\r
 726                         }\r
 727 \r
 728                         try {\r
 729                                 Deserialize (typeof (FlagEnum), "<FlagEnum>one something</FlagEnum>");\r
 730                                 Assert.Fail ("#D1");\r
 731                         } catch (InvalidOperationException ex) {\r
 732                                 Assert.AreEqual (typeof (InvalidOperationException), ex.GetType (), "#D2");\r
 733                                 Assert.IsNotNull (ex.InnerException, "#D3");\r
 734                                 Assert.AreEqual (typeof (InvalidOperationException), ex.InnerException.GetType (), "#D4");\r
 735                                 Assert.IsNotNull (ex.InnerException.Message, "#D5");\r
 736                                 Assert.IsTrue (ex.InnerException.Message.IndexOf ("'something'") != -1, "#D6");\r
 737                                 Assert.IsTrue (ex.InnerException.Message.IndexOf (typeof (FlagEnum).FullName) != -1, "#D7");\r
 738                         }\r
 739                 }\r
 740 \r
 741                 [Test]\r
 742                 public void TestDeserialize_ZeroFlagEnum ()\r
 743                 {\r
 744                         ZeroFlagEnum e;\r
 745 \r
 746                         e = (ZeroFlagEnum) Deserialize (typeof (ZeroFlagEnum), "<ZeroFlagEnum />");\r
 747                         Assert.AreEqual (ZeroFlagEnum.e0, e, "#A1");\r
 748                         e = (ZeroFlagEnum) Deserialize (typeof (ZeroFlagEnum), "<ZeroFlagEnum></ZeroFlagEnum>");\r
 749                         Assert.AreEqual (ZeroFlagEnum.e0, e, "#A2");\r
 750 \r
 751                         try {\r
 752                                 Deserialize (typeof (ZeroFlagEnum), "<ZeroFlagEnum>four</ZeroFlagEnum>");\r
 753                                 Assert.Fail ("#B1");\r
 754                         } catch (InvalidOperationException ex) {\r
 755                                 Assert.AreEqual (typeof (InvalidOperationException), ex.GetType (), "#B2");\r
 756                                 Assert.IsNotNull (ex.InnerException, "#B3");\r
 757                                 Assert.AreEqual (typeof (InvalidOperationException), ex.InnerException.GetType (), "#B4");\r
 758                                 Assert.IsNotNull (ex.InnerException.Message, "#B5");\r
 759                                 Assert.IsTrue (ex.InnerException.Message.IndexOf ("'four'") != -1, "#B6");\r
 760                                 Assert.IsTrue (ex.InnerException.Message.IndexOf (typeof (ZeroFlagEnum).FullName) != -1, "#B7");\r
 761                         }\r
 762 \r
 763                         try {\r
 764                                 Deserialize (typeof (ZeroFlagEnum), "<ZeroFlagEnum> o&lt;n&gt;e  four </ZeroFlagEnum>");\r
 765                                 Assert.Fail ("#C1");\r
 766                         } catch (InvalidOperationException ex) {\r
 767                                 Assert.AreEqual (typeof (InvalidOperationException), ex.GetType (), "#C2");\r
 768                                 Assert.IsNotNull (ex.InnerException, "#C3");\r
 769                                 Assert.AreEqual (typeof (InvalidOperationException), ex.InnerException.GetType (), "#C4");\r
 770                                 Assert.IsNotNull (ex.InnerException.Message, "#C5");\r
 771                                 Assert.IsTrue (ex.InnerException.Message.IndexOf ("'four'") != -1, "#C6");\r
 772                                 Assert.IsTrue (ex.InnerException.Message.IndexOf (typeof (ZeroFlagEnum).FullName) != -1, "#C7");\r
 773                         }\r
 774 \r
 775                         try {\r
 776                                 Deserialize (typeof (ZeroFlagEnum), "<ZeroFlagEnum>four o&lt;n&gt;e</ZeroFlagEnum>");\r
 777                                 Assert.Fail ("#D1");\r
 778                         } catch (InvalidOperationException ex) {\r
 779                                 Assert.AreEqual (typeof (InvalidOperationException), ex.GetType (), "#D2");\r
 780                                 Assert.IsNotNull (ex.InnerException, "#D3");\r
 781                                 Assert.AreEqual (typeof (InvalidOperationException), ex.InnerException.GetType (), "#D4");\r
 782                                 Assert.IsNotNull (ex.InnerException.Message, "#D5");\r
 783                                 Assert.IsTrue (ex.InnerException.Message.IndexOf ("'four'") != -1, "#D6");\r
 784                                 Assert.IsTrue (ex.InnerException.Message.IndexOf (typeof (ZeroFlagEnum).FullName) != -1, "#D7");\r
 785                         }\r
 786                 }\r
 787 \r
 788                 [Test]\r
 789                 public void TestDeserialize_PrimitiveTypesContainer ()\r
 790                 {\r
 791                         Deserialize (typeof (PrimitiveTypesContainer), string.Format (CultureInfo.InvariantCulture, \r
 792                                 "<?xml version='1.0' encoding='utf-16'?>" +\r
 793                                 "<PrimitiveTypesContainer xmlns:xsd='{0}' xmlns:xsi='{1}' xmlns='{2}'>" +\r
 794                                 "<Number xsi:type='xsd:int'>2004</Number>" +\r
 795                                 "<Name xsi:type='xsd:string'>some name</Name>" +\r
 796                                 "<Index xsi:type='xsd:unsignedByte'>56</Index>" +\r
 797                                 "<Password xsi:type='xsd:base64Binary'>8w8=</Password>" +\r
 798                                 "<PathSeparatorCharacter xmlns:q1='{3}' xsi:type='q1:char'>47</PathSeparatorCharacter>" +\r
 799                                 "</PrimitiveTypesContainer>", XmlSchemaNamespace,\r
 800                                 XmlSchemaInstanceNamespace, ANamespace, WsdlTypesNamespace));\r
 801                         Assert.AreEqual (typeof (PrimitiveTypesContainer), result.GetType (), "#A1");\r
 802 \r
 803                         PrimitiveTypesContainer deserialized = (PrimitiveTypesContainer) result;\r
 804                         Assert.AreEqual (2004, deserialized.Number, "#A2");\r
 805                         Assert.AreEqual ("some name", deserialized.Name, "#A3");\r
 806                         Assert.AreEqual ((byte) 56, deserialized.Index, "#A4");\r
 807                         Assert.AreEqual (new byte[] { 243, 15 }, deserialized.Password, "#A5");\r
 808                         Assert.AreEqual ('/', deserialized.PathSeparatorCharacter, "#A6");\r
 809 \r
 810                         DeserializeEncoded (typeof (PrimitiveTypesContainer), string.Format (CultureInfo.InvariantCulture,\r
 811                                 "<?xml version='1.0' encoding='utf-16'?>" +\r
 812                                 "<q1:PrimitiveTypesContainer xmlns:xsd='{0}' xmlns:xsi='{1}' id='id1' xmlns:q1='{2}'>" +\r
 813                                 "<Number xsi:type='xsd:int'>2004</Number>" +\r
 814                                 "<Name xsi:type='xsd:string'>some name</Name>" +\r
 815                                 "<Index xsi:type='xsd:unsignedByte'>56</Index>" +\r
 816                                 "<Password xsi:type='xsd:base64Binary'>8w8=</Password>" +\r
 817                                 "<PathSeparatorCharacter xmlns:q1='{3}' xsi:type='q1:char'>47</PathSeparatorCharacter>" +\r
 818                                 "</q1:PrimitiveTypesContainer>", XmlSchemaNamespace,\r
 819                                 XmlSchemaInstanceNamespace, AnotherNamespace, WsdlTypesNamespace));\r
 820                         Assert.AreEqual (typeof (PrimitiveTypesContainer), result.GetType (), "#B1");\r
 821 \r
 822                         deserialized = (PrimitiveTypesContainer) result;\r
 823                         Assert.AreEqual (2004, deserialized.Number, "#B2");\r
 824                         Assert.AreEqual ("some name", deserialized.Name, "#B3");\r
 825                         Assert.AreEqual ((byte) 56, deserialized.Index, "#B4");\r
 826                         Assert.AreEqual (new byte[] { 243, 15 }, deserialized.Password, "#B5");\r
 827                         Assert.AreEqual ('/', deserialized.PathSeparatorCharacter, "#B6");\r
 828                 }\r
 829         }\r
 830 }\r