2011-04-27 10:05:43 +00:00
|
|
|
/****************************************************************************
|
|
|
|
**
|
2012-09-19 12:28:29 +00:00
|
|
|
** Copyright (C) 2012 Digia Plc and/or its subsidiary(-ies).
|
|
|
|
** Contact: http://www.qt-project.org/legal
|
2011-04-27 10:05:43 +00:00
|
|
|
**
|
|
|
|
** This file is part of the test suite of the Qt Toolkit.
|
|
|
|
**
|
|
|
|
** $QT_BEGIN_LICENSE:LGPL$
|
2012-09-19 12:28:29 +00:00
|
|
|
** Commercial License Usage
|
|
|
|
** Licensees holding valid commercial Qt licenses may use this file in
|
|
|
|
** accordance with the commercial license agreement provided with the
|
|
|
|
** Software or, alternatively, in accordance with the terms contained in
|
|
|
|
** a written agreement between you and Digia. For licensing terms and
|
|
|
|
** conditions see http://qt.digia.com/licensing. For further information
|
|
|
|
** use the contact form at http://qt.digia.com/contact-us.
|
|
|
|
**
|
2011-04-27 10:05:43 +00:00
|
|
|
** GNU Lesser General Public License Usage
|
2012-09-19 12:28:29 +00:00
|
|
|
** 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.
|
2011-04-27 10:05:43 +00:00
|
|
|
**
|
2012-09-19 12:28:29 +00:00
|
|
|
** In addition, as a special exception, Digia gives you certain additional
|
|
|
|
** rights. These rights are described in the Digia Qt LGPL Exception
|
2011-04-27 10:05:43 +00:00
|
|
|
** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
|
|
|
|
**
|
2011-05-24 09:34:08 +00:00
|
|
|
** GNU General Public License Usage
|
2012-09-19 12:28:29 +00:00
|
|
|
** Alternatively, this file may be used under the terms of the GNU
|
|
|
|
** General Public License version 3.0 as published by the Free Software
|
|
|
|
** Foundation and appearing in the file LICENSE.GPL included in the
|
|
|
|
** packaging of this file. Please review the following information to
|
|
|
|
** ensure the GNU General Public License version 3.0 requirements will be
|
|
|
|
** met: http://www.gnu.org/copyleft/gpl.html.
|
2011-04-27 10:05:43 +00:00
|
|
|
**
|
2012-01-24 06:17:24 +00:00
|
|
|
**
|
2011-04-27 10:05:43 +00:00
|
|
|
** $QT_END_LICENSE$
|
|
|
|
**
|
|
|
|
****************************************************************************/
|
|
|
|
|
2012-01-10 00:28:42 +00:00
|
|
|
#include <QtCore/QCoreApplication>
|
2011-08-11 13:17:40 +00:00
|
|
|
#include <QtCore/QXmlStreamReader>
|
2011-12-13 16:08:45 +00:00
|
|
|
#include <QtCore/QFileInfo>
|
|
|
|
#include <QtCore/QDir>
|
2012-05-29 00:58:41 +00:00
|
|
|
#include <QtCore/QTemporaryDir>
|
2011-12-13 16:08:45 +00:00
|
|
|
#include <QtTest/QtTest>
|
|
|
|
|
2011-04-27 10:05:43 +00:00
|
|
|
#include <private/cycle_p.h>
|
|
|
|
|
2012-05-29 00:58:41 +00:00
|
|
|
struct LoggerSet;
|
|
|
|
|
2011-04-27 10:05:43 +00:00
|
|
|
class tst_Selftests: public QObject
|
|
|
|
{
|
|
|
|
Q_OBJECT
|
2012-05-29 00:58:41 +00:00
|
|
|
public:
|
|
|
|
tst_Selftests();
|
|
|
|
|
2011-04-27 10:05:43 +00:00
|
|
|
private slots:
|
2011-12-13 16:08:45 +00:00
|
|
|
void initTestCase();
|
2011-04-27 10:05:43 +00:00
|
|
|
void runSubTest_data();
|
|
|
|
void runSubTest();
|
2011-09-16 05:03:44 +00:00
|
|
|
void cleanup();
|
2011-04-27 10:05:43 +00:00
|
|
|
|
|
|
|
private:
|
2011-09-21 01:39:07 +00:00
|
|
|
void doRunSubTest(QString const& subdir, QStringList const& loggers, QStringList const& arguments);
|
2012-05-29 00:58:41 +00:00
|
|
|
QString logName(const QString &logger) const;
|
|
|
|
QList<LoggerSet> allLoggerSets() const;
|
|
|
|
|
|
|
|
QTemporaryDir tempDir;
|
2011-04-27 10:05:43 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
struct BenchmarkResult
|
|
|
|
{
|
|
|
|
qint64 total;
|
|
|
|
qint64 iterations;
|
|
|
|
QString unit;
|
|
|
|
|
|
|
|
inline QString toString() const
|
|
|
|
{ return QString("total:%1, unit:%2, iterations:%3").arg(total).arg(unit).arg(iterations); }
|
|
|
|
|
|
|
|
static BenchmarkResult parse(QString const&, QString*);
|
|
|
|
};
|
|
|
|
|
|
|
|
QT_BEGIN_NAMESPACE
|
|
|
|
namespace QTest
|
|
|
|
{
|
|
|
|
template <>
|
|
|
|
inline bool qCompare
|
|
|
|
(BenchmarkResult const &r1, BenchmarkResult const &r2,
|
|
|
|
const char* actual, const char* expected, const char* file, int line)
|
|
|
|
{
|
|
|
|
// First make sure the iterations and unit match.
|
|
|
|
if (r1.iterations != r2.iterations || r1.unit != r2.unit) {
|
2011-09-16 04:42:51 +00:00
|
|
|
// Nope - compare whole string for best failure message
|
2011-04-27 10:05:43 +00:00
|
|
|
return qCompare(r1.toString(), r2.toString(), actual, expected, file, line);
|
|
|
|
}
|
|
|
|
|
2011-09-16 04:42:51 +00:00
|
|
|
// Now check the value. Some variance is allowed, and how much depends on
|
|
|
|
// the measured unit.
|
2011-04-27 10:05:43 +00:00
|
|
|
qreal variance = 0.;
|
|
|
|
if (r1.unit == "msec") {
|
|
|
|
variance = 0.1;
|
|
|
|
}
|
|
|
|
else if (r1.unit == "instruction reads") {
|
|
|
|
variance = 0.001;
|
|
|
|
}
|
|
|
|
else if (r1.unit == "ticks") {
|
|
|
|
variance = 0.001;
|
|
|
|
}
|
|
|
|
if (variance == 0.) {
|
2011-09-16 04:42:51 +00:00
|
|
|
// No variance allowed - compare whole string
|
2011-04-27 10:05:43 +00:00
|
|
|
return qCompare(r1.toString(), r2.toString(), actual, expected, file, line);
|
|
|
|
}
|
|
|
|
|
|
|
|
if (qAbs(qreal(r1.total) - qreal(r2.total)) <= qreal(r1.total)*variance) {
|
2012-02-29 05:43:42 +00:00
|
|
|
return compare_helper(true, 0, 0, 0, actual, expected, file, line);
|
2011-04-27 10:05:43 +00:00
|
|
|
}
|
|
|
|
|
2011-09-16 04:42:51 +00:00
|
|
|
// Whoops, didn't match. Compare the whole string for the most useful failure message.
|
2011-04-27 10:05:43 +00:00
|
|
|
return qCompare(r1.toString(), r2.toString(), actual, expected, file, line);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
QT_END_NAMESPACE
|
|
|
|
|
2011-09-16 04:42:51 +00:00
|
|
|
// Split the passed block of text into an array of lines, replacing any
|
|
|
|
// filenames and line numbers with generic markers to avoid failing the test
|
|
|
|
// due to compiler-specific behaviour.
|
2011-04-27 10:05:43 +00:00
|
|
|
static QList<QByteArray> splitLines(QByteArray ba)
|
|
|
|
{
|
|
|
|
ba.replace('\r', "");
|
|
|
|
QList<QByteArray> out = ba.split('\n');
|
|
|
|
|
|
|
|
// Replace any ` file="..."' or ` line="..."' in XML with a generic location.
|
|
|
|
static const char *markers[][2] = {
|
|
|
|
{ " file=\"", " file=\"__FILE__\"" },
|
|
|
|
{ " line=\"", " line=\"__LINE__\"" }
|
|
|
|
};
|
|
|
|
static const int markerCount = sizeof markers / sizeof markers[0];
|
|
|
|
|
|
|
|
for (int i = 0; i < out.size(); ++i) {
|
|
|
|
QByteArray& line = out[i];
|
|
|
|
for (int j = 0; j < markerCount; ++j) {
|
|
|
|
int index = line.indexOf(markers[j][0]);
|
|
|
|
if (index == -1) {
|
|
|
|
continue;
|
|
|
|
}
|
2012-04-02 12:22:04 +00:00
|
|
|
const int end = line.indexOf('"', index + int(strlen(markers[j][0])));
|
2011-04-27 10:05:43 +00:00
|
|
|
if (end == -1) {
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
line.replace(index, end-index + 1, markers[j][1]);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return out;
|
|
|
|
}
|
|
|
|
|
2011-09-21 01:39:07 +00:00
|
|
|
// Return the log format, e.g. for both "stdout txt" and "txt", return "txt'.
|
|
|
|
static inline QString logFormat(const QString &logger)
|
|
|
|
{
|
|
|
|
return (logger.startsWith("stdout") ? logger.mid(7) : logger);
|
|
|
|
}
|
|
|
|
|
|
|
|
// Return the log file name, or an empty string if the log goes to stdout.
|
2012-05-29 00:58:41 +00:00
|
|
|
QString tst_Selftests::logName(const QString &logger) const
|
2011-09-21 01:39:07 +00:00
|
|
|
{
|
2012-05-29 00:58:41 +00:00
|
|
|
return (logger.startsWith("stdout") ? "" : QString(tempDir.path() + "/test_output." + logger));
|
2011-09-21 01:39:07 +00:00
|
|
|
}
|
|
|
|
|
2011-09-16 04:42:51 +00:00
|
|
|
// Load the expected test output for the nominated test (subdir) and logger
|
|
|
|
// as an array of lines. If there is no expected output file, return an
|
|
|
|
// empty array.
|
2011-04-27 10:05:43 +00:00
|
|
|
static QList<QByteArray> expectedResult(const QString &subdir, const QString &logger)
|
|
|
|
{
|
2011-09-21 01:39:07 +00:00
|
|
|
QFile file(":/expected_" + subdir + "." + logFormat(logger));
|
2011-04-27 10:05:43 +00:00
|
|
|
if (!file.open(QIODevice::ReadOnly))
|
|
|
|
return QList<QByteArray>();
|
|
|
|
return splitLines(file.readAll());
|
|
|
|
}
|
|
|
|
|
2011-09-21 01:39:07 +00:00
|
|
|
// Each test is run with a set of one or more test output loggers.
|
|
|
|
// This struct holds information about one such test.
|
|
|
|
struct LoggerSet
|
2011-04-27 10:05:43 +00:00
|
|
|
{
|
2011-09-21 01:39:07 +00:00
|
|
|
LoggerSet(QString const& _name, QStringList const& _loggers, QStringList const& _arguments)
|
|
|
|
: name(_name), loggers(_loggers), arguments(_arguments)
|
|
|
|
{ }
|
2011-04-27 10:05:43 +00:00
|
|
|
|
|
|
|
QString name;
|
2011-09-21 01:39:07 +00:00
|
|
|
QStringList loggers;
|
2011-04-27 10:05:43 +00:00
|
|
|
QStringList arguments;
|
|
|
|
};
|
|
|
|
|
2011-09-21 01:39:07 +00:00
|
|
|
// This function returns a list of all sets of loggers to be used for
|
|
|
|
// running each subtest.
|
2012-05-29 00:58:41 +00:00
|
|
|
QList<LoggerSet> tst_Selftests::allLoggerSets() const
|
2011-04-27 10:05:43 +00:00
|
|
|
{
|
Allow tests to log to multiple destinations
Each destination and the format of output to write there is specified by
adding "-o filename,format" to the command-line. The special filename
"-" indicates that the log output is written to the standard output
stream, though standard output can be used as a destination at most
once.
The old-style testlib output options are still supported, but can only
be used to specify one logging destination, as before.
If no logging options are given on the command-line, a plain text log
will go to the console, as before.
To log to the console in plain text and to the file "test_output" in
xunit format, one would invoke a test in the following way:
tst_foo -o test_output,xunitxml -o -,txt
This commit also enhances the selftests to test with multiple loggers,
but negative tests (e.g. bad combinations of command-line options) are
left for future task QTBUG-21567.
Task-number: QTBUG-20615
Change-Id: If91e752bc7001657e15e427aba9d25ab0a29a0b0
Reviewed-on: http://codereview.qt-project.org/4125
Reviewed-by: Qt Sanity Bot <qt_sanity_bot@ovi.com>
Reviewed-by: Rohan McGovern <rohan.mcgovern@nokia.com>
2011-09-02 09:08:21 +00:00
|
|
|
// Note that in order to test XML output to standard output, the subtests
|
|
|
|
// must not send output directly to stdout, bypassing Qt's output mechanisms
|
|
|
|
// (e.g. via printf), otherwise the output may not be well-formed XML.
|
2011-09-21 01:39:07 +00:00
|
|
|
return QList<LoggerSet>()
|
Allow tests to log to multiple destinations
Each destination and the format of output to write there is specified by
adding "-o filename,format" to the command-line. The special filename
"-" indicates that the log output is written to the standard output
stream, though standard output can be used as a destination at most
once.
The old-style testlib output options are still supported, but can only
be used to specify one logging destination, as before.
If no logging options are given on the command-line, a plain text log
will go to the console, as before.
To log to the console in plain text and to the file "test_output" in
xunit format, one would invoke a test in the following way:
tst_foo -o test_output,xunitxml -o -,txt
This commit also enhances the selftests to test with multiple loggers,
but negative tests (e.g. bad combinations of command-line options) are
left for future task QTBUG-21567.
Task-number: QTBUG-20615
Change-Id: If91e752bc7001657e15e427aba9d25ab0a29a0b0
Reviewed-on: http://codereview.qt-project.org/4125
Reviewed-by: Qt Sanity Bot <qt_sanity_bot@ovi.com>
Reviewed-by: Rohan McGovern <rohan.mcgovern@nokia.com>
2011-09-02 09:08:21 +00:00
|
|
|
// Test with old-style options for a single logger
|
|
|
|
<< LoggerSet("old stdout txt",
|
2011-09-21 01:39:07 +00:00
|
|
|
QStringList() << "stdout txt",
|
Allow tests to log to multiple destinations
Each destination and the format of output to write there is specified by
adding "-o filename,format" to the command-line. The special filename
"-" indicates that the log output is written to the standard output
stream, though standard output can be used as a destination at most
once.
The old-style testlib output options are still supported, but can only
be used to specify one logging destination, as before.
If no logging options are given on the command-line, a plain text log
will go to the console, as before.
To log to the console in plain text and to the file "test_output" in
xunit format, one would invoke a test in the following way:
tst_foo -o test_output,xunitxml -o -,txt
This commit also enhances the selftests to test with multiple loggers,
but negative tests (e.g. bad combinations of command-line options) are
left for future task QTBUG-21567.
Task-number: QTBUG-20615
Change-Id: If91e752bc7001657e15e427aba9d25ab0a29a0b0
Reviewed-on: http://codereview.qt-project.org/4125
Reviewed-by: Qt Sanity Bot <qt_sanity_bot@ovi.com>
Reviewed-by: Rohan McGovern <rohan.mcgovern@nokia.com>
2011-09-02 09:08:21 +00:00
|
|
|
QStringList()
|
|
|
|
)
|
|
|
|
<< LoggerSet("old txt",
|
2011-09-21 01:39:07 +00:00
|
|
|
QStringList() << "txt",
|
Allow tests to log to multiple destinations
Each destination and the format of output to write there is specified by
adding "-o filename,format" to the command-line. The special filename
"-" indicates that the log output is written to the standard output
stream, though standard output can be used as a destination at most
once.
The old-style testlib output options are still supported, but can only
be used to specify one logging destination, as before.
If no logging options are given on the command-line, a plain text log
will go to the console, as before.
To log to the console in plain text and to the file "test_output" in
xunit format, one would invoke a test in the following way:
tst_foo -o test_output,xunitxml -o -,txt
This commit also enhances the selftests to test with multiple loggers,
but negative tests (e.g. bad combinations of command-line options) are
left for future task QTBUG-21567.
Task-number: QTBUG-20615
Change-Id: If91e752bc7001657e15e427aba9d25ab0a29a0b0
Reviewed-on: http://codereview.qt-project.org/4125
Reviewed-by: Qt Sanity Bot <qt_sanity_bot@ovi.com>
Reviewed-by: Rohan McGovern <rohan.mcgovern@nokia.com>
2011-09-02 09:08:21 +00:00
|
|
|
QStringList() << "-o" << logName("txt")
|
|
|
|
)
|
|
|
|
<< LoggerSet("old stdout xml",
|
|
|
|
QStringList() << "stdout xml",
|
|
|
|
QStringList() << "-xml"
|
|
|
|
)
|
|
|
|
<< LoggerSet("old xml",
|
2011-09-21 01:39:07 +00:00
|
|
|
QStringList() << "xml",
|
Allow tests to log to multiple destinations
Each destination and the format of output to write there is specified by
adding "-o filename,format" to the command-line. The special filename
"-" indicates that the log output is written to the standard output
stream, though standard output can be used as a destination at most
once.
The old-style testlib output options are still supported, but can only
be used to specify one logging destination, as before.
If no logging options are given on the command-line, a plain text log
will go to the console, as before.
To log to the console in plain text and to the file "test_output" in
xunit format, one would invoke a test in the following way:
tst_foo -o test_output,xunitxml -o -,txt
This commit also enhances the selftests to test with multiple loggers,
but negative tests (e.g. bad combinations of command-line options) are
left for future task QTBUG-21567.
Task-number: QTBUG-20615
Change-Id: If91e752bc7001657e15e427aba9d25ab0a29a0b0
Reviewed-on: http://codereview.qt-project.org/4125
Reviewed-by: Qt Sanity Bot <qt_sanity_bot@ovi.com>
Reviewed-by: Rohan McGovern <rohan.mcgovern@nokia.com>
2011-09-02 09:08:21 +00:00
|
|
|
QStringList() << "-xml" << "-o" << logName("xml")
|
|
|
|
)
|
|
|
|
<< LoggerSet("old stdout xunitxml",
|
|
|
|
QStringList() << "stdout xunitxml",
|
|
|
|
QStringList() << "-xunitxml"
|
|
|
|
)
|
|
|
|
<< LoggerSet("old xunitxml",
|
2011-09-21 01:39:07 +00:00
|
|
|
QStringList() << "xunitxml",
|
Allow tests to log to multiple destinations
Each destination and the format of output to write there is specified by
adding "-o filename,format" to the command-line. The special filename
"-" indicates that the log output is written to the standard output
stream, though standard output can be used as a destination at most
once.
The old-style testlib output options are still supported, but can only
be used to specify one logging destination, as before.
If no logging options are given on the command-line, a plain text log
will go to the console, as before.
To log to the console in plain text and to the file "test_output" in
xunit format, one would invoke a test in the following way:
tst_foo -o test_output,xunitxml -o -,txt
This commit also enhances the selftests to test with multiple loggers,
but negative tests (e.g. bad combinations of command-line options) are
left for future task QTBUG-21567.
Task-number: QTBUG-20615
Change-Id: If91e752bc7001657e15e427aba9d25ab0a29a0b0
Reviewed-on: http://codereview.qt-project.org/4125
Reviewed-by: Qt Sanity Bot <qt_sanity_bot@ovi.com>
Reviewed-by: Rohan McGovern <rohan.mcgovern@nokia.com>
2011-09-02 09:08:21 +00:00
|
|
|
QStringList() << "-xunitxml" << "-o" << logName("xunitxml")
|
|
|
|
)
|
|
|
|
<< LoggerSet("old stdout lightxml",
|
|
|
|
QStringList() << "stdout lightxml",
|
|
|
|
QStringList() << "-lightxml"
|
|
|
|
)
|
|
|
|
<< LoggerSet("old lightxml",
|
2011-09-21 01:39:07 +00:00
|
|
|
QStringList() << "lightxml",
|
Allow tests to log to multiple destinations
Each destination and the format of output to write there is specified by
adding "-o filename,format" to the command-line. The special filename
"-" indicates that the log output is written to the standard output
stream, though standard output can be used as a destination at most
once.
The old-style testlib output options are still supported, but can only
be used to specify one logging destination, as before.
If no logging options are given on the command-line, a plain text log
will go to the console, as before.
To log to the console in plain text and to the file "test_output" in
xunit format, one would invoke a test in the following way:
tst_foo -o test_output,xunitxml -o -,txt
This commit also enhances the selftests to test with multiple loggers,
but negative tests (e.g. bad combinations of command-line options) are
left for future task QTBUG-21567.
Task-number: QTBUG-20615
Change-Id: If91e752bc7001657e15e427aba9d25ab0a29a0b0
Reviewed-on: http://codereview.qt-project.org/4125
Reviewed-by: Qt Sanity Bot <qt_sanity_bot@ovi.com>
Reviewed-by: Rohan McGovern <rohan.mcgovern@nokia.com>
2011-09-02 09:08:21 +00:00
|
|
|
QStringList() << "-lightxml" << "-o" << logName("lightxml")
|
|
|
|
)
|
|
|
|
// Test with new-style options for a single logger
|
|
|
|
<< LoggerSet("new stdout txt",
|
|
|
|
QStringList() << "stdout txt",
|
|
|
|
QStringList() << "-o" << "-,txt"
|
|
|
|
)
|
|
|
|
<< LoggerSet("new txt",
|
|
|
|
QStringList() << "txt",
|
|
|
|
QStringList() << "-o" << logName("txt")+",txt"
|
|
|
|
)
|
|
|
|
<< LoggerSet("new stdout xml",
|
|
|
|
QStringList() << "stdout xml",
|
|
|
|
QStringList() << "-o" << "-,xml"
|
|
|
|
)
|
|
|
|
<< LoggerSet("new xml",
|
|
|
|
QStringList() << "xml",
|
|
|
|
QStringList() << "-o" << logName("xml")+",xml"
|
|
|
|
)
|
|
|
|
<< LoggerSet("new stdout xunitxml",
|
|
|
|
QStringList() << "stdout xunitxml",
|
|
|
|
QStringList() << "-o" << "-,xunitxml"
|
|
|
|
)
|
|
|
|
<< LoggerSet("new xunitxml",
|
|
|
|
QStringList() << "xunitxml",
|
|
|
|
QStringList() << "-o" << logName("xunitxml")+",xunitxml"
|
|
|
|
)
|
|
|
|
<< LoggerSet("new stdout lightxml",
|
|
|
|
QStringList() << "stdout lightxml",
|
|
|
|
QStringList() << "-o" << "-,lightxml"
|
|
|
|
)
|
|
|
|
<< LoggerSet("new lightxml",
|
|
|
|
QStringList() << "lightxml",
|
|
|
|
QStringList() << "-o" << logName("lightxml")+",lightxml"
|
|
|
|
)
|
|
|
|
// Test with two loggers (don't test all 32 combinations, just a sample)
|
|
|
|
<< LoggerSet("stdout txt + txt",
|
|
|
|
QStringList() << "stdout txt" << "txt",
|
|
|
|
QStringList() << "-o" << "-,txt"
|
|
|
|
<< "-o" << logName("txt")+",txt"
|
|
|
|
)
|
|
|
|
<< LoggerSet("xml + stdout txt",
|
|
|
|
QStringList() << "xml" << "stdout txt",
|
|
|
|
QStringList() << "-o" << logName("xml")+",xml"
|
|
|
|
<< "-o" << "-,txt"
|
|
|
|
)
|
|
|
|
<< LoggerSet("txt + xunitxml",
|
|
|
|
QStringList() << "txt" << "xunitxml",
|
|
|
|
QStringList() << "-o" << logName("txt")+",txt"
|
|
|
|
<< "-o" << logName("xunitxml")+",xunitxml"
|
|
|
|
)
|
|
|
|
<< LoggerSet("lightxml + stdout xunitxml",
|
|
|
|
QStringList() << "lightxml" << "stdout xunitxml",
|
|
|
|
QStringList() << "-o" << logName("lightxml")+",lightxml"
|
|
|
|
<< "-o" << "-,xunitxml"
|
|
|
|
)
|
|
|
|
// All loggers at the same time
|
|
|
|
<< LoggerSet("all loggers",
|
|
|
|
QStringList() << "txt" << "xml" << "lightxml" << "stdout txt" << "xunitxml",
|
|
|
|
QStringList() << "-o" << logName("txt")+",txt"
|
|
|
|
<< "-o" << logName("xml")+",xml"
|
|
|
|
<< "-o" << logName("lightxml")+",lightxml"
|
|
|
|
<< "-o" << "-,txt"
|
|
|
|
<< "-o" << logName("xunitxml")+",xunitxml"
|
|
|
|
)
|
2011-04-27 10:05:43 +00:00
|
|
|
;
|
|
|
|
}
|
|
|
|
|
2012-05-29 00:58:41 +00:00
|
|
|
tst_Selftests::tst_Selftests()
|
|
|
|
: tempDir(QDir::tempPath() + "/tst_selftests.XXXXXX")
|
|
|
|
{}
|
|
|
|
|
2011-12-13 16:08:45 +00:00
|
|
|
void tst_Selftests::initTestCase()
|
|
|
|
{
|
2012-01-04 02:28:20 +00:00
|
|
|
//Detect the location of the sub programs
|
|
|
|
QString subProgram = QLatin1String("float/float");
|
|
|
|
#if defined(Q_OS_WIN)
|
|
|
|
subProgram = QLatin1String("float/float.exe");
|
|
|
|
#endif
|
|
|
|
QString testdataDir = QFINDTESTDATA(subProgram);
|
|
|
|
if (testdataDir.lastIndexOf(subProgram) > 0)
|
|
|
|
testdataDir = testdataDir.left(testdataDir.lastIndexOf(subProgram));
|
|
|
|
else
|
|
|
|
testdataDir = QCoreApplication::applicationDirPath();
|
2011-12-13 16:08:45 +00:00
|
|
|
// chdir to our testdata path and execute helper apps relative to that.
|
|
|
|
QVERIFY2(QDir::setCurrent(testdataDir), qPrintable("Could not chdir to " + testdataDir));
|
|
|
|
}
|
|
|
|
|
2011-04-27 10:05:43 +00:00
|
|
|
void tst_Selftests::runSubTest_data()
|
|
|
|
{
|
|
|
|
QTest::addColumn<QString>("subdir");
|
2011-09-21 01:39:07 +00:00
|
|
|
QTest::addColumn<QStringList>("loggers");
|
2011-04-27 10:05:43 +00:00
|
|
|
QTest::addColumn<QStringList>("arguments");
|
|
|
|
|
|
|
|
QStringList tests = QStringList()
|
|
|
|
// << "alive" // timer dependent
|
|
|
|
#if !defined(Q_OS_WIN)
|
2011-09-23 01:41:16 +00:00
|
|
|
// On windows, assert does nothing in release mode and blocks execution
|
|
|
|
// with a popup window in debug mode.
|
2011-04-27 10:05:43 +00:00
|
|
|
<< "assert"
|
|
|
|
#endif
|
2011-09-23 01:41:16 +00:00
|
|
|
<< "badxml"
|
2011-04-27 10:05:43 +00:00
|
|
|
#if defined(__GNUC__) && defined(__i386) && defined(Q_OS_LINUX)
|
2011-09-23 01:41:16 +00:00
|
|
|
// Only run on platforms where callgrind is available.
|
2011-04-27 10:05:43 +00:00
|
|
|
<< "benchlibcallgrind"
|
|
|
|
#endif
|
2012-02-17 03:39:30 +00:00
|
|
|
<< "benchlibcounting"
|
2011-04-27 10:05:43 +00:00
|
|
|
<< "benchlibeventcounter"
|
|
|
|
<< "benchliboptions"
|
2011-09-23 01:41:16 +00:00
|
|
|
<< "cmptest"
|
|
|
|
<< "commandlinedata"
|
2012-01-31 04:07:58 +00:00
|
|
|
<< "counting"
|
2011-09-23 01:41:16 +00:00
|
|
|
<< "crashes"
|
|
|
|
<< "datatable"
|
|
|
|
<< "datetime"
|
|
|
|
<< "differentexec"
|
2011-12-22 14:01:40 +00:00
|
|
|
#if !defined(QT_NO_EXCEPTIONS) && !defined(Q_CC_INTEL) && !defined(Q_OS_WIN)
|
2011-09-23 01:41:16 +00:00
|
|
|
// Disable this test on Windows and for intel compiler, as the run-times
|
|
|
|
// will popup dialogs with warnings that uncaught exceptions were thrown
|
|
|
|
<< "exceptionthrow"
|
|
|
|
#endif
|
|
|
|
<< "expectfail"
|
2012-02-03 00:22:13 +00:00
|
|
|
<< "failcleanup"
|
2011-09-23 01:41:16 +00:00
|
|
|
<< "failinit"
|
|
|
|
<< "failinitdata"
|
2011-12-22 14:01:40 +00:00
|
|
|
#if !defined(Q_OS_WIN)
|
|
|
|
// Disable this test on Windows, as the run-time will popup dialogs with warnings
|
2011-09-23 01:41:16 +00:00
|
|
|
<< "fetchbogus"
|
2011-12-22 14:01:40 +00:00
|
|
|
#endif
|
2012-03-01 01:01:49 +00:00
|
|
|
<< "findtestdata"
|
2011-09-23 01:41:16 +00:00
|
|
|
<< "float"
|
|
|
|
<< "globaldata"
|
2011-04-27 10:05:43 +00:00
|
|
|
<< "longstring"
|
2011-09-23 01:41:16 +00:00
|
|
|
<< "maxwarnings"
|
|
|
|
<< "multiexec"
|
2011-11-01 11:19:39 +00:00
|
|
|
<< "printdatatags"
|
|
|
|
<< "printdatatagswithglobaltags"
|
2011-12-09 15:16:46 +00:00
|
|
|
<< "qexecstringlist"
|
2012-02-27 06:31:03 +00:00
|
|
|
<< "silent"
|
2011-09-23 01:41:16 +00:00
|
|
|
<< "singleskip"
|
|
|
|
<< "skip"
|
2012-02-03 00:22:13 +00:00
|
|
|
<< "skipcleanup"
|
2011-09-23 01:41:16 +00:00
|
|
|
<< "skipinit"
|
|
|
|
<< "skipinitdata"
|
|
|
|
<< "sleep"
|
|
|
|
<< "strcmp"
|
|
|
|
<< "subtest"
|
2012-03-01 01:01:49 +00:00
|
|
|
<< "verbose1"
|
|
|
|
<< "verbose2"
|
2011-09-23 01:41:16 +00:00
|
|
|
<< "warnings"
|
|
|
|
<< "xunit"
|
2011-04-27 10:05:43 +00:00
|
|
|
;
|
|
|
|
|
2011-10-28 08:19:05 +00:00
|
|
|
// These tests are affected by timing and whether the CPU tick counter
|
|
|
|
// is monotonically increasing. They won't work on some machines so
|
|
|
|
// leave them off by default. Feel free to enable them for your own
|
|
|
|
// testing by setting the QTEST_ENABLE_EXTRA_SELFTESTS environment
|
|
|
|
// variable to something non-empty.
|
|
|
|
if (!qgetenv("QTEST_ENABLE_EXTRA_SELFTESTS").isEmpty())
|
|
|
|
tests << "benchlibtickcounter"
|
|
|
|
<< "benchlibwalltime"
|
|
|
|
;
|
|
|
|
|
2011-09-21 01:39:07 +00:00
|
|
|
foreach (LoggerSet const& loggerSet, allLoggerSets()) {
|
|
|
|
QStringList loggers = loggerSet.loggers;
|
2011-04-27 10:05:43 +00:00
|
|
|
|
|
|
|
foreach (QString const& subtest, tests) {
|
2011-09-21 01:39:07 +00:00
|
|
|
QStringList arguments = loggerSet.arguments;
|
2011-04-27 10:05:43 +00:00
|
|
|
if (subtest == "commandlinedata") {
|
|
|
|
arguments << QString("fiveTablePasses fiveTablePasses:fiveTablePasses_data1 -v2").split(' ');
|
|
|
|
}
|
|
|
|
else if (subtest == "benchlibcallgrind") {
|
|
|
|
arguments << "-callgrind";
|
|
|
|
}
|
|
|
|
else if (subtest == "benchlibeventcounter") {
|
|
|
|
arguments << "-eventcounter";
|
|
|
|
}
|
|
|
|
else if (subtest == "benchliboptions") {
|
|
|
|
arguments << "-eventcounter";
|
|
|
|
}
|
|
|
|
else if (subtest == "benchlibtickcounter") {
|
|
|
|
arguments << "-tickcounter";
|
|
|
|
}
|
|
|
|
else if (subtest == "badxml") {
|
|
|
|
arguments << "-eventcounter";
|
|
|
|
}
|
2012-02-17 03:39:30 +00:00
|
|
|
else if (subtest == "benchlibcounting") {
|
|
|
|
arguments << "-eventcounter";
|
|
|
|
}
|
2011-11-01 11:19:39 +00:00
|
|
|
else if (subtest == "printdatatags") {
|
|
|
|
arguments << "-datatags";
|
|
|
|
}
|
|
|
|
else if (subtest == "printdatatagswithglobaltags") {
|
|
|
|
arguments << "-datatags";
|
|
|
|
}
|
2012-02-27 06:31:03 +00:00
|
|
|
else if (subtest == "silent") {
|
|
|
|
arguments << "-silent";
|
|
|
|
}
|
2012-03-01 01:01:49 +00:00
|
|
|
else if (subtest == "verbose1") {
|
|
|
|
arguments << "-v1";
|
|
|
|
}
|
|
|
|
else if (subtest == "verbose2") {
|
|
|
|
arguments << "-v2";
|
|
|
|
}
|
2011-11-01 11:19:39 +00:00
|
|
|
|
2011-04-27 10:05:43 +00:00
|
|
|
|
2011-09-21 00:38:09 +00:00
|
|
|
// These tests don't work right unless logging plain text to
|
|
|
|
// standard output, either because they execute multiple test
|
|
|
|
// objects or because they internally supply arguments to
|
|
|
|
// themselves.
|
Allow tests to log to multiple destinations
Each destination and the format of output to write there is specified by
adding "-o filename,format" to the command-line. The special filename
"-" indicates that the log output is written to the standard output
stream, though standard output can be used as a destination at most
once.
The old-style testlib output options are still supported, but can only
be used to specify one logging destination, as before.
If no logging options are given on the command-line, a plain text log
will go to the console, as before.
To log to the console in plain text and to the file "test_output" in
xunit format, one would invoke a test in the following way:
tst_foo -o test_output,xunitxml -o -,txt
This commit also enhances the selftests to test with multiple loggers,
but negative tests (e.g. bad combinations of command-line options) are
left for future task QTBUG-21567.
Task-number: QTBUG-20615
Change-Id: If91e752bc7001657e15e427aba9d25ab0a29a0b0
Reviewed-on: http://codereview.qt-project.org/4125
Reviewed-by: Qt Sanity Bot <qt_sanity_bot@ovi.com>
Reviewed-by: Rohan McGovern <rohan.mcgovern@nokia.com>
2011-09-02 09:08:21 +00:00
|
|
|
if (loggerSet.name != "old stdout txt" && loggerSet.name != "new stdout txt") {
|
2011-04-27 10:05:43 +00:00
|
|
|
if (subtest == "differentexec") {
|
|
|
|
continue;
|
|
|
|
}
|
2011-09-21 00:38:09 +00:00
|
|
|
if (subtest == "multiexec") {
|
|
|
|
continue;
|
|
|
|
}
|
2011-12-09 15:16:46 +00:00
|
|
|
if (subtest == "qexecstringlist") {
|
|
|
|
continue;
|
|
|
|
}
|
2011-04-27 10:05:43 +00:00
|
|
|
if (subtest == "benchliboptions") {
|
|
|
|
continue;
|
|
|
|
}
|
2011-11-01 11:19:39 +00:00
|
|
|
if (subtest == "printdatatags") {
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
if (subtest == "printdatatagswithglobaltags") {
|
|
|
|
continue;
|
|
|
|
}
|
2012-02-27 06:31:03 +00:00
|
|
|
if (subtest == "silent") {
|
|
|
|
continue;
|
|
|
|
}
|
2011-04-27 10:05:43 +00:00
|
|
|
// `crashes' will not output valid XML on platforms without a crash handler
|
|
|
|
if (subtest == "crashes") {
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
// this test prints out some floats in the testlog and the formatting is
|
|
|
|
// platform-specific and hard to predict.
|
2011-09-20 01:56:31 +00:00
|
|
|
if (subtest == "float") {
|
2011-10-17 04:11:13 +00:00
|
|
|
continue;
|
|
|
|
}
|
|
|
|
// these tests are quite slow, and running them for all the loggers significantly
|
|
|
|
// increases the overall test time. They do not really relate to logging, so it
|
|
|
|
// should be safe to run them just for the stdout loggers.
|
|
|
|
if (subtest == "benchlibcallgrind" || subtest == "sleep") {
|
2011-04-27 10:05:43 +00:00
|
|
|
continue;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2011-09-21 01:39:07 +00:00
|
|
|
QTest::newRow(qPrintable(QString("%1 %2").arg(subtest).arg(loggerSet.name)))
|
2011-04-27 10:05:43 +00:00
|
|
|
<< subtest
|
2011-09-21 01:39:07 +00:00
|
|
|
<< loggers
|
2011-04-27 10:05:43 +00:00
|
|
|
<< arguments
|
|
|
|
;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2012-02-02 09:12:21 +00:00
|
|
|
static void insertEnvironmentVariable(QString const& name, QProcessEnvironment &result)
|
|
|
|
{
|
|
|
|
const QProcessEnvironment systemEnvironment = QProcessEnvironment::systemEnvironment();
|
|
|
|
const QString value = systemEnvironment.value(name);
|
|
|
|
if (!value.isEmpty())
|
|
|
|
result.insert(name, value);
|
|
|
|
}
|
|
|
|
|
2011-12-07 15:45:14 +00:00
|
|
|
static inline QProcessEnvironment processEnvironment()
|
|
|
|
{
|
|
|
|
QProcessEnvironment result;
|
2012-02-02 09:12:21 +00:00
|
|
|
insertEnvironmentVariable(QStringLiteral("PATH"), result);
|
2011-12-19 10:33:07 +00:00
|
|
|
// Preserve DISPLAY for X11 as some tests use QtGui.
|
|
|
|
#if defined(Q_OS_UNIX) && !defined(Q_OS_MAC)
|
2012-02-02 09:12:21 +00:00
|
|
|
insertEnvironmentVariable(QStringLiteral("DISPLAY"), result);
|
|
|
|
#endif
|
|
|
|
insertEnvironmentVariable(QStringLiteral("QT_QPA_PLATFORM"), result);
|
|
|
|
#ifdef __COVERAGESCANNER__
|
|
|
|
insertEnvironmentVariable(QStringLiteral("QT_TESTCOCOON_ACTIVE"), result);
|
2011-12-19 10:33:07 +00:00
|
|
|
#endif
|
2011-12-07 15:45:14 +00:00
|
|
|
return result;
|
|
|
|
}
|
|
|
|
|
2011-09-21 01:39:07 +00:00
|
|
|
void tst_Selftests::doRunSubTest(QString const& subdir, QStringList const& loggers, QStringList const& arguments)
|
2011-04-27 10:05:43 +00:00
|
|
|
{
|
2012-01-10 03:46:12 +00:00
|
|
|
#if defined(__GNUC__) && defined(__i386) && defined(Q_OS_LINUX)
|
|
|
|
if (arguments.contains("-callgrind")) {
|
|
|
|
QProcess checkProcess;
|
|
|
|
QStringList args;
|
|
|
|
args << QLatin1String("--version");
|
|
|
|
checkProcess.start(QLatin1String("valgrind"), args);
|
|
|
|
if (!checkProcess.waitForFinished(-1))
|
|
|
|
QSKIP(QString("Valgrind broken or not available. Not running %1 test!").arg(subdir).toLocal8Bit());
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
2011-04-27 10:05:43 +00:00
|
|
|
QProcess proc;
|
2011-12-07 15:45:14 +00:00
|
|
|
static const QProcessEnvironment environment = processEnvironment();
|
|
|
|
proc.setProcessEnvironment(environment);
|
2011-12-13 16:08:45 +00:00
|
|
|
const QString path = subdir + QLatin1Char('/') + subdir;
|
|
|
|
proc.start(path, arguments);
|
|
|
|
QVERIFY2(proc.waitForStarted(), qPrintable(QString::fromLatin1("Cannot start '%1': %2").arg(path, proc.errorString())));
|
2011-04-27 10:05:43 +00:00
|
|
|
QVERIFY2(proc.waitForFinished(), qPrintable(proc.errorString()));
|
|
|
|
|
2011-09-21 01:39:07 +00:00
|
|
|
QList<QByteArray> actualOutputs;
|
|
|
|
for (int i = 0; i < loggers.count(); ++i) {
|
|
|
|
QString logFile = logName(loggers[i]);
|
|
|
|
QByteArray out;
|
|
|
|
if (logFile.isEmpty()) {
|
|
|
|
out = proc.readAllStandardOutput();
|
|
|
|
} else {
|
|
|
|
QFile file(logFile);
|
|
|
|
if (file.open(QIODevice::ReadOnly))
|
|
|
|
out = file.readAll();
|
|
|
|
}
|
|
|
|
actualOutputs << out;
|
2011-04-27 10:05:43 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
const QByteArray err(proc.readAllStandardError());
|
|
|
|
|
2011-09-16 04:42:51 +00:00
|
|
|
// Some tests may output unpredictable strings to stderr, which we'll ignore.
|
|
|
|
//
|
|
|
|
// For instance, uncaught exceptions on Windows might say (depending on Windows
|
|
|
|
// version and JIT debugger settings):
|
|
|
|
// "This application has requested the Runtime to terminate it in an unusual way.
|
|
|
|
// Please contact the application's support team for more information."
|
|
|
|
//
|
|
|
|
// Also, tests which use valgrind may generate warnings if the toolchain is
|
|
|
|
// newer than the valgrind version, such that valgrind can't understand the
|
|
|
|
// debug information on the binary.
|
2011-04-27 10:05:43 +00:00
|
|
|
if (subdir != QLatin1String("exceptionthrow")
|
2011-12-19 10:33:07 +00:00
|
|
|
&& subdir != QLatin1String("cmptest") // QImage comparison requires QGuiApplication
|
2011-04-27 10:05:43 +00:00
|
|
|
&& subdir != QLatin1String("fetchbogus")
|
|
|
|
&& subdir != QLatin1String("xunit")
|
|
|
|
&& subdir != QLatin1String("benchlibcallgrind"))
|
|
|
|
QVERIFY2(err.isEmpty(), err.constData());
|
|
|
|
|
2011-09-21 01:39:07 +00:00
|
|
|
for (int n = 0; n < loggers.count(); ++n) {
|
|
|
|
QString logger = loggers[n];
|
|
|
|
QList<QByteArray> res = splitLines(actualOutputs[n]);
|
|
|
|
QList<QByteArray> exp = expectedResult(subdir, logger);
|
2011-12-07 15:45:14 +00:00
|
|
|
#ifdef Q_CC_MSVC
|
|
|
|
// MSVC formats double numbers differently
|
|
|
|
if (n == 0 && subdir == QStringLiteral("float")) {
|
|
|
|
for (int i = 0; i < exp.size(); ++i) {
|
|
|
|
exp[i].replace("e-07", "e-007");
|
|
|
|
exp[i].replace("e+07", "e+007");
|
|
|
|
}
|
|
|
|
}
|
|
|
|
#endif
|
2011-09-21 01:39:07 +00:00
|
|
|
|
|
|
|
// For the "crashes" test, there are multiple versions of the
|
|
|
|
// expected output. Load the one with the same line count as
|
|
|
|
// the actual output.
|
|
|
|
if (exp.count() == 0) {
|
|
|
|
QList<QList<QByteArray> > expArr;
|
2012-03-07 06:17:46 +00:00
|
|
|
QList<QByteArray> tmp;
|
2011-09-21 01:39:07 +00:00
|
|
|
int i = 1;
|
|
|
|
do {
|
2012-03-07 06:17:46 +00:00
|
|
|
tmp = expectedResult(subdir + QString("_%1").arg(i++), logger);
|
|
|
|
if (tmp.count())
|
|
|
|
expArr += tmp;
|
|
|
|
} while (tmp.count());
|
2011-09-21 01:39:07 +00:00
|
|
|
|
|
|
|
for (int j = 0; j < expArr.count(); ++j) {
|
|
|
|
if (res.count() == expArr.at(j).count()) {
|
|
|
|
exp = expArr.at(j);
|
|
|
|
break;
|
|
|
|
}
|
2011-04-27 10:05:43 +00:00
|
|
|
}
|
2012-03-07 06:17:46 +00:00
|
|
|
|
|
|
|
if (expArr.count()) {
|
|
|
|
QVERIFY2(exp.count(),
|
|
|
|
qPrintable(QString::fromLatin1("None of the expected output files for "
|
|
|
|
"%1 format has matching line count.")
|
|
|
|
.arg(loggers.at(n))));
|
|
|
|
}
|
2011-09-21 01:39:07 +00:00
|
|
|
} else {
|
2011-12-19 10:33:07 +00:00
|
|
|
QVERIFY2(res.count() == exp.count(),
|
|
|
|
qPrintable(QString::fromLatin1("Mismatch in line count: %1 != %2 (%3).")
|
|
|
|
.arg(res.count()).arg(exp.count()).arg(loggers.at(n))));
|
2011-04-27 10:05:43 +00:00
|
|
|
}
|
|
|
|
|
2012-03-07 06:17:46 +00:00
|
|
|
// By this point, we should have loaded a non-empty expected data file.
|
|
|
|
QVERIFY2(exp.count(),
|
|
|
|
qPrintable(QString::fromLatin1("Expected test data for %1 format is empty or not found.")
|
|
|
|
.arg(loggers.at(n))));
|
|
|
|
|
2011-09-21 01:39:07 +00:00
|
|
|
// For xml output formats, verify that the log is valid XML.
|
|
|
|
if (logFormat(logger) == "xunitxml" || logFormat(logger) == "xml" || logFormat(logger) == "lightxml") {
|
|
|
|
QByteArray xml(actualOutputs[n]);
|
|
|
|
// lightxml intentionally skips the root element, which technically makes it
|
|
|
|
// not valid XML.
|
|
|
|
// We'll add that ourselves for the purpose of validation.
|
|
|
|
if (logFormat(logger) == "lightxml") {
|
|
|
|
xml.prepend("<root>");
|
|
|
|
xml.append("</root>");
|
|
|
|
}
|
2011-04-27 10:05:43 +00:00
|
|
|
|
2011-09-21 01:39:07 +00:00
|
|
|
QXmlStreamReader reader(xml);
|
2011-04-27 10:05:43 +00:00
|
|
|
|
2011-09-21 01:39:07 +00:00
|
|
|
while (!reader.atEnd())
|
|
|
|
reader.readNext();
|
2011-04-27 10:05:43 +00:00
|
|
|
|
2011-09-21 01:39:07 +00:00
|
|
|
QVERIFY2(!reader.error(), qPrintable(QString("line %1, col %2: %3")
|
|
|
|
.arg(reader.lineNumber())
|
|
|
|
.arg(reader.columnNumber())
|
|
|
|
.arg(reader.errorString())
|
|
|
|
));
|
2011-04-27 10:05:43 +00:00
|
|
|
}
|
|
|
|
|
2011-09-21 01:39:07 +00:00
|
|
|
// Verify that the actual output is an acceptable match for the
|
|
|
|
// expected output.
|
|
|
|
bool benchmark = false;
|
|
|
|
for (int i = 0; i < res.count(); ++i) {
|
|
|
|
QByteArray line = res.at(i);
|
|
|
|
// the __FILE__ __LINE__ output is compiler dependent, skip it
|
|
|
|
if (line.startsWith(" Loc: [") && line.endsWith(")]"))
|
|
|
|
continue;
|
|
|
|
if (line.endsWith(" : failure location"))
|
|
|
|
continue;
|
2011-04-27 10:05:43 +00:00
|
|
|
|
2011-09-21 01:39:07 +00:00
|
|
|
const QString output(QString::fromLatin1(line));
|
|
|
|
const QString expected(QString::fromLatin1(exp.at(i)).replace("@INSERT_QT_VERSION_HERE@", QT_VERSION_STR));
|
|
|
|
|
2011-09-22 06:35:56 +00:00
|
|
|
if (subdir == "assert" && output.contains("ASSERT: ") && expected.contains("ASSERT: ") && output != expected)
|
|
|
|
// Q_ASSERT uses __FILE__, the exact contents of which are
|
|
|
|
// undefined. If we something that looks like a Q_ASSERT and we
|
|
|
|
// were expecting to see a Q_ASSERT, we'll skip the line.
|
|
|
|
continue;
|
|
|
|
else if (expected.startsWith(QLatin1String("FAIL! : tst_Exception::throwException() Caught unhandled exce")) && expected != output)
|
2011-09-21 01:39:07 +00:00
|
|
|
// On some platforms we compile without RTTI, and as a result we never throw an exception.
|
|
|
|
QCOMPARE(output.simplified(), QString::fromLatin1("tst_Exception::throwException()").simplified());
|
|
|
|
else if (benchmark || line.startsWith("<BenchmarkResult")) {
|
|
|
|
// Don't do a literal comparison for benchmark results, since
|
|
|
|
// results have some natural variance.
|
|
|
|
QString error;
|
2011-04-27 10:05:43 +00:00
|
|
|
|
2011-09-21 01:39:07 +00:00
|
|
|
BenchmarkResult actualResult = BenchmarkResult::parse(output, &error);
|
|
|
|
QVERIFY2(error.isEmpty(), qPrintable(QString("Actual line didn't parse as benchmark result: %1\nLine: %2").arg(error).arg(output)));
|
|
|
|
|
|
|
|
BenchmarkResult expectedResult = BenchmarkResult::parse(expected, &error);
|
|
|
|
QVERIFY2(error.isEmpty(), qPrintable(QString("Expected line didn't parse as benchmark result: %1\nLine: %2").arg(error).arg(expected)));
|
|
|
|
|
|
|
|
QCOMPARE(actualResult, expectedResult);
|
|
|
|
} else {
|
2011-12-19 10:33:07 +00:00
|
|
|
QVERIFY2(output == expected,
|
|
|
|
qPrintable(QString::fromLatin1("Mismatch at line %1 (%2): '%3' != '%4'")
|
|
|
|
.arg(i).arg(loggers.at(n), output, expected)));
|
2011-09-21 01:39:07 +00:00
|
|
|
}
|
2011-04-27 10:05:43 +00:00
|
|
|
|
2011-09-21 01:39:07 +00:00
|
|
|
benchmark = line.startsWith("RESULT : ");
|
|
|
|
}
|
2011-04-27 10:05:43 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
void tst_Selftests::runSubTest()
|
|
|
|
{
|
|
|
|
QFETCH(QString, subdir);
|
2011-09-21 01:39:07 +00:00
|
|
|
QFETCH(QStringList, loggers);
|
2011-04-27 10:05:43 +00:00
|
|
|
QFETCH(QStringList, arguments);
|
|
|
|
|
2011-09-21 01:39:07 +00:00
|
|
|
doRunSubTest(subdir, loggers, arguments);
|
2011-04-27 10:05:43 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
// attribute must contain ="
|
|
|
|
QString extractXmlAttribute(const QString &line, const char *attribute)
|
|
|
|
{
|
|
|
|
int index = line.indexOf(attribute);
|
|
|
|
if (index == -1)
|
|
|
|
return QString();
|
2012-04-02 12:22:04 +00:00
|
|
|
const int attributeLength = int(strlen(attribute));
|
|
|
|
const int end = line.indexOf('"', index + attributeLength);
|
2011-04-27 10:05:43 +00:00
|
|
|
if (end == -1)
|
|
|
|
return QString();
|
|
|
|
|
2012-04-02 12:22:04 +00:00
|
|
|
const QString result = line.mid(index + attributeLength, end - index - attributeLength);
|
2011-04-27 10:05:43 +00:00
|
|
|
if (result.isEmpty())
|
|
|
|
return ""; // ensure empty but not null
|
|
|
|
return result;
|
|
|
|
}
|
|
|
|
|
2011-09-16 04:42:51 +00:00
|
|
|
// Parse line into the BenchmarkResult it represents.
|
2011-04-27 10:05:43 +00:00
|
|
|
BenchmarkResult BenchmarkResult::parse(QString const& line, QString* error)
|
|
|
|
{
|
|
|
|
if (error) *error = QString();
|
|
|
|
BenchmarkResult out;
|
|
|
|
|
|
|
|
QString remaining = line.trimmed();
|
|
|
|
|
|
|
|
if (remaining.isEmpty()) {
|
|
|
|
if (error) *error = "Line is empty";
|
|
|
|
return out;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (line.startsWith("<BenchmarkResult ")) {
|
|
|
|
// XML result
|
|
|
|
// format:
|
|
|
|
// <BenchmarkResult metric="$unit" tag="$tag" value="$total" iterations="$iterations" />
|
|
|
|
if (!line.endsWith("/>")) {
|
|
|
|
if (error) *error = "unterminated XML";
|
|
|
|
return out;
|
|
|
|
}
|
|
|
|
|
|
|
|
QString unit = extractXmlAttribute(line, " metric=\"");
|
|
|
|
QString sTotal = extractXmlAttribute(line, " value=\"");
|
|
|
|
QString sIterations = extractXmlAttribute(line, " iterations=\"");
|
|
|
|
if (unit.isNull() || sTotal.isNull() || sIterations.isNull()) {
|
|
|
|
if (error) *error = "XML snippet did not contain all required values";
|
|
|
|
return out;
|
|
|
|
}
|
|
|
|
|
|
|
|
bool ok;
|
|
|
|
double total = sTotal.toDouble(&ok);
|
|
|
|
if (!ok) {
|
|
|
|
if (error) *error = sTotal + " is not a valid number";
|
|
|
|
return out;
|
|
|
|
}
|
|
|
|
double iterations = sIterations.toDouble(&ok);
|
|
|
|
if (!ok) {
|
|
|
|
if (error) *error = sIterations + " is not a valid number";
|
|
|
|
return out;
|
|
|
|
}
|
|
|
|
|
|
|
|
out.unit = unit;
|
|
|
|
out.total = total;
|
|
|
|
out.iterations = iterations;
|
|
|
|
return out;
|
|
|
|
}
|
|
|
|
// Text result
|
2011-09-16 04:42:51 +00:00
|
|
|
// This code avoids using a QRegExp because QRegExp might be broken.
|
|
|
|
// Sample format: 4,000 msec per iteration (total: 4,000, iterations: 1)
|
2011-04-27 10:05:43 +00:00
|
|
|
|
|
|
|
QString sFirstNumber;
|
|
|
|
while (!remaining.isEmpty() && !remaining.at(0).isSpace()) {
|
|
|
|
sFirstNumber += remaining.at(0);
|
|
|
|
remaining.remove(0,1);
|
|
|
|
}
|
|
|
|
remaining = remaining.trimmed();
|
|
|
|
|
2011-09-16 04:42:51 +00:00
|
|
|
// 4,000 -> 4000
|
2011-04-27 10:05:43 +00:00
|
|
|
sFirstNumber.remove(',');
|
|
|
|
|
2011-09-16 04:42:51 +00:00
|
|
|
// Should now be parseable as floating point
|
2011-04-27 10:05:43 +00:00
|
|
|
bool ok;
|
|
|
|
double firstNumber = sFirstNumber.toDouble(&ok);
|
|
|
|
if (!ok) {
|
|
|
|
if (error) *error = sFirstNumber + " (at beginning of line) is not a valid number";
|
|
|
|
return out;
|
|
|
|
}
|
|
|
|
|
2011-09-16 04:42:51 +00:00
|
|
|
// Remaining: msec per iteration (total: 4000, iterations: 1)
|
2011-04-27 10:05:43 +00:00
|
|
|
static const char periterbit[] = " per iteration (total: ";
|
|
|
|
QString unit;
|
|
|
|
while (!remaining.startsWith(periterbit) && !remaining.isEmpty()) {
|
|
|
|
unit += remaining.at(0);
|
|
|
|
remaining.remove(0,1);
|
|
|
|
}
|
|
|
|
if (remaining.isEmpty()) {
|
|
|
|
if (error) *error = "Could not find pattern: '<unit> per iteration (total: '";
|
|
|
|
return out;
|
|
|
|
}
|
|
|
|
|
|
|
|
remaining = remaining.mid(sizeof(periterbit)-1);
|
|
|
|
|
2011-09-16 04:42:51 +00:00
|
|
|
// Remaining: 4,000, iterations: 1)
|
2011-04-27 10:05:43 +00:00
|
|
|
static const char itersbit[] = ", iterations: ";
|
|
|
|
QString sTotal;
|
|
|
|
while (!remaining.startsWith(itersbit) && !remaining.isEmpty()) {
|
|
|
|
sTotal += remaining.at(0);
|
|
|
|
remaining.remove(0,1);
|
|
|
|
}
|
|
|
|
if (remaining.isEmpty()) {
|
|
|
|
if (error) *error = "Could not find pattern: '<number>, iterations: '";
|
|
|
|
return out;
|
|
|
|
}
|
|
|
|
|
|
|
|
remaining = remaining.mid(sizeof(itersbit)-1);
|
|
|
|
|
2011-09-16 04:42:51 +00:00
|
|
|
// 4,000 -> 4000
|
2011-04-27 10:05:43 +00:00
|
|
|
sTotal.remove(',');
|
|
|
|
|
|
|
|
double total = sTotal.toDouble(&ok);
|
|
|
|
if (!ok) {
|
|
|
|
if (error) *error = sTotal + " (total) is not a valid number";
|
|
|
|
return out;
|
|
|
|
}
|
|
|
|
|
2011-09-16 04:42:51 +00:00
|
|
|
// Remaining: 1)
|
2011-04-27 10:05:43 +00:00
|
|
|
QString sIters;
|
|
|
|
while (remaining != QLatin1String(")") && !remaining.isEmpty()) {
|
|
|
|
sIters += remaining.at(0);
|
|
|
|
remaining.remove(0,1);
|
|
|
|
}
|
|
|
|
if (remaining.isEmpty()) {
|
|
|
|
if (error) *error = "Could not find pattern: '<num>)'";
|
|
|
|
return out;
|
|
|
|
}
|
|
|
|
qint64 iters = sIters.toLongLong(&ok);
|
|
|
|
if (!ok) {
|
|
|
|
if (error) *error = sIters + " (iterations) is not a valid integer";
|
|
|
|
return out;
|
|
|
|
}
|
|
|
|
|
|
|
|
double calcFirstNumber = double(total)/double(iters);
|
|
|
|
if (!qFuzzyCompare(firstNumber, calcFirstNumber)) {
|
|
|
|
if (error) *error = QString("total/iters is %1, but benchlib output result as %2").arg(calcFirstNumber).arg(firstNumber);
|
|
|
|
return out;
|
|
|
|
}
|
|
|
|
|
|
|
|
out.total = total;
|
|
|
|
out.unit = unit;
|
|
|
|
out.iterations = iters;
|
|
|
|
return out;
|
|
|
|
}
|
|
|
|
|
2011-09-16 05:03:44 +00:00
|
|
|
void tst_Selftests::cleanup()
|
2011-04-27 10:05:43 +00:00
|
|
|
{
|
2011-09-21 01:39:07 +00:00
|
|
|
QFETCH(QStringList, loggers);
|
|
|
|
|
|
|
|
// Remove the test output files
|
|
|
|
for (int i = 0; i < loggers.count(); ++i) {
|
2011-12-19 10:33:07 +00:00
|
|
|
QString logFileName = logName(loggers[i]);
|
|
|
|
if (!logFileName.isEmpty()) {
|
|
|
|
QFile logFile(logFileName);
|
|
|
|
if (logFile.exists())
|
|
|
|
QVERIFY2(logFile.remove(), qPrintable(QString::fromLatin1("Cannot remove file '%1': %2: ").arg(logFileName, logFile.errorString())));
|
|
|
|
}
|
2011-09-21 01:39:07 +00:00
|
|
|
}
|
2011-04-27 10:05:43 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
QTEST_MAIN(tst_Selftests)
|
|
|
|
|
|
|
|
#include "tst_selftests.moc"
|