PageRenderTime 31ms CodeModel.GetById 22ms RepoModel.GetById 0ms app.codeStats 0ms

/ATF2/control-software/epics-3.14.8/extensions/src/ChannelArchiver/ThirdParty/xerces-c-src2_4_0/tests/DOM/TypeInfo/TypeInfo.cpp

http://atf2flightsim.googlecode.com/
C++ | 996 lines | 616 code | 268 blank | 112 comment | 10 complexity | ee71619bd13df0f6b6d485d7bbcf67c2 MD5 | raw file
Possible License(s): BSD-2-Clause, LGPL-2.0, IPL-1.0, BSD-3-Clause 
    

  1. /*
    2. 

  2.  * The Apache Software License, Version 1.1
    3. 

  3.  *
    4. 

  4.  * Copyright (c) 2003 The Apache Software Foundation->  All rights
    5. 

  5.  * reserved.
    6. 

  6.  *
    7. 

  7.  * Redistribution and use in source and binary forms, with or without
    8. 

  8.  * modification, are permitted provided that the following conditions
    9. 

  9.  * are met:
    10. 

  10.  *
    11. 

  11.  * 1. Redistributions of source code must retain the above copyright
    12. 

  12.  *    notice, this list of conditions and the following disclaimer.
    13. 

  13.  *
    14. 

  14.  * 2. Redistributions in binary form must reproduce the above copyright
    15. 

  15.  *    notice, this list of conditions and the following disclaimer in
    16. 

  16.  *    the documentation and/or other materials provided with the
    17. 

  17.  *    distribution->
    18. 

  18.  *
    19. 

  19.  * 3. The end-user documentation included with the redistribution,
    20. 

  20.  *    if any, must include the following acknowledgment:
    21. 

  21.  *       "This product includes software developed by the
    22. 

  22.  *        Apache Software Foundation (http://www.apache.org/)."
    23. 

  23.  *    Alternately, this acknowledgment may appear in the software itself,
    24. 

  24.  *    if and wherever such third-party acknowledgments normally appear.
    25. 

  25.  *
    26. 

  26.  * 4. The names "Xerces" and "Apache Software Foundation" must
    27. 

  27.  *    not be used to endorse or promote products derived from this
    28. 

  28.  *    software without prior written permission-> For written
    29. 

  29.  *    permission, please contact apache\@apache.org.
    30. 

  30.  *
    31. 

  31.  * 5. Products derived from this software may not be called "Apache",
    32. 

  32.  *    nor may "Apache" appear in their name, without prior written
    33. 

  33.  *    permission of the Apache Software Foundation->
    34. 

  34.  *
    35. 

  35.  * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESSED OR IMPLIED
    36. 

  36.  * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
    37. 

  37.  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
    38. 

  38.  * DISCLAIMED.  IN NO EVENT SHALL THE APACHE SOFTWARE FOUNDATION OR
    39. 

  39.  * ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
    40. 

  40.  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
    41. 

  41.  * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF
    42. 

  42.  * USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
    43. 

  43.  * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
    44. 

  44.  * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
    45. 

  45.  * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
    46. 

  46.  * SUCH DAMAGE.
    47. 

  47.  * ====================================================================
    48. 

  48.  *
    49. 

  49.  * This software consists of voluntary contributions made by many
    50. 

  50.  * individuals on behalf of the Apache Software Foundation, and was
    51. 

  51.  * originally based on software copyright (c) 2001, International
    52. 

  52.  * Business Machines, Inc., http://www.ibm.com .  For more information
    53. 

  53.  * on the Apache Software Foundation, please see
    54. 

  54.  * <http://www.apache.org/>.
    55. 

  55.  */
    56. 

  56. 

  57. #include "TypeInfo.hpp"
    58. 

  58. 

  59. #include <xercesc/util/PlatformUtils.hpp>
    60. 

  60. #include <xercesc/util/XMLException.hpp>
    61. 

  61. #include <xercesc/util/XMLString.hpp>
    62. 

  62. #include <xercesc/parsers/XercesDOMParser.hpp>
    63. 

  63. #include <xercesc/dom/DOMException.hpp>
    64. 

  64. #include <xercesc/dom/DOM.hpp>
    65. 

  65. #include <xercesc/validators/schema/SchemaSymbols.hpp>
    66. 

  66. 

  67. #if defined(XERCES_NEW_IOSTREAMS)
    68. 

  68. #include <iostream>
    69. 

  69. #else
    70. 

  70. #include <iostream.h>
    71. 

  71. #endif
    72. 

  72. 

  73. 

  74. #define DOMTYPEINFOTEST(info, type, uri, line) \
    75. 

  75.     tmp = XMLString::equals(info->getName(), type) && XMLString::equals(info->getNamespace(), uri);\
    76. 

  76.     if(!tmp) { \
    77. 

  77.       XERCES_STD_QUALIFIER cerr << "DOMTypeInfo test failed at line, " << line << "\nExpected values : typename '" << XMLString::transcode(type) << "', uri '" << XMLString::transcode(uri) << "'\nActual values   : typename '" << XMLString::transcode(info->getName()) << "', uri '" << XMLString::transcode(info->getNamespace()) << "'\n" << XERCES_STD_QUALIFIER endl; \
    78. 

  78.       passed = false; \
    79. 

  79.     }
    80. 

  80. 

  81. bool tmp;
    82. 

  82. 

  83. // ---------------------------------------------------------------------------
    84. 

  84. //  This is a simple class that lets us do easy (though not terribly efficient)
    85. 

  85. //  trancoding of char* data to XMLCh data.
    86. 

  86. // ---------------------------------------------------------------------------
    87. 

  87. class XStr
    88. 

  88. {
    89. 

  89. public :
    90. 

  90.     // -----------------------------------------------------------------------
    91. 

  91.     //  Constructors and Destructor
    92. 

  92.     // -----------------------------------------------------------------------
    93. 

  93.     XStr(const char* const toTranscode)
    94. 

  94.     {
    95. 

  95.         // Call the private transcoding method
    96. 

  96.         fUnicodeForm = XMLString::transcode(toTranscode);
    97. 

  97.     }
    98. 

  98. 

  99.     ~XStr()
    100. 

  100.     {
    101. 

  101.         XMLString::release(&fUnicodeForm);
    102. 

  102.     }
    103. 

  103. 

  104. 

  105.     // -----------------------------------------------------------------------
    106. 

  106.     //  Getter methods
    107. 

  107.     // -----------------------------------------------------------------------
    108. 

  108.     const XMLCh* unicodeForm() const
    109. 

  109.     {
    110. 

  110.         return fUnicodeForm;
    111. 

  111.     }
    112. 

  112. 

  113. private :
    114. 

  114.     // -----------------------------------------------------------------------
    115. 

  115.     //  Private data members
    116. 

  116.     //
    117. 

  117.     //  fUnicodeForm
    118. 

  118.     //      This is the Unicode XMLCh format of the string.
    119. 

  119.     // -----------------------------------------------------------------------
    120. 

  120.     XMLCh*   fUnicodeForm;
    121. 

  121. };
    122. 

  122. 

  123. #define X(str) XStr(str).unicodeForm()
    124. 

  124. 

  125. 

  126. //  This is a simple class that lets us do easy (though not terribly efficient)
    127. 

  127. //  trancoding of XMLCh data to local code page for display.
    128. 

  128. // ---------------------------------------------------------------------------
    129. 

  129. class StrX
    130. 

  130. {
    131. 

  131. public :
    132. 

  132.     // -----------------------------------------------------------------------
    133. 

  133.     //  Constructors and Destructor
    134. 

  134.     // -----------------------------------------------------------------------
    135. 

  135.     StrX(const XMLCh* const toTranscode)
    136. 

  136.     {
    137. 

  137.         // Call the private transcoding method
    138. 

  138.         fLocalForm = XMLString::transcode(toTranscode);
    139. 

  139.     }
    140. 

  140. 

  141.     ~StrX()
    142. 

  142.     {
    143. 

  143.         XMLString::release(&fLocalForm);
    144. 

  144.     }
    145. 

  145. 

  146. 

  147.     // -----------------------------------------------------------------------
    148. 

  148.     //  Getter methods
    149. 

  149.     // -----------------------------------------------------------------------
    150. 

  150.     const char* localForm() const
    151. 

  151.     {
    152. 

  152.         return fLocalForm;
    153. 

  153.     }
    154. 

  154. 

  155. private :
    156. 

  156.     // -----------------------------------------------------------------------
    157. 

  157.     //  Private data members
    158. 

  158.     //
    159. 

  159.     //  fLocalForm
    160. 

  160.     //      This is the local code page form of the string.
    161. 

  161.     // -----------------------------------------------------------------------
    162. 

  162.     char*   fLocalForm;
    163. 

  163. };
    164. 

  164. 

  165. #define StrX(str) StrX(str).localForm()
    166. 

  166. 

  167. TypeInfo::TypeInfo() {
    168. 

  168.     try
    169. 

  169.     {
    170. 

  170.         XMLPlatformUtils::Initialize();
    171. 

  171.     }
    172. 

  172. 

  173.     catch(const XMLException &toCatch)
    174. 

  174.     {
    175. 

  175.         XERCES_STD_QUALIFIER cerr << "Error during Xerces-c Initialization.\n"
    176. 

  176.              << "  Exception message:"
    177. 

  177.              << StrX(toCatch.getMessage()) << XERCES_STD_QUALIFIER endl;
    178. 

  178.     }
    179. 

  179.     parser = 0;
    180. 

  180. }
    181. 

  181. 

  182. TypeInfo::~TypeInfo() {
    183. 

  183.     XMLPlatformUtils::Terminate();
    184. 

  184. }
    185. 

  185. 

  186. bool TypeInfo::testInBuiltTypesOnAttributes(bool DTDPresent) {
    187. 

  187. 

  188.     bool passed = true;
    189. 

  189.     DOMElement *testEle = findElement(X("attrTest"));
    190. 

  190. 

  191.     DOMTYPEINFOTEST(testEle->getTypeInfo(), X("attrTestType"), X(""), __LINE__);
    192. 

  192. 

  193.     DOMAttr *testAttr;
    194. 

  194. 

  195.     testAttr = testEle->getAttributeNodeNS(0, X("anySimpleType"));
    196. 

  196.     DOMTYPEINFOTEST(testAttr->getTypeInfo(), SchemaSymbols::fgDT_ANYSIMPLETYPE, SchemaSymbols::fgURI_SCHEMAFORSCHEMA, __LINE__);
    197. 

  197. 

  198.     testAttr = testEle->getAttributeNodeNS(0, X("string"));
    199. 

  199.     DOMTYPEINFOTEST(testAttr->getTypeInfo(), SchemaSymbols::fgDT_STRING, SchemaSymbols::fgURI_SCHEMAFORSCHEMA, __LINE__);
    200. 

  200. 

  201.     testAttr = testEle->getAttributeNodeNS(0, X("boolean"));
    202. 

  202.     DOMTYPEINFOTEST(testAttr->getTypeInfo(), SchemaSymbols::fgDT_BOOLEAN, SchemaSymbols::fgURI_SCHEMAFORSCHEMA, __LINE__);
    203. 

  203. 

  204.     testAttr = testEle->getAttributeNodeNS(0, X("decimal"));
    205. 

  205.     DOMTYPEINFOTEST(testAttr->getTypeInfo(), SchemaSymbols::fgDT_DECIMAL, SchemaSymbols::fgURI_SCHEMAFORSCHEMA, __LINE__);
    206. 

  206. 

  207.     testAttr = testEle->getAttributeNodeNS(0, X("float"));
    208. 

  208.     DOMTYPEINFOTEST(testAttr->getTypeInfo(), SchemaSymbols::fgDT_FLOAT, SchemaSymbols::fgURI_SCHEMAFORSCHEMA, __LINE__);
    209. 

  209. 

  210.     testAttr = testEle->getAttributeNodeNS(0, X("double"));
    211. 

  211.     DOMTYPEINFOTEST(testAttr->getTypeInfo(), SchemaSymbols::fgDT_DOUBLE, SchemaSymbols::fgURI_SCHEMAFORSCHEMA, __LINE__);
    212. 

  212. 

  213.     testAttr = testEle->getAttributeNodeNS(0, X("duration"));
    214. 

  214.     DOMTYPEINFOTEST(testAttr->getTypeInfo(), SchemaSymbols::fgDT_DURATION, SchemaSymbols::fgURI_SCHEMAFORSCHEMA, __LINE__);
    215. 

  215. 

  216.     testAttr = testEle->getAttributeNodeNS(0, X("dateTime"));
    217. 

  217.     DOMTYPEINFOTEST(testAttr->getTypeInfo(), SchemaSymbols::fgDT_DATETIME, SchemaSymbols::fgURI_SCHEMAFORSCHEMA, __LINE__);
    218. 

  218. 

  219.     testAttr = testEle->getAttributeNodeNS(0, X("time"));
    220. 

  220.     DOMTYPEINFOTEST(testAttr->getTypeInfo(), SchemaSymbols::fgDT_TIME, SchemaSymbols::fgURI_SCHEMAFORSCHEMA, __LINE__);
    221. 

  221. 

  222.     testAttr = testEle->getAttributeNodeNS(0, X("date"));
    223. 

  223.     DOMTYPEINFOTEST(testAttr->getTypeInfo(), SchemaSymbols::fgDT_DATE, SchemaSymbols::fgURI_SCHEMAFORSCHEMA, __LINE__);
    224. 

  224. 

  225.     testAttr = testEle->getAttributeNodeNS(0, X("gYearMonth"));
    226. 

  226.     DOMTYPEINFOTEST(testAttr->getTypeInfo(), SchemaSymbols::fgDT_YEARMONTH, SchemaSymbols::fgURI_SCHEMAFORSCHEMA, __LINE__);
    227. 

  227. 

  228.     testAttr = testEle->getAttributeNodeNS(0, X("gYear"));
    229. 

  229.     DOMTYPEINFOTEST(testAttr->getTypeInfo(), SchemaSymbols::fgDT_YEAR, SchemaSymbols::fgURI_SCHEMAFORSCHEMA, __LINE__);
    230. 

  230. 

  231.     testAttr = testEle->getAttributeNodeNS(0, X("gMonthDay"));
    232. 

  232.     DOMTYPEINFOTEST(testAttr->getTypeInfo(), SchemaSymbols::fgDT_MONTHDAY, SchemaSymbols::fgURI_SCHEMAFORSCHEMA, __LINE__);
    233. 

  233. 

  234.     testAttr = testEle->getAttributeNodeNS(0, X("gDay"));
    235. 

  235.     DOMTYPEINFOTEST(testAttr->getTypeInfo(), SchemaSymbols::fgDT_DAY, SchemaSymbols::fgURI_SCHEMAFORSCHEMA, __LINE__);
    236. 

  236. 

  237.     testAttr = testEle->getAttributeNodeNS(0, X("gMonth"));
    238. 

  238.     DOMTYPEINFOTEST(testAttr->getTypeInfo(), SchemaSymbols::fgDT_MONTH, SchemaSymbols::fgURI_SCHEMAFORSCHEMA, __LINE__);
    239. 

  239. 

  240.     testAttr = testEle->getAttributeNodeNS(0, X("hexBinary"));
    241. 

  241.     DOMTYPEINFOTEST(testAttr->getTypeInfo(), SchemaSymbols::fgDT_HEXBINARY, SchemaSymbols::fgURI_SCHEMAFORSCHEMA, __LINE__);
    242. 

  242. 

  243.     testAttr = testEle->getAttributeNodeNS(0, X("base64Binary"));
    244. 

  244.     DOMTYPEINFOTEST(testAttr->getTypeInfo(), SchemaSymbols::fgDT_BASE64BINARY, SchemaSymbols::fgURI_SCHEMAFORSCHEMA, __LINE__);
    245. 

  245. 

  246.     testAttr = testEle->getAttributeNodeNS(0, X("anyURI"));
    247. 

  247.     DOMTYPEINFOTEST(testAttr->getTypeInfo(), SchemaSymbols::fgDT_ANYURI, SchemaSymbols::fgURI_SCHEMAFORSCHEMA, __LINE__);
    248. 

  248. 

  249.     testAttr = testEle->getAttributeNodeNS(0, X("QName"));
    250. 

  250.     DOMTYPEINFOTEST(testAttr->getTypeInfo(), SchemaSymbols::fgDT_QNAME, SchemaSymbols::fgURI_SCHEMAFORSCHEMA, __LINE__);
    251. 

  251. 

  252. 

  253.     testAttr = testEle->getAttributeNodeNS(0, X("normalizedString"));
    254. 

  254.     DOMTYPEINFOTEST(testAttr->getTypeInfo(), SchemaSymbols::fgDT_NORMALIZEDSTRING, SchemaSymbols::fgURI_SCHEMAFORSCHEMA, __LINE__);
    255. 

  255. 

  256.     testAttr = testEle->getAttributeNodeNS(0, X("token"));
    257. 

  257.     DOMTYPEINFOTEST(testAttr->getTypeInfo(), SchemaSymbols::fgDT_TOKEN, SchemaSymbols::fgURI_SCHEMAFORSCHEMA, __LINE__);
    258. 

  258. 

  259.     testAttr = testEle->getAttributeNodeNS(0, X("language"));
    260. 

  260.     DOMTYPEINFOTEST(testAttr->getTypeInfo(), SchemaSymbols::fgDT_LANGUAGE, SchemaSymbols::fgURI_SCHEMAFORSCHEMA, __LINE__);
    261. 

  261. 

  262.     testAttr = testEle->getAttributeNodeNS(0, X("NMTOKEN"));
    263. 

  263.     DOMTYPEINFOTEST(testAttr->getTypeInfo(), XMLUni::fgNmTokenString, SchemaSymbols::fgURI_SCHEMAFORSCHEMA, __LINE__);
    264. 

  264. 

  265.     testAttr = testEle->getAttributeNodeNS(0, X("NMTOKENS"));
    266. 

  266.     DOMTYPEINFOTEST(testAttr->getTypeInfo(), XMLUni::fgNmTokensString, SchemaSymbols::fgURI_SCHEMAFORSCHEMA, __LINE__);
    267. 

  267. 

  268.     testAttr = testEle->getAttributeNodeNS(0, X("Name"));
    269. 

  269.     DOMTYPEINFOTEST(testAttr->getTypeInfo(), SchemaSymbols::fgDT_NAME, SchemaSymbols::fgURI_SCHEMAFORSCHEMA, __LINE__);
    270. 

  270. 

  271.     testAttr = testEle->getAttributeNodeNS(0, X("NCName"));
    272. 

  272.     DOMTYPEINFOTEST(testAttr->getTypeInfo(), SchemaSymbols::fgDT_NCNAME, SchemaSymbols::fgURI_SCHEMAFORSCHEMA, __LINE__);
    273. 

  273. 

  274.     testAttr = testEle->getAttributeNodeNS(0, X("ID"));
    275. 

  275.     DOMTYPEINFOTEST(testAttr->getTypeInfo(), XMLUni::fgIDString, SchemaSymbols::fgURI_SCHEMAFORSCHEMA, __LINE__);
    276. 

  276. 

  277.     testAttr = testEle->getAttributeNodeNS(0, X("IDREF"));
    278. 

  278.     DOMTYPEINFOTEST(testAttr->getTypeInfo(), XMLUni::fgIDRefString, SchemaSymbols::fgURI_SCHEMAFORSCHEMA, __LINE__);
    279. 

  279. 

  280.     testAttr = testEle->getAttributeNodeNS(0, X("IDREFS"));
    281. 

  281.     DOMTYPEINFOTEST(testAttr->getTypeInfo(), XMLUni::fgIDRefsString, SchemaSymbols::fgURI_SCHEMAFORSCHEMA, __LINE__);
    282. 

  282. 

  283. 

  284.     if(DTDPresent) {
    285. 

  285.         testAttr = testEle->getAttributeNodeNS(0, X("ENTITY"));
    286. 

  286.         DOMTYPEINFOTEST(testAttr->getTypeInfo(), XMLUni::fgEntityString, SchemaSymbols::fgURI_SCHEMAFORSCHEMA, __LINE__);
    287. 

  287. 

  288.         testAttr = testEle->getAttributeNodeNS(0, X("ENTITIES"));
    289. 

  289.         DOMTYPEINFOTEST(testAttr->getTypeInfo(), XMLUni::fgEntitiesString, SchemaSymbols::fgURI_SCHEMAFORSCHEMA, __LINE__);
    290. 

  290.     }
    291. 

  291. 

  292.     testAttr = testEle->getAttributeNodeNS(0, X("integer"));
    293. 

  293.     DOMTYPEINFOTEST(testAttr->getTypeInfo(), SchemaSymbols::fgDT_INTEGER, SchemaSymbols::fgURI_SCHEMAFORSCHEMA, __LINE__);
    294. 

  294. 

  295.     testAttr = testEle->getAttributeNodeNS(0, X("nonPositiveInteger"));
    296. 

  296.     DOMTYPEINFOTEST(testAttr->getTypeInfo(), SchemaSymbols::fgDT_NONPOSITIVEINTEGER, SchemaSymbols::fgURI_SCHEMAFORSCHEMA, __LINE__);
    297. 

  297. 

  298.     testAttr = testEle->getAttributeNodeNS(0, X("negativeInteger"));
    299. 

  299.     DOMTYPEINFOTEST(testAttr->getTypeInfo(), SchemaSymbols::fgDT_NEGATIVEINTEGER, SchemaSymbols::fgURI_SCHEMAFORSCHEMA, __LINE__);
    300. 

  300. 

  301.     testAttr = testEle->getAttributeNodeNS(0, X("long"));
    302. 

  302.     DOMTYPEINFOTEST(testAttr->getTypeInfo(), SchemaSymbols::fgDT_LONG, SchemaSymbols::fgURI_SCHEMAFORSCHEMA, __LINE__);
    303. 

  303. 

  304.     testAttr = testEle->getAttributeNodeNS(0, X("int"));
    305. 

  305.     DOMTYPEINFOTEST(testAttr->getTypeInfo(), SchemaSymbols::fgDT_INT, SchemaSymbols::fgURI_SCHEMAFORSCHEMA, __LINE__);
    306. 

  306. 

  307.     testAttr = testEle->getAttributeNodeNS(0, X("short"));
    308. 

  308.     DOMTYPEINFOTEST(testAttr->getTypeInfo(), SchemaSymbols::fgDT_SHORT, SchemaSymbols::fgURI_SCHEMAFORSCHEMA, __LINE__);
    309. 

  309. 

  310.     testAttr = testEle->getAttributeNodeNS(0, X("byte"));
    311. 

  311.     DOMTYPEINFOTEST(testAttr->getTypeInfo(), SchemaSymbols::fgDT_BYTE, SchemaSymbols::fgURI_SCHEMAFORSCHEMA, __LINE__);
    312. 

  312. 

  313.     testAttr = testEle->getAttributeNodeNS(0, X("nonNegativeInteger"));
    314. 

  314.     DOMTYPEINFOTEST(testAttr->getTypeInfo(), SchemaSymbols::fgDT_NONNEGATIVEINTEGER, SchemaSymbols::fgURI_SCHEMAFORSCHEMA, __LINE__);
    315. 

  315. 

  316.     testAttr = testEle->getAttributeNodeNS(0, X("unsignedLong"));
    317. 

  317.     DOMTYPEINFOTEST(testAttr->getTypeInfo(), SchemaSymbols::fgDT_ULONG, SchemaSymbols::fgURI_SCHEMAFORSCHEMA, __LINE__);
    318. 

  318. 

  319.     testAttr = testEle->getAttributeNodeNS(0, X("unsignedInt"));
    320. 

  320.     DOMTYPEINFOTEST(testAttr->getTypeInfo(), SchemaSymbols::fgDT_UINT, SchemaSymbols::fgURI_SCHEMAFORSCHEMA, __LINE__);
    321. 

  321. 

  322.     testAttr = testEle->getAttributeNodeNS(0, X("unsignedShort"));
    323. 

  323.     DOMTYPEINFOTEST(testAttr->getTypeInfo(), SchemaSymbols::fgDT_USHORT, SchemaSymbols::fgURI_SCHEMAFORSCHEMA, __LINE__);
    324. 

  324. 

  325.     testAttr = testEle->getAttributeNodeNS(0, X("unsignedByte"));
    326. 

  326.     DOMTYPEINFOTEST(testAttr->getTypeInfo(), SchemaSymbols::fgDT_UBYTE, SchemaSymbols::fgURI_SCHEMAFORSCHEMA, __LINE__);
    327. 

  327. 

  328.     testAttr = testEle->getAttributeNodeNS(0, X("positiveInteger"));
    329. 

  329.     DOMTYPEINFOTEST(testAttr->getTypeInfo(), SchemaSymbols::fgDT_POSITIVEINTEGER, SchemaSymbols::fgURI_SCHEMAFORSCHEMA, __LINE__);
    330. 

  330. 

  331.     //couple of defaulted ones
    332. 

  332.     testAttr = testEle->getAttributeNodeNS(0, X("defaultString"));
    333. 

  333.     DOMTYPEINFOTEST(testAttr->getTypeInfo(), SchemaSymbols::fgDT_STRING, SchemaSymbols::fgURI_SCHEMAFORSCHEMA, __LINE__);
    334. 

  334. 

  335.     testAttr = testEle->getAttributeNodeNS(0, X("defaultInt"));
    336. 

  336.     DOMTYPEINFOTEST(testAttr->getTypeInfo(), SchemaSymbols::fgDT_INTEGER, SchemaSymbols::fgURI_SCHEMAFORSCHEMA, __LINE__);
    337. 

  337. 

  338.     //ns attr
    339. 

  339.     testAttr = testEle->getAttributeNodeNS(X("http://www.w3.org/2000/xmlns/"), X("prefix"));
    340. 

  340.     DOMTYPEINFOTEST(testAttr->getTypeInfo(), SchemaSymbols::fgDT_ANYURI, SchemaSymbols::fgURI_SCHEMAFORSCHEMA, __LINE__);
    341. 

  341. 

  342.     testAttr = testEle->getAttributeNodeNS(X("http://www.w3.org/2001/XMLSchema-instance"), X("noNamespaceSchemaLocation"));
    343. 

  343.     DOMTYPEINFOTEST(testAttr->getTypeInfo(), SchemaSymbols::fgDT_ANYURI, SchemaSymbols::fgURI_SCHEMAFORSCHEMA, __LINE__);
    344. 

  344. 

  345.     return passed;
    346. 

  346. }
    347. 

  347. 

  348. 

  349. bool TypeInfo::testInBuiltTypesOnElements() {
    350. 

  350. 

  351.     bool passed = true;
    352. 

  352.     DOMNode *docEle = doc->getDocumentElement();
    353. 

  353. 

  354.     //the eleTest element.
    355. 

  355.     DOMElement *testEle = findElement(X("eleTest"));
    356. 

  356. 

  357.     testEle = (DOMElement *)testEle->getFirstChild()->getNextSibling();
    358. 

  358.     DOMTYPEINFOTEST(testEle->getTypeInfo(), SchemaSymbols::fgDT_STRING, SchemaSymbols::fgURI_SCHEMAFORSCHEMA, __LINE__);
    359. 

  359.     testEle = (DOMElement *)testEle->getNextSibling()->getNextSibling();
    360. 

  360.     DOMTYPEINFOTEST(testEle->getTypeInfo(), SchemaSymbols::fgDT_BOOLEAN, SchemaSymbols::fgURI_SCHEMAFORSCHEMA, __LINE__);
    361. 

  361. 

  362.     testEle = (DOMElement *)testEle->getNextSibling()->getNextSibling();
    363. 

  363.     DOMTYPEINFOTEST(testEle->getTypeInfo(), SchemaSymbols::fgDT_DECIMAL, SchemaSymbols::fgURI_SCHEMAFORSCHEMA, __LINE__);
    364. 

  364. 

  365.     testEle = (DOMElement *)testEle->getNextSibling()->getNextSibling();
    366. 

  366.     DOMTYPEINFOTEST(testEle->getTypeInfo(), SchemaSymbols::fgDT_FLOAT, SchemaSymbols::fgURI_SCHEMAFORSCHEMA, __LINE__);
    367. 

  367. 

  368.     testEle = (DOMElement *)testEle->getNextSibling()->getNextSibling();
    369. 

  369.     DOMTYPEINFOTEST(testEle->getTypeInfo(), SchemaSymbols::fgDT_DOUBLE, SchemaSymbols::fgURI_SCHEMAFORSCHEMA, __LINE__);
    370. 

  370. 

  371.     testEle = (DOMElement *)testEle->getNextSibling()->getNextSibling();
    372. 

  372.     DOMTYPEINFOTEST(testEle->getTypeInfo(), SchemaSymbols::fgDT_DURATION, SchemaSymbols::fgURI_SCHEMAFORSCHEMA, __LINE__);
    373. 

  373. 

  374.     testEle = (DOMElement *)testEle->getNextSibling()->getNextSibling();
    375. 

  375.     DOMTYPEINFOTEST(testEle->getTypeInfo(), SchemaSymbols::fgDT_DATETIME, SchemaSymbols::fgURI_SCHEMAFORSCHEMA, __LINE__);
    376. 

  376. 

  377.     testEle = (DOMElement *)testEle->getNextSibling()->getNextSibling();
    378. 

  378.     DOMTYPEINFOTEST(testEle->getTypeInfo(), SchemaSymbols::fgDT_TIME, SchemaSymbols::fgURI_SCHEMAFORSCHEMA, __LINE__);
    379. 

  379. 

  380.     testEle = (DOMElement *)testEle->getNextSibling()->getNextSibling();
    381. 

  381.     DOMTYPEINFOTEST(testEle->getTypeInfo(), SchemaSymbols::fgDT_DATE, SchemaSymbols::fgURI_SCHEMAFORSCHEMA, __LINE__);
    382. 

  382. 

  383.     testEle = (DOMElement *)testEle->getNextSibling()->getNextSibling();
    384. 

  384.     DOMTYPEINFOTEST(testEle->getTypeInfo(), SchemaSymbols::fgDT_YEARMONTH, SchemaSymbols::fgURI_SCHEMAFORSCHEMA, __LINE__);
    385. 

  385. 

  386.     testEle = (DOMElement *)testEle->getNextSibling()->getNextSibling();
    387. 

  387.     DOMTYPEINFOTEST(testEle->getTypeInfo(), SchemaSymbols::fgDT_YEAR, SchemaSymbols::fgURI_SCHEMAFORSCHEMA, __LINE__);
    388. 

  388. 

  389.     testEle = (DOMElement *)testEle->getNextSibling()->getNextSibling();
    390. 

  390.     DOMTYPEINFOTEST(testEle->getTypeInfo(), SchemaSymbols::fgDT_MONTHDAY, SchemaSymbols::fgURI_SCHEMAFORSCHEMA, __LINE__);
    391. 

  391. 

  392.     testEle = (DOMElement *)testEle->getNextSibling()->getNextSibling();
    393. 

  393.     DOMTYPEINFOTEST(testEle->getTypeInfo(), SchemaSymbols::fgDT_DAY, SchemaSymbols::fgURI_SCHEMAFORSCHEMA, __LINE__);
    394. 

  394. 

  395.     testEle = (DOMElement *)testEle->getNextSibling()->getNextSibling();
    396. 

  396.     DOMTYPEINFOTEST(testEle->getTypeInfo(), SchemaSymbols::fgDT_MONTH, SchemaSymbols::fgURI_SCHEMAFORSCHEMA, __LINE__);
    397. 

  397. 

  398.     testEle = (DOMElement *)testEle->getNextSibling()->getNextSibling();
    399. 

  399.     DOMTYPEINFOTEST(testEle->getTypeInfo(), SchemaSymbols::fgDT_HEXBINARY, SchemaSymbols::fgURI_SCHEMAFORSCHEMA, __LINE__);
    400. 

  400. 

  401.     testEle = (DOMElement *)testEle->getNextSibling()->getNextSibling();
    402. 

  402.     DOMTYPEINFOTEST(testEle->getTypeInfo(), SchemaSymbols::fgDT_BASE64BINARY, SchemaSymbols::fgURI_SCHEMAFORSCHEMA, __LINE__);
    403. 

  403. 

  404.     testEle = (DOMElement *)testEle->getNextSibling()->getNextSibling();
    405. 

  405.     DOMTYPEINFOTEST(testEle->getTypeInfo(), SchemaSymbols::fgDT_ANYURI, SchemaSymbols::fgURI_SCHEMAFORSCHEMA, __LINE__);
    406. 

  406. 

  407.     testEle = (DOMElement *)testEle->getNextSibling()->getNextSibling();
    408. 

  408.     DOMTYPEINFOTEST(testEle->getTypeInfo(), SchemaSymbols::fgDT_QNAME, SchemaSymbols::fgURI_SCHEMAFORSCHEMA, __LINE__);
    409. 

  409. 

  410.     testEle = (DOMElement *)testEle->getNextSibling()->getNextSibling();
    411. 

  411.     DOMTYPEINFOTEST(testEle->getTypeInfo(), SchemaSymbols::fgDT_NORMALIZEDSTRING, SchemaSymbols::fgURI_SCHEMAFORSCHEMA, __LINE__);
    412. 

  412. 

  413.     testEle = (DOMElement *)testEle->getNextSibling()->getNextSibling();
    414. 

  414.     DOMTYPEINFOTEST(testEle->getTypeInfo(), SchemaSymbols::fgDT_TOKEN, SchemaSymbols::fgURI_SCHEMAFORSCHEMA, __LINE__);
    415. 

  415. 

  416.     testEle = (DOMElement *)testEle->getNextSibling()->getNextSibling();
    417. 

  417.     DOMTYPEINFOTEST(testEle->getTypeInfo(), SchemaSymbols::fgDT_LANGUAGE, SchemaSymbols::fgURI_SCHEMAFORSCHEMA, __LINE__);
    418. 

  418. 

  419.     testEle = (DOMElement *)testEle->getNextSibling()->getNextSibling();
    420. 

  420.     DOMTYPEINFOTEST(testEle->getTypeInfo(), XMLUni::fgNmTokenString, SchemaSymbols::fgURI_SCHEMAFORSCHEMA, __LINE__);
    421. 

  421. 

  422.     testEle = (DOMElement *)testEle->getNextSibling()->getNextSibling();
    423. 

  423.     DOMTYPEINFOTEST(testEle->getTypeInfo(), XMLUni::fgNmTokensString, SchemaSymbols::fgURI_SCHEMAFORSCHEMA, __LINE__);
    424. 

  424. 

  425.     testEle = (DOMElement *)testEle->getNextSibling()->getNextSibling();
    426. 

  426.     DOMTYPEINFOTEST(testEle->getTypeInfo(), SchemaSymbols::fgDT_NAME, SchemaSymbols::fgURI_SCHEMAFORSCHEMA, __LINE__);
    427. 

  427. 

  428.     testEle = (DOMElement *)testEle->getNextSibling()->getNextSibling();
    429. 

  429.     DOMTYPEINFOTEST(testEle->getTypeInfo(), SchemaSymbols::fgDT_NCNAME, SchemaSymbols::fgURI_SCHEMAFORSCHEMA, __LINE__);
    430. 

  430. 

  431.     testEle = (DOMElement *)testEle->getNextSibling()->getNextSibling();
    432. 

  432.     DOMTYPEINFOTEST(testEle->getTypeInfo(), SchemaSymbols::fgDT_INTEGER, SchemaSymbols::fgURI_SCHEMAFORSCHEMA, __LINE__);
    433. 

  433. 

  434.     testEle = (DOMElement *)testEle->getNextSibling()->getNextSibling();
    435. 

  435.     DOMTYPEINFOTEST(testEle->getTypeInfo(), SchemaSymbols::fgDT_NONPOSITIVEINTEGER, SchemaSymbols::fgURI_SCHEMAFORSCHEMA, __LINE__);
    436. 

  436. 

  437.     testEle = (DOMElement *)testEle->getNextSibling()->getNextSibling();
    438. 

  438.     DOMTYPEINFOTEST(testEle->getTypeInfo(), SchemaSymbols::fgDT_NEGATIVEINTEGER, SchemaSymbols::fgURI_SCHEMAFORSCHEMA, __LINE__);
    439. 

  439. 

  440.     testEle = (DOMElement *)testEle->getNextSibling()->getNextSibling();
    441. 

  441.     DOMTYPEINFOTEST(testEle->getTypeInfo(), SchemaSymbols::fgDT_LONG, SchemaSymbols::fgURI_SCHEMAFORSCHEMA, __LINE__);
    442. 

  442. 

  443.     testEle = (DOMElement *)testEle->getNextSibling()->getNextSibling();
    444. 

  444.     DOMTYPEINFOTEST(testEle->getTypeInfo(), SchemaSymbols::fgDT_INT, SchemaSymbols::fgURI_SCHEMAFORSCHEMA, __LINE__);
    445. 

  445. 

  446.     testEle = (DOMElement *)testEle->getNextSibling()->getNextSibling();
    447. 

  447.     DOMTYPEINFOTEST(testEle->getTypeInfo(), SchemaSymbols::fgDT_SHORT, SchemaSymbols::fgURI_SCHEMAFORSCHEMA, __LINE__);
    448. 

  448. 

  449.     testEle = (DOMElement *)testEle->getNextSibling()->getNextSibling();
    450. 

  450.     DOMTYPEINFOTEST(testEle->getTypeInfo(), SchemaSymbols::fgDT_BYTE, SchemaSymbols::fgURI_SCHEMAFORSCHEMA, __LINE__);
    451. 

  451. 

  452.     testEle = (DOMElement *)testEle->getNextSibling()->getNextSibling();
    453. 

  453.     DOMTYPEINFOTEST(testEle->getTypeInfo(), SchemaSymbols::fgDT_NONNEGATIVEINTEGER, SchemaSymbols::fgURI_SCHEMAFORSCHEMA, __LINE__);
    454. 

  454. 

  455.     testEle = (DOMElement *)testEle->getNextSibling()->getNextSibling();
    456. 

  456.     DOMTYPEINFOTEST(testEle->getTypeInfo(), SchemaSymbols::fgDT_ULONG, SchemaSymbols::fgURI_SCHEMAFORSCHEMA, __LINE__);
    457. 

  457. 

  458.     testEle = (DOMElement *)testEle->getNextSibling()->getNextSibling();
    459. 

  459.     DOMTYPEINFOTEST(testEle->getTypeInfo(), SchemaSymbols::fgDT_UINT, SchemaSymbols::fgURI_SCHEMAFORSCHEMA, __LINE__);
    460. 

  460. 

  461.     testEle = (DOMElement *)testEle->getNextSibling()->getNextSibling();
    462. 

  462.     DOMTYPEINFOTEST(testEle->getTypeInfo(), SchemaSymbols::fgDT_USHORT, SchemaSymbols::fgURI_SCHEMAFORSCHEMA, __LINE__);
    463. 

  463. 

  464.     testEle = (DOMElement *)testEle->getNextSibling()->getNextSibling();
    465. 

  465.     DOMTYPEINFOTEST(testEle->getTypeInfo(), SchemaSymbols::fgDT_UBYTE, SchemaSymbols::fgURI_SCHEMAFORSCHEMA, __LINE__);
    466. 

  466. 

  467.     testEle = (DOMElement *)testEle->getNextSibling()->getNextSibling();
    468. 

  468.     DOMTYPEINFOTEST(testEle->getTypeInfo(), SchemaSymbols::fgDT_POSITIVEINTEGER, SchemaSymbols::fgURI_SCHEMAFORSCHEMA, __LINE__);
    469. 

  469. 

  470.     testEle = (DOMElement *)testEle->getNextSibling()->getNextSibling();
    471. 

  471.     DOMTYPEINFOTEST(testEle->getTypeInfo(), SchemaSymbols::fgATTVAL_ANYTYPE, SchemaSymbols::fgURI_SCHEMAFORSCHEMA, __LINE__);
    472. 

  472. 

  473.     return passed;
    474. 

  474. }
    475. 

  475. 

  476. bool TypeInfo::testSimpleDerived() {
    477. 

  477. 

  478.     bool passed = true;
    479. 

  479.     DOMNode *docEle = doc->getDocumentElement();
    480. 

  480. 

  481.     //element simpleDerTest
    482. 

  482.     DOMElement *testEle = (DOMElement *)docEle->getFirstChild()->getNextSibling()->getNextSibling()
    483. 

  483.         ->getNextSibling()->getNextSibling()->getNextSibling();
    484. 

  484. 

  485.     DOMAttr *testAtt = testEle->getAttributeNodeNS(0, X("decimalDerived"));
    486. 

  486.     DOMTYPEINFOTEST(testAtt->getTypeInfo(), X("decimalDerivedType"), X(""),  __LINE__);
    487. 

  487. 

  488.     testAtt = testEle->getAttributeNodeNS(0, X("stringDerived"));
    489. 

  489.     DOMTYPEINFOTEST(testAtt->getTypeInfo(), X("stringDerivedType"), X(""), __LINE__);
    490. 

  490. 

  491.     testEle = (DOMElement *)testEle->getFirstChild()->getNextSibling();
    492. 

  492.     DOMTYPEINFOTEST(testEle->getTypeInfo(), X("decimalDerivedType"), X(""), __LINE__);
    493. 

  493. 

  494.     testEle = (DOMElement *)testEle->getNextSibling()->getNextSibling();
    495. 

  495.     DOMTYPEINFOTEST(testEle->getTypeInfo(), X("stringDerivedType"), X(""), __LINE__);
    496. 

  496. 

  497.     return passed;
    498. 

  498. }
    499. 

  499. 

  500. bool TypeInfo::testComplexTypes() {
    501. 

  501. 

  502.     bool passed = true;
    503. 

  503.     DOMNode *docEle = doc->getDocumentElement();
    504. 

  504. 

  505.     //element complexTest
    506. 

  506.     DOMElement *testEle = findElement(X("complexTest"));
    507. 

  507.     DOMTYPEINFOTEST(testEle->getTypeInfo(), X("complexTestType"), X(""), __LINE__);
    508. 

  508. 

  509.     testEle = (DOMElement *)testEle->getNextSibling()->getNextSibling();
    510. 

  510.     DOMTYPEINFOTEST(testEle->getTypeInfo(), X("complexDerTestType"), X(""), __LINE__);
    511. 

  511.     return passed;
    512. 

  512. }
    513. 

  513. 

  514. 

  515. bool TypeInfo::testUnions() {
    516. 

  516. 

  517.     bool passed = true;
    518. 

  518.     DOMNode *docEle = doc->getDocumentElement();
    519. 

  519.     DOMAttr *testAttr;
    520. 

  520. 

  521.     //element unionTest
    522. 

  522.     DOMElement *testEle = findElement(X("unionTest"));
    523. 

  523. 

  524.     testEle = (DOMElement *)testEle->getFirstChild()->getNextSibling();
    525. 

  525.     DOMTYPEINFOTEST(testEle->getTypeInfo(), X("decimalDerivedType"), X(""), __LINE__);
    526. 

  526. 

  527.     testEle = (DOMElement *)testEle->getNextSibling()->getNextSibling();
    528. 

  528.     DOMTYPEINFOTEST(testEle->getTypeInfo(), X("stringDerivedType"), X(""), __LINE__);
    529. 

  529. 

  530.     testEle = (DOMElement *)testEle->getNextSibling()->getNextSibling();
    531. 

  531.     DOMTYPEINFOTEST(testEle->getTypeInfo(), X("decimal"), SchemaSymbols::fgURI_SCHEMAFORSCHEMA, __LINE__);
    532. 

  532. 

  533.     testEle = (DOMElement *)testEle->getNextSibling()->getNextSibling();
    534. 

  534.     DOMTYPEINFOTEST(testEle->getTypeInfo(), X("string"), SchemaSymbols::fgURI_SCHEMAFORSCHEMA, __LINE__);
    535. 

  535. 

  536.     testEle = (DOMElement *)testEle->getNextSibling()->getNextSibling();
    537. 

  537.     testAttr = testEle->getAttributeNodeNS(0, X("testAttr"));
    538. 

  538.     DOMTYPEINFOTEST(testAttr->getTypeInfo(), X("decimalDerivedType"), X(""), __LINE__);
    539. 

  539.     testAttr = testEle->getAttributeNodeNS(0, X("testAttr2"));
    540. 

  540.     DOMTYPEINFOTEST(testAttr->getTypeInfo(), X("stringDerivedType"), X(""), __LINE__);
    541. 

  541. 

  542.     testEle = (DOMElement *)testEle->getNextSibling()->getNextSibling();
    543. 

  543.     testAttr = testEle->getAttributeNodeNS(0, X("testAttr"));
    544. 

  544.     DOMTYPEINFOTEST(testAttr->getTypeInfo(), X("stringDerivedType"), X(""), __LINE__);
    545. 

  545.     testAttr = testEle->getAttributeNodeNS(0, X("testAttr2"));
    546. 

  546.     DOMTYPEINFOTEST(testAttr->getTypeInfo(), X("decimalDerivedType"), X(""), __LINE__);
    547. 

  547. 

  548.     testEle = (DOMElement *)testEle->getNextSibling()->getNextSibling();
    549. 

  549.     testAttr = testEle->getAttributeNodeNS(0, X("testAttr"));
    550. 

  550.     DOMTYPEINFOTEST(testAttr->getTypeInfo(), X("decimal"), SchemaSymbols::fgURI_SCHEMAFORSCHEMA, __LINE__);
    551. 

  551.     testAttr = testEle->getAttributeNodeNS(0, X("testAttr2"));
    552. 

  552.     DOMTYPEINFOTEST(testAttr->getTypeInfo(), X("string"), SchemaSymbols::fgURI_SCHEMAFORSCHEMA, __LINE__);
    553. 

  553. 

  554.     testEle = (DOMElement *)testEle->getNextSibling()->getNextSibling();
    555. 

  555.     testAttr = testEle->getAttributeNodeNS(0, X("testAttr"));
    556. 

  556.     DOMTYPEINFOTEST(testAttr->getTypeInfo(), X("string"), SchemaSymbols::fgURI_SCHEMAFORSCHEMA, __LINE__);
    557. 

  557.     testAttr = testEle->getAttributeNodeNS(0, X("testAttr2"));
    558. 

  558.     DOMTYPEINFOTEST(testAttr->getTypeInfo(), X("decimal"), SchemaSymbols::fgURI_SCHEMAFORSCHEMA, __LINE__);
    559. 

  559. 

  560.     return passed;
    561. 

  561. 

  562. }
    563. 

  563. 

  564. bool TypeInfo::testAnonymous() {
    565. 

  565. 

  566.     bool passed = true;
    567. 

  567.     DOMNode *docEle = doc->getDocumentElement();
    568. 

  568.     DOMAttr *testAttr;
    569. 

  569. 

  570. 

  571.     //element anonymousTest
    572. 

  572.     DOMElement *testEle = findElement(X("anonymousTest"));
    573. 

  573.     DOMTYPEINFOTEST(testEle->getTypeInfo(), X(""), X(""), __LINE__);
    574. 

  574. 

  575.     testAttr = testEle->getAttributeNodeNS(X(""), X("partNum"));
    576. 

  576.     DOMTYPEINFOTEST(testAttr->getTypeInfo(), X(""), X(""), __LINE__);
    577. 

  577. 

  578.     testEle = (DOMElement *)testEle->getFirstChild()->getNextSibling();
    579. 

  579.     DOMTYPEINFOTEST(testEle->getTypeInfo(), X(""), X(""), __LINE__);
    580. 

  580. 

  581.     testEle = (DOMElement *)testEle->getNextSibling()->getNextSibling();
    582. 

  582.     DOMTYPEINFOTEST(testEle->getTypeInfo(), X(""), X(""), __LINE__);
    583. 

  583. 

  584.     testEle = (DOMElement *)testEle->getNextSibling()->getNextSibling();
    585. 

  585.     DOMTYPEINFOTEST(testEle->getTypeInfo(), X(""), X(""), __LINE__);
    586. 

  586. 

  587.     return passed;
    588. 

  588. }
    589. 

  589. 

  590. 

  591. bool TypeInfo::testXsiTypes() {
    592. 

  592. 

  593.     bool passed = true;
    594. 

  594.     DOMNode *docEle = doc->getDocumentElement();
    595. 

  595. 

  596.     //element xsiTypeTest
    597. 

  597.     DOMElement *testEle = findElement(X("xsiTypeTest"));
    598. 

  598. 

  599.     testEle = (DOMElement *)testEle->getFirstChild()->getNextSibling();
    600. 

  600.     DOMTYPEINFOTEST(testEle->getTypeInfo(), X("base"), X(""), __LINE__);
    601. 

  601. 

  602.     testEle = (DOMElement *)testEle->getNextSibling()->getNextSibling();
    603. 

  603.     DOMTYPEINFOTEST(testEle->getTypeInfo(), X("level1"), X(""), __LINE__);
    604. 

  604. 

  605.     testEle = (DOMElement *)testEle->getNextSibling()->getNextSibling();
    606. 

  606.     DOMTYPEINFOTEST(testEle->getTypeInfo(), X("level2"), X(""), __LINE__);
    607. 

  607. 

  608.     testEle = (DOMElement *)testEle->getNextSibling()->getNextSibling();
    609. 

  609.     DOMTYPEINFOTEST(testEle->getTypeInfo(), X("baseComplex"), X(""), __LINE__);
    610. 

  610. 

  611.     testEle = (DOMElement *)testEle->getNextSibling()->getNextSibling();
    612. 

  612.     DOMTYPEINFOTEST(testEle->getTypeInfo(), X("level1Complex"), X(""), __LINE__);
    613. 

  613. 

  614.     testEle = (DOMElement *)testEle->getNextSibling()->getNextSibling();
    615. 

  615.     DOMTYPEINFOTEST(testEle->getTypeInfo(), X("level2Complex"), X(""), __LINE__);
    616. 

  616. 

  617.     return passed;
    618. 

  618. }
    619. 

  619. 

  620. 

  621. 

  622. bool TypeInfo::testAnys() {
    623. 

  623. 

  624.     bool passed = true;
    625. 

  625.     DOMNode *docEle = doc->getDocumentElement();
    626. 

  626.     DOMAttr *testAttr;
    627. 

  627. 

  628.     //element anyTestPartial
    629. 

  629.     DOMElement *testEle = findElement(X("anyTestPartial"));
    630. 

  630.     DOMElement *back = testEle;
    631. 

  631. 

  632.     testAttr = testEle->getAttributeNodeNS(X("http://www.w3.org/1999/xhtml"), X("attr2"));
    633. 

  633.     DOMTYPEINFOTEST(testAttr->getTypeInfo(), SchemaSymbols::fgDT_ANYSIMPLETYPE, SchemaSymbols::fgURI_SCHEMAFORSCHEMA, __LINE__);
    634. 

  634. 

  635. 

  636.     DOMTYPEINFOTEST(testEle->getTypeInfo(), SchemaSymbols::fgATTVAL_ANYTYPE, SchemaSymbols::fgURI_SCHEMAFORSCHEMA, __LINE__);
    637. 

  637. 

  638.     testEle = (DOMElement *)testEle->getFirstChild()->getNextSibling();
    639. 

  639.     DOMTYPEINFOTEST(testEle->getTypeInfo(), SchemaSymbols::fgATTVAL_ANYTYPE, SchemaSymbols::fgURI_SCHEMAFORSCHEMA, __LINE__);
    640. 

  640. 

  641.     testEle = (DOMElement *)testEle->getNextSibling()->getNextSibling();
    642. 

  642.     DOMTYPEINFOTEST(testEle->getTypeInfo(), SchemaSymbols::fgATTVAL_ANYTYPE, SchemaSymbols::fgURI_SCHEMAFORSCHEMA, __LINE__);
    643. 

  643. 

  644.     testEle = (DOMElement *)testEle->getNextSibling()->getNextSibling();
    645. 

  645.     DOMTYPEINFOTEST(testEle->getTypeInfo(), SchemaSymbols::fgDT_STRING, SchemaSymbols::fgURI_SCHEMAFORSCHEMA, __LINE__);
    646. 

  646. 

  647. 

  648.     //element anyTest
    649. 

  649.     testEle = (DOMElement *)back->getNextSibling()->getNextSibling();
    650. 

  650.     back = testEle;
    651. 

  651. 

  652.     testAttr = testEle->getAttributeNodeNS(X("http://www.secondSchema"), X("attr1"));
    653. 

  653.     DOMTYPEINFOTEST(testAttr->getTypeInfo(), SchemaSymbols::fgDT_STRING, SchemaSymbols::fgURI_SCHEMAFORSCHEMA, __LINE__);
    654. 

  654. 

  655.     testAttr = testEle->getAttributeNodeNS(X("http://www.secondSchema"), X("attr2"));
    656. 

  656.     DOMTYPEINFOTEST(testAttr->getTypeInfo(), SchemaSymbols::fgDT_INTEGER, SchemaSymbols::fgURI_SCHEMAFORSCHEMA, __LINE__);
    657. 

  657. 

  658.     testAttr = testEle->getAttributeNodeNS(X("http://www.secondSchema"), X("attr3"));
    659. 

  659.     DOMTYPEINFOTEST(testAttr->getTypeInfo(), SchemaSymbols::fgDT_STRING, SchemaSymbols::fgURI_SCHEMAFORSCHEMA, __LINE__);
    660. 

  660. 

  661.     testAttr = testEle->getAttributeNodeNS(X("http://www.secondSchema"), X("attr4"));
    662. 

  662.     DOMTYPEINFOTEST(testAttr->getTypeInfo(), SchemaSymbols::fgDT_INTEGER, SchemaSymbols::fgURI_SCHEMAFORSCHEMA, __LINE__);
    663. 

  663. 

  664.     DOMTYPEINFOTEST(testEle->getTypeInfo(), SchemaSymbols::fgATTVAL_ANYTYPE, SchemaSymbols::fgURI_SCHEMAFORSCHEMA, __LINE__);
    665. 

  665. 

  666.     testEle = (DOMElement *)testEle->getFirstChild()->getNextSibling();
    667. 

  667.     DOMTYPEINFOTEST(testEle->getTypeInfo(), SchemaSymbols::fgDT_STRING, SchemaSymbols::fgURI_SCHEMAFORSCHEMA, __LINE__);
    668. 

  668. 

  669.     testEle = (DOMElement *)testEle->getNextSibling()->getNextSibling();
    670. 

  670.     DOMTYPEINFOTEST(testEle->getTypeInfo(), SchemaSymbols::fgDT_STRING, SchemaSymbols::fgURI_SCHEMAFORSCHEMA, __LINE__);
    671. 

  671. 

  672.     testEle = (DOMElement *)testEle->getNextSibling()->getNextSibling();
    673. 

  673.     DOMTYPEINFOTEST(testEle->getTypeInfo(), SchemaSymbols::fgATTVAL_ANYTYPE, SchemaSymbols::fgURI_SCHEMAFORSCHEMA, __LINE__);
    674. 

  674. 

  675.     //anyTestAttr1
    676. 

  676.     testEle = (DOMElement *)back->getNextSibling()->getNextSibling();
    677. 

  677.     back = testEle;
    678. 

  678. 

  679.     testAttr = testEle->getAttributeNodeNS(X("http://www.secondSchema"), X("attr5"));
    680. 

  680.     DOMTYPEINFOTEST(testAttr->getTypeInfo(), SchemaSymbols::fgDT_ANYSIMPLETYPE, SchemaSymbols::fgURI_SCHEMAFORSCHEMA, __LINE__);
    681. 

  681. 

  682.     //anyTestAttr2
    683. 

  683.     testEle = (DOMElement *)back->getNextSibling()->getNextSibling();
    684. 

  684.     back = testEle;
    685. 

  685. 

  686.     testAttr = testEle->getAttributeNodeNS(X("http://www.secondSchema"), X("attr5"));
    687. 

  687.     DOMTYPEINFOTEST(testAttr->getTypeInfo(), SchemaSymbols::fgDT_ANYSIMPLETYPE, SchemaSymbols::fgURI_SCHEMAFORSCHEMA, __LINE__);
    688. 

  688. 

  689.     //anyTestMissing
    690. 

  690.     testEle = (DOMElement *)back->getNextSibling()->getNextSibling();
    691. 

  691.     back = testEle;
    692. 

  692.     DOMTYPEINFOTEST(testEle->getTypeInfo(), SchemaSymbols::fgATTVAL_ANYTYPE, SchemaSymbols::fgURI_SCHEMAFORSCHEMA, __LINE__);
    693. 

  693.     return passed;
    694. 

  694. }
    695. 

  695. 

  696. 

  697. 

  698. bool TypeInfo::testInvaild() {
    699. 

  699. 

  700.     bool passed = true;
    701. 

  701.     DOMNode *docEle = doc->getDocumentElement();
    702. 

  702.     DOMAttr *testAttr;
    703. 

  703. 

  704. 

  705.     DOMTYPEINFOTEST(((DOMElement *)docEle)->getTypeInfo(), SchemaSymbols::fgATTVAL_ANYTYPE, SchemaSymbols::fgURI_SCHEMAFORSCHEMA, __LINE__);
    706. 

  706. 

  707.     //element invalidTest
    708. 

  708.     DOMElement *testEle = findElement(X("invalidTest"));
    709. 

  709. 

  710.     testAttr = testEle->getAttributeNodeNS(X(""), X("simple"));
    711. 

  711.     DOMTYPEINFOTEST(testAttr->getTypeInfo(), SchemaSymbols::fgDT_ANYSIMPLETYPE, SchemaSymbols::fgURI_SCHEMAFORSCHEMA, __LINE__);
    712. 

  712. 

  713.     testAttr = testEle->getAttributeNodeNS(X(""), X("invalid"));
    714. 

  714.     DOMTYPEINFOTEST(testAttr->getTypeInfo(), SchemaSymbols::fgDT_ANYSIMPLETYPE, SchemaSymbols::fgURI_SCHEMAFORSCHEMA, __LINE__);
    715. 

  715. 

  716.     testEle = (DOMElement *)testEle->getFirstChild()->getNextSibling();
    717. 

  717.     DOMTYPEINFOTEST(testEle->getTypeInfo(), SchemaSymbols::fgDT_ANYSIMPLETYPE, SchemaSymbols::fgURI_SCHEMAFORSCHEMA, __LINE__);
    718. 

  718. 

  719.     testEle = (DOMElement *)testEle->getNextSibling()->getNextSibling();
    720. 

  720.     DOMTYPEINFOTEST(testEle->getTypeInfo(), SchemaSymbols::fgATTVAL_ANYTYPE, SchemaSymbols::fgURI_SCHEMAFORSCHEMA, __LINE__);
    721. 

  721. 

  722.     testEle = (DOMElement *)testEle->getNextSibling()->getNextSibling();
    723. 

  723.     DOMTYPEINFOTEST(testEle->getTypeInfo(), SchemaSymbols::fgDT_ANYSIMPLETYPE, SchemaSymbols::fgURI_SCHEMAFORSCHEMA, __LINE__);
    724. 

  724. 

  725.     testEle = (DOMElement *)testEle->getNextSibling()->getNextSibling();
    726. 

  726.     DOMTYPEINFOTEST(testEle->getTypeInfo(), SchemaSymbols::fgATTVAL_ANYTYPE, SchemaSymbols::fgURI_SCHEMAFORSCHEMA, __LINE__);
    727. 

  727. 

  728.     testEle = (DOMElement *)testEle->getNextSibling()->getNextSibling();
    729. 

  729.     DOMTYPEINFOTEST(testEle->getTypeInfo(), SchemaSymbols::fgDT_ANYSIMPLETYPE, SchemaSymbols::fgURI_SCHEMAFORSCHEMA, __LINE__);
    730. 

  730.     //an undeclared element does not have anon value. Test this here
    731. 

  731.     testEle = (DOMElement *)testEle->getNextSibling()->getNextSibling();
    732. 

  732.     DOMTYPEINFOTEST(testEle->getTypeInfo(), SchemaSymbols::fgATTVAL_ANYTYPE, SchemaSymbols::fgURI_SCHEMAFORSCHEMA, __LINE__);
    733. 

  733. 

  734.     DOMElement *testEle2 = (DOMElement *)testEle->getFirstChild()->getNextSibling();
    735. 

  735.     DOMTYPEINFOTEST(testEle2->getTypeInfo(), SchemaSymbols::fgATTVAL_ANYTYPE, SchemaSymbols::fgURI_SCHEMAFORSCHEMA, __LINE__);
    736. 

  736.     
    737. 

  737.     testEle = (DOMElement *)testEle->getNextSibling()->getNextSibling();
    738. 

  738.     DOMTYPEINFOTEST(testEle->getTypeInfo(), SchemaSymbols::fgATTVAL_ANYTYPE, SchemaSymbols::fgURI_SCHEMAFORSCHEMA, __LINE__);
    739. 

  739. 

  740.     testEle = (DOMElement *)testEle->getNextSibling()->getNextSibling();
    741. 

  741.     DOMTYPEINFOTEST(testEle->getTypeInfo(), SchemaSymbols::fgATTVAL_ANYTYPE, SchemaSymbols::fgURI_SCHEMAFORSCHEMA, __LINE__);
    742. 

  742. 

  743.     testEle = (DOMElement *)testEle->getNextSibling()->getNextSibling();
    744. 

  744.     DOMTYPEINFOTEST(testEle->getTypeInfo(), SchemaSymbols::fgATTVAL_ANYTYPE, SchemaSymbols::fgURI_SCHEMAFORSCHEMA, __LINE__);
    745. 

  745. 

  746.     return passed;
    747. 

  747. }
    748. 

  748. 

  749. 

  750. bool TypeInfo::compareDOMTypeInfo(const DOMTypeInfo *info, const XMLCh* type, const XMLCh* uri) {
    751. 

  751.     return XMLString::equals(info->getName(), type) && XMLString::equals(info->getNamespace(), uri);
    752. 

  752. }
    753. 

  753. 

  754. 

  755. bool TypeInfo::testDTD() {
    756. 

  756. 

  757.     bool passed = true;
    758. 

  758.     DOMElement *testEle = doc->getDocumentElement();
    759. 

  759.     DOMAttr *testAttr;
    760. 

  760. 

  761.     DOMTYPEINFOTEST(testEle->getTypeInfo(), X(""), X(""), __LINE__);
    762. 

  762. 

  763.     testAttr = testEle->getAttributeNodeNS(X(""), X("cdata"));
    764. 

  764.     DOMTYPEINFOTEST(testAttr->getTypeInfo(), X("CDATA"), X(""), __LINE__);
    765. 

  765. 

  766.     testAttr = testEle->getAttributeNodeNS(X(""), X("enum"));
    767. 

  767.     DOMTYPEINFOTEST(testAttr->getTypeInfo(), X("ENUMERATION"), X(""), __LINE__);
    768. 

  768. 

  769.     testAttr = testEle->getAttributeNodeNS(X(""), X("id"));
    770. 

  770.     DOMTYPEINFOTEST(testAttr->getTypeInfo(), X("ID"), X(""), __LINE__);
    771. 

  771. 

  772.     testAttr = testEle->getAttributeNodeNS(X(""), X("idRef"));
    773. 

  773.     DOMTYPEINFOTEST(testAttr->getTypeInfo(), X("IDREF"), X(""), __LINE__);
    774. 

  774. 

  775.     testAttr = testEle->getAttributeNodeNS(X(""), X("idRefs"));
    776. 

  776.     DOMTYPEINFOTEST(testAttr->getTypeInfo(), X("IDREFS"), X(""), __LINE__);
    777. 

  777. 

  778.     testAttr = testEle->getAttributeNodeNS(X(""), X("nmToken"));
    779. 

  779.     DOMTYPEINFOTEST(testAttr->getTypeInfo(), X("NMTOKEN"), X(""), __LINE__);
    780. 

  780. 

  781.     testAttr = testEle->getAttributeNodeNS(X(""), X("nmTokenDefault"));
    782. 

  782.     DOMTYPEINFOTEST(testAttr->getTypeInfo(), X("NMTOKEN"), X(""), __LINE__);
    783. 

  783. 

  784.     testAttr = testEle->getAttributeNodeNS(X(""), X("nmTokenDefault2"));
    785. 

  785.     DOMTYPEINFOTEST(testAttr->getTypeInfo(), X("NMTOKEN"), X(""), __LINE__);
    786. 

  786. 

  787.     testAttr = testEle->getAttributeNodeNS(X(""), X("nmTokens"));
    788. 

  788.     DOMTYPEINFOTEST(testAttr->getTypeInfo(), X("NMTOKENS"), X(""), __LINE__);
    789. 

  789. 

  790.     testAttr = testEle->getAttributeNodeNS(X(""), X("entity"));
    791. 

  791.     DOMTYPEINFOTEST(testAttr->getTypeInfo(), X("ENTITY"), X(""), __LINE__);
    792. 

  792. 

  793.     testAttr = testEle->getAttributeNodeNS(X(""), X("entities"));
    794. 

  794.     DOMTYPEINFOTEST(testAttr->getTypeInfo(), X("ENTITIES"), X(""), __LINE__);
    795. 

  795. 

  796.     testAttr = testEle->getAttributeNodeNS(X(""), X("notation"));
    797. 

  797.     DOMTYPEINFOTEST(testAttr->getTypeInfo(), X("NOTATION"), X(""), __LINE__);
    798. 

  798. 

  799.     testAttr = testEle->getAttributeNodeNS(X(""), X("noDecl"));
    800. 

  800.     DOMTYPEINFOTEST(testAttr->getTypeInfo(), X("CDATA"), X(""), __LINE__);
    801. 

  801. 

  802.     testAttr = testEle->getAttributeNode(X("xmlns:foo"));
    803. 

  803.     DOMTYPEINFOTEST(testAttr->getTypeInfo(), X("CDATA"), X(""), __LINE__);
    804. 

  804. 

  805.     return passed;
    806. 

  806. 

  807. }
    808. 

  808. 

  809. bool TypeInfo::combinedTest() {
    810. 

  810.     bool passed = true;
    811. 

  811.     DOMNode *docEle = doc->getDocumentElement();
    812. 

  812.     DOMAttr *testAttr;
    813. 

  813. 

  814.     DOMElement *testEle = doc->getDocumentElement();
    815. 

  815.     DOMTYPEINFOTEST(testEle->getTypeInfo(), SchemaSymbols::fgATTVAL_ANYTYPE, SchemaSymbols::fgURI_SCHEMAFORSCHEMA, __LINE__);
    816. 

  816. 

  817.     testAttr = testEle->getAttributeNodeNS(X(""), X("attBoth"));
    818. 

  818.     DOMTYPEINFOTEST(testAttr->getTypeInfo(), SchemaSymbols::fgDT_STRING, SchemaSymbols::fgURI_SCHEMAFORSCHEMA, __LINE__);
    819. 

  819. 

  820.     testAttr = testEle->getAttributeNodeNS(X(""), X("attSchema"));
    821. 

  821.     DOMTYPEINFOTEST(testAttr->getTypeInfo(), SchemaSymbols::fgDT_STRING, SchemaSymbols::fgURI_SCHEMAFORSCHEMA, __LINE__);
    822. 

  822. 

  823.     testAttr = testEle->getAttributeNodeNS(X(""), X("attDTD"));
    824. 

  824.     DOMTYPEINFOTEST(testAttr->getTypeInfo(), SchemaSymbols::fgDT_ANYSIMPLETYPE, SchemaSymbols::fgURI_SCHEMAFORSCHEMA, __LINE__);
    825. 

  825. 

  826.     testEle = (DOMElement *)testEle->getFirstChild()->getNextSibling();
    827. 

  827.     DOMTYPEINFOTEST(testEle->getTypeInfo(), SchemaSymbols::fgDT_STRING, SchemaSymbols::fgURI_SCHEMAFORSCHEMA, __LINE__);
    828. 

  828. 

  829.     testEle = (DOMElement *)testEle->getNextSibling()->getNextSibling();
    830. 

  830.     DOMTYPEINFOTEST(testEle->getTypeInfo(), SchemaSymbols::fgATTVAL_ANYTYPE, SchemaSymbols::fgURI_SCHEMAFORSCHEMA, __LINE__);
    831. 

  831. 

  832.     return passed;
    833. 

  833. }
    834. 

  834. 

  835. 

  836. DOMElement* TypeInfo::findElement(const XMLCh *name) const {
    837. 

  837. 

  838.     DOMNode *toTest = doc->getDocumentElement()->getFirstChild();
    839. 

  839. 

  840.     while(!XMLString::equals(toTest->getNodeName(), name)) {
    841. 

  841.         toTest = toTest->getNextSibling();
    842. 

  842.     }
    843. 

  843. 

  844.     return (DOMElement *)toTest;
    845. 

  845. }
    846. 

  846. 

  847. int main(int argc, char **argv)
    848. 

  848. {
    849. 

  849.     bool passed = true;
    850. 

  850. 

  851.     TypeInfo ti;
    852. 

  852. 

  853.     try {
    854. 

  854.         //first the combined DTD/Schema scanner
    855. 

  855.         ti.parser = new XercesDOMParser;
    856. 

  856.         ti.parser->setValidationScheme(XercesDOMParser::Val_Auto);
    857. 

  857.         ti.parser->setDoNamespaces(true);
    858. 

  858.         ti.parser->setDoSchema(true);
    859. 

  859.         ti.parser->parse("data/TypeInfo.xml");
    860. 

  860.         ti.doc = ti.parser->getDocument();
    861. 

  861.     }
    862. 

  862.     catch (...) {
    863. 

  863.         XERCES_STD_QUALIFIER cerr << "parsing data/TypeInfo.xml failed at line" <<  __LINE__ << XERCES_STD_QUALIFIER endl;
    864. 

  864.         delete ti.parser;
    865. 

  865.         return false;
    866. 

  866.     }
    867. 

  867. 

  868.     // test only if we got a doc
    869. 

  869.     if (ti.doc) {
    870. 

  870.         passed &= ti.testInBuiltTypesOnAttributes(true);
    871. 

  871.         passed &= ti.testInBuiltTypesOnElements();
    872. 

  872.         passed &= ti.testSimpleDerived();
    873. 

  873.         passed &= ti.testComplexTypes();
    874. 

  874.         passed &= ti.testUnions();
    875. 

  875.         passed &= ti.testAnonymous();
    876. 

  876.         passed &= ti.testXsiTypes();
    877. 

  877.         passed &= ti.testAnys();
    878. 

  878.         passed &= ti.testInvaild();
    879. 

  879.     }
    880. 

  880.     else
    881. 

  881.         XERCES_STD_QUALIFIER cout << "DOMTypeInfo test at line " << __LINE__ << "was not carried out" << XERCES_STD_QUALIFIER endl;
    882. 

  882. 

  883.     delete ti.parser;
    884. 

  884. 

  885. 

  886.     //lets do the same for the just schema scanner
    887. 

  887.     try {
    888. 

  888.         ti.parser = new XercesDOMParser;
    889. 

  889.         ti.parser->setValidationScheme(XercesDOMParser::Val_Auto);
    890. 

  890.         ti.parser->setDoNamespaces(true);
    891. 

  891.         ti.parser->setDoSchema(true);
    892. 

  892.         ti.parser->useScanner(X("SGXMLScanner"));
    893. 

  893.         ti.parser->parse("data/TypeInfoNoDTD.xml");
    894. 

  894.         ti.doc = ti.parser->getDocument();
    895. 

  895.     }
    896. 

  896.     catch (...) {
    897. 

  897.         XERCES_STD_QUALIFIER cerr << "parsing data/TypeInfoNoDTD.xml failed at line" <<  __LINE__ << XERCES_STD_QUALIFIER endl;
    898. 

  898.         delete ti.parser;
    899. 

  899.         return false;
    900. 

  900.     }
    901. 

  901. 

  902.     // test only if we got a doc
    903. 

  903.     if (ti.doc) {
    904. 

  904.         passed &= ti.testInBuiltTypesOnAttributes(false);
    905. 

  905.         passed &= ti.testInBuiltTypesOnElements();
    906. 

  906.         passed &= ti.testSimpleDerived();
    907. 

  907.         passed &= ti.testComplexTypes();
    908. 

  908.         passed &= ti.testUnions();
    909. 

  909.         passed &= ti.testAnonymous();
    910. 

  910.         passed &= ti.testXsiTypes();
    911. 

  911.         passed &= ti.testAnys();
    912. 

  912.         passed &= ti.testInvaild();
    913. 

  913.     }
    914. 

  914.     else
    915. 

  915.         XERCES_STD_QUALIFIER cout << "DOMTypeInfo test at line " << __LINE__ << "was not carried out" << XERCES_STD_QUALIFIER endl;
    916. 

  916. 

  917.     delete ti.parser;
    918. 

  918. 

  919. 

  920.     //now default for DTD
    921. 

  921.     try {
    922. 

  922.         ti.parser = new XercesDOMParser;
    923. 

  923.         ti.parser->setValidationScheme(XercesDOMParser::Val_Auto);
    924. 

  924.         ti.parser->parse("data/TypeInfoJustDTD.xml");
    925. 

  925.         ti.doc = ti.parser->getDocument();
    926. 

  926.     }
    927. 

  927.     catch (...) {
    928. 

  928.         XERCES_STD_QUALIFIER cerr << "parsing data/TypeInfoJustDTD.xml failed at line" <<  __LINE__ << XERCES_STD_QUALIFIER endl;
    929. 

  929.         delete ti.parser;
    930. 

  930.         return false;
    931. 

  931.     }
    932. 

  932. 

  933.     // test only if we got a doc
    934. 

  934.     if (ti.doc) {
    935. 

  935.         passed &= ti.testDTD();
    936. 

  936.     }
    937. 

  937.     else
    938. 

  938.         XERCES_STD_QUALIFIER cout << "DOMTypeInfo test at line " << __LINE__ << "was not carried out" << XERCES_STD_QUALIFIER endl;
    939. 

  939. 

  940.     delete ti.parser;
    941. 

  941. 

  942. 

  943.     //and specific scanner
    944. 

  944.     try {
    945. 

  945.         ti.parser = new XercesDOMParser;
    946. 

  946.         ti.parser->setValidationScheme(XercesDOMParser::Val_Auto);
    947. 

  947.         ti.parser->useScanner(X("DGXMLScanner"));
    948. 

  948.         ti.parser->parse("data/TypeInfoJustDTD.xml");
    949. 

  949.         ti.doc = ti.parser->getDocument();
    950. 

  950.     }
    951. 

  951.     catch (...) {
    952. 

  952.         XERCES_STD_QUALIFIER cerr << "parsing data/TypeInfoJustDTD.xml failed at line" <<  __LINE__ << XERCES_STD_QUALIFIER endl;
    953. 

  953.         delete ti.parser;
    954. 

  954.         return false;
    955. 

  955.     }
    956. 

  956. 

  957.     // test only if we got a doc
    958. 

  958.     if (ti.doc) {
    959. 

  959.         passed &=  ti.testDTD();
    960. 

  960.     }
    961. 

  961.     else
    962. 

  962.         XERCES_STD_QUALIFIER cout << "DOMTypeInfo test at line " << __LINE__ << "was not carried out" << XERCES_STD_QUALIFIER endl;
    963. 

  963. 

  964.     delete ti.parser;
    965. 

  965. 

  966.     try {
    967. 

  967.         ti.parser = new XercesDOMParser;
    968. 

  968.         ti.parser->setValidationScheme(XercesDOMParser::Val_Auto);
    969. 

  969.         ti.parser->setDoNamespaces(true);
    970. 

  970.         ti.parser->setDoSchema(true);
    971. 

  971.         ti.parser->parse("data/combined.xml");
    972. 

  972.         ti.doc = ti.parser->getDocument();
    973. 

  973.     }
    974. 

  974.     catch (...) {
    975. 

  975.         XERCES_STD_QUALIFIER cerr << "parsing data/combined.xml failed at line" <<  __LINE__ << XERCES_STD_QUALIFIER endl;
    976. 

  976.         delete ti.parser;
    977. 

  977.         return false;
    978. 

  978.     }
    979. 

  979. 

  980.     // test only if we got a doc
    981. 

  981.     if (ti.doc) {
    982. 

  982.         passed &= ti.combinedTest();
    983. 

  983.     }
    984. 

  984.     else
    985. 

  985.         XERCES_STD_QUALIFIER cout << "DOMTypeInfo test at line " << __LINE__ << "was not carried out" << XERCES_STD_QUALIFIER endl;
    986. 

  986. 

  987.     delete ti.parser;
    988. 

  988. 

  989.     if (!passed) {
    990. 

  990.         XERCES_STD_QUALIFIER cerr << "test failed" << XERCES_STD_QUALIFIER endl;
    991. 

  991.         return 4;
    992. 

  992.     }
    993. 

  993. 

  994.     XERCES_STD_QUALIFIER cerr << "Test Run Successfully" << XERCES_STD_QUALIFIER endl;
    995. 

  995.     return 0;
    996. 

  996. }
    997. 

  997.