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

   1 //\r
   2 // MonoTests.System.Xml.Serialization.XmlSerializationWriterTests\r
   3 //\r
   4 // Author: Erik LeBel <eriklebel@yahoo.ca>\r
   5 //\r
   6 //  (C) Erik LeBel 2003\r
   7 //  \r
   8 // FIXME add tests for callbacks\r
   9 // FIXME add tests for writes that generate namespaces\r
  10 // FIXME add test that write XmlNode objects\r
  11 // \r
  12 \r
  13 using System;\r
  14 using System.IO;\r
  15 using System.Xml;\r
  16 using System.Xml.Serialization;\r
  17 \r
  18 using NUnit.Framework;\r
  19 \r
  20 namespace MonoTests.System.XmlSerialization\r
  21 {\r
  22         // base, common implementation of XmlSerializationWriter test harness.\r
  23         // the reason for this is that all auto generated namespace prefixes \r
  24         // of the form q# are modified by any Write* that defines a new namespace.\r
  25         // The result of this is that even though we redefine the string results\r
  26         // to exclude previous tests, the q#s will change depending on number of\r
  27         // namespace declarations were made prior to the perticual test. This \r
  28         // means that if the [Test] methods are called out of sequence, they \r
  29         // all start to fail. For this reason, tests that define and verify \r
  30         // temporary namespaces should be stored in a seperate class which protects\r
  31         // itself from accidental pre-definitions.\r
  32         public class XmlSerializarionWriterTester : XmlSerializationWriter\r
  33         {\r
  34                 // appease the compiler\r
  35                 protected override void InitCallbacks ()\r
  36                 {\r
  37                 }\r
  38 \r
  39                 StringWriter sw;\r
  40                 XmlTextWriter writer;\r
  41                 \r
  42                 [SetUp]\r
  43                 protected void Reset()\r
  44                 {\r
  45                         sw = new StringWriter ();\r
  46                         writer = new XmlTextWriter (sw);\r
  47                         writer.QuoteChar = '\'';\r
  48                         writer.Formatting = Formatting.None;\r
  49                         Writer = writer;\r
  50                 }\r
  51 \r
  52                 protected string Content\r
  53                 {\r
  54                         get\r
  55                         { \r
  56                                 string val = sw.GetStringBuilder().ToString();\r
  57 //                              Console.WriteLine(val);\r
  58                                 return val;\r
  59                         }\r
  60                 }\r
  61         }\r
  62         \r
  63         // this class tests the methods of the XmlSerializationWriter that\r
  64         // can be executed out of order.\r
  65         [TestFixture]\r
  66         public class XmlSerializationWriterSimpleTests : XmlSerializarionWriterTester\r
  67         {\r
  68                 const string ANamespace = "some:urn";\r
  69 \r
  70                 // These TestFrom* methods indirectly test the functionality of XmlCustomFormatter\r
  71 \r
  72                 [Test]\r
  73                 public void TestFromByteArrayBase64()\r
  74                 {\r
  75                         // FIXME\r
  76                         // This should work according to Mono's API, but .NET's FromByteArrayBase64 \r
  77                         // returns a byte array.\r
  78                         // \r
  79                         //string val = this.FromByteArrayBase64(new byte [] {143, 144, 1, 0});\r
  80                         //Assertion.AssertEquals(FromByteArrayBase64(null), "");\r
  81                         \r
  82                         //val = FromByteArrayBase64(null);\r
  83                         //try/catch or AssertEruals?\r
  84                 }\r
  85 \r
  86                 [Test]\r
  87                 public void TestFromByteArrayHex()\r
  88                 {\r
  89                         byte [] vals = {143, 144, 1, 0};\r
  90                         Assertion.AssertEquals("8F900100", FromByteArrayHex(vals));\r
  91                         Assertion.AssertEquals(null, FromByteArrayHex(null));\r
  92                 }\r
  93 \r
  94                 [Test]\r
  95                 public void TestFromChar()\r
  96                 {\r
  97                         Assertion.AssertEquals("97", FromChar('a'));\r
  98                         Assertion.AssertEquals("0", FromChar('\0'));\r
  99                         Assertion.AssertEquals("10", FromChar('\n'));\r
 100                         Assertion.AssertEquals("65281", FromChar('\uFF01'));\r
 101                 }\r
 102 \r
 103                 [Test]\r
 104                 public void TestFromDate()\r
 105                 {\r
 106                         DateTime d = new DateTime();\r
 107                         Assertion.AssertEquals("0001-01-01", FromDate(d));\r
 108                 }\r
 109 \r
 110                 [Test]\r
 111                 public void TestFromDateTime()\r
 112                 {\r
 113                         DateTime d = new DateTime();\r
 114                         Assertion.AssertEquals("0001-01-01T00:00:00.0000000", FromDateTime(d).Substring (0, 27));\r
 115                 }\r
 116 \r
 117                 [Test]\r
 118                 public void TestFromEnum()\r
 119                 {\r
 120                         long[] ids = {1, 2, 3, 4};\r
 121                         string[] values = {"one", "two", "three"};\r
 122                         \r
 123                         Assertion.AssertEquals("one", FromEnum(1, values, ids));\r
 124                         Assertion.AssertEquals("", FromEnum(0, values, ids));\r
 125 \r
 126                         try\r
 127                         {\r
 128                                 string dummy = FromEnum(4, values, ids);\r
 129                                 Assertion.Fail("This should fail with an array-out-of-bunds error");\r
 130                         }\r
 131                         catch (Exception)\r
 132                         {\r
 133                         }\r
 134                 }\r
 135 \r
 136                 [Test]\r
 137                 public void TestFromTime()\r
 138                 {\r
 139                         DateTime d = new DateTime();\r
 140                         // Don't include time zone.\r
 141                         Assertion.AssertEquals("00:00:00.0000000", FromTime(d).Substring (0, 16));\r
 142                 }\r
 143 \r
 144                 [Test]\r
 145                 public void TestFromXmlName()\r
 146                 {\r
 147                         Assertion.AssertEquals("Hello", FromXmlName("Hello"));\r
 148                         Assertion.AssertEquals("go_x0020_dogs_x0020_go", FromXmlName("go dogs go"));\r
 149                         Assertion.AssertEquals("what_x0027_s_x0020_up", FromXmlName("what's up"));\r
 150                         Assertion.AssertEquals("_x0031_23go", FromXmlName("123go"));\r
 151                         Assertion.AssertEquals("Hello_x0020_what_x0027_s.up", FromXmlName("Hello what's.up"));\r
 152                 }\r
 153 \r
 154                 [Test]\r
 155                 public void TestFromXmlNCName()\r
 156                 {\r
 157                         Assertion.AssertEquals("Hello", FromXmlNCName("Hello"));\r
 158                         Assertion.AssertEquals("go_x0020_dogs_x0020_go", FromXmlNCName("go dogs go"));\r
 159                         Assertion.AssertEquals("what_x0027_s_x0020_up", FromXmlNCName("what's up"));\r
 160                         Assertion.AssertEquals("_x0031_23go", FromXmlNCName("123go"));\r
 161                         Assertion.AssertEquals("Hello_x0020_what_x0027_s.up", FromXmlNCName("Hello what's.up"));\r
 162                 }\r
 163 \r
 164                 [Test]\r
 165                 public void TestFromXmlNmToken()\r
 166                 {\r
 167                         Assertion.AssertEquals("Hello", FromXmlNmToken("Hello"));\r
 168                         Assertion.AssertEquals("go_x0020_dogs_x0020_go", FromXmlNmToken("go dogs go"));\r
 169                         Assertion.AssertEquals("what_x0027_s_x0020_up", FromXmlNmToken("what's up"));\r
 170                         Assertion.AssertEquals("123go", FromXmlNmToken("123go"));\r
 171                         Assertion.AssertEquals("Hello_x0020_what_x0027_s.up", FromXmlNmToken("Hello what's.up"));\r
 172                 }\r
 173 \r
 174                 [Test]\r
 175                 public void TestFromXmlNmTokens()\r
 176                 {\r
 177                         Assertion.AssertEquals("Hello go dogs_go 123go what_x0027_s.up", FromXmlNmTokens("Hello go dogs_go 123go what's.up"));\r
 178                 }\r
 179 \r
 180                 [Test]\r
 181                 public void TestWriteAttribute()\r
 182                 {\r
 183                         WriteStartElement("x");\r
 184                         WriteAttribute("a", "b");\r
 185                         WriteEndElement();\r
 186                         Assertion.AssertEquals("<x a='b' />", Content);\r
 187 \r
 188                         Reset();\r
 189                         WriteStartElement("x");\r
 190                         WriteAttribute("a", new byte[] {1, 2, 3});\r
 191                         WriteEndElement();\r
 192                         Assertion.AssertEquals("<x a='AQID' />", Content);\r
 193 \r
 194                         Reset();\r
 195                         WriteStartElement("x");\r
 196                         WriteAttribute("a", "<b");\r
 197                         WriteEndElement();\r
 198                         Assertion.AssertEquals("<x a='&lt;b' />", Content);\r
 199 \r
 200                         Reset();\r
 201                         WriteStartElement("x");\r
 202                         string typedPlaceholder = null;\r
 203                         WriteAttribute("a", typedPlaceholder);\r
 204                         WriteEndElement();\r
 205                         Assertion.AssertEquals("<x />", Content);\r
 206 \r
 207                         Reset();\r
 208                         WriteStartElement("x");\r
 209                         WriteAttribute("a", "\"");\r
 210                         WriteEndElement();\r
 211                         Assertion.AssertEquals("<x a='\"' />", Content);\r
 212 \r
 213                         Reset();\r
 214                         WriteStartElement("x");\r
 215                         WriteAttribute("a", "b\nc");\r
 216                         WriteEndElement();\r
 217                         Assertion.AssertEquals("<x a='b&#xA;c' />", Content);\r
 218 \r
 219                         Reset();\r
 220                         WriteStartElement("x");\r
 221                         WriteAttribute("a", ANamespace, "b");\r
 222                         WriteEndElement();\r
 223                         Assertion.AssertEquals("<x d1p1:a='b' xmlns:d1p1='some:urn' />", Content);\r
 224 \r
 225 \r
 226                 }\r
 227 \r
 228                 [Test]\r
 229                 public void TestWriteElementEncoded()\r
 230                 {\r
 231                         // FIXME\r
 232                         // XmlNode related\r
 233                 }\r
 234 \r
 235                 [Test]\r
 236                 public void TestWriteElementLiteral()\r
 237                 {\r
 238                         // FIXME\r
 239                         // XmlNode related\r
 240                 }\r
 241 \r
 242                 [Test]\r
 243                 public void TestWriteElementString()\r
 244                 {\r
 245                         WriteElementString("x", "a");\r
 246                         Assertion.AssertEquals("<x>a</x>", Content);\r
 247 \r
 248                         Reset();\r
 249                         WriteElementString("x", "<a");\r
 250                         Assertion.AssertEquals("<x>&lt;a</x>", Content);\r
 251                 }\r
 252 \r
 253                 [Test]\r
 254                 public void TestWriteElementStringRaw()\r
 255                 {\r
 256                         byte [] placeHolderArray = null;\r
 257                         WriteElementStringRaw("x", placeHolderArray);\r
 258                         Assertion.AssertEquals("", Content);\r
 259 \r
 260                         Reset();\r
 261                         WriteElementStringRaw("x", new byte[] {0, 2, 4});\r
 262                         Assertion.AssertEquals("<x>AAIE</x>", Content);\r
 263 \r
 264                         Reset();\r
 265                         WriteElementStringRaw("x", new byte[] {});\r
 266                         Assertion.AssertEquals("<x />", Content);\r
 267 \r
 268                         // Note to reader, the output is not valid xml\r
 269                         Reset();\r
 270                         WriteElementStringRaw("x", "a > 13 && a < 19");\r
 271                         Assertion.AssertEquals("<x>a > 13 && a < 19</x>", Content);\r
 272                 }\r
 273 \r
 274                 [Test]\r
 275                 public void TestWriteEmptyTag()\r
 276                 {\r
 277                         WriteEmptyTag("x");\r
 278                         Assertion.AssertEquals("<x />", Content);\r
 279                 }\r
 280 \r
 281                 [Test]\r
 282                 public void TestWriteNamespaceDeclarations()\r
 283                 {\r
 284                         XmlSerializerNamespaces ns = new XmlSerializerNamespaces();\r
 285 \r
 286                         WriteStartElement("x");\r
 287                         WriteNamespaceDeclarations(ns);\r
 288                         WriteEndElement();\r
 289                         Assertion.AssertEquals("<x />", Content);\r
 290 \r
 291                         Reset();\r
 292                         ns.Add("mypref", ANamespace);\r
 293                         WriteStartElement("x");\r
 294                         WriteNamespaceDeclarations(ns);\r
 295                         WriteEndElement();\r
 296                         Assertion.AssertEquals(XmlSerializerTests.Infoset("<x xmlns:mypref='some:urn' />"), XmlSerializerTests.Infoset(Content));\r
 297 \r
 298                         Reset();\r
 299                         ns.Add("ns2", "another:urn");\r
 300                         WriteStartElement("x");\r
 301                         WriteNamespaceDeclarations(ns);\r
 302                         WriteEndElement();\r
 303                         Assertion.AssertEquals(XmlSerializerTests.Infoset("<x xmlns:ns2='another:urn' xmlns:mypref='some:urn' />"), XmlSerializerTests.Infoset(Content));\r
 304 \r
 305                         Reset();\r
 306                         ns.Add("ns3", "ya:urn");\r
 307                         WriteStartElement("x");\r
 308                         WriteNamespaceDeclarations(ns);\r
 309                         WriteEndElement();\r
 310                         Assertion.AssertEquals(XmlSerializerTests.Infoset("<x xmlns:ns3='ya:urn' xmlns:ns2='another:urn' xmlns:mypref='some:urn' />"), XmlSerializerTests.Infoset(Content));\r
 311                 }\r
 312 \r
 313                 [Test]\r
 314                 public void TestWriteNullableStringLiteral()\r
 315                 {\r
 316                         WriteNullableStringLiteral("x", null, null);\r
 317                         Assertion.AssertEquals(XmlSerializerTests.Infoset("<x d1p1:nil='true' xmlns:d1p1='http://www.w3.org/2001/XMLSchema-instance' />"), XmlSerializerTests.Infoset(Content));\r
 318 \r
 319                         Reset();\r
 320                         WriteNullableStringLiteral("x", null, "");\r
 321                         Assertion.AssertEquals("<x />", Content);\r
 322                         \r
 323                         Reset();\r
 324                         WriteNullableStringLiteral("x", null, "a<b\'c");\r
 325                         Assertion.AssertEquals("<x>a&lt;b\'c</x>", Content);\r
 326 \r
 327                         Reset();\r
 328                         WriteNullableStringLiteral("x", ANamespace, "b");\r
 329                         Assertion.AssertEquals("<x xmlns='some:urn'>b</x>", Content);\r
 330                 }\r
 331 \r
 332                 [Test]\r
 333                 public void TestWriteNullableStringLiteralRaw()\r
 334                 {\r
 335                         WriteNullableStringLiteralRaw("x", null, new byte[] {1, 2, 244});\r
 336                         Assertion.AssertEquals("<x>AQL0</x>", Content);\r
 337                 }\r
 338 \r
 339                 [Test]\r
 340                 public void TestWriteNullTagEncoded()\r
 341                 {\r
 342                         WriteNullTagEncoded("x");\r
 343                         Assertion.AssertEquals(XmlSerializerTests.Infoset("<x d1p1:nil='true' xmlns:d1p1='http://www.w3.org/2001/XMLSchema-instance' />"), XmlSerializerTests.Infoset(Content));\r
 344                 }\r
 345 \r
 346                 [Test]\r
 347                 public void TestWriteNullTagLiteral()\r
 348                 {\r
 349                         WriteNullTagLiteral("x");\r
 350                         Assertion.AssertEquals(XmlSerializerTests.Infoset("<x d1p1:nil='true' xmlns:d1p1='http://www.w3.org/2001/XMLSchema-instance' />"), XmlSerializerTests.Infoset(Content));\r
 351                 }\r
 352 \r
 353                 [Test]\r
 354                 public void TestWriteSerializable()\r
 355                 {\r
 356                         // FIXME\r
 357                         //Assertion.AssertEquals(, "");\r
 358                 }\r
 359 \r
 360                 public void TestWriteStartDocument()\r
 361                 {\r
 362                         Assertion.AssertEquals("", Content);\r
 363                         \r
 364                         WriteStartDocument();\r
 365                         Assertion.AssertEquals("<?xml version='1.0' encoding='utf-16'?>", Content);\r
 366                 }\r
 367 \r
 368                 [Test]\r
 369                 public void TestWriteStartElement()\r
 370                 {\r
 371                         WriteStartElement("x");\r
 372                         WriteEndElement();\r
 373                         Assertion.AssertEquals("<x />", Content);\r
 374 \r
 375                         Reset();\r
 376                         WriteStartElement("x");\r
 377                         WriteValue("a");\r
 378                         WriteEndElement();\r
 379                         Assertion.AssertEquals("<x>a</x>", Content);\r
 380 \r
 381                         Reset();\r
 382                         WriteStartElement("x");\r
 383                         WriteStartElement("y", "z");\r
 384                         WriteEndElement();\r
 385                         WriteEndElement();\r
 386                         Assertion.AssertEquals("<x><y xmlns='z' /></x>", Content);\r
 387 \r
 388                         Reset();\r
 389                         WriteStartElement("x");\r
 390                         WriteStartElement("y", "z", true);\r
 391                         WriteEndElement();\r
 392                         WriteEndElement();\r
 393                         Assertion.AssertEquals("<x><q1:y xmlns:q1='z' /></x>", Content);\r
 394                 }\r
 395                 \r
 396                 public void TestWriteTypedPrimitive()\r
 397                 {\r
 398                         // as long as WriteTypePrimitive's last argument is false, this is OK here.\r
 399                         WriteTypedPrimitive("x", ANamespace, "hello", false);\r
 400                         Assertion.AssertEquals("<x xmlns='some:urn'>hello</x>", Content);\r
 401 \r
 402                         Reset();\r
 403                         WriteTypedPrimitive("x", ANamespace, 10, false);\r
 404                         Assertion.AssertEquals("<x xmlns='some:urn'>10</x>", Content);\r
 405 \r
 406                         try\r
 407                         {\r
 408                                 WriteTypedPrimitive("x", ANamespace, null, false);\r
 409                                 Assertion.Fail("Should not be able to write a null primitive");\r
 410                         }\r
 411                         catch (Exception)\r
 412                         {\r
 413                         }\r
 414                 }\r
 415 \r
 416                 public void TestWriteValue()\r
 417                 {\r
 418                         WriteValue("");\r
 419                         Assertion.AssertEquals("", Content);\r
 420 \r
 421                         Reset();\r
 422                         WriteValue("hello");\r
 423                         Assertion.AssertEquals("hello", Content);\r
 424 \r
 425                         Reset();\r
 426                         string v = null;\r
 427                         WriteValue(v);\r
 428                         Assertion.AssertEquals("", Content);\r
 429 \r
 430                         Reset();\r
 431                         WriteValue(new byte[] {13, 8, 99});\r
 432                         Assertion.AssertEquals("DQhj", Content);\r
 433                 }\r
 434 \r
 435                 public void TestWriteXmlAttribute()\r
 436                 {\r
 437                         // FIXME\r
 438                         // XmlNode related\r
 439                 }\r
 440 \r
 441                 public void TestWriteXsiType()\r
 442                 {\r
 443                         WriteStartElement("x");\r
 444                         WriteXsiType("pref", null);\r
 445                         WriteEndElement();\r
 446                         Assertion.AssertEquals(XmlSerializerTests.Infoset("<x d1p1:type='pref' xmlns:d1p1='http://www.w3.org/2001/XMLSchema-instance' />"), XmlSerializerTests.Infoset(Content));\r
 447                 }\r
 448         }\r
 449 }\r