path: root/tests/auto/xmlpatternsxqts/lib/TestBaseLine.cpp

/****************************************************************************
**
** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
** All rights reserved.
** Contact: Nokia Corporation (qt-info@nokia.com)
**
** This file is part of the test suite of the Qt Toolkit.
**
** $QT_BEGIN_LICENSE:LGPL$
** No Commercial Usage
** This file contains pre-release code and may not be distributed.
** You may use this file in accordance with the terms and conditions
** contained in the Technology Preview License Agreement accompanying
** this package.
**
** GNU Lesser General Public License Usage
** Alternatively, this file may be used under the terms of the GNU Lesser
** General Public License version 2.1 as published by the Free Software
** Foundation and appearing in the file LICENSE.LGPL included in the
** packaging of this file.  Please review the following information to
** ensure the GNU Lesser General Public License version 2.1 requirements
** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
**
** In addition, as a special exception, Nokia gives you certain additional
** rights.  These rights are described in the Nokia Qt LGPL Exception
** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
**
** If you have questions regarding the use of this file, please contact
** Nokia at qt-info@nokia.com.
**
**
**
**
**
**
**
**
** $QT_END_LICENSE$
**
****************************************************************************/

#include <QDomDocument>
#include <QFile>
#include <QFileInfo>
#include <QRegExp>
#include <QtDebug>
#include <QUrl>
#include <QXmlAttributes>
#include <QXmlSimpleReader>

#include "qdebug_p.h"
#include "XMLWriter.h"

#include "TestBaseLine.h"

using namespace QPatternistSDK;
using namespace QPatternist;

Q_GLOBAL_STATIC_WITH_ARGS(QRegExp, errorRegExp, (QLatin1String("[A-Z]{4}[0-9]{4}")))

TestBaseLine::TestBaseLine(const Type t) : m_type(t)
{
    Q_ASSERT(errorRegExp()->isValid());
}

TestResult::Status TestBaseLine::scan(const QString &serialized,
                                      const TestBaseLine::List &lines)
{
    Q_ASSERT_X(lines.count() >= 1, Q_FUNC_INFO,
               "At least one base line must be passed, otherwise there's nothing "
               "to compare to.");

    const TestBaseLine::List::const_iterator end(lines.constEnd());
    TestBaseLine::List::const_iterator it(lines.constBegin());
    for(; it != end; ++it)
    {
        const TestResult::Status retval((*it)->verify(serialized));

        if(retval == TestResult::Pass || retval == TestResult::NotTested)
            return retval;
    }

    return TestResult::Fail;
}

TestResult::Status TestBaseLine::scanErrors(const ErrorHandler::Message::List &errors,
                                            const TestBaseLine::List &lines)
{
    pDebug() << "TestBaseLine::scanErrors()";

    /* 1. Find the first error in @p errors that's a Patternist
     * error(not warning and not from Qt) and extract the error code. */
    QString errorCode;

    const ErrorHandler::Message::List::const_iterator end(errors.constEnd());
    ErrorHandler::Message::List::const_iterator it(errors.constBegin());
    for(; it != end; ++it)
    {
        if((*it).type() != QtFatalMsg)
            continue;

        errorCode = QUrl((*it).identifier()).fragment();

        pDebug() << "ERR:" << (*it).description();
        /* This is hackish. We have no way of determining whether a Message
         * is actually issued from Patternist, so we try to narrow it down like this. */
        if(errorRegExp()->exactMatch(errorCode))
            break; /* It's an error code. */
        else
            errorCode.clear();
    }

    pDebug() << "Got error code: " << errorCode;
    /* 2. Loop through @p lines, and for the first base line
     * which is of type ExpectedError and which matches @p errorCode
     * return Pass, otherwise Fail. */
    const TestBaseLine::List::const_iterator blend(lines.constEnd());
    TestBaseLine::List::const_iterator blit(lines.constBegin());
    for(; blit != blend; ++blit)
    {
        const Type t = (*blit)->type();

        if(t == TestBaseLine::ExpectedError)
        {
            const QString d((*blit)->details());
            if(d == errorCode || d == QChar::fromLatin1('*'))
                return TestResult::Pass;
        }
    }

    return TestResult::Fail;
}

