| /* |
| * Licensed to the Apache Software Foundation (ASF) under one or more |
| * contributor license agreements. See the NOTICE file distributed with |
| * this work for additional information regarding copyright ownership. |
| * The ASF licenses this file to You under the Apache License, Version 2.0 |
| * (the "License"); you may not use this file except in compliance with |
| * the License. You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| * See the License for the specific language governing permissions and |
| * limitations under the License. |
| */ |
| |
| /* |
| * $Id$ |
| */ |
| |
| // --------------------------------------------------------------------------- |
| // This program tests the XMLPlatformUtils::Initialize/Terminate() pair |
| // by calling the pair a number of times. |
| // --------------------------------------------------------------------------- |
| |
| // --------------------------------------------------------------------------- |
| // Includes |
| // --------------------------------------------------------------------------- |
| #include <xercesc/util/PlatformUtils.hpp> |
| #include <xercesc/sax/SAXException.hpp> |
| #include <xercesc/sax/SAXParseException.hpp> |
| |
| #include <xercesc/parsers/XercesDOMParser.hpp> |
| #include <xercesc/parsers/SAXParser.hpp> |
| #include <xercesc/sax2/SAX2XMLReader.hpp> |
| #include <xercesc/sax2/XMLReaderFactory.hpp> |
| #include <xercesc/util/OutOfMemoryException.hpp> |
| #include <xercesc/dom/DOMException.hpp> |
| #include "InitTermTest.hpp" |
| |
| #include <string.h> |
| #include <stdlib.h> |
| |
| #if defined(XERCES_NEW_IOSTREAMS) |
| #include <fstream> |
| #else |
| #include <fstream.h> |
| #endif |
| #include <limits.h> |
| |
| |
| // --------------------------------------------------------------------------- |
| // Local Enum to switch theState |
| // --------------------------------------------------------------------------- |
| enum Teststate { |
| Once, |
| Multiple, |
| UnEven, |
| Limit, |
| ExceedLimit |
| }; |
| |
| // --------------------------------------------------------------------------- |
| // Declare functions |
| // --------------------------------------------------------------------------- |
| int TestInit4DOM(const char* xmlFile, bool gDoNamespaces, bool gDoSchema, bool gSchemaFullChecking, Teststate theState); |
| int TestInit4SAX(const char* xmlFile, bool gDoNamespaces, bool gDoSchema, bool gSchemaFullChecking, Teststate theState); |
| int TestInit4SAX2(const char* xmlFile, bool gDoNamespaces, bool gDoSchema, bool gSchemaFullChecking, Teststate theState); |
| |
| // --------------------------------------------------------------------------- |
| // Define macro |
| // --------------------------------------------------------------------------- |
| #define TESTINITPRE \ |
| long times = 1; \ |
| switch (theState) { \ |
| case Multiple: \ |
| case UnEven: \ |
| times = 100; \ |
| break; \ |
| case Limit: \ |
| case ExceedLimit: \ |
| times = LONG_MAX; \ |
| break; \ |
| case Once: \ |
| default: \ |
| times = 1; \ |
| } \ |
| long i = 0; \ |
| for (i = 0; i < times; i++) { \ |
| try \ |
| { \ |
| XMLPlatformUtils::Initialize(); \ |
| } \ |
| \ |
| catch (const XMLException& toCatch) \ |
| { \ |
| XERCES_STD_QUALIFIER cerr << "Error during initialization! :\n" \ |
| << StrX(toCatch.getMessage()) << XERCES_STD_QUALIFIER endl; \ |
| return 1; \ |
| } \ |
| } \ |
| \ |
| if (theState == ExceedLimit) { \ |
| try \ |
| { \ |
| XMLPlatformUtils::Initialize(); \ |
| } \ |
| \ |
| catch (const XMLException& toCatch) \ |
| { \ |
| XERCES_STD_QUALIFIER cerr << "Error during initialization! :\n" \ |
| << StrX(toCatch.getMessage()) << XERCES_STD_QUALIFIER endl; \ |
| return 1; \ |
| } \ |
| } |
| |
| |
| #define TESTINITPOST \ |
| InitTermTestErrorHandler errorHandler; \ |
| parser->setErrorHandler(&errorHandler); \ |
| bool errorOccurred = false; \ |
| \ |
| errorHandler.resetErrors(); \ |
| \ |
| try \ |
| { \ |
| parser->parse(xmlFile); \ |
| } \ |
| catch (const OutOfMemoryException&) \ |
| { \ |
| XERCES_STD_QUALIFIER cerr << "OutOfMemoryException" << XERCES_STD_QUALIFIER endl; \ |
| errorOccurred = true; \ |
| } \ |
| catch (const XMLException& toCatch) \ |
| { \ |
| XERCES_STD_QUALIFIER cerr << "\nError during parsing: '" << xmlFile << "'\n" \ |
| << "Exception message is: \n" \ |
| << StrX(toCatch.getMessage()) << "\n" << XERCES_STD_QUALIFIER endl; \ |
| errorOccurred = true; \ |
| } \ |
| catch (const DOMException& toCatch) \ |
| { \ |
| XERCES_STD_QUALIFIER cerr << "\nDOM Error during parsing: '" << xmlFile \ |
| << "\nDOMException code is: \n" \ |
| << toCatch.code << "\n" << XERCES_STD_QUALIFIER endl; \ |
| errorOccurred = true; \ |
| } \ |
| catch (...) \ |
| { \ |
| XERCES_STD_QUALIFIER cerr << "\nUnexpected exception during parsing: '" \ |
| << xmlFile << "'\n"; \ |
| errorOccurred = true; \ |
| } \ |
| \ |
| if (errorHandler.getSawErrors()) \ |
| { \ |
| XERCES_STD_QUALIFIER cout << "\nErrors occurred, no output available\n" << XERCES_STD_QUALIFIER endl;\ |
| errorOccurred = true; \ |
| } \ |
| \ |
| delete parser; \ |
| \ |
| for (i = 0; i < times; i++) { \ |
| XMLPlatformUtils::Terminate(); \ |
| } \ |
| \ |
| if (theState == ExceedLimit || theState == UnEven) { \ |
| XMLPlatformUtils::Terminate(); \ |
| } \ |
| \ |
| if (errorOccurred) \ |
| return 4; \ |
| else \ |
| return 0; |
| |
| // --------------------------------------------------------------------------- |
| // DOM Parser |
| // --------------------------------------------------------------------------- |
| int TestInit4DOM(const char* xmlFile, bool gDoNamespaces, bool gDoSchema, bool gSchemaFullChecking, Teststate theState) |
| { |
| TESTINITPRE; |
| XercesDOMParser* parser = new XercesDOMParser; |
| parser->setDoNamespaces(gDoNamespaces); |
| parser->setDoSchema(gDoSchema); |
| parser->setHandleMultipleImports (true); |
| parser->setValidationSchemaFullChecking(gSchemaFullChecking); |
| TESTINITPOST; |
| } |
| |
| // --------------------------------------------------------------------------- |
| // SAX Parser |
| // --------------------------------------------------------------------------- |
| int TestInit4SAX(const char* xmlFile, bool gDoNamespaces, bool gDoSchema, bool gSchemaFullChecking, Teststate theState) |
| { |
| TESTINITPRE; |
| SAXParser* parser = new SAXParser; |
| parser->setDoNamespaces(gDoNamespaces); |
| parser->setDoSchema(gDoSchema); |
| parser->setHandleMultipleImports (true); |
| parser->setValidationSchemaFullChecking(gSchemaFullChecking); |
| TESTINITPOST; |
| } |
| |
| // --------------------------------------------------------------------------- |
| // SAX2 XML Reader |
| // --------------------------------------------------------------------------- |
| int TestInit4SAX2(const char* xmlFile, bool gDoNamespaces, bool gDoSchema, bool gSchemaFullChecking, Teststate theState) |
| { |
| TESTINITPRE; |
| SAX2XMLReader* parser = XMLReaderFactory::createXMLReader(); |
| |
| XMLCh* doNamespaceFeature = XMLString::transcode("http://xml.org/sax/features/namespaces"); |
| parser->setFeature(doNamespaceFeature, gDoNamespaces); |
| |
| XMLCh* doSchemaFeature = XMLString::transcode("http://apache.org/xml/features/validation/schema"); |
| parser->setFeature(doSchemaFeature, gDoSchema); |
| |
| XMLCh* handleMultipleImportsFeature = XMLString::transcode("http://apache.org/xml/features/validation/schema/handle-multiple-imports"); |
| parser->setFeature(handleMultipleImportsFeature, true); |
| |
| XMLCh* fullSchemaCheckFeature = XMLString::transcode("http://apache.org/xml/features/validation/schema-full-checking"); |
| parser->setFeature(fullSchemaCheckFeature, gSchemaFullChecking); |
| |
| XMLString::release(&doNamespaceFeature); |
| XMLString::release(&doSchemaFeature); |
| XMLString::release(&handleMultipleImportsFeature); |
| XMLString::release(&fullSchemaCheckFeature); |
| |
| TESTINITPOST; |
| } |
| |
| // --------------------------------------------------------------------------- |
| // |
| // Usage() |
| // |
| // --------------------------------------------------------------------------- |
| void usage() |
| { |
| XERCES_STD_QUALIFIER cout << "\nUsage:\n" |
| " InitTermTest [options] <XML file>\n\n" |
| "This program tests the XMLPlatformUtils::Initialize()/Terminate()\n" |
| "pair by calling it a number of times.\n" |
| "Options:\n" |
| " -n Enable namespace processing. Default is off.\n" |
| " -s Enable schema processing. Default is off.\n" |
| " -f Enable full schema constraint checking. Defaults to off.\n" |
| " -? Show this help.\n" |
| << XERCES_STD_QUALIFIER endl; |
| } |
| |
| // --------------------------------------------------------------------------- |
| // Main |
| // --------------------------------------------------------------------------- |
| int main(int argC, char* argV[]) { |
| |
| // --------------------------------------------------------------------------- |
| // Local data |
| // |
| // gDoNamespaces |
| // Indicates whether namespace processing should be done. |
| // |
| // gDoSchema |
| // Indicates whether schema processing should be done. |
| // |
| // gSchemaFullChecking |
| // Indicates whether full schema constraint checking should be done. |
| // |
| // --------------------------------------------------------------------------- |
| bool gDoNamespaces = false; |
| bool gDoSchema = false; |
| bool gSchemaFullChecking = false; |
| |
| // Check command line and extract arguments. |
| if (argC < 2) |
| { |
| usage(); |
| return 1; |
| } |
| |
| // See if non validating dom parser configuration is requested. |
| int parmInd; |
| for (parmInd = 1; parmInd < argC; parmInd++) |
| { |
| // Break out on first parm not starting with a dash |
| if (argV[parmInd][0] != '-') |
| break; |
| |
| // Watch for special case help request |
| if (!strcmp(argV[parmInd], "-?")) |
| { |
| usage(); |
| return 2; |
| } |
| else if (!strcmp(argV[parmInd], "-n") |
| || !strcmp(argV[parmInd], "-N")) |
| { |
| gDoNamespaces = true; |
| } |
| else if (!strcmp(argV[parmInd], "-s") |
| || !strcmp(argV[parmInd], "-S")) |
| { |
| gDoSchema = true; |
| } |
| else if (!strcmp(argV[parmInd], "-f") |
| || !strcmp(argV[parmInd], "-F")) |
| { |
| gSchemaFullChecking = true; |
| } |
| else |
| { |
| XERCES_STD_QUALIFIER cerr << "Unknown option '" << argV[parmInd] |
| << "', ignoring it.\n" << XERCES_STD_QUALIFIER endl; |
| } |
| } |
| |
| // |
| // And now we have to have only one parameter left and it must be |
| // the file name. |
| // |
| if (parmInd + 1 != argC) |
| { |
| usage(); |
| return 1; |
| } |
| |
| char* xmlFile = argV[parmInd]; |
| bool error = false; |
| |
| // |
| // Calling Init/Term pair a number of times |
| // |
| unsigned int i = 0; |
| for (i=0; i < 100; i++) { |
| if (error) { |
| XERCES_STD_QUALIFIER cout << "Test Failed" << XERCES_STD_QUALIFIER endl; |
| return 4; |
| } |
| |
| if (TestInit4DOM(xmlFile, gDoNamespaces, gDoSchema, gSchemaFullChecking, Once)) |
| error = true; |
| if (TestInit4SAX(xmlFile, gDoNamespaces, gDoSchema, gSchemaFullChecking, Once)) |
| error = true; |
| if (TestInit4SAX2(xmlFile, gDoNamespaces, gDoSchema, gSchemaFullChecking, Once)) |
| error = true; |
| } |
| |
| if (error || TestInit4DOM(xmlFile, gDoNamespaces, gDoSchema, gSchemaFullChecking, Multiple)) |
| error = true; |
| if (error || TestInit4SAX(xmlFile, gDoNamespaces, gDoSchema, gSchemaFullChecking, Multiple)) |
| error = true; |
| if (error || TestInit4SAX2(xmlFile, gDoNamespaces, gDoSchema, gSchemaFullChecking, Multiple)) |
| error = true; |
| /* |
| * The following Limit test is a stress test that can run a long time |
| * Commented out for regular sanity test |
| */ |
| /* |
| if (error || TestInit4DOM(xmlFile, gDoNamespaces, gDoSchema, gSchemaFullChecking, Limit)) |
| error = true; |
| if (error || TestInit4SAX(xmlFile, gDoNamespaces, gDoSchema, gSchemaFullChecking, Limit)) |
| error = true; |
| if (error || TestInit4SAX2(xmlFile, gDoNamespaces, gDoSchema, gSchemaFullChecking, Limit)) |
| error = true; |
| |
| if (error || TestInit4DOM(xmlFile, gDoNamespaces, gDoSchema, gSchemaFullChecking, ExceedLimit)) |
| error = true; |
| if (error || TestInit4SAX(xmlFile, gDoNamespaces, gDoSchema, gSchemaFullChecking, ExceedLimit)) |
| error = true; |
| if (error || TestInit4SAX2(xmlFile, gDoNamespaces, gDoSchema, gSchemaFullChecking, ExceedLimit)) |
| error = true; |
| */ |
| |
| if (error || TestInit4DOM(xmlFile, gDoNamespaces, gDoSchema, gSchemaFullChecking, UnEven)) |
| error = true; |
| if (error || TestInit4SAX(xmlFile, gDoNamespaces, gDoSchema, gSchemaFullChecking, UnEven)) |
| error = true; |
| if (error || TestInit4SAX2(xmlFile, gDoNamespaces, gDoSchema, gSchemaFullChecking, UnEven)) |
| error = true; |
| |
| if (error) { |
| XERCES_STD_QUALIFIER cout << "Test Failed" << XERCES_STD_QUALIFIER endl; |
| return 4; |
| } |
| |
| XERCES_STD_QUALIFIER cout << "Test Run Successfully" << XERCES_STD_QUALIFIER endl; |
| return 0; |
| } |
| |
| // --------------------------------------------------------------------------- |
| // InitTermTestErrorHandler |
| // --------------------------------------------------------------------------- |
| InitTermTestErrorHandler::InitTermTestErrorHandler() : |
| |
| fSawErrors(false) |
| { |
| } |
| |
| InitTermTestErrorHandler::~InitTermTestErrorHandler() |
| { |
| } |
| |
| void InitTermTestErrorHandler::error(const SAXParseException& e) |
| { |
| fSawErrors = true; |
| XERCES_STD_QUALIFIER cerr << "\nError at file " << StrX(e.getSystemId()) |
| << ", line " << e.getLineNumber() |
| << ", char " << e.getColumnNumber() |
| << "\n Message: " << StrX(e.getMessage()) << XERCES_STD_QUALIFIER endl; |
| } |
| |
| void InitTermTestErrorHandler::fatalError(const SAXParseException& e) |
| { |
| fSawErrors = true; |
| XERCES_STD_QUALIFIER cerr << "\nFatal Error at file " << StrX(e.getSystemId()) |
| << ", line " << e.getLineNumber() |
| << ", char " << e.getColumnNumber() |
| << "\n Message: " << StrX(e.getMessage()) << XERCES_STD_QUALIFIER endl; |
| } |
| |
| void InitTermTestErrorHandler::warning(const SAXParseException& e) |
| { |
| XERCES_STD_QUALIFIER cerr << "\nWarning at file " << StrX(e.getSystemId()) |
| << ", line " << e.getLineNumber() |
| << ", char " << e.getColumnNumber() |
| << "\n Message: " << StrX(e.getMessage()) << XERCES_STD_QUALIFIER endl; |
| } |
| |
| void InitTermTestErrorHandler::resetErrors() |
| { |
| fSawErrors = false; |
| } |
