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

   1 //
   2 // System.Xml.XmlWriterSettingsTests.cs
   3 //
   4 // Authors:
   5 //      Atsushi Enomoto <atsushi@ximian.com>
   6 //
   7 // (C)2004 Novell Inc.
   8 //
   9
  10 using System;
  11 using System.IO;
  12 using System.Text;
  13 using System.Xml;
  14 using System.Xml.Schema;
  15 using NUnit.Framework;
  16
  17 namespace MonoTests.System.Xml
  18 {
  19         [TestFixture]
  20         public class XmlWriterSettingsTests
  21         {
  22                 [Test]
  23                 public void DefaultValue ()
  24                 {
  25                         XmlWriterSettings s = new XmlWriterSettings ();
  26                         DefaultValue (s);
  27                         s.Reset ();
  28                         DefaultValue (s);
  29                 }
  30
  31                 private void DefaultValue (XmlWriterSettings s)
  32                 {
  33                         Assert.AreEqual (true, s.CheckCharacters);
  34                         Assert.AreEqual (false, s.CloseOutput);
  35                         Assert.AreEqual (ConformanceLevel.Document, s.ConformanceLevel);
  36                         Assert.AreEqual (Encoding.UTF8, s.Encoding);
  37                         Assert.AreEqual (false, s.Indent);
  38                         Assert.AreEqual ("  ", s.IndentChars);
  39                         Assert.AreEqual (Environment.NewLine, s.NewLineChars);
  40                         Assert.AreEqual (false, s.NewLineOnAttributes);
  41                         Assert.AreEqual (false, s.OmitXmlDeclaration);
  42                         Assert.AreEqual (NewLineHandling.Replace, s.NewLineHandling);
  43                         Assert.IsFalse (s.Async);
  44                 }
  45
  46                 [Test]
  47                 [Category ("MobileNotWorking")]
  48                 public void EncodingTest ()
  49                 {
  50                         // For Stream it makes sense
  51                         XmlWriterSettings s = new XmlWriterSettings ();
  52                         s.Encoding = Encoding.GetEncoding ("shift_jis");
  53                         MemoryStream ms = new MemoryStream ();
  54                         XmlWriter w = XmlWriter.Create (ms, s);
  55                         w.WriteStartElement ("root");
  56                         w.WriteEndElement ();
  57                         w.Close ();
  58                         byte [] data = ms.ToArray ();
  59                         Assert.IsTrue (data.Length != 0);
  60                         string str = s.Encoding.GetString (data);
  61                         Assert.AreEqual ("<?xml version=\"1.0\" encoding=\"shift_jis\"?><root />", str);
  62
  63                         // For TextWriter it does not make sense
  64                         StringWriter sw = new StringWriter ();
  65                         w = XmlWriter.Create (sw, s);
  66                         w.WriteStartElement ("root");
  67                         w.WriteEndElement ();
  68                         w.Close ();
  69                         Assert.AreEqual ("<?xml version=\"1.0\" encoding=\"utf-16\"?><root />", sw.ToString ());
  70                 }
  71
  72                 [Test]
  73                 [ExpectedException (typeof (ArgumentException))]
  74                 public void CheckCharactersTest ()
  75                 {
  76                         XmlWriterSettings s = new XmlWriterSettings ();
  77                         StringWriter sw = new StringWriter ();
  78                         XmlWriter w = XmlWriter.Create (sw, s);
  79                         w.WriteStartElement ("root");
  80                         w.WriteString ("\0"); // invalid
  81                         w.WriteEndElement ();
  82                         w.Close ();
  83                 }
  84
  85                 [Test]
  86                 public void CheckCharactersFalseTest ()
  87                 {
  88                         XmlWriterSettings s = new XmlWriterSettings ();
  89                         s.CheckCharacters = false;
  90                         StringWriter sw = new StringWriter ();
  91                         XmlWriter w = XmlWriter.Create (sw, s);
  92                         w.WriteStartElement ("root");
  93                         w.WriteString ("\0"); // invalid
  94                         w.WriteEndElement ();
  95                 }
  96
  97                 [Test]
  98                 [ExpectedException (typeof (ObjectDisposedException))]
  99                 public void CloseOutputTest ()
 100                 {
 101                         XmlWriterSettings s = new XmlWriterSettings ();
 102                         s.CloseOutput = true;
 103                         StringWriter sw = new StringWriter ();
 104                         XmlWriter w = XmlWriter.Create (sw, s);
 105                         w.WriteStartElement ("root");
 106                         w.WriteEndElement ();
 107                         w.Close ();
 108                         sw.Write ("more"); // not allowed
 109                 }
 110
 111                 [Test]
 112                 [ExpectedException (typeof (InvalidOperationException))]
 113                 public void ConformanceLevelFragmentAndWriteStartDocument ()
 114                 {
 115                         XmlWriterSettings s = new XmlWriterSettings ();
 116                         s.ConformanceLevel = ConformanceLevel.Fragment;
 117                         s.OmitXmlDeclaration = true;
 118                         XmlWriter w = XmlWriter.Create (Console.Out, s);
 119                         w.WriteStartDocument ();
 120                 }
 121
 122                 [Test]
 123                 public void ConformanceLevelAuto ()
 124                 {
 125                         XmlWriterSettings s = new XmlWriterSettings ();
 126                         s.ConformanceLevel = ConformanceLevel.Auto;
 127                         StringWriter sw = new StringWriter ();
 128                         XmlWriter w = XmlWriter.Create (sw, s);
 129                         w.WriteElementString ("foo", "");
 130                         w.Close ();
 131                         Assert.AreEqual ("<foo />", sw.ToString ());
 132                 }
 133
 134                 [Test]
 135                 public void ConformanceLevelAuto_WriteStartDocument ()
 136                 {
 137                         XmlWriterSettings s = new XmlWriterSettings ();
 138                         s.ConformanceLevel = ConformanceLevel.Auto;
 139                         StringWriter sw = new StringWriter ();
 140                         XmlWriter w = XmlWriter.Create (sw, s);
 141                         w.WriteStartDocument ();
 142                         w.WriteElementString ("foo", "");
 143                         w.Close ();
 144                         Assert.AreEqual ("<?xml version=\"1.0\" encoding=\"utf-16\"?><foo />", sw.ToString ());
 145                 }
 146
 147                 [Test]
 148                 public void ConformanceLevelAuto_OmitXmlDecl_WriteStartDocument ()
 149                 {
 150                         XmlWriterSettings s = new XmlWriterSettings ();
 151                         s.ConformanceLevel = ConformanceLevel.Auto;
 152                         s.OmitXmlDeclaration = true;
 153                         StringWriter sw = new StringWriter ();
 154                         XmlWriter w = XmlWriter.Create (sw, s);
 155                         w.WriteStartDocument ();
 156                         w.WriteElementString ("foo", "");
 157                         w.Close ();
 158                         Assert.AreEqual ("<foo />", sw.ToString ());
 159                 }
 160
 161                 [Test]
 162                 public void ConformanceLevelDocument_OmitXmlDeclDeclaration ()
 163                 {
 164                         XmlWriterSettings s = new XmlWriterSettings ();
 165                         s.ConformanceLevel = ConformanceLevel.Document;
 166                         // LAMESPEC:
 167                         // On MSDN, XmlWriterSettings.OmitXmlDeclaration is documented as:
 168                         // "The XML declaration is always written if
 169                         //  ConformanceLevel is set to Document, even
 170                         //  if OmitXmlDeclaration is set to true. "
 171                         // but it is incorrect. It does consider
 172                         // OmitXmlDeclaration property.
 173                         s.OmitXmlDeclaration = true;
 174                         StringWriter sw = new StringWriter ();
 175                         XmlWriter w = XmlWriter.Create (sw, s);
 176                         w.WriteElementString ("foo", "");
 177                         w.Close ();
 178                         Assert.AreEqual ("<foo />", sw.ToString ());
 179                 }
 180
 181                 [Test]
 182                 public void IndentationAndFormatting ()
 183                 {
 184                         // Test for Indent, IndentChars, NewLineOnAttributes,
 185                         // NewLineChars and OmitXmlDeclaration.
 186                         string output = "<root\n    attr=\"value\"\n    attr2=\"value\">\n    <child>test</child>\n</root>";
 187                         XmlWriterSettings s = new XmlWriterSettings ();
 188                         s.OmitXmlDeclaration = true;
 189                         s.Indent = true;
 190                         s.IndentChars = "    ";
 191                         s.NewLineChars = "\n";
 192                         s.NewLineOnAttributes = true;
 193                         StringWriter sw = new StringWriter ();
 194                         XmlWriter w = XmlWriter.Create (sw, s);
 195                         w.WriteStartElement ("root");
 196                         w.WriteAttributeString ("attr", "value");
 197                         w.WriteAttributeString ("attr2", "value");
 198                         w.WriteStartElement ("child");
 199                         w.WriteString ("test");
 200                         w.WriteEndElement ();
 201                         w.WriteEndElement ();
 202                         w.Close ();
 203                         Assert.AreEqual (output, sw.ToString ());
 204                 }
 205
 206                 [Test]
 207                 public void SetEncodingNull ()
 208                 {
 209                         // null is allowed.
 210                         new XmlWriterSettings ().Encoding = null;
 211                 }
 212
 213                 [Test]
 214                 [ExpectedException (typeof (ArgumentNullException))]
 215                 public void NewLineCharsNull ()
 216                 {
 217                         new XmlWriterSettings ().NewLineChars = null;
 218                 }
 219
 220                 [Test]
 221                 public void CreateOmitXmlDeclaration ()
 222                 {
 223                         StringBuilder sb = new StringBuilder ();
 224                         // Even if XmlWriter is allowed to write fragment,
 225                         // DataContractSerializer never allows it to write
 226                         // content in contentOnly mode.
 227                         XmlWriterSettings settings = new XmlWriterSettings ();
 228                         settings.OmitXmlDeclaration = true;
 229                         //settings.ConformanceLevel = ConformanceLevel.Fragment;
 230                         XmlWriter w = XmlWriter.Create (sb, settings);
 231                         w.WriteStartElement ("root");
 232                         w.WriteEndElement ();
 233                         w.Flush ();
 234                         Assert.AreEqual ("<root />", sb.ToString ());
 235                 }
 236
 237                 [Test]
 238                 public void NewLineOnAttributesMixedContent ()
 239                 {
 240                         StringWriter sw = new StringWriter ();
 241                         XmlWriterSettings s = new XmlWriterSettings ();
 242                         s.NewLineOnAttributes = true;
 243                         s.OmitXmlDeclaration = true;
 244                         XmlWriter w = XmlWriter.Create (sw, s);
 245                         w.WriteStartElement ("root");
 246                         w.WriteAttributeString ("a", "v");
 247                         w.WriteAttributeString ("b", "x");
 248                         w.WriteString ("some string");
 249                         w.WriteEndElement ();
 250                         w.Close ();
 251                         Assert.AreEqual ("<root a=\"v\" b=\"x\">some string</root>", sw.ToString (), "#1");
 252
 253                         // mixed content: bug #81770
 254                         string expected = "<root>some string<mixed\n    a=\"v\"\n    b=\"x\">some string</mixed></root>";
 255                         s.Indent = true;
 256                         sw = new StringWriter ();
 257                         w = XmlWriter.Create (sw, s);
 258                         w.WriteStartElement ("root");
 259                         w.WriteString ("some string");
 260                         w.WriteStartElement ("mixed");
 261                         w.WriteAttributeString ("a", "v");
 262                         w.WriteAttributeString ("b", "x");
 263                         w.WriteString ("some string");
 264                         w.WriteEndElement ();
 265                         w.WriteEndElement ();
 266                         w.Close ();
 267                         Assert.AreEqual (expected, sw.ToString ().Replace ("\r\n", "\n"), "#2");
 268                 }
 269
 270                 [Test]
 271                 public void OmitXmlDeclarationAndNewLine ()
 272                 {
 273                         XmlDocument doc = new XmlDocument ();
 274                         doc.LoadXml ("<root/>");
 275                         XmlWriterSettings settings = new XmlWriterSettings ();
 276                         settings.OmitXmlDeclaration = true;
 277                         settings.NewLineChars = "\r\n";
 278                         settings.NewLineHandling = NewLineHandling.Replace;
 279                         settings.Encoding = Encoding.UTF8;
 280                         settings.Indent = true;
 281
 282                         StringWriter sw = new StringWriter ();
 283                         using (XmlWriter xw = XmlWriter.Create (sw, settings)) {
 284                                 doc.Save (xw);
 285                         }
 286                         // no heading newline.
 287                         Assert.AreEqual ("<root />", sw.ToString ());
 288                 }
 289
 290                 [Test] // surprisingly niche behavior yet caused bug #3231.
 291                 public void IndentAndTopLevelWhitespaces ()
 292                 {
 293                         var sw = new StringWriter ();
 294                         var xw = XmlWriter.Create (sw, new XmlWriterSettings () { Indent = true });
 295                         xw.WriteProcessingInstruction ("xml", "version='1.0'");
 296                         xw.WriteWhitespace ("\n");
 297                         xw.WriteComment ("AAA");
 298                         xw.WriteWhitespace ("\n");
 299                         xw.WriteWhitespace ("\n");
 300                         xw.WriteStartElement ("root");
 301                         xw.Close ();
 302                         string xml = @"<?xml version='1.0'?>
 303 <!--AAA-->
 304
 305 <root />";
 306                         Assert.AreEqual (xml, sw.ToString ().Replace ("\r\n", "\n"), "#1");
 307                 }
 308
 309                 [Test]
 310                 public void NewlineHandlingNone ()
 311                 {
 312                         var sw = new StringWriter ();
 313                         var xw = XmlWriter.Create (sw, new XmlWriterSettings () { NewLineHandling = NewLineHandling.None });
 314                         xw.WriteStartElement("root");
 315                         xw.WriteElementString("element", "lf\ncr\rcrlf\r\nht\t");
 316                         xw.WriteStartElement("element");
 317                         xw.WriteAttributeString("attr", "lf\ncr\rcrlf\r\nht\t");
 318                         xw.WriteEndElement();
 319                         xw.WriteEndElement();
 320                         xw.Close();
 321                         string xml = "<?xml version=\"1.0\" encoding=\"utf-16\"?><root><element>lf\ncr\rcrlf\r\nht\t</element><element attr=\"lf\ncr\rcrlf\r\nht\t\" /></root>";
 322                         Assert.AreEqual (xml, sw.ToString ());
 323                 }
 324
 325                 [Test]
 326                 public void NewlineHandlingReplace ()
 327                 {
 328                         var sw = new StringWriter ();
 329                         var xw = XmlWriter.Create (sw, new XmlWriterSettings () {
 330                                         NewLineHandling = NewLineHandling.Replace,
 331                                         NewLineChars = "\n"
 332                         });
 333                         xw.WriteStartElement("root");
 334                         xw.WriteElementString("element", "lf\ncr\rcrlf\r\nht\t");
 335                         xw.WriteStartElement("element");
 336                         xw.WriteAttributeString("attr", "lf\ncr\rcrlf\r\nht\t");
 337                         xw.WriteEndElement();
 338                         xw.WriteEndElement();
 339                         xw.Close();
 340                         string xml = "<?xml version=\"1.0\" encoding=\"utf-16\"?><root><element>lf\ncr\ncrlf\nht\t</element><element attr=\"lf&#xA;cr&#xD;crlf&#xD;&#xA;ht&#x9;\" /></root>";
 341                         Assert.AreEqual (xml, sw.ToString ());
 342                 }
 343
 344                 [Test]
 345                 public void NewlineHandlingReplaceCRLF ()
 346                 {
 347                         var sw = new StringWriter ();
 348                         var xw = XmlWriter.Create (sw, new XmlWriterSettings () {
 349                                         NewLineHandling = NewLineHandling.Replace,
 350                                         NewLineChars = "\r\n"
 351                         });
 352                         xw.WriteStartElement("root");
 353                         xw.WriteElementString("element", "lf\ncr\rcrlf\r\nht\t");
 354                         xw.WriteStartElement("element");
 355                         xw.WriteAttributeString("attr", "lf\ncr\rcrlf\r\nht\t");
 356                         xw.WriteEndElement();
 357                         xw.WriteEndElement();
 358                         xw.Close();
 359                         string xml = "<?xml version=\"1.0\" encoding=\"utf-16\"?><root><element>lf\r\ncr\r\ncrlf\r\nht\t</element><element attr=\"lf&#xA;cr&#xD;crlf&#xD;&#xA;ht&#x9;\" /></root>";
 360                         Assert.AreEqual (xml, sw.ToString ());
 361                 }
 362
 363                 [Test]
 364                 public void NewlineHandlingEntitize ()
 365                 {
 366                         var sw = new StringWriter ();
 367                         var xw = XmlWriter.Create (sw, new XmlWriterSettings () {
 368                                         NewLineHandling = NewLineHandling.Entitize,
 369                                         NewLineChars = "\n"
 370                         });
 371                         xw.WriteStartElement("root");
 372                         xw.WriteElementString("element", "lf\ncr\rcrlf\r\nht\t");
 373                         xw.WriteStartElement("element");
 374                         xw.WriteAttributeString("attr", "lf\ncr\rcrlf\r\nht\t");
 375                         xw.WriteEndElement();
 376                         xw.WriteEndElement();
 377                         xw.Close();
 378                         string xml = "<?xml version=\"1.0\" encoding=\"utf-16\"?><root><element>lf\ncr&#xD;crlf&#xD;\nht\t</element><element attr=\"lf&#xA;cr&#xD;crlf&#xD;&#xA;ht&#x9;\" /></root>";
 379                         Assert.AreEqual (xml, sw.ToString ());
 380                 }
 381
 382                 [Test]
 383                 [ExpectedException (typeof (XmlException))]
 384                 public void ReadonlyAsync ()
 385                 {
 386                         var sw = new StringWriter ();
 387                         var s = new XmlWriterSettings ();
 388                         var w = XmlWriter.Create (sw, s);
 389                         w.Settings.Async = true;
 390                 }
 391
 392                 [Test]
 393                 public void AsyncPropagation ()
 394                 {
 395                         var sw = new StringWriter ();
 396                         var s = new XmlWriterSettings ();
 397                         s.Async = true;
 398                         var w = XmlWriter.Create (sw, s);
 399
 400                         var c = s.Clone ();
 401                         Assert.IsTrue (c.Async);
 402                         c.Reset ();
 403                         Assert.IsFalse (c.Async);
 404
 405                         var w2 = XmlWriter.Create (w, c);
 406                         Assert.IsTrue (w2.Settings.Async);
 407                 }
 408
 409         }
 410 }