void TestBaseLine::toXML(XMLWriter &receiver) const
{
    switch(m_type)
    {
        case XML: /* Fallthrough. */
        case Fragment: /* Fallthrough. */
        case SchemaIsValid: /* Fallthrough. */
        case Text:
        {
            QXmlAttributes inspectAtts;
            inspectAtts.append(QLatin1String("role"), QString(),
                               QLatin1String("role"), QLatin1String("principal"));
            inspectAtts.append(QLatin1String("compare"), QString(),
                               QLatin1String("compare"), displayName(m_type));
            receiver.startElement(QLatin1String("output-file"), inspectAtts);
            receiver.characters(m_details);
            receiver.endElement(QLatin1String("output-file"));
            return;
        }
        case Ignore:
        {
            Q_ASSERT_X(false, Q_FUNC_INFO, "Serializing 'Ignore' is not implemented.");
            return;
        }
        case Inspect:
        {
            QXmlAttributes inspectAtts;
            inspectAtts.append(QLatin1String("role"), QString(),
                               QLatin1String("role"), QLatin1String("principal"));
            inspectAtts.append(QLatin1String("compare"), QString(),
                               QLatin1String("compare"), QLatin1String("Inspect"));
            receiver.startElement(QLatin1String("output-file"), inspectAtts);
            receiver.characters(m_details);
            receiver.endElement(QLatin1String("output-file"));
            return;
        }
        case ExpectedError:
        {
            receiver.startElement(QLatin1String("expected-error"));
            receiver.characters(m_details);
            receiver.endElement(QLatin1String("expected-error"));
            return;
        }
    }
}

bool TestBaseLine::isChildrenDeepEqual(const QDomNodeList &cl1, const QDomNodeList &cl2)
{
    const unsigned int len = cl1.length();

    if(len == cl2.length())
    {
        for(unsigned int i = 0; i < len; ++i)
        {
            if(!isDeepEqual(cl1.at(i), cl2.at(i)))
                return false;
        }

        return true;
    }
    else
        return false;
}

bool TestBaseLine::isAttributesEqual(const QDomNamedNodeMap &cl1, const QDomNamedNodeMap &cl2)
{
    const unsigned int len = cl1.length();
    pDebug() << "LEN:" << len;

    if(len == cl2.length())
    {
        for(unsigned int i1 = 0; i1 < len; ++i1)
        {
            const QDomNode attr1(cl1.item(i1));
            Q_ASSERT(!attr1.isNull());

            /* This is set if attr1 cannot be found at all in cl2. */
            bool earlyExit = false;

            for(unsigned int i2 = 0; i2 < len; ++i2)
            {
                const QDomNode attr2(cl2.item(i2));
                Q_ASSERT(!attr2.isNull());
                pDebug() << "ATTR1:" << attr1.localName() << attr1.namespaceURI() << attr1.prefix() << attr1.nodeName();
                pDebug() << "ATTR2:" << attr2.localName() << attr2.namespaceURI() << attr2.prefix() << attr2.nodeName();

                if(attr1.localName() == attr2.localName()       &&
                   attr1.namespaceURI() == attr2.namespaceURI() &&
                   attr1.prefix() == attr2.prefix()             &&
                   attr1.nodeName() == attr2.nodeName()         && /* Yes, needed in addition to all the other. */
                   attr1.nodeValue() == attr2.nodeValue())
                {
                    earlyExit = true;
                    break;
                }
            }

            if(!earlyExit)
            {
                /* An attribute was found that doesn't exist in the other list so exit. */
                return false;
            }
        }

        return true;
    }
    else
        return false;
}

