Don't depend on moc to disable test functions.

The moc tool is not aware of all defines (particularly those that are
compiler builtins) and does not correctly evaluate others that depend
on compiler builtins, such as Q_OS_FOO.

This commit reverts parts of the following commits, but is not a
complete fix as there were many instances of this problem in the tests
prior to those commits:
    924d810dbdcd5b5b0fa860922b2487ea9062d002
    8aaff6751038b88d17e23be6fcee945771297c5b
    338d3f11973412047c2c9cd41cbd0c961d738ef3
    a55034062ba2bf73a9f1ed3d9cf31745b38149e3
    253497b7446c7d723aa3bdd7152e25d6852f2604
    7cfad460c56319ba89c4a3a0bbcb2e54ab1cdbc6
    9d2ff58f3642828e494e7e9b2df7dbb8e2cd408f
    0cf6baa2d61ebaad2a2a0530c37f27e719b68f4b

Change-Id: I947d797fe3ec76139ba1b55561cea569895662c5
Reviewed-by: Rohan McGovern <rohan.mcgovern@nokia.com>

1 files changed, 141 insertions, 162 deletions

diff --git a/tests/auto/corelib/io/qprocess/tst_qprocess.cpp b/tests/auto/corelib/io/qprocess/tst_qprocess.cpp
index 0662f890e1..bd27da994a 100644
--- a/tests/auto/corelib/io/qprocess/tst_qprocess.cpp
+++ b/tests/auto/corelib/io/qprocess/tst_qprocess.cpp
@@ -84,72 +84,55 @@ private slots:
     void simpleStart();
     void execute();
     void startDetached();
-#ifndef Q_OS_WIN
     void crashTest();
     void crashTest2();
-#endif
-#ifndef Q_OS_WINCE
     void echoTest_data();
     void echoTest();
     void echoTest2();
     void echoTest_performance();
-#endif
-#if defined(Q_OS_WIN) && !defined(Q_OS_WINCE)
+#if defined Q_OS_WIN
     void echoTestGui();
     void batFiles_data();
     void batFiles();
 #endif
     void exitStatus_data();
     void exitStatus();
-#ifndef Q_OS_WINCE
     void loopBackTest();
     void readTimeoutAndThenCrash();
-#endif
     void waitForFinished();
-#ifndef Q_OS_WINCE
     void deadWhileReading();
     void restartProcessDeadlock();
     void closeWriteChannel();
     void closeReadChannel();
     void openModes();
     void emitReadyReadOnlyWhenNewDataArrives();
-#endif
     void hardExit();
     void softExit();
-#ifndef Q_OS_WINCE
     void softExitInSlots_data();
     void softExitInSlots();
     void mergedChannels();
     void forwardedChannels();
     void atEnd();
     void atEnd2();
-#endif
     void processInAThread();
     void processesInMultipleThreads();
-#ifndef Q_OS_WINCE
     void waitForFinishedWithTimeout();
     void waitForReadyReadInAReadyReadSlot();
     void waitForBytesWrittenInABytesWrittenSlot();
-#endif
     void spaceArgsTest_data();
     void spaceArgsTest();
 #if defined(Q_OS_WIN)
     void nativeArguments();
 #endif
     void exitCodeTest();
-#ifndef Q_OS_WINCE
     void setEnvironment_data();
     void setEnvironment();
     void setProcessEnvironment_data();
     void setProcessEnvironment();
-#endif
     void systemEnvironment();
-#ifndef Q_OS_WINCE
     void spaceInName();
-#endif
     void lockupsInStartDetached();
     void waitForReadyReadForNonexistantProcess();
-#ifndef Q_OS_WINCE
     void setStandardInputFile();
     void setStandardOutputFile_data();
     void setStandardOutputFile();
@@ -157,14 +140,9 @@ private slots:
     void setStandardOutputProcess();
     void removeFileWhileProcessIsRunning();
     void fileWriterProcess();
-#endif
     void detachedWorkingDirectoryAndPid();
