//**************************************************************************
//
//
//                       National Institute Of Standards and Technology
//                                     DTS Version 1.0
//         
//                                 CharacterData 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 CharacterDataTest : Assertion//,ITest
	{
		public static int i = 2;
/*
		public testResults[] RunTests()
		{
			testResults[] tests = new testResults[] {core0001C(), core0002C(), core0003C(),core0004C(),
														core0005C(), core0006C(), core0007C(), core0008C(),
														core0009C(), core0010C(), core0011C(), core0012C(),
														core0013C(), core0014C(), core0015C(),
														core0016C(), core0017C(), core0018C(), core0019C(),
														core0020C(), core0021C(), core0022C(), core0023C(),
														core0024C(), core0025C(), core0026C(), core0027C(),
														core0028C(), core0029C(), core0030C(), core0031C(),
														core0032C(), core0033C(), core0034C(), core0035C(),
														core0036C()};
  
			return tests;
		}
*/
		//------------------------ test case core-0001C ------------------------
		//
		// Testing feature -  The "data" attribute is the character data that
		//                    implements this interface.
		//
		// Testing approach - Retrieve the character data from the second child of
		//                    the first employee and invoke its "data" attribute.  The 
		//                    attribute should return the actual data.
		//                    
		// Semantic Requirements: 1
		//
		//----------------------------------------------------------------------------

		[Test]
		public void core0001C()
		{
			string computedValue = "";
			string expectedValue = "Margaret Martin";
			System.Xml.XmlNode testNode = null;
			System.Xml.XmlCharacterData testNodeData = null;

			testResults results = new testResults("Core0001C");
			try
			{
				results.description = "The \"data\" attribute is the character data that " +
					"implements this interface.";
				//
				// Access the targeted data.
				//
				testNode = util.nodeObject(util.FIRST,util.SECOND);
				testNodeData = (System.Xml.XmlCharacterData)testNode.FirstChild; 
				computedValue = testNodeData.Data;
			}
			catch(System.Exception ex)
			{
				computedValue = "Exception " + ex.Message;
			}
			//
			// Write out results 
			//
			results.expected = expectedValue;
			results.actual = computedValue;

			AssertEquals (results.expected, results.actual);
		}

		//------------------------ End test case core-0001C --------------------------
		//
		//--------------------------- test case core-0002C ---------------------------
		//
		// Testing feature -  The "length" attribute contains the number of 16-bit 
		//                    units that are available through the data attribute and
		//                    the substringData method.  Test for the "data" attribute.
		//
		// Testing approach - Retrieve the character data from the second child of
		//                    the first employee and access its data by using the
		//                    "data" attribute.  Finally the "length" attribute
		//                    is used on the character data returned by the "data"
		//                    attribute to determine the number of 16 bit units in
		//                    the data.
		//
		// Semantic Requirements: 2 
		//
		//----------------------------------------------------------------------------

		[Test]
		public void core0002C()
		{
			string computedValue = "";
			string expectedValue = "15";
			System.Xml.XmlNode testNode = null;
			System.Xml.XmlCharacterData testNodeData = null;

			testResults results = new testResults("Core0002C");
			try
			{
				results.description = "The \"length\" attribute is the number of 16-bit units " +
					"that are available through the \"data\" attribute " +
					"and the \"substringData\" method (test for \"data\").";
				//
				// Retrieve the targeted data and invoke its "data" attribute.
				//
				testNode = util.nodeObject(util.FIRST,util.SECOND);
				testNodeData = (System.Xml.XmlCharacterData)testNode.FirstChild;
				computedValue = testNodeData.Length.ToString();
			}
			catch(System.Exception ex)
			{
				computedValue = "Exception " + ex.Message;
			}
			//
			// Write out results
			//
			results.expected = expectedValue;
			results.actual = computedValue;

			AssertEquals (results.expected, results.actual);
		}

		//------------------------ End test case core-0002C --------------------------
		//
		//--------------------------- test case core-0003C ---------------------------
		//
		// Testing feature -  The "length" attribute contains the number of 16-bit units 
		//                    that are available through the data attribute and the
		//                    substringData method.  Test for the "substringData"
		//                    method.
		//
		// Testing approach - Retrieve the character data of the second child of the
		//                    first employee and access part of the data by using the 
		//                    "substringData(offset,count)" method.  Finally the 
		//                    "length" attribute is used on the character data 
		//                    returned by the "substringData(offset,count)" method 
		//                    to determine the number of 16-bit units in the data.
		//
		// Semantic Requirements: 2
		//
		//----------------------------------------------------------------------------

		[Test]
		public void core0003C()
		{
			string computedValue = "";
			string expectedValue = "8";
			System.Xml.XmlNode testNode = null;
			System.Xml.XmlCharacterData testNodeData = null;
			string subString = "";

			testResults results = new testResults("Core0003C");
			try
			{
				results.description = "The \"length\" attribute is the number of 16-bit units " +
					"that are available through the \"data\" attribute " +
					"and the \"substringData\" method (test for \"substringData\").";
				//
				// Retrieve the targeted data and invoke its "substringData" method.
				//
				testNode = util.nodeObject(util.FIRST,util.SECOND);
				testNodeData = (System.Xml.XmlCharacterData)testNode.FirstChild;
				subString = testNodeData.Substring(0,8);
				computedValue = subString.Length.ToString();
			}
			catch(System.Exception ex)
			{
				computedValue = "Exception " + ex.Message;
			}
			//
			// write out results
			//
			results.expected = expectedValue;
			results.actual = computedValue;

			AssertEquals (results.expected, results.actual);
		}

		//------------------------ End test case core-0003C --------------------------
		//
		//--------------------------- test case core-0004C ---------------------------
		//
		// Testing feature -  The "substringData(offset,count)" method returns the
		//                    specified substring.
		//
		// Testing approach - Retrieve the character data from the second child of the
		//                    first employee and access part of the data by using the
		//                    "substringData(offset,count)" method.  The method should
		//                    return the specified substring starting at position
		//                    "offset" and extract "count" characters.  The method
		//                    method should return the string "Margaret".
		//
		// Semantic Requirements: 3 
		//
		//----------------------------------------------------------------------------

		[Test]
		public void core0004C()
		{
			//string testName = "core-0004C";
			string computedValue = "";
			string expectedValue = "Margaret";
			System.Xml.XmlNode testNode = null;
			System.Xml.XmlCharacterData testNodeData = null;

			testResults results = new testResults("Core0004C");
			try
			{
				results.description = "The \"substringData(offset,count)\" method returns the " +
					"specified substring.";
				//
				// Retrieve the targeted data and invoke its "substringData" method.
				//
				testNode = util.nodeObject(util.FIRST,util.SECOND);
				testNodeData = (System.Xml.XmlCharacterData)testNode.FirstChild;
				computedValue = testNodeData.Substring(0,8);
			}
			catch(System.Exception ex)
			{
				computedValue = "Exception " + ex.Message;
			}
			//
			// Write out results
			//
			results.expected = expectedValue;
			results.actual = computedValue;

			AssertEquals (results.expected, results.actual);
		}

		//------------------------ End test case core-0004C --------------------------
		//
		//--------------------------- test case core-0005C ---------------------------
		//
		// Testing feature -  If the sum of "offset" and "count" exceeds "length" then 
		//                    the substringData(offset,count) method returns all 
		//                    the 16-bit units to the end of the data. 
		//
		// Testing approach - Retrieve the character data from the second child of the
		//                    first employee and access part of the data by using the
		//                    "substringData(offset,count)" method with offset = 9 and
		//                    count = 10.  The method should return the substring
		//                    "Martin" since offset + count > length (19 > 15).
		//
		// Semantic Requirements: 4 
		//
		//----------------------------------------------------------------------------

		[Test]
		public void core0005C()
		{
			string computedValue = "";
			string expectedValue = "Martin";
			System.Xml.XmlNode testNode = null;
			System.Xml.XmlCharacterData testNodeData = null;

			testResults results = new testResults("Core0005C");
			try
			{
				results.description = "If the sum of \"offset\" and \"count\" exceeds " +
					"the value of the \"length\" attribute then the " +
					"\"substringData(offset,count)\" method returns all " +
					"the 16-bit units to the end of the data.";
				//
				// Retrieve the targeted data and invoke its "substringData" method.
				//
				testNode = util.nodeObject(util.FIRST,util.SECOND);
				testNodeData = (System.Xml.XmlCharacterData)testNode.FirstChild;
				computedValue = testNodeData.Substring(9,10);
			}
			catch(System.Exception ex)
			{
				computedValue = "Exception " + ex.Message;
			}

			//
			// Write out results
			//
			results.expected = expectedValue;
			results.actual = computedValue;

			AssertEquals (results.expected, results.actual);
		}

		//------------------------ End test case core-0005C --------------------------
		//
		//--------------------------- test case core-0006C ---------------------------
		//
		// Testing feature - The "appendData(arg)" method appends a string to the end
		//                   of the character data of the node.
		//
		// Testing approach - Retrieve the character data from the second child of the
		//                    first employee.  The "appendData(arg)" method is then 
		//                    called with arg = ", Esquire".  The method should append 
		//                    the specified data to the already existing character 
		//                    data.  The new value of the "length" attribute should 
		//                    be 24.
		//
		// Semantic Requirements: 5 
		//
		//----------------------------------------------------------------------------

		[Test]
		public void core0006C()
		{
			string computedValue = "";
			string expectedValue = "24";
			System.Xml.XmlNode testNode = null;
			System.Xml.XmlCharacterData testNodeData = null;

			testResults results = new testResults("Core0006C");
			try
			{
				results.description = "The \"appendData(arg)\" method appends the specified " +
					"string to the end of the character data of the node.";
				//
				// Retrieve targeted data and invoke the "appendData" method.
				//
				testNode = util.nodeObject(util.FIRST,util.SECOND); 
				testNodeData = (System.Xml.XmlCharacterData)testNode.FirstChild;
				testNodeData.AppendData(", Esquire");;
				computedValue = testNodeData.Length.ToString();
			}
			catch(System.Exception ex)
			{
				computedValue = "Exception " + ex.Message;
			}
			//
			// Write out results
			//
			results.expected = expectedValue;
			results.actual = computedValue;

			util.resetData();

			AssertEquals (results.expected, results.actual);
		}

		//------------------------ End test case core-0006C --------------------------
		//
		//--------------------------- test case core-0007C ---------------------------
		//
		// Testing feature - Upon successful invocation of the "appendData(arg)" 
		//                   method, the "data" attribute provides access to the
		//                   concatenation of data and the specified DOMString.
		//
		// Testing approach - Retrieve the character data from the second child of 
		//                    the first employee.  The "appendData(arg)" method is 
		//                    then called with arg = ", Esquire".  The method should 
		//                    append the specified data to the already existing 
		//                    character data.  The new value of the "data" attribute 
		//                    should be "Margaret Martin, Esquire".
		//
		// Semantic Requirements: 6 
		//
		//----------------------------------------------------------------------------

		[Test]
		public void core0007C()
		{
			string computedValue = "";
			string expectedValue = "Margaret Martin, Esquire";
			System.Xml.XmlNode testNode = null;
			System.Xml.XmlCharacterData testNodeData = null;

			testResults results = new testResults("Core0007C");
			try
			{
				results.description = "Upon successful invocation of the \"appendData(arg)\" " +
					"method ,the \"data\" attribute provides access " +
					"to the concatenation of \"data\" and the specified DOMString.";
				//
				// Retrieve targeted data and invoke its "appendData" method.
				//
				testNode = util.nodeObject(util.FIRST,util.SECOND);
				testNodeData = (System.Xml.XmlCharacterData)testNode.FirstChild;
				testNodeData.AppendData(", Esquire");
				computedValue = testNodeData.Data;
			}
			catch(System.Exception ex)
			{
				computedValue = "Exception " + ex.Message;
			}
			//
			// Write out results
			//
			results.expected = expectedValue;
			results.actual = computedValue;

			util.resetData();

			AssertEquals (results.expected, results.actual);
		}

		//------------------------ End test case core-0007C --------------------------
		//
		//--------------------------- test case core-0008C ---------------------------
		//
		// Testing feature - The "insertData(offset,arg)" method insert a string at the
		//                   specified 16-bit unit offset.  Insert at the beginning of
		//                   the character data.
		//
		// Testing approach - Retrieve the character data from the second child of 
		//                    the first employee.  The "insertData(offset,arg)" 
		//                    method is then called with offset = 0 and arg = "Mss.".
		//                    The method should insert the string "Mss." at position 
		//                    0.  The new value of the character data should be "Mss.
		//                    Margaret Martin".
		//
		// Semantic Requirements: 7 
		//
		//----------------------------------------------------------------------------

		[Test]
		public void core0008C()
		{
			string computedValue = "";
			string expectedValue = "Mss. Margaret Martin";
			System.Xml.XmlNode testNode = null;
			System.Xml.XmlCharacterData testNodeData = null;

			testResults results = new testResults("Core0008C");
			try
			{
				results.description = "Insert a string at the beginning of character data.";
				//
				// Retrieve the targeted data and invoke its "insertData" method.
				//
				testNode = util.nodeObject(util.FIRST,util.SECOND);
				testNodeData = (System.Xml.XmlCharacterData)testNode.FirstChild;
				testNodeData.InsertData(0,"Mss. ");
				computedValue = testNodeData.Data;
			}
			catch(System.Exception ex)
			{
				computedValue = "Exception " + ex.Message;
			}
			//
			//    Write out results
			//
			results.expected = expectedValue;
			results.actual = computedValue;

			util.resetData();

			AssertEquals (results.expected, results.actual);
		}

		//------------------------ End test case core-0008C --------------------------
		//
		//--------------------------- test case core-0009C ---------------------------
		//
		// Testing feature - The "insertData(offset,arg)" method insert a string at the
		//                   specified 16-bit units offset.  Insert in the middle of
		//                   the character data.
		//
		// Testing approach - Retrieve the character data from the second child of the
		//                    first employee.  The "insertData(offset,arg)" method is 
		//                    then called with offset = 9 and arg = "Ann".  The 
		//                    method should insert the string "Ann" at position 9.  
		//                    The new value of the character data should be 
		//                    "Margaret Ann Martin".
		//
		// Semantic Requirements: 7
		//
		//----------------------------------------------------------------------------

		[Test]
		public void core0009C()
		{
			string computedValue = "";//0;
			string expectedValue = "Margaret Ann Martin";
			System.Xml.XmlNode testNode = null;
			System.Xml.XmlCharacterData testNodeData = null;

			testResults results = new testResults("Core0009C");
			try
			{
				results.description = "Insert a character string in the middle of character data."; 
				//
				// Retrieve targeted data and invoke its "insertData" method.
				//
				testNode = util.nodeObject(util.FIRST,util.SECOND);
				testNodeData = (System.Xml.XmlCharacterData)testNode.FirstChild; 
				testNodeData.InsertData(9,"Ann ");
				computedValue = testNodeData.Data;
			}
			catch(System.Exception ex)
			{
				computedValue = "Exception " + ex.Message;
			}
			//
			//    Write out results
			//
			results.expected = expectedValue;
			results.actual = computedValue;

			util.resetData();

			AssertEquals (results.expected, results.actual);
		}

		//------------------------ End test case core-0009C --------------------------
		//
		//--------------------------- test case core-0010C ---------------------------
		//
		// Testing feature - The "insertData(offset,arg)" method insert a string at the
		//                   specified 16-bit units offset.  Insert at the end of the
		//                   character data.
		//
		// Testing approach - Retrieve the character data from the second child of the
		//                    first employee.  The "insertData(offset,arg)" method 
		//                    is then called with offset = 14 and arg = ", Esquire".  
		//                    The method should insert the string ", Esquire" at 
		//                    position 14.  The new value of the character data 
		//                    should be "Margaret Martin, Esquire"
		//
		// Semantic Requirements: 7
		//
		//----------------------------------------------------------------------------

		[Test]
		public void core0010C()
		{
			string computedValue = "";
			string expectedValue = "Margaret Martin, Esquire";
			System.Xml.XmlNode testNode = null;
			System.Xml.XmlCharacterData testNodeData = null;

			testResults results = new testResults("Core0010C");
			try
			{
				results.description = "Insert a string at the end of character data.";
				//
				// Retrieve the targeted data and invoke its "insertData" method.
				//
				testNode = util.nodeObject(util.FIRST,util.SECOND);
				testNodeData = (System.Xml.XmlCharacterData)testNode.FirstChild; 
				testNodeData.InsertData(15,", Esquire");
				computedValue = testNodeData.Data;
			}
			catch(System.Exception ex)
			{
				computedValue = "Exception " + ex.Message;
			}
			//
			// Write out results
			//
			results.expected = expectedValue;
			results.actual = computedValue;

			util.resetData();

			AssertEquals (results.expected, results.actual);
		}

		//------------------------ End test case core-0010C --------------------------
		//
		//--------------------------- test case core-0011C ---------------------------
		//
		// Testing feature - The "deleteData(offset,count)" method removes a range of
		//                   16-bit units from the node.  Delete at the beginning of the
		//                   character data.
		//
		// Testing approach - Retrieve the character data from the last child of the
		//                    first employee.  The "deleteData(offset,count)" 
		//                    method is then called with offset = 0 and count = 16.  
		//                    The method should delete the characters from position 0 
		//                    thru position 16.  The new value of the character data 
		//                    should be "Dallas, Texas 98551".
		//
		// Semantic Requirements: 8, 9 
		//
		//----------------------------------------------------------------------------

		[Test]
		public void core0011C()
		{
			string computedValue = "";
			string expectedValue = "Dallas, Texas 98551";
			System.Xml.XmlNode testNode = null;
			System.Xml.XmlCharacterData testNodeData = null;

			testResults results = new testResults("Core0011C");
			try
			{
				results.description = "Delete character string from beginning of character data.";
				//
				// Retrieve the targeted data and invoke its "deleteData" method..
				//
				testNode = util.nodeObject(util.FIRST,util.SIXTH);
				testNodeData = (System.Xml.XmlCharacterData)testNode.FirstChild;
				testNodeData.DeleteData(0,16);
				computedValue = testNodeData.Data;
			}
			catch(System.Exception ex)
			{
				computedValue = "Exception " + ex.Message;
			}
			//
			// Write out results
			//
			results.expected = expectedValue;
			results.actual = computedValue;

			util.resetData();

			AssertEquals (results.expected, results.actual);
		}

		//------------------------ End test case core-0011C --------------------------
		//
		//--------------------------- test case core-0012C ---------------------------
		//
		// Testing feature - The "deleteData(offset,count)" method removes a range of
		//                   16-bit units from the node.  Delete in the middle of
		//                   the character data.
		//
		// Testing approach - Retrieve the character data from the last child of 
		//                    the first employee.  The "deleteData(offset,count)"
		//                    method is then called with offset = 16 and count = 8.
		//                    The method should delete the characters from position 16
		//                    thru position 24.  The new value of the character data
		//                    should be "1230 North Ave. Texas 98551".
		//
		// Semantic Requirements: 8, 9
		//
		//----------------------------------------------------------------------------

		[Test]
		public void core0012C()
		{
			string computedValue = "";
			string expectedValue = "1230 North Ave. Texas 98551";
			System.Xml.XmlNode testNode = null;
			System.Xml.XmlCharacterData testNodeData = null;

			testResults results = new testResults("Core0012C");
			try
			{
				results.description = "Delete character string from the middle of character data.";
				//
				// Retrieve the targeted data and invoke its "deleteData" method.
				//
				testNode = util.nodeObject(util.FIRST,util.SIXTH);
				testNodeData = (System.Xml.XmlCharacterData)testNode.FirstChild;
				testNodeData.DeleteData(16,8);
				computedValue = testNodeData.Data;
			}
			catch(System.Exception ex)
			{
				computedValue = "Exception " + ex.Message;
			}
			//
			// Write out results
			//
			results.expected = expectedValue;
			results.actual = computedValue;

			util.resetData();

			AssertEquals (results.expected, results.actual);
		}

		//------------------------ End test case core-0012C --------------------------
		//
		//--------------------------- test case core-0013C ---------------------------
		//
		// Testing feature - The "deleteData(offset,count)" method removes a range of
		//                   16-bit units from the node.  Delete at the end of the
		//                   character data.
		//
		// Testing approach - Retrieve the character data from the last child of 
		//                    the first employee.  The "deleteData(offset,count)"
		//                    method is then called with offset = 30 and count = 5.
		//                    The method should delete the characters from position 30 
		//                    thru position 35.  The new value of the character data
		//                    should be "1230 North Ave. Dallas, Texas".
		//
		// Semantic Requirements: 8, 9
		//
		//----------------------------------------------------------------------------

		[Test]
		public void core0013C()
		{
			string computedValue = "";
			string expectedValue = "1230 North Ave. Dallas, Texas ";
			System.Xml.XmlNode testNode = null;
			System.Xml.XmlCharacterData testNodeData = null;

			testResults results = new testResults("Core0013C");
			try
			{
				results.description = "Delete character string from the end of character data.";
				//
				// Retrieve the targeted data and invoke its "deleteData" method.
				//
				testNode = util.nodeObject(util.FIRST,util.SIXTH);
				testNodeData = (System.Xml.XmlCharacterData)testNode.FirstChild;
				testNodeData.DeleteData(30,5);
				computedValue = testNodeData.Data;
			}
			catch(System.Exception ex)
			{
				computedValue = "Exception " + ex.Message;
			}
			//
			// Write out results
			//
			results.expected = expectedValue;
			results.actual = computedValue;

			util.resetData();

			AssertEquals (results.expected, results.actual);
		}

		//------------------------ End test case core-0013C --------------------------
		//
		//--------------------------- test case core-0014C ---------------------------
		//
		// Testing feature - Upon successful invocation of the 
		//                   "deleteData(offset,count)" method, the data and length 
		//                   attributes reflect that change.
		//
		// Testing approach - Retrieve the character data of the last child of the
		//                    first employee.  The "deleteData(offset,count)"
		//                    method is then called with offset = 30 and count = 5.
		//                    The method should delete the characters from position 30 
		//                    thru position 35.  The new value of the character data
		//                    should be "1230 North Ave. Dallas, Texas" (the data
		//                    attribute) and its length attribute should be 30.  This
		//                    new values should be reflected immediately upon
		//                    its invocation. 
		//
		// Semantic Requirements: 9
		//
		//----------------------------------------------------------------------------

		[Test]
		public void core0014C()
		{
			string computedValue = "";
			string expectedValue = "1230 North Ave. Dallas, Texas 30";
			System.Xml.XmlNode testNode = null;
			System.Xml.XmlCharacterData testNodeData = null;

			testResults results = new testResults("Core0014C");
			try
			{
				results.description = "Data and length attributes are updated as a result " +
					"of the \"deleteData(offset, count)\" method.";
				//
				// Retrieve the targeted data and invoke its "deleteData" attribute.
				//
				testNode = util.nodeObject(util.FIRST,util.SIXTH);
				testNodeData = (System.Xml.XmlCharacterData)testNode.FirstChild;
				testNodeData.DeleteData(30,5);
				computedValue += testNodeData.Data;
				computedValue += testNodeData.Length;
			}
			catch(System.Exception ex)
			{
				computedValue = "Exception " + ex.Message;
			}
 
			//
			// Write out results
			//
			results.expected = expectedValue;
			results.actual = computedValue;

			util.resetData();

			AssertEquals (results.expected, results.actual);
		}

		//------------------------ End test case core-0014C --------------------------
		//
		//--------------------------- test case core-0015C ---------------------------
		//
		// Testing feature - If the sum of the offset and count attributes (from the
		//                   deleteData method) is greater than the length of the 
		//                   character data then all the 16-bit units from the offset 
		//                   to the end of the data are deleted.
		//
		// Testing approach - Retrieve the character data from the last child of the
		//                    first employee.  The "deleteData(offset,count)"
		//                    method is then called with offset = 4 and count = 50.
		//                    The method should delete the characters from position 4
		//                    to the end of the data since offset + count (50+4) is
		//                    greater than the length of the character data (35).  
		//                    The new value for the character data should be "1230".
		//
		// Semantic Requirements: 10 
		//
		//----------------------------------------------------------------------------

		[Test]
		public void core0015C()
		{
			string computedValue = "";
			string expectedValue = "1230";
			System.Xml.XmlNode testNode = null;
			System.Xml.XmlCharacterData testNodeData = null;

			testResults results = new testResults("Core0015C");
			try
			{
				results.description = "If the sum of \"offset\" and \"count\" exceeds the " +
					"length of the character data then all the " +
					"16-bit units from the offset thru the end of the " +
					"data are removed.<br>";
				//
				// Retrieve the targeted data and invoke its "deleteData" method.
				//
				testNode = util.nodeObject(util.FIRST,util.SIXTH);
				testNodeData = (System.Xml.XmlCharacterData)testNode.FirstChild;
				testNodeData.DeleteData(4,50);
				computedValue = testNodeData.Data;
			}
			catch(System.Exception ex)
			{
				computedValue = "Exception " + ex.Message;
			}

			//
			// Write out results
			//
			results.expected = expectedValue;
			results.actual = computedValue;

			util.resetData();

			AssertEquals (results.expected, results.actual);
		}

		//------------------------ End test case core-0015C --------------------------
		//
		//--------------------------- test case core-0016C ---------------------------
		//
		// Testing feature - The "replaceData(offset,count,arg)" method replace the 
		//                   characters starting at the specified 16-bit units with the
		//                   specified string.  Test for replacement at the 
		//                   beginning of the data.
		//
		// Testing approach - Retrieve the character data from the last child of the
		//                    first employee.  The "replaceData(offset,count,arg)"
		//                    method is then called with offset = 0 and count = 4 and
		//                    arg = "2500".  The method should replace the first four
		//                    characters of the character data with "2500".
		//
		// Semantic Requirements: 11 
		//
		//----------------------------------------------------------------------------

		[Test]
		public void core0016C()
		{
			string computedValue = "";//0;
			string expectedValue = "2500 North Ave. Dallas, Texas 98551";
			System.Xml.XmlNode testNode = null;
			System.Xml.XmlCharacterData testNodeData = null;

			testResults results = new testResults("Core0016C");
			try
			{
				results.description = "Replace a character string at the beginning of character data.";
				//
				// Retrieve the targeted data and invoke its "replaceData" method .
				//
				testNode = util.nodeObject(util.FIRST,util.SIXTH);
				testNodeData = (System.Xml.XmlCharacterData)testNode.FirstChild;
				testNodeData.ReplaceData(0,4,"2500");
				computedValue = testNodeData.Data;
			}
			catch(System.Exception ex)
			{
				computedValue = "Exception " + ex.Message;
			}

			//
			// Write out results
			//
			results.expected = expectedValue;
			results.actual = computedValue;

			util.resetData();

			AssertEquals (results.expected, results.actual);
		}

		//------------------------ End test case core-0016C --------------------------
		//
		//--------------------------- test case core-0017C ---------------------------
		// Testing feature - The "replaceData(offset,count,arg)" method replace the
		//                   characters starting at the specified 16-bit units with the
		//                   specified string.  Test for replacement in the
		//                   middle of the data.
		//
		// Testing approach - Retrieve the character data from the last child of the
		//                    first employee.  The "replaceData(offset,count,arg)"
		//                    method is then called with offset = 5 and count = 5 and
		//                    arg = "South".  The method should replace characters
		//                    five thru nine of the character data with "South".
		//
		// Semantic Requirements: 11
		//
		//----------------------------------------------------------------------------

		[Test]
		public void core0017C()
		{
			string computedValue = "";
			string expectedValue = "1230 South Ave. Dallas, Texas 98551";
			System.Xml.XmlNode testNode = null;
			System.Xml.XmlCharacterData testNodeData = null;

			testResults results = new testResults("Core0017C");
			try
			{
				results.description = "Replace a character string in the middle of character data.";
				//
				// Retrieve the targeted data and invoke its "replaceData" method.
				//
				testNode = util.nodeObject(util.FIRST,util.SIXTH);
				testNodeData = (System.Xml.XmlCharacterData)testNode.FirstChild;
				testNodeData.ReplaceData(5,5,"South");
				computedValue = testNodeData.Data;
			}
			catch(System.Exception ex)
			{
				computedValue = "Exception " + ex.Message;
			}

			//
			// Write out results
			//
			results.expected = expectedValue;
			results.actual = computedValue;

			util.resetData();

			AssertEquals (results.expected, results.actual);
		}

		//------------------------ End test case core-0017C --------------------------
		//
		//--------------------------- test case core-0018C ---------------------------
		//
		// Testing feature - The "replaceData(offset,count,arg)" method replace the
		//                   characters starting at the specified 16-bit units with the
		//                   specified string.  Test for replacement at the
		//                   end of the data.
		//
		// Testing approach - Retrieve the character data from the last child of the
		//                    first employee.  The "replaceData(offset,count,arg)"
		//                    method is then called with offset = 30 and count = 5 and
		//                    arg = "98665".  The method should replace characters
		//                    30 thru 34 of the character data with "98665".
		//
		// Semantic Requirements: 11
		//
		//----------------------------------------------------------------------------

		[Test]
		public void core0018C()
		{
			string computedValue = "";//0;
			string expectedValue = "1230 North Ave. Dallas, Texas 98665";
			System.Xml.XmlNode testNode = null;
			System.Xml.XmlCharacterData testNodeData = null;

			testResults results = new testResults("Core0018C");
			try
			{
				results.description = "Replace a character substring at the end of character data.";
				//
				// Retrieve the targeted data and invoke its "replaceData" method.
				//
				testNode = util.nodeObject(util.FIRST,util.SIXTH);
				testNodeData = (System.Xml.XmlCharacterData)testNode.FirstChild;
				testNodeData.ReplaceData(30,5,"98665");
				computedValue = testNodeData.Data;
			}
			catch(System.Exception ex)
			{
				computedValue = "Exception " + ex.Message;
			}

			//
			// Write out results
			//
			results.expected = expectedValue;
			results.actual = computedValue;

			util.resetData();

			AssertEquals (results.expected, results.actual);
		}

		//------------------------ End test case core-0018C --------------------------
		//
		//--------------------------- test case core-0019C ---------------------------
		//
		// Testing feature - The "replaceData(offset,count,arg)" method replace the
		//                   characters starting at the specified 16-bit units with the
		//                   specified string.  Test situation where the length of
		//                   the arg string is greater than the specified offset.
		//
		// Testing approach - Retrieve the character data from the last child of the
		//                    first employee.  The "replaceData(offset,count,arg)"
		//                    method is then called with offset = 0 and count = 4 and
		//                    arg = "260030".  The method should replace characters
		//                    one thru four with the string "260030".  Note that the
		//                    length of the specified string is greater than the
		//                    specified offset. 
		//
		// Semantic Requirements: 11
		//
		//----------------------------------------------------------------------------

		[Test]
		public void core0019C()
		{
			string computedValue = "";
			string expectedValue = "260030 North Ave. Dallas, Texas 98551";
			System.Xml.XmlNode testNode = null;
			System.Xml.XmlCharacterData testNodeData = null;
   
			testResults results = new testResults("Core0019C");
			try
			{
				results.description = "Checks \"replaceData(offset,count,arg)\" method when " +
					"length of arg > count.";
				//
				// Retrieve targeted data and invoke its "replaceData" method.
				//
				testNode = util.nodeObject(util.FIRST,util.SIXTH);
				testNodeData = (System.Xml.XmlCharacterData)testNode.FirstChild;
				testNodeData.ReplaceData(0,4,"260030");
				computedValue = testNodeData.Data;
			}
			catch(System.Exception ex)
			{
				computedValue = "Exception " + ex.Message;
			}

			//
			// Write out results
			//
			results.expected = expectedValue;
			results.actual = computedValue;

			util.resetData();

			AssertEquals (results.expected, results.actual);
		}

		//------------------------ End test case core-0019C --------------------------
		//
		//--------------------------- test case core-0020C ---------------------------
		//
		// Testing feature - If the sum of offset and count exceeds length then all 
		//                   the 16-bit units to the end of data are replaced. 
		//
		// Testing approach - Retrieve the character data from the last child of the
		//                    first employee.  The "replaceData(offset,count,arg)"
		//                    method is then called with offset = 0 and count = 50 and
		//                    arg = "2600".  The method should replace all the
		//                    characters in the character data with "2600".  This
		//                    is because the sum of offset and count exceeds the
		//                    length of the character data. 
		//
		// Semantic Requirements: 12
		//
		//----------------------------------------------------------------------------

		[Test]
		public void core0020C()
		{
			//string testName = "core-0020C";
			string computedValue = "";
			string expectedValue = "2600";
			System.Xml.XmlNode testNode = null;
			System.Xml.XmlCharacterData testNodeData = null;

			testResults results = new testResults("Core0020C");
			try
			{
				results.description = "If the sum of offset and count exceeds the length " +
					"of the character data then the \"replaceData(offset,count,arg)\" " +
					"method replaces all the 16-bit units to the end of the data.";
				//
				// Retrieve the targeted data and invoke its "replaceData" method.
				//
				testNode = util.nodeObject(util.FIRST,util.SIXTH);
				testNodeData = (System.Xml.XmlCharacterData)testNode.FirstChild;
				testNodeData.ReplaceData(0,50,"2600");
				computedValue = testNodeData.Data;
			}
			catch(System.Exception ex)
			{
				computedValue = "Exception " + ex.Message;
			}

			//
			// Write out results
			//
			results.expected = expectedValue;
			results.actual = computedValue;

			util.resetData();

			AssertEquals (results.expected, results.actual);
		}

		//------------------------ End test case core-0020C --------------------------
		//
		//--------------------------- test case core-0021C ---------------------------
		//
		// Testing feature - The "data" attribute raises a 
		//                   NO_MODIFICATION_ALLOWED_ERR Exception when 
		//                   this node is readonly.
		//
		// Testing approach - Retrieve the character data from the first
		//                    EntityReference node of the last child of the second
		//                    employee and attempt to set its "data" attribute.  Since
		//                    the the descendants of EntityReference nodes are readonly,
		//                    the desired exception should be raised.
		//
		// Semantic Requirements: 13
		//
		//----------------------------------------------------------------------------

		[Test]
		public void core0021C()
		{
			string computedValue = "";
			System.Xml.XmlNode testNode = null;
			System.Xml.XmlText readOnlyText = null;
			string expectedValue = "System.ArgumentException";//util.NO_MODIFICATION_ALLOWED_ERR;

			testResults results = new testResults("Core0021C");
			try
			{
				results.description = "The \"data\" attribute raises a NO_MODIFICATION_ALLOWED_ERR " +
					"DOMException when this node is readonly.";
				//
				// Retrieve targeted data.
				//
				testNode = util.nodeObject(util.SECOND,util.SIXTH);
				readOnlyText = (System.Xml.XmlText)testNode.FirstChild.FirstChild;
				//
				// Attempt to modify the "data" attribute should raise exception. 
				//
				try 
				{
					readOnlyText.Data = "ABCD";
				}
				catch (ArgumentException ex) 
				{
					computedValue = ex.GetType ().FullName; 
				}
			}
			catch(InvalidOperationException ex)
			{
				computedValue = "Exception " + ex.Message;
			}

			results.expected = expectedValue;
			results.actual = computedValue;

			util.resetData();

			AssertEquals (results.expected, results.actual);
		}

		//------------------------ End test case core-0021C --------------------------
		//
		//--------------------------- test case core-0022C ---------------------------
		//
		// Testing feature - The "appendData(arg) method raises a
		//                   NO_MODIFICATION_ALLOWED_ERR Exception when
		//                   this node is readonly.
		//
		// Testing approach - Retrieve the textual data from the the first
		//                    EntityReference node of the last child of the
		//                    second employee and attempt to append data to it.  
		//                    Descendants of EntityReference nodes are readonly 
		//                    nodes and therefore the desired exception should be
		//                    raised.
		//
		// Semantic Requirements: 14
		//
		//----------------------------------------------------------------------------

		[Test]
		public void core0022C()
		{
			string computedValue = "";
			System.Xml.XmlNode testNode = null;
			System.Xml.XmlCharacterData readOnlyNode = null;
			string expectedValue = "System.ArgumentException";//util.NO_MODIFICATION_ALLOWED_ERR;

			testResults results = new testResults("Core0022C");
			try
			{
				results.description = "The \"appendData(arg)\" method raises a " +
					"NO_MODIFICATION_ALLOWED_ERR Exception when this " +
					"node is readonly.";
				//
				// Retrieve the targeted data.
				//
				testNode = util.nodeObject(util.SECOND,util.SIXTH);
				readOnlyNode = (System.Xml.XmlCharacterData)testNode.FirstChild.FirstChild;
				//
				// Attempt to append data to a readonly node should raise an exception. 
				//
				try 
				{
					readOnlyNode.AppendData("002");
				}
				catch(ArgumentException ex) 
				{
					computedValue = ex.GetType ().FullName; 
				}
			}
			catch(System.Exception ex)
			{
				computedValue = "Exception " + ex.Message;
			}

			results.expected = expectedValue;
			results.actual = computedValue;

			util.resetData();

			AssertEquals (results.expected, results.actual);
		}

		//------------------------ End test case core-0022C --------------------------
		//
		//--------------------------- test case core-0023C ---------------------------
		//
		// Testing feature - The "insertData(offset,arg) method raises a
		//                   NO_MODIFICATION_ALLOWED_ERR Exception when
		//                   this node is readonly.
		//
		// Testing approach - Retrieve the Text data of the first EntityReference
		//                    node from the last child of the second employee and 
		//                    attempt to insert data into it.  Since the descendants
		//                    of EntityReference nodes are readonly, the desired
		//                    exception should be raised.
		//
		// Semantic Requirements: 15
		//
		//----------------------------------------------------------------------------

		[Test]
		public void core0023C()
		{
			string computedValue = "";
			System.Xml.XmlNode testNode = null;
			System.Xml.XmlCharacterData readOnlyNode = null;
			string expectedValue = "System.ArgumentException";//util.NO_MODIFICATION_ALLOWED_ERR;

			testResults results = new testResults("Core0023C");
			try
			{
				results.description = "The \"insertData(offset,arg)\" method raises a " +
					"NO_MODIFICATION_ALLOWED_ERR Exception when this " +
					"node is readonly.";
				//
				// Retrieve the targeted data
				//
				testNode = util.nodeObject(util.SECOND,util.SIXTH);
				readOnlyNode = (System.Xml.XmlCharacterData)testNode.FirstChild.FirstChild;
				//
				// Attempt to insert data into a readonly node should raise an exception.
				//
				try 
				{
					readOnlyNode.InsertData(2,"ABCD");
				}
				catch(ArgumentException ex) 
				{
					computedValue = ex.GetType ().FullName; 
				}
			}
			catch(System.Exception ex)
			{
				computedValue = "Exception " + ex.Message;
			}

			results.expected = expectedValue;
			results.actual = computedValue;

			util.resetData();

			AssertEquals (results.expected, results.actual);
		}

		//------------------------ End test case core-0023C --------------------------
		//
		//--------------------------- test case core-0024C ---------------------------
		//
		// Testing feature - The "deleteData(offset,count) method raises a
		//                   NO_MODIFICATION_ALLOWED_ERR Exception when
		//                   ths is readonly.
		//
		// Testing approach - Retrieve the textual data of the the first
		//                    EntityReference node from the last child of the
		//                    second employee and attempt to delete data from it.  
		//                    Since the descendants of EntityReference nodes are 
		//                    readonly, the desired exception should be raised.
		//
		// Semantic Requirements: 16
		//
		//----------------------------------------------------------------------------

		[Test]
		public void core0024C()
		{
			string computedValue = "";
			System.Xml.XmlCharacterData readOnlyNode = null;
			System.Xml.XmlNode testNode = null;
			string expectedValue = "System.ArgumentException";//util.NO_MODIFICATION_ALLOWED_ERR;

			testResults results = new testResults("Core0024C");
			try
			{
				results.description = "The \"deleteData(offset,count)\" method raises a " +
					"NO_MODIFICATION_ALLOWED_ERR Exception when this " +
					"node is readonly.";
				//
				// Retrieve the targeted data. 
				//
				testNode = util.nodeObject(util.SECOND,util.SIXTH); 
				readOnlyNode = (System.Xml.XmlCharacterData)testNode.FirstChild.FirstChild;
				//
				// Attempt to delete data from a readonly node should raise an
				// exception.
				//
				try 
				{
					readOnlyNode.DeleteData(2,4);
				}
				catch(System.Exception ex) 
				{
					computedValue = ex.GetType ().FullName; 
				}
			}
			catch(System.Exception ex)
			{
				computedValue = "Exception " + ex.Message;
			}

			results.expected = expectedValue;
			results.actual = computedValue;

			util.resetData();

			AssertEquals (results.expected, results.actual);
		}

		//------------------------ End test case core-0024C --------------------------
		//
		//--------------------------- test case core-0025C ---------------------------
		//
		// Testing feature - The "replaceData(offset,count,arg) method raises a
		//                   NO_MODIFICATION_ALLOWED_ERR Exception when
		//                   this node is readonly.
		//
		// Testing approach - Retrieve the textual data of the first EntityReference
		//                    node from the last child of the second employee and
		//                    attempt to replace data from it.  Since the descendants
		//                    of EntityReference nodes are readonly, the desired 
		//                    exception should be raised.
		//
		// Semantic Requirements: 17
		//
		//----------------------------------------------------------------------------

		[Test]
		public void core0025C()
		{
			string computedValue = "";
			System.Xml.XmlCharacterData readOnlyNode = null;
			System.Xml.XmlNode testNode = null;
			string expectedValue = "System.ArgumentException";//util.NO_MODIFICATION_ALLOWED_ERR;

			testResults results = new testResults("Core0025C");
			try
			{
				results.description = "The \"replaceData(offset,count,arg)\" method raises a " +
					"NO_MODIFICATION_ALLOWED_ERR Exception " +
					"when this node is readonly.";
				//
				// Retrieve the targeted data.
				//
				testNode = util.nodeObject(util.SECOND,util.SIXTH);
				readOnlyNode = (System.Xml.XmlCharacterData)testNode.FirstChild.FirstChild;
				//
				// Attempt to replace data from a readonly node should raise an
				// exception.
				//
				try 
				{
					readOnlyNode.ReplaceData(2,4,"ABCD");
				}
				catch(System.Exception ex) 
				{
					computedValue = ex.GetType ().FullName; 
				}
			}
			catch(System.Exception ex)
			{
				computedValue = "Exception " + ex.Message;
			}

			results.expected = expectedValue;
			results.actual = computedValue;

			util.resetData();

			AssertEquals (results.expected, results.actual);
		}

		//------------------------ End test case core-0025C --------------------------
		//
		//--------------------------- test case core-0026C ---------------------------
		//
		// Testing feature - The "substringData(offset,count)" method raises an 
		//                   INDEX_SIZE_ERR Exception if the specified offset is
		//                   negative.
		//
		// Testing approach - Retrieve the character data of the last child of the
		//                    of the first employee and invoke its 
		//                    "substringData(offset,count)" method with offset = -5
		//                    count = 3.  It should raise the desired exception since
		//                    the offset is negative.
		//
		// Semantic Requirements: 19
		//
		//----------------------------------------------------------------------------

		[Test]
		public void core0026C()
		{
			string computedValue = "";
			string returnedValue = "";
			System.Xml.XmlNode testNode = null;
			System.Xml.XmlCharacterData testNodeData = null;
			string expectedValue = "System.ArgumentOutOfRangeException";//util.INDEX_SIZE_ERR;

			testResults results = new testResults("Core0026C");
			try
			{
				results.description = "The \"substringData(offset,count)\" method raises an " +
					"INDEX_SIZE_ERR Exception if the specified " +
					"offset is negative.";
				//
				// Retrieve the targeted data.
				//
				testNode = util.nodeObject(util.FIRST,util.SIXTH);
				testNodeData = (System.Xml.XmlCharacterData)testNode.FirstChild;  
				//
				// A negative offset value should raise and exception.
				//
				try 
				{
					returnedValue = testNodeData.Substring(-5,3); 
				}
				catch(System.Exception ex) 
				{
					computedValue = ex.GetType ().FullName; 
				}
			}
			catch(System.Exception ex)
			{
				computedValue = "Exception " + ex.Message;
			}

			results.expected = expectedValue;
			results.actual = computedValue;

			AssertEquals (results.expected, results.actual);
		}

		//------------------------ End test case core-0026C --------------------------
		//
		//--------------------------- test case core-0027C ---------------------------
		//
		// Testing feature - The "substringData(offset,count)" method raises an
		//                   INDEX_SIZE_ERR Exception if the specified offset is
		//                   greater than the number of 16-bit units in the "data"
		//                   attribute. 
		//
		// Testing approach - Retrieve the character data of the last child of the
		//                    first employee and invoke its 
		//                    "substringData(offset,count)" method with offset = 40 and 
		//                    count = 3.  The value of the offset is greater than that
		//                    one of the "data" attribute, therefore the desired 
		//                    exception should be raised.
		//
		// Semantic Requirements: 20 
		//
		//----------------------------------------------------------------------------

		[Test]
		public void core0027C()
		{
			string computedValue = "";
			string returnedValue = "";
			System.Xml.XmlNode testNode = null;
			System.Xml.XmlCharacterData testNodeData = null;
			string expectedValue = "System.ArgumentOutOfRangeException";

			testResults results = new testResults("Core0027C");
			try
			{
				results.description = "The \"substringData(offset,count)\" method raises an " +
					"ArgumentOutOfRangeException Exception if the specified " +
					"offset is greater than the number of 16-bit units " +
					"in the \"data\" attribute.";
				//
				// Retrieve the targeted data.
				//
				testNode = util.nodeObject(util.FIRST,util.SIXTH);
				testNodeData = (System.Xml.XmlCharacterData)testNode.FirstChild;
				//
				// Offset greater than number of characters in data should raise an
				// exception.
				//
				try 
				{
					returnedValue = testNodeData.Substring(40,3);
				}
				catch(System.Exception ex) 
				{
					computedValue = ex.GetType().ToString();
				}
			}
			catch(System.Exception ex)
			{
				computedValue = "Exception " + ex.Message;
			}
			results.expected = expectedValue;
			results.actual = computedValue;

			AssertEquals (results.expected, results.actual);
		}

		//------------------------ End test case core-0027C --------------------------
		//
		//--------------------------- test case core-0028C ---------------------------
		//
		// Testing feature - The "substringData(offset,count)" method raises an
		//                   INDEX_SIZE_ERR Exception if the count is negative 
		//
		// Testing approach - Retrieve the character data of the last child of the
		//                    first employee and invoke its
		//                    "substringData(offset,count)" method with offset = 10
		//                    and count = -3.  Since the value of count is negative,
		//                    the desired exception should be raised.
		//
		// Semantic Requirements: 21 
		//
		//----------------------------------------------------------------------------

		[Test]
		public void core0028C()
		{
			string computedValue = "";
			string returnedValue = "";
			System.Xml.XmlNode testNode = null;
			System.Xml.XmlCharacterData testNodeData = null;
			string expectedValue = "System.ArgumentOutOfRangeException";

			testResults results = new testResults("Core0028C");
			try
			{
				results.description = "The \"substringData(offset,count)\" method raises an " +
					"INDEX_SIZE_ERR Exception if the count is negative.";
				//
				// Retrieve the targeted data.
				//
				testNode = util.nodeObject(util.FIRST,util.SIXTH);
				testNodeData = (System.Xml.XmlCharacterData)testNode.FirstChild;
				//
				// A negative value for "count" should raise an exception.
				//
				try 
				{
					returnedValue = testNodeData.Substring(10,-3);
				}
				catch(System.Exception ex) 
				{
					computedValue = ex.GetType().ToString();
				}
			}
			catch(System.Exception ex)
			{
				computedValue = "Exception " + ex.Message;
			}
			results.expected = expectedValue;
			results.actual = computedValue;

			AssertEquals (results.expected, results.actual);
		}

		//------------------------ End test case core-0028C --------------------------
		//
		//--------------------------- test case core-0029C ---------------------------
		//
		// Testing feature - The "deleteData(offset,count)" method raises an
		//                   ArgumentOutOfRangeException if the specified offset is
		//                   negative.
		//
		// Testing approach - Retrieve the character data of the last child of the
		//                    first employee and invoke its "deleteData(offset,count)"
		//                    method with offset = -5 and count = 3.  The value of the
		//                    offset is negative and therefore the desired exception
		//                    should be raised.
		//
		// Semantic Requirements: 22 
		//
		//----------------------------------------------------------------------------

		[Test]
		public void core0029C()
		{
			string computedValue = "";
			System.Xml.XmlNode testNode = null;
			System.Xml.XmlCharacterData testNodeData = null;
			string expectedValue = "System.ArgumentOutOfRangeException";

			testResults results = new testResults("Core0029C");
			try
			{
				results.description = "The \"deleteData(offset,count)\" method raises an " +
					"ArgumentOutOfRangeException if the specified " +
					"offset is negative.";
				//
				// Retrieve the targeted data.
				//
				testNode = util.nodeObject(util.FIRST,util.SIXTH);
				testNodeData = (System.Xml.XmlCharacterData)testNode.FirstChild;
				//
				// Invoke "deleteData(offset,count)" method with negative offset should
				// should raise an excetion.
				//
				try 
				{
					testNodeData.DeleteData(-5,3);
				}
				catch(System.Exception ex) 
				{
					computedValue = ex.GetType().ToString();
				}
			}
			catch(System.Exception ex)
			{
				computedValue = "Exception " + ex.Message;
			}
			results.expected = expectedValue;
			results.actual = computedValue;

			util.resetData();

			AssertEquals (results.expected, results.actual);
		}

		//------------------------ End test case core-0029C --------------------------
		//
		//--------------------------- test case core-0030C ---------------------------
		//
		// Testing feature - The "deleteData(offset,count)" method raises an
		//                   ArgumentOutOfRangeException if the specified offset is
		//                   greater than the number of characters in the "data"
		//                   attribute.
		//
		// Testing approach - Retrieve the character data of the last child of the
		//                    first employee and invoke its "deleteData(offset,count)"
		//                    method with offset = 40 and count = 3.  The value of the
		//                    offset is greater than the number of characters in the
		//                    "data" attribute (35) and therefore the intended 
		//                    exception should be raised.
		//
		// Semantic Requirements: 23 
		//
		//----------------------------------------------------------------------------

		[Test]
		public void core0030C()
		{
			string computedValue = "";
			System.Xml.XmlNode testNode = null;
			System.Xml.XmlCharacterData testNodeData = null;
			string expectedValue = "System.ArgumentOutOfRangeException";

			testResults results = new testResults("Core0030C");
			try
			{
				results.description = "The \"deleteData(offset,count)\" method raises an " +
					"ArgumentOutOfRangeException if the specified " +
					"offset is greater than the number of characters " +
					"in the \"data\" attribute.";
				//
				// Retrieve the targeted data.
				//
				testNode = util.nodeObject(util.FIRST,util.SIXTH);
				testNodeData = (System.Xml.XmlCharacterData)testNode.FirstChild;
				//
				// Invocation of "deleteData(offset,count)" method with offset > data
				// attribute should raise and exception.
				//
				try 
				{
					testNodeData.DeleteData(40,3);
				}
				catch(System.Exception ex) 
				{
					computedValue = ex.GetType().ToString(); 
				}
			}
			catch(System.Exception ex)
			{
				computedValue = "Exception " + ex.Message;
			}

			results.expected = expectedValue;
			results.actual = computedValue;

			util.resetData();

			AssertEquals (results.expected, results.actual);
		}

		//------------------------ End test case core-0030C --------------------------
		//
		//--------------------------- test case core-0031C ---------------------------
		//
		// Testing feature - The "deleteData(offset,count)" method raises an
		//                   ArgumentOutOfRangeException if the specified count is
		//                   negative.
		//
		// Testing approach - Retrieve the character data of the last child of the
		//                    first employee and invoke its "deleteData(offset,count)" 
		//                    method with offset = 10 and count = -3.  The value
		//                    of the specified count is negative and therefore the
		//                    intended exception should be raised.
		//
		// Semantic Requirements: 24 
		//
		//----------------------------------------------------------------------------

		[Test]
		public void core0031C()
		{
			string computedValue = "";
			System.Xml.XmlNode testNode = null;
			System.Xml.XmlCharacterData testNodeData = null;
			string expectedValue = "System.ArgumentOutOfRangeException";

			testResults results = new testResults("Core0031C");
			try
			{
				results.description = "The \"deleteData(offset,count)\" method raises an " +
					"ArgumentOutOfRangeException if the specified " +
					"count is negative.";
				//
				// Retrieve the targeted data.
				//
				testNode = util.nodeObject(util.FIRST,util.SIXTH);
				testNodeData = (System.Xml.XmlCharacterData)testNode.FirstChild;
				//
				// Invocation of "deleteData(offset,count)" method with count < 0 
				// should raise and exception. 
				//
				try 
				{
					testNodeData.DeleteData(10,-3);
				}
				catch(System.Exception ex) 
				{
					computedValue = ex.GetType().ToString();
				}
			}
			catch(System.Exception ex)
			{
				computedValue = "Exception " + ex.Message;
			}

			results.expected = expectedValue;
			results.actual = computedValue;

			util.resetData();

			AssertEquals (results.expected, results.actual);
		}

		//------------------------ End test case core-0031C --------------------------
		//
		//--------------------------- test case core-0032C ---------------------------
		//
		// Testing feature - The "replaceData(offset,count,arg)" method raises an
		//                   ArgumentOutOfRangeException if the specified offset is
		//                   negative.
		//
		// Testing approach - Retrieve the character data of the last child of the
		//                    first employee and invoke its 
		//                    "replaceData(offset,count,arg)" method with 
		//                    offset = -5 and count = 3 and arg = "ABC".  The value 
		//                    of the offset is negative and therefore the desired 
		//                    exception should be raised.
		//
		// Semantic Requirements: 25
		//
		//----------------------------------------------------------------------------

		[Test]
		public void core0032C()
		{
			string computedValue = "";
			System.Xml.XmlNode testNode = null;
			System.Xml.XmlCharacterData testNodeData = null;
			string expectedValue = "System.ArgumentOutOfRangeException";

			testResults results = new testResults("Core0032C");
			try
			{
				results.description = "The \"replaceData(offset,count,arg)\" method raises an " +
					"ArgumentOutOfRangeException if the specified " +
					"offset is negative.";
				//
				// Retrieve the targeted data.
				//
				testNode = util.nodeObject(util.FIRST,util.SIXTH);
				testNodeData = (System.Xml.XmlCharacterData)testNode.FirstChild;
				//
				// Invocation of "replaceData(offset,count,arg)" method offset < 0
				// should raise an exception.
				//
				try 
				{
					testNodeData.ReplaceData(-5,3,"ABC");
				}
				catch(System.Exception ex) 
				{
					computedValue = ex.GetType().ToString();
				}
			}
			catch(System.Exception ex)
			{
				computedValue = "Exception " + ex.Message;
			}

			results.expected = expectedValue;
			results.actual = computedValue;

			util.resetData();

			AssertEquals (results.expected, results.actual);
		}

		//------------------------ End test case core-0032C --------------------------
		//
		//--------------------------- test case core-0033C ---------------------------
		//
		// Testing feature - The "replaceData(offset,count,arg)" method raises an
		//                   INDEX_RANGE_ERR Exception if the specified offset is
		//                   greater than the number of 16-bit units in the "data"
		//                   attribute.
		//
		// Testing approach - Retrieve the character data of the last child of the
		//                    first employee and invoke its 
		//                    "replaceData(offset,count,arg)" method with offset = 40,
		//                    count = 3 and arg = "ABC".  The value of the offset is 
		//                    greater than the number of characters in the "data" 
		//                    attribute (35) and therefore the intended exception 
		//                    should be raised.
		//
		// Semantic Requirements: 26
		//
		//----------------------------------------------------------------------------

		[Test]
		public void core0033C()
		{
			string computedValue = "";
			System.Xml.XmlNode testNode = null;
			System.Xml.XmlCharacterData testNodeData = null;
			string expectedValue = "System.ArgumentOutOfRangeException";

			testResults results = new testResults("Core0033C");
			try
			{
				results.description = "The \"replaceData(offset,count,arg)\" method raises an " +
					"ArgumentOutOfRangeException if the specified " +
					"offset is greater than the number of 16-bit units " +
					"in the \"data\" attribute.";
				//
				// Retrieve the targeted data.
				//
				testNode = util.nodeObject(util.FIRST,util.SIXTH);
				testNodeData = (System.Xml.XmlCharacterData)testNode.FirstChild;
				//
				// Invocation of "replaceData(offset,count,arg)" method with offset > data  
				// attribute should raise and exception.
				//
				try 
				{
					testNodeData.ReplaceData(40,3,"ABC");
				}
				catch(System.Exception ex) 
				{
					computedValue = ex.GetType().ToString();
				}
			}
			catch(System.Exception ex)
			{
				computedValue = "Exception " + ex.Message;
			}

			results.expected = expectedValue;
			results.actual = computedValue;

			util.resetData();

			AssertEquals (results.expected, results.actual);
		} 

		//------------------------ End test case core-0033C --------------------------
		//
		//--------------------------- test case core-0034C ---------------------------
		//
		// Testing feature - The "replaceData(offset,count,arg)" method raises an
		//                   ArgumentOutOfRangeException if the specified count is
		//                   negative.
		//
		// Testing approach - Retrieve the character data of the last child of the
		//                    first employee and invoke its 
		//                    "replaceData(offset,count,arg)" method with offset = 10,
		//                    count = -3 and arg = "ABC".  The value of the specified 
		//                    count is negative and therefore the intended exception 
		//                    should be raised.
		//
		// Semantic Requirements: 27
		//
		//----------------------------------------------------------------------------

		[Test]
		public void core0034C()
		{
			string computedValue = "";
			System.Xml.XmlNode testNode = null;
			System.Xml.XmlCharacterData testNodeData = null;
			string expectedValue = "System.ArgumentOutOfRangeException";

			testResults results = new testResults("Core0034C");
			try
			{
				results.description = "The \"replaceData(offset,count,arg)\" method raises an " +
					"ArgumentOutOfRangeException if the specified " +
					"count is negative.";
				//
				// Retrieve the targeted data.
				//
				testNode = util.nodeObject(util.FIRST,util.SIXTH);
				testNodeData = (System.Xml.XmlCharacterData)testNode.FirstChild;
				//
				// Invocation of "replaceData(offset,count,arg)" method with count < 0
				// should raise an exception.
				//
				try 
				{
					testNodeData.ReplaceData(10,-3,"ABC");
				}
				catch(System.Exception ex) 
				{
					computedValue = ex.GetType().ToString(); 
				}
			}
			catch(System.Exception ex)
			{
				computedValue = "Exception " + ex.Message;
			}

			results.expected = expectedValue;
			results.actual = computedValue;

			util.resetData();

			AssertEquals (results.expected, results.actual);
		}

		//------------------------ End test case core-0034C --------------------------
		//
		//--------------------------- test case core-0035C ---------------------------
		//
		// Testing feature - The "insertData(offset,arg)" method raises an
		//                   ArgumentOutOfRangeException if the specified offset is
		//                   negative.
		//
		// Testing approach - Retrieve the character data from the last child of the
		//                    first employee and invoke its "insertData(offset,arg)" 
		//                    method with offset = -5 arg = "ABC".  The value
		//                    of the offset is negative and therefore the desired
		//                    exception should be raised.
		//
		// Semantic Requirements: 28
		//
		//----------------------------------------------------------------------------

		[Test]
		public void core0035C()
		{
			string computedValue = "";
			System.Xml.XmlNode testNode = null;
			System.Xml.XmlCharacterData testNodeData = null;
			string expectedValue = "System.ArgumentOutOfRangeException";

			testResults results = new testResults("Core0035C");
			try
			{
				results.description = "The \"insertData(offset,arg)\" method raises an " +
					"ArgumentOutOfRangeException if the specified offset is negative.";
				//
				// Retrieve the targeted data.
				//
				testNode = util.nodeObject(util.FIRST,util.SIXTH);
				testNodeData = (System.Xml.XmlCharacterData)testNode.FirstChild;
				//
				// Invocation of insertData(offset,arg)" method with offset < 0
				// should raise an exception.
				//
				try 
				{
					testNodeData.InsertData(-5,"ABC");
				}
				catch(System.Exception ex) 
				{
					computedValue = ex.GetType().ToString();
				}
			}
			catch(System.Exception ex)
			{
				computedValue = "Exception " + ex.Message;
			}

			results.expected = expectedValue;
			results.actual = computedValue;

			util.resetData();

			AssertEquals (results.expected, results.actual);
		}

		//------------------------ End test case core-0035C --------------------------
		//
		//--------------------------- test case core-0036C ---------------------------
		//
		// Testing feature - The "insertData(offset,arg)" method raises an
		//                   ArgumentOutOfRangeException if the specified offset is
		//                   greater than the number of 16-bit units in the "data"
		//                   attribute.
		//
		// Testing approach - Retrieve the character data from the last child of the
		//                    first employee and invoke its "insertData(offset,arg)" 
		//                    method with offset = 40 and arg = "ABC".  The value of 
		//                    the offset is greater than the number of characters in 
		//                    the "data" attribute(35) and therefore the intended
		//                    exception should be raised.
		//
		// Semantic Requirements: 29
		//
		//----------------------------------------------------------------------------

		[Test]
		public void core0036C()
		{
			string computedValue = "";
			System.Xml.XmlNode testNode = null;
			System.Xml.XmlCharacterData testNodeData = null;
			string expectedValue = "System.ArgumentOutOfRangeException";

			testResults results = new testResults("Core0036C");
			try
			{
				results.description = "The \"insertData(offset,arg)\" method raises an " +
					"ArgumentOutOfRangeException if the specified " +
					"offset is greater than the number of 16-bit units " +
					"in the \"data\" attribute.<br>";
				//
				// Retrieve the targeted data.
				//
				testNode = util.nodeObject(util.FIRST,util.SIXTH);
				testNodeData = (System.Xml.XmlCharacterData)testNode.FirstChild;
				//
				// Invocation of "insertData(offset arg)" method with offset > data 
				// attribute should raise an exception.
				//
				try 
				{
					testNodeData.InsertData(40,"ABC");
				}
				catch(System.Exception ex) 
				{
					computedValue = ex.GetType().ToString(); 
				}
			}
			catch(System.Exception ex)
			{
				computedValue = "Exception " + ex.Message;
			}

			results.expected = expectedValue;
			results.actual = computedValue;

			util.resetData();

			AssertEquals (results.expected, results.actual);
		}

		//------------------------ End test case core-0036C --------------------------
	}
}