mcs/class/System.XML/Test/System.Xml/XmlWriterTests.cs

   1 //\r
   2 // System.Xml.XmlTextWriterTests\r
   3 //\r
   4 // Authors:\r
   5 //   Atsushi Enomoto <ginga@kit.hi-ho.ne.jp>\r
   6 //   Martin Willemoes Hansen <mwh@sysrq.dk>\r
   7 //\r
   8 // (C) 2003 Atsushi Enomoto\r
   9 // (C) 2003 Martin Willemoes Hansen\r
  10 //\r
  11 //\r
  12 //  This class mainly checks inheritance and behaviors of XmlWriter.\r
  13 //\r
  14 \r
  15 using System;\r
  16 using System.IO;\r
  17 using System.Text;\r
  18 using System.Xml;\r
  19 using System.Xml.XPath;\r
  20 \r
  21 using NUnit.Framework;\r
  22 \r
  23 using AssertType = NUnit.Framework.Assert;\r
  24 \r
  25 namespace MonoTests.System.Xml\r
  26 {\r
  27         [TestFixture]\r
  28         public class XmlWriterTests\r
  29         {\r
  30                 StringWriter writer;\r
  31                 XmlTextWriter xtw;\r
  32 \r
  33                 [SetUp]\r
  34                 public void SetUp ()\r
  35                 {\r
  36                         writer = new StringWriter ();\r
  37                         xtw = new XmlTextWriter (writer);\r
  38                 }\r
  39 \r
  40                 [Test]\r
  41                 public void WriteNodeFullDocument ()\r
  42                 {\r
  43                         string xml = "<?xml version='1.0'?><root />";\r
  44                         XmlTextReader xtr = new XmlTextReader (xml, XmlNodeType.Document, null);\r
  45                         xtw.WriteNode (xtr, false);\r
  46                         Assert.AreEqual (xml, writer.ToString ());\r
  47 \r
  48                         writer.GetStringBuilder ().Length = 0;\r
  49 \r
  50                         // With encoding\r
  51                         xml = "<?xml version='1.0' encoding='iso-2022-jp'?><root />";\r
  52                         xtr = new XmlTextReader (xml, XmlNodeType.Document, null);\r
  53                         xtw.WriteNode (xtr, false);\r
  54                         Assert.AreEqual (xml, writer.ToString ());\r
  55                         xtr.Close ();\r
  56                 }\r
  57 \r
  58                 [Test]\r
  59                 public void WriteNodeXmlDecl ()\r
  60                 {\r
  61                         string xml = "<?xml version='1.0'?><root />";\r
  62                         StringReader sr = new StringReader (xml);\r
  63                         XmlTextReader xtr = new XmlTextReader (sr);\r
  64                         xtr.Read ();\r
  65                         xtw.WriteNode (xtr, false);\r
  66                         Assert.AreEqual ("<?xml version='1.0'?>",\r
  67                                  writer.ToString ());\r
  68                         xtr.Close ();\r
  69                 }\r
  70 \r
  71                 [Test]\r
  72                 public void WriteNodeEmptyElement ()\r
  73                 {\r
  74                         string xml = "<root attr='value' attr2='value' />";\r
  75                         StringReader sr = new StringReader (xml);\r
  76                         XmlTextReader xtr = new XmlTextReader (sr);\r
  77                         xtw.WriteNode (xtr, false);\r
  78                         Assert.AreEqual (xml.Replace ("'", "\""),\r
  79                                 writer.ToString ());\r
  80                         xtr.Close ();\r
  81                 }\r
  82 \r
  83                 [Test]\r
  84                 public void WriteNodeNonEmptyElement ()\r
  85                 {\r
  86                         string xml = @"<foo><bar></bar></foo>";\r
  87                         xtw.WriteNode (new XmlTextReader (xml, XmlNodeType.Document, null), false);\r
  88                         Assert.AreEqual (xml, writer.ToString ());\r
  89                 }\r
  90 \r
  91                 [Test]\r
  92                 public void WriteNodeSingleContentElement ()\r
  93                 {\r
  94                         string xml = "<root attr='value' attr2='value'><foo /></root>";\r
  95                         StringReader sr = new StringReader (xml);\r
  96                         XmlTextReader xtr = new XmlTextReader (sr);\r
  97                         xtw.WriteNode (xtr, false);\r
  98                         Assert.AreEqual (xml.Replace ("'", "\""),\r
  99                                 writer.ToString ());\r
 100                         xtr.Close ();\r
 101                 }\r
 102 \r
 103                 [Test]\r
 104                 public void WriteNodeNone ()\r
 105                 {\r
 106                         XmlTextReader xtr = new XmlTextReader ("", XmlNodeType.Element, null);\r
 107                         xtr.Read ();\r
 108                         xtw.WriteNode (xtr, false); // does not report any errors\r
 109                         xtr.Close ();\r
 110                 }\r
 111 \r
 112                 [Test]\r
 113 #if NET_2_0\r
 114                 [Category ("NotDotNet")] // enbugged in 2.0\r
 115 #endif\r
 116                 [ExpectedException (typeof (XmlException))]\r
 117                 public void WriteNodeError ()\r
 118                 {\r
 119                         XmlTextReader xtr = new XmlTextReader ("<root>", XmlNodeType.Document, null);\r
 120                         xtr.Read ();\r
 121                         try {\r
 122                                 xtr.Read ();\r
 123                         } catch {\r
 124                         }\r
 125                         XmlTextWriter xtw = new XmlTextWriter (new StringWriter ());\r
 126                         xtw.WriteNode (xtr, false);\r
 127                 }\r
 128 \r
 129                 [Test]\r
 130                 public void WriteSurrogateCharEntity ()\r
 131                 {\r
 132                         xtw.WriteSurrogateCharEntity ('\udfff', '\udb00');\r
 133                         Assert.AreEqual ("&#xD03FF;", writer.ToString ());\r
 134 \r
 135                         try {\r
 136                                 xtw.WriteSurrogateCharEntity ('\ud800', '\udc00');\r
 137                                 Assert.Fail ();\r
 138                         } catch {\r
 139                         }\r
 140                         try {\r
 141                                 xtw.WriteSurrogateCharEntity ('\udbff', '\ud800');\r
 142                                 Assert.Fail ();\r
 143                         } catch {\r
 144                         }\r
 145                         try {\r
 146                                 xtw.WriteSurrogateCharEntity ('\ue000', '\ud800');\r
 147                                 Assert.Fail ();\r
 148                         } catch {\r
 149                         }\r
 150                         try {\r
 151                                 xtw.WriteSurrogateCharEntity ('\udfff', '\udc00');\r
 152                                 Assert.Fail ();\r
 153                         } catch {\r
 154                         }\r
 155                 }\r
 156 \r
 157                 // MS.NET's not-overriden XmlWriter.WriteStartElement(name)\r
 158                 // invokes WriteStartElement(null, name, null). \r
 159                 // WriteStartElement(name, ns) invokes (null, name, ns), too.\r
 160                 [Test]\r
 161                 public void StartElement ()\r
 162                 {\r
 163                         StartElementTestWriter xw = new StartElementTestWriter ();\r
 164                         xw.WriteStartDocument ();\r
 165                         xw.WriteStartElement ("test");\r
 166                         Assert.IsNull (xw.NS, "StartElementOverride.NS");\r
 167                         Assert.IsNull (xw.Prefix, "StartElementOverride.Prefix");\r
 168                         xw.NS = String.Empty;\r
 169                         xw.Prefix = String.Empty;\r
 170                         xw.WriteStartElement ("test", "urn:hoge");\r
 171                         Assert.AreEqual ("urn:hoge", xw.NS, "StartElementOverride.NS");\r
 172                         Assert.IsNull (null, xw.Prefix, "StartElementOverride.Prefix");\r
 173                 }\r
 174                 \r
 175                 class StartElementTestWriter : DefaultXmlWriter\r
 176                 {\r
 177                         public StartElementTestWriter () : base () {}\r
 178                         public string NS = String.Empty;\r
 179                         public string Prefix = String.Empty;\r
 180 \r
 181                         public override void WriteStartElement (string prefix, string localName, string ns)\r
 182                         {\r
 183                                 this.NS = ns;\r
 184                                 this.Prefix = prefix;\r
 185                         }\r
 186                 }\r
 187 \r
 188                 [Test]\r
 189                 public void WriteAttributes ()\r
 190                 {\r
 191                         string xml = "<root><test a='b' c='d' /><b /></root>";\r
 192                         XmlTextReader xtr = new XmlTextReader (xml,\r
 193                                 XmlNodeType.Document, null);\r
 194                         xtw.QuoteChar = '\'';\r
 195                         xtr.Read ();\r
 196                         xtw.WriteStartElement ("root"); // <root\r
 197                         xtr.Read ();\r
 198                         xtw.WriteStartElement ("test"); // ><test\r
 199                         xtw.WriteAttributes (xtr, false); // a='b' c='d'\r
 200                         Assert.AreEqual (XmlNodeType.Element, xtr.NodeType);\r
 201                         xtw.WriteEndElement (); // />\r
 202                         xtw.WriteStartElement ("b"); // <b\r
 203                         xtw.WriteEndElement (); // />\r
 204                         xtw.WriteEndElement (); // </root>\r
 205                         xtw.Close ();\r
 206                         Assert.AreEqual (xml, writer.ToString ());\r
 207                 }\r
 208 \r
 209 #if NET_2_0\r
 210                 [Test]\r
 211                 public void Create_File ()\r
 212                 {\r
 213                         string file = Path.GetTempFileName ();\r
 214                         XmlWriter writer = XmlWriter.Create (file);\r
 215                         Assert.IsNotNull (writer.Settings, "#A1");\r
 216                         //Assert.IsTrue (writer.Settings.CloseOutput, "#A2");\r
 217                         writer.Close ();\r
 218                         File.Delete (file);\r
 219 \r
 220                         XmlWriterSettings settings = new XmlWriterSettings ();\r
 221                         settings.CloseOutput = true;\r
 222                         writer = XmlWriter.Create (file, settings);\r
 223                         //Assert.IsFalse (object.ReferenceEquals (settings, writer.Settings), "#B1");\r
 224                         Assert.IsTrue (settings.CloseOutput, "#B2");\r
 225                         writer.Close ();\r
 226                         File.Delete (file);\r
 227 \r
 228                         writer = XmlWriter.Create (file, (XmlWriterSettings) null);\r
 229                         Assert.IsNotNull (writer.Settings, "#C1");\r
 230                         //Assert.IsTrue (writer.Settings.CloseOutput, "#C2");\r
 231                         writer.Close ();\r
 232                         File.Delete (file);\r
 233 \r
 234                         settings = new XmlWriterSettings ();\r
 235                         writer = XmlWriter.Create (file, settings);\r
 236                         //Assert.IsFalse (object.ReferenceEquals (settings, writer.Settings), "#D1");\r
 237                         //Assert.IsTrue (writer.Settings.CloseOutput, "#D2");\r
 238                         writer.Close ();\r
 239                         File.Delete (file);\r
 240 \r
 241                         writer = XmlWriter.Create (file);\r
 242                         Assert.IsNotNull (writer.Settings, "#E1");\r
 243                         //Assert.IsTrue (writer.Settings.CloseOutput, "#E2");\r
 244                         writer.Close ();\r
 245                         File.Delete (file);\r
 246                 }\r
 247 \r
 248                 [Test]\r
 249                 public void Create_Stream ()\r
 250                 {\r
 251                         MemoryStream ms = new MemoryStream ();\r
 252                         XmlWriter writer = XmlWriter.Create (ms);\r
 253                         Assert.IsNotNull (writer.Settings, "#A1");\r
 254                         Assert.IsFalse (writer.Settings.CloseOutput, "#A2");\r
 255                         writer.Close ();\r
 256                         Assert.IsTrue (ms.CanWrite, "#A3");\r
 257 \r
 258                         XmlWriterSettings settings = new XmlWriterSettings ();\r
 259                         settings.CloseOutput = true;\r
 260                         writer = XmlWriter.Create (ms, settings);\r
 261                         //Assert.IsFalse (object.ReferenceEquals (settings, writer.Settings), "#B1");\r
 262                         Assert.IsTrue (settings.CloseOutput, "#B2");\r
 263                         writer.Close ();\r
 264                         Assert.IsFalse (ms.CanWrite, "#B3");\r
 265 \r
 266                         ms = new MemoryStream ();\r
 267                         settings = new XmlWriterSettings ();\r
 268                         writer = XmlWriter.Create (ms, settings);\r
 269                         //Assert.IsFalse (object.ReferenceEquals (settings, writer.Settings), "#C1");\r
 270                         Assert.IsFalse (writer.Settings.CloseOutput, "#C2");\r
 271                         writer.Close ();\r
 272                         Assert.IsTrue (ms.CanWrite, "#C3");\r
 273 \r
 274                         ms = new MemoryStream ();\r
 275                         writer = XmlWriter.Create (ms, (XmlWriterSettings) null);\r
 276                         Assert.IsNotNull (writer.Settings, "#D1");\r
 277                         Assert.IsFalse (writer.Settings.CloseOutput, "#D2");\r
 278                         writer.Close ();\r
 279                         Assert.IsTrue (ms.CanWrite, "#D3");\r
 280                 }\r
 281 \r
 282                 [Test]\r
 283                 public void Create_TextWriter ()\r
 284                 {\r
 285                         MemoryStream ms = new MemoryStream ();\r
 286                         XmlWriter writer = XmlWriter.Create (new StreamWriter (ms));\r
 287                         Assert.IsNotNull (writer.Settings, "#A1");\r
 288                         Assert.IsFalse (writer.Settings.CloseOutput, "#A2");\r
 289                         writer.Close ();\r
 290                         Assert.IsTrue (ms.CanWrite, "#A3");\r
 291 \r
 292                         XmlWriterSettings settings = new XmlWriterSettings ();\r
 293                         settings.CloseOutput = true;\r
 294                         writer = XmlWriter.Create (new StreamWriter (ms), settings);\r
 295                         //Assert.IsFalse (object.ReferenceEquals (settings, writer.Settings), "#B1");\r
 296                         Assert.IsTrue (settings.CloseOutput, "#B2");\r
 297                         writer.Close ();\r
 298                         Assert.IsFalse (ms.CanWrite, "#B3");\r
 299 \r
 300                         ms = new MemoryStream ();\r
 301                         settings = new XmlWriterSettings ();\r
 302                         writer = XmlWriter.Create (new StreamWriter (ms), settings);\r
 303                         //Assert.IsFalse (object.ReferenceEquals (settings, writer.Settings), "#C1");\r
 304                         Assert.IsFalse (writer.Settings.CloseOutput, "#C2");\r
 305                         writer.Close ();\r
 306                         Assert.IsTrue (ms.CanWrite, "#C3");\r
 307 \r
 308                         ms = new MemoryStream ();\r
 309                         writer = XmlWriter.Create (new StreamWriter (ms), (XmlWriterSettings) null);\r
 310                         Assert.IsNotNull (writer.Settings, "#D1");\r
 311                         Assert.IsFalse (writer.Settings.CloseOutput, "#D2");\r
 312                         writer.Close ();\r
 313                         Assert.IsTrue (ms.CanWrite, "#D3");\r
 314                 }\r
 315 \r
 316                 [Test]\r
 317                 public void Create_XmlWriter ()\r
 318                 {\r
 319                         MemoryStream ms = new MemoryStream ();\r
 320                         XmlTextWriter xtw = new XmlTextWriter (ms, Encoding.UTF8);\r
 321                         XmlWriter writer = XmlWriter.Create (xtw);\r
 322                         Assert.IsNotNull (writer.Settings, "#A1");\r
 323                         Assert.IsFalse (writer.Settings.CloseOutput, "#A2");\r
 324                         writer.Close ();\r
 325                         Assert.IsFalse (ms.CanWrite, "#A3");\r
 326 \r
 327                         ms = new MemoryStream ();\r
 328                         xtw = new XmlTextWriter (ms, Encoding.UTF8);\r
 329                         XmlWriterSettings settings = new XmlWriterSettings ();\r
 330                         settings.CloseOutput = true;\r
 331                         writer = XmlWriter.Create (xtw, settings);\r
 332                         //Assert.IsFalse (object.ReferenceEquals (settings, writer.Settings), "#B1");\r
 333                         //Assert.IsFalse (writer.Settings.CloseOutput, "#B2");\r
 334                         writer.Close ();\r
 335                         Assert.IsFalse (ms.CanWrite, "#B3");\r
 336 \r
 337                         ms = new MemoryStream ();\r
 338                         xtw = new XmlTextWriter (ms, Encoding.UTF8);\r
 339                         settings = new XmlWriterSettings ();\r
 340                         writer = XmlWriter.Create (xtw, settings);\r
 341                         //Assert.IsFalse (object.ReferenceEquals (settings, writer.Settings), "#C1");\r
 342                         Assert.IsFalse (writer.Settings.CloseOutput, "#C2");\r
 343                         writer.Close ();\r
 344                         Assert.IsFalse (ms.CanWrite, "#C3");\r
 345 \r
 346                         ms = new MemoryStream ();\r
 347                         xtw = new XmlTextWriter (ms, Encoding.UTF8);\r
 348                         writer = XmlWriter.Create (xtw, (XmlWriterSettings) null);\r
 349                         Assert.IsNotNull (writer.Settings, "#D1");\r
 350                         Assert.IsFalse (writer.Settings.CloseOutput, "#D2");\r
 351                         writer.Close ();\r
 352                         Assert.IsFalse (ms.CanWrite, "#D3");\r
 353                 }\r
 354 \r
 355                 [Test]\r
 356                 [Category ("NotWorking")]\r
 357                 public void Create_XmlWriter2 ()\r
 358                 {\r
 359                         MemoryStream ms = new MemoryStream ();\r
 360                         XmlWriterSettings settings = new XmlWriterSettings ();\r
 361                         XmlWriter xw = XmlWriter.Create (ms, settings);\r
 362                         XmlWriter writer = XmlWriter.Create (xw, new XmlWriterSettings ());\r
 363                         Assert.IsNotNull (writer.Settings, "#A1");\r
 364                         Assert.IsFalse (writer.Settings.CloseOutput, "#A2");\r
 365                         writer.Close ();\r
 366                         Assert.IsTrue (ms.CanWrite, "#A3");\r
 367 \r
 368                         ms = new MemoryStream ();\r
 369                         settings = new XmlWriterSettings ();\r
 370                         settings.CloseOutput = true;\r
 371                         xw = XmlWriter.Create (ms, settings);\r
 372                         writer = XmlWriter.Create (xw, new XmlWriterSettings ());\r
 373                         Assert.IsNotNull (writer.Settings, "#B1");\r
 374                         Assert.IsTrue (writer.Settings.CloseOutput, "#B2");\r
 375                         writer.Close ();\r
 376                         Assert.IsFalse (ms.CanWrite, "#B3");\r
 377                 }\r
 378 \r
 379                 [Test]\r
 380                 [ExpectedException (typeof (XmlException))]\r
 381                 public void CreateWriter_AttributeNamespacesXmlnsXmlns ()\r
 382                 {\r
 383                         // Unlike XmlTextWriter, null namespace is not ignored.\r
 384                         XmlWriter w = XmlWriter.Create (new StringWriter ());\r
 385                         w.WriteStartElement ("foo");\r
 386                         w.WriteAttributeString ("xmlns", "xmlns", null, "http://abc.def");\r
 387                 }\r
 388 \r
 389                 XmlWriter CreateWriter (TextWriter tw)\r
 390                 {\r
 391                         XmlWriterSettings s = new XmlWriterSettings ();\r
 392                         s.OmitXmlDeclaration = true;\r
 393                         XmlWriter w = XmlWriter.Create (tw, s);\r
 394                         w.WriteStartElement ("root");\r
 395                         return w;\r
 396                 }\r
 397 \r
 398                 [Test]\r
 399                 [ExpectedException (typeof (ArgumentNullException))]\r
 400                 public void WriteValueNull ()\r
 401                 {\r
 402                         XmlWriter w = CreateWriter (TextWriter.Null);\r
 403                         w.WriteValue ((object) null);\r
 404                 }\r
 405 \r
 406                 [Test]\r
 407                 [ExpectedException (typeof (InvalidCastException))] // it throws somewhat funny exception\r
 408                 public void WriteValueNonExistentQName ()\r
 409                 {\r
 410                         XmlWriter w = CreateWriter (TextWriter.Null);\r
 411                         w.WriteValue (new XmlQualifiedName ("foo", "urn:foo"));\r
 412                 }\r
 413 \r
 414                 [Test]\r
 415                 public void WriteValueEmptyQName ()\r
 416                 {\r
 417                         StringWriter sw = new StringWriter ();\r
 418                         XmlWriter w = CreateWriter (sw);\r
 419                         w.WriteValue (XmlQualifiedName.Empty);\r
 420                         w.Close ();\r
 421                 }\r
 422 \r
 423                 [Test]\r
 424                 public void WriteValueQName ()\r
 425                 {\r
 426                         StringWriter sw = new StringWriter ();\r
 427                         XmlWriter w = CreateWriter (sw);\r
 428                         w.WriteAttributeString ("xmlns", "x", "http://www.w3.org/2000/xmlns/", "urn:foo");\r
 429                         w.WriteValue (new XmlQualifiedName ("foo", "urn:foo"));\r
 430                         w.Close ();\r
 431                         Assert.AreEqual ("<root xmlns:x=\"urn:foo\">x:foo</root>", sw.ToString ());\r
 432                 }\r
 433 \r
 434                 [Test]\r
 435                 public void WriteValueTimeSpan ()\r
 436                 {\r
 437                         StringWriter sw = new StringWriter ();\r
 438                         XmlWriter w = CreateWriter (sw);\r
 439                         w.WriteValue (TimeSpan.FromSeconds (5));\r
 440                         w.Close ();\r
 441                         Assert.AreEqual ("<root>PT5S</root>", sw.ToString ());\r
 442                 }\r
 443 \r
 444                 [Test]\r
 445                 public void WriteValueArray ()\r
 446                 {\r
 447                         StringWriter sw = new StringWriter ();\r
 448                         XmlWriter w = CreateWriter (sw);\r
 449                         w.WriteValue (new int [] {1, 2, 3});\r
 450                         w.WriteValue (new int [] {4, 5, 6});\r
 451                         w.Close ();\r
 452                         Assert.AreEqual ("<root>1 2 34 5 6</root>", sw.ToString ());\r
 453                 }\r
 454 \r
 455                 [Test]\r
 456                 [ExpectedException (typeof (InvalidCastException))] // it throws somewhat funny exception\r
 457                 public void WriteValueTextReader ()\r
 458                 {\r
 459                         // it is documented as supported, but actually isn't.\r
 460                         XmlWriter w = CreateWriter (TextWriter.Null);\r
 461                         w.WriteValue (new StringReader ("foobar"));\r
 462                 }\r
 463 \r
 464                 XPathNavigator GetNavigator (string xml)\r
 465                 {\r
 466                         return new XPathDocument (XmlReader.Create (\r
 467                                 new StringReader (xml))).CreateNavigator ();\r
 468                 }\r
 469 \r
 470                 string WriteNavigator (XPathNavigator nav, bool defattr)\r
 471                 {\r
 472                         StringWriter sw = new StringWriter ();\r
 473                         XmlWriterSettings settings = new XmlWriterSettings ();\r
 474                         settings.OmitXmlDeclaration = true;\r
 475                         settings.ConformanceLevel = ConformanceLevel.Fragment;\r
 476                         using (XmlWriter w = XmlWriter.Create (sw, settings)) {\r
 477                                 w.WriteNode (nav, defattr);\r
 478                         }\r
 479                         return sw.ToString ();\r
 480                 }\r
 481 \r
 482                 [Test]\r
 483                 public void WriteNodeNavigator1 ()\r
 484                 {\r
 485                         XPathNavigator nav = GetNavigator ("<root>test<!-- comment --></root>");\r
 486                         // at Root\r
 487                         AssertType.AreEqual ("<root>test<!-- comment --></root>", WriteNavigator (nav, false), "#1");\r
 488                         // at document element\r
 489                         nav.MoveToFirstChild ();\r
 490                         AssertType.AreEqual ("<root>test<!-- comment --></root>", WriteNavigator (nav, false), "#2");\r
 491                         // at text\r
 492                         nav.MoveToFirstChild ();\r
 493                         AssertType.AreEqual ("test", WriteNavigator (nav, false), "#3");\r
 494 \r
 495                         // at comment\r
 496                         nav.MoveToNext ();\r
 497                         AssertType.AreEqual ("<!-- comment -->", WriteNavigator (nav, false), "#4");\r
 498                 }\r
 499 \r
 500                 string WriteSubtree (XPathNavigator nav)\r
 501                 {\r
 502                         StringWriter sw = new StringWriter ();\r
 503                         XmlWriterSettings settings = new XmlWriterSettings ();\r
 504                         settings.OmitXmlDeclaration = true;\r
 505                         settings.ConformanceLevel = ConformanceLevel.Fragment;\r
 506                         using (XmlWriter w = XmlWriter.Create (sw, settings)) {\r
 507                                 nav.WriteSubtree(w);\r
 508                         }\r
 509                         return sw.ToString ();\r
 510                 }\r
 511 \r
 512                 [Test]\r
 513                 public void NavigatorWriteSubtree1 ()\r
 514                 {\r
 515                         XPathNavigator nav = GetNavigator ("<root>test<!-- comment --></root>");\r
 516                         // at Root\r
 517                         AssertType.AreEqual ("<root>test<!-- comment --></root>", WriteSubtree (nav), "#1");\r
 518                         // at document element\r
 519                         nav.MoveToFirstChild ();\r
 520                         AssertType.AreEqual ("<root>test<!-- comment --></root>", WriteSubtree (nav), "#2");\r
 521                         // at text\r
 522                         nav.MoveToFirstChild ();\r
 523                         AssertType.AreEqual ("test", WriteSubtree (nav), "#3");\r
 524 \r
 525                         // at comment\r
 526                         nav.MoveToNext ();\r
 527                         AssertType.AreEqual ("<!-- comment -->", WriteSubtree (nav), "#4");\r
 528                 }\r
 529 \r
 530                 [Test]\r
 531                 public void WriteNodeXPathNavigator ()\r
 532                 {\r
 533                         string xml = "<A xmlns='urn:x'><B xmlns='urn:y' /></A>";\r
 534                         XPathNavigator nav = new XPathDocument (new StringReader(xml)).CreateNavigator ();\r
 535                         XmlWriterSettings s = new XmlWriterSettings ();\r
 536                         s.OmitXmlDeclaration = true;\r
 537                         StringWriter sw = new StringWriter ();\r
 538                         XmlWriter w = XmlWriter.Create (sw, s);\r
 539                         w.WriteNode (nav, false);\r
 540                         w.Close ();\r
 541                         AssertType.AreEqual ("<A xmlns=\"urn:x\"><B xmlns=\"urn:y\" /></A>", sw.ToString ());\r
 542                 }\r
 543 \r
 544                 [Test]\r
 545                 public void WriteNodeXPathNavigatorAttribute ()\r
 546                 {\r
 547                         string xml = "<!DOCTYPE root [<!ELEMENT root EMPTY> <!ATTLIST root implicit NMTOKEN 'nam'>]><root attr='val' />";\r
 548                         XPathNavigator nav = new XPathDocument (new StringReader (xml)).CreateNavigator ();\r
 549                         XmlWriterSettings s = new XmlWriterSettings ();\r
 550                         s.OmitXmlDeclaration = true;\r
 551                         StringWriter sw = new StringWriter ();\r
 552                         XmlWriter w = XmlWriter.Create (sw, s);\r
 553                         w.WriteStartElement ("hoge");\r
 554                         nav.MoveToFirstChild ();\r
 555                         nav.MoveToFirstAttribute ();\r
 556                         w.WriteNode (nav, false);\r
 557                         nav.MoveToNextAttribute ();\r
 558                         w.WriteNode (nav, false);\r
 559                         w.Close ();\r
 560                         AssertType.AreEqual ("<hoge />", sw.ToString ());\r
 561                 }\r
 562 \r
 563                 [Test]\r
 564                 public void WriteStringDifferentBehavior ()\r
 565                 {\r
 566                         // Messy implementation difference.\r
 567                         // from XmlTextWriter -> <foo />\r
 568                         // from XmlWriter.XCreate() -> <foo></foo>\r
 569                         var sw = new StringWriter ();\r
 570                         var xw = XmlWriter.Create (sw);\r
 571                         xw.WriteStartElement ("foo");\r
 572                         xw.WriteString ("");\r
 573                         xw.WriteEndElement ();\r
 574                         xw.Close ();\r
 575                         AssertType.AreEqual ("<?xml version='1.0' encoding='utf-16'?><foo></foo>".Replace ('\'', '"'), sw.ToString ());\r
 576                 }\r
 577 \r
 578                 [Test]\r
 579                 public void CreateCLAuto () {\r
 580                         ConformanceLevelAuto cl = new ConformanceLevelAuto ();\r
 581                         XmlWriter xw = XmlWriter.Create (cl);\r
 582                         WriteState state = xw.WriteState;\r
 583                 }\r
 584 \r
 585                 [Test]\r
 586                 [ExpectedException (typeof (InvalidOperationException))]\r
 587                 public void CreateCLDoc () {\r
 588                         ConformanceLevelDocument cl = new ConformanceLevelDocument ();\r
 589                         XmlWriter xw = XmlWriter.Create (cl);\r
 590                         WriteState state = xw.WriteState;\r
 591                 }\r
 592 \r
 593                 [Test]\r
 594                 public void CreateCLFrag () {\r
 595                         ConformanceLevelFragment cl = new ConformanceLevelFragment ();\r
 596                         XmlWriter xw = XmlWriter.Create (cl);\r
 597                         WriteState state = xw.WriteState;\r
 598                 }\r
 599 \r
 600                 [Test]\r
 601                 [ExpectedException (typeof (InvalidOperationException))]\r
 602                 public void CreateNOCL () {\r
 603                         InvalidWriteState cl = new InvalidWriteState ();\r
 604                         XmlWriter xw = XmlWriter.Create (cl);\r
 605                         WriteState state = xw.WriteState;\r
 606                 }\r
 607 \r
 608                 [Test]\r
 609                 [ExpectedException (typeof (InvalidOperationException))]\r
 610                 public void CreateNOCLSettingsCLAuto () {\r
 611                         InvalidWriteState cl = new InvalidWriteState ();\r
 612                         XmlWriter xw = XmlWriter.Create (cl, new XmlWriterSettings () { ConformanceLevel = ConformanceLevel.Auto });\r
 613                         WriteState state = xw.WriteState;\r
 614                 }\r
 615 \r
 616                 [Test]\r
 617                 [ExpectedException (typeof (InvalidOperationException))]\r
 618                 public void CreateNOCLSettingsCLDOC () {\r
 619                         InvalidWriteState cl = new InvalidWriteState ();\r
 620                         XmlWriter xw = XmlWriter.Create (cl, new XmlWriterSettings () { ConformanceLevel = ConformanceLevel.Document });\r
 621                         WriteState state = xw.WriteState;\r
 622                 }\r
 623 \r
 624                 [Test]\r
 625                 [ExpectedException (typeof (InvalidOperationException))]\r
 626                 public void CreateNOCLSettingsCLFrag () {\r
 627                         InvalidWriteState cl = new InvalidWriteState ();\r
 628                         XmlWriter xw = XmlWriter.Create (cl, new XmlWriterSettings () { ConformanceLevel = ConformanceLevel.Fragment });\r
 629                         WriteState state = xw.WriteState;\r
 630                 }\r
 631 \r
 632                 [Test]\r
 633                 public void CreateCLAutoSettingsCLDoc () {\r
 634                         ConformanceLevelAuto cl = new ConformanceLevelAuto ();\r
 635                         XmlWriter xw = XmlWriter.Create (cl, new XmlWriterSettings () { ConformanceLevel = ConformanceLevel.Document });\r
 636                         WriteState state = xw.WriteState;\r
 637                 }\r
 638 \r
 639                 [Test]\r
 640                 public void CreateCLAutoSettingsCLFrag () {\r
 641                         ConformanceLevelAuto cl = new ConformanceLevelAuto ();\r
 642                         XmlWriter xw = XmlWriter.Create (cl, new XmlWriterSettings () { ConformanceLevel = ConformanceLevel.Fragment });\r
 643                         WriteState state = xw.WriteState;\r
 644                 }\r
 645 \r
 646                 [Test]\r
 647                 [ExpectedException (typeof (InvalidOperationException))]\r
 648                 public void CreateCLDocSettingsCLAuto () {\r
 649                         ConformanceLevelDocument cl = new ConformanceLevelDocument ();\r
 650                         XmlWriter xw = XmlWriter.Create (cl, new XmlWriterSettings () { ConformanceLevel = ConformanceLevel.Auto });\r
 651                         WriteState state = xw.WriteState;\r
 652                 }\r
 653 \r
 654                 [Test]\r
 655                 public void CreateCLDocSettingsCLFrag () {\r
 656                         ConformanceLevelDocument cl = new ConformanceLevelDocument ();\r
 657                         XmlWriter xw = XmlWriter.Create (cl, new XmlWriterSettings () { ConformanceLevel = ConformanceLevel.Fragment });\r
 658                         WriteState state = xw.WriteState;\r
 659                 }\r
 660 \r
 661                 [Test]\r
 662                 [ExpectedException (typeof (InvalidOperationException))]\r
 663                 public void CreateCLFragSettingsCLAuto () {\r
 664                         ConformanceLevelFragment cl = new ConformanceLevelFragment ();\r
 665                         XmlWriter xw = XmlWriter.Create (cl, new XmlWriterSettings () { ConformanceLevel = ConformanceLevel.Auto });\r
 666                         WriteState state = xw.WriteState;\r
 667                 }\r
 668 \r
 669                 [Test]\r
 670                 public void CreateCLFragSettingsCLFDoc () {\r
 671                         ConformanceLevelFragment cl = new ConformanceLevelFragment ();\r
 672                         XmlWriter xw = XmlWriter.Create (cl, new XmlWriterSettings () { ConformanceLevel = ConformanceLevel.Document });\r
 673                         WriteState state = xw.WriteState;\r
 674                 }\r
 675 \r
 676 #endif\r
 677 \r
 678         }\r
 679 \r
 680         internal class DefaultXmlWriter : XmlWriter\r
 681         {\r
 682                 public DefaultXmlWriter () : base ()\r
 683                 {\r
 684                 }\r
 685 \r
 686                 public override void Close ()\r
 687                 {\r
 688                 }\r
 689 \r
 690                 public override void Flush ()\r
 691                 {\r
 692                 }\r
 693 \r
 694                 public override string LookupPrefix (string ns)\r
 695                 {\r
 696                         return null;\r
 697                 }\r
 698 \r
 699                 public override void WriteBase64 (byte [] buffer, int index, int count)\r
 700                 {\r
 701                 }\r
 702 \r
 703                 public override void WriteBinHex (byte [] buffer, int index, int count)\r
 704                 {\r
 705                 }\r
 706 \r
 707                 public override void WriteCData (string text)\r
 708                 {\r
 709                 }\r
 710 \r
 711                 public override void WriteCharEntity (char ch)\r
 712                 {\r
 713                 }\r
 714 \r
 715                 public override void WriteChars (char [] buffer, int index, int count)\r
 716                 {\r
 717                 }\r
 718 \r
 719                 public override void WriteComment (string text)\r
 720                 {\r
 721                 }\r
 722 \r
 723                 public override void WriteDocType (string name, string pubid, string sysid, string subset)\r
 724                 {\r
 725                 }\r
 726 \r
 727                 public override void WriteEndAttribute ()\r
 728                 {\r
 729                 }\r
 730 \r
 731                 public override void WriteEndDocument ()\r
 732                 {\r
 733                 }\r
 734 \r
 735                 public override void WriteEndElement ()\r
 736                 {\r
 737                 }\r
 738 \r
 739                 public override void WriteEntityRef (string name)\r
 740                 {\r
 741                 }\r
 742 \r
 743                 public override void WriteFullEndElement ()\r
 744                 {\r
 745                 }\r
 746 \r
 747                 public override void WriteName (string name)\r
 748                 {\r
 749                 }\r
 750 \r
 751                 public override void WriteNmToken (string name)\r
 752                 {\r
 753                 }\r
 754 \r
 755                 public override void WriteNode (XmlReader reader, bool defattr)\r
 756                 {\r
 757                 }\r
 758 \r
 759                 public override void WriteProcessingInstruction (string name, string text)\r
 760                 {\r
 761                 }\r
 762 \r
 763                 public override void WriteQualifiedName (string localName, string ns)\r
 764                 {\r
 765                 }\r
 766 \r
 767                 public override void WriteRaw (string data)\r
 768                 {\r
 769                 }\r
 770 \r
 771                 public override void WriteRaw (char [] buffer, int index, int count)\r
 772                 {\r
 773                 }\r
 774 \r
 775                 public override void WriteStartAttribute (string prefix, string localName, string ns)\r
 776                 {\r
 777                 }\r
 778 \r
 779                 public override void WriteStartDocument (bool standalone)\r
 780                 {\r
 781                 }\r
 782 \r
 783                 public override void WriteStartDocument ()\r
 784                 {\r
 785                 }\r
 786 \r
 787                 public override void WriteStartElement (string prefix, string localName, string ns)\r
 788                 {\r
 789                 }\r
 790 \r
 791                 public override void WriteString (string text)\r
 792                 {\r
 793                 }\r
 794 \r
 795                 public override void WriteSurrogateCharEntity (char lowChar, char highChar)\r
 796                 {\r
 797                 }\r
 798 \r
 799                 public override void WriteWhitespace (string ws)\r
 800                 {\r
 801                 }\r
 802 \r
 803                 public override WriteState WriteState {\r
 804                         get {\r
 805                                 return WriteState.Start;\r
 806                         }\r
 807                 }\r
 808 \r
 809                 public override string XmlLang {\r
 810                         get {\r
 811                                 return null;\r
 812                         }\r
 813                 }\r
 814 \r
 815                 public override XmlSpace XmlSpace {\r
 816                         get {\r
 817                                 return XmlSpace.None;\r
 818                         }\r
 819                 }\r
 820 \r
 821         }\r
 822 \r
 823 \r
 824         class InvalidWriteState : XmlWriter {\r
 825                 public override void Close () { }\r
 826                 public override void Flush () { }\r
 827                 public override string LookupPrefix (string ns) { return null; }\r
 828                 public override void WriteBase64 (byte [] buffer, int index, int count) { }\r
 829                 public override void WriteCData (string text) { }\r
 830                 public override void WriteCharEntity (char ch) { }\r
 831                 public override void WriteChars (char [] buffer, int index, int count) { }\r
 832                 public override void WriteComment (string text) { }\r
 833                 public override void WriteDocType (string name, string pubid, string sysid, string subset) { }\r
 834                 public override void WriteEndAttribute () { }\r
 835                 public override void WriteEndDocument () { }\r
 836                 public override void WriteEndElement () { }\r
 837                 public override void WriteEntityRef (string name) { }\r
 838                 public override void WriteFullEndElement () { }\r
 839                 public override void WriteProcessingInstruction (string name, string text) {}\r
 840                 public override void WriteRaw (string data) {}\r
 841                 public override void WriteRaw (char [] buffer, int index, int count) {}\r
 842                 public override void WriteStartAttribute (string prefix, string localName, string ns) {}\r
 843                 public override void WriteStartDocument (bool standalone) {}\r
 844                 public override void WriteStartDocument () {}\r
 845                 public override void WriteStartElement (string prefix, string localName, string ns) {}\r
 846                 public override void WriteString (string text) {}\r
 847                 public override void WriteSurrogateCharEntity (char lowChar, char highChar) {}\r
 848                 public override void WriteWhitespace (string ws) {}\r
 849 \r
 850                 public override WriteState WriteState {\r
 851                         get { throw new InvalidOperationException (); }\r
 852                 }\r
 853         }\r
 854 \r
 855         class ConformanceLevelAuto : InvalidWriteState {\r
 856                 public override XmlWriterSettings Settings {\r
 857                         get {\r
 858                                 return new XmlWriterSettings () { ConformanceLevel = ConformanceLevel.Auto };\r
 859                         }\r
 860                 }\r
 861         }\r
 862 \r
 863         class ConformanceLevelDocument : InvalidWriteState {\r
 864                 public override XmlWriterSettings Settings {\r
 865                         get {\r
 866                                 return new XmlWriterSettings () { ConformanceLevel = ConformanceLevel.Document };\r
 867                         }\r
 868                 }\r
 869         }\r
 870 \r
 871         class ConformanceLevelFragment : InvalidWriteState {\r
 872                 public override XmlWriterSettings Settings {\r
 873                         get {\r
 874                                 return new XmlWriterSettings () { ConformanceLevel = ConformanceLevel.Fragment };\r
 875                         }\r
 876                 }\r
 877         }\r
 878 \r
 879 }\r
 880 \r