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