Initial import from the monolithic Qt.

This is the beginning of revision history for this module. If you
want to look at revision history older than this, please refer to the
Qt Git wiki for how to use Git history grafting. At the time of
writing, this wiki is located here:

http://qt.gitorious.org/qt/pages/GitIntroductionWithQt

If you have already performed the grafting and you don't see any
history beyond this commit, try running "git log" with the "--follow"
argument.

Branched from the monolithic repo, Qt master branch, at commit
896db169ea224deb96c59ce8af800d019de63f12

1 files changed, 511 insertions, 0 deletions

diff --git a/tests/auto/xmlpatternssdk/TestBaseLine.cpp b/tests/auto/xmlpatternssdk/TestBaseLine.cpp
new file mode 100644
index 0000000..c54fad3
--- /dev/null
+++ b/tests/auto/xmlpatternssdk/TestBaseLine.cpp
@@ -0,0 +1,511 @@
+/****************************************************************************
+**
+** Copyright (C) 2011 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