-#ifndef Q_OS_WINCE
     void switchReadChannels();
-#endif
-#if defined(Q_OS_WIN) && !defined(Q_OS_WINCE)
     void setWorkingDirectory();
-#endif
     void startFinishStartFinish();
     void invalidProgramString_data();
     void invalidProgramString();
@@ -180,10 +158,8 @@ protected slots:
     void readFromProcess();
     void exitLoopSlot();
     void restartProcess();
-#ifndef Q_OS_WINCE
     void waitForReadyReadInAReadyReadSlotSlot();
     void waitForBytesWrittenInABytesWrittenSlotSlot();
-#endif
 
 private:
     QProcess *process;
@@ -316,12 +292,12 @@ void tst_QProcess::readFromProcess()
 }
 
 //-----------------------------------------------------------------------------
-
-// This test opens a crash dialog on Windows.
-#ifndef Q_OS_WIN
 void tst_QProcess::crashTest()
 {
     qRegisterMetaType<QProcess::ProcessState>("QProcess::ProcessState");
+#ifdef Q_OS_WIN
+    QSKIP("This test opens a crash dialog on Windows");
+#endif
     process = new QProcess;
     QSignalSpy stateSpy(process, SIGNAL(stateChanged(QProcess::ProcessState)));
     process->start("testProcessCrash/testProcessCrash");
@@ -351,14 +327,13 @@ void tst_QProcess::crashTest()
     QCOMPARE(qVariantValue<QProcess::ProcessState>(stateSpy.at(1).at(0)), QProcess::Running);
     QCOMPARE(qVariantValue<QProcess::ProcessState>(stateSpy.at(2).at(0)), QProcess::NotRunning);
 }
-#endif
 
 //-----------------------------------------------------------------------------
-
-// This test opens a crash dialog on Windows.
-#ifndef Q_OS_WIN
 void tst_QProcess::crashTest2()
 {
+#ifdef Q_OS_WIN
+    QSKIP("This test opens a crash dialog on Windows");
+#endif
     process = new QProcess;
     process->start("testProcessCrash/testProcessCrash");
     QVERIFY(process->waitForStarted(5000));
@@ -386,12 +361,8 @@ void tst_QProcess::crashTest2()
     delete process;
     process = 0;
 }
-#endif
 
 //-----------------------------------------------------------------------------
-
-// Reading and writing to a process is not supported on Qt/CE.
-#ifndef Q_OS_WINCE
 void tst_QProcess::echoTest_data()
 {
     QTest::addColumn<QByteArray>("input");
@@ -407,9 +378,12 @@ void tst_QProcess::echoTest_data()
 }
 
 //-----------------------------------------------------------------------------
-
 void tst_QProcess::echoTest()
 {
+#ifdef Q_OS_WINCE
+    QSKIP("Reading and writing to a process is not supported on Qt/CE");
+#endif
+
     QFETCH(QByteArray, input);
 
     process = new QProcess;
@@ -454,7 +428,6 @@ void tst_QProcess::echoTest()
     delete process;
     process = 0;
 }
-#endif
 
 //-----------------------------------------------------------------------------
 void tst_QProcess::exitLoopSlot()
@@ -463,11 +436,12 @@ void tst_QProcess::exitLoopSlot()
 }
 
 //-----------------------------------------------------------------------------
-
-// Reading and writing to a process is not supported on Qt/CE.
-#ifndef Q_OS_WINCE
 void tst_QProcess::echoTest2()
 {
+#ifdef Q_OS_WINCE
+    QSKIP("Reading and writing to a process is not supported on Qt/CE");
+#endif
+
     process = new QProcess;
     connect(process, SIGNAL(readyRead()), this, SLOT(exitLoopSlot()));
 
@@ -511,14 +485,14 @@ void tst_QProcess::echoTest2()
     delete process;
     process = 0;
 }
-#endif
 
 //-----------------------------------------------------------------------------
