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

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

词法分析

开发平台：

Visual C++

RangeTest.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.  */
  59. /**
  60.  * $Id: RangeTest.cpp,v 1.14 2003/02/05 18:55:20 tng Exp $
  61.  */
  64. /** This IRangeTest 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 <xercesc/dom/DOM.hpp>
  72. #include <xercesc/util/PlatformUtils.hpp>
  73. #include <xercesc/util/XMLException.hpp>
  74. #include <xercesc/util/XMLString.hpp>
  75. #include <xercesc/util/XMLUni.hpp>
  76. #include <xercesc/util/XMLUniDefs.hpp>
  77. #include <xercesc/dom/DOMRange.hpp>
  80. XERCES_CPP_NAMESPACE_USE
  82. bool errorOccurred = false;
  84. #define TASSERT(c) tassert((c), __FILE__, __LINE__)
  86. void tassert(bool c, const char *file, int line)
  87. {
  88.     if (!c) {
  89.         errorOccurred = true;
  90.         printf("Failure.  Line %d,   file %sn", line, file);
  91.     }
  92. };
  95. #define EXCEPTION_TEST(operation, expected_exception)               
  96. {                                                                   
  97.     try {                                                           
  98.     operation;                                                      
  99.     printf(" Error: no exception thrown at line %dn", __LINE__);   
  100.     errorOccurred = true;                                           
  101.     }                                                               
  102.     catch (DOMRangeException &e) {                                  
  103.     if (e.code != expected_exception) {                             
  104.         printf(" Wrong RangeException code: %d at line %dn", e.code, __LINE__); 
  105.         errorOccurred = true;                                       
  106.     }                                                               
  107.     }                                                               
  108.     catch (DOMException &e) {                                       
  109.     if (e.code != expected_exception) {                             
  110.         printf(" Wrong exception code: %d at line %dn", e.code, __LINE__); 
  111.         errorOccurred = true;                                       
  112.     }                                                               
  113.     }                                                               
  114.     catch (...)   {                                                 
  115.         printf(" Wrong exception thrown at line %dn", __LINE__);   
  116.         errorOccurred = true;                                       
  117.     }                                                               
  118. }
  119. //Define a bunch of XMLCh* string for comparison
  120. XMLCh xa[] = {chLatin_a, chNull};
  121. XMLCh xab[] = {chLatin_a, chLatin_b, chNull};
  122. XMLCh xabHello[] = {chLatin_a, chLatin_b, chLatin_H, chLatin_e, chLatin_l, chLatin_l, chLatin_o, chNull};
  123. XMLCh xabHellocd[] = {chLatin_a, chLatin_b, chLatin_H, chLatin_e, chLatin_l, chLatin_l, chLatin_o, chSpace, chLatin_c, chLatin_d, chNull};
  124. XMLCh xAnotherText[] = {chLatin_A, chLatin_n, chLatin_o, chLatin_t, chLatin_h, chLatin_e, chLatin_r,
  125.      chLatin_T, chLatin_e, chLatin_x, chLatin_t, chNull};
  126. XMLCh xb[] = {chLatin_b, chNull};
  127. XMLCh xBlahxyz[] = {chLatin_B, chLatin_l, chLatin_a, chLatin_h, chSpace,
  128.      chLatin_x, chLatin_y, chLatin_z, chNull};
  129. XMLCh xBody[] = {chLatin_B, chLatin_o, chLatin_d, chLatin_y, chNull};
  130. XMLCh xbody2[] = {chLatin_b, chLatin_o, chLatin_d, chLatin_y, chDigit_2, chNull};
  131. XMLCh xc[] = {chLatin_c, chNull};
  132. XMLCh xcool[] = {chLatin_c, chLatin_o, chLatin_o, chLatin_l, chNull};
  133. XMLCh xef[] = {chLatin_e, chLatin_f, chNull};
  134. XMLCh xElement1[] = {chLatin_E, chLatin_l, chLatin_e, chLatin_m, chLatin_e, chLatin_n, chLatin_t, chDigit_1, chNull};
  135. XMLCh xElement2[] = {chLatin_E, chLatin_l, chLatin_e, chLatin_m, chLatin_e, chLatin_n, chLatin_t, chDigit_2, chNull};
  136. XMLCh xElement3[] = {chLatin_E, chLatin_l, chLatin_e, chLatin_m, chLatin_e, chLatin_n, chLatin_t, chDigit_3, chNull};
  137. XMLCh xell[] = {chLatin_e, chLatin_l, chLatin_l, chNull};
  138. XMLCh xellocd[] = {chLatin_e, chLatin_l, chLatin_l, chLatin_o, chSpace, chLatin_c, chLatin_d, chNull};
  139. XMLCh xellocdef[] = {chLatin_e, chLatin_l, chLatin_l, chLatin_o, chSpace, chLatin_c, chLatin_d, chLatin_e, chLatin_f, chNull};
  140. XMLCh xeplacedTextInsertedTexttle[] = {chLatin_e, chLatin_p, chLatin_l, chLatin_a, chLatin_c, chLatin_e, chLatin_d,
  141.      chLatin_T, chLatin_e, chLatin_x, chLatin_t, chLatin_I, chLatin_n, chLatin_s, chLatin_e, chLatin_r, chLatin_t, chLatin_e, chLatin_d,
  142.      chLatin_T, chLatin_e, chLatin_x, chLatin_t, chLatin_t, chLatin_l, chLatin_e, chNull};
  143. XMLCh xex[] = {chLatin_e, chLatin_x, chNull};
  144. XMLCh xext1[] = {chLatin_e, chLatin_x, chLatin_t, chDigit_1, chNull};
  145. XMLCh xext3[] = {chLatin_e, chLatin_x, chLatin_t, chDigit_3, chNull};
  146. XMLCh xfoo[] = {chLatin_f, chLatin_o, chLatin_o, chNull};
  147. XMLCh xH1[] = {chLatin_H, chDigit_1, chNull};
  148. XMLCh xh2[] = {chLatin_h, chDigit_2, chNull};
  149. XMLCh xh3[] = {chLatin_h, chDigit_3, chNull};
  150. XMLCh xh4[] = {chLatin_h, chDigit_4, chNull};
  151. XMLCh xHellocd[] = {chLatin_H, chLatin_e, chLatin_l, chLatin_l, chLatin_o, chSpace, chLatin_c, chLatin_d, chNull};
  152. XMLCh xhead[] = {chLatin_h, chLatin_e, chLatin_a, chLatin_d, chNull};
  153. XMLCh xhead2[] = {chLatin_h, chLatin_e, chLatin_a, chLatin_d, chDigit_2, chNull};
  154. XMLCh xInsertedText[] = {chLatin_I, chLatin_n, chLatin_s, chLatin_e, chLatin_r, chLatin_t, chLatin_e, chLatin_d,
  155.      chLatin_T, chLatin_e, chLatin_x, chLatin_t, chNull};
  156. XMLCh xInsertedTexttle[] = {chLatin_I, chLatin_n, chLatin_s, chLatin_e, chLatin_r, chLatin_t, chLatin_e, chLatin_d,
  157.      chLatin_T, chLatin_e, chLatin_x, chLatin_t, chLatin_t, chLatin_l, chLatin_e, chNull};
  158. XMLCh xmoo[] = {chLatin_m, chLatin_o, chLatin_o, chNull};
  159. XMLCh xroot[] = {chLatin_r, chLatin_o, chLatin_o, chLatin_t, chNull};
  160. XMLCh xroot2[] = {chLatin_r, chLatin_o, chLatin_o, chLatin_t, chDigit_2, chNull};
  161. XMLCh xP[] = {chLatin_P, chNull};
  162. XMLCh xp1[] = {chLatin_p, chDigit_1, chNull};
  163. XMLCh xp2[] = {chLatin_p, chDigit_2, chNull};
  164. XMLCh xptext2[] = {chLatin_p, chLatin_t, chLatin_e, chLatin_x, chLatin_t, chDigit_2, chNull};
  165. XMLCh xReplacedText[] = {chLatin_R, chLatin_e, chLatin_p, chLatin_l, chLatin_a, chLatin_c, chLatin_e, chLatin_d,
  166.      chLatin_T, chLatin_e, chLatin_x, chLatin_t, chNull};
  167. XMLCh xSurroundNode1[] = {chLatin_S, chLatin_u, chLatin_r, chLatin_r, chLatin_o, chLatin_u, chLatin_n, chLatin_d,
  168.       chLatin_N, chLatin_o, chLatin_d, chLatin_e, chDigit_1, chNull};
  169. XMLCh xt[] = {chLatin_t, chNull};
  170. XMLCh xtl[] = {chLatin_t, chLatin_l, chNull};
  171. XMLCh xtext1[] = {chLatin_t, chLatin_e, chLatin_x, chLatin_t, chDigit_1, chNull};
  172. XMLCh xtext2[] = {chLatin_t, chLatin_e, chLatin_x, chLatin_t, chDigit_2, chNull};
  173. XMLCh xtext2ex[] = {chLatin_t, chLatin_e, chLatin_x, chLatin_t, chDigit_2, chLatin_e, chLatin_x, chNull};
  174. XMLCh xtext3[] = {chLatin_t, chLatin_e, chLatin_x, chLatin_t, chDigit_3, chNull};
  175. XMLCh xtext4[] = {chLatin_t, chLatin_e, chLatin_x, chLatin_t, chDigit_4, chNull};
  176. XMLCh xtext4ext3[] = {chLatin_t, chLatin_e, chLatin_x, chLatin_t, chDigit_4, chLatin_e, chLatin_x, chLatin_t, chDigit_3, chNull};
  177. XMLCh xttext4ext3[] = {chLatin_t, chLatin_t, chLatin_e, chLatin_x, chLatin_t, chDigit_4, chLatin_e, chLatin_x, chLatin_t, chDigit_3, chNull};
  178. XMLCh xtext5[] = {chLatin_t, chLatin_e, chLatin_x, chLatin_t, chDigit_5, chNull};
  179. XMLCh xtext6[] = {chLatin_t, chLatin_e, chLatin_x, chLatin_t, chDigit_6, chNull};
  180. XMLCh xTi[] = {chLatin_T, chLatin_i, chNull};
  181. XMLCh xTitle[] = {chLatin_T, chLatin_i, chLatin_t, chLatin_l, chLatin_e, chNull};
  182. XMLCh xtle[] = {chLatin_t, chLatin_l, chLatin_e, chNull};
  183. XMLCh xu[] = {chLatin_u, chNull};
  184. XMLCh xupbody[] = {chLatin_u, chLatin_p, chLatin_b, chLatin_o, chLatin_d, chLatin_y, chNull};
  185. XMLCh xupbody2[] = {chLatin_u, chLatin_p, chLatin_b, chLatin_o, chLatin_d, chLatin_y, chDigit_2, chNull};
  186. XMLCh xupp1[] = {chLatin_u, chLatin_p, chLatin_p, chDigit_1, chNull};
  187. XMLCh xuptext1[] = {chLatin_u, chLatin_p, chLatin_t, chLatin_e, chLatin_x, chLatin_t, chDigit_1, chNull};
  188. XMLCh xuptext2[] = {chLatin_u, chLatin_p, chLatin_t, chLatin_e, chLatin_x, chLatin_t, chDigit_2, chNull};
  191. int  main()
  192. {
  193. try {
  194. XMLPlatformUtils::Initialize();
  195. }
  196. catch (const XMLException& toCatch) {
  197.         char *pMessage = XMLString::transcode(toCatch.getMessage());
  198.         fprintf(stderr, "Error during XMLPlatformUtils::Initialize(). n"
  199.                         "  Message is: %sn", pMessage);
  200.         XMLString::release(&pMessage);
  201.         return -1;
  202.     }
  204.     /*
  205.     Range tests include testing of
  207.     createRange
  209.     setStart, setStartBefore. setStartAfter,
  210.     setEnd, setEndBefore. setEndAfter
  211.     getStartContainer, getStartOffset
  212.     getEndContainer, getEndOffset
  213.     getCommonAncestorContainer
  214.     selectNode
  215.     selectNodeContents
  216.     insertNode
  217.     deleteContents
  218.     collapse
  219.     getCollapsed
  220.     surroundContents
  221.     compareBoundaryPoints
  222.     cloneRange
  223.     cloneContents
  224.     extractContents
  225.     toString
  226.     detach
  227.     removeChild
  228.     */
  229.     {
  231.         XMLCh tempStr[100];
  232.         XMLString::transcode("Range",tempStr,99);
  233.         {
  234.             DOMImplementation* impl = DOMImplementationRegistry::getDOMImplementation(tempStr);
  235.             DOMDocument* doc = impl->createDocument();
  237.             //Creating a root element
  238.             DOMElement*     root = doc->createElement(xBody);
  239.             doc->appendChild(root);
  241.             //Creating the siblings of root
  242.             DOMElement*     E11 = doc->createElement(xH1);
  243.             root->appendChild(E11);
  245.             DOMElement*     E12 = doc->createElement(xP);
  246.             root->appendChild(E12);
  248.             //Attaching texts to siblings
  249.             DOMText*        textNode1 = doc->createTextNode(xTitle);
  250.             E11->appendChild(textNode1);
  252.             DOMText*        textNode11 = doc->createTextNode(xAnotherText);
  253.             E11->appendChild(textNode11);
  255.             DOMText*        textNode2 = doc->createTextNode(xBlahxyz);
  256.             E12->appendChild(textNode2);
  258.             DOMText*     E210 = doc->createTextNode(xInsertedText);
  260.             doc->release();
  263.         }
  266.         {
  267.             //DOM Tree and some usable node creation
  268.             DOMImplementation* impl = DOMImplementationRegistry::getDOMImplementation(tempStr);
  269.             DOMDocument* doc = impl->createDocument();
  271.             //Creating a root element
  272.             DOMElement*     root = doc->createElement(xBody);
  273.             doc->appendChild(root);
  275.             //Creating the siblings of root
  276.             DOMElement*     E11 = doc->createElement(xH1);
  277.             root->appendChild(E11);
  279.             DOMElement*     E12 = doc->createElement(xP);
  280.             root->appendChild(E12);
  282.             //Attaching texts to siblings
  283.             DOMText*        textNode1 = doc->createTextNode(xTitle);
  284.             E11->appendChild(textNode1);
  286.             DOMText*        textNode11 = doc->createTextNode(xAnotherText);
  287.             E11->appendChild(textNode11);
  289.             DOMText*        textNode2 = doc->createTextNode(xBlahxyz);
  290.             E12->appendChild(textNode2);
  292.             //experimental nodes
  293.             DOMElement*     E120 = doc->createElement(xElement1);
  294.             DOMElement*     E121 = doc->createElement(xElement2);
  295.             DOMElement*     E122 = doc->createElement(xElement3);
  296.             DOMElement*     E311 = doc->createElement(xSurroundNode1);
  298.             DOMText*     E210 = doc->createTextNode(xInsertedText);
  300.             DOMNode* rt = doc->getDocumentElement();
  301.             DOMRange* range = ((DOMDocumentRange*)doc)->createRange();
  305.             //Tests start here
  306.             // Initial dom tree looks like :
  307.             // <Body><H1>TitleAnother Text</H1><P>Blah xyz</P></Body>
  308.             //i.e.,            Body(rt)
  309.             //     _____________|________________
  310.             //     |                           |
  311.             //  ___H1(E11)___                    P(E12)
  312.             //  |           |                    |
  313.             //  "Title"  "Another Text"        "Blah xyz"
  316.             //test for start and end settings of a range
  317.             range->setStart(rt->getFirstChild(), 0);
  318.             TASSERT(range->getStartContainer() == rt->getFirstChild() );
  319.             TASSERT(range->getStartOffset() == 0);
  321.             range->setEnd(rt->getFirstChild(), 1);
  322.             TASSERT(range->getEndContainer() == rt->getFirstChild() );
  323.             TASSERT(range->getEndOffset() == 1);
  326.             //DOMNode* node = range->getCommonAncestorContainer();
  327.             TASSERT(range->getCommonAncestorContainer() == rt->getFirstChild());
  329.             //selection related test
  330.             range->selectNode(rt->getLastChild());
  331.             TASSERT(range->getStartContainer() == rt);
  332.             TASSERT(range->getStartOffset() == 1);
  333.             TASSERT(range->getEndContainer() == rt);
  334.             TASSERT(range->getEndOffset() == 2);
  336.             //insertion related tests
  337.             range->insertNode(E120);
  339.             //only end offset moves and new node gets into range as being inserted at boundary point
  340.             TASSERT(range->getStartContainer() == rt);
  341.             TASSERT(range->getStartOffset() == 1);
  342.             TASSERT(range->getEndContainer() == rt);
  343.             TASSERT(range->getEndOffset() == 3);
  345.             range->insertNode(E121);
  346.             //only end offset moves and new node gets into range as being inserted at boundary point
  347.             TASSERT(range->getStartContainer() == rt);
  348.             TASSERT(range->getStartOffset() == 1);
  349.             TASSERT(range->getEndContainer() == rt);
  350.             TASSERT(range->getEndOffset() == 4);
  352.             rt->insertBefore(E122, rt->getFirstChild());
  353.             //both offsets move as new node is not part of the range
  354.             TASSERT(range->getStartContainer() == rt);
  355.             TASSERT(range->getStartOffset() == 2);
  356.             TASSERT(range->getEndContainer() == rt);
  357.             TASSERT(range->getEndOffset() == 5);
  359.             //After above operations, now the tree looks like:
  360.             // <Body><Element3/><H1>TitleAnother Text</H1><Element2/><Element1/><P>Blah xyz</P></Body>
  361.             //i.e.,            Body(rt)
  362.             //     _____________|_______________________________________________________________
  363.             //     |                |                  |                |                      |
  364.             //  Element3(E122)  ___H1(E11)___        Element2(E121)    Element1(E120)          P(E12)
  365.             //                  |           |                                                  |
  366.             //               "Title"  "Another Text"                                        "Blah xyz"
  367.             //
  368.             // range has rt as start and end container, and 2 as start offset, 5 as end offset
  370.             //changing selection
  371.             range->selectNode(rt->getLastChild()->getPreviousSibling());
  372.             TASSERT(range->getStartContainer() == rt);
  373.             TASSERT(range->getStartOffset() == 3);
  374.             TASSERT(range->getEndContainer() == rt);
  375.             TASSERT(range->getEndOffset() == 4);
  377.             //deleting related tests
  378.             range->deleteContents();
  379.             TASSERT(rt->getLastChild()->getPreviousSibling() == E121);
  381.             range->setStart(rt->getFirstChild()->getNextSibling()->getFirstChild(), 2);
  382.             TASSERT(range->getStartContainer() == rt->getFirstChild()->getNextSibling()->getFirstChild());
  383.             TASSERT(!XMLString::compareString(range->getStartContainer()->getNodeValue(),xTitle));
  384.             TASSERT(range->getStartOffset() == 2);
  386.             range->setEnd(rt->getFirstChild()->getNextSibling()->getFirstChild(), 4);
  387.             TASSERT(range->getEndContainer() == rt->getFirstChild()->getNextSibling()->getFirstChild());
  388.             TASSERT(!XMLString::compareString(range->getEndContainer()->getNodeValue(),xTitle));
  389.             TASSERT(range->getEndOffset() == 4);
  390.             TASSERT(!XMLString::compareString(range->toString(),xtl));
  392.             //inserting text between a text node
  393.             range->insertNode(E210);
  395.             //only end offset moves and new node gets into range as being inserted at boundary point
  396.             TASSERT(range->getStartContainer() == rt->getFirstChild()->getNextSibling()->getFirstChild());
  397.             TASSERT(range->getStartOffset() == 2);
  398.             TASSERT(range->getEndContainer() == rt->getFirstChild()->getNextSibling()->getLastChild()->getPreviousSibling());
  399.             TASSERT(range->getEndOffset() == 2);
  401.             //inserting element node before the selected text node
  402.             range->insertNode(E120);
  403.             //only end offset moves and new node gets into range as being inserted at boundary point
  404.             TASSERT(range->getStartContainer() == rt->getFirstChild()->getNextSibling()->getFirstChild());
  405.             TASSERT(!XMLString::compareString(range->getStartContainer()->getNodeValue(),xTi));
  406.             TASSERT(range->getStartOffset() == 2);
  407.             TASSERT(range->getEndContainer() == rt->getFirstChild()->getNextSibling()->getLastChild()->getPreviousSibling());
  408.             TASSERT(!XMLString::compareString(range->getEndContainer()->getNodeValue(),xtle));
  409.             TASSERT(range->getEndOffset() == 2);
  410.             TASSERT(E11->getChildNodes()->getLength()==6);
  412.            //checking the text replacment
  413.             range->getStartContainer()->setNodeValue(xReplacedText);
  414.             //only the start offset is impact
  415.             TASSERT(range->getStartContainer() == rt->getFirstChild()->getNextSibling()->getFirstChild());
  416.             TASSERT(!XMLString::compareString(range->getStartContainer()->getNodeValue(),xReplacedText));
  417.             TASSERT(range->getStartOffset() == 0);
  418.             TASSERT(range->getEndContainer() == rt->getFirstChild()->getNextSibling()->getLastChild()->getPreviousSibling());
  419.             TASSERT(!XMLString::compareString(range->getEndContainer()->getNodeValue(),xtle));
  420.             TASSERT(range->getEndOffset() == 2);
  422.             //After above operations, now the tree looks like:
  423.             // <Body><Element3/><H1>ReplacedText<Element1/>InsertedTexttleAnother Text</H1><Element2/><P>Blah xyz</P></Body>
  424.             //i.e.,            Body(rt)
  425.             //     _____________|_______________________________________________________________________________________________
  426.             //     |                |                                                                          |                |
  427.             //  Element3(E122)  ___H1(E11)___________________________________________________________        Element2(E121)    P(E12)
  428.             //                  |              |     |                |                      |      |                             |
  429.             //               "ReplacedText"   ""   Element1(E120)   "InsertedText"(E210)   "tle"  "Another Text"              "Blah xyz"
  430.             //
  431.             // range has "ReplacedText" as start container and "tle" as end container
  432.             //   and 0 as start offset, 2 as end offset
  434.             //changing the selection. Preparing for 'surround'
  435.             range->setStart(range->getStartContainer()->getParentNode(), 2);
  436.             range->setEnd(range->getStartContainer(), 5);
  437.             TASSERT(!XMLString::compareString(range->getStartContainer()->getNodeName(),xH1));
  438.             TASSERT(!XMLString::compareString(range->getEndContainer()->getNodeName(),xH1));
  439.             TASSERT(!XMLString::compareString(range->toString(),xInsertedTexttle));
  441.             range->surroundContents(E311);
  442.             TASSERT(!XMLString::compareString(range->getStartContainer()->getNodeName(),xH1));
  443.             TASSERT(range->getStartOffset() == 2);
  444.             TASSERT(!XMLString::compareString(range->getEndContainer()->getNodeName(),xH1));
  445.             TASSERT(range->getEndOffset() == 3);
  446.             TASSERT(E11->getChildNodes()->getLength()==4);
  447.             TASSERT(E311->getChildNodes()->getLength()==3);
  448.             TASSERT(!XMLString::compareString(range->toString(),xInsertedTexttle));
  450.             //After above operations, now the tree looks like:
  451.             // <Body><Element3/><H1>ReplacedText<SurroundNode1><Element1/>InsertedTexttle</SurroundNode1>Another Text</H1><Element2/><P>Blah xyz</P></Body>
  452.             //i.e.,            Body(rt)
  453.             //     _____________|_________________________________________________________________________
  454.             //     |                |                                                    |                |
  455.             //  Element3(E122)  ___H1(E11)___________________________________        Element2(E121)    P(E12)
  456.             //                  |              |     |                      |                            |
  457.             //               "ReplacedText"   ""   SurroundNode1(E311)  "Another Text"              "Blah xyz"
  458.             //                          ____________ |_____________________________
  459.             //                          |                    |                    |
  460.             //                          Element1(E120)   "InsertedText"(E210)   "tle"
  461.             //
  462.             // range has H1 as start and end container and 2 as start offset, 3 as end offset
  464.             //testing cloning
  465.             DOMRange* aRange = range->cloneRange();
  467.             TASSERT(aRange->getStartContainer() == range->getStartContainer());
  468.             TASSERT(aRange->getEndContainer() == range->getEndContainer());
  469.             TASSERT(aRange->getStartOffset() == 2);
  470.             TASSERT(aRange->getEndOffset() == 3);
  471.             //changing the new ranges start
  472.             aRange->setStart(aRange->getStartContainer()->getFirstChild(), 1);
  474.             //comparing the ranges
  475.             short compVal = range->compareBoundaryPoints(DOMRange::END_TO_END, aRange);
  476.             TASSERT(compVal == 0);
  477.             compVal = range->compareBoundaryPoints(DOMRange::START_TO_START, aRange);
  478.             TASSERT(compVal == 1);
  479.             compVal = range->compareBoundaryPoints(DOMRange::START_TO_END, aRange);
  480.             TASSERT(compVal == 1);
  481.             compVal = range->compareBoundaryPoints(DOMRange::END_TO_START, aRange);
  482.             TASSERT(compVal == -1);
  484.             //testing collapse
  485.             //not collapsed
  486.             TASSERT(range->getCollapsed() == false);
  487.             TASSERT(range->getStartOffset() == 2);
  488.             TASSERT(range->getEndOffset() == 3);
  490.             //selectNodeContents
  491.             range->selectNodeContents(rt->getLastChild()->getFirstChild());
  492.             TASSERT(range->getStartContainer() == rt->getLastChild()->getFirstChild());
  493.             TASSERT(range->getEndContainer() == rt->getLastChild()->getFirstChild());
  494.             TASSERT(range->getStartOffset() == 0);
  495.             TASSERT(range->getEndOffset() == 8);
  496.             TASSERT(!XMLString::compareString(range->toString(),xBlahxyz));
  498.             //testing collapse
  499.             range->collapse(true); //collapse to start
  500.             TASSERT(range->getCollapsed() == true);
  501.             TASSERT(range->getStartOffset() == 0);
  502.             TASSERT(range->getEndOffset() == 0);
  503.             TASSERT(!XMLString::compareString(range->toString(),XMLUni::fgZeroLenString));
  504.             TASSERT(aRange->getEndOffset() == 3); //other range is unaffected
  505.             TASSERT(!XMLString::compareString(aRange->toString(),xeplacedTextInsertedTexttle));
  507.             //After above operations, now the tree looks like:
  508.             // <Body><Element3/><H1>ReplacedText<SurroundNode1><Element1/>InsertedTexttle</SurroundNode1>Another Text</H1><Element2/><P>Blah xyz</P></Body>
  509.             //i.e.,            Body(rt)
  510.             //     _____________|_________________________________________________________________________
  511.             //     |                |                                                    |                |
  512.             //  Element3(E122)  ___H1(E11)___________________________________        Element2(E121)    P(E12)
  513.             //                  |              |     |                      |                            |
  514.             //               "ReplacedText"   ""   SurroundNode1(E311)  "Another Text"              "Blah xyz"
  515.             //                          ____________ |_____________________________
  516.             //                          |                    |                    |
  517.             //                          Element1(E120)   "InsertedText"(E210)   "tle"
  518.             //
  519.             // range has "Blah xyz" as start and end container and 0 as start and end offset (collapsed)
  520.             // aRange has "ReplacedText" as start container and H1 as end container
  521.             //    and 1 as start offset and 3 as end offset
  523.             DOMDocumentFragment* docFrag = aRange->cloneContents();
  524.             TASSERT( docFrag != 0);
  525.             range->selectNode(rt->getFirstChild());
  526.             TASSERT(range->getStartContainer() == rt);
  527.             TASSERT(range->getEndContainer() == rt);
  528.             TASSERT(range->getStartOffset() == 0);
  529.             TASSERT(range->getEndOffset() == 1);
  531.             //Testing toString()
  532.             const XMLCh* str = aRange->toString();
  533.             TASSERT(!XMLString::compareString(str, xeplacedTextInsertedTexttle));
  535.             //start and end before and after tests
  536.             range->setStartBefore(rt->getFirstChild());
  537.             TASSERT(range->getStartOffset() == 0);
  538.             range->setEndBefore(rt->getFirstChild());
  539.             TASSERT(range->getEndOffset() == 0);
  540.             range->setStartAfter(rt->getLastChild());
  541.             TASSERT(range->getStartOffset() == 4);
  543.             range->setStartAfter(rt->getFirstChild());
  544.             TASSERT(range->getStartOffset() == 1);
  546.             range->setEndBefore(rt->getLastChild());
  547.             TASSERT(range->getEndOffset() == 3);
  549.             range->setEndAfter(rt->getLastChild());
  550.             TASSERT(range->getEndOffset() == 4);
  552.             //testing extract()
  553.             DOMDocumentFragment* frag2 = range->extractContents();
  554.             TASSERT( frag2 != 0);
  556.             //After above operations, now the tree looks like:
  557.             // <Body><Element3/></Body>
  558.             //i.e.,            Body(rt)
  559.             //                  |
  560.             //               Element3(E122)
  561.             //
  562.             // aRange has rt as start and end container, and 1 as start and end offset (collapsed)
  563.             // range has rt as start and end container, and 1 as start and end offset (collapsed)
  564.             //
  565.             //and frag2 looks:
  566.             // <Body>ReplacedText<SurroundNode1><Element1/>InsertedTexttle</SurroundNode1>Another Text</H1><Element2/><P>Blah xyz</P></Body>
  567.             //i.e.,             Body(rt)
  568.             //      ______________|________________________________________________________
  569.             //      |                                                    |                |
  570.             //   ___H1(E11)___________________________________        Element2(E121)    P(E12)
  571.             //   |              |     |                      |                            |
  572.             //"ReplacedText"   ""   SurroundNode1(E311)  "Another Text"              "Blah xyz"
  573.             //           ____________ |_____________________________
  574.             //           |                    |                    |
  575.             //        Element1(E120)   "InsertedText"(E210)   "tle"
  576.             //
  578.             //the tree do not have those node anymore after extract
  579.             //only Element3 left
  580.             TASSERT(rt->getChildNodes()->getLength()==1);
  582.             //aRange is collapsed
  583.             TASSERT(aRange->getCollapsed() == true);
  584.             TASSERT(aRange->getStartContainer() == rt);
  585.             TASSERT(aRange->getStartOffset() == 1);
  586.             TASSERT(aRange->getEndContainer() == rt);
  587.             TASSERT(aRange->getEndOffset() == 1);
  589.             //range is collapsed as well
  590.             TASSERT(range->getCollapsed() == true);
  591.             TASSERT(range->getStartContainer() == rt);
  592.             TASSERT(range->getStartOffset() == 1);
  593.             TASSERT(range->getEndContainer() == rt);
  594.             TASSERT(range->getEndOffset() == 1);
  596.             //test the document fragment frag2
  597.             TASSERT(frag2->getChildNodes()->getLength()==3);
  599.             //detaching the other range
  600.             aRange->detach();
  601.             range->detach();
  603.             //***************************************************************
  604.             //another set of test
  605.             //TEST createRange, setStart and setEnd, insertnode
  606.             //***************************************************************
  607.             DOMImplementation* impl2 = DOMImplementationRegistry::getDOMImplementation(tempStr);
  608.             DOMDocument* doc2 = impl2->createDocument();
  610.             DOMElement* root2 = doc2->createElement(xroot2);
  611.             doc2->appendChild(root2);
  612.             //case 1: simple text node, start==end
  613.             // <body>text1</body>
  614.             DOMElement* body = doc2->createElement(xBody);
  615.             DOMText* text1 = doc2->createTextNode(xtext1);
  616.             body->appendChild(text1);
  617.             root2->appendChild(body);
  619.             //set range
  620.             DOMRange* range1 = doc2->createRange();
  621.             range1->setStart(text1,1);
  622.             range1->setEnd(text1,3);
  624.             TASSERT(!XMLString::compareString(range1->toString(),xex));
  625.             TASSERT(range1->getStartOffset()==1);
  626.             TASSERT(!XMLString::compareString(range1->getStartContainer()->getNodeValue(),xtext1));
  627.             TASSERT(range1->getEndOffset()==3);
  628.             TASSERT(!XMLString::compareString(range1->getEndContainer()->getNodeValue(),xtext1));
  630.             //now insert a text node
  631.             //<body>ttext2ext1</body>
  632.             DOMText* text2 = doc2->createTextNode(xtext2);
  633.             range1->insertNode(text2);
  635.             TASSERT(!XMLString::compareString(range1->toString(),xtext2ex));
  636.             TASSERT(range1->getStartOffset()==1);
  637.             TASSERT(!XMLString::compareString(range1->getStartContainer()->getNodeValue(),xt));
  638.             TASSERT(range1->getEndOffset()==2);
  639.             TASSERT(!XMLString::compareString(range1->getEndContainer()->getNodeValue(),xext1));
  641.             //now insert a non-text node
  642.             //<body>t<p1/>text2ext1</body>
  643.             DOMElement* p1 = doc2->createElement(xp1);
  644.             range1->insertNode(p1);
  646.             TASSERT(!XMLString::compareString(range1->toString(),xtext2ex));
  647.             TASSERT(range1->getStartOffset()==1);
  648.             TASSERT(!XMLString::compareString(range1->getStartContainer()->getNodeValue(),xt));
  649.             TASSERT(range1->getEndOffset()==2);
  650.             TASSERT(!XMLString::compareString(range1->getEndContainer()->getNodeValue(),xext1));
  652.             //case 2: non-text node, start==end
  653.             // <head><h1/></head>
  654.             DOMElement* head = doc2->createElement(xhead);
  655.             DOMElement* h1 = doc2->createElement(xH1);
  656.             head->appendChild(h1);
  657.             root2->appendChild(head);
  659.             //set range
  660.             DOMRange* range2 = doc2->createRange();
  661.             range2->setStart(head,0);
  662.             range2->setEnd(head,1);
  664.             TASSERT(!XMLString::compareString(range2->toString(),XMLUni::fgZeroLenString));
  665.             TASSERT(range2->getStartOffset()==0);
  666.             TASSERT(!XMLString::compareString(range2->getStartContainer()->getNodeName(),xhead));
  667.             TASSERT(range2->getEndOffset()==1);
  668.             TASSERT(!XMLString::compareString(range2->getEndContainer()->getNodeName(),xhead));
  670.             //now insert a non-text node
  671.             //<head><h2/><h1/></head>
  672.             DOMElement* h2 = doc2->createElement(xh2);
  673.             range2->insertNode(h2);
  675.             TASSERT(!XMLString::compareString(range2->toString(),XMLUni::fgZeroLenString));
  676.             TASSERT(range2->getStartOffset()==0);
  677.             TASSERT(!XMLString::compareString(range2->getStartContainer()->getNodeName(),xhead));
  678.             TASSERT(range2->getEndOffset()==2);
  679.             TASSERT(!XMLString::compareString(range2->getEndContainer()->getNodeName(),xhead));
  681.             //now insert a text node
  682.             //<head>text5<h2/><h1/></head>
  683.             DOMText* text5 = doc2->createTextNode(xtext5);
  684.             range2->insertNode(text5);
  686.             TASSERT(!XMLString::compareString(range2->toString(),xtext5));
  687.             TASSERT(range2->getStartOffset()==0);
  688.             TASSERT(!XMLString::compareString(range2->getStartContainer()->getNodeName(),xhead));
  689.             TASSERT(range2->getEndOffset()==3);
  690.             TASSERT(!XMLString::compareString(range2->getEndContainer()->getNodeName(),xhead));
  692.             //case 3: simple text node, start!=end
  693.             // <body2>text3</body2>
  694.             DOMElement* body2 = doc2->createElement(xbody2);
  695.             DOMText* text3 = doc2->createTextNode(xtext3);
  696.             body2->appendChild(text3);
  697.             root2->appendChild(body2);
  699.             //set range
  700.             DOMRange* range3 = ((DOMDocumentRange*)doc2)->createRange();
  701.             range3->setStart(text3,1);
  702.             range3->setEnd(body2,1);
  704.             TASSERT(!XMLString::compareString(range3->toString(),xext3));
  705.             TASSERT(range3->getStartOffset()==1);
  706.             TASSERT(!XMLString::compareString(range3->getStartContainer()->getNodeValue(),xtext3));
  707.             TASSERT(range3->getEndOffset()==1);
  708.             TASSERT(!XMLString::compareString(range3->getEndContainer()->getNodeName(),xbody2));
  710.             //now insert a textnode
  711.             //<body2>ttext4ext3</body2>
  712.             DOMText* text4 = doc2->createTextNode(xtext4);
  713.             range3->insertNode(text4);
  715.             TASSERT(!XMLString::compareString(range3->toString(),XMLUni::fgZeroLenString));
  716.             TASSERT(range3->getStartOffset()==1);
  717.             TASSERT(!XMLString::compareString(range3->getStartContainer()->getNodeValue(),xt));
  718.             TASSERT(range3->getEndOffset()==1);
  719.             TASSERT(!XMLString::compareString(range3->getEndContainer()->getNodeName(),xbody2));
  721.             //now insert a non-text node
  722.             //<body2>t<p2/>text4ext3</body2>
  723.             DOMElement* p2 = doc2->createElement(xp2);
  724.             range3->insertNode(p2);
  726.             //extra empty node caused by splitting 't'
  727.             TASSERT(!XMLString::compareString(range3->toString(),XMLUni::fgZeroLenString));
  728.             TASSERT(range3->getStartOffset()==1);
  729.             TASSERT(!XMLString::compareString(range3->getStartContainer()->getNodeValue(),xt));
  730.             TASSERT(range3->getEndOffset()==1);
  731.             TASSERT(!XMLString::compareString(range3->getEndContainer()->getNodeName(),xbody2));
  733.             //test toString a bit
  734.             range3->setStart(body2,1);
  735.             range3->setEnd(body2,5);
  737.             TASSERT(!XMLString::compareString(range3->toString(),xtext4ext3));
  739.             range3->setStart(body2,0);
  740.             range3->setEnd(body2,5);
  742.             TASSERT(!XMLString::compareString(range3->toString(),xttext4ext3));
  744.             //case 4: non-text node, start!=end
  745.             // <head2><h3/></head2>
  746.             DOMElement* head2 = doc2->createElement(xhead2);
  747.             DOMElement* h3 = doc2->createElement(xh3);
  748.             head2->appendChild(h3);
  749.             root2->appendChild(head2);
  751.             //set range
  752.             DOMRange* range4 = doc2->createRange();
  753.             range4->setStart(head2,0);
  754.             range4->setEnd(h3,0);
  756.             TASSERT(!XMLString::compareString(range4->toString(),XMLUni::fgZeroLenString));
  757.             TASSERT(range4->getStartOffset()==0);
  758.             TASSERT(!XMLString::compareString(range4->getStartContainer()->getNodeName(),xhead2));
  759.             TASSERT(range4->getEndOffset()==0);
  760.             TASSERT(!XMLString::compareString(range4->getEndContainer()->getNodeName(),xh3));
  762.             //now insert a non-text node
  763.             //<head2><h4/><h3/></head2>
  764.             DOMElement* h4 = doc2->createElement(xh4);
  765.             range4->insertNode(h4);
  767.             TASSERT(!XMLString::compareString(range4->toString(),XMLUni::fgZeroLenString));
  768.             TASSERT(range4->getStartOffset()==0);
  769.             TASSERT(!XMLString::compareString(range4->getStartContainer()->getNodeName(),xhead2));
  770.             TASSERT(range4->getEndOffset()==0);
  771.             TASSERT(!XMLString::compareString(range4->getEndContainer()->getNodeName(),xh3));
  773.             //now insert a text node
  774.             //<head2>text6<h4/><h3/></head2>
  775.             DOMText* text6 = doc2->createTextNode(xtext6);
  776.             range4->insertNode(text6);
  778.             TASSERT(!XMLString::compareString(range4->toString(),xtext6));
  779.             TASSERT(range4->getStartOffset()==0);
  780.             TASSERT(!XMLString::compareString(range4->getStartContainer()->getNodeName(),xhead2));
  781.             TASSERT(range4->getEndOffset()==0);
  782.             TASSERT(!XMLString::compareString(range4->getEndContainer()->getNodeName(),xh3));
  784.             //***************************************************************
  785.             // quick test of updating
  786.             //***************************************************************
  787.             // <upbody>text1</upbody>
  788.             DOMElement* upbody = doc2->createElement(xupbody);
  789.             DOMText* uptext1 = doc2->createTextNode(xuptext1);
  790.             upbody->appendChild(uptext1);
  791.             root2->appendChild(upbody);
  793.             DOMRange* uprange = ((DOMDocumentRange*)doc2)->createRange();
  794.             uprange->setStart(upbody,0);
  795.             uprange->setEnd(upbody,1);
  797.             TASSERT(!XMLString::compareString(uprange->toString(),xuptext1));
  798.             TASSERT(uprange->getStartOffset()==0);
  799.             TASSERT(!XMLString::compareString(uprange->getStartContainer()->getNodeName(),xupbody));
  800.             TASSERT(uprange->getEndOffset()==1);
  801.             TASSERT(!XMLString::compareString(uprange->getEndContainer()->getNodeName(),xupbody));
  803.             // split text
  804.             uptext1->splitText(1);
  806.             TASSERT(!XMLString::compareString(uprange->toString(),xu));
  807.             TASSERT(uprange->getStartOffset()==0);
  808.             TASSERT(!XMLString::compareString(uprange->getStartContainer()->getNodeName(),xupbody));
  809.             TASSERT(uprange->getEndOffset()==1);
  810.             TASSERT(!XMLString::compareString(uprange->getEndContainer()->getNodeName(),xupbody));
  812.             //insert node
  813.             DOMElement* upbody2 = doc2->createElement(xupbody2);
  814.             DOMText* uptext2 = doc2->createTextNode(xuptext2);
  815.             upbody2->appendChild(uptext2);
  816.             root2->appendChild(upbody2);
  818.             DOMRange* uprange2 = ((DOMDocumentRange*)doc2)->createRange();
  819.             uprange2->setStart(uptext2,1);
  820.             uprange2->setEnd(upbody2,1);
  822.             DOMRange* uprange3 = doc2->createRange();
  823.             uprange3->setStart(uptext2,1);
  824.             uprange3->setEnd(upbody2,1);
  826.             TASSERT(!XMLString::compareString(uprange2->toString(),xptext2));
  827.             TASSERT(uprange2->getStartOffset()==1);
  828.             TASSERT(!XMLString::compareString(uprange2->getStartContainer()->getNodeValue(),xuptext2));
  829.             TASSERT(uprange2->getEndOffset()==1);
  830.             TASSERT(!XMLString::compareString(uprange2->getEndContainer()->getNodeName(),xupbody2));
  832.             TASSERT(!XMLString::compareString(uprange3->toString(),xptext2));
  833.             TASSERT(uprange3->getStartOffset()==1);
  834.             TASSERT(!XMLString::compareString(uprange3->getStartContainer()->getNodeValue(),xuptext2));
  835.             TASSERT(uprange3->getEndOffset()==1);
  836.             TASSERT(!XMLString::compareString(uprange3->getEndContainer()->getNodeName(),xupbody2));
  838.             DOMElement* upp1 = doc2->createElement(xupp1);
  839.             uprange2->insertNode(upp1);
  841.             TASSERT(!XMLString::compareString(uprange2->toString(),XMLUni::fgZeroLenString));
  842.             TASSERT(uprange2->getStartOffset()==1);
  843.             TASSERT(!XMLString::compareString(uprange2->getStartContainer()->getNodeValue(),xu));
  844.             TASSERT(uprange2->getEndOffset()==1);
  845.             TASSERT(!XMLString::compareString(uprange2->getEndContainer()->getNodeName(),xupbody2));
  847.             TASSERT(!XMLString::compareString(uprange3->toString(),XMLUni::fgZeroLenString));
  848.             TASSERT(uprange3->getStartOffset()==1);
  849.             TASSERT(!XMLString::compareString(uprange3->getStartContainer()->getNodeValue(),xu));
  850.             TASSERT(uprange3->getEndOffset()==1);
  851.             TASSERT(!XMLString::compareString(uprange3->getEndContainer()->getNodeName(),xupbody2));
  853.             //***************************************************************
  854.             //another set of test
  855.             //<foo><c/><moo><b/></moo>ab<a>Hello cd</a><cool>ef</cool></foo>
  856.             //
  857.             //  ______________________foo_____________________
  858.             //  |          |           |          |           |
  859.             //  c         moo        "ab"         a          cool
  860.             //             |                      |           |
  861.             //             b                    "Hello cd"   "ef"
  862.             //
  863.             DOMImplementation* impl3 = DOMImplementationRegistry::getDOMImplementation(tempStr);
  864.             DOMDocument* doc3 = impl3->createDocument();
  866.             DOMElement* root3 = doc3->createElement(xroot);
  867.             doc3->appendChild(root3);
  869.             DOMElement* foo = doc3->createElement(xfoo);
  870.             DOMElement* moo = doc3->createElement(xmoo);
  871.             DOMElement* cool = doc3->createElement(xcool);
  872.             DOMText* ab = doc3->createTextNode(xab);
  873.             DOMText* cd = doc3->createTextNode(xHellocd);
  874.             DOMText* ef = doc3->createTextNode(xef);
  876.             DOMElement* a = doc3->createElement(xa);
  877.             DOMElement* b = doc3->createElement(xb);
  878.             DOMElement* c = doc3->createElement(xc);
  880.             root3->appendChild(foo);
  881.             foo->appendChild(c);
  882.             foo->appendChild(moo);
  883.             foo->appendChild(ab);
  884.             foo->appendChild(a);
  885.             foo->appendChild(cool);
  886.             moo->appendChild(b);
  887.             a->appendChild(cd);
  888.             cool->appendChild(ef);
  890.             //***************************************************************
  891.             //TEST toString
  892.             //***************************************************************
  893.             DOMRange* newtestrange = ((DOMDocumentRange*)doc3)->createRange();
  894.             //case 1:
  895.             //start container is text node
  896.             //   i) end container is also text node
  897.             //    a) start==end
  898.             //    b) start!=end
  899.             //  ii) end container is not text node
  900.             //    a) start==end => impossible
  901.             //    b) start!=end
  902.             //
  903.             //case 2:
  904.             //start container is not text node
  905.             //   i) end container is text node
  906.             //    a) start==end => impossible
  907.             //    b) start!=end
  908.             //  ii) end container is not text node
  909.             //    a) start==end
  910.             //    b) start!=end
  912.             //case 1, i, a
  913.             newtestrange->setStart( cd, 1 );
  914.             newtestrange->setEnd( cd, 4 );
  916.             TASSERT(!XMLString::compareString(newtestrange->toString(),xell));
  918.             //case 1, i, b
  919.             newtestrange->setStart( cd, 1 );
  920.             newtestrange->setEnd( ef, 2 );
  922.             TASSERT(!XMLString::compareString(newtestrange->toString(),xellocdef));
  924.             //case 1, ii, b
  925.             newtestrange->setStart( cd, 1 );
  926.             newtestrange->setEnd( foo, 4 );
  928.             TASSERT(!XMLString::compareString(newtestrange->toString(),xellocd));
  930.             //case 2, i, b
  931.             newtestrange->setStart( foo, 1 );
  932.             newtestrange->setEnd( cd, 5 );
  934.             TASSERT(!XMLString::compareString(newtestrange->toString(),xabHello));
  936.             //case 2, ii, a
  937.             newtestrange->setStart( foo, 1 );
  938.             newtestrange->setEnd( foo, 4 );
  940.             TASSERT(!XMLString::compareString(newtestrange->toString(),xabHellocd));
  942.             //case 2, ii, b
  943.             newtestrange->setStart( moo, 1 );
  944.             newtestrange->setEnd( foo, 4 );
  946.             TASSERT(!XMLString::compareString(newtestrange->toString(),xabHellocd));
  948.             //***************************************************************
  949.             //test removeChild
  950.             //***************************************************************
  951.             DOMRange* newrange = doc3->createRange();
  952.             newrange->setStart( moo, 0 );
  953.             newrange->setEnd( foo, 4 );
  955.             TASSERT(newrange->getStartOffset()==0);
  956.             TASSERT(!XMLString::compareString(newrange->getStartContainer()->getNodeName(),xmoo));
  957.             TASSERT(newrange->getEndOffset()==4);
  958.             TASSERT(!XMLString::compareString(newrange->getEndContainer()->getNodeName(),xfoo));
  959.             TASSERT(!XMLString::compareString(newrange->toString(),xabHellocd));
  961.             DOMNode* n = newrange->cloneContents();
  962.             DOMNodeList* nol = foo->getChildNodes();
  964.             //removing moo
  965.             DOMNode* rem = foo->removeChild(nol->item(1));
  966.             rem->release();
  967.             TASSERT(newrange->getStartOffset()==1);
  968.             TASSERT(!XMLString::compareString(newrange->getStartContainer()->getNodeName(),xfoo));
  969.             TASSERT(newrange->getEndOffset()==3);
  970.             TASSERT(!XMLString::compareString(newrange->getEndContainer()->getNodeName(),xfoo));
  971.             TASSERT(!XMLString::compareString(newrange->toString(),xabHellocd));
  973.             TASSERT(newtestrange->getStartOffset()==1);
  974.             TASSERT(!XMLString::compareString(newtestrange->getStartContainer()->getNodeName(),xfoo));
  975.             TASSERT(newtestrange->getEndOffset()==3);
  976.             TASSERT(!XMLString::compareString(newtestrange->getEndContainer()->getNodeName(),xfoo));
  977.             TASSERT(!XMLString::compareString(newtestrange->toString(),xabHellocd));
  979.             // Now do some exception test
  980.             newrange->detach();
  981.             EXCEPTION_TEST(newrange->setStart( moo, 0 ), DOMException::INVALID_STATE_ERR);
  982.             EXCEPTION_TEST(newtestrange->setStartBefore(moo), DOMRangeException::INVALID_NODE_TYPE_ERR);
  985.             doc->release();
  986.             doc2->release();
  987.             doc3->release();
  988.         }
  989.     } //creating the dom tree and tests
  991.     // And call the termination method
  992.     XMLPlatformUtils::Terminate();
  994.     if (errorOccurred) {
  995.         printf("Test Failedn");
  996.         return 4;
  997.     }
  999.     printf("Test Run Successfullyn");
  1001.     return 0;
  1002. };