1berry/qtbase
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

tst_qprocess: Instantiate QProcess objects on the stack.

Browse Source 
Instantiate the QProcess object on the stack to ensure resource
cleanup and remove the QProcess * member variable.
Use qobject_cast<QProcess *>(QObject::sender()) instead
of the member variable in the helpers slots to ensure that signals
from a leaked QProcess do not interfere with other tests.

Task-number: QTBUG-47370
Change-Id: Ifc0dccb7e4b18069d236df53bccdcb6a47df6346
Reviewed-by: Joerg Bornemann <joerg.bornemann@theqtcompany.com>
This commit is contained in:
Friedemann Kleint 2015-09-25 11:53:46 +02:00
parent f322e2aa08
commit 3cbb89fa5a
1 changed files with 141 additions and 165 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

306
tests/auto/corelib/io/qprocess/tst_qprocess.cpp
View File

@ -73,6 +73,7 @@ class tst_QProcess : public QObject
public slots: public slots:
void initTestCase(); void initTestCase();
void cleanupTestCase(); void cleanupTestCase();
void init();
#ifndef QT_NO_PROCESS #ifndef QT_NO_PROCESS
private slots: private slots:
@ -178,7 +179,6 @@ protected slots:
#endif #endif
private: private:
QProcess *process;
qint64 bytesAvailable; qint64 bytesAvailable;
#endif //QT_NO_PROCESS #endif //QT_NO_PROCESS
}; };
@ -201,6 +201,11 @@ void tst_QProcess::cleanupTestCase()
#endif #endif
} }
void tst_QProcess::init()
{
bytesAvailable = 0;
}
#ifndef QT_NO_PROCESS #ifndef QT_NO_PROCESS
// Testing get/set functions // Testing get/set functions
@ -261,10 +266,10 @@ void tst_QProcess::simpleStart()
{ {
qRegisterMetaType<QProcess::ProcessState>("QProcess::ProcessState"); qRegisterMetaType<QProcess::ProcessState>("QProcess::ProcessState");
process = new QProcess; QScopedPointer<QProcess> process(new QProcess);
QSignalSpy spy(process, &QProcess::stateChanged); QSignalSpy spy(process.data(), &QProcess::stateChanged);
QVERIFY(spy.isValid()); QVERIFY(spy.isValid());
connect(process, &QIODevice::readyRead, this, &tst_QProcess::readFromProcess); connect(process.data(), &QIODevice::readyRead, this, &tst_QProcess::readFromProcess);
/* valgrind dislike SUID binaries(those that have the `s'-flag set), which /* 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 * makes it fail to start the process. For this reason utilities like `ping' won't
@ -276,8 +281,7 @@ void tst_QProcess::simpleStart()
QCOMPARE(process->state(), QProcess::Running); QCOMPARE(process->state(), QProcess::Running);
QTRY_COMPARE(process->state(), QProcess::NotRunning); QTRY_COMPARE(process->state(), QProcess::NotRunning);
delete process; process.reset();
process = 0;
QCOMPARE(spy.count(), 3); QCOMPARE(spy.count(), 3);
QCOMPARE(qvariant_cast<QProcess::ProcessState>(spy.at(0).at(0)), QProcess::Starting); QCOMPARE(qvariant_cast<QProcess::ProcessState>(spy.at(0).at(0)), QProcess::Starting);
@ -340,18 +344,20 @@ void tst_QProcess::startDetached()
void tst_QProcess::readFromProcess() void tst_QProcess::readFromProcess()
{ {
QProcess *process = qobject_cast<QProcess *>(sender());
QVERIFY(process);
int lines = 0; int lines = 0;
while (process->canReadLine()) { while (process->canReadLine()) {
++lines; ++lines;
QByteArray line = process->readLine(); process->readLine();
} }
} }
void tst_QProcess::crashTest() void tst_QProcess::crashTest()
{ {
qRegisterMetaType<QProcess::ProcessState>("QProcess::ProcessState"); qRegisterMetaType<QProcess::ProcessState>("QProcess::ProcessState");
process = new QProcess; QScopedPointer<QProcess> process(new QProcess);
QSignalSpy stateSpy(process, &QProcess::stateChanged); QSignalSpy stateSpy(process.data(), &QProcess::stateChanged);
QVERIFY(stateSpy.isValid()); QVERIFY(stateSpy.isValid());
process->start("testProcessCrash/testProcessCrash"); process->start("testProcessCrash/testProcessCrash");
QVERIFY(process->waitForStarted(5000)); QVERIFY(process->waitForStarted(5000));
@ -359,9 +365,9 @@ void tst_QProcess::crashTest()
qRegisterMetaType<QProcess::ProcessError>("QProcess::ProcessError"); qRegisterMetaType<QProcess::ProcessError>("QProcess::ProcessError");
qRegisterMetaType<QProcess::ExitStatus>("QProcess::ExitStatus"); qRegisterMetaType<QProcess::ExitStatus>("QProcess::ExitStatus");
QSignalSpy spy(process, &QProcess::errorOccurred); QSignalSpy spy(process.data(), &QProcess::errorOccurred);
QSignalSpy spy2(process, static_cast<QProcessErrorSignal>(&QProcess::error)); QSignalSpy spy2(process.data(), static_cast<QProcessErrorSignal>(&QProcess::error));
QSignalSpy spy3(process, static_cast<QProcessFinishedSignal2>(&QProcess::finished)); QSignalSpy spy3(process.data(), static_cast<QProcessFinishedSignal2>(&QProcess::finished));
QVERIFY(spy.isValid()); QVERIFY(spy.isValid());
QVERIFY(spy2.isValid()); QVERIFY(spy2.isValid());
@ -380,8 +386,8 @@ void tst_QProcess::crashTest()
QCOMPARE(process->exitStatus(), QProcess::CrashExit); QCOMPARE(process->exitStatus(), QProcess::CrashExit);
delete process; // delete process;
process = 0; process.reset();
QCOMPARE(stateSpy.count(), 3); QCOMPARE(stateSpy.count(), 3);
QCOMPARE(qvariant_cast<QProcess::ProcessState>(stateSpy.at(0).at(0)), QProcess::Starting); QCOMPARE(qvariant_cast<QProcess::ProcessState>(stateSpy.at(0).at(0)), QProcess::Starting);
@ -391,20 +397,20 @@ void tst_QProcess::crashTest()
void tst_QProcess::crashTest2() void tst_QProcess::crashTest2()
{ {
process = new QProcess; QProcess process;
process->start("testProcessCrash/testProcessCrash"); process.start("testProcessCrash/testProcessCrash");
QVERIFY(process->waitForStarted(5000)); QVERIFY(process.waitForStarted(5000));
qRegisterMetaType<QProcess::ProcessError>("QProcess::ProcessError"); qRegisterMetaType<QProcess::ProcessError>("QProcess::ProcessError");
qRegisterMetaType<QProcess::ExitStatus>("QProcess::ExitStatus"); qRegisterMetaType<QProcess::ExitStatus>("QProcess::ExitStatus");
QSignalSpy spy(process, static_cast<QProcessErrorSignal>(&QProcess::errorOccurred)); QSignalSpy spy(&process, static_cast<QProcessErrorSignal>(&QProcess::errorOccurred));
QSignalSpy spy2(process, static_cast<QProcessFinishedSignal2>(&QProcess::finished)); QSignalSpy spy2(&process, static_cast<QProcessFinishedSignal2>(&QProcess::finished));
QVERIFY(spy.isValid()); QVERIFY(spy.isValid());
QVERIFY(spy2.isValid()); QVERIFY(spy2.isValid());
QObject::connect(process, static_cast<QProcessFinishedSignal1>(&QProcess::finished), QObject::connect(&process, static_cast<QProcessFinishedSignal1>(&QProcess::finished),
this, &tst_QProcess::exitLoopSlot); this, &tst_QProcess::exitLoopSlot);
QTestEventLoop::instance().enterLoop(30); QTestEventLoop::instance().enterLoop(30);
@ -417,10 +423,7 @@ void tst_QProcess::crashTest2()
QCOMPARE(spy2.count(), 1); QCOMPARE(spy2.count(), 1);
QCOMPARE(*static_cast<const QProcess::ExitStatus *>(spy2.at(0).at(1).constData()), QProcess::CrashExit); QCOMPARE(*static_cast<const QProcess::ExitStatus *>(spy2.at(0).at(1).constData()), QProcess::CrashExit);
QCOMPARE(process->exitStatus(), QProcess::CrashExit); QCOMPARE(process.exitStatus(), QProcess::CrashExit);
delete process;
process = 0;
} }
#ifndef Q_OS_WINCE #ifndef Q_OS_WINCE
@ -443,24 +446,24 @@ void tst_QProcess::echoTest()
{ {
QFETCH(QByteArray, input); QFETCH(QByteArray, input);
process = new QProcess; QProcess process;
connect(process, &QIODevice::readyRead, this, &tst_QProcess::exitLoopSlot); connect(&process, &QIODevice::readyRead, this, &tst_QProcess::exitLoopSlot);
process->start("testProcessEcho/testProcessEcho"); process.start("testProcessEcho/testProcessEcho");
QVERIFY(process->waitForStarted(5000)); QVERIFY(process.waitForStarted(5000));
process->write(input); process.write(input);
QTime stopWatch; QTime stopWatch;
stopWatch.start(); stopWatch.start();
do { do {
QVERIFY(process->isOpen()); QVERIFY(process.isOpen());
QTestEventLoop::instance().enterLoop(2); QTestEventLoop::instance().enterLoop(2);
} while (stopWatch.elapsed() < 60000 && process->bytesAvailable() < input.size()); } while (stopWatch.elapsed() < 60000 && process.bytesAvailable() < input.size());
if (stopWatch.elapsed() >= 60000) if (stopWatch.elapsed() >= 60000)
QFAIL("Timed out"); QFAIL("Timed out");
QByteArray message = process->readAll(); QByteArray message = process.readAll();
QCOMPARE(message.size(), input.size()); QCOMPARE(message.size(), input.size());
char *c1 = message.data(); char *c1 = message.data();
@ -473,13 +476,9 @@ void tst_QProcess::echoTest()
} }
QCOMPARE(*c1, *c2); QCOMPARE(*c1, *c2);
process->write("", 1); process.write("", 1);
QVERIFY(process->waitForFinished(5000)); QVERIFY(process.waitForFinished(5000));
delete process;
process = 0;
} }
#endif #endif
@ -493,17 +492,17 @@ void tst_QProcess::exitLoopSlot()
void tst_QProcess::echoTest2() void tst_QProcess::echoTest2()
{ {
process = new QProcess; QProcess process;
connect(process, &QIODevice::readyRead, this, &tst_QProcess::exitLoopSlot); connect(&process, &QIODevice::readyRead, this, &tst_QProcess::exitLoopSlot);
process->start("testProcessEcho2/testProcessEcho2"); process.start("testProcessEcho2/testProcessEcho2");
QVERIFY(process->waitForStarted(5000)); QVERIFY(process.waitForStarted(5000));
QVERIFY(!process->waitForReadyRead(250)); QVERIFY(!process.waitForReadyRead(250));
QCOMPARE(process->error(), QProcess::Timedout); QCOMPARE(process.error(), QProcess::Timedout);
process->write("Hello"); process.write("Hello");
QSignalSpy spy1(process, &QProcess::readyReadStandardOutput); QSignalSpy spy1(&process, &QProcess::readyReadStandardOutput);
QSignalSpy spy2(process, &QProcess::readyReadStandardError); QSignalSpy spy2(&process, &QProcess::readyReadStandardError);
QVERIFY(spy1.isValid()); QVERIFY(spy1.isValid());
QVERIFY(spy2.isValid()); QVERIFY(spy2.isValid());
@ -514,11 +513,11 @@ void tst_QProcess::echoTest2()
QTestEventLoop::instance().enterLoop(1); QTestEventLoop::instance().enterLoop(1);
if (stopWatch.elapsed() >= 30000) if (stopWatch.elapsed() >= 30000)
QFAIL("Timed out"); QFAIL("Timed out");
process->setReadChannel(QProcess::StandardOutput); process.setReadChannel(QProcess::StandardOutput);
qint64 baso = process->bytesAvailable(); qint64 baso = process.bytesAvailable();
process->setReadChannel(QProcess::StandardError); process.setReadChannel(QProcess::StandardError);
qint64 base = process->bytesAvailable(); qint64 base = process.bytesAvailable();
if (baso == 5 && base == 5) if (baso == 5 && base == 5)
break; break;
} }
@ -526,14 +525,11 @@ void tst_QProcess::echoTest2()
QVERIFY(spy1.count() > 0); QVERIFY(spy1.count() > 0);
QVERIFY(spy2.count() > 0); QVERIFY(spy2.count() > 0);
QCOMPARE(process->readAllStandardOutput(), QByteArray("Hello")); QCOMPARE(process.readAllStandardOutput(), QByteArray("Hello"));
QCOMPARE(process->readAllStandardError(), QByteArray("Hello")); QCOMPARE(process.readAllStandardError(), QByteArray("Hello"));
process->write("", 1); process.write("", 1);
QVERIFY(process->waitForFinished(5000)); QVERIFY(process.waitForFinished(5000));
delete process;
process = 0;
} }
#endif #endif
@ -621,21 +617,18 @@ void tst_QProcess::exitStatus_data()
void tst_QProcess::exitStatus() void tst_QProcess::exitStatus()
{ {
process = new QProcess; QProcess process;
QFETCH(QStringList, processList); QFETCH(QStringList, processList);
QFETCH(QList<QProcess::ExitStatus>, exitStatus); QFETCH(QList<QProcess::ExitStatus>, exitStatus);
QCOMPARE(exitStatus.count(), processList.count()); QCOMPARE(exitStatus.count(), processList.count());
for (int i = 0; i < processList.count(); ++i) { for (int i = 0; i < processList.count(); ++i) {
process->start(processList.at(i)); process.start(processList.at(i));
QVERIFY(process->waitForStarted(5000)); QVERIFY(process.waitForStarted(5000));
QVERIFY(process->waitForFinished(30000)); QVERIFY(process.waitForFinished(30000));
QCOMPARE(process->exitStatus(), exitStatus.at(i)); QCOMPARE(process.exitStatus(), exitStatus.at(i));
} }
process->deleteLater();
process = 0;
} }
#ifndef Q_OS_WINCE #ifndef Q_OS_WINCE
@ -643,23 +636,20 @@ void tst_QProcess::exitStatus()
void tst_QProcess::loopBackTest() void tst_QProcess::loopBackTest()
{ {
process = new QProcess; QProcess process;
process->start("testProcessEcho/testProcessEcho"); process.start("testProcessEcho/testProcessEcho");
QVERIFY(process->waitForStarted(5000)); QVERIFY(process.waitForStarted(5000));
for (int i = 0; i < 100; ++i) { for (int i = 0; i < 100; ++i) {
process->write("Hello"); process.write("Hello");
do { do {
QVERIFY(process->waitForReadyRead(5000)); QVERIFY(process.waitForReadyRead(5000));
} while (process->bytesAvailable() < 5); } while (process.bytesAvailable() < 5);
QCOMPARE(process->readAll(), QByteArray("Hello")); QCOMPARE(process.readAll(), QByteArray("Hello"));
} }
process->write("", 1); process.write("", 1);
QVERIFY(process->waitForFinished(5000)); QVERIFY(process.waitForFinished(5000));
delete process;
process = 0;
} }
#endif #endif
@ -668,35 +658,32 @@ void tst_QProcess::loopBackTest()
void tst_QProcess::readTimeoutAndThenCrash() void tst_QProcess::readTimeoutAndThenCrash()
{ {
process = new QProcess; QProcess process;
process->start("testProcessEcho/testProcessEcho"); process.start("testProcessEcho/testProcessEcho");
if (process->state() != QProcess::Starting) if (process.state() != QProcess::Starting)
QCOMPARE(process->state(), QProcess::Running); QCOMPARE(process.state(), QProcess::Running);
QVERIFY(process->waitForStarted(5000)); QVERIFY(process.waitForStarted(5000));
QCOMPARE(process->state(), QProcess::Running); QCOMPARE(process.state(), QProcess::Running);
QVERIFY(!process->waitForReadyRead(5000)); QVERIFY(!process.waitForReadyRead(5000));
QCOMPARE(process->error(), QProcess::Timedout); QCOMPARE(process.error(), QProcess::Timedout);
qRegisterMetaType<QProcess::ProcessError>("QProcess::ProcessError"); qRegisterMetaType<QProcess::ProcessError>("QProcess::ProcessError");
QSignalSpy spy(process, &QProcess::errorOccurred); QSignalSpy spy(&process, &QProcess::errorOccurred);
QSignalSpy spy2(process, static_cast<QProcessErrorSignal>(&QProcess::error)); QSignalSpy spy2(&process, static_cast<QProcessErrorSignal>(&QProcess::error));
QVERIFY(spy.isValid()); QVERIFY(spy.isValid());
QVERIFY(spy2.isValid()); QVERIFY(spy2.isValid());
process->kill(); process.kill();
QVERIFY(process->waitForFinished(5000)); QVERIFY(process.waitForFinished(5000));
QCOMPARE(process->state(), QProcess::NotRunning); QCOMPARE(process.state(), QProcess::NotRunning);
QCOMPARE(spy.count(), 1); QCOMPARE(spy.count(), 1);
QCOMPARE(*static_cast<const QProcess::ProcessError *>(spy.at(0).at(0).constData()), QProcess::Crashed); QCOMPARE(*static_cast<const QProcess::ProcessError *>(spy.at(0).at(0).constData()), QProcess::Crashed);
QCOMPARE(spy2.count(), 1); QCOMPARE(spy2.count(), 1);
QCOMPARE(*static_cast<const QProcess::ProcessError *>(spy2.at(0).at(0).constData()), QProcess::Crashed); QCOMPARE(*static_cast<const QProcess::ProcessError *>(spy2.at(0).at(0).constData()), QProcess::Crashed);
delete process;
process = 0;
} }
#endif #endif
@ -754,24 +741,25 @@ void tst_QProcess::restartProcessDeadlock()
// The purpose of this test is to detect whether restarting a // The purpose of this test is to detect whether restarting a
// process in the finished() connected slot causes a deadlock // process in the finished() connected slot causes a deadlock
// because of the way QProcessManager uses its locks. // because of the way QProcessManager uses its locks.
QProcess proc; QProcess process;
process = &proc; connect(&process, static_cast<QProcessFinishedSignal1>(&QProcess::finished),
connect(process, static_cast<QProcessFinishedSignal1>(&QProcess::finished),
this, &tst_QProcess::restartProcess); this, &tst_QProcess::restartProcess);
process->start("testProcessEcho/testProcessEcho"); process.start("testProcessEcho/testProcessEcho");
QCOMPARE(process->write("", 1), qlonglong(1)); QCOMPARE(process.write("", 1), qlonglong(1));
QVERIFY(process->waitForFinished(5000)); QVERIFY(process.waitForFinished(5000));
QObject::disconnect(process, static_cast<QProcessFinishedSignal1>(&QProcess::finished), Q_NULLPTR, Q_NULLPTR); QObject::disconnect(&process, static_cast<QProcessFinishedSignal1>(&QProcess::finished), Q_NULLPTR, Q_NULLPTR);
QCOMPARE(process->write("", 1), qlonglong(1)); QCOMPARE(process.write("", 1), qlonglong(1));
QVERIFY(process->waitForFinished(5000)); QVERIFY(process.waitForFinished(5000));
} }
void tst_QProcess::restartProcess() void tst_QProcess::restartProcess()
{ {
QProcess *process = qobject_cast<QProcess *>(sender());
QVERIFY(process);
process->start("testProcessEcho/testProcessEcho"); process->start("testProcessEcho/testProcessEcho");
} }
#endif #endif
@ -1245,19 +1233,16 @@ void tst_QProcess::processesInMultipleThreads()
// Reading and writing to a process is not supported on Qt/CE // Reading and writing to a process is not supported on Qt/CE
void tst_QProcess::waitForFinishedWithTimeout() void tst_QProcess::waitForFinishedWithTimeout()
{ {
process = new QProcess(this); QProcess process;
process->start("testProcessEcho/testProcessEcho"); process.start("testProcessEcho/testProcessEcho");
QVERIFY(process->waitForStarted(5000)); QVERIFY(process.waitForStarted(5000));
QVERIFY(!process->waitForFinished(1)); QVERIFY(!process.waitForFinished(1));
process->write("", 1); process.write("", 1);
QVERIFY(process->waitForFinished()); QVERIFY(process.waitForFinished());
delete process;
process = 0;
} }
#endif #endif
@ -1265,28 +1250,26 @@ void tst_QProcess::waitForFinishedWithTimeout()
// Reading and writing to a process is not supported on Qt/CE // Reading and writing to a process is not supported on Qt/CE
void tst_QProcess::waitForReadyReadInAReadyReadSlot() void tst_QProcess::waitForReadyReadInAReadyReadSlot()
{ {
process = new QProcess(this); QProcess process;
connect(process, &QIODevice::readyRead, this, &tst_QProcess::waitForReadyReadInAReadyReadSlotSlot); connect(&process, &QIODevice::readyRead, this, &tst_QProcess::waitForReadyReadInAReadyReadSlotSlot);
connect(process, static_cast<QProcessFinishedSignal1>(&QProcess::finished), connect(&process, static_cast<QProcessFinishedSignal1>(&QProcess::finished),
this, &tst_QProcess::exitLoopSlot); this, &tst_QProcess::exitLoopSlot);
bytesAvailable = 0; bytesAvailable = 0;
process->start("testProcessEcho/testProcessEcho"); process.start("testProcessEcho/testProcessEcho");
QVERIFY(process->waitForStarted(5000)); QVERIFY(process.waitForStarted(5000));
QSignalSpy spy(process, &QProcess::readyRead); QSignalSpy spy(&process, &QProcess::readyRead);
QVERIFY(spy.isValid()); QVERIFY(spy.isValid());
process->write("foo"); process.write("foo");
QTestEventLoop::instance().enterLoop(30); QTestEventLoop::instance().enterLoop(30);
QVERIFY(!QTestEventLoop::instance().timeout()); QVERIFY(!QTestEventLoop::instance().timeout());
QCOMPARE(spy.count(), 1); QCOMPARE(spy.count(), 1);
process->disconnect(); process.disconnect();
QVERIFY(process->waitForFinished(5000)); QVERIFY(process.waitForFinished(5000));
QVERIFY(process->bytesAvailable() > bytesAvailable); QVERIFY(process.bytesAvailable() > bytesAvailable);
delete process;
process = 0;
} }
#endif #endif
@ -1294,6 +1277,8 @@ void tst_QProcess::waitForReadyReadInAReadyReadSlot()
// Reading and writing to a process is not supported on Qt/CE // Reading and writing to a process is not supported on Qt/CE
void tst_QProcess::waitForReadyReadInAReadyReadSlotSlot() void tst_QProcess::waitForReadyReadInAReadyReadSlotSlot()
{ {
QProcess *process = qobject_cast<QProcess *>(sender());
QVERIFY(process);
bytesAvailable = process->bytesAvailable(); bytesAvailable = process->bytesAvailable();
process->write("bar", 4); process->write("bar", 4);
QVERIFY(process->waitForReadyRead(5000)); QVERIFY(process->waitForReadyRead(5000));
@ -1305,25 +1290,23 @@ void tst_QProcess::waitForReadyReadInAReadyReadSlotSlot()
// Reading and writing to a process is not supported on Qt/CE // Reading and writing to a process is not supported on Qt/CE
void tst_QProcess::waitForBytesWrittenInABytesWrittenSlot() void tst_QProcess::waitForBytesWrittenInABytesWrittenSlot()
{ {
process = new QProcess(this); QProcess process;
connect(process, &QIODevice::bytesWritten, this, &tst_QProcess::waitForBytesWrittenInABytesWrittenSlotSlot); connect(&process, &QIODevice::bytesWritten, this, &tst_QProcess::waitForBytesWrittenInABytesWrittenSlotSlot);
bytesAvailable = 0; bytesAvailable = 0;
process->start("testProcessEcho/testProcessEcho"); process.start("testProcessEcho/testProcessEcho");
QVERIFY(process->waitForStarted(5000)); QVERIFY(process.waitForStarted(5000));
QSignalSpy spy(process, &QProcess::bytesWritten); QSignalSpy spy(&process, &QProcess::bytesWritten);
QVERIFY(spy.isValid()); QVERIFY(spy.isValid());
process->write("f"); process.write("f");
QTestEventLoop::instance().enterLoop(30); QTestEventLoop::instance().enterLoop(30);
QVERIFY(!QTestEventLoop::instance().timeout()); QVERIFY(!QTestEventLoop::instance().timeout());
QCOMPARE(spy.count(), 1); QCOMPARE(spy.count(), 1);
process->write("", 1); process.write("", 1);
process->disconnect(); process.disconnect();
QVERIFY(process->waitForFinished()); QVERIFY(process.waitForFinished());
delete process;
process = 0;
} }
#endif #endif
@ -1331,6 +1314,8 @@ void tst_QProcess::waitForBytesWrittenInABytesWrittenSlot()
// Reading and writing to a process is not supported on Qt/CE // Reading and writing to a process is not supported on Qt/CE
void tst_QProcess::waitForBytesWrittenInABytesWrittenSlotSlot() void tst_QProcess::waitForBytesWrittenInABytesWrittenSlotSlot()
{ {
QProcess *process = qobject_cast<QProcess *>(sender());
QVERIFY(process);
process->write("b"); process->write("b");
QVERIFY(process->waitForBytesWritten(5000)); QVERIFY(process->waitForBytesWritten(5000));
QTestEventLoop::instance().exitLoop(); QTestEventLoop::instance().exitLoop();
@ -1399,11 +1384,11 @@ void tst_QProcess::spaceArgsTest()
<< QString::fromLatin1("testProcessSpacesArgs/one space") << QString::fromLatin1("testProcessSpacesArgs/one space")
<< QString::fromLatin1("testProcessSpacesArgs/two space s"); << QString::fromLatin1("testProcessSpacesArgs/two space s");
process = new QProcess(this); QProcess process;
for (int i = 0; i < programs.size(); ++i) { for (int i = 0; i < programs.size(); ++i) {
QString program = programs.at(i); QString program = programs.at(i);
process->start(program, args); process.start(program, args);
#if defined(Q_OS_WINCE) #if defined(Q_OS_WINCE)
const int timeOutMS = 10000; const int timeOutMS = 10000;
@ -1411,14 +1396,14 @@ void tst_QProcess::spaceArgsTest()
const int timeOutMS = 5000; const int timeOutMS = 5000;
#endif #endif
QByteArray errorMessage; QByteArray errorMessage;
bool started = process->waitForStarted(timeOutMS); bool started = process.waitForStarted(timeOutMS);
if (!started) if (!started)
errorMessage = startFailMessage(program, *process); errorMessage = startFailMessage(program, process);
QVERIFY2(started, errorMessage.constData()); QVERIFY2(started, errorMessage.constData());
QVERIFY(process->waitForFinished(timeOutMS)); QVERIFY(process.waitForFinished(timeOutMS));
#if !defined(Q_OS_WINCE) #if !defined(Q_OS_WINCE)
QStringList actual = QString::fromLatin1(process->readAll()).split("|"); QStringList actual = QString::fromLatin1(process.readAll()).split("|");
#endif #endif
#if !defined(Q_OS_WINCE) #if !defined(Q_OS_WINCE)
QVERIFY(!actual.isEmpty()); QVERIFY(!actual.isEmpty());
@ -1435,16 +1420,16 @@ void tst_QProcess::spaceArgsTest()
program += QString::fromLatin1(" ") + stringArgs; program += QString::fromLatin1(" ") + stringArgs;
errorMessage.clear(); errorMessage.clear();
process->start(program); process.start(program);
started = process->waitForStarted(5000); started = process.waitForStarted(5000);
if (!started) if (!started)
errorMessage = startFailMessage(program, *process); errorMessage = startFailMessage(program, process);
QVERIFY2(started, errorMessage.constData()); QVERIFY2(started, errorMessage.constData());
QVERIFY(process->waitForFinished(5000)); QVERIFY(process.waitForFinished(5000));
#if !defined(Q_OS_WINCE) #if !defined(Q_OS_WINCE)
actual = QString::fromLatin1(process->readAll()).split("|"); actual = QString::fromLatin1(process.readAll()).split("|");
#endif #endif
#if !defined(Q_OS_WINCE) #if !defined(Q_OS_WINCE)
QVERIFY(!actual.isEmpty()); QVERIFY(!actual.isEmpty());
@ -1454,9 +1439,6 @@ void tst_QProcess::spaceArgsTest()
QCOMPARE(actual, args); QCOMPARE(actual, args);
#endif #endif
} }
delete process;
process = 0;
} }
#if defined(Q_OS_WIN) #if defined(Q_OS_WIN)
@ -2230,38 +2212,32 @@ void tst_QProcess::discardUnwantedOutput()
// Windows CE does not support working directory logic // Windows CE does not support working directory logic
void tst_QProcess::setWorkingDirectory() void tst_QProcess::setWorkingDirectory()
{ {
process = new QProcess; QProcess process;
process->setWorkingDirectory("test"); process.setWorkingDirectory("test");
// use absolute path because on Windows, the executable is relative to the parent's CWD // use absolute path because on Windows, the executable is relative to the parent's CWD
// while on Unix with fork it's relative to the child's (with posix_spawn, it could be either). // while on Unix with fork it's relative to the child's (with posix_spawn, it could be either).
process->start(QFileInfo("testSetWorkingDirectory/testSetWorkingDirectory").absoluteFilePath()); process.start(QFileInfo("testSetWorkingDirectory/testSetWorkingDirectory").absoluteFilePath());
QVERIFY2(process->waitForFinished(), process->errorString().toLocal8Bit()); QVERIFY2(process.waitForFinished(), process.errorString().toLocal8Bit());
QByteArray workingDir = process->readAllStandardOutput(); QByteArray workingDir = process.readAllStandardOutput();
QCOMPARE(QDir("test").canonicalPath(), QDir(workingDir.constData()).canonicalPath()); QCOMPARE(QDir("test").canonicalPath(), QDir(workingDir.constData()).canonicalPath());
delete process;
process = 0;
} }
void tst_QProcess::setNonExistentWorkingDirectory() void tst_QProcess::setNonExistentWorkingDirectory()
{ {
process = new QProcess; QProcess process;
process->setWorkingDirectory("this/directory/should/not/exist/for/sure"); process.setWorkingDirectory("this/directory/should/not/exist/for/sure");
// use absolute path because on Windows, the executable is relative to the parent's CWD // use absolute path because on Windows, the executable is relative to the parent's CWD
// while on Unix with fork it's relative to the child's (with posix_spawn, it could be either). // while on Unix with fork it's relative to the child's (with posix_spawn, it could be either).
process->start(QFileInfo("testSetWorkingDirectory/testSetWorkingDirectory").absoluteFilePath()); process.start(QFileInfo("testSetWorkingDirectory/testSetWorkingDirectory").absoluteFilePath());
QVERIFY(!process->waitForFinished()); QVERIFY(!process.waitForFinished());
#ifdef QPROCESS_USE_SPAWN #ifdef QPROCESS_USE_SPAWN
QEXPECT_FAIL("", "QProcess cannot detect failure to start when using posix_spawn()", Continue); QEXPECT_FAIL("", "QProcess cannot detect failure to start when using posix_spawn()", Continue);
#endif #endif
QCOMPARE(int(process->error()), int(QProcess::FailedToStart)); QCOMPARE(int(process.error()), int(QProcess::FailedToStart));
delete process;
process = 0;
} }
#endif #endif