开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > Internet/网络编程 > xml/soap/webservice > 查看源码
IDTest.cpp
资源名称：xerces-c-src1_6_0.tar.gz　[点击查看]
上传用户：huihehuasu
上传日期：2007-01-10
资源大小：6948k
文件大小：75k
源码类别：

xml/soap/webservice

开发平台：

C/C++

IDTest.cpp：源码内容
  1. /*
  2.  * The Apache Software License, Version 1.1
  3.  *
  4.  * Copyright (c) 2001 The Apache Software Foundation->  All rights
  5.  * reserved.
  6.  *
  7.  * Redistribution and use in source and binary forms, with or without
  8.  * modification, are permitted provided that the following conditions
  9.  * are met:
  10.  *
  11.  * 1. Redistributions of source code must retain the above copyright
  12.  *    notice, this list of conditions and the following disclaimer.
  13.  *
  14.  * 2. Redistributions in binary form must reproduce the above copyright
  15.  *    notice, this list of conditions and the following disclaimer in
  16.  *    the documentation and/or other materials provided with the
  17.  *    distribution->
  18.  *
  19.  * 3. The end-user documentation included with the redistribution,
  20.  *    if any, must include the following acknowledgment:
  21.  *       "This product includes software developed by the
  22.  *        Apache Software Foundation (http://www.apache.org/)."
  23.  *    Alternately, this acknowledgment may appear in the software itself,
  24.  *    if and wherever such third-party acknowledgments normally appear.
  25.  *
  26.  * 4. The names "Xerces" and "Apache Software Foundation" must
  27.  *    not be used to endorse or promote products derived from this
  28.  *    software without prior written permission-> For written
  29.  *    permission, please contact apache@apache.org.
  30.  *
  31.  * 5. Products derived from this software may not be called "Apache",
  32.  *    nor may "Apache" appear in their name, without prior written
  33.  *    permission of the Apache Software Foundation->
  34.  *
  35.  * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESSED OR IMPLIED
  36.  * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
  37.  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
  38.  * DISCLAIMED.  IN NO EVENT SHALL THE APACHE SOFTWARE FOUNDATION OR
  39.  * ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  40.  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
  41.  * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF
  42.  * USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
  43.  * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
  44.  * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
  45.  * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  46.  * SUCH DAMAGE.
  47.  * ====================================================================
  48.  *
  49.  * This software consists of voluntary contributions made by many
  50.  * individuals on behalf of the Apache Software Foundation, and was
  51.  * originally based on software copyright (c) 2001, International
  52.  * Business Machines, Inc., http://www.ibm.com .  For more information
  53.  * on the Apache Software Foundation, please see
  54.  * <http://www.apache.org/>.
  55.  */
  57. /*
  58.  * $Log: IDTest.cpp,v $
  59.  * Revision 1.3  2001/12/07 01:48:27  tng
  60.  * [Bug 1959] setNodeValue throws exception when spec specifies NOP.
  61.  *
  62.  * Revision 1.2  2001/11/23 16:16:52  tng
  63.  * Elimiate compiler warning Warning: String literal converted to char* in initialization.
  64.  *
  65.  * Revision 1.1  2001/08/09 19:28:47  tng
  66.  * Port test case DOMTest to  IDOMTest
  67.  *
  68.  */
  72. /**
  73.  * This class tests methods for XML IDOM implementation
  74.  * IDOM_DOMException errors are tested by calls to DOMExceptionsTest from: Main, docBuilder...
  75.  *
  76.  */
  78. #include <stdio.h>
  79. #include "IDTest.h"
  80. #include <util/PlatformUtils.hpp>
  81. #include <util/XMLException.hpp>
  82. #include <util/XMLString.hpp>
  85. #define EXCEPTIONSTEST(operation, expectedException, resultFlag, testNum) 
  86.     {                                                               
  87.         try                                                         
  88.         {                                                           
  89.             operation;                                              
  90.             fprintf(stderr, "Exceptions Test # %d: no Exception thrown->n", testNum); 
  91.         }                                                           
  92.         catch (IDOM_DOMException &e)                                 
  93.         {                                                           
  94.             if (e.code != expectedException) {                      
  95.                 fprintf(stderr, "Exceptions Test # %d: wrong IDOM_DOMException thrown->n", 
  96.                     testNum);                                       
  97.                 resultFlag = false;                                 
  98.             }                                                       
  99.         }                                                           
  100.         catch (...)                                                 
  101.         {                                                           
  102.             fprintf(stderr, "Exceptions Test # %d: unknown exception thrown->n",    
  103.                 testNum);                                           
  104.             resultFlag = false;                                     
  105.         }                                                           
  106.     }
  108. //temp XMLCh String Buffer
  109. XMLCh tempStr[4000];
  110. XMLCh tempStr2[4000];
  111. XMLCh tempStr3[4000];
  113. IDOM_Element*                 IDTest::testElementNode;
  114. IDOM_Attr*                    IDTest::testAttributeNode;
  115. IDOM_Text*                    IDTest::testTextNode;
  116. IDOM_CDATASection*            IDTest::testCDATASectionNode;
  117. IDOM_EntityReference*         IDTest::testEntityReferenceNode;
  118. IDOM_Entity*                  IDTest::testEntityNode;
  119. IDOM_ProcessingInstruction*   IDTest::testProcessingInstructionNode;
  120. IDOM_Comment*                 IDTest::testCommentNode;
  121. IDOM_Document*                IDTest::testDocumentNode;
  122. IDOM_DocumentType*            IDTest::testDocumentTypeNode;
  123. IDOM_DocumentFragment*        IDTest::testDocumentFragmentNode;
  124. IDOM_Notation*                IDTest::testNotationNode;
  126. /**
  127.  *
  128.  *
  129.  */
  131. IDTest::IDTest()
  132. {
  133. };
  136. /**
  137.  *
  138.  * @return IDOM_Document
  139.  *
  140.  */
  141. IDOM_Document* IDTest::createDocument() {
  142.     IDOM_DOMImplementation* impl = IDOM_DOMImplementation::getImplementation();
  143.     return impl->createDocument();
  144. };
  147. /**
  148.  *
  149.  * @return IDOM_DocumentType
  150.  * @param name XMLCh*
  151.  *
  152.  */
  153. IDOM_DocumentType* IDTest::createDocumentType(IDOM_Document* doc, XMLCh* name) {
  154.     return doc->createDocumentType(name);    //Replace with a IDOM_DocumentType* creator
  155. };
  158. /**
  159.  *
  160.  * @return org.w3c.dom.IDOM_Entity
  161.  * @param doc org.w3c.dom.IDOM_Document
  162.  * @param name XMLCh*
  163.  *
  164.  */
  165. IDOM_Entity* IDTest::createEntity(IDOM_Document* doc, XMLCh* name) {
  166.     return doc->createEntity(name);
  167. };
  171. /**
  172.  *
  173.  * @return org.w3c.dom.IDOM_Notation
  174.  * @param doc org.w3c.dom.IDOM_Document
  175.  * @param name XMLCh*
  176.  *
  177.  */
  178. IDOM_Notation* IDTest::createNotation(IDOM_Document* doc, XMLCh* name) {
  179.     return doc->createNotation(name);
  180. };
  183. /**
  184.  * This method builds test documents for the XML IDOM implementation
  185.  * @param document org.w3c.dom.IDOM_Document
  186.  * @param name document's name
  187.  * @param type document's type
  188.  *
  189.  */
  190. void IDTest::docBuilder(IDOM_Document* document, XMLCh* nameIn)
  191. {
  192.     XMLCh* name = XMLString::replicate(nameIn);
  194.     IDOM_Document* doc = document;
  195.     bool OK = true;
  197.     //name + "FirstElement"
  198.     XMLString::transcode("FirstElement", tempStr2, 3999);
  199.     XMLString::catString(tempStr, name);
  200.     XMLString::catString(tempStr, tempStr2);
  202.     IDOM_Element* docFirstElement = doc->createElement(tempStr);
  203.     doc->appendChild(docFirstElement);
  205.     //name + "FirstElement", name + "firstElement"
  206.     XMLString::catString(tempStr, name);
  207.     XMLString::transcode("FirstElement", tempStr2, 3999);
  208.     XMLString::catString(tempStr, tempStr2);
  209.     XMLString::catString(tempStr2, name);
  210.     XMLString::transcode("firstElement", tempStr3, 3999);
  211.     XMLString::catString(tempStr2, tempStr3);
  212.     docFirstElement->setAttribute(tempStr, tempStr2);
  214.     //name + "TargetProcessorChannel" + "This is " + doc->getNodeName() + "'s processing instruction");
  215.     XMLString::copyString(tempStr, name);
  216.     XMLString::transcode("TargetProcessorChannel", tempStr2, 3999);
  217.     XMLString::catString(tempStr, tempStr2);
  218.     XMLString::transcode("This is ", tempStr2, 3999);
  219.     XMLString::catString(tempStr2, doc->getNodeName());
  220.     XMLString::transcode("'s processing instruction", tempStr3, 3999);
  221.     XMLString::catString(tempStr2, tempStr3);
  223.     IDOM_ProcessingInstruction* docProcessingInstruction = doc->createProcessingInstruction(tempStr, tempStr2);
  224.     docFirstElement->appendChild(docProcessingInstruction);
  226.     //name + "TestBody"
  227.     XMLString::copyString(tempStr, name);
  228.     XMLString::transcode("TestBody", tempStr2, 3999);
  229.     XMLString::catString(tempStr, tempStr2);
  230.     IDOM_Element* docBody = doc->createElement(tempStr);
  231.     docFirstElement->appendChild(docBody);
  233.     //name + "BodyLevel21"
  234.     XMLString::copyString(tempStr, name);
  235.     XMLString::transcode("BodyLevel21", tempStr2, 3999);
  236.     XMLString::catString(tempStr, tempStr2);
  237.     IDOM_Element* docBodyLevel21 = doc->createElement(tempStr);
  239.     //name + "BodyLevel22"
  240.     XMLString::copyString(tempStr, name);
  241.     XMLString::transcode("BodyLevel22", tempStr2, 3999);
  242.     XMLString::catString(tempStr, tempStr2);
  243.     IDOM_Element* docBodyLevel22 = doc->createElement(tempStr);
  245.     //name + "BodyLevel23"
  246.     XMLString::copyString(tempStr, name);
  247.     XMLString::transcode("BodyLevel23", tempStr2, 3999);
  248.     XMLString::catString(tempStr, tempStr2);
  249.     IDOM_Element* docBodyLevel23 = doc->createElement(tempStr);
  251.     //name + "BodyLevel24"
  252.     XMLString::copyString(tempStr, name);
  253.     XMLString::transcode("BodyLevel24", tempStr2, 3999);
  254.     XMLString::catString(tempStr, tempStr2);
  255.     IDOM_Element* docBodyLevel24 = doc->createElement(tempStr);
  257.     docBody->appendChild(docBodyLevel21);
  258.     docBody->appendChild(docBodyLevel22);
  259.     docBody->appendChild(docBodyLevel23);
  260.     docBody->appendChild(docBodyLevel24);
  262.     //name + "BodyLevel31"
  263.     XMLString::copyString(tempStr, name);
  264.     XMLString::transcode("BodyLevel31", tempStr2, 3999);
  265.     XMLString::catString(tempStr, tempStr2);
  266.     IDOM_Element* docBodyLevel31 = doc->createElement(tempStr);
  268.     //name + "BodyLevel32"
  269.     XMLString::copyString(tempStr, name);
  270.     XMLString::transcode("BodyLevel32", tempStr2, 3999);
  271.     XMLString::catString(tempStr, tempStr2);
  272.     IDOM_Element* docBodyLevel32 = doc->createElement(tempStr);
  274.     //name + "BodyLevel33"
  275.     XMLString::copyString(tempStr, name);
  276.     XMLString::transcode("BodyLevel33", tempStr2, 3999);
  277.     XMLString::catString(tempStr, tempStr2);
  278.     IDOM_Element* docBodyLevel33 = doc->createElement(tempStr);
  280.     //name + "BodyLevel34"
  281.     XMLString::copyString(tempStr, name);
  282.     XMLString::transcode("BodyLevel34", tempStr2, 3999);
  283.     XMLString::catString(tempStr, tempStr2);
  284.     IDOM_Element* docBodyLevel34 = doc->createElement(tempStr);
  286.     docBodyLevel21->appendChild(docBodyLevel31);
  287.     docBodyLevel21->appendChild(docBodyLevel32);
  288.     docBodyLevel22->appendChild(docBodyLevel33);
  289.     docBodyLevel22->appendChild(docBodyLevel34);
  291.     //name + "BodyLevel31'sChildTextNode11"
  292.     XMLString::copyString(tempStr, name);
  293.     XMLString::transcode("BodyLevel31'sChildTextNode11", tempStr2, 3999);
  294.     XMLString::catString(tempStr, tempStr2);
  295.     IDOM_Text* docTextNode11 = doc->createTextNode(tempStr);
  297.     //name + "BodyLevel31'sChildTextNode12"
  298.     XMLString::copyString(tempStr, name);
  299.     XMLString::transcode("BodyLevel31'sChildTextNode12", tempStr2, 3999);
  300.     XMLString::catString(tempStr, tempStr2);
  301.     IDOM_Text* docTextNode12 = doc->createTextNode(tempStr);
  303.     //name + "BodyLevel31'sChildTextNode13"
  304.     XMLString::copyString(tempStr, name);
  305.     XMLString::transcode("BodyLevel31'sChildTextNode13", tempStr2, 3999);
  306.     XMLString::catString(tempStr, tempStr2);
  307.     IDOM_Text* docTextNode13 = doc->createTextNode(tempStr);
  309.     //name + "TextNode2"
  310.     XMLString::copyString(tempStr, name);
  311.     XMLString::transcode("TextNode2", tempStr2, 3999);
  312.     XMLString::catString(tempStr, tempStr2);
  313.     IDOM_Text* docTextNode2 = doc->createTextNode(tempStr);
  315.     //name + "TextNode3"
  316.     XMLString::copyString(tempStr, name);
  317.     XMLString::transcode("TextNode3", tempStr2, 3999);
  318.     XMLString::catString(tempStr, tempStr2);
  319.     IDOM_Text* docTextNode3 = doc->createTextNode(tempStr);
  321.     //name + "TextNode4"
  322.     XMLString::copyString(tempStr, name);
  323.     XMLString::transcode("TextNode4", tempStr2, 3999);
  324.     XMLString::catString(tempStr, tempStr2);
  325.     IDOM_Text* docTextNode4 = doc->createTextNode(tempStr);
  327.     docBodyLevel31->appendChild(docTextNode11);
  328.     docBodyLevel31->appendChild(docTextNode12);
  329.     docBodyLevel31->appendChild(docTextNode13);
  330.     docBodyLevel32->appendChild(docTextNode2);
  331.     docBodyLevel33->appendChild(docTextNode3);
  332.     docBodyLevel34->appendChild(docTextNode4);
  334.     //"<![CDATA[<greeting>Hello, world!</greeting>]]>"
  335.     XMLString::transcode("<![CDATA[<greeting>Hello, world!</greeting>]]>", tempStr, 3999);
  336.     IDOM_CDATASection* docCDATASection = doc->createCDATASection(tempStr);
  337.     docBodyLevel23->appendChild(docCDATASection);
  339.     //"This should be a comment of some kind "
  340.     XMLString::transcode("This should be a comment of some kind ", tempStr, 3999);
  341.     IDOM_Comment* docComment = doc->createComment(tempStr);
  342.     docBodyLevel23->appendChild(docComment);
  344.     //"ourEntityNode"
  345.     XMLString::transcode("ourEntityNode", tempStr, 3999);
  346.     IDOM_EntityReference* docReferenceEntity = doc->createEntityReference(tempStr);
  347.     docBodyLevel24->appendChild(docReferenceEntity);
  349.     IDTest make;
  351.     //"ourNotationNode"
  352.     XMLString::transcode("ourNotationNode", tempStr, 3999);
  353.     IDOM_Notation* docNotation = make.createNotation(doc, tempStr);
  354.     IDOM_Node*  abc1 = doc->getFirstChild();
  355.     IDOM_DocumentType* docType = (IDOM_DocumentType*) abc1;
  356.     docType->getNotations()->setNamedItem(docNotation);
  358.     IDOM_DocumentFragment* docDocFragment = doc->createDocumentFragment();
  360. //  printf("This document's first element name is " + docFirstElement->getTagName() + "n");
  363. //***********Following are for errorTests
  365.     //name + "docTextNode3"
  366.     XMLString::copyString(tempStr, name);
  367.     XMLString::transcode("docTextNode3", tempStr2, 3999);
  368.     XMLString::catString(tempStr, tempStr2);
  369.     IDOM_Text* docNode3 = doc->createTextNode(tempStr);
  371.     //name + "docTextNode4"
  372.     XMLString::copyString(tempStr, name);
  373.     XMLString::transcode("docTextNode4", tempStr2, 3999);
  374.     XMLString::catString(tempStr, tempStr2);
  375.     IDOM_Text* docNode4 = doc->createTextNode(tempStr);
  377.     //"ourEntityNode"
  378.     XMLString::transcode("ourEntityNode", tempStr, 3999);
  379.     IDOM_Node*   abc2 =  doc->getDoctype()->getEntities()->getNamedItem(tempStr);  // Get the IDOM_Entity* node
  380.     IDOM_Entity* docEntity = (IDOM_Entity*) abc2;
  381.     IDOM_Node*   abc3 = doc->getFirstChild(); // Get the IDOM_DocumentType* node
  382.     IDOM_DocumentType* docDocType = (IDOM_DocumentType*) abc3;
  383.     IDOM_Node*   abc4 = doc->getLastChild()->getLastChild()->getLastChild()->getFirstChild();
  384.     IDOM_EntityReference* entityReferenceText = (IDOM_EntityReference*) abc4;
  386.     //"entityReferenceText information"
  387.     XMLString::transcode("entityReferenceText information", tempStr, 3999);
  388.     IDOM_Text* entityReferenceText2 = doc->createTextNode(tempStr);
  389. //************************************************* ERROR TESTS
  390.     IDTest tests;
  392.     EXCEPTIONSTEST(document->appendChild(docBody), IDOM_DOMException::HIERARCHY_REQUEST_ERR, OK,  1);
  394.     EXCEPTIONSTEST(document->appendChild(docBody), IDOM_DOMException::HIERARCHY_REQUEST_ERR, OK, 2);
  395.     EXCEPTIONSTEST(docNode3->appendChild(docNode4), IDOM_DOMException::HIERARCHY_REQUEST_ERR, OK, 3);
  396.     // EXCEPTIONSTEST(doc->insertBefore(docEntity, docFirstElement), IDOM_DOMException::HIERARCHY_REQUEST_ERR, OK, 4);
  397.     EXCEPTIONSTEST(doc->replaceChild(docCDATASection, docFirstElement), IDOM_DOMException::HIERARCHY_REQUEST_ERR, OK, 5);
  399.     //"This shouldn't work!"
  400.     XMLString::transcode("entityReferenceText information", tempStr, 3999);
  402.     // The following setNodeValue tests are not invalid
  403.     // According to DOM spec, exception is raised only if the node is readonly, otherwise should be no-op.
  404.     // EXCEPTIONSTEST(docFirstElement->setNodeValue(tempStr), IDOM_DOMException::NO_MODIFICATION_ALLOWED_ERR, OK, 6);
  406.     EXCEPTIONSTEST(docReferenceEntity->setNodeValue(tempStr), IDOM_DOMException::NO_MODIFICATION_ALLOWED_ERR, OK, 7);
  408.     // The following setNodeValue tests are not invalid
  409.     // According to DOM spec, exception is raised only if the node is readonly, otherwise should be no-op.
  410.     // EXCEPTIONSTEST(docEntity->setNodeValue(tempStr), IDOM_DOMException::NO_MODIFICATION_ALLOWED_ERR, OK, 8);
  411.     // EXCEPTIONSTEST(doc->setNodeValue(tempStr), IDOM_DOMException::NO_MODIFICATION_ALLOWED_ERR, OK, 9);
  412.     // EXCEPTIONSTEST(docDocType->setNodeValue(tempStr), IDOM_DOMException::NO_MODIFICATION_ALLOWED_ERR, OK, 10);
  413.     // EXCEPTIONSTEST(docDocFragment->setNodeValue(tempStr), IDOM_DOMException::NO_MODIFICATION_ALLOWED_ERR, OK, 11);
  414.     // EXCEPTIONSTEST(docNotation->setNodeValue(tempStr), IDOM_DOMException::NO_MODIFICATION_ALLOWED_ERR, OK, 12);
  415.     EXCEPTIONSTEST(docReferenceEntity->appendChild(entityReferenceText2 ), IDOM_DOMException::NO_MODIFICATION_ALLOWED_ERR , OK, 13);
  416.     EXCEPTIONSTEST(docBodyLevel32->insertBefore(docTextNode11,docBody ), IDOM_DOMException::NOT_FOUND_ERR, OK, 14);
  417.     EXCEPTIONSTEST(docBodyLevel32->removeChild(docFirstElement), IDOM_DOMException::NOT_FOUND_ERR, OK, 15);
  418.     EXCEPTIONSTEST(docBodyLevel32->replaceChild(docTextNode11,docFirstElement ), IDOM_DOMException::NOT_FOUND_ERR, OK, 16);
  420.     delete [] name;
  423. //!! Throws a NOT_FOUND_ERR ********
  425.      // docBodyLevel32->getAttributes()->removeNamedItem(testAttribute->getName());    16  // To test removeNamedItem
  427. };  //END OF DOCBUILDER
  431. /**
  432.  * @param document org.w3c.dom.IDOM_Document
  433.  */
  434.  void IDTest::findTestNodes(IDOM_Document* document) {
  435.     IDOM_Node* node = document;
  436.     int nodeCount = 0;
  438.     // Walk the tree until you find and assign all node types needed that exist.
  439.     while (node != 0 && nodeCount < 12)
  440.     {
  442.         switch (node->getNodeType())
  443.     {
  444.         case IDOM_Node::ELEMENT_NODE :
  445.             if (testElementNode == 0) {testElementNode = (IDOM_Element*)node; nodeCount++;}
  446.             break;
  447.         case IDOM_Node::ATTRIBUTE_NODE :
  448.             if (testAttributeNode == 0) {testAttributeNode = (IDOM_Attr*)node; nodeCount++;}
  449.             break;
  450.         case IDOM_Node::TEXT_NODE :
  451.             if (testTextNode == 0) {testTextNode = (IDOM_Text*)node; nodeCount++;}
  452.             break;
  453.         case IDOM_Node::CDATA_SECTION_NODE :
  454.             if (testCDATASectionNode == 0) {testCDATASectionNode = (IDOM_CDATASection*)node; nodeCount++;}
  455.             break;
  456.         case IDOM_Node::ENTITY_REFERENCE_NODE :
  457.             if (testEntityReferenceNode == 0) {testEntityReferenceNode = (IDOM_EntityReference*)node; nodeCount++;}
  458.             break;
  459.         case IDOM_Node::ENTITY_NODE :
  460.             if (testEntityNode == 0) {testEntityNode = (IDOM_Entity*)node; nodeCount++;}
  461.             break;
  462.         case IDOM_Node::PROCESSING_INSTRUCTION_NODE :
  463.             if (testProcessingInstructionNode == 0) {testProcessingInstructionNode = (IDOM_ProcessingInstruction*)node; nodeCount++;}
  464.             break;
  465.         case IDOM_Node::COMMENT_NODE :
  466.             if (testCommentNode == 0) {testCommentNode = (IDOM_Comment*)node; nodeCount++;}
  467.             break;
  468.         case IDOM_Node::DOCUMENT_TYPE_NODE :
  469.             if (testDocumentTypeNode == 0) {testDocumentTypeNode = (IDOM_DocumentType*)node; nodeCount++;}
  470.             break;
  471.         case IDOM_Node::DOCUMENT_FRAGMENT_NODE :
  472.             if (testDocumentFragmentNode == 0) {testDocumentFragmentNode = (IDOM_DocumentFragment*)node; nodeCount++;}
  473.             break;
  474.         case IDOM_Node::NOTATION_NODE :
  475.             if (testNotationNode == 0) {testNotationNode = (IDOM_Notation*)node; nodeCount++;}
  476.             break;
  477.         case IDOM_Node::DOCUMENT_NODE :
  478.             if (testDocumentNode == 0) {testDocumentNode = (IDOM_Document*)node; nodeCount++;}
  479.             break;
  480.         default:
  481.             ;
  482.     }// End of switch
  484.     }   // End of while
  485. };
  488. /**
  489.  * @param document org.w3c.dom.IDOM_Document
  490.  */
  491.  void IDTest::findTestNodes(IDOM_Node* node) {
  492.     IDTest test;
  493.     IDOM_Node*  kid;
  494.     // Walk the tree until you find and assign all node types needed that exist.
  497.     if (node->getFirstChild() != 0)
  498.     {
  499.         kid = node->getFirstChild();
  500.         test.findTestNodes(kid);
  501.     }
  504.     if (node->getNextSibling() != 0)
  505.     {
  506.         kid = node->getNextSibling();
  507.         test.findTestNodes(kid);
  508.     }
  511.     switch (node->getNodeType())
  512.     {
  513.         case IDOM_Node::ELEMENT_NODE :
  514.             if (testElementNode == 0) {testElementNode = (IDOM_Element*)node; }
  515.             break;
  516.         case IDOM_Node::ATTRIBUTE_NODE :
  517.             if (testAttributeNode == 0) {testAttributeNode = (IDOM_Attr*)node; }
  518.             break;
  519.         case IDOM_Node::TEXT_NODE :
  520.             if (testTextNode == 0) {testTextNode = (IDOM_Text*)node; }
  521.             break;
  522.         case IDOM_Node::CDATA_SECTION_NODE :
  523.             if (testCDATASectionNode == 0) {testCDATASectionNode = (IDOM_CDATASection*)node; }
  524.             break;
  525.         case IDOM_Node::ENTITY_REFERENCE_NODE :
  526.             if (testEntityReferenceNode == 0) {testEntityReferenceNode = (IDOM_EntityReference*)node;}
  527.             break;
  528.         case IDOM_Node::ENTITY_NODE :
  529.             if (testEntityNode == 0) {testEntityNode = (IDOM_Entity*)node;}
  530.             break;
  531.         case IDOM_Node::PROCESSING_INSTRUCTION_NODE :
  532.             if (testProcessingInstructionNode == 0) {testProcessingInstructionNode = (IDOM_ProcessingInstruction*)node;}
  533.             break;
  534.         case IDOM_Node::COMMENT_NODE :
  535.             if (testCommentNode == 0) {testCommentNode = (IDOM_Comment*)node;}
  536.             break;
  537.         case IDOM_Node::DOCUMENT_TYPE_NODE :
  538.             if (testDocumentTypeNode == 0) {testDocumentTypeNode = (IDOM_DocumentType*)node; }
  539.             break;
  540.         case IDOM_Node::DOCUMENT_FRAGMENT_NODE :
  541.             if (testDocumentFragmentNode == 0) {testDocumentFragmentNode = (IDOM_DocumentFragment*)node;}
  542.             break;
  543.         case IDOM_Node::NOTATION_NODE :
  544.             if (testNotationNode == 0) {testNotationNode = (IDOM_Notation*)node;}
  545.             break;
  546.         case IDOM_Node::DOCUMENT_NODE :
  547.             if (testDocumentNode == 0) {testDocumentNode = (IDOM_Document*)node;}
  548.             break;
  549.         default:
  550.             ;
  551.     }// End of switch
  552. };//End of class
  554. /**
  555.  *
  556.  *
  557.  */
  558.  int main(int argc, char **argv)
  559.  {
  561.      {
  562.          //  Nest entire test in an inner block.
  563.          //     Reference counting should recover all document
  564.          //     storage when this block exits.
  566.          IDTest test;
  567.          try {
  568.              XMLPlatformUtils::Initialize();
  569.          }
  570.          catch (const XMLException& toCatch) {
  571.              char *pMessage = XMLString::transcode(toCatch.getMessage());
  572.              fprintf(stderr, "Error during initialization! n  %s n", pMessage);
  573.              delete [] pMessage;
  574.              return -1;
  575.          }
  577.          long avgTime = 0;
  578.          bool OK = true;
  579.          long startTime = 0;//****************Time the whole thing for efficiency of IDOM implementation
  581.          // for (int i=0; i< 1000; i++)
  582.          // {
  583.          // AH Revisit  //  startTime = System.currentTimeMillis();
  584.          //     if(!OK)
  585.          //     break;
  587.          IDOM_Document* d = test.createDocument();
  589.          XMLString::transcode("testDocument1", tempStr, 3999);
  590.          IDOM_DocumentType* docDocType = test.createDocumentType(d,tempStr);
  591.          d->appendChild(docDocType);
  593.          XMLString::transcode("ourEntityNode", tempStr, 3999);
  594.          IDOM_Entity* docEntity = test.createEntity( d, tempStr);
  595.          //Build a branch for entityReference tests
  596.          // IDOM_Text* entityChildText = d.createTextNode("entityChildText information"); //
  597.          // docEntity->appendChild(entityChildText);
  598.          // docDocType->getEntities()->setNamedItem(docEntity);
  600.          XMLString::transcode("d", tempStr3, 3999);
  601.          test.docBuilder(d, tempStr3);
  603.          test.findTestNodes((IDOM_Node*)d);
  605.          // Null out the static object references in class IDTest,
  606.          // which will recover their storage.
  607.          IDTest::testElementNode = 0;
  608.          IDTest::testAttributeNode = 0;
  609.          IDTest::testTextNode = 0;
  610.          IDTest::testCDATASectionNode = 0;
  611.          IDTest::testEntityReferenceNode = 0;
  612.          IDTest::testEntityNode = 0;
  613.          IDTest::testProcessingInstructionNode = 0;
  614.          IDTest::testCommentNode = 0;
  615.          IDTest::testDocumentNode = 0;
  616.          IDTest::testDocumentTypeNode = 0;
  617.          IDTest::testDocumentFragmentNode = 0;
  618.          IDTest::testNotationNode = 0;
  620.          delete d;
  622.     };
  624.     XMLPlatformUtils::Terminate();
  626.     printf("Test Run Successfullyn");
  627.     return 0;
  628. };
  631. /**
  632.  * This method tests IDOM_Attr* methods for the XML IDOM implementation
  633.  * @param document org.w3c.dom.IDOM_Document
  634.  *
  635.  */
  636. void IDTest::testAttr(IDOM_Document* document)
  637. {
  638.     IDOM_Node* node;
  639.     IDOM_Attr* attributeNode;
  640.     bool T = true;
  641.     bool F = false;
  642.     bool OK = true;
  643. // For debugging*****   printf("n          testAttr's outputs:nn");
  645.     XMLString::transcode("testAttribute", tempStr, 3999);
  646.     IDOM_Attr* testAttribute = document->createAttribute(tempStr);
  648.     XMLString::transcode("testAttribute's value", tempStr, 3999);
  649.     testAttribute->setValue(tempStr);
  650.     node = document->getDocumentElement(); // node gets first element
  652.     // ((IDOM_Element*)node)->setAttributeNode(testAttribute);
  653.     // attributeNode = ((IDOM_Element*)node)->getAttributeNode("testAttribute");
  654.     IDOM_Element* el = (IDOM_Element*)node;
  655.     el->setAttributeNode(testAttribute);
  657.     XMLString::transcode("testAttribute", tempStr, 3999);
  658.     attributeNode = el->getAttributeNode(tempStr);
  660.     if (XMLString::compareString(tempStr, attributeNode->getName()))
  661.     {
  662.         printf("Warning!!! IDOM_Attr's 'getName' method failed to work properly!n");
  663.         OK = false;
  664.     }
  666.     XMLString::transcode("testAttribute's value", tempStr, 3999);
  667.     if (XMLString::compareString(tempStr, attributeNode->getNodeValue()))
  668.     {
  669.         printf("Warning!!! IDOM_Attr's 'getNodeValue' method failed to work properly!n");
  670.         OK = false;
  671.     }
  672.     if (! T ==attributeNode->getSpecified())
  673.     {
  674.         printf("Warning!!! IDOM_Attr's 'getSpecified' method failed to work properly!n");
  675.         OK = false;
  676.     }
  678.     if (XMLString::compareString(tempStr, attributeNode->getValue()))
  679.     {
  680.         printf("Warning!!! IDOM_Attr's 'getValue' method failed to work properly!n");
  681.         OK = false;
  682.     }
  685.     XMLString::transcode("Reset Value", tempStr, 3999);
  686.     attributeNode->setNodeValue(tempStr);   /// LEAK!!!!!
  687.     if (XMLString::compareString(tempStr, attributeNode->getNodeValue()))
  688.     {
  689.         printf("Warning!!! IDOM_Attr's 'setNodeValue' method failed to work properly!n");
  690.         OK = false;
  691.     }
  693.     attributeNode->setValue(XMLUni::fgZeroLenString);
  694.     if (XMLString::compareString(XMLUni::fgZeroLenString, attributeNode->getValue()))
  695.     {
  696.         printf("Warning!!! IDOM_Attr's 'setValue' to '0' method failed to work properly!n");
  697.         OK = false;
  698.     }
  700.     XMLString::transcode("Another value ", tempStr, 3999);
  701.     attributeNode->setValue(tempStr);
  702.     if (XMLString::compareString(tempStr, attributeNode->getValue()))
  703.     {
  704.         printf("Warning!!! IDOM_Attr's 'setValue' method failed to work properly!");
  705.         OK = false;
  706.     }
  708.     node = attributeNode->cloneNode(T);
  710.     // Check nodes for equality, both their name and value or lack thereof
  711.     bool cloneOK = true;
  712.     if (XMLString::compareString(node->getNodeName(), attributeNode->getNodeName()))
  713.         cloneOK = false;
  714.     if (node->getNodeValue() == 0 &&
  715.         attributeNode->getNodeValue() != 0)
  716.     {
  717.         cloneOK = false;
  718.     }
  720.     if (node->getNodeValue() != 0 && attributeNode->getNodeValue() == 0)
  721.     {
  722.         cloneOK = false;
  723.     };
  725.     if (node->getNodeValue() != 0 && attributeNode->getNodeValue() != 0)
  726.     {
  727.         if (XMLString::compareString(node->getNodeValue(),attributeNode->getNodeValue()))
  728.             cloneOK = false;
  729.     }
  732. /*
  733.     if (! (node->getNodeName(), attributeNode->getNodeName()) &&         // Compares node names for equality
  734.           (node->getNodeValue() != 0 && attributeNode->getNodeValue() != 0)  // Checks to make sure each node has a value node
  735.         ?  node->getNodeValue(), attributeNode->getNodeValue())          // If both have value nodes test those value nodes for equality
  736.         : (node->getNodeValue() == 0 && attributeNode->getNodeValue() == 0)))// If one node doesn't have a value node make sure both don't
  737. */
  738.     if (cloneOK == false)
  739.         {
  740.             printf("'cloneNode' did not clone the Attribute node correctlyn");
  741.             OK = false;
  742.         }
  743.         // Deep clone test comparison is in testNode & testDocument
  745. //************************************************* ERROR TESTS
  746.     IDTest tests;
  747. //!! Throws HIERARCHY_REQUEST_ERR ****************
  748.     //  doc->getDocumentElement()->appendChild(attributeNode);
  750. //!! Throws a NOT_FOUND_ERR ********
  751.     //  attribute2 = doc->createAttribute("testAttribute2");
  752.     //  doc->getDocumentElement()->removeAttributeNode(attribute2);
  754. //!! Throws an INUSE_ATTRIBUTE_ERR ******
  755.     //  IDOM_Element* element = (IDOM_Element*)doc->getLastChild()->getLastChild();
  756.     //  element->setAttributeNode(testAttribute );// Tests setNamedItem which generates error through justSetNamedItem.
  758. // For debugging*****       printf("All IDOM_Attr* method calls worked correctly.n");
  759.     if (! OK)
  760.         printf("n*****The IDOM_Attr* method calls listed above failed, all others worked correctly.*****n");
  761. //  printf("");
  763. };
  768. /**
  769.  * This method tests IDOM_CDATASection* methods for the XML IDOM implementation
  770.  * @param document org.w3c.dom.IDOM_Document
  771.  *
  772.  */
  773. void IDTest::testCDATASection(IDOM_Document* document)
  774. {
  775.     IDOM_Node* node;
  776.     IDOM_Node* node2;
  777.     bool T = true;
  778.     bool OK = true;
  779. // For debugging*****   printf("n          testCDATASection's outputs:n");
  780.     XMLString::transcode("dBodyLevel23", tempStr, 3999);
  781.     node = document->getDocumentElement()->getElementsByTagName(tempStr)->item(0)->getFirstChild(); // node gets IDOM_CDATASection* node
  783.     node2 = node->cloneNode(T);//*****?
  784.     // Check nodes for equality, both their name and value or lack thereof
  785.     if (XMLString::compareString(node->getNodeName(), node2->getNodeName()) &&        // Compares node names for equality
  786.           (node->getNodeValue() != 0 && node2->getNodeValue() != 0)     // Checks to make sure each node has a value node
  787.         ?  !XMLString::compareString(node->getNodeValue(), node2->getNodeValue())         // If both have value nodes test those value nodes for equality
  788.         : (node->getNodeValue() == 0 && node2->getNodeValue() == 0))   // If one node doesn't have a value node make sure both don't
  789.     {
  790.         printf("'cloneNode' did not clone the IDOM_CDATASection* node correctlyn");
  791.         OK = false;
  792.     }
  793.     // Deep clone test comparison is in testNode & testDocument
  795. // For debugging*****   printf("All IDOM_CDATASection* method calls worked correctly.n");
  797.     if (! OK)
  798.         printf("n*****The IDOM_CDATASection* method calls listed above failed, all others worked correctly.*****n");
  799. //  printf("");
  800. };
  804. /**
  805.  * This method tests IDOM_CharacterData methods for the XML IDOM implementation
  806.  * @param document org.w3c.dom.IDOM_Document
  807.  *
  808.  */
  809. void IDTest::testCharacterData(IDOM_Document* document)
  810. {
  811.     IDOM_CharacterData* charData;
  812.     XMLCh resetData[3999];
  813.     bool OK = true;
  814. // For debugging*****   printf("n          testCharacterData's outputs:n");
  815.     XMLString::transcode("dBodyLevel31", tempStr, 3999);
  816.     IDOM_Node*  abc1 = document->getDocumentElement()->getElementsByTagName(tempStr)->item(0)->getFirstChild(); // charData gets textNode11
  818.     charData = (IDOM_CharacterData *) abc1;
  820.     XMLString::transcode("dBodyLevel31'sChildTextNode11", tempStr, 3999);
  821.     if (XMLString::compareString(tempStr, charData->getData()))
  822.     {
  823.         printf("Warning!!! IDOM_CharacterData's 'getData' failed to work properly!n This may corrupt other IDOM_CharacterData tests!!!*****n");
  824.         OK = false;
  825.     }
  827.     XMLString::copyString(resetData,charData->getData());
  828.     //  printf("This node's original data is: " + charData->getData());
  830.     XMLString::copyString(tempStr, charData->getData());
  831.     XMLString::transcode(" This is new data for this node", tempStr2, 3999);
  832.     XMLString::copyString(tempStr, tempStr2);
  833.     charData->appendData(tempStr);
  834.     if (XMLString::compareString(tempStr, charData->getData()))
  835.     {
  836.         printf("Warning!!! IDOM_CharacterData's 'appendData' failed to work properly!n");
  837.         OK = false;
  838.     }
  839.     //  printf("This node's appended data is: " + charData->getData());
  841.     XMLString::transcode("dBodyLevel", tempStr, 3999);
  842.     charData->deleteData(10, 100);
  843.     if (XMLString::compareString(tempStr, charData->getData()))
  844.     {
  845.         printf("Warning!!! IDOM_CharacterData's 'deleteData' failed to work properly!n");
  846.         OK = false;
  847.     }
  848.     //  printf("This node's partially deleted data is: " + charData->getData());
  850.     unsigned int length = 10;
  851.     if (!(length == charData->getLength()))
  852.     {
  853.         printf("Warning!!! IDOM_CharacterData's 'getLength' failed to work properly!n");
  854.         OK = false;
  855.     }
  856.     //  printf("This node's data length is: " + charData->getLength());
  858.     XMLString::transcode("dBody' This is data inserted into this node'Level", tempStr, 3999);
  859.     XMLString::transcode("' This is data inserted into this node'", tempStr2, 3999);
  860.     charData->insertData(5, tempStr2);
  861.     if (XMLString::compareString(tempStr, charData->getData()))
  862.     {
  863.         printf("Warning!!! IDOM_CharacterData's 'insertData' failed to work properly!n");
  864.         OK = false;
  865.     }
  866.     //  printf("This node's updated with insert data is: " + charData->getData());
  868.     XMLString::transcode("dBody' This is ' replacement data'ted into this node'Level", tempStr, 3999);
  869.     XMLString::transcode("' replacement data'", tempStr2, 3999);
  870.     charData->replaceData(15, 10, tempStr2);
  871.     if (XMLString::compareString(tempStr, charData->getData()))
  872.     {
  873.         printf("Warning!!! IDOM_CharacterData's 'replaceData' failed to work properly!n");
  874.         OK = false;
  875.     }
  876.     //  printf("This node's updated with replacement data is: " +charData->getData());
  878.     XMLString::transcode("New data A123456789B123456789C123456789D123456789E123456789", tempStr, 3999);
  879.     charData->setData(tempStr);
  880.     if (XMLString::compareString(tempStr, charData->getData()))
  881.     {
  882.         printf("Warning!!! IDOM_CharacterData's 'setData' failed to work properly!");
  883.         OK = false;
  884.     }
  885.     //  printf("This node's new data via setData: " + charData->getData());
  887.     XMLString::transcode("123456789D123456789E123456789", tempStr, 3999);
  888.     if (XMLString::compareString(tempStr, charData->substringData(30, 30)))
  889.     {
  890.         printf("Warning!!! IDOM_CharacterData's 'substringData' failed to work properly!n");
  891.         OK = false;
  892.     }
  893.     //  printf("Using subString 30,30 you get:");  charData->substringData(30,30)).print();
  895.     XMLString::transcode("New data A123456789B12345", tempStr, 3999);
  896.     if (XMLString::compareString(tempStr, charData->substringData(0, 25)))
  897.     {
  898.         printf("Warning!!! IDOM_CharacterData's 'substringData' failed to work properly!n");
  899.         OK = false;
  900.     }
  901.     //  printf("Using subString 0,25 you get: ");   charData->substringData(0,25)).print();
  903. //************************************************* ERROR TESTS
  904.     IDTest tests;   // What is this for?  'tests' is never used.
  906. //!! Throws INDEX_SIZE_ERR ********************
  907.     EXCEPTIONSTEST(charData->deleteData(-1, 5), IDOM_DOMException::INDEX_SIZE_ERR, OK, 101 );
  908.     // Test 102 is not an error because the -1 parameter is an unsigned value, and counts
  909.     //   that exceed the length of the string are allowed.
  910. //    EXCEPTIONSTEST(charData->deleteData(2, -1), IDOM_DOMException::INDEX_SIZE_ERR, OK, 102 );
  911.     EXCEPTIONSTEST(charData->deleteData(100, 5), IDOM_DOMException::INDEX_SIZE_ERR, OK,103 );
  913. //can't set negative unsigned int in c++ compiler
  915.   //  EXCEPTIONSTEST(charData->insertData(-1, "Stuff inserted"), IDOM_DOMException::INDEX_SIZE_ERR, OK, 104 );
  916.     XMLString::transcode("Stuff inserted", tempStr, 3999);
  917.     EXCEPTIONSTEST(charData->insertData(100, tempStr), IDOM_DOMException::INDEX_SIZE_ERR, OK, 105 );
  919.   //  EXCEPTIONSTEST(charData->replaceData(-1, 5, "Replacement stuff") , IDOM_DOMException::INDEX_SIZE_ERR, OK, 106 );
  920.     XMLString::transcode("Replacement stuff", tempStr, 3999);
  921.     EXCEPTIONSTEST(charData->replaceData(100, 5 ,tempStr), IDOM_DOMException::INDEX_SIZE_ERR, OK, 107 );
  922.   //  EXCEPTIONSTEST(charData->replaceData(2, -1, "Replacement stuff"), IDOM_DOMException::INDEX_SIZE_ERR,  OK, 108 );
  924.     EXCEPTIONSTEST(charData->substringData(-1, 5), IDOM_DOMException::INDEX_SIZE_ERR, OK, 109 );
  925.     EXCEPTIONSTEST(charData->substringData(100, 5), IDOM_DOMException::INDEX_SIZE_ERR, OK, 110 );
  926.  //   EXCEPTIONSTEST(charData->substringData(2, -1), IDOM_DOMException::INDEX_SIZE_ERR, OK, 111 );
  929. // For debugging*****       printf("All IDOM_CharacterData method calls worked correctly.n");
  930.     if (!OK)
  931.         printf("n*****The IDOM_CharacterData method calls listed above failed, all others worked correctly.*****n");
  932.     charData->setData(resetData); // reset node to original data
  933. //  printf(""n);
  934. };
  939. /**
  940.  * This method tests ChildNodeList methods for the XML IDOM implementation
  941.  * @param document org.w3c.dom.IDOM_Document
  942.  *
  943.  */
  944. void IDTest::testChildNodeList(IDOM_Document* document)
  945. {
  946.     IDOM_Node* node;
  947.     IDOM_Node* node2;
  948.     bool OK = true;
  949. // For debugging*****   printf("n          testChildNodeList's outputs:n");
  950.     node = document->getDocumentElement()->getLastChild(); // node gets doc's testBody element
  952.     if (!(node->getChildNodes()->getLength()== 4))
  953.         OK = false;
  954.     node2 = node->getChildNodes()->item(2);
  955.     XMLString::transcode("dBodyLevel23", tempStr, 3999);
  956.     if (XMLString::compareString(tempStr, node2->getNodeName()))
  957.         OK = false;
  959. // For debugging*****       printf("All ChildNodeList method calls worked correctly.n");
  960.     if (!OK)
  961.         printf("n*****The ChildNodeList method calls listed above failed, all others worked correctly.*****n");
  962. //  printf("");
  963. };
  967. /**
  968.  * This method tests IDOM_Comment* methods for the XML IDOM implementation
  969.  * @param document org.w3c.dom.IDOM_Document
  970.  *
  971.  */
  972. void IDTest::testComment(IDOM_Document* document)
  973. {
  974.     IDOM_Node* node;
  975.     IDOM_Node* node2;
  976.     bool T = true;
  977.     bool OK = true;
  978. // For debugging*****   printf("n          testComment's outputs:n");
  979.     XMLString::transcode("dBodyLevel31", tempStr, 3999);
  980.     node = document->getDocumentElement()->getElementsByTagName(tempStr)->item(0)->getFirstChild(); // node gets textNode11
  981.     node2 = node->cloneNode(T);
  982.     // Check nodes for equality, both their name and value or lack thereof
  983.     if (XMLString::compareString(node->getNodeName(),node2->getNodeName()) &&         // Compares node names for equality
  984.           (node->getNodeValue() != 0 && node2->getNodeValue() != 0)     // Checks to make sure each node has a value node
  985.         ?  !XMLString::compareString(node->getNodeValue(),node2->getNodeValue())         // If both have value nodes test those value nodes for equality
  986.         : (node->getNodeValue() == 0 && node2->getNodeValue() == 0))   // If one node doesn't have a value node make sure both don't
  987.         //printf("'cloneNode' did not clone the IDOM_Comment* node correctlyn");
  988.         OK = false;
  989.     // Deep clone test comparison is in testNode & testDocument
  990.     if (OK)
  991. // For debugging*****       printf("All IDOM_Comment* method calls worked correctly.n");
  992.     if (!OK)
  993.         printf("n*****The IDOM_Comment* method calls listed above failed, all others worked correctly.*****n");
  994. //  printf("n");
  995. };
  999. /**
  1000.  * This method tests DeepNodeList methods for the XML IDOM implementation
  1001.  * @param document org.w3c.dom.IDOM_Document
  1002.  *
  1003.  */
  1004. void IDTest::testDeepNodeList(IDOM_Document* document)
  1005. {
  1006.     IDOM_Node* node;
  1007.     IDOM_Node* node2;
  1008.     bool OK = true;
  1009. // For debugging*****   printf("n          testDeepNodeList's outputs:nn");
  1010.     node = document->getLastChild()->getLastChild(); // node gets docBody element
  1011. //  IDOM_Element* el = (IDOM_Element*)node;
  1012. //  IDOM_NodeList nl = el->getElementsByTagName("*");
  1013. //  int len = nl->getLength();
  1014. //  if (len != 8)
  1015.     XMLString::transcode("*",tempStr, 3999);
  1016.     if (!(8 == ((IDOM_Element*) node)->getElementsByTagName(tempStr)->getLength()))
  1017.         {
  1018.             printf ("Warning!!! DeepNodeList's 'getLength' failed to work properly!n");
  1019.             OK = false;
  1020.         }
  1021.     node2 = ((IDOM_Element*) node)->getElementsByTagName(tempStr)->item(2); //This also runs through 'nextMatchingElementAfter"
  1023.     XMLString::transcode("dBodyLevel32", tempStr, 3999);
  1024.     if (XMLString::compareString(tempStr, node2->getNodeName()))
  1025.         {
  1026.             printf ("Warning!!! DeepNodeList's 'item' (or IDOM_Element's 'getElementsBy TagName)failed to work properly!n");
  1027.             OK = false;
  1028.         }
  1029.     node2 = document->getLastChild();
  1030.     XMLString::transcode("dTestBody", tempStr, 3999);
  1031.     if (XMLString::compareString(tempStr, ((IDOM_Element*) node2)->getElementsByTagName(tempStr)->item(0)->getNodeName()))//This also runs through 'nextMatchingElementAfter"
  1032.         {
  1033.             printf ("Warning!!! DeepNodeList's 'item' (or IDOM_Element's 'getElementsBy TagName)failed to work properly!n");
  1034.             OK = false;
  1035.         }
  1038. // For debugging*****       printf("All DeepNodeList method calls worked correctly.n");
  1039.     if (!OK)
  1040.         printf("n*****The DeepNodeList method calls listed above failed, all others worked correctly.*****n");
  1041. //  printf("");
  1042. };
  1046. /**
  1047.  * This method tests IDOM_Document* methods for the XML IDOM implementation
  1048.  * @param document org.w3c.dom.IDOM_Document
  1049.  *
  1050.  *
  1051.  **** ALL IDOM_Document* create methods are run in docBuilder except createAttribute which is in testAttribute**
  1052.  */
  1053. void IDTest::testDocument(IDOM_Document* document)
  1054. {
  1055.     IDTest make;
  1056.     IDOM_DocumentFragment* docFragment, *docFragment2;
  1057.     IDOM_Element* newElement;
  1058.     IDOM_Node* node, *node2;
  1060.     const char* elementNames[] =  {"dFirstElement", "dTestBody", "dBodyLevel21","dBodyLevel31","dBodyLevel32",
  1061.                    "dBodyLevel22","dBodyLevel33","dBodyLevel34","dBodyLevel23","dBodyLevel24"};
  1062.     const char* newElementNames[] = {"dFirstElement", "dTestBody", "dBodyLevel22","dBodyLevel33","dBodyLevel34","dBodyLevel23"};
  1065.     bool result;
  1066.     bool OK = true;
  1067. // For debugging*****   printf("n          testDocument's outputs:n n");
  1069.     XMLString::transcode("testDocument1", tempStr, 3999);
  1070.     IDOM_DocumentType* checkDocType =  make.createDocumentType(document,tempStr);
  1071.     IDOM_DocumentType* docType = document->getDoctype();
  1073.     if (XMLString::compareString(checkDocType->getNodeName(),docType->getNodeName() ))
  1074.     {
  1075.         printf("Warning!!! IDOM_Document's 'getDocType method failed!n" );
  1076.         OK = false;
  1077.     }
  1079.     if (XMLString::compareString(checkDocType->getNodeValue(), docType->getNodeValue()))
  1080.     {
  1081.         printf("Warning!!! IDOM_Document's 'getDocType method failed!n" );
  1082.         OK = false;
  1083.     }
  1085.     /*
  1086.     if (! (checkDocType->getNodeName(), docType->getNodeName()) &&      // Compares node names for equality
  1087.           (checkDocType->getNodeValue() != 0 && docType->getNodeValue() != 0)   // Checks to make sure each node has a value node
  1088.         ?  checkDocType->getNodeValue(), docType->getNodeValue())       // If both have value nodes test those value nodes for equality
  1089.         : (checkDocType->getNodeValue() == 0 && docType->getNodeValue() == 0))) // If one node doesn't have a value node make sure both don't
  1090.     {
  1091.         printf("Warning!!! IDOM_Document's 'getDocType method failed!n" );
  1092.         OK = false;
  1093.     }
  1094.     */
  1096.     IDOM_Node*  rootElement = document->getLastChild();
  1097.     if (XMLString::compareString(rootElement->getNodeName(), document->getDocumentElement()->getNodeName()) &&         // Compares node names for equality
  1098.           (rootElement->getNodeValue() != 0 && document->getDocumentElement()->getNodeValue() != 0)   // Checks to make sure each node has a value node
  1099.         ?  !XMLString::compareString(rootElement->getNodeValue(), document->getDocumentElement()->getNodeValue())      // If both have value nodes test those value nodes for equality
  1100.         : (rootElement->getNodeValue() == 0 && document->getDocumentElement()->getNodeValue() == 0))    // If one node doesn't have a value node make sure both don't
  1101.     {
  1102.         printf("Warning!!! IDOM_Document's 'getDocumentElement' method failed!n" );
  1103.         OK = false;
  1104.     }
  1106.     XMLString::transcode("*", tempStr, 3999);
  1107.     IDOM_NodeList* docElements = document->getElementsByTagName(tempStr);
  1108.     int docSize = docElements->getLength();
  1109.     int i;
  1110.     for (i = 0; i < docSize; i++)
  1111.     {
  1112.         IDOM_Node*  n = (IDOM_Node*) docElements->item(i);
  1113.         if (XMLString::compareString(XMLString::transcode(elementNames[i]), n->getNodeName()))
  1114.         {
  1115.             printf("Comparison of this document's elements failed at element number %d at line %i n", i, __LINE__);
  1116.             OK = false;
  1117.             break;
  1118.         }
  1119.     }
  1121.     // What is this supposed to be doing?
  1122.     //
  1123.     //if (document->equals(document->getImplementation()))
  1124.     //{
  1125.     //  printf("Warning!!! IDOM_Document's 'getImplementation' method failed!n" );
  1126.     //  OK = false;
  1127.     //}
  1129.     XMLString::transcode("NewElementTestsInsertBefore", tempStr, 3999);
  1130.     newElement = document->createElement(tempStr);
  1131.     //  doc->insertBefore(newElement,0);//!! Throws a HIERARCHY_REQUEST_ERR   *******
  1132.     //  doc->removeChild(docElements->item(9));//!! Throws a NOT_FOUND_ERR  ********
  1134.     docFragment = document->createDocumentFragment();
  1135.     //Tests removeChild and stores removed branch for tree reconstruction
  1136.     docFragment->appendChild(docElements->item(1)->removeChild(docElements->item(9)));
  1137.     docFragment2 = document->createDocumentFragment();
  1138.     //Tests removeChild and stores removed branch for tree reconstruction
  1139.     docFragment2->appendChild(docElements->item(1)->removeChild(docElements->item(2)));
  1140.     docSize = docElements->getLength();
  1141.     for (i = 0; i < docSize; i++)
  1142.     {
  1143.         IDOM_Node*  n = (IDOM_Node*) docElements->item(i);
  1144.         XMLString::transcode(newElementNames[i], tempStr, 3999);
  1145.         if (XMLString::compareString(tempStr, n->getNodeName()))
  1146.         {
  1147.             printf("Comparison of new document's elements failed at element number %d at line %i n", i, __LINE__);
  1148.             OK = false;
  1149.             break;
  1150.         }
  1151.     }
  1152.     docElements->item(1)->insertBefore(docFragment, 0); //Reattaches removed branch to restore tree to the original
  1153.                                                 // AH Revist.  Note: insertBefore should be able to take
  1154.                                                 //   a 0 as its second parameter.
  1155.     docElements->item(1)->insertBefore(docFragment2, docElements->item(2)); //Reattaches removed branch to restore tree to the original
  1157.     //  printf(docElements->item(2)->getNodeName());
  1159.     docSize = docElements->getLength();
  1160.     for (i = 0; i < docSize; i++)
  1161.     {
  1162.         IDOM_Node*  n = (IDOM_Node*) docElements->item(i);
  1163.         XMLString::transcode(elementNames[i], tempStr, 3999);
  1164.         if (XMLString::compareString(tempStr, n->getNodeName()))
  1165.         {
  1166.             printf("Comparison of restored document's elements failed at element number %d at line %i n", i, __LINE__);
  1167.             OK = false;
  1168.             break;
  1169.         }
  1170.     }
  1172.     IDTest tests;
  1175. //  IDOM_Document* z = tests.createDocument();
  1176. //  tests.docBuilder(z, "z");
  1178. //!! Throws WRONG_DOCUMENT_ERR **********
  1179. //  EXCEPTIONSTEST(z->appendChild(
  1180.     //  z->appendChild(d.createComment("Test doc d comment"));// Tries to append z document with document d comment
  1181.     //  d->getDocumentElement()->appendChild(z.createElement("newZdocElement"));// Tries to append d document with document z IDOM_Element
  1182.     //  d->getLastChild()->getLastChild()->insertBefore(z.createElement("newZdocElement"),d->getLastChild()->getLastChild()->getFirstChild());// Tries to insert into d document with document z IDOM_Element
  1183.     //  d->replaceChild(z.createElement("newZdocElement"),d->getLastChild()->getLastChild()->getFirstChild());  // Tries to replace in d document with document z IDOM_Element
  1185.     //  doc->setNodeValue("This shouldn't work");//!! Throws a NO_MODIFICATION_ALLOWED_ERR ********
  1187.     node = document;
  1188.     node2 = document->cloneNode(true);
  1189.     result = treeCompare(node, node2); // Deep clone test comparison of document cloneNode
  1190.     if (!result)
  1191.     {
  1192.         printf("Warning!!! Deep clone of the document failed!n");
  1193.         OK = false;
  1194.     }
  1196.     // Deep clone test comparison is also in testNode
  1199. // For debugging*****       printf("All IDOM_Document* method calls worked correctly.n");
  1200.     if (!OK)
  1201.         printf("n*****The IDOM_Document* method calls listed above failed, all others worked correctly.*****n");
  1202. //  printf("n");
  1203. };
  1207. /**
  1208.  * This method tests IDOM_DocumentFragment* methods for the XML IDOM implementation
  1209.  * @param document org.w3c.dom.IDOM_Document
  1210.  *
  1211.  *
  1212.  *
  1213.  ********This really isn't needed, only exists to throw NO_MODIFICATION_ALLOWED_ERR ********
  1214.  */
  1215. void IDTest::testDocumentFragment(IDOM_Document* document)
  1216. {
  1217.     bool OK = true;
  1218. // For debugging*****   printf("n          testDocumentFragment's outputs:n");
  1219.     IDOM_DocumentFragment* testDocFragment = document->createDocumentFragment();
  1221.     //  testDocFragment->setNodeValue("This is a document fragment!");//!! Throws a NO_MODIFICATION_ALLOWED_ERR ********
  1223. // For debugging*****       printf("All IDOM_DocumentFragment* method calls worked correctly.n");
  1224.     if (!OK)
  1225.         printf("n*****The IDOM_DocumentFragment* method calls listed above failed, all others worked correctly.*****n");
  1226. //  printf("n");
  1227. };
  1231. /**
  1232.  * This method tests IDOM_DocumentType* methods for the XML IDOM implementation
  1233.  * @param document org.w3c.dom.IDOM_Document
  1234.  *
  1235.  */
  1236. void IDTest::testDocumentType(IDOM_Document* document)
  1237. {
  1238.     IDTest test;
  1239.     IDOM_DocumentType* docType, *holdDocType;
  1240.     IDOM_NamedNodeMap* docNotationMap;
  1241.     IDOM_Node* node, *node2;
  1242.     bool OK = true;
  1243. // For debugging*****   printf("n          testDocumentType's outputs:n");
  1244.     XMLString::transcode("TestDocument", tempStr, 3999);
  1245.     IDOM_DocumentType* newDocumentType =  test.createDocumentType(document, tempStr);
  1246.     node = document->getFirstChild(); // node gets doc's docType node
  1247.     node2 = node->cloneNode(true);
  1248.     // Check nodes for equality, both their name and value or lack thereof
  1249.     if (XMLString::compareString(node->getNodeName(), node2->getNodeName()) &&         // Compares node names for equality
  1250.           (node->getNodeValue() != 0 && node2->getNodeValue() != 0)  // Checks to make sure each node has a value node
  1251.         ?  !XMLString::compareString(node->getNodeValue(), node2->getNodeValue())          // If both have value nodes test those value nodes for equality
  1252.         : (node->getNodeValue() == 0 && node2->getNodeValue() == 0))// If one node doesn't have a value node make sure both don't
  1253.     {
  1254.         printf("'cloneNode' did not clone the IDOM_DocumentType* node correctlyn");
  1255.         OK = false;
  1256.     }
  1257.      // Deep clone test comparison is in testNode & testDocument
  1259.     IDOM_Node*   abc9 = document->getFirstChild();
  1260.     docType = (IDOM_DocumentType*) abc9;
  1262.     XMLString::transcode("ourNotationNode", tempStr, 3999);
  1263.     docNotationMap = docType->getNotations();
  1264.     if (XMLString::compareString(tempStr, docNotationMap->item(0)->getNodeName()))
  1265.     {
  1266.         printf("Warning!!! IDOM_DocumentType's 'getNotations' failed!n");
  1267.         OK = false;
  1268.     }
  1269.     //  doc->appendChild(newDocumentTypeImpl);//!! Throws a HIERARCHY_REQUEST_ERR    *******
  1270.     IDOM_Node*  abc10 = document->removeChild(document->getFirstChild()); //Tests removeChild and stores removed branch for tree reconstruction
  1271.     holdDocType = (IDOM_DocumentType*) abc10;
  1272.     document->insertBefore(newDocumentType, document->getDocumentElement());
  1273.     //** Other aspects of insertBefore are tested in docBuilder through appendChild*
  1275.     document->removeChild(document->getFirstChild()); //Removes newDocumentType for tree restoral
  1276.     document->insertBefore(holdDocType, document->getFirstChild()); //Reattaches removed branch to restore tree to the original
  1279. // For debugging*****       printf("All IDOM_DocumentType* method calls worked correctly.n");
  1280.     if (!OK)
  1281.         printf("n*****The IDOM_DocumentType* method calls listed above failed, all others worked correctly.*****n");
  1282. //  printf("");
  1283. };
  1287. /**
  1288.  * @param document org.w3c.dom.IDOM_Document
  1289.  */
  1290. void IDTest::testIDOMerrors(IDOM_Document* document) {
  1291.     bool OK = true;
  1293.     IDTest tests;
  1295.     EXCEPTIONSTEST(document->appendChild(testElementNode), IDOM_DOMException::HIERARCHY_REQUEST_ERR, OK, 201 );
  1296.     EXCEPTIONSTEST(testTextNode->appendChild(testTextNode), IDOM_DOMException::HIERARCHY_REQUEST_ERR, OK, 202 );
  1297. };
  1301. /**
  1302.  * This method tests IDOM_IDOMImplementation methods for the XML IDOM implementation
  1303.  * @param document org.w3c.dom.IDOM_Document
  1304.  *
  1305.  */
  1306. void IDTest::testIDOMImplementation(IDOM_Document* document)
  1307. {
  1309.     IDOM_DOMImplementation* implementation;
  1310.     bool result = false;
  1311.     bool OK = true;
  1312. // For debugging*****   printf("n          testIDOMImplementation's outputs:n");
  1313.     implementation = document->getImplementation(); //Uses getIDOMImplementation to obtain implementation
  1315.     XMLString::transcode("XML", tempStr, 3999);
  1316.     XMLString::transcode("1.0", tempStr2, 3999);
  1317.     result = implementation->hasFeature(tempStr, tempStr2);
  1318.     if(!result)
  1319.     {
  1320.         fprintf(stderr, "Warning!!! IDOM_IDOMImplementation's 'hasFeature' that should be 'true' failed!");
  1321.         OK = false;
  1322.     }
  1324.     XMLString::transcode("HTML", tempStr, 3999);
  1325.     XMLString::transcode("4.0", tempStr2, 3999);
  1326.     result = implementation->hasFeature(tempStr, tempStr2);
  1327.     if(result)
  1328.     {
  1329.         fprintf(stderr, "Warning!!! IDOM_IDOMImplementation's 'hasFeature' that should be 'false' failed!");
  1330.         OK = false;
  1331.     }
  1334. // For debugging*****       printf("All IDOM_IDOMImplementation method calls worked correctly.n");
  1335.     if (!OK)
  1336.         fprintf(stderr, "n*****The IDOM_IDOMImplementation method calls listed above failed, all others worked correctly.*****n");
  1337. //  printf("");
  1338. };
  1342. /**
  1343.  * This method tests IDOM_Element* methods for the XML IDOM implementation
  1344.  * @param document org.w3c.dom.IDOM_Document
  1345.  *
  1346.  */
  1347. void IDTest::testElement(IDOM_Document* document)
  1348. {
  1349.     IDOM_Attr* attributeNode, *newAttributeNode;
  1350.     IDOM_Element* element, *element2;
  1351.     IDOM_Node* node, *node2;
  1353.     const char* attributeCompare[] = {"AnotherFirstElementAttribute", "dFirstElement", "testAttribute"};
  1354.     const char* elementNames[] =  {"dFirstElement", "dTestBody", "dBodyLevel21","dBodyLevel31","dBodyLevel32",
  1355.                    "dBodyLevel22","dBodyLevel33","dBodyLevel34","dBodyLevel23","dBodyLevel24"};
  1356.     const char* textCompare[] = {"dBodyLevel31'sChildTextNode11",
  1357.                                 "dBodyLevel31'sChildTextNode12",
  1358.                                 "dBodyLevel31'sChildTextNode13"};
  1360.     IDOM_NamedNodeMap* nodeMap;
  1361.     bool OK = true;
  1362. // For debugging*****   printf("n          testElement's outputs:n");
  1363.     node = document->getDocumentElement(); // node gets doc's firstElement
  1364.     node2 = node->cloneNode(true);
  1365.     // Check nodes for equality, both their name and value or lack thereof
  1366.     if (XMLString::compareString(node->getNodeName(), node2->getNodeName()) &&         // Compares node names for equality
  1367.          (node->getNodeValue() != 0 && node2->getNodeValue() != 0)  // Checks to make sure each node has a value node
  1368.         ? !XMLString::compareString(node->getNodeValue(), node2->getNodeValue())          // If both have value nodes test those value nodes for equality
  1369.         :(node->getNodeValue() == 0 && node2->getNodeValue() == 0))// If one node doesn't have a value node make sure both don't
  1370.     {
  1371.         fprintf(stderr, "'cloneNode' did not clone the IDOM_Element* node correctly.n");
  1372.         OK = false;
  1373.     }
  1374.     // Deep clone test comparison is in testNode & testDocument
  1376.     element = document->getDocumentElement(); // element gets doc's firstElement
  1378.     XMLString::copyString(tempStr, document->getNodeValue());
  1379.     XMLString::transcode("'s test attribute", tempStr2, 3999);
  1380.     XMLString::catString(tempStr, tempStr2);
  1381.     if (XMLString::compareString(XMLUni::fgZeroLenString, element->getAttribute(tempStr)))
  1382.     {
  1383.         fprintf(stderr, "Warning!!! IDOM_Element's 'getAttribute' failed!n");
  1384.         OK = false;
  1385.     }
  1387.     XMLString::copyString(tempStr, document->getNodeValue());
  1388.     XMLString::transcode("FirstElement", tempStr2, 3999);
  1389.     XMLString::catString(tempStr, tempStr2);
  1390.     attributeNode = element->getAttributeNode(tempStr);
  1391.     if(! (attributeNode == 0))
  1392.     {
  1393.         fprintf(stderr, "Warning!!! IDOM_Element's 'getAttributeNode' failed! It should have returned '0' here!n");
  1394.         OK = false;
  1395.     }
  1398.     XMLString::transcode("AnotherFirstElementAttribute", tempStr, 3999);
  1399.     newAttributeNode = document->createAttribute(tempStr);
  1401.     XMLString::transcode("A new attribute which helps test calls in IDOM_Element", tempStr, 3999);
  1402.     newAttributeNode->setValue(tempStr);
  1403.     // This test is incorrect.  It assumes that there is a defined ordering of the entries
  1404.     //  in a nodeMap, but there is no ordering required.
  1405. #ifdef TheFollowingCheckIsInvalid
  1406.     element->setAttributeNode(newAttributeNode);
  1407.     nodeMap = element->getAttributes();
  1408.     int size = nodeMap->getLength();
  1409.     int k;
  1410.     for (k = 0; k < size; k++)
  1411.     {
  1412.         IDOM_Node*  n = (IDOM_Node) nodeMap->item(k);
  1413.         XMLString::transcode(attributeCompare[k], tempStr, 3999);
  1414.         if (XMLString::compareString(tempStr, n->getNodeName())))
  1415.         {
  1416.             printf("Warning!!! Comparison of firstElement's attributes failed at line %i.n", __LINE__);
  1417.             printf("   This failure can be a result of IDOM_Element's 'setValue' and/or 'setAttributeNode' and/or 'getAttributes' failing.n");
  1418.             OK = false;
  1419.             break;
  1420.         }
  1421.     //  printf("firstElement's attribute number " + k + " : " + n->getNodeName());
  1422.     }
  1423. #endif
  1425.     nodeMap = element->getAttributes();
  1426.     int size = nodeMap->getLength();
  1427.     if (size != 2)
  1428.     {
  1429.         printf("IDOM_Element* Tests Failure 001n");
  1430.         OK = false;
  1431.     };
  1432.     element->setAttributeNode(newAttributeNode);
  1433.     size = nodeMap->getLength();
  1434.     if (size != 3)
  1435.     {
  1436.         printf("IDOM_Element* Tests Failure 002n");
  1437.         OK = false;
  1438.     };
  1440.     // Fetch the newly added attribute node back out of from the named node map,
  1441.     //  and check that we are returned the same node that we put in->
  1442.     XMLString::transcode("AnotherFirstElementAttribute", tempStr, 3999);
  1443.     IDOM_Node*  abc12 = nodeMap->getNamedItem(tempStr);
  1444.     IDOM_Attr* fetchedAttr = (IDOM_Attr*) abc12;
  1445.     if (fetchedAttr != newAttributeNode)
  1446.     {
  1447.         printf("IDOM_Element* Tests Failure 003n");
  1448.         OK = false;
  1449.     };
  1451.     // Fetch the newly added attribute back out directly from the element itself.
  1452.     XMLString::transcode("AnotherFirstElementAttribute", tempStr, 3999);
  1453.     fetchedAttr = element->getAttributeNode(tempStr);
  1454.     if (fetchedAttr != newAttributeNode)
  1455.     {
  1456.         printf("IDOM_Element* Tests Failure 004n");
  1457.         OK = false;
  1458.     };
  1462.     XMLString::transcode("*",tempStr, 3999);
  1463.     IDOM_NodeList* docElements = document->getElementsByTagName(tempStr);
  1464.     int docSize = docElements->getLength();
  1465.     int i;
  1466.     for (i = 0; i < docSize; i++)
  1467.     {
  1468.         IDOM_Node*  n = docElements->item(i);
  1469.         XMLString::transcode(elementNames[i], tempStr, 3999);
  1470.         if (XMLString::compareString(tempStr, n->getNodeName()))
  1471.         {
  1472.             printf("Warning!!! Comparison of IDOM_Element's 'getElementsByTagName' "
  1473.                             "and/or 'item' failed at element number %d at line %i n", i, __LINE__ );
  1474.             printf("n");
  1475.             OK = false;
  1476.             break;
  1477.         }
  1478.     //  printf("docElement's number " + i + " is: " + n->getNodeName());
  1479.     }
  1480.     XMLString::transcode("dBodyLevel21", tempStr, 3999);
  1481.     IDOM_Node*  abc15 = document->getElementsByTagName(tempStr)->item(0); // element gets IDOM_Element* test BodyLevel21
  1482.     element = (IDOM_Element*) abc15;
  1484.     XMLString::transcode("dBodyLevel31", tempStr, 3999);
  1485.     IDOM_Node*  abc16 = document->getElementsByTagName(tempStr)->item(0); // element2 gets IDOM_Element* test BodyLevel31
  1486.     element2 = (IDOM_Element*) abc16;
  1487.     IDOM_NodeList* text = ((IDOM_Node*  &) element2)->getChildNodes();
  1488.     int textSize = text->getLength();
  1489.     int j;
  1490.     static bool firstTime = true;
  1491.     if (firstTime)
  1492.     {
  1493.         firstTime = false;      // Temporary fix.  Subsequent tests alter the doc, causing
  1494.                                 //   this test to fail on all but the first time through.
  1495.         for (j = 0; j < textSize; j++)
  1496.         {
  1497.             IDOM_Node*  n = text->item(j);
  1498.             XMLString::transcode(textCompare[j], tempStr, 3999);
  1499.             if (XMLString::compareString(tempStr, n->getNodeValue()))
  1500.             {
  1501.                 printf("Warning!!! Comparison of original text nodes via IDOM_Node*  'getChildNodes' & IDOM_NodeList 'item'n"
  1502.                     "     failed at text node: #%d at line %i n     ", j, __LINE__ );
  1503.                 OK = false;
  1504.                 break;
  1505.             }
  1506.             //  printf("IDOM_Element* testBodyLevel31's child text node " + j + " is: " + n->getNodeValue());
  1507.         }
  1508.     }
  1510.     element = document->getDocumentElement(); // element gets doc's firstElement
  1511.     element->normalize();        // Concatenates all adjacent text nodes in this element's subtree
  1512.     IDOM_NodeList* text2 = ((IDOM_Node*) element2)->getChildNodes();
  1513.     XMLString::transcode("dBodyLevel31'sChildTextNode11dBodyLevel31'sChildTextNode12dBodyLevel31'sChildTextNode13", tempStr, 3999);
  1514.     IDOM_Node*  n = text2->item(0);
  1515.     if (XMLString::compareString(tempStr, n->getNodeValue()))
  1516.     {
  1517.         printf("Warning!!! Comparison of concatenated text nodes created by IDOM_Element's 'normalize' failed!n");
  1518.         OK = false;
  1519.     }
  1521.     XMLString::transcode("FirstElementLastAttribute", tempStr, 3999);
  1522.     XMLString::transcode("More attribute stuff for firstElement!!", tempStr2, 3999);
  1523.     element->setAttribute(tempStr, tempStr2);
  1525.     XMLString::transcode("FirstElementLastAttribute", tempStr, 3999);
  1526.     element->removeAttribute(tempStr);
  1527.     element->removeAttributeNode(newAttributeNode);
  1529.     //  doc->getLastChild()->setNodeValue("This shouldn't work");//!! Throws a NO_MODIFICATION_ALLOWED_ERR***
  1531. // For debugging*****       printf("All IDOM_Element* method calls worked correctly.n");
  1532.     if (!OK)
  1533.         printf("n*****The IDOM_Element* method calls listed above failed, all others worked correctly.*****n");
  1534. //  printf("");
  1536. };
  1540. /**
  1541.  * This method tests IDOM_Entity* methods for the XML IDOM implementation
  1542.  * @param document org.w3c.dom.IDOM_Document
  1543.  *
  1544.  */
  1545. void IDTest::testEntity(IDOM_Document* document)
  1546. {
  1547.     IDOM_Entity* entity;
  1548.     IDOM_Node* node, *node2;
  1549.     bool OK = true;
  1550. // For debugging*****   printf("n          testEntity's outputs:nn");
  1551.     XMLString::transcode("ourEntityNode", tempStr, 3999);
  1552.     IDOM_Node*  abc20 = document->getDoctype()->getEntities()->getNamedItem(tempStr);
  1553.     entity = (IDOM_Entity*) abc20;
  1554.     node = entity;
  1555.     node2 = entity->cloneNode(true);
  1556.     // Check nodes for equality, both their name and value or lack thereof
  1557.     if (XMLString::compareString(node->getNodeName(), node2->getNodeName()) &&         // Compares node names for equality
  1558.             ((node->getNodeValue() != 0 && node2->getNodeValue() != 0) ?    // Checks to make sure each node has a value node
  1559.                !XMLString::compareString(node->getNodeValue(), node2->getNodeValue()) :       // If both have value nodes test those value nodes for equality
  1560.                (node->getNodeValue() == 0 && node2->getNodeValue() == 0))) // If one node doesn't have a value node make sure both don't
  1561.     {
  1562.         printf("Warning!!! 'cloneNode' did not clone the IDOM_Entity* node correctly");
  1563.         OK = false;
  1564.     }
  1565.     // Deep clone test comparison is in testNode & testDocument
  1567. // For debugging*****       printf("All IDOM_Entity* method calls worked correctly.n");
  1568.     if (!OK)
  1569.         printf("n*****The IDOM_Entity* method calls listed above failed, all others worked correctly.*****n");
  1570. //  printf("");
  1571. };
  1574. /**
  1575.  * This method tests IDOM_EntityReference* methods for the XML IDOM implementation
  1576.  * @param document org.w3c.dom.IDOM_Document
  1577.  *
  1578.  */
  1579. void IDTest::testEntityReference(IDOM_Document* document)
  1580. {
  1581.     IDOM_EntityReference* entityReference;
  1582.     IDOM_Node* node, *node2;
  1583.     bool OK = true;
  1584. // For debugging*****   printf("n          testEntityReference's outputs:n");
  1585.     IDOM_Node*  abc30 = document->getLastChild()->getLastChild()->getLastChild()->getFirstChild();
  1586.     entityReference = (IDOM_EntityReference*) abc30;
  1587.     node = entityReference;
  1588.     node2 = node->cloneNode(true);
  1589.     // Check nodes for equality, both their name and value or lack thereof
  1590.     if (XMLString::compareString(node->getNodeName(), node2->getNodeName()) &&         // Compares node names for equality
  1591.          (node->getNodeValue() != 0 && node2->getNodeValue() != 0)  // Checks to make sure each node has a value node
  1592.         ? !XMLString::compareString(node->getNodeValue(), node2->getNodeValue())          // If both have value nodes test those value nodes for equality
  1593.         :(node->getNodeValue() == 0 && node2->getNodeValue() == 0))// If one node doesn't have a value node make sure both don't
  1594.     {
  1595.         printf("'cloneNode' did not clone the IDOM_EntityReference* node correctlyn");
  1596.         OK = false;
  1597.     }
  1598.     // Deep clone test comparison is in testNode & testDocument
  1600.     //  entityReference->setNodeValue("This shouldn't work");//!! Throws a NO_MODIFICATION_ALLOWED_ERR ********
  1602. // For debugging*****       printf("All IDOM_EntityReference* method calls worked correctly.n");
  1603.     if (!OK)
  1604.         printf("n*****The IDOM_EntityReference* method calls listed above failed, all others worked correctly.*****n");
  1605. //  printf("n");
  1606. };
  1610. /**
  1611.  * This method tests IDOM_Node*  methods for the XML IDOM implementation
  1612.  * @param document org.w3c.dom.IDOM_Document
  1613.  *
  1614.  *
  1615.  *
  1616.  ********* This is only for a test of cloneNode "deep"*******
  1617.  ********* And for error tests*********
  1618.  */
  1619. void IDTest::testNode(IDOM_Document* document)
  1620. {
  1621.     IDOM_Node* node, *node2;
  1622.     bool result;
  1623.     bool OK = true;
  1624. // For debugging*****   printf("n          testNode's outputs:n");
  1625.     node = document->getDocumentElement();
  1626.     node2 = node->cloneNode(true);
  1627.     result = treeCompare(node, node2); // Deep clone test of cloneNode
  1628.     if (result)
  1629.     {
  1630.         //printf("'cloneNode' successfully cloned this whole node tree (deep)!n");
  1631.     }
  1632.     else
  1633.     {
  1634.         printf("'cloneNode' did not successfully clone this whole node tree (deep)!n");
  1635.         OK = false;
  1636.     }
  1637.     //!! The following gives a did not clone successfully message*********
  1638.     node = document->getDocumentElement();
  1639.     node2 = node->getFirstChild();
  1640.     result = treeCompare(node, node2);
  1641.     if (!result)
  1642.     {
  1643.         //printf("'cloneNode' did not successfully clone this whole node tree (deep)!n");
  1644.     }
  1645.     else
  1646.     {
  1647.         printf("'cloneNode' was supposed to fail here, either it or 'treeCompare' failed!!!n");
  1648.         OK = false;
  1649.     }
  1650.     // Deep clone test also in testDocument
  1652. // For debugging*****       printf("All IDOM_Node*  method calls worked correctly.n");
  1653.     if (!OK)
  1654.         printf("n*****The IDOM_Node*  method calls listed above failed, all others worked correctly.*****n");
  1655. //  printf("n");
  1656. };
  1660. /**
  1661.  * This method tests IDOM_Notation* methods for the XML IDOM implementation
  1662.  * @param document org.w3c.dom.IDOM_Document
  1663.  *
  1664.  */
  1665. void IDTest::testNotation(IDOM_Document* document)
  1666. {
  1667.     IDOM_Node* node, *node2;
  1668.     IDOM_Notation* notation;
  1669.     bool OK = true;
  1670. // For debugging*****   printf("n          testNotation's outputs:n");
  1671.     XMLString::transcode("ourNotationNode", tempStr, 3999);
  1672. IDOM_Node*  abc40 = document->getDoctype()->getNotations()->getNamedItem(tempStr);
  1673.     notation = (IDOM_Notation*) abc40;
  1674.     node = notation;
  1675.     node2 = notation->cloneNode(true);//*****?
  1676.     // Check nodes for equality, both their name and value or lack thereof
  1677.     if (XMLString::compareString(node->getNodeName(), node2->getNodeName()) &&         // Compares node names for equality
  1678.          (node->getNodeValue() != 0 && node2->getNodeValue() != 0)  // Checks to make sure each node has a value node
  1679.         ? !XMLString::compareString(node->getNodeValue(), node2->getNodeValue())          // If both have value nodes test those value nodes for equality
  1680.         :(node->getNodeValue() == 0 && node2->getNodeValue() == 0))// If one node doesn't have a value node make sure both don't
  1681.     {
  1682.         printf("'cloneNode' did not clone the IDOM_Notation* node correctly");
  1683.         OK = false;
  1684.     }
  1685.     // Deep clone test comparison is in testNode & testDocument
  1687.     //  notation->setNodeValue("This shouldn't work");//!! Throws a NO_MODIFICATION_ALLOWED_ERR ********
  1689. // For debugging*****       printf("All IDOM_Notation* method calls worked correctly.n");
  1690.     if (!OK)
  1691.         printf("n*****The IDOM_Notation* method calls listed above failed, all others worked correctly.*****n");
  1692. //  printf("");
  1693. };
  1697. /**
  1698.  * This method tests IDOM_ProcessingInstruction* methods for the XML IDOM implementation
  1699.  * @param document org.w3c.dom.IDOM_Document
  1700.  *
  1701.  */
  1702. void IDTest::testPI(IDOM_Document* document)
  1703. {
  1704.     IDOM_ProcessingInstruction* pI, *pI2;
  1705.     bool OK = true;
  1706. // For debugging*****   printf("n          testPI's outputs:n");
  1707. IDOM_Node*   abc50 = document->getDocumentElement()->getFirstChild();// Get doc's IDOM_ProcessingInstruction
  1708.     pI  = (IDOM_ProcessingInstruction*) abc50;
  1709. IDOM_Node*   abc51 = pI->cloneNode(true);//*****?
  1710.     pI2 = (IDOM_ProcessingInstruction*) abc51;
  1711.     // Check nodes for equality, both their name and value or lack thereof
  1712.     if (XMLString::compareString(pI->getNodeName(), pI2->getNodeName()) &&         // Compares node names for equality
  1713.          (pI->getNodeValue() != 0 && pI2->getNodeValue() != 0)  // Checks to make sure each node has a value node
  1714.         ? !XMLString::compareString(pI->getNodeValue(), pI2->getNodeValue())      // If both have value nodes test those value nodes for equality
  1715.         :(pI->getNodeValue() == 0 && pI2->getNodeValue() == 0))// If one node doesn't have a value node make sure both don't
  1716.     {
  1717.         printf("'cloneNode' did not clone the IDOM_Entity* node correctlyn");
  1718.         OK = false;
  1719.     }
  1720.     // Deep clone test comparison is in testNode & testDocument
  1721.     // compare = "This is [#document: 0]'s processing instruction";  // AH Revisit.  Where id
  1722.     //                  this ": 0]" stuff come from in the Java version??  I don' think that it is right.
  1723.     XMLString::transcode("This is #document's processing instruction", tempStr, 3999);
  1724.     if (XMLString::compareString(tempStr, pI->getData()))
  1725.     {
  1726.         printf("Warning!!! PI's 'getData' failed!n");
  1727.         OK = false;
  1728.     }
  1730.     XMLString::transcode("PI's reset data", tempStr, 3999);
  1731.     pI->setData(tempStr);
  1732.     if (XMLString::compareString(tempStr, pI->getData()))
  1733.     {
  1734.         printf("Warning!!! PI's 'setData' failed!n");
  1735.         OK = false;
  1736.     }
  1737.     XMLString::transcode("dTargetProcessorChannel", tempStr, 3999);
  1738.     if (XMLString::compareString(tempStr, pI->getTarget()))
  1739.     {
  1740.         printf("Warning!!! PI's 'getTarget' failed!n");
  1741.         OK = false;
  1742.     }
  1745.     // Restore original PI data.
  1746.     XMLString::transcode("This is #document's processing instruction", tempStr, 3999);
  1747.     pI->setData(tempStr);
  1749. // For debugging*****       printf("All PI method calls worked correctly.n");
  1750.     if (!OK)
  1751.         printf("n*****The PI method calls listed above failed, all others worked correctly.*****n");
  1753. //  printf("n");
  1754. };
  1758. /**
  1759.  * This method tests IDOM_Text* methods for the XML IDOM implementation
  1760.  * @param document org.w3c.dom.IDOM_Document
  1761.  *
  1762.  */
  1763. void IDTest::testText(IDOM_Document* document)
  1764. {
  1765.     IDOM_Node* node, *node2;
  1766.     IDOM_Text* text;
  1767.     bool OK = true;
  1768. // For debugging*****   printf("n          testText's outputs:n");
  1769.     XMLString::transcode("dBodyLevel31", tempStr, 3999);
  1770.     IDOM_Node*  abc70 = document->getDocumentElement()->getElementsByTagName(tempStr)->item(0);
  1771.     IDOM_Element* elem = (IDOM_Element*) abc70;
  1772.     node = elem->getFirstChild(); // charData gets textNode11
  1773.     text = (IDOM_Text*) node;
  1774.     node2 = node->cloneNode(true);//*****?
  1775.     // Check nodes for equality, both their name and value or lack thereof
  1776.     if (XMLString::compareString(node->getNodeName(), node2->getNodeName()) &&         // Compares node names for equality
  1777.          (node->getNodeValue() != 0 && node2->getNodeValue() != 0)  // Checks to make sure each node has a value node
  1778.         ? !XMLString::compareString(node->getNodeValue(), node2->getNodeValue())          // If both have value nodes test those value nodes for equality
  1779.         :(node->getNodeValue() == 0 && node2->getNodeValue() == 0))// If one node doesn't have a value node make sure both don't
  1780.     {
  1781.         printf("'cloneNode' did not clone the IDOM_Text* node correctlyn");
  1782.         OK = false;
  1783.     }
  1784.     // Deep clone test comparison is in testNode & testDocument
  1786.     text->splitText(25);
  1787.     // Three original text nodes were concatenated by 'normalize' in testElement
  1788.     XMLString::transcode("dBodyLevel31'sChildTextNo", tempStr, 3999);
  1789.     if (XMLString::compareString(tempStr, text->getNodeValue()))
  1790.         {
  1791.             printf("First part of IDOM_Text's split text failed!n" );
  1792.             OK = false;
  1793.         }
  1794.     // Three original text nodes were concatenated by 'normalize' in testElement
  1795.     XMLString::transcode("de11dBodyLevel31'sChildTextNode12dBodyLevel31'sChildTextNode13", tempStr, 3999);
  1796.     if (XMLString::compareString(tempStr, text->getNextSibling()->getNodeValue()))
  1797.         {
  1798.             printf("The second part of IDOM_Text's split text failed!n") ;
  1799.             OK = false;
  1800.         }
  1802.     // Re-normalize the text nodes under elem, so that this test can be rerun->
  1803.     elem->normalize();
  1806. //************************************************* ERROR TESTS
  1807.     IDTest tests;
  1808.     //!! Throws INDEX_SIZE_ERR ********************
  1809.     //  text.splitText(-1);
  1810.     //  text.splitText(100);
  1812. // For debugging*****       printf("All IDOM_Text* method calls worked correctly.n");
  1813.     if (!OK)
  1814.         printf("n*****The IDOM_Text* method calls listed above failed, all others worked correctly.*****n");
  1816. //  printf("n");
  1817. };
  1822. /**
  1823.  *
  1824.  * @param node org.w3c.dom.IDOM_Node
  1825.  * @param node2 org.w3c.dom.IDOM_Node
  1826.  *
  1827.  */
  1828. bool IDTest::treeCompare(IDOM_Node* node, IDOM_Node* node2)
  1829. {
  1830.     bool answer = true;
  1832.     IDOM_Node*  kid, *kid2;         // Check the subtree for equality
  1833.     kid = node->getFirstChild();
  1834.     kid2 = node2->getFirstChild();
  1835.     if (!kid && !kid2)
  1836.     {
  1837.         answer = treeCompare(kid, kid2);
  1838.         if (!answer)
  1839.             return answer;
  1840.         else
  1841.             if (!kid->getNextSibling() && !kid2->getNextSibling())
  1842.             {
  1843.                 while (!kid->getNextSibling() && !kid2->getNextSibling())
  1844.                 {
  1845.                     answer = treeCompare(kid->getNextSibling(), kid2->getNextSibling());
  1846.                     if (!answer)
  1847.                         return answer;
  1848.                     else
  1849.                     {
  1850.                         kid = kid->getNextSibling();
  1851.                         kid2 = kid2->getNextSibling();
  1852.                     }
  1853.                 }
  1854.             } else
  1855.                 if (!(kid->getNextSibling() && kid2->getNextSibling()))
  1856.                 {
  1857.                     return false;
  1858.                 }
  1859.     } else
  1860.         if (kid != kid2)
  1861.         {
  1862.             // One or the other of (kid1, kid2) is 0, but not both.
  1863.             return false;
  1864.         }
  1866.     if (XMLString::compareString(node->getNodeName(), node2->getNodeName()))
  1867.         return false;
  1868.     if (node->getNodeValue()==0 && node2->getNodeValue()!=0)
  1869.         return false;
  1870.     if (node->getNodeValue()!=0 && node2->getNodeValue()==0)
  1871.         return false;
  1872.     if (XMLString::compareString(node->getNodeValue(), node2->getNodeValue()))
  1873.         return false;
  1875.     return answer;
  1876. };