/*
 * The Apache Software License, Version 1.1
 * 
 * Copyright (c) 1999 The Apache Software Foundation.  All rights 
 * reserved.
 * 
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer. 
 * 
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in
 *    the documentation and/or other materials provided with the
 *    distribution.
 * 
 * 3. The end-user documentation included with the redistribution,
 *    if any, must include the following acknowledgment:  
 *       "This product includes software developed by the
 *        Apache Software Foundation (http://www.apache.org/)."
 *    Alternately, this acknowledgment may appear in the software itself,
 *    if and wherever such third-party acknowledgments normally appear.
 * 
 * 4. The names "Xerces" and "Apache Software Foundation" must
 *    not be used to endorse or promote products derived from this
 *    software without prior written permission. For written 
 *    permission, please contact apache\@apache.org.
 * 
 * 5. Products derived from this software may not be called "Apache",
 *    nor may "Apache" appear in their name, without prior written
 *    permission of the Apache Software Foundation.
 * 
 * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESSED OR IMPLIED
 * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
 * DISCLAIMED.  IN NO EVENT SHALL THE APACHE SOFTWARE FOUNDATION OR
 * ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF
 * USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
 * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
 * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
 * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
 * SUCH DAMAGE.
 * ====================================================================
 * 
 * This software consists of voluntary contributions made by many
 * individuals on behalf of the Apache Software Foundation, and was
 * originally based on software copyright (c) 1999, International
 * Business Machines, Inc., http://www.ibm.com .  For more information
 * on the Apache Software Foundation, please see
 * <http://www.apache.org/>.
 */

/**
 * $Log$
 * Revision 1.2  1999/12/03 00:02:25  andyh
 * DOM tests updated to catch DOMException by ref.
 * Added tests of DOMString::transcode() and append()
 *
 * Revision 1.1.1.1  1999/11/09 01:02:34  twl
 * Initial checkin
 *
 * Revision 1.2  1999/11/08 20:42:24  rahul
 * Swat for adding in Product name and CVS comment log variable.
 *
 */


/**
 * This class tests methods for XML DOM implementation
 * version 2.0 10/12/98
 * 
 * DOM_DOMException errors are tested by calls to DOMExceptionsTest from: Main, docBuilder...
 *
 */
 
/**
 * $Log$
 * Revision 1.2  1999/12/03 00:02:25  andyh
 * DOM tests updated to catch DOMException by ref.
 * Added tests of DOMString::transcode() and append()
 *
 * Revision 1.1.1.1  1999/11/09 01:02:34  twl
 * Initial checkin
 *
 * Revision 1.2  1999/11/08 20:42:24  rahul
 * Swat for adding in Product name and CVS comment log variable.
 *
 */

#include <stdio.h>
#include "DTest.h"
#include <util/PlatformUtils.hpp>
#include <util/XMLException.hpp>
#include <util/StdOut.hpp>


#define EXCEPTIONSTEST(operation, expectedException, resultFlag, testNum) \
    {                                                               \
        try                                                         \
        {                                                           \
            operation;                                              \
            fprintf(stderr, "Exceptions Test # %d: no Exception thrown.\n", testNum); \
        }                                                           \
        catch (DOM_DOMException &e)                                 \
        {                                                           \
            if (e.code != expectedException) {                      \
                fprintf(stderr, "Exceptions Test # %d: wrong DOM_DOMException thrown.\n", \
                    testNum);                                       \
                resultFlag = false;                                 \
            }                                                       \
        }                                                           \
        catch (...)                                                 \
        {                                                           \
            fprintf(stderr, "Exceptions Test # %d: unknown exception thrown.\n",    \
                testNum);                                           \
            resultFlag = false;                                     \
        }                                                           \
    }  


#define LEAKTEST(operation)                             \
{                                                       \
    operation;   /* Precondition  */                    \
    DomMemDebug entryMemState;                          \
    {                                                   \
        operation;                                      \
    }                                                   \
    DomMemDebug exitMemState;                           \
    if (entryMemState != exitMemState)                  \
    {                                                   \
        printf("Memory Leak at line %d\n", __LINE__);   \
        exitMemState.printDifference(entryMemState);    \
    }                                                   \
}


DOM_Element                 DTest::testElementNode;
DOM_Attr                    DTest::testAttributeNode;
DOM_Text                    DTest::testTextNode;
DOM_CDATASection            DTest::testCDATASectionNode;
DOM_EntityReference         DTest::testEntityReferenceNode;
DOM_Entity                  DTest::testEntityNode;
DOM_ProcessingInstruction   DTest::testProcessingInstructionNode;
DOM_Comment                 DTest::testCommentNode;
DOM_Document                DTest::testDocumentNode;
DOM_DocumentType            DTest::testDocumentTypeNode;
DOM_DocumentFragment        DTest::testDocumentFragmentNode;
DOM_Notation                DTest::testNotationNode;

/**
 * 
 * version 2.0 10/12/98
 *
 */
    
DTest::DTest()
{
};


/**
 * version 3.0 01/25/99
 *  
 * @return DOM_Document
 *
 */
DOM_Document DTest::createDocument() {
    return DOM_Document::createDocument();
};


/**
 * version 3.0 01/25/99
 * 
 * @return DOM_DocumentType
 * @param name DOMString
 *
 */
DOM_DocumentType DTest::createDocumentType(DOM_Document doc, DOMString name) {
    return doc.createDocumentType(name);    //Replace with a DOM_DocumentType creator
};


/**
 * version 3.0 01/25/99
 *  
 * @return org.w3c.dom.DOM_Entity
 * @param doc org.w3c.dom.DOM_Document
 * @param name DOMString
 *
 */
DOM_Entity DTest::createEntity(DOM_Document doc, DOMString name) {
    return doc.createEntity(name);
};


/**
 * version 3.0 01/25/99
 * 
 * @return org.w3c.dom.DOM_Notation
 * @param doc org.w3c.dom.DOM_Document
 * @param name DOMString
 *
 */
DOM_Notation DTest::createNotation(DOM_Document doc, DOMString name) {
    return doc.createNotation(name);
};


/**
 * This method builds test documents for the XML DOM implementation
 * version 2.0 10/12/98
 * @param document org.w3c.dom.DOM_Document
 * @param name document's name
 * @param type document's type
 *
 */
