/*
 * The Apache Software License, Version 1.1
 *
 * Copyright (c) 1999-2000 The Apache Software Foundation.  All rights
 * reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 *
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 *
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in
 *    the documentation and/or other materials provided with the
 *    distribution.
 *
 * 3. The end-user documentation included with the redistribution,
 *    if any, must include the following acknowledgment:
 *       "This product includes software developed by the
 *        Apache Software Foundation (http://www.apache.org/)."
 *    Alternately, this acknowledgment may appear in the software itself,
 *    if and wherever such third-party acknowledgments normally appear.
 *
 * 4. The names "Xerces" and "Apache Software Foundation" must
 *    not be used to endorse or promote products derived from this
 *    software without prior written permission. For written
 *    permission, please contact apache\@apache.org.
 *
 * 5. Products derived from this software may not be called "Apache",
 *    nor may "Apache" appear in their name, without prior written
 *    permission of the Apache Software Foundation.
 *
 * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESSED OR IMPLIED
 * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
 * DISCLAIMED.  IN NO EVENT SHALL THE APACHE SOFTWARE FOUNDATION OR
 * ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF
 * USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
 * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
 * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
 * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
 * SUCH DAMAGE.
 * ====================================================================
 *
 * This software consists of voluntary contributions made by many
 * individuals on behalf of the Apache Software Foundation, and was
 * originally based on software copyright (c) 1999, International
 * Business Machines, Inc., http://www.ibm.com .  For more information
 * on the Apache Software Foundation, please see
 * <http://www.apache.org/>.
 */

//---------------------------------------------------------------------
//
//  This test program is used, in conjunction with a set of test data files,
//  to verify support for different character encodings in XML.
//
//---------------------------------------------------------------------


// ---------------------------------------------------------------------------
//  Includes
// ---------------------------------------------------------------------------
#include <xercesc/util/PlatformUtils.hpp>
#include <xercesc/util/XMLString.hpp>
#include <xercesc/util/XMLException.hpp>

#include <xercesc/sax/SAXException.hpp>
#include <xercesc/sax/ErrorHandler.hpp>
#include <xercesc/sax/SAXParseException.hpp>


#include <xercesc/parsers/DOMParser.hpp>
#include <xercesc/dom/DOM.hpp>
#include <stdio.h>

static int gTestsFailed = 0;
static int gTestsRun    = 0;


//-----------------------------------------------------------------------
//
//  ErrorHandler.   The DOM Parser will report any parsing errors by means
//                  of call-backs to the methods of this class.
//                  This is just necessary boilerplate, as far as this
//                  program is concerned.
//
//-----------------------------------------------------------------------

class  ParseErrorHandler: public ErrorHandler
{
public:
    void warning(const SAXParseException& e);
    void error(const SAXParseException& e);
    void fatalError(const SAXParseException& e);
    void resetErrors() {};

};

void ParseErrorHandler::error(const SAXParseException& e)
{
    fprintf(stderr, "\nError at file \"%s\", line %d, char %d:  %s\n",
        XMLString::transcode(e.getSystemId()), e.getLineNumber(),
        e.getColumnNumber(), XMLString::transcode(e.getMessage()));
    throw e;

};

void ParseErrorHandler::fatalError(const SAXParseException& e)
{
    fprintf(stderr, "\nFatal Error at file \"%s\", line %d, char %d:  %s\n",
        XMLString::transcode(e.getSystemId()), e.getLineNumber(),
        e.getColumnNumber(), XMLString::transcode(e.getMessage()));
    throw e;
};

void ParseErrorHandler::warning(const SAXParseException& e)
{
    fprintf(stderr, "\nWarning at file \"%s\", line %d, char %d:  %s\n",
        XMLString::transcode(e.getSystemId()), e.getLineNumber(),
        e.getColumnNumber(), XMLString::transcode(e.getMessage()));
    throw e;

};


