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

**

** 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 <QtTest/QtTest>

#include <QtCore/QProcess>

#include <QtCore/QDir>

#include <QtCore/QFile>

#include <QtCore/QThread>

#include <QtCore/QRegExp>

#include <QtCore/QDebug>

#include <QtCore/QMetaType>

#if !defined(Q_OS_SYMBIAN)

// Network test unnecessary?

#include <QtNetwork/QHostInfo>

#endif

#include <stdlib.h>

#ifdef QT_NO_PROCESS

QTEST_NOOP_MAIN

#else

#if defined(Q_OS_WIN)

#include <windows.h>

#endif

//TESTED_CLASS=

//TESTED_FILES=

Q_DECLARE_METATYPE(QList<QProcess::ExitStatus>);

Q_DECLARE_METATYPE(QProcess::ExitStatus);

Q_DECLARE_METATYPE(QProcess::ProcessState);

#define QPROCESS_VERIFY(Process, Fn) \

{ \

const bool ret = Process.Fn; \

if (ret == false) \

	qWarning("QProcess error: %d: %s", Process.error(), qPrintable(Process.errorString())); \

QVERIFY(ret); \

}

class tst_QProcess : public QObject

{

    Q_OBJECT

public:

    tst_QProcess();

    virtual ~tst_QProcess();

public slots:

    void init();

    void cleanup();

private slots:

    void getSetCheck();

    void constructing();

    void simpleStart();

    void startDetached();

    void crashTest();

    void crashTest2();

    void echoTest_data();

    void echoTest();

    void echoTest2();

    void echoTest_performance();

#if defined Q_OS_WIN

    void echoTestGui();

    void batFiles_data();

    void batFiles();

#endif

    void exitStatus_data();

    void exitStatus();

    void loopBackTest();

    void readTimeoutAndThenCrash();

    void waitForFinished();

    void deadWhileReading();

    void restartProcessDeadlock();

    void closeWriteChannel();

    void closeReadChannel();

    void openModes();

    void emitReadyReadOnlyWhenNewDataArrives();

    void hardExit();

    void softExit();

    void softExitInSlots_data();

    void softExitInSlots();

    void mergedChannels();

    void forwardedChannels();

    void atEnd();

    void atEnd2();

    void processInAThread();

    void processesInMultipleThreads();

    void waitForFinishedWithTimeout();

    void waitForReadyReadInAReadyReadSlot();

    void waitForBytesWrittenInABytesWrittenSlot();

    void spaceArgsTest_data();

    void spaceArgsTest();

    void exitCodeTest();

    void setEnvironment_data();

    void setEnvironment();

    void setProcessEnvironment_data();

    void setProcessEnvironment();

    void systemEnvironment();

    void spaceInName();

    void lockupsInStartDetached();

    void waitForReadyReadForNonexistantProcess();

    void setStandardInputFile();

    void setStandardOutputFile_data();

    void setStandardOutputFile();

    void setStandardOutputProcess_data();

    void setStandardOutputProcess();

    void removeFileWhileProcessIsRunning();

    void fileWriterProcess();

    void detachedWorkingDirectoryAndPid();

    void switchReadChannels();

    void setWorkingDirectory();

    void startFinishStartFinish();

    void invalidProgramString_data();

    void invalidProgramString();

    // keep these at the end, since they use lots of processes and sometimes

    // caused obscure failures to occur in tests that followed them (esp. on the Mac)

    void failToStart();

    void failToStartWithWait();

    void failToStartWithEventLoop();

protected slots:

    void readFromProcess();

    void exitLoopSlot();

    void restartProcess();

    void waitForReadyReadInAReadyReadSlotSlot();

    void waitForBytesWrittenInABytesWrittenSlotSlot();

private:

    QProcess *process;

    qint64 bytesAvailable;

};

// Testing get/set functions

void tst_QProcess::getSetCheck()

