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

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

xml/soap/webservice

开发平台：

C/C++

Traversal.cpp：源码内容
  1. /*
  2.  * The Apache Software License, Version 1.1
  3.  *
  4.  * Copyright (c) 1999 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) 1999, 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 DOM 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: Traversal.cpp,v $
  69.  * Revision 1.3  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.2  2000/03/11 03:19:57  chchou
  73.  * Fix bug # 19, add const keyword to API.
  74.  * As a result, update test case.
  75.  *
  76.  * Revision 1.1  2000/02/18 23:01:01  abagchi
  77.  * Initial checkin
  78.  *
  79.  * Revision 1.2  2000/02/15 00:59:58  aruna1
  80.  * Previous node iterator related changes in.
  81.  *
  82.  * Revision 1.1  2000/02/08 02:08:58  aruna1
  83.  * DOM NodeIterator and TreeWalker tests initial check in
  84.  *
  86.  */
  88. #include <stdio.h>
  89. #include <string.h>
  90. #include <dom/DOM.hpp>
  91. #include <dom/DomMemDebug.hpp>
  92. #include <util/PlatformUtils.hpp>
  93. #include <util/XMLException.hpp>
  94. #include <util/XMLString.hpp>
  97. #define TASSERT(c) tassert((c), __FILE__, __LINE__)
  99. void tassert(bool c, const char *file, int line)
  100. {
  101.     if (!c)
  102.         printf("Failure.  Line %d,   file %sn", line, file);
  103. };
  106. #define TESTPROLOG entryMemState = DomMemDebug();
  108. #define TESTEPILOG    exitMemState = DomMemDebug(); 
  109.     if (entryMemState != exitMemState) { 
  110.         printf(" Memory leak at line %d, file %s:  ", __LINE__, __FILE__);  
  111.         exitMemState.printDifference(entryMemState); 
  112.     }
  115. #define EXCEPTION_TEST(operation, expected_exception)               
  116. {                                                                   
  117.     try {                                                           
  118.     operation;                                                      
  119.     printf(" Error: no exception thrown at line %dn", __LINE__);   
  120. }                                                                   
  121.     catch (DOM_DOMException &e) {                                       
  122.     if (e.code != expected_exception)                       
  123.     printf(" Wrong exception code: %d at line %dn", e.code, __LINE__); 
  124. }                                                                 
  125.     catch (...)   {                                                 
  126.     printf(" Wrong exception thrown at line %dn", __LINE__);       
  127. }                                                                   
  128. }
  130. class  MyFilter : public DOM_NodeFilter {
  131. public:
  133.   MyFilter(short nodeType, bool reject=false) : DOM_NodeFilter(), fNodeType(nodeType), fReject(reject) {};
  134.   virtual short acceptNode(const DOM_Node &node) const;
  135. private:
  136.     short fNodeType;
  137.     bool fReject;
  138. };
  139. /*
  140.         Node Types can be of the following:
  141.         ELEMENT_NODE         = 1,
  142.         ATTRIBUTE_NODE       = 2,
  143.         TEXT_NODE            = 3,
  144.         CDATA_SECTION_NODE   = 4,
  145.         ENTITY_REFERENCE_NODE = 5,
  146.         ENTITY_NODE          = 6,
  147.         PROCESSING_INSTRUCTION_NODE = 7,
  148.         COMMENT_NODE         = 8,
  149.         DOCUMENT_NODE        = 9,
  150.         DOCUMENT_TYPE_NODE   = 10,
  151.         DOCUMENT_FRAGMENT_NODE = 11,
  152.         NOTATION_NODE        = 12
  153. */
  154. short  MyFilter::acceptNode(const DOM_Node &node) const {
  155.     if (fNodeType == 0)
  156.         return  DOM_NodeFilter::FILTER_ACCEPT;
  157. if (node.getNodeType() ==  fNodeType) {
  158.         return  DOM_NodeFilter::FILTER_ACCEPT;
  159. } else {
  160.     return  fReject ? DOM_NodeFilter::FILTER_REJECT : DOM_NodeFilter::FILTER_SKIP;
  161. }
  162. }
  166. int  main()
  167. {
  168.     DomMemDebug     entryMemState, exitMemState;
  170. try {
  171. XMLPlatformUtils::Initialize();
  172. }
  173. catch (const XMLException& toCatch) {
  174.         char *pMessage = XMLString::transcode(toCatch.getMessage());
  175.         fprintf(stderr, "Error during XMLPlatformUtils::Initialize(). n"
  176.                         "  Message is: %sn", pMessage);
  177.         delete [] pMessage;
  178.         return -1;
  179.     }
  182.     //
  183.     //  Doc - Create a small document tree
  184.     //
  186.     {
  187.         //creating a DOM Tree
  188.          /* Tests are based on the tree structure below
  189.            doc - root - E11 (attr01) - textNode1
  190.                                      - E111
  191.                                      - E112
  192.                                      - cdataSec
  193.                       - E12 (attr02) - textNode2
  194.                                      - E121
  195.                                      - E122
  196.                       - E13          - E131
  197.                                      - docPI
  198.                       - comment
  199.          */
  201.         DOM_Document    doc = DOM_Document::createDocument();
  202.         //Creating a root element
  203.         DOM_Element     root = doc.createElement("RootElement");
  204.         doc.appendChild(root);
  205.         //Creating the siblings of root
  206.         DOM_Element     E11 = doc.createElement("FirstSibling");
  207.         root.appendChild(E11);
  208.         DOM_Element     E12 = doc.createElement("SecondSibling");
  209.         root.appendChild(E12);
  210.         DOM_Element     E13 = doc.createElement("ThirdSibling");
  211.         root.appendChild(E13);
  212.         //Attaching texts to few siblings
  213.         DOM_Text        textNode1 = doc.createTextNode("Text1");
  214.         E11.appendChild(textNode1);
  215.         DOM_Text        textNode2 = doc.createTextNode("Text2");
  216.         E12.appendChild(textNode2);
  217.         //creating child of siblings
  218.         DOM_Element     E111 = doc.createElement("FirstSiblingChild1");
  219.         E11.appendChild(E111);
  220.         DOM_Attr        attr01  = doc.createAttribute("Attr01");
  221.         E11.setAttributeNode(attr01);
  223.         DOM_Element     E112 = doc.createElement("FirstSiblingChild2");
  224.         E11.appendChild(E112);
  226.         DOM_Element     E121 = doc.createElement("SecondSiblingChild1");
  227.         E12.appendChild(E121);
  228.         DOM_Attr attr02 = doc.createAttribute("Attr01");
  229.         E12.setAttributeNode(attr02);
  231.         DOM_Element     E122 = doc.createElement("SecondSiblingChild2");
  232.         E12.appendChild(E122);
  234.         DOM_Element     E131 = doc.createElement("ThirdSiblingChild1");
  235.         E13.appendChild(E131);
  237.         DOM_Comment comment = doc.createComment("DocComment");
  238.         root.appendChild(comment);
  240.         DOM_CDATASection  cdataSec = doc.createCDATASection("DocCDataSection");
  241.         E11.appendChild(cdataSec);
  243.         DOM_ProcessingInstruction  docPI = doc.createProcessingInstruction("DocPI", "DocTarget");
  244.         E13.appendChild(docPI);
  247.         /*
  248.         following are whatToShow types:
  249.             SHOW_ALL                       = 0x0000FFFF,
  250.             SHOW_ELEMENT                   = 0x00000001,
  251.             SHOW_ATTRIBUTE                 = 0x00000002,
  252.             SHOW_TEXT                      = 0x00000004,
  253.             SHOW_CDATA_SECTION             = 0x00000008,
  254.             SHOW_ENTITY_REFERENCE          = 0x00000010,
  255.             SHOW_ENTITY                    = 0x00000020,
  256.             SHOW_PROCESSING_INSTRUCTION    = 0x00000040,
  257.             SHOW_COMMENT                   = 0x00000080,
  258.             SHOW_DOCUMENT                  = 0x00000100,
  259.             SHOW_DOCUMENT_TYPE             = 0x00000200,
  260.             SHOW_DOCUMENT_FRAGMENT         = 0x00000400,
  261.             SHOW_NOTATION                  = 0x00000800
  262.         */
  264.         ////////// NodeIterator Test Cases ////////////////
  266.         TESTPROLOG;
  267.         {
  268.             // all node iterating test
  270.             DOM_Node    node = doc.getFirstChild();
  271.             unsigned long       whatToShow = DOM_NodeFilter::SHOW_ALL;
  272.             MyFilter* filter = new MyFilter(0);
  274.             DOM_NodeIterator  iter = doc.createNodeIterator(root, whatToShow,  filter, true);
  275.             TASSERT(iter.getWhatToShow() == 65535);
  276.             TASSERT(iter.getExpandEntityReferences() == 1);
  278.             DOM_Node  nd;
  279.             nd = iter.nextNode();
  280.             TASSERT (nd ==root);
  281.             nd = iter.nextNode();
  282.             TASSERT (nd ==E11);
  283.             nd = iter.nextNode();
  284.             TASSERT(nd == textNode1);
  285.             nd = iter.nextNode();
  286.             TASSERT(nd == E111);
  287.             nd = iter.nextNode();
  288.             TASSERT(nd == E112);
  289.             nd = iter.nextNode();
  290.             TASSERT(nd == cdataSec);
  291.             nd = iter.nextNode();
  292.             TASSERT(nd == E12);
  293.             nd = iter.nextNode();
  294.             TASSERT(nd == textNode2);
  295.             nd = iter.nextNode();
  296.             TASSERT(nd == E121);
  297.             nd = iter.nextNode();
  298.             TASSERT(nd == E122);
  299.             nd = iter.nextNode();
  300.             TASSERT(nd == E13);
  301.             nd = iter.nextNode();
  302.             TASSERT(nd == E131);
  303.             nd = iter.nextNode();
  304.             TASSERT(nd == docPI);
  305.             nd = iter.nextNode();
  306.             TASSERT(nd == comment);
  307.             nd = iter.previousNode();
  308.             TASSERT(nd == comment);
  309.             nd = iter.previousNode();
  310.             TASSERT(nd == docPI);
  311.             nd = iter.previousNode();
  312.             TASSERT(nd == E131);
  314.         }
  315.         TESTEPILOG;
  317.         TESTPROLOG;
  318.         {
  319.             //element node iterating test
  321.             DOM_Node    node = doc.getFirstChild();
  322.             unsigned long       whatToShow = DOM_NodeFilter::SHOW_ELEMENT;
  323.             MyFilter* filter = new MyFilter(DOM_Node::ELEMENT_NODE);
  325.             DOM_NodeIterator  iter = doc.createNodeIterator(root, whatToShow,  filter, true);
  326.             TASSERT(iter.getWhatToShow() == 1);
  327.             TASSERT(iter.getExpandEntityReferences() == 1);
  329.             DOM_Node  nd;
  330.             nd = iter.nextNode();
  331.             TASSERT (nd ==root);
  332.             nd = iter.nextNode();
  333.             TASSERT (nd ==E11);
  334.             nd = iter.nextNode();
  335.             TASSERT(nd == E111);
  336.             nd = iter.nextNode();
  337.             TASSERT(nd == E112);
  338.             nd = iter.nextNode();
  339.             TASSERT(nd == E12);
  340.             nd = iter.nextNode();
  341.             TASSERT(nd == E121);
  342.             nd = iter.nextNode();
  343.             TASSERT(nd == E122);
  344.             nd = iter.nextNode();
  345.             TASSERT(nd == E13);
  346.             nd = iter.nextNode();
  347.             TASSERT(nd == E131);
  348.             nd = iter.previousNode();
  349.             TASSERT(nd == E131);
  350.             nd = iter.previousNode();
  351.             TASSERT(nd == E13);
  352.             nd = iter.previousNode();
  353.             TASSERT(nd == E122);
  354.         }
  355.         TESTEPILOG;
  359.         TESTPROLOG;
  360.         {
  361.             // Text node iterating test
  363.             DOM_Node    node = doc.getFirstChild();
  364.             unsigned long       whatToShow = DOM_NodeFilter::SHOW_TEXT;
  365.             MyFilter* filter = new MyFilter(DOM_Node::TEXT_NODE);
  367.             DOM_NodeIterator  iter = doc.createNodeIterator(root, whatToShow,  filter, true);
  369.             TASSERT(iter.getWhatToShow() == 4);
  370.             TASSERT(iter.getExpandEntityReferences() == 1);
  372.             DOM_Node  nd;
  373.             nd = iter.nextNode();
  374.             TASSERT (nd ==textNode1);
  375.             nd = iter.nextNode();
  376.             TASSERT (nd ==textNode2);
  377.             nd = iter.previousNode();
  378.             TASSERT(nd == textNode2);
  380.         }
  381.         TESTEPILOG;
  382.         TESTPROLOG;
  383.         {
  384.             //CDataSection node itearating test
  386.             DOM_Node    node = doc.getFirstChild();
  387.             unsigned long       whatToShow = DOM_NodeFilter::SHOW_CDATA_SECTION;
  388.             MyFilter* filter = new MyFilter(DOM_Node::CDATA_SECTION_NODE);
  390.             DOM_NodeIterator  iter = doc.createNodeIterator(root, whatToShow,  filter, true);
  391.             TASSERT(iter.getWhatToShow() == 8);
  392.             TASSERT(iter.getExpandEntityReferences() == 1);
  394.             DOM_Node  nd;
  395.             nd = iter.nextNode();
  396.             TASSERT(nd == cdataSec);
  397.             nd = iter.nextNode();
  398.             TASSERT(nd == 0);
  400.         }
  401.         TESTEPILOG;
  402.         TESTPROLOG;
  403.         {
  404.             // PI nodes iterating test
  406.             DOM_Node    node = doc.getFirstChild();
  407.             unsigned long       whatToShow = DOM_NodeFilter::SHOW_PROCESSING_INSTRUCTION;
  408.             MyFilter* filter = new MyFilter(DOM_Node::PROCESSING_INSTRUCTION_NODE);
  410.             DOM_NodeIterator  iter = doc.createNodeIterator(root, whatToShow,  filter, true);
  411.             TASSERT(iter.getWhatToShow() == 64);
  412.             TASSERT(iter.getExpandEntityReferences() == 1);
  414.             DOM_Node  nd;
  415.             nd = iter.nextNode();
  416.             TASSERT(nd == docPI);
  417.             nd = iter.nextNode();
  418.             TASSERT(nd == 0);
  421.         }
  422.         TESTEPILOG;
  424.         TESTPROLOG;
  425.         {
  426.             DOM_Node    node = doc.getFirstChild();
  427.             unsigned long       whatToShow = DOM_NodeFilter::SHOW_COMMENT;
  428.             MyFilter* filter = new MyFilter(DOM_Node::COMMENT_NODE);
  430.             DOM_NodeIterator  iter = doc.createNodeIterator(root, whatToShow,  filter, true);
  431.             TASSERT(iter.getWhatToShow() == 128);
  432.             TASSERT(iter.getExpandEntityReferences() == 1);
  434.             DOM_Node  nd;
  435.             nd = iter.nextNode();
  436.             TASSERT(nd == comment);
  437.             nd = iter.nextNode();
  438.             TASSERT(nd == 0);
  440.         }
  441.         TESTEPILOG;
  445.         ////////// TreeWalker Test Cases ////////////////
  448.         TESTPROLOG;
  449.         {
  450.             unsigned long whatToShow = DOM_NodeFilter::SHOW_ALL;
  451.             DOM_TreeWalker tw = doc.createTreeWalker(doc, whatToShow, 0, true);
  453.             TASSERT(tw.getCurrentNode() == doc);
  454.             TASSERT(tw.firstChild() == root);
  455.             TASSERT(tw.nextSibling() == 0);
  456.             TASSERT(tw.lastChild() == comment);
  457.             TASSERT(tw.firstChild() == 0);
  458.             TASSERT(tw.lastChild() == 0);
  459.             TASSERT(tw.nextSibling() == 0);
  460.             TASSERT(tw.nextNode() == 0);
  461.             TASSERT(tw.previousSibling() == E13);
  462.             TASSERT(tw.previousNode() == E122);
  463.             TASSERT(tw.parentNode() == E12);
  464.             TASSERT(tw.firstChild() == textNode2);
  465.             TASSERT(tw.previousSibling() == 0);
  466.             TASSERT(tw.nextSibling() == E121);
  467.             TASSERT(tw.nextNode() == E122);
  468.             TASSERT(tw.parentNode() == E12);
  469.             TASSERT(tw.previousSibling() == E11);
  470.             TASSERT(tw.previousNode() == root);
  471.             TASSERT(tw.previousNode() == doc);
  472.             TASSERT(tw.previousNode() == 0);
  473.             TASSERT(tw.parentNode() == 0);
  474.             TASSERT(tw.getCurrentNode() == doc);
  475.         }
  476.         TESTEPILOG;
  478.         TESTPROLOG;
  479.         {
  480.             MyFilter mf(DOM_Node::ELEMENT_NODE);
  481.             unsigned long whatToShow = DOM_NodeFilter::SHOW_ALL;
  482.             DOM_TreeWalker tw = doc.createTreeWalker(root, whatToShow, &mf, true);
  484.             TASSERT(tw.getCurrentNode() == root);
  485.             TASSERT(tw.parentNode() == 0);  //should not change currentNode
  486.             TASSERT(tw.getCurrentNode() == root);
  487.             TASSERT(tw.nextNode() == E11);
  488.             TASSERT(tw.nextNode() == E111);
  489.             tw.setCurrentNode(E12);
  490.             //when first is not visible, should it go to its sibling?
  491.             TASSERT(tw.firstChild() == E121);   //first visible child
  492.             TASSERT(tw.previousSibling() == 0);
  493.         }
  494.         TESTEPILOG;
  496.         TESTPROLOG;
  497.         {
  498.             MyFilter mf(DOM_Node::ELEMENT_NODE, true);
  499.             unsigned long whatToShow = DOM_NodeFilter::SHOW_ELEMENT;
  500.             DOM_TreeWalker tw = doc.createTreeWalker(root, whatToShow, &mf, true);
  502.             tw.setCurrentNode(E12);
  503.             TASSERT(tw.firstChild() == E121);   //still first visible child
  504.         }
  505.         TESTEPILOG;
  507.         TESTPROLOG;
  508.         {
  509.             MyFilter mf(DOM_Node::TEXT_NODE);
  510.             unsigned long whatToShow = DOM_NodeFilter::SHOW_TEXT;
  511.             DOM_TreeWalker tw = doc.createTreeWalker(root, whatToShow, &mf, true);
  513.             //when first is not visible, should it go to its descendent?
  514.             TASSERT(tw.firstChild() == textNode1);   //E11 skipped
  515.             TASSERT(tw.firstChild() == 0);
  516.             TASSERT(tw.nextNode() == textNode2);
  517.             TASSERT(tw.nextSibling() == 0);
  518.             TASSERT(tw.parentNode() == 0);  //no visible ancestor
  519.             TASSERT(tw.getCurrentNode() == textNode2);
  520.             tw.setCurrentNode(root);
  521.             //when last is not visible, should it go to its sibling & descendent?
  522.             TASSERT(tw.lastChild() == textNode2);   //last visible child
  523.             tw.setCurrentNode(E12);
  524.             //when next sibling is not visible, should it go to its descendent?
  525.             TASSERT(tw.nextSibling() == 0);
  526.         }
  527.         TESTEPILOG;
  529.         TESTPROLOG;
  530.         {
  531.             MyFilter mf(DOM_Node::TEXT_NODE, true);
  532.             unsigned long whatToShow = DOM_NodeFilter::SHOW_TEXT;
  533.             DOM_TreeWalker tw = doc.createTreeWalker(root, whatToShow, &mf, true);
  535.             TASSERT(tw.firstChild() == 0);   //E11 rejected and no children is TEXT
  536.             TASSERT(tw.getCurrentNode() == root);
  537.             TASSERT(tw.nextNode() == 0);    //E11 rejected so can't get to textNode1
  538.         }
  539.         TESTEPILOG;
  541.     };
  544.     //
  545.     //  Print Final allocation stats for full test
  546.     //
  547.     DomMemDebug().print();
  549.     return 0;
  550.     };