xml/soap/webservice

开发平台：
C/C++

DTest.cpp：源码内容
							/*
 * The Apache Software License, Version 1.1
 *
 * Copyright (c) 1999-2000 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: DTest.cpp,v $
 * Revision 1.15  2001/12/07 01:46:40  tng
 * [Bug 1959] setNodeValue throws exception when spec specifies NOP.
 *
 * Revision 1.14  2001/11/23 20:44:10  tng
 * Solaris Forte C++ core dump when handling this long condition check; so break it into smaller check to bypass this compiler problem.
 *
 * Revision 1.13  2000/08/30 22:21:44  andyh
 * Unix Build script fixes.  Clean up some UNIX compiler warnings.
 *
 * Revision 1.12  2000/05/15 23:08:59  andyh
 * Remove entity tests, which failed because entity nodes are (correctly)
 * read-only.
 *
 * Revision 1.11  2000/04/19 02:25:18  aruna1
 * Full support for DOM_EntityReference, DOM_Entity and DOM_DocumentType introduced
 *
 * Revision 1.10  2000/03/11 03:00:24  chchou
 * Fix bug # 18, remove set method of readonly attributes.
 * As a result, remove related test cases
 *
 * Revision 1.9  2000/03/02 19:55:45  roddey
 * This checkin includes many changes done while waiting for the
 * 1.1.0 code to be finished. I can't list them all here, but a list is
 * available elsewhere.
 *
 * Revision 1.8  2000/02/29 02:19:13  rahulj
 * No more compilation errors under HPUX 11.0. We do not build
 * DOMMemTest as it crashes the aCC compiler.
 *
 * Revision 1.7  2000/02/06 07:48:36  rahulj
 * Year 2K copyright swat.
 *
 * Revision 1.6  2000/02/04 05:46:31  andyh
 * Change offsets and lengths form signed to unsigned
 *
 * Revision 1.5  2000/02/04 01:50:13  aruna1
 * TreeWalker and NodeIterator changes
 *
 * Revision 1.4  2000/01/29 00:39:09  andyh
 * Redo synchronization in DOMStringHandle allocator.  There
 * was a bug in the use of Compare and Swap.  Switched to mutexes.
 *
 * Changed a few plain deletes to delete [].
 *
 * Revision 1.3  2000/01/19 21:40:58  andyh
 * Remove a few remaining dependencies on the (now defunct)
 * XML StdOut stream.
 *
 * 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...
 *
 */