-
-// Reading and writing to a process is not supported on Qt/CE.
-#ifndef Q_OS_WINCE
 void tst_QProcess::echoTest_performance()
 {
+#ifdef Q_OS_WINCE
+    QSKIP("Reading and writing to a process is not supported on Qt/CE");
+#endif
+
     QProcess process;
 #ifdef Q_OS_MAC
     process.start("testProcessLoopback/testProcessLoopback.app");
@@ -564,14 +538,15 @@ void tst_QProcess::echoTest_performance()
     process.closeWriteChannel();
     QVERIFY(process.waitForFinished());
 }
-#endif
 
+#if defined Q_OS_WIN
 //-----------------------------------------------------------------------------
-
-// Reading and writing to a process is not supported on Qt/CE, and neither are batch files.
-#if defined(Q_OS_WIN) && !defined(Q_OS_WINCE)
 void tst_QProcess::echoTestGui()
 {
+#ifdef Q_OS_WINCE
+    QSKIP("Reading and writing to a process is not supported on Qt/CE");
+#endif
+
     QProcess process;
 
     process.start("testProcessEchoGui/testProcessEchoGui");
@@ -598,6 +573,9 @@ void tst_QProcess::batFiles_data()
 
 void tst_QProcess::batFiles()
 {
+#if defined(Q_OS_WINCE)
+    QSKIP("Batch files are not supported on Windows CE");
+#endif
     QFETCH(QString, batFile);
     QFETCH(QByteArray, output);
 
@@ -611,6 +589,7 @@ void tst_QProcess::batFiles()
 
     QVERIFY(proc.readAll().startsWith(output));
 }
+
 #endif
 
 //-----------------------------------------------------------------------------
@@ -662,11 +641,12 @@ void tst_QProcess::exitStatus()
     process = 0;
 }
 //-----------------------------------------------------------------------------
-
-// Reading and writing to a process is not supported on Qt/CE.
-#ifndef Q_OS_WINCE
 void tst_QProcess::loopBackTest()
 {
+#ifdef Q_OS_WINCE
+    QSKIP("Reading and writing to a process is not supported on Qt/CE");
+#endif
+
     process = new QProcess;
 #ifdef Q_OS_MAC
     process->start("testProcessEcho/testProcessEcho.app");
@@ -689,14 +669,14 @@ void tst_QProcess::loopBackTest()
     delete process;
     process = 0;
 }
-#endif
 
 //-----------------------------------------------------------------------------
-
-// Reading and writing to a process is not supported on Qt/CE.
-#ifndef Q_OS_WINCE
 void tst_QProcess::readTimeoutAndThenCrash()
 {
+#ifdef Q_OS_WINCE
+    QSKIP("Reading and writing to a process is not supported on Qt/CE");
+#endif
+
     process = new QProcess;
 #ifdef Q_OS_MAC
     process->start("testProcessEcho/testProcessEcho.app");
@@ -726,7 +706,6 @@ void tst_QProcess::readTimeoutAndThenCrash()
     delete process;
     process = 0;
 }
-#endif
 
 void tst_QProcess::waitForFinished()
 {
@@ -756,10 +735,12 @@ void tst_QProcess::waitForFinished()
     QCOMPARE(process.error(), QProcess::FailedToStart);
 }
 
-// Reading and writing to a process is not supported on Qt/CE.
-#ifndef Q_OS_WINCE
 void tst_QProcess::deadWhileReading()
 {
+#ifdef Q_OS_WINCE
+    QSKIP("Reading and writing to a process is not supported on Qt/CE");
+#endif
+
     QProcess process;
 
 #ifdef Q_OS_MAC
@@ -777,14 +758,14 @@ void tst_QProcess::deadWhileReading()
     QCOMPARE(output.count("\n"), 10*1024);
     process.waitForFinished();
 }
-#endif
 
 //-----------------------------------------------------------------------------
