e7371c19d9
We don't want the signal dumper to pick up signals that our own test machinery produces, such as the ones emitted from the watchdog thread startup and shutdown. This would otherwise produce: tst_Signaldumper::initTestCase() Signal: QThread(7fc969e0d870) started () At startup, and at shutdown even more confusingly: tst_Signaldumper::UnknownTestFunc() Signal: QThread(7fc969e0d870) finished () Change-Id: I9e81fa168eaa92551d38d5576973bbf95ac23364 Reviewed-by: Volker Hilsheimer <volker.hilsheimer@qt.io>
3007 lines
102 KiB
C++
3007 lines
102 KiB
C++
/****************************************************************************
|
|
**
|
|
** Copyright (C) 2020 The Qt Company Ltd.
|
|
** Copyright (C) 2016 Intel Corporation.
|
|
** Contact: https://www.qt.io/licensing/
|
|
**
|
|
** This file is part of the QtTest module of the Qt Toolkit.
|
|
**
|
|
** $QT_BEGIN_LICENSE:LGPL$
|
|
** 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 The Qt Company. For licensing terms
|
|
** and conditions see https://www.qt.io/terms-conditions. For further
|
|
** information use the contact form at https://www.qt.io/contact-us.
|
|
**
|
|
** GNU Lesser General Public License Usage
|
|
** Alternatively, this file may be used under the terms of the GNU Lesser
|
|
** General Public License version 3 as published by the Free Software
|
|
** Foundation and appearing in the file LICENSE.LGPL3 included in the
|
|
** packaging of this file. Please review the following information to
|
|
** ensure the GNU Lesser General Public License version 3 requirements
|
|
** will be met: https://www.gnu.org/licenses/lgpl-3.0.html.
|
|
**
|
|
** GNU General Public License Usage
|
|
** Alternatively, this file may be used under the terms of the GNU
|
|
** General Public License version 2.0 or (at your option) the GNU General
|
|
** Public license version 3 or any later version approved by the KDE Free
|
|
** Qt Foundation. The licenses are as published by the Free Software
|
|
** Foundation and appearing in the file LICENSE.GPL2 and LICENSE.GPL3
|
|
** included in the packaging of this file. Please review the following
|
|
** information to ensure the GNU General Public License requirements will
|
|
** be met: https://www.gnu.org/licenses/gpl-2.0.html and
|
|
** https://www.gnu.org/licenses/gpl-3.0.html.
|
|
**
|
|
** $QT_END_LICENSE$
|
|
**
|
|
****************************************************************************/
|
|
|
|
#include <QtTest/qtestcase.h>
|
|
#include <QtTest/qtestassert.h>
|
|
|
|
#include <QtCore/qbytearray.h>
|
|
#include <QtCore/qcoreapplication.h>
|
|
#include <QtCore/qdebug.h>
|
|
#include <QtCore/qdir.h>
|
|
#include <QtCore/qdiriterator.h>
|
|
#include <QtCore/qfile.h>
|
|
#include <QtCore/qfileinfo.h>
|
|
#include <QtCore/qfloat16.h>
|
|
#include <QtCore/qlibraryinfo.h>
|
|
#include <QtCore/qlist.h>
|
|
#include <QtCore/qmetaobject.h>
|
|
#include <QtCore/qobject.h>
|
|
#include <QtCore/qstringlist.h>
|
|
#include <QtCore/qtemporarydir.h>
|
|
#include <QtCore/qthread.h>
|
|
#include <QtCore/qvarlengtharray.h>
|
|
#include <QtCore/private/qlocking_p.h>
|
|
#include <QtCore/private/qtools_p.h>
|
|
#include <QtCore/private/qwaitcondition_p.h>
|
|
|
|
#include <QtCore/qtestsupport_core.h>
|
|
|
|
#include <QtTest/private/qtestlog_p.h>
|
|
#include <QtTest/private/qtesttable_p.h>
|
|
#include <QtTest/qtestdata.h>
|
|
#include <QtTest/private/qtestresult_p.h>
|
|
#include <QtTest/private/qsignaldumper_p.h>
|
|
#include <QtTest/private/qbenchmark_p.h>
|
|
#include <QtTest/private/cycle_p.h>
|
|
#include <QtTest/private/qtestblacklist_p.h>
|
|
#if defined(HAVE_XCTEST)
|
|
#include <QtTest/private/qxctestlogger_p.h>
|
|
#endif
|
|
#if defined Q_OS_MACOS
|
|
#include <QtTest/private/qtestutil_macos_p.h>
|
|
#endif
|
|
|
|
#if defined(Q_OS_DARWIN)
|
|
#include <QtTest/private/qappletestlogger_p.h>
|
|
#endif
|
|
|
|
#include <cmath>
|
|
#include <numeric>
|
|
#include <algorithm>
|
|
#include <condition_variable>
|
|
#include <mutex>
|
|
#include <chrono>
|
|
|
|
#include <stdarg.h>
|
|
#include <stdio.h>
|
|
#include <stdlib.h>
|
|
|
|
#if defined(Q_OS_LINUX)
|
|
#include <sys/types.h>
|
|
#include <fcntl.h>
|
|
#endif
|
|
|
|
#ifdef Q_OS_WIN
|
|
# if !defined(Q_CC_MINGW) || (defined(Q_CC_MINGW) && defined(__MINGW64_VERSION_MAJOR))
|
|
# include <crtdbg.h>
|
|
# endif
|
|
#include <qt_windows.h> // for Sleep
|
|
#endif
|
|
#ifdef Q_OS_UNIX
|
|
#include <errno.h>
|
|
#include <signal.h>
|
|
#include <time.h>
|
|
#include <unistd.h>
|
|
# if !defined(Q_OS_INTEGRITY)
|
|
# include <sys/resource.h>
|
|
# endif
|
|
#endif
|
|
|
|
#if defined(Q_OS_MACOS)
|
|
#include <IOKit/pwr_mgt/IOPMLib.h>
|
|
#include <mach/task.h>
|
|
#include <mach/mach_init.h>
|
|
#include <CoreFoundation/CFPreferences.h>
|
|
#endif
|
|
|
|
#include <vector>
|
|
|
|
QT_BEGIN_NAMESPACE
|
|
|
|
using QtMiscUtils::toHexUpper;
|
|
using QtMiscUtils::fromHex;
|
|
|
|
static bool debuggerPresent()
|
|
{
|
|
#if defined(Q_OS_LINUX)
|
|
int fd = open("/proc/self/status", O_RDONLY);
|
|
if (fd == -1)
|
|
return false;
|
|
char buffer[2048];
|
|
ssize_t size = read(fd, buffer, sizeof(buffer) - 1);
|
|
if (size == -1) {
|
|
close(fd);
|
|
return false;
|
|
}
|
|
buffer[size] = 0;
|
|
const char tracerPidToken[] = "\nTracerPid:";
|
|
char *tracerPid = strstr(buffer, tracerPidToken);
|
|
if (!tracerPid) {
|
|
close(fd);
|
|
return false;
|
|
}
|
|
tracerPid += sizeof(tracerPidToken);
|
|
long int pid = strtol(tracerPid, &tracerPid, 10);
|
|
close(fd);
|
|
return pid != 0;
|
|
#elif defined(Q_OS_WIN)
|
|
return IsDebuggerPresent();
|
|
#elif defined(Q_OS_MACOS)
|
|
// Check if there is an exception handler for the process:
|
|
mach_msg_type_number_t portCount = 0;
|
|
exception_mask_t masks[EXC_TYPES_COUNT];
|
|
mach_port_t ports[EXC_TYPES_COUNT];
|
|
exception_behavior_t behaviors[EXC_TYPES_COUNT];
|
|
thread_state_flavor_t flavors[EXC_TYPES_COUNT];
|
|
exception_mask_t mask = EXC_MASK_ALL & ~(EXC_MASK_RESOURCE | EXC_MASK_GUARD);
|
|
kern_return_t result = task_get_exception_ports(mach_task_self(), mask, masks, &portCount,
|
|
ports, behaviors, flavors);
|
|
if (result == KERN_SUCCESS) {
|
|
for (mach_msg_type_number_t portIndex = 0; portIndex < portCount; ++portIndex) {
|
|
if (MACH_PORT_VALID(ports[portIndex])) {
|
|
return true;
|
|
}
|
|
}
|
|
}
|
|
return false;
|
|
#else
|
|
// TODO
|
|
return false;
|
|
#endif
|
|
}
|
|
|
|
static bool hasSystemCrashReporter()
|
|
{
|
|
#if defined(Q_OS_MACOS)
|
|
return QTestPrivate::macCrashReporterWillShowDialog();
|
|
#else
|
|
return false;
|
|
#endif
|
|
}
|
|
|
|
static void disableCoreDump()
|
|
{
|
|
bool ok = false;
|
|
const int disableCoreDump = qEnvironmentVariableIntValue("QTEST_DISABLE_CORE_DUMP", &ok);
|
|
if (ok && disableCoreDump == 1) {
|
|
#if defined(Q_OS_UNIX) && !defined(Q_OS_INTEGRITY)
|
|
struct rlimit limit;
|
|
limit.rlim_cur = 0;
|
|
limit.rlim_max = 0;
|
|
if (setrlimit(RLIMIT_CORE, &limit) != 0)
|
|
qWarning("Failed to disable core dumps: %d", errno);
|
|
#endif
|
|
}
|
|
}
|
|
Q_CONSTRUCTOR_FUNCTION(disableCoreDump);
|
|
|
|
static void stackTrace()
|
|
{
|
|
bool ok = false;
|
|
const int disableStackDump = qEnvironmentVariableIntValue("QTEST_DISABLE_STACK_DUMP", &ok);
|
|
if (ok && disableStackDump == 1)
|
|
return;
|
|
|
|
if (debuggerPresent() || hasSystemCrashReporter())
|
|
return;
|
|
|
|
#if defined(Q_OS_LINUX) || defined(Q_OS_MACOS)
|
|
const int msecsFunctionTime = qRound(QTestLog::msecsFunctionTime());
|
|
const int msecsTotalTime = qRound(QTestLog::msecsTotalTime());
|
|
fprintf(stderr, "\n=== Received signal at function time: %dms, total time: %dms, dumping stack ===\n",
|
|
msecsFunctionTime, msecsTotalTime);
|
|
#endif
|
|
#ifdef Q_OS_LINUX
|
|
char cmd[512];
|
|
qsnprintf(cmd, 512, "gdb --pid %d 2>/dev/null <<EOF\n"
|
|
"set prompt\n"
|
|
"set height 0\n"
|
|
"thread apply all where full\n"
|
|
"detach\n"
|
|
"quit\n"
|
|
"EOF\n",
|
|
(int)getpid());
|
|
if (system(cmd) == -1)
|
|
fprintf(stderr, "calling gdb failed\n");
|
|
fprintf(stderr, "=== End of stack trace ===\n");
|
|
#elif defined(Q_OS_MACOS)
|
|
char cmd[512];
|
|
qsnprintf(cmd, 512, "lldb -p %d 2>/dev/null <<EOF\n"
|
|
"bt all\n"
|
|
"quit\n"
|
|
"EOF\n",
|
|
(int)getpid());
|
|
if (system(cmd) == -1)
|
|
fprintf(stderr, "calling lldb failed\n");
|
|
fprintf(stderr, "=== End of stack trace ===\n");
|
|
#endif
|
|
}
|
|
|
|
static bool installCoverageTool(const char * appname, const char * testname)
|
|
{
|
|
#if defined(__COVERAGESCANNER__) && !QT_CONFIG(testlib_selfcover)
|
|
if (!qEnvironmentVariableIsEmpty("QT_TESTCOCOON_ACTIVE"))
|
|
return false;
|
|
// Set environment variable QT_TESTCOCOON_ACTIVE to prevent an eventual subtest from
|
|
// being considered as a stand-alone test regarding the coverage analysis.
|
|
qputenv("QT_TESTCOCOON_ACTIVE", "1");
|
|
|
|
// Install Coverage Tool
|
|
__coveragescanner_install(appname);
|
|
__coveragescanner_testname(testname);
|
|
__coveragescanner_clear();
|
|
return true;
|
|
#else
|
|
Q_UNUSED(appname);
|
|
Q_UNUSED(testname);
|
|
return false;
|
|
#endif
|
|
}
|
|
|
|
static bool isValidSlot(const QMetaMethod &sl)
|
|
{
|
|
if (sl.access() != QMetaMethod::Private || sl.parameterCount() != 0
|
|
|| sl.returnType() != QMetaType::Void || sl.methodType() != QMetaMethod::Slot)
|
|
return false;
|
|
const QByteArray name = sl.name();
|
|
return !(name.isEmpty() || name.endsWith("_data")
|
|
|| name == "initTestCase" || name == "cleanupTestCase"
|
|
|| name == "init" || name == "cleanup");
|
|
}
|
|
|
|
namespace QTestPrivate
|
|
{
|
|
Q_TESTLIB_EXPORT Qt::MouseButtons qtestMouseButtons = Qt::NoButton;
|
|
}
|
|
|
|
namespace QTest
|
|
{
|
|
extern Q_TESTLIB_EXPORT int lastMouseTimestamp;
|
|
|
|
class WatchDog;
|
|
|
|
static QObject *currentTestObject = nullptr;
|
|
static QString mainSourcePath;
|
|
|
|
#if defined(Q_OS_MACOS)
|
|
static IOPMAssertionID macPowerSavingDisabled = 0;
|
|
#endif
|
|
|
|
class TestMethods {
|
|
public:
|
|
Q_DISABLE_COPY_MOVE(TestMethods)
|
|
|
|
using MetaMethods = std::vector<QMetaMethod>;
|
|
|
|
explicit TestMethods(const QObject *o, const MetaMethods &m = MetaMethods());
|
|
|
|
void invokeTests(QObject *testObject) const;
|
|
|
|
static QMetaMethod findMethod(const QObject *obj, const char *signature);
|
|
|
|
private:
|
|
bool invokeTest(int index, const char *data, WatchDog *watchDog) const;
|
|
void invokeTestOnData(int index) const;
|
|
|
|
QMetaMethod m_initTestCaseMethod; // might not exist, check isValid().
|
|
QMetaMethod m_initTestCaseDataMethod;
|
|
QMetaMethod m_cleanupTestCaseMethod;
|
|
QMetaMethod m_initMethod;
|
|
QMetaMethod m_cleanupMethod;
|
|
|
|
MetaMethods m_methods;
|
|
};
|
|
|
|
TestMethods::TestMethods(const QObject *o, const MetaMethods &m)
|
|
: m_initTestCaseMethod(TestMethods::findMethod(o, "initTestCase()"))
|
|
, m_initTestCaseDataMethod(TestMethods::findMethod(o, "initTestCase_data()"))
|
|
, m_cleanupTestCaseMethod(TestMethods::findMethod(o, "cleanupTestCase()"))
|
|
, m_initMethod(TestMethods::findMethod(o, "init()"))
|
|
, m_cleanupMethod(TestMethods::findMethod(o, "cleanup()"))
|
|
, m_methods(m)
|
|
{
|
|
if (m.empty()) {
|
|
const QMetaObject *metaObject = o->metaObject();
|
|
const int count = metaObject->methodCount();
|
|
m_methods.reserve(count);
|
|
for (int i = 0; i < count; ++i) {
|
|
const QMetaMethod me = metaObject->method(i);
|
|
if (isValidSlot(me))
|
|
m_methods.push_back(me);
|
|
}
|
|
}
|
|
}
|
|
|
|
QMetaMethod TestMethods::findMethod(const QObject *obj, const char *signature)
|
|
{
|
|
const QMetaObject *metaObject = obj->metaObject();
|
|
const int funcIndex = metaObject->indexOfMethod(signature);
|
|
return funcIndex >= 0 ? metaObject->method(funcIndex) : QMetaMethod();
|
|
}
|
|
|
|
static int keyDelay = -1;
|
|
static int mouseDelay = -1;
|
|
static int eventDelay = -1;
|
|
#if QT_CONFIG(thread)
|
|
static int timeout = -1;
|
|
#endif
|
|
static bool noCrashHandler = false;
|
|
|
|
/*! \internal
|
|
Invoke a method of the object without generating warning if the method does not exist
|
|
*/
|
|
static void invokeMethod(QObject *obj, const char *methodName)
|
|
{
|
|
const QMetaObject *metaObject = obj->metaObject();
|
|
int funcIndex = metaObject->indexOfMethod(methodName);
|
|
if (funcIndex >= 0) {
|
|
QMetaMethod method = metaObject->method(funcIndex);
|
|
method.invoke(obj, Qt::DirectConnection);
|
|
}
|
|
}
|
|
|
|
int defaultEventDelay()
|
|
{
|
|
if (eventDelay == -1) {
|
|
const QByteArray env = qgetenv("QTEST_EVENT_DELAY");
|
|
if (!env.isEmpty())
|
|
eventDelay = atoi(env.constData());
|
|
else
|
|
eventDelay = 0;
|
|
}
|
|
return eventDelay;
|
|
}
|
|
|
|
int Q_TESTLIB_EXPORT defaultMouseDelay()
|
|
{
|
|
if (mouseDelay == -1) {
|
|
const QByteArray env = qgetenv("QTEST_MOUSEEVENT_DELAY");
|
|
if (!env.isEmpty())
|
|
mouseDelay = atoi(env.constData());
|
|
else
|
|
mouseDelay = defaultEventDelay();
|
|
}
|
|
return mouseDelay;
|
|
}
|
|
|
|
int Q_TESTLIB_EXPORT defaultKeyDelay()
|
|
{
|
|
if (keyDelay == -1) {
|
|
const QByteArray env = qgetenv("QTEST_KEYEVENT_DELAY");
|
|
if (!env.isEmpty())
|
|
keyDelay = atoi(env.constData());
|
|
else
|
|
keyDelay = defaultEventDelay();
|
|
}
|
|
return keyDelay;
|
|
}
|
|
#if QT_CONFIG(thread)
|
|
static std::chrono::milliseconds defaultTimeout()
|
|
{
|
|
if (timeout == -1) {
|
|
bool ok = false;
|
|
timeout = qEnvironmentVariableIntValue("QTEST_FUNCTION_TIMEOUT", &ok);
|
|
|
|
if (!ok || timeout <= 0)
|
|
timeout = 5*60*1000;
|
|
}
|
|
return std::chrono::milliseconds{timeout};
|
|
}
|
|
#endif
|
|
|
|
Q_TESTLIB_EXPORT bool printAvailableFunctions = false;
|
|
Q_TESTLIB_EXPORT QStringList testFunctions;
|
|
Q_TESTLIB_EXPORT QStringList testTags;
|
|
|
|
static void qPrintTestSlots(FILE *stream, const char *filter = nullptr)
|
|
{
|
|
for (int i = 0; i < QTest::currentTestObject->metaObject()->methodCount(); ++i) {
|
|
QMetaMethod sl = QTest::currentTestObject->metaObject()->method(i);
|
|
if (isValidSlot(sl)) {
|
|
const QByteArray signature = sl.methodSignature();
|
|
if (!filter || QString::fromLatin1(signature).contains(QLatin1String(filter), Qt::CaseInsensitive))
|
|
fprintf(stream, "%s\n", signature.constData());
|
|
}
|
|
}
|
|
}
|
|
|
|
static void qPrintDataTags(FILE *stream)
|
|
{
|
|
// Avoid invoking the actual test functions, and also avoid printing irrelevant output:
|
|
QTestLog::setPrintAvailableTagsMode();
|
|
|
|
// Get global data tags:
|
|
QTestTable::globalTestTable();
|
|
invokeMethod(QTest::currentTestObject, "initTestCase_data()");
|
|
const QTestTable *gTable = QTestTable::globalTestTable();
|
|
|
|
const QMetaObject *currTestMetaObj = QTest::currentTestObject->metaObject();
|
|
|
|
// Process test functions:
|
|
for (int i = 0; i < currTestMetaObj->methodCount(); ++i) {
|
|
QMetaMethod tf = currTestMetaObj->method(i);
|
|
|
|
if (isValidSlot(tf)) {
|
|
|
|
// Retrieve local tags:
|
|
QStringList localTags;
|
|
QTestTable table;
|
|
char *slot = qstrdup(tf.methodSignature().constData());
|
|
slot[strlen(slot) - 2] = '\0';
|
|
QByteArray member;
|
|
member.resize(qstrlen(slot) + qstrlen("_data()") + 1);
|
|
qsnprintf(member.data(), member.size(), "%s_data()", slot);
|
|
invokeMethod(QTest::currentTestObject, member.constData());
|
|
const int dataCount = table.dataCount();
|
|
localTags.reserve(dataCount);
|
|
for (int j = 0; j < dataCount; ++j)
|
|
localTags << QLatin1String(table.testData(j)->dataTag());
|
|
|
|
// Print all tag combinations:
|
|
if (gTable->dataCount() == 0) {
|
|
if (localTags.count() == 0) {
|
|
// No tags at all, so just print the test function:
|
|
fprintf(stream, "%s %s\n", currTestMetaObj->className(), slot);
|
|
} else {
|
|
// Only local tags, so print each of them:
|
|
for (int k = 0; k < localTags.size(); ++k)
|
|
fprintf(
|
|
stream, "%s %s %s\n",
|
|
currTestMetaObj->className(), slot, localTags.at(k).toLatin1().data());
|
|
}
|
|
} else {
|
|
for (int j = 0; j < gTable->dataCount(); ++j) {
|
|
if (localTags.count() == 0) {
|
|
// Only global tags, so print the current one:
|
|
fprintf(
|
|
stream, "%s %s __global__ %s\n",
|
|
currTestMetaObj->className(), slot, gTable->testData(j)->dataTag());
|
|
} else {
|
|
// Local and global tags, so print each of the local ones and
|
|
// the current global one:
|
|
for (int k = 0; k < localTags.size(); ++k)
|
|
fprintf(
|
|
stream, "%s %s %s __global__ %s\n", currTestMetaObj->className(), slot,
|
|
localTags.at(k).toLatin1().data(), gTable->testData(j)->dataTag());
|
|
}
|
|
}
|
|
}
|
|
|
|
delete[] slot;
|
|
}
|
|
}
|
|
}
|
|
|
|
static int qToInt(const char *str)
|
|
{
|
|
char *pEnd;
|
|
int l = (int)strtol(str, &pEnd, 10);
|
|
if (*pEnd != 0) {
|
|
fprintf(stderr, "Invalid numeric parameter: '%s'\n", str);
|
|
exit(1);
|
|
}
|
|
return l;
|
|
}
|
|
|
|
Q_TESTLIB_EXPORT void qtest_qParseArgs(int argc, const char *const argv[], bool qml)
|
|
{
|
|
int logFormat = -1; // Not set
|
|
const char *logFilename = nullptr;
|
|
|
|
QTest::testFunctions.clear();
|
|
QTest::testTags.clear();
|
|
|
|
#if defined(Q_OS_MAC) && defined(HAVE_XCTEST)
|
|
if (QXcodeTestLogger::canLogTestProgress())
|
|
logFormat = QTestLog::XCTest;
|
|
#endif
|
|
|
|
const char *testOptions =
|
|
" New-style logging options:\n"
|
|
" -o filename,format : Output results to file in the specified format\n"
|
|
" Use - to output to stdout\n"
|
|
" Valid formats are:\n"
|
|
" txt : Plain text\n"
|
|
" csv : CSV format (suitable for benchmarks)\n"
|
|
" junitxml : XML JUnit document\n"
|
|
" xml : XML document\n"
|
|
" lightxml : A stream of XML tags\n"
|
|
" teamcity : TeamCity format\n"
|
|
" tap : Test Anything Protocol\n"
|
|
"\n"
|
|
" *** Multiple loggers can be specified, but at most one can log to stdout.\n"
|
|
"\n"
|
|
" Old-style logging options:\n"
|
|
" -o filename : Write the output into file\n"
|
|
" -txt : Output results in Plain Text\n"
|
|
" -csv : Output results in a CSV format (suitable for benchmarks)\n"
|
|
" -junitxml : Output results as XML JUnit document\n"
|
|
" -xml : Output results as XML document\n"
|
|
" -lightxml : Output results as stream of XML tags\n"
|
|
" -teamcity : Output results in TeamCity format\n"
|
|
" -tap : Output results in Test Anything Protocol format\n"
|
|
"\n"
|
|
" *** If no output file is specified, stdout is assumed.\n"
|
|
" *** If no output format is specified, -txt is assumed.\n"
|
|
"\n"
|
|
" Test log detail options:\n"
|
|
" -silent : Log failures and fatal errors only\n"
|
|
" -v1 : Log the start of each testfunction\n"
|
|
" -v2 : Log each QVERIFY/QCOMPARE/QTEST (implies -v1)\n"
|
|
" -vs : Log every signal emission and resulting slot invocations\n"
|
|
"\n"
|
|
" *** The -silent and -v1 options only affect plain text output.\n"
|
|
"\n"
|
|
" Testing options:\n"
|
|
" -functions : Returns a list of current testfunctions\n"
|
|
" -datatags : Returns a list of current data tags.\n"
|
|
" A global data tag is preceded by ' __global__ '.\n"
|
|
" -eventdelay ms : Set default delay for mouse and keyboard simulation to ms milliseconds\n"
|
|
" -keydelay ms : Set default delay for keyboard simulation to ms milliseconds\n"
|
|
" -mousedelay ms : Set default delay for mouse simulation to ms milliseconds\n"
|
|
" -maxwarnings n : Sets the maximum amount of messages to output.\n"
|
|
" 0 means unlimited, default: 2000\n"
|
|
" -nocrashhandler : Disables the crash handler. Useful for debugging crashes.\n"
|
|
"\n"
|
|
" Benchmarking options:\n"
|
|
#if QT_CONFIG(valgrind)
|
|
" -callgrind : Use callgrind to time benchmarks\n"
|
|
#endif
|
|
#ifdef QTESTLIB_USE_PERF_EVENTS
|
|
" -perf : Use Linux perf events to time benchmarks\n"
|
|
" -perfcounter name : Use the counter named 'name'\n"
|
|
" -perfcounterlist : Lists the counters available\n"
|
|
#endif
|
|
#ifdef HAVE_TICK_COUNTER
|
|
" -tickcounter : Use CPU tick counters to time benchmarks\n"
|
|
#endif
|
|
" -eventcounter : Counts events received during benchmarks\n"
|
|
" -minimumvalue n : Sets the minimum acceptable measurement value\n"
|
|
" -minimumtotal n : Sets the minimum acceptable total for repeated executions of a test function\n"
|
|
" -iterations n : Sets the number of accumulation iterations.\n"
|
|
" -median n : Sets the number of median iterations.\n"
|
|
" -vb : Print out verbose benchmarking information.\n";
|
|
|
|
for (int i = 1; i < argc; ++i) {
|
|
if (strcmp(argv[i], "-help") == 0 || strcmp(argv[i], "--help") == 0
|
|
|| strcmp(argv[i], "/?") == 0) {
|
|
printf(" Usage: %s [options] [testfunction[:testdata]]...\n"
|
|
" By default, all testfunctions will be run.\n\n"
|
|
"%s", argv[0], testOptions);
|
|
|
|
if (qml) {
|
|
printf ("\n"
|
|
" QmlTest options:\n"
|
|
" -import dir : Specify an import directory.\n"
|
|
" -plugins dir : Specify a directory where to search for plugins.\n"
|
|
" -input dir/file : Specify the root directory for test cases or a single test case file.\n"
|
|
" -translation file : Specify the translation file.\n"
|
|
" -file-selector dir : Specify a file selector for the QML engine.\n"
|
|
);
|
|
}
|
|
|
|
printf("\n"
|
|
" -help : This help\n");
|
|
exit(0);
|
|
} else if (strcmp(argv[i], "-functions") == 0) {
|
|
if (qml) {
|
|
QTest::printAvailableFunctions = true;
|
|
} else {
|
|
qPrintTestSlots(stdout);
|
|
exit(0);
|
|
}
|
|
} else if (strcmp(argv[i], "-datatags") == 0) {
|
|
if (!qml) {
|
|
qPrintDataTags(stdout);
|
|
exit(0);
|
|
}
|
|
} else if (strcmp(argv[i], "-txt") == 0) {
|
|
logFormat = QTestLog::Plain;
|
|
} else if (strcmp(argv[i], "-csv") == 0) {
|
|
logFormat = QTestLog::CSV;
|
|
} else if (strcmp(argv[i], "-junitxml") == 0 || strcmp(argv[i], "-xunitxml") == 0) {
|
|
logFormat = QTestLog::JUnitXML;
|
|
} else if (strcmp(argv[i], "-xml") == 0) {
|
|
logFormat = QTestLog::XML;
|
|
} else if (strcmp(argv[i], "-lightxml") == 0) {
|
|
logFormat = QTestLog::LightXML;
|
|
} else if (strcmp(argv[i], "-teamcity") == 0) {
|
|
logFormat = QTestLog::TeamCity;
|
|
} else if (strcmp(argv[i], "-tap") == 0) {
|
|
logFormat = QTestLog::TAP;
|
|
} else if (strcmp(argv[i], "-silent") == 0) {
|
|
QTestLog::setVerboseLevel(-1);
|
|
} else if (strcmp(argv[i], "-v1") == 0) {
|
|
QTestLog::setVerboseLevel(1);
|
|
} else if (strcmp(argv[i], "-v2") == 0) {
|
|
QTestLog::setVerboseLevel(2);
|
|
} else if (strcmp(argv[i], "-vs") == 0) {
|
|
QSignalDumper::setEnabled(true);
|
|
} else if (strcmp(argv[i], "-o") == 0) {
|
|
if (i + 1 >= argc) {
|
|
fprintf(stderr, "-o needs an extra parameter specifying the filename and optional format\n");
|
|
exit(1);
|
|
}
|
|
++i;
|
|
// Do we have the old or new style -o option?
|
|
char *filename = new char[strlen(argv[i])+1];
|
|
char *format = new char[strlen(argv[i])+1];
|
|
if (sscanf(argv[i], "%[^,],%s", filename, format) == 1) {
|
|
// Old-style
|
|
logFilename = argv[i];
|
|
} else {
|
|
// New-style
|
|
if (strcmp(format, "txt") == 0)
|
|
logFormat = QTestLog::Plain;
|
|
else if (strcmp(format, "csv") == 0)
|
|
logFormat = QTestLog::CSV;
|
|
else if (strcmp(format, "lightxml") == 0)
|
|
logFormat = QTestLog::LightXML;
|
|
else if (strcmp(format, "xml") == 0)
|
|
logFormat = QTestLog::XML;
|
|
else if (strcmp(format, "junitxml") == 0 || strcmp(format, "xunitxml") == 0)
|
|
logFormat = QTestLog::JUnitXML;
|
|
else if (strcmp(format, "teamcity") == 0)
|
|
logFormat = QTestLog::TeamCity;
|
|
else if (strcmp(format, "tap") == 0)
|
|
logFormat = QTestLog::TAP;
|
|
else {
|
|
fprintf(stderr, "output format must be one of txt, csv, lightxml, xml, tap, teamcity or junitxml\n");
|
|
exit(1);
|
|
}
|
|
if (strcmp(filename, "-") == 0 && QTestLog::loggerUsingStdout()) {
|
|
fprintf(stderr, "only one logger can log to stdout\n");
|
|
exit(1);
|
|
}
|
|
QTestLog::addLogger(QTestLog::LogMode(logFormat), filename);
|
|
}
|
|
delete [] filename;
|
|
delete [] format;
|
|
} else if (strcmp(argv[i], "-eventdelay") == 0) {
|
|
if (i + 1 >= argc) {
|
|
fprintf(stderr, "-eventdelay needs an extra parameter to indicate the delay(ms)\n");
|
|
exit(1);
|
|
} else {
|
|
QTest::eventDelay = qToInt(argv[++i]);
|
|
}
|
|
} else if (strcmp(argv[i], "-keydelay") == 0) {
|
|
if (i + 1 >= argc) {
|
|
fprintf(stderr, "-keydelay needs an extra parameter to indicate the delay(ms)\n");
|
|
exit(1);
|
|
} else {
|
|
QTest::keyDelay = qToInt(argv[++i]);
|
|
}
|
|
} else if (strcmp(argv[i], "-mousedelay") == 0) {
|
|
if (i + 1 >= argc) {
|
|
fprintf(stderr, "-mousedelay needs an extra parameter to indicate the delay(ms)\n");
|
|
exit(1);
|
|
} else {
|
|
QTest::mouseDelay = qToInt(argv[++i]);
|
|
}
|
|
} else if (strcmp(argv[i], "-maxwarnings") == 0) {
|
|
if (i + 1 >= argc) {
|
|
fprintf(stderr, "-maxwarnings needs an extra parameter with the amount of warnings\n");
|
|
exit(1);
|
|
} else {
|
|
QTestLog::setMaxWarnings(qToInt(argv[++i]));
|
|
}
|
|
} else if (strcmp(argv[i], "-nocrashhandler") == 0) {
|
|
QTest::noCrashHandler = true;
|
|
#if QT_CONFIG(valgrind)
|
|
} else if (strcmp(argv[i], "-callgrind") == 0) {
|
|
if (QBenchmarkValgrindUtils::haveValgrind())
|
|
if (QFileInfo(QDir::currentPath()).isWritable()) {
|
|
QBenchmarkGlobalData::current->setMode(QBenchmarkGlobalData::CallgrindParentProcess);
|
|
} else {
|
|
fprintf(stderr, "WARNING: Current directory not writable. Using the walltime measurer.\n");
|
|
}
|
|
else {
|
|
fprintf(stderr, "WARNING: Valgrind not found or too old. Make sure it is installed and in your path. "
|
|
"Using the walltime measurer.\n");
|
|
}
|
|
} else if (strcmp(argv[i], "-callgrindchild") == 0) { // "private" option
|
|
QBenchmarkGlobalData::current->setMode(QBenchmarkGlobalData::CallgrindChildProcess);
|
|
QBenchmarkGlobalData::current->callgrindOutFileBase =
|
|
QBenchmarkValgrindUtils::outFileBase();
|
|
#endif
|
|
#ifdef QTESTLIB_USE_PERF_EVENTS
|
|
} else if (strcmp(argv[i], "-perf") == 0) {
|
|
if (QBenchmarkPerfEventsMeasurer::isAvailable()) {
|
|
// perf available
|
|
QBenchmarkGlobalData::current->setMode(QBenchmarkGlobalData::PerfCounter);
|
|
} else {
|
|
fprintf(stderr, "WARNING: Linux perf events not available. Using the walltime measurer.\n");
|
|
}
|
|
} else if (strcmp(argv[i], "-perfcounter") == 0) {
|
|
if (i + 1 >= argc) {
|
|
fprintf(stderr, "-perfcounter needs an extra parameter with the name of the counter\n");
|
|
exit(1);
|
|
} else {
|
|
QBenchmarkPerfEventsMeasurer::setCounter(argv[++i]);
|
|
}
|
|
} else if (strcmp(argv[i], "-perfcounterlist") == 0) {
|
|
QBenchmarkPerfEventsMeasurer::listCounters();
|
|
exit(0);
|
|
#endif
|
|
#ifdef HAVE_TICK_COUNTER
|
|
} else if (strcmp(argv[i], "-tickcounter") == 0) {
|
|
QBenchmarkGlobalData::current->setMode(QBenchmarkGlobalData::TickCounter);
|
|
#endif
|
|
} else if (strcmp(argv[i], "-eventcounter") == 0) {
|
|
QBenchmarkGlobalData::current->setMode(QBenchmarkGlobalData::EventCounter);
|
|
} else if (strcmp(argv[i], "-minimumvalue") == 0) {
|
|
if (i + 1 >= argc) {
|
|
fprintf(stderr, "-minimumvalue needs an extra parameter to indicate the minimum time(ms)\n");
|
|
exit(1);
|
|
} else {
|
|
QBenchmarkGlobalData::current->walltimeMinimum = qToInt(argv[++i]);
|
|
}
|
|
} else if (strcmp(argv[i], "-minimumtotal") == 0) {
|
|
if (i + 1 >= argc) {
|
|
fprintf(stderr, "-minimumtotal needs an extra parameter to indicate the minimum total measurement\n");
|
|
exit(1);
|
|
} else {
|
|
QBenchmarkGlobalData::current->minimumTotal = qToInt(argv[++i]);
|
|
}
|
|
} else if (strcmp(argv[i], "-iterations") == 0) {
|
|
if (i + 1 >= argc) {
|
|
fprintf(stderr, "-iterations needs an extra parameter to indicate the number of iterations\n");
|
|
exit(1);
|
|
} else {
|
|
QBenchmarkGlobalData::current->iterationCount = qToInt(argv[++i]);
|
|
}
|
|
} else if (strcmp(argv[i], "-median") == 0) {
|
|
if (i + 1 >= argc) {
|
|
fprintf(stderr, "-median needs an extra parameter to indicate the number of median iterations\n");
|
|
exit(1);
|
|
} else {
|
|
QBenchmarkGlobalData::current->medianIterationCount = qToInt(argv[++i]);
|
|
}
|
|
|
|
} else if (strcmp(argv[i], "-vb") == 0) {
|
|
QBenchmarkGlobalData::current->verboseOutput = true;
|
|
#if defined(Q_OS_MAC) && defined(HAVE_XCTEST)
|
|
} else if (int skip = QXcodeTestLogger::parseCommandLineArgument(argv[i])) {
|
|
i += (skip - 1); // Eating argv[i] with a continue counts towards skips
|
|
continue;
|
|
#endif
|
|
} else if (argv[i][0] == '-') {
|
|
fprintf(stderr, "Unknown option: '%s'\n\n%s", argv[i], testOptions);
|
|
if (qml) {
|
|
fprintf(stderr, "\nqmltest related options:\n"
|
|
" -import : Specify an import directory.\n"
|
|
" -plugins : Specify a directory where to search for plugins.\n"
|
|
" -input : Specify the root directory for test cases.\n"
|
|
);
|
|
}
|
|
|
|
fprintf(stderr, "\n"
|
|
" -help : This help\n");
|
|
exit(1);
|
|
} else {
|
|
// We can't check the availability of test functions until
|
|
// we load the QML files. So just store the data for now.
|
|
int colon = -1;
|
|
int offset;
|
|
for (offset = 0; argv[i][offset]; ++offset) {
|
|
if (argv[i][offset] == ':') {
|
|
if (argv[i][offset + 1] == ':') {
|
|
// "::" is used as a test name separator.
|
|
// e.g. "ClickTests::test_click:row1".
|
|
++offset;
|
|
} else {
|
|
colon = offset;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
if (colon == -1) {
|
|
QTest::testFunctions += QString::fromLatin1(argv[i]);
|
|
QTest::testTags += QString();
|
|
} else {
|
|
QTest::testFunctions +=
|
|
QString::fromLatin1(argv[i], colon);
|
|
QTest::testTags +=
|
|
QString::fromLatin1(argv[i] + colon + 1);
|
|
}
|
|
}
|
|
}
|
|
|
|
bool installedTestCoverage = installCoverageTool(QTestResult::currentAppName(), QTestResult::currentTestObjectName());
|
|
QTestLog::setInstalledTestCoverage(installedTestCoverage);
|
|
|
|
// If no loggers were created by the long version of the -o command-line
|
|
// option, but a logger was requested via the old-style option, add it.
|
|
const bool explicitLoggerRequested = logFormat != -1;
|
|
if (QTestLog::loggerCount() == 0 && explicitLoggerRequested)
|
|
QTestLog::addLogger(QTestLog::LogMode(logFormat), logFilename);
|
|
|
|
bool addFallbackLogger = !explicitLoggerRequested;
|
|
|
|
#if defined(QT_USE_APPLE_UNIFIED_LOGGING)
|
|
// Any explicitly requested loggers will be added by now, so we can check if they use stdout
|
|
const bool safeToAddAppleLogger = !AppleUnifiedLogger::willMirrorToStderr() || !QTestLog::loggerUsingStdout();
|
|
if (safeToAddAppleLogger && QAppleTestLogger::debugLoggingEnabled()) {
|
|
QTestLog::addLogger(QTestLog::Apple, nullptr);
|
|
if (AppleUnifiedLogger::willMirrorToStderr() && !logFilename)
|
|
addFallbackLogger = false; // Prevent plain test logger fallback below
|
|
}
|
|
#endif
|
|
|
|
if (addFallbackLogger)
|
|
QTestLog::addLogger(QTestLog::Plain, logFilename);
|
|
}
|
|
|
|
// Temporary, backwards compatibility, until qtdeclarative's use of it is converted
|
|
Q_TESTLIB_EXPORT void qtest_qParseArgs(int argc, char *argv[], bool qml) {
|
|
qtest_qParseArgs(argc, const_cast<const char *const *>(argv), qml);
|
|
}
|
|
|
|
QBenchmarkResult qMedian(const QList<QBenchmarkResult> &container)
|
|
{
|
|
const int count = container.count();
|
|
if (count == 0)
|
|
return QBenchmarkResult();
|
|
|
|
if (count == 1)
|
|
return container.front();
|
|
|
|
QList<QBenchmarkResult> containerCopy = container;
|
|
std::sort(containerCopy.begin(), containerCopy.end());
|
|
|
|
const int middle = count / 2;
|
|
|
|
// ### handle even-sized containers here by doing an aritmetic mean of the two middle items.
|
|
return containerCopy.at(middle);
|
|
}
|
|
|
|
struct QTestDataSetter
|
|
{
|
|
QTestDataSetter(QTestData *data)
|
|
{
|
|
QTestResult::setCurrentTestData(data);
|
|
}
|
|
~QTestDataSetter()
|
|
{
|
|
QTestResult::setCurrentTestData(nullptr);
|
|
}
|
|
};
|
|
|
|
namespace {
|
|
|
|
qreal addResult(qreal current, const QBenchmarkResult& r)
|
|
{
|
|
return current + r.value;
|
|
}
|
|
|
|
}
|
|
|
|
void TestMethods::invokeTestOnData(int index) const
|
|
{
|
|
/* Benchmarking: for each median iteration*/
|
|
|
|
bool isBenchmark = false;
|
|
int i = (QBenchmarkGlobalData::current->measurer->needsWarmupIteration()) ? -1 : 0;
|
|
|
|
QList<QBenchmarkResult> results;
|
|
bool minimumTotalReached = false;
|
|
do {
|
|
QBenchmarkTestMethodData::current->beginDataRun();
|
|
|
|
/* Benchmarking: for each accumulation iteration*/
|
|
bool invokeOk;
|
|
do {
|
|
if (m_initMethod.isValid())
|
|
m_initMethod.invoke(QTest::currentTestObject, Qt::DirectConnection);
|
|
if (QTestResult::skipCurrentTest() || QTestResult::currentTestFailed())
|
|
break;
|
|
|
|
QBenchmarkTestMethodData::current->result = QBenchmarkResult();
|
|
QBenchmarkTestMethodData::current->resultAccepted = false;
|
|
|
|
QBenchmarkGlobalData::current->context.tag =
|
|
QLatin1String(
|
|
QTestResult::currentDataTag()
|
|
? QTestResult::currentDataTag() : "");
|
|
|
|
invokeOk = m_methods[index].invoke(QTest::currentTestObject, Qt::DirectConnection);
|
|
if (!invokeOk)
|
|
QTestResult::addFailure("Unable to execute slot", __FILE__, __LINE__);
|
|
|
|
isBenchmark = QBenchmarkTestMethodData::current->isBenchmark();
|
|
|
|
QTestResult::finishedCurrentTestData();
|
|
|
|
if (m_cleanupMethod.isValid())
|
|
m_cleanupMethod.invoke(QTest::currentTestObject, Qt::DirectConnection);
|
|
|
|
// Process any deleteLater(), like event-loop based apps would do. Fixes memleak reports.
|
|
if (QCoreApplication::instance())
|
|
QCoreApplication::sendPostedEvents(nullptr, QEvent::DeferredDelete);
|
|
|
|
// If the test isn't a benchmark, finalize the result after cleanup() has finished.
|
|
if (!isBenchmark)
|
|
QTestResult::finishedCurrentTestDataCleanup();
|
|
|
|
// If this test method has a benchmark, repeat until all measurements are
|
|
// acceptable.
|
|
// The QBENCHMARK macro increases the number of iterations for each run until
|
|
// this happens.
|
|
} while (invokeOk && isBenchmark
|
|
&& QBenchmarkTestMethodData::current->resultsAccepted() == false
|
|
&& !QTestResult::skipCurrentTest() && !QTestResult::currentTestFailed());
|
|
|
|
QBenchmarkTestMethodData::current->endDataRun();
|
|
if (!QTestResult::skipCurrentTest() && !QTestResult::currentTestFailed()) {
|
|
if (i > -1) // iteration -1 is the warmup iteration.
|
|
results.append(QBenchmarkTestMethodData::current->result);
|
|
|
|
if (isBenchmark && QBenchmarkGlobalData::current->verboseOutput) {
|
|
if (i == -1) {
|
|
QTestLog::info(qPrintable(
|
|
QString::fromLatin1("warmup stage result : %1")
|
|
.arg(QBenchmarkTestMethodData::current->result.value)), nullptr, 0);
|
|
} else {
|
|
QTestLog::info(qPrintable(
|
|
QString::fromLatin1("accumulation stage result: %1")
|
|
.arg(QBenchmarkTestMethodData::current->result.value)), nullptr, 0);
|
|
}
|
|
}
|
|
}
|
|
|
|
// Verify if the minimum total measurement is reached, if it was specified:
|
|
if (QBenchmarkGlobalData::current->minimumTotal == -1) {
|
|
minimumTotalReached = true;
|
|
} else {
|
|
const qreal total = std::accumulate(results.begin(), results.end(), 0.0, addResult);
|
|
minimumTotalReached = (total >= QBenchmarkGlobalData::current->minimumTotal);
|
|
}
|
|
} while (isBenchmark
|
|
&& ((++i < QBenchmarkGlobalData::current->adjustMedianIterationCount()) || !minimumTotalReached)
|
|
&& !QTestResult::skipCurrentTest() && !QTestResult::currentTestFailed());
|
|
|
|
// If the test is a benchmark, finalize the result after all iterations have finished.
|
|
if (isBenchmark) {
|
|
bool testPassed = !QTestResult::skipCurrentTest() && !QTestResult::currentTestFailed();
|
|
QTestResult::finishedCurrentTestDataCleanup();
|
|
// Only report benchmark figures if the test passed
|
|
if (testPassed && QBenchmarkTestMethodData::current->resultsAccepted())
|
|
QTestLog::addBenchmarkResult(qMedian(results));
|
|
}
|
|
}
|
|
|
|
#if QT_CONFIG(thread)
|
|
|
|
class WatchDog : public QThread
|
|
{
|
|
enum Expectation {
|
|
ThreadStart,
|
|
TestFunctionStart,
|
|
TestFunctionEnd,
|
|
ThreadEnd,
|
|
};
|
|
|
|
bool waitFor(std::unique_lock<QtPrivate::mutex> &m, Expectation e) {
|
|
auto expectationChanged = [this, e] { return expecting != e; };
|
|
switch (e) {
|
|
case TestFunctionEnd:
|
|
return waitCondition.wait_for(m, defaultTimeout(), expectationChanged);
|
|
case ThreadStart:
|
|
case ThreadEnd:
|
|
case TestFunctionStart:
|
|
waitCondition.wait(m, expectationChanged);
|
|
return true;
|
|
}
|
|
Q_UNREACHABLE();
|
|
return false;
|
|
}
|
|
|
|
public:
|
|
WatchDog()
|
|
{
|
|
auto locker = qt_unique_lock(mutex);
|
|
expecting = ThreadStart;
|
|
start();
|
|
waitFor(locker, ThreadStart);
|
|
}
|
|
~WatchDog() {
|
|
{
|
|
const auto locker = qt_scoped_lock(mutex);
|
|
expecting = ThreadEnd;
|
|
waitCondition.notify_all();
|
|
}
|
|
wait();
|
|
}
|
|
|
|
void beginTest() {
|
|
const auto locker = qt_scoped_lock(mutex);
|
|
expecting = TestFunctionEnd;
|
|
waitCondition.notify_all();
|
|
}
|
|
|
|
void testFinished() {
|
|
const auto locker = qt_scoped_lock(mutex);
|
|
expecting = TestFunctionStart;
|
|
waitCondition.notify_all();
|
|
}
|
|
|
|
void run() override {
|
|
auto locker = qt_unique_lock(mutex);
|
|
expecting = TestFunctionStart;
|
|
waitCondition.notify_all();
|
|
while (true) {
|
|
switch (expecting) {
|
|
case ThreadEnd:
|
|
return;
|
|
case ThreadStart:
|
|
Q_UNREACHABLE();
|
|
case TestFunctionStart:
|
|
case TestFunctionEnd:
|
|
if (Q_UNLIKELY(!waitFor(locker, expecting))) {
|
|
stackTrace();
|
|
qFatal("Test function timed out");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
private:
|
|
QtPrivate::mutex mutex;
|
|
QtPrivate::condition_variable waitCondition;
|
|
Expectation expecting;
|
|
};
|
|
|
|
#else // !QT_CONFIG(thread)
|
|
|
|
class WatchDog : public QObject
|
|
{
|
|
public:
|
|
void beginTest() {};
|
|
void testFinished() {};
|
|
};
|
|
|
|
#endif
|
|
|
|
|
|
/*!
|
|
\internal
|
|
|
|
Call slot_data(), init(), slot(), cleanup(), init(), slot(), cleanup(), ...
|
|
If data is set then it is the only test that is performed
|
|
|
|
If the function was successfully called, true is returned, otherwise
|
|
false.
|
|
*/
|
|
bool TestMethods::invokeTest(int index, const char *data, WatchDog *watchDog) const
|
|
{
|
|
QBenchmarkTestMethodData benchmarkData;
|
|
QBenchmarkTestMethodData::current = &benchmarkData;
|
|
|
|
const QByteArray &name = m_methods[index].name();
|
|
QBenchmarkGlobalData::current->context.slotName = QLatin1String(name) + QLatin1String("()");
|
|
|
|
char member[512];
|
|
QTestTable table;
|
|
|
|
QTestResult::setCurrentTestFunction(name.constData());
|
|
|
|
const QTestTable *gTable = QTestTable::globalTestTable();
|
|
const int globalDataCount = gTable->dataCount();
|
|
int curGlobalDataIndex = 0;
|
|
|
|
/* For each entry in the global data table, do: */
|
|
do {
|
|
if (!gTable->isEmpty())
|
|
QTestResult::setCurrentGlobalTestData(gTable->testData(curGlobalDataIndex));
|
|
|
|
if (curGlobalDataIndex == 0) {
|
|
qsnprintf(member, 512, "%s_data()", name.constData());
|
|
invokeMethod(QTest::currentTestObject, member);
|
|
if (QTestResult::skipCurrentTest())
|
|
break;
|
|
}
|
|
|
|
bool foundFunction = false;
|
|
int curDataIndex = 0;
|
|
const int dataCount = table.dataCount();
|
|
|
|
// Data tag requested but none available?
|
|
if (data && !dataCount) {
|
|
// Let empty data tag through.
|
|
if (!*data)
|
|
data = nullptr;
|
|
else {
|
|
fprintf(stderr, "Unknown testdata for function %s(): '%s'\n", name.constData(), data);
|
|
fprintf(stderr, "Function has no testdata.\n");
|
|
return false;
|
|
}
|
|
}
|
|
|
|
/* For each entry in this test's data table, do: */
|
|
do {
|
|
QTestResult::setSkipCurrentTest(false);
|
|
QTestResult::setBlacklistCurrentTest(false);
|
|
if (!data || !qstrcmp(data, table.testData(curDataIndex)->dataTag())) {
|
|
foundFunction = true;
|
|
|
|
QTestPrivate::checkBlackLists(name.constData(), dataCount ? table.testData(curDataIndex)->dataTag() : nullptr);
|
|
|
|
QTestDataSetter s(curDataIndex >= dataCount ? nullptr : table.testData(curDataIndex));
|
|
|
|
QTestPrivate::qtestMouseButtons = Qt::NoButton;
|
|
if (watchDog)
|
|
watchDog->beginTest();
|
|
QTest::lastMouseTimestamp += 500; // Maintain at least 500ms mouse event timestamps between each test function call
|
|
invokeTestOnData(index);
|
|
if (watchDog)
|
|
watchDog->testFinished();
|
|
|
|
if (data)
|
|
break;
|
|
}
|
|
++curDataIndex;
|
|
} while (curDataIndex < dataCount);
|
|
|
|
if (data && !foundFunction) {
|
|
fprintf(stderr, "Unknown testdata for function %s: '%s()'\n", name.constData(), data);
|
|
fprintf(stderr, "Available testdata:\n");
|
|
for (int i = 0; i < table.dataCount(); ++i)
|
|
fprintf(stderr, "%s\n", table.testData(i)->dataTag());
|
|
return false;
|
|
}
|
|
|
|
QTestResult::setCurrentGlobalTestData(nullptr);
|
|
++curGlobalDataIndex;
|
|
} while (curGlobalDataIndex < globalDataCount);
|
|
|
|
QTestResult::finishedCurrentTestFunction();
|
|
QTestResult::setSkipCurrentTest(false);
|
|
QTestResult::setBlacklistCurrentTest(false);
|
|
QTestResult::setCurrentTestData(nullptr);
|
|
|
|
return true;
|
|
}
|
|
|
|
void *fetchData(QTestData *data, const char *tagName, int typeId)
|
|
{
|
|
QTEST_ASSERT(typeId);
|
|
QTEST_ASSERT_X(data, "QTest::fetchData()", "Test data requested, but no testdata available.");
|
|
QTEST_ASSERT(data->parent());
|
|
|
|
int idx = data->parent()->indexOf(tagName);
|
|
|
|
if (Q_UNLIKELY(idx == -1 || idx >= data->dataCount())) {
|
|
qFatal("QFETCH: Requested testdata '%s' not available, check your _data function.",
|
|
tagName);
|
|
}
|
|
|
|
if (Q_UNLIKELY(typeId != data->parent()->elementTypeId(idx))) {
|
|
qFatal("Requested type '%s' does not match available type '%s'.",
|
|
QMetaType::typeName(typeId),
|
|
QMetaType::typeName(data->parent()->elementTypeId(idx)));
|
|
}
|
|
|
|
return data->data(idx);
|
|
}
|
|
|
|
/*!
|
|
* \internal
|
|
*/
|
|
char *formatString(const char *prefix, const char *suffix, size_t numArguments, ...)
|
|
{
|
|
va_list ap;
|
|
va_start(ap, numArguments);
|
|
|
|
QByteArray arguments;
|
|
arguments += prefix;
|
|
|
|
if (numArguments > 0) {
|
|
arguments += va_arg(ap, const char *);
|
|
|
|
for (size_t i = 1; i < numArguments; ++i) {
|
|
arguments += ", ";
|
|
arguments += va_arg(ap, const char *);
|
|
}
|
|
}
|
|
|
|
va_end(ap);
|
|
arguments += suffix;
|
|
return qstrdup(arguments.constData());
|
|
}
|
|
|
|
/*!
|
|
\fn char* QTest::toHexRepresentation(const char *ba, int length)
|
|
|
|
Returns a pointer to a string that is the string \a ba represented
|
|
as a space-separated sequence of hex characters. If the input is
|
|
considered too long, it is truncated. A trucation is indicated in
|
|
the returned string as an ellipsis at the end. The caller has
|
|
ownership of the returned pointer and must ensure it is later passed
|
|
to operator delete[].
|
|
|
|
\a length is the length of the string \a ba.
|
|
*/
|
|
char *toHexRepresentation(const char *ba, int length)
|
|
{
|
|
if (length == 0)
|
|
return qstrdup("");
|
|
|
|
/* We output at maximum about maxLen characters in order to avoid
|
|
* running out of memory and flooding things when the byte array
|
|
* is large.
|
|
*
|
|
* maxLen can't be for example 200 because Qt Test is sprinkled with fixed
|
|
* size char arrays.
|
|
* */
|
|
const int maxLen = 50;
|
|
const int len = qMin(maxLen, length);
|
|
char *result = nullptr;
|
|
|
|
if (length > maxLen) {
|
|
const int size = len * 3 + 4;
|
|
result = new char[size];
|
|
|
|
char *const forElipsis = result + size - 5;
|
|
forElipsis[0] = ' ';
|
|
forElipsis[1] = '.';
|
|
forElipsis[2] = '.';
|
|
forElipsis[3] = '.';
|
|
result[size - 1] = '\0';
|
|
}
|
|
else {
|
|
const int size = len * 3;
|
|
result = new char[size];
|
|
result[size - 1] = '\0';
|
|
}
|
|
|
|
int i = 0;
|
|
int o = 0;
|
|
|
|
while (true) {
|
|
const char at = ba[i];
|
|
|
|
result[o] = toHexUpper(at >> 4);
|
|
++o;
|
|
result[o] = toHexUpper(at);
|
|
|
|
++i;
|
|
++o;
|
|
if (i == len)
|
|
break;
|
|
result[o] = ' ';
|
|
++o;
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
/*!
|
|
\internal
|
|
Returns the same QByteArray but with only the ASCII characters still shown;
|
|
everything else is replaced with \c {\xHH}.
|
|
*/
|
|
char *toPrettyCString(const char *p, int length)
|
|
{
|
|
bool trimmed = false;
|
|
QScopedArrayPointer<char> buffer(new char[256]);
|
|
const char *end = p + length;
|
|
char *dst = buffer.data();
|
|
|
|
bool lastWasHexEscape = false;
|
|
*dst++ = '"';
|
|
for ( ; p != end; ++p) {
|
|
// we can add:
|
|
// 1 byte: a single character
|
|
// 2 bytes: a simple escape sequence (\n)
|
|
// 3 bytes: "" and a character
|
|
// 4 bytes: an hex escape sequence (\xHH)
|
|
if (dst - buffer.data() > 246) {
|
|
// plus the quote, the three dots and NUL, it's 255 in the worst case
|
|
trimmed = true;
|
|
break;
|
|
}
|
|
|
|
// check if we need to insert "" to break an hex escape sequence
|
|
if (Q_UNLIKELY(lastWasHexEscape)) {
|
|
if (fromHex(*p) != -1) {
|
|
// yes, insert it
|
|
*dst++ = '"';
|
|
*dst++ = '"';
|
|
}
|
|
lastWasHexEscape = false;
|
|
}
|
|
|
|
if (*p < 0x7f && *p >= 0x20 && *p != '\\' && *p != '"') {
|
|
*dst++ = *p;
|
|
continue;
|
|
}
|
|
|
|
// write as an escape sequence
|
|
// this means we may advance dst to buffer.data() + 247 or 250
|
|
*dst++ = '\\';
|
|
switch (*p) {
|
|
case 0x5c:
|
|
case 0x22:
|
|
*dst++ = uchar(*p);
|
|
break;
|
|
case 0x8:
|
|
*dst++ = 'b';
|
|
break;
|
|
case 0xc:
|
|
*dst++ = 'f';
|
|
break;
|
|
case 0xa:
|
|
*dst++ = 'n';
|
|
break;
|
|
case 0xd:
|
|
*dst++ = 'r';
|
|
break;
|
|
case 0x9:
|
|
*dst++ = 't';
|
|
break;
|
|
default:
|
|
// print as hex escape
|
|
*dst++ = 'x';
|
|
*dst++ = toHexUpper(uchar(*p) >> 4);
|
|
*dst++ = toHexUpper(uchar(*p));
|
|
lastWasHexEscape = true;
|
|
break;
|
|
}
|
|
}
|
|
|
|
*dst++ = '"';
|
|
if (trimmed) {
|
|
*dst++ = '.';
|
|
*dst++ = '.';
|
|
*dst++ = '.';
|
|
}
|
|
*dst++ = '\0';
|
|
return buffer.take();
|
|
}
|
|
|
|
#if QT_VERSION < QT_VERSION_CHECK(6, 0, 0)
|
|
// this used to be the signature up to and including Qt 5.9
|
|
// keep it for BC reasons:
|
|
Q_TESTLIB_EXPORT
|
|
char *toPrettyUnicode(const ushort *p, int length)
|
|
{
|
|
return toPrettyUnicode(QStringView(p, length));
|
|
}
|
|
#endif
|
|
|
|
/*!
|
|
\internal
|
|
Returns the same QString but with only the ASCII characters still shown;
|
|
everything else is replaced with \c {\uXXXX}.
|
|
|
|
Similar to QDebug::putString().
|
|
*/
|
|
char *toPrettyUnicode(QStringView string)
|
|
{
|
|
auto p = reinterpret_cast<const ushort *>(string.utf16());
|
|
auto length = string.size();
|
|
// keep it simple for the vast majority of cases
|
|
bool trimmed = false;
|
|
QScopedArrayPointer<char> buffer(new char[256]);
|
|
const ushort *end = p + length;
|
|
char *dst = buffer.data();
|
|
|
|
*dst++ = '"';
|
|
for ( ; p != end; ++p) {
|
|
if (dst - buffer.data() > 245) {
|
|
// plus the quote, the three dots and NUL, it's 250, 251 or 255
|
|
trimmed = true;
|
|
break;
|
|
}
|
|
|
|
if (*p < 0x7f && *p >= 0x20 && *p != '\\' && *p != '"') {
|
|
*dst++ = *p;
|
|
continue;
|
|
}
|
|
|
|
// write as an escape sequence
|
|
// this means we may advance dst to buffer.data() + 246 or 250
|
|
*dst++ = '\\';
|
|
switch (*p) {
|
|
case 0x22:
|
|
case 0x5c:
|
|
*dst++ = uchar(*p);
|
|
break;
|
|
case 0x8:
|
|
*dst++ = 'b';
|
|
break;
|
|
case 0xc:
|
|
*dst++ = 'f';
|
|
break;
|
|
case 0xa:
|
|
*dst++ = 'n';
|
|
break;
|
|
case 0xd:
|
|
*dst++ = 'r';
|
|
break;
|
|
case 0x9:
|
|
*dst++ = 't';
|
|
break;
|
|
default:
|
|
*dst++ = 'u';
|
|
*dst++ = toHexUpper(*p >> 12);
|
|
*dst++ = toHexUpper(*p >> 8);
|
|
*dst++ = toHexUpper(*p >> 4);
|
|
*dst++ = toHexUpper(*p);
|
|
}
|
|
}
|
|
|
|
*dst++ = '"';
|
|
if (trimmed) {
|
|
*dst++ = '.';
|
|
*dst++ = '.';
|
|
*dst++ = '.';
|
|
}
|
|
*dst++ = '\0';
|
|
return buffer.take();
|
|
}
|
|
|
|
void TestMethods::invokeTests(QObject *testObject) const
|
|
{
|
|
const QMetaObject *metaObject = testObject->metaObject();
|
|
QTEST_ASSERT(metaObject);
|
|
QTestResult::setCurrentTestFunction("initTestCase");
|
|
if (m_initTestCaseDataMethod.isValid())
|
|
m_initTestCaseDataMethod.invoke(testObject, Qt::DirectConnection);
|
|
|
|
QScopedPointer<WatchDog> watchDog;
|
|
if (!debuggerPresent()
|
|
#if QT_CONFIG(valgrind)
|
|
&& QBenchmarkGlobalData::current->mode() != QBenchmarkGlobalData::CallgrindChildProcess
|
|
#endif
|
|
) {
|
|
watchDog.reset(new WatchDog);
|
|
}
|
|
|
|
QSignalDumper::startDump();
|
|
|
|
if (!QTestResult::skipCurrentTest() && !QTest::currentTestFailed()) {
|
|
if (m_initTestCaseMethod.isValid())
|
|
m_initTestCaseMethod.invoke(testObject, Qt::DirectConnection);
|
|
|
|
// finishedCurrentTestDataCleanup() resets QTestResult::currentTestFailed(), so use a local copy.
|
|
const bool previousFailed = QTestResult::currentTestFailed();
|
|
QTestResult::finishedCurrentTestData();
|
|
QTestResult::finishedCurrentTestDataCleanup();
|
|
QTestResult::finishedCurrentTestFunction();
|
|
|
|
if (!QTestResult::skipCurrentTest() && !previousFailed) {
|
|
for (int i = 0, count = int(m_methods.size()); i < count; ++i) {
|
|
const char *data = nullptr;
|
|
if (i < QTest::testTags.size() && !QTest::testTags.at(i).isEmpty())
|
|
data = qstrdup(QTest::testTags.at(i).toLatin1().constData());
|
|
const bool ok = invokeTest(i, data, watchDog.data());
|
|
delete [] data;
|
|
if (!ok)
|
|
break;
|
|
}
|
|
}
|
|
|
|
QTestResult::setSkipCurrentTest(false);
|
|
QTestResult::setBlacklistCurrentTest(false);
|
|
QTestResult::setCurrentTestFunction("cleanupTestCase");
|
|
if (m_cleanupTestCaseMethod.isValid())
|
|
m_cleanupTestCaseMethod.invoke(testObject, Qt::DirectConnection);
|
|
QTestResult::finishedCurrentTestData();
|
|
QTestResult::finishedCurrentTestDataCleanup();
|
|
}
|
|
QTestResult::finishedCurrentTestFunction();
|
|
QTestResult::setCurrentTestFunction(nullptr);
|
|
|
|
QSignalDumper::endDump();
|
|
}
|
|
|
|
#if defined(Q_OS_WIN)
|
|
|
|
// Helper class for resolving symbol names by dynamically loading "dbghelp.dll".
|
|
class DebugSymbolResolver
|
|
{
|
|
Q_DISABLE_COPY_MOVE(DebugSymbolResolver)
|
|
public:
|
|
struct Symbol {
|
|
Symbol() : name(nullptr), address(0) {}
|
|
|
|
const char *name; // Must be freed by caller.
|
|
DWORD64 address;
|
|
};
|
|
|
|
explicit DebugSymbolResolver(HANDLE process);
|
|
~DebugSymbolResolver() { cleanup(); }
|
|
|
|
bool isValid() const { return m_symFromAddr; }
|
|
|
|
Symbol resolveSymbol(DWORD64 address) const;
|
|
|
|
private:
|
|
// typedefs from DbgHelp.h/.dll
|
|
struct DBGHELP_SYMBOL_INFO { // SYMBOL_INFO
|
|
ULONG SizeOfStruct;
|
|
ULONG TypeIndex; // Type Index of symbol
|
|
ULONG64 Reserved[2];
|
|
ULONG Index;
|
|
ULONG Size;
|
|
ULONG64 ModBase; // Base Address of module comtaining this symbol
|
|
ULONG Flags;
|
|
ULONG64 Value; // Value of symbol, ValuePresent should be 1
|
|
ULONG64 Address; // Address of symbol including base address of module
|
|
ULONG Register; // register holding value or pointer to value
|
|
ULONG Scope; // scope of the symbol
|
|
ULONG Tag; // pdb classification
|
|
ULONG NameLen; // Actual length of name
|
|
ULONG MaxNameLen;
|
|
CHAR Name[1]; // Name of symbol
|
|
};
|
|
|
|
typedef BOOL (__stdcall *SymInitializeType)(HANDLE, PCSTR, BOOL);
|
|
typedef BOOL (__stdcall *SymFromAddrType)(HANDLE, DWORD64, PDWORD64, DBGHELP_SYMBOL_INFO *);
|
|
|
|
void cleanup();
|
|
|
|
const HANDLE m_process;
|
|
HMODULE m_dbgHelpLib;
|
|
SymFromAddrType m_symFromAddr;
|
|
};
|
|
|
|
void DebugSymbolResolver::cleanup()
|
|
{
|
|
if (m_dbgHelpLib)
|
|
FreeLibrary(m_dbgHelpLib);
|
|
m_dbgHelpLib = 0;
|
|
m_symFromAddr = nullptr;
|
|
}
|
|
|
|
DebugSymbolResolver::DebugSymbolResolver(HANDLE process)
|
|
: m_process(process), m_dbgHelpLib(0), m_symFromAddr(nullptr)
|
|
{
|
|
bool success = false;
|
|
m_dbgHelpLib = LoadLibraryW(L"dbghelp.dll");
|
|
if (m_dbgHelpLib) {
|
|
SymInitializeType symInitialize = reinterpret_cast<SymInitializeType>(
|
|
reinterpret_cast<QFunctionPointer>(GetProcAddress(m_dbgHelpLib, "SymInitialize")));
|
|
m_symFromAddr = reinterpret_cast<SymFromAddrType>(
|
|
reinterpret_cast<QFunctionPointer>(GetProcAddress(m_dbgHelpLib, "SymFromAddr")));
|
|
success = symInitialize && m_symFromAddr && symInitialize(process, NULL, TRUE);
|
|
}
|
|
if (!success)
|
|
cleanup();
|
|
}
|
|
|
|
DebugSymbolResolver::Symbol DebugSymbolResolver::resolveSymbol(DWORD64 address) const
|
|
{
|
|
// reserve additional buffer where SymFromAddr() will store the name
|
|
struct NamedSymbolInfo : public DBGHELP_SYMBOL_INFO {
|
|
enum { symbolNameLength = 255 };
|
|
|
|
char name[symbolNameLength + 1];
|
|
};
|
|
|
|
Symbol result;
|
|
if (!isValid())
|
|
return result;
|
|
NamedSymbolInfo symbolBuffer;
|
|
memset(&symbolBuffer, 0, sizeof(NamedSymbolInfo));
|
|
symbolBuffer.MaxNameLen = NamedSymbolInfo::symbolNameLength;
|
|
symbolBuffer.SizeOfStruct = sizeof(DBGHELP_SYMBOL_INFO);
|
|
if (!m_symFromAddr(m_process, address, 0, &symbolBuffer))
|
|
return result;
|
|
result.name = qstrdup(symbolBuffer.Name);
|
|
result.address = symbolBuffer.Address;
|
|
return result;
|
|
}
|
|
|
|
#endif // Q_OS_WIN
|
|
|
|
class FatalSignalHandler
|
|
{
|
|
public:
|
|
FatalSignalHandler()
|
|
{
|
|
#if defined(Q_OS_WIN)
|
|
# if !defined(Q_CC_MINGW)
|
|
_CrtSetReportMode(_CRT_ERROR, _CRTDBG_MODE_DEBUG);
|
|
# endif
|
|
SetErrorMode(SetErrorMode(0) | SEM_NOGPFAULTERRORBOX);
|
|
SetUnhandledExceptionFilter(windowsFaultHandler);
|
|
#elif defined(Q_OS_UNIX) && !defined(Q_OS_WASM)
|
|
sigemptyset(&handledSignals);
|
|
|
|
const int fatalSignals[] = {
|
|
SIGHUP, SIGINT, SIGQUIT, SIGILL, SIGBUS, SIGFPE, SIGSEGV, SIGPIPE, SIGTERM, 0 };
|
|
|
|
struct sigaction act;
|
|
memset(&act, 0, sizeof(act));
|
|
act.sa_handler = FatalSignalHandler::signal;
|
|
|
|
// Remove the handler after it is invoked.
|
|
# if !defined(Q_OS_INTEGRITY)
|
|
act.sa_flags = SA_RESETHAND;
|
|
# endif
|
|
|
|
// tvOS/watchOS both define SA_ONSTACK (in sys/signal.h) but mark sigaltstack() as
|
|
// unavailable (__WATCHOS_PROHIBITED __TVOS_PROHIBITED in signal.h)
|
|
# if defined(SA_ONSTACK) && !defined(Q_OS_TVOS) && !defined(Q_OS_WATCHOS)
|
|
// Let the signal handlers use an alternate stack
|
|
// This is necessary if SIGSEGV is to catch a stack overflow
|
|
# if defined(Q_CC_GNU) && defined(Q_OF_ELF)
|
|
// Put the alternate stack in the .lbss (large BSS) section so that it doesn't
|
|
// interfere with normal .bss symbols
|
|
__attribute__((section(".lbss.altstack"), aligned(4096)))
|
|
# endif
|
|
static char alternate_stack[16 * 1024];
|
|
stack_t stack;
|
|
stack.ss_flags = 0;
|
|
stack.ss_size = sizeof alternate_stack;
|
|
stack.ss_sp = alternate_stack;
|
|
sigaltstack(&stack, nullptr);
|
|
act.sa_flags |= SA_ONSTACK;
|
|
# endif
|
|
|
|
// Block all fatal signals in our signal handler so we don't try to close
|
|
// the testlog twice.
|
|
sigemptyset(&act.sa_mask);
|
|
for (int i = 0; fatalSignals[i]; ++i)
|
|
sigaddset(&act.sa_mask, fatalSignals[i]);
|
|
|
|
struct sigaction oldact;
|
|
|
|
for (int i = 0; fatalSignals[i]; ++i) {
|
|
sigaction(fatalSignals[i], &act, &oldact);
|
|
if (
|
|
# ifdef SA_SIGINFO
|
|
oldact.sa_flags & SA_SIGINFO ||
|
|
# endif
|
|
oldact.sa_handler != SIG_DFL) {
|
|
sigaction(fatalSignals[i], &oldact, nullptr);
|
|
} else
|
|
{
|
|
sigaddset(&handledSignals, fatalSignals[i]);
|
|
}
|
|
}
|
|
#endif // defined(Q_OS_UNIX) && !defined(Q_OS_WASM)
|
|
}
|
|
|
|
~FatalSignalHandler()
|
|
{
|
|
#if defined(Q_OS_UNIX) && !defined(Q_OS_WASM)
|
|
// Unregister any of our remaining signal handlers
|
|
struct sigaction act;
|
|
memset(&act, 0, sizeof(act));
|
|
act.sa_handler = SIG_DFL;
|
|
|
|
struct sigaction oldact;
|
|
|
|
for (int i = 1; i < 32; ++i) {
|
|
if (!sigismember(&handledSignals, i))
|
|
continue;
|
|
sigaction(i, &act, &oldact);
|
|
|
|
// If someone overwrote it in the mean time, put it back
|
|
if (oldact.sa_handler != FatalSignalHandler::signal)
|
|
sigaction(i, &oldact, nullptr);
|
|
}
|
|
#endif
|
|
}
|
|
|
|
private:
|
|
#if defined(Q_OS_WIN)
|
|
static LONG WINAPI windowsFaultHandler(struct _EXCEPTION_POINTERS *exInfo)
|
|
{
|
|
enum { maxStackFrames = 100 };
|
|
char appName[MAX_PATH];
|
|
if (!GetModuleFileNameA(NULL, appName, MAX_PATH))
|
|
appName[0] = 0;
|
|
const int msecsFunctionTime = qRound(QTestLog::msecsFunctionTime());
|
|
const int msecsTotalTime = qRound(QTestLog::msecsTotalTime());
|
|
const void *exceptionAddress = exInfo->ExceptionRecord->ExceptionAddress;
|
|
printf("A crash occurred in %s.\n"
|
|
"Function time: %dms Total time: %dms\n\n"
|
|
"Exception address: 0x%p\n"
|
|
"Exception code : 0x%lx\n",
|
|
appName, msecsFunctionTime, msecsTotalTime,
|
|
exceptionAddress, exInfo->ExceptionRecord->ExceptionCode);
|
|
|
|
DebugSymbolResolver resolver(GetCurrentProcess());
|
|
if (resolver.isValid()) {
|
|
DebugSymbolResolver::Symbol exceptionSymbol = resolver.resolveSymbol(DWORD64(exceptionAddress));
|
|
if (exceptionSymbol.name) {
|
|
printf("Nearby symbol : %s\n", exceptionSymbol.name);
|
|
delete [] exceptionSymbol.name;
|
|
}
|
|
void *stack[maxStackFrames];
|
|
fputs("\nStack:\n", stdout);
|
|
const unsigned frameCount = CaptureStackBackTrace(0, DWORD(maxStackFrames), stack, NULL);
|
|
for (unsigned f = 0; f < frameCount; ++f) {
|
|
DebugSymbolResolver::Symbol symbol = resolver.resolveSymbol(DWORD64(stack[f]));
|
|
if (symbol.name) {
|
|
printf("#%3u: %s() - 0x%p\n", f + 1, symbol.name, (const void *)symbol.address);
|
|
delete [] symbol.name;
|
|
} else {
|
|
printf("#%3u: Unable to obtain symbol\n", f + 1);
|
|
}
|
|
}
|
|
}
|
|
|
|
fputc('\n', stdout);
|
|
fflush(stdout);
|
|
|
|
return EXCEPTION_EXECUTE_HANDLER;
|
|
}
|
|
#endif // defined(Q_OS_WIN)
|
|
|
|
#if defined(Q_OS_UNIX) && !defined(Q_OS_WASM)
|
|
static void signal(int signum)
|
|
{
|
|
const int msecsFunctionTime = qRound(QTestLog::msecsFunctionTime());
|
|
const int msecsTotalTime = qRound(QTestLog::msecsTotalTime());
|
|
if (signum != SIGINT) {
|
|
stackTrace();
|
|
if (qEnvironmentVariableIsSet("QTEST_PAUSE_ON_CRASH")) {
|
|
fprintf(stderr, "Pausing process %d for debugging\n", getpid());
|
|
raise(SIGSTOP);
|
|
}
|
|
}
|
|
qFatal("Received signal %d\n"
|
|
" Function time: %dms Total time: %dms",
|
|
signum, msecsFunctionTime, msecsTotalTime);
|
|
# if defined(Q_OS_INTEGRITY)
|
|
{
|
|
struct sigaction act;
|
|
memset(&act, 0, sizeof(struct sigaction));
|
|
act.sa_handler = SIG_DFL;
|
|
sigaction(signum, &act, NULL);
|
|
}
|
|
# endif
|
|
}
|
|
|
|
sigset_t handledSignals;
|
|
#endif // defined(Q_OS_UNIX) && !defined(Q_OS_WASM)
|
|
};
|
|
|
|
} // namespace
|
|
|
|
static void initEnvironment()
|
|
{
|
|
qputenv("QT_QTESTLIB_RUNNING", "1");
|
|
}
|
|
|
|
/*!
|
|
Executes tests declared in \a testObject. In addition, the private slots
|
|
\c{initTestCase()}, \c{cleanupTestCase()}, \c{init()} and \c{cleanup()}
|
|
are executed if they exist. See \l{Creating a Test} for more details.
|
|
|
|
Optionally, the command line arguments \a argc and \a argv can be provided.
|
|
For a list of recognized arguments, read \l {Qt Test Command Line Arguments}.
|
|
|
|
The following example will run all tests in \c MyTestObject:
|
|
|
|
\snippet code/src_qtestlib_qtestcase.cpp 18
|
|
|
|
This function returns 0 if no tests failed, or a value other than 0 if one
|
|
or more tests failed or in case of unhandled exceptions. (Skipped tests do
|
|
not influence the return value.)
|
|
|
|
For stand-alone test applications, the convenience macro \l QTEST_MAIN() can
|
|
be used to declare a main() function that parses the command line arguments
|
|
and executes the tests, avoiding the need to call this function explicitly.
|
|
|
|
The return value from this function is also the exit code of the test
|
|
application when the \l QTEST_MAIN() macro is used.
|
|
|
|
For stand-alone test applications, this function should not be called more
|
|
than once, as command-line options for logging test output to files and
|
|
executing individual test functions will not behave correctly.
|
|
|
|
Note: This function is not reentrant, only one test can run at a time. A
|
|
test that was executed with qExec() can't run another test via qExec() and
|
|
threads are not allowed to call qExec() simultaneously.
|
|
|
|
If you have programatically created the arguments, as opposed to getting them
|
|
from the arguments in \c main(), it is likely of interest to use
|
|
QTest::qExec(QObject *, const QStringList &) since it is Unicode safe.
|
|
|
|
\sa QTEST_MAIN()
|
|
*/
|
|
|
|
int QTest::qExec(QObject *testObject, int argc, char **argv)
|
|
{
|
|
qInit(testObject, argc, argv);
|
|
int ret = qRun();
|
|
qCleanup();
|
|
return ret;
|
|
}
|
|
|
|
/*! \internal
|
|
*/
|
|
void QTest::qInit(QObject *testObject, int argc, char **argv)
|
|
{
|
|
initEnvironment();
|
|
QBenchmarkGlobalData::current = new QBenchmarkGlobalData;
|
|
|
|
#if defined(Q_OS_MACOS)
|
|
// Don't restore saved window state for auto tests
|
|
QTestPrivate::disableWindowRestore();
|
|
|
|
// Disable App Nap which may cause tests to stall
|
|
QTestPrivate::AppNapDisabler appNapDisabler;
|
|
|
|
if (qApp && (qstrcmp(qApp->metaObject()->className(), "QApplication") == 0)) {
|
|
IOPMAssertionCreateWithName(kIOPMAssertionTypeNoDisplaySleep,
|
|
kIOPMAssertionLevelOn, CFSTR("QtTest running tests"),
|
|
&macPowerSavingDisabled);
|
|
}
|
|
#endif
|
|
|
|
QTestPrivate::parseBlackList();
|
|
QTestResult::reset();
|
|
|
|
QTEST_ASSERT(testObject);
|
|
QTEST_ASSERT(!currentTestObject);
|
|
currentTestObject = testObject;
|
|
|
|
const QMetaObject *metaObject = testObject->metaObject();
|
|
QTEST_ASSERT(metaObject);
|
|
|
|
QTestResult::setCurrentTestObject(metaObject->className());
|
|
if (argc > 0)
|
|
QTestResult::setCurrentAppName(argv[0]);
|
|
|
|
qtest_qParseArgs(argc, argv, false);
|
|
|
|
QTestTable::globalTestTable();
|
|
QTestLog::startLogging();
|
|
}
|
|
|
|
/*! \internal
|
|
*/
|
|
int QTest::qRun()
|
|
{
|
|
QTEST_ASSERT(currentTestObject);
|
|
|
|
#if QT_CONFIG(valgrind)
|
|
int callgrindChildExitCode = 0;
|
|
#endif
|
|
|
|
#ifndef QT_NO_EXCEPTIONS
|
|
try {
|
|
#endif
|
|
|
|
#if QT_CONFIG(valgrind)
|
|
if (QBenchmarkGlobalData::current->mode() == QBenchmarkGlobalData::CallgrindParentProcess) {
|
|
if (Q_UNLIKELY(!qApp))
|
|
qFatal("QtTest: -callgrind option is not available with QTEST_APPLESS_MAIN");
|
|
|
|
const QStringList origAppArgs(QCoreApplication::arguments());
|
|
if (!QBenchmarkValgrindUtils::rerunThroughCallgrind(origAppArgs, callgrindChildExitCode))
|
|
return -1;
|
|
|
|
QBenchmarkValgrindUtils::cleanup();
|
|
|
|
} else
|
|
#endif
|
|
{
|
|
QScopedPointer<FatalSignalHandler> handler;
|
|
if (!noCrashHandler)
|
|
handler.reset(new FatalSignalHandler);
|
|
|
|
TestMethods::MetaMethods commandLineMethods;
|
|
for (const QString &tf : qAsConst(QTest::testFunctions)) {
|
|
const QByteArray tfB = tf.toLatin1();
|
|
const QByteArray signature = tfB + QByteArrayLiteral("()");
|
|
QMetaMethod m = TestMethods::findMethod(currentTestObject, signature.constData());
|
|
if (!m.isValid() || !isValidSlot(m)) {
|
|
fprintf(stderr, "Unknown test function: '%s'. Possible matches:\n", tfB.constData());
|
|
qPrintTestSlots(stderr, tfB.constData());
|
|
fprintf(stderr, "\n%s -functions\nlists all available test functions.\n", QTestResult::currentAppName());
|
|
exit(1);
|
|
}
|
|
commandLineMethods.push_back(m);
|
|
}
|
|
TestMethods test(currentTestObject, commandLineMethods);
|
|
test.invokeTests(currentTestObject);
|
|
}
|
|
|
|
#ifndef QT_NO_EXCEPTIONS
|
|
} catch (...) {
|
|
QTestResult::addFailure("Caught unhandled exception", __FILE__, __LINE__);
|
|
if (QTestResult::currentTestFunction()) {
|
|
QTestResult::finishedCurrentTestFunction();
|
|
QTestResult::setCurrentTestFunction(nullptr);
|
|
}
|
|
|
|
qCleanup();
|
|
|
|
// Re-throw exception to make debugging easier
|
|
throw;
|
|
return 1;
|
|
}
|
|
#endif
|
|
|
|
#if QT_CONFIG(valgrind)
|
|
if (QBenchmarkGlobalData::current->mode() == QBenchmarkGlobalData::CallgrindParentProcess)
|
|
return callgrindChildExitCode;
|
|
#endif
|
|
// make sure our exit code is never going above 127
|
|
// since that could wrap and indicate 0 test fails
|
|
return qMin(QTestLog::failCount(), 127);
|
|
}
|
|
|
|
/*! \internal
|
|
*/
|
|
void QTest::qCleanup()
|
|
{
|
|
currentTestObject = nullptr;
|
|
|
|
QTestTable::clearGlobalTestTable();
|
|
QTestLog::stopLogging();
|
|
|
|
delete QBenchmarkGlobalData::current;
|
|
QBenchmarkGlobalData::current = nullptr;
|
|
|
|
#if defined(Q_OS_MACOS)
|
|
IOPMAssertionRelease(macPowerSavingDisabled);
|
|
#endif
|
|
}
|
|
|
|
/*!
|
|
\overload
|
|
\since 4.4
|
|
|
|
Behaves identically to qExec(QObject *, int, char**) but takes a
|
|
QStringList of \a arguments instead of a \c char** list.
|
|
*/
|
|
int QTest::qExec(QObject *testObject, const QStringList &arguments)
|
|
{
|
|
const int argc = arguments.count();
|
|
QVarLengthArray<char *> argv(argc);
|
|
|
|
QList<QByteArray> args;
|
|
args.reserve(argc);
|
|
|
|
for (int i = 0; i < argc; ++i)
|
|
{
|
|
args.append(arguments.at(i).toLocal8Bit().constData());
|
|
argv[i] = args.last().data();
|
|
}
|
|
|
|
return qExec(testObject, argc, argv.data());
|
|
}
|
|
|
|
/*! \internal
|
|
*/
|
|
void QTest::qFail(const char *statementStr, const char *file, int line)
|
|
{
|
|
QTestResult::addFailure(statementStr, file, line);
|
|
}
|
|
|
|
/*! \internal
|
|
*/
|
|
bool QTest::qVerify(bool statement, const char *statementStr, const char *description,
|
|
const char *file, int line)
|
|
{
|
|
return QTestResult::verify(statement, statementStr, description, file, line);
|
|
}
|
|
|
|
/*! \fn void QTest::qSkip(const char *message, const char *file, int line)
|
|
\internal
|
|
*/
|
|
void QTest::qSkip(const char *message, const char *file, int line)
|
|
{
|
|
QTestResult::addSkip(message, file, line);
|
|
QTestResult::setSkipCurrentTest(true);
|
|
}
|
|
|
|
/*! \fn bool QTest::qExpectFail(const char *dataIndex, const char *comment, TestFailMode mode, const char *file, int line)
|
|
\internal
|
|
*/
|
|
bool QTest::qExpectFail(const char *dataIndex, const char *comment,
|
|
QTest::TestFailMode mode, const char *file, int line)
|
|
{
|
|
return QTestResult::expectFail(dataIndex, qstrdup(comment), mode, file, line);
|
|
}
|
|
|
|
/*! \internal
|
|
*/
|
|
void QTest::qWarn(const char *message, const char *file, int line)
|
|
{
|
|
QTestLog::warn(message, file, line);
|
|
}
|
|
|
|
/*!
|
|
Ignores messages created by qDebug(), qInfo() or qWarning(). If the \a message
|
|
with the corresponding \a type is outputted, it will be removed from the
|
|
test log. If the test finished and the \a message was not outputted,
|
|
a test failure is appended to the test log.
|
|
|
|
\b {Note:} Invoking this function will only ignore one message.
|
|
If the message you want to ignore is outputted twice, you have to
|
|
call ignoreMessage() twice, too.
|
|
|
|
Example:
|
|
\snippet code/src_qtestlib_qtestcase.cpp 19
|
|
|
|
The example above tests that QDir::mkdir() outputs the right warning when invoked
|
|
with an invalid file name.
|
|
*/
|
|
void QTest::ignoreMessage(QtMsgType type, const char *message)
|
|
{
|
|
QTestLog::ignoreMessage(type, message);
|
|
}
|
|
|
|
#if QT_CONFIG(regularexpression)
|
|
/*!
|
|
\overload
|
|
|
|
Ignores messages created by qDebug(), qInfo() or qWarning(). If the message
|
|
matching \a messagePattern
|
|
with the corresponding \a type is outputted, it will be removed from the
|
|
test log. If the test finished and the message was not outputted,
|
|
a test failure is appended to the test log.
|
|
|
|
\b {Note:} Invoking this function will only ignore one message.
|
|
If the message you want to ignore is outputted twice, you have to
|
|
call ignoreMessage() twice, too.
|
|
|
|
\since 5.3
|
|
*/
|
|
void QTest::ignoreMessage(QtMsgType type, const QRegularExpression &messagePattern)
|
|
{
|
|
QTestLog::ignoreMessage(type, messagePattern);
|
|
}
|
|
#endif // QT_CONFIG(regularexpression)
|
|
|
|
/*! \internal
|
|
*/
|
|
|
|
#ifdef Q_OS_WIN
|
|
static inline bool isWindowsBuildDirectory(const QString &dirName)
|
|
{
|
|
return dirName.compare(QLatin1String("Debug"), Qt::CaseInsensitive) == 0
|
|
|| dirName.compare(QLatin1String("Release"), Qt::CaseInsensitive) == 0;
|
|
}
|
|
#endif
|
|
|
|
#if QT_CONFIG(temporaryfile)
|
|
/*!
|
|
Extracts a directory from resources to disk. The content is extracted
|
|
recursively to a temporary folder. The extracted content is removed
|
|
automatically once the last reference to the return value goes out of scope.
|
|
|
|
\a dirName is the name of the directory to extract from resources.
|
|
|
|
Returns the temporary directory where the data was extracted or null in case of
|
|
errors.
|
|
*/
|
|
QSharedPointer<QTemporaryDir> QTest::qExtractTestData(const QString &dirName)
|
|
{
|
|
QSharedPointer<QTemporaryDir> result; // null until success, then == tempDir
|
|
|
|
QSharedPointer<QTemporaryDir> tempDir = QSharedPointer<QTemporaryDir>::create();
|
|
|
|
tempDir->setAutoRemove(true);
|
|
|
|
if (!tempDir->isValid())
|
|
return result;
|
|
|
|
const QString dataPath = tempDir->path();
|
|
const QString resourcePath = QLatin1Char(':') + dirName;
|
|
const QFileInfo fileInfo(resourcePath);
|
|
|
|
if (!fileInfo.isDir()) {
|
|
qWarning("Resource path '%s' is not a directory.", qPrintable(resourcePath));
|
|
return result;
|
|
}
|
|
|
|
QDirIterator it(resourcePath, QDirIterator::Subdirectories);
|
|
if (!it.hasNext()) {
|
|
qWarning("Resource directory '%s' is empty.", qPrintable(resourcePath));
|
|
return result;
|
|
}
|
|
|
|
while (it.hasNext()) {
|
|
it.next();
|
|
|
|
QFileInfo fileInfo = it.fileInfo();
|
|
|
|
if (!fileInfo.isDir()) {
|
|
const QString destination = dataPath + QLatin1Char('/') + QStringView{fileInfo.filePath()}.mid(resourcePath.length());
|
|
QFileInfo destinationFileInfo(destination);
|
|
QDir().mkpath(destinationFileInfo.path());
|
|
if (!QFile::copy(fileInfo.filePath(), destination)) {
|
|
qWarning("Failed to copy '%s'.", qPrintable(fileInfo.filePath()));
|
|
return result;
|
|
}
|
|
if (!QFile::setPermissions(destination, QFile::ReadUser | QFile::WriteUser | QFile::ReadGroup)) {
|
|
qWarning("Failed to set permissions on '%s'.", qPrintable(destination));
|
|
return result;
|
|
}
|
|
}
|
|
}
|
|
|
|
result = std::move(tempDir);
|
|
|
|
return result;
|
|
}
|
|
#endif // QT_CONFIG(temporaryfile)
|
|
|
|
/*! \internal
|
|
*/
|
|
|
|
QString QTest::qFindTestData(const QString& base, const char *file, int line, const char *builddir,
|
|
const char *sourcedir)
|
|
{
|
|
QString found;
|
|
|
|
// Testdata priorities:
|
|
|
|
// 1. relative to test binary.
|
|
if (qApp) {
|
|
QDir binDirectory(QCoreApplication::applicationDirPath());
|
|
if (binDirectory.exists(base)) {
|
|
found = binDirectory.absoluteFilePath(base);
|
|
}
|
|
#ifdef Q_OS_WIN
|
|
// Windows: The executable is typically located in one of the
|
|
// 'Release' or 'Debug' directories.
|
|
else if (isWindowsBuildDirectory(binDirectory.dirName())
|
|
&& binDirectory.cdUp() && binDirectory.exists(base)) {
|
|
found = binDirectory.absoluteFilePath(base);
|
|
}
|
|
#endif // Q_OS_WIN
|
|
else if (QTestLog::verboseLevel() >= 2) {
|
|
const QString candidate = QDir::toNativeSeparators(QCoreApplication::applicationDirPath() + QLatin1Char('/') + base);
|
|
QTestLog::info(qPrintable(
|
|
QString::fromLatin1("testdata %1 not found relative to test binary [%2]; "
|
|
"checking next location").arg(base, candidate)),
|
|
file, line);
|
|
}
|
|
}
|
|
|
|
// 2. installed path.
|
|
if (found.isEmpty()) {
|
|
const char *testObjectName = QTestResult::currentTestObjectName();
|
|
if (testObjectName) {
|
|
const QString testsPath = QLibraryInfo::location(QLibraryInfo::TestsPath);
|
|
const QString candidate = QString::fromLatin1("%1/%2/%3")
|
|
.arg(testsPath, QFile::decodeName(testObjectName).toLower(), base);
|
|
if (QFileInfo::exists(candidate)) {
|
|
found = candidate;
|
|
} else if (QTestLog::verboseLevel() >= 2) {
|
|
QTestLog::info(qPrintable(
|
|
QString::fromLatin1("testdata %1 not found in tests install path [%2]; "
|
|
"checking next location")
|
|
.arg(base, QDir::toNativeSeparators(candidate))),
|
|
file, line);
|
|
}
|
|
}
|
|
}
|
|
|
|
// 3. relative to test source.
|
|
if (found.isEmpty() && qstrncmp(file, ":/", 2) != 0) {
|
|
// srcdir is the directory containing the calling source file.
|
|
QFileInfo srcdir = QFileInfo(QFile::decodeName(file)).path();
|
|
|
|
// If the srcdir is relative, that means it is relative to the current working
|
|
// directory of the compiler at compile time, which should be passed in as `builddir'.
|
|
if (!srcdir.isAbsolute() && builddir) {
|
|
srcdir.setFile(QFile::decodeName(builddir) + QLatin1String("/") + srcdir.filePath());
|
|
}
|
|
|
|
const QString canonicalPath = srcdir.canonicalFilePath();
|
|
const QString candidate = QString::fromLatin1("%1/%2").arg(canonicalPath, base);
|
|
if (!canonicalPath.isEmpty() && QFileInfo::exists(candidate)) {
|
|
found = candidate;
|
|
} else if (QTestLog::verboseLevel() >= 2) {
|
|
QTestLog::info(qPrintable(
|
|
QString::fromLatin1("testdata %1 not found relative to source path [%2]")
|
|
.arg(base, QDir::toNativeSeparators(candidate))),
|
|
file, line);
|
|
}
|
|
}
|
|
|
|
// 4. Try resources
|
|
if (found.isEmpty()) {
|
|
const QString candidate = QString::fromLatin1(":/%1").arg(base);
|
|
if (QFileInfo::exists(candidate)) {
|
|
found = candidate;
|
|
} else if (QTestLog::verboseLevel() >= 2) {
|
|
QTestLog::info(qPrintable(
|
|
QString::fromLatin1("testdata %1 not found in resources [%2]")
|
|
.arg(base, QDir::toNativeSeparators(candidate))),
|
|
file, line);
|
|
}
|
|
}
|
|
|
|
// 5. Try current directory
|
|
if (found.isEmpty()) {
|
|
const QString candidate = QDir::currentPath() + QLatin1Char('/') + base;
|
|
if (QFileInfo::exists(candidate)) {
|
|
found = candidate;
|
|
} else if (QTestLog::verboseLevel() >= 2) {
|
|
QTestLog::info(qPrintable(
|
|
QString::fromLatin1("testdata %1 not found in current directory [%2]")
|
|
.arg(base, QDir::toNativeSeparators(candidate))),
|
|
file, line);
|
|
}
|
|
}
|
|
|
|
// 6. Try main source directory
|
|
if (found.isEmpty()) {
|
|
const QString candidate = QTest::mainSourcePath % QLatin1Char('/') % base;
|
|
if (QFileInfo::exists(candidate)) {
|
|
found = candidate;
|
|
} else if (QTestLog::verboseLevel() >= 2) {
|
|
QTestLog::info(qPrintable(
|
|
QString::fromLatin1("testdata %1 not found in main source directory [%2]")
|
|
.arg(base, QDir::toNativeSeparators(candidate))),
|
|
file, line);
|
|
}
|
|
}
|
|
|
|
// 7. Try the supplied source directory
|
|
if (found.isEmpty() && sourcedir) {
|
|
const QString candidate = QFile::decodeName(sourcedir) % QLatin1Char('/') % base;
|
|
if (QFileInfo::exists(candidate)) {
|
|
found = candidate;
|
|
} else if (QTestLog::verboseLevel() >= 2) {
|
|
QTestLog::info(qPrintable(
|
|
QString::fromLatin1("testdata %1 not found in supplied source directory [%2]")
|
|
.arg(base, QDir::toNativeSeparators(candidate))),
|
|
file, line);
|
|
}
|
|
}
|
|
|
|
|
|
if (found.isEmpty()) {
|
|
QTest::qWarn(qPrintable(
|
|
QString::fromLatin1("testdata %1 could not be located!").arg(base)),
|
|
file, line);
|
|
} else if (QTestLog::verboseLevel() >= 1) {
|
|
QTestLog::info(qPrintable(
|
|
QString::fromLatin1("testdata %1 was located at %2").arg(base, QDir::toNativeSeparators(found))),
|
|
file, line);
|
|
}
|
|
|
|
return found;
|
|
}
|
|
|
|
/*! \internal
|
|
*/
|
|
QString QTest::qFindTestData(const char *base, const char *file, int line, const char *builddir,
|
|
const char *sourcedir)
|
|
{
|
|
return qFindTestData(QFile::decodeName(base), file, line, builddir, sourcedir);
|
|
}
|
|
|
|
/*! \internal
|
|
*/
|
|
void *QTest::qData(const char *tagName, int typeId)
|
|
{
|
|
return fetchData(QTestResult::currentTestData(), tagName, typeId);
|
|
}
|
|
|
|
/*! \internal
|
|
*/
|
|
void *QTest::qGlobalData(const char *tagName, int typeId)
|
|
{
|
|
return fetchData(QTestResult::currentGlobalTestData(), tagName, typeId);
|
|
}
|
|
|
|
/*! \internal
|
|
*/
|
|
void *QTest::qElementData(const char *tagName, int metaTypeId)
|
|
{
|
|
QTEST_ASSERT(tagName);
|
|
QTestData *data = QTestResult::currentTestData();
|
|
QTEST_ASSERT(data);
|
|
QTEST_ASSERT(data->parent());
|
|
|
|
int idx = data->parent()->indexOf(tagName);
|
|
QTEST_ASSERT(idx != -1);
|
|
QTEST_ASSERT(data->parent()->elementTypeId(idx) == metaTypeId);
|
|
|
|
return data->data(data->parent()->indexOf(tagName));
|
|
}
|
|
|
|
/*! \internal
|
|
*/
|
|
void QTest::addColumnInternal(int id, const char *name)
|
|
{
|
|
QTestTable *tbl = QTestTable::currentTestTable();
|
|
QTEST_ASSERT_X(tbl, "QTest::addColumn()", "Cannot add testdata outside of a _data slot.");
|
|
|
|
tbl->addColumn(id, name);
|
|
}
|
|
|
|
/*!
|
|
Appends a new row to the current test data. \a dataTag is the name of
|
|
the testdata that will appear in the test output. Returns a QTestData reference
|
|
that can be used to stream in data.
|
|
|
|
Example:
|
|
\snippet code/src_qtestlib_qtestcase.cpp 20
|
|
|
|
\b {Note:} This macro can only be used in a test's data function
|
|
that is invoked by the test framework.
|
|
|
|
See \l {Chapter 2: Data Driven Testing}{Data Driven Testing} for
|
|
a more extensive example.
|
|
|
|
\sa addColumn(), QFETCH()
|
|
*/
|
|
QTestData &QTest::newRow(const char *dataTag)
|
|
{
|
|
QTEST_ASSERT_X(dataTag, "QTest::newRow()", "Data tag cannot be null");
|
|
QTestTable *tbl = QTestTable::currentTestTable();
|
|
QTEST_ASSERT_X(tbl, "QTest::newRow()", "Cannot add testdata outside of a _data slot.");
|
|
QTEST_ASSERT_X(tbl->elementCount(), "QTest::newRow()", "Must add columns before attempting to add rows.");
|
|
|
|
return *tbl->newData(dataTag);
|
|
}
|
|
|
|
/*!
|
|
\since 5.9
|
|
|
|
Appends a new row to the current test data. The function's arguments are passed
|
|
to qsnprintf() for formatting according to \a format. See the qvsnprintf()
|
|
documentation for caveats and limitations.
|
|
|
|
The formatted string will appear as the name of this test data in the test output.
|
|
|
|
Returns a QTestData reference that can be used to stream in data.
|
|
|
|
Example:
|
|
\snippet code/src_qtestlib_qtestcase.cpp addRow
|
|
|
|
\b {Note:} This function can only be used in a test's data function
|
|
that is invoked by the test framework.
|
|
|
|
See \l {Chapter 2: Data Driven Testing}{Data Driven Testing} for
|
|
a more extensive example.
|
|
|
|
\sa addColumn(), QFETCH()
|
|
*/
|
|
QTestData &QTest::addRow(const char *format, ...)
|
|
{
|
|
QTEST_ASSERT_X(format, "QTest::addRow()", "Format string cannot be null");
|
|
QTestTable *tbl = QTestTable::currentTestTable();
|
|
QTEST_ASSERT_X(tbl, "QTest::addRow()", "Cannot add testdata outside of a _data slot.");
|
|
QTEST_ASSERT_X(tbl->elementCount(), "QTest::addRow()", "Must add columns before attempting to add rows.");
|
|
|
|
char buf[1024];
|
|
|
|
va_list va;
|
|
va_start(va, format);
|
|
// we don't care about failures, we accept truncation, as well as trailing garbage.
|
|
// Names with more than 1K characters are nonsense, anyway.
|
|
(void)qvsnprintf(buf, sizeof buf, format, va);
|
|
buf[sizeof buf - 1] = '\0';
|
|
va_end(va);
|
|
|
|
return *tbl->newData(buf);
|
|
}
|
|
|
|
/*! \fn template <typename T> void QTest::addColumn(const char *name, T *dummy = 0)
|
|
|
|
Adds a column with type \c{T} to the current test data.
|
|
\a name is the name of the column. \a dummy is a workaround
|
|
for buggy compilers and can be ignored.
|
|
|
|
To populate the column with values, newRow() can be used. Use
|
|
\l QFETCH() to fetch the data in the actual test.
|
|
|
|
Example:
|
|
\snippet code/src_qtestlib_qtestcase.cpp 21
|
|
|
|
To add custom types to the testdata, the type must be registered with
|
|
QMetaType via \l Q_DECLARE_METATYPE().
|
|
|
|
\b {Note:} This macro can only be used in a test's data function
|
|
that is invoked by the test framework.
|
|
|
|
See \l {Chapter 2: Data Driven Testing}{Data Driven Testing} for
|
|
a more extensive example.
|
|
|
|
\sa QTest::newRow(), QFETCH(), QMetaType
|
|
*/
|
|
|
|
/*!
|
|
Returns the name of the binary that is currently executed.
|
|
*/
|
|
const char *QTest::currentAppName()
|
|
{
|
|
return QTestResult::currentAppName();
|
|
}
|
|
|
|
/*!
|
|
Returns the name of the test function that is currently executed.
|
|
|
|
Example:
|
|
|
|
\snippet code/src_qtestlib_qtestcase.cpp 22
|
|
*/
|
|
const char *QTest::currentTestFunction()
|
|
{
|
|
return QTestResult::currentTestFunction();
|
|
}
|
|
|
|
/*!
|
|
Returns the name of the current test data. If the test doesn't
|
|
have any assigned testdata, the function returns 0.
|
|
*/
|
|
const char *QTest::currentDataTag()
|
|
{
|
|
return QTestResult::currentDataTag();
|
|
}
|
|
|
|
/*!
|
|
Returns \c true if the current test function failed, otherwise false.
|
|
*/
|
|
bool QTest::currentTestFailed()
|
|
{
|
|
return QTestResult::currentTestFailed();
|
|
}
|
|
|
|
/*!
|
|
Sleeps for \a ms milliseconds, blocking execution of the
|
|
test. qSleep() will not do any event processing and leave your test
|
|
unresponsive. Network communication might time out while
|
|
sleeping. Use \l {QTest::qWait()} to do non-blocking sleeping.
|
|
|
|
\a ms must be greater than 0.
|
|
|
|
\b {Note:} The qSleep() function calls either \c nanosleep() on
|
|
unix or \c Sleep() on windows, so the accuracy of time spent in
|
|
qSleep() depends on the operating system.
|
|
|
|
Example:
|
|
\snippet code/src_qtestlib_qtestcase.cpp 23
|
|
|
|
\sa {QTest::qWait()}
|
|
*/
|
|
void QTest::qSleep(int ms)
|
|
{
|
|
// ### Qt 6, move to QtCore or remove altogether
|
|
QTEST_ASSERT(ms > 0);
|
|
QTestPrivate::qSleep(ms);
|
|
}
|
|
|
|
/*! \internal
|
|
*/
|
|
QObject *QTest::testObject()
|
|
{
|
|
return currentTestObject;
|
|
}
|
|
|
|
/*! \internal
|
|
*/
|
|
void QTest::setMainSourcePath(const char *file, const char *builddir)
|
|
{
|
|
QString mainSourceFile = QFile::decodeName(file);
|
|
QFileInfo fi;
|
|
if (builddir)
|
|
fi.setFile(QDir(QFile::decodeName(builddir)), mainSourceFile);
|
|
else
|
|
fi.setFile(mainSourceFile);
|
|
QTest::mainSourcePath = fi.absolutePath();
|
|
}
|
|
|
|
/*! \internal
|
|
This function is called by various specializations of QTest::qCompare
|
|
to decide whether to report a failure and to produce verbose test output.
|
|
|
|
The failureMsg parameter can be null, in which case a default message
|
|
will be output if the compare fails. If the compare succeeds, failureMsg
|
|
will not be output.
|
|
|
|
If the caller has already passed a failure message showing the compared
|
|
values, or if those values cannot be stringified, val1 and val2 can be null.
|
|
*/
|
|
bool QTest::compare_helper(bool success, const char *failureMsg,
|
|
char *val1, char *val2,
|
|
const char *actual, const char *expected,
|
|
const char *file, int line)
|
|
{
|
|
return QTestResult::compare(success, failureMsg, val1, val2, actual, expected, file, line);
|
|
}
|
|
|
|
template <typename T>
|
|
static bool floatingCompare(const T &actual, const T &expected)
|
|
{
|
|
switch (qFpClassify(expected))
|
|
{
|
|
case FP_INFINITE:
|
|
return (expected < 0) == (actual < 0) && qFpClassify(actual) == FP_INFINITE;
|
|
case FP_NAN:
|
|
return qFpClassify(actual) == FP_NAN;
|
|
default:
|
|
if (!qFuzzyIsNull(expected))
|
|
return qFuzzyCompare(actual, expected);
|
|
Q_FALLTHROUGH();
|
|
case FP_SUBNORMAL: // subnormal is always fuzzily null
|
|
case FP_ZERO:
|
|
return qFuzzyIsNull(actual);
|
|
}
|
|
}
|
|
|
|
/*! \fn bool QTest::qCompare(const qfloat16 &t1, const qfloat16 &t2, const char *actual, const char *expected, const char *file, int line)
|
|
\internal
|
|
*/
|
|
bool QTest::qCompare(qfloat16 const &t1, qfloat16 const &t2, const char *actual, const char *expected,
|
|
const char *file, int line)
|
|
{
|
|
return compare_helper(floatingCompare(t1, t2),
|
|
"Compared qfloat16s are not the same (fuzzy compare)",
|
|
toString(t1), toString(t2), actual, expected, file, line);
|
|
}
|
|
|
|
/*! \fn bool QTest::qCompare(const float &t1, const float &t2, const char *actual, const char *expected, const char *file, int line)
|
|
\internal
|
|
*/
|
|
bool QTest::qCompare(float const &t1, float const &t2, const char *actual, const char *expected,
|
|
const char *file, int line)
|
|
{
|
|
return QTestResult::compare(floatingCompare(t1, t2),
|
|
"Compared floats are not the same (fuzzy compare)",
|
|
t1, t2, actual, expected, file, line);
|
|
}
|
|
|
|
/*! \fn bool QTest::qCompare(const double &t1, const double &t2, const char *actual, const char *expected, const char *file, int line)
|
|
\internal
|
|
*/
|
|
bool QTest::qCompare(double const &t1, double const &t2, const char *actual, const char *expected,
|
|
const char *file, int line)
|
|
{
|
|
return QTestResult::compare(floatingCompare(t1, t2),
|
|
"Compared doubles are not the same (fuzzy compare)",
|
|
t1, t2, actual, expected, file, line);
|
|
}
|
|
|
|
/*! \fn bool QTest::qCompare(int t1, int t2, const char *actual, const char *expected, const char *file, int line)
|
|
\internal
|
|
\since 5.14
|
|
*/
|
|
bool QTest::qCompare(int t1, int t2, const char *actual, const char *expected,
|
|
const char *file, int line)
|
|
{
|
|
return QTestResult::compare(t1 == t2,
|
|
"Compared values are not the same",
|
|
t1, t2, actual, expected, file, line);
|
|
}
|
|
|
|
/*! \fn bool QTest::qCompare(unsigned t1, unsigned t2, const char *actual, const char *expected, const char *file, int line)
|
|
\internal
|
|
\since 5.14
|
|
*/
|
|
bool QTest::qCompare(unsigned t1, unsigned t2, const char *actual, const char *expected,
|
|
const char *file, int line)
|
|
{
|
|
return QTestResult::compare(t1 == t2,
|
|
"Compared values are not the same",
|
|
t1, t2, actual, expected, file, line);
|
|
}
|
|
|
|
/*! \fn bool QTest::qCompare(QStringView t1, QStringView t2, const char *actual, const char *expected, const char *file, int line)
|
|
\internal
|
|
\since 5.14
|
|
*/
|
|
bool QTest::qCompare(QStringView t1, QStringView t2, const char *actual, const char *expected,
|
|
const char *file, int line)
|
|
{
|
|
return QTestResult::compare(t1 == t2,
|
|
"Compared values are not the same",
|
|
t1, t2, actual, expected, file, line);
|
|
}
|
|
|
|
/*! \fn bool QTest::qCompare(QStringView t1, const QLatin1String &t2, const char *actual, const char *expected, const char *file, int line)
|
|
\internal
|
|
\since 5.14
|
|
*/
|
|
bool QTest::qCompare(QStringView t1, const QLatin1String &t2, const char *actual, const char *expected,
|
|
const char *file, int line)
|
|
{
|
|
return QTestResult::compare(t1 == t2,
|
|
"Compared values are not the same",
|
|
t1, t2, actual, expected, file, line);
|
|
}
|
|
|
|
/*! \fn bool QTest::qCompare(const QLatin1String &t1, QStringView t2, const char *actual, const char *expected, const char *file, int line)
|
|
\internal
|
|
\since 5.14
|
|
*/
|
|
bool QTest::qCompare(const QLatin1String &t1, QStringView t2, const char *actual, const char *expected,
|
|
const char *file, int line)
|
|
{
|
|
return QTestResult::compare(t1 == t2,
|
|
"Compared values are not the same",
|
|
t1, t2, actual, expected, file, line);
|
|
}
|
|
|
|
/*! \fn bool QTest::qCompare(const QString &t1, const QString &t2, const char *actual, const char *expected, const char *file, int line)
|
|
\internal
|
|
\since 5.14
|
|
*/
|
|
|
|
/*! \fn bool QTest::qCompare(const QString &t1, const QLatin1String &t2, const char *actual, const char *expected, const char *file, int line)
|
|
\internal
|
|
\since 5.14
|
|
*/
|
|
|
|
/*! \fn bool QTest::qCompare(const QLatin1String &t1, const QString &t2, const char *actual, const char *expected, const char *file, int line)
|
|
\internal
|
|
\since 5.14
|
|
*/
|
|
|
|
/*! \fn bool QTest::qCompare(const double &t1, const float &t2, const char *actual, const char *expected, const char *file, int line)
|
|
\internal
|
|
*/
|
|
|
|
/*! \fn bool QTest::qCompare(const float &t1, const double &t2, const char *actual, const char *expected, const char *file, int line)
|
|
\internal
|
|
*/
|
|
|
|
#define TO_STRING_IMPL(TYPE, FORMAT) \
|
|
template <> Q_TESTLIB_EXPORT char *QTest::toString<TYPE>(const TYPE &t) \
|
|
{ \
|
|
char *msg = new char[128]; \
|
|
qsnprintf(msg, 128, #FORMAT, t); \
|
|
return msg; \
|
|
}
|
|
|
|
TO_STRING_IMPL(short, %hd)
|
|
TO_STRING_IMPL(ushort, %hu)
|
|
TO_STRING_IMPL(int, %d)
|
|
TO_STRING_IMPL(uint, %u)
|
|
TO_STRING_IMPL(long, %ld)
|
|
TO_STRING_IMPL(ulong, %lu)
|
|
#if defined(Q_OS_WIN)
|
|
TO_STRING_IMPL(qint64, %I64d)
|
|
TO_STRING_IMPL(quint64, %I64u)
|
|
#else
|
|
TO_STRING_IMPL(qint64, %lld)
|
|
TO_STRING_IMPL(quint64, %llu)
|
|
#endif
|
|
TO_STRING_IMPL(bool, %d)
|
|
TO_STRING_IMPL(signed char, %hhd)
|
|
TO_STRING_IMPL(unsigned char, %hhu)
|
|
|
|
/*!
|
|
\internal
|
|
|
|
Be consistent about leading 0 in exponent.
|
|
|
|
POSIX specifies that %e (hence %g when using it) uses at least two digits in
|
|
the exponent, requiring a leading 0 on single-digit exponents; (at least)
|
|
MinGW includes a leading zero also on an already-two-digit exponent,
|
|
e.g. 9e-040, which differs from more usual platforms. So massage that away.
|
|
*/
|
|
static void massageExponent(char *text)
|
|
{
|
|
char *p = strchr(text, 'e');
|
|
if (!p)
|
|
return;
|
|
const char *const end = p + strlen(p); // *end is '\0'
|
|
p += (p[1] == '-' || p[1] == '+') ? 2 : 1;
|
|
if (p[0] != '0' || end - 2 <= p)
|
|
return;
|
|
// We have a leading 0 on an exponent of at least two more digits
|
|
const char *n = p + 1;
|
|
while (end - 2 > n && n[0] == '0')
|
|
++n;
|
|
memmove(p, n, end + 1 - n);
|
|
}
|
|
|
|
// Be consistent about display of infinities and NaNs (snprintf()'s varies,
|
|
// notably on MinGW, despite POSIX documenting "[-]inf" or "[-]infinity" for %f,
|
|
// %e and %g, uppercasing for their capital versions; similar for "nan"):
|
|
#define TO_STRING_FLOAT(TYPE, FORMAT) \
|
|
template <> Q_TESTLIB_EXPORT char *QTest::toString<TYPE>(const TYPE &t) \
|
|
{ \
|
|
char *msg = new char[128]; \
|
|
switch (qFpClassify(t)) { \
|
|
case FP_INFINITE: \
|
|
qstrncpy(msg, (t < 0 ? "-inf" : "inf"), 128); \
|
|
break; \
|
|
case FP_NAN: \
|
|
qstrncpy(msg, "nan", 128); \
|
|
break; \
|
|
default: \
|
|
qsnprintf(msg, 128, #FORMAT, double(t)); \
|
|
massageExponent(msg); \
|
|
break; \
|
|
} \
|
|
return msg; \
|
|
}
|
|
|
|
TO_STRING_FLOAT(qfloat16, %.3g)
|
|
TO_STRING_FLOAT(float, %g)
|
|
TO_STRING_FLOAT(double, %.12g)
|
|
|
|
template <> Q_TESTLIB_EXPORT char *QTest::toString<char>(const char &t)
|
|
{
|
|
unsigned char c = static_cast<unsigned char>(t);
|
|
char *msg = new char[16];
|
|
switch (c) {
|
|
case 0x00:
|
|
qstrcpy(msg, "'\\0'");
|
|
break;
|
|
case 0x07:
|
|
qstrcpy(msg, "'\\a'");
|
|
break;
|
|
case 0x08:
|
|
qstrcpy(msg, "'\\b'");
|
|
break;
|
|
case 0x09:
|
|
qstrcpy(msg, "'\\t'");
|
|
break;
|
|
case 0x0a:
|
|
qstrcpy(msg, "'\\n'");
|
|
break;
|
|
case 0x0b:
|
|
qstrcpy(msg, "'\\v'");
|
|
break;
|
|
case 0x0c:
|
|
qstrcpy(msg, "'\\f'");
|
|
break;
|
|
case 0x0d:
|
|
qstrcpy(msg, "'\\r'");
|
|
break;
|
|
case 0x22:
|
|
qstrcpy(msg, "'\\\"'");
|
|
break;
|
|
case 0x27:
|
|
qstrcpy(msg, "'\\\''");
|
|
break;
|
|
case 0x5c:
|
|
qstrcpy(msg, "'\\\\'");
|
|
break;
|
|
default:
|
|
if (c < 0x20 || c >= 0x7F)
|
|
qsnprintf(msg, 16, "'\\x%02x'", c);
|
|
else
|
|
qsnprintf(msg, 16, "'%c'" , c);
|
|
}
|
|
return msg;
|
|
}
|
|
|
|
/*! \internal
|
|
*/
|
|
char *QTest::toString(const char *str)
|
|
{
|
|
if (!str) {
|
|
char *msg = new char[1];
|
|
*msg = '\0';
|
|
return msg;
|
|
}
|
|
char *msg = new char[strlen(str) + 1];
|
|
return qstrcpy(msg, str);
|
|
}
|
|
|
|
/*! \internal
|
|
*/
|
|
char *QTest::toString(const void *p)
|
|
{
|
|
char *msg = new char[128];
|
|
qsnprintf(msg, 128, "%p", p);
|
|
return msg;
|
|
}
|
|
|
|
/*! \fn char *QTest::toString(const QColor &color)
|
|
\internal
|
|
*/
|
|
|
|
/*! \fn char *QTest::toString(const QRegion ®ion)
|
|
\internal
|
|
*/
|
|
|
|
/*! \fn char *QTest::toString(const QHostAddress &addr)
|
|
\internal
|
|
*/
|
|
|
|
/*! \fn char *QTest::toString(QNetworkReply::NetworkError code)
|
|
\internal
|
|
*/
|
|
|
|
/*! \fn char *QTest::toString(const QNetworkCookie &cookie)
|
|
\internal
|
|
*/
|
|
|
|
/*! \fn char *QTest::toString(const QList<QNetworkCookie> &list)
|
|
\internal
|
|
*/
|
|
|
|
/*! \internal
|
|
*/
|
|
bool QTest::compare_string_helper(const char *t1, const char *t2, const char *actual,
|
|
const char *expected, const char *file, int line)
|
|
{
|
|
return compare_helper(qstrcmp(t1, t2) == 0, "Compared strings are not the same",
|
|
toString(t1), toString(t2), actual, expected, file, line);
|
|
}
|
|
|
|
/*!
|
|
\namespace QTest::Internal
|
|
\internal
|
|
*/
|
|
|
|
/*! \fn bool QTest::compare_ptr_helper(const volatile void *t1, const volatile void *t2, const char *actual, const char *expected, const char *file, int line)
|
|
\internal
|
|
*/
|
|
|
|
/*! \fn bool QTest::compare_ptr_helper(const volatile void *t1, std::nullptr_t, const char *actual, const char *expected, const char *file, int line)
|
|
\internal
|
|
*/
|
|
|
|
/*! \fn bool QTest::compare_ptr_helper(std::nullptr_t, const volatile void *t2, const char *actual, const char *expected, const char *file, int line)
|
|
\internal
|
|
*/
|
|
|
|
/*! \fn template <typename T1, typename T2> bool QTest::qCompare(const T1 &t1, const T2 &t2, const char *actual, const char *expected, const char *file, int line)
|
|
\internal
|
|
*/
|
|
|
|
/*! \fn bool QTest::qCompare(const QIcon &t1, const QIcon &t2, const char *actual, const char *expected, const char *file, int line)
|
|
\internal
|
|
*/
|
|
|
|
/*! \fn bool QTest::qCompare(const QImage &t1, const QImage &t2, const char *actual, const char *expected, const char *file, int line)
|
|
\internal
|
|
*/
|
|
|
|
/*! \fn bool QTest::qCompare(const QPixmap &t1, const QPixmap &t2, const char *actual, const char *expected, const char *file, int line)
|
|
\internal
|
|
*/
|
|
|
|
/*! \fn template <typename T> bool QTest::qCompare(const T &t1, const T &t2, const char *actual, const char *expected, const char *file, int line)
|
|
\internal
|
|
*/
|
|
|
|
/*! \fn template <typename T> bool QTest::qCompare(const T *t1, const T *t2, const char *actual, const char *expected, const char *file, int line)
|
|
\internal
|
|
*/
|
|
|
|
/*! \fn template <typename T> bool QTest::qCompare(T *t, std::nullptr_t, const char *actual, const char *expected, const char *file, int line)
|
|
\internal
|
|
*/
|
|
|
|
/*! \fn template <typename T> bool QTest::qCompare(std::nullptr_t, T *t, const char *actual, const char *expected, const char *file, int line)
|
|
\internal
|
|
*/
|
|
|
|
/*! \fn template <typename T> bool QTest::qCompare(T *t1, T *t2, const char *actual, const char *expected, const char *file, int line)
|
|
\internal
|
|
*/
|
|
|
|
/*! \fn template <typename T1, typename T2> bool QTest::qCompare(const T1 *t1, const T2 *t2, const char *actual, const char *expected, const char *file, int line)
|
|
\internal
|
|
*/
|
|
|
|
/*! \fn template <typename T1, typename T2> bool QTest::qCompare(T1 *t1, T2 *t2, const char *actual, const char *expected, const char *file, int line)
|
|
\internal
|
|
*/
|
|
|
|
/*! \fn bool QTest::qCompare(const char *t1, const char *t2, const char *actual, const char *expected, const char *file, int line)
|
|
\internal
|
|
*/
|
|
|
|
/*! \fn bool QTest::qCompare(char *t1, char *t2, const char *actual, const char *expected, const char *file, int line)
|
|
\internal
|
|
*/
|
|
|
|
/*! \fn bool QTest::qCompare(char *t1, const char *t2, const char *actual, const char *expected, const char *file, int line)
|
|
\internal
|
|
*/
|
|
|
|
/*! \fn bool QTest::qCompare(const char *t1, char *t2, const char *actual, const char *expected, const char *file, int line)
|
|
\internal
|
|
*/
|
|
|
|
/*! \fn bool QTest::qCompare(const QString &t1, const QLatin1String &t2, const char *actual, const char *expected, const char *file, int line)
|
|
\internal
|
|
*/
|
|
|
|
/*! \fn bool QTest::qCompare(const QLatin1String &t1, const QString &t2, const char *actual, const char *expected, const char *file, int line)
|
|
\internal
|
|
*/
|
|
|
|
/*! \fn bool QTest::qCompare(const QStringList &t1, const QStringList &t2, const char *actual, const char *expected, const char *file, int line)
|
|
\internal
|
|
*/
|
|
|
|
/*! \fn template <typename T> bool QTest::qCompare(const QList<T> &t1, const QList<T> &t2, const char *actual, const char *expected, const char *file, int line)
|
|
\internal
|
|
*/
|
|
|
|
/*! \fn template <typename T> bool QTest::qCompare(const QFlags<T> &t1, const T &t2, const char *actual, const char *expected, const char *file, int line)
|
|
\internal
|
|
*/
|
|
|
|
/*! \fn template <typename T> bool QTest::qCompare(const QFlags<T> &t1, const int &t2, const char *actual, const char *expected, const char *file, int line)
|
|
\internal
|
|
*/
|
|
|
|
/*! \fn bool QTest::qCompare(const qint64 &t1, const qint32 &t2, const char *actual, const char *expected, const char *file, int line)
|
|
\internal
|
|
*/
|
|
|
|
/*! \fn bool QTest::qCompare(const qint64 &t1, const quint32 &t2, const char *actual, const char *expected, const char *file, int line)
|
|
\internal
|
|
*/
|
|
|
|
/*! \fn bool QTest::qCompare(const quint64 &t1, const quint32 &t2, const char *actual, const char *expected, const char *file, int line)
|
|
\internal
|
|
*/
|
|
|
|
/*! \fn bool QTest::qCompare(const qint32 &t1, const qint64 &t2, const char *actual, const char *expected, const char *file, int line)
|
|
\internal
|
|
*/
|
|
|
|
/*! \fn bool QTest::qCompare(const quint32 &t1, const qint64 &t2, const char *actual, const char *expected, const char *file, int line)
|
|
\internal
|
|
*/
|
|
|
|
/*! \fn bool QTest::qCompare(const quint32 &t1, const quint64 &t2, const char *actual, const char *expected, const char *file, int line)
|
|
\internal
|
|
*/
|
|
|
|
/*! \fn template <typename T> bool QTest::qTest(const T& actual, const char *elementName, const char *actualStr, const char *expected, const char *file, int line)
|
|
\internal
|
|
*/
|
|
|
|
/*! \fn void QTest::sendKeyEvent(KeyAction action, QWidget *widget, Qt::Key code, QString text, Qt::KeyboardModifiers modifier, int delay=-1)
|
|
\internal
|
|
*/
|
|
|
|
/*! \fn void QTest::sendKeyEvent(KeyAction action, QWindow *window, Qt::Key code, QString text, Qt::KeyboardModifiers modifier, int delay=-1)
|
|
\internal
|
|
*/
|
|
|
|
/*! \fn void QTest::sendKeyEvent(KeyAction action, QWidget *widget, Qt::Key code, char ascii, Qt::KeyboardModifiers modifier, int delay=-1)
|
|
\internal
|
|
*/
|
|
|
|
/*! \fn void QTest::sendKeyEvent(KeyAction action, QWindow *window, Qt::Key code, char ascii, Qt::KeyboardModifiers modifier, int delay=-1)
|
|
\internal
|
|
*/
|
|
|
|
/*! \fn void QTest::simulateEvent(QWidget *widget, bool press, int code, Qt::KeyboardModifiers modifier, QString text, bool repeat, int delay=-1)
|
|
\internal
|
|
*/
|
|
|
|
/*! \fn void QTest::simulateEvent(QWindow *window, bool press, int code, Qt::KeyboardModifiers modifier, QString text, bool repeat, int delay=-1)
|
|
\internal
|
|
*/
|
|
|
|
QT_END_NAMESPACE
|