diff options
Diffstat (limited to 'tests/auto/corelib/tools/qsharedpointer/externaltests.cpp')
| -rw-r--r-- | tests/auto/corelib/tools/qsharedpointer/externaltests.cpp | 745 |
1 files changed, 745 insertions, 0 deletions
diff --git a/tests/auto/corelib/tools/qsharedpointer/externaltests.cpp b/tests/auto/corelib/tools/qsharedpointer/externaltests.cpp new file mode 100644 index 0000000000..1bfa1c10a0 --- /dev/null +++ b/tests/auto/corelib/tools/qsharedpointer/externaltests.cpp @@ -0,0 +1,745 @@ +/**************************************************************************** +** +** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies). +** All rights reserved. +** Contact: Nokia Corporation (qt-info@nokia.com) +** +** This file is part of the test suite of the Qt Toolkit. +** +** $QT_BEGIN_LICENSE:LGPL$ +** GNU Lesser General Public License Usage +** This file may be used under the terms of the GNU Lesser General Public +** License version 2.1 as published by the Free Software Foundation and +** appearing in the file LICENSE.LGPL included in the packaging of this +** file. Please review the following information to ensure the GNU Lesser +** General Public License version 2.1 requirements will be met: +** http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html. +** +** In addition, as a special exception, Nokia gives you certain additional +** rights. These rights are described in the Nokia Qt LGPL Exception +** version 1.1, included in the file LGPL_EXCEPTION.txt in this package. +** +** GNU General Public License Usage +** Alternatively, this file may be used under the terms of the GNU General +** Public License version 3.0 as published by the Free Software Foundation +** and appearing in the file LICENSE.GPL included in the packaging of this +** file. Please review the following information to ensure the GNU General +** Public License version 3.0 requirements will be met: +** http://www.gnu.org/copyleft/gpl.html. +** +** Other Usage +** Alternatively, this file may be used in accordance with the terms and +** conditions contained in a signed written agreement between you and Nokia. +** +** +** +** +** +** $QT_END_LICENSE$ +** +****************************************************************************/ + + +#include "externaltests.h" + +#include <QtCore/QTemporaryFile> +#include <QtCore/QProcess> +#include <QtCore/QByteArray> +#include <QtCore/QString> +#include <QtCore/QFileInfo> +#include <QtCore/QDir> +#include <QtCore/QDirIterator> +#include <QtCore/QDateTime> +#include <QtCore/QDebug> + +#ifdef Q_OS_SYMBIAN +#define DEFAULT_MAKESPEC "X:/STLsupport/mkspecs/symbian-abld/" +#endif + +#ifndef DEFAULT_MAKESPEC +# error DEFAULT_MAKESPEC not defined +#endif + +#ifdef Q_OS_UNIX +# include <fcntl.h> +# include <unistd.h> +#endif + +static QString makespec() +{ + static const char default_makespec[] = DEFAULT_MAKESPEC; + const char *p; + for (p = default_makespec + sizeof(default_makespec) - 1; p >= default_makespec; --p) + if (*p == '/' || *p == '\\') + break; + + return QString::fromLatin1(p + 1); +} + +static bool removeRecursive(const QString &pathname) +{ + QFileInfo fi(pathname); + if (!fi.exists()) + return true; + + if (fi.isFile()) + return QFile::remove(pathname); + + if (!fi.isDir()) { + // not a file or directory. How do I remove it? + return false; + } + + // not empty -- we must empty it first + QDirIterator di(pathname, QDir::AllEntries | QDir::Hidden | QDir::System | QDir::NoDotAndDotDot); + while (di.hasNext()) { + di.next(); + if (!di.fileInfo().exists() && !di.fileInfo().isSymLink()) + continue; + bool ok; + if (di.fileInfo().isFile() || di.fileInfo().isSymLink()) + ok = QFile::remove(di.filePath()); + else + ok = removeRecursive(di.filePath()); + if (!ok) { + return false; + } + } + + QDir dir(pathname); + QString dirname = dir.dirName(); + dir.cdUp(); + return dir.rmdir(dirname); +} + +QT_BEGIN_NAMESPACE +namespace QTest { + class QExternalProcess: public QProcess + { + protected: +#ifdef Q_OS_UNIX + void setupChildProcess() + { + // run in user code + QProcess::setupChildProcess(); + + if (processChannelMode() == ForwardedChannels) { + // reopen /dev/tty into stdin + int fd = ::open("/dev/tty", O_RDONLY); + if (fd == -1) + return; + ::dup2(fd, 0); + ::close(fd); + } + } +#endif + }; + + class QExternalTestPrivate + { + public: + QExternalTestPrivate() + : qtModules(QExternalTest::QtCore | QExternalTest::QtGui | QExternalTest::QtTest), + appType(QExternalTest::AutoApplication), + exitCode(-1) + { + } + ~QExternalTestPrivate() + { + clear(); + } + + enum Target { Compile, Link, Run }; + + QList<QByteArray> qmakeLines; + QStringList extraProgramSources; + QByteArray programHeader; + QExternalTest::QtModules qtModules; + QExternalTest::ApplicationType appType; + + QString temporaryDir; + QByteArray sourceCode; + QByteArray std_out; + QByteArray std_err; + int exitCode; + QExternalTest::Stage failedStage; + + void clear(); + bool tryCompile(const QByteArray &body); + bool tryLink(const QByteArray &body); + bool tryRun(const QByteArray &body); + + private: + void removeTemporaryDirectory(); + bool createTemporaryDirectory(); + bool prepareSourceCode(const QByteArray &body); + bool createProjectFile(); + bool runQmake(); + bool runMake(Target target); + bool commonSetup(const QByteArray &body); + }; + + QExternalTest::QExternalTest() + : d(new QExternalTestPrivate) + { + } + + QExternalTest::~QExternalTest() + { + delete d; + } + + QList<QByteArray> QExternalTest::qmakeSettings() const + { + return d->qmakeLines; + } + + void QExternalTest::setQmakeSettings(const QList<QByteArray> &settings) + { + d->qmakeLines = settings; + } + + QExternalTest::QtModules QExternalTest::qtModules() const + { + return d->qtModules; + } + + void QExternalTest::setQtModules(QtModules modules) + { + d->qtModules = modules; + } + + QExternalTest::ApplicationType QExternalTest::applicationType() const + { + return d->appType; + } + + void QExternalTest::setApplicationType(ApplicationType type) + { + d->appType = type; + } + + QStringList QExternalTest::extraProgramSources() const + { + return d->extraProgramSources; + } + + void QExternalTest::setExtraProgramSources(const QStringList &extra) + { + d->extraProgramSources = extra; + } + + QByteArray QExternalTest::programHeader() const + { + return d->programHeader; + } + + void QExternalTest::setProgramHeader(const QByteArray &header) + { + d->programHeader = header; + } + + bool QExternalTest::tryCompile(const QByteArray &body) + { + return d->tryCompile(body) && d->exitCode == 0; + } + + bool QExternalTest::tryLink(const QByteArray &body) + { + return d->tryLink(body) && d->exitCode == 0; + } + + bool QExternalTest::tryRun(const QByteArray &body) + { + return d->tryRun(body) && d->exitCode == 0; + } + + bool QExternalTest::tryCompileFail(const QByteArray &body) + { + return d->tryCompile(body) && d->exitCode != 0; + } + + bool QExternalTest::tryLinkFail(const QByteArray &body) + { + return d->tryLink(body) && d->exitCode != 0; + } + + bool QExternalTest::tryRunFail(const QByteArray &body) + { + return d->tryRun(body) && d->exitCode != 0; + } + + QExternalTest::Stage QExternalTest::failedStage() const + { + return d->failedStage; + } + + int QExternalTest::exitCode() const + { + return d->exitCode; + } + + QByteArray QExternalTest::fullProgramSource() const + { + return d->sourceCode; + } + + QByteArray QExternalTest::standardOutput() const + { + return d->std_out; + } + + QByteArray QExternalTest::standardError() const + { + return d->std_err; + } + + QString QExternalTest::errorReport() const + { + const char *stage = 0; + switch (d->failedStage) { + case FileStage: + stage = "creating files"; + break; + case QmakeStage: + stage = "executing qmake"; + break; + case CompilationStage: + stage = "during compilation"; + break; + case LinkStage: + stage = "during linking"; + break; + case RunStage: + stage = "executing program"; + break; + } + + QString report = QString::fromLatin1( + "External test failed %1 with exit code %4\n" + "==== standard error: ====\n" + "%2\n" + "==== standard output: ====\n" + "%3\n" + "==== ====\n"); + return report.arg(QString::fromLatin1(stage), + QString::fromLocal8Bit(d->std_err), + QString::fromLocal8Bit(d->std_out)) + .arg(d->exitCode); + } + + // actual execution code + void QExternalTestPrivate::clear() + { + if (!temporaryDir.isEmpty()) + removeTemporaryDirectory(); + + sourceCode.clear(); + std_out.clear(); + std_err.clear(); + exitCode = -1; + failedStage = QExternalTest::FileStage; + } + + void QExternalTestPrivate::removeTemporaryDirectory() + { + if (temporaryDir.isEmpty()) + qWarning() << "Temporary directory is expected to be non-empty"; + removeRecursive(temporaryDir); + temporaryDir.clear(); + } + + bool QExternalTestPrivate::prepareSourceCode(const QByteArray &body) + { + sourceCode.clear(); + sourceCode.reserve(8192); + + sourceCode += programHeader; + + // Add Qt header includes + if (qtModules & QExternalTest::QtCore) + sourceCode += "#include <QtCore/QtCore>\n"; + if (qtModules & QExternalTest::QtGui) + sourceCode += "#include <QtGui/QtGui>\n"; + if (qtModules & QExternalTest::QtNetwork) + sourceCode += "#include <QtNetwork/QtNetwork>\n"; + if (qtModules & QExternalTest::QtXml) + sourceCode += "#include <QtXml/QtXml>\n"; + if (qtModules & QExternalTest::QtXmlPatterns) + sourceCode += "#include <QtXmlPatterns/QtXmlPatterns>\n"; + if (qtModules & QExternalTest::QtOpenGL) + sourceCode += "#include <QtOpenGL/QtOpenGL>\n"; + if (qtModules & QExternalTest::QtSql) + sourceCode += "#include <QtSql/QtSql>\n"; + if (qtModules & QExternalTest::QtSvg) + sourceCode += "#include <QtSvg/QtSvg>\n"; + if (qtModules & QExternalTest::QtScript) + sourceCode += "#include <QtScript/QtScript>\n"; + if (qtModules & QExternalTest::QtTest) + sourceCode += "#include <QtTest/QtTest>\n"; + if (qtModules & QExternalTest::QtDBus) + sourceCode += "#include <QtDBus/QtDBus>\n"; + if (qtModules & QExternalTest::QtWebKit) + sourceCode += "#include <QtWebKit/QtWebKit>\n"; + if (qtModules & QExternalTest::Phonon) + sourceCode += "#include <Phonon/Phonon>\n"; + sourceCode += + "#include <stdlib.h>\n" + "#include <stddef.h>\n"; + + sourceCode += + "\n" + "void q_external_test_user_code()\n" + "{\n" + "#include \"user_code.cpp\"\n" + "}\n" + "\n" + "#ifdef Q_OS_WIN\n" + "#include <windows.h>\n" + "static void q_test_setup()\n" + "{\n" + " SetErrorMode(SEM_FAILCRITICALERRORS | SEM_NOGPFAULTERRORBOX | SEM_NOOPENFILEERRORBOX);\n" + "}\n" + "#else\n" + "static void q_test_setup() { }\n" + "#endif\n" + "int main(int argc, char **argv)\n" + "{\n"; + + switch (appType) { + applicationless: + case QExternalTest::Applicationless: + sourceCode += + " (void)argc; (void)argv;\n"; + break; + + coreapplication: + case QExternalTest::QCoreApplication: + sourceCode += + " QCoreApplication app(argc, argv);\n"; + break; + + case QExternalTest::QApplicationTty: + sourceCode += + " QApplication app(argc, argv, QApplication::Tty);\n"; + break; + + guiapplication: + case QExternalTest::QApplicationGuiClient: + sourceCode += + " QApplication app(argc, argv, QApplication::GuiClient);\n"; + break; + + case QExternalTest::QApplicationGuiServer: + sourceCode += + " QApplication app(argc, argv, QApplication::GuiServer);\n"; + break; + + case QExternalTest::AutoApplication: + if (qtModules & QExternalTest::QtGui) + goto guiapplication; + if (qtModules == 0) + goto applicationless; + goto coreapplication; + } + + sourceCode += + " q_test_setup();\n" + " q_external_test_user_code();\n" + " return 0;\n" + "}\n"; + + QFile sourceFile(temporaryDir + QLatin1String("/project.cpp")); + if (!sourceFile.open(QIODevice::WriteOnly | QIODevice::Truncate | QIODevice::Text)) { + std_err = sourceFile.errorString().toLocal8Bit(); + return false; + } + + sourceFile.write(sourceCode); + sourceFile.close(); + + sourceFile.setFileName(temporaryDir + QLatin1String("/user_code.cpp")); + if (!sourceFile.open(QIODevice::WriteOnly | QIODevice::Truncate | QIODevice::Text)) { + std_err = sourceFile.errorString().toLocal8Bit(); + return false; + } + sourceFile.write(body); + + return true; + } + + bool QExternalTestPrivate::createTemporaryDirectory() + { + QDir temp = QDir::temp(); + QString subdir = QString::fromLatin1("qexternaltest-%1-%2-%3") + .arg(QDateTime::currentDateTime().toString(QLatin1String("yyyyMMddhhmmss"))) + .arg(quintptr(this), 0, 16) + .arg(qrand()); + if (!temp.mkdir(subdir)) + return false; + + if (!temp.cd(subdir)) + return false; + + temporaryDir = temp.absolutePath(); + return true; + } + + bool QExternalTestPrivate::createProjectFile() + { + if (temporaryDir.isEmpty()) + qWarning() << "Temporary directory is expected to be non-empty"; + + QFile projectFile(temporaryDir + QLatin1String("/project.pro")); + if (!projectFile.open(QIODevice::WriteOnly | QIODevice::Truncate | QIODevice::Text)) { + std_err = projectFile.errorString().toLocal8Bit(); + return false; + } + + projectFile.write( + "TEMPLATE = app\n" + "\n" + "TARGET = externaltest\n" + "CONFIG -= app_bundle\n" // for the Mac + "CONFIG -= debug_and_release\n" + "DESTDIR = .\n" + "OBJECTS_DIR = .\n" + "UI_DIR = .\n" + "MOC_DIR = .\n" + "RCC_DIR = .\n" + "HEADERS +=\n" + "SOURCES += project.cpp\n" + "QT -= core gui\n" + "INCLUDEPATH += . "); + projectFile.write(QFile::encodeName(QDir::currentPath())); + +#ifndef QT_NO_DEBUG + projectFile.write("\nCONFIG += debug\n"); +#else + projectFile.write("\nCONFIG += release\n"); +#endif + + QByteArray extraSources = QFile::encodeName(extraProgramSources.join(" ")); + if (!extraSources.isEmpty()) { + projectFile.write("SOURCES += "); + projectFile.write(extraSources); + projectFile.putChar('\n'); + } + + // Add Qt modules + if (qtModules & QExternalTest::QtCore) + projectFile.write("QT += core\n"); + if (qtModules & QExternalTest::QtGui) + projectFile.write("QT += gui\n"); + if (qtModules & QExternalTest::QtNetwork) + projectFile.write("QT += network\n"); + if (qtModules & QExternalTest::QtXml) + projectFile.write("QT += xml\n"); + if (qtModules & QExternalTest::QtXmlPatterns) + projectFile.write("QT += xmlpatterns\n"); + if (qtModules & QExternalTest::QtOpenGL) + projectFile.write("QT += opengl\n"); + if (qtModules & QExternalTest::QtSql) + projectFile.write("QT += sql\n"); + if (qtModules & QExternalTest::QtSvg) + projectFile.write("QT += svg\n"); + if (qtModules & QExternalTest::QtScript) + projectFile.write("QT += script\n"); + if (qtModules & QExternalTest::QtTest) + projectFile.write("QT += testlib\n"); + if (qtModules & QExternalTest::QtDBus) + projectFile.write("QT += dbus\n"); + if (qtModules & QExternalTest::QtWebKit) + projectFile.write("QT += webkit\n"); + if (qtModules & QExternalTest::Phonon) + projectFile.write("QT += phonon\n"); + + projectFile.write("\n### User-specified settings start ###\n"); + foreach (QByteArray line, qmakeLines) { + projectFile.write(line); + projectFile.write("\n"); + } + projectFile.write("\n### User-specified settings end ###\n"); + + // Use qmake to just compile: + projectFile.write( + "\n" + "test_compile.depends += $(OBJECTS)\n" + "QMAKE_EXTRA_TARGETS += test_compile\n"); + + // Use qmake to run the app too: + projectFile.write( + "\n" + "unix:test_run.commands = ./$(QMAKE_TARGET)\n" + "else:test_run.commands = $(QMAKE_TARGET)\n" + "embedded:test_run.commands += -qws\n" + "QMAKE_EXTRA_TARGETS += test_run\n"); + + // Use qmake to debug: + projectFile.write( + "\n" + "*-g++* {\n" + " unix:test_debug.commands = gdb --args ./$(QMAKE_TARGET)\n" + " else:test_debug.commands = gdb --args $(QMAKE_TARGET)\n" + " embedded:test_debug.commands += -qws\n" + " QMAKE_EXTRA_TARGETS += test_debug\n" + "}\n"); + + // Also use qmake to run the app with valgrind: + projectFile.write( + "\n" + "unix:test_valgrind.commands = valgrind ./$(QMAKE_TARGET)\n" + "else:test_valgrind.commands = valgrind $(QMAKE_TARGET)\n" + "embedded:test_valgrind.commands += -qws\n" + "QMAKE_EXTRA_TARGETS += test_valgrind\n"); + + return true; + } + + bool QExternalTestPrivate::runQmake() + { + if (temporaryDir.isEmpty()) + qWarning() << "Temporary directory is expected to be non-empty"; + + if (!createProjectFile()) + return false; + + failedStage = QExternalTest::QmakeStage; + QProcess qmake; + QStringList args; + args << QLatin1String("-makefile") + << QLatin1String("-spec") + << makespec() + << QLatin1String("project.pro"); + qmake.setWorkingDirectory(temporaryDir); + qmake.start(QLatin1String("qmake"), args); + + std_out += "### --- stdout from qmake --- ###\n"; + std_err += "### --- stderr from qmake --- ###\n"; + bool ok = qmake.waitForStarted(); + if (!ok) { + exitCode = 255; + std_err += "qmake: "; + std_err += qmake.errorString().toLocal8Bit(); + } else { + ok = qmake.waitForFinished(); + exitCode = qmake.exitCode(); + + std_out += qmake.readAllStandardOutput(); + std_err += qmake.readAllStandardError(); + } + + return ok && exitCode == 0; + } + + bool QExternalTestPrivate::runMake(Target target) + { + if (temporaryDir.isEmpty()) + qWarning() << "Temporary directory is expected to be non-empty"; + + QExternalProcess make; + make.setWorkingDirectory(temporaryDir); + + QStringList environment = QProcess::systemEnvironment(); + environment += QLatin1String("LC_ALL=C"); + make.setEnvironment(environment); + + QStringList args; + QProcess::ProcessChannelMode channelMode = QProcess::SeparateChannels; + if (target == Compile) { + args << QLatin1String("test_compile"); + } else if (target == Run) { + QByteArray run = qgetenv("QTEST_EXTERNAL_RUN"); + if (run == "valgrind") + args << QLatin1String("test_valgrind"); + else if (run == "debug") + args << QLatin1String("test_debug"); + else + args << QLatin1String("test_run"); + if (!run.isEmpty()) + channelMode = QProcess::ForwardedChannels; + } + + make.setProcessChannelMode(channelMode); + + static const char makes[] = + "nmake.exe\0" //for visual c++ + "mingw32-make.exe\0" //for mingw + "gmake\0" + "make\0"; + for (const char *p = makes; *p; p += strlen(p) + 1) { + make.start(QLatin1String(p), args); + if (make.waitForStarted()) + break; + } + + if (make.state() != QProcess::Running) { + exitCode = 255; + std_err += "make: "; + std_err += make.errorString().toLocal8Bit(); + return false; + } + + make.closeWriteChannel(); + bool ok = make.waitForFinished(channelMode == QProcess::ForwardedChannels ? -1 : 60000); + if (!ok) + make.terminate(); + exitCode = make.exitCode(); + std_out += make.readAllStandardOutput(); + std_err += make.readAllStandardError(); + + return ok; + } + + bool QExternalTestPrivate::commonSetup(const QByteArray &body) + { + clear(); + + if (!createTemporaryDirectory()) + return false; + if (!createProjectFile()) + return false; + if (!prepareSourceCode(body)) + return false; + if (!runQmake()) + return false; + return true; + } + + bool QExternalTestPrivate::tryCompile(const QByteArray &body) + { + if (!commonSetup(body)) + return false; + + // compile + failedStage = QExternalTest::CompilationStage; + std_out += "\n### --- stdout from make (compilation) --- ###\n"; + std_err += "\n### --- stderr from make (compilation) --- ###\n"; + return runMake(Compile); + } + + bool QExternalTestPrivate::tryLink(const QByteArray &body) + { + if (!tryCompile(body) || exitCode != 0) + return false; + + // link + failedStage = QExternalTest::LinkStage; + std_out += "\n### --- stdout from make (linking) --- ###\n"; + std_err += "\n### --- stderr from make (linking) --- ###\n"; + return runMake(Link); + } + + bool QExternalTestPrivate::tryRun(const QByteArray &body) + { + if (!tryLink(body) || exitCode != 0) + return false; + + // run + failedStage = QExternalTest::RunStage; + std_out += "\n### --- stdout from process --- ###\n"; + std_err += "\n### --- stderr from process --- ###\n"; + return runMake(Run); + } +} +QT_END_NAMESPACE |