-
-// Reading and writing to a process is not supported on Qt/CE.
-#ifndef Q_OS_WINCE
 void tst_QProcess::restartProcessDeadlock()
 {
+#ifdef Q_OS_WINCE
+    QSKIP("Reading and writing to a process is not supported on Qt/CE");
+#endif
+
     // The purpose of this test is to detect whether restarting a
     // process in the finished() connected slot causes a deadlock
     // because of the way QProcessManager uses its locks.
@@ -806,7 +787,6 @@ void tst_QProcess::restartProcessDeadlock()
     QCOMPARE(process->write("", 1), qlonglong(1));
     QVERIFY(process->waitForFinished(5000));
 }
-#endif
 
 void tst_QProcess::restartProcess()
 {
@@ -818,11 +798,12 @@ void tst_QProcess::restartProcess()
 }
 
 //-----------------------------------------------------------------------------
-
-// Reading and writing to a process is not supported on Qt/CE.
-#ifndef Q_OS_WINCE
 void tst_QProcess::closeWriteChannel()
 {
+#ifdef Q_OS_WINCE
+    QSKIP("Reading and writing to a process is not supported on Qt/CE");
+#endif
+
     QProcess more;
     more.start("testProcessEOF/testProcessEOF");
 
@@ -844,14 +825,14 @@ void tst_QProcess::closeWriteChannel()
         more.write("q");
     QVERIFY(more.waitForFinished(5000));
 }
-#endif
 
 //-----------------------------------------------------------------------------
-
-// Reading and writing to a process is not supported on Qt/CE.
-#ifndef Q_OS_WINCE
 void tst_QProcess::closeReadChannel()
 {
+#ifdef Q_OS_WINCE
+    QSKIP("Reading and writing to a process is not supported on Qt/CE");
+#endif
+
     for (int i = 0; i < 10; ++i) {
         QProcess::ProcessChannel channel1 = QProcess::StandardOutput;
         QProcess::ProcessChannel channel2 = QProcess::StandardError;
@@ -881,14 +862,14 @@ void tst_QProcess::closeReadChannel()
         QVERIFY(proc.waitForFinished(5000));
     }
 }
-#endif
 
 //-----------------------------------------------------------------------------
-
-// Reading and writing to a process is not supported on Qt/CE.
-#ifndef Q_OS_WINCE
 void tst_QProcess::openModes()
 {
+#ifdef Q_OS_WINCE
+    QSKIP("Reading and writing to a process is not supported on Qt/CE");
+#endif
+
     QProcess proc;
     QVERIFY(!proc.isOpen());
     QVERIFY(proc.openMode() == QProcess::NotOpen);
@@ -931,14 +912,14 @@ void tst_QProcess::openModes()
     QVERIFY(!proc.isWritable());
     QCOMPARE(proc.state(), QProcess::NotRunning);
 }
-#endif
 
 //-----------------------------------------------------------------------------
-
-// Reading and writing to a process is not supported on Qt/CE.
-#ifndef Q_OS_WINCE
 void tst_QProcess::emitReadyReadOnlyWhenNewDataArrives()
 {
+#ifdef Q_OS_WINCE
+    QSKIP("Reading and writing to a process is not supported on Qt/CE");
+#endif
+
     QProcess proc;
     connect(&proc, SIGNAL(readyRead()), this, SLOT(exitLoopSlot()));
     QSignalSpy spy(&proc, SIGNAL(readyRead()));
@@ -970,7 +951,6 @@ void tst_QProcess::emitReadyReadOnlyWhenNewDataArrives()
     proc.write("", 1);
     QVERIFY(proc.waitForFinished(5000));
 }
-#endif
 
 //-----------------------------------------------------------------------------
 void tst_QProcess::hardExit()
@@ -1017,8 +997,6 @@ void tst_QProcess::softExit()
     QCOMPARE(int(proc.error()), int(QProcess::UnknownError));
 }
 
-// Reading and writing to a process is not supported on Qt/CE.
-#ifndef Q_OS_WINCE
 class SoftExitProcess : public QProcess
 {
     Q_OBJECT
@@ -1085,7 +1063,6 @@ private:
 };
 
 //-----------------------------------------------------------------------------
