1 files changed, 258 insertions, 0 deletions
diff --git a/tests/auto/xmlpatternssdk/Worker.cpp b/tests/auto/xmlpatternssdk/Worker.cpp
new file mode 100644
index 0000000..0121099
--- /dev/null
+++ b/tests/auto/xmlpatternssdk/Worker.cpp
@@ -0,0 +1,258 @@
+/****************************************************************************
+**
+** 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 <QDir>
+#include <QEventLoop>
+#include <QPair>
+#include <QtDebug>
+
+#include "ExitCode.h"
+
+#include "Worker.h"
+
+using namespace QPatternistSDK;
+
+const char *const Worker::m_indent = "        ";
+
+Worker::Worker(QEventLoop &ev,
+               const QFileInfo &baseline,
+               const QFileInfo &result) : m_finishedCount(0)
+                                        , m_baselineFile(baseline)
+                                        , m_resultFile(result)
+                                        , m_eventLoop(ev)
+{
+}
+
+void Worker::list(QTextStream &out, const QString &msg, QStringList &list)
+{
+    Q_ASSERT(!msg.isEmpty());
+
+    if(list.isEmpty())
+        return;
+
+    list.sort(); /* Make it pretty, and easy to read. */
+
+    out << msg << ":\n";
+
+    const QStringList::const_iterator end(list.constEnd());
+    QStringList::const_iterator it(list.constBegin());
+
+    for(; it != end; ++it)
+        out << m_indent << qPrintable(*it) << '\n';
+}
+
+static inline int count(const ResultThreader::Hash &list, const TestResult::Status stat)
+{
+    const ResultThreader::Hash::const_iterator end(list.constEnd());
+    ResultThreader::Hash::const_iterator it(list.constBegin());
+    int result = 0;
+
+    for(; it != end; ++it)
+    {
+        if(it.value() == stat)
+            ++result;
+    }
+
+    return result;
+}
+
+void Worker::threadFinished()
+{
+    ++m_finishedCount;
+    Q_ASSERT(m_finishedCount == 1 || m_finishedCount == 2);
+
+    const ResultThreader *const handler = static_cast<ResultThreader *>(sender());
+    Q_ASSERT(handler);
+
+    switch(handler->type())
+    {
+        case ResultThreader::Baseline:
+        {
+            m_baseline = handler->result();
+            break;
+        }
+        case ResultThreader::Result:
+            m_result = handler->result();
+    }
+
+    if(m_finishedCount == 1) /* One thread's missing. */
+        return;
+
+    /* Ok, both threads have now finished, and we got their results in m_result and m_baseline. */
+
+    /* No matter how this function exits, we want to delete this Worker. */
+    deleteLater();
+
+    ResultThreader::Hash::const_iterator itA(m_result.constBegin());
+    ResultThreader::Hash::const_iterator itB(m_baseline.constBegin());
+    const ResultThreader::Hash::const_iterator endA(m_result.constEnd());
+    const ResultThreader::Hash::const_iterator endB(m_baseline.constEnd());
+    const int baselineCount = m_baseline.count();
+    const int resultCount = m_result.count();
+
+    /* If you want useful output, change the QTextStream to use stderr. */
+    //QTextStream err(stderr);
+    QByteArray out;
+    QTextStream err(&out);
+
+    if(resultCount < baselineCount)
+    {
+        err << qPrintable(QString(QLatin1String("WARNING: Test result contains %1 reports, "
+                                                "but the baseline contains %2, a DECREASE "
+                                                "of %3 tests.\n"))
+                                  .arg(resultCount)
+                                  .arg(baselineCount)
+                                  .arg(resultCount - baselineCount));
+    }
+    else if(resultCount > baselineCount)
+    {
+        err << qPrintable(QString(QLatin1String("NOTE: The number of tests run is more than what "
+                                                "the baseline specifies. Run was %1 test cases, the "
+                                                "baseline specifies %2; an increase of %3 tests.\n"))
+                                  .arg(resultCount)
+                                  .arg(baselineCount)
+                                  .arg(resultCount - baselineCount));
+    }
+
+    for(; itA != endA; ++itA)
+    {
+        const TestResult::Status result = itA.value();
+        const TestResult::Status baseline = m_baseline.value(itA.key());
+
+        if(result == baseline) /* We have no change. */
+        {
+            if(result == TestResult::NotTested)
+                m_notTested.append(itA.key());
+            else
+                continue;
+        }
+        else if(baseline == TestResult::Pass && result == TestResult::Fail)
+            m_unexpectedFailures.append(itA.key());
+        else if(baseline == TestResult::Fail && result == TestResult::Pass)
+            m_unexpectedPasses.append(itA.key());
+    }
+
+    list(err, QLatin1String("Not tested"),           m_notTested);
+    list(err, QLatin1String("Unexpected failures"),  m_unexpectedFailures);
+    list(err, QLatin1String("Unexpected passes"),    m_unexpectedPasses);
+
+    err << "SUMMARY:\n";
+    typedef QPair<QString, int> Info;
+    typedef QList<Info> InfoList;
+    InfoList info;
+
+    const int totFail       = count(m_result, TestResult::Fail);
+    const int totPass       = count(m_result, TestResult::Pass);
+    const int total         = resultCount;
+    const int notTested     = m_notTested.count();
+    const int percentage    = int((static_cast<double>(totPass) / total) * 100);
+
+    Q_ASSERT_X(percentage >= 0 && percentage <= 100, Q_FUNC_INFO,
+               qPrintable(QString(QLatin1String("Percentage was: %1")).arg(percentage)));
+
+    info.append(Info(QLatin1String("Total"),                total));
+    info.append(Info(QLatin1String("Failures"),             totFail));
+    info.append(Info(QLatin1String("Passes"),               totPass));
+    info.append(Info(QLatin1String("Not tested"),           notTested));
+    info.append(Info(QLatin1String("Pass percentage(%)"),   percentage));
+    info.append(Info(QLatin1String("Unexpected failures"),  m_unexpectedFailures.count()));
+    info.append(Info(QLatin1String("Unexpected passes"),    m_unexpectedPasses.count()));
+
+    const InfoList::const_iterator end(info.constEnd());
+    InfoList::const_iterator it(info.constBegin());
+
+    /* List the statistics nicely in a row with padded columns. */
+    for(; it != end; ++it)
+    {
+        const QString result((((*it).first) + QLatin1Char(':')).leftJustified(22, QLatin1Char(' ')));
+        err << m_indent << qPrintable(result) << (*it).second << '\n';
+    }
+
+    if(!m_unexpectedFailures.isEmpty())
+    {
+        err << "FAILURE: Regressions discovered, baseline was not updated.\n";
+        err.flush();
+        QTextStream(stderr) << out;
+        m_eventLoop.exit(ExitCode::Regression);
+        return;
+    }
+    else if(m_unexpectedPasses.isEmpty() && baselineCount == resultCount)
+    {
+        err << "Result was identical to the baseline, baseline was not updated.\n";
+        m_eventLoop.exit(ExitCode::Success);
+        return;
+    }
+
+    /* Ok, we got unexpected successes and no regressions: let's update the baseline. */
+
+    QFile resultFile(m_resultFile.absoluteFilePath());
+
+    /* Remove the old file, otherwise QFile::copy() will fail. */
+    QDir baselineDir(m_baselineFile.absolutePath());
+    baselineDir.remove(m_baselineFile.fileName());
+
+    if(resultFile.copy(m_baselineFile.absoluteFilePath()))
+    {
+        /* Give a detailed message of what's going on. */
+        if(resultCount > baselineCount)
+            err << "More tests was run than specified in the baseline, updating the baseline.\n";
+        else
+            err << "Improvement, the baseline was updated.\n";
+
+        /* We actually flag this as an error, because the new baseline must be submitted. */
+        err.flush();
+        QTextStream(stderr) << out;
+        m_eventLoop.exit(ExitCode::Regression);
+        return;
+    }
+    else
+    {
+        err << qPrintable(QString(QLatin1String("Encountered error when updating "
+                                                "the baseline: %1\n"))
+                                  .arg(resultFile.errorString()));
+        err.flush();
+        QTextStream(stderr) << out;
+        m_eventLoop.exit(ExitCode::WriteError);
+        return;
+    }
+}
+
+// vim: et:ts=4:sw=4:sts=4