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

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

xml/soap/webservice

开发平台：

C/C++

ITraversal.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. //  Various IDOM tests.
  59. //     Contents include
  60. //       1.  NodeIterator tests
  61. //       2.  Tree Walker tests
  62. //     All individual are wrapped in a memory leak checker.
  63. //
  64. //     This is NOT a complete test of DOM functionality.
  65. //
  67. /**
  68.  * $Log: ITraversal.cpp,v $
  69.  * Revision 1.4  2001/11/23 16:18:54  tng
  70.  * Elimiate compiler warning: Warning: String literal converted to char* in formal argument file in call to tassert(bool, char*, int).
  71.  *
  72.  * Revision 1.3  2001/07/19 20:45:16  tng
  73.  * Add some test cases in the tests folder to sanityTest.pl
  74.  *
  75.  * Revision 1.2  2001/06/05 11:58:31  tng
  76.  * Delete the document at the end for clearing the memory.
  77.  *
  78.  * Revision 1.1  2001/06/04 20:11:55  tng
  79.  * IDOM: Complete IDNodeIterator, IDTreeWalker, IDNodeFilter.
  80.  *
  81.  *
  83.  */
  85. #include <stdio.h>
  86. #include <string.h>
  87. #include <idom/IDOM.hpp>
  88. #include <util/PlatformUtils.hpp>
  89. #include <util/XMLException.hpp>
  90. #include <util/XMLString.hpp>
  91. #include <util/XMLUniDefs.hpp>
  94. #define TASSERT(c) tassert((c), __FILE__, __LINE__)
  96. void tassert(bool c, const char *file, int line)
  97. {
  98.     if (!c)
  99.         printf("Failure.  Line %d,   file %sn", line, file);
  100. };
  103. #define EXCEPTION_TEST(operation, expected_exception)               
  104. {                                                                   
  105.     try {                                                           
  106.     operation;                                                      
  107.     printf(" Error: no exception thrown at line %dn", __LINE__);   
  108. }                                                                   
  109.     catch (IDOM_DOMException &e) {                                       
  110.     if (e.code != expected_exception)                       
  111.     printf(" Wrong exception code: %d at line %dn", e.code, __LINE__); 
  112. }                                                                 
  113.     catch (...)   {                                                 
  114.     printf(" Wrong exception thrown at line %dn", __LINE__);       
  115. }                                                                   
  116. }
  118. class  MyFilter : public IDOM_NodeFilter {
  119. public:
  121.   MyFilter(short nodeType, bool reject=false) : IDOM_NodeFilter(), fNodeType(nodeType), fReject(reject) {};
  122.   virtual short acceptNode(const IDOM_Node* node) const;
  123. private:
  124.     short fNodeType;
  125.     bool fReject;
  126. };
  127. /*
  128.         Node Types can be of the following:
  129.         ELEMENT_NODE         = 1,
  130.         ATTRIBUTE_NODE       = 2,
  131.         TEXT_NODE            = 3,
  132.         CDATA_SECTION_NODE   = 4,
  133.         ENTITY_REFERENCE_NODE = 5,
  134.         ENTITY_NODE          = 6,
  135.         PROCESSING_INSTRUCTION_NODE = 7,
  136.         COMMENT_NODE         = 8,
  137.         DOCUMENT_NODE        = 9,
  138.         DOCUMENT_TYPE_NODE   = 10,
  139.         DOCUMENT_FRAGMENT_NODE = 11,
  140.         NOTATION_NODE        = 12
  141. */
  142. short  MyFilter::acceptNode(const IDOM_Node* node) const {
  143.     if (fNodeType == 0)
  144.         return  IDOM_NodeFilter::FILTER_ACCEPT;
  145. if (node->getNodeType() ==  fNodeType) {
  146.         return  IDOM_NodeFilter::FILTER_ACCEPT;
  147. } else {
  148.     return  fReject ? IDOM_NodeFilter::FILTER_REJECT : IDOM_NodeFilter::FILTER_SKIP;
  149. }
  150. }
  154. int  main()
  155. {
  156. try {
  157. XMLPlatformUtils::Initialize();
  158. }
  159. catch (const XMLException& toCatch) {
  160.         char *pMessage = XMLString::transcode(toCatch.getMessage());
  161.         fprintf(stderr, "Error during XMLPlatformUtils::Initialize(). n"
  162.                         "  Message is: %sn", pMessage);
  163.         delete [] pMessage;
  164.         return -1;
  165.     }
  167.     // Create a XMLCh buffer for string manipulation
  168.     XMLCh tempStr[4000];
  171.     //
  172.     //  Doc - Create a small document tree
  173.     //
  175.     {
  176.         //creating a DOM Tree
  177.          /* Tests are based on the tree structure below
  178.            doc - root - E11 (attr01) - textNode1
  179.                                      - E111
  180.                                      - E112
  181.                                      - cdataSec
  182.                       - E12 (attr02) - textNode2
  183.                                      - E121
  184.                                      - E122
  185.                       - E13          - E131
  186.                                      - docPI
  187.                       - comment
  188.          */
  190.         IDOM_DOMImplementation* impl = IDOM_DOMImplementation::getImplementation();
  191.         IDOM_Document* doc = impl->createDocument();
  193.         //Creating a root element
  194.         XMLString::transcode("RootElement", tempStr, 3999);
  195.         IDOM_Element*     root = doc->createElement(tempStr);
  196.         doc->appendChild(root);
  198.         //Creating the siblings of root
  199.         XMLString::transcode("FirstSibling", tempStr, 3999);
  200.         IDOM_Element*     E11 = doc->createElement(tempStr);
  201.         root->appendChild(E11);
  203.         XMLString::transcode("SecondSibling", tempStr, 3999);
  204.         IDOM_Element*     E12 = doc->createElement(tempStr);
  205.         root->appendChild(E12);
  207.         XMLString::transcode("ThirdSibling", tempStr, 3999);
  208.         IDOM_Element*     E13 = doc->createElement(tempStr);
  209.         root->appendChild(E13);
  211.         //Attaching texts to few siblings
  212.         XMLString::transcode("Text1", tempStr, 3999);
  213.         IDOM_Text*        textNode1 = doc->createTextNode(tempStr);
  214.         E11->appendChild(textNode1);
  216.         XMLString::transcode("Text2", tempStr, 3999);
  217.         IDOM_Text*        textNode2 = doc->createTextNode(tempStr);
  218.         E12->appendChild(textNode2);
  220.         //creating child of siblings
  221.         XMLString::transcode("FirstSiblingChild1", tempStr, 3999);
  222.         IDOM_Element*     E111 = doc->createElement(tempStr);
  223.         E11->appendChild(E111);
  225.         XMLString::transcode("Attr01", tempStr, 3999);
  226.         IDOM_Attr*        attr01  = doc->createAttribute(tempStr);
  227.         E11->setAttributeNode(attr01);
  229.         XMLString::transcode("FirstSiblingChild2", tempStr, 3999);
  230.         IDOM_Element*     E112 = doc->createElement(tempStr);
  231.         E11->appendChild(E112);
  233.         XMLString::transcode("SecondSiblingChild1", tempStr, 3999);
  234.         IDOM_Element*     E121 = doc->createElement(tempStr);
  235.         E12->appendChild(E121);
  237.         XMLString::transcode("Attr01", tempStr, 3999);
  238.         IDOM_Attr* attr02 = doc->createAttribute(tempStr);
  239.         E12->setAttributeNode(attr02);
  241.         XMLString::transcode("SecondSiblingChild2", tempStr, 3999);
  242.         IDOM_Element*     E122 = doc->createElement(tempStr);
  243.         E12->appendChild(E122);
  245.         XMLString::transcode("ThirdSiblingChild1", tempStr, 3999);
  246.         IDOM_Element*     E131 = doc->createElement(tempStr);
  247.         E13->appendChild(E131);
  249.         XMLString::transcode("DocComment", tempStr, 3999);
  250.         IDOM_Comment* comment = doc->createComment(tempStr);
  251.         root->appendChild(comment);
  253.         XMLString::transcode("DocCDataSection", tempStr, 3999);
  254.         IDOM_CDATASection*  cdataSec = doc->createCDATASection(tempStr);
  255.         E11->appendChild(cdataSec);
  257.         XMLString::transcode("DocPI", tempStr, 3999);
  258.         XMLCh piStr[] = {chLatin_D, chLatin_o, chLatin_c, chLatin_P, chLatin_I, chNull};
  259.         IDOM_ProcessingInstruction*  docPI = doc->createProcessingInstruction(piStr, tempStr);
  260.         E13->appendChild(docPI);
  263.         /*
  264.         following are whatToShow types:
  265.             SHOW_ALL                       = 0x0000FFFF,
  266.             SHOW_ELEMENT                   = 0x00000001,
  267.             SHOW_ATTRIBUTE                 = 0x00000002,
  268.             SHOW_TEXT                      = 0x00000004,
  269.             SHOW_CDATA_SECTION             = 0x00000008,
  270.             SHOW_ENTITY_REFERENCE          = 0x00000010,
  271.             SHOW_ENTITY                    = 0x00000020,
  272.             SHOW_PROCESSING_INSTRUCTION    = 0x00000040,
  273.             SHOW_COMMENT                   = 0x00000080,
  274.             SHOW_DOCUMENT                  = 0x00000100,
  275.             SHOW_DOCUMENT_TYPE             = 0x00000200,
  276.             SHOW_DOCUMENT_FRAGMENT         = 0x00000400,
  277.             SHOW_NOTATION                  = 0x00000800
  278.         */
  280.         ////////// NodeIterator Test Cases ////////////////
  283.         {
  284.             // all node iterating test
  286.             IDOM_Node*    node = doc->getFirstChild();
  287.             unsigned long       whatToShow = IDOM_NodeFilter::SHOW_ALL;
  288.             MyFilter* filter = new MyFilter(0);
  290.             IDOM_NodeIterator*  iter = doc->createNodeIterator(root, whatToShow,  filter, true);
  291.             TASSERT(iter->getWhatToShow() == 65535);
  292.             TASSERT(iter->getExpandEntityReferences() == 1);
  294.             IDOM_Node*  nd;
  295.             nd = iter->nextNode();
  296.             TASSERT (nd ==root);
  297.             nd = iter->nextNode();
  298.             TASSERT (nd ==E11);
  299.             nd = iter->nextNode();
  300.             TASSERT(nd == textNode1);
  301.             nd = iter->nextNode();
  302.             TASSERT(nd == E111);
  303.             nd = iter->nextNode();
  304.             TASSERT(nd == E112);
  305.             nd = iter->nextNode();
  306.             TASSERT(nd == cdataSec);
  307.             nd = iter->nextNode();
  308.             TASSERT(nd == E12);
  309.             nd = iter->nextNode();
  310.             TASSERT(nd == textNode2);
  311.             nd = iter->nextNode();
  312.             TASSERT(nd == E121);
  313.             nd = iter->nextNode();
  314.             TASSERT(nd == E122);
  315.             nd = iter->nextNode();
  316.             TASSERT(nd == E13);
  317.             nd = iter->nextNode();
  318.             TASSERT(nd == E131);
  319.             nd = iter->nextNode();
  320.             TASSERT(nd == docPI);
  321.             nd = iter->nextNode();
  322.             TASSERT(nd == comment);
  323.             nd = iter->previousNode();
  324.             TASSERT(nd == comment);
  325.             nd = iter->previousNode();
  326.             TASSERT(nd == docPI);
  327.             nd = iter->previousNode();
  328.             TASSERT(nd == E131);
  330.         }
  334.         {
  335.             //element node iterating test
  337.             IDOM_Node*    node = doc->getFirstChild();
  338.             unsigned long       whatToShow = IDOM_NodeFilter::SHOW_ELEMENT;
  339.             MyFilter* filter = new MyFilter(IDOM_Node::ELEMENT_NODE);
  341.             IDOM_NodeIterator*  iter = doc->createNodeIterator(root, whatToShow,  filter, true);
  342.             TASSERT(iter->getWhatToShow() == 1);
  343.             TASSERT(iter->getExpandEntityReferences() == 1);
  345.             IDOM_Node*  nd;
  346.             nd = iter->nextNode();
  347.             TASSERT (nd ==root);
  348.             nd = iter->nextNode();
  349.             TASSERT (nd ==E11);
  350.             nd = iter->nextNode();
  351.             TASSERT(nd == E111);
  352.             nd = iter->nextNode();
  353.             TASSERT(nd == E112);
  354.             nd = iter->nextNode();
  355.             TASSERT(nd == E12);
  356.             nd = iter->nextNode();
  357.             TASSERT(nd == E121);
  358.             nd = iter->nextNode();
  359.             TASSERT(nd == E122);
  360.             nd = iter->nextNode();
  361.             TASSERT(nd == E13);
  362.             nd = iter->nextNode();
  363.             TASSERT(nd == E131);
  364.             nd = iter->previousNode();
  365.             TASSERT(nd == E131);
  366.             nd = iter->previousNode();
  367.             TASSERT(nd == E13);
  368.             nd = iter->previousNode();
  369.             TASSERT(nd == E122);
  370.         }
  376.         {
  377.             // Text node iterating test
  379.             IDOM_Node*    node = doc->getFirstChild();
  380.             unsigned long       whatToShow = IDOM_NodeFilter::SHOW_TEXT;
  381.             MyFilter* filter = new MyFilter(IDOM_Node::TEXT_NODE);
  383.             IDOM_NodeIterator*  iter = doc->createNodeIterator(root, whatToShow,  filter, true);
  385.             TASSERT(iter->getWhatToShow() == 4);
  386.             TASSERT(iter->getExpandEntityReferences() == 1);
  388.             IDOM_Node*  nd;
  389.             nd = iter->nextNode();
  390.             TASSERT (nd ==textNode1);
  391.             nd = iter->nextNode();
  392.             TASSERT (nd ==textNode2);
  393.             nd = iter->previousNode();
  394.             TASSERT(nd == textNode2);
  396.         }
  399.         {
  400.             //CDataSection node itearating test
  402.             IDOM_Node*    node = doc->getFirstChild();
  403.             unsigned long       whatToShow = IDOM_NodeFilter::SHOW_CDATA_SECTION;
  404.             MyFilter* filter = new MyFilter(IDOM_Node::CDATA_SECTION_NODE);
  406.             IDOM_NodeIterator*  iter = doc->createNodeIterator(root, whatToShow,  filter, true);
  407.             TASSERT(iter->getWhatToShow() == 8);
  408.             TASSERT(iter->getExpandEntityReferences() == 1);
  410.             IDOM_Node*  nd;
  411.             nd = iter->nextNode();
  412.             TASSERT(nd == cdataSec);
  413.             nd = iter->nextNode();
  414.             TASSERT(nd == 0);
  416.         }
  419.         {
  420.             // PI nodes iterating test
  422.             IDOM_Node*    node = doc->getFirstChild();
  423.             unsigned long       whatToShow = IDOM_NodeFilter::SHOW_PROCESSING_INSTRUCTION;
  424.             MyFilter* filter = new MyFilter(IDOM_Node::PROCESSING_INSTRUCTION_NODE);
  426.             IDOM_NodeIterator*  iter = doc->createNodeIterator(root, whatToShow,  filter, true);
  427.             TASSERT(iter->getWhatToShow() == 64);
  428.             TASSERT(iter->getExpandEntityReferences() == 1);
  430.             IDOM_Node*  nd;
  431.             nd = iter->nextNode();
  432.             TASSERT(nd == docPI);
  433.             nd = iter->nextNode();
  434.             TASSERT(nd == 0);
  437.         }
  441.         {
  442.             IDOM_Node*    node = doc->getFirstChild();
  443.             unsigned long       whatToShow = IDOM_NodeFilter::SHOW_COMMENT;
  444.             MyFilter* filter = new MyFilter(IDOM_Node::COMMENT_NODE);
  446.             IDOM_NodeIterator*  iter = doc->createNodeIterator(root, whatToShow,  filter, true);
  447.             TASSERT(iter->getWhatToShow() == 128);
  448.             TASSERT(iter->getExpandEntityReferences() == 1);
  450.             IDOM_Node*  nd;
  451.             nd = iter->nextNode();
  452.             TASSERT(nd == comment);
  453.             nd = iter->nextNode();
  454.             TASSERT(nd == 0);
  456.         }
  461.         ////////// TreeWalker Test Cases ////////////////
  465.         {
  466.             unsigned long whatToShow = IDOM_NodeFilter::SHOW_ALL;
  467.             IDOM_TreeWalker* tw = doc->createTreeWalker(doc, whatToShow, 0, true);
  469.             TASSERT(tw->getCurrentNode() == doc);
  470.             TASSERT(tw->firstChild() == root);
  471.             TASSERT(tw->nextSibling() == 0);
  472.             TASSERT(tw->lastChild() == comment);
  473.             TASSERT(tw->firstChild() == 0);
  474.             TASSERT(tw->lastChild() == 0);
  475.             TASSERT(tw->nextSibling() == 0);
  476.             TASSERT(tw->nextNode() == 0);
  477.             TASSERT(tw->previousSibling() == E13);
  478.             TASSERT(tw->previousNode() == E122);
  479.             TASSERT(tw->parentNode() == E12);
  480.             TASSERT(tw->firstChild() == textNode2);
  481.             TASSERT(tw->previousSibling() == 0);
  482.             TASSERT(tw->nextSibling() == E121);
  483.             TASSERT(tw->nextNode() == E122);
  484.             TASSERT(tw->parentNode() == E12);
  485.             TASSERT(tw->previousSibling() == E11);
  486.             TASSERT(tw->previousNode() == root);
  487.             TASSERT(tw->previousNode() == doc);
  488.             TASSERT(tw->previousNode() == 0);
  489.             TASSERT(tw->parentNode() == 0);
  490.             TASSERT(tw->getCurrentNode() == doc);
  491.         }
  495.         {
  496.             MyFilter mf(IDOM_Node::ELEMENT_NODE);
  497.             unsigned long whatToShow = IDOM_NodeFilter::SHOW_ALL;
  498.             IDOM_TreeWalker* tw = doc->createTreeWalker(root, whatToShow, &mf, true);
  500.             TASSERT(tw->getCurrentNode() == root);
  501.             TASSERT(tw->parentNode() == 0);  //should not change currentNode
  502.             TASSERT(tw->getCurrentNode() == root);
  503.             TASSERT(tw->nextNode() == E11);
  504.             TASSERT(tw->nextNode() == E111);
  505.             tw->setCurrentNode(E12);
  506.             //when first is not visible, should it go to its sibling?
  507.             TASSERT(tw->firstChild() == E121);   //first visible child
  508.             TASSERT(tw->previousSibling() == 0);
  509.         }
  513.         {
  514.             MyFilter mf(IDOM_Node::ELEMENT_NODE, true);
  515.             unsigned long whatToShow = IDOM_NodeFilter::SHOW_ELEMENT;
  516.             IDOM_TreeWalker* tw = doc->createTreeWalker(root, whatToShow, &mf, true);
  518.             tw->setCurrentNode(E12);
  519.             TASSERT(tw->firstChild() == E121);   //still first visible child
  520.         }
  524.         {
  525.             MyFilter mf(IDOM_Node::TEXT_NODE);
  526.             unsigned long whatToShow = IDOM_NodeFilter::SHOW_TEXT;
  527.             IDOM_TreeWalker* tw = doc->createTreeWalker(root, whatToShow, &mf, true);
  529.             //when first is not visible, should it go to its descendent?
  530.             TASSERT(tw->firstChild() == textNode1);   //E11 skipped
  531.             TASSERT(tw->firstChild() == 0);
  532.             TASSERT(tw->nextNode() == textNode2);
  533.             TASSERT(tw->nextSibling() == 0);
  534.             TASSERT(tw->parentNode() == 0);  //no visible ancestor
  535.             TASSERT(tw->getCurrentNode() == textNode2);
  536.             tw->setCurrentNode(root);
  537.             //when last is not visible, should it go to its sibling & descendent?
  538.             TASSERT(tw->lastChild() == textNode2);   //last visible child
  539.             tw->setCurrentNode(E12);
  540.             //when next sibling is not visible, should it go to its descendent?
  541.             TASSERT(tw->nextSibling() == 0);
  542.         }
  546.         {
  547.             MyFilter mf(IDOM_Node::TEXT_NODE, true);
  548.             unsigned long whatToShow = IDOM_NodeFilter::SHOW_TEXT;
  549.             IDOM_TreeWalker* tw = doc->createTreeWalker(root, whatToShow, &mf, true);
  551.             TASSERT(tw->firstChild() == 0);   //E11 rejected and no children is TEXT
  552.             TASSERT(tw->getCurrentNode() == root);
  553.             TASSERT(tw->nextNode() == 0);    //E11 rejected so can't get to textNode1
  554.         }
  556.         delete doc;
  558.     };
  560.     printf("Test Run Successfullyn");
  561.     return 0;
  562. };