//------------------------------------------------------------------------
//
//   parseFile  - a simpler to use function for just parsing an XML file
//                and getting the DOM Document back.
//
//------------------------------------------------------------------------
static DOM_Document parseFile(char *fileName)
{
    ParseErrorHandler eh;
    DOMParser parser;
    parser.setDoValidation(false);
    parser.setErrorHandler(&eh);
    try
    {
        parser.parse(fileName);
    }

    catch (const XMLException& e )
    {
		fprintf(stderr, "Exception Occured \"%s\".  \n",
			XMLString::transcode(e.getMessage()));
		fprintf(stderr, "File being parsed is \"%s\".\n", fileName);
        return DOM_Document();  // A null document.
    }

	catch (...)
	{
		fprintf(stderr, "Unexpected Exception thrown during parse of file \"%s\".\n",
		                 fileName);
		return DOM_Document();
	}
    return parser.getDocument();
}


//------------------------------------------------------------------------
//
//  writeUData - Write out a udata xml element for a DOMString contents.
//
//------------------------------------------------------------------------
static void writeUData(const DOMString s)
{
    unsigned int i;
    printf("<udata>\n");
    for (i=0; i<s.length(); i++)
    {
        if (i % 16 == 0)
            printf("\n");
        XMLCh c = s.charAt(i);
        printf("%4x ", c);
    }
    printf("\n</udata>\n");
};



//------------------------------------------------------------------------
//
//  eatWhiteSpace -  DOMStrings are kind of short on utility functions :-(
//
//------------------------------------------------------------------------
static void eatWhiteSpace(DOMString s, unsigned int &i)
{
    while (i < s.length())
    {
    XMLCh c = s.charAt(i);
    if (!(c == 0x20 ||           // These are the official XML space characters,
        c == 0x09 ||             //   expressed as Unicode constants.
        c == 0x0A))
        break;
    i++;
    }
}

//------------------------------------------------------------------------
//
//   convertHexValue     if the DOMString contains a hex number at position i,
//                       convert it and return it, and update i to index the
//                       first char not in the string.
//                       return 0 if string[i] didn't have a hex digit.
//                       0 return is ambiguous, but it doesn't matter for XML,
//                       where 0 is not a valid character.
//
//------------------------------------------------------------------------
static int convertHexValue(DOMString s, unsigned int &i)
{
    int value = 0;

                                   // For reference, the digits  0-9 are Unicode 0x30-39
                                   //                the letters A-F are Unicode 0x41-0x46
                                   //                the letters a-f are Unicode 0x61-66
                                   // We can't use character literals - we might be
                                   //  building on an EBCDIC machine.
    while (i < s.length())
    {
        XMLCh c = s.charAt(i);
        if (c >= 0x61 && c <= 0x66)     // Uppercase a-f to A-F.
            c -= 0x20;

        if (c < 0x30 || c >0x46)        // Stop if not a hex digit
            break;
        if (c > 0x39 && c <0x41)
            break;

        value = value << 4;             // Append this digit to accumulating value
        if (c <= 0x39)
            value += c-0x30;
        else
            value += 0xA + c - 0x41;

        i++;
    }
    return value;
}