-
 void tst_QProcess::softExitInSlots_data()
 {
     QTest::addColumn<QString>("appName");
@@ -1103,9 +1080,12 @@ void tst_QProcess::softExitInSlots_data()
 }
 
 //-----------------------------------------------------------------------------
-
 void tst_QProcess::softExitInSlots()
 {
+#ifdef Q_OS_WINCE
+    QSKIP("Reading and writing to a process is not supported on Qt/CE");
+#endif
+
     QFETCH(QString, appName);
 
     for (int i = 0; i < 5; ++i) {
@@ -1117,14 +1097,14 @@ void tst_QProcess::softExitInSlots()
         QVERIFY(proc.waitedForFinished);
     }
 }
-#endif
 
 //-----------------------------------------------------------------------------
-
-// Reading and writing to a process is not supported on Qt/CE.
-#ifndef Q_OS_WINCE
 void tst_QProcess::mergedChannels()
 {
+#ifdef Q_OS_WINCE
+    QSKIP("Reading and writing to a process is not supported on Qt/CE");
+#endif
+
     QProcess process;
     process.setReadChannelMode(QProcess::MergedChannels);
     QCOMPARE(process.readChannelMode(), QProcess::MergedChannels);
@@ -1147,14 +1127,14 @@ void tst_QProcess::mergedChannels()
     process.closeWriteChannel();
     QVERIFY(process.waitForFinished(5000));
 }
-#endif
 
 //-----------------------------------------------------------------------------
-
-// Reading and writing to a process is not supported on Qt/CE.
-#ifndef Q_OS_WINCE
 void tst_QProcess::forwardedChannels()
 {
+#ifdef Q_OS_WINCE
+    QSKIP("Reading and writing to a process is not supported on Qt/CE");
+#endif
+
     QProcess process;
     process.setReadChannelMode(QProcess::ForwardedChannels);
     QCOMPARE(process.readChannelMode(), QProcess::ForwardedChannels);
@@ -1173,14 +1153,15 @@ void tst_QProcess::forwardedChannels()
     process.closeWriteChannel();
     QVERIFY(process.waitForFinished(5000));
 }
-#endif
 
-//-----------------------------------------------------------------------------
 
-// Reading and writing to a process is not supported on Qt/CE.
-#ifndef Q_OS_WINCE
+//-----------------------------------------------------------------------------
 void tst_QProcess::atEnd()
 {
+#ifdef Q_OS_WINCE
+    QSKIP("Reading and writing to a process is not supported on Qt/CE");
+#endif
+
     QProcess process;
 
 #ifdef Q_OS_MAC
@@ -1202,7 +1183,6 @@ void tst_QProcess::atEnd()
     process.write("", 1);
     QVERIFY(process.waitForFinished(5000));
 }
-#endif
 
 class TestThread : public QThread
 {
@@ -1279,11 +1259,12 @@ void tst_QProcess::processesInMultipleThreads()
 }
 
 //-----------------------------------------------------------------------------
-
-// Reading and writing to a process is not supported on Qt/CE.
-#ifndef Q_OS_WINCE
 void tst_QProcess::waitForFinishedWithTimeout()
 {
+#ifdef Q_OS_WINCE
+    QSKIP("Reading and writing to a process is not supported on Qt/CE");
+#endif
+
     process = new QProcess(this);
 
 #ifdef Q_OS_MAC
@@ -1302,14 +1283,14 @@ void tst_QProcess::waitForFinishedWithTimeout()
     delete process;
     process = 0;
 }
-#endif
 
 //-----------------------------------------------------------------------------
-
-// Reading and writing to a process is not supported on Qt/CE.
-#ifndef Q_OS_WINCE
 void tst_QProcess::waitForReadyReadInAReadyReadSlot()
 {
+#ifdef Q_OS_WINCE
+    QSKIP("Reading and writing to a process is not supported on Qt/CE");
+#endif
+
     process = new QProcess(this);
     connect(process, SIGNAL(readyRead()), this, SLOT(waitForReadyReadInAReadyReadSlotSlot()));
     connect(process, SIGNAL(finished(int)), this, SLOT(exitLoopSlot()));
@@ -1335,27 +1316,27 @@ void tst_QProcess::waitForReadyReadInAReadyReadSlot()
     delete process;
     process = 0;
 }