{

    QProcess obj1;

    // ProcessChannelMode QProcess::readChannelMode()

    // void QProcess::setReadChannelMode(ProcessChannelMode)

    obj1.setReadChannelMode(QProcess::ProcessChannelMode(QProcess::SeparateChannels));

    QCOMPARE(QProcess::ProcessChannelMode(QProcess::SeparateChannels), obj1.readChannelMode());

    obj1.setReadChannelMode(QProcess::ProcessChannelMode(QProcess::MergedChannels));

    QCOMPARE(QProcess::ProcessChannelMode(QProcess::MergedChannels), obj1.readChannelMode());

    obj1.setReadChannelMode(QProcess::ProcessChannelMode(QProcess::ForwardedChannels));

    QCOMPARE(QProcess::ProcessChannelMode(QProcess::ForwardedChannels), obj1.readChannelMode());

    // ProcessChannel QProcess::readChannel()

    // void QProcess::setReadChannel(ProcessChannel)

    obj1.setReadChannel(QProcess::ProcessChannel(QProcess::StandardOutput));

    QCOMPARE(QProcess::ProcessChannel(QProcess::StandardOutput), obj1.readChannel());

    obj1.setReadChannel(QProcess::ProcessChannel(QProcess::StandardError));

    QCOMPARE(QProcess::ProcessChannel(QProcess::StandardError), obj1.readChannel());

}

tst_QProcess::tst_QProcess()

{

}

tst_QProcess::~tst_QProcess()

{

}

void tst_QProcess::init()

{

#ifdef Q_OS_SYMBIAN

    QString dirStr = QString::fromLatin1("c:\\logs");

    QDir dir;

    if (!dir.exists(dirStr))

        dir.mkpath(dirStr);

#endif

}

void tst_QProcess::cleanup()

{

}

//-----------------------------------------------------------------------------

void tst_QProcess::constructing()

{

    QProcess process;

    QCOMPARE(process.readChannel(), QProcess::StandardOutput);

    QCOMPARE(process.workingDirectory(), QString());

    QCOMPARE(process.environment(), QStringList());

    QCOMPARE(process.error(), QProcess::UnknownError);

    QCOMPARE(process.state(), QProcess::NotRunning);

    QCOMPARE(process.pid(), Q_PID(0));

    QCOMPARE(process.readAllStandardOutput(), QByteArray());

    QCOMPARE(process.readAllStandardError(), QByteArray());

    QCOMPARE(process.canReadLine(), false);

    // QIODevice

    QCOMPARE(process.openMode(), QIODevice::NotOpen);

    QVERIFY(!process.isOpen());

    QVERIFY(!process.isReadable());

    QVERIFY(!process.isWritable());

    QVERIFY(process.isSequential());

    QCOMPARE(process.pos(), qlonglong(0));

    QCOMPARE(process.size(), qlonglong(0));

    QVERIFY(process.atEnd());

    QCOMPARE(process.bytesAvailable(), qlonglong(0));

    QCOMPARE(process.bytesToWrite(), qlonglong(0));

    QVERIFY(!process.errorString().isEmpty());

    char c;

    QCOMPARE(process.read(&c, 1), qlonglong(-1));

    QCOMPARE(process.write(&c, 1), qlonglong(-1));

}

void tst_QProcess::simpleStart()

{

    qRegisterMetaType<QProcess::ProcessState>("QProcess::ProcessState");

    process = new QProcess;

    QSignalSpy spy(process, SIGNAL(stateChanged(QProcess::ProcessState)));

    connect(process, SIGNAL(readyRead()), this, SLOT(readFromProcess()));

    /* valgrind dislike SUID binaries(those that have the `s'-flag set), which

     * makes it fail to start the process. For this reason utilities like `ping' won't

     * start, when the auto test is run through `valgrind'. */

    process->start("testProcessNormal/testProcessNormal");

    if (process->state() != QProcess::Starting)

        QCOMPARE(process->state(), QProcess::Running);

    QVERIFY(process->waitForStarted(5000));

    QCOMPARE(process->state(), QProcess::Running);

#if defined(Q_OS_WINCE)

    // Note: This actually seems incorrect, it will only exit the while loop when finishing fails

    while (process->waitForFinished(5000))

    { }

#elif defined(Q_OS_SYMBIAN)

    QVERIFY(process->waitForFinished(5000));

#else

    while (process->waitForReadyRead(5000))

    { }

#endif

    QCOMPARE(process->state(), QProcess::NotRunning);

    delete process;

    process = 0;

    QCOMPARE(spy.count(), 3);

    QCOMPARE(qVariantValue<QProcess::ProcessState>(spy.at(0).at(0)), QProcess::Starting);

    QCOMPARE(qVariantValue<QProcess::ProcessState>(spy.at(1).at(0)), QProcess::Running);

    QCOMPARE(qVariantValue<QProcess::ProcessState>(spy.at(2).at(0)), QProcess::NotRunning);

}

//-----------------------------------------------------------------------------

void tst_QProcess::startDetached()