//------------------------------------------------------------------------
//
//  processTestFile   Given the file name of an encoding test xml file,
//                    run it.
//
//------------------------------------------------------------------------
static bool  processTestFile(DOMString fileName)
{
    //
    //  Send the input file through the parse, create a DOM document for it.
    //
    char *cFileName = fileName.transcode();
    DOM_Document testDoc = parseFile(fileName.transcode());
    if (testDoc == 0)
        return false;    // parse errors in the source xml.

    //
    //  Pull the "data" element out of the document.
    //
    DOM_NodeList nl = testDoc.getElementsByTagName("data");
    if (nl.getLength() != 1) {
        fprintf(stderr, "Test file \"%s\" must have exactly one \"data\" element.\n", cFileName);
        return false;
    };
    DOM_Node tmpNode = nl.item(0);
    DOM_Element data = (DOM_Element &) tmpNode;


    //
    //  Build up a string containing the character data contents of the data element.
    //
    DOM_Node child;
    DOMString elData;
    for (child=data.getFirstChild(); child != 0; child= child.getNextSibling())
    {
		if (child.getNodeType() == DOM_Node::COMMENT_NODE)
			continue;
        if (! (child.getNodeType() == DOM_Node::TEXT_NODE ||
               child.getNodeType() == DOM_Node::CDATA_SECTION_NODE ||
               child.getNodeType() == DOM_Node::ENTITY_REFERENCE_NODE))
        {
               fprintf(stderr, "Test file \"%s\": data element contains unexpected children.",
                    cFileName);
               return false;
        }
        elData += ((DOM_CharacterData &)child).getData();
    };

    //
    //  Pull the "udata" element out of the document
    //
    nl = testDoc.getElementsByTagName("udata");
    if (nl.getLength() != 1) {
        fprintf(stderr, "Test file \"%s\" must have exactly one \"udata\" element.\n", cFileName);
        return false;
    };
    DOM_Node tmpNode1 = nl.item(0);
    DOM_Element udata = (DOM_Element &) tmpNode1;

    //
    //  Build up a string containing the character data contents of the udata element.
    //  This will consist of a whole bunch hex numbers, still in string from
    //

    DOMString rawUData;
    for (child=udata.getFirstChild(); child != 0; child= child.getNextSibling())
    {
        if (child.getNodeType() == DOM_Node::COMMENT_NODE)
            continue;
        if (! (child.getNodeType() == DOM_Node::TEXT_NODE ||
            child.getNodeType() == DOM_Node::CDATA_SECTION_NODE ||
            child.getNodeType() == DOM_Node::ENTITY_REFERENCE_NODE))
        {
            fprintf(stderr, "Test file \"%s\": udata element contains unexpected children.",
                cFileName);
            return false;
        }
        rawUData += ((DOM_CharacterData &)child).getData();
    };


    //
    // Convert the raw (hex numbers)  form of the udata to the corresponding string.
    //
    DOMString uData;
    unsigned int rawIndex = 0;

    while (rawIndex < rawUData.length())
    {
        eatWhiteSpace(rawUData, rawIndex);
        XMLCh c = convertHexValue(rawUData, rawIndex);
        if (c > 0)
            uData += c;
        else
            if (rawIndex < rawUData.length())
            {
                fprintf(stderr, "Test file \"%s\": Bad hex number in udata element.  "
                    "Data character number %d\n", cFileName, uData.length());
                return false;
            }
    }


    //
    // Compare the two strings.
    //
    unsigned int i;
    for (i=0; i<elData.length(); i++)
    {
        if (i >= uData.length())
        {
            fprintf(stderr, "Test file \"%s\": udata element shorter than data at char number %d\n",
                cFileName, i);
            writeUData(elData);
            return false;
        }
        if (uData.charAt(i) != elData.charAt(i))
        {
            fprintf(stderr, "Test file \"%s\": comparison failure at character number %d\n",
                cFileName, i);
            writeUData(elData);
            return false;
        };
    }

    if (elData.length() != uData.length())
    {
        fprintf(stderr, "Test file \"%s\": udata element longer than data at char number %d\n",
            cFileName, i);
        writeUData(elData);
        return false;
    }


    return true;
}


int main(int argc, char ** argv) {

   //
    // Initialize the Xerces-c environment
    //
	try
    {
        XMLPlatformUtils::Initialize();
    }

    catch (const XMLException& toCatch)
    {
        fprintf(stderr, "Error during initialization of xerces-c: %s\n",
            XMLString::transcode(toCatch.getMessage()));
         return 1;
    }

    //
    // Parse the command line, which should specify exactly one file, which is an
    //   xml file containing the list of test files to be processed.
    //
    if (argc != 2) {
        printf("usage: %s file_name \n"
               "   where file name is the xml file specifying the list of test files.", argv[0]);
        return 1;
    }
    DOM_Document fileListDoc = parseFile(argv[1]);
    if (fileListDoc == 0) return 1;


    //
    // Iterate over the list of files, running each as a test.
    //
    DOM_NodeList list = fileListDoc.getElementsByTagName("testFile");
    int i;
    int numFiles = list.getLength();
    for (i=0; i<numFiles; i++)
    {
        ++gTestsRun;
        DOM_Node tmpNode3 = list.item(i);
        DOMString fileName = ((DOM_Element &) tmpNode3).getAttribute("name");
        if (processTestFile(fileName) == false)
            ++gTestsFailed;
    };



    //
    // We are done.  Print out a summary of the results
    //
    printf("Encoding Tests Results Summary: \n"
           "   %d encoding tests run.\n"
           "   %d tests passed,\n"
           "   %d tests failed\n", gTestsRun, gTestsRun-gTestsFailed, gTestsFailed);

   return 0;
};