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

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

Add original Xerces tests and samples directories

File size: 18.9 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//  Various DOM tests.
20//     Contents include
21//       1.  NodeIterator tests
22//       2.  Tree Walker tests
23//     All individual are wrapped in a memory leak checker.
24//
25//     This is NOT a complete test of DOM functionality.
26//
27
28/*
29 * $Id: Traversal.cpp 671894 2008-06-26 13:29:21Z borisk $
30 */
31
32#include <stdio.h>
33#include <string.h>
34#include <xercesc/dom/DOM.hpp>
35#include <xercesc/util/PlatformUtils.hpp>
36#include <xercesc/util/XMLException.hpp>
37#include <xercesc/util/XMLString.hpp>
38#include <xercesc/util/XMLUniDefs.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        printf("Failure.  Line %d,   file %s\n", line, file);
53        errorOccurred = true;
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 (DOMException &e) {                                       \
66    if (e.code != expected_exception) {                             \
67        printf(" Wrong exception code: %d at line %d\n", e.code, __LINE__); \
68        errorOccurred = true;                                       \
69    }                                                               \
70    }                                                               \
71    catch (...)   {                                                 \
72        printf(" Wrong exception thrown at line %d\n", __LINE__);   \
73        errorOccurred = true;                                       \
74    }                                                               \
75}
76
77class  MyFilter : public DOMNodeFilter {
78public:
79
80  MyFilter(short nodeType, bool reject=false) : DOMNodeFilter(), fNodeType(nodeType), fReject(reject) {};
81  virtual FilterAction acceptNode(const DOMNode* node) const;
82private:
83    short fNodeType;
84    bool fReject;
85};
86/*
87        Node Types can be of the following:
88        ELEMENT_NODE         = 1,
89        ATTRIBUTE_NODE       = 2,
90        TEXT_NODE            = 3,
91        CDATA_SECTION_NODE   = 4,
92        ENTITY_REFERENCE_NODE = 5,
93        ENTITY_NODE          = 6,
94        PROCESSING_INSTRUCTION_NODE = 7,
95        COMMENT_NODE         = 8,
96        DOCUMENT_NODE        = 9,
97        DOCUMENT_TYPE_NODE   = 10,
98        DOCUMENT_FRAGMENT_NODE = 11,
99        NOTATION_NODE        = 12
100*/
101DOMNodeFilter::FilterAction  MyFilter::acceptNode(const DOMNode* node) const {
102    if (fNodeType == 0)
103        return  DOMNodeFilter::FILTER_ACCEPT;
104        if (node->getNodeType() ==  fNodeType) {
105        return  DOMNodeFilter::FILTER_ACCEPT;
106        } else {
107            return  fReject ? DOMNodeFilter::FILTER_REJECT : DOMNodeFilter::FILTER_SKIP;
108        }
109}
110
111
112
113int  main()
114{
115        try {
116                XMLPlatformUtils::Initialize();
117        }
118        catch (const XMLException& toCatch) {
119        char *pMessage = XMLString::transcode(toCatch.getMessage());
120        fprintf(stderr, "Error during XMLPlatformUtils::Initialize(). \n"
121                        "  Message is: %s\n", pMessage);
122        XMLString::release(&pMessage);
123        return -1;
124    }
125
126    // Create a XMLCh buffer for string manipulation
127    XMLCh tempStr[4000];
128    XMLCh featureStr[100];
129    XMLString::transcode("Traversal",featureStr,99);
130
131
132
133    //
134    //  Doc - Create a small document tree
135    //
136
137    {
138        //creating a DOM Tree
139         /* Tests are based on the tree structure below
140           doc - root - E11 (attr01) - textNode1
141                                     - E111
142                                     - E112
143                                     - cdataSec
144                      - E12 (attr02) - textNode2
145                                     - E121
146                                     - E122
147                      - E13          - E131
148                                     - docPI
149                      - comment
150         */
151
152        DOMImplementation* impl = DOMImplementationRegistry::getDOMImplementation(featureStr);
153        DOMDocument* doc = impl->createDocument();
154
155        //Creating a root element
156        XMLString::transcode("RootElement", tempStr, 3999);
157        DOMElement*     root = doc->createElement(tempStr);
158        doc->appendChild(root);
159
160        //Creating the siblings of root
161        XMLString::transcode("FirstSibling", tempStr, 3999);
162        DOMElement*     E11 = doc->createElement(tempStr);
163        root->appendChild(E11);
164
165        XMLString::transcode("SecondSibling", tempStr, 3999);
166        DOMElement*     E12 = doc->createElement(tempStr);
167        root->appendChild(E12);
168
169        XMLString::transcode("ThirdSibling", tempStr, 3999);
170        DOMElement*     E13 = doc->createElement(tempStr);
171        root->appendChild(E13);
172
173        //Attaching texts to few siblings
174        XMLString::transcode("Text1", tempStr, 3999);
175        DOMText*        textNode1 = doc->createTextNode(tempStr);
176        E11->appendChild(textNode1);
177
178        XMLString::transcode("Text2", tempStr, 3999);
179        DOMText*        textNode2 = doc->createTextNode(tempStr);
180        E12->appendChild(textNode2);
181
182        //creating child of siblings
183        XMLString::transcode("FirstSiblingChild1", tempStr, 3999);
184        DOMElement*     E111 = doc->createElement(tempStr);
185        E11->appendChild(E111);
186
187        XMLString::transcode("Attr01", tempStr, 3999);
188        DOMAttr*        attr01  = doc->createAttribute(tempStr);
189        DOMNode* rem = E11->setAttributeNode(attr01);
190        if (rem)
191            rem->release();
192
193        XMLString::transcode("FirstSiblingChild2", tempStr, 3999);
194        DOMElement*     E112 = doc->createElement(tempStr);
195        E11->appendChild(E112);
196
197        XMLString::transcode("SecondSiblingChild1", tempStr, 3999);
198        DOMElement*     E121 = doc->createElement(tempStr);
199        E12->appendChild(E121);
200
201        XMLString::transcode("Attr01", tempStr, 3999);
202        DOMAttr* attr02 = doc->createAttribute(tempStr);
203        rem = E12->setAttributeNode(attr02);
204        if (rem)
205            rem->release();
206
207        XMLString::transcode("SecondSiblingChild2", tempStr, 3999);
208        DOMElement*     E122 = doc->createElement(tempStr);
209        E12->appendChild(E122);
210
211        XMLString::transcode("ThirdSiblingChild1", tempStr, 3999);
212        DOMElement*     E131 = doc->createElement(tempStr);
213        E13->appendChild(E131);
214
215        XMLString::transcode("DocComment", tempStr, 3999);
216        DOMComment* comment = doc->createComment(tempStr);
217        root->appendChild(comment);
218
219        XMLString::transcode("DocCDataSection", tempStr, 3999);
220        DOMCDATASection*  cdataSec = doc->createCDATASection(tempStr);
221        E11->appendChild(cdataSec);
222
223        XMLString::transcode("DocPI", tempStr, 3999);
224        XMLCh piStr[] = {chLatin_D, chLatin_o, chLatin_c, chLatin_P, chLatin_I, chNull};
225        DOMProcessingInstruction*  docPI = doc->createProcessingInstruction(piStr, tempStr);
226        E13->appendChild(docPI);
227
228
229        /*
230        following are whatToShow types:
231            SHOW_ALL                       = 0x0000FFFF,
232            SHOW_ELEMENT                   = 0x00000001,
233            SHOW_ATTRIBUTE                 = 0x00000002,
234            SHOW_TEXT                      = 0x00000004,
235            SHOW_CDATA_SECTION             = 0x00000008,
236            SHOW_ENTITY_REFERENCE          = 0x00000010,
237            SHOW_ENTITY                    = 0x00000020,
238            SHOW_PROCESSING_INSTRUCTION    = 0x00000040,
239            SHOW_COMMENT                   = 0x00000080,
240            SHOW_DOCUMENT                  = 0x00000100,
241            SHOW_DOCUMENT_TYPE             = 0x00000200,
242            SHOW_DOCUMENT_FRAGMENT         = 0x00000400,
243            SHOW_NOTATION                  = 0x00000800
244        */
245
246        ////////// NodeIterator Test Cases ////////////////
247
248
249        {
250            // all node iterating test
251
252            DOMNode*    node = doc->getFirstChild();
253            UNUSED(node); // silence warning
254            unsigned long       whatToShow = DOMNodeFilter::SHOW_ALL;
255            MyFilter* filter = new MyFilter(0);
256
257            DOMNodeIterator*  iter = ((DOMDocumentTraversal*)doc)->createNodeIterator(root, whatToShow,  filter, true);
258            TASSERT(iter->getWhatToShow() == 65535);
259            TASSERT(iter->getExpandEntityReferences() == 1);
260
261            DOMNode*  nd;
262            nd = iter->nextNode();
263            TASSERT (nd ==root);
264            nd = iter->nextNode();
265            TASSERT (nd ==E11);
266            nd = iter->nextNode();
267            TASSERT(nd == textNode1);
268            nd = iter->nextNode();
269            TASSERT(nd == E111);
270            nd = iter->nextNode();
271            TASSERT(nd == E112);
272            nd = iter->nextNode();
273            TASSERT(nd == cdataSec);
274            nd = iter->nextNode();
275            TASSERT(nd == E12);
276            nd = iter->nextNode();
277            TASSERT(nd == textNode2);
278            nd = iter->nextNode();
279            TASSERT(nd == E121);
280            nd = iter->nextNode();
281            TASSERT(nd == E122);
282            nd = iter->nextNode();
283            TASSERT(nd == E13);
284            nd = iter->nextNode();
285            TASSERT(nd == E131);
286            nd = iter->nextNode();
287            TASSERT(nd == docPI);
288            nd = iter->nextNode();
289            TASSERT(nd == comment);
290            nd = iter->previousNode();
291            TASSERT(nd == comment);
292            nd = iter->previousNode();
293            TASSERT(nd == docPI);
294            nd = iter->previousNode();
295            TASSERT(nd == E131);
296
297            //test getRoot
298            TASSERT(iter->getRoot() == root);
299            TASSERT(iter->getRoot() != doc);
300
301            delete filter;
302
303        }
304
305
306
307        {
308            //element node iterating test
309
310            DOMNode*    node = doc->getFirstChild();
311            UNUSED(node); // silence warning
312            unsigned long       whatToShow = DOMNodeFilter::SHOW_ELEMENT;
313            MyFilter* filter = new MyFilter(DOMNode::ELEMENT_NODE);
314
315            DOMNodeIterator*  iter = doc->createNodeIterator(root, whatToShow,  filter, true);
316            TASSERT(iter->getWhatToShow() == 1);
317            TASSERT(iter->getExpandEntityReferences() == 1);
318
319            DOMNode*  nd;
320            nd = iter->nextNode();
321            TASSERT (nd ==root);
322            nd = iter->nextNode();
323            TASSERT (nd ==E11);
324            nd = iter->nextNode();
325            TASSERT(nd == E111);
326            nd = iter->nextNode();
327            TASSERT(nd == E112);
328            nd = iter->nextNode();
329            TASSERT(nd == E12);
330            nd = iter->nextNode();
331            TASSERT(nd == E121);
332            nd = iter->nextNode();
333            TASSERT(nd == E122);
334            nd = iter->nextNode();
335            TASSERT(nd == E13);
336            nd = iter->nextNode();
337            TASSERT(nd == E131);
338            nd = iter->previousNode();
339            TASSERT(nd == E131);
340            nd = iter->previousNode();
341            TASSERT(nd == E13);
342            nd = iter->previousNode();
343            TASSERT(nd == E122);
344
345            delete filter;
346        }
347
348
349
350
351
352        {
353            // Text node iterating test
354
355            DOMNode*    node = doc->getFirstChild();
356            UNUSED(node); // silence warning
357            unsigned long       whatToShow = DOMNodeFilter::SHOW_TEXT;
358            MyFilter* filter = new MyFilter(DOMNode::TEXT_NODE);
359
360            DOMNodeIterator*  iter = ((DOMDocumentTraversal*)doc)->createNodeIterator(root, whatToShow,  filter, true);
361
362            TASSERT(iter->getWhatToShow() == 4);
363            TASSERT(iter->getExpandEntityReferences() == 1);
364
365            DOMNode*  nd;
366            nd = iter->nextNode();
367            TASSERT (nd ==textNode1);
368            nd = iter->nextNode();
369            TASSERT (nd ==textNode2);
370            nd = iter->previousNode();
371            TASSERT(nd == textNode2);
372
373            delete filter;
374        }
375
376
377        {
378            //CDataSection node itearating test
379
380            DOMNode*    node = doc->getFirstChild();
381            UNUSED(node); // silence warning
382            unsigned long       whatToShow = DOMNodeFilter::SHOW_CDATA_SECTION;
383            MyFilter* filter = new MyFilter(DOMNode::CDATA_SECTION_NODE);
384
385            DOMNodeIterator*  iter = doc->createNodeIterator(root, whatToShow,  filter, true);
386            TASSERT(iter->getWhatToShow() == 8);
387            TASSERT(iter->getExpandEntityReferences() == 1);
388
389            DOMNode*  nd;
390            nd = iter->nextNode();
391            TASSERT(nd == cdataSec);
392            nd = iter->nextNode();
393            TASSERT(nd == 0);
394
395            delete filter;
396        }
397
398
399        {
400            // PI nodes iterating test
401
402            DOMNode*    node = doc->getFirstChild();
403            UNUSED(node); // silence warning
404            unsigned long       whatToShow = DOMNodeFilter::SHOW_PROCESSING_INSTRUCTION;
405            MyFilter* filter = new MyFilter(DOMNode::PROCESSING_INSTRUCTION_NODE);
406
407            DOMNodeIterator*  iter = ((DOMDocumentTraversal*)doc)->createNodeIterator(root, whatToShow,  filter, true);
408            TASSERT(iter->getWhatToShow() == 64);
409            TASSERT(iter->getExpandEntityReferences() == 1);
410
411            DOMNode*  nd;
412            nd = iter->nextNode();
413            TASSERT(nd == docPI);
414            nd = iter->nextNode();
415            TASSERT(nd == 0);
416
417            delete filter;
418        }
419
420
421
422        {
423            DOMNode*    node = doc->getFirstChild();
424            UNUSED(node); // silence warning
425            unsigned long       whatToShow = DOMNodeFilter::SHOW_COMMENT;
426            MyFilter* filter = new MyFilter(DOMNode::COMMENT_NODE);
427
428            DOMNodeIterator*  iter = doc->createNodeIterator(root, whatToShow,  filter, true);
429            TASSERT(iter->getWhatToShow() == 128);
430            TASSERT(iter->getExpandEntityReferences() == 1);
431
432            DOMNode*  nd;
433            nd = iter->nextNode();
434            TASSERT(nd == comment);
435            nd = iter->nextNode();
436            TASSERT(nd == 0);
437
438            delete filter;
439        }
440
441
442
443
444        ////////// TreeWalker Test Cases ////////////////
445
446
447
448        {
449            unsigned long whatToShow = DOMNodeFilter::SHOW_ALL;
450            DOMTreeWalker* tw = ((DOMDocumentTraversal*)doc)->createTreeWalker(doc, whatToShow, 0, true);
451
452            TASSERT(tw->getCurrentNode() == doc);
453            TASSERT(tw->firstChild() == root);
454            TASSERT(tw->nextSibling() == 0);
455            TASSERT(tw->lastChild() == comment);
456            TASSERT(tw->firstChild() == 0);
457            TASSERT(tw->lastChild() == 0);
458            TASSERT(tw->nextSibling() == 0);
459            TASSERT(tw->nextNode() == 0);
460            TASSERT(tw->previousSibling() == E13);
461            TASSERT(tw->previousNode() == E122);
462            TASSERT(tw->parentNode() == E12);
463            TASSERT(tw->firstChild() == textNode2);
464            TASSERT(tw->previousSibling() == 0);
465            TASSERT(tw->nextSibling() == E121);
466            TASSERT(tw->nextNode() == E122);
467            TASSERT(tw->parentNode() == E12);
468            TASSERT(tw->previousSibling() == E11);
469            TASSERT(tw->previousNode() == root);
470            TASSERT(tw->previousNode() == doc);
471            TASSERT(tw->previousNode() == 0);
472            TASSERT(tw->parentNode() == 0);
473            TASSERT(tw->getCurrentNode() == doc);
474        }
475
476
477
478        {
479            MyFilter mf(DOMNode::ELEMENT_NODE);
480            unsigned long whatToShow = DOMNodeFilter::SHOW_ALL;
481            DOMTreeWalker* tw = doc->createTreeWalker(root, whatToShow, &mf, true);
482
483            TASSERT(tw->getCurrentNode() == root);
484            TASSERT(tw->parentNode() == 0);  //should not change currentNode
485            TASSERT(tw->getCurrentNode() == root);
486            TASSERT(tw->nextNode() == E11);
487            TASSERT(tw->nextNode() == E111);
488            tw->setCurrentNode(E12);
489            //when first is not visible, should it go to its sibling?
490            TASSERT(tw->firstChild() == E121);   //first visible child
491            TASSERT(tw->previousSibling() == 0);
492        }
493
494
495
496        {
497            MyFilter mf(DOMNode::ELEMENT_NODE, true);
498            unsigned long whatToShow = DOMNodeFilter::SHOW_ELEMENT;
499            DOMTreeWalker* tw = ((DOMDocumentTraversal*)doc)->createTreeWalker(root, whatToShow, &mf, true);
500
501            tw->setCurrentNode(E12);
502            TASSERT(tw->firstChild() == E121);   //still first visible child
503        }
504
505
506
507        {
508            MyFilter mf(DOMNode::TEXT_NODE);
509            unsigned long whatToShow = DOMNodeFilter::SHOW_TEXT;
510            DOMTreeWalker* tw = doc->createTreeWalker(root, whatToShow, &mf, true);
511
512            //when first is not visible, should it go to its descendent?
513            TASSERT(tw->firstChild() == textNode1);   //E11 skipped
514            TASSERT(tw->firstChild() == 0);
515            TASSERT(tw->nextNode() == textNode2);
516            TASSERT(tw->nextSibling() == 0);
517            TASSERT(tw->parentNode() == 0);  //no visible ancestor
518            TASSERT(tw->getCurrentNode() == textNode2);
519            tw->setCurrentNode(root);
520            //when last is not visible, should it go to its sibling & descendent?
521            TASSERT(tw->lastChild() == textNode2);   //last visible child
522            tw->setCurrentNode(E12);
523            //when next sibling is not visible, should it go to its descendent?
524            TASSERT(tw->nextSibling() == 0);
525        }
526
527
528
529        {
530            MyFilter mf(DOMNode::TEXT_NODE, true);
531            unsigned long whatToShow = DOMNodeFilter::SHOW_TEXT;
532            DOMTreeWalker* tw = ((DOMDocumentTraversal*)doc)->createTreeWalker(root, whatToShow, &mf, true);
533
534            TASSERT(tw->firstChild() == 0);   //E11 rejected and no children is TEXT
535            TASSERT(tw->getCurrentNode() == root);
536            TASSERT(tw->nextNode() == 0);    //E11 rejected so can't get to textNode1
537
538            //test getRoot
539            TASSERT(tw->getRoot() == root);
540            TASSERT(tw->getRoot() != doc);
541        }
542
543        doc->release();
544
545    };
546
547    // And call the termination method
548    XMLPlatformUtils::Terminate();
549
550    if (errorOccurred) {
551        printf("Test Failed\n");
552        return 4;
553    }
554
555    printf("Test Run Successfully\n");
556    return 0;
557};
Note: See TracBrowser for help on using the repository browser.