{

    QProcess proc;

    QVERIFY(proc.startDetached("testProcessNormal/testProcessNormal",

                               QStringList() << "arg1" << "arg2"));

    QCOMPARE(QProcess::startDetached("nonexistingexe"), false);

}

//-----------------------------------------------------------------------------

void tst_QProcess::readFromProcess()

{

    int lines = 0;

    while (process->canReadLine()) {

        ++lines;

        QByteArray line = process->readLine();

    }

}

//-----------------------------------------------------------------------------

void tst_QProcess::crashTest()

{

    qRegisterMetaType<QProcess::ProcessState>("QProcess::ProcessState");

#ifdef Q_OS_WIN

    QSKIP("This test opens a crash dialog on Windows", SkipSingle);

#endif

    process = new QProcess;

    QSignalSpy stateSpy(process, SIGNAL(stateChanged(QProcess::ProcessState)));

    process->start("testProcessCrash/testProcessCrash");

    QVERIFY(process->waitForStarted(5000));

    qRegisterMetaType<QProcess::ProcessError>("QProcess::ProcessError");

    qRegisterMetaType<QProcess::ProcessError>("QProcess::ExitStatus");

    QSignalSpy spy(process, SIGNAL(error(QProcess::ProcessError)));

    QSignalSpy spy2(process, SIGNAL(finished(int, QProcess::ExitStatus)));

    QVERIFY(process->waitForFinished(5000));

    QCOMPARE(spy.count(), 1);

    QCOMPARE(*static_cast<const QProcess::ProcessError *>(spy.at(0).at(0).constData()), QProcess::Crashed);

    QCOMPARE(spy2.count(), 1);

    QCOMPARE(*static_cast<const QProcess::ExitStatus *>(spy2.at(0).at(1).constData()), QProcess::CrashExit);

    QCOMPARE(process->exitStatus(), QProcess::CrashExit);

    delete process;

    process = 0;

    QCOMPARE(stateSpy.count(), 3);

    QCOMPARE(qVariantValue<QProcess::ProcessState>(stateSpy.at(0).at(0)), QProcess::Starting);

    QCOMPARE(qVariantValue<QProcess::ProcessState>(stateSpy.at(1).at(0)), QProcess::Running);

    QCOMPARE(qVariantValue<QProcess::ProcessState>(stateSpy.at(2).at(0)), QProcess::NotRunning);

}

//-----------------------------------------------------------------------------

void tst_QProcess::crashTest2()

{

#ifdef Q_OS_WIN

    QSKIP("This test opens a crash dialog on Windows", SkipSingle);

#endif

    process = new QProcess;

    process->start("testProcessCrash/testProcessCrash");

    QVERIFY(process->waitForStarted(5000));

    qRegisterMetaType<QProcess::ProcessError>("QProcess::ProcessError");

    qRegisterMetaType<QProcess::ProcessError>("QProcess::ExitStatus");

    QSignalSpy spy(process, SIGNAL(error(QProcess::ProcessError)));

    QSignalSpy spy2(process, SIGNAL(finished(int, QProcess::ExitStatus)));

    QObject::connect(process, SIGNAL(finished(int)), this, SLOT(exitLoopSlot()));

    QTestEventLoop::instance().enterLoop(5);

    if (QTestEventLoop::instance().timeout())

        QFAIL("Failed to detect crash : operation timed out");

    QCOMPARE(spy.count(), 1);

    QCOMPARE(*static_cast<const QProcess::ProcessError *>(spy.at(0).at(0).constData()), QProcess::Crashed);

    QCOMPARE(spy2.count(), 1);

    QCOMPARE(*static_cast<const QProcess::ExitStatus *>(spy2.at(0).at(1).constData()), QProcess::CrashExit);

    QCOMPARE(process->exitStatus(), QProcess::CrashExit);

    delete process;

    process = 0;

}

//-----------------------------------------------------------------------------

void tst_QProcess::echoTest_data()

{

    QTest::addColumn<QByteArray>("input");

    QTest::newRow("1") << QByteArray("H");

    QTest::newRow("2") << QByteArray("He");

    QTest::newRow("3") << QByteArray("Hel");

    QTest::newRow("4") << QByteArray("Hell");

    QTest::newRow("5") << QByteArray("Hello");

    QTest::newRow("100 bytes") << QByteArray(100, '@');

    QTest::newRow("1000 bytes") << QByteArray(1000, '@');

    QTest::newRow("10000 bytes") << QByteArray(10000, '@');

}