void DTest::docBuilder(DOM_Document document, DOMString name)
{
    DOM_Document doc = document;
    bool OK = true;
        
    DOM_Element docFirstElement = doc.createElement(name + "FirstElement");
    doc.appendChild(docFirstElement);
    docFirstElement.setAttribute(name + "FirstElement", name + "firstElement");
    
    DOM_ProcessingInstruction docProcessingInstruction = doc.createProcessingInstruction(name +
                    "TargetProcessorChannel", DOMString("This is ") + doc.getNodeName() + "'s processing instruction");
    docFirstElement.appendChild(docProcessingInstruction);
    
    DOM_Element docBody = doc.createElement(name + "TestBody");
    docFirstElement.appendChild(docBody);
    
    DOM_Element docBodyLevel21 = doc.createElement(name + "BodyLevel21");
    DOM_Element docBodyLevel22 = doc.createElement(name + "BodyLevel22");
    DOM_Element docBodyLevel23 = doc.createElement(name + "BodyLevel23");
    DOM_Element docBodyLevel24 = doc.createElement(name + "BodyLevel24");
    docBody.appendChild(docBodyLevel21);
    docBody.appendChild(docBodyLevel22);
    docBody.appendChild(docBodyLevel23);
    docBody.appendChild(docBodyLevel24);
    
    DOM_Element docBodyLevel31 = doc.createElement(name + "BodyLevel31");
    DOM_Element docBodyLevel32 = doc.createElement(name + "BodyLevel32");
    DOM_Element docBodyLevel33 = doc.createElement(name + "BodyLevel33");
    DOM_Element docBodyLevel34 = doc.createElement(name + "BodyLevel34");
    docBodyLevel21.appendChild(docBodyLevel31);
    docBodyLevel21.appendChild(docBodyLevel32);
    docBodyLevel22.appendChild(docBodyLevel33);
    docBodyLevel22.appendChild(docBodyLevel34);
    
    DOM_Text docTextNode11 = doc.createTextNode(name + "BodyLevel31'sChildTextNode11");
    DOM_Text docTextNode12 = doc.createTextNode(name + "BodyLevel31'sChildTextNode12");
    DOM_Text docTextNode13 = doc.createTextNode(name + "BodyLevel31'sChildTextNode13");
    DOM_Text docTextNode2 = doc.createTextNode(name + "TextNode2");
    DOM_Text docTextNode3 = doc.createTextNode(name + "TextNode3");
    DOM_Text docTextNode4 = doc.createTextNode(name + "TextNode4");
    docBodyLevel31.appendChild(docTextNode11);
    docBodyLevel31.appendChild(docTextNode12);
    docBodyLevel31.appendChild(docTextNode13);
    docBodyLevel32.appendChild(docTextNode2);
    docBodyLevel33.appendChild(docTextNode3);
    docBodyLevel34.appendChild(docTextNode4);
    
    DOM_CDATASection docCDATASection = doc.createCDATASection("<![CDATA[<greeting>Hello, world!</greeting>]]>");
    docBodyLevel23.appendChild(docCDATASection);
    
    DOM_Comment docComment = doc.createComment("This should be a comment of some kind ");
    docBodyLevel23.appendChild(docComment);
    
    DOM_EntityReference docReferenceEntity = doc.createEntityReference("ourEntityNode");
    docBodyLevel24.appendChild(docReferenceEntity);

    DTest make;
    DOM_Notation docNotation = make.createNotation(doc, "ourNotationNode");
    DOM_DocumentType docType = (DOM_DocumentType &)doc.getFirstChild();
    docType.getNotations().setNamedItem(docNotation);
    
    DOM_DocumentFragment docDocFragment = doc.createDocumentFragment();
    
//  printf("This document's first element name is " + docFirstElement.getTagName() + "\n");


//***********Following are for errorTests
    DOM_Text docNode3 = doc.createTextNode(name + "docTextNode3");
    DOM_Text docNode4 = doc.createTextNode(name + "docTextNode4");
    
    DOM_Entity docEntity = (DOM_Entity &) doc.getDoctype().getEntities().getNamedItem("ourEntityNode"); // Get the DOM_Entity node
    DOM_DocumentType docDocType = (DOM_DocumentType &) doc.getFirstChild(); // Get the DOM_DocumentType node
    DOM_EntityReference & entityReferenceText = (DOM_EntityReference &) doc.getLastChild().getLastChild().getLastChild().getFirstChild();
    DOM_Text entityReferenceText2 = doc.createTextNode("entityReferenceText information");
//************************************************* ERROR TESTS
    DTest tests;

    EXCEPTIONSTEST(document.appendChild(docBody), DOM_DOMException::HIERARCHY_REQUEST_ERR, OK,  1);

    EXCEPTIONSTEST(document.appendChild(docBody), DOM_DOMException::HIERARCHY_REQUEST_ERR, OK, 2);
    EXCEPTIONSTEST(docNode3.appendChild(docNode4), DOM_DOMException::HIERARCHY_REQUEST_ERR, OK, 3); 
    EXCEPTIONSTEST(doc.insertBefore(docEntity, docFirstElement), DOM_DOMException::HIERARCHY_REQUEST_ERR, OK, 4); 
    EXCEPTIONSTEST(doc.replaceChild(docCDATASection, docFirstElement), DOM_DOMException::HIERARCHY_REQUEST_ERR, OK, 5); 
    EXCEPTIONSTEST(docFirstElement.setNodeValue("This shouldn't work!" ), DOM_DOMException::NO_MODIFICATION_ALLOWED_ERR, OK, 6);    
    EXCEPTIONSTEST(docReferenceEntity.setNodeValue("This shouldn't work!" ), DOM_DOMException::NO_MODIFICATION_ALLOWED_ERR, OK, 7);
    EXCEPTIONSTEST(docEntity.setNodeValue("This shouldn't work!" ), DOM_DOMException::NO_MODIFICATION_ALLOWED_ERR, OK, 8);
    EXCEPTIONSTEST(doc.setNodeValue("This shouldn't work!" ), DOM_DOMException::NO_MODIFICATION_ALLOWED_ERR, OK, 9);
    EXCEPTIONSTEST(docDocType.setNodeValue("This shouldn't work!" ), DOM_DOMException::NO_MODIFICATION_ALLOWED_ERR, OK, 10);
    EXCEPTIONSTEST(docDocFragment.setNodeValue("This shouldn't work!" ), DOM_DOMException::NO_MODIFICATION_ALLOWED_ERR, OK, 11);
    EXCEPTIONSTEST(docNotation.setNodeValue("This shouldn't work!" ), DOM_DOMException::NO_MODIFICATION_ALLOWED_ERR, OK, 12);
    EXCEPTIONSTEST(docReferenceEntity.appendChild(entityReferenceText2 ), DOM_DOMException::NO_MODIFICATION_ALLOWED_ERR , OK, 13);
    EXCEPTIONSTEST(docBodyLevel32.insertBefore(docTextNode11,docBody ), DOM_DOMException::NOT_FOUND_ERR, OK, 14);
    EXCEPTIONSTEST(docBodyLevel32.removeChild(docFirstElement), DOM_DOMException::NOT_FOUND_ERR, OK, 15);
    EXCEPTIONSTEST(docBodyLevel32.replaceChild(docTextNode11,docFirstElement ), DOM_DOMException::NOT_FOUND_ERR, OK, 16);


//!! Throws a NOT_FOUND_ERR ********
     
     // docBodyLevel32.getAttributes().removeNamedItem(testAttribute.getName());    16  // To test removeNamedItem
     
};  //END OF DOCBUILDER


/**
 * @param document org.w3c.dom.DOM_Document
 */
 void DTest::findTestNodes(DOM_Document document) {
    DOM_Node node = document;
    int nodeCount = 0;

    // Walk the tree until you find and assign all node types needed that exist.
    while (node != null && nodeCount < 12)
    {

        switch (node.getNodeType())
    {
        case DOM_Node::ELEMENT_NODE :
            if (testElementNode == null) {testElementNode = (DOM_Element &)node; nodeCount++;}
            break;
        case DOM_Node::ATTRIBUTE_NODE :
            if (testAttributeNode == null) {testAttributeNode = (DOM_Attr &)node; nodeCount++;}
            break;
        case DOM_Node::TEXT_NODE :
            if (testTextNode == null) {testTextNode = (DOM_Text &)node; nodeCount++;}
            break;
        case DOM_Node::CDATA_SECTION_NODE :
            if (testCDATASectionNode == null) {testCDATASectionNode = (DOM_CDATASection &)node; nodeCount++;}
            break;
        case DOM_Node::ENTITY_REFERENCE_NODE :
            if (testEntityReferenceNode == null) {testEntityReferenceNode = (DOM_EntityReference &)node; nodeCount++;}
            break;
        case DOM_Node::ENTITY_NODE :
            if (testEntityNode == null) {testEntityNode = (DOM_Entity &)node; nodeCount++;}
            break;
        case DOM_Node::PROCESSING_INSTRUCTION_NODE :
            if (testProcessingInstructionNode == null) {testProcessingInstructionNode = (DOM_ProcessingInstruction &)node; nodeCount++;}
            break;
        case DOM_Node::COMMENT_NODE :
            if (testCommentNode == null) {testCommentNode = (DOM_Comment &)node; nodeCount++;}
            break;
        case DOM_Node::DOCUMENT_TYPE_NODE :
            if (testDocumentTypeNode == null) {testDocumentTypeNode = (DOM_DocumentType &)node; nodeCount++;}
            break;
        case DOM_Node::DOCUMENT_FRAGMENT_NODE :
            if (testDocumentFragmentNode == null) {testDocumentFragmentNode = (DOM_DocumentFragment &)node; nodeCount++;}
            break;
        case DOM_Node::NOTATION_NODE :
            if (testNotationNode == null) {testNotationNode = (DOM_Notation &)node; nodeCount++;}
            break;
        case DOM_Node::DOCUMENT_NODE :
            if (testDocumentNode == null) {testDocumentNode = (DOM_Document &)node; nodeCount++;}
            break;
        default:
            ;
    }// End of switch

    }   // End of while
};


/**
 * @param document org.w3c.dom.DOM_Document
 */
 void DTest::findTestNodes(DOM_Node node) {
    DTest test;
    DOM_Node kid;
    // Walk the tree until you find and assign all node types needed that exist.
    
        
    if (node.getFirstChild() != null)
    {
        kid = node.getFirstChild();
        test.findTestNodes(kid);
    }
            
                
    if (node.getNextSibling() != null)
    {
        kid = node.getNextSibling();
        test.findTestNodes(kid);
    }

        
    switch (node.getNodeType())
    {
        case DOM_Node::ELEMENT_NODE :
            if (testElementNode == null) {testElementNode = (DOM_Element &)node; }
            break;
        case DOM_Node::ATTRIBUTE_NODE :
            if (testAttributeNode == null) {testAttributeNode = (DOM_Attr &)node; }
            break;
        case DOM_Node::TEXT_NODE :
            if (testTextNode == null) {testTextNode = (DOM_Text &)node; }
            break;
        case DOM_Node::CDATA_SECTION_NODE :
            if (testCDATASectionNode == null) {testCDATASectionNode = (DOM_CDATASection &)node; }
            break;
        case DOM_Node::ENTITY_REFERENCE_NODE :
            if (testEntityReferenceNode == null) {testEntityReferenceNode = (DOM_EntityReference &)node;}
            break;
        case DOM_Node::ENTITY_NODE :
            if (testEntityNode == null) {testEntityNode = (DOM_Entity &)node;}
            break;
        case DOM_Node::PROCESSING_INSTRUCTION_NODE :
            if (testProcessingInstructionNode == null) {testProcessingInstructionNode = (DOM_ProcessingInstruction &)node;}
            break;
        case DOM_Node::COMMENT_NODE :
            if (testCommentNode == null) {testCommentNode = (DOM_Comment &)node;}
            break;
        case DOM_Node::DOCUMENT_TYPE_NODE :
            if (testDocumentTypeNode == null) {testDocumentTypeNode = (DOM_DocumentType &)node; }
            break;
        case DOM_Node::DOCUMENT_FRAGMENT_NODE :
            if (testDocumentFragmentNode == null) {testDocumentFragmentNode = (DOM_DocumentFragment &)node;}
            break;
        case DOM_Node::NOTATION_NODE :
            if (testNotationNode == null) {testNotationNode = (DOM_Notation &)node;}
            break;
        case DOM_Node::DOCUMENT_NODE :
            if (testDocumentNode == null) {testDocumentNode = (DOM_Document &)node;}
            break;
        default:
            ;
    }// End of switch
};//End of class