-#endif
 
 //-----------------------------------------------------------------------------
-
-// Reading and writing to a process is not supported on Qt/CE.
-#ifndef Q_OS_WINCE
 void tst_QProcess::waitForReadyReadInAReadyReadSlotSlot()
 {
+#ifdef Q_OS_WINCE
+    QSKIP("Reading and writing to a process is not supported on Qt/CE");
+#endif
+
     bytesAvailable = process->bytesAvailable();
     process->write("bar", 4);
     QVERIFY(process->waitForReadyRead(5000));
     QTestEventLoop::instance().exitLoop();
 }
-#endif
 
 //-----------------------------------------------------------------------------
-
-// Reading and writing to a process is not supported on Qt/CE.
-#ifndef Q_OS_WINCE
 void tst_QProcess::waitForBytesWrittenInABytesWrittenSlot()
 {
+#ifdef Q_OS_WINCE
+    QSKIP("Reading and writing to a process is not supported on Qt/CE");
+#endif
+
     process = new QProcess(this);
     connect(process, SIGNAL(bytesWritten(qint64)), this, SLOT(waitForBytesWrittenInABytesWrittenSlotSlot()));
     bytesAvailable = 0;
@@ -1380,19 +1361,18 @@ void tst_QProcess::waitForBytesWrittenInABytesWrittenSlot()
     delete process;
     process = 0;
 }
-#endif
 
 //-----------------------------------------------------------------------------
-
-// Reading and writing to a process is not supported on Qt/CE.
-#ifndef Q_OS_WINCE
 void tst_QProcess::waitForBytesWrittenInABytesWrittenSlotSlot()
 {
+#ifdef Q_OS_WINCE
+    QSKIP("Reading and writing to a process is not supported on Qt/CE");
+#endif
+
     process->write("b");
     QVERIFY(process->waitForBytesWritten(5000));
     QTestEventLoop::instance().exitLoop();
 }
-#endif
 
 //-----------------------------------------------------------------------------
 void tst_QProcess::spaceArgsTest_data()
@@ -1673,11 +1653,12 @@ void tst_QProcess::failToStartWithEventLoop()
 }
 
 //-----------------------------------------------------------------------------
-
-// Reading and writing to a process is not supported on Qt/CE.
-#ifndef Q_OS_WINCE
 void tst_QProcess::removeFileWhileProcessIsRunning()
 {
+#ifdef Q_OS_WINCE
+    QSKIP("Reading and writing to a process is not supported on Qt/CE");
+#endif
+
     QFile file("removeFile.txt");
     QVERIFY(file.open(QFile::WriteOnly));
 
@@ -1695,12 +1676,8 @@ void tst_QProcess::removeFileWhileProcessIsRunning()
     process.write("", 1);
     QVERIFY(process.waitForFinished(5000));
 }
-#endif
 
 //-----------------------------------------------------------------------------
-
-// WinCE doesn't support environment variables.
-#ifndef Q_OS_WINCE
 void tst_QProcess::setEnvironment_data()
 {
     QTest::addColumn<QString>("name");
@@ -1720,6 +1697,10 @@ void tst_QProcess::setEnvironment_data()
 
 void tst_QProcess::setEnvironment()
 {
+#if defined (Q_OS_WINCE)
+    QSKIP("OS doesn't support environment variables");
+#endif
+
     // make sure our environment variables are correct
     QVERIFY(qgetenv("tst_QProcess").isEmpty());
     QVERIFY(!qgetenv("PATH").isEmpty());
@@ -1775,12 +1756,8 @@ void tst_QProcess::setEnvironment()
         QCOMPARE(process.readAll(), value.toLocal8Bit());
     }
 }