bool TestBaseLine::isDeepEqual(const QDomNode &n1, const QDomNode &n2)
{
    if(n1.nodeType() != n2.nodeType())
        return false;

    switch(n1.nodeType())
    {
        case QDomNode::CommentNode:
        /* Fallthrough. */
        case QDomNode::TextNode:
        {
            return static_cast<const QDomCharacterData &>(n1).data() ==
                   static_cast<const QDomCharacterData &>(n2).data();
        }
        case QDomNode::ProcessingInstructionNode:
        {
            return n1.nodeName() == n2.nodeName() &&
                   n1.nodeValue() == n2.nodeValue();
        }
        case QDomNode::DocumentNode:
            return isChildrenDeepEqual(n1.childNodes(), n2.childNodes());
        case QDomNode::ElementNode:
        {
            return n1.localName() == n2.localName()                     &&
                   n1.namespaceURI() == n2.namespaceURI()               &&
                   n1.nodeName() == n2.nodeName()                       && /* Yes, this one is needed in addition to localName(). */
                   isAttributesEqual(n1.attributes(), n2.attributes())  &&
                   isChildrenDeepEqual(n1.childNodes(), n2.childNodes());
        }
        /* Fallthrough all these. */
        case QDomNode::EntityReferenceNode:
        case QDomNode::CDATASectionNode:
        case QDomNode::EntityNode:
        case QDomNode::DocumentTypeNode:
        case QDomNode::DocumentFragmentNode:
        case QDomNode::NotationNode:
        case QDomNode::BaseNode:
        case QDomNode::CharacterDataNode:
        {
            Q_ASSERT_X(false, Q_FUNC_INFO,
                       "An unsupported node type was encountered.");
            return false;
        }
        case QDomNode::AttributeNode:
        {
            Q_ASSERT_X(false, Q_FUNC_INFO,
                       "This should never happen. QDom doesn't allow us to compare DOM attributes "
                       "properly.");
            return false;
        }
        default:
        {
            Q_ASSERT_X(false, Q_FUNC_INFO, "Unhandled QDom::NodeType value.");
            return false;
        }
    }
}

TestResult::Status TestBaseLine::verify(const QString &serializedInput) const
{
    switch(m_type)
    {
        case SchemaIsValid:
        /* Fall through. */
        case Text:
        {
            if(serializedInput == details())
                return TestResult::Pass;
            else
                return TestResult::Fail;
        }
        case Fragment:
        /* Fall through. */
        case XML:
        {
            /* Read the baseline and the serialized input into two QDomDocuments, and compare
             * them deeply. We wrap fragments in a root node such that it is well-formed XML.
             */

            QDomDocument output;
            {
                /* The reason we put things into a QByteArray and then parse it through QXmlSimpleReader, is that
                 * QDomDocument does whitespace stripping when calling setContent(QString). In other words,
                 * this workarounds a bug. */

                QXmlInputSource source;
                source.setData((m_type == XML ? serializedInput : QLatin1String("<r>") +
                                                                  serializedInput +
                                                                  QLatin1String("</r>")).toUtf8());

                QString outputReadingError;

                QXmlSimpleReader reader;
                reader.setFeature(QLatin1String("http://xml.org/sax/features/namespace-prefixes"), true);

                const bool success = output.setContent(&source,
                                                       &reader,
                                                       &outputReadingError);

                if(!success)
                    return TestResult::Fail;

                Q_ASSERT(success);
            }

            QDomDocument baseline;
            {
                QXmlInputSource source;
                source.setData((m_type == XML ? details() : QLatin1String("<r>") +
                                                            details() +
                                                            QLatin1String("</r>")).toUtf8());
                QString baselineReadingError;

                QXmlSimpleReader reader;
                reader.setFeature(QLatin1String("http://xml.org/sax/features/namespace-prefixes"), true);

                const bool success = baseline.setContent(&source,
                                                         &reader,
                                                         &baselineReadingError);

                if(!success)
                    return TestResult::Fail;

                /* This piece of code workaround a bug in QDom, which treats XML prologs as processing
                 * instructions and make them available in the tree as so. */
                if(m_type == XML)
                {
                    /* $doc/r/node() */
                    const QDomNodeList children(baseline.childNodes());
                    const int len = children.length();

                    for(int i = 0; i < len; ++i)
                    {
                        const QDomNode &child = children.at(i);
                        if(child.isProcessingInstruction() && child.nodeName() == QLatin1String("xml"))
                        {
                            baseline.removeChild(child);
                            break;
                        }
                    }
                }

                Q_ASSERT_X(baselineReadingError.isNull(), Q_FUNC_INFO,
                           qPrintable((QLatin1String("Reading the baseline failed: ") + baselineReadingError)));
            }

            if(isDeepEqual(output, baseline))
                return TestResult::Pass;
            else
            {
                pDebug() << "FAILURE:" << output.toString() << "is NOT IDENTICAL to(baseline):" << baseline.toString();
                return TestResult::Fail;
            }
        }
        case Ignore:
            return TestResult::Pass;
        case Inspect:
            return TestResult::NotTested;
        case ExpectedError:
        {
            /* This function is only called for Text/XML/Fragment tests. */
            return TestResult::Fail;
        }
    }
    Q_ASSERT(false);
    return TestResult::Fail;
}