/**
 * 
 * version 2.0 10/12/98
 *
 */
 void main(int argc, char **argv)
 {

     {
         //  Nest entire test in an inner block.
         //     Reference counting should recover all document
         //     storage when this block exits.
         
         DTest test;
		XMLStdOut errStrm;
		try {
			XMLPlatformUtils::Initialize();
        }
        catch (const XMLException& toCatch) {
			errStrm << "Error during initialization! :\n"
			<< toCatch.getMessage() << EndLn;
			return ;
        } 
 
         long avgTime = 0;
         bool OK = true;
         long startTime = 0;//****************Time the whole thing for efficiency of DOM implementation
         
         // for (int i=0; i< 1000; i++)
         // {   
         // AH Revisit  //  startTime = System.currentTimeMillis();
         //     if(!OK)
         //     break;
         
         DOM_Document d = test.createDocument();
         // DOM_Document z = test.createDocument();
         
         DOM_DocumentType docDocType = test.createDocumentType(d,"testDocument1");
         d.appendChild(docDocType);
         
         DOM_Entity docEntity = test.createEntity( d, "ourEntityNode");
         DOM_Text entityChildText = d.createTextNode("entityChildText information"); // Build a branch for entityReference tests
         docEntity.appendChild(entityChildText);                      // & for READONLY_ERR tests
         docDocType.getEntities().setNamedItem(docEntity);
         
         test.docBuilder(d, "d");
         
         test.findTestNodes((DOM_Node)d);
         // test.docBuilder(z, "z");
         // try {
         LEAKTEST(test.testAttr(d););
         LEAKTEST(test.testCDATASection(d););
         LEAKTEST(test.testCharacterData(d););
         LEAKTEST(test.testChildNodeList(d););
         LEAKTEST(test.testComment(d););
         LEAKTEST(test.testDeepNodeList(d););
         LEAKTEST(test.testDocument(d););
         LEAKTEST(test.testDocumentFragment(d););
         LEAKTEST(test.testDocumentType(d);); 
         LEAKTEST(test.testDOMImplementation(d););
         LEAKTEST(test.testElement(d););
         LEAKTEST(test.testEntity(d););
         LEAKTEST(test.testEntityReference(d););
         LEAKTEST(test.testNode(d););
         LEAKTEST(test.testNotation(d););  
         LEAKTEST(test.testPI(d);); 
         LEAKTEST(test.testText(d););  
         LEAKTEST(test.testDOMerrors(d););
         
         //!! Throws WRONG_DOCUMENT_ERR **********
         
         // z.appendChild(d.createComment("Test doc d comment"));// Tries to append z document with document d comment
         // d.getDocumentElement().appendChild(z.createElement("newZdocElement"));// Tries to append d document with document z DOM_Element
         // d.getLastChild().getLastChild().insertBefore(z.createElement("newZdocElement"),d.getLastChild().getLastChild().getFirstChild());// Tries to insert into d document with document z DOM_Element
         // d.replaceChild(z.createElement("newZdocElement"),d.getLastChild().getLastChild().getFirstChild());  // Tries to replace in d document with document z DOM_Element
         
         /* Attribute newAttribute = d.createAttribute("newAttribute");
         d.getDocumentElement().setAttributeNode(newAttribute);
         d.getDocumentElement().getAttributes().setNamedItem(z.createAttribute("newzAttribute"));
         */
         
         //!! Throws INVALID_CHARACTER_ERR **********
         // ******This just gets us through each method. JKess has a comprehensive test of Invalid Names******
         // d.createAttribute("Invalid Name"); // Name with blank space
         // d.createElement("5InvalidName"); // Name starts with numeric
         // d.createProcessingInstruction("This is the target processor channel","InvalidName>");// Name ends with >
         // d.getDocumentElement().setAttribute("Invalid%Name",""); // Name contains %
         
         
         //!!   ******** NO_DATA_ALLOWED_ERR ********No cases to test as of 9/15
         
         
         //!!   ******** NO_MODIFICATION_ALLOWED_ERR ******** When read only exists
         /*
         
           
               // **** FOR DOM_Element when read only exists********
               .removeAttribute("aString");        // ***** Not until read only exists.
               .removeAttributeNode(Attribute);        // ***** Not until read only exists.
               .setAttribute("aString", "anotherString"); // ***** Not until read only exists.
               
                 
                   // **** FOR DOM_Node when read only exists********
                   .appendChild(aNode);         // ***** Not until read only exists.
                   .insertBefore(aNode, AnotherNode);   // ***** Not until read only exists.
                   .removeChild(aNode);         // ***** Not until read only exists.
                   .replaceChild(aNode);            // ***** Not until read only exists.
                   
                     .splitText(2); // ***** Not until read only exists.
                     
                       .setNamedItem(DOM_Node); // ***** Not until read only exists.
         */
         
         
         //!!******** NOT_SUPPORTED_ERR ********For HTML when implemented
         /*
         .createCDATASection("String stuff");
         .createEntityReference("String stuff");
         .createProcessingInstruction("String stuff", "Some more String stuff");
         */
         
         // } catch (DOM_DOMException &e) {
         //     fprintf(stderr, "Unexpected DOM Exception caught.  Code is: %d\n", e.code);
         //     OK = false;
         // }
         //    catch (...) {
         //        fprintf(stderr, "Unexpected non-DOM exception caught.");
         //    };
         
         
         //System.err.println("Elapsed time (measured in seconds): " +   ((System.currentTimeMillis() - startTime) / 1000.0));
         // AH revisit avgTime += System.currentTimeMillis() - startTime;
         // }//END OF FOR
         
         
         // System.err.println("Elapsed time (measured in seconds): " +
         //                    ((System.currentTimeMillis() - startTime) / 1000.0));
         //       System.err.println("Elapsed time (measured in mili-seconds): " +
         //                    ((System.currentTimeMillis() - startTime)));
         
         
         // System.err.println("Average Elapsed time (measured in seconds): " + (avgTime/10000000.0) );

         // Null out the static object references in class DTest,
         // which will recover their storage.  Part of testing for memory leaks.
         DTest::testElementNode = null;
         DTest::testAttributeNode = null;
         DTest::testTextNode = null;
         DTest::testCDATASectionNode = null;
         DTest::testEntityReferenceNode = null;
         DTest::testEntityNode = null;
         DTest::testProcessingInstructionNode = null;
         DTest::testCommentNode = null;
         DTest::testDocumentNode = null;
         DTest::testDocumentTypeNode = null;
         DTest::testDocumentFragmentNode = null;
         DTest::testNotationNode = null;
         
    };
    DomMemDebug().print();
};


/**
 * This method tests DOM_Attr methods for the XML DOM implementation
 * version 2.0 10/12/98
 * @param document org.w3c.dom.DOM_Document
 *
 */
void DTest::testAttr(DOM_Document document)
{
    DOM_Node node;  
    DOM_Attr attributeNode, attribute2;
    DOMString compare;
    bool T = true;
    bool F = false;
    bool OK = true;
// For debugging*****   printf("\n          testAttr's outputs:\n\n");

    DOM_Attr testAttribute = document.createAttribute("testAttribute");
    testAttribute.setValue("testAttribute's value");
    node = document.getDocumentElement(); // node gets first element

    // ((DOM_Element &)node).setAttributeNode(testAttribute);
    // attributeNode = ((DOM_Element &)node).getAttributeNode("testAttribute");
    DOM_Element el = (DOM_Element &)node;
    el.setAttributeNode(testAttribute); 
    attributeNode = el.getAttributeNode("testAttribute");
    
    compare = "testAttribute";
    if (!compare.equals(attributeNode.getName()))
    {
        printf("Warning!!! DOM_Attr's 'getName' method failed to work properly!\n");
        OK = false;
    }
    compare = "testAttribute's value";
    if (!compare.equals(attributeNode.getNodeValue()))
    {
        printf("Warning!!! DOM_Attr's 'getNodeValue' method failed to work properly!\n");
        OK = false;
    }
    if (! T ==attributeNode.getSpecified())
    {
        printf("Warning!!! DOM_Attr's 'getSpecified' method failed to work properly!\n");
        OK = false;
    }
    
    if (!compare.equals(attributeNode.getValue()))
    {
        printf("Warning!!! DOM_Attr's 'getValue' method failed to work properly!\n");
        OK = false;
    }


    attributeNode.setNodeValue("Reset Value");   /// LEAK!!!!!
    compare = "Reset Value";
    if (!compare.equals(attributeNode.getNodeValue()))
    {
        printf("Warning!!! DOM_Attr's 'setNodeValue' method failed to work properly!\n");
        OK = false;
    }

    // IBM Specific function
    attributeNode.setSpecified(F);//***** How do we change this for external use??
    if (! F ==attributeNode.getSpecified())
    {
        printf("Warning!!! DOM_Attr's 'setSpecified' method failed to work properly!\n");
        OK = false;
    }
    
    attributeNode.setValue(null);
    if (! attributeNode.getValue().equals(""))
    {
        printf("Warning!!! DOM_Attr's 'setValue' to 'null' method failed to work properly!\n");
        OK = false;
    }
    
    attributeNode.setValue("Another value ");
    compare = "Another value ";
    if (!compare.equals(attributeNode.getValue()))
    {
        printf("Warning!!! DOM_Attr's 'setValue' method failed to work properly!");
        OK = false;
    }

    node = attributeNode.cloneNode(T);
                                      
    // Check nodes for equality, both their name and value or lack thereof
    bool cloneOK = true;
    if (!(node.getNodeName().equals(attributeNode.getNodeName())))
        cloneOK = false;
    if (node.getNodeValue() == null &&
        attributeNode.getNodeValue() != null)
    {
        attributeNode.getNodeValue().print();
        cloneOK = false;
    }

    if (node.getNodeValue() != null && attributeNode.getNodeValue() == null)
    {
        cloneOK = false;
        node.getNodeValue().print();
    };

    if (node.getNodeValue() != null && attributeNode.getNodeValue() != null)
    {
        if (!(node.getNodeValue().equals(attributeNode.getNodeValue())))
            cloneOK = false;
    }


/*
    if (! (node.getNodeName().equals(attributeNode.getNodeName()) &&         // Compares node names for equality
          (node.getNodeValue() != null && attributeNode.getNodeValue() != null)  // Checks to make sure each node has a value node
        ?  node.getNodeValue().equals(attributeNode.getNodeValue())          // If both have value nodes test those value nodes for equality
        : (node.getNodeValue() == null && attributeNode.getNodeValue() == null)))// If one node doesn't have a value node make sure both don't
*/
    if (cloneOK == false)
        {   
            printf("'cloneNode' did not clone the Attribute node correctly\n");
            OK = false;
        }
        // Deep clone test comparison is in testNode & testDocument

//************************************************* ERROR TESTS
    DTest tests;
//!! Throws HIERARCHY_REQUEST_ERR ****************  
    //  doc.getDocumentElement().appendChild(attributeNode);

//!! Throws a NOT_FOUND_ERR ********
    //  attribute2 = doc.createAttribute("testAttribute2");
    //  doc.getDocumentElement().removeAttributeNode(attribute2);

//!! Throws an INUSE_ATTRIBUTE_ERR ******
    //  DOM_Element element = (DOM_Element &)doc.getLastChild().getLastChild();
    //  element.setAttributeNode(testAttribute );// Tests setNamedItem which generates error through justSetNamedItem.
    
// For debugging*****       printf("All DOM_Attr method calls worked correctly.\n");
    if (! OK)
        printf("\n*****The DOM_Attr method calls listed above failed, all others worked correctly.*****\n");
//  printf("");

};


