2 files changed, 99 insertions, 36 deletions

diff --git a/tests/auto/corelib/io/qprocess/testForwarding/main.cpp b/tests/auto/corelib/io/qprocess/testForwarding/main.cpp
index e69ae173f4..42394f6414 100644
--- a/tests/auto/corelib/io/qprocess/testForwarding/main.cpp
+++ b/tests/auto/corelib/io/qprocess/testForwarding/main.cpp
@@ -39,30 +39,49 @@
 **
 ****************************************************************************/
 
+#include <QtCore/QCoreApplication>
 #include <QtCore/QProcess>
 
-int main()
+#include <stdlib.h>
+
+int main(int argc, char **argv)
 {
+    QCoreApplication app(argc, argv);
+
+    if (argc < 3)
+        return 13;
+
 #ifndef QT_NO_PROCESS
     QProcess process;
-    process.setProcessChannelMode(QProcess::ForwardedChannels);
-    if (process.processChannelMode() != QProcess::ForwardedChannels)
-        return -1;
 
-    process.start("testProcessEcho/testProcessEcho");
+    QProcess::ProcessChannelMode mode = (QProcess::ProcessChannelMode)atoi(argv[1]);
+    process.setProcessChannelMode(mode);
+    if (process.processChannelMode() != mode)
+        return 1;
 
-    if (!process.waitForStarted(5000))
-        return -1;
+    QProcess::InputChannelMode inmode = (QProcess::InputChannelMode)atoi(argv[2]);
+    process.setInputChannelMode(inmode);
+    if (process.inputChannelMode() != inmode)
+        return 11;
 
-    if (process.write("forwarded\n") != 10)
-        return -1;
+    process.start("testProcessEcho2/testProcessEcho2");
 
-    process.waitForReadyRead(250);
-    if (process.bytesAvailable() != 0)
-        return -1;
+    if (!process.waitForStarted(5000))
+        return 2;
+
+    if (inmode == QProcess::ManagedInputChannel && process.write("forwarded") != 9)
+        return 3;
 
     process.closeWriteChannel();
-    process.waitForFinished(5000);
+    if (!process.waitForFinished(5000))
+        return 4;
+
+    if ((mode == QProcess::ForwardedOutputChannel || mode == QProcess::ForwardedChannels)
+            && !process.readAllStandardOutput().isEmpty())
+        return 5;
+    if ((mode == QProcess::ForwardedErrorChannel || mode == QProcess::ForwardedChannels)
+            && !process.readAllStandardError().isEmpty())
+        return 6;
 #endif
     return 0;
 }
diff --git a/tests/auto/corelib/io/qprocess/tst_qprocess.cpp b/tests/auto/corelib/io/qprocess/tst_qprocess.cpp
index 7a3f6837f8..d248f022ed 100644
--- a/tests/auto/corelib/io/qprocess/tst_qprocess.cpp
+++ b/tests/auto/corelib/io/qprocess/tst_qprocess.cpp
@@ -107,8 +107,8 @@ private slots:
     void softExitInSlots_data();
     void softExitInSlots();
     void mergedChannels();
+    void forwardedChannels_data();
     void forwardedChannels();
-    void forwardedChannelsOutput();
     void atEnd();
     void atEnd2();
     void waitForFinishedWithTimeout();
@@ -122,6 +122,7 @@ private slots:
     void setStandardInputFile();
     void setStandardOutputFile_data();
     void setStandardOutputFile();
+    void setStandardOutputFile2();
     void setStandardOutputProcess_data();
     void setStandardOutputProcess();
     void removeFileWhileProcessIsRunning();
@@ -1089,36 +1090,55 @@ void tst_QProcess::mergedChannels()
 //-----------------------------------------------------------------------------
 #ifndef Q_OS_WINCE
 // Reading and writing to a process is not supported on Qt/CE
