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

   1 //
   2 // System.Xml.XmlWhitespaceTests.cs
   3 //
   4 // Authors:
   5 //      Duncan Mak  (duncan@ximian.com)
   6 //      Martin Willemoes Hansen (mwh@sysrq.dk)
   7 //
   8 // (C) Ximian, Inc.
   9 // (C) 2003 Martin Willemoes Hansen
  10 //
  11
  12 using System;
  13 using System.Xml;
  14
  15 using NUnit.Framework;
  16
  17 namespace MonoTests.System.Xml
  18 {
  19         [TestFixture]
  20         public class XmlSignificantWhitespaceTests : Assertion
  21         {
  22                 XmlDocument document;
  23                 XmlDocument doc2;
  24                 XmlSignificantWhitespace whitespace;
  25                 XmlSignificantWhitespace broken;
  26                 XmlNode original;
  27                 XmlNode deep;
  28                 XmlNode shallow;
  29
  30                 [SetUp]
  31                 public void GetReady ()
  32                 {
  33                         document = new XmlDocument ();
  34                         document.LoadXml ("<root><foo></foo></root>");
  35                         XmlElement element = document.CreateElement ("foo");
  36                         whitespace = document.CreateSignificantWhitespace ("\r\n");
  37                         element.AppendChild (whitespace);
  38
  39                         doc2 = new XmlDocument ();
  40                 }
  41
  42                 [Test]
  43                 public void InnerAndOuterXml ()
  44                 {
  45                         whitespace = doc2.CreateSignificantWhitespace ("\r\n\t ");
  46                         AssertEquals (String.Empty, whitespace.InnerXml);
  47                         AssertEquals ("\r\n\t ", whitespace.OuterXml);
  48                 }
  49
  50                 [Test]
  51                 public void DataAndValue ()
  52                 {
  53                         string val = "\t\t\r\n ";
  54                         whitespace = doc2.CreateSignificantWhitespace (val);
  55                         AssertEquals ("#DataValue.1", val, whitespace.Data);
  56                         AssertEquals ("#DataValue.2", val, whitespace.Value);
  57                         whitespace.Value = val + "\t";
  58                         AssertEquals ("#DataValue.3", val + "\t", whitespace.Data);
  59                 }
  60
  61                 internal void XmlNodeBaseProperties (XmlNode original, XmlNode cloned)
  62                 {
  63 //                      assertequals (original.nodetype + " was incorrectly cloned.",
  64 //                                    original.baseuri, cloned.baseuri);
  65                         AssertNull (cloned.ParentNode);
  66                         AssertEquals ("Value incorrectly cloned",
  67                                        cloned.Value, original.Value);
  68
  69                         Assert ("Copies, not pointers", !Object.ReferenceEquals (original,cloned));
  70                 }
  71
  72                 [Test]
  73                 public void XmlSignificantWhitespaceBadConstructor ()
  74                 {
  75                         try {
  76                                 broken = document.CreateSignificantWhitespace ("black");
  77
  78                         } catch (ArgumentException) {
  79                                 return;
  80
  81                         } catch (Exception) {
  82                                 Fail ("Incorrect Exception thrown.");
  83                         }
  84                 }
  85
  86                 [Test]
  87                 public void XmlSignificantWhitespaceConstructor ()
  88                 {
  89                         AssertEquals ("whitespace char didn't get copied right",
  90                                       "\r\n", whitespace.Data);
  91                 }
  92
  93                 [Test]
  94                 public void XmlSignificantWhitespaceName ()
  95                 {
  96                         AssertEquals (whitespace.NodeType + " Name property broken",
  97                                       whitespace.Name, "#significant-whitespace");
  98                 }
  99
 100                 [Test]
 101                 public void XmlSignificantWhitespaceLocalName ()
 102                 {
 103                         AssertEquals (whitespace.NodeType + " LocalName property broken",
 104                                       whitespace.LocalName, "#significant-whitespace");
 105                 }
 106
 107                 [Test]
 108                 public void XmlSignificantWhitespaceNodeType ()
 109                 {
 110                         AssertEquals ("XmlSignificantWhitespace NodeType property broken",
 111                                       whitespace.NodeType.ToString (), "SignificantWhitespace");
 112                 }
 113
 114                 [Test]
 115                 public void XmlSignificantWhitespaceIsReadOnly ()
 116                 {
 117                         AssertEquals ("XmlSignificantWhitespace IsReadOnly property broken",
 118                                       whitespace.IsReadOnly, false);
 119                 }
 120
 121                 [Test]
 122                 public void XmlSignificantWhitespaceCloneNode ()
 123                 {
 124                         original = whitespace;
 125
 126                         shallow = whitespace.CloneNode (false); // shallow
 127                         XmlNodeBaseProperties (original, shallow);
 128
 129                         deep = whitespace.CloneNode (true); // deep
 130                         XmlNodeBaseProperties (original, deep);
 131
 132                         AssertEquals ("deep cloning differs from shallow cloning",
 133                                       deep.OuterXml, shallow.OuterXml);
 134                 }
 135         }
 136 }