/**
 * This method tests DOM_CDATASection methods for the XML DOM implementation
 * version 2.0 10/12/98
 * @param document org.w3c.dom.DOM_Document
 *
 */
void DTest::testCDATASection(DOM_Document document)
{
    DOM_Node node, node2;
    bool T = true;
    bool OK = true;
// For debugging*****   printf("\n          testCDATASection's outputs:\n");
    node = document.getDocumentElement().getElementsByTagName("dBodyLevel23").item(0).getFirstChild(); // node gets DOM_CDATASection node

    node2 = node.cloneNode(T);//*****?
    // Check nodes for equality, both their name and value or lack thereof
    if (! (node.getNodeName().equals(node2.getNodeName()) &&        // Compares node names for equality
          (node.getNodeValue() != null && node2.getNodeValue() != null)     // Checks to make sure each node has a value node
        ?  node.getNodeValue().equals(node2.getNodeValue())         // If both have value nodes test those value nodes for equality
        : (node.getNodeValue() == null && node2.getNodeValue() == null)))   // If one node doesn't have a value node make sure both don't
    {
        printf("'cloneNode' did not clone the DOM_CDATASection node correctly\n");
        OK = false;
    }
    // Deep clone test comparison is in testNode & testDocument
    
// For debugging*****   printf("All DOM_CDATASection method calls worked correctly.\n");
        
    if (! OK)
        printf("\n*****The DOM_CDATASection method calls listed above failed, all others worked correctly.*****\n");
//  printf("");
};


/**
 * This method tests DOM_CharacterData methods for the XML DOM implementation
 * version 2.0 10/12/98
 * @param document org.w3c.dom.DOM_Document
 *
 */
void DTest::testCharacterData(DOM_Document document)
{
    DOM_CharacterData charData;
    DOMString compareData, newData, resetData;
    bool OK = true;
// For debugging*****   printf("\n          testCharacterData's outputs:\n");
    charData = (DOM_CharacterData &) document.getDocumentElement().getElementsByTagName("dBodyLevel31").item(0).getFirstChild(); // charData gets textNode11
    compareData = "dBodyLevel31'sChildTextNode11";
    if (!compareData.equals(charData.getData()))
    {
        printf("Warning!!! DOM_CharacterData's 'getData' failed to work properly!\n This may corrupt other DOM_CharacterData tests!!!*****\n");
        OK = false;
    }   
    
    resetData = charData.getData();
    //  printf("This node's original data is: " + charData.getData());

    newData = " This is new data for this node";
    compareData = charData.getData() + newData;
    charData.appendData(newData);
    if (!compareData.equals(charData.getData()))
    {
        printf("Warning!!! DOM_CharacterData's 'appendData' failed to work properly!\n");
        OK = false;
    }
    //  printf("This node's appended data is: " + charData.getData());

    compareData = "dBodyLevel";
    charData.deleteData(10, 100);
    if (!compareData.equals(charData.getData()))
    {
        printf("Warning!!! DOM_CharacterData's 'deleteData' failed to work properly!\n");
        OK = false;
    }
    //  printf("This node's partially deleted data is: " + charData.getData());

    int length = 10;
    if (!(length == charData.getLength()))
    {
        printf("Warning!!! DOM_CharacterData's 'getLength' failed to work properly!\n");
        OK = false;
    }
    //  printf("This node's data length is: " + charData.getLength());

    compareData = "dBody' This is data inserted into this node'Level";
    charData.insertData(5, "' This is data inserted into this node'");
    if (!compareData.equals(charData.getData()))
    {
        printf("Warning!!! DOM_CharacterData's 'insertData' failed to work properly!\n");
        OK = false;
    }
    //  printf("This node's updated with insert data is: " + charData.getData());

    compareData = "dBody' This is ' replacement data'ted into this node'Level";
    charData.replaceData(15, 10, "' replacement data'");
    if (!compareData.equals(charData.getData()))
    {
        printf("Warning!!! DOM_CharacterData's 'replaceData' failed to work properly!\n");
        OK = false;
    }
    //  printf("This node's updated with replacement data is: " +charData.getData());

    compareData = "New data A123456789B123456789C123456789D123456789E123456789";
    charData.setData("New data A123456789B123456789C123456789D123456789E123456789");
    if (!compareData.equals(charData.getData()))
    {
        printf("Warning!!! DOM_CharacterData's 'setData' failed to work properly!");
        OK = false;
    }
    //  printf("This node's new data via setData: " + charData.getData());

    compareData = "123456789D123456789E123456789";
    if (!compareData.equals(charData.substringData(30, 30)))
    {
        printf("Warning!!! DOM_CharacterData's 'substringData' failed to work properly!\n");
        OK = false;
    }
    //  printf("Using subString 30,30 you get:");  charData.substringData(30,30)).print();

    compareData = "New data A123456789B12345";
    if (!compareData.equals(charData.substringData(0, 25)))
    {
        printf("Warning!!! DOM_CharacterData's 'substringData' failed to work properly!\n");
        OK = false;
    }
    //  printf("Using subString 0,25 you get: ");   charData.substringData(0,25)).print();

//************************************************* ERROR TESTS
    DTest tests;   // What is this for?  'tests' is never used.

//!! Throws INDEX_SIZE_ERR ********************
    EXCEPTIONSTEST(charData.deleteData(-1, 5), DOM_DOMException::INDEX_SIZE_ERR, OK, 101 );
    EXCEPTIONSTEST(charData.deleteData(2, -1), DOM_DOMException::INDEX_SIZE_ERR, OK, 102 );
    EXCEPTIONSTEST(charData.deleteData(100, 5), DOM_DOMException::INDEX_SIZE_ERR, OK,103 );
    
    EXCEPTIONSTEST(charData.insertData(-1, "Stuff inserted"), DOM_DOMException::INDEX_SIZE_ERR, OK, 104 );
    EXCEPTIONSTEST(charData.insertData(100,"Stuff inserted"), DOM_DOMException::INDEX_SIZE_ERR, OK, 105 );
    
    EXCEPTIONSTEST(charData.replaceData(-1, 5, "Replacement stuff") , DOM_DOMException::INDEX_SIZE_ERR, OK, 106 );
    EXCEPTIONSTEST(charData.replaceData(100, 5 ,"Replacement stuff"), DOM_DOMException::INDEX_SIZE_ERR, OK, 107 );
    EXCEPTIONSTEST(charData.replaceData(2, -1, "Replacement stuff"), DOM_DOMException::INDEX_SIZE_ERR,  OK, 108 );
    
    EXCEPTIONSTEST(charData.substringData(-1, 5), DOM_DOMException::INDEX_SIZE_ERR, OK, 109 );
    EXCEPTIONSTEST(charData.substringData(100, 5), DOM_DOMException::INDEX_SIZE_ERR, OK, 110 );
    EXCEPTIONSTEST(charData.substringData(2, -1), DOM_DOMException::INDEX_SIZE_ERR, OK, 111 );
    

//!! Throws NO_MODIFICATION_ALLOWED_ERR ******** 
    DOM_Text node = (DOM_Text &)document.getDocumentElement().getElementsByTagName("dBodyLevel24").
        item(0).getFirstChild().getChildNodes().item(0); // node gets ourEntityReference node's child text

    EXCEPTIONSTEST(node.appendData("new data"), DOM_DOMException::NO_MODIFICATION_ALLOWED_ERR, OK, 112 );
    EXCEPTIONSTEST(node.deleteData(5, 10), DOM_DOMException::NO_MODIFICATION_ALLOWED_ERR, OK, 113 );
    EXCEPTIONSTEST(node.insertData(5, "Stuff inserted"), DOM_DOMException::NO_MODIFICATION_ALLOWED_ERR, OK, 114 );
    EXCEPTIONSTEST(node.replaceData(5, 10, "Replacementstuff"), DOM_DOMException::NO_MODIFICATION_ALLOWED_ERR, OK, 115 );
    EXCEPTIONSTEST(node.setData("New setdata stuff"), DOM_DOMException::NO_MODIFICATION_ALLOWED_ERR, OK, 116 );
    
        
// For debugging*****       printf("All DOM_CharacterData method calls worked correctly.\n");
    if (!OK)
        printf("\n*****The DOM_CharacterData method calls listed above failed, all others worked correctly.*****\n");
    charData.setData(resetData); // reset node to original data
//  printf(""\n);
};


/**
 * This method tests ChildNodeList methods for the XML DOM implementation
 * version 2.0 10/12/98
 * @param document org.w3c.dom.DOM_Document
 *
 */
void DTest::testChildNodeList(DOM_Document document)
{
    DOM_Node node, node2;
    bool OK = true;
// For debugging*****   printf("\n          testChildNodeList's outputs:\n");
    node = document.getDocumentElement().getLastChild(); // node gets doc's testBody element
    
    if (!(node.getChildNodes().getLength()== 4))
        OK = false;
    node2 = node.getChildNodes().item(2);
    if (! node2.getNodeName().equals("dBodyLevel23"))
        OK = false;
    
// For debugging*****       printf("All ChildNodeList method calls worked correctly.\n");
    if (!OK)
        printf("\n*****The ChildNodeList method calls listed above failed, all others worked correctly.*****\n");       
//  printf("");
};


/**
 * This method tests DOM_Comment methods for the XML DOM implementation
 * version 1.0 10/12/98
 * @param document org.w3c.dom.DOM_Document
 *
 */