-#endif
 
 //-----------------------------------------------------------------------------
-
-// WinCE doesn't support environment variables.
-#ifndef Q_OS_WINCE
 void tst_QProcess::setProcessEnvironment_data()
 {
     setEnvironment_data();
@@ -1788,6 +1765,10 @@ void tst_QProcess::setProcessEnvironment_data()
 
 void tst_QProcess::setProcessEnvironment()
 {
+#if defined (Q_OS_WINCE)
+    QSKIP("OS doesn't support environment variables");
+#endif
+
     // make sure our environment variables are correct
     QVERIFY(qgetenv("tst_QProcess").isEmpty());
     QVERIFY(!qgetenv("PATH").isEmpty());
@@ -1818,8 +1799,6 @@ void tst_QProcess::setProcessEnvironment()
         QCOMPARE(process.readAll(), value.toLocal8Bit());
     }
 }
-#endif
-
 //-----------------------------------------------------------------------------
 void tst_QProcess::systemEnvironment()
 {
@@ -1837,18 +1816,17 @@ void tst_QProcess::systemEnvironment()
 }
 
 //-----------------------------------------------------------------------------
-
-// Reading and writing to a process is not supported on Qt/CE.
-#ifndef Q_OS_WINCE
 void tst_QProcess::spaceInName()
 {
+#ifdef Q_OS_WINCE
+    QSKIP("Reading and writing to a process is not supported on Qt/CE");
+#endif
     QProcess process;
     process.start("test Space In Name/testSpaceInName", QStringList());
     QVERIFY(process.waitForStarted());
     process.write("", 1);
     QVERIFY(process.waitForFinished());
 }
-#endif
 
 //-----------------------------------------------------------------------------
 void tst_QProcess::lockupsInStartDetached()
@@ -1864,11 +1842,12 @@ void tst_QProcess::lockupsInStartDetached()
 }
 
 //-----------------------------------------------------------------------------
-
-// Reading and writing to a process is not supported on Qt/CE.
-#ifndef Q_OS_WINCE
 void tst_QProcess::atEnd2()
 {
+#ifdef Q_OS_WINCE
+    QSKIP("Reading and writing to a process is not supported on Qt/CE");
+#endif
+
     QProcess process;
 
 #ifdef Q_OS_MAC
@@ -1885,7 +1864,6 @@ void tst_QProcess::atEnd2()
     }
     QCOMPARE(lines.size(), 7);
 }
-#endif
 
 //-----------------------------------------------------------------------------
 void tst_QProcess::waitForReadyReadForNonexistantProcess()
@@ -1909,11 +1887,12 @@ void tst_QProcess::waitForReadyReadForNonexistantProcess()
 }
 
 //-----------------------------------------------------------------------------
-
-// Reading and writing to a process is not supported on Qt/CE.
-#ifndef Q_OS_WINCE
 void tst_QProcess::setStandardInputFile()
 {
+#ifdef Q_OS_WINCE
+    QSKIP("Reading and writing to a process is not supported on Qt/CE");
+#endif
+
     static const char data[] = "A bunch\1of\2data\3\4\5\6\7...";
     QProcess process;
     QFile file("data");
@@ -1934,12 +1913,8 @@ void tst_QProcess::setStandardInputFile()
     QCOMPARE(all.size(), int(sizeof data) - 1); // testProcessEcho drops the ending \0
     QVERIFY(all == data);
 }
-#endif
 
 //-----------------------------------------------------------------------------
