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

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

Add original Xerces tests and samples directories

File size: 13.8 KB
Line 
1/*
2 * Licensed to the Apache Software Foundation (ASF) under one or more
3 * contributor license agreements.  See the NOTICE file distributed with
4 * this work for additional information regarding copyright ownership.
5 * The ASF licenses this file to You under the Apache License, Version 2.0
6 * (the "License"); you may not use this file except in compliance with
7 * the License.  You may obtain a copy of the License at
8 *
9 *      http://www.apache.org/licenses/LICENSE-2.0
10 *
11 * Unless required by applicable law or agreed to in writing, software
12 * distributed under the License is distributed on an "AS IS" BASIS,
13 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14 * See the License for the specific language governing permissions and
15 * limitations under the License.
16 */
17
18/*
19 * $Id: XSTSHarness.cpp 833057 2009-11-05 15:25:10Z borisk $
20 */
21
22
23// ---------------------------------------------------------------------------
24//  Includes
25// ---------------------------------------------------------------------------
26#include "XSTSHarness.hpp"
27#include "XSTSHarnessHandlers.hpp"
28#include "XMLHarnessHandlers.hpp"
29#include <xercesc/util/PlatformUtils.hpp>
30#include <xercesc/util/OutOfMemoryException.hpp>
31#include <xercesc/util/BinInputStream.hpp>
32#include <xercesc/sax2/SAX2XMLReader.hpp>
33#include <xercesc/sax2/XMLReaderFactory.hpp>
34#if defined(XERCES_NEW_IOSTREAMS)
35#include <fstream>
36#else
37#include <fstream.h>
38#endif
39#include <xercesc/util/OutOfMemoryException.hpp>
40#include <xercesc/framework/MemBufInputSource.hpp>
41
42static XMLCh sz_XMLTestSuiteRoot[]={ chLatin_T, chLatin_E, chLatin_S, chLatin_T, chLatin_S, chLatin_U, chLatin_I, chLatin_T, chLatin_E, chNull };
43const XMLCh dummy[]={ chLatin_f, chLatin_i, chLatin_l, chLatin_e, chColon, chForwardSlash, chForwardSlash,
44                       chLatin_d, chLatin_u, chLatin_m, chLatin_m, chLatin_y, chForwardSlash, chNull };
45
46
47// ---------------------------------------------------------------------------
48//  Local helper methods
49// ---------------------------------------------------------------------------
50void usage()
51{
52    XERCES_STD_QUALIFIER cout <<
53            "\n"
54            "Usage:\n"
55            "    XSTSHarness <testSet>\n"
56            "\n"
57            "This program runs the tests listed in the XMLSchema Test Suite, available at\n"
58            "http://www.w3.org/XML/2004/xml-schema-test-suite/xmlschema2006-11-06/xsts-2007-06-20.tar.gz\n"
59            "Run this executable against the suite.xml file found in the top directory\n"
60            "\n"
61            "It also runs the tests listed in the XML Test Suite, available at\n"
62            "http://www.w3.org/XML/Test/xmlts20080827.zip\n"
63            "Run this executable against the xmlconf.xml file found in the top directory\n"
64            "\n"
65         << XERCES_STD_QUALIFIER endl;
66}
67
68BaseHarnessHandlers::BaseHarnessHandlers(const XMLCh* baseURL) :
69    fSawErrors(false),
70    fBaseURL(baseURL),
71    fFailures(0),
72    fTests(0)
73{
74}
75
76void BaseHarnessHandlers::error(const SAXParseException& e)
77{
78    fSawErrors = true;
79    XERCES_STD_QUALIFIER cout << "\nError at file " << StrX(e.getSystemId())
80                 << ", line " << e.getLineNumber()
81                 << ", char " << e.getColumnNumber()
82         << "\n  Message: " << StrX(e.getMessage()) << XERCES_STD_QUALIFIER endl;
83}
84
85void BaseHarnessHandlers::fatalError(const SAXParseException& e)
86{
87    fSawErrors = true;
88    XERCES_STD_QUALIFIER cout << "\nFatal Error at file " << StrX(e.getSystemId())
89                 << ", line " << e.getLineNumber()
90                 << ", char " << e.getColumnNumber()
91         << "\n  Message: " << StrX(e.getMessage()) << XERCES_STD_QUALIFIER endl;
92}
93
94void BaseHarnessHandlers::warning(const SAXParseException& e)
95{
96    XERCES_STD_QUALIFIER cout << "\nWarning at file " << StrX(e.getSystemId())
97                 << ", line " << e.getLineNumber()
98                 << ", char " << e.getColumnNumber()
99         << "\n  Message: " << StrX(e.getMessage()) << XERCES_STD_QUALIFIER endl;
100}
101
102void BaseHarnessHandlers::printFile(XMLURL& url)
103{
104    if(XMLString::equals(url.getURLText(), dummy))
105        return;
106    BinInputStream* stream=url.makeNewStream();
107    if(stream==NULL)
108    {
109        XERCES_STD_QUALIFIER cout << "File " << StrX(url.getURLText()) << " is missing" << XERCES_STD_QUALIFIER endl;
110        return;
111    }
112    XERCES_STD_QUALIFIER cout << "Content of file " << StrX(url.getURLText()) << XERCES_STD_QUALIFIER endl;
113    XMLByte buffer[256];
114    XMLSize_t nRead;
115    while((nRead=stream->readBytes(buffer, 255)) >0)
116    {
117        buffer[nRead]=0;
118        // sending data containing \n\r to cout generates \n\n\r, so strip any \r
119        XMLSize_t idx=0;
120        while(true)
121        {
122            int cr=XMLString::indexOf((const char*)buffer, '\r', idx);
123            if(cr==-1)
124                break;
125            memmove(&buffer[cr], &buffer[cr+1], XMLString::stringLen((const char*)&buffer[cr+1])+1);
126            idx=cr;
127            if(buffer[idx]==0)
128                break;
129        }
130        XERCES_STD_QUALIFIER cout << (const char*)buffer;
131    }
132    XERCES_STD_QUALIFIER cout << XERCES_STD_QUALIFIER endl;
133    delete stream;
134}
135
136/////////////////////////////////////////////////////////////////////
137
138void BaseErrorHandler::error(const SAXParseException& exc)
139{
140    fSawErrors=true;
141    fErrorText.append(exc.getMessage());
142    fErrorText.append(chLF);
143}
144
145void BaseErrorHandler::fatalError(const SAXParseException& exc)
146{
147    fSawErrors=true;
148    fErrorText.append(exc.getMessage());
149    fErrorText.append(chLF);
150}
151
152/////////////////////////////////////////////////////////////////////
153
154InputSource* BaseEntityResolver::resolveEntity(XMLResourceIdentifier* resourceIdentifier)
155{
156    if(XMLString::equals(resourceIdentifier->getNameSpace(), XMLUni::fgXMLURIName))
157    {
158        static const char* xmlXsd=  "<?xml version='1.0'?>"
159                                    "<xs:schema targetNamespace='http://www.w3.org/XML/1998/namespace' "
160                                    "  xmlns:xs='http://www.w3.org/2001/XMLSchema' "
161                                    "  xml:lang='en'>"
162                                    ""
163                                    " <xs:attribute name='lang'>"
164                                    "  <xs:simpleType>"
165                                    "   <xs:union memberTypes='xs:language'>"
166                                    "    <xs:simpleType>"
167                                    "     <xs:restriction base='xs:string'>"
168                                    "      <xs:enumeration value=''/>"
169                                    "     </xs:restriction>"
170                                    "    </xs:simpleType>"
171                                    "   </xs:union>"
172                                    "  </xs:simpleType>"
173                                    " </xs:attribute>"
174                                    ""
175                                    " <xs:attribute name='space'>"
176                                    "  <xs:simpleType>"
177                                    "   <xs:restriction base='xs:NCName'>"
178                                    "    <xs:enumeration value='default'/>"
179                                    "    <xs:enumeration value='preserve'/>"
180                                    "   </xs:restriction>"
181                                    "  </xs:simpleType>"
182                                    " </xs:attribute>"
183                                    ""
184                                    " <xs:attribute name='base' type='xs:anyURI'>"
185                                    " </xs:attribute>"
186                                    ""
187                                    " <xs:attribute name='id' type='xs:ID'>"
188                                    " </xs:attribute>"
189                                    ""
190                                    " <xs:attributeGroup name='specialAttrs'>"
191                                    "  <xs:attribute ref='xml:base'/>"
192                                    "  <xs:attribute ref='xml:lang'/>"
193                                    "  <xs:attribute ref='xml:space'/>"
194                                    "  <xs:attribute ref='xml:id'/>"
195                                    " </xs:attributeGroup>"
196                                    ""
197                                    "</xs:schema>";
198        return new MemBufInputSource((XMLByte*)xmlXsd, strlen(xmlXsd), "");
199    }
200    return 0;
201}
202
203/////////////////////////////////////////////////////////////////////
204
205class RootExtractor : public DefaultHandler
206{
207public:
208    // -----------------------------------------------------------------------
209    //  Constructors and Destructor
210    // -----------------------------------------------------------------------
211    RootExtractor()
212    {
213        fIsXMLSuite=false;
214    }
215
216    // -----------------------------------------------------------------------
217    //  Getter methods
218    // -----------------------------------------------------------------------
219    bool isXMLSuite() const
220    {
221        return fIsXMLSuite;
222    }
223
224    // -----------------------------------------------------------------------
225    //  Handlers for the SAX DocumentHandler interface
226    // -----------------------------------------------------------------------
227    void startElement(const XMLCh* const uri, const XMLCh* const localname, const XMLCh* const qname, const Attributes& attrs)
228    {
229        fIsXMLSuite=XMLString::equals(qname, sz_XMLTestSuiteRoot);
230        throw fIsXMLSuite;
231    }
232
233protected:
234    bool fIsXMLSuite;
235};
236
237// ---------------------------------------------------------------------------
238//  Program entry point
239// ---------------------------------------------------------------------------
240int main(int argC, char* argV[])
241{
242
243    // Check command line and extract arguments.
244    if (argC < 2)
245    {
246        usage();
247        return 1;
248    }
249
250    int argInd;
251    for (argInd = 1; argInd < argC; argInd++)
252    {
253        // Break out on first parm not starting with a dash
254        if (argV[argInd][0] != '-')
255            break;
256
257        // Watch for special case help request
258        if (!strcmp(argV[argInd], "-?"))
259        {
260            usage();
261            return 2;
262        }
263        // TODO: add option to generate the XML summarizing the result
264        else if (!strncmp(argV[argInd], "-v=", 3)
265             ||  !strncmp(argV[argInd], "-V=", 3))
266        {
267        }
268        else
269        {
270            XERCES_STD_QUALIFIER cout << "Unknown option '" << argV[argInd]
271                << "', ignoring it\n" << XERCES_STD_QUALIFIER endl;
272        }
273    }
274
275    //
276    //  There should be only one and only one parameter left, and that
277    //  should be the file name.
278    //
279    if (argInd != argC - 1)
280    {
281        usage();
282        return 1;
283    }
284
285    try
286    {
287        XMLPlatformUtils::Initialize();
288    }
289
290    catch (const XMLException& toCatch)
291    {
292        XERCES_STD_QUALIFIER cout << "Error during initialization! Message:\n"
293            << StrX(toCatch.getMessage()) << XERCES_STD_QUALIFIER endl;
294        return 1;
295    }
296
297    //
298    //  Create a SAX parser object.
299    //
300    SAX2XMLReader* parser = XMLReaderFactory::createXMLReader();
301    parser->setFeature(XMLUni::fgSAX2CoreNameSpaces, true);
302    parser->setFeature(XMLUni::fgSAX2CoreValidation, false);
303
304    const char* xmlFile = argV[argInd];
305
306    // Discover if the test suite is the XML or XMLSchema one
307    RootExtractor rootExtractor;
308    parser->setContentHandler(&rootExtractor);
309    try
310    {
311        parser->parse(xmlFile);
312    }
313    catch (...)
314    {
315    }
316
317    XMLCh* uniFile = XMLString::transcode(xmlFile);
318    XMLCh* uri = new XMLCh[XMLString::stringLen(xmlFile) + 9];
319    XMLString::fixURI(uniFile, uri);
320    BaseHarnessHandlers* handler=NULL;
321    if(rootExtractor.isXMLSuite())
322    {
323        // XML Test Suite
324        handler=new XMLHarnessHandlers(uri);
325    }
326    else
327    {
328        // XMLSchema Test Suite
329        handler=new XSTSHarnessHandlers(uri);
330    }
331    XMLString::release(&uniFile);
332    delete [] uri;
333    parser->setContentHandler(handler);
334    parser->setErrorHandler(handler);
335
336    //
337    //  Get the starting time and kick off the parse of the indicated
338    //  file. Catch any exceptions that might propogate out of it.
339    //
340    bool errorOccurred=false;
341    const unsigned long startMillis = XMLPlatformUtils::getCurrentMillis();
342    try
343    {
344        parser->parse(xmlFile);
345    }
346    catch (const OutOfMemoryException&)
347    {
348        XERCES_STD_QUALIFIER cout << "OutOfMemoryException" << XERCES_STD_QUALIFIER endl;
349        errorOccurred = true;
350    }
351    catch (const XMLException& e)
352    {
353        XERCES_STD_QUALIFIER cout << "\nError during parsing: '" << xmlFile << "'\n"
354            << "Exception message is:  \n"
355            << StrX(e.getMessage()) << "\n" << XERCES_STD_QUALIFIER endl;
356        errorOccurred = true;
357    }
358    catch (...)
359    {
360        XERCES_STD_QUALIFIER cout << "\nUnexpected exception during parsing: '" << xmlFile << "'\n";
361        errorOccurred = true;
362    }
363    const unsigned long endMillis = XMLPlatformUtils::getCurrentMillis();
364    unsigned long duration = endMillis - startMillis;
365
366    if (handler->getSawErrors())
367        errorOccurred = true;
368
369    XERCES_STD_QUALIFIER cout << "Total tests: " << handler->getTotalTests() << XERCES_STD_QUALIFIER endl;
370    XERCES_STD_QUALIFIER cout << "Failed tests: " << handler->getFailedTests() << XERCES_STD_QUALIFIER endl;
371    XERCES_STD_QUALIFIER cout << "Success rate: " << ((double)(handler->getTotalTests()-handler->getFailedTests()))/(double)handler->getTotalTests()*100 << "%" << XERCES_STD_QUALIFIER endl;
372    XERCES_STD_QUALIFIER cout << "Duration: ";
373    if(duration > 60000)
374    {
375        XERCES_STD_QUALIFIER cout << duration/60000 << ":";
376        duration=duration % 60000;
377    }
378    if(duration/1000 < 10)
379        XERCES_STD_QUALIFIER cout << "0";
380    XERCES_STD_QUALIFIER cout << duration/1000 << "." << duration % 1000 << XERCES_STD_QUALIFIER endl;
381
382    //
383    //  Delete the parser itself.  Must be done prior to calling Terminate, below.
384    //
385    delete parser;
386    delete handler;
387
388    // And call the termination method
389    XMLPlatformUtils::Terminate();
390
391    if (errorOccurred)
392        return 4;
393    else
394        return 0;
395
396}
Note: See TracBrowser for help on using the repository browser.