-void tst_QProcess::forwardedChannels()
-{
-    QProcess process;
-    process.setReadChannelMode(QProcess::ForwardedChannels);
-    QCOMPARE(process.readChannelMode(), QProcess::ForwardedChannels);
-
-    process.start("testProcessEcho2/testProcessEcho2");
 
-    QVERIFY(process.waitForStarted(5000));
-    QCOMPARE(process.write("forwarded\n"), qlonglong(10));
-    QVERIFY(!process.waitForReadyRead(250));
-    QCOMPARE(process.bytesAvailable(), qlonglong(0));
+void tst_QProcess::forwardedChannels_data()
+{
+    QTest::addColumn<int>("mode");
+    QTest::addColumn<int>("inmode");
+    QTest::addColumn<QByteArray>("outdata");
+    QTest::addColumn<QByteArray>("errdata");
 
-    process.closeWriteChannel();
-    QVERIFY(process.waitForFinished(5000));
+    QTest::newRow("separate") << int(QProcess::SeparateChannels) << int(QProcess::ManagedInputChannel)
+                              << QByteArray() << QByteArray();
+    QTest::newRow("forwarded") << int(QProcess::ForwardedChannels) << int(QProcess::ManagedInputChannel)
+                               << QByteArray("forwarded") << QByteArray("forwarded");
+    QTest::newRow("stdout") << int(QProcess::ForwardedOutputChannel) << int(QProcess::ManagedInputChannel)
+                            << QByteArray("forwarded") << QByteArray();
+    QTest::newRow("stderr") << int(QProcess::ForwardedErrorChannel) << int(QProcess::ManagedInputChannel)
+                            << QByteArray() << QByteArray("forwarded");
+    QTest::newRow("fwdinput") << int(QProcess::ForwardedErrorChannel) << int(QProcess::ForwardedInputChannel)
+                            << QByteArray() << QByteArray("input");
 }
-#endif
 
-#ifndef Q_OS_WINCE
-// Reading and writing to a process is not supported on Qt/CE
-void tst_QProcess::forwardedChannelsOutput()
+void tst_QProcess::forwardedChannels()
 {
+    QFETCH(int, mode);
+    QFETCH(int, inmode);
+    QFETCH(QByteArray, outdata);
+    QFETCH(QByteArray, errdata);
+
     QProcess process;
-    process.start("testForwarding/testForwarding");
+    process.start("testForwarding/testForwarding", QStringList() << QString::number(mode) << QString::number(inmode));
     QVERIFY(process.waitForStarted(5000));
+    QCOMPARE(process.write("input"), 5);
+    process.closeWriteChannel();
     QVERIFY(process.waitForFinished(5000));
-    QVERIFY(!process.exitCode());
-    QByteArray data = process.readAll();
-    QVERIFY(!data.isEmpty());
-    QVERIFY(data.contains("forwarded"));
+    const char *err;
+    switch (process.exitCode()) {
+    case 0: err = "ok"; break;
+    case 1: err = "processChannelMode is wrong"; break;
+    case 11: err = "inputChannelMode is wrong"; break;
+    case 2: err = "failed to start"; break;
+    case 3: err = "failed to write"; break;
+    case 4: err = "did not finish"; break;
+    case 5: err = "unexpected stdout"; break;
+    case 6: err = "unexpected stderr"; break;
+    case 13: err = "parameter error"; break;
+    default: err = "unknown exit code"; break;
+    }
+    QVERIFY2(!process.exitCode(), err);
+    QCOMPARE(process.readAllStandardOutput(), outdata);
+    QCOMPARE(process.readAllStandardError(), errdata);
 }
 #endif
 
@@ -1868,6 +1888,13 @@ void tst_QProcess::setStandardInputFile()
         QByteArray all = process.readAll();
     QCOMPARE(all.size(), int(sizeof data) - 1); // testProcessEcho drops the ending \0
     QVERIFY(all == data);
+
+    QProcess process2;
+    process2.setStandardInputFile(QProcess::nullDevice());
+    process2.start("testProcessEcho/testProcessEcho");
+    QPROCESS_VERIFY(process2, waitForFinished());
+    all = process2.readAll();
+    QCOMPARE(all.size(), 0);
 }
 #endif
 
@@ -1902,6 +1929,23 @@ void tst_QProcess::setStandardOutputFile_data()
                                    << true;
 }
 
+//-----------------------------------------------------------------------------
+#ifndef Q_OS_WINCE
+void tst_QProcess::setStandardOutputFile2()
+{
+    static const char testdata[] = "Test data.";
+
+    QProcess process;
+    process.setStandardOutputFile(QProcess::nullDevice());
+    process.start("testProcessEcho2/testProcessEcho2");
+    process.write(testdata, sizeof testdata);
+    QPROCESS_VERIFY(process,waitForFinished());
+    QVERIFY(!process.bytesAvailable());
+
+    QVERIFY(!QFileInfo(QProcess::nullDevice()).isFile());
+}
+#endif
+
 void tst_QProcess::setStandardOutputFile()
 {
     static const char data[] = "Original data. ";