void DTest::testComment(DOM_Document document)
{
    DOM_Node node, node2;
    bool T = true;
    bool OK = true;
// For debugging*****   printf("\n          testComment's outputs:\n");
    node = document.getDocumentElement().getElementsByTagName("dBodyLevel31").item(0).getFirstChild(); // node gets textNode11
    node2 = node.cloneNode(T);
    // Check nodes for equality, both their name and value or lack thereof
    if (!(node.getNodeName().equals(node2.getNodeName()) &&         // Compares node names for equality
          (node.getNodeValue() != null && node2.getNodeValue() != null)     // Checks to make sure each node has a value node
        ?  node.getNodeValue().equals(node2.getNodeValue())         // If both have value nodes test those value nodes for equality
        : (node.getNodeValue() == null && node2.getNodeValue() == null)))   // If one node doesn't have a value node make sure both don't
        //printf("'cloneNode' did not clone the DOM_Comment node correctly\n");
        OK = false;
    // Deep clone test comparison is in testNode & testDocument
    if (OK)
// For debugging*****       printf("All DOM_Comment method calls worked correctly.\n");
    if (!OK)
        printf("\n*****The DOM_Comment method calls listed above failed, all others worked correctly.*****\n");
//  printf("\n");
};


/**
 * This method tests DeepNodeList methods for the XML DOM implementation
 * version 2.0 10/12/98
 * @param document org.w3c.dom.DOM_Document
 *
 */
void DTest::testDeepNodeList(DOM_Document document)
{
    DOM_Node node, node2;
    bool OK = true;
// For debugging*****   printf("\n          testDeepNodeList's outputs:\n\n");
    node = document.getLastChild().getLastChild(); // node gets docBody element
//  DOM_Element el = (DOM_Element &)node;
//  DOM_NodeList nl = el.getElementsByTagName("*");
//  int len = nl.getLength();
//  if (len != 8)
  if (!(8 == ((DOM_Element &) node).getElementsByTagName("*").getLength()))
        {
            printf ("Warning!!! DeepNodeList's 'getLength' failed to work properly!\n");
            OK = false;     
        }
    node2 = ((DOM_Element &) node).getElementsByTagName("*").item(2); //This also runs through 'nextMatchingElementAfter"
    if (! node2.getNodeName().equals("dBodyLevel32"))
        {
            printf ("Warning!!! DeepNodeList's 'item' (or DOM_Element's 'getElementsBy TagName)failed to work properly!\n");
            OK = false;     
        }
    node2 = document.getLastChild();
    if (! ((DOM_Element &) node2).getElementsByTagName("dTestBody").item(0).getNodeName().equals("dTestBody"))//This also runs through 'nextMatchingElementAfter"
        {
            printf ("Warning!!! DeepNodeList's 'item' (or DOM_Element's 'getElementsBy TagName)failed to work properly!\n");
            OK = false;     
        }
        
    
// For debugging*****       printf("All DeepNodeList method calls worked correctly.\n");
    if (!OK)
        printf("\n*****The DeepNodeList method calls listed above failed, all others worked correctly.*****\n");
//  printf("");
};


/**
 * This method tests DOM_Document methods for the XML DOM implementation
 * version 2.0 10/12/98
 * @param document org.w3c.dom.DOM_Document
 *
 *
 **** ALL DOM_Document create methods are run in docBuilder except createAttribute which is in testAttribute**
 */
void DTest::testDocument(DOM_Document document)
{
    DTest make;
    DOM_DocumentFragment docFragment, docFragment2;
    DOM_Element newElement;
    DOM_Node node, node2;
    DOMString elementNames[] =  {"dFirstElement", "dTestBody", "dBodyLevel21","dBodyLevel31","dBodyLevel32",
                   "dBodyLevel22","dBodyLevel33","dBodyLevel34","dBodyLevel23","dBodyLevel24"};
    DOMString newElementNames[] = {"dFirstElement", "dTestBody", "dBodyLevel22","dBodyLevel33","dBodyLevel34","dBodyLevel23"};
    bool result;
    bool OK = true;
// For debugging*****   printf("\n          testDocument's outputs:\n \n");
    
    DOM_DocumentType checkDocType =  make.createDocumentType(document,"testDocument1");
    DOM_DocumentType docType = document.getDoctype();

    if (! checkDocType.getNodeName().equals(docType.getNodeName() ))
    {
        printf("Warning!!! DOM_Document's 'getDocType method failed!\n" );
        OK = false;
    }

    if (!checkDocType.getNodeValue().equals(docType.getNodeValue()))
    {
        printf("Warning!!! DOM_Document's 'getDocType method failed!\n" );
        OK = false;
    }

    /*
    if (! (checkDocType.getNodeName().equals(docType.getNodeName()) &&      // Compares node names for equality
          (checkDocType.getNodeValue() != null && docType.getNodeValue() != null)   // Checks to make sure each node has a value node
        ?  checkDocType.getNodeValue().equals(docType.getNodeValue())       // If both have value nodes test those value nodes for equality
        : (checkDocType.getNodeValue() == null && docType.getNodeValue() == null))) // If one node doesn't have a value node make sure both don't
    {
        printf("Warning!!! DOM_Document's 'getDocType method failed!\n" );
        OK = false;
    }
    */
        
    DOM_Node rootElement = document.getLastChild();
    if (! (rootElement.getNodeName().equals(document.getDocumentElement().getNodeName()) &&         // Compares node names for equality
          (rootElement.getNodeValue() != null && document.getDocumentElement().getNodeValue() != null)   // Checks to make sure each node has a value node
        ?  rootElement.getNodeValue().equals(document.getDocumentElement().getNodeValue())      // If both have value nodes test those value nodes for equality
        : (rootElement.getNodeValue() == null && document.getDocumentElement().getNodeValue() == null)))    // If one node doesn't have a value node make sure both don't
    {
        printf("Warning!!! DOM_Document's 'getDocumentElement' method failed!\n" );
        OK = false;
    }
    
    DOM_NodeList docElements = document.getElementsByTagName("*");
    int docSize = docElements.getLength();
    int i;
    for (i = 0; i < docSize; i++)
    {
        DOM_Node n = (DOM_Node) docElements.item(i);
        if (! (elementNames[i].equals(n.getNodeName())))
        {
            printf("Comparison of this document's elements failed at element number %d : ", i); 
            n.getNodeName().print();
            OK = false;
            break;
        }
    }

    // What is this supposed to be doing?
    //
    //if (document.equals(document.getImplementation()))
    //{
    //  printf("Warning!!! DOM_Document's 'getImplementation' method failed!\n" );
    //  OK = false;     
    //}
        
    newElement = document.createElement("NewElementTestsInsertBefore");
    //  doc.insertBefore(newElement,null);//!! Throws a HIERARCHY_REQUEST_ERR   ******* 
    //  doc.removeChild(docElements.item(9));//!! Throws a NOT_FOUND_ERR  ********

    docFragment = document.createDocumentFragment();
    //Tests removeChild and stores removed branch for tree reconstruction
    docFragment.appendChild(docElements.item(1).removeChild(docElements.item(9)));
    docFragment2 = document.createDocumentFragment();
    //Tests removeChild and stores removed branch for tree reconstruction
    docFragment2.appendChild(docElements.item(1).removeChild(docElements.item(2)));
    docSize = docElements.getLength();
    for (i = 0; i < docSize; i++)
    {
        DOM_Node n = (DOM_Node) docElements.item(i);
        if (! (newElementNames[i].equals(n.getNodeName())))
        {
            printf("Comparison of new document's elements failed at element number %d : ", i);
            n.getNodeName().print();
            OK = false;
            break;
        }
    }
    docElements.item(1).insertBefore(docFragment, DOM_Node()); //Reattaches removed branch to restore tree to the original
                                                // AH Revist.  Note: insertBefore should be able to take 
                                                //   a null as its second parameter.
    docElements.item(1).insertBefore(docFragment2, docElements.item(2)); //Reattaches removed branch to restore tree to the original

    //  printf(docElements.item(2).getNodeName());

    docSize = docElements.getLength();
    for (i = 0; i < docSize; i++)
    {
        DOM_Node n = (DOM_Node) docElements.item(i);
        if (! (elementNames[i].equals(n.getNodeName())))
        {
            printf("Comparison of restored document's elements failed at element number %d : ", i);
            n.getNodeName().print();
            OK = false;
            break;
        }
    }

    DTest tests;

    
//  DOM_Document z = tests.createDocument();
//  tests.docBuilder(z, "z");

//!! Throws WRONG_DOCUMENT_ERR **********
//  EXCEPTIONSTEST(z.appendChild(       
    //  z.appendChild(d.createComment("Test doc d comment"));// Tries to append z document with document d comment
    //  d.getDocumentElement().appendChild(z.createElement("newZdocElement"));// Tries to append d document with document z DOM_Element
    //  d.getLastChild().getLastChild().insertBefore(z.createElement("newZdocElement"),d.getLastChild().getLastChild().getFirstChild());// Tries to insert into d document with document z DOM_Element
    //  d.replaceChild(z.createElement("newZdocElement"),d.getLastChild().getLastChild().getFirstChild());  // Tries to replace in d document with document z DOM_Element

    //  doc.setNodeValue("This shouldn't work");//!! Throws a NO_MODIFICATION_ALLOWED_ERR ********
    
    node = document;
    node2 = document.cloneNode(true);
    result = treeCompare(node, node2); // Deep clone test comparison of document cloneNode
    if (!result)
    {
        printf("Warning!!! Deep clone of the document failed!\n");
        OK = false;
    }

    // Deep clone test comparison is also in testNode
    
    
// For debugging*****       printf("All DOM_Document method calls worked correctly.\n");
    if (!OK)
        printf("\n*****The DOM_Document method calls listed above failed, all others worked correctly.*****\n");
//  printf("\n");
};


