context: //**************************************************************************
  //
  //
  //                       National Institute Of Standards and Technology
  //                                     DTS Version 1.0
  //         
  //                                 NamedNodeMap Interface
  //
  // Written by: Carmelo Montanez
  // Modified by:  Mary Brady
  //
  // Ported to System.Xml by: Mizrahi Rafael rafim@mainsoft.com
  // Mainsoft Corporation (c) 2003-2004
  //**************************************************************************
  using System;
  using System.Xml;
  
  using nist_dom;
  using NUnit.Framework;
  
  namespace nist_dom.fundamental
  {
      [TestFixture]
      public class NamedNodeMapTest
      {
          public static int i = 2;
  /*
          public testResults[] RunTests()
          {
              testResults[] tests = new testResults[] {core0001M(), core0002M(), core0003M(),core0004M(),
                                                          core0005M(), core0006M(), core0007M(), core0008M(),
                                                          core0009M(), core0010M(), core0011M(),
                                                          core0014M(), core0015M(), core0016M(),
                                                          core0017M(), core0018M(), core0019M(), core0020M(),
                                                          core0021M()};
    
              return tests;
          }
  */
          //------------------------ test case core-0001M ------------------------
          //
          // Testing feature - The "getNamedItem(name)" method retrieves a node 
          //                   specified by name.
          //
          // Testing approach - Retrieve the second employee and create a NamedNodeMap 
          //                    listing of the attributes of its last child.  Once 
          //                    the list is created an invocation of the 
          //                    "getNamedItem(name)" method is done where 
          //                    name = "domestic".  This should result on the domestic 
          //                    Attr node being returned.
          //                    
          // Semantic Requirements: 1
          //
          //----------------------------------------------------------------------------
  
          [Test]
  	public void core0001M()
          {
              string computedValue = "";
              string expectedValue = "domestic";
              System.Xml.XmlAttribute domesticAttr = null;
              System.Xml.XmlNode testNode = null;
  
              testResults results = new testResults("Core0001M");
              try
              {
                  results.description = "The \"getNamedItem(name)\" method retrieves a node " +
                      "specified by name.";
                  //
                  // Retrieve targeted data.
                  //
                  testNode = util.nodeObject(util.SECOND,util.SIXTH);
                  domesticAttr = (System.Xml.XmlAttribute)testNode.Attributes.GetNamedItem("domestic");
                  computedValue = domesticAttr.Name;
              }
              catch(System.Exception ex)
              {
                  computedValue = "Exception " + ex.Message;
              }
  
              //
              // Write out results 
              //
              results.expected = expectedValue;
              results.actual = computedValue;
  
              Assert.AreEqual (results.expected, results.actual);
          }
  
          //------------------------ End test case core-0001M --------------------------
          //
          //--------------------------- test case core-0002M ---------------------------
          //
          // Testing feature - The "getNamedItem(name)" method returns a node of any
          //                   type specified by name.
          //
          // Testing approach - Retrieve the second employee and create a NamedNodeMap
          //                    listing of the attributes of its last child.  Once
          //                    the list is created an invocation of the
          //                    "getNamedItem(name)" method is done where 
          //                    name = "street".  This should cause the method to return 
          //                    an Attr node.
          //
          // Semantic Requirements: 2 
          //
          //----------------------------------------------------------------------------
  
          [Test]
  	public void core0002M()
          {
              string computedValue = "";
              string expectedValue = "street";
              System.Xml.XmlAttribute streetAttr = null;
              System.Xml.XmlNode testNode = null;
  
              testResults results = new testResults("Core0002M");
              try
              {
                  results.description = "The \"getNamedItem(name)\" method returns a node "+
                      "of any type specified by name (test for Attr node).";
                  //
                  // Retrieve targeted data and get its attributes.
                  //
                  testNode =  util.nodeObject(util.SECOND,util.SIXTH);
                  streetAttr = (System.Xml.XmlAttribute)testNode.Attributes.GetNamedItem("street");
                  computedValue = streetAttr.Name;
              }
              catch(System.Exception ex)
              {
                  computedValue = "Exception " + ex.Message;
              }
  
              //
              // Write out results
              //
              results.expected = expectedValue;
              results.actual = computedValue;
  
              Assert.AreEqual (results.expected, results.actual);
          }
  
          //------------------------ End test case core-0002M --------------------------
          //
          //--------------------------- test case core-0003M ---------------------------
          //
          // Testing feature - The "getNamedItem(name)" method returns null if the
          //                   specified name did not identify any node in the map.
          //
          // Testing approach - Retrieve the second employee and create a NamedNodeMap
          //                    listing of the attributes of its last child.  Once
          //                    the list is created an invocation of the
          //                    "getNamedItem(name)" method is done where 
          //                    name = "district", this name does not match any names 
          //                    in the list and the method should return null.
          //
          // Semantic Requirements: 3 
          //
          //----------------------------------------------------------------------------
  
          [Test]
  	public void core0003M()
          {
              object computedValue = null;
              object expectedValue = null;
              System.Xml.XmlNode testNode = null;
  
  
              testResults results = new testResults("Core0003M");
              try
              {
                  results.description = "The \"getNamedItem(name)\" method returns null if the " +
                      "specified name did not identify any node in the map.";
                  //
                  // Retrieve targeted data and attempt to get a non-existing attribute.
                  //
                  testNode = util.nodeObject(util.SECOND,util.SIXTH);
                  computedValue = testNode.Attributes.GetNamedItem("district");
              }
              catch(System.Exception ex)
              {
                  computedValue = "Exception " + ex.Message;
              }
  
              //
              // Write out results
              //
              results.expected = (expectedValue == null).ToString();
              results.actual = (computedValue == null).ToString();
  
              Assert.AreEqual (results.expected, results.actual);
          }
  
          //------------------------ End test case core-0003M --------------------------
          //
          //--------------------------- test case core-0004M ---------------------------
          //
          // Testing feature - The "setNamedItem(arg)" method adds a node using its
          //                   nodeName attribute. 
          //
          // Testing approach - Retrieve the second employee and create a NamedNodeMap 
          //                    object from the attributes in its last child 
          //                    by invoking the "attributes" attribute.  Once the
          //                    list is created, the "setNamedItem(arg)" method is 
          //                    invoked with arg = newAttr, where newAttr is a new 
          //                    Attr Node previously created.  The "setNamedItem(arg)" 
          //                    method should add the new node to the NamedNodeItem 
          //                    object by using its "nodeName" attribute ("district" 
          //                    in this case).  Further this node is retrieved by using 
          //                    the "getNamedItem(name)" method.  This test uses the 
          //                    "createAttribute(name)" method from the Document 
          //                    interface.
          //
          // Semantic Requirements: 4 
          //
          //----------------------------------------------------------------------------
  
          [Test]
  	public void core0004M()
          {
              string computedValue = "";
              string expectedValue = "district";
              System.Xml.XmlAttribute districtAttr = null;
              System.Xml.XmlAttribute newAttr = (System.Xml.XmlAttribute)util.createNode(util.ATTRIBUTE_NODE,"district");
              System.Xml.XmlNode testNode = null;
  
              testResults results = new testResults("Core0004M");
              try
              {
                  results.description = "The \"setNamedItem(arg)\" method adds a node "+
                      "using its nodeName attribute.";
                  //
                  // Retrieve targeted data and add new attribute.
                  //
                  testNode = util.nodeObject(util.SECOND,util.SIXTH);
                  testNode.Attributes.SetNamedItem(newAttr);
                  districtAttr = (System.Xml.XmlAttribute)testNode.Attributes.GetNamedItem("district");
                  computedValue = districtAttr.Name; 
              }
              catch(System.Exception ex)
              {
                  computedValue = "Exception " + ex.Message;
              }
  
              //
              // Write out results
              //
              results.expected = expectedValue;
              results.actual = computedValue;
  
              util.resetData();
              Assert.AreEqual (results.expected, results.actual);
          }
  
          //------------------------ End test case core-0004M --------------------------
          //
          //--------------------------- test case core-0005 ---------------------------
          //
          // Testing feature - If the node to be added by the "setNamedItem(arg)" method 
          //                   already exists in the NamedNodeMap, it is replaced by the 
          //                   new one.
          //
          // Testing approach - Retrieve the second employee and create a NamedNodeMap
          //                    object from the attributes in its last child.  Once
          //                    the list is created, the "setNamedItem(arg) method is 
          //                    invoked with arg = newAttr, where newAttr is a Node Attr
          //                    previously created and whose node name already exist
          //                    in the map.   The "setNamedItem(arg)" method should 
          //                    replace the already existing node with the new one.  
          //                    Further this node is retrieved by using the 
          //                    "getNamedItem(name)" method.  This test uses the 
          //                    "createAttribute(name)" method from the Document 
          //                    interface.
          //
          // Semantic Requirements: 5 
          //
          //----------------------------------------------------------------------------
  
          [Test]
  	public void core0005M()
          {
              string computedValue = "";
              string expectedValue = "";
              System.Xml.XmlAttribute streetAttr = null;
              System.Xml.XmlAttribute newAttr = (System.Xml.XmlAttribute)util.createNode(util.ATTRIBUTE_NODE,"street");
              System.Xml.XmlNode testNode = null;
  
              testResults results = new testResults("Core0005M");
              try
              {
                  results.description = "If the node to be replaced by the \"setNamedItem(arg)\" " +
                      "method is already in the list, the existing node should " +
                      "be replaced by the new one.";
  
                  //
                  // Retrieve targeted data and add new attribute with name matching an 
                  // already existing attribute.
                  //
                  testNode = util.nodeObject(util.SECOND,util.SIXTH);
                  testNode.Attributes.SetNamedItem(newAttr);
                  streetAttr = (System.Xml.XmlAttribute)testNode.Attributes.GetNamedItem("street");
                  computedValue = streetAttr.Value;
              }
              catch(System.Exception ex)
              {
                  computedValue = "Exception " + ex.Message;
              }
              //
              // Write out results
              //
              results.expected = expectedValue;
              results.actual = computedValue;
  
              util.resetData();
              Assert.AreEqual (results.expected, results.actual);
          }
  
          //------------------------ End test case core-0005M --------------------------
          //
          //--------------------------- test case core-0006 ---------------------------
          //
          // Testing feature - If the "setNamedItem(arg)" method replaces an already 
          //                   existing node with the same name then the already existing
          //                   node is returned. 
          //
          // Testing approach - Retrieve the third employee and create a "NamedNodeMap"
          //                    object of the attributes in its last child by
          //                    invoking the "attributes" attribute.  Once the
          //                    list is created, the "setNamedItem(arg) method is 
          //                    invoked with arg = newAttr, where newAttr is a Node Attr
          //                    previously created and whose node name already exist
          //                    in the map.  The "setNamedItem(arg)" method should replace
          //                    the already existing node with the new one and return
          //                    the existing node.  Further this node is retrieved by 
          //                    using the "getNamedItem(name)" method.  This test 
          //                    uses the "createAttribute(name)" method from the Document 
          //                    interface.
          //
          // Semantic Requirements: 6 
          //
          //----------------------------------------------------------------------------
  
          [Test]
  	public void core0006M()
          {
              string computedValue = "";
              string expectedValue = "No";
              System.Xml.XmlNode returnedNode = null;
              System.Xml.XmlAttribute newAttr = (System.Xml.XmlAttribute)util.createNode(util.ATTRIBUTE_NODE,"street");
              System.Xml.XmlNode testNode = null;
  
              testResults results = new testResults("Core0006M");
              try
              {
                  results.description = "If the \"setNamedItem(arg)\" method replaces an "+
                      "already existing node with the same name then it "+
                      "returns the already existing node.";
                  //
                  // Retrieve targeted data and examine value returned by the setNamedItem
                  // method.
                  //
                  testNode = util.nodeObject(util.THIRD,util.SIXTH);
                  returnedNode = testNode.Attributes.SetNamedItem(newAttr);
                  computedValue = returnedNode.Value;
              }
              catch(System.Exception ex)
              {
                  computedValue = "Exception " + ex.Message;
              }
              //
              // Write out results
              //
              results.expected = expectedValue;
              results.actual = computedValue;
  
              util.resetData();
              Assert.AreEqual (results.expected, results.actual);
          }
  
          //------------------------ End test case core-0006M --------------------------
          //
          //--------------------------- test case core-0007 ---------------------------
          //
          // Testing feature - The "setNamedItem(arg)" method replace an 
          //                   already existing node with the same name. If a node with 
          //                   that name is already present in the collection, 
          //                   it is replaced by the new one.
          //
          // Testing approach - Retrieve the third employee and create a NamedNodeMap
          //                    object from the attributes in its last child. 
          //                    Once the list is created, the "setNamedItem(arg)" 
          //                    method is invoked with arg = newAttr, where newAttr is 
          //                    a new previously created Attr node The 
          //                    "setNamedItem(arg)" method should add the new node 
          //                    and return the new one.  Further this node is retrieved by 
          //                    using the "getNamedItem(name)" method.  This test 
          //                    uses the "createAttribute(name)" method from the 
          //                    Document interface.
          //
          // Semantic Requirements: 7 
          //
          //----------------------------------------------------------------------------
  
          [Test]
  	public void core0007M()
          {
              string computedValue = "";
              string expectedValue = "district";
              System.Xml.XmlAttribute newAttr = (System.Xml.XmlAttribute)util.createNode(util.ATTRIBUTE_NODE,"district");
              System.Xml.XmlNode testNode = null;
  
              testResults results = new testResults("Core0007M");
              try
              {
                  results.description = "If a node with that name is already present in the collection. The \"setNamedItem(arg)\" method is replacing it by the new one";
                  //
                  // Retrieve targeted data and set new attribute.
                  //
                  testNode = util.nodeObject(util.THIRD,util.SIXTH);
                  computedValue = testNode.Attributes.SetNamedItem(newAttr).Name;
              }
              catch(System.Exception ex)
              {
                  computedValue = "Exception " + ex.Message;
              }
              //
              // Write out results
              //
              results.expected = expectedValue;
              results.actual = computedValue;
  
              util.resetData();
              Assert.AreEqual (results.expected, results.actual);
          }
  
          //------------------------ End test case core-0007M --------------------------
          //
          //--------------------------- test case core-0008 ----------------------------
          //
          // Testing feature - The "removeNamedItem(name)" method removes a node
          //                   specified by name. 
          //
          // Testing approach - Retrieve the third employee and create a NamedNodeMap
          //                    object from the attributes in its last child. Once
          //                    the list is created, the "removeNamedItem(name)" 
          //                    method is invoked where "name" is the name of an 
          //                    existing attribute.  The "removeNamedItem(name)" method
          //                    should remove the specified attribute and its "specified"
          //                    attribute (since this is an Attr node) should be set
          //                    to false.  
          //
          // Semantic Requirements: 8 
          //
          //----------------------------------------------------------------------------
  
          [Test]
  	public void core0008M()
          {
              string computedValue = "";
              string expectedValue = "False";
              System.Xml.XmlNode testNode = null;
              System.Xml.XmlAttribute Attr = null;
  
              testResults results = new testResults("Core0008M");
              try
              {
                  results.description = "The \"removeNamedItem(name)\" method removes "+
                      "a node specified by name.";
                  //
                  // Retrive targeted data and and remove attribute.  It should no longer
                  // be specified.
                  //
                  testNode = (System.Xml.XmlNode)util.nodeObject(util.THIRD,util.SIXTH);
                  testNode.Attributes.RemoveNamedItem("street");
                  Attr = (System.Xml.XmlAttribute)testNode.Attributes.GetNamedItem("street");
                  computedValue = Attr.Specified.ToString();
              }
              catch(System.Exception ex)
              {
                  computedValue = "Exception " + ex.Message;
              }
              //
              // Write out results
              //
              results.expected = expectedValue;
              results.actual = computedValue;
  
              util.resetData();
              Assert.AreEqual (results.expected, results.actual);
          }
  
          //------------------------ End test case core-0008M --------------------------
          //
          //--------------------------- test case core-0009 ----------------------------
          //
          // Testing feature - If the node removed by the "removeNamedItem(name)" method
          //                   is an Attr node with a default value, its is immediately
          //                   replaced.
          //
          // Testing approach - Retrieve the third employee and create a NamedNodeMap
          //                    object from the attributes in its last child.  Once
          //                    the list is created, the "removeNamedItem(name)" method
          //                    is invoked where "name" is the name of an existing
          //                    attribute ("street)".  The "removeNamedItem(name)" method
          //                    should remove the "street" attribute and since it has 
          //                    a default value of "Yes", that value should immediately
          //                    be the attribute's value.
          //
          // Semantic Requirements: 9 
          //
          //----------------------------------------------------------------------------
  
          [Test]
  #if NET_2_0
  	[Category ("NotDotNet")]
  #endif
  	public void core0009M()
          {
              string computedValue = "";
              string expectedValue = "Yes";
              System.Xml.XmlNode testNode = null;
  
              testResults results = new testResults("Core0009M");
              try
              {
                  results.description = "If the node removed by the \"removeNamedItem(name)\" "+
                      "method is an Attr node with a default value, then "+
                      "it is immediately replaced.";
                  //
                  // Retrieve targeted data and remove attribute.
                  //
                  testNode = util.nodeObject(util.THIRD,util.SIXTH);
                  testNode.Attributes.RemoveNamedItem("street");
                  computedValue = testNode.Attributes.GetNamedItem("street").Value;
              }
              catch(System.Exception ex)
              {
                  computedValue = "Exception " + ex.Message;
              }
              //
              // Write out results
              //
              results.expected = expectedValue;
              results.actual = computedValue;
  
              util.resetData();
  
              Assert.AreEqual (results.expected, results.actual);
          }
  
          //------------------------ End test case core-0009M --------------------------
          //
          //--------------------------- test case core-0010M ---------------------------
          //
          // Testing feature - The "removeNamedItem(name)" method returns the node removed
          //                   from the map.
          //
          // Testing approach - Retrieve the third employee and create a NamedNodeMap
          //                    object from the attributes in its last child. 
          //                    Once the list is created, the "removeNamedItem(name)" 
          //                    method is invoked where "name" is the name of an existing
          //                    attribute ("street)".  The "removeNamedItem(name)" 
          //                    method should remove the existing "street" attribute
          //                    and return it.
          //
          // Semantic Requirements: 10 
          //
          //----------------------------------------------------------------------------
  
          [Test]
  	public void core0010M()
          {
              string computedValue = "";
              string expectedValue = "No";
              System.Xml.XmlNode returnedNode = null;
              System.Xml.XmlNode testNode = null;
  
              testResults results = new testResults("Core0010M");
              try
              {
                  results.description = "The \"removeNamedItem(name)\" method returns the "+
                      "node removed from the map.";
                  //
                  // Retrieve targeted data, remove attribute and examine returned value of
                  // removeNamedItem method.
                  //
                  testNode = util.nodeObject(util.THIRD,util.SIXTH);
                  returnedNode = testNode.Attributes.RemoveNamedItem("street");
                  computedValue = returnedNode.Value;
              }
              catch(System.Exception ex)
              {
                  computedValue = "Exception " + ex.Message;
              }
  
              //
              // Write out results
              //
              results.expected = expectedValue;
              results.actual = computedValue;
  
              util.resetData();
  
              Assert.AreEqual (results.expected, results.actual);
          }
  
          //------------------------ End test case core-0010M --------------------------
          //
          //--------------------------- test case core-0011M ---------------------------
          //
          // Testing feature - The "removeNamedItem(name)" method returns null if the
          //                   name specified does not exists in the map.
          //
          // Testing approach - Retrieve the third employee and create a NamedNodeMap
          //                    object from the attributes in its last child.
          //                    Once the list is created, the "removeNamedItem(name)" 
          //                    method is invoked where "name" does not exist in the 
          //                    map.  The method should return null.
          //
          // Semantic Requirements: 11
          //
          //----------------------------------------------------------------------------
  
          [Test]
  	public void core0011M()
          {
              object computedValue = null;
              object expectedValue = null;
              System.Xml.XmlNode testNode = null;
  
              testResults results = new testResults("Core0011M");
              try
              {
                  results.description = "The \"removeNamedItem(name)\" method returns null "+
                      "if the specified \"name\" is not in the map.";
                  //
                  // Retrieve targeted data and attempt to remove a non-existing attribute.
                  //
                  testNode = util.nodeObject(util.THIRD,util.SIXTH);
                  computedValue = testNode.Attributes.RemoveNamedItem("district");
              }
              catch(System.Exception ex)
              {
                  computedValue = "Exception " + ex.Message;
              }
  
              //
              // Write out results
              //
              results.expected = (expectedValue == null).ToString();
              results.actual = (computedValue == null).ToString();
  
              util.resetData();
  
              Assert.AreEqual (results.expected, results.actual);
          }
  
          //------------------------ End test case core-0011M --------------------------
          //
          //--------------------------- test case core-0012M ---------------------------
          //
          // Testing feature - The "item(index)" method returns the indexth item in the
          //                   map (test for first item).
          //
          // Testing approach - Retrieve the second employee and create a NamedNodeMap
          //                    object from the attributes in its last child by
          //                    by invoking the "attributes" attribute.  Once
          //                    the list is created, the "item(index)" method is
          //                    invoked with index = 0.  This should return the node at
          //                    the first position.  Since there are no guarantees that
          //                    first item in the map is the one that was listed first 
          //                    in the attribute list the test checks for all of them.
          //
          // Semantic Requirements: 12
          //
          //----------------------------------------------------------------------------
  
          [Test]
  	public void core0012M()
          {
              //string testName = "core-0012M";
              string computedValue = "";
  //            string expectedValue = "domestic or street";
              string expectedValue = "domestic";
              System.Xml.XmlNode returnedNode = null;
              System.Xml.XmlNode testNode = null;
  
              testResults results = new testResults("Core0012M");
              try
              {
                  results.description = "Retrieve the first item in the map via the \"item(index)\" method."; 
  
                  //
                  // Retrieve targeted data and invoke "item" method.
                  //  
                  testNode = util.nodeObject(util.SECOND,util.SIXTH);
                  returnedNode = testNode.Attributes.Item(0);
                  computedValue = returnedNode.Name;
              }
              catch(System.Exception ex)
              {
                  computedValue = "Exception " + ex.Message;
              }
  
              //
              // Write out results
              //
              results.expected = expectedValue;
              results.actual = computedValue;
  
              Assert.AreEqual (results.expected, results.actual);
          }
  
          //------------------------ End test case core-0012M --------------------------
          //
          //--------------------------- test case core-0013M ---------------------------
          //
          // Testing feature - The "item(index)" method returns the indexth item in the
          //                   map (test for last item).
          //
          // Testing approach - Retrieve the second employee and create a NamedNodeMap
          //                    object from the attributes in its last child. 
          //                    Once the list is created, the "item(index)" method is
          //                    invoked with index = 1.  This should return the node at
          //                    the last position.  Since there are no guarantees that
          //                    the last item in the map is the one that was listed last 
          //                    in the attribute list, the test checks for all of them.
          //
          // Semantic Requirements: 12
          //
          //----------------------------------------------------------------------------
  
          [Test]
  	public void core0013M()
          {
              string computedValue = "";
  //            string expectedValue = "domestic or street";
              string expectedValue = "street";
              System.Xml.XmlNode returnedNode = null;
              System.Xml.XmlNode testNode = null;
  
              testResults results = new testResults("Core0013M");
              try
              {
                  results.description = "Retrieve the last item in the map via the \"item(index)\" method."; 
                  //
                  // Retrieve targeted data and invoke "item" attribute.
                  //
                  testNode = util.nodeObject(util.THIRD,util.SIXTH);
                  returnedNode = testNode.Attributes.Item(1);
                  computedValue = returnedNode.Name;
              }
              catch(System.Exception ex)
              {
                  computedValue = "Exception " + ex.Message;
              }
              //
              // Write out results
              //
              results.expected = expectedValue;
              results.actual = computedValue;
  
              Assert.AreEqual (results.expected, results.actual);
          }
  
          //------------------------ End test case core-0013M --------------------------
          //
          //--------------------------- test case core-0014M ---------------------------
          //
          // Testing feature - The "item(index)" method returns null if the index is 
          //                   greater than the number of nodes in the map.
          //
          // Testing approach - Retrieve the second employee and create a NamedNodeMap
          //                    object from the attributes in its last child. 
          //                    element by invoking the "attributes" attribute.  Once
          //                    the list is created, the "item(index)" method is
          //                    invoked with index = 3.  This index value is greater than
          //                    the number of nodes in the map and under that condition
          //                    the method should return null.
          //
          // Semantic Requirements: 13
          //
          //----------------------------------------------------------------------------
  
          [Test]
  	public void core0014M()
          {
              object computedValue = null;
              object expectedValue = null;
              System.Xml.XmlNode testNode = null;
  
              testResults results = new testResults("Core0014M");
              try
              {
                  results.description = "The \"item(index)\" method returns null if the "+
                      "index is greater than the number of nodes in the map.";
  
                  //
                  // Retrieve targeted data and invoke "item" method.
                  //
                  testNode = util.nodeObject(util.THIRD,util.SIXTH);
                  computedValue = testNode.Attributes.Item(3);
              }
              catch(System.Exception ex)
              {
                  computedValue = "Exception " + ex.Message;
              }
  
              //
              // Write out results
              //
              results.expected = (expectedValue == null).ToString();
              results.actual = (computedValue == null).ToString();
  
              Assert.AreEqual (results.expected, results.actual);
          }
  
          //------------------------ End test case core-0014M --------------------------
          //
          //--------------------------- test case core-0015M ---------------------------
          //
          // Testing feature - The "item(index)" method returns null if the index is
          //                   equal to the number of nodes in the map.
          //
          // Testing approach - Retrieve the second employee and create a NamedNodeMap
          //                    object from the attributes in its last child 
          //                    Once the list is created, the "item(index)" method is
          //                    invoked with index = 2.  This index value is equal to 
          //                    the number of nodes in the map and under that condition
          //                    the method should return null (first item is at position
          //                    0).
          //
          // Semantic Requirements: 13
          //
          //----------------------------------------------------------------------------
  
          [Test]
  	public void core0015M()
          {
              object computedValue = null;
              object expectedValue = null;
              System.Xml.XmlNode testNode = null;
  
              testResults results = new testResults("Core0015M");
              try
              {
                  results.description = "The \"item(index)\" method returns null if the index " +
                      "is equal to the number of nodes in the map.";
                  //
                  // Retrieve targeted data and invoke "item" method.
                  //
                  testNode = util.nodeObject(util.THIRD,util.SIXTH);
                  computedValue = testNode.Attributes.Item(2);
              }
              catch(System.Exception ex)
              {
                  computedValue = "Exception " + ex.Message;
              }
              //
              // Write out results
              //
              results.expected = (expectedValue == null).ToString();
              results.actual = (computedValue == null).ToString();
  
              Assert.AreEqual (results.expected, results.actual);
          }
  
          //------------------------ End test case core-0015M --------------------------
          //
          //--------------------------- test case core-0016M ---------------------------
          //
          // Testing feature - The "length" attribute contains the total number of
          //                   nodes in the map.
          //
          // Testing approach - Retrieve the second employee and create a NamedNodeMap
          //                    object from the attributes in its last child. 
          //                    Once the list is created, the "length" attribute is
          //                    invoked.  That attribute should contain the number 2. 
          //
          // Semantic Requirements: 14
          //
          //----------------------------------------------------------------------------
  
          [Test]
  	public void core0016M()
          {
              string computedValue = "";
              string expectedValue = "2";
              System.Xml.XmlNode testNode = null;
  
              testResults results = new testResults("Core0016M");
              try
              {
                  results.description = "The \"length\" attribute contains the number of " +
                      "nodes in the map.";
                  //
                  // Retrieve targeted data and invoke "length" attribute.
                  //
                  testNode = util.nodeObject(util.THIRD,util.SIXTH);
  
gt:                 computedValue = testNode.Attributes.Count.ToString();