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

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

词法分析

开发平台：

Visual C++

DOMMemTest.cpp：源码内容
  1. /*
  2.  * The Apache Software License, Version 1.1
  3.  *
  4.  * Copyright (c) 2002 The Apache Software Foundation.  All rights
  5.  * reserved.
  6.  *
  7.  * Redistribution and use in source and binary forms, with or without
  8.  * modification, are permitted provided that the following conditions
  9.  * are met:
  10.  *
  11.  * 1. Redistributions of source code must retain the above copyright
  12.  *    notice, this list of conditions and the following disclaimer.
  13.  *
  14.  * 2. Redistributions in binary form must reproduce the above copyright
  15.  *    notice, this list of conditions and the following disclaimer in
  16.  *    the documentation and/or other materials provided with the
  17.  *    distribution.
  18.  *
  19.  * 3. The end-user documentation included with the redistribution,
  20.  *    if any, must include the following acknowledgment:
  21.  *       "This product includes software developed by the
  22.  *        Apache Software Foundation (http://www.apache.org/)."
  23.  *    Alternately, this acknowledgment may appear in the software itself,
  24.  *    if and wherever such third-party acknowledgments normally appear.
  25.  *
  26.  * 4. The names "Xerces" and "Apache Software Foundation" must
  27.  *    not be used to endorse or promote products derived from this
  28.  *    software without prior written permission. For written
  29.  *    permission, please contact apache@apache.org.
  30.  *
  31.  * 5. Products derived from this software may not be called "Apache",
  32.  *    nor may "Apache" appear in their name, without prior written
  33.  *    permission of the Apache Software Foundation.
  34.  *
  35.  * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESSED OR IMPLIED
  36.  * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
  37.  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
  38.  * DISCLAIMED.  IN NO EVENT SHALL THE APACHE SOFTWARE FOUNDATION OR
  39.  * ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  40.  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
  41.  * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF
  42.  * USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
  43.  * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
  44.  * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
  45.  * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  46.  * SUCH DAMAGE.
  47.  * ====================================================================
  48.  *
  49.  * This software consists of voluntary contributions made by many
  50.  * individuals on behalf of the Apache Software Foundation, and was
  51.  * originally based on software copyright (c) 2002, International
  52.  * Business Machines, Inc., http://www.ibm.com .  For more information
  53.  * on the Apache Software Foundation, please see
  54.  * <http://www.apache.org/>.
  55.  */
  57. //
  58. //  Various DOM tests.
  59. //     This is NOT a complete test of DOM functionality.
  60. //
  62. /*
  63.  * $Id: DOMMemTest.cpp,v 1.42 2003/02/05 18:55:19 tng Exp $
  64.  */
  66. #include <stdio.h>
  67. #include <string.h>
  68. #include <xercesc/dom/DOM.hpp>
  69. #include <xercesc/util/PlatformUtils.hpp>
  70. #include <xercesc/util/XMLException.hpp>
  71. #include <xercesc/util/XMLString.hpp>
  72. #include <xercesc/util/XMLUniDefs.hpp>
  75. XERCES_CPP_NAMESPACE_USE
  77. bool errorOccurred = false;
  79. #define TASSERT(c) tassert((c), __FILE__, __LINE__)
  81. void tassert(bool c, const char *file, int line)
  82. {
  83.     if (!c) {
  84.         printf("Failure.  Line %d,   file %sn", line, file);
  85.         errorOccurred = true;
  86.     }
  87. };
  90. #define EXCEPTION_TEST(operation, expected_exception)               
  91. {                                                                   
  92.     try {                                                           
  93.     operation;                                                      
  94.     printf(" Error: no exception thrown at line %dn", __LINE__);   
  95.     errorOccurred = true;                                           
  96.     }                                                               
  97.     catch (DOMException &e) {                                       
  98.     if (e.code != expected_exception) {                             
  99.         printf(" Wrong exception code: %d at line %dn", e.code, __LINE__); 
  100.         errorOccurred = true;                                       
  101.     }                                                               
  102.     }                                                               
  103.     catch (...)   {                                                 
  104.         printf(" Wrong exception thrown at line %dn", __LINE__);   
  105.         errorOccurred = true;                                       
  106.     }                                                               
  107. }
  109. // ---------------------------------------------------------------------------
  110. //  This is a simple class that lets us do easy (though not terribly efficient)
  111. //  trancoding of char* data to XMLCh data.
  112. // ---------------------------------------------------------------------------
  113. class XStr
  114. {
  115. public :
  116.     // -----------------------------------------------------------------------
  117.     //  Constructors and Destructor
  118.     // -----------------------------------------------------------------------
  119.     XStr(const char* const toTranscode)
  120.     {
  121.         // Call the private transcoding method
  122.         fUnicodeForm = XMLString::transcode(toTranscode);
  123.     }
  125.     ~XStr()
  126.     {
  127.         XMLString::release(&fUnicodeForm);
  128.     }
  131.     // -----------------------------------------------------------------------
  132.     //  Getter methods
  133.     // -----------------------------------------------------------------------
  134.     const XMLCh* unicodeForm() const
  135.     {
  136.         return fUnicodeForm;
  137.     }
  139. private :
  140.     // -----------------------------------------------------------------------
  141.     //  Private data members
  142.     //
  143.     //  fUnicodeForm
  144.     //      This is the Unicode XMLCh format of the string.
  145.     // -----------------------------------------------------------------------
  146.     XMLCh*   fUnicodeForm;
  147. };
  149. #define X(str) XStr(str).unicodeForm()
  151. //---------------------------------------------------------------------------------------
  152. //
  153. //   DOMBasicTests    Basic DOM Level 1 tests
  154. //
  155. //---------------------------------------------------------------------------------------
  156. void DOMBasicTests()
  157. {
  158.     //
  159.     //  Test Doc01      Create a new empty document
  160.     //
  161.     {
  162.         //  First precondition, so that lazily created strings do not appear
  163.         //  as memory leaks.
  164.         DOMDocument*   doc;
  165.         doc = DOMImplementationRegistry::getDOMImplementation(X("Core"))->createDocument();
  166.         doc->release();
  167.     }
  169.     //
  170.     //  Test Doc02      Create one of each kind of node using the
  171.     //                  document createXXX methods.
  172.     //                  Watch for memory leaks.
  173.     //
  174.     {
  175.         //  Do all operations in a preconditioning step, to force the
  176.         //  creation of implementation objects that are set up on first use.
  177.         //  Don't watch for leaks in this block (no  / )
  178.         DOMDocument* doc = DOMImplementationRegistry::getDOMImplementation(X("Core"))->createDocument();
  180.         DOMElement*   el = doc->createElement(X("Doc02Element"));
  182.         DOMDocumentFragment* frag = doc->createDocumentFragment ();
  184.         DOMText*  text = doc->createTextNode(X("Doc02TextNode"));
  186.         DOMComment* comment = doc->createComment(X("Doc02Comment"));
  188.         DOMCDATASection*  cdataSec = doc->createCDATASection(X("Doc02CDataSection"));
  190.         DOMDocumentType*  docType = doc->createDocumentType(X("Doc02DocumentType"));
  192.         DOMNotation* notation = doc->createNotation(X("Doc02Notation"));
  194.         DOMProcessingInstruction* pi = doc->createProcessingInstruction(X("Doc02PITarget"), X("Doc02PIData"));
  196.         DOMNodeList*    nodeList = doc->getElementsByTagName(X("*"));
  198.         doc->release();
  199.     }
  203.     //
  204.     //  Doc03 - Create a small document tree
  205.     //
  207.     {
  208.         DOMDocument*   doc = DOMImplementationRegistry::getDOMImplementation(X("Core"))->createDocument();
  210.         DOMElement*   rootEl = doc->createElement(X("Doc03RootElement"));
  212.         doc->appendChild(rootEl);
  214.         DOMText*       textNode = doc->createTextNode(X("Doc03 text stuff"));
  216.         rootEl->appendChild(textNode);
  218.         DOMNodeList*    nodeList = doc->getElementsByTagName(X("*"));
  219.         doc->release();
  220.     };
  224.     //
  225.     //  Attr01
  226.     //
  227.     {
  228.         DOMDocument*   doc = DOMImplementationRegistry::getDOMImplementation(X("Core"))->createDocument();
  230.         DOMElement*   rootEl  = doc->createElement(X("RootElement"));
  232.         doc->appendChild(rootEl);
  233.         {
  234.             DOMAttr*        attr01  = doc->createAttribute(X("Attr01"));
  235.             DOMNode* rem = rootEl->setAttributeNode(attr01);
  236.             if (rem)
  237.                 rem->release();
  239.         }
  242.         {
  243.             DOMAttr* attr02 = doc->createAttribute(X("Attr01"));
  244.             DOMNode* rem = rootEl->setAttributeNode(attr02);
  245.             if (rem)
  246.                 rem->release();
  247.         }
  248.         doc->release();
  250.     };
  252.     //
  253.     //  Attr02
  254.     //
  256.     {
  257.         DOMDocument*   doc = DOMImplementationRegistry::getDOMImplementation(X("Core"))->createDocument();
  259.         DOMElement*   rootEl  = doc->createElement(X("RootElement"));
  261.         doc->appendChild(rootEl);
  263.         DOMAttr*        attr01  = doc->createAttribute(X("Attr02"));
  265.         DOMNode* rem = rootEl->setAttributeNode(attr01);
  266.         if (rem)
  267.             rem->release();
  270.         DOMAttr*        attr02 = doc->createAttribute(X("Attr02"));
  272.         rem = rootEl->setAttributeNode(attr02);
  273.         if (rem)
  274.             rem->release();
  275.         doc->release();
  276.     }
  280.     //
  281.     //  Attr03
  282.     //
  284.     {
  285.         DOMDocument*   doc = DOMImplementationRegistry::getDOMImplementation(X("Core"))->createDocument();
  287.         DOMElement*   rootEl  = doc->createElement(X("RootElement"));
  289.         doc->appendChild(rootEl);
  291.         DOMAttr*        attr01  = doc->createAttribute(X("Attr03"));
  293.         DOMNode* rem = rootEl->setAttributeNode(attr01);
  294.         if (rem)
  295.             rem->release();
  298.         attr01->setValue(X("Attr03Value1"));
  300.         attr01->setValue(X("Attr03Value2"));
  301.         doc->release();
  302.     }
  306.     //
  307.     //  Attr04
  308.     //
  310.     {
  311.         DOMDocument*   doc = DOMImplementationRegistry::getDOMImplementation(X("Core"))->createDocument();
  313.         DOMElement*   rootEl  = doc->createElement(X("RootElement"));
  315.         doc->appendChild(rootEl);
  317.         DOMAttr*        attr01  = doc->createAttribute(X("Attr04"));
  319.         DOMNode* rem = rootEl->setAttributeNode(attr01);
  320.         if (rem)
  321.             rem->release();
  323.         attr01->setValue(X("Attr04Value1"));
  325.         DOMNode* value = attr01->getFirstChild();
  326.         doc->release();
  327.     }
  332.     //
  333.     //  Text01
  334.     //
  336.     {
  337.         DOMDocument*   doc = DOMImplementationRegistry::getDOMImplementation(X("Core"))->createDocument();
  339.         DOMElement*   rootEl  = doc->createElement(X("RootElement"));
  341.         doc->appendChild(rootEl);
  343.         DOMText*        txt1 = doc->createTextNode(X("Hello Goodbye"));
  344.         rootEl->appendChild(txt1);
  346.         txt1->splitText(6);
  347.         rootEl->normalize();
  348.         doc->release();
  350.     }
  354.     //
  355.     //  Notation01
  356.     //
  358.     {
  359.         DOMDocument*       doc = DOMImplementationRegistry::getDOMImplementation(X("Core"))->createDocument();
  361.         DOMDocumentType*   dt  = doc->createDocumentType(X("DocType_for_Notation01"));
  363.         doc->appendChild(dt);
  366.         DOMNamedNodeMap* notationMap = dt->getNotations();
  368.         DOMNotation*    nt1 = doc->createNotation(X("Notation01"));
  370.         DOMNode* rem = notationMap->setNamedItem (nt1);
  371.         if (rem)
  372.             rem->release();
  374.         DOMNode*  abc1 = notationMap->getNamedItem(X("Notation01"));
  376.         DOMNotation*    nt2 = (DOMNotation*) abc1;
  377.         TASSERT(nt1==nt2);
  378.         nt2 = 0;
  379.         nt1 = 0;
  381.         DOMNode* abc6 = notationMap->getNamedItem(X("Notation01"));
  383.         nt2 = (DOMNotation*) abc6;
  384.         doc->release();
  385.     }
  389.     //
  390.     //  NamedNodeMap01 - comparison operators.
  391.     //
  393.     {
  394.         DOMNamedNodeMap*    nnm = 0;
  395.         TASSERT(nnm == 0);
  397.         DOMDocument*       doc = DOMImplementationRegistry::getDOMImplementation(X("Core"))->createDocument();
  398.         nnm = doc->getAttributes();    // Should be null, because node type
  399.                                       //   is not Element.
  400.         TASSERT(nnm == 0);
  401.         TASSERT(!(nnm != 0));
  403.         DOMElement* el = doc->createElement(X("NamedNodeMap01"));
  405.         DOMNamedNodeMap* nnm2 = el->getAttributes();    // Should be an empty, but non-null map.
  406.         TASSERT(nnm2 != 0);
  407.         TASSERT(nnm != nnm2);
  408.         nnm = nnm2;
  409.         TASSERT(nnm == nnm2);
  410.         doc->release();
  411.     }
  415.     //
  416.     //  importNode quick test
  417.     //
  419.     {
  420.         DOMDocument*   doc1 = DOMImplementationRegistry::getDOMImplementation(X("Core"))->createDocument();
  421.         DOMDocument*   doc2 = DOMImplementationRegistry::getDOMImplementation(X("Core"))->createDocument();
  423.         DOMElement*   el1  = doc1->createElement(X("abc"));
  425.         doc1->appendChild(el1);
  426.         TASSERT(el1->getParentNode() != 0);
  427.         DOMNode*        el2  = doc2->importNode(el1, true);
  428.         TASSERT(el2->getParentNode() == 0);
  429.         const XMLCh*       tagName = el2->getNodeName();
  431.         TASSERT(!XMLString::compareString(tagName, X("abc")));
  433.         TASSERT(el2->getOwnerDocument() == doc2);
  434.         TASSERT(doc1 != doc2);
  435.         doc1->release();
  436.         doc2->release();
  437.     }
  440.     //
  441.     //  getLength() tests.  Both Node CharacterData and NodeList implement
  442.     //                  getLength().  Early versions of the DOM had a clash
  443.     //                  between the two, originating in the implementation class
  444.     //                  hirearchy, which has NodeList as a (distant) base class
  445.     //                  of CharacterData.  This is a regression test to verify
  446.     //                  that the problem stays fixed.
  447.     //
  449.     {
  450.         DOMDocument*    doc = DOMImplementationRegistry::getDOMImplementation(X("Core"))->createDocument();
  452.         DOMText*          tx = doc->createTextNode(X("Hello"));
  454.         DOMElement*     el = doc->createElement(X("abc"));
  456.         el->appendChild(tx);
  458.         int     textLength = tx->getLength();
  459.         TASSERT(textLength == 5);
  461.         DOMNodeList*      nl = tx->getChildNodes();
  462.         int      nodeListLen = nl->getLength();
  463.         TASSERT(nodeListLen == 0);
  465.         nl = el->getChildNodes();
  466.         nodeListLen = nl->getLength();
  467.         TASSERT(nodeListLen == 1);
  468.         doc->release();
  469.     }
  472.     //
  473.     //  NodeList - comparison operators, basic operation.
  474.     //
  476.     {
  477.         DOMNodeList*    nl = 0;
  478.         DOMNodeList*    nl2 = 0;
  479.         TASSERT(nl == 0);
  480.         TASSERT(!(nl != 0));
  481.         TASSERT(nl == nl2);
  483.         DOMDocument*       doc = DOMImplementationRegistry::getDOMImplementation(X("Core"))->createDocument();
  484.         nl = doc->getChildNodes();    // Should be non-null, but empty
  486.         TASSERT(nl != 0);
  487.         int len = nl->getLength();
  488.         TASSERT(len == 0);
  490.         DOMElement* el = doc->createElement(X("NodeList01"));
  492.         doc->appendChild(el);
  493.         len = nl->getLength();
  494.         TASSERT(len == 1);
  495.         TASSERT(nl != nl2);
  496.         nl2 = nl;
  497.         TASSERT(nl == nl2);
  498.         doc->release();
  499.     }
  504.     //
  505.     //  Name validity checking.
  506.     //
  508.     {
  509.          DOMDocument*       doc = DOMImplementationRegistry::getDOMImplementation(X("Core"))->createDocument();
  510.          try
  511.          {
  512.              DOMElement* el = doc->createElement(X("!@@ bad element name"));
  513.              TASSERT(false);  // Exception above should prevent us reaching here.
  514.          }
  515.          catch ( DOMException e)
  516.          {
  517.              TASSERT(e.code == DOMException::INVALID_CHARACTER_ERR);
  518.          }
  519.          catch (...)
  520.          {
  521.              TASSERT(false);  // Wrong exception thrown.
  522.          }
  523.          doc->release();
  524.     }
  528.     //
  529.     //  Assignment ops return value
  530.     //
  532.     {
  533.         DOMDocument*       doc = DOMImplementationRegistry::getDOMImplementation(X("Core"))->createDocument();
  535.         DOMElement* el = doc->createElement(X("NodeList01"));
  537.         doc->appendChild(el);
  539.         DOMElement* n1, *n2, *n3;
  541.         n1 = n2 = n3 = el;
  542.         TASSERT(n1 == n2);
  543.         TASSERT(n1 == n3);
  544.         TASSERT(n1 == el);
  545.         TASSERT(n1 != 0);
  546.         n1 = n2 = n3 = 0;
  547.         TASSERT(n1 == 0);
  548.         doc->release();
  549.     }
  553.     //
  554.     //  Cloning of a node with attributes. Regression test for a ref counting
  555.     //  bug in attributes of cloned nodes that occured when the "owned" flag
  556.     //  was not set in the clone.
  557.     //
  559.     {
  560.         DOMDocument*   doc = DOMImplementationRegistry::getDOMImplementation(X("Core"))->createDocument();
  562.         DOMElement*   root = doc->createElement(X("CTestRoot"));
  564.         root->setAttribute(X("CTestAttr"), X("CTestAttrValue"));
  566.         const XMLCh* s = root->getAttribute(X("CTestAttr"));
  567.         TASSERT(!XMLString::compareString(s, X("CTestAttrValue")));
  569.         DOMNode* abc2 = root->cloneNode(true);
  570.         DOMElement*   cloned = (DOMElement*) abc2;
  571.         DOMAttr* a = cloned->getAttributeNode(X("CTestAttr"));
  572.         TASSERT(a != 0);
  573.         s = a->getValue();
  574.         TASSERT(!XMLString::compareString(s, X("CTestAttrValue")));
  575.         a = 0;
  577.         a = cloned->getAttributeNode(X("CTestAttr"));
  578.         TASSERT(a != 0);
  579.         s = a->getValue();
  580.         TASSERT(!XMLString::compareString(s, X("CTestAttrValue")));
  581.         doc->release();
  583.     }
  587.     //
  588.     //  splitText()
  589.     //     Regression test for a bug from Tinny Ng
  590.     //
  592.     {
  593.         DOMDocument* doc;
  594.         doc = DOMImplementationRegistry::getDOMImplementation(X("Core"))->createDocument();
  595.         DOMText* tn, *tn1, *tn2;
  597.         tn = doc->createTextNode (X("0123456789"));
  599.         tn1 = tn->splitText(5);
  601.         TASSERT(!XMLString::compareString(tn->getNodeValue(), X("01234")));
  603.         TASSERT(!XMLString::compareString(tn1->getNodeValue(), X("56789")));
  606.         tn2 = tn->splitText(5);
  607.         TASSERT(!XMLString::compareString(tn->getNodeValue(), X("01234")));
  609.         TASSERT(!XMLString::compareString(tn2->getNodeValue(), XMLUni::fgZeroLenString));
  611.         EXCEPTION_TEST(tn->splitText(6), DOMException::INDEX_SIZE_ERR);
  612.         doc->release();
  613.     }
  617. }
  620. //---------------------------------------------------------------------------------------
  621. //
  622. //   DOMNSTests    DOM Name Space tests
  623. //
  624. //---------------------------------------------------------------------------------------
  625. void DOMNSTests()
  626. {
  628.     //
  629.     //  DOM Level 2 tests.  These should be split out as a separate test.
  630.     //
  633.     //
  634.     // hasFeature.  The set of supported options tested here is for Xerces 1.1
  635.     //              Note: because the implementation lazily creates some of the comprison
  636.     //                    strings within the implementation, this test must be pre-flighted
  637.     //                    outside of the TESPROLOG/ macros to avoid spurious
  638.     //                    reports of memory leaks.
  639.     //
  640.     // Also test the case-insensitive
  641.     //
  642.     {
  644.         DOMImplementation*  impl = DOMImplementationRegistry::getDOMImplementation(X("Core"));
  646.         TASSERT(impl->hasFeature(X("XmL"), X("2.0")) == true);
  648.         TASSERT(impl->hasFeature(X("xML"), 0) == true);
  649.         TASSERT(impl->hasFeature(X("xML"), XMLUni::fgZeroLenString) == true);
  651.         TASSERT(impl->hasFeature(X("XMl"), X("1.0"))  == true);
  653.         TASSERT(impl->hasFeature(X("xMl"), X("3.0"))  == false);
  655.         TASSERT(impl->hasFeature(X("TrAveRsal"), 0)  == true);
  656.         TASSERT(impl->hasFeature(X("TrAveRsal"), XMLUni::fgZeroLenString)  == true);
  657.     }
  661.     {
  662.         DOMImplementation*  impl = DOMImplementationRegistry::getDOMImplementation(X("Core"));
  664.         TASSERT(impl->hasFeature(X("XmL"), 0)   == true);
  665.         TASSERT(impl->hasFeature(X("XmL"), X("1.0"))    == true);
  666.         TASSERT(impl->hasFeature(X("XmL"), X("2.0"))   == true);
  667.         TASSERT(impl->hasFeature(X("XmL"), X("3.0"))   == false);
  669.         TASSERT(impl->hasFeature(X("Core"), 0)   == true);
  671.         TASSERT(impl->hasFeature(X("coRe"), X("1.0"))    == true);
  673.         TASSERT(impl->hasFeature(X("core"), X("2.0"))   == true);
  675.         TASSERT(impl->hasFeature(X("cORe"), X("3.0"))   == true);
  676.         TASSERT(impl->hasFeature(X("cORe"), X("4.0"))   == false);
  678.         TASSERT(impl->hasFeature(X("Traversal"), XMLUni::fgZeroLenString)   == true);
  680.         TASSERT(impl->hasFeature(X("traversal"), X("1.0"))    == false);
  682.         TASSERT(impl->hasFeature(X("TraVersal"), X("2.0"))   == true);
  684.         TASSERT(impl->hasFeature(X("Range"), 0)   == true);
  686.         TASSERT(impl->hasFeature(X("raNge"), X("1.0"))    == false);
  688.         TASSERT(impl->hasFeature(X("RaNge"), X("2.0"))   == true);
  691.         TASSERT(impl->hasFeature(X("HTML"), 0)   == false);
  693.         TASSERT(impl->hasFeature(X("Views"), XMLUni::fgZeroLenString)   == false);
  695.         TASSERT(impl->hasFeature(X("StyleSheets"), 0)   == false);
  697.         TASSERT(impl->hasFeature(X("CSS"), XMLUni::fgZeroLenString)   == false);
  699.         TASSERT(impl->hasFeature(X("CSS2"), 0)   == false);
  701.         TASSERT(impl->hasFeature(X("Events"), 0)   == false);
  703.         TASSERT(impl->hasFeature(X("UIEvents"), 0)   == false);
  705.         TASSERT(impl->hasFeature(X("MouseEvents"), 0)   == false);
  707.         TASSERT(impl->hasFeature(X("MutationEvents"), 0)   == false);
  709.         TASSERT(impl->hasFeature(X("HTMLEvents"), 0)   == false);
  710.     }
  714.     //
  715.     // isSupported test (similar to hasFeature)
  716.     //
  718.     {
  719.         DOMDocument* doc;
  720.         doc = DOMImplementationRegistry::getDOMImplementation(X("Core"))->createDocument();
  723.         TASSERT(doc->isSupported(X("XmL"), 0)   == true);
  724.         TASSERT(doc->isSupported(X("XmL"), X("1.0"))    == true);
  725.         TASSERT(doc->isSupported(X("XmL"), X("2.0"))   == true);
  726.         TASSERT(doc->isSupported(X("XmL"), X("3.0"))   == false);
  728.         TASSERT(doc->isSupported(X("Core"), 0)   == true);
  729.         TASSERT(doc->isSupported(X("Core"), XMLUni::fgZeroLenString)   == true);
  731.         TASSERT(doc->isSupported(X("coRe"), X("1.0"))    == true);
  733.         TASSERT(doc->isSupported(X("core"), X("2.0"))   == true);
  735.         TASSERT(doc->isSupported(X("cORe"), X("3.0"))   == true);
  736.         TASSERT(doc->isSupported(X("cORe"), X("4.0"))   == false);
  738.         TASSERT(doc->isSupported(X("Traversal"), 0)   == true);
  740.         TASSERT(doc->isSupported(X("traversal"), X("1.0"))    == false);
  742.         TASSERT(doc->isSupported(X("TraVersal"), X("2.0"))   == true);
  744.         TASSERT(doc->isSupported(X("Range"), XMLUni::fgZeroLenString)   == true);
  746.         TASSERT(doc->isSupported(X("raNge"), X("1.0"))    == false);
  748.         TASSERT(doc->isSupported(X("RaNge"), X("2.0"))   == true);
  750.         TASSERT(doc->isSupported(X("HTML"), 0)   == false);
  752.         TASSERT(doc->isSupported(X("Views"), 0)   == false);
  754.         TASSERT(doc->isSupported(X("StyleSheets"), 0)   == false);
  756.         TASSERT(doc->isSupported(X("CSS"), 0)   == false);
  758.         TASSERT(doc->isSupported(X("CSS2"), XMLUni::fgZeroLenString)   == false);
  759.         TASSERT(doc->isSupported(X("Events"), 0)   == false);
  761.         TASSERT(doc->isSupported(X("UIEvents"), 0)   == false);
  763.         TASSERT(doc->isSupported(X("MouseEvents"), 0)   == false);
  765.         TASSERT(doc->isSupported(X("MutationEvents"), XMLUni::fgZeroLenString)   == false);
  767.         TASSERT(doc->isSupported(X("HTMLEvents"), 0)   == false);
  768.         doc->release();
  769.     }
  772.     //
  773.     // CreateDocumentType
  774.     //
  776.     {
  777.         DOMImplementation*  impl = DOMImplementationRegistry::getDOMImplementation(X("Core"));
  780.         DOMDocumentType* dt = impl->createDocumentType(X("foo:docName"), X("pubId"), X("http://sysId"));
  782.         TASSERT(dt != 0);
  783.         TASSERT(dt->getNodeType() == DOMNode::DOCUMENT_TYPE_NODE);
  784.         TASSERT(!XMLString::compareString(dt->getNodeName(), X("foo:docName")));
  785.         TASSERT(dt->getNamespaceURI() == 0);
  786.         TASSERT(dt->getPrefix() == 0);
  787.         TASSERT(dt->getLocalName() == 0);
  788.         TASSERT(!XMLString::compareString(dt->getPublicId(), X("pubId")));
  789.         TASSERT(!XMLString::compareString(dt->getSystemId(), X("http://sysId")));
  790.         TASSERT(dt->getInternalSubset() == 0);
  791.         TASSERT(dt->getOwnerDocument() == 0);
  793.         DOMNamedNodeMap* nnm = dt->getEntities();
  794.         TASSERT(nnm->getLength() == 0);
  795.         nnm = dt->getNotations();
  796.         TASSERT(nnm->getLength() == 0);
  798.         // release the documentType (dt) which is an orphaned node (does not have the owner)
  799.         dt->release();
  801.         //
  802.         // Qualified name without prefix should also work.
  803.         //
  804.         dt = impl->createDocumentType(X("docName"), X("pubId"), X("http://sysId"));
  806.         TASSERT(dt != 0);
  807.         TASSERT(dt->getNodeType() == DOMNode::DOCUMENT_TYPE_NODE);
  808.         TASSERT(!XMLString::compareString(dt->getNodeName(), X("docName")));
  809.         TASSERT(dt->getNamespaceURI() == 0);
  810.         TASSERT(dt->getPrefix() == 0);
  811.         TASSERT(dt->getLocalName() == 0);
  812.         TASSERT(!XMLString::compareString(dt->getPublicId(), X("pubId")));
  813.         TASSERT(!XMLString::compareString(dt->getSystemId(), X("http://sysId")));
  814.         TASSERT(dt->getInternalSubset() == 0);
  815.         TASSERT(dt->getOwnerDocument() == 0);
  817.         // Creating a DocumentType with invalid or malformed qName should fail.
  818.         EXCEPTION_TEST(impl->createDocumentType(X("<docName"), X("pubId"), X("http://sysId")), DOMException::INVALID_CHARACTER_ERR);
  820.         EXCEPTION_TEST(impl->createDocumentType(X(":docName"), X("pubId"), X("http://sysId")), DOMException::NAMESPACE_ERR);
  822.         EXCEPTION_TEST(impl->createDocumentType(X("docName:"), X("pubId"), X("http://sysId")), DOMException::NAMESPACE_ERR);
  824.         EXCEPTION_TEST(impl->createDocumentType(X("doc::Name"), X("pubId"), X("http://sysId")), DOMException::NAMESPACE_ERR);
  826.         EXCEPTION_TEST(impl->createDocumentType(X("doc:N:ame"), X("pubId"), X("http://sysId")), DOMException::NAMESPACE_ERR);
  828.         // release the documentType (dt) which is an orphaned node (does not have the owner)
  829.         dt->release();
  831.     }
  835.     //
  836.     //  DOMImplementation::CreateDocument
  837.     {
  839.         DOMImplementation*   impl = DOMImplementationRegistry::getDOMImplementation(X("Core"));
  840.         DOMDocumentType*       dt = 0;
  842.         DOMDocument*           doc = impl->createDocument(XMLUni::fgZeroLenString, X("a"), dt);
  844.         doc->getNodeName();
  845.         doc->release();
  846.     }
  848.     //
  850.     {
  852.         DOMImplementation* impl = DOMImplementationRegistry::getDOMImplementation(X("Core"));
  856.         DOMDocumentType* dt = impl->createDocumentType(X("foo:docName"), X("pubId"), X("http://sysId"));
  858.         DOMDocument* doc = impl->createDocument(X("http://document.namespace"), X("foo:docName"), dt);
  860.         TASSERT(dt->getOwnerDocument() == doc);
  861.         TASSERT(doc->getOwnerDocument() == 0);
  863.         TASSERT(doc->getNodeType() == DOMNode::DOCUMENT_NODE);
  864.         TASSERT(doc->getDoctype() == dt);
  866.         TASSERT(!XMLString::compareString(doc->getNodeName(), X("#document")));
  868.         TASSERT(doc->getNodeValue() == 0);
  869.         TASSERT(doc->getNamespaceURI() == 0);
  870.         TASSERT(doc->getPrefix() == 0);
  871.         TASSERT(doc->getLocalName() == 0);
  873.         DOMElement* el = doc->getDocumentElement();
  875.         TASSERT(!XMLString::compareString(el->getLocalName(), X("docName")));
  877.         TASSERT(!XMLString::compareString(el->getNamespaceURI(), X("http://document.namespace")));
  878.         TASSERT(!XMLString::compareString(el->getNodeName(), X("foo:docName")));
  879.         TASSERT(el->getOwnerDocument() == doc);
  880.         TASSERT(el->getParentNode() == doc);
  882.         TASSERT(!XMLString::compareString(el->getPrefix(), X("foo")));
  884.         TASSERT(!XMLString::compareString(el->getTagName(), X("foo:docName")));
  885.         TASSERT(el->hasChildNodes() == false);
  888.         //
  889.         // Creating a second document with the same docType object should fail.
  890.         //
  891.         try
  892.         {
  893.             DOMDocument* doc2 = impl->createDocument(X("pubId"), X("foo:docName"), dt);
  894.             TASSERT(false);  // should not reach here.
  895.         }
  896.         catch ( DOMException &e)
  897.         {
  898.             TASSERT(e.code == DOMException::WRONG_DOCUMENT_ERR);
  899.         }
  900.         catch (...)
  901.         {
  902.             TASSERT(false);  // Wrong exception thrown.
  903.         }
  905.         // release the document, the documentType (dt) still has the owner, and thus no need to release
  906.         doc->release();
  908.         // Creating a document with null NamespaceURI and DocumentType
  909.         doc = impl->createDocument(X("pubId"), X("foo:docName"), 0);
  910.         doc->release();
  912.         // Namespace tests of createDocument are covered by createElementNS below
  913.     }
  919.     //
  920.     //  CreateElementNS methods
  921.     //
  923.     {
  925.         // Set up an initial (root element only) document.
  926.         //
  927.         DOMImplementation* impl = DOMImplementationRegistry::getDOMImplementation(X("Core"));
  930.         DOMDocumentType* dt = impl->createDocumentType(X("foo:docName"), X("pubId"), X("http://sysId"));
  933.         DOMDocument* doc = impl->createDocument(X("http://document.namespace"), X("foo:docName"), dt);
  934.         DOMElement* rootEl = doc->getDocumentElement();
  936.         //
  937.         // CreateElementNS
  938.         //
  939.         DOMElement* ela = doc->createElementNS(X("http://nsa"), X("a:ela"));  // prefix and URI
  941.         TASSERT(!XMLString::compareString(ela->getNodeName(), X("a:ela")));
  942.         TASSERT(!XMLString::compareString(ela->getNamespaceURI(), X("http://nsa")));
  943.         TASSERT(!XMLString::compareString(ela->getPrefix(), X("a")));
  944.         TASSERT(!XMLString::compareString(ela->getLocalName(), X("ela")));
  945.         TASSERT(!XMLString::compareString(ela->getTagName(), X("a:ela")));
  947.         DOMElement* elb = doc->createElementNS(X("http://nsb"), X("elb"));    //  URI, no prefix.
  949.         TASSERT(!XMLString::compareString(elb->getNodeName(), X("elb")));
  950.         TASSERT(!XMLString::compareString(elb->getNamespaceURI(), X("http://nsb")));
  951.         TASSERT(!XMLString::compareString(elb->getPrefix(), XMLUni::fgZeroLenString));
  952.         TASSERT(!XMLString::compareString(elb->getLocalName(), X("elb")));
  953.         TASSERT(!XMLString::compareString(elb->getTagName(), X("elb")));
  955.         DOMElement* elc = doc->createElementNS(XMLUni::fgZeroLenString, X("elc"));              // No URI, no prefix.
  957.         TASSERT(!XMLString::compareString(elc->getNodeName(), X("elc")));
  958.         TASSERT(!XMLString::compareString(elc->getNamespaceURI(), XMLUni::fgZeroLenString));
  959.         TASSERT(!XMLString::compareString(elc->getPrefix(), XMLUni::fgZeroLenString));
  960.         TASSERT(!XMLString::compareString(elc->getLocalName(), X("elc")));
  961.         TASSERT(!XMLString::compareString(elc->getTagName(), X("elc")));
  963.         rootEl->appendChild(ela);
  964.         rootEl->appendChild(elb);
  965.         rootEl->appendChild(elc);
  967.         // Badly formed qualified name
  968.         EXCEPTION_TEST(doc->createElementNS(X("http://nsa"), X("<a")), DOMException::INVALID_CHARACTER_ERR);
  970.         EXCEPTION_TEST(doc->createElementNS(X("http://nsa"), X(":a")), DOMException::NAMESPACE_ERR);
  972.         EXCEPTION_TEST(doc->createElementNS(X("http://nsa"), X("a:")), DOMException::NAMESPACE_ERR);
  974.         EXCEPTION_TEST(doc->createElementNS(X("http://nsa"), X("a::a")), DOMException::NAMESPACE_ERR);
  976.         EXCEPTION_TEST(doc->createElementNS(X("http://nsa"), X("a:a:a")), DOMException::NAMESPACE_ERR);
  978.         // xml:a must have namespaceURI == "http://www.w3.org/XML/1998/namespace"
  979.         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")));
  980.         EXCEPTION_TEST(doc->createElementNS(X("http://nsa"), X("xml:a")), DOMException::NAMESPACE_ERR);
  981.         EXCEPTION_TEST(doc->createElementNS(XMLUni::fgZeroLenString, X("xml:a")), DOMException::NAMESPACE_ERR);
  982.         EXCEPTION_TEST(doc->createElementNS(0,  X("xml:a")), DOMException::NAMESPACE_ERR);
  984.         //unlike Attribute, xmlns (no different from foo) can have any namespaceURI for Element
  985.         TASSERT(!XMLString::compareString(doc->createElementNS(X("http://nsa"), X("xmlns"))->getNamespaceURI(), X("http://nsa")));
  987.         TASSERT(!XMLString::compareString(doc->createElementNS(X("http://www.w3.org/XML/1998/namespace"), X("xmlns"))->getNamespaceURI(), X("http://www.w3.org/XML/1998/namespace")));
  988.         TASSERT(!XMLString::compareString(doc->createElementNS(XMLUni::fgZeroLenString, X("xmlns"))->getNamespaceURI(), XMLUni::fgZeroLenString));
  989.         TASSERT(!XMLString::compareString(doc->createElementNS(0,  X("xmlns"))->getNamespaceURI(), XMLUni::fgZeroLenString));
  991.         //unlike Attribute, xmlns:a (no different from foo:a) can have any namespaceURI for Element
  992.         //except "" and null
  993.         TASSERT(!XMLString::compareString(doc->createElementNS(X("http://nsa"), X("xmlns:a"))->getNamespaceURI(), X("http://nsa")));
  994.         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")));
  995.         EXCEPTION_TEST(doc->createElementNS(XMLUni::fgZeroLenString, X("xmlns:a")), DOMException::NAMESPACE_ERR);
  996.         EXCEPTION_TEST(doc->createElementNS(0, X("xmlns:a")), DOMException::NAMESPACE_ERR);
  998.         //In fact, any prefix != null should have a namespaceURI != 0 or != ""
  999.         TASSERT(!XMLString::compareString(doc->createElementNS(X("http://nsa"), X("foo:a"))->getNamespaceURI(), X("http://nsa")));
  1000.         EXCEPTION_TEST(doc->createElementNS(XMLUni::fgZeroLenString, X("foo:a")), DOMException::NAMESPACE_ERR);
  1001.         EXCEPTION_TEST(doc->createElementNS(0,  X("foo:a")), DOMException::NAMESPACE_ERR);
  1003.         //Change prefix
  1004.         DOMElement* elem = doc->createElementNS(X("http://nsa"), X("foo:a"));
  1005.         elem->setPrefix(X("bar"));
  1006.         TASSERT(!XMLString::compareString(elem->getNodeName(), X("bar:a")));
  1007.         TASSERT(!XMLString::compareString(elem->getNamespaceURI(), X("http://nsa")));
  1008.         TASSERT(!XMLString::compareString(elem->getPrefix(), X("bar")));
  1009.         TASSERT(!XMLString::compareString(elem->getLocalName(), X("a")));
  1010.         TASSERT(!XMLString::compareString(elem->getTagName(), X("bar:a")));
  1011.         //The spec does not prevent us from setting prefix to a node without prefix
  1012.         elem = doc->createElementNS(X("http://nsa"), X("a"));
  1013.         TASSERT(!XMLString::compareString(elem->getPrefix(), XMLUni::fgZeroLenString));
  1014.         elem->setPrefix(X("bar"));
  1015.         TASSERT(!XMLString::compareString(elem->getNodeName(), X("bar:a")));
  1016.         TASSERT(!XMLString::compareString(elem->getNamespaceURI(), X("http://nsa")));
  1017.         TASSERT(!XMLString::compareString(elem->getPrefix(), X("bar")));
  1018.         TASSERT(!XMLString::compareString(elem->getLocalName(), X("a")));
  1019.         TASSERT(!XMLString::compareString(elem->getTagName(), X("bar:a")));
  1021.         //Special case for xml:a where namespaceURI must be xmlURI
  1022.         elem = doc->createElementNS(X("http://www.w3.org/XML/1998/namespace"), X("foo:a"));
  1023.         elem->setPrefix(X("xml"));
  1024.         elem = doc->createElementNS(X("http://nsa"), X("foo:a"));
  1025.         EXCEPTION_TEST(elem->setPrefix(X("xml")), DOMException::NAMESPACE_ERR);
  1026.         //However, there is no restriction on prefix xmlns
  1027.         elem->setPrefix(X("xmlns"));
  1028.         //Also an element can not have a prefix with namespaceURI == null or ""
  1029.         elem = doc->createElementNS(0, X("a"));
  1030.         EXCEPTION_TEST(elem->setPrefix(X("foo")), DOMException::NAMESPACE_ERR);
  1031.         elem = doc->createElementNS(XMLUni::fgZeroLenString, X("a"));
  1032.         EXCEPTION_TEST(elem->setPrefix(X("foo")), DOMException::NAMESPACE_ERR);
  1034.         //Only prefix of Element and Attribute can be changed
  1035.         EXCEPTION_TEST(doc->setPrefix(X("foo")), DOMException::NAMESPACE_ERR);
  1037.         //Prefix of readonly Element can not be changed.
  1038.         //However, there is no way to create such DOMElement* for testing yet.
  1040.         // release the document, the documentType (dt) still has the owner, and thus no need to release
  1041.         doc->release();
  1042.     }
  1047.     //
  1048.     //  CreateAttributeNS methods
  1049.     //
  1051.     {
  1053.         // Set up an initial (root element only) document.
  1054.         //
  1055.         DOMImplementation* impl = DOMImplementationRegistry::getDOMImplementation(X("Core"));
  1059.         DOMDocumentType* dt = impl->createDocumentType(X("foo:docName"), X("pubId"), X("http://sysId"));
  1061.         DOMDocument* doc = impl->createDocument(X("http://document.namespace"), X("foo:docName"), dt);
  1062.         DOMElement* rootEl = doc->getDocumentElement();
  1064.         //
  1065.         // CreateAttributeNS
  1066.         //
  1069.         DOMAttr* attra = doc->createAttributeNS(X("http://nsa"), X("a:attra"));       // prefix and URI
  1070.         TASSERT(!XMLString::compareString(attra->getNodeName(), X("a:attra")));
  1071.         TASSERT(!XMLString::compareString(attra->getNamespaceURI(), X("http://nsa")));
  1073.         TASSERT(!XMLString::compareString(attra->getPrefix(), X("a")));
  1075.         TASSERT(!XMLString::compareString(attra->getLocalName(), X("attra")));
  1076.         TASSERT(!XMLString::compareString(attra->getName(), X("a:attra")));
  1077.         TASSERT(attra->getOwnerElement() == 0);
  1079.         DOMAttr* attrb = doc->createAttributeNS(X("http://nsb"), X("attrb"));         //  URI, no prefix.
  1080.         TASSERT(!XMLString::compareString(attrb->getNodeName(), X("attrb")));
  1081.         TASSERT(!XMLString::compareString(attrb->getNamespaceURI(), X("http://nsb")));
  1082.         TASSERT(!XMLString::compareString(attrb->getPrefix(), XMLUni::fgZeroLenString));
  1083.         TASSERT(!XMLString::compareString(attrb->getLocalName(), X("attrb")));
  1084.         TASSERT(!XMLString::compareString(attrb->getName(), X("attrb")));
  1085.         TASSERT(attrb->getOwnerElement() == 0);
  1089.         DOMAttr* attrc = doc->createAttributeNS(XMLUni::fgZeroLenString, X("attrc"));
  1090.         TASSERT(!XMLString::compareString(attrc->getNodeName(), X("attrc")));
  1091.         TASSERT(!XMLString::compareString(attrc->getNamespaceURI(), XMLUni::fgZeroLenString));
  1092.         TASSERT(!XMLString::compareString(attrc->getPrefix(), XMLUni::fgZeroLenString));
  1093.         TASSERT(!XMLString::compareString(attrc->getLocalName(), X("attrc")));
  1094.         TASSERT(!XMLString::compareString(attrc->getName(), X("attrc")));
  1095.         TASSERT(attrc->getOwnerElement() == 0);
  1097.         // Badly formed qualified name
  1098.         EXCEPTION_TEST(doc->createAttributeNS(X("http://nsa"), X("<a")), DOMException::INVALID_CHARACTER_ERR);
  1100.         EXCEPTION_TEST(doc->createAttributeNS(X("http://nsa"), X(":a")), DOMException::NAMESPACE_ERR);
  1102.         EXCEPTION_TEST(doc->createAttributeNS(X("http://nsa"), X("a:")), DOMException::NAMESPACE_ERR);
  1104.         EXCEPTION_TEST(doc->createAttributeNS(X("http://nsa"), X("a::a")), DOMException::NAMESPACE_ERR);
  1106.         EXCEPTION_TEST(doc->createAttributeNS(X("http://nsa"), X("a:a:a")), DOMException::NAMESPACE_ERR);
  1108.         // xml:a must have namespaceURI == "http://www.w3.org/XML/1998/namespace"
  1109.         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")));
  1110.         EXCEPTION_TEST(doc->createAttributeNS(X("http://nsa"), X("xml:a")), DOMException::NAMESPACE_ERR);
  1111.         EXCEPTION_TEST(doc->createAttributeNS(XMLUni::fgZeroLenString, X("xml:a")), DOMException::NAMESPACE_ERR);
  1112.         EXCEPTION_TEST(doc->createAttributeNS(0,  X("xml:a")), DOMException::NAMESPACE_ERR);
  1114.         //unlike Element, xmlns must have namespaceURI == "http://www.w3.org/2000/xmlns/"
  1115.         TASSERT(!XMLString::compareString(doc->createAttributeNS(X("http://www.w3.org/2000/xmlns/"), X("xmlns"))->getNamespaceURI(), X("http://www.w3.org/2000/xmlns/")));
  1116.         EXCEPTION_TEST(doc->createAttributeNS(X("http://nsa"), X("xmlns")), DOMException::NAMESPACE_ERR);
  1117.         EXCEPTION_TEST(doc->createAttributeNS(X("http://www.w3.org/XML/1998/namespace"), X("xmlns")), DOMException::NAMESPACE_ERR);
  1118.         EXCEPTION_TEST(doc->createAttributeNS(XMLUni::fgZeroLenString, X("xmlns")), DOMException::NAMESPACE_ERR);
  1119.         EXCEPTION_TEST(doc->createAttributeNS(0,  X("xmlns")), DOMException::NAMESPACE_ERR);
  1121.         //unlike Element, xmlns:a must have namespaceURI == "http://www.w3.org/2000/xmlns/"
  1122.         TASSERT(!XMLString::compareString(doc->createAttributeNS(X("http://www.w3.org/2000/xmlns/"), X("xmlns:a"))->getNamespaceURI(), X("http://www.w3.org/2000/xmlns/")));
  1123.         EXCEPTION_TEST(doc->createAttributeNS(X("http://nsa"), X("xmlns:a")), DOMException::NAMESPACE_ERR);
  1124.         EXCEPTION_TEST(doc->createAttributeNS(X("http://www.w3.org/XML/1998/namespace"), X("xmlns:a")), DOMException::NAMESPACE_ERR);
  1125.         EXCEPTION_TEST(doc->createAttributeNS(XMLUni::fgZeroLenString, X("xmlns:a")), DOMException::NAMESPACE_ERR);
  1126.         EXCEPTION_TEST(doc->createAttributeNS(0,  X("xmlns:a")), DOMException::NAMESPACE_ERR);
  1128.         //In fact, any prefix != null should have a namespaceURI != 0 or != ""
  1129.         TASSERT(!XMLString::compareString(doc->createAttributeNS(X("http://nsa"), X("foo:a"))->getNamespaceURI(), X("http://nsa")));
  1130.         EXCEPTION_TEST(doc->createAttributeNS(XMLUni::fgZeroLenString, X("foo:a")), DOMException::NAMESPACE_ERR);
  1131.         EXCEPTION_TEST(doc->createAttributeNS(0,  X("foo:a")), DOMException::NAMESPACE_ERR);
  1133.         //Change prefix
  1134.         DOMAttr* attr = doc->createAttributeNS(X("http://nsa"), X("foo:a"));
  1135.         attr->setPrefix(X("bar"));
  1137.         TASSERT(!XMLString::compareString(attr->getNodeName(), X("bar:a")));
  1138.         TASSERT(!XMLString::compareString(attr->getNamespaceURI(), X("http://nsa")));
  1139.         TASSERT(!XMLString::compareString(attr->getPrefix(), X("bar")));
  1140.         TASSERT(!XMLString::compareString(attr->getName(), X("bar:a")));
  1141.         //The spec does not prevent us from setting prefix to a node without prefix
  1142.         TASSERT(!XMLString::compareString(attr->getLocalName(), X("a")));
  1143.         attr = doc->createAttributeNS(X("http://nsa"), X("a"));
  1144.         TASSERT(!XMLString::compareString(attr->getPrefix(), XMLUni::fgZeroLenString));
  1145.         attr->setPrefix(X("bar"));
  1146.         TASSERT(!XMLString::compareString(attr->getNodeName(), X("bar:a")));
  1147.         TASSERT(!XMLString::compareString(attr->getNamespaceURI(), X("http://nsa")));
  1148.         TASSERT(!XMLString::compareString(attr->getPrefix(), X("bar")));
  1149.         TASSERT(!XMLString::compareString(attr->getLocalName(), X("a")));
  1150.         TASSERT(!XMLString::compareString(attr->getName(), X("bar:a")));
  1153.         //Special case for xml:a where namespaceURI must be xmlURI
  1154.         attr = doc->createAttributeNS(X("http://www.w3.org/XML/1998/namespace"), X("foo:a"));
  1155.         attr->setPrefix(X("xml"));
  1156.         attr = doc->createAttributeNS(X("http://nsa"), X("foo:a"));
  1157.         EXCEPTION_TEST(attr->setPrefix(X("xml")), DOMException::NAMESPACE_ERR);
  1158.         //Special case for xmlns:a where namespaceURI must be xmlURI
  1159.         attr = doc->createAttributeNS(X("http://www.w3.org/2000/xmlns/"), X("foo:a"));
  1161.         attr->setPrefix(X("xmlns"));
  1162.         attr = doc->createAttributeNS(X("http://nsa"), X("foo:a"));
  1163.         EXCEPTION_TEST(attr->setPrefix(X("xmlns")), DOMException::NAMESPACE_ERR);
  1164.         //Special case for xmlns where no prefix can be set
  1165.         attr = doc->createAttributeNS(X("http://www.w3.org/2000/xmlns/"), X("xmlns"));
  1167.         EXCEPTION_TEST(attr->setPrefix(X("foo")), DOMException::NAMESPACE_ERR);
  1168.         EXCEPTION_TEST(attr->setPrefix(X("xmlns")), DOMException::NAMESPACE_ERR);
  1169.         //Also an attribute can not have a prefix with namespaceURI == null or ""
  1170.         attr = doc->createAttributeNS(XMLUni::fgZeroLenString, X("a"));
  1171.         EXCEPTION_TEST(attr->setPrefix(X("foo")), DOMException::NAMESPACE_ERR);
  1172.         attr = doc->createAttributeNS(0, X("a"));
  1173.         EXCEPTION_TEST(attr->setPrefix(X("foo")), DOMException::NAMESPACE_ERR);
  1175.         //Only prefix of Element and Attribute can be changed
  1176.         EXCEPTION_TEST(doc->setPrefix(X("foo")), DOMException::NAMESPACE_ERR);
  1178.         //Prefix of readonly Attribute can not be changed.
  1179.         //However, there is no way to create such DOMAttribute for testing yet.
  1181.         // release the document, the documentType (dt) still has the owner, and thus no need to release
  1182.         doc->release();
  1183.     }
  1187.     //
  1188.     //  getElementsByTagName*
  1189.     //
  1191.     {
  1193.         // Set up an initial (root element only) document.
  1194.         //
  1195.         DOMImplementation* impl = DOMImplementationRegistry::getDOMImplementation(X("Core"));
  1196.         DOMDocumentType* dt = impl->createDocumentType(X("foo:docName"), X("pubId"), X("http://sysId"));
  1198.         DOMDocument* doc = impl->createDocument(X("http://document.namespace"), X("foo:docName"), dt);
  1200.         DOMElement* rootEl = doc->getDocumentElement();
  1202.         //
  1203.         // Populate the document
  1204.         //
  1206.         DOMElement* ela = doc->createElementNS(X("http://nsa"), X("a:ela"));
  1207.         rootEl->appendChild(ela);
  1209.         DOMElement* elb = doc->createElementNS(X("http://nsb"), X("elb"));
  1210.         rootEl->appendChild(elb);
  1212.         DOMElement* elc = doc->createElementNS(XMLUni::fgZeroLenString, X("elc"));
  1213.         rootEl->appendChild(elc);
  1215.         DOMElement* eld = doc->createElementNS(X("http://nsa"), X("d:ela"));
  1216.         rootEl->appendChild(eld);
  1218.         DOMElement* ele = doc->createElementNS(X("http://nse"), X("elb"));
  1219.         rootEl->appendChild(ele);
  1222.         //
  1223.         // Access with DOM Level 1 getElementsByTagName
  1224.         //
  1226.         DOMNodeList* nl;
  1228.         nl = doc->getElementsByTagName(X("a:ela"));
  1229.         TASSERT(nl->getLength() == 1);
  1230.         TASSERT(nl->item(0) == ela);
  1232.         nl = doc->getElementsByTagName(X("elb"));
  1233.         TASSERT(nl->getLength() == 2);
  1234.         TASSERT(nl->item(0) == elb);
  1235.         TASSERT(nl->item(1) == ele);
  1237.         nl = doc->getElementsByTagName(X("d:ela"));
  1238.         TASSERT(nl->getLength() == 1);
  1239.         TASSERT(nl->item(0) == eld);
  1241.         //
  1242.         //  Access with DOM Level 2 getElementsByTagNameNS
  1243.         //
  1245.         nl = doc->getElementsByTagNameNS(XMLUni::fgZeroLenString, X("elc"));
  1246.         TASSERT(nl->getLength() == 1);
  1247.         TASSERT(nl->item(0) == elc);
  1249.         nl = doc->getElementsByTagNameNS(0, X("elc"));
  1250.         TASSERT(nl->getLength() == 1);
  1251.         TASSERT(nl->item(0) == elc);
  1253.         nl = doc->getElementsByTagNameNS(X("http://nsa"), X("ela"));
  1254.         TASSERT(nl->getLength() == 2);
  1255.         TASSERT(nl->item(0) == ela);
  1256.         TASSERT(nl->item(1) == eld);
  1258.         nl = doc->getElementsByTagNameNS(XMLUni::fgZeroLenString, X("elb"));
  1259.         TASSERT(nl->getLength() == 0);
  1261.         nl = doc->getElementsByTagNameNS(X("http://nsb"), X("elb"));
  1262.         TASSERT(nl->getLength() == 1);
  1263.         TASSERT(nl->item(0) == elb);
  1265.         nl = doc->getElementsByTagNameNS(X("*"), X("elb"));
  1266.         TASSERT(nl->getLength() == 2);
  1267.         TASSERT(nl->item(0) == elb);
  1268.         TASSERT(nl->item(1) == ele);
  1270.         nl = doc->getElementsByTagNameNS(X("http://nsa"), X("*"));
  1271.         TASSERT(nl->getLength() == 2);
  1272.         TASSERT(nl->item(0) == ela);
  1273.         TASSERT(nl->item(1) == eld);
  1275.         nl = doc->getElementsByTagNameNS(X("*"), X("*"));
  1276.         TASSERT(nl->getLength() == 6);     // Gets the document root element, plus 5 more
  1278.         TASSERT(nl->item(6) == 0);
  1279.         // TASSERT(nl->item(-1) == 0);
  1281.         nl = rootEl->getElementsByTagNameNS(X("*"), X("*"));
  1282.         TASSERT(nl->getLength() == 5);
  1285.         nl = doc->getElementsByTagNameNS(X("http://nsa"), X("d:ela"));
  1286.         TASSERT(nl->getLength() == 0);
  1289.         //
  1290.         // Node lists are Live
  1291.         //
  1293.         nl = doc->getElementsByTagNameNS(X("*"), X("*"));
  1294.         DOMNodeList* nla = ela->getElementsByTagNameNS(X("*"), X("*"));
  1296.         TASSERT(nl->getLength() == 6);
  1297.         TASSERT(nla->getLength() == 0);
  1299.         DOMNode* rem = rootEl->removeChild(elc);
  1300.         rem->release();
  1301.         TASSERT(nl->getLength() == 5);
  1302.         TASSERT(nla->getLength() == 0);
  1304.         ela->appendChild(elc);
  1305.         TASSERT(nl->getLength() == 6);
  1306.         TASSERT(nla->getLength() == 1);
  1308.         // release the document, the documentType (dt) still has the owner, and thus no need to release
  1309.         doc->release();
  1310.     }
  1314.    //
  1315.     // Attributes and NamedNodeMaps.
  1316.     //
  1318.     {
  1320.         // Set up an initial (root element only) document.
  1321.         //
  1322.         DOMImplementation* impl = DOMImplementationRegistry::getDOMImplementation(X("Core"));
  1324.         DOMDocumentType* dt = impl->createDocumentType(X("foo:docName"), X("pubId"), X("http://sysId"));
  1326.         DOMDocument* doc = impl->createDocument(X("http://document.namespace"), X("foo:docName"), dt);
  1327.         DOMElement* rootEl = doc->getDocumentElement();
  1329.         //
  1330.         // Create a set of attributes and hang them on the root element.
  1331.         //
  1333.         DOMAttr* attra = doc->createAttributeNS(X("http://nsa"), X("a:attra"));
  1334.         DOMNode* rem = rootEl->setAttributeNodeNS(attra);
  1335.         if (rem)
  1336.             rem->release();
  1338.         //
  1339.         // Check that the attribute nodes were created with the correct properties.
  1340.         //
  1341.         TASSERT(!XMLString::compareString(attra->getNodeName(), X("a:attra")));
  1342.         TASSERT(!XMLString::compareString(attra->getNamespaceURI(), X("http://nsa")));
  1344.         TASSERT(!XMLString::compareString(attra->getLocalName(), X("attra")));
  1345.         TASSERT(!XMLString::compareString(attra->getName(), X("a:attra")));
  1346.         TASSERT(attra->getNodeType() == DOMNode::ATTRIBUTE_NODE);
  1347.         TASSERT(!XMLString::compareString(attra->getNodeValue(), XMLUni::fgZeroLenString));
  1349.         TASSERT(!XMLString::compareString(attra->getPrefix(), X("a")));
  1350.         TASSERT(attra->getSpecified() == true);
  1351.         TASSERT(!XMLString::compareString(attra->getValue(), XMLUni::fgZeroLenString));
  1353.         //
  1354.         // Create a set of attributes and hang them on the root element.
  1355.         //
  1357.         DOMAttr* attrb = doc->createAttributeNS(X("http://nsb"), X("attrb"));
  1358.         rem = rootEl->setAttributeNodeNS(attrb);
  1359.         if (rem)
  1360.             rem->release();
  1362.         DOMAttr* attrc = doc->createAttributeNS(XMLUni::fgZeroLenString, X("attrc"));
  1363.         rem = rootEl->setAttributeNodeNS(attrc);
  1364.         if (rem)
  1365.             rem->release();
  1367.         // this one will replace the attra
  1368.         DOMAttr* attrd = doc->createAttributeNS(X("http://nsa"), X("d:attra"));
  1369.         rem = rootEl->setAttributeNodeNS(attrd);
  1370.         TASSERT(attra->getOwnerElement() == 0);
  1371.         if (rem)
  1372.             rem->release();
  1374.         DOMAttr* attre = doc->createAttributeNS(X("http://nse"), X("attrb"));
  1375.         rem = rootEl->setAttributeNodeNS(attre);
  1376.         if (rem)
  1377.             rem->release();
  1379.         // Test methods of NamedNodeMap
  1380.         DOMNamedNodeMap* nnm = rootEl->getAttributes();
  1381.         TASSERT(nnm->getLength() == 4);
  1384.         TASSERT(nnm->getNamedItemNS(X("http://nsa"), X("attra")) == attrd);
  1385.         TASSERT(nnm->getNamedItemNS(X("http://nsb"), X("attrb")) == attrb);
  1386.         TASSERT(nnm->getNamedItemNS(XMLUni::fgZeroLenString, X("attra")) == 0);
  1387.         TASSERT(nnm->getNamedItemNS(X("http://nsa"), X("attrb")) == 0);
  1389.         TASSERT(nnm->getNamedItemNS(X("http://nse"), X("attrb")) == attre);
  1391.         TASSERT(nnm->getNamedItemNS(XMLUni::fgZeroLenString, X("attrc")) == attrc);
  1393.         // Test hasAttributes, hasAttribute, hasAttributeNS
  1394.         TASSERT(doc->hasAttributes() ==  false);
  1395.         TASSERT(attrc->hasAttributes() == false);
  1396.         TASSERT(rootEl->hasAttributes() == true);
  1397.         TASSERT(rootEl->hasAttribute(X("attrc")) == true);
  1399.         TASSERT(rootEl->hasAttribute(X("wrong")) == false);
  1401.         TASSERT(rootEl->hasAttributeNS(X("http://nsa"), X("attra")) == true);
  1402.         TASSERT(rootEl->hasAttributeNS(X("http://nsa"), X("wrong")) == false);
  1404.         // release the document, the documentType (dt) still has the owner, and thus no need to release
  1405.         doc->release();
  1406.     }
  1409.     //
  1410.     //
  1411.     //
  1413. }
  1416. //---------------------------------------------------------------------------------------
  1417. //
  1418. //   DOMReleaseTests    Test if the release() function
  1419. //
  1420. //---------------------------------------------------------------------------------------
  1421. void DOMReleaseTests()
  1422. {
  1423.     XMLCh tempStr[4000];
  1424.     XMLCh tempStr2[4000];
  1425.     XMLCh tempStr3[4000];
  1426.     XMLString::transcode("status", tempStr, 3999);
  1427.     XMLString::transcode("true", tempStr2, 3999);
  1428.     XMLString::transcode("root", tempStr3, 3999);
  1430.     //create document
  1431.     DOMDocument*  cpXMLDocument;
  1432.     cpXMLDocument = DOMImplementation::getImplementation()->createDocument();
  1433.     //create root element
  1434.     DOMElement*   cpRoot = cpXMLDocument->createElement(tempStr3);
  1435.     //create status attribute
  1436.     cpRoot->setAttribute(tempStr,tempStr2);
  1437.     DOMAttr* pAttr = cpRoot->getAttributeNode(tempStr);
  1439.     //simulate setting the attribute value
  1440.     //   The setValue and setAttribute should call release internally so that
  1441.     //   the overall memory usage is not increased
  1442.     int i = 0;
  1443.     for(i=0;i<20000;i++)
  1444.     {
  1445.         pAttr->setValue(tempStr2);
  1446.     }
  1447.     for(i=0;i<20000;i++)
  1448.     {
  1449.         //same problem
  1450.         cpRoot->removeAttribute(tempStr);
  1451.         cpRoot->setAttribute(tempStr,tempStr2);
  1452.     }
  1454.     //simulate changing node value
  1455.     //   the overall memory usage is not increased
  1456.     char tempchar[4000];
  1457.     for(i=0;i<20000;i++)
  1458.     {
  1459.         sprintf(tempchar, "time is %in",XMLPlatformUtils::getCurrentMillis());
  1460.         int len = strlen(tempchar);
  1461.         for (int j = len; j < 4000-len; j++)
  1462.             tempchar[j] = 'a';
  1463.         pAttr->setNodeValue(X(tempchar));
  1464.     }
  1466.     DOMText*  text = cpXMLDocument->createTextNode(tempStr3);
  1467.     for(i=0;i<20000;i++)
  1468.     {
  1469.         sprintf(tempchar, "time is %in",XMLPlatformUtils::getCurrentMillis());
  1470.         int len = strlen(tempchar);
  1471.         for (int j = len; j < 4000-len; j++)
  1472.             tempchar[j] = 'a';
  1473.         text->setNodeValue(X(tempchar));
  1474.     }
  1476.     cpXMLDocument->release();
  1478. }
  1481. //---------------------------------------------------------------------------------------
  1482. //
  1483. //   main
  1484. //
  1485. //---------------------------------------------------------------------------------------
  1486. int  mymain()
  1487. {
  1488.     try {
  1489.         XMLPlatformUtils::Initialize();
  1490.     }
  1491.     catch (const XMLException& toCatch) {
  1492.         char *pMessage = XMLString::transcode(toCatch.getMessage());
  1493.         fprintf(stderr, "Error during XMLPlatformUtils::Initialize(). n"
  1494.             "  Message is: %sn", pMessage);
  1495.         XMLString::release(&pMessage);
  1496.         return -1;
  1497.     }
  1499.     DOMBasicTests();
  1500.     DOMNSTests();
  1501.     DOMReleaseTests();
  1503.     //
  1504.     //  Print Final allocation stats for full set of tests
  1505.     //
  1506.     XMLPlatformUtils::Terminate();
  1508.     return 0;
  1510. };
  1512. int  main() {
  1513.    for (int i = 0; i<3; i++)
  1514.         mymain();
  1516.     if (errorOccurred) {
  1517.         printf("Test Failedn");
  1518.         return 4;
  1519.     }
  1521.     printf("Test Run Successfullyn");
  1523.     return 0;
  1524. }