source: icXML/icXML-devel/tests/src/DOM/DOMMemTest/DOMMemTest.cpp

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

More path fixes.

File size: 52.4 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//     This is NOT a complete test of DOM functionality.
21//
22
23/*
24 * $Id: DOMMemTest.cpp 676911 2008-07-15 13:27:32Z amassari $
25 */
26
27#include <stdio.h>
28#include <string.h>
29#include <xercesc/dom/DOM.hpp>
30#include <icxercesc/util/PlatformUtils.hpp>
31#include <xercesc/util/XMLException.hpp>
32#include <icxercesc/util/XMLString.hpp>
33#include <xercesc/util/XMLUniDefs.hpp>
34
35
36XERCES_CPP_NAMESPACE_USE
37
38bool errorOccurred = false;
39
40#define UNUSED(x) { if(x!=0){} }
41
42#define TASSERT(c) tassert((c), __FILE__, __LINE__)
43
44void tassert(bool c, const char *file, int line)
45{
46    if (!c) {
47        printf("Failure.  Line %d,   file %s\n", line, file);
48        errorOccurred = true;
49    }
50};
51
52
53#define EXCEPTION_TEST(operation, expected_exception)               \
54{                                                                   \
55    try {                                                           \
56    operation;                                                      \
57    printf(" Error: no exception thrown at line %d\n", __LINE__);   \
58    errorOccurred = true;                                           \
59    }                                                               \
60    catch (DOMException &e) {                                       \
61    if (e.code != expected_exception) {                             \
62        printf(" Wrong exception code: %d at line %d\n", e.code, __LINE__); \
63        errorOccurred = true;                                       \
64    }                                                               \
65    }                                                               \
66    catch (...)   {                                                 \
67        printf(" Wrong exception thrown at line %d\n", __LINE__);   \
68        errorOccurred = true;                                       \
69    }                                                               \
70}
71
72// ---------------------------------------------------------------------------
73//  This is a simple class that lets us do easy (though not terribly efficient)
74//  trancoding of char* data to XMLCh data.
75// ---------------------------------------------------------------------------
76class XStr
77{
78public :
79    // -----------------------------------------------------------------------
80    //  Constructors and Destructor
81    // -----------------------------------------------------------------------
82    XStr(const char* const toTranscode)
83    {
84        // Call the private transcoding method
85        fUnicodeForm = XMLString::transcode(toTranscode);
86    }
87
88    ~XStr()
89    {
90        XMLString::release(&fUnicodeForm);
91    }
92
93
94    // -----------------------------------------------------------------------
95    //  Getter methods
96    // -----------------------------------------------------------------------
97    const XMLCh* unicodeForm() const
98    {
99        return fUnicodeForm;
100    }
101
102private :
103    // -----------------------------------------------------------------------
104    //  Private data members
105    //
106    //  fUnicodeForm
107    //      This is the Unicode XMLCh format of the string.
108    // -----------------------------------------------------------------------
109    XMLCh*   fUnicodeForm;
110};
111
112#define X(str) XStr(str).unicodeForm()
113
114//---------------------------------------------------------------------------------------
115//
116//   DOMBasicTests    Basic DOM Level 1 tests
117//
118//---------------------------------------------------------------------------------------
119void DOMBasicTests()
120{
121    //
122    //  Test Doc01      Create a new empty document
123    //
124    {
125        //  First precondition, so that lazily created strings do not appear
126        //  as memory leaks.
127        DOMDocument*   doc;
128        doc = DOMImplementationRegistry::getDOMImplementation(X("Core"))->createDocument();
129        doc->release();
130    }
131
132    //
133    //  Test Doc02      Create one of each kind of node using the
134    //                  document createXXX methods.
135    //                  Watch for memory leaks.
136    //
137    {
138        //  Do all operations in a preconditioning step, to force the
139        //  creation of implementation objects that are set up on first use.
140        //  Don't watch for leaks in this block (no  / )
141        DOMDocument* doc = DOMImplementationRegistry::getDOMImplementation(X("Core"))->createDocument();
142
143        DOMElement*   el = doc->createElement(X("Doc02Element"));
144        UNUSED(el); // silence warning
145
146        DOMDocumentFragment* frag = doc->createDocumentFragment ();
147        UNUSED(frag); // silence warning
148
149        DOMText*  text = doc->createTextNode(X("Doc02TextNode"));
150        UNUSED(text); // silence warning
151
152        DOMComment* comment = doc->createComment(X("Doc02Comment"));
153        UNUSED(comment); // silence warning
154
155        DOMCDATASection*  cdataSec = doc->createCDATASection(X("Doc02CDataSection"));
156        UNUSED(cdataSec); // silence warning
157
158        DOMDocumentType*  docType = doc->createDocumentType(X("Doc02DocumentType"));
159        UNUSED(docType); // silence warning
160
161        DOMNotation* notation = doc->createNotation(X("Doc02Notation"));
162        UNUSED(notation); // silence warning
163
164        DOMProcessingInstruction* pi = doc->createProcessingInstruction(X("Doc02PITarget"), X("Doc02PIData"));
165        UNUSED(pi); // silence warning
166
167        DOMNodeList*    nodeList = doc->getElementsByTagName(X("*"));
168        UNUSED(nodeList); // silence warning
169
170        doc->release();
171    }
172
173
174
175    //
176    //  Doc03 - Create a small document tree
177    //
178
179    {
180        DOMDocument*   doc = DOMImplementationRegistry::getDOMImplementation(X("Core"))->createDocument();
181
182        DOMElement*   rootEl = doc->createElement(X("Doc03RootElement"));
183
184        doc->appendChild(rootEl);
185
186        DOMText*       textNode = doc->createTextNode(X("Doc03 text stuff"));
187
188        rootEl->appendChild(textNode);
189
190        DOMNodeList*    nodeList = doc->getElementsByTagName(X("*"));
191        UNUSED(nodeList); // silence warning
192        doc->release();
193    };
194
195
196
197    //
198    //  Attr01
199    //
200    {
201        DOMDocument*   doc = DOMImplementationRegistry::getDOMImplementation(X("Core"))->createDocument();
202
203        DOMElement*   rootEl  = doc->createElement(X("RootElement"));
204
205        doc->appendChild(rootEl);
206        {
207            DOMAttr*        attr01  = doc->createAttribute(X("Attr01"));
208            DOMNode* rem = rootEl->setAttributeNode(attr01);
209            if (rem)
210                rem->release();
211
212        }
213
214
215        {
216            DOMAttr* attr02 = doc->createAttribute(X("Attr01"));
217            DOMNode* rem = rootEl->setAttributeNode(attr02);
218            if (rem)
219                rem->release();
220        }
221        doc->release();
222
223    };
224
225    //
226    //  Attr02
227    //
228
229    {
230        DOMDocument*   doc = DOMImplementationRegistry::getDOMImplementation(X("Core"))->createDocument();
231
232        DOMElement*   rootEl  = doc->createElement(X("RootElement"));
233
234        doc->appendChild(rootEl);
235
236        DOMAttr*        attr01  = doc->createAttribute(X("Attr02"));
237
238        DOMNode* rem = rootEl->setAttributeNode(attr01);
239        if (rem)
240            rem->release();
241
242
243        DOMAttr*        attr02 = doc->createAttribute(X("Attr02"));
244
245        rem = rootEl->setAttributeNode(attr02);
246        if (rem)
247            rem->release();
248        doc->release();
249    }
250
251
252
253    //
254    //  Attr03
255    //
256
257    {
258        DOMDocument*   doc = DOMImplementationRegistry::getDOMImplementation(X("Core"))->createDocument();
259
260        DOMElement*   rootEl  = doc->createElement(X("RootElement"));
261
262        doc->appendChild(rootEl);
263
264        DOMAttr*        attr01  = doc->createAttribute(X("Attr03"));
265
266        DOMNode* rem = rootEl->setAttributeNode(attr01);
267        if (rem)
268            rem->release();
269
270
271        attr01->setValue(X("Attr03Value1"));
272
273        attr01->setValue(X("Attr03Value2"));
274        doc->release();
275    }
276
277
278
279    //
280    //  Attr04
281    //
282
283    {
284        DOMDocument*   doc = DOMImplementationRegistry::getDOMImplementation(X("Core"))->createDocument();
285
286        DOMElement*   rootEl  = doc->createElement(X("RootElement"));
287
288        doc->appendChild(rootEl);
289
290        DOMAttr*        attr01  = doc->createAttribute(X("Attr04"));
291
292        DOMNode* rem = rootEl->setAttributeNode(attr01);
293        if (rem)
294            rem->release();
295
296        attr01->setValue(X("Attr04Value1"));
297
298        DOMNode* value = attr01->getFirstChild();
299        UNUSED(value); // silence warning
300        doc->release();
301    }
302
303
304
305
306    //
307    //  Text01
308    //
309
310    {
311        DOMDocument*   doc = DOMImplementationRegistry::getDOMImplementation(X("Core"))->createDocument();
312
313        DOMElement*   rootEl  = doc->createElement(X("RootElement"));
314
315        doc->appendChild(rootEl);
316
317        DOMText*        txt1 = doc->createTextNode(X("Hello Goodbye"));
318        rootEl->appendChild(txt1);
319
320        txt1->splitText(6);
321        rootEl->normalize();
322        doc->release();
323
324    }
325
326
327
328    //
329    //  Notation01
330    //
331
332    {
333        DOMDocument*       doc = DOMImplementationRegistry::getDOMImplementation(X("Core"))->createDocument();
334
335        DOMDocumentType*   dt  = doc->createDocumentType(X("DocType_for_Notation01"));
336
337        doc->appendChild(dt);
338
339
340        DOMNamedNodeMap* notationMap = dt->getNotations();
341
342        DOMNotation*    nt1 = doc->createNotation(X("Notation01"));
343
344        DOMNode* rem = notationMap->setNamedItem (nt1);
345        if (rem)
346            rem->release();
347
348        DOMNode*  abc1 = notationMap->getNamedItem(X("Notation01"));
349
350        DOMNotation*    nt2 = (DOMNotation*) abc1;
351        TASSERT(nt1==nt2);
352        nt2 = 0;
353        nt1 = 0;
354
355        DOMNode* abc6 = notationMap->getNamedItem(X("Notation01"));
356
357        nt2 = (DOMNotation*) abc6;
358        doc->release();
359    }
360
361
362
363    //
364    //  NamedNodeMap01 - comparison operators.
365    //
366
367    {
368        DOMNamedNodeMap*    nnm = 0;
369        TASSERT(nnm == 0);
370
371        DOMDocument*       doc = DOMImplementationRegistry::getDOMImplementation(X("Core"))->createDocument();
372        nnm = doc->getAttributes();    // Should be null, because node type
373                                      //   is not Element.
374        TASSERT(nnm == 0);
375        TASSERT(!(nnm != 0));
376
377        DOMElement* el = doc->createElement(X("NamedNodeMap01"));
378
379        DOMNamedNodeMap* nnm2 = el->getAttributes();    // Should be an empty, but non-null map.
380        TASSERT(nnm2 != 0);
381        TASSERT(nnm != nnm2);
382        nnm = nnm2;
383        TASSERT(nnm == nnm2);
384        doc->release();
385    }
386
387
388
389    //
390    //  importNode quick test
391    //
392
393    {
394        DOMDocument*   doc1 = DOMImplementationRegistry::getDOMImplementation(X("Core"))->createDocument();
395        DOMDocument*   doc2 = DOMImplementationRegistry::getDOMImplementation(X("Core"))->createDocument();
396
397        DOMElement*   el1  = doc1->createElement(X("abc"));
398
399        doc1->appendChild(el1);
400        TASSERT(el1->getParentNode() != 0);
401        DOMNode*        el2  = doc2->importNode(el1, true);
402        TASSERT(el2->getParentNode() == 0);
403        const XMLCh*       tagName = el2->getNodeName();
404
405        TASSERT(!XMLString::compareString(tagName, X("abc")));
406
407        TASSERT(el2->getOwnerDocument() == doc2);
408        TASSERT(doc1 != doc2);
409        doc1->release();
410        doc2->release();
411    }
412
413
414    //
415    //  getLength() tests.  Both Node CharacterData and NodeList implement
416    //                  getLength().  Early versions of the DOM had a clash
417    //                  between the two, originating in the implementation class
418    //                  hirearchy, which has NodeList as a (distant) base class
419    //                  of CharacterData.  This is a regression test to verify
420    //                  that the problem stays fixed.
421    //
422
423    {
424        DOMDocument*    doc = DOMImplementationRegistry::getDOMImplementation(X("Core"))->createDocument();
425
426        DOMText*          tx = doc->createTextNode(X("Hello"));
427
428        DOMElement*     el = doc->createElement(X("abc"));
429
430        el->appendChild(tx);
431
432        XMLSize_t textLength = tx->getLength();
433        TASSERT(textLength == 5);
434
435        DOMNodeList*      nl = tx->getChildNodes();
436        XMLSize_t nodeListLen = nl->getLength();
437        TASSERT(nodeListLen == 0);
438
439        nl = el->getChildNodes();
440        nodeListLen = nl->getLength();
441        TASSERT(nodeListLen == 1);
442        doc->release();
443    }
444
445
446    //
447    //  NodeList - comparison operators, basic operation.
448    //
449
450    {
451        DOMNodeList*    nl = 0;
452        DOMNodeList*    nl2 = 0;
453        TASSERT(nl == 0);
454        TASSERT(!(nl != 0));
455        TASSERT(nl == nl2);
456
457        DOMDocument*       doc = DOMImplementationRegistry::getDOMImplementation(X("Core"))->createDocument();
458        nl = doc->getChildNodes();    // Should be non-null, but empty
459
460        TASSERT(nl != 0);
461        XMLSize_t len = nl->getLength();
462        TASSERT(len == 0);
463
464        DOMElement* el = doc->createElement(X("NodeList01"));
465
466        doc->appendChild(el);
467        len = nl->getLength();
468        TASSERT(len == 1);
469        TASSERT(nl != nl2);
470        nl2 = nl;
471        TASSERT(nl == nl2);
472        doc->release();
473    }
474
475
476
477
478    //
479    //  Name validity checking.
480    //
481
482    {
483         DOMDocument*       doc = DOMImplementationRegistry::getDOMImplementation(X("Core"))->createDocument();
484         try
485         {
486             DOMElement* el = doc->createElement(X("!@@ bad element name"));
487             UNUSED(el); // silence warning
488             TASSERT(false);  // Exception above should prevent us reaching here.
489         }
490         catch ( DOMException e)
491         {
492             TASSERT(e.code == DOMException::INVALID_CHARACTER_ERR);
493         }
494         catch (...)
495         {
496             TASSERT(false);  // Wrong exception thrown.
497         }
498         doc->release();
499    }
500
501
502
503    //
504    //  Assignment ops return value
505    //
506
507    {
508        DOMDocument*       doc = DOMImplementationRegistry::getDOMImplementation(X("Core"))->createDocument();
509
510        DOMElement* el = doc->createElement(X("NodeList01"));
511
512        doc->appendChild(el);
513
514        DOMElement* n1, *n2, *n3;
515
516        n1 = n2 = n3 = el;
517        TASSERT(n1 == n2);
518        TASSERT(n1 == n3);
519        TASSERT(n1 == el);
520        TASSERT(n1 != 0);
521        n1 = n2 = n3 = 0;
522        TASSERT(n1 == 0);
523        doc->release();
524    }
525
526
527
528    //
529    //  Cloning of a node with attributes. Regression test for a ref counting
530    //  bug in attributes of cloned nodes that occured when the "owned" flag
531    //  was not set in the clone.
532    //
533
534    {
535        DOMDocument*   doc = DOMImplementationRegistry::getDOMImplementation(X("Core"))->createDocument();
536
537        DOMElement*   root = doc->createElement(X("CTestRoot"));
538
539        root->setAttribute(X("CTestAttr"), X("CTestAttrValue"));
540
541        const XMLCh* s = root->getAttribute(X("CTestAttr"));
542        TASSERT(!XMLString::compareString(s, X("CTestAttrValue")));
543
544        DOMNode* abc2 = root->cloneNode(true);
545        DOMElement*   cloned = (DOMElement*) abc2;
546        DOMAttr* a = cloned->getAttributeNode(X("CTestAttr"));
547        TASSERT(a != 0);
548        s = a->getValue();
549        TASSERT(!XMLString::compareString(s, X("CTestAttrValue")));
550        a = 0;
551
552        a = cloned->getAttributeNode(X("CTestAttr"));
553        TASSERT(a != 0);
554        s = a->getValue();
555        TASSERT(!XMLString::compareString(s, X("CTestAttrValue")));
556        doc->release();
557
558    }
559
560
561
562    //
563    //  splitText()
564    //     Regression test for a bug from Tinny Ng
565    //
566
567    {
568        DOMDocument* doc;
569        doc = DOMImplementationRegistry::getDOMImplementation(X("Core"))->createDocument();
570        DOMText* tn, *tn1, *tn2;
571
572        tn = doc->createTextNode (X("0123456789"));
573
574        tn1 = tn->splitText(5);
575
576        TASSERT(!XMLString::compareString(tn->getNodeValue(), X("01234")));
577
578        TASSERT(!XMLString::compareString(tn1->getNodeValue(), X("56789")));
579
580
581        tn2 = tn->splitText(5);
582        TASSERT(!XMLString::compareString(tn->getNodeValue(), X("01234")));
583
584        TASSERT(!XMLString::compareString(tn2->getNodeValue(), XMLUni::fgZeroLenString));
585
586        EXCEPTION_TEST(tn->splitText(6), DOMException::INDEX_SIZE_ERR);
587        doc->release();
588    }
589
590
591
592}
593
594
595//---------------------------------------------------------------------------------------
596//
597//   DOMNSTests    DOM Name Space tests
598//
599//---------------------------------------------------------------------------------------
600void DOMNSTests()
601{
602
603    //
604    //  DOM Level 2 tests.  These should be split out as a separate test.
605    //
606
607
608    //
609    // hasFeature.  The set of supported options tested here is for Xerces 1.1
610    //              Note: because the implementation lazily creates some of the comprison
611    //                    strings within the implementation, this test must be pre-flighted
612    //                    outside of the TESPROLOG/ macros to avoid spurious
613    //                    reports of memory leaks.
614    //
615    // Also test the case-insensitive
616    //
617    {
618
619        DOMImplementation*  impl = DOMImplementationRegistry::getDOMImplementation(X("Core"));
620
621        TASSERT(impl->hasFeature(X("XmL"), X("2.0")) == true);
622
623        TASSERT(impl->hasFeature(X("xML"), 0) == true);
624        TASSERT(impl->hasFeature(X("xML"), XMLUni::fgZeroLenString) == true);
625
626        TASSERT(impl->hasFeature(X("XMl"), X("1.0"))  == true);
627
628        TASSERT(impl->hasFeature(X("xMl"), X("3.0"))  == false);
629
630        TASSERT(impl->hasFeature(X("TrAveRsal"), 0)  == true);
631        TASSERT(impl->hasFeature(X("TrAveRsal"), XMLUni::fgZeroLenString)  == true);
632    }
633
634
635
636    {
637        DOMImplementation*  impl = DOMImplementationRegistry::getDOMImplementation(X("Core"));
638
639        TASSERT(impl->hasFeature(X("XmL"), 0)   == true);
640        TASSERT(impl->hasFeature(X("XmL"), X("1.0"))    == true);
641        TASSERT(impl->hasFeature(X("XmL"), X("2.0"))   == true);
642        TASSERT(impl->hasFeature(X("XmL"), X("3.0"))   == false);
643
644        TASSERT(impl->hasFeature(X("Core"), 0)   == true);
645
646        TASSERT(impl->hasFeature(X("coRe"), X("1.0"))    == true);
647
648        TASSERT(impl->hasFeature(X("core"), X("2.0"))   == true);
649
650        TASSERT(impl->hasFeature(X("cORe"), X("3.0"))   == true);
651        TASSERT(impl->hasFeature(X("cORe"), X("4.0"))   == false);
652
653        TASSERT(impl->hasFeature(X("Traversal"), XMLUni::fgZeroLenString)   == true);
654
655        TASSERT(impl->hasFeature(X("traversal"), X("1.0"))    == false);
656
657        TASSERT(impl->hasFeature(X("TraVersal"), X("2.0"))   == true);
658
659        TASSERT(impl->hasFeature(X("Range"), 0)   == true);
660
661        TASSERT(impl->hasFeature(X("raNge"), X("1.0"))    == false);
662
663        TASSERT(impl->hasFeature(X("RaNge"), X("2.0"))   == true);
664
665
666        TASSERT(impl->hasFeature(X("HTML"), 0)   == false);
667
668        TASSERT(impl->hasFeature(X("Views"), XMLUni::fgZeroLenString)   == false);
669
670        TASSERT(impl->hasFeature(X("StyleSheets"), 0)   == false);
671
672        TASSERT(impl->hasFeature(X("CSS"), XMLUni::fgZeroLenString)   == false);
673
674        TASSERT(impl->hasFeature(X("CSS2"), 0)   == false);
675
676        TASSERT(impl->hasFeature(X("Events"), 0)   == false);
677
678        TASSERT(impl->hasFeature(X("UIEvents"), 0)   == false);
679
680        TASSERT(impl->hasFeature(X("MouseEvents"), 0)   == false);
681
682        TASSERT(impl->hasFeature(X("MutationEvents"), 0)   == false);
683
684        TASSERT(impl->hasFeature(X("HTMLEvents"), 0)   == false);
685    }
686
687
688
689    //
690    // isSupported test (similar to hasFeature)
691    //
692
693    {
694        DOMDocument* doc;
695        doc = DOMImplementationRegistry::getDOMImplementation(X("Core"))->createDocument();
696
697
698        TASSERT(doc->isSupported(X("XmL"), 0)   == true);
699        TASSERT(doc->isSupported(X("XmL"), X("1.0"))    == true);
700        TASSERT(doc->isSupported(X("XmL"), X("2.0"))   == true);
701        TASSERT(doc->isSupported(X("XmL"), X("3.0"))   == false);
702
703        TASSERT(doc->isSupported(X("Core"), 0)   == true);
704        TASSERT(doc->isSupported(X("Core"), XMLUni::fgZeroLenString)   == true);
705
706        TASSERT(doc->isSupported(X("coRe"), X("1.0"))    == true);
707
708        TASSERT(doc->isSupported(X("core"), X("2.0"))   == true);
709
710        TASSERT(doc->isSupported(X("cORe"), X("3.0"))   == true);
711        TASSERT(doc->isSupported(X("cORe"), X("4.0"))   == false);
712
713        TASSERT(doc->isSupported(X("Traversal"), 0)   == true);
714
715        TASSERT(doc->isSupported(X("traversal"), X("1.0"))    == false);
716
717        TASSERT(doc->isSupported(X("TraVersal"), X("2.0"))   == true);
718
719        TASSERT(doc->isSupported(X("Range"), XMLUni::fgZeroLenString)   == true);
720
721        TASSERT(doc->isSupported(X("raNge"), X("1.0"))    == false);
722
723        TASSERT(doc->isSupported(X("RaNge"), X("2.0"))   == true);
724
725        TASSERT(doc->isSupported(X("HTML"), 0)   == false);
726
727        TASSERT(doc->isSupported(X("Views"), 0)   == false);
728
729        TASSERT(doc->isSupported(X("StyleSheets"), 0)   == false);
730
731        TASSERT(doc->isSupported(X("CSS"), 0)   == false);
732
733        TASSERT(doc->isSupported(X("CSS2"), XMLUni::fgZeroLenString)   == false);
734        TASSERT(doc->isSupported(X("Events"), 0)   == false);
735
736        TASSERT(doc->isSupported(X("UIEvents"), 0)   == false);
737
738        TASSERT(doc->isSupported(X("MouseEvents"), 0)   == false);
739
740        TASSERT(doc->isSupported(X("MutationEvents"), XMLUni::fgZeroLenString)   == false);
741
742        TASSERT(doc->isSupported(X("HTMLEvents"), 0)   == false);
743        doc->release();
744    }
745
746
747    //
748    // CreateDocumentType
749    //
750
751    {
752        DOMImplementation*  impl = DOMImplementationRegistry::getDOMImplementation(X("Core"));
753
754
755        DOMDocumentType* dt = impl->createDocumentType(X("foo:docName"), X("pubId"), X("http://sysId"));
756
757        TASSERT(dt != 0);
758        TASSERT(dt->getNodeType() == DOMNode::DOCUMENT_TYPE_NODE);
759        TASSERT(!XMLString::compareString(dt->getNodeName(), X("foo:docName")));
760        TASSERT(dt->getNamespaceURI() == 0);
761        TASSERT(dt->getPrefix() == 0);
762        TASSERT(dt->getLocalName() == 0);
763        TASSERT(!XMLString::compareString(dt->getPublicId(), X("pubId")));
764        TASSERT(!XMLString::compareString(dt->getSystemId(), X("http://sysId")));
765        TASSERT(dt->getInternalSubset() == 0);
766        TASSERT(dt->getOwnerDocument() == 0);
767
768        DOMNamedNodeMap* nnm = dt->getEntities();
769        TASSERT(nnm->getLength() == 0);
770        nnm = dt->getNotations();
771        TASSERT(nnm->getLength() == 0);
772
773        // release the documentType (dt) which is an orphaned node (does not have the owner)
774        dt->release();
775
776        //
777        // Qualified name without prefix should also work.
778        //
779        dt = impl->createDocumentType(X("docName"), X("pubId"), X("http://sysId"));
780
781        TASSERT(dt != 0);
782        TASSERT(dt->getNodeType() == DOMNode::DOCUMENT_TYPE_NODE);
783        TASSERT(!XMLString::compareString(dt->getNodeName(), X("docName")));
784        TASSERT(dt->getNamespaceURI() == 0);
785        TASSERT(dt->getPrefix() == 0);
786        TASSERT(dt->getLocalName() == 0);
787        TASSERT(!XMLString::compareString(dt->getPublicId(), X("pubId")));
788        TASSERT(!XMLString::compareString(dt->getSystemId(), X("http://sysId")));
789        TASSERT(dt->getInternalSubset() == 0);
790        TASSERT(dt->getOwnerDocument() == 0);
791
792        // Creating a DocumentType with invalid or malformed qName should fail.
793        EXCEPTION_TEST(impl->createDocumentType(X("<docName"), X("pubId"), X("http://sysId")), DOMException::INVALID_CHARACTER_ERR);
794
795        EXCEPTION_TEST(impl->createDocumentType(X(":docName"), X("pubId"), X("http://sysId")), DOMException::NAMESPACE_ERR);
796
797        EXCEPTION_TEST(impl->createDocumentType(X("docName:"), X("pubId"), X("http://sysId")), DOMException::NAMESPACE_ERR);
798
799        EXCEPTION_TEST(impl->createDocumentType(X("doc::Name"), X("pubId"), X("http://sysId")), DOMException::NAMESPACE_ERR);
800
801        EXCEPTION_TEST(impl->createDocumentType(X("doc:N:ame"), X("pubId"), X("http://sysId")), DOMException::NAMESPACE_ERR);
802
803        // release the documentType (dt) which is an orphaned node (does not have the owner)
804        dt->release();
805
806    }
807
808
809
810    //
811    //  DOMImplementation::CreateDocument
812    {
813
814        DOMImplementation*   impl = DOMImplementationRegistry::getDOMImplementation(X("Core"));
815        DOMDocumentType*       dt = 0;
816
817        DOMDocument*           doc = impl->createDocument(XMLUni::fgZeroLenString, X("a"), dt);
818
819        doc->getNodeName();
820        doc->release();
821    }
822
823    //
824
825    {
826
827        DOMImplementation* impl = DOMImplementationRegistry::getDOMImplementation(X("Core"));
828
829
830
831        DOMDocumentType* dt = impl->createDocumentType(X("foo:docName"), X("pubId"), X("http://sysId"));
832
833        DOMDocument* doc = impl->createDocument(X("http://document.namespace"), X("foo:docName"), dt);
834
835        TASSERT(dt->getOwnerDocument() == doc);
836        TASSERT(doc->getOwnerDocument() == 0);
837
838        TASSERT(doc->getNodeType() == DOMNode::DOCUMENT_NODE);
839        TASSERT(doc->getDoctype() == dt);
840
841        TASSERT(!XMLString::compareString(doc->getNodeName(), X("#document")));
842
843        TASSERT(doc->getNodeValue() == 0);
844        TASSERT(doc->getNamespaceURI() == 0);
845        TASSERT(doc->getPrefix() == 0);
846        TASSERT(doc->getLocalName() == 0);
847
848        DOMElement* el = doc->getDocumentElement();
849
850        TASSERT(!XMLString::compareString(el->getLocalName(), X("docName")));
851
852        TASSERT(!XMLString::compareString(el->getNamespaceURI(), X("http://document.namespace")));
853        TASSERT(!XMLString::compareString(el->getNodeName(), X("foo:docName")));
854        TASSERT(el->getOwnerDocument() == doc);
855        TASSERT(el->getParentNode() == doc);
856
857        TASSERT(!XMLString::compareString(el->getPrefix(), X("foo")));
858
859        TASSERT(!XMLString::compareString(el->getTagName(), X("foo:docName")));
860        TASSERT(el->hasChildNodes() == false);
861
862
863        //
864        // Creating a second document with the same docType object should fail.
865        //
866        try
867        {
868            DOMDocument* doc2 = impl->createDocument(X("pubId"), X("foo:docName"), dt);
869            UNUSED(doc2); // silence warning
870            TASSERT(false);  // should not reach here.
871        }
872        catch ( DOMException &e)
873        {
874            TASSERT(e.code == DOMException::WRONG_DOCUMENT_ERR);
875        }
876        catch (...)
877        {
878            TASSERT(false);  // Wrong exception thrown.
879        }
880
881        // release the document, the documentType (dt) still has the owner, and thus no need to release
882        doc->release();
883
884        // Creating a document with null NamespaceURI and DocumentType
885        doc = impl->createDocument(X("pubId"), X("foo:docName"), 0);
886        doc->release();
887
888        // Namespace tests of createDocument are covered by createElementNS below
889    }
890
891
892
893
894
895    //
896    //  CreateElementNS methods
897    //
898
899    {
900
901        // Set up an initial (root element only) document.
902        //
903        DOMImplementation* impl = DOMImplementationRegistry::getDOMImplementation(X("Core"));
904
905
906        DOMDocumentType* dt = impl->createDocumentType(X("foo:docName"), X("pubId"), X("http://sysId"));
907
908
909        DOMDocument* doc = impl->createDocument(X("http://document.namespace"), X("foo:docName"), dt);
910        DOMElement* rootEl = doc->getDocumentElement();
911
912        //
913        // CreateElementNS
914        //
915        DOMElement* ela = doc->createElementNS(X("http://nsa"), X("a:ela"));  // prefix and URI
916
917        TASSERT(!XMLString::compareString(ela->getNodeName(), X("a:ela")));
918        TASSERT(!XMLString::compareString(ela->getNamespaceURI(), X("http://nsa")));
919        TASSERT(!XMLString::compareString(ela->getPrefix(), X("a")));
920        TASSERT(!XMLString::compareString(ela->getLocalName(), X("ela")));
921        TASSERT(!XMLString::compareString(ela->getTagName(), X("a:ela")));
922
923        DOMElement* elb = doc->createElementNS(X("http://nsb"), X("elb"));    //  URI, no prefix.
924
925        TASSERT(!XMLString::compareString(elb->getNodeName(), X("elb")));
926        TASSERT(!XMLString::compareString(elb->getNamespaceURI(), X("http://nsb")));
927        TASSERT(!XMLString::compareString(elb->getPrefix(), XMLUni::fgZeroLenString));
928        TASSERT(!XMLString::compareString(elb->getLocalName(), X("elb")));
929        TASSERT(!XMLString::compareString(elb->getTagName(), X("elb")));
930
931        DOMElement* elc = doc->createElementNS(XMLUni::fgZeroLenString, X("elc"));              // No URI, no prefix.
932
933        TASSERT(!XMLString::compareString(elc->getNodeName(), X("elc")));
934        TASSERT(!XMLString::compareString(elc->getNamespaceURI(), XMLUni::fgZeroLenString));
935        TASSERT(!XMLString::compareString(elc->getPrefix(), XMLUni::fgZeroLenString));
936        TASSERT(!XMLString::compareString(elc->getLocalName(), X("elc")));
937        TASSERT(!XMLString::compareString(elc->getTagName(), X("elc")));
938
939        rootEl->appendChild(ela);
940        rootEl->appendChild(elb);
941        rootEl->appendChild(elc);
942
943        // Badly formed qualified name
944        EXCEPTION_TEST(doc->createElementNS(X("http://nsa"), X("<a")), DOMException::INVALID_CHARACTER_ERR);
945
946        EXCEPTION_TEST(doc->createElementNS(X("http://nsa"), X(":a")), DOMException::NAMESPACE_ERR);
947
948        EXCEPTION_TEST(doc->createElementNS(X("http://nsa"), X("a:")), DOMException::NAMESPACE_ERR);
949
950        EXCEPTION_TEST(doc->createElementNS(X("http://nsa"), X("a::a")), DOMException::NAMESPACE_ERR);
951
952        EXCEPTION_TEST(doc->createElementNS(X("http://nsa"), X("a:a:a")), DOMException::NAMESPACE_ERR);
953
954        // xml:a must have namespaceURI == "http://www.w3.org/XML/1998/namespace"
955        TASSERT(!XMLString::compareString(doc->createElementNS(X("http://www.w3.org/XML/1998/namespace"), X("xml:a"))->getNamespaceURI(), X("http://www.w3.org/XML/1998/namespace")));
956        EXCEPTION_TEST(doc->createElementNS(X("http://nsa"), X("xml:a")), DOMException::NAMESPACE_ERR);
957        EXCEPTION_TEST(doc->createElementNS(XMLUni::fgZeroLenString, X("xml:a")), DOMException::NAMESPACE_ERR);
958        EXCEPTION_TEST(doc->createElementNS(0,  X("xml:a")), DOMException::NAMESPACE_ERR);
959
960        //unlike Attribute, xmlns (no different from foo) can have any namespaceURI for Element
961        TASSERT(!XMLString::compareString(doc->createElementNS(X("http://nsa"), X("xmlns"))->getNamespaceURI(), X("http://nsa")));
962
963        TASSERT(!XMLString::compareString(doc->createElementNS(X("http://www.w3.org/XML/1998/namespace"), X("xmlns"))->getNamespaceURI(), X("http://www.w3.org/XML/1998/namespace")));
964        TASSERT(!XMLString::compareString(doc->createElementNS(XMLUni::fgZeroLenString, X("xmlns"))->getNamespaceURI(), XMLUni::fgZeroLenString));
965        TASSERT(!XMLString::compareString(doc->createElementNS(0,  X("xmlns"))->getNamespaceURI(), XMLUni::fgZeroLenString));
966
967        //unlike Attribute, xmlns:a (no different from foo:a) can have any namespaceURI for Element
968        //except "" and null
969        TASSERT(!XMLString::compareString(doc->createElementNS(X("http://nsa"), X("xmlns:a"))->getNamespaceURI(), X("http://nsa")));
970        TASSERT(!XMLString::compareString(doc->createElementNS(X("http://www.w3.org/XML/1998/namespace"), X("xmlns:a"))->getNamespaceURI(), X("http://www.w3.org/XML/1998/namespace")));
971        EXCEPTION_TEST(doc->createElementNS(XMLUni::fgZeroLenString, X("xmlns:a")), DOMException::NAMESPACE_ERR);
972        EXCEPTION_TEST(doc->createElementNS(0, X("xmlns:a")), DOMException::NAMESPACE_ERR);
973
974        //In fact, any prefix != null should have a namespaceURI != 0 or != ""
975        TASSERT(!XMLString::compareString(doc->createElementNS(X("http://nsa"), X("foo:a"))->getNamespaceURI(), X("http://nsa")));
976        EXCEPTION_TEST(doc->createElementNS(XMLUni::fgZeroLenString, X("foo:a")), DOMException::NAMESPACE_ERR);
977        EXCEPTION_TEST(doc->createElementNS(0,  X("foo:a")), DOMException::NAMESPACE_ERR);
978
979        //Change prefix
980        DOMElement* elem = doc->createElementNS(X("http://nsa"), X("foo:a"));
981        elem->setPrefix(X("bar"));
982        TASSERT(!XMLString::compareString(elem->getNodeName(), X("bar:a")));
983        TASSERT(!XMLString::compareString(elem->getNamespaceURI(), X("http://nsa")));
984        TASSERT(!XMLString::compareString(elem->getPrefix(), X("bar")));
985        TASSERT(!XMLString::compareString(elem->getLocalName(), X("a")));
986        TASSERT(!XMLString::compareString(elem->getTagName(), X("bar:a")));
987        //The spec does not prevent us from setting prefix to a node without prefix
988        elem = doc->createElementNS(X("http://nsa"), X("a"));
989        TASSERT(!XMLString::compareString(elem->getPrefix(), XMLUni::fgZeroLenString));
990        elem->setPrefix(X("bar"));
991        TASSERT(!XMLString::compareString(elem->getNodeName(), X("bar:a")));
992        TASSERT(!XMLString::compareString(elem->getNamespaceURI(), X("http://nsa")));
993        TASSERT(!XMLString::compareString(elem->getPrefix(), X("bar")));
994        TASSERT(!XMLString::compareString(elem->getLocalName(), X("a")));
995        TASSERT(!XMLString::compareString(elem->getTagName(), X("bar:a")));
996
997        //Special case for xml:a where namespaceURI must be xmlURI
998        elem = doc->createElementNS(X("http://www.w3.org/XML/1998/namespace"), X("foo:a"));
999        elem->setPrefix(X("xml"));
1000        elem = doc->createElementNS(X("http://nsa"), X("foo:a"));
1001        EXCEPTION_TEST(elem->setPrefix(X("xml")), DOMException::NAMESPACE_ERR);
1002        //However, there is no restriction on prefix xmlns
1003        elem->setPrefix(X("xmlns"));
1004        //Also an element can not have a prefix with namespaceURI == null or ""
1005        elem = doc->createElementNS(0, X("a"));
1006        EXCEPTION_TEST(elem->setPrefix(X("foo")), DOMException::NAMESPACE_ERR);
1007        elem = doc->createElementNS(XMLUni::fgZeroLenString, X("a"));
1008        EXCEPTION_TEST(elem->setPrefix(X("foo")), DOMException::NAMESPACE_ERR);
1009
1010        //Only prefix of Element and Attribute can be changed
1011        EXCEPTION_TEST(doc->setPrefix(X("foo")), DOMException::NAMESPACE_ERR);
1012
1013        //Prefix of readonly Element can not be changed.
1014        //However, there is no way to create such DOMElement* for testing yet.
1015
1016        // release the document, the documentType (dt) still has the owner, and thus no need to release
1017        doc->release();
1018    }
1019
1020
1021
1022
1023    //
1024    //  CreateAttributeNS methods
1025    //
1026
1027    {
1028
1029        // Set up an initial (root element only) document.
1030        //
1031        DOMImplementation* impl = DOMImplementationRegistry::getDOMImplementation(X("Core"));
1032
1033
1034
1035        DOMDocumentType* dt = impl->createDocumentType(X("foo:docName"), X("pubId"), X("http://sysId"));
1036
1037        DOMDocument* doc = impl->createDocument(X("http://document.namespace"), X("foo:docName"), dt);
1038        DOMElement* rootEl = doc->getDocumentElement();
1039        UNUSED(rootEl); // silence warning
1040
1041        //
1042        // CreateAttributeNS
1043        //
1044
1045
1046        DOMAttr* attra = doc->createAttributeNS(X("http://nsa"), X("a:attra"));       // prefix and URI
1047        TASSERT(!XMLString::compareString(attra->getNodeName(), X("a:attra")));
1048        TASSERT(!XMLString::compareString(attra->getNamespaceURI(), X("http://nsa")));
1049
1050        TASSERT(!XMLString::compareString(attra->getPrefix(), X("a")));
1051
1052        TASSERT(!XMLString::compareString(attra->getLocalName(), X("attra")));
1053        TASSERT(!XMLString::compareString(attra->getName(), X("a:attra")));
1054        TASSERT(attra->getOwnerElement() == 0);
1055
1056        DOMAttr* attrb = doc->createAttributeNS(X("http://nsb"), X("attrb"));         //  URI, no prefix.
1057        TASSERT(!XMLString::compareString(attrb->getNodeName(), X("attrb")));
1058        TASSERT(!XMLString::compareString(attrb->getNamespaceURI(), X("http://nsb")));
1059        TASSERT(!XMLString::compareString(attrb->getPrefix(), XMLUni::fgZeroLenString));
1060        TASSERT(!XMLString::compareString(attrb->getLocalName(), X("attrb")));
1061        TASSERT(!XMLString::compareString(attrb->getName(), X("attrb")));
1062        TASSERT(attrb->getOwnerElement() == 0);
1063
1064
1065
1066        DOMAttr* attrc = doc->createAttributeNS(XMLUni::fgZeroLenString, X("attrc"));
1067        TASSERT(!XMLString::compareString(attrc->getNodeName(), X("attrc")));
1068        TASSERT(!XMLString::compareString(attrc->getNamespaceURI(), XMLUni::fgZeroLenString));
1069        TASSERT(!XMLString::compareString(attrc->getPrefix(), XMLUni::fgZeroLenString));
1070        TASSERT(!XMLString::compareString(attrc->getLocalName(), X("attrc")));
1071        TASSERT(!XMLString::compareString(attrc->getName(), X("attrc")));
1072        TASSERT(attrc->getOwnerElement() == 0);
1073
1074        // Badly formed qualified name
1075        EXCEPTION_TEST(doc->createAttributeNS(X("http://nsa"), X("<a")), DOMException::INVALID_CHARACTER_ERR);
1076
1077        EXCEPTION_TEST(doc->createAttributeNS(X("http://nsa"), X(":a")), DOMException::NAMESPACE_ERR);
1078
1079        EXCEPTION_TEST(doc->createAttributeNS(X("http://nsa"), X("a:")), DOMException::NAMESPACE_ERR);
1080
1081        EXCEPTION_TEST(doc->createAttributeNS(X("http://nsa"), X("a::a")), DOMException::NAMESPACE_ERR);
1082
1083        EXCEPTION_TEST(doc->createAttributeNS(X("http://nsa"), X("a:a:a")), DOMException::NAMESPACE_ERR);
1084
1085        // xml:a must have namespaceURI == "http://www.w3.org/XML/1998/namespace"
1086        TASSERT(!XMLString::compareString(doc->createAttributeNS(X("http://www.w3.org/XML/1998/namespace"), X("xml:a"))->getNamespaceURI(), X("http://www.w3.org/XML/1998/namespace")));
1087        EXCEPTION_TEST(doc->createAttributeNS(X("http://nsa"), X("xml:a")), DOMException::NAMESPACE_ERR);
1088        EXCEPTION_TEST(doc->createAttributeNS(XMLUni::fgZeroLenString, X("xml:a")), DOMException::NAMESPACE_ERR);
1089        EXCEPTION_TEST(doc->createAttributeNS(0,  X("xml:a")), DOMException::NAMESPACE_ERR);
1090
1091        //unlike Element, xmlns must have namespaceURI == "http://www.w3.org/2000/xmlns/"
1092        TASSERT(!XMLString::compareString(doc->createAttributeNS(X("http://www.w3.org/2000/xmlns/"), X("xmlns"))->getNamespaceURI(), X("http://www.w3.org/2000/xmlns/")));
1093        EXCEPTION_TEST(doc->createAttributeNS(X("http://nsa"), X("xmlns")), DOMException::NAMESPACE_ERR);
1094        EXCEPTION_TEST(doc->createAttributeNS(X("http://www.w3.org/XML/1998/namespace"), X("xmlns")), DOMException::NAMESPACE_ERR);
1095        EXCEPTION_TEST(doc->createAttributeNS(XMLUni::fgZeroLenString, X("xmlns")), DOMException::NAMESPACE_ERR);
1096        EXCEPTION_TEST(doc->createAttributeNS(0,  X("xmlns")), DOMException::NAMESPACE_ERR);
1097
1098        //unlike Element, xmlns:a must have namespaceURI == "http://www.w3.org/2000/xmlns/"
1099        TASSERT(!XMLString::compareString(doc->createAttributeNS(X("http://www.w3.org/2000/xmlns/"), X("xmlns:a"))->getNamespaceURI(), X("http://www.w3.org/2000/xmlns/")));
1100        EXCEPTION_TEST(doc->createAttributeNS(X("http://nsa"), X("xmlns:a")), DOMException::NAMESPACE_ERR);
1101        EXCEPTION_TEST(doc->createAttributeNS(X("http://www.w3.org/XML/1998/namespace"), X("xmlns:a")), DOMException::NAMESPACE_ERR);
1102        EXCEPTION_TEST(doc->createAttributeNS(XMLUni::fgZeroLenString, X("xmlns:a")), DOMException::NAMESPACE_ERR);
1103        EXCEPTION_TEST(doc->createAttributeNS(0,  X("xmlns:a")), DOMException::NAMESPACE_ERR);
1104
1105        //In fact, any prefix != null should have a namespaceURI != 0 or != ""
1106        TASSERT(!XMLString::compareString(doc->createAttributeNS(X("http://nsa"), X("foo:a"))->getNamespaceURI(), X("http://nsa")));
1107        EXCEPTION_TEST(doc->createAttributeNS(XMLUni::fgZeroLenString, X("foo:a")), DOMException::NAMESPACE_ERR);
1108        EXCEPTION_TEST(doc->createAttributeNS(0,  X("foo:a")), DOMException::NAMESPACE_ERR);
1109
1110        //Change prefix
1111        DOMAttr* attr = doc->createAttributeNS(X("http://nsa"), X("foo:a"));
1112        attr->setPrefix(X("bar"));
1113
1114        TASSERT(!XMLString::compareString(attr->getNodeName(), X("bar:a")));
1115        TASSERT(!XMLString::compareString(attr->getNamespaceURI(), X("http://nsa")));
1116        TASSERT(!XMLString::compareString(attr->getPrefix(), X("bar")));
1117        TASSERT(!XMLString::compareString(attr->getName(), X("bar:a")));
1118        //The spec does not prevent us from setting prefix to a node without prefix
1119        TASSERT(!XMLString::compareString(attr->getLocalName(), X("a")));
1120        attr = doc->createAttributeNS(X("http://nsa"), X("a"));
1121        TASSERT(!XMLString::compareString(attr->getPrefix(), XMLUni::fgZeroLenString));
1122        attr->setPrefix(X("bar"));
1123        TASSERT(!XMLString::compareString(attr->getNodeName(), X("bar:a")));
1124        TASSERT(!XMLString::compareString(attr->getNamespaceURI(), X("http://nsa")));
1125        TASSERT(!XMLString::compareString(attr->getPrefix(), X("bar")));
1126        TASSERT(!XMLString::compareString(attr->getLocalName(), X("a")));
1127        TASSERT(!XMLString::compareString(attr->getName(), X("bar:a")));
1128
1129
1130        //Special case for xml:a where namespaceURI must be xmlURI
1131        attr = doc->createAttributeNS(X("http://www.w3.org/XML/1998/namespace"), X("foo:a"));
1132        attr->setPrefix(X("xml"));
1133        attr = doc->createAttributeNS(X("http://nsa"), X("foo:a"));
1134        EXCEPTION_TEST(attr->setPrefix(X("xml")), DOMException::NAMESPACE_ERR);
1135        //Special case for xmlns:a where namespaceURI must be xmlURI
1136        attr = doc->createAttributeNS(X("http://www.w3.org/2000/xmlns/"), X("foo:a"));
1137
1138        attr->setPrefix(X("xmlns"));
1139        attr = doc->createAttributeNS(X("http://nsa"), X("foo:a"));
1140        EXCEPTION_TEST(attr->setPrefix(X("xmlns")), DOMException::NAMESPACE_ERR);
1141        //Special case for xmlns where no prefix can be set
1142        attr = doc->createAttributeNS(X("http://www.w3.org/2000/xmlns/"), X("xmlns"));
1143
1144        EXCEPTION_TEST(attr->setPrefix(X("foo")), DOMException::NAMESPACE_ERR);
1145        EXCEPTION_TEST(attr->setPrefix(X("xmlns")), DOMException::NAMESPACE_ERR);
1146        //Also an attribute can not have a prefix with namespaceURI == null or ""
1147        attr = doc->createAttributeNS(XMLUni::fgZeroLenString, X("a"));
1148        EXCEPTION_TEST(attr->setPrefix(X("foo")), DOMException::NAMESPACE_ERR);
1149        attr = doc->createAttributeNS(0, X("a"));
1150        EXCEPTION_TEST(attr->setPrefix(X("foo")), DOMException::NAMESPACE_ERR);
1151
1152        //Only prefix of Element and Attribute can be changed
1153        EXCEPTION_TEST(doc->setPrefix(X("foo")), DOMException::NAMESPACE_ERR);
1154
1155        //Prefix of readonly Attribute can not be changed.
1156        //However, there is no way to create such DOMAttribute for testing yet.
1157
1158        // release the document, the documentType (dt) still has the owner, and thus no need to release
1159        doc->release();
1160    }
1161
1162
1163
1164    //
1165    //  getElementsByTagName*
1166    //
1167
1168    {
1169
1170        // Set up an initial (root element only) document.
1171        //
1172        DOMImplementation* impl = DOMImplementationRegistry::getDOMImplementation(X("Core"));
1173        DOMDocumentType* dt = impl->createDocumentType(X("foo:docName"), X("pubId"), X("http://sysId"));
1174
1175        DOMDocument* doc = impl->createDocument(X("http://document.namespace"), X("foo:docName"), dt);
1176
1177        DOMElement* rootEl = doc->getDocumentElement();
1178
1179        //
1180        // Populate the document
1181        //
1182
1183        DOMElement* ela = doc->createElementNS(X("http://nsa"), X("a:ela"));
1184        rootEl->appendChild(ela);
1185
1186        DOMElement* elb = doc->createElementNS(X("http://nsb"), X("elb"));
1187        rootEl->appendChild(elb);
1188
1189        DOMElement* elc = doc->createElementNS(XMLUni::fgZeroLenString, X("elc"));
1190        rootEl->appendChild(elc);
1191
1192        DOMElement* eld = doc->createElementNS(X("http://nsa"), X("d:ela"));
1193        rootEl->appendChild(eld);
1194
1195        DOMElement* ele = doc->createElementNS(X("http://nse"), X("elb"));
1196        rootEl->appendChild(ele);
1197
1198
1199        //
1200        // Access with DOM Level 1 getElementsByTagName
1201        //
1202
1203        DOMNodeList* nl;
1204
1205        nl = doc->getElementsByTagName(X("a:ela"));
1206        TASSERT(nl->getLength() == 1);
1207        TASSERT(nl->item(0) == ela);
1208
1209        nl = doc->getElementsByTagName(X("elb"));
1210        TASSERT(nl->getLength() == 2);
1211        TASSERT(nl->item(0) == elb);
1212        TASSERT(nl->item(1) == ele);
1213
1214        nl = doc->getElementsByTagName(X("d:ela"));
1215        TASSERT(nl->getLength() == 1);
1216        TASSERT(nl->item(0) == eld);
1217
1218        //
1219        //  Access with DOM Level 2 getElementsByTagNameNS
1220        //
1221
1222        nl = doc->getElementsByTagNameNS(XMLUni::fgZeroLenString, X("elc"));
1223        TASSERT(nl->getLength() == 1);
1224        TASSERT(nl->item(0) == elc);
1225
1226        nl = doc->getElementsByTagNameNS(0, X("elc"));
1227        TASSERT(nl->getLength() == 1);
1228        TASSERT(nl->item(0) == elc);
1229
1230        nl = doc->getElementsByTagNameNS(X("http://nsa"), X("ela"));
1231        TASSERT(nl->getLength() == 2);
1232        TASSERT(nl->item(0) == ela);
1233        TASSERT(nl->item(1) == eld);
1234
1235        nl = doc->getElementsByTagNameNS(XMLUni::fgZeroLenString, X("elb"));
1236        TASSERT(nl->getLength() == 0);
1237
1238        nl = doc->getElementsByTagNameNS(X("http://nsb"), X("elb"));
1239        TASSERT(nl->getLength() == 1);
1240        TASSERT(nl->item(0) == elb);
1241
1242        nl = doc->getElementsByTagNameNS(X("*"), X("elb"));
1243        TASSERT(nl->getLength() == 2);
1244        TASSERT(nl->item(0) == elb);
1245        TASSERT(nl->item(1) == ele);
1246
1247        nl = doc->getElementsByTagNameNS(X("http://nsa"), X("*"));
1248        TASSERT(nl->getLength() == 2);
1249        TASSERT(nl->item(0) == ela);
1250        TASSERT(nl->item(1) == eld);
1251
1252        nl = doc->getElementsByTagNameNS(X("*"), X("*"));
1253        TASSERT(nl->getLength() == 6);     // Gets the document root element, plus 5 more
1254
1255        TASSERT(nl->item(6) == 0);
1256        // TASSERT(nl->item(-1) == 0);
1257
1258        nl = rootEl->getElementsByTagNameNS(X("*"), X("*"));
1259        TASSERT(nl->getLength() == 5);
1260
1261
1262        nl = doc->getElementsByTagNameNS(X("http://nsa"), X("d:ela"));
1263        TASSERT(nl->getLength() == 0);
1264
1265
1266        //
1267        // Node lists are Live
1268        //
1269
1270        nl = doc->getElementsByTagNameNS(X("*"), X("*"));
1271        DOMNodeList* nla = ela->getElementsByTagNameNS(X("*"), X("*"));
1272
1273        TASSERT(nl->getLength() == 6);
1274        TASSERT(nla->getLength() == 0);
1275
1276        DOMNode* rem = rootEl->removeChild(elc);
1277        rem->release();
1278        TASSERT(nl->getLength() == 5);
1279        TASSERT(nla->getLength() == 0);
1280
1281        ela->appendChild(elc);
1282        TASSERT(nl->getLength() == 6);
1283        TASSERT(nla->getLength() == 1);
1284
1285        // release the document, the documentType (dt) still has the owner, and thus no need to release
1286        doc->release();
1287    }
1288
1289
1290
1291   //
1292    // Attributes and NamedNodeMaps.
1293    //
1294
1295    {
1296
1297        // Set up an initial (root element only) document.
1298        //
1299        DOMImplementation* impl = DOMImplementationRegistry::getDOMImplementation(X("Core"));
1300
1301        DOMDocumentType* dt = impl->createDocumentType(X("foo:docName"), X("pubId"), X("http://sysId"));
1302
1303        DOMDocument* doc = impl->createDocument(X("http://document.namespace"), X("foo:docName"), dt);
1304        DOMElement* rootEl = doc->getDocumentElement();
1305
1306        //
1307        // Create a set of attributes and hang them on the root element.
1308        //
1309
1310        DOMAttr* attra = doc->createAttributeNS(X("http://nsa"), X("a:attra"));
1311        DOMNode* rem = rootEl->setAttributeNodeNS(attra);
1312        if (rem)
1313            rem->release();
1314
1315        //
1316        // Check that the attribute nodes were created with the correct properties.
1317        //
1318        TASSERT(!XMLString::compareString(attra->getNodeName(), X("a:attra")));
1319        TASSERT(!XMLString::compareString(attra->getNamespaceURI(), X("http://nsa")));
1320
1321        TASSERT(!XMLString::compareString(attra->getLocalName(), X("attra")));
1322        TASSERT(!XMLString::compareString(attra->getName(), X("a:attra")));
1323        TASSERT(attra->getNodeType() == DOMNode::ATTRIBUTE_NODE);
1324        TASSERT(!XMLString::compareString(attra->getNodeValue(), XMLUni::fgZeroLenString));
1325
1326        TASSERT(!XMLString::compareString(attra->getPrefix(), X("a")));
1327        TASSERT(attra->getSpecified() == true);
1328        TASSERT(!XMLString::compareString(attra->getValue(), XMLUni::fgZeroLenString));
1329
1330        //
1331        // Create a set of attributes and hang them on the root element.
1332        //
1333
1334        DOMAttr* attrb = doc->createAttributeNS(X("http://nsb"), X("attrb"));
1335        rem = rootEl->setAttributeNodeNS(attrb);
1336        if (rem)
1337            rem->release();
1338
1339        DOMAttr* attrc = doc->createAttributeNS(XMLUni::fgZeroLenString, X("attrc"));
1340        rem = rootEl->setAttributeNodeNS(attrc);
1341        if (rem)
1342            rem->release();
1343
1344        // this one will replace the attra
1345        DOMAttr* attrd = doc->createAttributeNS(X("http://nsa"), X("d:attra"));
1346        rem = rootEl->setAttributeNodeNS(attrd);
1347        TASSERT(attra->getOwnerElement() == 0);
1348        if (rem)
1349            rem->release();
1350
1351        DOMAttr* attre = doc->createAttributeNS(X("http://nse"), X("attrb"));
1352        rem = rootEl->setAttributeNodeNS(attre);
1353        if (rem)
1354            rem->release();
1355
1356        // Test methods of NamedNodeMap
1357        DOMNamedNodeMap* nnm = rootEl->getAttributes();
1358        TASSERT(nnm->getLength() == 4);
1359
1360
1361        TASSERT(nnm->getNamedItemNS(X("http://nsa"), X("attra")) == attrd);
1362        TASSERT(nnm->getNamedItemNS(X("http://nsb"), X("attrb")) == attrb);
1363        TASSERT(nnm->getNamedItemNS(XMLUni::fgZeroLenString, X("attra")) == 0);
1364        TASSERT(nnm->getNamedItemNS(X("http://nsa"), X("attrb")) == 0);
1365
1366        TASSERT(nnm->getNamedItemNS(X("http://nse"), X("attrb")) == attre);
1367
1368        TASSERT(nnm->getNamedItemNS(XMLUni::fgZeroLenString, X("attrc")) == attrc);
1369
1370        // Test hasAttributes, hasAttribute, hasAttributeNS
1371        TASSERT(doc->hasAttributes() ==  false);
1372        TASSERT(attrc->hasAttributes() == false);
1373        TASSERT(rootEl->hasAttributes() == true);
1374        TASSERT(rootEl->hasAttribute(X("attrc")) == true);
1375
1376        TASSERT(rootEl->hasAttribute(X("wrong")) == false);
1377
1378        TASSERT(rootEl->hasAttributeNS(X("http://nsa"), X("attra")) == true);
1379        TASSERT(rootEl->hasAttributeNS(X("http://nsa"), X("wrong")) == false);
1380
1381        // release the document, the documentType (dt) still has the owner, and thus no need to release
1382        doc->release();
1383    }
1384
1385
1386    //
1387    //
1388    //
1389
1390}
1391
1392
1393//---------------------------------------------------------------------------------------
1394//
1395//   DOMReleaseTests    Test if the release() function
1396//
1397//---------------------------------------------------------------------------------------
1398void DOMReleaseTests()
1399{
1400    XMLCh tempStr[4000];
1401    XMLCh tempStr2[4000];
1402    XMLCh tempStr3[4000];
1403    XMLString::transcode("status", tempStr, 3999);
1404    XMLString::transcode("true", tempStr2, 3999);
1405    XMLString::transcode("root", tempStr3, 3999);
1406
1407    //create document
1408    DOMDocument*  cpXMLDocument;
1409    cpXMLDocument = DOMImplementation::getImplementation()->createDocument();
1410    //create root element
1411    DOMElement*   cpRoot = cpXMLDocument->createElement(tempStr3);
1412    //create status attribute
1413    cpRoot->setAttribute(tempStr,tempStr2);
1414    DOMAttr* pAttr = cpRoot->getAttributeNode(tempStr);
1415
1416    //simulate setting the attribute value
1417    //   The setValue and setAttribute should call release internally so that
1418    //   the overall memory usage is not increased
1419    int i = 0;
1420    for(i=0;i<20000;i++)
1421    {
1422        pAttr->setValue(tempStr2);
1423    }
1424    for(i=0;i<20000;i++)
1425    {
1426        //same problem
1427        cpRoot->removeAttribute(tempStr);
1428        cpRoot->setAttribute(tempStr,tempStr2);
1429    }
1430
1431    //simulate changing node value
1432    //   the overall memory usage is not increased
1433    char tempchar[4000];
1434    for(i=0;i<20000;i++)
1435    {
1436        sprintf(tempchar, "time is %lu\n",XMLPlatformUtils::getCurrentMillis());
1437        XMLSize_t len = strlen(tempchar), j;
1438        for (j = len; j < 4000-len; j++)
1439            tempchar[j] = 'a';
1440        tempchar[j]=0;
1441        pAttr->setNodeValue(X(tempchar));
1442    }
1443
1444    DOMText*  text = cpXMLDocument->createTextNode(tempStr3);
1445    for(i=0;i<20000;i++)
1446    {
1447        sprintf(tempchar, "time is %lu\n",XMLPlatformUtils::getCurrentMillis());
1448        XMLSize_t len = strlen(tempchar), j;
1449        for (j = len; j < 4000-len; j++)
1450            tempchar[j] = 'a';
1451        tempchar[j]=0;
1452        text->setNodeValue(X(tempchar));
1453    }
1454
1455    cpXMLDocument->release();
1456
1457}
1458
1459
1460//---------------------------------------------------------------------------------------
1461//
1462//   main
1463//
1464//---------------------------------------------------------------------------------------
1465int  mymain()
1466{
1467    try {
1468        XMLPlatformUtils::Initialize();
1469    }
1470    catch (const XMLException& toCatch) {
1471        char *pMessage = XMLString::transcode(toCatch.getMessage());
1472        fprintf(stderr, "Error during XMLPlatformUtils::Initialize(). \n"
1473            "  Message is: %s\n", pMessage);
1474        XMLString::release(&pMessage);
1475        return -1;
1476    }
1477
1478    DOMBasicTests();
1479    DOMNSTests();
1480    DOMReleaseTests();
1481
1482    //
1483    //  Print Final allocation stats for full set of tests
1484    //
1485    XMLPlatformUtils::Terminate();
1486
1487    return 0;
1488
1489};
1490
1491int  main() {
1492   for (int i = 0; i<3; i++)
1493        mymain();
1494
1495    if (errorOccurred) {
1496        printf("Test Failed\n");
1497        return 4;
1498    }
1499
1500    printf("Test Run Successfully\n");
1501
1502    return 0;
1503}
1504
Note: See TracBrowser for help on using the repository browser.