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

   1 // XmlAttributeTests.cs : Tests for the XmlAttribute class
   2 //
   3 // Author: Mike Kestner <mkestner@speakeasy.net>
   4 // Author: Martin Willemoes Hansen <mwh@sysrq.dk>
   5 //
   6 // (C) 2002 Mike Kestner
   7 // (C) 2003 Martin Willemoes Hansen
   8
   9 using System;
  10 using System.IO;
  11 using System.Xml;
  12
  13 using NUnit.Framework;
  14
  15 namespace MonoTests.System.Xml
  16 {
  17         [TestFixture]
  18         public class XmlAttributeTests : Assertion
  19         {
  20                 XmlDocument doc;
  21                 XmlAttribute attr;
  22                 bool inserted;
  23                 bool changed;
  24                 bool removed;
  25
  26                 [SetUp]
  27                 public void GetReady()
  28                 {
  29                         doc = new XmlDocument ();
  30                         attr = doc.CreateAttribute ("attr1");
  31                         attr.Value = "val1";
  32                 }
  33
  34                 private void EventNodeInserted(Object sender, XmlNodeChangedEventArgs e)
  35                 {
  36                         inserted = true;
  37                 }
  38
  39                 private void EventNodeChanged(Object sender, XmlNodeChangedEventArgs e)
  40                 {
  41                         changed = true;
  42                 }
  43
  44                 private void EventNodeRemoved(Object sender, XmlNodeChangedEventArgs e)
  45                 {
  46                         removed = true;
  47                 }
  48
  49                 [Test]
  50                 public void Attributes ()
  51                 {
  52                         AssertNull (attr.Attributes);
  53                 }
  54
  55                 [Test]
  56                 public void AttributeInnerAndOuterXml ()
  57                 {
  58                         attr = doc.CreateAttribute ("foo", "bar", "http://abc.def");
  59                         attr.Value = "baz";
  60                         AssertEquals ("baz", attr.InnerXml);
  61                         AssertEquals ("foo:bar=\"baz\"", attr.OuterXml);
  62                 }
  63
  64                 [Test]
  65                 public void AttributeWithNoValue ()
  66                 {
  67                         XmlAttribute attribute = doc.CreateAttribute ("name");
  68                         AssertEquals (String.Empty, attribute.Value);
  69                         Assert (!attribute.HasChildNodes);
  70                         AssertNull (attribute.FirstChild);
  71                         AssertNull (attribute.LastChild);
  72                         AssertEquals (0, attribute.ChildNodes.Count);
  73                 }
  74
  75                 [Test]
  76                 public void AttributeWithValue ()
  77                 {
  78                         XmlAttribute attribute = doc.CreateAttribute ("name");
  79                         attribute.Value = "value";
  80                         AssertEquals ("value", attribute.Value);
  81                         Assert (attribute.HasChildNodes);
  82                         AssertNotNull (attribute.FirstChild);
  83                         AssertNotNull (attribute.LastChild);
  84                         AssertEquals (1, attribute.ChildNodes.Count);
  85                         AssertEquals (XmlNodeType.Text, attribute.ChildNodes [0].NodeType);
  86                         AssertEquals ("value", attribute.ChildNodes [0].Value);
  87                 }
  88
  89                 [Test]
  90                 [ExpectedException (typeof (ArgumentException))]
  91                 public void CheckPrefixWithNamespace ()
  92                 {
  93                         XmlDocument doc = new XmlDocument ();
  94                         doc.LoadXml ("<root xmlns:foo='urn:foo' foo='attfoo' foo:foo='attfoofoo' />");
  95                         // hogehoge does not match to any namespace.
  96                         AssertEquals ("xmlns:foo", doc.DocumentElement.Attributes [0].Name);
  97                         doc.DocumentElement.Attributes [0].Prefix="hogehoge";
  98                         doc.Save (Console.Out);
  99                 }
 100
 101                 [Test]
 102                 public void NamespaceAttributes ()
 103                 {
 104                         try {
 105                                 doc.CreateAttribute ("", "xmlns", "urn:foo");
 106                                 Assertion.Fail ("Creating xmlns attribute with invalid nsuri should be error.");
 107                         } catch (Exception) {
 108                         }
 109                         doc.LoadXml ("<root/>");
 110                         try {
 111                                 doc.DocumentElement.SetAttribute ("xmlns", "urn:foo", "urn:bar");
 112                                 Assertion.Fail ("SetAttribute for xmlns with invalid nsuri should be error.");
 113                         } catch (ArgumentException) {
 114                         }
 115                 }
 116
 117                 [Test]
 118                 public void HasChildNodes ()
 119                 {
 120                         Assert (attr.HasChildNodes);
 121                 }
 122
 123                 [Test]
 124                 public void Name ()
 125                 {
 126                         AssertEquals ("attr1", attr.Name);
 127                 }
 128
 129                 [Test]
 130                 public void NodeType ()
 131                 {
 132                         AssertEquals (XmlNodeType.Attribute, attr.NodeType);
 133                 }
 134
 135                 [Test]
 136                 public void OwnerDocument ()
 137                 {
 138                         AssertSame (doc, attr.OwnerDocument);
 139                 }
 140
 141                 [Test]
 142                 public void ParentNode ()
 143                 {
 144                         AssertNull ("Attr parents not allowed", attr.ParentNode);
 145                 }
 146
 147                 [Test]
 148                 public void Value ()
 149                 {
 150                         AssertEquals ("val1", attr.Value);
 151                 }
 152
 153                 [Test]
 154                 public void SetInnerTextAndXml ()
 155                 {
 156                         string original = doc.OuterXml;
 157                         doc.LoadXml ("<root name='value' />");
 158                         XmlAttribute attr = doc.DocumentElement.Attributes ["name"];
 159                         attr.InnerText = "a&b";
 160                         AssertEquals ("setInnerText", "a&b", attr.Value);
 161                         attr.InnerXml = "a&amp;b";
 162                         AssertEquals ("setInnerXml", "a&b", attr.Value);
 163                         attr.InnerXml = "'a&amp;b'";
 164                         AssertEquals ("setInnerXml.InnerXml", "'a&amp;b'", attr.InnerXml);
 165                         AssertEquals ("setInnerXml.Value", "'a&b'", attr.Value);
 166                         attr.InnerXml = "\"a&amp;b\"";
 167                         AssertEquals ("\"a&amp;b\"", attr.InnerXml);
 168                         attr.InnerXml = "\"a&amp;b'";
 169                         AssertEquals ("\"a&amp;b'", attr.InnerXml);
 170
 171                         attr.Value = "";
 172                         XmlNodeChangedEventHandler evInserted = new XmlNodeChangedEventHandler (EventNodeInserted);
 173                         XmlNodeChangedEventHandler evChanged = new XmlNodeChangedEventHandler (EventNodeChanged);
 174                         XmlNodeChangedEventHandler evRemoved = new XmlNodeChangedEventHandler (EventNodeRemoved);
 175                         doc.NodeInserted += evInserted;
 176                         doc.NodeChanged += evChanged;
 177                         doc.NodeRemoved += evRemoved;
 178                         try {
 179                                 // set_InnerText event
 180                                 attr.InnerText = "fire";
 181                                 AssertEquals ("setInnerText.NodeInserted", false, inserted);
 182                                 AssertEquals ("setInnerText.NodeChanged", true, changed);
 183                                 AssertEquals ("setInnerText.NodeRemoved", false, removed);
 184                                 inserted = changed = removed = false;
 185                                 // set_InnerXml event
 186                                 attr.InnerXml = "fire";
 187                                 AssertEquals ("setInnserXml.NodeInserted", true, inserted);
 188                                 AssertEquals ("setInnserXml.NodeChanged", false, changed);
 189                                 AssertEquals ("setInnserXml.NodeRemoved", true, removed);
 190                                 inserted = changed = removed = false;
 191                         } finally {
 192                                 doc.NodeInserted -= evInserted;
 193                                 doc.NodeChanged -= evChanged;
 194                                 doc.NodeRemoved -= evRemoved;
 195                         }
 196                 }
 197
 198
 199
 200                 private void OnSetInnerText (object o, XmlNodeChangedEventArgs e)
 201                 {
 202                         if(e.NewParent.Value == "fire")
 203                                 doc.DocumentElement.SetAttribute ("appended", "event was fired");
 204                 }
 205
 206                 [Test]
 207                 public void WriteTo ()
 208                 {
 209                         doc.AppendChild (doc.CreateElement ("root"));
 210                         doc.DocumentElement.SetAttribute ("attr","");
 211                         doc.DocumentElement.Attributes ["attr"].InnerXml = "&ent;";
 212                         StringWriter sw = new StringWriter ();
 213                         XmlTextWriter xtw = new XmlTextWriter (sw);
 214                         xtw.WriteStartElement ("result");
 215                         XmlAttribute attr = doc.DocumentElement.Attributes ["attr"];
 216                         attr.WriteTo (xtw);
 217                         xtw.Close ();
 218                         Assertion.AssertEquals ("<result attr=\"&ent;\" />", sw.ToString ());
 219                 }
 220
 221                 [Test]
 222                 public void IdentityConstraints ()
 223                 {
 224                         string dtd = "<!DOCTYPE root [<!ELEMENT root (c)+><!ELEMENT c EMPTY><!ATTLIST c foo ID #IMPLIED bar CDATA #IMPLIED>]>";
 225                         string xml = dtd + "<root><c foo='id1' bar='1' /><c foo='id2' bar='2'/></root>";
 226                         XmlValidatingReader vr = new XmlValidatingReader (xml, XmlNodeType.Document, null);
 227                         doc.Load (vr);
 228                         AssertNotNull (doc.GetElementById ("id1"));
 229                         AssertNotNull (doc.GetElementById ("id2"));
 230                         // MS.NET BUG: Later I try to append it to another element, but
 231                         // it should raise InvalidOperationException.
 232                         // (and if MS.NET conform to DOM 1.0, it should be XmlException.)
 233 //                      XmlAttribute attr = doc.DocumentElement.FirstChild.Attributes [0];
 234                         XmlAttribute attr = doc.DocumentElement.FirstChild.Attributes.RemoveAt (0);
 235                         AssertEquals ("id1", attr.Value);
 236
 237                         doc.DocumentElement.LastChild.Attributes.SetNamedItem (attr);
 238                         AssertNotNull (doc.GetElementById ("id1"));
 239                         XmlElement elem2 = doc.GetElementById ("id2");
 240                         // MS.NET BUG: it doesn't remove replaced attribute with SetNamedItem!
 241 //                      AssertNull (elem2);
 242 //                      AssertEquals ("2", elem2.GetAttribute ("bar"));
 243 //                      elem2.RemoveAttribute ("foo");
 244 //                      AssertEquals ("", elem2.GetAttribute ("foo"));
 245
 246                         // MS.NET BUG: elem should be the element which has the attribute bar='1'!
 247                         XmlElement elem = doc.GetElementById ("id1");
 248 //                      AssertEquals ("2", elem.GetAttribute ("bar"));
 249
 250                         // Here, required attribute foo is no more required,
 251                         XmlElement elemNew = doc.CreateElement ("c");
 252                         doc.DocumentElement.AppendChild (elemNew);
 253                         // but once attribute is set, document recognizes this ID.
 254                         elemNew.SetAttribute ("foo", "id3");
 255                         AssertNotNull (doc.GetElementById ("id3"));
 256                         elemNew.RemoveAttribute ("foo");
 257                         AssertNull (doc.GetElementById ("id3"));
 258
 259                         // MS.NET BUG: multiple IDs are allowed.
 260                         // In such case GetElementById fails.
 261                         elemNew.SetAttribute ("foo", "id2");
 262
 263                         // While XmlValidatingReader validated ID cannot be removed.
 264                         // It is too curious for me.
 265                         elem.RemoveAttribute ("foo");
 266
 267                         // Finally...
 268                         doc.RemoveAll ();
 269                         AssertNull (doc.GetElementById ("id1"));
 270                         AssertNull (doc.GetElementById ("id2"));
 271                         AssertNull (doc.GetElementById ("id3"));
 272                 }
 273
 274                 int removeAllStep;
 275                 [Test]
 276                 public void DefaultAttributeRemoval ()
 277                 {
 278                         XmlDocument doc = new XmlDocument ();
 279                         doc.LoadXml ("<!DOCTYPE root [<!ELEMENT root (#PCDATA)><!ATTLIST root foo CDATA 'foo-def'>]><root></root>");
 280                         doc.NodeInserted += new XmlNodeChangedEventHandler (OnInsert);
 281                         doc.NodeChanged += new XmlNodeChangedEventHandler (OnChange);
 282                         doc.NodeRemoved += new XmlNodeChangedEventHandler (OnRemove);
 283                         doc.DocumentElement.RemoveAll ();
 284                 }
 285
 286                 private void OnInsert (object o, XmlNodeChangedEventArgs e)
 287                 {
 288                         if (removeAllStep == 1)
 289                                 AssertEquals (XmlNodeType.Text, e.Node.NodeType);
 290                         else if (removeAllStep == 2) {
 291                                 AssertEquals ("foo", e.Node.Name);
 292                                 Assert (! ((XmlAttribute) e.Node).Specified);
 293                         }
 294                         else
 295                                 Fail ();
 296                         removeAllStep++;
 297                 }
 298                 private void OnChange (object o, XmlNodeChangedEventArgs e)
 299                 {
 300                         Fail ("Should not be called.");
 301                 }
 302                 private void OnRemove (object o, XmlNodeChangedEventArgs e)
 303                 {
 304                         AssertEquals (0, removeAllStep);
 305                         AssertEquals ("foo", e.Node.Name);
 306                         removeAllStep++;
 307                 }
 308
 309                 [Test]
 310                 public void EmptyStringHasTextNode ()
 311                 {
 312                         doc.LoadXml ("<root attr=''/>");
 313                         XmlAttribute attr = doc.DocumentElement.GetAttributeNode ("attr");
 314                         AssertNotNull (attr);
 315                         AssertEquals (1, attr.ChildNodes.Count);
 316                         AssertEquals (XmlNodeType.Text, attr.ChildNodes [0].NodeType);
 317                         AssertEquals (String.Empty, attr.ChildNodes [0].Value);
 318                 }
 319         }
 320 }