/**
 * This method tests DOM_DocumentFragment methods for the XML DOM implementation
 * version 2.0 10/12/98
 * @param document org.w3c.dom.DOM_Document
 *
 *
 *
 ********This really isn't needed, only exists to throw NO_MODIFICATION_ALLOWED_ERR ********
 */
void DTest::testDocumentFragment(DOM_Document document)
{
    bool OK = true;
// For debugging*****   printf("\n          testDocumentFragment's outputs:\n");
    DOM_DocumentFragment testDocFragment = document.createDocumentFragment();
        
    //  testDocFragment.setNodeValue("This is a document fragment!");//!! Throws a NO_MODIFICATION_ALLOWED_ERR ********
    
// For debugging*****       printf("All DOM_DocumentFragment method calls worked correctly.\n");
    if (!OK)
        printf("\n*****The DOM_DocumentFragment method calls listed above failed, all others worked correctly.*****\n");
//  printf("\n");
};


/**
 * This method tests DOM_DocumentType methods for the XML DOM implementation
 * version 2.0 10/12/98
 * @param document org.w3c.dom.DOM_Document
 *
 */
void DTest::testDocumentType(DOM_Document document)
{
    DTest test;
    DOM_DocumentType docType, holdDocType;
    DOM_NamedNodeMap docEntityMap, docNotationMap;
    DOM_Node node, node2;
    DOMString compare;
    bool OK = true;
// For debugging*****   printf("\n          testDocumentType's outputs:\n");
    DOM_DocumentType newDocumentType =  test.createDocumentType(document, "TestDocument");
    node = document.getFirstChild(); // node gets doc's docType node
    node2 = node.cloneNode(true);
    // Check nodes for equality, both their name and value or lack thereof
    if (! (node.getNodeName().equals(node2.getNodeName()) &&         // Compares node names for equality
          (node.getNodeValue() != null && node2.getNodeValue() != null)  // Checks to make sure each node has a value node
        ?  node.getNodeValue().equals(node2.getNodeValue())          // If both have value nodes test those value nodes for equality
        : (node.getNodeValue() == null && node2.getNodeValue() == null)))// If one node doesn't have a value node make sure both don't
    {   
        printf("'cloneNode' did not clone the DOM_DocumentType node correctly\n");
        OK = false;
    }
     // Deep clone test comparison is in testNode & testDocument

    docType = (DOM_DocumentType &) document.getFirstChild();
    compare = "ourEntityNode";
    docEntityMap = docType.getEntities();
    if (! compare.equals(docEntityMap.item(0).getNodeName()))
    {
        printf("Warning!!! DOM_DocumentType's 'getEntities' failed!\n" );
        OK = false;
    }
    docNotationMap = docType.getNotations();
    compare = "ourNotationNode";
    if (! compare.equals(docNotationMap.item(0).getNodeName()))
    {
        printf("Warning!!! DOM_DocumentType's 'getNotations' failed!\n");
        OK = false;
    }
    //  doc.appendChild(newDocumentTypeImpl);//!! Throws a HIERARCHY_REQUEST_ERR    ******* 
    holdDocType = (DOM_DocumentType &) document.removeChild(document.getFirstChild()); //Tests removeChild and stores removed branch for tree reconstruction
    document.insertBefore(newDocumentType, document.getDocumentElement());
    //** Other aspects of insertBefore are tested in docBuilder through appendChild*

    document.removeChild(document.getFirstChild()); //Removes newDocumentType for tree restoral
    document.insertBefore(holdDocType, document.getFirstChild()); //Reattaches removed branch to restore tree to the original

    
// For debugging*****       printf("All DOM_DocumentType method calls worked correctly.\n");
    if (!OK)
        printf("\n*****The DOM_DocumentType method calls listed above failed, all others worked correctly.*****\n");
//  printf("");
};


/**
 * @param document org.w3c.dom.DOM_Document
 */
void DTest::testDOMerrors(DOM_Document document) {
    bool OK = true;

    DTest tests;

    EXCEPTIONSTEST(document.appendChild(testElementNode), DOM_DOMException::HIERARCHY_REQUEST_ERR, OK, 201 ); 
    EXCEPTIONSTEST(testTextNode.appendChild(testTextNode), DOM_DOMException::HIERARCHY_REQUEST_ERR, OK, 202 ); 
#ifdef skipthese
    EXCEPTIONSTEST(document.insertBefore(document.getElementsByTagName("docEntity").item(0),
        document.getElementsByTagName("docFirstElement").item(0)), DOM_DOMException::HIERARCHY_REQUEST_ERR, OK, 203 ); 
    EXCEPTIONSTEST(document.replaceChild(document.getElementsByTagName("docCDATASection").item(0),
        document.getElementsByTagName("docFirstElement").item(0)), DOM_DOMException::HIERARCHY_REQUEST_ERR, OK, 204 ); 

    EXCEPTIONSTEST(document.getElementsByTagName("docFirstElement").item(0).setNodeValue("This shouldn't work!" ),
            DOM_DOMException::NO_MODIFICATION_ALLOWED_ERR, OK, 205 );   
    EXCEPTIONSTEST(docReferenceEntity.setNodeValue("This shouldn't work!"),
        DOM_DOMException::NO_MODIFICATION_ALLOWED_ERR, OK, 206 );
    EXCEPTIONSTEST(docEntity.setNodeValue("This shouldn't work!"), 
        DOM_DOMException::NO_MODIFICATION_ALLOWED_ERR, OK, 207 );
    EXCEPTIONSTEST(document.setNodeValue("This shouldn't work!"),
        DOM_DOMException::NO_MODIFICATION_ALLOWED_ERR, OK, 208 );
    EXCEPTIONSTEST(docDocType.setNodeValue("This shouldn't work!"),
        DOM_DOMException::NO_MODIFICATION_ALLOWED_ERR, OK, 209 );
    EXCEPTIONSTEST(docDocFragment.setNodeValue("This shouldn't work!"),
        DOM_DOMException::NO_MODIFICATION_ALLOWED_ERR, OK, 210 );
    EXCEPTIONSTEST(docNotation.setNodeValue("This shouldn't work!"),
        DOM_DOMException::NO_MODIFICATION_ALLOWED_ERR, OK, 211 );
    EXCEPTIONSTEST(docReferenceEntity.appendChild(entityReferenceText2)
        , DOM_DOMException::NO_MODIFICATION_ALLOWED_ERR, OK, 212 );


    EXCEPTIONSTEST(docBodyLevel32.insertBefore(docTextNode11,docBody), DOM_DOMException::NOT_FOUND_ERR, OK, 213 );
    EXCEPTIONSTEST(docBodyLevel32.removeChild(docFirstElement), DOM_DOMException::NOT_FOUND_ERR, OK, 214 );
    EXCEPTIONSTEST(docBodyLevel32.replaceChild(docTextNode11,docFirstElement), DOM_DOMException::NOT_FOUND_ERR );

#endif

//!! Throws a NOT_FOUND_ERR ********
     
     // docBodyLevel32.getAttributes().removeNamedItem(testAttribute.getName());    16  // To test removeNamedItem
     
};


/**
 * This method tests DOM_DOMImplementation methods for the XML DOM implementation
 * version 2.0 10/12/98
 * @param document org.w3c.dom.DOM_Document
 *
 */
void DTest::testDOMImplementation(DOM_Document document)
{
    
    DOM_DOMImplementation implementation;
    bool result = false;
    bool OK = true;
// For debugging*****   printf("\n          testDOMImplementation's outputs:\n");
    implementation = document.getImplementation(); //Uses getDOMImplementation to obtain implementation 

    result = implementation.hasFeature("XML", "1.0");
    if(!result)
    {
        fprintf(stderr, "Warning!!! DOM_DOMImplementation's 'hasFeature' that should be 'true' failed!");
        OK = false;
    }
    
    result = implementation.hasFeature("HTML", "4.0");
    if(result)
    {
        fprintf(stderr, "Warning!!! DOM_DOMImplementation's 'hasFeature' that should be 'false' failed!");
        OK = false;
    }
    
    
// For debugging*****       printf("All DOM_DOMImplementation method calls worked correctly.\n");
    if (!OK)
        fprintf(stderr, "\n*****The DOM_DOMImplementation method calls listed above failed, all others worked correctly.*****\n");
//  printf("");
};


/**
 * This method tests DOM_Element methods for the XML DOM implementation
 * version 2.0 10/12/98
 * @param document org.w3c.dom.DOM_Document
 *
 */
