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                 [Category ("NotDotNet")] // enbugged in 2.0\r
 114                 [ExpectedException (typeof (XmlException))]\r
 115                 public void WriteNodeError ()\r
 116                 {\r
 117                         XmlTextReader xtr = new XmlTextReader ("<root>", XmlNodeType.Document, null);\r
 118                         xtr.Read ();\r
 119                         try {\r
 120                                 xtr.Read ();\r
 121                         } catch {\r
 122                         }\r
 123                         XmlTextWriter xtw = new XmlTextWriter (new StringWriter ());\r
 124                         xtw.WriteNode (xtr, false);\r
 125                 }\r
 126 \r
 127                 [Test]\r
 128                 public void WriteSurrogateCharEntity ()\r
 129                 {\r
 130                         xtw.WriteSurrogateCharEntity ('\udfff', '\udb00');\r
 131                         Assert.AreEqual ("&#xD03FF;", writer.ToString ());\r
 132 \r
 133                         try {\r
 134                                 xtw.WriteSurrogateCharEntity ('\ud800', '\udc00');\r
 135                                 Assert.Fail ();\r
 136                         } catch {\r
 137                         }\r
 138                         try {\r
 139                                 xtw.WriteSurrogateCharEntity ('\udbff', '\ud800');\r
 140                                 Assert.Fail ();\r
 141                         } catch {\r
 142                         }\r
 143                         try {\r
 144                                 xtw.WriteSurrogateCharEntity ('\ue000', '\ud800');\r
 145                                 Assert.Fail ();\r
 146                         } catch {\r
 147                         }\r
 148                         try {\r
 149                                 xtw.WriteSurrogateCharEntity ('\udfff', '\udc00');\r
 150                                 Assert.Fail ();\r
 151                         } catch {\r
 152                         }\r
 153                 }\r
 154 \r
 155                 // MS.NET's not-overriden XmlWriter.WriteStartElement(name)\r
 156                 // invokes WriteStartElement(null, name, null). \r
 157                 // WriteStartElement(name, ns) invokes (null, name, ns), too.\r
 158                 [Test]\r
 159                 public void StartElement ()\r
 160                 {\r
 161                         StartElementTestWriter xw = new StartElementTestWriter ();\r
 162                         xw.WriteStartDocument ();\r
 163                         xw.WriteStartElement ("test");\r
 164                         Assert.IsNull (xw.NS, "StartElementOverride.NS");\r
 165                         Assert.IsNull (xw.Prefix, "StartElementOverride.Prefix");\r
 166                         xw.NS = String.Empty;\r
 167                         xw.Prefix = String.Empty;\r
 168                         xw.WriteStartElement ("test", "urn:hoge");\r
 169                         Assert.AreEqual ("urn:hoge", xw.NS, "StartElementOverride.NS");\r
 170                         Assert.IsNull (null, xw.Prefix, "StartElementOverride.Prefix");\r
 171                 }\r
 172                 \r
 173                 class StartElementTestWriter : DefaultXmlWriter\r
 174                 {\r
 175                         public StartElementTestWriter () : base () {}\r
 176                         public string NS = String.Empty;\r
 177                         public string Prefix = String.Empty;\r
 178 \r
 179                         public override void WriteStartElement (string prefix, string localName, string ns)\r
 180                         {\r
 181                                 this.NS = ns;\r
 182                                 this.Prefix = prefix;\r
 183                         }\r
 184                 }\r
 185 \r
 186                 [Test]\r
 187                 public void WriteAttributes ()\r
 188                 {\r
 189                         string xml = "<root><test a='b' c='d' /><b /></root>";\r
 190                         XmlTextReader xtr = new XmlTextReader (xml,\r
 191                                 XmlNodeType.Document, null);\r
 192                         xtw.QuoteChar = '\'';\r
 193                         xtr.Read ();\r
 194                         xtw.WriteStartElement ("root"); // <root\r
 195                         xtr.Read ();\r
 196                         xtw.WriteStartElement ("test"); // ><test\r
 197                         xtw.WriteAttributes (xtr, false); // a='b' c='d'\r
 198                         Assert.AreEqual (XmlNodeType.Element, xtr.NodeType);\r
 199                         xtw.WriteEndElement (); // />\r
 200                         xtw.WriteStartElement ("b"); // <b\r
 201                         xtw.WriteEndElement (); // />\r
 202                         xtw.WriteEndElement (); // </root>\r
 203                         xtw.Close ();\r
 204                         Assert.AreEqual (xml, writer.ToString ());\r
 205                 }\r
 206 \r
 207                 [Test]\r
 208                 public void Create_File ()\r
 209                 {\r
 210                         string file = Path.GetTempFileName ();\r
 211                         XmlWriter writer = XmlWriter.Create (file);\r
 212                         Assert.IsNotNull (writer.Settings, "#A1");\r
 213                         //Assert.IsTrue (writer.Settings.CloseOutput, "#A2");\r
 214                         writer.Close ();\r
 215                         File.Delete (file);\r
 216 \r
 217                         XmlWriterSettings settings = new XmlWriterSettings ();\r
 218                         settings.CloseOutput = true;\r
 219                         writer = XmlWriter.Create (file, settings);\r
 220                         //Assert.IsFalse (object.ReferenceEquals (settings, writer.Settings), "#B1");\r
 221                         Assert.IsTrue (settings.CloseOutput, "#B2");\r
 222                         writer.Close ();\r
 223                         File.Delete (file);\r
 224 \r
 225                         writer = XmlWriter.Create (file, (XmlWriterSettings) null);\r
 226                         Assert.IsNotNull (writer.Settings, "#C1");\r
 227                         //Assert.IsTrue (writer.Settings.CloseOutput, "#C2");\r
 228                         writer.Close ();\r
 229                         File.Delete (file);\r
 230 \r
 231                         settings = new XmlWriterSettings ();\r
 232                         writer = XmlWriter.Create (file, settings);\r
 233                         //Assert.IsFalse (object.ReferenceEquals (settings, writer.Settings), "#D1");\r
 234                         //Assert.IsTrue (writer.Settings.CloseOutput, "#D2");\r
 235                         writer.Close ();\r
 236                         File.Delete (file);\r
 237 \r
 238                         writer = XmlWriter.Create (file);\r
 239                         Assert.IsNotNull (writer.Settings, "#E1");\r
 240                         //Assert.IsTrue (writer.Settings.CloseOutput, "#E2");\r
 241                         writer.Close ();\r
 242                         File.Delete (file);\r
 243                 }\r
 244 \r
 245                 [Test]\r
 246                 public void Create_Stream ()\r
 247                 {\r
 248                         MemoryStream ms = new MemoryStream ();\r
 249                         XmlWriter writer = XmlWriter.Create (ms);\r
 250                         Assert.IsNotNull (writer.Settings, "#A1");\r
 251                         Assert.IsFalse (writer.Settings.CloseOutput, "#A2");\r
 252                         writer.Close ();\r
 253                         Assert.IsTrue (ms.CanWrite, "#A3");\r
 254 \r
 255                         XmlWriterSettings settings = new XmlWriterSettings ();\r
 256                         settings.CloseOutput = true;\r
 257                         writer = XmlWriter.Create (ms, settings);\r
 258                         //Assert.IsFalse (object.ReferenceEquals (settings, writer.Settings), "#B1");\r
 259                         Assert.IsTrue (settings.CloseOutput, "#B2");\r
 260                         writer.Close ();\r
 261                         Assert.IsFalse (ms.CanWrite, "#B3");\r
 262 \r
 263                         ms = new MemoryStream ();\r
 264                         settings = new XmlWriterSettings ();\r
 265                         writer = XmlWriter.Create (ms, settings);\r
 266                         //Assert.IsFalse (object.ReferenceEquals (settings, writer.Settings), "#C1");\r
 267                         Assert.IsFalse (writer.Settings.CloseOutput, "#C2");\r
 268                         writer.Close ();\r
 269                         Assert.IsTrue (ms.CanWrite, "#C3");\r
 270 \r
 271                         ms = new MemoryStream ();\r
 272                         writer = XmlWriter.Create (ms, (XmlWriterSettings) null);\r
 273                         Assert.IsNotNull (writer.Settings, "#D1");\r
 274                         Assert.IsFalse (writer.Settings.CloseOutput, "#D2");\r
 275                         writer.Close ();\r
 276                         Assert.IsTrue (ms.CanWrite, "#D3");\r
 277                 }\r
 278 \r
 279                 [Test]\r
 280                 public void Create_TextWriter ()\r
 281                 {\r
 282                         MemoryStream ms = new MemoryStream ();\r
 283                         XmlWriter writer = XmlWriter.Create (new StreamWriter (ms));\r
 284                         Assert.IsNotNull (writer.Settings, "#A1");\r
 285                         Assert.IsFalse (writer.Settings.CloseOutput, "#A2");\r
 286                         writer.Close ();\r
 287                         Assert.IsTrue (ms.CanWrite, "#A3");\r
 288 \r
 289                         XmlWriterSettings settings = new XmlWriterSettings ();\r
 290                         settings.CloseOutput = true;\r
 291                         writer = XmlWriter.Create (new StreamWriter (ms), settings);\r
 292                         //Assert.IsFalse (object.ReferenceEquals (settings, writer.Settings), "#B1");\r
 293                         Assert.IsTrue (settings.CloseOutput, "#B2");\r
 294                         writer.Close ();\r
 295                         Assert.IsFalse (ms.CanWrite, "#B3");\r
 296 \r
 297                         ms = new MemoryStream ();\r
 298                         settings = new XmlWriterSettings ();\r
 299                         writer = XmlWriter.Create (new StreamWriter (ms), settings);\r
 300                         //Assert.IsFalse (object.ReferenceEquals (settings, writer.Settings), "#C1");\r
 301                         Assert.IsFalse (writer.Settings.CloseOutput, "#C2");\r
 302                         writer.Close ();\r
 303                         Assert.IsTrue (ms.CanWrite, "#C3");\r
 304 \r
 305                         ms = new MemoryStream ();\r
 306                         writer = XmlWriter.Create (new StreamWriter (ms), (XmlWriterSettings) null);\r
 307                         Assert.IsNotNull (writer.Settings, "#D1");\r
 308                         Assert.IsFalse (writer.Settings.CloseOutput, "#D2");\r
 309                         writer.Close ();\r
 310                         Assert.IsTrue (ms.CanWrite, "#D3");\r
 311                 }\r
 312 \r
 313                 [Test]\r
 314                 public void Create_XmlWriter ()\r
 315                 {\r
 316                         MemoryStream ms = new MemoryStream ();\r
 317                         XmlTextWriter xtw = new XmlTextWriter (ms, Encoding.UTF8);\r
 318                         XmlWriter writer = XmlWriter.Create (xtw);\r
 319                         Assert.IsNotNull (writer.Settings, "#A1");\r
 320                         Assert.IsFalse (writer.Settings.CloseOutput, "#A2");\r
 321                         writer.Close ();\r
 322                         Assert.IsFalse (ms.CanWrite, "#A3");\r
 323 \r
 324                         ms = new MemoryStream ();\r
 325                         xtw = new XmlTextWriter (ms, Encoding.UTF8);\r
 326                         XmlWriterSettings settings = new XmlWriterSettings ();\r
 327                         settings.CloseOutput = true;\r
 328                         writer = XmlWriter.Create (xtw, settings);\r
 329                         //Assert.IsFalse (object.ReferenceEquals (settings, writer.Settings), "#B1");\r
 330                         //Assert.IsFalse (writer.Settings.CloseOutput, "#B2");\r
 331                         writer.Close ();\r
 332                         Assert.IsFalse (ms.CanWrite, "#B3");\r
 333 \r
 334                         ms = new MemoryStream ();\r
 335                         xtw = new XmlTextWriter (ms, Encoding.UTF8);\r
 336                         settings = new XmlWriterSettings ();\r
 337                         writer = XmlWriter.Create (xtw, settings);\r
 338                         //Assert.IsFalse (object.ReferenceEquals (settings, writer.Settings), "#C1");\r
 339                         Assert.IsFalse (writer.Settings.CloseOutput, "#C2");\r
 340                         writer.Close ();\r
 341                         Assert.IsFalse (ms.CanWrite, "#C3");\r
 342 \r
 343                         ms = new MemoryStream ();\r
 344                         xtw = new XmlTextWriter (ms, Encoding.UTF8);\r
 345                         writer = XmlWriter.Create (xtw, (XmlWriterSettings) null);\r
 346                         Assert.IsNotNull (writer.Settings, "#D1");\r
 347                         Assert.IsFalse (writer.Settings.CloseOutput, "#D2");\r
 348                         writer.Close ();\r
 349                         Assert.IsFalse (ms.CanWrite, "#D3");\r
 350                 }\r
 351 \r
 352                 [Test]\r
 353                 public void Create_XmlWriter2 ()\r
 354                 {\r
 355                         MemoryStream ms = new MemoryStream ();\r
 356                         XmlWriterSettings settings = new XmlWriterSettings ();\r
 357                         XmlWriter xw = XmlWriter.Create (ms, settings);\r
 358                         XmlWriter writer = XmlWriter.Create (xw, new XmlWriterSettings ());\r
 359                         Assert.IsNotNull (writer.Settings, "#A1");\r
 360                         Assert.IsFalse (writer.Settings.CloseOutput, "#A2");\r
 361                         writer.Close ();\r
 362                         Assert.IsTrue (ms.CanWrite, "#A3");\r
 363 \r
 364                         ms = new MemoryStream ();\r
 365                         settings = new XmlWriterSettings ();\r
 366                         settings.CloseOutput = true;\r
 367                         settings.OmitXmlDeclaration = true;\r
 368                         xw = XmlWriter.Create (ms, settings);\r
 369                         writer = XmlWriter.Create (xw, new XmlWriterSettings ());\r
 370                         Assert.IsNotNull (writer.Settings, "#B1");\r
 371                         Assert.IsTrue (writer.Settings.CloseOutput, "#B2");\r
 372                         Assert.IsTrue (writer.Settings.OmitXmlDeclaration, "#B3");\r
 373                         writer.Close ();\r
 374                         Assert.IsFalse (ms.CanWrite, "#B3");\r
 375                 }\r
 376 \r
 377                 [Test]\r
 378                 [ExpectedException (typeof (XmlException))]\r
 379                 public void CreateWriter_AttributeNamespacesXmlnsXmlns ()\r
 380                 {\r
 381                         // Unlike XmlTextWriter, null namespace is not ignored.\r
 382                         XmlWriter w = XmlWriter.Create (new StringWriter ());\r
 383                         w.WriteStartElement ("foo");\r
 384                         w.WriteAttributeString ("xmlns", "xmlns", null, "http://abc.def");\r
 385                 }\r
 386 \r
 387                 XmlWriter CreateWriter (TextWriter tw)\r
 388                 {\r
 389                         XmlWriterSettings s = new XmlWriterSettings ();\r
 390                         s.OmitXmlDeclaration = true;\r
 391                         XmlWriter w = XmlWriter.Create (tw, s);\r
 392                         w.WriteStartElement ("root");\r
 393                         return w;\r
 394                 }\r
 395 \r
 396                 [Test]\r
 397                 [ExpectedException (typeof (ArgumentNullException))]\r
 398                 public void WriteValueNull ()\r
 399                 {\r
 400                         XmlWriter w = CreateWriter (TextWriter.Null);\r
 401                         w.WriteValue ((object) null);\r
 402                 }\r
 403 \r
 404                 [Test]\r
 405                 [ExpectedException (typeof (InvalidCastException))] // it throws somewhat funny exception\r
 406                 public void WriteValueNonExistentQName ()\r
 407                 {\r
 408                         XmlWriter w = CreateWriter (TextWriter.Null);\r
 409                         w.WriteValue (new XmlQualifiedName ("foo", "urn:foo"));\r
 410                 }\r
 411 \r
 412                 [Test]\r
 413                 public void WriteValueEmptyQName ()\r
 414                 {\r
 415                         StringWriter sw = new StringWriter ();\r
 416                         XmlWriter w = CreateWriter (sw);\r
 417                         w.WriteValue (XmlQualifiedName.Empty);\r
 418                         w.Close ();\r
 419                 }\r
 420 \r
 421                 [Test]\r
 422                 public void WriteValueQName ()\r
 423                 {\r
 424                         StringWriter sw = new StringWriter ();\r
 425                         XmlWriter w = CreateWriter (sw);\r
 426                         w.WriteAttributeString ("xmlns", "x", "http://www.w3.org/2000/xmlns/", "urn:foo");\r
 427                         w.WriteValue (new XmlQualifiedName ("foo", "urn:foo"));\r
 428                         w.Close ();\r
 429                         Assert.AreEqual ("<root xmlns:x=\"urn:foo\">x:foo</root>", sw.ToString ());\r
 430                 }\r
 431 \r
 432                 [Test]\r
 433                 public void WriteValueTimeSpan ()\r
 434                 {\r
 435                         StringWriter sw = new StringWriter ();\r
 436                         XmlWriter w = CreateWriter (sw);\r
 437                         w.WriteValue (TimeSpan.FromSeconds (5));\r
 438                         w.Close ();\r
 439                         Assert.AreEqual ("<root>PT5S</root>", sw.ToString ());\r
 440                 }\r
 441 \r
 442                 [Test]\r
 443                 public void WriteValueArray ()\r
 444                 {\r
 445                         StringWriter sw = new StringWriter ();\r
 446                         XmlWriter w = CreateWriter (sw);\r
 447                         w.WriteValue (new int [] {1, 2, 3});\r
 448                         w.WriteValue (new int [] {4, 5, 6});\r
 449                         w.Close ();\r
 450                         Assert.AreEqual ("<root>1 2 34 5 6</root>", sw.ToString ());\r
 451                 }\r
 452 \r
 453                 [Test]\r
 454                 [ExpectedException (typeof (InvalidCastException))] // it throws somewhat funny exception\r
 455                 public void WriteValueTextReader ()\r
 456                 {\r
 457                         // it is documented as supported, but actually isn't.\r
 458                         XmlWriter w = CreateWriter (TextWriter.Null);\r
 459                         w.WriteValue (new StringReader ("foobar"));\r
 460                 }\r
 461 \r
 462                 XPathNavigator GetNavigator (string xml)\r
 463                 {\r
 464                         return new XPathDocument (XmlReader.Create (\r
 465                                 new StringReader (xml))).CreateNavigator ();\r
 466                 }\r
 467 \r
 468                 string WriteNavigator (XPathNavigator nav, bool defattr)\r
 469                 {\r
 470                         StringWriter sw = new StringWriter ();\r
 471                         XmlWriterSettings settings = new XmlWriterSettings ();\r
 472                         settings.OmitXmlDeclaration = true;\r
 473                         settings.ConformanceLevel = ConformanceLevel.Fragment;\r
 474                         using (XmlWriter w = XmlWriter.Create (sw, settings)) {\r
 475                                 w.WriteNode (nav, defattr);\r
 476                         }\r
 477                         return sw.ToString ();\r
 478                 }\r
 479 \r
 480                 [Test]\r
 481                 public void WriteNodeNavigator1 ()\r
 482                 {\r
 483                         XPathNavigator nav = GetNavigator ("<root>test<!-- comment --></root>");\r
 484                         // at Root\r
 485                         AssertType.AreEqual ("<root>test<!-- comment --></root>", WriteNavigator (nav, false), "#1");\r
 486                         // at document element\r
 487                         nav.MoveToFirstChild ();\r
 488                         AssertType.AreEqual ("<root>test<!-- comment --></root>", WriteNavigator (nav, false), "#2");\r
 489                         // at text\r
 490                         nav.MoveToFirstChild ();\r
 491                         AssertType.AreEqual ("test", WriteNavigator (nav, false), "#3");\r
 492 \r
 493                         // at comment\r
 494                         nav.MoveToNext ();\r
 495                         AssertType.AreEqual ("<!-- comment -->", WriteNavigator (nav, false), "#4");\r
 496                 }\r
 497 \r
 498                 string WriteSubtree (XPathNavigator nav)\r
 499                 {\r
 500                         StringWriter sw = new StringWriter ();\r
 501                         XmlWriterSettings settings = new XmlWriterSettings ();\r
 502                         settings.OmitXmlDeclaration = true;\r
 503                         settings.ConformanceLevel = ConformanceLevel.Fragment;\r
 504                         using (XmlWriter w = XmlWriter.Create (sw, settings)) {\r
 505                                 nav.WriteSubtree(w);\r
 506                         }\r
 507                         return sw.ToString ();\r
 508                 }\r
 509 \r
 510                 [Test]\r
 511                 public void NavigatorWriteSubtree1 ()\r
 512                 {\r
 513                         XPathNavigator nav = GetNavigator ("<root>test<!-- comment --></root>");\r
 514                         // at Root\r
 515                         AssertType.AreEqual ("<root>test<!-- comment --></root>", WriteSubtree (nav), "#1");\r
 516                         // at document element\r
 517                         nav.MoveToFirstChild ();\r
 518                         AssertType.AreEqual ("<root>test<!-- comment --></root>", WriteSubtree (nav), "#2");\r
 519                         // at text\r
 520                         nav.MoveToFirstChild ();\r
 521                         AssertType.AreEqual ("test", WriteSubtree (nav), "#3");\r
 522 \r
 523                         // at comment\r
 524                         nav.MoveToNext ();\r
 525                         AssertType.AreEqual ("<!-- comment -->", WriteSubtree (nav), "#4");\r
 526                 }\r
 527 \r
 528                 [Test]\r
 529                 public void WriteNodeXPathNavigator ()\r
 530                 {\r
 531                         string xml = "<A xmlns='urn:x'><B xmlns='urn:y' /></A>";\r
 532                         XPathNavigator nav = new XPathDocument (new StringReader(xml)).CreateNavigator ();\r
 533                         XmlWriterSettings s = new XmlWriterSettings ();\r
 534                         s.OmitXmlDeclaration = true;\r
 535                         StringWriter sw = new StringWriter ();\r
 536                         XmlWriter w = XmlWriter.Create (sw, s);\r
 537                         w.WriteNode (nav, false);\r
 538                         w.Close ();\r
 539                         AssertType.AreEqual ("<A xmlns=\"urn:x\"><B xmlns=\"urn:y\" /></A>", sw.ToString ());\r
 540                 }\r
 541 \r
 542                 [Test]\r
 543                 public void WriteNodeXPathNavigatorAttribute ()\r
 544                 {\r
 545                         string xml = "<!DOCTYPE root [<!ELEMENT root EMPTY> <!ATTLIST root implicit NMTOKEN 'nam'>]><root attr='val' />";\r
 546                         XPathNavigator nav = new XPathDocument (new StringReader (xml)).CreateNavigator ();\r
 547                         XmlWriterSettings s = new XmlWriterSettings ();\r
 548                         s.OmitXmlDeclaration = true;\r
 549                         StringWriter sw = new StringWriter ();\r
 550                         XmlWriter w = XmlWriter.Create (sw, s);\r
 551                         w.WriteStartElement ("hoge");\r
 552                         nav.MoveToFirstChild ();\r
 553                         nav.MoveToFirstAttribute ();\r
 554                         w.WriteNode (nav, false);\r
 555                         nav.MoveToNextAttribute ();\r
 556                         w.WriteNode (nav, false);\r
 557                         w.Close ();\r
 558                         AssertType.AreEqual ("<hoge />", sw.ToString ());\r
 559                 }\r
 560 \r
 561                 [Test]\r
 562                 public void WriteStringDifferentBehavior ()\r
 563                 {\r
 564                         // Messy implementation difference.\r
 565                         // from XmlTextWriter -> <foo />\r
 566                         // from XmlWriter.XCreate() -> <foo></foo>\r
 567                         var sw = new StringWriter ();\r
 568                         var xw = XmlWriter.Create (sw);\r
 569                         xw.WriteStartElement ("foo");\r
 570                         xw.WriteString ("");\r
 571                         xw.WriteEndElement ();\r
 572                         xw.Close ();\r
 573                         AssertType.AreEqual ("<?xml version='1.0' encoding='utf-16'?><foo></foo>".Replace ('\'', '"'), sw.ToString ());\r
 574                 }\r
 575 \r
 576                 //          |       |      |returns the same reader\r
 577                 // source   |wrapper|result| |checks state (and err)\r
 578                 // overrides|setting|      | | |test name\r
 579                 // ---------+----------------------------\r
 580                 //      -   | -(Doc)| Doc  | |x|0:CreateNOCL\r
 581                 //          | Auto  | Doc  | |x|1:CreateNOCLSettingsCLAuto\r
 582                 //          | Doc   | Doc  | |x|2:CreateNOCLSettingsCLDoc\r
 583                 //          | Frag  | Doc  | |x|3:CreateNOCLSettingsCLFrag\r
 584                 // Auto     | -(Doc)| Doc  | | |4:CreateCLAuto\r
 585                 //          | Auto  | Auto |=|x|5:CreateCLAutoSettingsCLAuto\r
 586                 //          | Doc   | Doc  | | |6:CreateCLAutoSettingsCLDoc\r
 587                 //          | Frag  | Frag | | |7:CreateCLAutoSettingsCLFrag\r
 588                 // Document | -(Doc)| Doc  |=|x|8:CreateCLDoc\r
 589                 //          | Auto  | Doc  |=|x|9:CreateCLDocSettingsCLAuto\r
 590                 //          | Doc   | Doc  |=|x|A:CreateCLDocSettingsCLDoc\r
 591                 //          | Frag  | Frag | | |B:CreateCLDocSettingsCLFrag\r
 592                 // Fragment | -(Doc)| Doc  | | |C:CreateCLFrag\r
 593                 //          | Auto  | Frag |=|x|D:CreateCLFragSettingsCLAuto\r
 594                 //          | Doc   | Doc  | | |E:CreateCLFragSettingsCLDoc\r
 595                 //          | Frag  | Frag |=|x|F:CreateCLFragSettingsCLFrag\r
 596                 //\r
 597                 // What we can see from above:\r
 598                 // - default ConformanceLevel is Document. (0 4 8 C)\r
 599                 // - If wrapper is Auto, it delegates to source. (1 5 9 D)\r
 600                 //   - Auto can happen only if both inputs are Auto (5)\r
 601                 // - If wrapper is Frag, all but default becomes Frag (7 B F)\r
 602                 //   - with default it becomes Document (3)\r
 603                 //     So a default value is likely stronger(!)\r
 604                 // - Basically, when there is no difference between the wrapper\r
 605                 //   and the source settings, it does not create wrapper.\r
 606 \r
 607                 [Test]\r
 608                 public void CreateCLAuto ()\r
 609                 {\r
 610                         ConformanceLevelAuto cl = new ConformanceLevelAuto ();\r
 611                         XmlWriter xw = XmlWriter.Create (cl);\r
 612                         Assert.AreEqual (ConformanceLevel.Document, xw.Settings.ConformanceLevel, "#1");\r
 613                         Assert.AreNotEqual (xw, cl, "#2");\r
 614                         WriteState state = xw.WriteState;\r
 615                 }\r
 616 \r
 617                 [Test]\r
 618                 [ExpectedException (typeof (InvalidOperationException))]\r
 619                 public void CreateCLDoc ()\r
 620                 {\r
 621                         ConformanceLevelDocument cl = new ConformanceLevelDocument ();\r
 622                         XmlWriter xw = XmlWriter.Create (cl);\r
 623                         Assert.AreEqual (ConformanceLevel.Document, xw.Settings.ConformanceLevel, "#1");\r
 624                         Assert.AreEqual (xw, cl, "#2"); // equal\r
 625                         WriteState state = xw.WriteState;\r
 626                 }\r
 627 \r
 628                 [Test]\r
 629                 public void CreateCLFrag ()\r
 630                 {\r
 631                         ConformanceLevelFragment cl = new ConformanceLevelFragment ();\r
 632                         XmlWriter xw = XmlWriter.Create (cl);\r
 633                         Assert.AreEqual (ConformanceLevel.Document, xw.Settings.ConformanceLevel, "#1");\r
 634                         Assert.AreNotEqual (xw, cl, "#2");\r
 635                         WriteState state = xw.WriteState;\r
 636                 }\r
 637 \r
 638                 [Test]\r
 639                 [ExpectedException (typeof (InvalidOperationException))]\r
 640                 public void CreateNOCL ()\r
 641                 {\r
 642                         InvalidWriteState cl = new InvalidWriteState ();\r
 643                         Assert.IsNull (cl.Settings, "#0");\r
 644                         XmlWriter xw = XmlWriter.Create (cl);\r
 645                         Assert.AreEqual (ConformanceLevel.Document, xw.Settings.ConformanceLevel, "#1");\r
 646                         Assert.AreNotEqual (xw, cl, "#2");\r
 647                         WriteState state = xw.WriteState;\r
 648                 }\r
 649 \r
 650                 [Test]\r
 651                 [ExpectedException (typeof (InvalidOperationException))]\r
 652                 public void CreateNOCLSettingsCLAuto ()\r
 653                 {\r
 654                         InvalidWriteState cl = new InvalidWriteState ();\r
 655                         XmlWriter xw = XmlWriter.Create (cl, new XmlWriterSettings () { ConformanceLevel = ConformanceLevel.Auto });\r
 656                         Assert.AreEqual (ConformanceLevel.Document, xw.Settings.ConformanceLevel, "#1");\r
 657                         Assert.AreNotEqual (xw, cl, "#2");\r
 658                         WriteState state = xw.WriteState;\r
 659                 }\r
 660 \r
 661                 [Test]\r
 662                 [ExpectedException (typeof (InvalidOperationException))]\r
 663                 public void CreateNOCLSettingsCLDoc ()\r
 664                 {\r
 665                         InvalidWriteState cl = new InvalidWriteState ();\r
 666                         XmlWriter xw = XmlWriter.Create (cl, new XmlWriterSettings () { ConformanceLevel = ConformanceLevel.Document });\r
 667                         Assert.AreEqual (ConformanceLevel.Document, xw.Settings.ConformanceLevel, "#1");\r
 668                         Assert.AreNotEqual (xw, cl, "#2");\r
 669                         WriteState state = xw.WriteState;\r
 670                 }\r
 671 \r
 672                 [Test]\r
 673                 [ExpectedException (typeof (InvalidOperationException))]\r
 674                 public void CreateNOCLSettingsCLFrag ()\r
 675                 {\r
 676                         InvalidWriteState cl = new InvalidWriteState ();\r
 677                         XmlWriter xw = XmlWriter.Create (cl, new XmlWriterSettings () { ConformanceLevel = ConformanceLevel.Fragment });\r
 678                         Assert.AreEqual (ConformanceLevel.Document, xw.Settings.ConformanceLevel, "#1");\r
 679                         Assert.AreNotEqual (xw, cl, "#2");\r
 680                         WriteState state = xw.WriteState;\r
 681                 }\r
 682 \r
 683                 [Test]\r
 684                 [ExpectedException (typeof (InvalidOperationException))]\r
 685                 public void CreateCLAutoSettingsCLAuto ()\r
 686                 {\r
 687                         ConformanceLevelAuto cl = new ConformanceLevelAuto ();\r
 688                         XmlWriter xw = XmlWriter.Create (cl, new XmlWriterSettings () { ConformanceLevel = ConformanceLevel.Auto });\r
 689                         Assert.AreEqual (ConformanceLevel.Auto, xw.Settings.ConformanceLevel, "#1");\r
 690                         Assert.AreEqual (xw, cl, "#2"); // equal\r
 691                         WriteState state = xw.WriteState;\r
 692                 }\r
 693 \r
 694                 [Test]\r
 695                 public void CreateCLAutoSettingsCLDoc ()\r
 696                 {\r
 697                         ConformanceLevelAuto cl = new ConformanceLevelAuto ();\r
 698                         XmlWriter xw = XmlWriter.Create (cl, new XmlWriterSettings () { ConformanceLevel = ConformanceLevel.Document });\r
 699                         Assert.AreEqual (ConformanceLevel.Document, xw.Settings.ConformanceLevel, "#1");\r
 700                         Assert.AreNotEqual (xw, cl, "#2");\r
 701                         WriteState state = xw.WriteState;\r
 702                 }\r
 703 \r
 704                 [Test]\r
 705                 public void CreateCLAutoSettingsCLFrag ()\r
 706                 {\r
 707                         ConformanceLevelAuto cl = new ConformanceLevelAuto ();\r
 708                         XmlWriter xw = XmlWriter.Create (cl, new XmlWriterSettings () { ConformanceLevel = ConformanceLevel.Fragment });\r
 709                         Assert.AreEqual (ConformanceLevel.Fragment, xw.Settings.ConformanceLevel, "#1");\r
 710                         Assert.AreNotEqual (xw, cl, "#2");\r
 711                         WriteState state = xw.WriteState;\r
 712                 }\r
 713 \r
 714                 [Test]\r
 715                 [ExpectedException (typeof (InvalidOperationException))]\r
 716                 public void CreateCLDocSettingsCLAuto ()\r
 717                 {\r
 718                         ConformanceLevelDocument cl = new ConformanceLevelDocument ();\r
 719                         XmlWriter xw = XmlWriter.Create (cl, new XmlWriterSettings () { ConformanceLevel = ConformanceLevel.Auto });\r
 720                         Assert.AreEqual (ConformanceLevel.Document, xw.Settings.ConformanceLevel, "#1");\r
 721                         Assert.AreEqual (xw, cl, "#2"); // equal\r
 722                         WriteState state = xw.WriteState;\r
 723                 }\r
 724 \r
 725                 [Test]\r
 726                 [ExpectedException (typeof (InvalidOperationException))]\r
 727                 public void CreateCLDocSettingsCLDoc ()\r
 728                 {\r
 729                         ConformanceLevelDocument cl = new ConformanceLevelDocument ();\r
 730                         XmlWriter xw = XmlWriter.Create (cl, new XmlWriterSettings () { ConformanceLevel = ConformanceLevel.Document });\r
 731                         Assert.AreEqual (ConformanceLevel.Document, xw.Settings.ConformanceLevel, "#1");\r
 732                         Assert.AreEqual (xw, cl, "#2"); // equal\r
 733                         WriteState state = xw.WriteState;\r
 734                 }\r
 735 \r
 736                 [Test]\r
 737                 public void CreateCLDocSettingsCLFrag ()\r
 738                 {\r
 739                         ConformanceLevelDocument cl = new ConformanceLevelDocument ();\r
 740                         XmlWriter xw = XmlWriter.Create (cl, new XmlWriterSettings () { ConformanceLevel = ConformanceLevel.Fragment });\r
 741                         Assert.AreEqual (ConformanceLevel.Fragment, xw.Settings.ConformanceLevel, "#1");\r
 742                         Assert.AreNotEqual (xw, cl, "#2");\r
 743                         WriteState state = xw.WriteState;\r
 744                 }\r
 745 \r
 746                 [Test]\r
 747                 [ExpectedException (typeof (InvalidOperationException))]\r
 748                 public void CreateCLFragSettingsCLAuto ()\r
 749                 {\r
 750                         ConformanceLevelFragment cl = new ConformanceLevelFragment ();\r
 751                         XmlWriter xw = XmlWriter.Create (cl, new XmlWriterSettings () { ConformanceLevel = ConformanceLevel.Auto });\r
 752                         Assert.AreEqual (ConformanceLevel.Fragment, xw.Settings.ConformanceLevel, "#1");\r
 753                         Assert.AreEqual (xw, cl, "#2"); // equal\r
 754                         WriteState state = xw.WriteState;\r
 755                 }\r
 756 \r
 757                 [Test]\r
 758                 public void CreateCLFragSettingsCLDoc ()\r
 759                 {\r
 760                         ConformanceLevelFragment cl = new ConformanceLevelFragment ();\r
 761                         XmlWriter xw = XmlWriter.Create (cl, new XmlWriterSettings () { ConformanceLevel = ConformanceLevel.Document });\r
 762                         Assert.AreEqual (ConformanceLevel.Document, xw.Settings.ConformanceLevel, "#1");\r
 763                         Assert.AreNotEqual (xw, cl, "#2");\r
 764                         WriteState state = xw.WriteState;\r
 765                 }\r
 766 \r
 767                 [Test]\r
 768                 [ExpectedException (typeof (InvalidOperationException))]\r
 769                 public void CreateCLFragSettingsCLFrag ()\r
 770                 {\r
 771                         ConformanceLevelFragment cl = new ConformanceLevelFragment ();\r
 772                         XmlWriter xw = XmlWriter.Create (cl, new XmlWriterSettings () { ConformanceLevel = ConformanceLevel.Fragment });\r
 773                         Assert.AreEqual (ConformanceLevel.Fragment, xw.Settings.ConformanceLevel, "#1");\r
 774                         Assert.AreEqual (xw, cl, "#2"); // equal\r
 775                         WriteState state = xw.WriteState;\r
 776                 }\r
 777 \r
 778 \r
 779         }\r
 780 \r
 781         internal class DefaultXmlWriter : XmlWriter\r
 782         {\r
 783                 public DefaultXmlWriter () : base ()\r
 784                 {\r
 785                 }\r
 786 \r
 787                 public override void Close ()\r
 788                 {\r
 789                 }\r
 790 \r
 791                 public override void Flush ()\r
 792                 {\r
 793                 }\r
 794 \r
 795                 public override string LookupPrefix (string ns)\r
 796                 {\r
 797                         return null;\r
 798                 }\r
 799 \r
 800                 public override void WriteBase64 (byte [] buffer, int index, int count)\r
 801                 {\r
 802                 }\r
 803 \r
 804                 public override void WriteBinHex (byte [] buffer, int index, int count)\r
 805                 {\r
 806                 }\r
 807 \r
 808                 public override void WriteCData (string text)\r
 809                 {\r
 810                 }\r
 811 \r
 812                 public override void WriteCharEntity (char ch)\r
 813                 {\r
 814                 }\r
 815 \r
 816                 public override void WriteChars (char [] buffer, int index, int count)\r
 817                 {\r
 818                 }\r
 819 \r
 820                 public override void WriteComment (string text)\r
 821                 {\r
 822                 }\r
 823 \r
 824                 public override void WriteDocType (string name, string pubid, string sysid, string subset)\r
 825                 {\r
 826                 }\r
 827 \r
 828                 public override void WriteEndAttribute ()\r
 829                 {\r
 830                 }\r
 831 \r
 832                 public override void WriteEndDocument ()\r
 833                 {\r
 834                 }\r
 835 \r
 836                 public override void WriteEndElement ()\r
 837                 {\r
 838                 }\r
 839 \r
 840                 public override void WriteEntityRef (string name)\r
 841                 {\r
 842                 }\r
 843 \r
 844                 public override void WriteFullEndElement ()\r
 845                 {\r
 846                 }\r
 847 \r
 848                 public override void WriteName (string name)\r
 849                 {\r
 850                 }\r
 851 \r
 852                 public override void WriteNmToken (string name)\r
 853                 {\r
 854                 }\r
 855 \r
 856                 public override void WriteNode (XmlReader reader, bool defattr)\r
 857                 {\r
 858                 }\r
 859 \r
 860                 public override void WriteProcessingInstruction (string name, string text)\r
 861                 {\r
 862                 }\r
 863 \r
 864                 public override void WriteQualifiedName (string localName, string ns)\r
 865                 {\r
 866                 }\r
 867 \r
 868                 public override void WriteRaw (string data)\r
 869                 {\r
 870                 }\r
 871 \r
 872                 public override void WriteRaw (char [] buffer, int index, int count)\r
 873                 {\r
 874                 }\r
 875 \r
 876                 public override void WriteStartAttribute (string prefix, string localName, string ns)\r
 877                 {\r
 878                 }\r
 879 \r
 880                 public override void WriteStartDocument (bool standalone)\r
 881                 {\r
 882                 }\r
 883 \r
 884                 public override void WriteStartDocument ()\r
 885                 {\r
 886                 }\r
 887 \r
 888                 public override void WriteStartElement (string prefix, string localName, string ns)\r
 889                 {\r
 890                 }\r
 891 \r
 892                 public override void WriteString (string text)\r
 893                 {\r
 894                 }\r
 895 \r
 896                 public override void WriteSurrogateCharEntity (char lowChar, char highChar)\r
 897                 {\r
 898                 }\r
 899 \r
 900                 public override void WriteWhitespace (string ws)\r
 901                 {\r
 902                 }\r
 903 \r
 904                 public override WriteState WriteState {\r
 905                         get {\r
 906                                 return WriteState.Start;\r
 907                         }\r
 908                 }\r
 909 \r
 910                 public override string XmlLang {\r
 911                         get {\r
 912                                 return null;\r
 913                         }\r
 914                 }\r
 915 \r
 916                 public override XmlSpace XmlSpace {\r
 917                         get {\r
 918                                 return XmlSpace.None;\r
 919                         }\r
 920                 }\r
 921 \r
 922         }\r
 923 \r
 924 \r
 925         class InvalidWriteState : XmlWriter {\r
 926                 public override void Close () { }\r
 927                 public override void Flush () { }\r
 928                 public override string LookupPrefix (string ns) { return null; }\r
 929                 public override void WriteBase64 (byte [] buffer, int index, int count) { }\r
 930                 public override void WriteCData (string text) { }\r
 931                 public override void WriteCharEntity (char ch) { }\r
 932                 public override void WriteChars (char [] buffer, int index, int count) { }\r
 933                 public override void WriteComment (string text) { }\r
 934                 public override void WriteDocType (string name, string pubid, string sysid, string subset) { }\r
 935                 public override void WriteEndAttribute () { }\r
 936                 public override void WriteEndDocument () { }\r
 937                 public override void WriteEndElement () { }\r
 938                 public override void WriteEntityRef (string name) { }\r
 939                 public override void WriteFullEndElement () { }\r
 940                 public override void WriteProcessingInstruction (string name, string text) {}\r
 941                 public override void WriteRaw (string data) {}\r
 942                 public override void WriteRaw (char [] buffer, int index, int count) {}\r
 943                 public override void WriteStartAttribute (string prefix, string localName, string ns) {}\r
 944                 public override void WriteStartDocument (bool standalone) {}\r
 945                 public override void WriteStartDocument () {}\r
 946                 public override void WriteStartElement (string prefix, string localName, string ns) {}\r
 947                 public override void WriteString (string text) {}\r
 948                 public override void WriteSurrogateCharEntity (char lowChar, char highChar) {}\r
 949                 public override void WriteWhitespace (string ws) {}\r
 950 \r
 951                 public override WriteState WriteState {\r
 952                         get { throw new InvalidOperationException (); }\r
 953                 }\r
 954         }\r
 955 \r
 956         class ConformanceLevelAuto : InvalidWriteState {\r
 957                 public override XmlWriterSettings Settings {\r
 958                         get {\r
 959                                 return new XmlWriterSettings () { ConformanceLevel = ConformanceLevel.Auto };\r
 960                         }\r
 961                 }\r
 962         }\r
 963 \r
 964         class ConformanceLevelDocument : InvalidWriteState {\r
 965                 public override XmlWriterSettings Settings {\r
 966                         get {\r
 967                                 return new XmlWriterSettings () { ConformanceLevel = ConformanceLevel.Document };\r
 968                         }\r
 969                 }\r
 970         }\r
 971 \r
 972         class ConformanceLevelFragment : InvalidWriteState {\r
 973                 public override XmlWriterSettings Settings {\r
 974                         get {\r
 975                                 return new XmlWriterSettings () { ConformanceLevel = ConformanceLevel.Fragment };\r
 976                         }\r
 977                 }\r
 978         }\r
 979 \r
 980 }\r
 981 \r