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

源码开发语言/平台
当前位置：首页 > 源码/资料 > 多国语言处理 > 词法分析 > 查看源码
Traversal.cpp
资源名称：xerces-c-src_2_3_0.zip　[点击查看]
上传用户：zhuqijet
上传日期：2013-06-25
资源大小：10074k
文件大小：23k
源码类别：

词法分析

开发平台：

Visual C++

Traversal.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 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.15  2003/02/05 18:55:20  tng
  70.  * [Bug 11915] Utility for freeing memory.
  71.  *
  72.  * Revision 1.14  2002/11/12 17:52:12  tng
  73.  * Test update: do not issue "Test Run Successfully" if there was an error.
  74.  *
  75.  * Revision 1.13  2002/11/05 21:47:36  tng
  76.  * Explicit code using namespace in application.
  77.  *
  78.  * Revision 1.12  2002/06/25 16:23:16  tng
  79.  * DOM L3: use release()
  80.  *
  81.  * Revision 1.11  2002/06/04 16:14:44  tng
  82.  * Use proper feature in DOMImplementationRegistry::getDOMImplementation
  83.  *
  84.  * Revision 1.10  2002/06/03 20:51:46  tng
  85.  * DOM L3: Add DOMImplementationRegistry and DOMImplementationSource
  86.  *
  87.  * Revision 1.9  2002/05/27 21:11:26  tng
  88.  * Add DOMDocumentRange and DOMDocumentTraversal.
  89.  *
  90.  * Revision 1.8  2002/05/21 18:52:35  tng
  91.  * Test case update: modify to use the latest DOM interface.
  92.  *
  93.  * Revision 1.8  2002/03/07 21:41:58  peiyongz
  94.  * Call Terminate() to avoid memory tools reporting memory leak
  95.  *
  96.  * Revision 1.7  2002/02/04 21:56:57  tng
  97.  * Test DOM Level 2 function getRoot.
  98.  *
  99.  * Revision 1.6  2002/02/04 19:02:37  tng
  100.  * Memory leak fix in samples / test cases.
  101.  *
  102.  * Revision 1.5  2002/02/01 22:44:51  peiyongz
  103.  * sane_include
  104.  *
  105.  * Revision 1.4  2001/11/23 16:18:54  tng
  106.  * Elimiate compiler warning: Warning: String literal converted to char* in formal argument file in call to tassert(bool, char*, int).
  107.  *
  108.  * Revision 1.3  2001/07/19 20:45:16  tng
  109.  * Add some test cases in the tests folder to sanityTest.pl
  110.  *
  111.  * Revision 1.2  2001/06/05 11:58:31  tng
  112.  * Delete the document at the end for clearing the memory.
  113.  *
  114.  * Revision 1.1  2001/06/04 20:11:55  tng
  115.  * IDOM: Complete IDNodeIterator, IDTreeWalker, IDNodeFilter.
  116.  *
  117.  *
  119.  */
  121. #include <stdio.h>
  122. #include <string.h>
  123. #include <xercesc/dom/DOM.hpp>
  124. #include <xercesc/util/PlatformUtils.hpp>
  125. #include <xercesc/util/XMLException.hpp>
  126. #include <xercesc/util/XMLString.hpp>
  127. #include <xercesc/util/XMLUniDefs.hpp>
  130. XERCES_CPP_NAMESPACE_USE
  132. bool errorOccurred = false;
  134. #define TASSERT(c) tassert((c), __FILE__, __LINE__)
  136. void tassert(bool c, const char *file, int line)
  137. {
  138.     if (!c) {
  139.         printf("Failure.  Line %d,   file %sn", line, file);
  140.         errorOccurred = true;
  141.     }
  142. };
  145. #define EXCEPTION_TEST(operation, expected_exception)               
  146. {                                                                   
  147.     try {                                                           
  148.     operation;                                                      
  149.     printf(" Error: no exception thrown at line %dn", __LINE__);   
  150.     errorOccurred = true;                                           
  151.     }                                                               
  152.     catch (DOMException &e) {                                       
  153.     if (e.code != expected_exception) {                             
  154.         printf(" Wrong exception code: %d at line %dn", e.code, __LINE__); 
  155.         errorOccurred = true;                                       
  156.     }                                                               
  157.     }                                                               
  158.     catch (...)   {                                                 
  159.         printf(" Wrong exception thrown at line %dn", __LINE__);   
  160.         errorOccurred = true;                                       
  161.     }                                                               
  162. }
  164. class  MyFilter : public DOMNodeFilter {
  165. public:
  167.   MyFilter(short nodeType, bool reject=false) : DOMNodeFilter(), fNodeType(nodeType), fReject(reject) {};
  168.   virtual short acceptNode(const DOMNode* node) const;
  169. private:
  170.     short fNodeType;
  171.     bool fReject;
  172. };
  173. /*
  174.         Node Types can be of the following:
  175.         ELEMENT_NODE         = 1,
  176.         ATTRIBUTE_NODE       = 2,
  177.         TEXT_NODE            = 3,
  178.         CDATA_SECTION_NODE   = 4,
  179.         ENTITY_REFERENCE_NODE = 5,
  180.         ENTITY_NODE          = 6,
  181.         PROCESSING_INSTRUCTION_NODE = 7,
  182.         COMMENT_NODE         = 8,
  183.         DOCUMENT_NODE        = 9,
  184.         DOCUMENT_TYPE_NODE   = 10,
  185.         DOCUMENT_FRAGMENT_NODE = 11,
  186.         NOTATION_NODE        = 12
  187. */
  188. short  MyFilter::acceptNode(const DOMNode* node) const {
  189.     if (fNodeType == 0)
  190.         return  DOMNodeFilter::FILTER_ACCEPT;
  191. if (node->getNodeType() ==  fNodeType) {
  192.         return  DOMNodeFilter::FILTER_ACCEPT;
  193. } else {
  194.     return  fReject ? DOMNodeFilter::FILTER_REJECT : DOMNodeFilter::FILTER_SKIP;
  195. }
  196. }
  200. int  main()
  201. {
  202. try {
  203. XMLPlatformUtils::Initialize();
  204. }
  205. catch (const XMLException& toCatch) {
  206.         char *pMessage = XMLString::transcode(toCatch.getMessage());
  207.         fprintf(stderr, "Error during XMLPlatformUtils::Initialize(). n"
  208.                         "  Message is: %sn", pMessage);
  209.         XMLString::release(&pMessage);
  210.         return -1;
  211.     }
  213.     // Create a XMLCh buffer for string manipulation
  214.     XMLCh tempStr[4000];
  215.     XMLCh featureStr[100];
  216.     XMLString::transcode("Traversal",featureStr,99);
  220.     //
  221.     //  Doc - Create a small document tree
  222.     //
  224.     {
  225.         //creating a DOM Tree
  226.          /* Tests are based on the tree structure below
  227.            doc - root - E11 (attr01) - textNode1
  228.                                      - E111
  229.                                      - E112
  230.                                      - cdataSec
  231.                       - E12 (attr02) - textNode2
  232.                                      - E121
  233.                                      - E122
  234.                       - E13          - E131
  235.                                      - docPI
  236.                       - comment
  237.          */
  239.         DOMImplementation* impl = DOMImplementationRegistry::getDOMImplementation(featureStr);
  240.         DOMDocument* doc = impl->createDocument();
  242.         //Creating a root element
  243.         XMLString::transcode("RootElement", tempStr, 3999);
  244.         DOMElement*     root = doc->createElement(tempStr);
  245.         doc->appendChild(root);
  247.         //Creating the siblings of root
  248.         XMLString::transcode("FirstSibling", tempStr, 3999);
  249.         DOMElement*     E11 = doc->createElement(tempStr);
  250.         root->appendChild(E11);
  252.         XMLString::transcode("SecondSibling", tempStr, 3999);
  253.         DOMElement*     E12 = doc->createElement(tempStr);
  254.         root->appendChild(E12);
  256.         XMLString::transcode("ThirdSibling", tempStr, 3999);
  257.         DOMElement*     E13 = doc->createElement(tempStr);
  258.         root->appendChild(E13);
  260.         //Attaching texts to few siblings
  261.         XMLString::transcode("Text1", tempStr, 3999);
  262.         DOMText*        textNode1 = doc->createTextNode(tempStr);
  263.         E11->appendChild(textNode1);
  265.         XMLString::transcode("Text2", tempStr, 3999);
  266.         DOMText*        textNode2 = doc->createTextNode(tempStr);
  267.         E12->appendChild(textNode2);
  269.         //creating child of siblings
  270.         XMLString::transcode("FirstSiblingChild1", tempStr, 3999);
  271.         DOMElement*     E111 = doc->createElement(tempStr);
  272.         E11->appendChild(E111);
  274.         XMLString::transcode("Attr01", tempStr, 3999);
  275.         DOMAttr*        attr01  = doc->createAttribute(tempStr);
  276.         DOMNode* rem = E11->setAttributeNode(attr01);
  277.         if (rem)
  278.             rem->release();
  280.         XMLString::transcode("FirstSiblingChild2", tempStr, 3999);
  281.         DOMElement*     E112 = doc->createElement(tempStr);
  282.         E11->appendChild(E112);
  284.         XMLString::transcode("SecondSiblingChild1", tempStr, 3999);
  285.         DOMElement*     E121 = doc->createElement(tempStr);
  286.         E12->appendChild(E121);
  288.         XMLString::transcode("Attr01", tempStr, 3999);
  289.         DOMAttr* attr02 = doc->createAttribute(tempStr);
  290.         rem = E12->setAttributeNode(attr02);
  291.         if (rem)
  292.             rem->release();
  294.         XMLString::transcode("SecondSiblingChild2", tempStr, 3999);
  295.         DOMElement*     E122 = doc->createElement(tempStr);
  296.         E12->appendChild(E122);
  298.         XMLString::transcode("ThirdSiblingChild1", tempStr, 3999);
  299.         DOMElement*     E131 = doc->createElement(tempStr);
  300.         E13->appendChild(E131);
  302.         XMLString::transcode("DocComment", tempStr, 3999);
  303.         DOMComment* comment = doc->createComment(tempStr);
  304.         root->appendChild(comment);
  306.         XMLString::transcode("DocCDataSection", tempStr, 3999);
  307.         DOMCDATASection*  cdataSec = doc->createCDATASection(tempStr);
  308.         E11->appendChild(cdataSec);
  310.         XMLString::transcode("DocPI", tempStr, 3999);
  311.         XMLCh piStr[] = {chLatin_D, chLatin_o, chLatin_c, chLatin_P, chLatin_I, chNull};
  312.         DOMProcessingInstruction*  docPI = doc->createProcessingInstruction(piStr, tempStr);
  313.         E13->appendChild(docPI);
  316.         /*
  317.         following are whatToShow types:
  318.             SHOW_ALL                       = 0x0000FFFF,
  319.             SHOW_ELEMENT                   = 0x00000001,
  320.             SHOW_ATTRIBUTE                 = 0x00000002,
  321.             SHOW_TEXT                      = 0x00000004,
  322.             SHOW_CDATA_SECTION             = 0x00000008,
  323.             SHOW_ENTITY_REFERENCE          = 0x00000010,
  324.             SHOW_ENTITY                    = 0x00000020,
  325.             SHOW_PROCESSING_INSTRUCTION    = 0x00000040,
  326.             SHOW_COMMENT                   = 0x00000080,
  327.             SHOW_DOCUMENT                  = 0x00000100,
  328.             SHOW_DOCUMENT_TYPE             = 0x00000200,
  329.             SHOW_DOCUMENT_FRAGMENT         = 0x00000400,
  330.             SHOW_NOTATION                  = 0x00000800
  331.         */
  333.         ////////// NodeIterator Test Cases ////////////////
  336.         {
  337.             // all node iterating test
  339.             DOMNode*    node = doc->getFirstChild();
  340.             unsigned long       whatToShow = DOMNodeFilter::SHOW_ALL;
  341.             MyFilter* filter = new MyFilter(0);
  343.             DOMNodeIterator*  iter = ((DOMDocumentTraversal*)doc)->createNodeIterator(root, whatToShow,  filter, true);
  344.             TASSERT(iter->getWhatToShow() == 65535);
  345.             TASSERT(iter->getExpandEntityReferences() == 1);
  347.             DOMNode*  nd;
  348.             nd = iter->nextNode();
  349.             TASSERT (nd ==root);
  350.             nd = iter->nextNode();
  351.             TASSERT (nd ==E11);
  352.             nd = iter->nextNode();
  353.             TASSERT(nd == textNode1);
  354.             nd = iter->nextNode();
  355.             TASSERT(nd == E111);
  356.             nd = iter->nextNode();
  357.             TASSERT(nd == E112);
  358.             nd = iter->nextNode();
  359.             TASSERT(nd == cdataSec);
  360.             nd = iter->nextNode();
  361.             TASSERT(nd == E12);
  362.             nd = iter->nextNode();
  363.             TASSERT(nd == textNode2);
  364.             nd = iter->nextNode();
  365.             TASSERT(nd == E121);
  366.             nd = iter->nextNode();
  367.             TASSERT(nd == E122);
  368.             nd = iter->nextNode();
  369.             TASSERT(nd == E13);
  370.             nd = iter->nextNode();
  371.             TASSERT(nd == E131);
  372.             nd = iter->nextNode();
  373.             TASSERT(nd == docPI);
  374.             nd = iter->nextNode();
  375.             TASSERT(nd == comment);
  376.             nd = iter->previousNode();
  377.             TASSERT(nd == comment);
  378.             nd = iter->previousNode();
  379.             TASSERT(nd == docPI);
  380.             nd = iter->previousNode();
  381.             TASSERT(nd == E131);
  383.             //test getRoot
  384.             TASSERT(iter->getRoot() == root);
  385.             TASSERT(iter->getRoot() != doc);
  387.             delete filter;
  389.         }
  393.         {
  394.             //element node iterating test
  396.             DOMNode*    node = doc->getFirstChild();
  397.             unsigned long       whatToShow = DOMNodeFilter::SHOW_ELEMENT;
  398.             MyFilter* filter = new MyFilter(DOMNode::ELEMENT_NODE);
  400.             DOMNodeIterator*  iter = doc->createNodeIterator(root, whatToShow,  filter, true);
  401.             TASSERT(iter->getWhatToShow() == 1);
  402.             TASSERT(iter->getExpandEntityReferences() == 1);
  404.             DOMNode*  nd;
  405.             nd = iter->nextNode();
  406.             TASSERT (nd ==root);
  407.             nd = iter->nextNode();
  408.             TASSERT (nd ==E11);
  409.             nd = iter->nextNode();
  410.             TASSERT(nd == E111);
  411.             nd = iter->nextNode();
  412.             TASSERT(nd == E112);
  413.             nd = iter->nextNode();
  414.             TASSERT(nd == E12);
  415.             nd = iter->nextNode();
  416.             TASSERT(nd == E121);
  417.             nd = iter->nextNode();
  418.             TASSERT(nd == E122);
  419.             nd = iter->nextNode();
  420.             TASSERT(nd == E13);
  421.             nd = iter->nextNode();
  422.             TASSERT(nd == E131);
  423.             nd = iter->previousNode();
  424.             TASSERT(nd == E131);
  425.             nd = iter->previousNode();
  426.             TASSERT(nd == E13);
  427.             nd = iter->previousNode();
  428.             TASSERT(nd == E122);
  430.             delete filter;
  431.         }
  437.         {
  438.             // Text node iterating test
  440.             DOMNode*    node = doc->getFirstChild();
  441.             unsigned long       whatToShow = DOMNodeFilter::SHOW_TEXT;
  442.             MyFilter* filter = new MyFilter(DOMNode::TEXT_NODE);
  444.             DOMNodeIterator*  iter = ((DOMDocumentTraversal*)doc)->createNodeIterator(root, whatToShow,  filter, true);
  446.             TASSERT(iter->getWhatToShow() == 4);
  447.             TASSERT(iter->getExpandEntityReferences() == 1);
  449.             DOMNode*  nd;
  450.             nd = iter->nextNode();
  451.             TASSERT (nd ==textNode1);
  452.             nd = iter->nextNode();
  453.             TASSERT (nd ==textNode2);
  454.             nd = iter->previousNode();
  455.             TASSERT(nd == textNode2);
  457.             delete filter;
  458.         }
  461.         {
  462.             //CDataSection node itearating test
  464.             DOMNode*    node = doc->getFirstChild();
  465.             unsigned long       whatToShow = DOMNodeFilter::SHOW_CDATA_SECTION;
  466.             MyFilter* filter = new MyFilter(DOMNode::CDATA_SECTION_NODE);
  468.             DOMNodeIterator*  iter = doc->createNodeIterator(root, whatToShow,  filter, true);
  469.             TASSERT(iter->getWhatToShow() == 8);
  470.             TASSERT(iter->getExpandEntityReferences() == 1);
  472.             DOMNode*  nd;
  473.             nd = iter->nextNode();
  474.             TASSERT(nd == cdataSec);
  475.             nd = iter->nextNode();
  476.             TASSERT(nd == 0);
  478.             delete filter;
  479.         }
  482.         {
  483.             // PI nodes iterating test
  485.             DOMNode*    node = doc->getFirstChild();
  486.             unsigned long       whatToShow = DOMNodeFilter::SHOW_PROCESSING_INSTRUCTION;
  487.             MyFilter* filter = new MyFilter(DOMNode::PROCESSING_INSTRUCTION_NODE);
  489.             DOMNodeIterator*  iter = ((DOMDocumentTraversal*)doc)->createNodeIterator(root, whatToShow,  filter, true);
  490.             TASSERT(iter->getWhatToShow() == 64);
  491.             TASSERT(iter->getExpandEntityReferences() == 1);
  493.             DOMNode*  nd;
  494.             nd = iter->nextNode();
  495.             TASSERT(nd == docPI);
  496.             nd = iter->nextNode();
  497.             TASSERT(nd == 0);
  499.             delete filter;
  500.         }
  504.         {
  505.             DOMNode*    node = doc->getFirstChild();
  506.             unsigned long       whatToShow = DOMNodeFilter::SHOW_COMMENT;
  507.             MyFilter* filter = new MyFilter(DOMNode::COMMENT_NODE);
  509.             DOMNodeIterator*  iter = doc->createNodeIterator(root, whatToShow,  filter, true);
  510.             TASSERT(iter->getWhatToShow() == 128);
  511.             TASSERT(iter->getExpandEntityReferences() == 1);
  513.             DOMNode*  nd;
  514.             nd = iter->nextNode();
  515.             TASSERT(nd == comment);
  516.             nd = iter->nextNode();
  517.             TASSERT(nd == 0);
  519.             delete filter;
  520.         }
  525.         ////////// TreeWalker Test Cases ////////////////
  529.         {
  530.             unsigned long whatToShow = DOMNodeFilter::SHOW_ALL;
  531.             DOMTreeWalker* tw = ((DOMDocumentTraversal*)doc)->createTreeWalker(doc, whatToShow, 0, true);
  533.             TASSERT(tw->getCurrentNode() == doc);
  534.             TASSERT(tw->firstChild() == root);
  535.             TASSERT(tw->nextSibling() == 0);
  536.             TASSERT(tw->lastChild() == comment);
  537.             TASSERT(tw->firstChild() == 0);
  538.             TASSERT(tw->lastChild() == 0);
  539.             TASSERT(tw->nextSibling() == 0);
  540.             TASSERT(tw->nextNode() == 0);
  541.             TASSERT(tw->previousSibling() == E13);
  542.             TASSERT(tw->previousNode() == E122);
  543.             TASSERT(tw->parentNode() == E12);
  544.             TASSERT(tw->firstChild() == textNode2);
  545.             TASSERT(tw->previousSibling() == 0);
  546.             TASSERT(tw->nextSibling() == E121);
  547.             TASSERT(tw->nextNode() == E122);
  548.             TASSERT(tw->parentNode() == E12);
  549.             TASSERT(tw->previousSibling() == E11);
  550.             TASSERT(tw->previousNode() == root);
  551.             TASSERT(tw->previousNode() == doc);
  552.             TASSERT(tw->previousNode() == 0);
  553.             TASSERT(tw->parentNode() == 0);
  554.             TASSERT(tw->getCurrentNode() == doc);
  555.         }
  559.         {
  560.             MyFilter mf(DOMNode::ELEMENT_NODE);
  561.             unsigned long whatToShow = DOMNodeFilter::SHOW_ALL;
  562.             DOMTreeWalker* tw = doc->createTreeWalker(root, whatToShow, &mf, true);
  564.             TASSERT(tw->getCurrentNode() == root);
  565.             TASSERT(tw->parentNode() == 0);  //should not change currentNode
  566.             TASSERT(tw->getCurrentNode() == root);
  567.             TASSERT(tw->nextNode() == E11);
  568.             TASSERT(tw->nextNode() == E111);
  569.             tw->setCurrentNode(E12);
  570.             //when first is not visible, should it go to its sibling?
  571.             TASSERT(tw->firstChild() == E121);   //first visible child
  572.             TASSERT(tw->previousSibling() == 0);
  573.         }
  577.         {
  578.             MyFilter mf(DOMNode::ELEMENT_NODE, true);
  579.             unsigned long whatToShow = DOMNodeFilter::SHOW_ELEMENT;
  580.             DOMTreeWalker* tw = ((DOMDocumentTraversal*)doc)->createTreeWalker(root, whatToShow, &mf, true);
  582.             tw->setCurrentNode(E12);
  583.             TASSERT(tw->firstChild() == E121);   //still first visible child
  584.         }
  588.         {
  589.             MyFilter mf(DOMNode::TEXT_NODE);
  590.             unsigned long whatToShow = DOMNodeFilter::SHOW_TEXT;
  591.             DOMTreeWalker* tw = doc->createTreeWalker(root, whatToShow, &mf, true);
  593.             //when first is not visible, should it go to its descendent?
  594.             TASSERT(tw->firstChild() == textNode1);   //E11 skipped
  595.             TASSERT(tw->firstChild() == 0);
  596.             TASSERT(tw->nextNode() == textNode2);
  597.             TASSERT(tw->nextSibling() == 0);
  598.             TASSERT(tw->parentNode() == 0);  //no visible ancestor
  599.             TASSERT(tw->getCurrentNode() == textNode2);
  600.             tw->setCurrentNode(root);
  601.             //when last is not visible, should it go to its sibling & descendent?
  602.             TASSERT(tw->lastChild() == textNode2);   //last visible child
  603.             tw->setCurrentNode(E12);
  604.             //when next sibling is not visible, should it go to its descendent?
  605.             TASSERT(tw->nextSibling() == 0);
  606.         }
  610.         {
  611.             MyFilter mf(DOMNode::TEXT_NODE, true);
  612.             unsigned long whatToShow = DOMNodeFilter::SHOW_TEXT;
  613.             DOMTreeWalker* tw = ((DOMDocumentTraversal*)doc)->createTreeWalker(root, whatToShow, &mf, true);
  615.             TASSERT(tw->firstChild() == 0);   //E11 rejected and no children is TEXT
  616.             TASSERT(tw->getCurrentNode() == root);
  617.             TASSERT(tw->nextNode() == 0);    //E11 rejected so can't get to textNode1
  619.             //test getRoot
  620.             TASSERT(tw->getRoot() == root);
  621.             TASSERT(tw->getRoot() != doc);
  622.         }
  624.         doc->release();
  626.     };
  628.     // And call the termination method
  629.     XMLPlatformUtils::Terminate();
  631.     if (errorOccurred) {
  632.         printf("Test Failedn");
  633.         return 4;
  634.     }
  636.     printf("Test Run Successfullyn");
  637.     return 0;
  638. };