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

   1 //
   2 // System.Xml.XmlTextWriterTests
   3 //
   4 // Authors:
   5 //   Atsushi Enomoto <ginga@kit.hi-ho.ne.jp>
   6 //   Martin Willemoes Hansen <mwh@sysrq.dk>
   7 //
   8 // (C) 2003 Atsushi Enomoto
   9 // (C) 2003 Martin Willemoes Hansen
  10 //
  11 //
  12 //  This class mainly checks inheritance and behaviors of XmlWriter.
  13 //
  14
  15 using System;
  16 using System.IO;
  17 using System.Text;
  18 using System.Xml;
  19
  20 using NUnit.Framework;
  21
  22 namespace MonoTests.System.Xml
  23 {
  24         [TestFixture]
  25         public class XmlWriterTests : Assertion
  26         {
  27                 StringWriter writer;
  28                 XmlTextWriter xtw;
  29
  30                 [SetUp]
  31                 public void SetUp ()
  32                 {
  33                         writer = new StringWriter ();
  34                         xtw = new XmlTextWriter (writer);
  35                 }
  36
  37                 private void setupWriter ()
  38                 {
  39                         writer.GetStringBuilder ().Length = 0;
  40                 }
  41
  42                 [Test]
  43                 public void WriteNodeFullDocument ()
  44                 {
  45                         setupWriter ();
  46                         string xml = "<?xml version='1.0'?><root />";
  47                         XmlTextReader xtr = new XmlTextReader (xml, XmlNodeType.Document, null);
  48                         xtw.WriteNode (xtr, false);
  49                         AssertEquals (xml, writer.ToString ());
  50
  51                         // With encoding
  52                         setupWriter ();
  53                         xml = "<?xml version='1.0' encoding='iso-2022-jp'?><root />";
  54                         xtr = new XmlTextReader (xml, XmlNodeType.Document, null);
  55                         xtw.WriteNode (xtr, false);
  56                         AssertEquals (xml, writer.ToString ());
  57                         xtr.Close ();
  58                 }
  59
  60                 [Test]
  61                 public void WriteNodeXmlDecl ()
  62                 {
  63                         setupWriter ();
  64                         string xml = "<?xml version='1.0'?><root />";
  65                         StringReader sr = new StringReader (xml);
  66                         XmlTextReader xtr = new XmlTextReader (sr);
  67                         xtr.Read ();
  68                         xtw.WriteNode (xtr, false);
  69                         AssertEquals ("<?xml version='1.0'?>",
  70                                  writer.ToString ());
  71                         xtr.Close ();
  72                 }
  73
  74                 [Test]
  75                 public void WriteNodeEmptyElement ()
  76                 {
  77                         setupWriter ();
  78                         string xml = "<root attr='value' attr2='value' />";
  79                         StringReader sr = new StringReader (xml);
  80                         XmlTextReader xtr = new XmlTextReader (sr);
  81                         xtw.WriteNode (xtr, false);
  82                         AssertEquals (xml.Replace ("'", "\""),
  83                                 writer.ToString ());
  84                         xtr.Close ();
  85                 }
  86
  87                 [Test]
  88                 public void WriteNodeNonEmptyElement ()
  89                 {
  90                         setupWriter ();
  91                         string xml = @"<foo><bar></bar></foo>";
  92                         xtw.WriteNode (new XmlTextReader (xml, XmlNodeType.Document, null), false);
  93                         AssertEquals (xml, writer.ToString ());
  94                 }
  95
  96                 [Test]
  97                 public void WriteNodeSingleContentElement ()
  98                 {
  99                         setupWriter ();
 100                         string xml = "<root attr='value' attr2='value'><foo /></root>";
 101                         StringReader sr = new StringReader (xml);
 102                         XmlTextReader xtr = new XmlTextReader (sr);
 103                         xtw.WriteNode (xtr, false);
 104                         AssertEquals (xml.Replace ("'", "\""),
 105                                 writer.ToString ());
 106                         xtr.Close ();
 107                 }
 108
 109                 [Test]
 110                 public void WriteNodeNone ()
 111                 {
 112                         setupWriter ();
 113                         XmlTextReader xtr = new XmlTextReader ("", XmlNodeType.Element, null);
 114                         xtr.Read ();
 115                         xtw.WriteNode (xtr, false); // does not report any errors
 116                         xtr.Close ();
 117                 }
 118
 119                 [Test]
 120                 [ExpectedException (typeof (XmlException))]
 121                 public void WriteNodeError ()
 122                 {
 123                         XmlTextReader xtr = new XmlTextReader ("<root>", XmlNodeType.Document, null);
 124                         xtr.Read ();
 125                         try {
 126                                 xtr.Read ();
 127                         } catch (XmlException ex) {
 128                         }
 129                         XmlTextWriter xtw = new XmlTextWriter (new StringWriter ());
 130                         xtw.WriteNode (xtr, false);
 131                 }
 132
 133                 [Test]
 134                 public void WriteSurrogateCharEntity ()
 135                 {
 136                         setupWriter ();
 137                         xtw.WriteSurrogateCharEntity ('\udfff', '\udb00');
 138                         AssertEquals ("&#xD03FF;", writer.ToString ());
 139
 140                         try {
 141                                 xtw.WriteSurrogateCharEntity ('\ud800', '\udc00');
 142                                 Fail ();
 143                         } catch {
 144                         }
 145                         try {
 146                                 xtw.WriteSurrogateCharEntity ('\udbff', '\ud800');
 147                                 Fail ();
 148                         } catch {
 149                         }
 150                         try {
 151                                 xtw.WriteSurrogateCharEntity ('\ue000', '\ud800');
 152                                 Fail ();
 153                         } catch {
 154                         }
 155                         try {
 156                                 xtw.WriteSurrogateCharEntity ('\udfff', '\udc00');
 157                                 Fail ();
 158                         } catch {
 159                         }
 160                 }
 161
 162                 // MS.NET's not-overriden XmlWriter.WriteStartElement(name)
 163                 // invokes WriteStartElement(null, name, null).
 164                 // WriteStartElement(name, ns) invokes (null, name, ns), too.
 165                 [Test]
 166                 public void StartElement ()
 167                 {
 168                         StartElementTestWriter xw = new StartElementTestWriter ();
 169                         xw.WriteStartDocument ();
 170                         xw.WriteStartElement ("test");
 171                         AssertEquals ("StartElementOverride.NS", null, xw.NS);
 172                         AssertEquals ("StartElementOverride.Prefix", null, xw.Prefix);
 173                         xw.NS = String.Empty;
 174                         xw.Prefix = String.Empty;
 175                         xw.WriteStartElement ("test", "urn:hoge");
 176                         AssertEquals ("StartElementOverride.NS", "urn:hoge", xw.NS);
 177                         AssertEquals ("StartElementOverride.Prefix", null, xw.Prefix);
 178                 }
 179
 180                 class StartElementTestWriter : DefaultXmlWriter
 181                 {
 182                         public StartElementTestWriter () : base () {}
 183                         public string NS = String.Empty;
 184                         public string Prefix = String.Empty;
 185
 186                         public override void WriteStartElement (string prefix, string localName, string ns)
 187                         {
 188                                 this.NS = ns;
 189                                 this.Prefix = prefix;
 190                         }
 191                 }
 192         }
 193
 194         internal class DefaultXmlWriter : XmlWriter
 195         {
 196                 public DefaultXmlWriter () : base ()
 197                 {
 198                 }
 199
 200                 public override void Close ()
 201                 {
 202                 }
 203
 204                 public override void Flush ()
 205                 {
 206                 }
 207
 208                 public override string LookupPrefix (string ns)
 209                 {
 210                         return null;
 211                 }
 212
 213                 public override void WriteBase64 (byte [] buffer, int index, int count)
 214                 {
 215                 }
 216
 217                 public override void WriteBinHex (byte [] buffer, int index, int count)
 218                 {
 219                 }
 220
 221                 public override void WriteCData (string text)
 222                 {
 223                 }
 224
 225                 public override void WriteCharEntity (char ch)
 226                 {
 227                 }
 228
 229                 public override void WriteChars (char [] buffer, int index, int count)
 230                 {
 231                 }
 232
 233                 public override void WriteComment (string text)
 234                 {
 235                 }
 236
 237                 public override void WriteDocType (string name, string pubid, string sysid, string subset)
 238                 {
 239                 }
 240
 241                 public override void WriteEndAttribute ()
 242                 {
 243                 }
 244
 245                 public override void WriteEndDocument ()
 246                 {
 247                 }
 248
 249                 public override void WriteEndElement ()
 250                 {
 251                 }
 252
 253                 public override void WriteEntityRef (string name)
 254                 {
 255                 }
 256
 257                 public override void WriteFullEndElement ()
 258                 {
 259                 }
 260
 261                 public override void WriteName (string name)
 262                 {
 263                 }
 264
 265                 public override void WriteNmToken (string name)
 266                 {
 267                 }
 268
 269                 public override void WriteNode (XmlReader reader, bool defattr)
 270                 {
 271                 }
 272
 273                 public override void WriteProcessingInstruction (string name, string text)
 274                 {
 275                 }
 276
 277                 public override void WriteQualifiedName (string localName, string ns)
 278                 {
 279                 }
 280
 281                 public override void WriteRaw (string data)
 282                 {
 283                 }
 284
 285                 public override void WriteRaw (char [] buffer, int index, int count)
 286                 {
 287                 }
 288
 289                 public override void WriteStartAttribute (string prefix, string localName, string ns)
 290                 {
 291                 }
 292
 293                 public override void WriteStartDocument (bool standalone)
 294                 {
 295                 }
 296
 297                 public override void WriteStartDocument ()
 298                 {
 299                 }
 300
 301                 public override void WriteStartElement (string prefix, string localName, string ns)
 302                 {
 303                 }
 304
 305                 public override void WriteString (string text)
 306                 {
 307                 }
 308
 309                 public override void WriteSurrogateCharEntity (char lowChar, char highChar)
 310                 {
 311                 }
 312
 313                 public override void WriteWhitespace (string ws)
 314                 {
 315                 }
 316
 317                 public override WriteState WriteState {
 318                         get {
 319                                 return WriteState.Start;
 320                         }
 321                 }
 322
 323                 public override string XmlLang {
 324                         get {
 325                                 return null;
 326                         }
 327                 }
 328
 329                 public override XmlSpace XmlSpace {
 330                         get {
 331                                 return XmlSpace.None;
 332                         }
 333                 }
 334
 335         }
 336 }