/****************************************************************************
**
** Copyright (C) 2009 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