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

   1 //
   2 // MonoTests.System.Xml.Serialization.XmlSerializationWriterTests
   3 //
   4 // Author: Erik LeBel <eriklebel@yahoo.ca>
   5 //
   6 //  (C) Erik LeBel 2003
   7 // Copyright 2003-2011 Novell
   8 // Copyright 2011 Xamarin Inc
   9 //
  10 // FIXME add tests for callbacks
  11 // FIXME add tests for writes that generate namespaces
  12 // FIXME add test that write XmlNode objects
  13 //
  14
  15 using System;
  16 using System.Globalization;
  17 using System.IO;
  18 using System.Xml;
  19 using System.Xml.Serialization;
  20
  21 using NUnit.Framework;
  22
  23 using MonoTests.System.Xml.TestClasses;
  24
  25 namespace MonoTests.System.XmlSerialization
  26 {
  27         // base, common implementation of XmlSerializationWriter test harness.
  28         // the reason for this is that all auto generated namespace prefixes
  29         // of the form q# are modified by any Write* that defines a new namespace.
  30         // The result of this is that even though we redefine the string results
  31         // to exclude previous tests, the q#s will change depending on number of
  32         // namespace declarations were made prior to the perticual test. This
  33         // means that if the [Test] methods are called out of sequence, they
  34         // all start to fail. For this reason, tests that define and verify
  35         // temporary namespaces should be stored in a seperate class which protects
  36         // itself from accidental pre-definitions.
  37         public class XmlSerializarionWriterTester : XmlSerializationWriter
  38         {
  39                 // appease the compiler
  40                 protected override void InitCallbacks ()
  41                 {
  42                 }
  43
  44                 StringWriter sw;
  45                 XmlTextWriter writer;
  46
  47                 [SetUp]
  48                 public void Reset()
  49                 {
  50                         sw = new StringWriter ();
  51                         writer = new XmlTextWriter (sw);
  52                         writer.QuoteChar = '\'';
  53                         writer.Formatting = Formatting.None;
  54                         Writer = writer;
  55                 }
  56
  57                 public string Content
  58                 {
  59                         get
  60                         {
  61                                 string val = sw.GetStringBuilder().ToString();
  62                                 return val;
  63                         }
  64                 }
  65
  66                 public void ExecuteWritePotentiallyReferencingElement (string name, string ns, object o, Type ambientType, bool suppressReference, bool isNullable)
  67                 {
  68                         WritePotentiallyReferencingElement (name, ns, o, ambientType, suppressReference, isNullable);
  69                 }
  70
  71                 public void ExecuteWriteTypedPrimitive (string name, string ns, object o, bool xsiType)
  72                 {
  73                         WriteTypedPrimitive (name, ns, o, xsiType);
  74                 }
  75         }
  76
  77         // this class tests the methods of the XmlSerializationWriter that
  78         // can be executed out of order.
  79         [TestFixture]
  80         public class XmlSerializationWriterSimpleTests : XmlSerializarionWriterTester
  81         {
  82                 const string XmlSchemaNamespace = "http://www.w3.org/2001/XMLSchema";
  83                 const string XmlSchemaInstanceNamespace = "http://www.w3.org/2001/XMLSchema-instance";
  84                 const string SoapEncodingNamespace = "http://schemas.xmlsoap.org/soap/encoding/";
  85                 const string WsdlTypesNamespace = "http://microsoft.com/wsdl/types/";
  86                 const string ANamespace = "some:urn";
  87                 const string AnotherNamespace = "another:urn";
  88
  89                 // These TestFrom* methods indirectly test the functionality of XmlCustomFormatter
  90
  91                 [Test]
  92                 public void TestFromByteArrayBase64()
  93                 {
  94                         // FIXME
  95                         // This should work according to Mono's API, but .NET's FromByteArrayBase64
  96                         // returns a byte array.
  97                         //
  98                         //string val = this.FromByteArrayBase64(new byte [] {143, 144, 1, 0});
  99                         //Assert.AreEqual (FromByteArrayBase64(null), "");
 100
 101                         //val = FromByteArrayBase64(null);
 102                         //try/catch or AssertEruals?
 103                 }
 104
 105                 [Test]
 106                 public void TestFromByteArrayHex()
 107                 {
 108                         byte [] vals = {143, 144, 1, 0};
 109                         Assert.AreEqual ("8F900100", FromByteArrayHex(vals));
 110                         Assert.IsNull (FromByteArrayHex (null));
 111                 }
 112
 113                 [Test]
 114                 public void TestFromChar()
 115                 {
 116                         Assert.AreEqual ("97", FromChar ('a'));
 117                         Assert.AreEqual ("0", FromChar ('\0'));
 118                         Assert.AreEqual ("10", FromChar ('\n'));
 119                         Assert.AreEqual ("65281", FromChar ('\uFF01'));
 120                 }
 121
 122                 [Test]
 123                 public void TestFromDate()
 124                 {
 125                         DateTime d = new DateTime();
 126                         Assert.AreEqual ("0001-01-01", FromDate (d));
 127                 }
 128
 129                 [Test]
 130                 public void TestFromDateTime()
 131                 {
 132                         DateTime d = new DateTime();
 133                         Assert.AreEqual ("0001-01-01T00:00:00", FromDateTime (d));
 134                 }
 135
 136                 [Test] // bug #77500
 137                 public void TestFromEnum()
 138                 {
 139                         long[] ids = {1, 2, 3, 4};
 140                         string[] values = {"one", "two", "three"};
 141
 142                         Assert.AreEqual ("one", FromEnum (1, values, ids), "#1");
 143                         Assert.AreEqual (string.Empty, FromEnum (0, values, ids), "#2");
 144                         Assert.AreEqual ("one two", FromEnum (3, values, ids), "#3");
 145
 146                         try {
 147                                 string dummy = FromEnum(4, values, ids);
 148                                 Assert.Fail("#4");
 149                         } catch (IndexOutOfRangeException) {
 150                         }
 151
 152                         string[] correctValues = {"one", "two", "three", "four"};
 153                         Assert.AreEqual ("four", FromEnum (4, correctValues, ids), "#5");
 154                         Assert.AreEqual ("one four", FromEnum (5, correctValues, ids), "#6");
 155                         Assert.AreEqual ("two four", FromEnum (6, correctValues, ids), "#7");
 156                         Assert.AreEqual ("one two three four", FromEnum (7, correctValues, ids), "#8");
 157
 158                         string[] flagValues = {"one", "two", "four", "eight"};
 159                         long[] flagIDs = {1, 2, 4, 8};
 160                         Assert.AreEqual (string.Empty, FromEnum (0, flagValues, flagIDs), "#9");
 161                         Assert.AreEqual ("two", FromEnum (2, flagValues, flagIDs), "#10");
 162                         Assert.AreEqual ("four", FromEnum (4, flagValues, flagIDs), "#1");
 163                         Assert.AreEqual ("one four", FromEnum (5, flagValues, flagIDs), "#12");
 164                         Assert.AreEqual ("two four", FromEnum (6, flagValues, flagIDs), "#13");
 165                         Assert.AreEqual ("one two four", FromEnum (7, flagValues, flagIDs), "#14");
 166                         Assert.AreEqual ("eight", FromEnum (8, flagValues, flagIDs), "#15");
 167                         Assert.AreEqual ("one four eight", FromEnum (13, flagValues, flagIDs), "#16");
 168
 169                         string[] unorderedValues = {"one", "four", "two", "zero"};
 170                         long[] unorderedIDs = {1, 4, 2, 0};
 171
 172                         Assert.AreEqual (string.Empty, FromEnum (0, unorderedValues, unorderedIDs), "#17");
 173                         Assert.AreEqual ("two", FromEnum (2, unorderedValues, unorderedIDs), "#18");
 174                         Assert.AreEqual ("four", FromEnum (4, unorderedValues, unorderedIDs), "#19");
 175                         Assert.AreEqual ("one four", FromEnum (5, unorderedValues, unorderedIDs), "#20");
 176                         Assert.AreEqual ("four two", FromEnum (6, unorderedValues, unorderedIDs), "#21");
 177                         Assert.AreEqual ("one four two", FromEnum (7, unorderedValues, unorderedIDs), "#22");
 178
 179                         string[] zeroValues = {"zero", "ten"};
 180                         long[] zeroIDs = {0, 10};
 181
 182                         Assert.AreEqual ("zero", FromEnum (0, zeroValues, zeroIDs), "#9");
 183                         Assert.AreEqual ("ten", FromEnum (10, zeroValues, zeroIDs), "#9");
 184
 185                         string[] reverseZeroValues = {"", "zero"};
 186                         long[] reverseZeroIDs = {4, 0};
 187                         Assert.AreEqual (string.Empty, FromEnum (0, reverseZeroValues, reverseZeroIDs), "#9");
 188                         Assert.AreEqual ("zero", FromEnum (4, reverseZeroValues, reverseZeroIDs), "#9");
 189
 190                         string[] emptyValues = { "zero" };
 191                         long[] emptyIDs = {0};
 192                         Assert.AreEqual ("zero", FromEnum (0, emptyValues, emptyIDs), "#9");
 193                 }
 194
 195                 [Test]
 196                 public void TestFromEnum_InvalidValue ()
 197                 {
 198                         long[] ids = {1, 2, 3, 4};
 199                         string[] values = {"one", "two", "three", "four"};
 200
 201                         try {
 202                                 FromEnum (8, values, ids);
 203                                 Assert.Fail ("#A1");
 204                         } catch (InvalidOperationException ex) {
 205                                 Assert.AreEqual (typeof (InvalidOperationException), ex.GetType (), "#A2");
 206                                 Assert.IsNotNull (ex.Message, "#A3");
 207                                 Assert.IsTrue (ex.Message.IndexOf ("'8'") != -1, "#A4");
 208                                 Assert.IsNull (ex.InnerException, "#A5");
 209                         }
 210
 211                         try {
 212                                 FromEnum (8, values, ids, "Some.Type.Name");
 213                                 Assert.Fail ("#B1");
 214                         } catch (InvalidOperationException ex) {
 215                                 Assert.AreEqual (typeof (InvalidOperationException), ex.GetType (), "#B2");
 216                                 Assert.IsNotNull (ex.Message, "#B3");
 217                                 Assert.IsTrue (ex.Message.IndexOf ("'8'") != -1, "#B4");
 218                                 Assert.IsTrue (ex.Message.IndexOf ("Some.Type.Name") != -1, "#B5");
 219                                 Assert.IsNull (ex.InnerException, "#B6");
 220                         }
 221                 }
 222
 223                 [Test]
 224                 [ExpectedException (typeof (NullReferenceException))]
 225                 public void TestFromEnum_Null_Values ()
 226                 {
 227                         long[] ids = { 1, 2, 3, 4 };
 228                         string[] values = { "one", "two", "three", "four" };
 229
 230                         FromEnum (1, (string[]) null, ids);
 231                 }
 232
 233                 [Test]
 234                 [ExpectedException (typeof (NullReferenceException))]
 235                 public void TestFromEnum_Null_IDs ()
 236                 {
 237                         string[] values = { "one", "two", "three", "four" };
 238
 239                         FromEnum (1, values, (long[]) null);
 240                 }
 241
 242                 [Test]
 243                 public void TestFromTime()
 244                 {
 245                         DateTime d = new DateTime();
 246                         // Don't include time zone.
 247                         Assert.AreEqual ("00:00:00.0000000", FromTime (d).Substring (0, 16));
 248                 }
 249
 250                 [Test]
 251                 public void TestFromXmlName()
 252                 {
 253                         Assert.AreEqual ("Hello", FromXmlName ("Hello"));
 254                         Assert.AreEqual ("go_x0020_dogs_x0020_go", FromXmlName ("go dogs go"));
 255                         Assert.AreEqual ("what_x0027_s_x0020_up", FromXmlName ("what's up"));
 256                         Assert.AreEqual ("_x0031_23go", FromXmlName ("123go"));
 257                         Assert.AreEqual ("Hello_x0020_what_x0027_s.up", FromXmlName ("Hello what's.up"));
 258                 }
 259
 260                 [Test]
 261                 public void TestFromXmlNCName()
 262                 {
 263                         Assert.AreEqual ("Hello", FromXmlNCName ("Hello"));
 264                         Assert.AreEqual ("go_x0020_dogs_x0020_go", FromXmlNCName ("go dogs go"));
 265                         Assert.AreEqual ("what_x0027_s_x0020_up", FromXmlNCName ("what's up"));
 266                         Assert.AreEqual ("_x0031_23go", FromXmlNCName ("123go"));
 267                         Assert.AreEqual ("Hello_x0020_what_x0027_s.up", FromXmlNCName ("Hello what's.up"));
 268                 }
 269
 270                 [Test]
 271                 public void TestFromXmlNmToken()
 272                 {
 273                         Assert.AreEqual ("Hello", FromXmlNmToken ("Hello"));
 274                         Assert.AreEqual ("go_x0020_dogs_x0020_go", FromXmlNmToken ("go dogs go"));
 275                         Assert.AreEqual ("what_x0027_s_x0020_up", FromXmlNmToken ("what's up"));
 276                         Assert.AreEqual ("123go", FromXmlNmToken ("123go"));
 277                         Assert.AreEqual ("Hello_x0020_what_x0027_s.up", FromXmlNmToken ("Hello what's.up"));
 278                 }
 279
 280                 [Test]
 281                 public void TestFromXmlNmTokens()
 282                 {
 283                         Assert.AreEqual ("Hello go dogs_go 123go what_x0027_s.up", FromXmlNmTokens ("Hello go dogs_go 123go what's.up"));
 284                 }
 285
 286                 [Test]
 287                 public void TestWriteAttribute()
 288                 {
 289                         WriteStartElement("x");
 290                         WriteAttribute("a", "b");
 291                         WriteEndElement();
 292                         Assert.AreEqual ("<x a='b' />", Content);
 293
 294                         Reset();
 295                         WriteStartElement("x");
 296                         WriteAttribute("a", new byte[] {1, 2, 3});
 297                         WriteEndElement();
 298                         Assert.AreEqual ("<x a='AQID' />", Content);
 299
 300                         Reset();
 301                         WriteStartElement("x");
 302                         WriteAttribute("a", "<b");
 303                         WriteEndElement();
 304                         Assert.AreEqual ("<x a='&lt;b' />", Content);
 305
 306                         Reset();
 307                         WriteStartElement("x");
 308                         string typedPlaceholder = null;
 309                         WriteAttribute("a", typedPlaceholder);
 310                         WriteEndElement();
 311                         Assert.AreEqual ("<x />", Content);
 312
 313                         Reset();
 314                         WriteStartElement("x");
 315                         WriteAttribute("a", "\"");
 316                         WriteEndElement();
 317                         Assert.AreEqual ("<x a='\"' />", Content);
 318
 319                         Reset();
 320                         WriteStartElement("x");
 321                         WriteAttribute("a", "b\nc");
 322                         WriteEndElement();
 323                         Assert.AreEqual ("<x a='b&#xA;c' />", Content);
 324
 325                         Reset();
 326                         WriteStartElement("x");
 327                         WriteAttribute("a", ANamespace, "b");
 328                         WriteEndElement();
 329                         Assert.AreEqual ("<x d1p1:a='b' xmlns:d1p1='some:urn' />", Content);
 330                 }
 331
 332                 [Test]
 333                 public void TestWriteElementEncoded()
 334                 {
 335                         // FIXME
 336                         // XmlNode related
 337                 }
 338
 339                 [Test]
 340                 public void TestWriteElementLiteral()
 341                 {
 342                         // FIXME
 343                         // XmlNode related
 344                 }
 345
 346                 [Test]
 347                 public void TestWriteElementString()
 348                 {
 349                         WriteElementString("x", "a");
 350                         Assert.AreEqual ("<x>a</x>", Content);
 351
 352                         Reset();
 353                         WriteElementString("x", "<a");
 354                         Assert.AreEqual ("<x>&lt;a</x>", Content);
 355                 }
 356
 357                 [Test]
 358                 public void TestWriteElementStringRaw()
 359                 {
 360                         byte [] placeHolderArray = null;
 361                         WriteElementStringRaw("x", placeHolderArray);
 362                         Assert.AreEqual ("", Content);
 363
 364                         Reset();
 365                         WriteElementStringRaw("x", new byte[] {0, 2, 4});
 366                         Assert.AreEqual ("<x>AAIE</x>", Content);
 367
 368                         Reset();
 369                         WriteElementStringRaw("x", new byte[] {});
 370                         Assert.AreEqual ("<x />", Content);
 371
 372                         // Note to reader, the output is not valid xml
 373                         Reset();
 374                         WriteElementStringRaw("x", "a > 13 && a < 19");
 375                         Assert.AreEqual ("<x>a > 13 && a < 19</x>", Content);
 376                 }
 377
 378                 [Test]
 379                 public void TestWriteEmptyTag()
 380                 {
 381                         WriteEmptyTag("x");
 382                         Assert.AreEqual ("<x />", Content);
 383                 }
 384
 385                 [Test]
 386                 public void TestWriteNamespaceDeclarations()
 387                 {
 388                         XmlSerializerNamespaces ns = new XmlSerializerNamespaces();
 389
 390                         WriteStartElement("x");
 391                         WriteNamespaceDeclarations(ns);
 392                         WriteEndElement();
 393                         Assert.AreEqual ("<x />", Content);
 394
 395                         Reset();
 396                         ns.Add("mypref", ANamespace);
 397                         WriteStartElement("x");
 398                         WriteNamespaceDeclarations(ns);
 399                         WriteEndElement();
 400                         Assert.AreEqual (XmlSerializerTests.Infoset("<x xmlns:mypref='some:urn' />"), XmlSerializerTests.Infoset(Content));
 401
 402                         Reset();
 403                         ns.Add("ns2", "another:urn");
 404                         WriteStartElement("x");
 405                         WriteNamespaceDeclarations(ns);
 406                         WriteEndElement();
 407                         Assert.AreEqual (XmlSerializerTests.Infoset("<x xmlns:ns2='another:urn' xmlns:mypref='some:urn' />"), XmlSerializerTests.Infoset(Content));
 408
 409                         Reset();
 410                         ns.Add("ns3", "ya:urn");
 411                         WriteStartElement("x");
 412                         WriteNamespaceDeclarations(ns);
 413                         WriteEndElement();
 414                         Assert.AreEqual (XmlSerializerTests.Infoset("<x xmlns:ns3='ya:urn' xmlns:ns2='another:urn' xmlns:mypref='some:urn' />"), XmlSerializerTests.Infoset(Content));
 415                 }
 416
 417                 [Test]
 418                 public void TestWriteNullableStringLiteral()
 419                 {
 420                         WriteNullableStringLiteral("x", null, null);
 421                         Assert.AreEqual (XmlSerializerTests.Infoset("<x d1p1:nil='true' xmlns:d1p1='http://www.w3.org/2001/XMLSchema-instance' />"), XmlSerializerTests.Infoset(Content));
 422
 423                         Reset();
 424                         WriteNullableStringLiteral("x", null, "");
 425                         Assert.AreEqual ("<x />", Content);
 426
 427                         Reset();
 428                         WriteNullableStringLiteral("x", null, "a<b\'c");
 429                         Assert.AreEqual ("<x>a&lt;b\'c</x>", Content);
 430
 431                         Reset();
 432                         WriteNullableStringLiteral("x", ANamespace, "b");
 433                         Assert.AreEqual ("<x xmlns='some:urn'>b</x>", Content);
 434                 }
 435
 436                 [Test]
 437                 public void TestWriteNullableStringLiteralRaw()
 438                 {
 439                         WriteNullableStringLiteralRaw("x", null, new byte[] {1, 2, 244});
 440                         Assert.AreEqual ("<x>AQL0</x>", Content);
 441                 }
 442
 443                 [Test]
 444                 public void TestWriteNullTagEncoded()
 445                 {
 446                         WriteNullTagEncoded("x");
 447                         Assert.AreEqual (XmlSerializerTests.Infoset("<x d1p1:nil='true' xmlns:d1p1='http://www.w3.org/2001/XMLSchema-instance' />"), XmlSerializerTests.Infoset(Content));
 448                 }
 449
 450                 [Test]
 451                 public void TestWriteNullTagLiteral()
 452                 {
 453                         WriteNullTagLiteral("x");
 454                         Assert.AreEqual (XmlSerializerTests.Infoset("<x d1p1:nil='true' xmlns:d1p1='http://www.w3.org/2001/XMLSchema-instance' />"), XmlSerializerTests.Infoset(Content));
 455                 }
 456
 457                 [Test]
 458                 [Category ("MobileNotWorking")]
 459                 public void TestWritePotentiallyReferencingElement ()
 460                 {
 461                         XmlSerializarionWriterTester xsw = new XmlSerializarionWriterTester ();
 462                         xsw.Reset ();
 463
 464                         xsw.ExecuteWritePotentiallyReferencingElement ("x", ANamespace, EnumDefaultValue.e1, typeof (EnumDefaultValue), true, false);
 465                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
 466                                 "<x xmlns='{0}'>1</x>", ANamespace), xsw.Content, "#1");
 467
 468                         xsw.Reset ();
 469
 470                         xsw.ExecuteWritePotentiallyReferencingElement ("x", ANamespace, (int) 1, typeof (EnumDefaultValue), true, false);
 471                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
 472                                 "<x xmlns:q1='{0}' d1p1:type='q1:int' xmlns:d1p1='{1}' xmlns='{2}'>1</x>",
 473                                 XmlSchemaNamespace, XmlSchemaInstanceNamespace, ANamespace),
 474                                 xsw.Content, "#2");
 475
 476                         xsw.Reset ();
 477
 478                         xsw.ExecuteWritePotentiallyReferencingElement ("x", ANamespace, "something", typeof (string), true, false);
 479                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
 480                                 "<x xmlns='{0}'>something</x>", ANamespace), xsw.Content, "#3");
 481
 482                         xsw.Reset ();
 483
 484                         xsw.ExecuteWritePotentiallyReferencingElement ("x", ANamespace, "something", null, true, false);
 485                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
 486                                 "<x xmlns:q2='{0}' d1p1:type='q2:string' xmlns:d1p1='{1}' xmlns='{2}'>something</x>",
 487                                 XmlSchemaNamespace, XmlSchemaInstanceNamespace, ANamespace),
 488                                 xsw.Content, "#4");
 489
 490                         xsw.Reset ();
 491
 492                         xsw.ExecuteWritePotentiallyReferencingElement ("x", ANamespace, new string[] { "A", "B" }, typeof (string[]), true, false);
 493                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
 494                                 "<q3:Array id='id1' xmlns:q4='{0}' q3:arrayType='q4:string[2]' xmlns:q3='{1}'>" +
 495                                 "<Item>A</Item>" +
 496                                 "<Item>B</Item>" +
 497                                 "</q3:Array>", XmlSchemaNamespace, SoapEncodingNamespace), xsw.Content, "#5");
 498                 }
 499
 500                 [Test]
 501                 public void TestWriteStartDocument()
 502                 {
 503                         Assert.AreEqual ("", Content);
 504
 505                         WriteStartDocument();
 506                         Assert.AreEqual ("<?xml version='1.0' encoding='utf-16'?>", Content);
 507                 }
 508
 509                 [Test]
 510                 public void TestWriteStartElement()
 511                 {
 512                         WriteStartElement("x");
 513                         WriteEndElement();
 514                         Assert.AreEqual ("<x />", Content);
 515
 516                         Reset();
 517                         WriteStartElement("x");
 518                         WriteValue("a");
 519                         WriteEndElement();
 520                         Assert.AreEqual ("<x>a</x>", Content);
 521
 522                         Reset();
 523                         WriteStartElement("x");
 524                         WriteStartElement("y", "z");
 525                         WriteEndElement();
 526                         WriteEndElement();
 527                         Assert.AreEqual ("<x><y xmlns='z' /></x>", Content);
 528
 529                         Reset();
 530                         WriteStartElement("x");
 531                         WriteStartElement("y", "z", true);
 532                         WriteEndElement();
 533                         WriteEndElement();
 534                         Assert.AreEqual ("<x><q1:y xmlns:q1='z' /></x>", Content);
 535                 }
 536
 537                 [Test]
 538                 public void TestWriteTypedPrimitive_Base64Binary ()
 539                 {
 540                         byte[] byteArray = new byte[] { 255, 20, 10, 5, 0, 7 };
 541                         string expected = "/xQKBQAH";
 542
 543                         XmlSerializarionWriterTester xsw = new XmlSerializarionWriterTester ();
 544                         xsw.Reset ();
 545
 546                         xsw.ExecuteWriteTypedPrimitive ("x", ANamespace, byteArray, false);
 547                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
 548                                 "<x xmlns='{0}'>{1}</x>", ANamespace, expected),
 549                                 xsw.Content, "#1");
 550
 551                         xsw.Reset ();
 552
 553                         xsw.ExecuteWriteTypedPrimitive ("x", string.Empty, byteArray, false);
 554                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
 555                                 "<x>{0}</x>", expected), xsw.Content, "#2");
 556
 557                         xsw.Reset ();
 558
 559                         xsw.ExecuteWriteTypedPrimitive ("x", null, byteArray, false);
 560                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
 561                                 "<x>{0}</x>", expected), xsw.Content, "#3");
 562
 563                         xsw.Reset ();
 564
 565                         xsw.ExecuteWriteTypedPrimitive ("x", XmlSchemaNamespace, byteArray, false);
 566                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
 567                                 "<x xmlns='{0}'>{1}</x>", XmlSchemaNamespace, expected),
 568                                 xsw.Content, "#4");
 569
 570                         xsw.Reset ();
 571
 572                         xsw.ExecuteWriteTypedPrimitive ("x", XmlSchemaInstanceNamespace, byteArray, false);
 573                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
 574                                 "<x xmlns='{0}'>{1}</x>", XmlSchemaInstanceNamespace, expected),
 575                                 xsw.Content, "#5");
 576
 577                         xsw.Reset ();
 578
 579                         xsw.ExecuteWriteTypedPrimitive (string.Empty, ANamespace, byteArray, false);
 580                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
 581                                 "< xmlns='{0}'>{1}</>", ANamespace, expected), xsw.Content, "#6");
 582
 583                         xsw.Reset ();
 584
 585                         xsw.ExecuteWriteTypedPrimitive (null, ANamespace, byteArray, false);
 586                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
 587                                 "<base64Binary xmlns='{0}'>{1}</base64Binary>",
 588                                 XmlSchemaNamespace, expected), xsw.Content, "#7");
 589                 }
 590
 591                 [Test]
 592                 public void TestWriteTypedPrimitive_Base64Binary_XsiType ()
 593                 {
 594                         byte[] byteArray = new byte[] { 255, 20, 10, 5, 0, 7 };
 595                         string expected = "/xQKBQAH";
 596
 597                         XmlSerializarionWriterTester xsw = new XmlSerializarionWriterTester ();
 598                         xsw.Reset ();
 599
 600                         xsw.ExecuteWriteTypedPrimitive ("x", string.Empty, byteArray, true);
 601                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
 602                                 "<x xmlns:q1='{0}' d1p1:type='q1:base64Binary' xmlns:d1p1='{1}'>{2}</x>",
 603                                 XmlSchemaNamespace, XmlSchemaInstanceNamespace, expected),
 604                                 xsw.Content, "#1");
 605
 606                         xsw.Reset ();
 607
 608                         xsw.ExecuteWriteTypedPrimitive ("x", null, byteArray, true);
 609                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
 610                                 "<x xmlns:q2='{0}' d1p1:type='q2:base64Binary' xmlns:d1p1='{1}'>{2}</x>",
 611                                 XmlSchemaNamespace, XmlSchemaInstanceNamespace, expected),
 612                                 xsw.Content, "#2");
 613                 }
 614
 615                 [Test]
 616                 public void TestWriteTypedPrimitive_Boolean ()
 617                 {
 618                         XmlSerializarionWriterTester xsw = new XmlSerializarionWriterTester ();
 619                         xsw.Reset ();
 620
 621                         xsw.ExecuteWriteTypedPrimitive ("x", ANamespace, true, false);
 622                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
 623                                 "<x xmlns='{0}'>true</x>", ANamespace), xsw.Content, "#1");
 624
 625                         xsw.Reset ();
 626
 627                         xsw.ExecuteWriteTypedPrimitive ("x", string.Empty, false, false);
 628                         Assert.AreEqual ("<x>false</x>", xsw.Content, "#2");
 629
 630                         xsw.Reset ();
 631
 632                         xsw.ExecuteWriteTypedPrimitive ("x", null, true, false);
 633                         Assert.AreEqual ("<x>true</x>", xsw.Content, "#3");
 634
 635                         xsw.Reset ();
 636
 637                         xsw.ExecuteWriteTypedPrimitive ("x", XmlSchemaNamespace, false, false);
 638                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
 639                                 "<x xmlns='{0}'>false</x>", XmlSchemaNamespace), xsw.Content, "#4");
 640
 641                         xsw.Reset ();
 642
 643                         xsw.ExecuteWriteTypedPrimitive ("x", XmlSchemaInstanceNamespace, true, false);
 644                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
 645                                 "<x xmlns='{0}'>true</x>", XmlSchemaInstanceNamespace),
 646                                 xsw.Content, "#5");
 647
 648                         xsw.Reset ();
 649
 650                         xsw.ExecuteWriteTypedPrimitive (string.Empty, ANamespace, false, false);
 651                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
 652                                 "< xmlns='{0}'>false</>", ANamespace), xsw.Content, "#6");
 653
 654                         xsw.Reset ();
 655
 656                         xsw.ExecuteWriteTypedPrimitive (null, ANamespace, true, false);
 657                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
 658                                 "<boolean xmlns='{0}'>true</boolean>", XmlSchemaNamespace),
 659                                 xsw.Content, "#7");
 660                 }
 661
 662                 [Test]
 663                 public void TestWriteTypedPrimitive_Boolean_XsiType ()
 664                 {
 665                         XmlSerializarionWriterTester xsw = new XmlSerializarionWriterTester ();
 666                         xsw.Reset ();
 667
 668                         xsw.ExecuteWriteTypedPrimitive ("x", string.Empty, true, true);
 669                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
 670                                 "<x xmlns:q1='{0}' d1p1:type='q1:boolean' xmlns:d1p1='{1}'>true</x>",
 671                                 XmlSchemaNamespace, XmlSchemaInstanceNamespace),
 672                                 xsw.Content, "#1");
 673
 674                         xsw.Reset ();
 675
 676                         xsw.ExecuteWriteTypedPrimitive ("x", null, false, true);
 677                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
 678                                 "<x xmlns:q2='{0}' d1p1:type='q2:boolean' xmlns:d1p1='{1}'>false</x>",
 679                                 XmlSchemaNamespace, XmlSchemaInstanceNamespace),
 680                                 xsw.Content, "#2");
 681                 }
 682
 683                 [Test]
 684                 public void TestWriteTypedPrimitive_Char ()
 685                 {
 686                         XmlSerializarionWriterTester xsw = new XmlSerializarionWriterTester ();
 687                         xsw.Reset ();
 688
 689                         xsw.ExecuteWriteTypedPrimitive ("x", ANamespace, 'c', false);
 690                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
 691                                 "<x xmlns='{0}'>99</x>", ANamespace), xsw.Content, "#1");
 692
 693                         xsw.Reset ();
 694
 695                         xsw.ExecuteWriteTypedPrimitive ("x", string.Empty, 'a', false);
 696                         Assert.AreEqual ("<x>97</x>", xsw.Content, "#2");
 697
 698                         xsw.Reset ();
 699
 700                         xsw.ExecuteWriteTypedPrimitive ("x", null, 'b', false);
 701                         Assert.AreEqual ("<x>98</x>", xsw.Content, "#3");
 702
 703                         xsw.Reset ();
 704
 705                         xsw.ExecuteWriteTypedPrimitive ("x", XmlSchemaNamespace, 'd', false);
 706                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
 707                                 "<x xmlns='{0}'>100</x>", XmlSchemaNamespace), xsw.Content, "#4");
 708
 709                         xsw.Reset ();
 710
 711                         xsw.ExecuteWriteTypedPrimitive ("x", XmlSchemaInstanceNamespace, 'e', false);
 712                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
 713                                 "<x xmlns='{0}'>101</x>", XmlSchemaInstanceNamespace),
 714                                 xsw.Content, "#5");
 715
 716                         xsw.Reset ();
 717
 718                         xsw.ExecuteWriteTypedPrimitive (string.Empty, ANamespace, ' ', false);
 719                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
 720                                 "< xmlns='{0}'>32</>", ANamespace), xsw.Content, "#6");
 721
 722                         xsw.Reset ();
 723
 724                         xsw.ExecuteWriteTypedPrimitive (null, ANamespace, '0', false);
 725                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
 726                                 "<char xmlns='{0}'>48</char>", WsdlTypesNamespace),
 727                                 xsw.Content, "#7");
 728                 }
 729
 730                 [Test]
 731                 public void TestWriteTypedPrimitive_Char_XsiType ()
 732                 {
 733                         XmlSerializarionWriterTester xsw = new XmlSerializarionWriterTester ();
 734                         xsw.Reset ();
 735
 736                         xsw.ExecuteWriteTypedPrimitive ("x", string.Empty, 'c', true);
 737                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
 738                                 "<x xmlns:q1='{0}' d1p1:type='q1:char' xmlns:d1p1='{1}'>99</x>",
 739                                 WsdlTypesNamespace, XmlSchemaInstanceNamespace),
 740                                 xsw.Content, "#1");
 741
 742                         xsw.Reset ();
 743
 744                         xsw.ExecuteWriteTypedPrimitive ("x", null, 'a', true);
 745                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
 746                                 "<x xmlns:q2='{0}' d1p1:type='q2:char' xmlns:d1p1='{1}'>97</x>",
 747                                 WsdlTypesNamespace, XmlSchemaInstanceNamespace),
 748                                 xsw.Content, "#2");
 749                 }
 750
 751                 [Test]
 752                 public void TestWriteTypedPrimitive_DateTime ()
 753                 {
 754                         DateTime dateTime = new DateTime (1973, 08, 13);
 755
 756                         XmlSerializarionWriterTester xsw = new XmlSerializarionWriterTester ();
 757                         xsw.Reset ();
 758
 759                         xsw.ExecuteWriteTypedPrimitive ("x", ANamespace, dateTime, false);
 760                         // FIXME: This is a bad test case. The following switch
 761                         // should be applied to the entire test.
 762                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
 763                                 "<x xmlns='{0}'>1973-08-13T00:00:00</x>", ANamespace),
 764                                 xsw.Content, "#1");
 765                         xsw.Reset ();
 766
 767                         xsw.ExecuteWriteTypedPrimitive ("x", string.Empty, dateTime, false);
 768                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
 769                                 "<x>{0}</x>", FromDateTime (dateTime)), xsw.Content, "#2");
 770
 771                         xsw.Reset ();
 772
 773                         xsw.ExecuteWriteTypedPrimitive ("x", null, dateTime, false);
 774                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
 775                                 "<x>{0}</x>", FromDateTime (dateTime)), xsw.Content, "#3");
 776
 777                         xsw.Reset ();
 778
 779                         xsw.ExecuteWriteTypedPrimitive ("x", XmlSchemaNamespace, dateTime, false);
 780                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
 781                                 "<x xmlns='{0}'>{1}</x>", XmlSchemaNamespace,
 782                                 FromDateTime (dateTime)), xsw.Content, "#4");
 783
 784                         xsw.Reset ();
 785
 786                         xsw.ExecuteWriteTypedPrimitive ("x", XmlSchemaInstanceNamespace, dateTime, false);
 787                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
 788                                 "<x xmlns='{0}'>{1}</x>", XmlSchemaInstanceNamespace,
 789                                 FromDateTime (dateTime)), xsw.Content, "#5");
 790
 791                         xsw.Reset ();
 792
 793                         xsw.ExecuteWriteTypedPrimitive (string.Empty, ANamespace, dateTime, false);
 794                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
 795                                 "< xmlns='{0}'>{1}</>", ANamespace, FromDateTime (dateTime)),
 796                                 xsw.Content, "#6");
 797
 798                         xsw.Reset ();
 799
 800                         xsw.ExecuteWriteTypedPrimitive (null, ANamespace, dateTime, false);
 801                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
 802                                 "<dateTime xmlns='{0}'>{1}</dateTime>", XmlSchemaNamespace,
 803                                 FromDateTime (dateTime)), xsw.Content, "#7");
 804                 }
 805
 806                 // FIXME: This is a bad test case.
 807                 // See TestWriteTypedPrimitive_DateTime.
 808                 [Test]
 809                 public void TestWriteTypedPrimitive_DateTime_XsiType ()
 810                 {
 811                         DateTime dateTime = new DateTime (1973, 08, 13);
 812
 813                         XmlSerializarionWriterTester xsw = new XmlSerializarionWriterTester ();
 814                         xsw.Reset ();
 815
 816                         xsw.ExecuteWriteTypedPrimitive ("x", string.Empty, dateTime, true);
 817                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
 818                                 "<x xmlns:q1='{0}' d1p1:type='q1:dateTime' xmlns:d1p1='{1}'>{2}</x>",
 819                                 XmlSchemaNamespace, XmlSchemaInstanceNamespace,
 820                                 FromDateTime (dateTime)), xsw.Content, "#1");
 821
 822                         xsw.Reset ();
 823
 824                         xsw.ExecuteWriteTypedPrimitive ("x", null, dateTime, true);
 825                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
 826                                 "<x xmlns:q2='{0}' d1p1:type='q2:dateTime' xmlns:d1p1='{1}'>{2}</x>",
 827                                 XmlSchemaNamespace, XmlSchemaInstanceNamespace,
 828                                 FromDateTime (dateTime)), xsw.Content, "#2");
 829                 }
 830
 831                 [Test]
 832                 public void TestWriteTypedPrimitive_Enum ()
 833                 {
 834                         XmlSerializarionWriterTester xsw = new XmlSerializarionWriterTester ();
 835                         xsw.Reset ();
 836
 837                         xsw.ExecuteWriteTypedPrimitive ("x", ANamespace, EnumDefaultValue.e1, false);
 838                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
 839                                 "<x xmlns='{0}'>1</x>", ANamespace), xsw.Content, "#1");
 840
 841                         xsw.Reset ();
 842
 843                         xsw.ExecuteWriteTypedPrimitive ("x", string.Empty, EnumDefaultValue.e2, false);
 844                         Assert.AreEqual ("<x>2</x>", xsw.Content, "#2");
 845
 846                         xsw.Reset ();
 847
 848                         xsw.ExecuteWriteTypedPrimitive ("x", null, EnumDefaultValue.e3, false);
 849                         Assert.AreEqual ("<x>3</x>", xsw.Content, "#3");
 850
 851                         xsw.Reset ();
 852
 853                         xsw.ExecuteWriteTypedPrimitive ("x", XmlSchemaNamespace, EnumDefaultValue.e1, false);
 854                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
 855                                 "<x xmlns='{0}'>1</x>", XmlSchemaNamespace), xsw.Content, "#4");
 856
 857                         xsw.Reset ();
 858
 859                         xsw.ExecuteWriteTypedPrimitive ("x", XmlSchemaInstanceNamespace, EnumDefaultValue.e2, false);
 860                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
 861                                 "<x xmlns='{0}'>2</x>", XmlSchemaInstanceNamespace),
 862                                 xsw.Content, "#5");
 863
 864                         xsw.Reset ();
 865
 866                         xsw.ExecuteWriteTypedPrimitive (string.Empty, ANamespace, EnumDefaultValue.e3, false);
 867                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
 868                                 "< xmlns='{0}'>3</>", ANamespace), xsw.Content, "#6");
 869
 870                         xsw.Reset ();
 871
 872                         xsw.ExecuteWriteTypedPrimitive (null, ANamespace, EnumDefaultValue.e2, false);
 873                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
 874                                 "<int xmlns='{0}'>2</int>", XmlSchemaNamespace),
 875                                 xsw.Content, "#7");
 876                 }
 877
 878                 [Test]
 879                 public void TestWriteTypedPrimitive_Enum_XsiType ()
 880                 {
 881                         XmlSerializarionWriterTester xsw = new XmlSerializarionWriterTester ();
 882                         xsw.Reset ();
 883
 884                         xsw.ExecuteWriteTypedPrimitive ("x", string.Empty, EnumDefaultValue.e1, true);
 885                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
 886                                 "<x xmlns:q1='{0}' d1p1:type='q1:int' xmlns:d1p1='{1}'>1</x>",
 887                                 XmlSchemaNamespace, XmlSchemaInstanceNamespace),
 888                                 xsw.Content, "#1");
 889
 890                         xsw.Reset ();
 891
 892                         xsw.ExecuteWriteTypedPrimitive ("x", null, EnumDefaultValue.e2, true);
 893                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
 894                                 "<x xmlns:q2='{0}' d1p1:type='q2:int' xmlns:d1p1='{1}'>2</x>",
 895                                 XmlSchemaNamespace, XmlSchemaInstanceNamespace),
 896                                 xsw.Content, "#2");
 897                 }
 898
 899                 [Test]
 900                 public void TestWriteTypedPrimitive_Guid ()
 901                 {
 902                         Guid guid = new Guid ("CA761232-ED42-11CE-BACD-00AA0057B223");
 903                         string expectedGuid = "ca761232-ed42-11ce-bacd-00aa0057b223";
 904
 905                         XmlSerializarionWriterTester xsw = new XmlSerializarionWriterTester ();
 906                         xsw.Reset ();
 907
 908                         xsw.ExecuteWriteTypedPrimitive ("x", ANamespace, guid, false);
 909                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
 910                                 "<x xmlns='{0}'>{1}</x>", ANamespace, expectedGuid),
 911                                 xsw.Content, "#1");
 912
 913                         xsw.Reset ();
 914
 915                         xsw.ExecuteWriteTypedPrimitive ("x", string.Empty, guid, false);
 916                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
 917                                 "<x>{0}</x>", expectedGuid), xsw.Content, "#2");
 918
 919                         xsw.Reset ();
 920
 921                         xsw.ExecuteWriteTypedPrimitive ("x", null, guid, false);
 922                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
 923                                 "<x>{0}</x>", expectedGuid), xsw.Content, "#3");
 924
 925                         xsw.Reset ();
 926
 927                         xsw.ExecuteWriteTypedPrimitive ("x", XmlSchemaNamespace, guid, false);
 928                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
 929                                 "<x xmlns='{0}'>{1}</x>", XmlSchemaNamespace, expectedGuid),
 930                                 xsw.Content, "#4");
 931
 932                         xsw.Reset ();
 933
 934                         xsw.ExecuteWriteTypedPrimitive ("x", XmlSchemaInstanceNamespace, guid, false);
 935                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
 936                                 "<x xmlns='{0}'>{1}</x>", XmlSchemaInstanceNamespace, expectedGuid),
 937                                 xsw.Content, "#5");
 938
 939                         xsw.Reset ();
 940
 941                         xsw.ExecuteWriteTypedPrimitive (string.Empty, ANamespace, guid, false);
 942                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
 943                                 "< xmlns='{0}'>{1}</>", ANamespace, expectedGuid),
 944                                 xsw.Content, "#6");
 945
 946                         xsw.Reset ();
 947
 948                         xsw.ExecuteWriteTypedPrimitive (null, ANamespace, guid, false);
 949                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
 950                                 "<guid xmlns='{0}'>{1}</guid>", WsdlTypesNamespace,
 951                                 expectedGuid), xsw.Content, "#7");
 952                 }
 953
 954                 [Test]
 955                 public void TestWriteTypedPrimitive_Guid_XsiType ()
 956                 {
 957                         Guid guid = new Guid ("CA761232-ED42-11CE-BACD-00AA0057B223");
 958                         string expectedGuid = "ca761232-ed42-11ce-bacd-00aa0057b223";
 959
 960                         XmlSerializarionWriterTester xsw = new XmlSerializarionWriterTester ();
 961                         xsw.Reset ();
 962
 963                         xsw.ExecuteWriteTypedPrimitive ("x", string.Empty, guid, true);
 964                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
 965                                 "<x xmlns:q1='{0}' d1p1:type='q1:guid' xmlns:d1p1='{1}'>{2}</x>",
 966                                 WsdlTypesNamespace, XmlSchemaInstanceNamespace, expectedGuid),
 967                                 xsw.Content, "#1");
 968
 969                         xsw.Reset ();
 970
 971                         xsw.ExecuteWriteTypedPrimitive ("x", null, guid, true);
 972                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
 973                                 "<x xmlns:q2='{0}' d1p1:type='q2:guid' xmlns:d1p1='{1}'>{2}</x>",
 974                                 WsdlTypesNamespace, XmlSchemaInstanceNamespace, expectedGuid),
 975                                 xsw.Content, "#2");
 976                 }
 977
 978                 [Test]
 979                 public void TestWriteTypedPrimitive_Int ()
 980                 {
 981                         XmlSerializarionWriterTester xsw = new XmlSerializarionWriterTester ();
 982                         xsw.Reset ();
 983
 984                         xsw.ExecuteWriteTypedPrimitive ("x", ANamespace, 76665, false);
 985                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
 986                                 "<x xmlns='{0}'>76665</x>", ANamespace), xsw.Content, "#1");
 987
 988                         xsw.Reset ();
 989
 990                         xsw.ExecuteWriteTypedPrimitive ("x", string.Empty, -5656, false);
 991                         Assert.AreEqual ("<x>-5656</x>", xsw.Content, "#2");
 992
 993                         xsw.Reset ();
 994
 995                         xsw.ExecuteWriteTypedPrimitive ("x", null, 0, false);
 996                         Assert.AreEqual ("<x>0</x>", xsw.Content, "#3");
 997
 998                         xsw.Reset ();
 999