void DTest::testElement(DOM_Document document)
{
    DOM_Attr attributeNode, newAttributeNode;
    DOM_Element element, element2;
    DOM_Node node, node2;
    DOMString attribute, compare;
    DOMString attributeCompare[] = {"AnotherFirstElementAttribute", "dFirstElement", "testAttribute"};
    DOMString elementNames[] =  {"dFirstElement", "dTestBody", "dBodyLevel21","dBodyLevel31","dBodyLevel32",
                   "dBodyLevel22","dBodyLevel33","dBodyLevel34","dBodyLevel23","dBodyLevel24"};
    DOMString textCompare[] = {"dBodyLevel31'sChildTextNode11",
                                "dBodyLevel31'sChildTextNode12",
                                "dBodyLevel31'sChildTextNode13"};
    DOM_NamedNodeMap nodeMap;
    bool OK = true;
// For debugging*****   printf("\n          testElement's outputs:\n");
    node = document.getDocumentElement(); // node gets doc's firstElement
    node2 = node.cloneNode(true);
    // Check nodes for equality, both their name and value or lack thereof
    if (!(node.getNodeName().equals(node2.getNodeName()) &&         // Compares node names for equality
         (node.getNodeValue() != null && node2.getNodeValue() != null)  // Checks to make sure each node has a value node
        ? node.getNodeValue().equals(node2.getNodeValue())          // If both have value nodes test those value nodes for equality
        :(node.getNodeValue() == null && node2.getNodeValue() == null)))// If one node doesn't have a value node make sure both don't
    {   
        fprintf(stderr, "'cloneNode' did not clone the DOM_Element node correctly.\n");
        OK = false;
    }
    // Deep clone test comparison is in testNode & testDocument

    element = document.getDocumentElement(); // element gets doc's firstElement
    compare = "";
    attribute = element.getAttribute(document.getNodeValue() + "'s test attribute");
    if (! compare.equals(element.getAttribute(document.getNodeValue() + "'s test attribute")))
    {
        fprintf(stderr, "Warning!!! DOM_Element's 'getAttribute' failed!\n");
        OK = false;
    }
    
    attributeNode = element.getAttributeNode(document.getNodeValue() + "FirstElement");
    if(! (attributeNode == null))
    {
        fprintf(stderr, "Warning!!! DOM_Element's 'getAttributeNode' failed! It should have returned 'null' here!\n");
        OK = false;
    }
    

    newAttributeNode = document.createAttribute("AnotherFirstElementAttribute");
    newAttributeNode.setValue("A new attribute which helps test calls in DOM_Element");
    // This test is incorrect.  It assumes that there is a defined ordering of the entries
    //  in a nodeMap, but there is no ordering required.
#ifdef TheFollowingCheckIsInvalid
    element.setAttributeNode(newAttributeNode);
    nodeMap = element.getAttributes();
    int size = nodeMap.getLength();
    int k;
    for (k = 0; k < size; k++)
    {
        DOM_Node n = (DOM_Node) nodeMap.item(k);
        if (! (attributeCompare[k].equals(n.getNodeName())))
        {
            printf("Warning!!! Comparison of firstElement's attributes failed.\n");
            printf("   n.getNodeName() = \""); n.getNodeValue().print(); printf("\"\n");
            printf("   expected value  = \""); attributeCompare[k].print(); printf("\"\n");
            printf("   This failure can be a result of DOM_Element's 'setValue' and/or 'setAttributeNode' and/or 'getAttributes' failing.\n");
            OK = false;
            break;
        }
    //  printf("firstElement's attribute number " + k + " : " + n.getNodeName());
    }
#endif

    nodeMap = element.getAttributes();
    int size = nodeMap.getLength();
    if (size != 2)
    {
        printf("DOM_Element Tests Failure 001\n");
        OK = false;
    };
    element.setAttributeNode(newAttributeNode);
    size = nodeMap.getLength();
    if (size != 3)
    {
        printf("DOM_Element Tests Failure 002\n");
        OK = false;
    };

    // Fetch the newly added attribute node back out of from the named node map,
    //  and check that we are returned the same node that we put in.
    DOM_Attr fetchedAttr = (DOM_Attr &)nodeMap.getNamedItem("AnotherFirstElementAttribute");
    if (fetchedAttr != newAttributeNode)
    {       
        printf("DOM_Element Tests Failure 003\n");
        OK = false;
    };

    // Fetch the newly added attribute back out directly from the element itself.
    fetchedAttr = (DOM_Attr &)element.getAttributeNode("AnotherFirstElementAttribute");
    if (fetchedAttr != newAttributeNode)
    {       
        printf("DOM_Element Tests Failure 004\n");
        OK = false;
    };


    DOM_NodeList docElements = document.getElementsByTagName("*");
    int docSize = docElements.getLength();
    int i;
    for (i = 0; i < docSize; i++)
    {
        DOM_Node n = (DOM_Node &) docElements.item(i);
        if (! (elementNames[i].equals(n.getNodeName())))
        {
            printf("Warning!!! Comparison of DOM_Element's 'getElementsByTagName' "
                            "and/or 'item' failed at element number %d : ", i );
            n.getNodeName().print();
            printf("\n");
            OK = false;
            break;
        }       
    //  printf("docElement's number " + i + " is: " + n.getNodeName());
    }
    element = (DOM_Element &) document.getElementsByTagName("dBodyLevel21").item(0); // element gets DOM_Element test BodyLevel21 
    element2 = (DOM_Element &) document.getElementsByTagName("dBodyLevel31").item(0); // element2 gets DOM_Element test BodyLevel31 
    DOM_NodeList text = ((DOM_Node &) element2).getChildNodes();
    int textSize = text.getLength();
    int j;
    static bool firstTime = true;
    if (firstTime)
    {
        firstTime = false;      // Temporary fix.  Subsequent tests alter the doc, causing
                                //   this test to fail on all but the first time through.
        for (j = 0; j < textSize; j++)
        {
            DOM_Node n = (DOM_Node &) text.item(j);
            if (! (textCompare[j].equals(n.getNodeValue())))
            {
                printf("Warning!!! Comparison of original text nodes via DOM_Node 'getChildNodes' & DOM_NodeList 'item'\n"
                    "     failed at text node: #%d \n     ", j );
                n.getNodeValue().print();
                printf("\n");
                OK = false;
                break;
            }
            //  printf("DOM_Element testBodyLevel31's child text node " + j + " is: " + n.getNodeValue());
        }
    }

    element = document.getDocumentElement(); // element gets doc's firstElement
    element.normalize();        // Concatenates all adjacent text nodes in this element's subtree
    DOM_NodeList text2 = ((DOM_Node) element2).getChildNodes();
    compare = "dBodyLevel31'sChildTextNode11dBodyLevel31'sChildTextNode12dBodyLevel31'sChildTextNode13";
    DOM_Node n = (DOM_Node &) text2.item(0);
    if (! (compare.equals(n.getNodeValue())))
    {
        printf("Warning!!! Comparison of concatenated text nodes created by DOM_Element's 'normalize' failed!\n");
        OK = false;
    }
    
    element.setAttribute("FirstElementLastAttribute", "More attribute stuff for firstElement!!");
    element.removeAttribute("FirstElementLastAttribute");
    element.removeAttributeNode(newAttributeNode);

    //  doc.getLastChild().setNodeValue("This shouldn't work");//!! Throws a NO_MODIFICATION_ALLOWED_ERR***
    
// For debugging*****       printf("All DOM_Element method calls worked correctly.\n");
    if (!OK)
        printf("\n*****The DOM_Element method calls listed above failed, all others worked correctly.*****\n");
//  printf("");

};


/**
 * This method tests DOM_Entity methods for the XML DOM implementation
 * version 2.0 10/12/98
 * @param document org.w3c.dom.DOM_Document
 *
 */
void DTest::testEntity(DOM_Document document)
{
    DOM_Entity entity;
    DOM_Node node, node2;
    bool OK = true;
    DOMString compare;
// For debugging*****   printf("\n          testEntity's outputs:\n\n");
    entity = (DOM_Entity &) document.getDoctype().getEntities().getNamedItem("ourEntityNode");
    node = entity;
    node2 = entity.cloneNode(true);
    // Check nodes for equality, both their name and value or lack thereof
    if (!(node.getNodeName().equals(node2.getNodeName()) &&         // Compares node names for equality
            ((node.getNodeValue() != null && node2.getNodeValue() != null) ?    // Checks to make sure each node has a value node
               node.getNodeValue().equals(node2.getNodeValue()) :       // If both have value nodes test those value nodes for equality
               (node.getNodeValue() == null && node2.getNodeValue() == null)))) // If one node doesn't have a value node make sure both don't
    {   
        printf("Warning!!! 'cloneNode' did not clone the DOM_Entity node correctly");
        OK = false;
    }
    // Deep clone test comparison is in testNode & testDocument

    entity.setNotationName("testNotationName");
    compare = "testNotationName";
    if(! compare.equals(entity.getNotationName()))
    {
        printf("Warning!!! DOM_Entity's 'setNotationName' and/or getNotationName' failed!\n");
        OK = false;
    }
    entity.setPublicId("testPublicId");
    compare = "testPublicId";
    if(! compare.equals(entity.getPublicId()))
    {
        printf("Warning!!! DOM_Entity's 'setPublicId' and/or getPublicId' failed!\n");
        OK = false;
    }   
    entity.setSystemId("testSystemId");
    compare = "testSystemId";
    if(! compare.equals(entity.getSystemId()))
    {
        printf("Warning!!! DOM_Entity's 'setSystemId' and/or getSystemId' failed!\n");
        OK = false;
    }       
    //  entity.setNodeValue("This shouldn't work");//!! Throws a NO_MODIFICATION_ALLOWED_ERR ********
    
// For debugging*****       printf("All DOM_Entity method calls worked correctly.\n");
    if (!OK)
        printf("\n*****The DOM_Entity method calls listed above failed, all others worked correctly.*****\n");
//  printf("");
};


/**
 * This method tests DOM_EntityReference methods for the XML DOM implementation
 * version 2.0 10/12/98
 * @param document org.w3c.dom.DOM_Document
 *
 */
void DTest::testEntityReference(DOM_Document document)
{
    DOM_EntityReference entityReference;
    DOM_Node node, node2;
    bool OK = true;
// For debugging*****   printf("\n          testEntityReference's outputs:\n");
    entityReference = (DOM_EntityReference &) document.getLastChild().getLastChild().getLastChild().getFirstChild();
    node = entityReference;
    node2 = node.cloneNode(true);
    // Check nodes for equality, both their name and value or lack thereof
    if (!(node.getNodeName().equals(node2.getNodeName()) &&         // Compares node names for equality
         (node.getNodeValue() != null && node2.getNodeValue() != null)  // Checks to make sure each node has a value node
        ? node.getNodeValue().equals(node2.getNodeValue())          // If both have value nodes test those value nodes for equality
        :(node.getNodeValue() == null && node2.getNodeValue() == null)))// If one node doesn't have a value node make sure both don't
    {   
        printf("'cloneNode' did not clone the DOM_EntityReference node correctly\n");
        OK = false;
    }
    // Deep clone test comparison is in testNode & testDocument

    //  entityReference.setNodeValue("This shouldn't work");//!! Throws a NO_MODIFICATION_ALLOWED_ERR ********
    
// For debugging*****       printf("All DOM_EntityReference method calls worked correctly.\n");
    if (!OK)
        printf("\n*****The DOM_EntityReference method calls listed above failed, all others worked correctly.*****\n");
//  printf("\n");
};


