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

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

xml/soap/webservice

开发平台：

C/C++

RangeTest.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.  */
  59. /**
  60.  * $Id: RangeTest.cpp,v 1.4 2001/11/23 19:28:49 tng Exp $
  61.  */
  64. /** This RangeTest tests all of the cases delineated as examples
  65.  *  in the DOM Level 2 Range specification, and a few others.
  66.  *  <p>These do not by any means completely test the API and
  67.  *  corner cases.
  68.  */
  70. #include <stdio.h>
  71. #include <string.h>
  72. #include <dom/DOM.hpp>
  73. #include <dom/DomMemDebug.hpp>
  74. #include <parsers/DOMParser.hpp>
  75. #include <util/PlatformUtils.hpp>
  76. #include <util/XMLException.hpp>
  77. #include <util/XMLString.hpp>
  78. #include <dom/DOM_Range.hpp>
  79. #include <dom/DOM_XMLDecl.hpp>
  80. #include <framework/MemBufInputSource.hpp>
  83. #define TASSERT(c) tassert((c), __FILE__, __LINE__)
  85. void tassert(bool c, const char *file, int line)
  86. {
  87.     if (!c)
  88.         printf("Failure.  Line %d,   file %sn", line, file);
  89. };
  92. #define TESTPROLOG entryMemState = DomMemDebug();
  94. #define TESTEPILOG    exitMemState = DomMemDebug(); 
  95.     if (entryMemState != exitMemState) { 
  96.         printf(" Memory leak at line %d, file %s:  ", __LINE__, __FILE__);  
  97.         exitMemState.printDifference(entryMemState); 
  98.     }
  101. #define EXCEPTION_TEST(operation, expected_exception)               
  102. {                                                                   
  103.     try {                                                           
  104.     operation;                                                      
  105.     printf(" Error: no exception thrown at line %dn", __LINE__);   
  106. }                                                                   
  107.     catch (DOM_DOMException &e) {                                       
  108.     if (e.code != expected_exception)                       
  109.     printf(" Wrong exception code: %d at line %dn", e.code, __LINE__); 
  110. }                                                                 
  111.     catch (...)   {                                                 
  112.     printf(" Wrong exception thrown at line %dn", __LINE__);       
  113. }                                                                   
  114. }
  116. int  main()
  117. {
  118.     DomMemDebug     entryMemState, exitMemState;
  120. try {
  121. XMLPlatformUtils::Initialize();
  122. }
  123. catch (const XMLException& toCatch) {
  124.         char *pMessage = XMLString::transcode(toCatch.getMessage());
  125.         fprintf(stderr, "Error during XMLPlatformUtils::Initialize(). n"
  126.                         "  Message is: %sn", pMessage);
  127.         delete [] pMessage;
  128.         return -1;
  129.     }
  131.     /*
  132.     Range tests include testing of
  134.     createRange
  136.     setStart, setStartBefore. setStartAfter,
  137.     setEnd, setEndBefore. setEndAfter
  138.     getStartContainer, getStartOffset
  139.     getEndContainer, getEndOffset
  140.     getCommonAncestorContainer
  141.     selectNode
  142.     selectNodeContents
  143.     insertNode
  144.     deleteContents
  145.     collapse
  146.     getCollapsed
  147.     surroundContents
  148.     compareBoundaryPoints
  149.     cloneRange
  150.     cloneContents
  151.     extractContents
  152.     toString
  153.     detach
  154.     removeChild
  155.     */
  156.     {
  158.         {
  159.             DOM_Document    doc = DOM_Document::createDocument();
  160.             //Creating a root element
  161.             DOM_Element     root = doc.createElement("Body");
  162.             doc.appendChild(root);
  164.             //Creating the siblings of root
  165.             DOM_Element     E11 = doc.createElement("H1");
  166.             root.appendChild(E11);
  168.             DOM_Element     E12 = doc.createElement("P");
  169.             root.appendChild(E12);
  171.             //Attaching texts to siblings
  172.             DOM_Text        textNode1 = doc.createTextNode("Title");
  173.             E11.appendChild(textNode1);
  175.             DOM_Text        textNode11 = doc.createTextNode("AnotherText");
  176.             E11.appendChild(textNode11);
  178.             DOM_Text        textNode2 = doc.createTextNode("Blah xyz");
  179.             E12.appendChild(textNode2);
  181.             DOM_Text     E210 = doc.createTextNode("insertedText");
  184.         }
  187.         TESTPROLOG;
  188.         {
  189.             //DOM Tree and some usable node creation
  190.             DOM_Document    doc = DOM_Document::createDocument();
  191.             //Creating a root element
  192.             DOM_Element     root = doc.createElement("Body");
  193.             doc.appendChild(root);
  195.             //Creating the siblings of root
  196.             DOM_Element     E11 = doc.createElement("H1");
  197.             root.appendChild(E11);
  199.             DOM_Element     E12 = doc.createElement("P");
  200.             root.appendChild(E12);
  202.             //Attaching texts to siblings
  203.             DOM_Text        textNode1 = doc.createTextNode("Title");
  204.             E11.appendChild(textNode1);
  206.             DOM_Text        textNode11 = doc.createTextNode("AnotherText");
  207.             E11.appendChild(textNode11);
  209.             DOM_Text        textNode2 = doc.createTextNode("Blah xyz");
  210.             E12.appendChild(textNode2);
  212.             //experimental nodes
  213.             DOM_Element     E120 = doc.createElement("Element1");
  214.             DOM_Element     E121 = doc.createElement("Element2");
  215.             DOM_Element     E122 = doc.createElement("Element3");
  216.             DOM_Element     E311 = doc.createElement("SurroundNode1");
  218.             DOM_Text     E210 = doc.createTextNode("insertedText");
  220.             DOM_Node rt = doc.getDocumentElement();
  221.             DOM_Range range = doc.createRange();
  225.             //Tests start here
  226.             // Initial dom tree looks like :
  227.             // <Body><H1>TitleAnother Text</H1><P>Blah xyz</P></Body>
  228.             //i.e.,            Body(rt)
  229.             //     _____________|________________
  230.             //     |                           |
  231.             //  ___H1(E11)___                    P(E12)
  232.             //  |           |                    |
  233.             //  "Title"  "Another Text"        "Blah xyz"
  236.             //test for start and end settings of a range
  237.             range.setStart(rt.getFirstChild(), 0);
  238.             TASSERT(range.getStartContainer() == rt.getFirstChild() );
  239.             TASSERT(range.getStartOffset() == 0);
  241.             range.setEnd(rt.getFirstChild(), 1);
  242.             TASSERT(range.getEndContainer() == rt.getFirstChild() );
  243.             TASSERT(range.getEndOffset() == 1);
  246.             DOM_Node node = range.getCommonAncestorContainer();
  247.             TASSERT(range.getCommonAncestorContainer() == rt.getFirstChild());
  249.             //selection related test
  250.             range.selectNode(rt.getLastChild());
  251.             TASSERT(range.getStartContainer() == rt);
  252.             TASSERT(range.getStartOffset() == 1);
  253.             TASSERT(range.getEndContainer() == rt);
  254.             TASSERT(range.getEndOffset() == 2);
  256.             //insertion related tests
  257.             range.insertNode(E120);
  259.             //only end offset moves and new node gets into range as being inserted at boundary point
  260.             TASSERT(range.getStartContainer() == rt);
  261.             TASSERT(range.getStartOffset() == 1);
  262.             TASSERT(range.getEndContainer() == rt);
  263.             TASSERT(range.getEndOffset() == 3);
  265.             range.insertNode(E121);
  266.             //only end offset moves and new node gets into range as being inserted at boundary point
  267.             TASSERT(range.getStartContainer() == rt);
  268.             TASSERT(range.getStartOffset() == 1);
  269.             TASSERT(range.getEndContainer() == rt);
  270.             TASSERT(range.getEndOffset() == 4);
  272.             rt.insertBefore(E122, rt.getFirstChild());
  273.             //both offsets move as new node is not part of the range
  274.             TASSERT(range.getStartContainer() == rt);
  275.             TASSERT(range.getStartOffset() == 2);
  276.             TASSERT(range.getEndContainer() == rt);
  277.             TASSERT(range.getEndOffset() == 5);
  279.             //After above operations, now the tree looks like:
  280.             // <Body><Element3/><H1>TitleAnother Text</H1><Element2/><Element1/><P>Blah xyz</P></Body>
  281.             //i.e.,            Body(rt)
  282.             //     _____________|_______________________________________________________________
  283.             //     |                |                  |                |                      |
  284.             //  Element3(E122)  ___H1(E11)___        Element2(E121)    Element1(E120)          P(E12)
  285.             //                  |           |                                                  |
  286.             //               "Title"  "Another Text"                                        "Blah xyz"
  287.             //
  288.             // range has rt as start and end container, and 2 as start offset, 5 as end offset
  290.             //changing selection
  291.             range.selectNode(rt.getLastChild().getPreviousSibling());
  292.             TASSERT(range.getStartContainer() == rt);
  293.             TASSERT(range.getStartOffset() == 3);
  294.             TASSERT(range.getEndContainer() == rt);
  295.             TASSERT(range.getEndOffset() == 4);
  297.             //deleting related tests
  298.             range.deleteContents();
  299.             TASSERT(rt.getLastChild().getPreviousSibling() == E121);
  301.             range.setStart(rt.getFirstChild().getNextSibling().getFirstChild(), 2);
  302.             TASSERT(range.getStartContainer() == rt.getFirstChild().getNextSibling().getFirstChild());
  303.             TASSERT(range.getStartContainer().getNodeValue().equals("Title"));
  304.             TASSERT(range.getStartOffset() == 2);
  306.             range.setEnd(rt.getFirstChild().getNextSibling().getFirstChild(), 4);
  307.             TASSERT(range.getEndContainer() == rt.getFirstChild().getNextSibling().getFirstChild());
  308.             TASSERT(range.getEndContainer().getNodeValue().equals("Title"));
  309.             TASSERT(range.getEndOffset() == 4);
  310.             TASSERT(range.toString().equals("tl"));
  312.             //inserting text between a text node
  313.             range.insertNode(E210);
  315.             //only end offset moves and new node gets into range as being inserted at boundary point
  316.             TASSERT(range.getStartContainer() == rt.getFirstChild().getNextSibling().getFirstChild());
  317.             TASSERT(range.getStartOffset() == 2);
  318.             TASSERT(range.getEndContainer() == rt.getFirstChild().getNextSibling().getLastChild().getPreviousSibling());
  319.             TASSERT(range.getEndOffset() == 2);
  321.             //inserting element node before the selected text node
  322.             range.insertNode(E120);
  323.             //only end offset moves and new node gets into range as being inserted at boundary point
  324.             TASSERT(range.getStartContainer() == rt.getFirstChild().getNextSibling().getFirstChild());
  325.             TASSERT(range.getStartContainer().getNodeValue().equals("Ti"));
  326.             TASSERT(range.getStartOffset() == 2);
  327.             TASSERT(range.getEndContainer() == rt.getFirstChild().getNextSibling().getLastChild().getPreviousSibling());
  328.             TASSERT(range.getEndContainer().getNodeValue().equals("tle"));
  329.             TASSERT(range.getEndOffset() == 2);
  330.             TASSERT(E11.getChildNodes().getLength()==6);
  332.            //checking the text replacment
  333.             range.getStartContainer().setNodeValue("ReplacedText");
  334.             //only the start offset is impact
  335.             TASSERT(range.getStartContainer() == rt.getFirstChild().getNextSibling().getFirstChild());
  336.             TASSERT(range.getStartContainer().getNodeValue().equals("ReplacedText"));
  337.             TASSERT(range.getStartOffset() == 0);
  338.             TASSERT(range.getEndContainer() == rt.getFirstChild().getNextSibling().getLastChild().getPreviousSibling());
  339.             TASSERT(range.getEndContainer().getNodeValue().equals("tle"));
  340.             TASSERT(range.getEndOffset() == 2);
  342.             //After above operations, now the tree looks like:
  343.             // <Body><Element3/><H1>ReplacedText<Element1/>insertedTexttleAnother Text</H1><Element2/><P>Blah xyz</P></Body>
  344.             //i.e.,            Body(rt)
  345.             //     _____________|_______________________________________________________________________________________________
  346.             //     |                |                                                                          |                |
  347.             //  Element3(E122)  ___H1(E11)___________________________________________________________        Element2(E121)    P(E12)
  348.             //                  |              |     |                |                      |      |                             |
  349.             //               "ReplacedText"   ""   Element1(E120)   "insertedText"(E210)   "tle"  "Another Text"              "Blah xyz"
  350.             //
  351.             // range has "ReplacedText" as start container and "tle" as end container
  352.             //   and 0 as start offset, 2 as end offset
  354.             //changing the selection. Preparing for 'surround'
  355.             range.setStart(range.getStartContainer().getParentNode(), 2);
  356.             range.setEnd(range.getStartContainer(), 5);
  357.             TASSERT(range.getStartContainer().getNodeName().equals("H1"));
  358.             TASSERT(range.getEndContainer().getNodeName().equals("H1"));
  359.             TASSERT(range.toString().equals("insertedTexttle"));
  361.             range.surroundContents(E311);
  362.             TASSERT(range.getStartContainer().getNodeName().equals("H1"));
  363.             TASSERT(range.getStartOffset() == 2);
  364.             TASSERT(range.getEndContainer().getNodeName().equals("H1"));
  365.             TASSERT(range.getEndOffset() == 3);
  366.             TASSERT(E11.getChildNodes().getLength()==4);
  367.             TASSERT(E311.getChildNodes().getLength()==3);
  368.             TASSERT(range.toString().equals("insertedTexttle"));
  370.             //After above operations, now the tree looks like:
  371.             // <Body><Element3/><H1>ReplacedText<SurroundNode1><Element1/>insertedTexttle</SurroundNode1>Another Text</H1><Element2/><P>Blah xyz</P></Body>
  372.             //i.e.,            Body(rt)
  373.             //     _____________|_________________________________________________________________________
  374.             //     |                |                                                    |                |
  375.             //  Element3(E122)  ___H1(E11)___________________________________        Element2(E121)    P(E12)
  376.             //                  |              |     |                      |                            |
  377.             //               "ReplacedText"   ""   SurroundNode1(E311)  "Another Text"              "Blah xyz"
  378.             //                          ____________ |_____________________________
  379.             //                          |                    |                    |
  380.             //                          Element1(E120)   "insertedText"(E210)   "tle"
  381.             //
  382.             // range has H1 as start and end container and 2 as start offset, 3 as end offset
  384.             //testing cloning
  385.             DOM_Range aRange = range.cloneRange();
  387.             TASSERT(aRange.getStartContainer() == range.getStartContainer());
  388.             TASSERT(aRange.getEndContainer() == range.getEndContainer());
  389.             TASSERT(aRange.getStartOffset() == 2);
  390.             TASSERT(aRange.getEndOffset() == 3);
  391.             //changing the new ranges start
  392.             aRange.setStart(aRange.getStartContainer().getFirstChild(), 1);
  394.             //comparing the ranges
  395.             short compVal = range.compareBoundaryPoints(DOM_Range::END_TO_END, aRange);
  396.             TASSERT(compVal == 0);
  397.             compVal = range.compareBoundaryPoints(DOM_Range::START_TO_START, aRange);
  398.             TASSERT(compVal == 1);
  399.             compVal = range.compareBoundaryPoints(DOM_Range::START_TO_END, aRange);
  400.             TASSERT(compVal == 1);
  401.             compVal = range.compareBoundaryPoints(DOM_Range::END_TO_START, aRange);
  402.             TASSERT(compVal == -1);
  404.             //testing collapse
  405.             //not collapsed
  406.             TASSERT(range.getCollapsed() == false);
  407.             TASSERT(range.getStartOffset() == 2);
  408.             TASSERT(range.getEndOffset() == 3);
  410.             //selectNodeContents
  411.             range.selectNodeContents(rt.getLastChild().getFirstChild());
  412.             TASSERT(range.getStartContainer() == rt.getLastChild().getFirstChild());
  413.             TASSERT(range.getEndContainer() == rt.getLastChild().getFirstChild());
  414.             TASSERT(range.getStartOffset() == 0);
  415.             TASSERT(range.getEndOffset() == 8);
  416.             TASSERT(range.toString().equals("Blah xyz"));
  418.             //testing collapse
  419.             range.collapse(true); //collapse to start
  420.             TASSERT(range.getCollapsed() == true);
  421.             TASSERT(range.getStartOffset() == 0);
  422.             TASSERT(range.getEndOffset() == 0);
  423.             TASSERT(range.toString().equals(""));
  424.             TASSERT(aRange.getEndOffset() == 3); //other range is unaffected
  425.             TASSERT(aRange.toString().equals("eplacedTextinsertedTexttle"));
  427.             //After above operations, now the tree looks like:
  428.             // <Body><Element3/><H1>ReplacedText<SurroundNode1><Element1/>insertedTexttle</SurroundNode1>Another Text</H1><Element2/><P>Blah xyz</P></Body>
  429.             //i.e.,            Body(rt)
  430.             //     _____________|_________________________________________________________________________
  431.             //     |                |                                                    |                |
  432.             //  Element3(E122)  ___H1(E11)___________________________________        Element2(E121)    P(E12)
  433.             //                  |              |     |                      |                            |
  434.             //               "ReplacedText"   ""   SurroundNode1(E311)  "Another Text"              "Blah xyz"
  435.             //                          ____________ |_____________________________
  436.             //                          |                    |                    |
  437.             //                          Element1(E120)   "insertedText"(E210)   "tle"
  438.             //
  439.             // range has "Blah xyz" as start and end container and 0 as start and end offset (collapsed)
  440.             // aRange has "ReplacedText" as start container and H1 as end container
  441.             //    and 1 as start offset and 3 as end offset
  443.             DOM_DocumentFragment docFrag = aRange.cloneContents();
  444.             TASSERT( docFrag != 0);
  445.             range.selectNode(rt.getFirstChild());
  446.             TASSERT(range.getStartContainer() == rt);
  447.             TASSERT(range.getEndContainer() == rt);
  448.             TASSERT(range.getStartOffset() == 0);
  449.             TASSERT(range.getEndOffset() == 1);
  451.             //Testing toString()
  452.             const char* str = aRange.toString().transcode();
  453.             const char* str2 = "eplacedTextinsertedTexttle";
  454.             TASSERT(*str == *str2);
  456.             //start and end before and after tests
  457.             range.setStartBefore(rt.getFirstChild());
  458.             TASSERT(range.getStartOffset() == 0);
  459.             range.setEndBefore(rt.getFirstChild());
  460.             TASSERT(range.getEndOffset() == 0);
  461.             range.setStartAfter(rt.getLastChild());
  462.             TASSERT(range.getStartOffset() == 4);
  464.             range.setStartAfter(rt.getFirstChild());
  465.             TASSERT(range.getStartOffset() == 1);
  467.             range.setEndBefore(rt.getLastChild());
  468.             TASSERT(range.getEndOffset() == 3);
  470.             range.setEndAfter(rt.getLastChild());
  471.             TASSERT(range.getEndOffset() == 4);
  473.             //testing extract()
  474.             DOM_DocumentFragment frag2 = range.extractContents();
  475.             TASSERT( frag2 != 0);
  477.             //After above operations, now the tree looks like:
  478.             // <Body><Element3/></Body>
  479.             //i.e.,            Body(rt)
  480.             //                  |
  481.             //               Element3(E122)
  482.             //
  483.             // aRange has rt as start and end container, and 1 as start and end offset (collapsed)
  484.             // range has rt as start and end container, and 1 as start and end offset (collapsed)
  485.             //
  486.             //and frag2 looks:
  487.             // <Body>ReplacedText<SurroundNode1><Element1/>insertedTexttle</SurroundNode1>Another Text</H1><Element2/><P>Blah xyz</P></Body>
  488.             //i.e.,             Body(rt)
  489.             //      ______________|________________________________________________________
  490.             //      |                                                    |                |
  491.             //   ___H1(E11)___________________________________        Element2(E121)    P(E12)
  492.             //   |              |     |                      |                            |
  493.             //"ReplacedText"   ""   SurroundNode1(E311)  "Another Text"              "Blah xyz"
  494.             //           ____________ |_____________________________
  495.             //           |                    |                    |
  496.             //        Element1(E120)   "insertedText"(E210)   "tle"
  497.             //
  499.             //the tree do not have those node anymore after extract
  500.             //only Element3 left
  501.             TASSERT(rt.getChildNodes().getLength()==1);
  503.             //aRange is collapsed
  504.             TASSERT(aRange.getCollapsed() == true);
  505.             TASSERT(aRange.getStartContainer() == rt);
  506.             TASSERT(aRange.getStartOffset() == 1);
  507.             TASSERT(aRange.getEndContainer() == rt);
  508.             TASSERT(aRange.getEndOffset() == 1);
  510.             //range is collapsed as well
  511.             TASSERT(range.getCollapsed() == true);
  512.             TASSERT(range.getStartContainer() == rt);
  513.             TASSERT(range.getStartOffset() == 1);
  514.             TASSERT(range.getEndContainer() == rt);
  515.             TASSERT(range.getEndOffset() == 1);
  517.             //test the document fragment frag2
  518.             TASSERT(frag2.getChildNodes().getLength()==3);
  520.             //detaching the other range
  521.             aRange.detach();
  522.             range.detach();
  524.            //***************************************************************
  525.            //another set of test
  526.            //TEST createRange, setStart and setEnd, insertnode
  527.            //***************************************************************
  528.            DOM_Document doc2 = DOM_Document::createDocument();
  529.            DOM_Element root2 = doc2.createElement("root2");
  530.            doc2.appendChild(root2);
  531.            //case 1: simple text node, start==end
  532.            // <body>text1</body>
  533.            DOM_Element body = doc2.createElement("body");
  534.            DOM_Text text1 = doc2.createTextNode("text1");
  535.            body.appendChild(text1);
  536.            root2.appendChild(body);
  538.            //set range
  539.            DOM_Range range1 = doc2.createRange();
  540.            range1.setStart(text1,1);
  541.            range1.setEnd(text1,3);
  543.            TASSERT(range1.toString().equals("ex"));
  544.            TASSERT(range1.getStartOffset()==1);
  545.            TASSERT(range1.getStartContainer().getNodeValue().equals("text1"));
  546.            TASSERT(range1.getEndOffset()==3);
  547.            TASSERT(range1.getEndContainer().getNodeValue().equals("text1"));
  549.            //now insert a text node
  550.            //<body>ttext2ext1</body>
  551.            DOM_Text text2 = doc2.createTextNode("text2");
  552.            range1.insertNode(text2);
  554.            TASSERT(range1.toString().equals("text2ex"));
  555.            TASSERT(range1.getStartOffset()==1);
  556.            TASSERT(range1.getStartContainer().getNodeValue().equals("t"));
  557.            TASSERT(range1.getEndOffset()==2);
  558.            TASSERT(range1.getEndContainer().getNodeValue().equals("ext1"));
  560.            //now insert a non-text node
  561.            //<body>t<p1/>text2ext1</body>
  562.            DOM_Element p1 = doc2.createElement("p1");
  563.            range1.insertNode(p1);
  565.            TASSERT(range1.toString().equals("text2ex"));
  566.            TASSERT(range1.getStartOffset()==1);
  567.            TASSERT(range1.getStartContainer().getNodeValue().equals("t"));
  568.            TASSERT(range1.getEndOffset()==2);
  569.            TASSERT(range1.getEndContainer().getNodeValue().equals("ext1"));
  571.            //case 2: non-text node, start==end
  572.            // <head><h1/></head>
  573.            DOM_Element head = doc2.createElement("head");
  574.            DOM_Element h1 = doc2.createElement("h1");
  575.            head.appendChild(h1);
  576.            root2.appendChild(head);
  578.            //set range
  579.            DOM_Range range2 = doc2.createRange();
  580.            range2.setStart(head,0);
  581.            range2.setEnd(head,1);
  583.            TASSERT(range2.toString().equals(""));
  584.            TASSERT(range2.getStartOffset()==0);
  585.            TASSERT(range2.getStartContainer().getNodeName().equals("head"));
  586.            TASSERT(range2.getEndOffset()==1);
  587.            TASSERT(range2.getEndContainer().getNodeName().equals("head"));
  589.            //now insert a non-text node
  590.            //<head><h2/><h1/></head>
  591.            DOM_Element h2 = doc2.createElement("h2");
  592.            range2.insertNode(h2);
  594.            TASSERT(range2.toString().equals(""));
  595.            TASSERT(range2.getStartOffset()==0);
  596.            TASSERT(range2.getStartContainer().getNodeName().equals("head"));
  597.            TASSERT(range2.getEndOffset()==2);
  598.            TASSERT(range2.getEndContainer().getNodeName().equals("head"));
  600.            //now insert a text node
  601.            //<head>text5<h2/><h1/></head>
  602.            DOM_Text text5 = doc2.createTextNode("text5");
  603.            range2.insertNode(text5);
  605.            TASSERT(range2.toString().equals("text5"));
  606.            TASSERT(range2.getStartOffset()==0);
  607.            TASSERT(range2.getStartContainer().getNodeName().equals("head"));
  608.            TASSERT(range2.getEndOffset()==3);
  609.            TASSERT(range2.getEndContainer().getNodeName().equals("head"));
  611.            //case 3: simple text node, start!=end
  612.            // <body2>text3</body2>
  613.            DOM_Element body2 = doc2.createElement("body2");
  614.            DOM_Text text3 = doc2.createTextNode("text3");
  615.            body2.appendChild(text3);
  616.            root2.appendChild(body2);
  618.            //set range
  619.            DOM_Range range3 = doc2.createRange();
  620.            range3.setStart(text3,1);
  621.            range3.setEnd(body2,1);
  623.            TASSERT(range3.toString().equals("ext3"));
  624.            TASSERT(range3.getStartOffset()==1);
  625.            TASSERT(range3.getStartContainer().getNodeValue().equals("text3"));
  626.            TASSERT(range3.getEndOffset()==1);
  627.            TASSERT(range3.getEndContainer().getNodeName().equals("body2"));
  629.            //now insert a textnode
  630.            //<body2>ttext4ext3</body2>
  631.            DOM_Text text4 = doc2.createTextNode("text4");
  632.            range3.insertNode(text4);
  634.            TASSERT(range3.toString().equals(""));
  635.            TASSERT(range3.getStartOffset()==1);
  636.            TASSERT(range3.getStartContainer().getNodeValue().equals("t"));
  637.            TASSERT(range3.getEndOffset()==1);
  638.            TASSERT(range3.getEndContainer().getNodeName().equals("body2"));
  640.            //now insert a non-text node
  641.            //<body2>t<p2/>text4ext3</body2>
  642.            DOM_Element p2 = doc2.createElement("p2");
  643.            range3.insertNode(p2);
  645.            //extra empty node caused by splitting 't'
  646.            TASSERT(range3.toString().equals(""));
  647.            TASSERT(range3.getStartOffset()==1);
  648.            TASSERT(range3.getStartContainer().getNodeValue().equals("t"));
  649.            TASSERT(range3.getEndOffset()==1);
  650.            TASSERT(range3.getEndContainer().getNodeName().equals("body2"));
  652.            //test toString a bit
  653.            range3.setStart(body2,1);
  654.            range3.setEnd(body2,5);
  656.            TASSERT(range3.toString().equals("text4ext3"));
  658.            range3.setStart(body2,0);
  659.            range3.setEnd(body2,5);
  661.            TASSERT(range3.toString().equals("ttext4ext3"));
  663.            //case 4: non-text node, start!=end
  664.            // <head2><h3/></head2>
  665.            DOM_Element head2 = doc2.createElement("head2");
  666.            DOM_Element h3 = doc2.createElement("h3");
  667.            head2.appendChild(h3);
  668.            root2.appendChild(head2);
  670.            //set range
  671.            DOM_Range range4 = doc2.createRange();
  672.            range4.setStart(head2,0);
  673.            range4.setEnd(h3,0);
  675.            TASSERT(range4.toString().equals(""));
  676.            TASSERT(range4.getStartOffset()==0);
  677.            TASSERT(range4.getStartContainer().getNodeName().equals("head2"));
  678.            TASSERT(range4.getEndOffset()==0);
  679.            TASSERT(range4.getEndContainer().getNodeName().equals("h3"));
  681.            //now insert a non-text node
  682.            //<head2><h4/><h3/></head2>
  683.            DOM_Element h4 = doc2.createElement("h4");
  684.            range4.insertNode(h4);
  686.            TASSERT(range4.toString().equals(""));
  687.            TASSERT(range4.getStartOffset()==0);
  688.            TASSERT(range4.getStartContainer().getNodeName().equals("head2"));
  689.            TASSERT(range4.getEndOffset()==0);
  690.            TASSERT(range4.getEndContainer().getNodeName().equals("h3"));
  692.            //now insert a text node
  693.            //<head2>text6<h4/><h3/></head2>
  694.            DOM_Text text6 = doc2.createTextNode("text6");
  695.            range4.insertNode(text6);
  697.            TASSERT(range4.toString().equals("text6"));
  698.            TASSERT(range4.getStartOffset()==0);
  699.            TASSERT(range4.getStartContainer().getNodeName().equals("head2"));
  700.            TASSERT(range4.getEndOffset()==0);
  701.            TASSERT(range4.getEndContainer().getNodeName().equals("h3"));
  703.            //***************************************************************
  704.            // quick test of updating
  705.            //***************************************************************
  706.            // <upbody>text1</upbody>
  707.            DOM_Element upbody = doc2.createElement("upbody");
  708.            DOM_Text uptext1 = doc2.createTextNode("uptext1");
  709.            upbody.appendChild(uptext1);
  710.            root2.appendChild(upbody);
  712.            DOM_Range uprange = doc2.createRange();
  713.            uprange.setStart(upbody,0);
  714.            uprange.setEnd(upbody,1);
  716.            TASSERT(uprange.toString().equals("uptext1"));
  717.            TASSERT(uprange.getStartOffset()==0);
  718.            TASSERT(uprange.getStartContainer().getNodeName().equals("upbody"));
  719.            TASSERT(uprange.getEndOffset()==1);
  720.            TASSERT(uprange.getEndContainer().getNodeName().equals("upbody"));
  722.            // split text
  723.            uptext1.splitText(1);
  725.            TASSERT(uprange.toString().equals("u"));
  726.            TASSERT(uprange.getStartOffset()==0);
  727.            TASSERT(uprange.getStartContainer().getNodeName().equals("upbody"));
  728.            TASSERT(uprange.getEndOffset()==1);
  729.            TASSERT(uprange.getEndContainer().getNodeName().equals("upbody"));
  731.            //insert node
  732.            DOM_Element upbody2 = doc2.createElement("upbody2");
  733.            DOM_Text uptext2 = doc2.createTextNode("uptext2");
  734.            upbody2.appendChild(uptext2);
  735.            root2.appendChild(upbody2);
  737.            DOM_Range uprange2 = doc2.createRange();
  738.            uprange2.setStart(uptext2,1);
  739.            uprange2.setEnd(upbody2,1);
  741.            DOM_Range uprange3 = doc2.createRange();
  742.            uprange3.setStart(uptext2,1);
  743.            uprange3.setEnd(upbody2,1);
  745.            TASSERT(uprange2.toString().equals("ptext2"));
  746.            TASSERT(uprange2.getStartOffset()==1);
  747.            TASSERT(uprange2.getStartContainer().getNodeValue().equals("uptext2"));
  748.            TASSERT(uprange2.getEndOffset()==1);
  749.            TASSERT(uprange2.getEndContainer().getNodeName().equals("upbody2"));
  751.            TASSERT(uprange3.toString().equals("ptext2"));
  752.            TASSERT(uprange3.getStartOffset()==1);
  753.            TASSERT(uprange3.getStartContainer().getNodeValue().equals("uptext2"));
  754.            TASSERT(uprange3.getEndOffset()==1);
  755.            TASSERT(uprange3.getEndContainer().getNodeName().equals("upbody2"));
  757.            DOM_Element upp1 = doc2.createElement("upp1");
  758.            uprange2.insertNode(upp1);
  760.            TASSERT(uprange2.toString().equals(""));
  761.            TASSERT(uprange2.getStartOffset()==1);
  762.            TASSERT(uprange2.getStartContainer().getNodeValue().equals("u"));
  763.            TASSERT(uprange2.getEndOffset()==1);
  764.            TASSERT(uprange2.getEndContainer().getNodeName().equals("upbody2"));
  766.            TASSERT(uprange3.toString().equals(""));
  767.            TASSERT(uprange3.getStartOffset()==1);
  768.            TASSERT(uprange3.getStartContainer().getNodeValue().equals("u"));
  769.            TASSERT(uprange3.getEndOffset()==1);
  770.            TASSERT(uprange3.getEndContainer().getNodeName().equals("upbody2"));
  772.            //***************************************************************
  773.            //another set of test
  774.            //<foo><c/><moo><b/></moo>ab<a>Hello cd</a><cool>ef</cool></foo>
  775.            //
  776.            //  ______________________foo_____________________
  777.            //  |          |           |          |           |
  778.            //  c         moo        "ab"         a          cool
  779.            //             |                      |           |
  780.            //             b                    "Hello cd"   "ef"
  781.            //
  782.            DOM_Document doc3 = DOM_Document::createDocument();
  783.            DOM_Element root3 = doc3.createElement("root");
  784.            doc3.appendChild(root3);
  786.            DOM_Element foo = doc3.createElement("foo");
  787.            DOM_Element moo = doc3.createElement("moo");
  788.            DOM_Element cool = doc3.createElement("cool");
  789.            DOM_Text ab = doc3.createTextNode("ab");
  790.            DOM_Text cd = doc3.createTextNode("Hello cd");
  791.            DOM_Text ef = doc3.createTextNode("ef");
  793.            DOM_Element a = doc3.createElement("a");
  794.            DOM_Element b = doc3.createElement("b");
  795.            DOM_Element c = doc3.createElement("c");
  797.            root3.appendChild(foo);
  798.            foo.appendChild(c);
  799.            foo.appendChild(moo);
  800.            foo.appendChild(ab);
  801.            foo.appendChild(a);
  802.            foo.appendChild(cool);
  803.            moo.appendChild(b);
  804.            a.appendChild(cd);
  805.            cool.appendChild(ef);
  807.            //***************************************************************
  808.            //TEST toString
  809.            //***************************************************************
  810.            DOM_Range newtestrange = doc3.createRange();
  811.            //case 1:
  812.            //start container is text node
  813.            //   i) end container is also text node
  814.            //    a) start==end
  815.            //    b) start!=end
  816.            //  ii) end container is not text node
  817.            //    a) start==end => impossible
  818.            //    b) start!=end
  819.            //
  820.            //case 2:
  821.            //start container is not text node
  822.            //   i) end container is text node
  823.            //    a) start==end => impossible
  824.            //    b) start!=end
  825.            //  ii) end container is not text node
  826.            //    a) start==end
  827.            //    b) start!=end
  829.            //case 1, i, a
  830.            newtestrange.setStart( cd, 1 );
  831.            newtestrange.setEnd( cd, 4 );
  833.            TASSERT(newtestrange.toString().equals("ell"));
  835.            //case 1, i, b
  836.            newtestrange.setStart( cd, 1 );
  837.            newtestrange.setEnd( ef, 2 );
  839.            TASSERT(newtestrange.toString().equals("ello cdef"));
  841.            //case 1, ii, b
  842.            newtestrange.setStart( cd, 1 );
  843.            newtestrange.setEnd( foo, 4 );
  845.            TASSERT(newtestrange.toString().equals("ello cd"));
  847.            //case 2, i, b
  848.            newtestrange.setStart( foo, 1 );
  849.            newtestrange.setEnd( cd, 5 );
  851.            TASSERT(newtestrange.toString().equals("abHello"));
  853.            //case 2, ii, a
  854.            newtestrange.setStart( foo, 1 );
  855.            newtestrange.setEnd( foo, 4 );
  857.            TASSERT(newtestrange.toString().equals("abHello cd"));
  859.            //case 2, ii, b
  860.            newtestrange.setStart( moo, 1 );
  861.            newtestrange.setEnd( foo, 4 );
  863.            TASSERT(newtestrange.toString().equals("abHello cd"));
  865.            //***************************************************************
  866.            //test removeChild
  867.            //***************************************************************
  868.            DOM_Range newrange = doc3.createRange();
  869.            newrange.setStart( moo, 0 );
  870.            newrange.setEnd( foo, 4 );
  872.            TASSERT(newrange.getStartOffset()==0);
  873.            TASSERT(newrange.getStartContainer().getNodeName().equals("moo"));
  874.            TASSERT(newrange.getEndOffset()==4);
  875.            TASSERT(newrange.getEndContainer().getNodeName().equals("foo"));
  876.            TASSERT(newrange.toString().equals("abHello cd"));
  878.            DOM_Node n = newrange.cloneContents();
  879.            DOM_NodeList nol = foo.getChildNodes();
  881.            //removing moo
  882.            foo.removeChild(nol.item(1));
  883.            TASSERT(newrange.getStartOffset()==1);
  884.            TASSERT(newrange.getStartContainer().getNodeName().equals("foo"));
  885.            TASSERT(newrange.getEndOffset()==3);
  886.            TASSERT(newrange.getEndContainer().getNodeName().equals("foo"));
  887.            TASSERT(newrange.toString().equals("abHello cd"));
  889.            TASSERT(newtestrange.getStartOffset()==1);
  890.            TASSERT(newtestrange.getStartContainer().getNodeName().equals("foo"));
  891.            TASSERT(newtestrange.getEndOffset()==3);
  892.            TASSERT(newtestrange.getEndContainer().getNodeName().equals("foo"));
  893.            TASSERT(newtestrange.toString().equals("abHello cd"));
  895.     }
  896.     TESTEPILOG;
  899.     } //creating the dom tree and tests
  902.     //
  903.     //  Print Final allocation stats for full test
  904.     //
  905.     DomMemDebug().print();
  907.     // And call the termination method
  908.     XMLPlatformUtils::Terminate();
  910.     return 0;
  911. };