1 //**************************************************************************
4 // National Institute Of Standards and Technology
9 // Written by: Carmelo Montanez
11 // Ported to System.Xml by: Mizrahi Rafael rafim@mainsoft.com
12 // Mainsoft Corporation (c) 2003-2004
14 //**************************************************************************
18 using NUnit.Framework;
20 namespace nist_dom.fundamental
23 public class AttrTest//, ITest
25 public static int i = 1;
27 public testResults[] RunTests()
29 testResults[] tests = new testResults[] {core0001A(), core0002A(), core0003A(),core0004A(),
30 core0005A(), core0006A(), core0007A(), core0008A(),
31 core0009A(), core0010A(), core0011A(), core0012A(),
32 core0013A(), core0014A()};
37 //------------------------ test case core-0001A ------------------------
39 // Testing feature - The parentNode attribute for an Attr object should
42 // Testing approach - Retrieve the attribute named "domestic" from the last
43 // child of of the first employee and examine its
44 // parentNode attribute. This test uses the
45 // "GetNamedItem(name)" method from the NamedNodeMap
48 // Semantic Requirements: 1
50 //----------------------------------------------------------------------------
53 public void core0001A()
55 object computedValue = null;
56 object expectedValue = null;
57 System.Xml.XmlNode testNode = null;
58 System.Xml.XmlAttribute domesticAttr = null;
60 testResults results = new testResults("Core0001A");
64 results.description = "The ParentNode attribute should be null for" +
67 // Retrieve targeted data and examine parentNode attribute.
69 testNode = util.nodeObject(util.FIRST, util.SIXTH);
70 domesticAttr = (System.Xml.XmlAttribute)testNode.Attributes.GetNamedItem("domestic");
71 computedValue = domesticAttr.ParentNode;
76 catch(System.Exception ex)
78 computedValue = "Exception " + ex.Message;
81 results.expected = (expectedValue == null).ToString();
82 results.actual = (computedValue == null).ToString();
83 Assert.AreEqual (results.expected, results.actual);
88 //------------------------ End test case core-0001A --------------------------
90 //------------------------- test case core-0002A ----------------------------
93 // Written By: Carmelo Montanez
95 // Testing feature - The previousSibling attribute for an Attr object
98 // Testing approach - Retrieve the attribute named "domestic" from the last
99 // child of of the first employee and examine its
100 // previousSibling attribute. This test uses the
101 // "GetNamedItem(name)" method from the NamedNodeMap
104 // Semantic Requirements: 1
106 //----------------------------------------------------------------------------
109 public void core0002A()
111 object computedValue = null;
112 object expectedValue = null;
113 System.Xml.XmlAttribute domesticAttr = null;
114 System.Xml.XmlNode testNode = null;
116 testResults results = new testResults("Core0002A");
119 results.description = "The previousSibling attribute should be " +
120 "null for an Attr object.";
122 // Retrieve the targeted data and examine its previousSibling attribute.
124 testNode = util.nodeObject(util.FIRST,util.SIXTH);
125 domesticAttr = (System.Xml.XmlAttribute)testNode.Attributes.GetNamedItem("domestic");
126 computedValue = domesticAttr.PreviousSibling;
128 catch(System.Exception ex)
130 computedValue = "Exception " + ex.Message;
135 results.expected = (expectedValue == null).ToString();
136 results.actual = (computedValue == null).ToString();
138 Assert.AreEqual (results.expected, results.actual);
142 //------------------------ End test case core-0002A --------------------------
144 //------------------------- test case core-0003A ----------------------------
145 // Written By: Carmelo Montanez
147 // Testing feature - The nextSibling attribute for an Attr object should
150 // Testing approach - Retrieve the attribute named "domestic" from the
151 // last child of of the first employee and examine
152 // its nextSibling attribute. This test uses the
153 // "GetNamedItem(name)" method from the NamedNodeMap
156 // Semantic Requirements: 1
158 //----------------------------------------------------------------------------
161 public void core0003A()
163 object computedValue = null;
164 object expectedValue = null;
165 System.Xml.XmlAttribute domesticAttr = null;
166 System.Xml.XmlNode testNode = null;
168 testResults results = new testResults("Core0003A");
171 results.description = "The nextSibling attribute should be null " +
172 "for an Attr object.";
174 // Retrieve the targeted data and examine its nextSibling attribute.
176 testNode = util.nodeObject(util.FIRST,util.SIXTH);
177 domesticAttr = (System.Xml.XmlAttribute)testNode.Attributes.GetNamedItem("domestic");
178 computedValue = domesticAttr.NextSibling;
180 catch(System.Exception ex)
182 computedValue = "Exception " + ex.Message;
187 results.expected = (expectedValue == null).ToString();
188 results.actual = (computedValue == null).ToString();
190 Assert.AreEqual (results.expected, results.actual);
194 //------------------------ End test case core-0003A --------------------------
196 //------------------------- test case core-0004A ----------------------------
198 // Written By: Carmelo Montanez
200 // Testing feature - Attr objects may be associated with Element nodes
201 // contained within a DocumentFragment.
203 // Testing approach - Create a new DocumentFragment object and add a newly
204 // created Element node to it (with one attribute). Once
205 // the element is added, its attribute should be available
206 // as an attribute associated with an Element within a
209 // Semantic Requirements: 2
211 //----------------------------------------------------------------------------
214 public void core0004A()
216 string computedValue = "";
217 string expectedValue = "domestic";
218 System.Xml.XmlAttribute domesticAttr = null;
220 testResults results = new testResults("Core0004A");
223 results.description = "Attr objects may be associated with Element " +
224 "nodes contained within a DocumentFragment.";
226 System.Xml.XmlDocumentFragment docFragment = util.getDOMDocument().CreateDocumentFragment();
227 System.Xml.XmlElement newElement = (System.Xml.XmlElement)util.createNode(util.ELEMENT_NODE,"element1");
229 // The new DocumentFragment is empty upon creation. Set an attribute for
230 // a newly created element and add the element to the documentFragment.
232 newElement.SetAttribute("domestic","Yes");
233 docFragment.AppendChild(newElement);
235 // Access the attributes of the only child of the documentFragment
237 domesticAttr = (System.Xml.XmlAttribute)docFragment.FirstChild.Attributes.Item(0) ;
238 computedValue = domesticAttr.Name;
240 catch(System.Exception ex)
242 computedValue = "Exception " + ex.Message;
247 results.expected = expectedValue;
248 results.actual = computedValue;
251 Assert.AreEqual (results.expected, results.actual);
255 //------------------------ End test case core-0004A --------------------------
257 //-------------------------- test case core-0005A ----------------------------
259 // Testing feature - If an Attr is explicitly assigned any value, then that
260 // value is the attribute's effective value.
262 // Testing approach - Retrieve the attribute name "domestic" from the last
263 // child of of the first employee element and examine its
264 // assigned value. This test uses the
265 // "GetNamedItem(name)" method from the NamedNodeMap
268 // Semantic Requirements: 3
270 //----------------------------------------------------------------------------
273 public void core0005A()
275 string computedValue = "";
276 string expectedValue = "Yes";
277 System.Xml.XmlAttribute domesticAttr = null;
278 System.Xml.XmlNode testNode = null;
280 testResults results = new testResults("Core0005A");
283 results.description = "If an attribute is explicitly assigned any value, " +
284 "then that value is the attribute's effective value.";
286 // Retrieve the targeted data and examine its assigned value.
288 testNode = util.nodeObject(util.FIRST,util.SIXTH);
289 domesticAttr = (System.Xml.XmlAttribute)testNode.Attributes.GetNamedItem("domestic");
290 computedValue = domesticAttr.Value;
292 catch(System.Exception ex)
294 computedValue = "Exception " + ex.Message;
299 results.expected = expectedValue;
300 results.actual = computedValue;
302 Assert.AreEqual (results.expected, results.actual);
306 //------------------------ End test case core-0005A --------------------------
308 //-------------------------- test case core-0006A ----------------------------
310 // Testing feature - If there is no explicit value assigned to an attribute
311 // and there is a declaration for this attribute and that
312 // declaration includes a default value, then that default
313 // value is the Attribute's default value.
315 // Testing approach - Retrieve the attribute named "street" from the
316 // last child of of the first employee and examine its
317 // value. That value should be the value given during
318 // the declaration of the attribute in the DTD file.
319 // This test uses the "GetNamedItem(name)" method from
320 // the NamedNodeMap interface.
322 // Semantic Requirements: 4
324 //----------------------------------------------------------------------------
328 [Category ("NotDotNet")]
330 public void core0006A()
332 string computedValue = "";
333 string expectedValue = "Yes";
334 System.Xml.XmlAttribute streetAttr = null;
335 System.Xml.XmlNode testNode = null;
337 testResults results = new testResults("Core0006A");
340 results.description = "If there is no explicit value assigned to an " +
341 "attribute and there is a declaration for this " +
342 "attribute and that declaration includes a default " +
343 "value, then that default value is the Attribute's " +
346 // Retrieve the targeted data and examine its default value.
348 testNode = util.nodeObject(util.FIRST,util.SIXTH);
349 streetAttr = (System.Xml.XmlAttribute)testNode.Attributes.GetNamedItem("street");
350 computedValue = streetAttr.Value;
352 catch(System.Exception ex)
354 computedValue = "Exception " + ex.Message;
359 results.expected = expectedValue;
360 results.actual = computedValue;
362 Assert.AreEqual (results.expected, results.actual);
366 //------------------------ End test case core-0006A --------------------------
368 //-------------------------- test case core-0007A ---------------------------
370 // Testing feature - The "name" Attribute of an Attribute node.
372 // Testing approach - Retrieve the attribute named "street" from the
373 // last child of the second employee and examine its "name"
374 // attribute. This test uses the "GetNamedItem(name)"
375 // method from the NamedNodeMap interface.
377 // Semantic Requirements: 5
379 //----------------------------------------------------------------------------
382 public void core0007A()
384 string computedValue = "";
385 string expectedValue = "street";
386 System.Xml.XmlAttribute streetAttr = null;
387 System.Xml.XmlNode testNode = null;
389 testResults results = new testResults("Core0007A");
392 results.description = "The \"name\" attribute of an Attr object contains " +
393 "the name of that attribute.";
395 // Retrieve the targeted data and capture its assigned name.
397 testNode = util.nodeObject(util.SECOND,util.SIXTH);
398 streetAttr = (System.Xml.XmlAttribute)testNode.Attributes.GetNamedItem("street");
399 computedValue = streetAttr.Name;
401 catch(System.Exception ex)
403 computedValue = "Exception " + ex.Message;
408 results.expected = expectedValue;
409 results.actual = computedValue;
411 Assert.AreEqual (results.expected, results.actual);
415 //------------------------ End test case core-0007A --------------------------
417 //-------------------------- test case core-0008A ---------------------------
419 // Testing feature - The "specified" attribute of an Attr node should be set
420 // to true if the attribute was explicitly given a value.
422 // Testing approach - Retrieve the attribute named "doestic" from the last
423 // child of the first employee and examine its "specified"
424 // attribute. It should be set to true. This test
425 // uses the "GetNamedItem(name)" method from the
426 // NamedNodeMap interface.
428 // Semantic Requirements: 6
430 //----------------------------------------------------------------------------
433 public void core0008A()
435 string computedValue = "";//0;
436 string expectedValue = "True";
437 System.Xml.XmlNode testNode = null;
438 System.Xml.XmlAttribute domesticAttr = null;
440 testResults results = new testResults("Core0008A");
443 results.description = "The \"specified\" attribute for an Attr object " +
444 "should be set to true if the attribute was " +
445 "explictly given a value.";
447 // Retrieve the targeted data and capture its "specified" value.
449 testNode = util.nodeObject(util.FIRST,util.SIXTH);
450 domesticAttr = (System.Xml.XmlAttribute)testNode.Attributes.GetNamedItem("domestic");;
451 computedValue = domesticAttr.Specified.ToString();
453 catch(System.Exception ex)
455 computedValue = "Exception " + ex.Message;
460 results.expected = expectedValue;
461 results.actual = computedValue;
463 Assert.AreEqual (results.expected, results.actual);
467 //------------------------ End test case core-0008A --------------------------
469 //-------------------------- test case core-0009A ---------------------------
471 // Testing feature - The "specified" attribute for an Attr node should be
472 // set to false if the attribute was not explicitly given
475 // Testing approach - Retrieve the attribute named "street"(not explicity
476 // given a value) from the last child of the first employee
477 // and examine its "specified" attribute. It should be
478 // set to false. This test uses the
479 // "GetNamedItem(name)" method from the NamedNodeMap
482 // Semantic Requirements: 6
484 //----------------------------------------------------------------------------
487 public void core0009A()
489 string computedValue = "";//0;
490 string expectedValue = "False";
491 System.Xml.XmlAttribute streetAttr = null;
492 System.Xml.XmlNode testNode = null;
494 testResults results = new testResults("Core0009A");
497 results.description = "The \"specified\" attribute for an Attr node " +
498 "should be set to false if the attribute was " +
499 "not explictly given a value.";
501 // Retrieve the targeted data and capture its "specified" attribute.
503 testNode = util.nodeObject(util.FIRST,util.SIXTH);
504 streetAttr = (System.Xml.XmlAttribute)testNode.Attributes.GetNamedItem("street");
505 computedValue = streetAttr.Specified.ToString();
507 catch(System.Exception ex)
509 computedValue = "Exception " + ex.Message;
514 results.expected = expectedValue;
515 results.actual = computedValue;
517 Assert.AreEqual (results.expected, results.actual);
521 //------------------------ End test case core-0009A --------------------------
523 //-------------------------- test case core-0010A ---------------------------
525 // Testing feature - The "specified" attribute for an Attr node should be
526 // automatically flipped to true if value of the attribute
527 // is changed (even its ends up having a default DTD value)
529 // Testing approach - Retrieve the attribute named "street" from the last
530 // child of the third employee and change its value to "Yes"
531 // (which is its default DTD value). This should cause the
532 // "specified" attribute to be flipped to true. This test
533 // makes use of the "setAttribute(name,value )" method from
534 // the Element interface and the "GetNamedItem(name)"
535 // method from the NamedNodeMap interface.
537 // Semantic Requirements: 7
539 //----------------------------------------------------------------------------
542 public void core0010A()
544 string computedValue = "";//"";
545 string expectedValue = "True";
546 System.Xml.XmlAttribute streetAttr = null;
547 System.Xml.XmlElement testNode = null;
549 testResults results = new testResults("Core0010A");
552 results.description = "The \"specified\" attribute for an Attr node " +
553 "should be flipped to true if the attribute value " +
554 "is changed (even it changed to its default value).";
556 // Retrieve the targeted data and set a new attribute for it, then
557 // capture its "specified" attribute.
559 testNode = (System.Xml.XmlElement)util.nodeObject(util.THIRD,util.FIFTH);
560 testNode.SetAttribute("street","Yes");//testNode.node.setAttribute("street","Yes");
561 streetAttr = (System.Xml.XmlAttribute)testNode.Attributes.GetNamedItem("street");
562 computedValue = streetAttr.Specified.ToString();
564 catch(System.Exception ex)
566 computedValue = "Exception " + ex.Message;
571 results.expected = expectedValue;
572 results.actual = computedValue;
574 Assert.AreEqual (results.expected, results.actual);
578 //------------------------ End test case core-0010A --------------------------
580 //-------------------------- test case core-0011A ---------------------------
582 // Testing feature - To respecify the attribute to its default value from the
583 // DTD, the attribute must be deleted. The implementation
584 // will then make a new attribute available with the
585 // "specified" attribute set to false.
587 // Testing approach - Retrieve the attribute named "street" from the last
588 // child of the third employee and delete it. The
589 // implementation should then create a new attribute with
590 // its default value and "specified" set to false. This
591 // test uses the "removeAttribute(name)" from the Element
592 // interface and the "GetNamedItem(name)" method from the
593 // NamedNodeMap interface.
595 // Semantic Requirements: 8
597 //----------------------------------------------------------------------------
600 public void core0011A()
602 string computedValue = "";//"";
603 string expectedValue = "False";
604 System.Xml.XmlAttribute streetAttr = null;
605 System.Xml.XmlElement testNode = null;
607 testResults results = new testResults("Core0011A");
610 results.description = "Re-setting an attribute to its default value " +
611 "requires that the attribute be deleted. The " +
612 "implementation should create a new attribute " +
613 "with its \"specified\" attribute set to false.";
615 // Retrieve the targeted data, remove the "street" attribute and capture
616 // its specified attribute.
618 testNode = (System.Xml.XmlElement)util.nodeObject(util.THIRD,util.SIXTH);
619 testNode.RemoveAttribute("street");//testNode.node.removeAttribute("street");
620 streetAttr = (System.Xml.XmlAttribute)testNode.Attributes.GetNamedItem("street");
621 computedValue = streetAttr.Specified.ToString();
623 catch(System.Exception ex)
625 computedValue = "Exception " + ex.Message;
630 results.expected = expectedValue;
631 results.actual = computedValue;
633 Assert.AreEqual (results.expected, results.actual);
637 //------------------------ End test case core-0011A --------------------------
639 //-------------------------- test case core-0012A ---------------------------
641 // Testing feature - Upon retrieval, the "value" of an attribute is returned
642 // as a string with characters and general entity references
643 // replaced with their values.
645 // Testing approach - Retrieve the attribute named "street" from the last
646 // child of the fourth employee and examine its value
647 // attribute. This value should be "Yes" after the
648 // EntityReference is replaced with its value. This
649 // test uses the "GetNamedItem(name)" method from
650 // the NamedNodeMap interface.
652 // Semantic Requirements: 9
654 //----------------------------------------------------------------------------
657 public void core0012A()
659 string computedValue = "";
660 string expectedValue = "Yes";
661 System.Xml.XmlAttribute streetAttr = null;
662 System.Xml.XmlNode testNode = null;
664 testResults results = new testResults("Core0012A");
667 results.description = "Upon retrieval the \"value\" attribute of an Attr" +
668 "object is returned as a string with any Entity " +
669 "References replaced with their values.";
671 // Retrieve the targeted data.
673 testNode = util.nodeObject(util.FOURTH,util.SIXTH);
674 streetAttr = (System.Xml.XmlAttribute)testNode.Attributes.GetNamedItem("street");
675 computedValue = streetAttr.Value;
677 catch(System.Exception ex)
679 computedValue = "Exception " + ex.Message;
684 results.expected = expectedValue;
685 results.actual = computedValue;
687 Assert.AreEqual (results.expected, results.actual);
691 //------------------------ End test case core-0012A --------------------------
693 //-------------------------- test case core-0013A ---------------------------
695 // Testing feature - On setting, the "value" attribute of an Attr node
696 // creates a Text node with the unparsed content of
699 // Testing approach - Retrieve the attribute named "street" from the last
700 // child of the fourth employee and assign the "Y%ent1;"
701 // string to its value attribute. This value is not yet
702 // parsed and therefore should still be the same upon
703 // retrieval. This test uses the "GetNamedItem(name)"
704 // method from the NamedNodeMap interface.
706 // Semantic Requirements: 10
708 //----------------------------------------------------------------------------
711 public void core0013A()
713 string computedValue = "";
714 string expectedValue = "Y%ent1;";
715 System.Xml.XmlAttribute streetAttr = null;
716 System.Xml.XmlNode testNode = null;
718 testResults results = new testResults("Core0013A");
721 results.description = "On setting, the \"value\" attribute of an Attr " +
722 "object creates a Text node with the unparsed " +
723 "content of the string.";
725 // Retrieve the targeted data, assign a value to it and capture its
726 // "value" attribute.
728 testNode = util.nodeObject(util.FOURTH,util.SIXTH);
729 streetAttr = (System.Xml.XmlAttribute)testNode.Attributes.GetNamedItem("street");
730 streetAttr.Value = "Y%ent1;";
731 computedValue = streetAttr.Value;
733 catch(System.Exception ex)
735 computedValue = "Exception " + ex.Message;
740 results.expected = expectedValue;
741 results.actual = computedValue;
743 Assert.AreEqual (results.expected, results.actual);
747 //------------------------ End test case core-0013A --------------------------
749 //-------------------------- test case core-0014A ---------------------------
751 // Testing feature - Setting the "value" attribute raises a
752 // NO_MODIFICATION_ALLOWED_ERR Exception if the
755 // Testing approach - Retrieve the first attribute of the Entity node named
756 // "ent4" and attempt to change its value attribute.
757 // Since the descendants of Entity nodes are readonly, the
758 // desired exception should be raised.
760 // Semantic Requirements: 11
762 //----------------------------------------------------------------------------
765 [Category ("NotDotNet")] // MS DOM is buggy
766 public void core0014A()
768 string computedValue = "";
769 System.Xml.XmlNode testNode = null;
770 System.Xml.XmlAttribute readOnlyAttribute = null;
771 string expectedValue = "System.ArgumentException";//util.NO_MODIFICATION_ALLOWED_ERR;
773 testResults results = new testResults("Core0014A");
776 results.description = "Setting the \"value\" attribute raises a " +
777 "NO_MODIFICATION_ALLOWED_ERR Exception if " +
778 "the node is readonly.";
781 // Retrieve the targeted data.
783 testNode = util.getEntity("ent4");
784 readOnlyAttribute = (System.Xml.XmlAttribute)testNode.FirstChild.Attributes.Item(0);
786 // attempt to set a value on a readonly node should raise an exception.
790 readOnlyAttribute.Value = "ABCD";
792 catch (ArgumentException ex)
794 computedValue = ex.GetType ().FullName;
797 catch(System.Exception ex)
799 computedValue = "Exception " + ex.Message;
801 results.expected = expectedValue;
802 results.actual = computedValue;
806 Assert.AreEqual (results.expected, results.actual);
809 //------------------------ End test case core-0014A --------------------------