source: icXML/icXML-devel/tests/src/DOM/RangeTest/RangeTest.cpp @ 2726

Last change on this file since 2726 was 2726, checked in by cameron, 7 years ago

Add original Xerces tests and samples directories

File size: 46.3 KB
Line 
1/*
2 * Licensed to the Apache Software Foundation (ASF) under one or more
3 * contributor license agreements.  See the NOTICE file distributed with
4 * this work for additional information regarding copyright ownership.
5 * The ASF licenses this file to You under the Apache License, Version 2.0
6 * (the "License"); you may not use this file except in compliance with
7 * the License.  You may obtain a copy of the License at
8 *
9 *      http://www.apache.org/licenses/LICENSE-2.0
10 *
11 * Unless required by applicable law or agreed to in writing, software
12 * distributed under the License is distributed on an "AS IS" BASIS,
13 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14 * See the License for the specific language governing permissions and
15 * limitations under the License.
16 */
17
18
19
20/**
21 * $Id: RangeTest.cpp 470088 2006-11-01 20:35:12Z amassari $
22 */
23
24
25/** This IRangeTest tests all of the cases delineated as examples
26 *  in the DOM Level 2 Range specification, and a few others.
27 *  <p>These do not by any means completely test the API and
28 *  corner cases.
29 */
30
31#include <stdio.h>
32#include <xercesc/dom/DOM.hpp>
33#include <xercesc/util/PlatformUtils.hpp>
34#include <xercesc/util/XMLException.hpp>
35#include <xercesc/util/XMLString.hpp>
36#include <xercesc/util/XMLUni.hpp>
37#include <xercesc/util/XMLUniDefs.hpp>
38#include <xercesc/dom/DOMRange.hpp>
39
40
41XERCES_CPP_NAMESPACE_USE
42
43bool errorOccurred = false;
44
45#define UNUSED(x) { if(x!=0){} }
46
47#define TASSERT(c) tassert((c), __FILE__, __LINE__)
48
49void tassert(bool c, const char *file, int line)
50{
51    if (!c) {
52        errorOccurred = true;
53        printf("Failure.  Line %d,   file %s\n", line, file);
54    }
55};
56
57
58#define EXCEPTION_TEST(operation, expected_exception)               \
59{                                                                   \
60    try {                                                           \
61    operation;                                                      \
62    printf(" Error: no exception thrown at line %d\n", __LINE__);   \
63    errorOccurred = true;                                           \
64    }                                                               \
65    catch (DOMRangeException &e) {                                  \
66    if (e.code != (DOMRangeException::RangeExceptionCode)expected_exception) {                             \
67        printf(" Wrong RangeException code: %d at line %d\n", e.code, __LINE__); \
68        errorOccurred = true;                                       \
69    }                                                               \
70    }                                                               \
71    catch (DOMException &e) {                                       \
72    if (e.code != (DOMException::ExceptionCode)expected_exception) {                             \
73        printf(" Wrong exception code: %d at line %d\n", e.code, __LINE__); \
74        errorOccurred = true;                                       \
75    }                                                               \
76    }                                                               \
77    catch (...)   {                                                 \
78        printf(" Wrong exception thrown at line %d\n", __LINE__);   \
79        errorOccurred = true;                                       \
80    }                                                               \
81}
82//Define a bunch of XMLCh* string for comparison
83XMLCh xa[] = {chLatin_a, chNull};
84XMLCh xab[] = {chLatin_a, chLatin_b, chNull};
85XMLCh xabHello[] = {chLatin_a, chLatin_b, chLatin_H, chLatin_e, chLatin_l, chLatin_l, chLatin_o, chNull};
86XMLCh xabHellocd[] = {chLatin_a, chLatin_b, chLatin_H, chLatin_e, chLatin_l, chLatin_l, chLatin_o, chSpace, chLatin_c, chLatin_d, chNull};
87XMLCh xAnotherText[] = {chLatin_A, chLatin_n, chLatin_o, chLatin_t, chLatin_h, chLatin_e, chLatin_r,
88     chLatin_T, chLatin_e, chLatin_x, chLatin_t, chNull};
89XMLCh xb[] = {chLatin_b, chNull};
90XMLCh xBlahxyz[] = {chLatin_B, chLatin_l, chLatin_a, chLatin_h, chSpace,
91     chLatin_x, chLatin_y, chLatin_z, chNull};
92XMLCh xBody[] = {chLatin_B, chLatin_o, chLatin_d, chLatin_y, chNull};
93XMLCh xbody2[] = {chLatin_b, chLatin_o, chLatin_d, chLatin_y, chDigit_2, chNull};
94XMLCh xc[] = {chLatin_c, chNull};
95XMLCh xcool[] = {chLatin_c, chLatin_o, chLatin_o, chLatin_l, chNull};
96XMLCh xef[] = {chLatin_e, chLatin_f, chNull};
97XMLCh xElement1[] = {chLatin_E, chLatin_l, chLatin_e, chLatin_m, chLatin_e, chLatin_n, chLatin_t, chDigit_1, chNull};
98XMLCh xElement2[] = {chLatin_E, chLatin_l, chLatin_e, chLatin_m, chLatin_e, chLatin_n, chLatin_t, chDigit_2, chNull};
99XMLCh xElement3[] = {chLatin_E, chLatin_l, chLatin_e, chLatin_m, chLatin_e, chLatin_n, chLatin_t, chDigit_3, chNull};
100XMLCh xell[] = {chLatin_e, chLatin_l, chLatin_l, chNull};
101XMLCh xellocd[] = {chLatin_e, chLatin_l, chLatin_l, chLatin_o, chSpace, chLatin_c, chLatin_d, chNull};
102XMLCh xellocdef[] = {chLatin_e, chLatin_l, chLatin_l, chLatin_o, chSpace, chLatin_c, chLatin_d, chLatin_e, chLatin_f, chNull};
103XMLCh xeplacedTextInsertedTexttle[] = {chLatin_e, chLatin_p, chLatin_l, chLatin_a, chLatin_c, chLatin_e, chLatin_d,
104     chLatin_T, chLatin_e, chLatin_x, chLatin_t, chLatin_I, chLatin_n, chLatin_s, chLatin_e, chLatin_r, chLatin_t, chLatin_e, chLatin_d,
105     chLatin_T, chLatin_e, chLatin_x, chLatin_t, chLatin_t, chLatin_l, chLatin_e, chNull};
106XMLCh xex[] = {chLatin_e, chLatin_x, chNull};
107XMLCh xext1[] = {chLatin_e, chLatin_x, chLatin_t, chDigit_1, chNull};
108XMLCh xext3[] = {chLatin_e, chLatin_x, chLatin_t, chDigit_3, chNull};
109XMLCh xfoo[] = {chLatin_f, chLatin_o, chLatin_o, chNull};
110XMLCh xH1[] = {chLatin_H, chDigit_1, chNull};
111XMLCh xh2[] = {chLatin_h, chDigit_2, chNull};
112XMLCh xh3[] = {chLatin_h, chDigit_3, chNull};
113XMLCh xh4[] = {chLatin_h, chDigit_4, chNull};
114XMLCh xHellocd[] = {chLatin_H, chLatin_e, chLatin_l, chLatin_l, chLatin_o, chSpace, chLatin_c, chLatin_d, chNull};
115XMLCh xhead[] = {chLatin_h, chLatin_e, chLatin_a, chLatin_d, chNull};
116XMLCh xhead2[] = {chLatin_h, chLatin_e, chLatin_a, chLatin_d, chDigit_2, chNull};
117XMLCh xInsertedText[] = {chLatin_I, chLatin_n, chLatin_s, chLatin_e, chLatin_r, chLatin_t, chLatin_e, chLatin_d,
118     chLatin_T, chLatin_e, chLatin_x, chLatin_t, chNull};
119XMLCh xInsertedTexttle[] = {chLatin_I, chLatin_n, chLatin_s, chLatin_e, chLatin_r, chLatin_t, chLatin_e, chLatin_d,
120     chLatin_T, chLatin_e, chLatin_x, chLatin_t, chLatin_t, chLatin_l, chLatin_e, chNull};
121XMLCh xmoo[] = {chLatin_m, chLatin_o, chLatin_o, chNull};
122XMLCh xroot[] = {chLatin_r, chLatin_o, chLatin_o, chLatin_t, chNull};
123XMLCh xroot2[] = {chLatin_r, chLatin_o, chLatin_o, chLatin_t, chDigit_2, chNull};
124XMLCh xP[] = {chLatin_P, chNull};
125XMLCh xp1[] = {chLatin_p, chDigit_1, chNull};
126XMLCh xp2[] = {chLatin_p, chDigit_2, chNull};
127XMLCh xptext2[] = {chLatin_p, chLatin_t, chLatin_e, chLatin_x, chLatin_t, chDigit_2, chNull};
128XMLCh xReplacedText[] = {chLatin_R, chLatin_e, chLatin_p, chLatin_l, chLatin_a, chLatin_c, chLatin_e, chLatin_d,
129     chLatin_T, chLatin_e, chLatin_x, chLatin_t, chNull};
130XMLCh xSurroundNode1[] = {chLatin_S, chLatin_u, chLatin_r, chLatin_r, chLatin_o, chLatin_u, chLatin_n, chLatin_d,
131      chLatin_N, chLatin_o, chLatin_d, chLatin_e, chDigit_1, chNull};
132XMLCh xt[] = {chLatin_t, chNull};
133XMLCh xtl[] = {chLatin_t, chLatin_l, chNull};
134XMLCh xtext1[] = {chLatin_t, chLatin_e, chLatin_x, chLatin_t, chDigit_1, chNull};
135XMLCh xtext2[] = {chLatin_t, chLatin_e, chLatin_x, chLatin_t, chDigit_2, chNull};
136XMLCh xtext2ex[] = {chLatin_t, chLatin_e, chLatin_x, chLatin_t, chDigit_2, chLatin_e, chLatin_x, chNull};
137XMLCh xtext3[] = {chLatin_t, chLatin_e, chLatin_x, chLatin_t, chDigit_3, chNull};
138XMLCh xtext4[] = {chLatin_t, chLatin_e, chLatin_x, chLatin_t, chDigit_4, chNull};
139XMLCh xtext4ext3[] = {chLatin_t, chLatin_e, chLatin_x, chLatin_t, chDigit_4, chLatin_e, chLatin_x, chLatin_t, chDigit_3, chNull};
140XMLCh xttext4ext3[] = {chLatin_t, chLatin_t, chLatin_e, chLatin_x, chLatin_t, chDigit_4, chLatin_e, chLatin_x, chLatin_t, chDigit_3, chNull};
141XMLCh xtext5[] = {chLatin_t, chLatin_e, chLatin_x, chLatin_t, chDigit_5, chNull};
142XMLCh xtext6[] = {chLatin_t, chLatin_e, chLatin_x, chLatin_t, chDigit_6, chNull};
143XMLCh xTi[] = {chLatin_T, chLatin_i, chNull};
144XMLCh xTitle[] = {chLatin_T, chLatin_i, chLatin_t, chLatin_l, chLatin_e, chNull};
145XMLCh xtle[] = {chLatin_t, chLatin_l, chLatin_e, chNull};
146XMLCh xu[] = {chLatin_u, chNull};
147XMLCh xupbody[] = {chLatin_u, chLatin_p, chLatin_b, chLatin_o, chLatin_d, chLatin_y, chNull};
148XMLCh xupbody2[] = {chLatin_u, chLatin_p, chLatin_b, chLatin_o, chLatin_d, chLatin_y, chDigit_2, chNull};
149XMLCh xupp1[] = {chLatin_u, chLatin_p, chLatin_p, chDigit_1, chNull};
150XMLCh xuptext1[] = {chLatin_u, chLatin_p, chLatin_t, chLatin_e, chLatin_x, chLatin_t, chDigit_1, chNull};
151XMLCh xuptext2[] = {chLatin_u, chLatin_p, chLatin_t, chLatin_e, chLatin_x, chLatin_t, chDigit_2, chNull};
152
153
154int  main()
155{
156        try {
157                XMLPlatformUtils::Initialize();
158        }
159        catch (const XMLException& toCatch) {
160        char *pMessage = XMLString::transcode(toCatch.getMessage());
161        fprintf(stderr, "Error during XMLPlatformUtils::Initialize(). \n"
162                        "  Message is: %s\n", pMessage);
163        XMLString::release(&pMessage);
164        return -1;
165    }
166
167    /*
168    Range tests include testing of
169
170    createRange
171
172    setStart, setStartBefore. setStartAfter,
173    setEnd, setEndBefore. setEndAfter
174    getStartContainer, getStartOffset
175    getEndContainer, getEndOffset
176    getCommonAncestorContainer
177    selectNode
178    selectNodeContents
179    insertNode
180    deleteContents
181    collapse
182    getCollapsed
183    surroundContents
184    compareBoundaryPoints
185    cloneRange
186    cloneContents
187    extractContents
188    toString
189    detach
190    removeChild
191    */
192    {
193
194        XMLCh tempStr[100];
195        XMLString::transcode("Range",tempStr,99);
196        {
197            DOMImplementation* impl = DOMImplementationRegistry::getDOMImplementation(tempStr);
198            DOMDocument* doc = impl->createDocument();
199
200            //Creating a root element
201            DOMElement*     root = doc->createElement(xBody);
202            doc->appendChild(root);
203
204            //Creating the siblings of root
205            DOMElement*     E11 = doc->createElement(xH1);
206            root->appendChild(E11);
207
208            DOMElement*     E12 = doc->createElement(xP);
209            root->appendChild(E12);
210
211            //Attaching texts to siblings
212            DOMText*        textNode1 = doc->createTextNode(xTitle);
213            E11->appendChild(textNode1);
214
215            DOMText*        textNode11 = doc->createTextNode(xAnotherText);
216            E11->appendChild(textNode11);
217
218            DOMText*        textNode2 = doc->createTextNode(xBlahxyz);
219            E12->appendChild(textNode2);
220
221            DOMText*     E210 = doc->createTextNode(xInsertedText);
222            UNUSED(E210); // silence warning
223            doc->release();
224
225
226        }
227
228
229        {
230            //DOM Tree and some usable node creation
231            DOMImplementation* impl = DOMImplementationRegistry::getDOMImplementation(tempStr);
232            DOMDocument* doc = impl->createDocument();
233
234            //Creating a root element
235            DOMElement*     root = doc->createElement(xBody);
236            doc->appendChild(root);
237
238            //Creating the siblings of root
239            DOMElement*     E11 = doc->createElement(xH1);
240            root->appendChild(E11);
241
242            DOMElement*     E12 = doc->createElement(xP);
243            root->appendChild(E12);
244
245            //Attaching texts to siblings
246            DOMText*        textNode1 = doc->createTextNode(xTitle);
247            E11->appendChild(textNode1);
248
249            DOMText*        textNode11 = doc->createTextNode(xAnotherText);
250            E11->appendChild(textNode11);
251
252            DOMText*        textNode2 = doc->createTextNode(xBlahxyz);
253            E12->appendChild(textNode2);
254
255            //experimental nodes
256            DOMElement*     E120 = doc->createElement(xElement1);
257            DOMElement*     E121 = doc->createElement(xElement2);
258            DOMElement*     E122 = doc->createElement(xElement3);
259            DOMElement*     E311 = doc->createElement(xSurroundNode1);
260
261            DOMText*     E210 = doc->createTextNode(xInsertedText);
262
263            DOMNode* rt = doc->getDocumentElement();
264            DOMRange* range = ((DOMDocumentRange*)doc)->createRange();
265
266
267
268            //Tests start here
269            // Initial dom tree looks like :
270            // <Body><H1>TitleAnother Text</H1><P>Blah xyz</P></Body>
271            //i.e.,            Body(rt)
272            //     _____________|________________
273            //     |                           |
274            //  ___H1(E11)___                    P(E12)
275            //  |           |                    |
276            //  "Title"  "Another Text"        "Blah xyz"
277
278
279            //test for start and end settings of a range
280            range->setStart(rt->getFirstChild(), 0);
281            TASSERT(range->getStartContainer() == rt->getFirstChild() );
282            TASSERT(range->getStartOffset() == 0);
283
284            range->setEnd(rt->getFirstChild(), 1);
285            TASSERT(range->getEndContainer() == rt->getFirstChild() );
286            TASSERT(range->getEndOffset() == 1);
287
288
289            //DOMNode* node = range->getCommonAncestorContainer();
290            TASSERT(range->getCommonAncestorContainer() == rt->getFirstChild());
291
292            //selection related test
293            range->selectNode(rt->getLastChild());
294            TASSERT(range->getStartContainer() == rt);
295            TASSERT(range->getStartOffset() == 1);
296            TASSERT(range->getEndContainer() == rt);
297            TASSERT(range->getEndOffset() == 2);
298
299            //insertion related tests
300            range->insertNode(E120);
301
302            //only end offset moves and new node gets into range as being inserted at boundary point
303            TASSERT(range->getStartContainer() == rt);
304            TASSERT(range->getStartOffset() == 1);
305            TASSERT(range->getEndContainer() == rt);
306            TASSERT(range->getEndOffset() == 3);
307
308            range->insertNode(E121);
309            //only end offset moves and new node gets into range as being inserted at boundary point
310            TASSERT(range->getStartContainer() == rt);
311            TASSERT(range->getStartOffset() == 1);
312            TASSERT(range->getEndContainer() == rt);
313            TASSERT(range->getEndOffset() == 4);
314
315            rt->insertBefore(E122, rt->getFirstChild());
316            //both offsets move as new node is not part of the range
317            TASSERT(range->getStartContainer() == rt);
318            TASSERT(range->getStartOffset() == 2);
319            TASSERT(range->getEndContainer() == rt);
320            TASSERT(range->getEndOffset() == 5);
321
322            //After above operations, now the tree looks like:
323            // <Body><Element3/><H1>TitleAnother Text</H1><Element2/><Element1/><P>Blah xyz</P></Body>
324            //i.e.,            Body(rt)
325            //     _____________|_______________________________________________________________
326            //     |                |                  |                |                      |
327            //  Element3(E122)  ___H1(E11)___        Element2(E121)    Element1(E120)          P(E12)
328            //                  |           |                                                  |
329            //               "Title"  "Another Text"                                        "Blah xyz"
330            //
331            // range has rt as start and end container, and 2 as start offset, 5 as end offset
332
333            //changing selection
334            range->selectNode(rt->getLastChild()->getPreviousSibling());
335            TASSERT(range->getStartContainer() == rt);
336            TASSERT(range->getStartOffset() == 3);
337            TASSERT(range->getEndContainer() == rt);
338            TASSERT(range->getEndOffset() == 4);
339
340            //deleting related tests
341            range->deleteContents();
342            TASSERT(rt->getLastChild()->getPreviousSibling() == E121);
343
344            range->setStart(rt->getFirstChild()->getNextSibling()->getFirstChild(), 2);
345            TASSERT(range->getStartContainer() == rt->getFirstChild()->getNextSibling()->getFirstChild());
346            TASSERT(!XMLString::compareString(range->getStartContainer()->getNodeValue(),xTitle));
347            TASSERT(range->getStartOffset() == 2);
348
349            range->setEnd(rt->getFirstChild()->getNextSibling()->getFirstChild(), 4);
350            TASSERT(range->getEndContainer() == rt->getFirstChild()->getNextSibling()->getFirstChild());
351            TASSERT(!XMLString::compareString(range->getEndContainer()->getNodeValue(),xTitle));
352            TASSERT(range->getEndOffset() == 4);
353            TASSERT(!XMLString::compareString(range->toString(),xtl));
354
355            //inserting text between a text node
356            range->insertNode(E210);
357
358            //only end offset moves and new node gets into range as being inserted at boundary point
359            TASSERT(range->getStartContainer() == rt->getFirstChild()->getNextSibling()->getFirstChild());
360            TASSERT(range->getStartOffset() == 2);
361            TASSERT(range->getEndContainer() == rt->getFirstChild()->getNextSibling()->getLastChild()->getPreviousSibling());
362            TASSERT(range->getEndOffset() == 2);
363
364            //inserting element node before the selected text node
365            range->insertNode(E120);
366            //only end offset moves and new node gets into range as being inserted at boundary point
367            TASSERT(range->getStartContainer() == rt->getFirstChild()->getNextSibling()->getFirstChild());
368            TASSERT(!XMLString::compareString(range->getStartContainer()->getNodeValue(),xTi));
369            TASSERT(range->getStartOffset() == 2);
370            TASSERT(range->getEndContainer() == rt->getFirstChild()->getNextSibling()->getLastChild()->getPreviousSibling());
371            TASSERT(!XMLString::compareString(range->getEndContainer()->getNodeValue(),xtle));
372            TASSERT(range->getEndOffset() == 2);
373            TASSERT(E11->getChildNodes()->getLength()==6);
374
375           //checking the text replacment
376            range->getStartContainer()->setNodeValue(xReplacedText);
377            //only the start offset is impact
378            TASSERT(range->getStartContainer() == rt->getFirstChild()->getNextSibling()->getFirstChild());
379            TASSERT(!XMLString::compareString(range->getStartContainer()->getNodeValue(),xReplacedText));
380            TASSERT(range->getStartOffset() == 0);
381            TASSERT(range->getEndContainer() == rt->getFirstChild()->getNextSibling()->getLastChild()->getPreviousSibling());
382            TASSERT(!XMLString::compareString(range->getEndContainer()->getNodeValue(),xtle));
383            TASSERT(range->getEndOffset() == 2);
384
385            //After above operations, now the tree looks like:
386            // <Body><Element3/><H1>ReplacedText<Element1/>InsertedTexttleAnother Text</H1><Element2/><P>Blah xyz</P></Body>
387            //i.e.,            Body(rt)
388            //     _____________|_______________________________________________________________________________________________
389            //     |                |                                                                          |                |
390            //  Element3(E122)  ___H1(E11)___________________________________________________________        Element2(E121)    P(E12)
391            //                  |              |     |                |                      |      |                             |
392            //               "ReplacedText"   ""   Element1(E120)   "InsertedText"(E210)   "tle"  "Another Text"              "Blah xyz"
393            //
394            // range has "ReplacedText" as start container and "tle" as end container
395            //   and 0 as start offset, 2 as end offset
396
397            //changing the selection. Preparing for 'surround'
398            range->setStart(range->getStartContainer()->getParentNode(), 2);
399            range->setEnd(range->getStartContainer(), 5);
400            TASSERT(!XMLString::compareString(range->getStartContainer()->getNodeName(),xH1));
401            TASSERT(!XMLString::compareString(range->getEndContainer()->getNodeName(),xH1));
402            TASSERT(!XMLString::compareString(range->toString(),xInsertedTexttle));
403
404            range->surroundContents(E311);
405            TASSERT(!XMLString::compareString(range->getStartContainer()->getNodeName(),xH1));
406            TASSERT(range->getStartOffset() == 2);
407            TASSERT(!XMLString::compareString(range->getEndContainer()->getNodeName(),xH1));
408            TASSERT(range->getEndOffset() == 3);
409            TASSERT(E11->getChildNodes()->getLength()==4);
410            TASSERT(E311->getChildNodes()->getLength()==3);
411            TASSERT(!XMLString::compareString(range->toString(),xInsertedTexttle));
412
413            //After above operations, now the tree looks like:
414            // <Body><Element3/><H1>ReplacedText<SurroundNode1><Element1/>InsertedTexttle</SurroundNode1>Another Text</H1><Element2/><P>Blah xyz</P></Body>
415            //i.e.,            Body(rt)
416            //     _____________|_________________________________________________________________________
417            //     |                |                                                    |                |
418            //  Element3(E122)  ___H1(E11)___________________________________        Element2(E121)    P(E12)
419            //                  |              |     |                      |                            |
420            //               "ReplacedText"   ""   SurroundNode1(E311)  "Another Text"              "Blah xyz"
421            //                          ____________ |_____________________________
422            //                          |                    |                    |
423            //                          Element1(E120)   "InsertedText"(E210)   "tle"
424            //
425            // range has H1 as start and end container and 2 as start offset, 3 as end offset
426
427            //testing cloning
428            DOMRange* aRange = range->cloneRange();
429
430            TASSERT(aRange->getStartContainer() == range->getStartContainer());
431            TASSERT(aRange->getEndContainer() == range->getEndContainer());
432            TASSERT(aRange->getStartOffset() == 2);
433            TASSERT(aRange->getEndOffset() == 3);
434            //changing the new ranges start
435            aRange->setStart(aRange->getStartContainer()->getFirstChild(), 1);
436
437            //comparing the ranges
438            short compVal = range->compareBoundaryPoints(DOMRange::END_TO_END, aRange);
439            TASSERT(compVal == 0);
440            compVal = range->compareBoundaryPoints(DOMRange::START_TO_START, aRange);
441            TASSERT(compVal == 1);
442            compVal = range->compareBoundaryPoints(DOMRange::START_TO_END, aRange);
443            TASSERT(compVal == 1);
444            compVal = range->compareBoundaryPoints(DOMRange::END_TO_START, aRange);
445            TASSERT(compVal == -1);
446
447            //testing collapse
448            //not collapsed
449            TASSERT(range->getCollapsed() == false);
450            TASSERT(range->getStartOffset() == 2);
451            TASSERT(range->getEndOffset() == 3);
452
453            //selectNodeContents
454            range->selectNodeContents(rt->getLastChild()->getFirstChild());
455            TASSERT(range->getStartContainer() == rt->getLastChild()->getFirstChild());
456            TASSERT(range->getEndContainer() == rt->getLastChild()->getFirstChild());
457            TASSERT(range->getStartOffset() == 0);
458            TASSERT(range->getEndOffset() == 8);
459            TASSERT(!XMLString::compareString(range->toString(),xBlahxyz));
460
461            //testing collapse
462            range->collapse(true); //collapse to start
463            TASSERT(range->getCollapsed() == true);
464            TASSERT(range->getStartOffset() == 0);
465            TASSERT(range->getEndOffset() == 0);
466            TASSERT(!XMLString::compareString(range->toString(),XMLUni::fgZeroLenString));
467            TASSERT(aRange->getEndOffset() == 3); //other range is unaffected
468            TASSERT(!XMLString::compareString(aRange->toString(),xeplacedTextInsertedTexttle));
469
470            //After above operations, now the tree looks like:
471            // <Body><Element3/><H1>ReplacedText<SurroundNode1><Element1/>InsertedTexttle</SurroundNode1>Another Text</H1><Element2/><P>Blah xyz</P></Body>
472            //i.e.,            Body(rt)
473            //     _____________|_________________________________________________________________________
474            //     |                |                                                    |                |
475            //  Element3(E122)  ___H1(E11)___________________________________        Element2(E121)    P(E12)
476            //                  |              |     |                      |                            |
477            //               "ReplacedText"   ""   SurroundNode1(E311)  "Another Text"              "Blah xyz"
478            //                          ____________ |_____________________________
479            //                          |                    |                    |
480            //                          Element1(E120)   "InsertedText"(E210)   "tle"
481            //
482            // range has "Blah xyz" as start and end container and 0 as start and end offset (collapsed)
483            // aRange has "ReplacedText" as start container and H1 as end container
484            //    and 1 as start offset and 3 as end offset
485
486            DOMDocumentFragment* docFrag = aRange->cloneContents();
487            TASSERT( docFrag != 0);
488            range->selectNode(rt->getFirstChild());
489            TASSERT(range->getStartContainer() == rt);
490            TASSERT(range->getEndContainer() == rt);
491            TASSERT(range->getStartOffset() == 0);
492            TASSERT(range->getEndOffset() == 1);
493
494            //Testing toString()
495            const XMLCh* str = aRange->toString();
496            TASSERT(!XMLString::compareString(str, xeplacedTextInsertedTexttle));
497
498            //start and end before and after tests
499            range->setStartBefore(rt->getFirstChild());
500            TASSERT(range->getStartOffset() == 0);
501            range->setEndBefore(rt->getFirstChild());
502            TASSERT(range->getEndOffset() == 0);
503            range->setStartAfter(rt->getLastChild());
504            TASSERT(range->getStartOffset() == 4);
505
506            range->setStartAfter(rt->getFirstChild());
507            TASSERT(range->getStartOffset() == 1);
508
509            range->setEndBefore(rt->getLastChild());
510            TASSERT(range->getEndOffset() == 3);
511
512            range->setEndAfter(rt->getLastChild());
513            TASSERT(range->getEndOffset() == 4);
514
515            //testing extract()
516            DOMDocumentFragment* frag2 = range->extractContents();
517            TASSERT( frag2 != 0);
518
519            //After above operations, now the tree looks like:
520            // <Body><Element3/></Body>
521            //i.e.,            Body(rt)
522            //                  |
523            //               Element3(E122)
524            //
525            // aRange has rt as start and end container, and 1 as start and end offset (collapsed)
526            // range has rt as start and end container, and 1 as start and end offset (collapsed)
527            //
528            //and frag2 looks:
529            // <Body>ReplacedText<SurroundNode1><Element1/>InsertedTexttle</SurroundNode1>Another Text</H1><Element2/><P>Blah xyz</P></Body>
530            //i.e.,             Body(rt)
531            //      ______________|________________________________________________________
532            //      |                                                    |                |
533            //   ___H1(E11)___________________________________        Element2(E121)    P(E12)
534            //   |              |     |                      |                            |
535            //"ReplacedText"   ""   SurroundNode1(E311)  "Another Text"              "Blah xyz"
536            //           ____________ |_____________________________
537            //           |                    |                    |
538            //        Element1(E120)   "InsertedText"(E210)   "tle"
539            //
540
541            //the tree do not have those node anymore after extract
542            //only Element3 left
543            TASSERT(rt->getChildNodes()->getLength()==1);
544
545            //aRange is collapsed
546            TASSERT(aRange->getCollapsed() == true);
547            TASSERT(aRange->getStartContainer() == rt);
548            TASSERT(aRange->getStartOffset() == 1);
549            TASSERT(aRange->getEndContainer() == rt);
550            TASSERT(aRange->getEndOffset() == 1);
551
552            //range is collapsed as well
553            TASSERT(range->getCollapsed() == true);
554            TASSERT(range->getStartContainer() == rt);
555            TASSERT(range->getStartOffset() == 1);
556            TASSERT(range->getEndContainer() == rt);
557            TASSERT(range->getEndOffset() == 1);
558
559            //test the document fragment frag2
560            TASSERT(frag2->getChildNodes()->getLength()==3);
561
562            //detaching the other range
563            aRange->detach();
564            range->detach();
565
566            //***************************************************************
567            //another set of test
568            //TEST createRange, setStart and setEnd, insertnode
569            //***************************************************************
570            DOMImplementation* impl2 = DOMImplementationRegistry::getDOMImplementation(tempStr);
571            DOMDocument* doc2 = impl2->createDocument();
572
573            DOMElement* root2 = doc2->createElement(xroot2);
574            doc2->appendChild(root2);
575            //case 1: simple text node, start==end
576            // <body>text1</body>
577            DOMElement* body = doc2->createElement(xBody);
578            DOMText* text1 = doc2->createTextNode(xtext1);
579            body->appendChild(text1);
580            root2->appendChild(body);
581
582            //set range
583            DOMRange* range1 = doc2->createRange();
584            range1->setStart(text1,1);
585            range1->setEnd(text1,3);
586
587            TASSERT(!XMLString::compareString(range1->toString(),xex));
588            TASSERT(range1->getStartOffset()==1);
589            TASSERT(!XMLString::compareString(range1->getStartContainer()->getNodeValue(),xtext1));
590            TASSERT(range1->getEndOffset()==3);
591            TASSERT(!XMLString::compareString(range1->getEndContainer()->getNodeValue(),xtext1));
592
593            //now insert a text node
594            //<body>ttext2ext1</body>
595            DOMText* text2 = doc2->createTextNode(xtext2);
596            range1->insertNode(text2);
597
598            TASSERT(!XMLString::compareString(range1->toString(),xtext2ex));
599            TASSERT(range1->getStartOffset()==1);
600            TASSERT(!XMLString::compareString(range1->getStartContainer()->getNodeValue(),xt));
601            TASSERT(range1->getEndOffset()==2);
602            TASSERT(!XMLString::compareString(range1->getEndContainer()->getNodeValue(),xext1));
603
604            //now insert a non-text node
605            //<body>t<p1/>text2ext1</body>
606            DOMElement* p1 = doc2->createElement(xp1);
607            range1->insertNode(p1);
608
609            TASSERT(!XMLString::compareString(range1->toString(),xtext2ex));
610            TASSERT(range1->getStartOffset()==1);
611            TASSERT(!XMLString::compareString(range1->getStartContainer()->getNodeValue(),xt));
612            TASSERT(range1->getEndOffset()==2);
613            TASSERT(!XMLString::compareString(range1->getEndContainer()->getNodeValue(),xext1));
614
615            //case 2: non-text node, start==end
616            // <head><h1/></head>
617            DOMElement* head = doc2->createElement(xhead);
618            DOMElement* h1 = doc2->createElement(xH1);
619            head->appendChild(h1);
620            root2->appendChild(head);
621
622            //set range
623            DOMRange* range2 = doc2->createRange();
624            range2->setStart(head,0);
625            range2->setEnd(head,1);
626
627            TASSERT(!XMLString::compareString(range2->toString(),XMLUni::fgZeroLenString));
628            TASSERT(range2->getStartOffset()==0);
629            TASSERT(!XMLString::compareString(range2->getStartContainer()->getNodeName(),xhead));
630            TASSERT(range2->getEndOffset()==1);
631            TASSERT(!XMLString::compareString(range2->getEndContainer()->getNodeName(),xhead));
632
633            //now insert a non-text node
634            //<head><h2/><h1/></head>
635            DOMElement* h2 = doc2->createElement(xh2);
636            range2->insertNode(h2);
637
638            TASSERT(!XMLString::compareString(range2->toString(),XMLUni::fgZeroLenString));
639            TASSERT(range2->getStartOffset()==0);
640            TASSERT(!XMLString::compareString(range2->getStartContainer()->getNodeName(),xhead));
641            TASSERT(range2->getEndOffset()==2);
642            TASSERT(!XMLString::compareString(range2->getEndContainer()->getNodeName(),xhead));
643
644            //now insert a text node
645            //<head>text5<h2/><h1/></head>
646            DOMText* text5 = doc2->createTextNode(xtext5);
647            range2->insertNode(text5);
648
649            TASSERT(!XMLString::compareString(range2->toString(),xtext5));
650            TASSERT(range2->getStartOffset()==0);
651            TASSERT(!XMLString::compareString(range2->getStartContainer()->getNodeName(),xhead));
652            TASSERT(range2->getEndOffset()==3);
653            TASSERT(!XMLString::compareString(range2->getEndContainer()->getNodeName(),xhead));
654
655            //case 3: simple text node, start!=end
656            // <body2>text3</body2>
657            DOMElement* body2 = doc2->createElement(xbody2);
658            DOMText* text3 = doc2->createTextNode(xtext3);
659            body2->appendChild(text3);
660            root2->appendChild(body2);
661
662            //set range
663            DOMRange* range3 = ((DOMDocumentRange*)doc2)->createRange();
664            range3->setStart(text3,1);
665            range3->setEnd(body2,1);
666
667            TASSERT(!XMLString::compareString(range3->toString(),xext3));
668            TASSERT(range3->getStartOffset()==1);
669            TASSERT(!XMLString::compareString(range3->getStartContainer()->getNodeValue(),xtext3));
670            TASSERT(range3->getEndOffset()==1);
671            TASSERT(!XMLString::compareString(range3->getEndContainer()->getNodeName(),xbody2));
672
673            //now insert a textnode
674            //<body2>ttext4ext3</body2>
675            DOMText* text4 = doc2->createTextNode(xtext4);
676            range3->insertNode(text4);
677
678            TASSERT(!XMLString::compareString(range3->toString(),XMLUni::fgZeroLenString));
679            TASSERT(range3->getStartOffset()==1);
680            TASSERT(!XMLString::compareString(range3->getStartContainer()->getNodeValue(),xt));
681            TASSERT(range3->getEndOffset()==1);
682            TASSERT(!XMLString::compareString(range3->getEndContainer()->getNodeName(),xbody2));
683
684            //now insert a non-text node
685            //<body2>t<p2/>text4ext3</body2>
686            DOMElement* p2 = doc2->createElement(xp2);
687            range3->insertNode(p2);
688
689            //extra empty node caused by splitting 't'
690            TASSERT(!XMLString::compareString(range3->toString(),XMLUni::fgZeroLenString));
691            TASSERT(range3->getStartOffset()==1);
692            TASSERT(!XMLString::compareString(range3->getStartContainer()->getNodeValue(),xt));
693            TASSERT(range3->getEndOffset()==1);
694            TASSERT(!XMLString::compareString(range3->getEndContainer()->getNodeName(),xbody2));
695
696            //test toString a bit
697            range3->setStart(body2,1);
698            range3->setEnd(body2,5);
699
700            TASSERT(!XMLString::compareString(range3->toString(),xtext4ext3));
701
702            range3->setStart(body2,0);
703            range3->setEnd(body2,5);
704
705            TASSERT(!XMLString::compareString(range3->toString(),xttext4ext3));
706
707            //case 4: non-text node, start!=end
708            // <head2><h3/></head2>
709            DOMElement* head2 = doc2->createElement(xhead2);
710            DOMElement* h3 = doc2->createElement(xh3);
711            head2->appendChild(h3);
712            root2->appendChild(head2);
713
714            //set range
715            DOMRange* range4 = doc2->createRange();
716            range4->setStart(head2,0);
717            range4->setEnd(h3,0);
718
719            TASSERT(!XMLString::compareString(range4->toString(),XMLUni::fgZeroLenString));
720            TASSERT(range4->getStartOffset()==0);
721            TASSERT(!XMLString::compareString(range4->getStartContainer()->getNodeName(),xhead2));
722            TASSERT(range4->getEndOffset()==0);
723            TASSERT(!XMLString::compareString(range4->getEndContainer()->getNodeName(),xh3));
724
725            //now insert a non-text node
726            //<head2><h4/><h3/></head2>
727            DOMElement* h4 = doc2->createElement(xh4);
728            range4->insertNode(h4);
729
730            TASSERT(!XMLString::compareString(range4->toString(),XMLUni::fgZeroLenString));
731            TASSERT(range4->getStartOffset()==0);
732            TASSERT(!XMLString::compareString(range4->getStartContainer()->getNodeName(),xhead2));
733            TASSERT(range4->getEndOffset()==0);
734            TASSERT(!XMLString::compareString(range4->getEndContainer()->getNodeName(),xh3));
735
736            //now insert a text node
737            //<head2>text6<h4/><h3/></head2>
738            DOMText* text6 = doc2->createTextNode(xtext6);
739            range4->insertNode(text6);
740
741            TASSERT(!XMLString::compareString(range4->toString(),xtext6));
742            TASSERT(range4->getStartOffset()==0);
743            TASSERT(!XMLString::compareString(range4->getStartContainer()->getNodeName(),xhead2));
744            TASSERT(range4->getEndOffset()==0);
745            TASSERT(!XMLString::compareString(range4->getEndContainer()->getNodeName(),xh3));
746
747            //***************************************************************
748            // quick test of updating
749            //***************************************************************
750            // <upbody>text1</upbody>
751            DOMElement* upbody = doc2->createElement(xupbody);
752            DOMText* uptext1 = doc2->createTextNode(xuptext1);
753            upbody->appendChild(uptext1);
754            root2->appendChild(upbody);
755
756            DOMRange* uprange = ((DOMDocumentRange*)doc2)->createRange();
757            uprange->setStart(upbody,0);
758            uprange->setEnd(upbody,1);
759
760            TASSERT(!XMLString::compareString(uprange->toString(),xuptext1));
761            TASSERT(uprange->getStartOffset()==0);
762            TASSERT(!XMLString::compareString(uprange->getStartContainer()->getNodeName(),xupbody));
763            TASSERT(uprange->getEndOffset()==1);
764            TASSERT(!XMLString::compareString(uprange->getEndContainer()->getNodeName(),xupbody));
765
766            // split text
767            uptext1->splitText(1);
768
769            TASSERT(!XMLString::compareString(uprange->toString(),xu));
770            TASSERT(uprange->getStartOffset()==0);
771            TASSERT(!XMLString::compareString(uprange->getStartContainer()->getNodeName(),xupbody));
772            TASSERT(uprange->getEndOffset()==1);
773            TASSERT(!XMLString::compareString(uprange->getEndContainer()->getNodeName(),xupbody));
774
775            //insert node
776            DOMElement* upbody2 = doc2->createElement(xupbody2);
777            DOMText* uptext2 = doc2->createTextNode(xuptext2);
778            upbody2->appendChild(uptext2);
779            root2->appendChild(upbody2);
780
781            DOMRange* uprange2 = ((DOMDocumentRange*)doc2)->createRange();
782            uprange2->setStart(uptext2,1);
783            uprange2->setEnd(upbody2,1);
784
785            DOMRange* uprange3 = doc2->createRange();
786            uprange3->setStart(uptext2,1);
787            uprange3->setEnd(upbody2,1);
788
789            TASSERT(!XMLString::compareString(uprange2->toString(),xptext2));
790            TASSERT(uprange2->getStartOffset()==1);
791            TASSERT(!XMLString::compareString(uprange2->getStartContainer()->getNodeValue(),xuptext2));
792            TASSERT(uprange2->getEndOffset()==1);
793            TASSERT(!XMLString::compareString(uprange2->getEndContainer()->getNodeName(),xupbody2));
794
795            TASSERT(!XMLString::compareString(uprange3->toString(),xptext2));
796            TASSERT(uprange3->getStartOffset()==1);
797            TASSERT(!XMLString::compareString(uprange3->getStartContainer()->getNodeValue(),xuptext2));
798            TASSERT(uprange3->getEndOffset()==1);
799            TASSERT(!XMLString::compareString(uprange3->getEndContainer()->getNodeName(),xupbody2));
800
801            DOMElement* upp1 = doc2->createElement(xupp1);
802            uprange2->insertNode(upp1);
803
804            TASSERT(!XMLString::compareString(uprange2->toString(),XMLUni::fgZeroLenString));
805            TASSERT(uprange2->getStartOffset()==1);
806            TASSERT(!XMLString::compareString(uprange2->getStartContainer()->getNodeValue(),xu));
807            TASSERT(uprange2->getEndOffset()==1);
808            TASSERT(!XMLString::compareString(uprange2->getEndContainer()->getNodeName(),xupbody2));
809
810            TASSERT(!XMLString::compareString(uprange3->toString(),XMLUni::fgZeroLenString));
811            TASSERT(uprange3->getStartOffset()==1);
812            TASSERT(!XMLString::compareString(uprange3->getStartContainer()->getNodeValue(),xu));
813            TASSERT(uprange3->getEndOffset()==1);
814            TASSERT(!XMLString::compareString(uprange3->getEndContainer()->getNodeName(),xupbody2));
815
816            //***************************************************************
817            //another set of test
818            //<foo><c/><moo><b/></moo>ab<a>Hello cd</a><cool>ef</cool></foo>
819            //
820            //  ______________________foo_____________________
821            //  |          |           |          |           |
822            //  c         moo        "ab"         a          cool
823            //             |                      |           |
824            //             b                    "Hello cd"   "ef"
825            //
826            DOMImplementation* impl3 = DOMImplementationRegistry::getDOMImplementation(tempStr);
827            DOMDocument* doc3 = impl3->createDocument();
828
829            DOMElement* root3 = doc3->createElement(xroot);
830            doc3->appendChild(root3);
831
832            DOMElement* foo = doc3->createElement(xfoo);
833            DOMElement* moo = doc3->createElement(xmoo);
834            DOMElement* cool = doc3->createElement(xcool);
835            DOMText* ab = doc3->createTextNode(xab);
836            DOMText* cd = doc3->createTextNode(xHellocd);
837            DOMText* ef = doc3->createTextNode(xef);
838
839            DOMElement* a = doc3->createElement(xa);
840            DOMElement* b = doc3->createElement(xb);
841            DOMElement* c = doc3->createElement(xc);
842
843            root3->appendChild(foo);
844            foo->appendChild(c);
845            foo->appendChild(moo);
846            foo->appendChild(ab);
847            foo->appendChild(a);
848            foo->appendChild(cool);
849            moo->appendChild(b);
850            a->appendChild(cd);
851            cool->appendChild(ef);
852
853            //***************************************************************
854            //TEST toString
855            //***************************************************************
856            DOMRange* newtestrange = ((DOMDocumentRange*)doc3)->createRange();
857            //case 1:
858            //start container is text node
859            //   i) end container is also text node
860            //    a) start==end
861            //    b) start!=end
862            //  ii) end container is not text node
863            //    a) start==end => impossible
864            //    b) start!=end
865            //
866            //case 2:
867            //start container is not text node
868            //   i) end container is text node
869            //    a) start==end => impossible
870            //    b) start!=end
871            //  ii) end container is not text node
872            //    a) start==end
873            //    b) start!=end
874
875            //case 1, i, a
876            newtestrange->setStart( cd, 1 );
877            newtestrange->setEnd( cd, 4 );
878
879            TASSERT(!XMLString::compareString(newtestrange->toString(),xell));
880
881            //case 1, i, b
882            newtestrange->setStart( cd, 1 );
883            newtestrange->setEnd( ef, 2 );
884
885            TASSERT(!XMLString::compareString(newtestrange->toString(),xellocdef));
886
887            //case 1, ii, b
888            newtestrange->setStart( cd, 1 );
889            newtestrange->setEnd( foo, 4 );
890
891            TASSERT(!XMLString::compareString(newtestrange->toString(),xellocd));
892
893            //case 2, i, b
894            newtestrange->setStart( foo, 1 );
895            newtestrange->setEnd( cd, 5 );
896
897            TASSERT(!XMLString::compareString(newtestrange->toString(),xabHello));
898
899            //case 2, ii, a
900            newtestrange->setStart( foo, 1 );
901            newtestrange->setEnd( foo, 4 );
902
903            TASSERT(!XMLString::compareString(newtestrange->toString(),xabHellocd));
904
905            //case 2, ii, b
906            newtestrange->setStart( moo, 1 );
907            newtestrange->setEnd( foo, 4 );
908
909            TASSERT(!XMLString::compareString(newtestrange->toString(),xabHellocd));
910
911            //***************************************************************
912            //test removeChild
913            //***************************************************************
914            DOMRange* newrange = doc3->createRange();
915            newrange->setStart( moo, 0 );
916            newrange->setEnd( foo, 4 );
917
918            TASSERT(newrange->getStartOffset()==0);
919            TASSERT(!XMLString::compareString(newrange->getStartContainer()->getNodeName(),xmoo));
920            TASSERT(newrange->getEndOffset()==4);
921            TASSERT(!XMLString::compareString(newrange->getEndContainer()->getNodeName(),xfoo));
922            TASSERT(!XMLString::compareString(newrange->toString(),xabHellocd));
923
924            DOMNode* n = newrange->cloneContents();
925            UNUSED(n); // silence warning
926            DOMNodeList* nol = foo->getChildNodes();
927
928            //removing moo
929            DOMNode* rem = foo->removeChild(nol->item(1));
930            rem->release();
931            TASSERT(newrange->getStartOffset()==1);
932            TASSERT(!XMLString::compareString(newrange->getStartContainer()->getNodeName(),xfoo));
933            TASSERT(newrange->getEndOffset()==3);
934            TASSERT(!XMLString::compareString(newrange->getEndContainer()->getNodeName(),xfoo));
935            TASSERT(!XMLString::compareString(newrange->toString(),xabHellocd));
936
937            TASSERT(newtestrange->getStartOffset()==1);
938            TASSERT(!XMLString::compareString(newtestrange->getStartContainer()->getNodeName(),xfoo));
939            TASSERT(newtestrange->getEndOffset()==3);
940            TASSERT(!XMLString::compareString(newtestrange->getEndContainer()->getNodeName(),xfoo));
941            TASSERT(!XMLString::compareString(newtestrange->toString(),xabHellocd));
942
943            // Now do some exception test
944            newrange->detach();
945            EXCEPTION_TEST(newrange->setStart( moo, 0 ), DOMException::INVALID_STATE_ERR);
946            EXCEPTION_TEST(newtestrange->setStartBefore(moo), DOMRangeException::INVALID_NODE_TYPE_ERR);
947
948
949            doc->release();
950            doc2->release();
951            doc3->release();
952        }
953    } //creating the dom tree and tests
954
955    // And call the termination method
956    XMLPlatformUtils::Terminate();
957
958    if (errorOccurred) {
959        printf("Test Failed\n");
960        return 4;
961    }
962
963    printf("Test Run Successfully\n");
964
965    return 0;
966};
967
968
969
Note: See TracBrowser for help on using the repository browser.