//-----------------------------------------------------------------------------

void tst_QProcess::echoTest()

{

#ifdef Q_OS_WINCE

    QSKIP("Reading and writing to a process is not supported on Qt/CE", SkipAll);

#endif

#if defined(Q_OS_SYMBIAN)

    QSKIP("Reading and writing to a process is not supported on Qt/Symbian", SkipAll);

#endif

    QFETCH(QByteArray, input);

    process = new QProcess;

    connect(process, SIGNAL(readyRead()), this, SLOT(exitLoopSlot()));

#ifdef Q_OS_MAC

    process->start("testProcessEcho/testProcessEcho.app");

#else

    process->start("testProcessEcho/testProcessEcho");

#endif

    QVERIFY(process->waitForStarted(5000));

    process->write(input);

    QTime stopWatch;

    stopWatch.start();

    do {

        QVERIFY(process->isOpen());

        QTestEventLoop::instance().enterLoop(2);

    } while (stopWatch.elapsed() < 60000 && process->bytesAvailable() < input.size());

    if (stopWatch.elapsed() >= 60000)

        QFAIL("Timed out");

    QByteArray message = process->readAll();

    QCOMPARE(message.size(), input.size());

    char *c1 = message.data();

    char *c2 = input.data();

    while (*c1 && *c2) {

        if (*c1 != *c2)

            QCOMPARE(*c1, *c2);

        ++c1;

        ++c2;

    }

    QCOMPARE(*c1, *c2);

    process->write("", 1);

    QVERIFY(process->waitForFinished(5000));

    delete process;

    process = 0;

}

//-----------------------------------------------------------------------------

void tst_QProcess::exitLoopSlot()

{

    QTestEventLoop::instance().exitLoop();

}

//-----------------------------------------------------------------------------

void tst_QProcess::echoTest2()

{

#ifdef Q_OS_WINCE

    QSKIP("Reading and writing to a process is not supported on Qt/CE", SkipAll);

#endif

#if defined(Q_OS_SYMBIAN)

    QSKIP("Reading and writing to a process is not supported on Qt/Symbian", SkipAll);

#endif

    process = new QProcess;

    connect(process, SIGNAL(readyRead()), this, SLOT(exitLoopSlot()));

#ifdef Q_OS_MAC

    process->start("testProcessEcho2/testProcessEcho2.app");

#else

    process->start("testProcessEcho2/testProcessEcho2");

#endif

    QVERIFY(process->waitForStarted(5000));

    QVERIFY(!process->waitForReadyRead(250));

    QCOMPARE(process->error(), QProcess::Timedout);

    process->write("Hello");

    QSignalSpy spy1(process, SIGNAL(readyReadStandardOutput()));

    QSignalSpy spy2(process, SIGNAL(readyReadStandardError()));

    QTime stopWatch;

    stopWatch.start();

    forever {

        QTestEventLoop::instance().enterLoop(1);

        if (stopWatch.elapsed() >= 30000)

            QFAIL("Timed out");

        process->setReadChannel(QProcess::StandardOutput);

        qint64 baso = process->bytesAvailable();

        process->setReadChannel(QProcess::StandardError);

        qint64 base = process->bytesAvailable();

        if (baso == 5 && base == 5)

            break;

    }

    QVERIFY(spy1.count() > 0);

    QVERIFY(spy2.count() > 0);

    QCOMPARE(process->readAllStandardOutput(), QByteArray("Hello"));

    QCOMPARE(process->readAllStandardError(), QByteArray("Hello"));

    process->write("", 1);

    QVERIFY(process->waitForFinished(5000));

    delete process;

    process = 0;

}

//-----------------------------------------------------------------------------

void tst_QProcess::echoTest_performance()

{

#ifdef Q_OS_WINCE

    QSKIP("Reading and writing to a process is not supported on Qt/CE", SkipAll);

#endif

#if defined(Q_OS_SYMBIAN)

    QSKIP("Reading and writing to a process is not supported on Qt/Symbian", SkipAll);

#endif

    QProcess process;

#ifdef Q_OS_MAC

    process.start("testProcessLoopback/testProcessLoopback.app");

#else

    process.start("testProcessLoopback/testProcessLoopback");

#endif

    QByteArray array;

    array.resize(1024 * 1024);

    for (int j = 0; j < array.size(); ++j)

        array[j] = 'a' + (j % 20);

    QVERIFY(process.waitForStarted());