1 /****************************************************************************

     2 **

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

     4 ** All rights reserved.

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

     6 **

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

     8 **

     9 ** $QT_BEGIN_LICENSE:LGPL$

    10 ** No Commercial Usage

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

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

    13 ** contained in the Technology Preview License Agreement accompanying

    14 ** this package.

    15 **

    16 ** GNU Lesser General Public License Usage

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

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

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

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

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

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

    23 **

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

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

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

    27 **

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

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

    30 **

    31 **

    32 **

    33 **

    34 **

    35 **

    36 **

    37 **

    38 ** $QT_END_LICENSE$

    39 **

    40 ****************************************************************************/

    41 

    42 

    43 #include <QtTest/QtTest>

    44 #include <QtCore/QProcess>

    45 #include <QtCore/QDir>

    46 #include <QtCore/QFile>

    47 #include <QtCore/QThread>

    48 #include <QtCore/QRegExp>

    49 #include <QtCore/QDebug>

    50 #include <QtCore/QMetaType>

    51 #if !defined(Q_OS_SYMBIAN)

    52 // Network test unnecessary?

    53 #include <QtNetwork/QHostInfo>

    54 #endif

    55 #include <stdlib.h>

    56 

    57 #ifdef QT_NO_PROCESS

    58 QTEST_NOOP_MAIN

    59 #else

    60 

    61 #if defined(Q_OS_WIN)

    62 #include <windows.h>

    63 #endif

    64 

    65 //TESTED_CLASS=

    66 //TESTED_FILES=

    67 

    68 Q_DECLARE_METATYPE(QList<QProcess::ExitStatus>);

    69 Q_DECLARE_METATYPE(QProcess::ExitStatus);

    70 Q_DECLARE_METATYPE(QProcess::ProcessState);

    71 

    72 #define QPROCESS_VERIFY(Process, Fn) \

    73 { \

    74 const bool ret = Process.Fn; \

    75 if (ret == false) \

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

    77 QVERIFY(ret); \

    78 }

    79 

    80 class tst_QProcess : public QObject

    81 {

    82     Q_OBJECT

    83 

    84 public:

    85     tst_QProcess();

    86     virtual ~tst_QProcess();

    87 

    88 public slots:

    89     void init();

    90     void cleanup();

    91 

    92 private slots:

    93     void getSetCheck();

    94     void constructing();

    95     void simpleStart();

    96     void startDetached();

    97     void crashTest();

    98     void crashTest2();

    99     void echoTest_data();

   100     void echoTest();

   101     void echoTest2();

   102     void echoTest_performance();

   103 #if defined Q_OS_WIN

   104     void echoTestGui();

   105     void batFiles_data();

   106     void batFiles();

   107 #endif

   108     void exitStatus_data();

   109     void exitStatus();

   110     void loopBackTest();

   111     void readTimeoutAndThenCrash();

   112     void waitForFinished();

   113     void deadWhileReading();

   114     void restartProcessDeadlock();

   115     void closeWriteChannel();

   116     void closeReadChannel();

   117     void openModes();

   118     void emitReadyReadOnlyWhenNewDataArrives();

   119     void hardExit();

   120     void softExit();

   121     void softExitInSlots_data();

   122     void softExitInSlots();

   123     void mergedChannels();

   124     void forwardedChannels();

   125     void atEnd();

   126     void atEnd2();

   127     void processInAThread();

   128     void processesInMultipleThreads();

   129     void waitForFinishedWithTimeout();

   130     void waitForReadyReadInAReadyReadSlot();

   131     void waitForBytesWrittenInABytesWrittenSlot();

   132     void spaceArgsTest_data();

   133     void spaceArgsTest();

   134     void exitCodeTest();

   135     void setEnvironment_data();

   136     void setEnvironment();

   137     void setProcessEnvironment_data();

   138     void setProcessEnvironment();

   139     void systemEnvironment();

   140     void spaceInName();

   141     void lockupsInStartDetached();

   142     void waitForReadyReadForNonexistantProcess();

   143     void setStandardInputFile();

   144     void setStandardOutputFile_data();

   145     void setStandardOutputFile();

   146     void setStandardOutputProcess_data();

   147     void setStandardOutputProcess();

   148     void removeFileWhileProcessIsRunning();

   149     void fileWriterProcess();

   150     void detachedWorkingDirectoryAndPid();

   151     void switchReadChannels();

   152     void setWorkingDirectory();

   153     void startFinishStartFinish();

   154     void invalidProgramString_data();

   155     void invalidProgramString();

   156 

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

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

   159     void failToStart();

   160     void failToStartWithWait();

   161     void failToStartWithEventLoop();

   162 

   163 protected slots:

   164     void readFromProcess();

   165     void exitLoopSlot();

   166     void restartProcess();

   167     void waitForReadyReadInAReadyReadSlotSlot();

   168     void waitForBytesWrittenInABytesWrittenSlotSlot();

   169 

   170 private:

   171     QProcess *process;

   172     qint64 bytesAvailable;

   173 };

   174 

   175 // Testing get/set functions

   176 void tst_QProcess::getSetCheck()

   177 {

   178     QProcess obj1;

   179     // ProcessChannelMode QProcess::readChannelMode()

   180     // void QProcess::setReadChannelMode(ProcessChannelMode)

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

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

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

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

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

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

   187 

   188     // ProcessChannel QProcess::readChannel()

   189     // void QProcess::setReadChannel(ProcessChannel)

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

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

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

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

   194 }

   195 

   196 tst_QProcess::tst_QProcess()

   197 {

   198 }

   199 

   200 tst_QProcess::~tst_QProcess()

   201 {

   202 }

   203 

   204 void tst_QProcess::init()

   205 {

   206 #ifdef Q_OS_SYMBIAN

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

   208     QDir dir;

   209     if (!dir.exists(dirStr))

   210         dir.mkpath(dirStr);

   211 #endif

   212 }

   213 

   214 void tst_QProcess::cleanup()

   215 {

   216 }

   217 

   218 //-----------------------------------------------------------------------------

   219 void tst_QProcess::constructing()

   220 {

   221     QProcess process;

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

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

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

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

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

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

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

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

   230     QCOMPARE(process.canReadLine(), false);

   231 

   232     // QIODevice

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

   234     QVERIFY(!process.isOpen());

   235     QVERIFY(!process.isReadable());

   236     QVERIFY(!process.isWritable());

   237     QVERIFY(process.isSequential());

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

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

   240     QVERIFY(process.atEnd());

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

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

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

   244 

   245     char c;

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

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

   248 }

   249 

   250 void tst_QProcess::simpleStart()

   251 {

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

   253 

   254     process = new QProcess;

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

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

   257 

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

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

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

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

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

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

   264     QVERIFY(process->waitForStarted(5000));

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

   266 #if defined(Q_OS_WINCE)

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

   268     while (process->waitForFinished(5000))

   269     { }

   270 #elif defined(Q_OS_SYMBIAN)

   271     QVERIFY(process->waitForFinished(5000));

   272 #else

   273     while (process->waitForReadyRead(5000))

   274     { }

   275 #endif

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

   277 

   278     delete process;

   279     process = 0;

   280 

   281     QCOMPARE(spy.count(), 3);

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

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

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

   285 }

   286 //-----------------------------------------------------------------------------

   287 void tst_QProcess::startDetached()

   288 {

   289     QProcess proc;

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

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

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

   293 }

   294 

   295 //-----------------------------------------------------------------------------

   296 void tst_QProcess::readFromProcess()

   297 {

   298     int lines = 0;

   299     while (process->canReadLine()) {

   300         ++lines;

   301         QByteArray line = process->readLine();

   302     }

   303 }

   304 

   305 //-----------------------------------------------------------------------------

   306 void tst_QProcess::crashTest()

   307 {

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

   309 #ifdef Q_OS_WIN

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

   311 #endif

   312     process = new QProcess;

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

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

   315     QVERIFY(process->waitForStarted(5000));

   316 

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

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

   319 

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

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

   322 

   323     QVERIFY(process->waitForFinished(5000));

   324 

   325     QCOMPARE(spy.count(), 1);

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

   327 

   328     QCOMPARE(spy2.count(), 1);

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

   330 

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

   332 

   333     delete process;

   334     process = 0;

   335 

   336     QCOMPARE(stateSpy.count(), 3);

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

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

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

   340 }

   341 

   342 //-----------------------------------------------------------------------------

   343 void tst_QProcess::crashTest2()

   344 {

   345 #ifdef Q_OS_WIN

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

   347 #endif

   348     process = new QProcess;

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

   350     QVERIFY(process->waitForStarted(5000));

   351 

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

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

   354 

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

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

   357 

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

   359 

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

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

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

   363 

   364     QCOMPARE(spy.count(), 1);

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

   366 

   367     QCOMPARE(spy2.count(), 1);

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

   369 

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

   371 

   372     delete process;

   373     process = 0;

   374 }

   375 

   376 //-----------------------------------------------------------------------------

   377 void tst_QProcess::echoTest_data()

   378 {

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

   380 

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

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

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

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

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

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

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

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

   389 }

   390 

   391 //-----------------------------------------------------------------------------

   392 void tst_QProcess::echoTest()

   393 {

   394 #ifdef Q_OS_WINCE

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

   396 #endif

   397 #if defined(Q_OS_SYMBIAN)

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

   399 #endif

   400 

   401     QFETCH(QByteArray, input);

   402 

   403     process = new QProcess;

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

   405 

   406 #ifdef Q_OS_MAC

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

   408 #else

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

   410 #endif

   411     QVERIFY(process->waitForStarted(5000));

   412 

   413     process->write(input);

   414 

   415     QTime stopWatch;

   416     stopWatch.start();

   417     do {

   418         QVERIFY(process->isOpen());

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

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

   421     if (stopWatch.elapsed() >= 60000)

   422         QFAIL("Timed out");

   423 

   424     QByteArray message = process->readAll();

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

   426 

   427     char *c1 = message.data();

   428     char *c2 = input.data();

   429     while (*c1 && *c2) {

   430         if (*c1 != *c2)

   431             QCOMPARE(*c1, *c2);

   432         ++c1;

   433         ++c2;

   434     }

   435     QCOMPARE(*c1, *c2);

   436 

   437     process->write("", 1);

   438 

   439     QVERIFY(process->waitForFinished(5000));

   440 

   441 

   442     delete process;

   443     process = 0;

   444 }

   445 

   446 //-----------------------------------------------------------------------------

   447 void tst_QProcess::exitLoopSlot()

   448 {

   449     QTestEventLoop::instance().exitLoop();

   450 }

   451 

   452 //-----------------------------------------------------------------------------

   453 void tst_QProcess::echoTest2()

   454 {

   455 #ifdef Q_OS_WINCE

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

   457 #endif

   458 #if defined(Q_OS_SYMBIAN)

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

   460 #endif

   461 

   462     process = new QProcess;

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

   464 

   465 #ifdef Q_OS_MAC

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

   467 #else

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

   469 #endif

   470     QVERIFY(process->waitForStarted(5000));

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

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

   473 

   474     process->write("Hello");

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

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

   477 

   478     QTime stopWatch;

   479     stopWatch.start();

   480     forever {

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

   482         if (stopWatch.elapsed() >= 30000)

   483             QFAIL("Timed out");

   484         process->setReadChannel(QProcess::StandardOutput);

   485         qint64 baso = process->bytesAvailable();

   486 

   487         process->setReadChannel(QProcess::StandardError);

   488         qint64 base = process->bytesAvailable();

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

   490             break;

   491     }

   492 

   493     QVERIFY(spy1.count() > 0);

   494     QVERIFY(spy2.count() > 0);

   495 

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

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

   498 

   499     process->write("", 1);

   500     QVERIFY(process->waitForFinished(5000));

   501 

   502     delete process;

   503     process = 0;

   504 }

   505 

   506 //-----------------------------------------------------------------------------

   507 void tst_QProcess::echoTest_performance()

   508 {

   509 #ifdef Q_OS_WINCE

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

   511 #endif

   512 #if defined(Q_OS_SYMBIAN)

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

   514 #endif

   515 

   516     QProcess process;

   517 #ifdef Q_OS_MAC

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

   519 #else

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

   521 #endif

   522 

   523     QByteArray array;

   524     array.resize(1024 * 1024);

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

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

   527 

   528     QVERIFY(process.waitForStarted());

   529 

   530     QTime stopWatch;

   531     stopWatch.start();

   532 

   533     qint64 totalBytes = 0;

   534     QByteArray dump;

   535     QSignalSpy readyReadSpy(&process, SIGNAL(readyRead()));

   536     while (stopWatch.elapsed() < 2000) {

   537         process.write(array);

   538         while (process.bytesToWrite() > 0) {

   539             int readCount = readyReadSpy.count();

   540             QVERIFY(process.waitForBytesWritten(5000));

   541             if (readyReadSpy.count() == readCount)

   542                 QVERIFY(process.waitForReadyRead(5000));

   543         }

   544 

   545         while (process.bytesAvailable() < array.size())

   546             QVERIFY2(process.waitForReadyRead(5000), qPrintable(process.errorString()));

   547         dump = process.readAll();

   548         totalBytes += dump.size();

   549     }

   550 

   551     qDebug() << "Elapsed time:" << stopWatch.elapsed() << "ms;"

   552              << "transfer rate:" << totalBytes / (1048.576) / stopWatch.elapsed()

   553              << "MB/s";

   554 

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

   556         QCOMPARE(char(dump.at(j)), char('a' + (j % 20)));

   557 

   558     process.closeWriteChannel();

   559     QVERIFY(process.waitForFinished());

   560 }

   561 

   562 #if defined Q_OS_WIN

   563 //-----------------------------------------------------------------------------

   564 void tst_QProcess::echoTestGui()

   565 {

   566 #ifdef Q_OS_WINCE

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

   568 #endif

   569 #if defined(Q_OS_SYMBIAN)

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

   571 #endif

   572 

   573     QProcess process;

   574 

   575     process.start("testProcessEchoGui/testProcessEchoGui");

   576 

   577 

   578     process.write("Hello");

   579     process.write("q");

   580 

   581     QVERIFY(process.waitForFinished(50000));

   582 

   583     QCOMPARE(process.readAllStandardOutput(), QByteArray("Hello"));

   584     QCOMPARE(process.readAllStandardError(), QByteArray("Hello"));

   585 }

   586 

   587 //-----------------------------------------------------------------------------

   588 void tst_QProcess::batFiles_data()

   589 {

   590     QTest::addColumn<QString>("batFile");

   591     QTest::addColumn<QByteArray>("output");

   592 

   593     QTest::newRow("simple") << QString::fromLatin1("testBatFiles/simple.bat") << QByteArray("Hello");

   594     QTest::newRow("with space") << QString::fromLatin1("testBatFiles/with space.bat") << QByteArray("Hello");

   595 }

   596 

   597 void tst_QProcess::batFiles()

   598 {

   599 #if defined(Q_OS_WINCE)

   600     QSKIP("Batch files are not supported on Windows CE", SkipAll);

   601 #endif

   602 #if defined(Q_OS_SYMBIAN)

   603     QSKIP("Batch files are not supported on Symbian", SkipAll);

   604 #endif

   605     QFETCH(QString, batFile);

   606     QFETCH(QByteArray, output);

   607 

   608     QProcess proc;

   609 

   610     proc.start(batFile, QStringList());

   611 

   612     QVERIFY(proc.waitForFinished(5000));

   613 

   614     QVERIFY(proc.bytesAvailable() > 0);

   615 

   616     QVERIFY(proc.readAll().startsWith(output));

   617 }

   618 

   619 #endif

   620 

   621 //-----------------------------------------------------------------------------

   622 void tst_QProcess::exitStatus_data()

   623 {

   624     QTest::addColumn<QStringList>("processList");

   625     QTest::addColumn<QList<QProcess::ExitStatus> >("exitStatus");

   626 

   627     QTest::newRow("normal") << (QStringList() << "testProcessNormal/testProcessNormal")

   628                             << (QList<QProcess::ExitStatus>() << QProcess::NormalExit);

   629     QTest::newRow("crash") << (QStringList() << "testProcessCrash/testProcessCrash")

   630                             << (QList<QProcess::ExitStatus>() << QProcess::CrashExit);

   631 

   632     QTest::newRow("normal-crash") << (QStringList()

   633                                       << "testProcessNormal/testProcessNormal"

   634                                       << "testProcessCrash/testProcessCrash")

   635                                   << (QList<QProcess::ExitStatus>()

   636                                       << QProcess::NormalExit

   637                                       << QProcess::CrashExit);

   638     QTest::newRow("crash-normal") << (QStringList()

   639                                       << "testProcessCrash/testProcessCrash"

   640                                       << "testProcessNormal/testProcessNormal")

   641                                   << (QList<QProcess::ExitStatus>()

   642                                       << QProcess::CrashExit

   643                                       << QProcess::NormalExit);

   644 }

   645 

   646 void tst_QProcess::exitStatus()

   647 {

   648     process = new QProcess;

   649     QFETCH(QStringList, processList);

   650     QFETCH(QList<QProcess::ExitStatus>, exitStatus);

   651 

   652 #ifdef Q_OS_WIN

   653     if (exitStatus.contains(QProcess::CrashExit))

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

   655 #endif

   656 

   657     Q_ASSERT(processList.count() == exitStatus.count());

   658     for (int i = 0; i < processList.count(); ++i) {

   659         process->start(processList.at(i));

   660         QVERIFY(process->waitForStarted(5000));

   661         QVERIFY(process->waitForFinished(5000));

   662 

   663         QCOMPARE(process->exitStatus(), exitStatus.at(i));

   664     }

   665 

   666     process->deleteLater();

   667     process = 0;

   668 }

   669 //-----------------------------------------------------------------------------

   670 void tst_QProcess::loopBackTest()

   671 {

   672 #ifdef Q_OS_WINCE

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

   674 #endif

   675 #if defined(Q_OS_SYMBIAN)

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

   677 #endif

   678 

   679     process = new QProcess;

   680 #ifdef Q_OS_MAC

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

   682 #else

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

   684 #endif

   685     QVERIFY(process->waitForStarted(5000));

   686 

   687     for (int i = 0; i < 100; ++i) {

   688         process->write("Hello");

   689         do {

   690             QVERIFY(process->waitForReadyRead(5000));

   691         } while (process->bytesAvailable() < 5);

   692         QCOMPARE(process->readAll(), QByteArray("Hello"));

   693     }

   694 

   695     process->write("", 1);

   696     QVERIFY(process->waitForFinished(5000));

   697 

   698     delete process;

   699     process = 0;

   700 }

   701 

   702 //-----------------------------------------------------------------------------

   703 void tst_QProcess::readTimeoutAndThenCrash()

   704 {

   705 #ifdef Q_OS_WINCE

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

   707 #endif

   708 #if defined(Q_OS_SYMBIAN)

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

   710 #endif

   711 

   712     process = new QProcess;

   713 #ifdef Q_OS_MAC

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

   715 #else

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

   717 #endif

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

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

   720 

   721     QVERIFY(process->waitForStarted(5000));

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

   723 

   724     QVERIFY(!process->waitForReadyRead(5000));

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

   726 

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

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

   729 

   730     process->kill();

   731 

   732     QVERIFY(process->waitForFinished(5000));

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

   734 

   735     QCOMPARE(spy.count(), 1);

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

   737 

   738     delete process;

   739     process = 0;

   740 }

   741 

   742 void tst_QProcess::waitForFinished()

   743 {

   744     QProcess process;

   745 

   746 #ifdef Q_OS_MAC

   747     process.start("testProcessOutput/testProcessOutput.app");

   748 #else

   749     process.start("testProcessOutput/testProcessOutput");

   750 #endif

   751 

   752 #if !defined(Q_OS_WINCE) && !defined(Q_OS_SYMBIAN)

   753     QVERIFY(process.waitForFinished(5000));

   754 #else

   755     QVERIFY(process.waitForFinished(30000));

   756 #endif

   757     QCOMPARE(process.exitStatus(), QProcess::NormalExit);

   758 

   759 #if defined(Q_OS_SYMBIAN)

   760     // Symbian test outputs to a file, so check that

   761     FILE* file = fopen("c:\\logs\\qprocess_output_test.txt","r");

   762     int retval = 0;

   763     int count = 0;

   764     while((int)(retval = fgetc(file) )!= EOF)

   765         if (retval == '\n')

   766             count++;

   767     fclose(file);

   768     QCOMPARE(count, 200);

   769 #else

   770 #  if defined (Q_OS_WINCE)

   771     QEXPECT_FAIL("", "Reading and writing to a process is not supported on Qt/CE", Continue);

   772 #  endif

   773     QString output = process.readAll();

   774     QCOMPARE(output.count("\n"), 10*1024);

   775 #endif

   776 

   777     process.start("blurdybloop");

   778     QVERIFY(!process.waitForFinished());

   779     QCOMPARE(process.error(), QProcess::FailedToStart);

   780 }

   781 

   782 

   783 void tst_QProcess::deadWhileReading()

   784 {

   785 #ifdef Q_OS_WINCE

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

   787 #endif

   788 #if defined(Q_OS_SYMBIAN)

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

   790 #endif

   791 

   792     QProcess process;

   793 

   794 #ifdef Q_OS_MAC

   795     process.start("testProcessDeadWhileReading/testProcessDeadWhileReading.app");

   796 #else

   797     process.start("testProcessDeadWhileReading/testProcessDeadWhileReading");

   798 #endif

   799 

   800     QString output;

   801 

   802     QVERIFY(process.waitForStarted(5000));

   803     while (process.waitForReadyRead(5000))

   804         output += process.readAll();

   805 

   806     QCOMPARE(output.count("\n"), 10*1024);

   807     process.waitForFinished();

   808 }

   809 

   810 //-----------------------------------------------------------------------------

   811 void tst_QProcess::restartProcessDeadlock()

   812 {

   813 #ifdef Q_OS_WINCE

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

   815 #endif

   816 #if defined(Q_OS_SYMBIAN)

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

   818 #endif

   819 

   820     // The purpose of this test is to detect whether restarting a

   821     // process in the finished() connected slot causes a deadlock

   822     // because of the way QProcessManager uses its locks.

   823     QProcess proc;

   824     process = &proc;

   825     connect(process, SIGNAL(finished(int)), this, SLOT(restartProcess()));

   826 

   827 #ifdef Q_OS_MAC

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

   829 #else

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

   831 #endif

   832 

   833     QCOMPARE(process->write("", 1), qlonglong(1));

   834     QVERIFY(process->waitForFinished(5000));

   835 

   836     process->disconnect(SIGNAL(finished(int)));

   837 

   838     QCOMPARE(process->write("", 1), qlonglong(1));

   839     QVERIFY(process->waitForFinished(5000));

   840 }

   841 

   842 void tst_QProcess::restartProcess()

   843 {

   844 #ifdef Q_OS_MAC

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

   846 #else

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

   848 #endif

   849 }

   850 

   851 //-----------------------------------------------------------------------------

   852 void tst_QProcess::closeWriteChannel()

   853 {

   854 #ifdef Q_OS_WINCE

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

   856 #endif

   857 #if defined(Q_OS_SYMBIAN)

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

   859 #endif

   860 

   861     QProcess more;

   862     more.start("testProcessEOF/testProcessEOF");

   863 

   864     QVERIFY(more.waitForStarted(5000));

   865     QVERIFY(!more.waitForReadyRead(250));

   866     QCOMPARE(more.error(), QProcess::Timedout);

   867 

   868     QVERIFY(more.write("Data to read") != -1);

   869 

   870     QVERIFY(!more.waitForReadyRead(250));

   871     QCOMPARE(more.error(), QProcess::Timedout);

   872 

   873     more.closeWriteChannel();

   874 

   875     QVERIFY(more.waitForReadyRead(5000));

   876     QVERIFY(more.readAll().startsWith("Data to read"));

   877 

   878     if (more.state() == QProcess::Running)

   879         more.write("q");

   880     QVERIFY(more.waitForFinished(5000));

   881 }

   882 

   883 //-----------------------------------------------------------------------------

   884 void tst_QProcess::closeReadChannel()

   885 {

   886 #ifdef Q_OS_WINCE

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

   888 #endif

   889 #if defined(Q_OS_SYMBIAN)

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

   891 #endif

   892 

   893     for (int i = 0; i < 10; ++i) {

   894         QProcess::ProcessChannel channel1 = QProcess::StandardOutput;

   895         QProcess::ProcessChannel channel2 = QProcess::StandardError;

   896 

   897         QProcess proc;

   898 #ifdef Q_OS_MAC

   899         proc.start("testProcessEcho2/testProcessEcho2.app");

   900 #else

   901         proc.start("testProcessEcho2/testProcessEcho2");

   902 #endif

   903         QVERIFY(proc.waitForStarted(5000));

   904         proc.closeReadChannel(i&1 ? channel2 : channel1);

   905         proc.setReadChannel(i&1 ? channel2 : channel1);

   906         proc.write("Data");

   907 

   908         QVERIFY(!proc.waitForReadyRead(5000));

   909         QVERIFY(proc.readAll().isEmpty());

   910 

   911         proc.setReadChannel(i&1 ? channel1 : channel2);

   912 

   913         while (proc.bytesAvailable() < 4 && proc.waitForReadyRead(5000))

   914         { }

   915 

   916         QCOMPARE(proc.readAll(), QByteArray("Data"));

   917 

   918         proc.write("", 1);

   919         QVERIFY(proc.waitForFinished(5000));

   920     }

   921 }

   922 

   923 //-----------------------------------------------------------------------------

   924 void tst_QProcess::openModes()

   925 {

   926 #ifdef Q_OS_WINCE

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

   928 #endif

   929 #if defined(Q_OS_SYMBIAN)

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

   931 #endif

   932 

   933     QProcess proc;

   934     QVERIFY(!proc.isOpen());

   935     QVERIFY(proc.openMode() == QProcess::NotOpen);

   936 #ifdef Q_OS_MAC

   937     proc.start("testProcessEcho3/testProcessEcho3.app");

   938 #else

   939     proc.start("testProcessEcho3/testProcessEcho3");

   940 #endif

   941     QVERIFY(proc.waitForStarted(5000));

   942     QVERIFY(proc.isOpen());

   943     QVERIFY(proc.openMode() == QProcess::ReadWrite);

   944     QVERIFY(proc.isReadable());

   945     QVERIFY(proc.isWritable());

   946 

   947     proc.write("Data");

   948 

   949     proc.closeWriteChannel();

   950 

   951     QVERIFY(proc.isWritable());

   952     QVERIFY(proc.openMode() == QProcess::ReadWrite);

   953 

   954     while (proc.bytesAvailable() < 4 && proc.waitForReadyRead(5000))

   955     { }

   956 

   957     QCOMPARE(proc.readAll().constData(), QByteArray("Data").constData());

   958 

   959     proc.closeReadChannel(QProcess::StandardOutput);

   960 

   961     QVERIFY(proc.openMode() == QProcess::ReadWrite);

   962     QVERIFY(proc.isReadable());

   963 

   964     proc.closeReadChannel(QProcess::StandardError);

   965 

   966     QVERIFY(proc.openMode() == QProcess::ReadWrite);

   967     QVERIFY(proc.isReadable());

   968 

   969     proc.close();

   970     QVERIFY(!proc.isOpen());

   971     QVERIFY(!proc.isReadable());

   972     QVERIFY(!proc.isWritable());

   973     QCOMPARE(proc.state(), QProcess::NotRunning);

   974 }

   975 

   976 //-----------------------------------------------------------------------------

   977 void tst_QProcess::emitReadyReadOnlyWhenNewDataArrives()

   978 {

   979 #ifdef Q_OS_WINCE

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

   981 #endif

   982 #if defined(Q_OS_SYMBIAN)

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

   984 #endif

   985 

   986     QProcess proc;

   987     connect(&proc, SIGNAL(readyRead()), this, SLOT(exitLoopSlot()));

   988     QSignalSpy spy(&proc, SIGNAL(readyRead()));

   989 

   990 #ifdef Q_OS_MAC

   991     proc.start("testProcessEcho/testProcessEcho.app");

   992 #else

   993     proc.start("testProcessEcho/testProcessEcho");

   994 #endif

   995 

   996     QCOMPARE(spy.count(), 0);

   997 

   998     proc.write("A");

   999 

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

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

  1002         QFAIL("Operation timed out");

  1003 

  1004     QCOMPARE(spy.count(), 1);

  1005 

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

  1007     QVERIFY(QTestEventLoop::instance().timeout());

  1008     QVERIFY(!proc.waitForReadyRead(250));

  1009 

  1010     QObject::disconnect(&proc, SIGNAL(readyRead()), 0, 0);

  1011     proc.write("B");

  1012     QVERIFY(proc.waitForReadyRead(5000));

  1013 

  1014     proc.write("", 1);

  1015     QVERIFY(proc.waitForFinished(5000));

  1016 }

  1017 

  1018 //-----------------------------------------------------------------------------

  1019 void tst_QProcess::hardExit()

  1020 {

  1021 #if defined(Q_OS_SYMBIAN)

  1022     QSKIP("Killing started processes is not supported on Qt/Symbian due platform security", SkipAll);

  1023 #endif

  1024     QProcess proc;

  1025 

  1026 #if defined(Q_OS_MAC)

  1027     proc.start("testProcessEcho/testProcessEcho.app");

  1028 #elif defined(Q_OS_WINCE)

  1029     proc.start("testSoftExit/testSoftExit");

  1030 #else

  1031     proc.start("testProcessEcho/testProcessEcho");

  1032 #endif

  1033 

  1034 #ifndef Q_OS_WINCE

  1035     QVERIFY(proc.waitForStarted(5000));

  1036 #else

  1037     QVERIFY(proc.waitForStarted(10000));

  1038 #endif

  1039 

  1040     proc.kill();

  1041 

  1042     QVERIFY(proc.waitForFinished(5000));

  1043     QCOMPARE(int(proc.state()), int(QProcess::NotRunning));

  1044     QCOMPARE(int(proc.error()), int(QProcess::Crashed));

  1045 }

  1046 

  1047 //-----------------------------------------------------------------------------

  1048 void tst_QProcess::softExit()

  1049 {

  1050 #if defined(Q_OS_SYMBIAN)

  1051     QSKIP("Terminating started processes is not supported on Qt/Symbian due platform security", SkipAll);

  1052 #endif

  1053     QProcess proc;

  1054 

  1055     proc.start("testSoftExit/testSoftExit");

  1056 

  1057     QVERIFY(proc.waitForStarted(10000));

  1058 #if !defined(Q_OS_WINCE)

  1059     QVERIFY(proc.waitForReadyRead(10000));

  1060 #endif

  1061 

  1062     proc.terminate();

  1063 

  1064     QVERIFY(proc.waitForFinished(10000));

  1065     QCOMPARE(int(proc.state()), int(QProcess::NotRunning));

  1066     QCOMPARE(int(proc.error()), int(QProcess::UnknownError));

  1067 }

  1068 

  1069 class SoftExitProcess : public QProcess

  1070 {

  1071     Q_OBJECT

  1072 public:

  1073     bool waitedForFinished;

  1074 

  1075     SoftExitProcess(int n) : waitedForFinished(false), n(n), killing(false)

  1076     {

  1077         connect(this, SIGNAL(finished(int, QProcess::ExitStatus)),

  1078                 this, SLOT(finishedSlot(int, QProcess::ExitStatus)));

  1079 

  1080         switch (n) {

  1081         case 0:

  1082             setReadChannelMode(QProcess::MergedChannels);

  1083             connect(this, SIGNAL(readyRead()), this, SLOT(terminateSlot()));

  1084             break;

  1085         case 1:

  1086             connect(this, SIGNAL(readyReadStandardOutput()),

  1087                     this, SLOT(terminateSlot()));

  1088             break;

  1089         case 2:

  1090             connect(this, SIGNAL(readyReadStandardError()),

  1091                     this, SLOT(terminateSlot()));

  1092             break;

  1093         case 3:

  1094             connect(this, SIGNAL(started()),

  1095                     this, SLOT(terminateSlot()));

  1096             break;

  1097         case 4:

  1098         default:

  1099             connect(this, SIGNAL(stateChanged(QProcess::ProcessState)),

  1100                     this, SLOT(terminateSlot()));

  1101             break;

  1102         }

  1103     }

  1104 

  1105 public slots:

  1106     void terminateSlot()

  1107     {

  1108         if (killing || (n == 4 && state() != Running)) {

  1109             // Don't try to kill the process before it is running - that can

  1110             // be hazardous, as the actual child process might not be running

  1111             // yet. Also, don't kill it "recursively".

  1112             return;

  1113         }

  1114         killing = true;

  1115         readAll();

  1116         terminate();

  1117         if ((waitedForFinished = waitForFinished(5000)) == false) {

  1118             kill();

  1119             if (state() != NotRunning)

  1120                 waitedForFinished = waitForFinished(5000);

  1121         }

  1122     }

  1123 

  1124     void finishedSlot(int, QProcess::ExitStatus)

  1125     {

  1126         waitedForFinished = true;

  1127     }

  1128 

  1129 private:

  1130     int n;

  1131     bool killing;

  1132 };

  1133 

  1134 //-----------------------------------------------------------------------------