/**
 * This method tests DOM_Node methods for the XML DOM implementation
 * version 2.0 10/12/98
 * @param document org.w3c.dom.DOM_Document
 *
 *
 *
 ********* This is only for a test of cloneNode "deep"*******
 ********* And for error tests*********
 */
void DTest::testNode(DOM_Document document)
{
    DOM_Node node, node2;
    bool result;
    bool OK = true;
// For debugging*****   printf("\n          testNode's outputs:\n");
    node = document.getDocumentElement();
    node2 = node.cloneNode(true);
    result = treeCompare(node, node2); // Deep clone test of cloneNode
    if (result)
    {
        //printf("'cloneNode' successfully cloned this whole node tree (deep)!\n");
    }
    else
    {
        printf("'cloneNode' did not successfully clone this whole node tree (deep)!\n");
        OK = false; 
    }
    //!! The following gives a did not clone successfully message*********
    node = document.getDocumentElement();
    node2 = node.getFirstChild();
    result = treeCompare(node, node2);
    if (!result)
    {
        //printf("'cloneNode' did not successfully clone this whole node tree (deep)!\n");
    }
    else
    {
        printf("'cloneNode' was supposed to fail here, either it or 'treeCompare' failed!!!\n");
        OK = false;
    }
    // Deep clone test also in testDocument
    
// For debugging*****       printf("All DOM_Node method calls worked correctly.\n");
    if (!OK)
        printf("\n*****The DOM_Node method calls listed above failed, all others worked correctly.*****\n");    
//  printf("\n");
};


/**
 * This method tests DOM_Notation methods for the XML DOM implementation
 * version 2.0 10/12/98
 * @param document org.w3c.dom.DOM_Document
 *
 */
void DTest::testNotation(DOM_Document document)
{
    DOM_Node node, node2;
    DOM_Notation notation;
    bool OK = true;
    DOMString compare;
// For debugging*****   printf("\n          testNotation's outputs:\n");
    notation = (DOM_Notation &) document.getDoctype().getNotations().getNamedItem("ourNotationNode");
    node = notation;
    node2 = notation.cloneNode(true);//*****?
    // Check nodes for equality, both their name and value or lack thereof
    if (!(node.getNodeName().equals(node2.getNodeName()) &&         // Compares node names for equality
         (node.getNodeValue() != null && node2.getNodeValue() != null)  // Checks to make sure each node has a value node
        ? node.getNodeValue().equals(node2.getNodeValue())          // If both have value nodes test those value nodes for equality
        :(node.getNodeValue() == null && node2.getNodeValue() == null)))// If one node doesn't have a value node make sure both don't
    {   
        printf("'cloneNode' did not clone the DOM_Notation node correctly");
        OK = false;
    }
    // Deep clone test comparison is in testNode & testDocument

    // IBM specific call...
    notation.setPublicId("testPublicId");//*****?
    compare = "testPublicId";
    if (!compare.equals(notation.getPublicId()))
    {
        printf("Warning!!! DOM_Notation's 'getPublicId' failed!");
        OK = false;
    }
    // IBM specific call...
    notation.setSystemId("testSystemId");//*****?
    compare = "testSystemId";
    if (! compare.equals(notation.getSystemId()))
    {
        printf("Warning!!! DOM_Notation's 'getSystemId' failed!\n");
        OK = false;
    }
    //  notation.setNodeValue("This shouldn't work");//!! Throws a NO_MODIFICATION_ALLOWED_ERR ********
    
// For debugging*****       printf("All DOM_Notation method calls worked correctly.\n");
    if (!OK)
        printf("\n*****The DOM_Notation method calls listed above failed, all others worked correctly.*****\n");
//  printf("");
};


/**
 * This method tests DOM_ProcessingInstruction methods for the XML DOM implementation
 * version 2.0 10/12/98
 * @param document org.w3c.dom.DOM_Document
 *
 */
void DTest::testPI(DOM_Document document)
{
    DOM_Node node, node2;
    DOM_ProcessingInstruction pI, pI2;
    DOMString compare;
    bool OK = true;
// For debugging*****   printf("\n          testPI's outputs:\n");
    pI  = (DOM_ProcessingInstruction &) document.getDocumentElement().getFirstChild();// Get doc's DOM_ProcessingInstruction
    pI2 = (DOM_ProcessingInstruction &)pI.cloneNode(true);//*****?
    // Check nodes for equality, both their name and value or lack thereof
    if (!(pI.getNodeName().equals(pI2.getNodeName()) &&         // Compares node names for equality
         (pI.getNodeValue() != null && pI2.getNodeValue() != null)  // Checks to make sure each node has a value node
        ? pI.getNodeValue().equals(pI2.getNodeValue())      // If both have value nodes test those value nodes for equality
        :(pI.getNodeValue() == null && pI2.getNodeValue() == null)))// If one node doesn't have a value node make sure both don't
    {   
        printf("'cloneNode' did not clone the DOM_Entity node correctly\n");
        OK = false;
    }
    // Deep clone test comparison is in testNode & testDocument
    // compare = "This is [#document: null]'s processing instruction";  // AH Revisit.  Where id
    //                  this ": null]" stuff come from in the Java version??  I don' think that it is right.
    compare = "This is #document's processing instruction";
    if (! compare.equals(pI.getData()))
    {
        printf("Warning!!! PI's 'getData' failed!\n");
        OK = false;
    }
    
    pI.setData("PI's reset data");
    compare = "PI's reset data";
    if (! compare.equals(pI.getData()))
    {
        printf("Warning!!! PI's 'setData' failed!\n");
        OK = false;
    }   
    compare = "dTargetProcessorChannel";
    if (! compare.equals(pI.getTarget()))
    {
        printf("Warning!!! PI's 'getTarget' failed!\n");
        OK = false;
    }   
    

    // Restore original PI data.
    pI.setData("This is #document's processing instruction");

// For debugging*****       printf("All PI method calls worked correctly.\n");
    if (!OK)
        printf("\n*****The PI method calls listed above failed, all others worked correctly.*****\n");
    
//  printf("\n");
};


/**
 * This method tests DOM_Text methods for the XML DOM implementation
 * version 2.0 10/12/98
 * @param document org.w3c.dom.DOM_Document
 *
 */
void DTest::testText(DOM_Document document)
{
    DOM_Node node, node2;
    DOM_Text text;
    DOMString compare;
    bool OK = true;
// For debugging*****   printf("\n          testText's outputs:\n");
    DOM_Element elem = (DOM_Element &)document.getDocumentElement().getElementsByTagName("dBodyLevel31").item(0);
    node = elem.getFirstChild(); // charData gets textNode11
    text = (DOM_Text &) node;
    node2 = node.cloneNode(true);//*****?
    // Check nodes for equality, both their name and value or lack thereof
    if (!(node.getNodeName().equals(node2.getNodeName()) &&         // Compares node names for equality
         (node.getNodeValue() != null && node2.getNodeValue() != null)  // Checks to make sure each node has a value node
        ? node.getNodeValue().equals(node2.getNodeValue())          // If both have value nodes test those value nodes for equality
        :(node.getNodeValue() == null && node2.getNodeValue() == null)))// If one node doesn't have a value node make sure both don't
    {   
        printf("'cloneNode' did not clone the DOM_Text node correctly\n");
        OK = false;
    }
    // Deep clone test comparison is in testNode & testDocument

    text.splitText(25);
    // Three original text nodes were concatenated by 'normalize' in testElement
    compare = "dBodyLevel31'sChildTextNo";
    if (! compare.equals(text.getNodeValue()))
        {
            printf("First part of DOM_Text's split text failed!\n" );
            OK = false;
        }
    // Three original text nodes were concatenated by 'normalize' in testElement
    compare = "de11dBodyLevel31'sChildTextNode12dBodyLevel31'sChildTextNode13";
    if (! compare.equals(text.getNextSibling().getNodeValue()))
        {
            printf("The second part of DOM_Text's split text failed!\n") ;
            OK = false; 
        }

    // Re-normalize the text nodes under elem, so that this test can be rerun.
    elem.normalize();


//************************************************* ERROR TESTS
    DTest tests;        
    //!! Throws INDEX_SIZE_ERR ********************
    //  text.splitText(-1);
    //  text.splitText(100);
    
// For debugging*****       printf("All DOM_Text method calls worked correctly.\n");
    if (!OK)
        printf("\n*****The DOM_Text method calls listed above failed, all others worked correctly.*****\n");
    
//  printf("\n");
};


/**
 * 
 * @param node org.w3c.dom.DOM_Node
 * @param node2 org.w3c.dom.DOM_Node
 *
 */
bool DTest::treeCompare(DOM_Node node, DOM_Node node2)
{
    bool answer = true;
        
    DOM_Node kid, kid2;         // Check the subtree for equality
    kid = node.getFirstChild();
    kid2 = node2.getFirstChild();
    if (!kid.isNull() && !kid2.isNull())
    {
        answer = treeCompare(kid, kid2);
        if (!answer)
            return answer;
        else
            if (!kid.getNextSibling().isNull() && !kid2.getNextSibling().isNull())
            {
                while (!kid.getNextSibling().isNull() && !kid2.getNextSibling().isNull())
                {
                    answer = treeCompare(kid.getNextSibling(), kid2.getNextSibling());
                    if (!answer)
                        return answer;
                    else
                    {
                        kid = kid.getNextSibling();
                        kid2 = kid2.getNextSibling();
                    }
                }
            } else
                if (!(kid.getNextSibling().isNull() && kid2.getNextSibling().isNull()))
                {
                    return false;
                }
    } else
        if (kid != kid2)
        {
            // One or the other of (kid1, kid2) is null, but not both.
            return false;
        }

    if (!(node.getNodeName().equals(node2.getNodeName())))
        return false;
    if (node.getNodeValue()==null && node2.getNodeValue()!=null)
        return false;
    if (node.getNodeValue()!=null && node2.getNodeValue()==null)
        return false;
    if (!(node.getNodeValue().equals(node2.getNodeValue())))
        return false;

    return answer;
};