#include <stdio.h>
#include "DTest.h"
#include <util/PlatformUtils.hpp>
#include <util/XMLException.hpp>
#include <util/XMLString.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 %dn", __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_Node abc1 = doc.getFirstChild();
    DOM_DocumentType docType = (DOM_DocumentType &) abc1;
    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_Node  abc2 =  doc.getDoctype().getEntities().getNamedItem("ourEntityNode"); // Get the DOM_Entity node
    DOM_Entity docEntity = (DOM_Entity &) abc2;
    DOM_Node  abc3 = doc.getFirstChild(); // Get the DOM_DocumentType node
    DOM_DocumentType docDocType = (DOM_DocumentType &) abc3;
    DOM_Node  abc4 = doc.getLastChild().getLastChild().getLastChild().getFirstChild();
    DOM_EntityReference & entityReferenceText = (DOM_EntityReference &) abc4;
    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);
    // The following setNodeValue tests are not invalid
    // According to DOM spec, exception is raised only if the node is readonly, otherwise should be no-op.
    // 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);
    // The following setNodeValue tests are not invalid
    // According to DOM spec, exception is raised only if the node is readonly, otherwise should be no-op.
    // 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
 *
 */
 int 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;
         try {
             XMLPlatformUtils::Initialize();
         }
         catch (const XMLException& toCatch) {
             char *pMessage = XMLString::transcode(toCatch.getMessage());
             fprintf(stderr, "Error during initialization! n  %s n", pMessage);
             delete [] pMessage;
             return -1;
         }
         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");
         //Build a branch for entityReference tests
         // DOM_Text entityChildText = d.createTextNode("entityChildText information"); //
         // docEntity.appendChild(entityChildText);
         // 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););      // Can not test entities;  only parser can create them.
         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: %dn", 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;
    };
    XMLPlatformUtils::Terminate();
    DomMemDebug().print();
    return 0;
};
/**
 * 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:nn");
    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;
    }
    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 correctlyn");
            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 correctlyn");
        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");
    DOM_Node abc1 = document.getDocumentElement().getElementsByTagName("dBodyLevel31").item(0).getFirstChild(); // charData gets textNode11
    charData = (DOM_CharacterData &) abc1;
    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());
    unsigned 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 );
    // Test 102 is not an error because the -1 parameter is an unsigned value, and counts
    //   that exceed the length of the string are allowed.
//    EXCEPTIONSTEST(charData.deleteData(2, -1), DOM_DOMException::INDEX_SIZE_ERR, OK, 102 );
    EXCEPTIONSTEST(charData.deleteData(100, 5), DOM_DOMException::INDEX_SIZE_ERR, OK,103 );
//can't set negative unsigned int in c++ compiler
  //  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 ********
// Since user cannot add children to Entity and EntityReference Nodes this test can't be done.
#if 0
    DOM_Node abc8 = document.getDocumentElement().getElementsByTagName("dBodyLevel24").
        item(0).getFirstChild().getChildNodes().item(0); // node gets ourEntityReference node's child text
    DOM_Text node = (DOM_Text &) abc8;
    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 );
#endif
// 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 correctlyn");
        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:nn");
    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();
    bool check = (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
    if (! (rootElement.getNodeName().equals(document.getDocumentElement().getNodeName()) &&        // Compares node names for equality
         check))
    {
        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
    bool check = (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
    if (! (node.getNodeName().equals(node2.getNodeName()) &&         // Compares node names for equality
          check))
    {
        printf("'cloneNode' did not clone the DOM_DocumentType node correctlyn");
        OK = false;
    }
     // Deep clone test comparison is in testNode & testDocument
    DOM_Node  abc9 = document.getFirstChild();
    docType = (DOM_DocumentType &) abc9;
    compare = "ourEntityNode";
#if 0
    // Entity tests omitted; can not create entity nodes outside of the Parser.
    docEntityMap = docType.getEntities();
    if (! compare.equals(docEntityMap.item(0).getNodeName()))
    {
        printf("Warning!!! DOM_DocumentType's 'getEntities' failed!n" );
        OK = false;
    }
#endif
    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    *******
    DOM_Node abc10 = document.removeChild(document.getFirstChild()); //Tests removeChild and stores removed branch for tree reconstruction
    holdDocType = (DOM_DocumentType &) abc10;
    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 001n");
        OK = false;
    };
    element.setAttributeNode(newAttributeNode);
    size = nodeMap.getLength();
    if (size != 3)
    {
        printf("DOM_Element Tests Failure 002n");
        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_Node abc12 = nodeMap.getNamedItem("AnotherFirstElementAttribute");
    DOM_Attr fetchedAttr = (DOM_Attr &) abc12;
    if (fetchedAttr != newAttributeNode)
    {
        printf("DOM_Element Tests Failure 003n");
        OK = false;
    };
    // Fetch the newly added attribute back out directly from the element itself.
    fetchedAttr = element.getAttributeNode("AnotherFirstElementAttribute");
    if (fetchedAttr != newAttributeNode)
    {
        printf("DOM_Element Tests Failure 004n");
        OK = false;
    };
    DOM_NodeList docElements = document.getElementsByTagName("*");
    int docSize = docElements.getLength();
    int i;
    for (i = 0; i < docSize; i++)
    {
        DOM_Node n = 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());
    }
    DOM_Node abc15 = document.getElementsByTagName("dBodyLevel21").item(0); // element gets DOM_Element test BodyLevel21
    element = (DOM_Element &) abc15;
    DOM_Node abc16 = document.getElementsByTagName("dBodyLevel31").item(0); // element2 gets DOM_Element test BodyLevel31
    element2 = (DOM_Element &) abc16;
    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 = 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 = 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:nn");
    DOM_Node abc20 = document.getDoctype().getEntities().getNamedItem("ourEntityNode");
    entity = (DOM_Entity &) abc20;
    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
// 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");
    DOM_Node abc30 = document.getLastChild().getLastChild().getLastChild().getFirstChild();
    entityReference = (DOM_EntityReference &) abc30;
    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 correctlyn");
        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");
	DOM_Node abc40 = document.getDoctype().getNotations().getNamedItem("ourNotationNode");
    notation = (DOM_Notation &) abc40;
    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
    //  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");
	DOM_Node  abc50 = document.getDocumentElement().getFirstChild();// Get doc's DOM_ProcessingInstruction
    pI  = (DOM_ProcessingInstruction &) abc50;
	DOM_Node  abc51 = pI.cloneNode(true);//*****?
    pI2 = (DOM_ProcessingInstruction &) abc51;
    // 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 correctlyn");
        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_Node abc70 = document.getDocumentElement().getElementsByTagName("dBodyLevel31").item(0);
    DOM_Element elem = (DOM_Element &) abc70;
    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 correctlyn");
        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;
};

						