-
-// Reading and writing to a process is not supported on Qt/CE.
-#ifndef Q_OS_WINCE
 void tst_QProcess::setStandardOutputFile_data()
 {
     QTest::addColumn<int>("channelToTest");
@@ -1970,6 +1945,10 @@ void tst_QProcess::setStandardOutputFile_data()
 
 void tst_QProcess::setStandardOutputFile()
 {
+#ifdef Q_OS_WINCE
+    QSKIP("Reading and writing to a process is not supported on Qt/CE");
+#endif
+
     static const char data[] = "Original data. ";
     static const char testdata[] = "Test data.";
 
@@ -2020,11 +1999,8 @@ void tst_QProcess::setStandardOutputFile()
 
     QCOMPARE(all.size(), expectedsize);
 }
-#endif
 
 //-----------------------------------------------------------------------------
-// Reading and writing to a process is not supported on Qt/CE.
-#ifndef Q_OS_WINCE
 void tst_QProcess::setStandardOutputProcess_data()
 {
     QTest::addColumn<bool>("merged");
@@ -2034,6 +2010,10 @@ void tst_QProcess::setStandardOutputProcess_data()
 
 void tst_QProcess::setStandardOutputProcess()
 {
+#ifdef Q_OS_WINCE
+    QSKIP("Reading and writing to a process is not supported on Qt/CE");
+#endif
+
     QProcess source;
     QProcess sink;
 
@@ -2061,14 +2041,14 @@ void tst_QProcess::setStandardOutputProcess()
     else
         QCOMPARE(all, QByteArray("HHeelllloo,,  WWoorrlldd"));
 }
-#endif
 
 //-----------------------------------------------------------------------------
-
-// Reading and writing to a process is not supported on Qt/CE.
-#ifndef Q_OS_WINCE
 void tst_QProcess::fileWriterProcess()
 {
+#ifdef Q_OS_WINCE
+    QSKIP("Reading and writing to a process is not supported on Qt/CE");
+#endif
+
     QString stdinStr;
     for (int i = 0; i < 5000; ++i)
         stdinStr += QString::fromLatin1("%1 -- testing testing 1 2 3\n").arg(i);
@@ -2090,7 +2070,6 @@ void tst_QProcess::fileWriterProcess()
         QCOMPARE(QFile("fileWriterProcess.txt").size(), qint64(stdinStr.size()));
     } while (stopWatch.elapsed() < 3000);
 }
-#endif
 
 //-----------------------------------------------------------------------------
 void tst_QProcess::detachedWorkingDirectoryAndPid()
@@ -2137,11 +2116,11 @@ void tst_QProcess::detachedWorkingDirectoryAndPid()
 }
 
 //-----------------------------------------------------------------------------
-
-// Reading and writing to a process is not supported on Qt/CE.
-#ifndef Q_OS_WINCE
 void tst_QProcess::switchReadChannels()
 {
+#ifdef Q_OS_WINCE
+    QSKIP("Reading and writing to a process is not supported on Qt/CE");
+#endif
     const char data[] = "ABCD";
 
     QProcess process;
@@ -2170,15 +2149,13 @@ void tst_QProcess::switchReadChannels()
     process.setReadChannel(QProcess::StandardOutput);
     QCOMPARE(process.read(1), QByteArray("D"));
 }
-#endif
 
 //-----------------------------------------------------------------------------
-
-// Windows CE does not support working directory logic, and
-// setWorkingDirectory will chdir before starting the process on unices.
-#if defined(Q_OS_WIN) && !defined(Q_OS_WINCE)
 void tst_QProcess::setWorkingDirectory()
 {
+#ifdef Q_OS_WINCE
+    QSKIP("Windows CE does not support working directory logic");
+#endif
     process = new QProcess;
     process->setWorkingDirectory("test");
 #ifdef Q_OS_MAC
@@ -2186,6 +2163,9 @@ void tst_QProcess::setWorkingDirectory()
 #else
     process->start("testSetWorkingDirectory/testSetWorkingDirectory");
 #endif
+#ifndef Q_OS_WIN
+    QSKIP("setWorkingDirectory will chdir before starting the process on unices");
+#endif
     QVERIFY(process->waitForFinished());
 
     QByteArray workingDir = process->readAllStandardOutput();
@@ -2194,7 +2174,6 @@ void tst_QProcess::setWorkingDirectory()
     delete process;
     process = 0;
 }
-#endif
 
 //-----------------------------------------------------------------------------
 void tst_QProcess::startFinishStartFinish()