1000                         xsw.ExecuteWriteTypedPrimitive ("x", XmlSchemaNamespace, 534, false);
1001                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
1002                                 "<x xmlns='{0}'>534</x>", XmlSchemaNamespace), xsw.Content, "#4");
1003
1004                         xsw.Reset ();
1005
1006                         xsw.ExecuteWriteTypedPrimitive ("x", XmlSchemaInstanceNamespace, -6756, false);
1007                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
1008                                 "<x xmlns='{0}'>-6756</x>", XmlSchemaInstanceNamespace),
1009                                 xsw.Content, "#5");
1010
1011                         xsw.Reset ();
1012
1013                         xsw.ExecuteWriteTypedPrimitive (string.Empty, ANamespace, 434, false);
1014                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
1015                                 "< xmlns='{0}'>434</>", ANamespace), xsw.Content, "#6");
1016
1017                         xsw.Reset ();
1018
1019                         xsw.ExecuteWriteTypedPrimitive (null, ANamespace, 434, false);
1020                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
1021                                 "<int xmlns='{0}'>434</int>", XmlSchemaNamespace),
1022                                 xsw.Content, "#7");
1023                 }
1024
1025                 [Test]
1026                 public void TestWriteTypedPrimitive_Int_XsiType ()
1027                 {
1028                         XmlSerializarionWriterTester xsw = new XmlSerializarionWriterTester ();
1029                         xsw.Reset ();
1030
1031                         xsw.ExecuteWriteTypedPrimitive ("x", string.Empty, -6756, true);
1032                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
1033                                 "<x xmlns:q1='{0}' d1p1:type='q1:int' xmlns:d1p1='{1}'>-6756</x>",
1034                                 XmlSchemaNamespace, XmlSchemaInstanceNamespace),
1035                                 xsw.Content, "#1");
1036
1037                         xsw.Reset ();
1038
1039                         xsw.ExecuteWriteTypedPrimitive ("x", null, 434, true);
1040                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
1041                                 "<x xmlns:q2='{0}' d1p1:type='q2:int' xmlns:d1p1='{1}'>434</x>",
1042                                 XmlSchemaNamespace, XmlSchemaInstanceNamespace),
1043                                 xsw.Content, "#2");
1044                 }
1045
1046                 [Test]
1047                 public void TestWriteTypedPrimitive_String ()
1048                 {
1049                         XmlSerializarionWriterTester xsw = new XmlSerializarionWriterTester ();
1050                         xsw.Reset ();
1051
1052                         xsw.ExecuteWriteTypedPrimitive ("x", ANamespace, "hello", false);
1053                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
1054                                 "<x xmlns='{0}'>hello</x>", ANamespace), xsw.Content, "#1");
1055
1056                         xsw.Reset ();
1057
1058                         xsw.ExecuteWriteTypedPrimitive ("x", string.Empty, "hello", false);
1059                         Assert.AreEqual ("<x>hello</x>", xsw.Content, "#2");
1060
1061                         xsw.Reset ();
1062
1063                         xsw.ExecuteWriteTypedPrimitive ("x", null, "hello", false);
1064                         Assert.AreEqual ("<x>hello</x>", xsw.Content, "#3");
1065
1066                         xsw.Reset ();
1067
1068                         xsw.ExecuteWriteTypedPrimitive ("x", XmlSchemaNamespace, "hello", false);
1069                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
1070                                 "<x xmlns='{0}'>hello</x>", XmlSchemaNamespace),
1071                                 xsw.Content, "#4");
1072
1073                         xsw.Reset ();
1074
1075                         xsw.ExecuteWriteTypedPrimitive ("x", XmlSchemaInstanceNamespace, "hello", false);
1076                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
1077                                 "<x xmlns='{0}'>hello</x>", XmlSchemaInstanceNamespace),
1078                                 xsw.Content, "#5");
1079
1080                         xsw.Reset ();
1081
1082                         xsw.ExecuteWriteTypedPrimitive ("x", ANamespace, string.Empty, false);
1083                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
1084                                 "<x xmlns='{0}' />", ANamespace), xsw.Content, "#6");
1085
1086                         xsw.Reset ();
1087
1088                         xsw.ExecuteWriteTypedPrimitive (string.Empty, ANamespace, "<\"te'st\">", false);
1089                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
1090                                 "< xmlns='{0}'>&lt;\"te'st\"&gt;</>", ANamespace),
1091                                 xsw.Content, "#7");
1092
1093                         xsw.Reset ();
1094
1095                         xsw.ExecuteWriteTypedPrimitive (null, ANamespace, "hello", false);
1096                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
1097                                 "<string xmlns='{0}'>hello</string>", XmlSchemaNamespace),
1098                                 xsw.Content, "#8");
1099                 }
1100
1101                 [Test]
1102                 public void TestWriteTypedPrimitive_String_XsiType ()
1103                 {
1104                         XmlSerializarionWriterTester xsw = new XmlSerializarionWriterTester ();
1105                         xsw.Reset ();
1106
1107                         xsw.ExecuteWriteTypedPrimitive ("x", string.Empty, "hello", true);
1108                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
1109                                 "<x xmlns:q1='{0}' d1p1:type='q1:string' xmlns:d1p1='{1}'>hello</x>",
1110                                 XmlSchemaNamespace, XmlSchemaInstanceNamespace),
1111                                 xsw.Content, "#1");
1112
1113                         xsw.Reset ();
1114
1115                         xsw.ExecuteWriteTypedPrimitive ("x", null, "hello", true);
1116                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
1117                                 "<x xmlns:q2='{0}' d1p1:type='q2:string' xmlns:d1p1='{1}'>hello</x>",
1118                                 XmlSchemaNamespace, XmlSchemaInstanceNamespace),
1119                                 xsw.Content, "#2");
1120                 }
1121
1122                 [Test]
1123                 public void TestWriteTypedPrimitive_String_XsiType_Namespace ()
1124                 {
1125                         XmlSerializarionWriterTester xsw = new XmlSerializarionWriterTester ();
1126                         xsw.Reset ();
1127
1128                         xsw.ExecuteWriteTypedPrimitive ("x", ANamespace, "hello", true);
1129                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
1130                                 "<x xmlns:q1='{0}' d1p1:type='q1:string' xmlns:d1p1='{1}' xmlns='{2}'>hello</x>",
1131                                 XmlSchemaNamespace, XmlSchemaInstanceNamespace, ANamespace),
1132                                 xsw.Content, "#1");
1133
1134                         xsw.Reset ();
1135
1136                         xsw.ExecuteWriteTypedPrimitive ("x", XmlSchemaNamespace, "hello", true);
1137                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
1138                                 "<x d1p1:type='string' xmlns:d1p1='{0}' xmlns='{1}'>hello</x>",
1139                                 XmlSchemaInstanceNamespace, XmlSchemaNamespace),
1140                                 xsw.Content, "#2");
1141
1142                         xsw.Reset ();
1143
1144                         xsw.ExecuteWriteTypedPrimitive ("x", XmlSchemaInstanceNamespace, "hello", true);
1145                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
1146                                 "<x xmlns:q2='{0}' d1p1:type='q2:string' xmlns:d1p1='{1}' xmlns='{1}'>hello</x>",
1147                                 XmlSchemaNamespace, XmlSchemaInstanceNamespace), xsw.Content, "#3");
1148
1149                         xsw.Reset ();
1150
1151                         xsw.ExecuteWriteTypedPrimitive ("x", ANamespace, string.Empty, true);
1152                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
1153                                 "<x xmlns:q3='{0}' d1p1:type='q3:string' xmlns:d1p1='{1}' xmlns='{2}' />",
1154                                 XmlSchemaNamespace, XmlSchemaInstanceNamespace, ANamespace),
1155                                 xsw.Content, "#4");
1156
1157                         xsw.Reset ();
1158
1159                         xsw.ExecuteWriteTypedPrimitive (string.Empty, ANamespace, "<\"te'st\">", true);
1160                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
1161                                 "< xmlns:q4='{0}' d1p1:type='q4:string' xmlns:d1p1='{1}' xmlns='{2}'>&lt;\"te'st\"&gt;</>",
1162                                 XmlSchemaNamespace, XmlSchemaInstanceNamespace, ANamespace),
1163                                 xsw.Content, "#5");
1164
1165                         xsw.Reset ();
1166
1167                         xsw.ExecuteWriteTypedPrimitive (null, ANamespace, "hello", true);
1168                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
1169                                 "<string d1p1:type='string' xmlns:d1p1='{0}' xmlns='{1}'>hello</string>",
1170                                 XmlSchemaInstanceNamespace, XmlSchemaNamespace),
1171                                 xsw.Content, "#6");
1172                 }
1173
1174                 [Test]
1175                 public void TestWriteTypedPrimitive_UnsignedByte ()
1176                 {
1177                         XmlSerializarionWriterTester xsw = new XmlSerializarionWriterTester ();
1178                         xsw.Reset ();
1179
1180                         xsw.ExecuteWriteTypedPrimitive ("x", ANamespace, (byte) 5, false);
1181                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
1182                                 "<x xmlns='{0}'>5</x>", ANamespace), xsw.Content, "#1");
1183
1184                         xsw.Reset ();
1185
1186                         xsw.ExecuteWriteTypedPrimitive ("x", string.Empty, (byte) 125, false);
1187                         Assert.AreEqual ("<x>125</x>", xsw.Content, "#2");
1188
1189                         xsw.Reset ();
1190
1191                         xsw.ExecuteWriteTypedPrimitive ("x", null, (byte) 0, false);
1192                         Assert.AreEqual ("<x>0</x>", xsw.Content, "#3");
1193
1194                         xsw.Reset ();
1195
1196                         xsw.ExecuteWriteTypedPrimitive ("x", XmlSchemaNamespace, (byte) 255, false);
1197                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
1198                                 "<x xmlns='{0}'>255</x>", XmlSchemaNamespace), xsw.Content, "#4");
1199
1200                         xsw.Reset ();
1201
1202                         xsw.ExecuteWriteTypedPrimitive ("x", XmlSchemaInstanceNamespace, (byte) 128, false);
1203                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
1204                                 "<x xmlns='{0}'>128</x>", XmlSchemaInstanceNamespace),
1205                                 xsw.Content, "#5");
1206
1207                         xsw.Reset ();
1208
1209                         xsw.ExecuteWriteTypedPrimitive (string.Empty, ANamespace, (byte) 1, false);
1210                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
1211                                 "< xmlns='{0}'>1</>", ANamespace), xsw.Content, "#6");
1212
1213                         xsw.Reset ();
1214
1215                         xsw.ExecuteWriteTypedPrimitive (null, ANamespace, (byte) 99, false);
1216                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
1217                                 "<unsignedByte xmlns='{0}'>99</unsignedByte>",
1218                                 XmlSchemaNamespace), xsw.Content, "#7");
1219                 }
1220
1221                 [Test]
1222                 public void TestWriteTypedPrimitive_UnsignedByte_XsiType ()
1223                 {
1224                         XmlSerializarionWriterTester xsw = new XmlSerializarionWriterTester ();
1225                         xsw.Reset ();
1226
1227                         xsw.ExecuteWriteTypedPrimitive ("x", string.Empty, (byte) 5, true);
1228                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
1229                                 "<x xmlns:q1='{0}' d1p1:type='q1:unsignedByte' xmlns:d1p1='{1}'>5</x>",
1230                                 XmlSchemaNamespace, XmlSchemaInstanceNamespace),
1231                                 xsw.Content, "#1");
1232
1233                         xsw.Reset ();
1234
1235                         xsw.ExecuteWriteTypedPrimitive ("x", null, (byte) 99, true);
1236                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
1237                                 "<x xmlns:q2='{0}' d1p1:type='q2:unsignedByte' xmlns:d1p1='{1}'>99</x>",
1238                                 XmlSchemaNamespace, XmlSchemaInstanceNamespace),
1239                                 xsw.Content, "#2");
1240                 }
1241
1242                 [Test]
1243                 public void TestWriteTypedPrimitive_XmlQualifiedName ()
1244                 {
1245                         XmlQualifiedName qname = new XmlQualifiedName ("something", AnotherNamespace);
1246
1247                         XmlSerializarionWriterTester xsw = new XmlSerializarionWriterTester ();
1248                         xsw.Reset ();
1249
1250                         xsw.ExecuteWriteTypedPrimitive ("x", ANamespace, qname, false);
1251                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
1252                                 "<x xmlns:q1='{0}' xmlns='{1}'>q1:something</x>",
1253                                 AnotherNamespace, ANamespace), xsw.Content, "#A1");
1254
1255                         xsw.Reset ();
1256
1257                         xsw.ExecuteWriteTypedPrimitive ("x", string.Empty, qname, false);
1258                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
1259                                 "<x xmlns:q2='{0}'>q2:something</x>",
1260                                 AnotherNamespace), xsw.Content, "#A2");
1261
1262                         xsw.Reset ();
1263
1264                         xsw.ExecuteWriteTypedPrimitive ("x", null, qname, false);
1265                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
1266                                 "<x xmlns:q3='{0}'>q3:something</x>", AnotherNamespace),
1267                                 xsw.Content, "#A3");
1268
1269                         xsw.Reset ();
1270
1271                         xsw.ExecuteWriteTypedPrimitive ("x", XmlSchemaNamespace, qname, false);
1272                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
1273                                 "<x xmlns:q4='{0}' xmlns='{1}'>q4:something</x>", AnotherNamespace,
1274                                 XmlSchemaNamespace), xsw.Content, "#A4");
1275
1276                         xsw.Reset ();
1277
1278                         xsw.ExecuteWriteTypedPrimitive ("x", XmlSchemaInstanceNamespace, qname, false);
1279                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
1280                                 "<x xmlns:q5='{0}' xmlns='{1}'>q5:something</x>", AnotherNamespace,
1281                                 XmlSchemaInstanceNamespace), xsw.Content, "#A5");
1282
1283                         xsw.Reset ();
1284
1285                         xsw.ExecuteWriteTypedPrimitive (string.Empty, ANamespace, qname, false);
1286                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
1287                                 "< xmlns:q6='{0}' xmlns='{1}'>q6:something</>", AnotherNamespace,
1288                                 ANamespace), xsw.Content, "#A6");
1289
1290                         xsw.Reset ();
1291
1292                         xsw.ExecuteWriteTypedPrimitive (null, ANamespace, qname, false);
1293                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
1294                                 "<QName xmlns:q7='{0}' xmlns='{1}'>q7:something</QName>",
1295                                 AnotherNamespace, XmlSchemaNamespace), xsw.Content, "#A7");
1296
1297                         xsw.Reset ();
1298
1299                         qname = new XmlQualifiedName ("else");
1300
1301                         xsw.ExecuteWriteTypedPrimitive ("x", ANamespace, qname, false);
1302                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
1303                                 "<x xmlns='{0}'>else</x>", ANamespace), xsw.Content, "#B1");
1304
1305                         xsw.Reset ();
1306
1307                         xsw.ExecuteWriteTypedPrimitive ("x", string.Empty, qname, false);
1308                         Assert.AreEqual ("<x>else</x>", xsw.Content, "#B2");
1309
1310                         xsw.Reset ();
1311
1312                         xsw.ExecuteWriteTypedPrimitive ("x", null, qname, false);
1313                         Assert.AreEqual ("<x>else</x>", xsw.Content, "#B3");
1314
1315                         xsw.Reset ();
1316
1317                         xsw.ExecuteWriteTypedPrimitive ("x", XmlSchemaNamespace, qname, false);
1318                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
1319                                 "<x xmlns='{0}'>else</x>", XmlSchemaNamespace), xsw.Content, "#B4");
1320
1321                         xsw.Reset ();
1322
1323                         xsw.ExecuteWriteTypedPrimitive ("x", XmlSchemaInstanceNamespace, qname, false);
1324                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
1325                                 "<x xmlns='{0}'>else</x>", XmlSchemaInstanceNamespace),
1326                                 xsw.Content, "#B5");
1327
1328                         xsw.Reset ();
1329
1330                         xsw.ExecuteWriteTypedPrimitive (string.Empty, ANamespace, qname, false);
1331                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
1332                                 "< xmlns='{0}'>else</>", ANamespace), xsw.Content, "#B6");
1333
1334                         xsw.Reset ();
1335
1336                         xsw.ExecuteWriteTypedPrimitive (null, ANamespace, qname, false);
1337                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
1338                                 "<QName xmlns='{0}'>else</QName>", XmlSchemaNamespace),
1339                                 xsw.Content, "#B7");
1340                 }
1341
1342                 [Test]
1343                 [ExpectedException (typeof (NullReferenceException))]
1344                 public void TestWriteTypedPrimitive_Null_Value()
1345                 {
1346                         WriteTypedPrimitive("x", ANamespace, null, false);
1347                 }
1348
1349                 [Test]
1350                 [ExpectedException (typeof (InvalidOperationException))]
1351                 public void TestWriteTypedPrimitive_NonPrimitive ()
1352                 {
1353                         // The type System.Version was not expected. Use the XmlInclude
1354                         // or SoapInclude attribute to specify types that are not known
1355                         // statically.
1356                         WriteTypedPrimitive ("x", ANamespace, new Version (), false);
1357                 }
1358
1359                 [Test]
1360                 [ExpectedException (typeof (InvalidOperationException))]
1361                 public void TestWriteTypedPrimitive_XmlNode ()
1362                 {
1363                         WriteTypedPrimitive ("x", ANamespace, new XmlDocument ().CreateElement ("foo"), false);
1364                 }
1365
1366                 [Test]
1367                 public void TestWriteValue()
1368                 {
1369                         WriteValue("");
1370                         Assert.AreEqual ("", Content);
1371
1372                         Reset();
1373                         WriteValue("hello");
1374                         Assert.AreEqual ("hello", Content);
1375
1376                         Reset();
1377                         string v = null;
1378                         WriteValue(v);
1379                         Assert.AreEqual ("", Content);
1380
1381                         Reset();
1382                         WriteValue(new byte[] {13, 8, 99});
1383                         Assert.AreEqual ("DQhj", Content);
1384                 }
1385
1386                 public void TestWriteXmlAttribute()
1387                 {
1388                         // FIXME
1389                         // XmlNode related
1390                 }
1391
1392                 [Test]
1393                 public void TestWriteXsiType()
1394                 {
1395                         WriteStartElement("x");
1396                         WriteXsiType("pref", null);
1397                         WriteEndElement();
1398                         Assert.AreEqual (string.Format(CultureInfo.InvariantCulture,
1399                                 "<x d1p1:type='pref' xmlns:d1p1='{0}' />", XmlSchemaInstanceNamespace),
1400                                 Content, "#1");
1401
1402                         Reset ();
1403
1404                         WriteStartElement ("x");
1405                         WriteXsiType ("int", XmlSchemaNamespace);
1406                         WriteEndElement ();
1407                         Assert.AreEqual (string.Format(CultureInfo.InvariantCulture,
1408                                 "<x xmlns:q2='{0}' d1p1:type='q2:int' xmlns:d1p1='{1}' />",
1409                                 XmlSchemaNamespace, XmlSchemaInstanceNamespace),
1410                                 Content, "#2");
1411
1412                         Reset ();
1413
1414                         WriteStartElement ("x");
1415                         WriteXsiType ("int", ANamespace);
1416                         WriteEndElement ();
1417                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
1418                                 "<x xmlns:q3='{0}' d1p1:type='q3:int' xmlns:d1p1='{1}' />",
1419                                 ANamespace, XmlSchemaInstanceNamespace), Content, "#3");
1420
1421                         Reset ();
1422
1423                         WriteStartElement ("x");
1424                         WriteXsiType ("int", XmlSchemaInstanceNamespace);
1425                         WriteEndElement ();
1426                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
1427                                 "<x xmlns:q4='{0}' q4:type='q4:int' />",
1428                                 XmlSchemaInstanceNamespace), Content, "#4");
1429
1430                         Reset ();
1431
1432                         WriteStartElement ("x");
1433                         WriteXsiType ("int", string.Empty);
1434                         WriteEndElement ();
1435                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
1436                                 "<x d1p1:type='int' xmlns:d1p1='{0}' />", XmlSchemaInstanceNamespace),
1437                                 Content, "#5");
1438
1439                         Reset ();
1440
1441                         WriteStartElement ("x");
1442                         WriteXsiType (string.Empty, null);
1443                         WriteEndElement ();
1444                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
1445                                 "<x d1p1:type='' xmlns:d1p1='{0}' />", XmlSchemaInstanceNamespace),
1446                                 Content, "#6");
1447
1448                         Reset ();
1449
1450                         WriteStartElement ("x");
1451                         WriteXsiType (null, null);
1452                         WriteEndElement ();
1453                         Assert.AreEqual ("<x />", Content, "#7");
1454                 }
1455
1456                 [Test]
1457                 public void TestWriteXsiType_Namespace ()
1458                 {
1459                         WriteStartElement ("x", ANamespace);
1460                         WriteXsiType ("pref", null);
1461                         WriteEndElement ();
1462                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
1463                                 "<x d1p1:type='pref' xmlns:d1p1='{0}' xmlns='{1}' />",
1464                                 XmlSchemaInstanceNamespace, ANamespace), Content, "#1");
1465
1466                         Reset ();
1467
1468                         WriteStartElement ("x", ANamespace);
1469                         WriteXsiType ("int", XmlSchemaNamespace);
1470                         WriteEndElement ();
1471                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
1472                                 "<x xmlns:q5='{0}' d1p1:type='q5:int' xmlns:d1p1='{1}' xmlns='{2}' />",
1473                                 XmlSchemaNamespace, XmlSchemaInstanceNamespace, ANamespace),
1474                                 Content, "#2");
1475
1476                         Reset ();
1477
1478                         WriteStartElement ("x", ANamespace);
1479                         WriteXsiType ("int", ANamespace);
1480                         WriteEndElement ();
1481                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
1482                                 "<x d1p1:type='int' xmlns:d1p1='{1}' xmlns='{2}' />",
1483                                 ANamespace, XmlSchemaInstanceNamespace, ANamespace),
1484                                 Content, "#3");
1485
1486                         Reset ();
1487
1488                         WriteStartElement ("x", ANamespace);
1489                         WriteXsiType ("int", XmlSchemaInstanceNamespace);
1490                         WriteEndElement ();
1491                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
1492                                 "<x xmlns:q6='{0}' q6:type='q6:int' xmlns='{1}' />",
1493                                 XmlSchemaInstanceNamespace, ANamespace), Content, "#4");
1494
1495                         Reset ();
1496
1497                         WriteStartElement ("x", ANamespace);
1498                         WriteXsiType ("int", string.Empty);
1499                         WriteEndElement ();
1500                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
1501                                 "<x d1p1:type='int' xmlns:d1p1='{0}' xmlns='{1}' />",
1502                                 XmlSchemaInstanceNamespace, ANamespace), Content, "#5");
1503
1504                         Reset ();
1505
1506                         WriteStartElement ("x", ANamespace);
1507                         WriteXsiType (string.Empty, null);
1508                         WriteEndElement ();
1509                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
1510                                 "<x d1p1:type='' xmlns:d1p1='{0}' xmlns='{1}' />",
1511                                 XmlSchemaInstanceNamespace, ANamespace), Content, "#6");
1512
1513                         Reset ();
1514
1515                         WriteStartElement ("x", ANamespace);
1516                         WriteXsiType (null, null);
1517                         WriteEndElement ();
1518                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
1519                                 "<x xmlns='{0}' />", ANamespace), Content, "#7");
1520                 }
1521
1522
1523                 [Test]
1524                 public void TestFromEnum_Null_TypeName ()
1525                 {
1526                         string[] values = { "one", "two", "three", "four" };
1527                         long[] ids = { 1, 2, 3, 4 };
1528
1529                         Assert.AreEqual ("one", FromEnum (1, values, ids, (string) null));
1530                 }
1531
1532                 [Test]
1533                 public void TestCreateInvalidEnumValueException ()
1534                 {
1535                         Exception ex = CreateInvalidEnumValueException("AnInvalidValue", "SomeType");
1536                         Assert.IsNotNull (ex, "#1");
1537                         Assert.AreEqual (typeof (InvalidOperationException), ex.GetType (), "#2");
1538                         Assert.IsNotNull (ex.Message, "#3");
1539                         Assert.IsTrue (ex.Message.IndexOf ("AnInvalidValue") != -1, "#4");
1540                         Assert.IsTrue (ex.Message.IndexOf ("SomeType") != -1, "#5");
1541                 }
1542
1543                 [Test]
1544                 public void WriteCharacter ()
1545                 {
1546                         // mostly from bug #673019
1547                         var SerializerObj = new XmlSerializer (typeof (ToBeSerialized));
1548                         StringWriter writer = new StringWriter ();
1549                         SerializerObj.Serialize (writer, new ToBeSerialized ());
1550                         Assert.IsTrue (writer.ToString ().IndexOf ("<character>39</character>") > 0, "#1");
1551                 }
1552
1553                 [Serializable]
1554                 public class ToBeSerialized
1555                 {
1556                         [global::System.ComponentModel.DefaultValue ('a')]
1557                         public char character = '\'';
1558                 }
1559
1560                 [Test]
1561                 [Category ("MobileNotWorking")]
1562                 public void TestNullableDatesAndTimes ()
1563                 {
1564                         DateTime dt = new DateTime (2012, 1, 3, 10, 0, 0, 0, DateTimeKind.Utc);
1565
1566                         var d = new NullableDatesAndTimes () {
1567                                 MyTime = dt,
1568                                 MyTimeNullable = dt,
1569                                 MyDate = dt,
1570                                 MyDateNullable = dt
1571                         };
1572
1573                         XmlSerializer ser = new XmlSerializer (d.GetType ());
1574                         StringWriter sw = new StringWriter ();
1575                         ser.Serialize (sw, d);
1576                         string str = sw.ToString ();
1577
1578                         str = RemoveTZ (str, "MyTime");
1579                         str = RemoveTZ (str, "MyTimeNullable");
1580
1581                         var expected =
1582 "<?xml version=\"1.0\" encoding=\"utf-16\"?>" + Environment.NewLine +
1583 "<root xmlns:xsd=\"http://www.w3.org/2001/XMLSchema\" xmlns:xsi=\"http://www.w3.org/2001/XMLSchema-instance\">" + Environment.NewLine +
1584 "  <MyTime>10:00:00.0000000$TZ$</MyTime>" + Environment.NewLine +
1585 "  <MyTimeNullable>10:00:00.0000000$TZ$</MyTimeNullable>" + Environment.NewLine +
1586 "  <MyDate>2012-01-03</MyDate>" + Environment.NewLine +
1587 "  <MyDateNullable>2012-01-03</MyDateNullable>" + Environment.NewLine +
1588 "</root>";
1589
1590                         Assert.AreEqual (expected, str);
1591                 }
1592
1593                 static string RemoveTZ (string str, string tag)
1594                 {
1595                         var st = str.IndexOf ("<" + tag + ">");
1596                         var et = str.IndexOf ("</" + tag + ">");
1597                         if (st < 0 || et < 0)
1598                                 return str;
1599
1600                         var     start = str.IndexOfAny (new [] { '+', '-' }, st, et - st);
1601                         return str.Substring (0, start) + "$TZ$" + str.Substring (et, str.Length - et);
1602                 }
1603         }
1604 }