/****************************************************************************

**

** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).

** All rights reserved.

** Contact: Nokia Corporation (qt-info@nokia.com)

**

** This file is part of the test suite of the Qt Toolkit.

**

** $QT_BEGIN_LICENSE:LGPL$

** No Commercial Usage

** This file contains pre-release code and may not be distributed.

** You may use this file in accordance with the terms and conditions

** contained in the Technology Preview License Agreement accompanying

** this package.

**

** GNU Lesser General Public License Usage

** Alternatively, this file may be used under the terms of the GNU Lesser

** General Public License version 2.1 as published by the Free Software

** Foundation and appearing in the file LICENSE.LGPL included in the

** packaging of this file.  Please review the following information to

** ensure the GNU Lesser General Public License version 2.1 requirements

** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.

**

** In addition, as a special exception, Nokia gives you certain additional

** rights.  These rights are described in the Nokia Qt LGPL Exception

** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.

**

** If you have questions regarding the use of this file, please contact

** Nokia at qt-info@nokia.com.

**

**

**

**

**

**

**

**

** $QT_END_LICENSE$

**

****************************************************************************/

#include "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>

#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),

              debugMode(true),

              exitCode(-1)

        {

        }

        ~QExternalTestPrivate()

        {

            clear();

        }

        enum Target { Compile, Link, Run };

        QList<QByteArray> qmakeLines;

        QStringList extraProgramSources;

        QByteArray programHeader;

        QExternalTest::QtModules qtModules;

        QExternalTest::ApplicationType appType;

        bool debugMode;

        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;

    }

    bool QExternalTest::isDebugMode() const

    {

        return d->debugMode;

    }

    void QExternalTest::setDebugMode(bool enable)

    {

        d->debugMode = enable;

    }

    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()

    {

        Q_ASSERT(!temporaryDir.isEmpty());

        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::Qt3Support)

            sourceCode += "#include <Qt3Support/Qt3Support>\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()

    {

        Q_ASSERT(!temporaryDir.isEmpty());

        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()));

        if (debugMode)

            projectFile.write("\nCONFIG  += debug\n");

        else