#ifndef QT_NO_EXCEPTIONS
void exceptions();
#endif
-#ifdef Q_COMPILER_DECLTYPE
void functor();
-#endif
-#ifdef Q_COMPILER_LAMBDA
void lambda();
-#endif
};
void light()
};
// This tests functor without result_type; decltype need to be supported by the compiler.
-#ifdef Q_COMPILER_DECLTYPE
void tst_QtConcurrentRun::functor()
{
+#ifndef Q_COMPILER_DECLTYPE
+ QSKIP("Compiler does not support decltype");
+#else
Functor f;
{
QFuture<int> fut = QtConcurrent::run(f);
QtConcurrent::run(f, 1,2,3,4).waitForFinished();
QtConcurrent::run(f, 1,2,3,4,5).waitForFinished();
}
-}
#endif
+}
-#ifdef Q_COMPILER_LAMBDA
void tst_QtConcurrentRun::lambda()
{
+#ifndef Q_COMPILER_LAMBDA
+ QSKIP("Compiler does not support lambda");
+#else
QCOMPARE(QtConcurrent::run([](){ return 45; }).result(), 45);
QCOMPARE(QtConcurrent::run([](int a){ return a+15; }, 12).result(), 12+15);
QCOMPARE(QtConcurrent::run([](int a, double b){ return a + b; }, 12, 15).result(), double(12+15));
QCOMPARE(r, QStringList({"Hello", "World", "Foo"}));
}
#endif
-}
#endif
+}
QTEST_MAIN(tst_QtConcurrentRun)
#include "tst_qtconcurrentrun.moc"
void stream_QPen_data();
void stream_QPen();
-#ifndef Q_OS_WINCE
void stream_QPixmap_data();
void stream_QPixmap();
-#endif
void stream_QPoint_data();
void stream_QPoint();
void stream_qint64_data();
void stream_qint64();
-#ifndef Q_OS_WINCE
void stream_QIcon_data();
void stream_QIcon();
-#endif
void stream_QEasingCurve_data();
void stream_QEasingCurve();
// pixmap testing is currently limited to one pixmap only.
//
-// Test depends on more memory than available on Qt/CE.
-#ifndef Q_OS_WINCE
void tst_QDataStream::stream_QPixmap_data()
{
+#ifndef Q_OS_WINCE
stream_data(1);
+#endif
}
void tst_QDataStream::stream_QPixmap()
{
+#ifdef Q_OS_WINCE
+ QSKIP("Test depends on more memory than available on Qt/CE");
+#endif
STREAM_IMPL(QPixmap);
}
-#endif
-// Test depends on more memory than available on Qt/CE.
-#ifndef Q_OS_WINCE
void tst_QDataStream::stream_QIcon_data()
{
+#ifndef Q_OS_WINCE
stream_data(1);
+#endif
}
void tst_QDataStream::stream_QIcon()
{
+#ifdef Q_OS_WINCE
+ QSKIP("Test depends on more memory than available on Qt/CE");
+#endif
STREAM_IMPL(QIcon);
}
-#endif
void tst_QDataStream::writeQPixmap(QDataStream *s)
{
void operator_eq();
-#ifndef Q_OS_WINCE
void dotAndDotDot();
-#endif
void homePath();
void tempPath();
void rootPath();
dir1.setPath("..");
}
-// WinCE does not have . nor ..
-#ifndef Q_OS_WINCE
void tst_QDir::dotAndDotDot()
{
+#if defined(Q_OS_WINCE)
+ QSKIP("WinCE does not have . nor ..");
+#else
QDir dir(QString(SRCDIR "testdir/"));
QStringList entryList = dir.entryList(QDir::Dirs);
QCOMPARE(entryList, QStringList() << QString(".") << QString("..") << QString("dir") << QString("spaces"));
entryList = dir.entryList(QDir::Dirs | QDir::NoDotAndDotDot);
QCOMPARE(entryList, QStringList() << QString("dir") << QString("spaces"));
-}
#endif
+}
void tst_QDir::homePath()
{
void uncPaths_data();
void uncPaths();
#endif
-#if !defined(Q_OS_WIN) && !defined(Q_OS_WINCE)
void qtbug15421_hiddenDirs_hiddenFiles();
-#endif
};
tst_QDirIterator::tst_QDirIterator()
}
#endif
-// In Unix it is easy to create hidden files, but in Windows it requires
-// a special call since hidden files need to be "marked" while in Unix
-// anything starting by a '.' is a hidden file.
-// For that reason this test is not run in Windows.
-#if !defined(Q_OS_WIN) && !defined(Q_OS_WINCE)
void tst_QDirIterator::qtbug15421_hiddenDirs_hiddenFiles()
{
+ // In Unix it is easy to create hidden files, but in Windows it requires
+ // a special call since hidden files need to be "marked" while in Unix
+ // anything starting by a '.' is a hidden file.
+ // For that reason this test is not run in Windows.
+#if defined Q_OS_WIN || Q_OS_WINCE
+ QSKIP("To create hidden files a special call is required in Windows.");
+#else
// Only files
{
int matches = 0;
QCOMPARE(matches, 6);
QCOMPARE(failures, 0);
}
+#endif // Q_OS_WIN || Q_OS_WINCE
}
-#endif
QTEST_MAIN(tst_QDirIterator)
// Map/unmap large file
void mapFile();
-#ifndef Q_OS_MAC
void mapOffsetOverflow();
-#endif
void closeFile() { largeFile.close(); }
QVERIFY( largeFile.unmap( baseAddress ) );
}
-// mmap'ping beyond EOF may succeed; generate bus error on access.
-#ifndef Q_OS_MAC
void tst_LargeFile::mapOffsetOverflow()
{
+#if defined(Q_OS_MAC)
+ QSKIP("mmap'ping beyond EOF may succeed; generate bus error on access");
+#endif
+
// Out-of-range mappings should fail, and not silently clip the offset
for (int i = 50; i < 63; ++i) {
uchar *address = 0;
QVERIFY( !address );
}
}
-#endif
QTEST_APPLESS_MAIN(tst_LargeFile)
#include "tst_largefile.moc"
void readAll_data();
void readAll();
void readAllBuffer();
-#if !defined(Q_OS_WINCE) && !defined(QT_NO_PROCESS)
void readAllStdin();
void readLineStdin();
void readLineStdin_lineByLine();
-#endif
void text();
void missingEndOfLine();
void readBlock();
void readTextFile2();
void writeTextFile_data();
void writeTextFile();
-#ifndef Q_OS_SOLARIS
/* void largeFileSupport(); */
-#endif
#if defined(Q_OS_WIN) && !defined(Q_OS_WINCE)
void largeUncFileSupport();
#endif
void tailFile();
void flush();
void bufferedRead();
-#ifdef Q_OS_UNIX
void isSequential();
-#endif
void encodeName();
void truncate();
void seekToPos();
NumberOfFileTypes
};
-#ifndef Q_WS_WINCE
void openStandardStreamsFileDescriptors();
-#endif
-#ifdef Q_OS_UNIX
void openStandardStreamsBufferedStreams();
-#endif
bool openFd(QFile &file, QIODevice::OpenMode mode, QFile::FileHandleFlags handleFlags)
{
QFile::remove(fileName);
}
-// Currently no stdin/out supported for Windows CE.
-#if !defined(Q_OS_WINCE) && !defined(QT_NO_PROCESS)
void tst_QFile::readAllStdin()
{
+#if defined(Q_OS_WINCE)
+ QSKIP("Currently no stdin/out supported for Windows CE");
+#endif
+#if defined(QT_NO_PROCESS)
+ QSKIP("Qt was compiled with QT_NO_PROCESS");
+#else
QByteArray lotsOfData(1024, '@'); // 10 megs
QProcess process;
process.closeWriteChannel();
process.waitForFinished();
QCOMPARE(process.readAll().size(), lotsOfData.size() * 5);
-}
#endif
+}
-// Currently no stdin/out supported for Windows CE.
-#if !defined(Q_OS_WINCE) && !defined(QT_NO_PROCESS)
void tst_QFile::readLineStdin()
{
+#if defined(Q_OS_WINCE)
+ QSKIP("Currently no stdin/out supported for Windows CE");
+#endif
+#if defined(QT_NO_PROCESS)
+ QSKIP("Qt was compiled with QT_NO_PROCESS");
+#else
+
QByteArray lotsOfData(1024, '@'); // 10 megs
for (int i = 0; i < lotsOfData.size(); ++i) {
if ((i % 32) == 31)
QCOMPARE(char(array[i]), char('0' + i % 32));
}
}
-}
#endif
+}
-// Currently no stdin/out supported for Windows CE.
-#if !defined(Q_OS_WINCE) && !defined(QT_NO_PROCESS)
void tst_QFile::readLineStdin_lineByLine()
{
+#if defined(Q_OS_WINCE)
+ QSKIP("Currently no stdin/out supported for Windows CE");
+#endif
+#if defined(QT_NO_PROCESS)
+ QSKIP("Qt was compiled with QT_NO_PROCESS");
+#else
for (int i = 0; i < 2; ++i) {
QProcess process;
process.start(QString("stdinprocess/stdinprocess line %1").arg(i), QIODevice::Text | QIODevice::ReadWrite);
process.closeWriteChannel();
QVERIFY(process.waitForFinished(5000));
}
-}
#endif
+}
void tst_QFile::text()
{
fclose(stdFile);
}
-#ifdef Q_OS_UNIX
void tst_QFile::isSequential()
{
+#ifndef Q_OS_UNIX
+ QSKIP("Unix only test.");
+#endif
QFile zero("/dev/null");
QVERIFY(zero.open(QFile::ReadOnly));
QVERIFY(zero.isSequential());
}
-#endif
void tst_QFile::encodeName()
{
#include <qglobal.h>
#define BUFFSIZE 1
#define FILESIZE 0x10000000f
-
-// Solaris does not support statfs.
-#ifndef Q_OS_SOLARIS
void tst_QFile::largeFileSupport()
{
+#ifdef Q_OS_SOLARIS
+ QSKIP("Solaris does not support statfs");
+#else
qlonglong sizeNeeded = 2147483647;
sizeNeeded *= 2;
sizeNeeded += 1024;
} else {
QFAIL("Could not determin disk space");
}
-}
#endif
+}
*/
void tst_QFile::i18nFileName_data()
f1.close();
}
-// Although Windows CE (not mobile!) has functions that allow redirecting
-// the standard file descriptors to a file (see SetStdioPathW/GetStdioPathW)
-// it does not have functions to simply open them like below.
-#ifndef Q_WS_WINCE
void tst_QFile::openStandardStreamsFileDescriptors()
{
+#ifdef Q_OS_WINCE
+ //allthough Windows CE (not mobile!) has functions that allow redirecting
+ //the standard file descriptors to a file (see SetStdioPathW/GetStdioPathW)
+ //it does not have functions to simply open them like below .
+ QSKIP("Opening standard streams on Windows CE via descriptor not implemented");
+#endif
// Using file descriptors
{
QFile in;
QVERIFY( err.isSequential() );
}
}
-#endif
-#ifdef Q_OS_UNIX
void tst_QFile::openStandardStreamsBufferedStreams()
{
+#ifndef Q_OS_UNIX
+ QSKIP("Unix only test.");
+#endif
// Using streams
{
QFile in;
QVERIFY( err.isSequential() );
}
}
-#endif
void tst_QFile::openStandardStreams()
{
-#ifndef Q_WS_WINCE
openStandardStreamsFileDescriptors();
-#endif
-#ifdef Q_OS_UNIX
openStandardStreamsBufferedStreams();
-#endif
}
void tst_QFile::writeNothing()
void size_data();
void size();
-#if defined(Q_OS_WIN) && !defined(Q_OS_WINCE)
void systemFiles();
-#endif
void compare_data();
void compare();
void isWritable();
void isExecutable();
-#ifdef Q_OS_MAC
void testDecomposedUnicodeNames_data();
void testDecomposedUnicodeNames();
-#endif
void equalOperator() const;
void equalOperatorWithDifferentSlashes() const;
QTEST(int(fi.size()), "size");
}
-// This is a Windows only test.
-#if defined(Q_OS_WIN) && !defined(Q_OS_WINCE)
void tst_QFileInfo::systemFiles()
{
+#if !defined(Q_OS_WIN) || defined(Q_OS_WINCE)
+ QSKIP("This is a Windows only test");
+#endif
QFileInfo fi("c:\\pagefile.sys");
QVERIFY(fi.exists()); // task 167099
QVERIFY(fi.size() > 0); // task 189202
QVERIFY(fi.lastModified().isValid());
}
-#endif
void tst_QFileInfo::compare_data()
{
}
-// This is a OS X only test (unless you know more about filesystems, then maybe you should try it ;)
-#ifdef Q_OS_MAC
void tst_QFileInfo::testDecomposedUnicodeNames_data()
{
QTest::addColumn<QString>("filePath");
static void createFileNative(const QString &filePath)
{
+#ifdef Q_OS_UNIX
int fd = open(filePath.normalized(QString::NormalizationForm_D).toUtf8().constData(), O_CREAT | O_WRONLY, S_IRUSR | S_IWUSR);
if (fd < 0) {
QFAIL("couldn't create file");
} else {
close(fd);
}
+#else
+ Q_UNUSED(filePath);
+#endif
}
static void removeFileNative(const QString &filePath)
{
+#ifdef Q_OS_UNIX
unlink(filePath.normalized(QString::NormalizationForm_D).toUtf8().constData());
+#else
+ Q_UNUSED(filePath);
+#endif
}
void tst_QFileInfo::testDecomposedUnicodeNames()
{
+#ifndef Q_OS_MAC
+ QSKIP("This is a OS X only test (unless you know more about filesystems, then maybe you should try it ;)");
+#endif
QFETCH(QString, filePath);
createFileNative(filePath);
QTEST(file.exists(), "exists");
removeFileNative(filePath);
}
-#endif
void tst_QFileInfo::equalOperator() const
{
private slots:
void getSetCheck();
-#if !defined(Q_OS_WINCE) || !defined(WINCE_EMULATOR_TEST)
void constructing_QTcpSocket();
-#endif
void constructing_QFile();
void read_QByteArray();
-#if !defined(Q_OS_WINCE) || !defined(WINCE_EMULATOR_TEST)
void unget();
-#endif
void peek();
void peekAndRead();
}
//----------------------------------------------------------------------------------
-
-// Networking tests in a WinCE emulator are unstable.
-#if !defined(Q_OS_WINCE) || !defined(WINCE_EMULATOR_TEST)
void tst_QIODevice::constructing_QTcpSocket()
{
+#if defined(Q_OS_WINCE) && defined(WINCE_EMULATOR_TEST)
+ QSKIP("Networking tests in a WinCE emulator are unstable");
+#endif
QTcpSocket socket;
QIODevice *device = &socket;
}
QCOMPARE(*c1, *c2);
}
-#endif
//----------------------------------------------------------------------------------
void tst_QIODevice::constructing_QFile()
}
//--------------------------------------------------------------------
-
-// Networking tests in a WinCE emulator are unstable.
-#if !defined(Q_OS_WINCE) || !defined(WINCE_EMULATOR_TEST)
void tst_QIODevice::unget()
{
+#if defined(Q_OS_WINCE) && defined(WINCE_EMULATOR_TEST)
+ QSKIP("Networking tests in a WinCE emulator are unstable");
+#endif
QBuffer buffer;
buffer.open(QBuffer::ReadWrite);
buffer.write("ZXCV");
socket.close();
}
}
-#endif
//--------------------------------------------------------------------
void tst_QIODevice::peek()
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();
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();
void readFromProcess();
void exitLoopSlot();
void restartProcess();
-#ifndef Q_OS_WINCE
void waitForReadyReadInAReadyReadSlotSlot();
void waitForBytesWrittenInABytesWrittenSlotSlot();
-#endif
private:
QProcess *process;
}
//-----------------------------------------------------------------------------
-
-// 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");
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));
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");
}
//-----------------------------------------------------------------------------
-
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;
delete process;
process = 0;
}
-#endif
//-----------------------------------------------------------------------------
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()));
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");
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");
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);
QVERIFY(proc.readAll().startsWith(output));
}
+
#endif
//-----------------------------------------------------------------------------
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");
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");
delete process;
process = 0;
}
-#endif
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
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.
QCOMPARE(process->write("", 1), qlonglong(1));
QVERIFY(process->waitForFinished(5000));
}
-#endif
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");
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;
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);
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()));
proc.write("", 1);
QVERIFY(proc.waitForFinished(5000));
}
-#endif
//-----------------------------------------------------------------------------
void tst_QProcess::hardExit()
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
};
//-----------------------------------------------------------------------------
-
void tst_QProcess::softExitInSlots_data()
{
QTest::addColumn<QString>("appName");
}
//-----------------------------------------------------------------------------
-
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) {
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);
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);
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
process.write("", 1);
QVERIFY(process.waitForFinished(5000));
}
-#endif
class TestThread : public QThread
{
}
//-----------------------------------------------------------------------------
-
-// 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
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()));
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;
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()
}
//-----------------------------------------------------------------------------
-
-// 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));
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");
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());
QCOMPARE(process.readAll(), value.toLocal8Bit());
}
}
-#endif
//-----------------------------------------------------------------------------
-
-// WinCE doesn't support environment variables.
-#ifndef Q_OS_WINCE
void tst_QProcess::setProcessEnvironment_data()
{
setEnvironment_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());
QCOMPARE(process.readAll(), value.toLocal8Bit());
}
}
-#endif
-
//-----------------------------------------------------------------------------
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()
}
//-----------------------------------------------------------------------------
-
-// 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
}
QCOMPARE(lines.size(), 7);
}
-#endif
//-----------------------------------------------------------------------------
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");
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");
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.";
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");
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;
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);
QCOMPARE(QFile("fileWriterProcess.txt").size(), qint64(stdinStr.size()));
} while (stopWatch.elapsed() < 3000);
}
-#endif
//-----------------------------------------------------------------------------
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;
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
#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();
delete process;
process = 0;
}
-#endif
//-----------------------------------------------------------------------------
void tst_QProcess::startFinishStartFinish()
void caseSensitivity();
void systemEnvironment();
-#ifndef Q_OS_WINCE
void putenv();
-#endif
};
void tst_QProcessEnvironment::operator_eq()
#endif
}
-// Windows CE has no environment.
-#ifndef Q_OS_WINCE
void tst_QProcessEnvironment::putenv()
{
+#ifdef Q_OS_WINCE
+ QSKIP("Windows CE has no environment");
+#else
static const char envname[] = "WE_RE_SETTING_THIS_ENVIRONMENT_VARIABLE";
static bool testRan = false;
QVERIFY(eAfter.contains(lower));
QCOMPARE(eAfter.value(lower), QString("Hello, World"));
# endif
-}
#endif
+}
QTEST_MAIN(tst_QProcessEnvironment)
void testEscapes();
void testCaseSensitivity_data();
void testCaseSensitivity();
-#if defined(QT_BUILD_INTERNAL) && !defined(Q_OS_WIN)
void testErrorHandling_data();
void testErrorHandling();
-#endif
void testIniParsing_data();
void testIniParsing();
void testChildKeysAndGroups_data();
void setPath();
void setDefaultFormat();
void dontCreateNeedlessPaths();
-#if !defined(Q_OS_WIN) && !defined(QT_QSETTINGS_ALWAYS_CASE_SENSITIVE_AND_FORGET_ORIGINAL_KEY_ORDER)
+#if !defined(Q_OS_WIN)
void dontReorderIniKeysNeedlessly();
#endif
#if defined(Q_OS_WIN)
}
}
-// Windows doesn't support most file modes, including read-only directories, so this test is moot.
-#if defined(QT_BUILD_INTERNAL) && !defined(Q_OS_WIN)
void tst_QSettings::testErrorHandling_data()
{
QTest::addColumn<int>("filePerms"); // -1 means file should not exist
void tst_QSettings::testErrorHandling()
{
-#if defined(Q_OS_UNIX)
+#ifdef QT_BUILD_INTERNAL
+#ifdef Q_OS_WIN
+ QSKIP("Windows doesn't support most file modes, including read-only directories, so this test is moot.");
+#elif defined(Q_OS_UNIX)
if (::getuid() == 0)
QSKIP("Running this test as root doesn't work, since file perms do not bother him");
#else
QCOMPARE(settings.value("alpha/beta/geometry").toInt(), 100);
QCOMPARE((int)settings.status(), statusAfterSetAndSync);
}
+#endif // !Q_OS_WIN
#endif
}
-#endif
Q_DECLARE_METATYPE(QVariant)
Q_DECLARE_METATYPE(QSettings::Status)
QVERIFY(!fileInfo.dir().exists());
}
-// if QT_QSETTINGS_ALWAYS_CASE_SENSITIVE_AND_FORGET_ORIGINAL_KEY_ORDER is defined,
-// the Qt build does not preserve ordering, as a code size optimization.
-#if !defined(Q_OS_WIN) && !defined(QT_QSETTINGS_ALWAYS_CASE_SENSITIVE_AND_FORGET_ORIGINAL_KEY_ORDER)
+#if !defined(Q_OS_WIN)
void tst_QSettings::dontReorderIniKeysNeedlessly()
{
+#ifdef QT_QSETTINGS_ALWAYS_CASE_SENSITIVE_AND_FORGET_ORIGINAL_KEY_ORDER
+ QSKIP("This Qt build does not preserve ordering, as a code size optimization.");
+#endif
+
/*
This is a very strong test. It asserts that modifying
resourcefile2.ini will lead to the exact contents of
void octTest();
void zeroTermination();
void ws_manipulator();
-#ifndef Q_OS_WINCE
void stillOpenWhenAtEnd();
-#endif
void readNewlines_data();
void readNewlines();
void seek();
void pos();
void pos2();
void pos3LargeFile();
-#ifndef Q_OS_WINCE
void readStdin();
void readAllFromStdin();
void readLineFromStdin();
-#endif
void read();
void qbool();
void forcePoint();
}
// ------------------------------------------------------------------------------
-
-// Qt/CE: Cannot test network on emulator.
-#ifndef Q_OS_WINCE
void tst_QTextStream::stillOpenWhenAtEnd()
{
int argc = 0;
while (!stream.readLine().isNull()) {}
QVERIFY(file.isOpen());
+#ifdef Q_OS_WINCE
+ QSKIP("Qt/CE: Cannot test network on emulator");
+#endif
QTcpSocket socket;
socket.connectToHost(QtNetworkSettings::serverName(), 143);
QVERIFY(socket.waitForReadyRead(5000));
while (!stream2.readLine().isNull()) {}
QVERIFY(socket.isOpen());
}
-#endif
// ------------------------------------------------------------------------------
void tst_QTextStream::readNewlines_data()
}
// ------------------------------------------------------------------------------
-
-// Qt/CE has no stdin/out support for processes.
-#ifndef Q_OS_WINCE
void tst_QTextStream::readStdin()
{
+#if defined(Q_OS_WINCE)
+ QSKIP("Qt/CE has no stdin/out support for processes");
+#endif
QProcess stdinProcess;
stdinProcess.start("stdinProcess/stdinProcess");
stdinProcess.setReadChannel(QProcess::StandardError);
QCOMPARE(b, 2);
QCOMPARE(c, 3);
}
-#endif
// ------------------------------------------------------------------------------
-
-// Qt/CE has no stdin/out support for processes.
-#ifndef Q_OS_WINCE
void tst_QTextStream::readAllFromStdin()
{
+#if defined(Q_OS_WINCE)
+ QSKIP("Qt/CE has no stdin/out support for processes");
+#endif
QProcess stdinProcess;
stdinProcess.start("readAllStdinProcess/readAllStdinProcess", QIODevice::ReadWrite | QIODevice::Text);
stdinProcess.setReadChannel(QProcess::StandardError);
QChar quoteChar('"');
QCOMPARE(stream.readAll(), QString::fromLatin1("%1hello world%2 \n").arg(quoteChar).arg(quoteChar));
}
-#endif
// ------------------------------------------------------------------------------
-
-// Qt/CE has no stdin/out support for processes.
-#ifndef Q_OS_WINCE
void tst_QTextStream::readLineFromStdin()
{
+#if defined(Q_OS_WINCE)
+ QSKIP("Qt/CE has no stdin/out support for processes");
+#endif
QProcess stdinProcess;
stdinProcess.start("readLineStdinProcess/readLineStdinProcess", QIODevice::ReadWrite | QIODevice::Text);
stdinProcess.setReadChannel(QProcess::StandardError);
QVERIFY(stdinProcess.waitForFinished(5000));
}
-#endif
// ------------------------------------------------------------------------------
void tst_QTextStream::read()
// This test *must* run first. See the definition for why.
void processEvents();
void exec();
-#if !defined(QT_NO_EXCEPTIONS) && !defined(Q_OS_WINCE_WM)
void throwInExec();
-#endif
void reexec();
void execAfterExit();
void wakeUp();
}
}
-// This test needs exceptions to be enabled.
-// Windows Mobile cannot handle cross library exceptions
-// qobject.cpp will try to rethrow the exception after handling
-// which causes gwes.exe to crash
-#if !defined(QT_NO_EXCEPTIONS) && !defined(Q_OS_WINCE_WM)
void tst_QEventLoop::throwInExec()
{
-#if defined(Q_OS_LINUX)
+#if defined(QT_NO_EXCEPTIONS) || defined(NO_EVENTLOOP_EXCEPTIONS)
+ QSKIP("Exceptions are disabled");
+#elif defined(Q_OS_WINCE_WM)
+ // Windows Mobile cannot handle cross library exceptions
+ // qobject.cpp will try to rethrow the exception after handling
+ // which causes gwes.exe to crash
+ QSKIP("This platform doesn't support propagating exceptions through the event loop");
+#elif defined(Q_OS_LINUX)
// C++ exceptions can't be passed through glib callbacks. Skip the test if
// we're using the glib event loop.
QByteArray dispatcher = QAbstractEventDispatcher::instance()->metaObject()->className();
QCOMPARE(caughtExceptions, 2);
}
}
-#endif
void tst_QEventLoop::reexec()
{
private slots:
void unexpectedDisconnection();
void mixingWithTimers();
-#ifdef Q_OS_UNIX
void posixSockets();
-#endif
};
class UnexpectedDisconnectTester : public QObject
QCOMPARE(helper.socketActivated, true);
}
-#ifdef Q_OS_UNIX
void tst_QSocketNotifier::posixSockets()
{
+#ifndef Q_OS_UNIX
+ QSKIP("test only for posix");
+#else
QTcpServer server;
QVERIFY(server.listen(QHostAddress::LocalHost, 0));
QCOMPARE(passive->readAll(), QByteArray("goodbye",8));
}
qt_safe_close(posixSocket);
-}
#endif
+}
QTEST_MAIN(tst_QSocketNotifier)
#include <tst_qsocketnotifier.moc>
void customEventDispatcher();
-#ifndef Q_OS_WINCE
void stressTest();
-#endif
};
enum { one_minute = 60 * 1000, five_minutes = 5 * one_minute };
QVERIFY(!QTestEventLoop::instance().timeout());
QCOMPARE(recorder.activationCount.load(), numThreads);
}
-
-// Disconnects on WinCE, so skip this test.
-#ifndef Q_OS_WINCE
void tst_QThread::stressTest()
{
+#if defined(Q_OS_WINCE)
+ QSKIP("Disconnects on WinCE, skipping...");
+#endif
QTime t;
t.start();
while (t.elapsed() < one_minute) {
t.wait(one_minute);
}
}
-#endif
class Syncronizer : public QObject
{ Q_OBJECT
void reserve();
-#if defined(Q_COMPILER_LAMBDA) || defined(Q_CC_GNU)
void literals();
-#endif
};
tst_QByteArray::tst_QByteArray()
nil2.reserve(0);
}
-// Only tested on c++0x compliant compiler or gcc.
-#if defined(Q_COMPILER_LAMBDA) || defined(Q_CC_GNU)
void tst_QByteArray::literals()
{
+#if defined(Q_COMPILER_LAMBDA) || defined(Q_CC_GNU)
QByteArray str(QByteArrayLiteral("abcd"));
QVERIFY(str.length() == 4);
QVERIFY(str2.constData() == s);
QVERIFY(str2.data() != s);
-}
+#else
+ QSKIP("Only tested on c++0x compliant compiler or gcc");
#endif
+}
const char globalChar = '1';
void dateTimeFromStringFormat_data();
void dateTimeFromStringFormat();
-#ifdef Q_OS_WIN
void fromString_LOCALE_ILDATE();
-#endif
void fromString();
QLocale::setDefault(def);
}
-#ifdef Q_OS_WIN
void tst_QDateTime::fromString_LOCALE_ILDATE()
{
+#ifdef Q_OS_WIN
QString date1 = QLatin1String("Sun 1. Dec 13:02:00 1974");
QString date2 = QLatin1String("Sun Dec 1 13:02:00 1974");
QDateTime ref(QDate(1974, 12, 1), QTime(13, 2));
QCOMPARE(ref, QDateTime::fromString(date2, Qt::TextDate));
QCOMPARE(ref, QDateTime::fromString(date1, Qt::TextDate));
-}
+#else
+ QSKIP("Windows only");
#endif
+}
void tst_QDateTime::utcOffset()
{
tst_QLocale();
private slots:
-#ifdef Q_OS_WIN
void windowsDefaultLocale();
-#endif
-#ifdef Q_OS_MAC
void macDefaultLocale();
-#endif
void ctor();
-#if !defined(Q_OS_WINCE) && !defined(QT_NO_PROCESS)
void emptyCtor();
-#endif
void unixLocaleName();
void double_conversion_data();
void double_conversion();
#undef TEST_CTOR
}
-// Uses unsupported Windows CE QProcess functionality (std streams, env).
-#if !defined(Q_OS_WINCE) && !defined(QT_NO_PROCESS)
void tst_QLocale::emptyCtor()
{
+#if defined(Q_OS_WINCE)
+ QSKIP("Uses unsupported Windows CE QProcess functionality (std streams, env)");
+#endif
+#if defined(QT_NO_PROCESS)
+ QSKIP("Qt was compiled with QT_NO_PROCESS");
+#else
#define TEST_CTOR(req_lc, exp_str) \
{ \
/* Test constructor without arguments. Needs separate process */ \
TEST_CTOR("123456", defaultLoc);
#undef TEST_CTOR
-}
#endif
+}
void tst_QLocale::unixLocaleName()
{
QCOMPARE(l.toDateTime(string, QLocale::LongFormat), result);
}
-#ifdef Q_OS_MAC
void tst_QLocale::macDefaultLocale()
{
+#ifndef Q_OS_MAC
+ QSKIP("This is a Mac OS X-only test");
+#endif
+
QLocale locale = QLocale::system();
if (locale.name() != QLatin1String("en_US"))
QSKIP("This test only tests for en_US");
QList<Qt::DayOfWeek> days;
days << Qt::Monday << Qt::Tuesday << Qt::Wednesday << Qt::Thursday << Qt::Friday;
QCOMPARE(locale.weekdays(), days);
+
}
-#endif
#ifdef Q_OS_WIN
#include <qt_windows.h>
QString m_decimal, m_thousand, m_sdate, m_ldate, m_time;
};
+
#endif
-#ifdef Q_OS_WIN
void tst_QLocale::windowsDefaultLocale()
{
+#ifndef Q_OS_WIN
+ QSKIP("This is a Windows test");
+#else
RestoreLocaleHelper systemLocale;
// set weird system defaults and make sure we're using them
setWinLocaleInfo(LOCALE_SDECIMAL, QLatin1String("@"));
QCOMPARE(locale.toString(QDateTime(QDate(1974, 12, 1), QTime(1,2,3)), QLocale::LongFormat),
QString("1@12@1974 1^2^3"));
QCOMPARE(locale.toString(QTime(1,2,3), QLocale::LongFormat), QString("1^2^3"));
-}
#endif
+}
void tst_QLocale::numberOptions()
{
void basics();
void operators();
void swap();
-#ifndef Q_CC_SUN
void forwardDeclaration1();
-#endif
void forwardDeclaration2();
void memoryManagement();
void downCast();
void map();
void hash();
void validConstructs();
-#ifndef QTEST_CROSS_COMPILED
void invalidConstructs_data();
void invalidConstructs();
-#endif
public slots:
void cleanup() { check(); }
void externalForwardDeclaration();
extern int forwardDeclaredDestructorRunCount;
-// This type of forward declaration is not valid with SunCC.
-#ifndef Q_CC_SUN
void tst_QSharedPointer::forwardDeclaration1()
{
+#if defined(Q_CC_SUN) || defined(Q_CC_WINSCW) || defined(Q_CC_RVCT)
+ QSKIP("This type of forward declaration is not valid with this compiler");
+#else
externalForwardDeclaration();
struct Wrapper { QSharedPointer<ForwardDeclared> pointer; };
QVERIFY(!w.pointer.isNull());
}
QCOMPARE(forwardDeclaredDestructorRunCount, 1);
-}
#endif
+}
#include "forwarddeclared.h"
typedef bool (QTest::QExternalTest:: * TestFunction)(const QByteArray &body);
Q_DECLARE_METATYPE(TestFunction)
-
-// This test does not work on cross compiled systems.
-#ifndef QTEST_CROSS_COMPILED
void tst_QSharedPointer::invalidConstructs_data()
{
QTest::addColumn<TestFunction>("testFunction");
#ifdef Q_CC_MINGW
QSKIP("The maintainer of QSharedPointer: 'We don't know what the problem is so skip the tests.'");
#endif
+#ifdef QTEST_CROSS_COMPILED
+ QSKIP("This test does not work on cross compiled systems");
+#endif
QTest::QExternalTest test;
test.setQtModules(QTest::QExternalTest::QtCore);
QFAIL("Fail");
}
}
-#endif
namespace QTBUG11730 {
struct IB
public slots:
void cleanup();
private slots:
-#if !defined(Q_CC_HPACC) && !defined(QT_NO_STL)
void fromStdString();
void toStdString();
-#endif
void check_QTextIOStream();
void check_QTextStream();
void check_QDataStream();
void constructor();
void constructorQByteArray_data();
void constructorQByteArray();
-#if !defined(Q_CC_HPACC) && !defined(QT_NO_STL)
void STL();
-#endif
void isEmpty();
void isNull();
void acc_01();
void integer_conversion();
void tortureSprintfDouble();
void toNum();
-#if !defined(Q_OS_MAC) && (!defined(Q_OS_WIN) || defined(Q_OS_WINCE))
void localeAwareCompare_data();
void localeAwareCompare();
-#endif
void split_data();
void split();
void split_regexp();
void QTBUG10404_compareRef();
void QTBUG9281_arg_locale();
-#ifdef QT_USE_ICU
void toUpperLower_icu();
-#endif
-#if defined(QT_UNICODE_LITERAL) && (defined(Q_COMPILER_LAMBDA) || defined(Q_CC_GNU))
void literals();
-#endif
void reserve();
void toHtmlEscaped_data();
QCOMPARE( strBA, expected );
}
-// This test crashes on HP-UX with aCC.
-#if !defined(Q_CC_HPACC) && !defined(QT_NO_STL)
void tst_QString::STL()
{
+#ifdef Q_CC_HPACC
+ QSKIP("This test crashes on HP-UX with aCC");
+#endif
+#ifndef QT_NO_STL
#ifndef QT_NO_CAST_TO_ASCII
QString qt( "QString" );
QCOMPARE(s, QString::fromLatin1("hello"));
QCOMPARE(stlStr, s.toStdWString());
#endif
-}
+#else
+ QSKIP( "Not tested without STL support");
#endif
+}
void tst_QString::truncate()
{
QVERIFY(cstr.data_ptr() != csd);
}
-// This test crashes on HP-UX with aCC.
-#if !defined(Q_CC_HPACC) && !defined(QT_NO_STL)
void tst_QString::fromStdString()
{
+#ifdef Q_CC_HPACC
+ QSKIP("This test crashes on HP-UX with aCC");
+#endif
+#if !defined(QT_NO_STL)
std::string stroustrup = "foo";
QString eng = QString::fromStdString( stroustrup );
QCOMPARE( eng, QString("foo") );
std::string stdnull( cnull, sizeof(cnull)-1 );
QString qtnull = QString::fromStdString( stdnull );
QCOMPARE( qtnull.size(), int(stdnull.size()) );
-}
#endif
+}
-// This test crashes on HP-UX with aCC.
-#if !defined(Q_CC_HPACC) && !defined(QT_NO_STL)
void tst_QString::toStdString()
{
+#ifdef Q_CC_HPACC
+ QSKIP("This test crashes on HP-UX with aCC");
+#endif
+#if !defined(QT_NO_STL)
QString nord = "foo";
std::string stroustrup1 = nord.toStdString();
QVERIFY( qstrcmp(stroustrup1.c_str(), "foo") == 0 );
QString qtnull( qcnull, sizeof(qcnull)/sizeof(QChar) );
std::string stdnull = qtnull.toStdString();
QCOMPARE( int(stdnull.size()), qtnull.size() );
-}
#endif
+}
void tst_QString::utf8()
{
#include <locale.h>
-// Setting the locale is not supported on OS X (you can set the C locale,
-// but that won't affect CFStringCompare which is used to compare strings).
-// On Windows other than Win CE, we cannot set the system or user locale.
-#if !defined(Q_OS_MAC) && (!defined(Q_OS_WIN) || defined(Q_OS_WINCE))
void tst_QString::localeAwareCompare_data()
{
#ifdef Q_OS_WIN
void tst_QString::localeAwareCompare()
{
#ifdef Q_OS_WIN
+# ifndef Q_OS_WINCE
+ QSKIP("On others than Win CE, we cannot set the system or user locale.");
+# endif
QFETCH(ulong, locale);
#else
QFETCH(QString, locale);
QCOMPARE(locale, GetThreadLocale());
# endif
+#elif defined (Q_OS_MAC)
+ QSKIP("Setting the locale is not supported on OS X (you can set the C locale, but that won't affect CFStringCompare which is used to compare strings)");
#elif defined(QT_USE_ICU)
QLocale::setDefault(QLocale(locale));
#else
setlocale(LC_ALL, "");
#endif
}
-#endif
void tst_QString::split_data()
{
QLocale::setDefault(QLocale::C);
}
-#ifdef QT_USE_ICU
void tst_QString::toUpperLower_icu()
{
+#ifndef QT_USE_ICU
+ QSKIP("Qt was built without ICU support");
+#endif
+
QString s = QString::fromLatin1("i");
QCOMPARE(s.toUpper(), QString::fromLatin1("I"));
// the cleanup function will restore the default locale
}
-#endif
-// Only tested on c++0x compliant compiler or gcc.
-#if defined(QT_UNICODE_LITERAL) && (defined(Q_COMPILER_LAMBDA) || defined(Q_CC_GNU))
void tst_QString::literals()
{
+#if defined(QT_UNICODE_LITERAL) && (defined(Q_COMPILER_LAMBDA) || defined(Q_CC_GNU))
QString str(QStringLiteral("abcd"));
QVERIFY(str.length() == 4);
QVERIFY(str2.constData() == s);
QVERIFY(str2.data() != s);
-}
+
+#else
+ QSKIP("Only tested on c++0x compliant compiler or gcc");
#endif
+}
void tst_QString::reserve()
{
void join_data() const;
void joinEmptiness() const;
-#ifdef Q_COMPILER_INITIALIZER_LISTS
void initializeList() const;
-#endif
};
extern const char email[];
QVERIFY(string.isNull());
}
-// this test require C++0x support
-#ifdef Q_COMPILER_INITIALIZER_LISTS
void tst_QStringList::initializeList() const
{
+#ifdef Q_COMPILER_INITIALIZER_LISTS
QStringList v1{QLatin1String("hello"),"world",QString::fromLatin1("plop")};
QCOMPARE(v1, (QStringList() << "hello" << "world" << "plop"));
QCOMPARE(v1, (QStringList{"hello","world","plop"}));
-}
+#else
+ QSKIP("Require C++0x support, pass the right flag to the compiler");
#endif
+}
QTEST_APPLESS_MAIN(tst_QStringList)
#include "tst_qstringlist.moc"
{
Q_OBJECT
private slots:
-#if (defined(Q_OS_WIN) || defined(Q_OS_MAC)) && !defined(QT_NO_PROCESS)
void copy_exit_paste();
-#endif
void capabiliyFunctions();
void modes();
void testSignals();
}
// Test that pasted text remains on the clipboard after a Qt application exits.
-// This test does not make sense on X11 and embedded, as copied data disappears
-// from the clipboard when the application exits. It's still possible to test
-// copy/paste - just keep the apps running.
-#if (defined(Q_OS_WIN) || defined(Q_OS_MAC)) && !defined(QT_NO_PROCESS)
void tst_QClipboard::copy_exit_paste()
{
+#ifndef QT_NO_PROCESS
+#if !defined(Q_OS_WIN) && !defined(Q_OS_MAC)
+ QSKIP("This test does not make sense on X11 and embedded, copied data disappears from the clipboard when the application exits ");
+ // ### It's still possible to test copy/paste - just keep the apps running
+#endif
if (!nativeClipboardWorking())
QSKIP("Native clipboard not working in this setup");
const QStringList stringArgument = QStringList() << "Test string.";
QTest::qWait(100);
#endif
QCOMPARE(QProcess::execute("paster/paster", stringArgument), 0);
-}
#endif
+}
void tst_QClipboard::setMimeData()
{
void symetricConstructors();
void checkMultipleNames();
void checkMultipleCodes();
-#ifndef Q_WS_MAC
void mnemonic_data();
void mnemonic();
-#endif
void toString_data();
void toString();
void streamOperators_data();
void standardKeys_data();
void standardKeys();
void keyBindings();
-#if !defined(Q_WS_MAC) && !defined(Q_OS_WINCE)
void translated_data();
void translated();
-#endif
void i18nKeys_data();
void i18nKeys();
QVERIFY(bindings == expected);
}
-// mnemonics are not used on Mac OS X.
-#ifndef Q_WS_MAC
void tst_QKeySequence::mnemonic_data()
{
QTest::addColumn<QString>("string");
void tst_QKeySequence::mnemonic()
{
+#ifdef Q_WS_MAC
+ QSKIP("mnemonics are not used on Mac OS X");
+#endif
QFETCH(QString, string);
QFETCH(QString, key);
QFETCH(bool, warning);
QCOMPARE(seq, res);
}
-#endif
void tst_QKeySequence::toString_data()
{
QCOMPARE(ks4, ks1);
}
-// No need to translate modifiers on Mac OS X or WinCE.
-#if !defined(Q_WS_MAC) && !defined(Q_OS_WINCE)
void tst_QKeySequence::translated_data()
{
qApp->installTranslator(ourTranslator);
{
QFETCH(QString, transKey);
QFETCH(QString, compKey);
+#ifdef Q_WS_MAC
+ QSKIP("No need to translate modifiers on Mac OS X");
+#elif defined(Q_OS_WINCE)
+ QSKIP("No need to translate modifiers on WinCE");
+#endif
qApp->installTranslator(ourTranslator);
qApp->installTranslator(qtTranslator);
qApp->removeTranslator(ourTranslator);
qApp->removeTranslator(qtTranslator);
}
-#endif
+
void tst_QKeySequence::i18nKeys_data()
{
void achromaticHslHue();
-#if defined(Q_WS_X11) && !defined(Q_OS_IRIX)
+#ifdef Q_WS_X11
void setallowX11ColorNames();
#endif
};
QCOMPARE(hsl.hslHue(), -1);
}
-// This test fails on IRIX due to the gamma settings in the SGI X server.
-#if defined(Q_WS_X11) && !defined(Q_OS_IRIX)
+#ifdef Q_WS_X11
void tst_QColor::setallowX11ColorNames()
{
+#if defined(Q_OS_IRIX)
+ QSKIP("This fails due to the gamma settings in the SGI X server");
+#endif
RGBData x11RgbTbl[] = {
// a few standard X11 color names
{ "DodgerBlue1", qRgb(30, 144, 255) },
void cleanup();
private slots:
void getSetCheck();
-#ifndef Q_WS_MAC
void drawPixmap_comp_data();
void drawPixmap_comp();
-#endif
void saveAndRestore_data();
void saveAndRestore();
void fillRect_stretchToDeviceMode();
void monoImages();
-#ifndef Q_WS_QWS
void linearGradientSymmetry_data();
void linearGradientSymmetry();
-#endif
void gradientInterpolation();
void fpe_pixmapTransform();
void drawRect_task215378();
void drawRect_task247505();
-#if defined(Q_OS_MAC)
void drawText_subPixelPositionsInRaster_qtbug5053();
-#endif
void drawImage_data();
void drawImage();
"...ddddddddddddd"};
-// Mac has other ideas about alpha composition
-#ifndef Q_WS_MAC
void tst_QPainter::drawPixmap_comp_data()
{
if (qApp->desktop()->depth() < 24)
*/
void tst_QPainter::drawPixmap_comp()
{
+#ifdef Q_WS_MAC
+ QSKIP("Mac has other ideas about alpha composition");
+#endif
QFETCH(uint, dest);
QFETCH(uint, source);
QVERIFY(!different);
}
-#endif
void tst_QPainter::saveAndRestore_data()
{
return g2;
}
-// QWS has limited resolution in the gradient color table
-#ifndef Q_WS_QWS
void tst_QPainter::linearGradientSymmetry_data()
{
QTest::addColumn<QGradientStops>("stops");
void tst_QPainter::linearGradientSymmetry()
{
+#ifdef Q_WS_QWS
+ QSKIP("QWS has limited resolution in the gradient color table");
+#else
QFETCH(QGradientStops, stops);
QImage a(64, 8, QImage::Format_ARGB32_Premultiplied);
b = b.mirrored(true);
QCOMPARE(a, b);
-}
#endif
+}
void tst_QPainter::gradientInterpolation()
{
}
-//Only Mac/Cocoa supports sub pixel positions in raster engine currently
-#ifdef Q_OS_MAC
void tst_QPainter::drawText_subPixelPositionsInRaster_qtbug5053()
{
- QFontMetricsF fm(qApp->font());
+#if !defined(Q_OS_MAC)
+ QSKIP("Only Mac supports sub pixel positions in raster engine currently");
+#endif
+ QFontMetricsF fm(qApp->font());
QImage baseLine(fm.width(QChar::fromLatin1('e')), fm.height(), QImage::Format_RGB32);
baseLine.fill(Qt::white);
QVERIFY(foundDifferentRasterization);
}
-#endif
void tst_QPainter::drawPointScaled()
{
private slots:
void getSetCheck();
// Add your testfunctions and testdata create functions here
-#ifdef Q_WS_WIN
void testPageSize();
-#endif
void testPageRectAndPaperRect();
void testPageRectAndPaperRect_data();
void testSetOptions();
void testMargins_data();
void testMargins();
-#ifdef Q_OS_WIN
void testNonExistentPrinter();
-#endif // Q_OS_WIN
void testPageSetupDialog();
void testMulitpleSets_data();
void testMulitpleSets();
}
}
-// QPrinter::winPageSize() does not exist for non-Windows platforms.
-#ifdef Q_WS_WIN
void tst_QPrinter::testPageSize()
{
+#ifndef Q_OS_WIN
+ QSKIP("QPrinter::winPageSize() does not exist for non-Windows platforms");
+#else
QPrinter prn;
prn.setPageSize(QPrinter::Letter);
prn.setWinPageSize(DMPAPER_A4);
MYCOMPARE(prn.winPageSize(), DMPAPER_A4);
MYCOMPARE(prn.pageSize(), QPrinter::A4);
-}
#endif
+}
void tst_QPrinter::testPageRectAndPaperRect_data()
{
delete painter;
}
-#ifdef Q_OS_WIN
void tst_QPrinter::testNonExistentPrinter()
{
+#ifndef Q_OS_WIN
+ QSKIP("QPrinter::testNonExistentPrinter() is not relevant for this platform");
+#else
QPrinter printer;
QPainter painter;
QCOMPARE(printer.printEngine()->metric(QPaintDevice::PdmPhysicalDpiY), 0);
QVERIFY(!painter.begin(&printer));
+#endif
}
-#endif // Q_OS_WIN
void tst_QPrinter::testMulitpleSets_data()
{
void initTestCase();
#else
private slots:
-#if defined(Q_OS_UNIX) || defined(Q_OS_WIN32)
void testForDefaultPrinter();
void testForPrinters();
-#endif
void testForPaperSizes();
void testConstructors();
void testAssignment();
#endif
}
-#if defined(Q_OS_UNIX) || defined(Q_OS_WIN32)
void tst_QPrinterInfo::testForDefaultPrinter()
{
+#if defined(Q_OS_UNIX) || defined(Q_OS_WIN32)
# ifdef Q_OS_WIN32
if (QHostInfo::localHostName() == "fantomet" || QHostInfo::localHostName() == "bobo") {
QWARN("Test is hardcoded to \"fantomet\" and \"bobo\" on Windows and may fail");
}
if (!found && defSysPrinter != "") QFAIL("No default printer reported by Qt, although there is one");
-}
+#else
+ QSKIP("Test doesn't work on non-Unix");
#endif
+}
-#if defined(Q_OS_UNIX) || defined(Q_OS_WIN32)
void tst_QPrinterInfo::testForPrinters()
{
+#if defined(Q_OS_UNIX) || defined(Q_OS_WIN32)
# ifdef Q_OS_WIN32
if (QHostInfo::localHostName() == "fantomet" || QHostInfo::localHostName() == "bobo") {
QWARN("Test is hardcoded to \"fantomet\" and \"bobo\" on Windows and may fail");
QFAIL(qPrintable(QString("Printer '%1' reported by system, but not reported by Qt").arg(sysPrinters.at(i))));
}
}
-}
+#else
+ QSKIP("Test doesn't work on non-Unix");
#endif
+}
void tst_QPrinterInfo::testForPaperSizes()
{
void cleanup();
private slots:
void getSetCheck();
-#ifndef Q_WS_WIN
void exactMatch();
-#endif
void compare();
void resolve();
void resetFont();
void isCopyOf();
-#ifdef Q_WS_X11
void setFontRaw();
-#endif
void italicOblique();
void insertAndRemoveSubstitutions();
void serializeSpacing();
void lastResortFont();
-#if defined(Q_WS_MAC)
void styleName();
-#endif
#ifdef QT_BUILD_INTERNAL
void defaultFamily_data();
void defaultFamily();
// This will be executed immediately after each test is run.
}
-// Exact matching on windows misses a lot because of the sample chars.
-#ifndef Q_WS_WIN
void tst_QFont::exactMatch()
{
QFont font;
font = QFont( "BogusFont", 33 );
QVERIFY( !font.exactMatch() );
+#ifdef Q_WS_WIN
+ QSKIP("Exact matching on windows misses a lot because of the sample chars");
+#endif
+
#ifdef Q_WS_X11
QVERIFY(QFont("sans").exactMatch());
QVERIFY(QFont("sans-serif").exactMatch());
}
}
}
-#endif
void tst_QFont::italicOblique()
{
QVERIFY(!font3.isCopyOf(font));
}
-#ifdef Q_WS_X11
void tst_QFont::setFontRaw()
{
+#ifndef Q_WS_X11
+ QSKIP("Only tested on X11");
+#else
QFont f;
f.setRawName("-*-fixed-bold-r-normal--0-0-*-*-*-0-iso8859-1");
// qDebug("font family: %s", f.family().utf8());
if (!found)
QSKIP("Fixed font not available.");
QCOMPARE(QFontInfo(f).family().left(5).toLower(), QString("fixed"));
-}
#endif
+}
void tst_QFont::insertAndRemoveSubstitutions()
{
QVERIFY(!font.lastResortFont().isEmpty());
}
-#if defined(Q_WS_MAC)
void tst_QFont::styleName()
{
+#if !defined(Q_WS_MAC)
+ QSKIP("Only tested on Mac");
+#else
QFont font("Helvetica Neue");
font.setStyleName("UltraLight");
QCOMPARE(QFontInfo(font).styleName(), QString("UltraLight"));
-}
#endif
+}
#ifdef QT_BUILD_INTERNAL
Q_DECLARE_METATYPE(QFont::StyleHint)
void styles_data();
void styles();
-#ifndef Q_WS_QWS
void fixedPitch_data();
void fixedPitch();
-#endif
#ifdef Q_WS_MAC
void trickyFonts_data();
}
}
-// fixedPitch not implemented for Qtopia Core.
-#ifndef Q_WS_QWS
void tst_QFontDatabase::fixedPitch_data()
{
QTest::addColumn<QString>("font");
void tst_QFontDatabase::fixedPitch()
{
+#ifdef Q_WS_QWS
+ QSKIP("fixedPitch not implemented for Qtopia Core");
+#endif
QFETCH(QString, font);
QFETCH(bool, fixedPitch);
QFontInfo fi(qfont);
QCOMPARE(fi.fixedPitch(), fixedPitch);
}
-#endif
#ifdef Q_WS_MAC
void tst_QFontDatabase::trickyFonts_data()
void cleanup();
private slots:
void getSetCheck();
-#ifdef Q_WS_X11
void lineBreaking();
-#endif
void simpleBoundingRect();
-#ifndef Q_WS_MAC
void threeLineBoundingRect();
-#endif
void boundingRectWithLongLineAndNoWrap();
void forcedBreaks();
-#ifndef Q_WS_MAC
void breakAny();
void noWrap();
-#endif
void cursorToXForInlineObjects();
void cursorToXForSetColumns();
void defaultWordSeparators_data();
void cursorMovementFromInvalidPositions();
void cursorMovementInsideSpaces();
void charWordStopOnLineSeparator();
-#ifndef Q_WS_MAC
void xToCursorAtEndOfLine();
-#endif
void boundingRectTopLeft();
void charStopForSurrogatePairs();
-#ifndef Q_WS_MAC
void tabStops();
-#endif
void integerOverflow();
void testDefaultTabs();
void testTabs();
testFont = QFont();
}
-#ifdef Q_WS_X11
void tst_QTextLayout::lineBreaking()
{
+#if defined(Q_WS_X11)
struct Breaks {
const char *utf8;
uchar breaks[32];
QCOMPARE(b->breaks[i], (uchar)0xff);
++b;
}
-}
+#else
+ QSKIP("This test can not be run on non-X11 platforms");
#endif
+}
void tst_QTextLayout::simpleBoundingRect()
{
QCOMPARE(layout.boundingRect(), QRectF(0, 0, width, QFontMetrics(testFont).height()));
}
-// QTestFontEngine on the mac does not support logclusters at the moment.
-#ifndef Q_WS_MAC
void tst_QTextLayout::threeLineBoundingRect()
{
+#if defined(Q_WS_MAC)
+ QSKIP("QTestFontEngine on the mac does not support logclusters at the moment");
+#endif
/* stricter check. break text into three lines */
QString firstWord("hello");
QCOMPARE(layout.boundingRect(), QRectF(0, 0, longestLine, y + 1));
}
-#endif
void tst_QTextLayout::boundingRectWithLongLineAndNoWrap()
{
QCOMPARE(line.xToCursor(0), line.textStart());
}
-// QTestFontEngine on the mac does not support logclusters at the moment.
-#ifndef Q_WS_MAC
void tst_QTextLayout::breakAny()
{
+#if defined(Q_WS_MAC)
+ QSKIP("QTestFontEngine on the mac does not support logclusters at the moment");
+#endif
QString text = "ABCD";
QTextLayout layout(text, testFont);
layout.endLayout();
}
-#endif
-// QTestFontEngine on the mac does not support logclusters at the moment.
-#ifndef Q_WS_MAC
void tst_QTextLayout::noWrap()
{
+#if defined(Q_WS_MAC)
+ QSKIP("QTestFontEngine on the mac does not support logclusters at the moment");
+#endif
QString text = "AB CD";
QTextLayout layout(text, testFont);
layout.endLayout();
}
-#endif
void tst_QTextLayout::cursorToXForInlineObjects()
{
QVERIFY(attrs[1].charStop);
}
-// QTestFontEngine on the mac does not support logclusters at the moment.
-#ifndef Q_WS_MAC
void tst_QTextLayout::xToCursorAtEndOfLine()
{
+#if defined(Q_WS_MAC)
+ QSKIP("QTestFontEngine on the mac does not support logclusters at the moment");
+#endif
QString text = "FirstLine SecondLine";
text.replace('\n', QChar::LineSeparator);
line = layout.lineAt(1);
QCOMPARE(line.xToCursor(100000), 20);
}
-#endif
void tst_QTextLayout::boundingRectTopLeft()
{
QVERIFY(attrs[3].charStop);
}
-// QTestFontEngine on the mac does not support logclusters at the moment.
-#ifndef Q_WS_MAC
void tst_QTextLayout::tabStops()
{
+#if defined(Q_WS_MAC)
+ QSKIP("QTestFontEngine on the mac does not support logclusters at the moment");
+#endif
QString txt("Hello there\tworld");
QTextLayout layout(txt, testFont);
layout.beginLayout();
layout.endLayout();
}
-#endif
void tst_QTextLayout::integerOverflow()
{
void init();
void cleanup();
private slots:
-#ifdef Q_WS_X11
void devanagari();
void bengali();
void gurmukhi();
void khmer();
void linearB();
void controlInSyllable_qtbug14204();
-#endif
-#if (defined(Q_WS_MAC) && defined(QT_MAC_USE_COCOA)) || defined(Q_WS_X11)
void combiningMarks_qtbug15675();
-#endif
-#ifndef Q_WS_MAC
void mirroredChars_data();
void mirroredChars();
-#endif
private:
bool haveTestFonts;
}
#endif
-#ifdef Q_WS_X11
void tst_QTextScriptEngine::devanagari()
{
+#if defined(Q_WS_X11)
if (!haveTestFonts)
QSKIP("Test fonts are not available");
} else
QSKIP("couldn't find mangal");
}
-}
+#else
+ QSKIP("X11 specific test");
#endif
+}
-#ifdef Q_WS_X11
void tst_QTextScriptEngine::bengali()
{
+#if defined(Q_WS_X11)
if (!haveTestFonts)
QSKIP("Test fonts are not available");
} else
QSKIP("couldn't find Likhan");
}
-}
+#else
+ QSKIP("X11 specific test");
#endif
+}
-#ifdef Q_WS_X11
void tst_QTextScriptEngine::gurmukhi()
{
+#if defined(Q_WS_X11)
if (!haveTestFonts)
QSKIP("Test fonts are not available");
} else
QSKIP("couldn't find Lohit Punjabi");
}
-}
+#else
+ QSKIP("X11 specific test");
#endif
+}
-#ifdef Q_WS_X11
void tst_QTextScriptEngine::oriya()
{
+#if defined(Q_WS_X11)
if (!haveTestFonts)
QSKIP("Test fonts are not available");
}
} else
QSKIP("couldn't find utkal");
- }
-}
+ }
+#else
+ QSKIP("X11 specific test");
#endif
+}
-#ifdef Q_WS_X11
void tst_QTextScriptEngine::tamil()
{
+#if defined(Q_WS_X11)
if (!haveTestFonts)
QSKIP("Test fonts are not available");
} else
QSKIP("couldn't find AkrutiTml1");
}
-}
+#else
+ QSKIP("X11 specific test");
#endif
+}
-#ifdef Q_WS_X11
void tst_QTextScriptEngine::telugu()
{
+#if defined(Q_WS_X11)
if (!haveTestFonts)
QSKIP("Test fonts are not available");
} else
QSKIP("couldn't find Pothana2000");
}
-}
+#else
+ QSKIP("X11 specific test");
#endif
+}
-#ifdef Q_WS_X11
void tst_QTextScriptEngine::kannada()
{
+#if defined(Q_WS_X11)
{
if (QFontDatabase().families(QFontDatabase::Kannada).contains("Sampige")) {
QFont f("Sampige");
} else
QSKIP("couldn't find Tunga");
}
-}
+#else
+ QSKIP("X11 specific test");
#endif
+}
-#ifdef Q_WS_X11
void tst_QTextScriptEngine::malayalam()
{
+#if defined(Q_WS_X11)
if (!haveTestFonts)
QSKIP("Test fonts are not available");
} else
QSKIP("couldn't find Rachana");
}
-}
+#else
+ QSKIP("X11 specific test");
#endif
+}
-#ifdef Q_WS_X11
void tst_QTextScriptEngine::sinhala()
{
+#if defined(Q_WS_X11)
if (!haveTestFonts)
QSKIP("Test fonts are not available");
} else
QSKIP("couldn't find Malithi Web");
}
-}
+#else
+ QSKIP("X11 specific test");
#endif
+}
-#ifdef Q_WS_X11
void tst_QTextScriptEngine::khmer()
{
+#if defined(Q_WS_X11)
if (!haveTestFonts)
QSKIP("Test fonts are not available");
} else
QSKIP("couldn't find Khmer OS");
}
-}
+#else
+ QSKIP("X11 specific test");
#endif
+}
-#ifdef Q_WS_X11
void tst_QTextScriptEngine::linearB()
{
+#if defined(Q_WS_X11)
if (!haveTestFonts)
QSKIP("Test fonts are not available");
} else
QSKIP("couldn't find Penuturesu");
}
-}
+#else
+ QSKIP("X11 specific test");
#endif
+}
#if defined(Q_WS_X11)
static bool decomposedShaping( const QFont &f, const QChar &ch)
}
#endif
-#ifdef Q_WS_X11
void tst_QTextScriptEngine::greek()
{
+#if defined(Q_WS_X11)
if (!haveTestFonts)
QSKIP("Test fonts are not available");
} else
QSKIP("couldn't find SBL_grk");
}
-}
+#else
+ QSKIP("X11 specific test");
#endif
+}
-#if defined(Q_WS_X11)
void tst_QTextScriptEngine::controlInSyllable_qtbug14204()
{
+#if defined(Q_WS_X11)
QString s;
s.append(QChar(0x0915));
s.append(QChar(0x094d));
QVERIFY(e->layoutData->items[0].num_glyphs == 2);
QVERIFY(e->layoutData->glyphLayout.advances_x[1] != 0);
-}
+#else
+ QSKIP("X11 specific test");
#endif
+}
-#if (defined(Q_WS_MAC) && defined(QT_MAC_USE_COCOA)) || defined(Q_WS_X11)
void tst_QTextScriptEngine::combiningMarks_qtbug15675()
{
#if defined(Q_WS_MAC)
QVERIFY(e->layoutData->items[0].num_glyphs == 3);
QVERIFY(e->layoutData->glyphLayout.advances_x[1] == 0);
+#else
+ QSKIP("X11/Mac specific test");
#endif
}
-#endif
-#ifndef Q_WS_MAC
void tst_QTextScriptEngine::mirroredChars_data()
{
QTest::addColumn<int>("hintingPreference");
void tst_QTextScriptEngine::mirroredChars()
{
+#if defined(Q_WS_MAC)
+ QSKIP("Not supported on Mac");
+#endif
QFETCH(int, hintingPreference);
QFont font;
QCOMPARE(glyphLayout.glyphs[1], leftParenthesis);
}
}
-#endif
QTEST_MAIN(tst_QTextScriptEngine)
#include "tst_qtextscriptengine.moc"
void qtimerList();
void containerTypedefs();
void forwardDeclared();
-#if defined(Q_ALIGNOF) && defined(Q_DECL_ALIGN)
void alignment();
-#endif
void QTBUG13079_collectionInsideCollection();
void foreach_2();
testAssociativeContainerAlignment<QHash<Aligned128, Aligned4> >();
testAssociativeContainerAlignment<QHash<Aligned128, Aligned128> >();
}
+
+#else
+void tst_Collections::alignment()
+{
+ QSKIP("Compiler doesn't support necessary extension keywords");
+}
#endif
#ifndef QT_NO_TEMPLATE_TEMPLATE_PARAMETERS
void abstractScrollAreaTest();
void scrollAreaTest();
- // Accessible table1 interface is no longer supported on X11,
- // where it has been replaced by table2 interface.
-#ifndef Q_OS_UNIX
void listViewTest();
void treeWidgetTest();
void tableWidgetTest();
void tableViewTest();
-#else
+
void table2ListTest();
void table2TreeTest();
void table2TableTest();
-#endif
void calendarWidgetTest();
void dockWidgetTest();
QTestAccessibility::clearEvents();
}
-// Accessible table1 interface is no longer supported on X11,
-// where it has been replaced by table2 interface.
-#ifndef Q_OS_UNIX
-
void tst_QAccessibility::listViewTest()
{
+#if defined(Q_OS_UNIX)
+ QSKIP( "Accessible table1 interface is no longer supported on X11.");
+#else
{
QListView listView;
QAccessibleInterface *iface = QAccessible::queryAccessibleInterface(&listView);
delete iface;
}
QTestAccessibility::clearEvents();
+#endif
}
void tst_QAccessibility::treeWidgetTest()
{
+#if defined(Q_OS_UNIX)
+ QSKIP( "Accessible table1 interface is no longer supported on X11.");
+#else
QWidget *w = new QWidget;
QTreeWidget *tree = new QTreeWidget(w);
QHBoxLayout *l = new QHBoxLayout(w);
delete w;
QTestAccessibility::clearEvents();
+#endif
}
void tst_QAccessibility::tableWidgetTest()
{
+#if defined(Q_OS_UNIX)
+ QSKIP( "Accessible table1 interface is no longer supported on X11.");
+#else
{
QWidget *topLevel = new QWidget;
QTableWidget *w = new QTableWidget(8,4,topLevel);
delete topLevel;
}
QTestAccessibility::clearEvents();
+#endif
}
class QtTestTableModel: public QAbstractTableModel
void tst_QAccessibility::tableViewTest()
{
+#if defined(Q_OS_UNIX)
+ QSKIP( "Accessible table1 interface is no longer supported on X11.");
+#else
{
QtTestTableModel *model = new QtTestTableModel(3, 4);
QTableView *w = new QTableView();
delete model;
}
QTestAccessibility::clearEvents();
+#endif
}
-#else
-// Test accessible table2 interface on unix
-
void tst_QAccessibility::table2ListTest()
{
+#if !defined(Q_OS_UNIX)
+ QSKIP( "Accessible table2 interface is currently only supported on X11.");
+#else
QListWidget *listView = new QListWidget;
listView->addItem("Oslo");
listView->addItem("Berlin");
delete iface;
delete listView;
QTestAccessibility::clearEvents();
+#endif
}
void tst_QAccessibility::table2TreeTest()
{
+#if !defined(Q_OS_UNIX)
+ QSKIP( "Accessible table2 interface is currently only supported on X11.");
+#else
QTreeWidget *treeView = new QTreeWidget;
treeView->setColumnCount(2);
QTreeWidgetItem *header = new QTreeWidgetItem;
delete iface;
QTestAccessibility::clearEvents();
+#endif
}
void tst_QAccessibility::table2TableTest()
{
+#if !defined(Q_OS_UNIX)
+ QSKIP( "Accessible table2 interface is currently only supported on X11.");
+#else
QTableWidget *tableView = new QTableWidget(3, 3);
tableView->setColumnCount(3);
QStringList hHeader;
delete tableView;
QTestAccessibility::clearEvents();
-}
#endif
+}
void tst_QAccessibility::calendarWidgetTest()
{
private slots:
void checkReason_Tab();
void checkReason_ShiftTab();
-#ifndef Q_OS_WIN32
void checkReason_BackTab();
-#endif
void checkReason_Popup();
void checkReason_focusWidget();
void checkReason_Shortcut();
/*!
In this test we verify that the Qt::KeyBacktab key is handled in a qfocusevent
*/
-// Backtab is not supported on Windows.
-#ifndef Q_OS_WIN32
void tst_QFocusEvent::checkReason_BackTab()
{
+#ifdef Q_OS_WIN32 // key is not supported on Windows
+ QSKIP( "Backtab is not supported on Windows");
+#else
initWidget();
QVERIFY( childFocusWidgetOne->hasFocus() );
QVERIFY( childFocusWidgetTwo->hasFocus() );
QCOMPARE( childFocusWidgetOne->focusOutEventReason, int(Qt::BacktabFocusReason) );
QCOMPARE( childFocusWidgetTwo->focusInEventReason, int(Qt::BacktabFocusReason) );
-}
#endif
+}
void tst_QFocusEvent::checkReason_Popup()
{
void ioPutToFileFromSocket();
void ioPutToFileFromLocalSocket_data();
void ioPutToFileFromLocalSocket();
-#if !defined(QT_NO_PROCESS) && !defined(Q_OS_WINCE)
+#ifndef QT_NO_PROCESS
void ioPutToFileFromProcess_data();
void ioPutToFileFromProcess();
#endif
}
// Currently no stdin/out supported for Windows CE.
-#if !defined(QT_NO_PROCESS) && !defined(Q_OS_WINCE)
+#ifndef QT_NO_PROCESS
void tst_QNetworkReply::ioPutToFileFromProcess_data()
{
putToFile_data();
void tst_QNetworkReply::ioPutToFileFromProcess()
{
+#if defined(Q_OS_WINCE)
+ QSKIP("Currently no stdin/out supported for Windows CE");
+#else
#ifdef Q_OS_WIN
if (qstrcmp(QTest::currentDataTag(), "small") == 0)
QSKIP("When passing a CR-LF-LF sequence through Windows stdio, it gets converted, "
QCOMPARE(file.size(), qint64(data.size()));
QByteArray contents = file.readAll();
QCOMPARE(contents, data);
+#endif
}
#endif
void simpleConnectToIMAP();
void udpLoopbackTest();
void udpIPv6LoopbackTest();
-#ifndef Q_OS_AIX
void broadcastTest();
-#endif
void serverTest();
void udpLoopbackPerformance();
void tcpLoopbackPerformance();
void setSocketDescriptor();
void invalidSend();
void receiveUrgentData();
-#ifndef Q_OS_WIN
void tooManySockets();
-#endif
};
tst_PlatformSocketEngine::tst_PlatformSocketEngine()
}
//---------------------------------------------------------------------------
-
-#ifndef Q_OS_AIX
void tst_PlatformSocketEngine::broadcastTest()
{
+#ifdef Q_OS_AIX
+ QSKIP("Broadcast does not work on darko");
+#endif
PLATFORMSOCKETENGINE broadcastSocket;
// Initialize a regular Udp socket
QVERIFY(broadcastSocket.readDatagram(response.data(), response.size())
== response.size());
QCOMPARE(response, trollMessage);
+
}
-#endif
//---------------------------------------------------------------------------
void tst_PlatformSocketEngine::serverTest()
}
//---------------------------------------------------------------------------
-
-// Certain windows machines suffocate and spend too much time in this test.
-#ifndef Q_OS_WIN
void tst_PlatformSocketEngine::tooManySockets()
{
+#if defined Q_OS_WIN
+ QSKIP("Certain windows machines suffocate and spend too much time in this test.");
+#endif
QList<PLATFORMSOCKETENGINE *> sockets;
PLATFORMSOCKETENGINE *socketLayer = 0;
for (;;) {
qDeleteAll(sockets);
}
-#endif
//---------------------------------------------------------------------------
void tst_PlatformSocketEngine::bind()
void socketsInThreads();
void waitForReadyReadInASlot();
void remoteCloseError();
-#ifndef Q_OS_VXWORKS
void openMessageBoxInErrorSlot();
-#endif
#ifndef Q_OS_WIN
void connectToLocalHostNoService();
#endif
void waitForConnectedInHostLookupSlot();
-#if !defined(Q_OS_WIN) && !defined(Q_OS_VXWORKS)
void waitForConnectedInHostLookupSlot2();
-#endif
void readyReadSignalsAfterWaitForReadyRead();
#ifdef Q_OS_LINUX
void linuxKernelBugLocalSocket();
void connectionRefused();
void suddenRemoteDisconnect_data();
void suddenRemoteDisconnect();
-#ifndef Q_OS_VXWORKS
void connectToMultiIP();
-#endif
void moveToThread0();
void increaseReadBufferSize();
void taskQtBug5799ConnectionErrorWaitForConnected();
void downloadBigFileSlot();
void recursiveReadyReadSlot();
void waitForReadyReadInASlotSlot();
-#ifndef Q_OS_VXWORKS
void messageBoxSlot();
-#endif
void hostLookupSlot();
void abortiveClose_abortSlot();
void remoteCloseErrorSlot();
static_cast<QTcpSocket *>(sender())->close();
}
-// VxWorks has no default gui
-#ifndef Q_OS_VXWORKS
void tst_QTcpSocket::messageBoxSlot()
{
+#if !defined(Q_OS_VXWORKS) // no gui
QTcpSocket *socket = qobject_cast<QTcpSocket *>(sender());
socket->deleteLater();
QMessageBox box;
// Fire a non-0 singleshot to leave time for the delete
QTimer::singleShot(250, this, SLOT(exitLoopSlot()));
-}
#endif
-
+}
//----------------------------------------------------------------------------------
-
-// VxWorks has no default gui
-#ifndef Q_OS_VXWORKS
void tst_QTcpSocket::openMessageBoxInErrorSlot()
{
+#if defined(Q_OS_VXWORKS) // no gui
+ QSKIP("no default gui available on VxWorks");
+#else
QTcpSocket *socket = newSocket();
QPointer<QTcpSocket> p(socket);
connect(socket, SIGNAL(error(QAbstractSocket::SocketError)), this, SLOT(messageBoxSlot()));
socket->connectToHost("hostnotfoundhostnotfound.troll.no", 9999); // Host not found, fyi
enterLoop(30);
QVERIFY(!p);
-}
#endif
+}
//----------------------------------------------------------------------------------
#ifndef Q_OS_WIN
};
//----------------------------------------------------------------------------------
-
-#if !defined(Q_OS_WIN) && !defined(Q_OS_VXWORKS)
void tst_QTcpSocket::waitForConnectedInHostLookupSlot2()
{
+#if defined(Q_OS_WIN) || defined(Q_OS_VXWORKS)
+ QSKIP("waitForConnectedInHostLookupSlot2 is not run on Windows and VxWorks");
+#else
+
Foo foo;
QPushButton top("Go", 0);
top.show();
QVERIFY(foo.attemptedToConnect);
QCOMPARE(foo.count, 1);
-}
#endif
+}
//----------------------------------------------------------------------------------
void tst_QTcpSocket::readyReadSignalsAfterWaitForReadyRead()
//----------------------------------------------------------------------------------
-// VxSim in standard config doesn't even run a DNS resolver.
-#ifndef Q_OS_VXWORKS
void tst_QTcpSocket::connectToMultiIP()
{
QSKIP("TODO: setup DNS in the new network");
-
+#if defined(Q_OS_VXWORKS)
+ QSKIP("VxSim in standard config doesn't even run a DNS resolver");
+#else
QFETCH_GLOBAL(bool, ssl);
if (ssl)
return;
QCOMPARE(socket->error(), QAbstractSocket::SocketTimeoutError);
delete socket;
-}
#endif
+}
//----------------------------------------------------------------------------------
void tst_QTcpSocket::moveToThread0()
private slots:
void constructing();
void unconnectedServerAndClientTest();
-#ifndef Q_OS_AIX
void broadcasting();
-#endif
void loop_data();
void loop();
void ipv6Loop_data();
void writeDatagramToNonExistingPeer();
void writeToNonExistingPeer_data();
void writeToNonExistingPeer();
-#if !defined(Q_OS_WINCE) && !defined(QT_NO_PROCESS)
+#ifndef QT_NO_PROCESS
void outOfProcessConnectedClientServerTest();
void outOfProcessUnconnectedClientServerTest();
#endif
//----------------------------------------------------------------------------------
-#ifndef Q_OS_AIX
void tst_QUdpSocket::broadcasting()
{
QFETCH_GLOBAL(bool, setProxy);
if (proxyType == QNetworkProxy::Socks5Proxy)
QSKIP("With socks5 Broadcast is not supported.");
}
+#ifdef Q_OS_AIX
+ QSKIP("Broadcast does not work on darko");
+#endif
const char *message[] = {"Yo mista", "", "Yo", "Wassap"};
QList<QHostAddress> broadcastAddresses;
}
}
}
-#endif
//----------------------------------------------------------------------------------
QCOMPARE(int(sConnected.state()), int(QUdpSocket::ConnectedState));
}
-// This test depends on reading data from QProcess (not supported on Qt/WinCE).
-#if !defined(Q_OS_WINCE) && !defined(QT_NO_PROCESS)
+#ifndef QT_NO_PROCESS
void tst_QUdpSocket::outOfProcessConnectedClientServerTest()
{
+#if defined(Q_OS_WINCE)
+ QSKIP("This test depends on reading data from QProcess (not supported on Qt/WinCE).");
+#endif
QProcess serverProcess;
serverProcess.start(QLatin1String("clientserver/clientserver server 1 1"),
QIODevice::ReadWrite | QIODevice::Text);
}
#endif
-// This test depends on reading data from QProcess (not supported on Qt/WinCE).
-#if !defined(Q_OS_WINCE) && !defined(QT_NO_PROCESS)
+#ifndef QT_NO_PROCESS
void tst_QUdpSocket::outOfProcessUnconnectedClientServerTest()
{
+#if defined(Q_OS_WINCE)
+ QSKIP("This test depends on reading data from QProcess (not supported on Qt/WinCE).");
+#endif
QProcess serverProcess;
serverProcess.start(QLatin1String("clientserver/clientserver server 1 1"),
QIODevice::ReadWrite | QIODevice::Text);
**
****************************************************************************/
-
#include <QtCore/QtCore>
#include <QtTest/QtTest>
#include "baseclass.h"
#include "derivedclass.h"
-#if defined(Q_CC_HPACC)
-# define DONT_TEST_TEMPLATE_CONSTRUCTORS
-# define DONT_TEST_CONSTRUCTOR_SPECIALIZATION
-# define DONT_TEST_DATASTREAM_DETECTION
-#endif
-
-#if defined(Q_CC_SUN)
-# define DONT_TEST_STL_SORTING
-#endif
-
QT_USE_NAMESPACE
class tst_Compiler : public QObject
{
Q_OBJECT
-
private slots:
void template_methods();
-#ifndef DONT_TEST_TEMPLATE_CONSTRUCTORS
void template_constructors();
-#endif
void template_subclasses();
void methodSpecialization();
-#ifndef DONT_TEST_CONSTRUCTOR_SPECIALIZATION
void constructorSpecialization();
-#endif
void staticTemplateMethods();
void staticTemplateMethodSpecialization();
-#ifndef DONT_TEST_DATASTREAM_DETECTION
void detectDataStream();
-#endif
void detectEnums();
void overrideCFunction();
-#ifndef DONT_TEST_STL_SORTING
void stdSortQList();
void stdSortQVector();
-#endif
void templateCallOrder();
void virtualFunctionNoLongerPureVirtual();
void charSignedness() const;
void staticConstUnionWithInitializerList() const;
};
+#if defined(Q_CC_HPACC)
+# define DONT_TEST_TEMPLATE_CONSTRUCTORS
+# define DONT_TEST_CONSTRUCTOR_SPECIALIZATION
+# define DONT_TEST_DATASTREAM_DETECTION
+#endif
+
+#if defined(Q_CC_SUN)
+# define DONT_TEST_STL_SORTING
+#endif
+
class TemplateMethodClass
{
public:
QCOMPARE(t2.i, 42);
QCOMPARE(t3.i, 42);
}
+#else
+void tst_Compiler::template_constructors()
+{ QSKIP("Compiler doesn't do template constructors"); }
#endif
template <typename T>
QCOMPARE(t2.i, 42);
QCOMPARE(t3.i, 42);
}
+#else
+void tst_Compiler::constructorSpecialization()
+{ QSKIP("Compiler doesn't do constructor specialization"); }
#endif
class StaticTemplateClass
QVERIFY(QtTestInternal::getSaveOperator<MyString>() != 0);
QVERIFY(QtTestInternal::getSaveOperator<Qxxx>() == 0);
}
+#else
+void tst_Compiler::detectDataStream()
+{ QSKIP("Compiler doesn't evaluate templates correctly"); }
#endif
enum Enum1 { Foo = 0, Bar = 1 };
QVERIFY(QTestTypeInfo<Qt::MatchFlag>::IsEnum);
QVERIFY(!QTestTypeInfo<Qt::MatchFlags>::IsEnum);
}
-
static int indicator = 0;
-
// this is a silly C function
extern "C" {
void someCFunc(void *) { indicator = 42; }
QCOMPARE(strvec.value(0), QString("a"));
QCOMPARE(strvec.value(1), QString("b"));
}
+#else
+void tst_Compiler::stdSortQList()
+{ QSKIP("Compiler's STL broken"); }
+void tst_Compiler::stdSortQVector()
+{ QSKIP("Compiler's STL broken"); }
#endif
// the C func will set it to 1, the template to 2
void slotWithException() throw(MyStruct);
void dontStripNamespaces();
-#if !defined(MOC_CROSS_COMPILED) && defined(Q_OS_LINUX) && defined(Q_CC_GNU) && !defined(QT_NO_PROCESS)
void oldStyleCasts();
void warnOnExtraSignalSlotQualifiaction();
-#endif
void uLongLong();
-#if !defined(MOC_CROSS_COMPILED) && defined(Q_OS_LINUX) && defined(Q_CC_GNU) && !defined(QT_NO_PROCESS)
void inputFileNameWithDotsButNoExtension();
-#endif
void userProperties();
void supportConstSignals();
void task87883();
void slotsWithVoidTemplate();
void structQObject();
void namespacedFlags();
-#if !defined(MOC_CROSS_COMPILED) && defined(Q_OS_LINUX) && defined(Q_CC_GNU) && !defined(QT_NO_PROCESS)
void warnOnMultipleInheritance();
void forgottenQInterface();
-#endif
void os9Newline();
void winNewline();
void escapesInStringLiterals();
-#if !defined(MOC_CROSS_COMPILED) && defined(Q_OS_UNIX) && !defined(QT_NO_PROCESS)
void frameworkSearchPath();
-#endif
void cstyleEnums();
-#if defined(Q_OS_LINUX) && defined(Q_CC_GNU) && !defined(QT_NO_PROCESS)
void defineMacroViaCmdline();
-#endif
void invokable();
void singleFunctionKeywordSignalAndSlot();
-#if !defined(MOC_CROSS_COMPILED) && defined(Q_OS_LINUX) && defined(Q_CC_GNU) && !defined(QT_NO_PROCESS)
void templateGtGt();
-#endif
void qprivateslots();
void qprivateproperties();
void inlineSlotsWithThrowDeclaration();
-#if !defined(MOC_CROSS_COMPILED) && defined(Q_OS_LINUX) && defined(Q_CC_GNU) && !defined(QT_NO_PROCESS)
void warnOnPropertyWithoutREAD();
-#endif
void constructors();
void typenameWithUnsigned();
-#if !defined(MOC_CROSS_COMPILED) && defined(Q_OS_LINUX) && defined(Q_CC_GNU) && !defined(QT_NO_PROCESS)
void warnOnVirtualSignal();
-#endif
void QTBUG5590_dummyProperty();
void QTBUG12260_defaultTemplate();
-#if !defined(MOC_CROSS_COMPILED) && defined(Q_OS_LINUX) && defined(Q_CC_GNU) && !defined(QT_NO_PROCESS)
void notifyError();
-#endif
void QTBUG17635_invokableAndProperty();
void revisions();
-#ifndef MOC_CROSS_COMPILED
void warnings_data();
void warnings();
-#endif
void privateClass();
void cxx11Enums_data();
void cxx11Enums();
QCOMPARE(receiver.intCallCount, 1);
}
-// Only tested on linux/gcc. Not tested when cross-compiled.
-#if !defined(MOC_CROSS_COMPILED) && defined(Q_OS_LINUX) && defined(Q_CC_GNU) && !defined(QT_NO_PROCESS)
void tst_Moc::oldStyleCasts()
{
+#ifdef MOC_CROSS_COMPILED
+ QSKIP("Not tested when cross-compiled");
+#endif
+#if defined(Q_OS_LINUX) && defined(Q_CC_GNU) && !defined(QT_NO_PROCESS)
QProcess proc;
proc.start("moc", QStringList(srcify("/oldstyle-casts.h")));
QVERIFY(proc.waitForFinished());
QVERIFY(proc.waitForFinished());
QCOMPARE(proc.exitCode(), 0);
QCOMPARE(QString::fromLocal8Bit(proc.readAllStandardError()), QString());
-}
+#else
+ QSKIP("Only tested on linux/gcc");
#endif
+}
-// Only tested on linux/gcc. Not tested when cross-compiled.
-#if !defined(MOC_CROSS_COMPILED) && defined(Q_OS_LINUX) && defined(Q_CC_GNU) && !defined(QT_NO_PROCESS)
void tst_Moc::warnOnExtraSignalSlotQualifiaction()
{
+#ifdef MOC_CROSS_COMPILED
+ QSKIP("Not tested when cross-compiled");
+#endif
+#if defined(Q_OS_LINUX) && defined(Q_CC_GNU) && !defined(QT_NO_PROCESS)
QProcess proc;
proc.start("moc", QStringList(srcify("extraqualification.h")));
QVERIFY(proc.waitForFinished());
QCOMPARE(mocWarning, QString(SRCDIR) +
QString("/extraqualification.h:53: Warning: Function declaration Test::badFunctionDeclaration contains extra qualification. Ignoring as signal or slot.\n") +
QString(SRCDIR) + QString("/extraqualification.h:56: Warning: parsemaybe: Function declaration Test::anotherOne contains extra qualification. Ignoring as signal or slot.\n"));
-}
+#else
+ QSKIP("Only tested on linux/gcc");
#endif
+}
void tst_Moc::uLongLong()
{
QVERIFY(idx != -1);
}
-// Only tested on linux/gcc. Not tested when cross-compiled.
-#if !defined(MOC_CROSS_COMPILED) && defined(Q_OS_LINUX) && defined(Q_CC_GNU) && !defined(QT_NO_PROCESS)
void tst_Moc::inputFileNameWithDotsButNoExtension()
{
+#ifdef MOC_CROSS_COMPILED
+ QSKIP("Not tested when cross-compiled");
+#endif
+#if defined(Q_OS_LINUX) && defined(Q_CC_GNU) && !defined(QT_NO_PROCESS)
QProcess proc;
proc.setWorkingDirectory(QString(SRCDIR) + "/task71021");
proc.start("moc", QStringList("../Header"));
QVERIFY(proc.waitForFinished());
QCOMPARE(QString::fromLocal8Bit(proc.readAllStandardError()), QString());
QCOMPARE(proc.exitCode(), 0);
-}
+#else
+ QSKIP("Only tested on linux/gcc");
#endif
+}
void tst_Moc::userProperties()
{
QCOMPARE(l, qvariant_cast<QList<Foo::Bar::Flags> >(baz.property("flagsList")));
}
-// Only tested on linux/gcc. Not tested when cross-compiled.
-#if !defined(MOC_CROSS_COMPILED) && defined(Q_OS_LINUX) && defined(Q_CC_GNU) && !defined(QT_NO_PROCESS)
void tst_Moc::warnOnMultipleInheritance()
{
+#ifdef MOC_CROSS_COMPILED
+ QSKIP("Not tested when cross-compiled");
+#endif
+#if defined(Q_OS_LINUX) && defined(Q_CC_GNU) && !defined(QT_NO_PROCESS)
QProcess proc;
QStringList args;
args << "-I" << qtIncludePath + "/QtGui"
QString mocWarning = QString::fromLocal8Bit(proc.readAllStandardError());
QCOMPARE(mocWarning, QString(SRCDIR) +
QString("/warn-on-multiple-qobject-subclasses.h:53: Warning: Class Bar inherits from two QObject subclasses QWindow and Foo. This is not supported!\n"));
-}
+#else
+ QSKIP("Only tested on linux/gcc");
#endif
+}
-// Only tested on linux/gcc. Not tested when cross-compiled.
-#if !defined(MOC_CROSS_COMPILED) && defined(Q_OS_LINUX) && defined(Q_CC_GNU) && !defined(QT_NO_PROCESS)
void tst_Moc::forgottenQInterface()
{
+#ifdef MOC_CROSS_COMPILED
+ QSKIP("Not tested when cross-compiled");
+#endif
+#if defined(Q_OS_LINUX) && defined(Q_CC_GNU) && !defined(QT_NO_PROCESS)
QProcess proc;
QStringList args;
args << "-I" << qtIncludePath + "/QtCore"
QString mocWarning = QString::fromLocal8Bit(proc.readAllStandardError());
QCOMPARE(mocWarning, QString(SRCDIR) +
QString("/forgotten-qinterface.h:55: Warning: Class Test implements the interface MyInterface but does not list it in Q_INTERFACES. qobject_cast to MyInterface will not work!\n"));
-}
+#else
+ QSKIP("Only tested on linux/gcc");
#endif
+}
void tst_Moc::os9Newline()
{
QByteArray("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\nb"));
}
-// Only tested on unix. Not tested when cross-compiled.
-#if !defined(MOC_CROSS_COMPILED) && defined(Q_OS_UNIX) && !defined(QT_NO_PROCESS)
void tst_Moc::frameworkSearchPath()
{
+#ifdef MOC_CROSS_COMPILED
+ QSKIP("Not tested when cross-compiled");
+#endif
+#if defined(Q_OS_UNIX) && !defined(QT_NO_PROCESS)
QStringList args;
args << "-F" << srcify(".")
<< srcify("interface-from-framework.h")
}
QCOMPARE(proc.exitCode(), 0);
QCOMPARE(proc.readAllStandardError(), QByteArray());
-}
+#else
+ QSKIP("Only tested/relevant on unixy platforms");
#endif
+}
void tst_Moc::cstyleEnums()
{
QCOMPARE(metaEnum.key(1), "Bar");
}
-// Only tested on linux/gcc. Not tested when cross-compiled.
-#if !defined(MOC_CROSS_COMPILED) && defined(Q_OS_LINUX) && defined(Q_CC_GNU) && !defined(QT_NO_PROCESS)
void tst_Moc::templateGtGt()
{
+#ifdef MOC_CROSS_COMPILED
+ QSKIP("Not tested when cross-compiled");
+#endif
+#if defined(Q_OS_LINUX) && defined(Q_CC_GNU) && !defined(QT_NO_PROCESS)
QProcess proc;
proc.start("moc", QStringList(srcify("template-gtgt.h")));
QVERIFY(proc.waitForFinished());
QVERIFY(!mocOut.isEmpty());
QString mocWarning = QString::fromLocal8Bit(proc.readAllStandardError());
QVERIFY(mocWarning.isEmpty());
-}
+#else
+ QSKIP("Only tested on linux/gcc");
#endif
+}
-// Only tested on linux/gcc.
-#if defined(Q_OS_LINUX) && defined(Q_CC_GNU) && !defined(QT_NO_PROCESS)
void tst_Moc::defineMacroViaCmdline()
{
+#if defined(Q_OS_LINUX) && defined(Q_CC_GNU) && !defined(QT_NO_PROCESS)
QProcess proc;
QStringList args;
QCOMPARE(proc.readAllStandardError(), QByteArray());
QByteArray mocOut = proc.readAllStandardOutput();
QVERIFY(!mocOut.isEmpty());
-}
+#else
+ QSKIP("Only tested on linux/gcc");
#endif
+}
void tst_Moc::invokable()
{
QVERIFY(mobj->indexOfSlot("e()") != -1);
}
-// Only tested on linux/gcc. Not tested when cross-compiled.
-#if !defined(MOC_CROSS_COMPILED) && defined(Q_OS_LINUX) && defined(Q_CC_GNU) && !defined(QT_NO_PROCESS)
void tst_Moc::warnOnPropertyWithoutREAD()
{
+#ifdef MOC_CROSS_COMPILED
+ QSKIP("Not tested when cross-compiled");
+#endif
+#if defined(Q_OS_LINUX) && defined(Q_CC_GNU) && !defined(QT_NO_PROCESS)
QProcess proc;
proc.start("moc", QStringList(srcify("warn-on-property-without-read.h")));
QVERIFY(proc.waitForFinished());
QString mocWarning = QString::fromLocal8Bit(proc.readAllStandardError());
QCOMPARE(mocWarning, QString(SRCDIR) +
QString("/warn-on-property-without-read.h:46: Warning: Property declaration foo has no READ accessor function. The property will be invalid.\n"));
-}
+#else
+ QSKIP("Only tested on linux/gcc");
#endif
+}
void tst_Moc::constructors()
{
QVERIFY(mobj->indexOfSlot("l(unsignedQImage)") != -1);
}
-// Only tested on linux/gcc. Not tested when cross-compiled.
-#if !defined(MOC_CROSS_COMPILED) && defined(Q_OS_LINUX) && defined(Q_CC_GNU) && !defined(QT_NO_PROCESS)
void tst_Moc::warnOnVirtualSignal()
{
+#ifdef MOC_CROSS_COMPILED
+ QSKIP("Not tested when cross-compiled");
+#endif
+#if defined(Q_OS_LINUX) && defined(Q_CC_GNU) && !defined(QT_NO_PROCESS)
QProcess proc;
proc.start("moc", QStringList(srcify("pure-virtual-signals.h")));
QVERIFY(proc.waitForFinished());
QString mocWarning = QString::fromLocal8Bit(proc.readAllStandardError());
QCOMPARE(mocWarning, QString(SRCDIR) + QString("/pure-virtual-signals.h:48: Warning: Signals cannot be declared virtual\n") +
QString(SRCDIR) + QString("/pure-virtual-signals.h:50: Warning: Signals cannot be declared virtual\n"));
-}
+#else
+ QSKIP("Only tested on linux/gcc");
#endif
+}
class QTBUG5590_DummyObject: public QObject
{
QVERIFY(QTBUG12260_defaultTemplate_Object::staticMetaObject.indexOfSlot("doAnotherThing(bool,bool)") != -1);
}
-// Only tested on linux/gcc. Not tested when cross-compiled.
-#if !defined(MOC_CROSS_COMPILED) && defined(Q_OS_LINUX) && defined(Q_CC_GNU) && !defined(QT_NO_PROCESS)
void tst_Moc::notifyError()
{
+#ifdef MOC_CROSS_COMPILED
+ QSKIP("Not tested when cross-compiled");
+#endif
+#if defined(Q_OS_LINUX) && defined(Q_CC_GNU) && !defined(QT_NO_PROCESS)
QProcess proc;
proc.start("moc", QStringList(srcify("error-on-wrong-notify.h")));
QVERIFY(proc.waitForFinished());
QString mocError = QString::fromLocal8Bit(proc.readAllStandardError());
QCOMPARE(mocError, QString(SRCDIR) +
QString("/error-on-wrong-notify.h:52: Error: NOTIFY signal 'fooChanged' of property 'foo' does not exist in class ClassWithWrongNOTIFY.\n"));
-}
+#else
+ QSKIP("Only tested on linux/gcc");
#endif
+}
class QTBUG_17635_InvokableAndProperty : public QObject
{
revisions_T<VersionTestNotify>();
}
-// Not tested when cross-compiled.
-#ifndef MOC_CROSS_COMPILED
void tst_Moc::warnings_data()
{
QTest::addColumn<QByteArray>("input");
void tst_Moc::warnings()
{
+#ifdef MOC_CROSS_COMPILED
+ QSKIP("Not tested when cross-compiled");
+#endif
QFETCH(QByteArray, input);
QFETCH(QStringList, args);
QFETCH(int, exitCode);
QCOMPARE(QString::fromLocal8Bit(proc.readAllStandardOutput()).trimmed(), expectedStdOut);
QCOMPARE(QString::fromLocal8Bit(proc.readAllStandardError()).trimmed(), expectedStdErr);
}
-#endif
class tst_Moc::PrivateClass : public QObject {
Q_PROPERTY(int someProperty READ someSlot WRITE someSlot2)
void showMaximized();
void showMinimized();
void showFullScreen();
-#if !defined(Q_OS_UNIX) && !defined(Q_OS_WINCE)
void showAsTool();
-#endif
-#ifndef Q_OS_WINCE
void toolDialogPosition();
-#endif
void deleteMainDefault();
void deleteInExec();
-#if !defined(QT_NO_EXCEPTIONS) && !defined(Q_OS_MAC) && !(defined(Q_OS_WINCE) && defined(_ARM_))
void throwInExec();
-#endif
void showSizeGrip();
void setVisible();
void reject();
QVERIFY(!dialog.isVisible());
}
-// Qt/X11: Skipped since activeWindow() is not respected by all window managers.
-// Qt/WinCE: No real support for Qt::Tool on WinCE.
-#if !defined(Q_OS_UNIX) && !defined(Q_OS_WINCE)
void tst_QDialog::showAsTool()
{
+#if defined(Q_OS_UNIX)
+ QSKIP("Qt/X11: Skipped since activeWindow() is not respected by all window managers");
+#elif defined(Q_OS_WINCE)
+ QSKIP("No real support for Qt::Tool on WinCE");
+#endif
ToolDialog dialog(testWidget);
testWidget->activateWindow();
dialog.exec();
QCOMPARE(dialog.wasActive(), false);
}
}
-#endif
// Verify that pos() returns the same before and after show()
// for a dialog with the Tool window type.
-// No real support for Qt::Tool on WinCE, so skip this test.
-#ifndef Q_OS_WINCE
void tst_QDialog::toolDialogPosition()
{
+#if defined(Q_OS_WINCE)
+ QSKIP("No real support for Qt::Tool on WinCE");
+#endif
QDialog dialog(0, Qt::Tool);
dialog.move(QPoint(100,100));
const QPoint beforeShowPosition = dialog.pos();
const QPoint afterShowPosition = dialog.pos();
QCOMPARE(afterShowPosition, beforeShowPosition);
}
-#endif
class Dialog : public QDialog
{
QCOMPARE(dialog->exec(), int(QDialog::Rejected));
}
-// Throwing exceptions in exec() is not supported on Mac or on WinCE/ARM.
-#if !defined(QT_NO_EXCEPTIONS) && !defined(Q_OS_MAC) && !(defined(Q_OS_WINCE) && defined(_ARM_))
+#ifndef QT_NO_EXCEPTIONS
class QDialogTestException : public std::exception { };
class ExceptionDialog : public QDialog
void tst_QDialog::throwInExec()
{
+#if defined(Q_WS_MAC) || (defined(Q_WS_WINCE) && defined(_ARM_))
+ QSKIP("Throwing exceptions in exec() is not supported on this platform.");
+#endif
#if defined(Q_OS_LINUX)
// C++ exceptions can't be passed through glib callbacks. Skip the test if
// we're using the glib event loop.
}
QCOMPARE(caughtExceptions, 1);
}
-#endif
+#else
+void tst_QDialog::throwInExec()
+{
+ QSKIP("Exceptions are disabled");
+}
+#endif //QT_NO_EXCEPTIONS
// From Task 124269
void tst_QDialog::showSizeGrip()
void clearLineEdit();
void enableChooseButton();
void hooks();
-#if defined(Q_OS_UNIX) && defined(QT_BUILD_INTERNAL)
+#ifdef Q_OS_UNIX
void tildeExpansion_data();
void tildeExpansion();
#endif
QCOMPARE(QFileDialog::getSaveFileName(), QString("saveName"));
}
-// Test case relies on developer build (AUTOTEST_EXPORT).
-#if defined(Q_OS_UNIX) && defined(QT_BUILD_INTERNAL)
+#ifdef Q_OS_UNIX
void tst_QFiledialog::tildeExpansion_data()
{
QTest::addColumn<QString>("tildePath");
void tst_QFiledialog::tildeExpansion()
{
+#ifndef QT_BUILD_INTERNAL
+ QSKIP("Test case relies on developer build (AUTOTEST_EXPORT)");
+#else
QFETCH(QString, tildePath);
QFETCH(QString, expandedPath);
QCOMPARE(qt_tildeExpansion(tildePath), expandedPath);
+#endif
}
#endif
void detailsText();
void detailsButtonText();
-#ifndef Q_WS_MAC
void shortcut();
-#endif
void staticSourceCompat();
void instanceSourceCompat();
}
}
-// Shortcuts are not used on Mac OS X.
-#ifndef Q_WS_MAC
void tst_QMessageBox::shortcut()
{
+#ifdef Q_WS_MAC
+ QSKIP("shortcuts are not used on MAC OS X");
+#endif
QMessageBox msgBox;
msgBox.addButton("O&k", QMessageBox::YesRole);
msgBox.addButton("&No", QMessageBox::YesRole);
msgBox.addButton("&Maybe", QMessageBox::YesRole);
QCOMPARE(exec(&msgBox, Qt::Key_M), 2);
}
-#endif
void tst_QMessageBox::about()
{
void setOption_HaveHelpButton();
void setOption_HelpButtonOnRight();
void setOption_HaveCustomButtonX();
-#ifndef Q_OS_WINCE
void combinations_data();
void combinations();
-#endif
void showCurrentPageOnly();
void setButtonText();
void setCommitPage();
}
};
-// Too much memory usage for testing on CE emulator.
-#ifndef Q_OS_WINCE
void tst_QWizard::combinations_data()
{
CombinationsTestData combTestData;
void tst_QWizard::combinations()
{
+#ifdef Q_OS_WINCE
+ QSKIP("Too much memory usage for testing on CE emulator");
+#endif
+
QFETCH(bool, ref);
QFETCH(bool, testEquality);
QFETCH(QList<Operation *>, operations);
QVERIFY(false);
}
}
-#endif
class WizardPage : public QWizardPage
{
void qgraphicsgridlayout();
void addItem_data();
void addItem();
-#ifndef Q_WS_MAC
void alignment_data();
void alignment();
-#endif
void alignment2();
void alignment2_data();
-#ifndef Q_WS_MAC
void columnAlignment_data();
void columnAlignment();
-#endif
void columnCount_data();
void columnCount();
void columnMaximumWidth_data();
delete layout;
}
-// Resizing a QGraphicsWidget to effectiveSizeHint(Qt::MaximumSize) is currently not supported on mac.
-#ifndef Q_WS_MAC
void tst_QGraphicsGridLayout::alignment_data()
{
QTest::addColumn<bool>("hasHeightForWidth");
// public Qt::Alignment alignment(QGraphicsLayoutItem* item) const
void tst_QGraphicsGridLayout::alignment()
{
+#ifdef Q_WS_MAC
+ QSKIP("Resizing a QGraphicsWidget to effectiveSizeHint(Qt::MaximumSize) is currently not supported on mac");
+#endif
QFETCH(bool, hasHeightForWidth);
QGraphicsScene scene;
QGraphicsView view(&scene);
delete widget;
}
-#endif
-// Resizing a QGraphicsWidget to effectiveSizeHint(Qt::MaximumSize) is currently not supported on mac.
-#ifndef Q_WS_MAC
void tst_QGraphicsGridLayout::columnAlignment_data()
{
QTest::addColumn<bool>("hasHeightForWidth");
// public Qt::Alignment columnAlignment(int column) const
void tst_QGraphicsGridLayout::columnAlignment()
{
+#ifdef Q_WS_MAC
+ QSKIP("Resizing a QGraphicsWidget to effectiveSizeHint(Qt::MaximumSize) is currently not supported on mac");
+#endif
QFETCH(bool, hasHeightForWidth);
QGraphicsScene scene;
QGraphicsView view(&scene);
delete widget;
}
-#endif
void tst_QGraphicsGridLayout::columnCount_data()
{
void focusNextPrevChild();
void focusOutEvent_data();
void focusOutEvent();
-#if !defined(Q_OS_WINCE) || (defined(GWES_ICONCURS) && !defined(QT_NO_CURSOR))
void hoverEnterLeaveEvent_data();
void hoverEnterLeaveEvent();
-#endif
void hoverMoveEvent_data();
void hoverMoveEvent();
void keyPressEvent_data();
void setFocus_complexTwoWidgets();
void popup_basic();
void popup_subwidget();
-#if !defined(QT_NO_CURSOR) && (!defined(Q_OS_WINCE) || defined(GWES_ICONCURS))
void changingCursor_basic();
-#endif
void tooltip_basic();
void childPos_data();
void childPos();
}
};
-// protected void hoverEnterEvent(QGraphicsSceneHoverEvent* event)
-#if !defined(Q_OS_WINCE) || (defined(GWES_ICONCURS) && !defined(QT_NO_CURSOR))
void tst_QGraphicsProxyWidget::hoverEnterLeaveEvent_data()
{
QTest::addColumn<bool>("hasWidget");
QTest::newRow("no widget, hover") << false << true;
}
+// protected void hoverEnterEvent(QGraphicsSceneHoverEvent* event)
void tst_QGraphicsProxyWidget::hoverEnterLeaveEvent()
{
QFETCH(bool, hasWidget);
QFETCH(bool, hoverEnabled);
+#if defined(Q_OS_WINCE) && (!defined(GWES_ICONCURS) || defined(QT_NO_CURSOR))
+ QSKIP("hover events not supported on this platform");
+#endif
+
// proxy should translate this into events that the widget would expect
QGraphicsScene scene;
if (!hasWidget)
delete widget;
}
-#endif
void tst_QGraphicsProxyWidget::hoverMoveEvent_data()
{
QCOMPARE(popup->size(), child->size().toSize());
}
-#if !defined(QT_NO_CURSOR) && (!defined(Q_OS_WINCE) || defined(GWES_ICONCURS))
void tst_QGraphicsProxyWidget::changingCursor_basic()
{
+#if defined(Q_OS_WINCE) && (!defined(GWES_ICONCURS) || defined(QT_NO_CURSOR))
+ QSKIP("hover events not supported on this platform");
+#endif
+#ifndef QT_NO_CURSOR
// Confirm that mouse events are working properly by checking that
// when moving the mouse over a line edit it will change the cursor into the I
QGraphicsScene scene;
QTest::mouseMove(view.viewport(), QPoint(1, 1));
sendMouseMove(view.viewport(), QPoint(1, 1));
QTRY_COMPARE(view.viewport()->cursor().shape(), Qt::ArrowCursor);
-}
#endif
+}
void tst_QGraphicsProxyWidget::tooltip_basic()
{
void addPixmap();
void addRect();
void addText();
-#if !defined(Q_OS_WINCE) || defined(GWES_ICONCURS)
void removeItem();
-#endif
void clear();
void focusItem();
void focusItemLostFocus();
QCOMPARE(text->font(), QFont());
}
-#if !defined(Q_OS_WINCE) || defined(GWES_ICONCURS)
void tst_QGraphicsScene::removeItem()
{
+#if defined(Q_OS_WINCE) && !defined(GWES_ICONCURS)
+ QSKIP("No mouse cursor support");
+#endif
QGraphicsScene scene;
QGraphicsItem *item = scene.addRect(QRectF(0, 0, 10, 10));
QCOMPARE(scene.itemAt(0, 0), item); // forces indexing
qApp->processEvents(); // <- pending update is sent to view
QVERIFY(!hoverItem->isHovered);
}
-#endif
void tst_QGraphicsScene::focusItem()
{
void mapFromScenePath();
void sendEvent();
void wheelEvent();
-#if !defined(QT_NO_CURSOR) && !defined(Q_OS_WINCE)
void cursor();
void cursor2();
-#endif
void transformationAnchor();
void resizeAnchor();
void viewportUpdateMode();
void task239047_fitInViewSmallViewport();
void task245469_itemsAtPointWithClip();
void task253415_reconnectUpdateSceneOnSceneChanged();
-#ifndef Q_OS_WINCE
void task255529_transformationAnchorMouseAndViewportMargins();
-#endif
void task259503_scrollingArtifacts();
void QTBUG_4151_clipAndIgnore_data();
void QTBUG_4151_clipAndIgnore();
void QTBUG_5859_exposedRect();
-#if !defined(QT_NO_CURSOR) && !defined(Q_OS_WINCE)
void QTBUG_7438_cursor();
-#endif
void hoverLeave();
void QTBUG_16063_microFocusRect();
QVERIFY(widget->hasFocus());
}
-// Qt/CE does not have regular cursor support.
-#if !defined(QT_NO_CURSOR) && !defined(Q_OS_WINCE)
void tst_QGraphicsView::cursor()
{
+#ifndef QT_NO_CURSOR
+#if defined(Q_OS_WINCE)
+ QSKIP("Qt/CE does not have regular cursor support");
+#endif
if (PlatformQuirks::haveMouseCursor())
QSKIP("The Platform does not have regular cursor support");
sendMouseMove(view.viewport(), QPoint(5, 5));
QCOMPARE(view.viewport()->cursor().shape(), Qt::PointingHandCursor);
-}
#endif
+}
// Qt/CE does not have regular cursor support.
#if !defined(QT_NO_CURSOR) && !defined(Q_OS_WINCE)
void tst_QGraphicsView::cursor2()
{
+#ifndef QT_NO_CURSOR
+#if defined(Q_OS_WINCE)
+ QSKIP("Qt/CE does not have regular cursor support");
+#endif
if (PlatformQuirks::haveMouseCursor())
QSKIP("The Platform does not have regular cursor support");
QCOMPARE(view.viewport()->cursor().shape(), Qt::IBeamCursor);
sendMouseMove(view.viewport(), view.mapFromScene(-15, -15));
QCOMPARE(view.viewport()->cursor().shape(), Qt::SizeAllCursor);
-}
#endif
+}
void tst_QGraphicsView::transformationAnchor()
{
QVERIFY(wasConnected2);
}
-// Qt/CE does not implement mouse tracking at this point.
-#ifndef Q_OS_WINCE
void tst_QGraphicsView::task255529_transformationAnchorMouseAndViewportMargins()
{
+#if defined(Q_OS_WINCE)
+ QSKIP("Qt/CE does not implement mouse tracking at this point");
+#endif
QGraphicsScene scene(-100, -100, 200, 200);
scene.addRect(QRectF(-50, -50, 100, 100), QPen(Qt::black), QBrush(Qt::blue));
QEXPECT_FAIL("", "QTBUG-22455", Abort);
QVERIFY(qAbs(newMouseScenePos.x() - mouseScenePos.x()) < slack);
QVERIFY(qAbs(newMouseScenePos.y() - mouseScenePos.y()) < slack);
-}
#endif
+}
void tst_QGraphicsView::task259503_scrollingArtifacts()
{
QCOMPARE(item.lastExposedRect, scene.lastBackgroundExposedRect);
}
-// Qt/CE does not have regular cursor support.
-#if !defined(QT_NO_CURSOR) && !defined(Q_OS_WINCE)
void tst_QGraphicsView::QTBUG_7438_cursor()
{
+#ifndef QT_NO_CURSOR
+#if defined(Q_OS_WINCE)
+ QSKIP("Qt/CE does not have regular cursor support");
+#endif
QGraphicsScene scene;
QGraphicsItem *item = scene.addRect(QRectF(-10, -10, 20, 20));
item->setFlag(QGraphicsItem::ItemIsMovable);
QCOMPARE(view.viewport()->cursor().shape(), Qt::PointingHandCursor);
sendMouseRelease(view.viewport(), view.mapFromScene(0, 0));
QCOMPARE(view.viewport()->cursor().shape(), Qt::PointingHandCursor);
-}
#endif
+}
class GraphicsItemWithHover : public QGraphicsRectItem
{
Q_OBJECT
public slots:
void cleanupTestCase();
-#ifdef Q_OS_UNIX
void init();
-#endif
private slots:
void getSetCheck();
-#ifdef Q_OS_UNIX
void unreadable();
-#endif
/*
void construct();
void rowCount();
void filePath();
-#ifdef Q_OS_UNIX
void hidden();
-#endif
void fileName();
void fileName_data();
current.rmdir(".qtest_hidden");
}
-#ifdef Q_OS_UNIX
void tst_QDirModel::init()
{
+#ifdef Q_OS_UNIX
if (QTest::currentTestFunction() == QLatin1String( "unreadable" )) {
// Make sure that the unreadable file created by the unreadable()
// test function doesn't already exist.
QVERIFY(!unreadableFile.exists());
}
}
-}
#endif
+}
/*
tests
QVERIFY(rowsAboutToBeRemoved_cleanup(test_path));
}
-#ifdef Q_OS_UNIX
void tst_QDirModel::hidden()
{
+#ifndef Q_OS_UNIX
+ QSKIP("Test not implemented on non-Unixes");
+#else
QDir current;
current.mkdir(".qtest_hidden");
model2.setFilter(model2.filter() | QDir::Hidden);
index = model2.index(QDir::currentPath() + "/.qtest_hidden");
QVERIFY(index.isValid());
-}
#endif
+}
void tst_QDirModel::fileName_data()
{
QCOMPARE(model.fileName(model.index(path)), result);
}
-#ifdef Q_OS_UNIX
void tst_QDirModel::unreadable()
{
+#ifndef Q_OS_UNIX
+ QSKIP("Test not implemented on non-Unixes");
+#else
// Create an empty file which has no read permissions (file will be removed by cleanup()).
QFile unreadableFile(QDir::currentPath() + "qtest_unreadable");
QVERIFY2(unreadableFile.open(QIODevice::WriteOnly | QIODevice::Text), qPrintable(unreadableFile.errorString()));
model2.setFilter(model2.filter() | QDir::Hidden);
index = model2.index(QDir::currentPath() + "/qtest_unreadable");
QVERIFY(!index.isValid());
-}
#endif
+}
void tst_QDirModel::filePath()
{
void scrollBarAsNeeded();
void moveItems();
void wordWrap();
-#if defined(Q_OS_WIN) && !defined(Q_OS_WINCE) && WINVER >= 0x0500
void setCurrentIndexAfterAppendRowCrash();
-#endif
void emptyItemSize();
void task203585_selectAll();
void task228566_infiniteRelayout();
};
#endif
-// This test only makes sense on Windows 2000 and higher.
-#if defined(Q_OS_WIN) && !defined(Q_OS_WINCE) && WINVER >= 0x0500
void tst_QListView::setCurrentIndexAfterAppendRowCrash()
{
+#if defined(Q_OS_WIN) && !defined(Q_OS_WINCE) && WINVER >= 0x0500
SetCurrentIndexAfterAppendRowCrashDialog w;
w.exec();
-}
+#else
+ QSKIP("This test only makes sense on windows 2000 and higher.");
#endif
+}
void tst_QListView::emptyItemSize()
{
void taskQTBUG_8777_scrollToSpans();
void taskQTBUG_10169_sizeHintForRow();
-#ifndef Q_OS_WINCE
void mouseWheel_data();
void mouseWheel();
-#endif
void addColumnWhileEditing();
void task234926_setHeaderSorting();
}
-// Since different Windows CE versions sport different taskbars, we skip this test.
-#ifndef Q_OS_WINCE
void tst_QTableView::mouseWheel_data()
{
QTest::addColumn<int>("scrollMode");
void tst_QTableView::mouseWheel()
{
+#ifdef Q_OS_WINCE
+ QSKIP("Since different Windows CE versions sport different taskbars, we skip this test");
+#endif
QFETCH(int, scrollMode);
QFETCH(int, delta);
QApplication::sendEvent(view.viewport(), &verticalEvent);
QVERIFY(qAbs(view.verticalScrollBar()->value() - verticalPosition) < 10);
}
-#endif
void tst_QTableView::addColumnWhileEditing()
{
void tst_windowFilePath_data();
void tst_windowFilePath();
-#ifdef Q_WS_X11
void tst_showWithoutActivating();
-#endif
void tst_paintEventOnSecondShow();
};
}
}
-#ifdef Q_WS_X11
void tst_QWidget_window::tst_showWithoutActivating()
{
+#ifndef Q_WS_X11
+ QSKIP("This test is X11-only.");
+#else
QWidget w;
w.show();
QTest::qWaitForWindowShown(&w);
(XGetInputFocus(QX11Info::display(), &window, &revertto), window) );
// Note the use of the , before window because we want the XGetInputFocus to be re-executed
// in each iteration of the inside loop of the QTRY_COMPARE macro
+
+#endif // Q_WS_X11
}
-#endif
void tst_QWidget_window::tst_paintEventOnSecondShow()
{
#ifndef QT_NO_STYLE_CDE
void testCDEStyle();
#endif
-#if defined(Q_WS_WIN) && !defined(QT_NO_STYLE_WINDOWSXP)
+#ifndef QT_NO_STYLE_WINDOWSXP
void testWindowsXPStyle();
#endif
void testWindowsVistaStyle();
void testCleanlooksStyle();
#endif
void testMacStyle();
-#ifdef Q_OS_WINCE
void testWindowsCEStyle();
-#endif
-#ifdef Q_OS_WINCE_WM
void testWindowsMobileStyle();
-#endif
void testStyleFactory();
void testProxyStyle();
void pixelMetric();
wstyle.drawControl(QStyle::CE_ProgressBar, &pb, &painter, 0);
}
-#if defined(Q_WS_WIN) && !defined(QT_NO_STYLE_WINDOWSXP)
+#ifndef QT_NO_STYLE_WINDOWSXP
void tst_QStyle::testWindowsXPStyle()
{
+#ifdef Q_WS_WIN
QWindowsXPStyle xpstyle;
QVERIFY(testAllFunctions(&xpstyle));
lineUpLayoutTest(&xpstyle);
+#else
+ QSKIP("No WindowsXP style");
+#endif
}
#endif
}
#endif
-#ifdef Q_OS_WINCE
void tst_QStyle::testWindowsCEStyle()
{
+#if defined(Q_OS_WINCE)
QWindowsCEStyle cstyle;
QVERIFY(testAllFunctions(&cstyle));
-}
+#else
+ QSKIP("No WindowsCEStyle style");
#endif
+}
-#ifdef Q_OS_WINCE_WM
void tst_QStyle::testWindowsMobileStyle()
{
+#if defined(Q_OS_WINCE_WM)
QWindowsMobileStyle cstyle;
QVERIFY(testAllFunctions(&cstyle));
-}
+#else
+ QSKIP("No WindowsMobileStyle style");
#endif
+}
// Helper class...
void fontPropagation();
void onWidgetDestroyed();
void fontPrecedence();
-#if defined(Q_OS_WIN32) || defined(Q_OS_MAC) || (defined(Q_OS_LINUX) && defined(Q_CC_GNU) && !defined(Q_CC_INTEL))
void focusColors();
-#endif
void hoverColors();
void background();
void tabAlignement();
return false;
}
-// This is a fragile test which fails on many esoteric platforms
-// because of focus problems. Test only on Windows, Mac, and Linux/gcc.
-#if defined(Q_OS_WIN32) || defined(Q_OS_MAC) || (defined(Q_OS_LINUX) && defined(Q_CC_GNU) && !defined(Q_CC_INTEL))
void tst_QStyleSheetStyle::focusColors()
{
// Tests if colors can be changed by altering the focus of the widget.
// is reached if at least ten pixels of the right color can be found in
// the image.
// For this reason, we use unusual and extremely ugly colors! :-)
+#if !defined(Q_OS_WIN32) && !defined(Q_OS_MAC) && !(defined(Q_OS_LINUX) && defined(Q_CC_GNU) && !defined(Q_CC_INTEL))
+ QSKIP("This is a fragile test which fails on many esoteric platforms because of focus problems. "
+ "That doesn't mean that the feature doesn't work in practice.");
+#endif
QList<QWidget *> widgets;
widgets << new QPushButton("TESTING");
widgets << new QLineEdit("TESTING");
.toLocal8Bit().constData());
}
}
-#endif
void tst_QStyleSheetStyle::hoverColors()
{
void staticScrollers();
void scrollerProperties();
void scrollTo();
-#if !defined(QT_NO_GESTURES) && !(defined(Q_OS_MACX) && (MAC_OS_X_VERSION_MAX_ALLOWED < MAC_OS_X_VERSION_10_6))
void scroll();
void overshoot();
-#endif
};
/*! \internal
}
}
-// Mac OS X < 10.6 does not support QTouchEvents.
-#if !defined(QT_NO_GESTURES) && !(defined(Q_OS_MACX) && (MAC_OS_X_VERSION_MAX_ALLOWED < MAC_OS_X_VERSION_10_6))
void tst_QScroller::scroll()
{
+#if defined(Q_OS_MACX) && (MAC_OS_X_VERSION_MAX_ALLOWED < MAC_OS_X_VERSION_10_6)
+ QSKIP("Mac OS X < 10.6 does not support QTouchEvents");
+ return;
+#endif
+
+#ifndef QT_NO_GESTURES
// -- good case. normal scroll
tst_QScrollerWidget *sw = new tst_QScrollerWidget();
sw->scrollArea = QRectF(0, 0, 1000, 1000);
QCOMPARE(sw->currentPos.y(), 500.0);
delete sw;
-}
#endif
+}
-// Mac OS X < 10.6 does not support QTouchEvents.
-#if !defined(QT_NO_GESTURES) && !(defined(Q_OS_MACX) && (MAC_OS_X_VERSION_MAX_ALLOWED < MAC_OS_X_VERSION_10_6))
void tst_QScroller::overshoot()
{
+#if defined(Q_OS_MACX) && (MAC_OS_X_VERSION_MAX_ALLOWED < MAC_OS_X_VERSION_10_6)
+ QSKIP("Mac OS X < 10.6 does not support QTouchEvents");
+ return;
+#endif
+
+#ifndef QT_NO_GESTURES
tst_QScrollerWidget *sw = new tst_QScrollerWidget();
sw->scrollArea = QRectF(0, 0, 1000, 1000);
QScroller::grabGesture(sw, QScroller::TouchGesture);
QCOMPARE( sw->receivedOvershoot, false );
delete sw;
-}
#endif
+}
QTEST_MAIN(tst_QScroller)
void setText_data();
void setText();
void setTextFormat();
-#ifndef Q_WS_MAC
void setBuddy();
-#endif
void setNum();
void clear();
void wordWrap();
}
}
-// Set buddy doesn't make much sense on Mac OS X.
-#ifndef Q_WS_MAC
void tst_QLabel::setBuddy()
{
+#ifdef Q_OS_MAC
+ QSKIP("Set buddy doesn't make much sense on Mac OS X");
+#endif
testWidget->hide();
test_box = new Widget;
QVERIFY( test_edit->hasFocus() );
delete test_box;
}
-#endif
void tst_QLabel::setText_data()
{
void taskQTBUG_7902_contextMenuCrash();
#endif
void taskQTBUG_7395_readOnlyShortcut();
-#ifdef Q_WS_X11
void QTBUG697_paletteCurrentColorGroup();
-#endif
void QTBUG13520_textNotVisible();
void bidiVisualMovement_data();
QCOMPARE(spy.count(), 1);
}
-#ifdef Q_WS_X11
void tst_QLineEdit::QTBUG697_paletteCurrentColorGroup()
{
+#ifndef Q_WS_X11
+ QSKIP("Only tested on X11");
+#endif
QLineEdit le;
le.setText(" ");
QPalette p = le.palette();
le.render(&img);
QCOMPARE(img.pixel(10, le.height()/2), QColor(Qt::red).rgb());
}
-#endif
void tst_QLineEdit::QTBUG13520_textNotVisible()
{
void constructor();
void iconSize();
void toolButtonStyle();
-#ifndef Q_WS_WINCE_WM
void menuBar();
-#endif
void statusBar();
void centralWidget();
void corner();
void centralWidgetSize();
void dockWidgetSize();
void QTBUG2774_stylechange();
-#ifdef Q_OS_MAC
void toggleUnifiedTitleAndToolBarOnMac();
-#endif
};
// Testing get/set functions
}
}
-// With native menubar integration on Windows Mobile the menubar is not a child
-#ifndef Q_WS_WINCE_WM
void tst_QMainWindow::menuBar()
{
{
mw.setMenuBar(mb1);
QVERIFY(mw.menuBar() != 0);
QCOMPARE(mw.menuBar(), (QMenuBar *)mb1);
+#ifdef Q_WS_WINCE_WM
+ QSKIP("With native menubar integration the menubar is not a child");
+#endif
QCOMPARE(mb1->parentWidget(), (QWidget *)&mw);
mw.setMenuBar(0);
QVERIFY(!topRightCornerWidget);
}
}
-#endif
void tst_QMainWindow::statusBar()
{
}
}
-#ifdef Q_OS_MAC
void tst_QMainWindow::toggleUnifiedTitleAndToolBarOnMac()
{
+#ifdef Q_OS_MAC
QMainWindow mw;
QToolBar *tb = new QToolBar;
tb->addAction("Test");
QVERIFY(frameGeometry.topLeft() == mw.frameGeometry().topLeft());
mw.setUnifiedTitleAndToolBarOnMac(true);
QVERIFY(frameGeometry.topLeft() == mw.frameGeometry().topLeft());
-}
+#else
+ QSKIP("Mac specific test");
#endif
+}
+
QTEST_MAIN(tst_QMainWindow)
#include "tst_qmainwindow.moc"
void showShaded();
void showNormal_data();
void showNormal();
-#if !defined(QT_NO_CURSOR) && !defined(Q_OS_WINCE_WM)
void setOpaqueResizeAndMove_data();
void setOpaqueResizeAndMove();
-#endif
void setWindowFlags_data();
void setWindowFlags();
void mouseDoubleClick();
int _count;
};
-// This test requires cursor support, which is absent on WinCE
-#if !defined(QT_NO_CURSOR) && !defined(Q_OS_WINCE_WM)
void tst_QMdiSubWindow::setOpaqueResizeAndMove_data()
{
QTest::addColumn<bool>("opaqueMode");
void tst_QMdiSubWindow::setOpaqueResizeAndMove()
{
+#if defined (QT_NO_CURSOR) || defined (Q_OS_WINCE_WM) //For Windows CE we will set QT_NO_CURSOR if there is no cursor support
+ QSKIP("No cursor available");
+#endif
QFETCH(bool, opaqueMode);
QFETCH(int, geometryCount);
QFETCH(int, expectedGeometryCount);
QCOMPARE(window->size(), windowSize + QSize(geometryCount, geometryCount));
}
}
-#endif
void tst_QMdiSubWindow::setWindowFlags_data()
{
void overrideMenuAction();
void statusTip();
void widgetActionFocus();
-#ifndef Q_OS_WINCE_WM
void mouseActivation();
-#endif
void tearOff();
void layoutDirection();
void task250673_activeMultiColumnSubMenuPosition();
void task256918_setFont();
void menuSizeHint();
-#ifndef Q_OS_WINCE_WM
void task258920_mouseBorder();
-#endif
void setFixedWidth();
void deleteActionInTriggered();
void pushButtonPopulateOnAboutToShow();
QCOMPARE(menus[0]->actions().count(), 0);
}
-// We have a separate mouseActivation test for Windows mobile.
-#ifndef Q_OS_WINCE_WM
void tst_QMenu::mouseActivation()
{
+#ifdef Q_OS_WINCE_WM
+ QSKIP("We have a separate mouseActivation test for Windows mobile.");
+#endif
QWidget topLevel;
QMenu menu(&topLevel);
topLevel.show();
QVERIFY(submenu.isVisible());
#endif
}
-#endif
void tst_QMenu::keyboardNavigation_data()
{
bool painted;
};
-// Mouse move related signals for Windows Mobile unavailable.
-#ifndef Q_OS_WINCE_WM
void tst_QMenu::task258920_mouseBorder()
{
+#ifdef Q_OS_WINCE_WM
+ QSKIP("Mouse move related signals for Windows Mobile unavailable");
+#endif
// ### fixme: Check platforms
QSKIP("QTBUG-20753 QCursor::setPos() / QTest::mouseMove() doesn't work on qpa");
QCOMPARE(static_cast<QAction*>(0), menu.activeAction());
QVERIFY(menu.painted);
}
-#endif
void tst_QMenu::setFixedWidth()
{
void removeItem();
void count();
void insertItem_QString_QObject();
-#if !defined(Q_WS_MAC) && !defined(Q_OS_WINCE_WM)
void accel();
void activatedCount();
-#endif
void allowActiveAndDisabled();
-#if !defined(Q_WS_MAC) && !defined(Q_OS_WINCE_WM)
void check_accelKeys();
void check_cursorKeys1();
void check_cursorKeys2();
void check_cursorKeys3();
-#endif
void check_homeKey();
void check_endKey();
-#if !defined(Q_WS_MAC) && !defined(Q_OS_WINCE_WM)
void check_escKey();
-#endif
// void check_mouse1_data();
// void check_mouse1();
// void check_mouse2();
void check_altPress();
-#if !defined(Q_WS_MAC) && !defined(Q_OS_WINCE_WM)
void check_shortcutPress();
void check_menuPosition();
-#endif
void task223138_triggered();
void task256322_highlight();
void menubarSizeHint();
-#ifndef Q_WS_MAC
void taskQTBUG4965_escapeEaten();
-#endif
void taskQTBUG11823_crashwithInvisibleActions();
protected slots:
// printf( QString("acceleratorId: %1, count: %1\n").arg( i ).arg(activated_count) );
}
-// On Mac/WinCE, native key events are needed to test menu action activation.
-#if !defined(Q_WS_MAC) && !defined(Q_OS_WINCE_WM)
void tst_QMenuBar::accel()
{
+#if defined(Q_WS_MAC) || defined(Q_OS_WINCE_WM)
+ QSKIP("On Mac/WinCE, native key events are needed to test menu action activation");
+#endif
+
// create a popup menu with menu items set the accelerators later...
initSimpleMenubar();
QCOMPARE( last_accel_id, action );
}
-#endif
-// On Mac/WinCE, native key events are needed to test menu action activation.
-#if !defined(Q_WS_MAC) && !defined(Q_OS_WINCE_WM)
void tst_QMenuBar::activatedCount()
{
+#if defined(Q_WS_MAC) || defined(Q_OS_WINCE_WM)
+ QSKIP("On Mac/WinCE, native key events are needed to test menu action activation");
+#endif
// create a popup menu with menu items set the accelerators later...
initSimpleMenubar();
//wait(5000);
QCOMPARE( activated_count, 2 ); //1 from the popupmenu and 1 from the menubar
}
-#endif
void tst_QMenuBar::clear()
{
QVERIFY(actions.size() < 4); // there is no menu 4!
}
-// On Mac/WinCE, native key events are needed to test menu action activation.
-#if !defined(Q_WS_MAC) && !defined(Q_OS_WINCE_WM)
void tst_QMenuBar::check_accelKeys()
{
+#if defined(Q_WS_MAC) || defined(Q_OS_WINCE_WM)
+ QSKIP("On Mac/WinCE, native key events are needed to test menu action activation");
+#endif
initComplexMenubar();
// start with a bogus key that shouldn't trigger anything
QCOMPARE(item2_C->selCount(), 1u);
QCOMPARE(item2_D->selCount(), 1u);
}
-#endif
-// Qt/Mac,WinCE does not use the native popups/menubar.
-#if !defined(Q_WS_MAC) && !defined(Q_OS_WINCE_WM)
void tst_QMenuBar::check_cursorKeys1()
{
+#if defined(Q_WS_MAC) || defined(Q_OS_WINCE_WM)
+ QSKIP("Qt/Mac,WinCE does not use the native popups/menubar");
+#endif
+
initComplexMenubar();
// start with a ALT + 1 that activates the first popupmenu
QCOMPARE(item2_C->selCount(), 0u);
QCOMPARE(item2_D->selCount(), 0u);
}
-#endif
-// Qt/Mac,WinCE does not use the native popups/menubar.
-#if !defined(Q_WS_MAC) && !defined(Q_OS_WINCE_WM)
void tst_QMenuBar::check_cursorKeys2()
{
+#if defined(Q_WS_MAC) || defined(Q_OS_WINCE_WM)
+ QSKIP("Qt/Mac,WinCE does not use the native popups/menubar");
+#endif
+
initComplexMenubar();
// select popupmenu2
QCOMPARE(item2_C->selCount(), 0u);
QCOMPARE(item2_D->selCount(), 1u);
}
-#endif
/*!
If a popupmenu is active you can use Left to move to the menu to the left of it.
- Qt/Mac,WinCE does not use the native popups/menubar.
*/
-#if !defined(Q_WS_MAC) && !defined(Q_OS_WINCE_WM)
void tst_QMenuBar::check_cursorKeys3()
{
+#if defined(Q_WS_MAC) || defined(Q_OS_WINCE_WM)
+ QSKIP("Qt/Mac,WinCE does not use the native popups/menubar");
+#endif
+
initComplexMenubar();
// select Popupmenu 2
QCOMPARE(item2_C->selCount(), 0u);
QCOMPARE(item2_D->selCount(), 0u);
}
-#endif
/*!
If a popupmenu is active you can use home to go quickly to the first item in the menu.
If Down is pressed next the popup is activated again.
*/
-// Qt/Mac,WinCE does not use the native popups/menubar.
-#if !defined(Q_WS_MAC) && !defined(Q_OS_WINCE_WM)
void tst_QMenuBar::check_escKey()
{
+#if defined(Q_WS_MAC) || defined(Q_OS_WINCE_WM)
+ QSKIP("Qt/Mac,WinCE does not use the native popups/menubar");
+#endif
+
initComplexMenubar();
QVERIFY( !pm1->isActiveWindow() );
// Let's see if the correct slot is called...
QVERIFY2( item2_C->selCount() == 1, "Expected item 2C to be selected" );
}
-#endif
+
// void tst_QMenuBar::check_mouse1_data()
// {
QVERIFY( ::qobject_cast<QMenuBar *>(qApp->focusWidget()) );
}
-// Qt/Mac,WinCE does not use the native popups/menubar.
-#if !defined(Q_WS_MAC) && !defined(Q_OS_WINCE_WM)
void tst_QMenuBar::check_shortcutPress()
{
+#if defined(Q_WS_MAC) || defined(Q_OS_WINCE_WM)
+ QSKIP("Qt/Mac,WinCE does not use the native popups/menubar");
+#endif
+
initComplexMenubar();
qApp->setActiveWindow(mw);
QTest::keyClick(mb, Qt::Key_2);
QVERIFY(pm1->isActiveWindow());
}
-#endif
-// Qt/Mac does not use the native popups/menubar.
-// Qt/CE uses native menubar.
-#if !defined(Q_WS_MAC) && !defined(Q_OS_WINCE_WM)
void tst_QMenuBar::check_menuPosition()
{
+#ifdef Q_WS_MAC
+ QSKIP("Qt/Mac does not use the native popups/menubar");
+#endif
+#ifdef Q_OS_WINCE_WM
+ QSKIP("Qt/CE uses native menubar");
+#endif
Menu menu;
initComplexMenubar();
menu.setTitle("&menu");
menu.close();
qApp->setLayoutDirection(dir);
}
+
}
-#endif
void tst_QMenuBar::task223138_triggered()
{
QCOMPARE(resSize, mb.sizeHint());
}
-// On Mac, do not test the menubar with escape key.
-#ifndef Q_WS_MAC
void tst_QMenuBar::taskQTBUG4965_escapeEaten()
{
+#ifdef Q_WS_MAC
+ QSKIP("On Mac, do not test the menubar with escape key");
+#endif
QMenuBar menubar;
QMenu menu("menu1");
QAction *first = menubar.addMenu(&menu);
QTest::keyClick(static_cast<QWidget *>(0), Qt::Key_Escape); //now the action should be triggered
QTRY_VERIFY(!menubar.isVisible());
}
-#endif
void tst_QMenuBar::taskQTBUG11823_crashwithInvisibleActions()
{
void mapRectToScene();
void mapRectFromScene_data();
void mapRectFromScene();
-#ifndef Q_WS_WINCE_WM
void chipTester_data();
void chipTester();
-#endif
void deepNesting_data();
void deepNesting();
void imageRiver_data();
}
}
-// This test does not make sense Windows Mobile without OpenGL
-#ifndef Q_WS_WINCE_WM
void tst_QGraphicsView::chipTester_data()
{
QTest::addColumn<bool>("antialias");
void tst_QGraphicsView::chipTester()
{
+#ifdef Q_WS_WINCE_WM
+ QSKIP("WinCE WM: Fails on Windows Mobile w/o OpenGL");
+#endif
QFETCH(bool, antialias);
QFETCH(bool, opengl);
QFETCH(int, operation);
tester.runBenchmark();
}
}
-#endif
static void addChildHelper(QGraphicsItem *parent, int n, bool rotate)
{
void cleanup();
private slots:
void ipv4LoopbackPerformanceTest();
-#ifndef Q_WS_WINCE_WM
void ipv6LoopbackPerformanceTest();
-#endif
void ipv4PerformanceTest();
};
}
//----------------------------------------------------------------------------------
-// IPv6 loopback not yet supported on Windows Mobile
-#ifndef Q_WS_WINCE_WM
void tst_QTcpServer::ipv6LoopbackPerformanceTest()
{
QFETCH_GLOBAL(bool, setProxy);
if (setProxy)
return;
+#if defined(Q_WS_WINCE_WM)
+ QSKIP("WinCE WM: Not yet supported");
+#endif
QTcpServer server;
if (!server.listen(QHostAddress::LocalHostIPv6, 0)) {
delete clientB;
}
}
-#endif
//----------------------------------------------------------------------------------
void tst_QTcpServer::ipv4PerformanceTest()
projects / profile / ivi / qtbase.git / commitdiff