TestBaseLine::Type TestBaseLine::identifierFromString(const QString &string)
{
    /* "html-output: Using an ad hoc tool, it must assert that the document obeys the HTML
     * Output Method as defined in the Serialization specification and section
     * 20 of the XSLT 2.0 specification." We treat it as XML for now, same with
     * xhtml-output. */
    if(string.compare(QLatin1String("XML"), Qt::CaseInsensitive) == 0 ||
       string == QLatin1String("html-output") ||
       string == QLatin1String("xml-output") ||
       string == QLatin1String("xhtml-output"))
        return XML;
    else if(string == QLatin1String("Fragment") || string == QLatin1String("xml-frag"))
        return Fragment;
    else if(string.compare(QLatin1String("Text"), Qt::CaseInsensitive) == 0)
        return Text;
    else if(string == QLatin1String("Ignore"))
        return Ignore;
    else if(string.compare(QLatin1String("Inspect"), Qt::CaseInsensitive) == 0)
        return Inspect;
    else
    {
        Q_ASSERT_X(false, Q_FUNC_INFO,
                   qPrintable(QString::fromLatin1("Invalid string representation for a comparation type: %1").arg(string)));

        return Ignore; /* Silence GCC. */
    }
}

QString TestBaseLine::displayName(const Type id)
{
    switch(id)
    {
        case XML:
            return QLatin1String("XML");
        case Fragment:
            return QLatin1String("Fragment");
        case Text:
            return QLatin1String("Text");
        case Ignore:
            return QLatin1String("Ignore");
        case Inspect:
            return QLatin1String("Inspect");
        case ExpectedError:
            return QLatin1String("ExpectedError");
        case SchemaIsValid:
            return QLatin1String("SchemaIsValid");
    }

    Q_ASSERT(false);
    return QString();
}

QString TestBaseLine::details() const
{
    if(m_type == Ignore) /* We're an error code. */
        return QString();
    if(m_type == ExpectedError) /* We're an error code. */
        return m_details;
    if(m_type == SchemaIsValid) /* We're a schema validation information . */
        return m_details;

    if(m_details.isEmpty())
        return m_details;

    /* m_details is a file name, we open it and return the result. */
    QFile file(QUrl(m_details).toLocalFile());

    QString retval;
    if(!file.exists())
        retval = QString::fromLatin1("%1 does not exist.").arg(file.fileName());
    else if(!QFileInfo(file.fileName()).isFile())
        retval = QString::fromLatin1("%1 is not a file, cannot display it.").arg(file.fileName());
    else if(!file.open(QIODevice::ReadOnly | QIODevice::Text))
        retval = QString::fromLatin1("Could not open %1. Likely a permission error.").arg(file.fileName());

    if(retval.isNull())
    {
        /* Scary, we assume the query/baseline is in UTF-8. */
        return QString::fromUtf8(file.readAll());
    }
    else
    {
        /* We had a file error. */
        retval.prepend(QLatin1String("Test-suite harness error: "));
        qCritical() << retval;
        return retval;
    }
}

TestBaseLine::Type TestBaseLine::type() const
{
    return m_type;
}

void TestBaseLine::setDetails(const QString &detailsP)
{
    m_details = detailsP;
}

// vim: et:ts=4:sw=4:sts=4