Merge remote-tracking branch 'origin/5.6' into dev

Based on merge done by Liang Qi

Change-Id: Id566e5b9f284d29bff2199f13f9417c660f5b26f

8 files changed, 162 insertions, 89 deletions

diff --git a/tests/auto/corelib/io/qfile/BLACKLIST b/tests/auto/corelib/io/qfile/BLACKLIST
index 7aac313b12..e3bc093c83 100644
--- a/tests/auto/corelib/io/qfile/BLACKLIST
+++ b/tests/auto/corelib/io/qfile/BLACKLIST
@@ -3,3 +3,7 @@
 msvc-2015
 [readLineStdin_lineByLine]
 msvc-2015
+[openStandardStreamsFileDescriptors]
+osx
+[openStandardStreamsBufferedStreams]
+osx
diff --git a/tests/auto/corelib/io/qstandardpaths/tst_qstandardpaths.cpp b/tests/auto/corelib/io/qstandardpaths/tst_qstandardpaths.cpp
index 8a7ca8429f..3425c14cd4 100644
--- a/tests/auto/corelib/io/qstandardpaths/tst_qstandardpaths.cpp
+++ b/tests/auto/corelib/io/qstandardpaths/tst_qstandardpaths.cpp
@@ -464,6 +464,15 @@ void tst_qstandardpaths::testCustomRuntimeDirectory()
 #endif
 
 #ifdef Q_XDG_PLATFORM
+    struct EnvVarRestorer
+    {
+        EnvVarRestorer() : origRuntimeDir(qgetenv("XDG_RUNTIME_DIR")) {}
+        ~EnvVarRestorer() { qputenv("XDG_RUNTIME_DIR", origRuntimeDir.constData()); }
+        const QByteArray origRuntimeDir;
+    };
+    EnvVarRestorer restorer;
+
+    // When $XDG_RUNTIME_DIR points to a directory with wrong ownership, QStandardPaths should warn
     qputenv("XDG_RUNTIME_DIR", QFile::encodeName("/tmp"));
     // It's very unlikely that /tmp is 0600 or that we can chmod it
     // The call below outputs
@@ -474,6 +483,20 @@ void tst_qstandardpaths::testCustomRuntimeDirectory()
             qPrintable(QString::fromLatin1("QStandardPaths: wrong ownership on runtime directory /tmp, 0 instead of %1").arg(uid)));
     const QString runtimeDir = QStandardPaths::writableLocation(QStandardPaths::RuntimeLocation);
     QVERIFY2(runtimeDir.isEmpty(), qPrintable(runtimeDir));
+
+    // When $XDG_RUNTIME_DIR points to a non-existing directory, QStandardPaths should warn (QTBUG-48771)
+    qputenv("XDG_RUNTIME_DIR", "does_not_exist");
+    QTest::ignoreMessage(QtWarningMsg, "QStandardPaths: XDG_RUNTIME_DIR points to non-existing path 'does_not_exist', please create it with 0700 permissions.");
+    const QString nonExistingRuntimeDir = QStandardPaths::writableLocation(QStandardPaths::RuntimeLocation);
+    QVERIFY2(nonExistingRuntimeDir.isEmpty(), qPrintable(nonExistingRuntimeDir));
+
+    // When $XDG_RUNTIME_DIR points to a file, QStandardPaths should warn
+    const QString file = QFINDTESTDATA("tst_qstandardpaths.cpp");
+    QVERIFY(!file.isEmpty());
+    qputenv("XDG_RUNTIME_DIR", QFile::encodeName(file));
+    QTest::ignoreMessage(QtWarningMsg, qPrintable(QString::fromLatin1("QStandardPaths: XDG_RUNTIME_DIR points to '%1' which is not a directory").arg(file)));
+    const QString noRuntimeDir = QStandardPaths::writableLocation(QStandardPaths::RuntimeLocation);
+    QVERIFY2(noRuntimeDir.isEmpty(), qPrintable(file));
 #endif
 }
 
diff --git a/tests/auto/corelib/io/qtemporarydir/tst_qtemporarydir.cpp b/tests/auto/corelib/io/qtemporarydir/tst_qtemporarydir.cpp
index 58a3db9615..621e215d60 100644
--- a/tests/auto/corelib/io/qtemporarydir/tst_qtemporarydir.cpp
+++ b/tests/auto/corelib/io/qtemporarydir/tst_qtemporarydir.cpp
@@ -229,6 +229,13 @@ void tst_QTemporaryDir::autoRemove()
 void tst_QTemporaryDir::nonWritableCurrentDir()
 {
 #ifdef Q_OS_UNIX
+
+#  if defined(Q_OS_ANDROID) && !defined(Q_OS_ANDROID_NO_SDK)
+    const char nonWritableDir[] = "/data";
+#  else
+    const char nonWritableDir[] = "/home";
+#  endif
+
     if (::geteuid() == 0)
         QSKIP("not valid running this test as root");
 
@@ -240,13 +247,13 @@ void tst_QTemporaryDir::nonWritableCurrentDir()
         }
         QString dir;
     };
-    ChdirOnReturn cor(QDir::currentPath());
 
-#if defined(Q_OS_ANDROID) && !defined(Q_OS_ANDROID_NO_SDK)
-    QDir::setCurrent("/data");
-#else
-    QDir::setCurrent("/home");
-#endif
+    const QFileInfo nonWritableDirFi = QFileInfo(QLatin1String(nonWritableDir));
+    QVERIFY(nonWritableDirFi.isDir());
+    QVERIFY(!nonWritableDirFi.isWritable());
+
+    ChdirOnReturn cor(QDir::currentPath());
+    QVERIFY(QDir::setCurrent(nonWritableDirFi.absoluteFilePath()));
     // QTemporaryDir("tempXXXXXX") is probably a bad idea in any app
     // where the current dir could anything...
     QTemporaryDir dir("tempXXXXXX");
diff --git a/tests/auto/corelib/io/qurl/tst_qurl.cpp b/tests/auto/corelib/io/qurl/tst_qurl.cpp
index 97dfac3062..07257297e0 100644
--- a/tests/auto/corelib/io/qurl/tst_qurl.cpp
+++ b/tests/auto/corelib/io/qurl/tst_qurl.cpp
@@ -79,6 +79,8 @@ private slots:
     void toLocalFile();
     void fromLocalFile_data();
     void fromLocalFile();
+    void fromLocalFileNormalize_data();
+    void fromLocalFileNormalize();
     void macTypes();
     void relative();
     void compat_legacy();
@@ -1242,16 +1244,6 @@ void tst_QUrl::fromLocalFile_data()
                         << QString::fromLatin1("/");
     QTest::newRow("data7") << QString::fromLatin1("/Mambo <#5>.mp3") << QString::fromLatin1("file:///Mambo <%235>.mp3")
                            << QString::fromLatin1("/Mambo <#5>.mp3");
-    QTest::newRow("data8") << QString::fromLatin1("/a%.txt") << QString::fromLatin1("file:///a%25.txt")
-                           << QString::fromLatin1("/a%.txt");
-    QTest::newRow("data9") << QString::fromLatin1("/a%25.txt") << QString::fromLatin1("file:///a%2525.txt")
-                           << QString::fromLatin1("/a%25.txt");
-    QTest::newRow("data10") << QString::fromLatin1("/%80.txt") << QString::fromLatin1("file:///%2580.txt")
-                            << QString::fromLatin1("/%80.txt");
-    QTest::newRow("data11") << QString::fromLatin1("./a.txt") << QString::fromLatin1("file:a.txt") << QString::fromLatin1("a.txt");
-    QTest::newRow("data12") << QString::fromLatin1("././a.txt") << QString::fromLatin1("file:a.txt") << QString::fromLatin1("a.txt");
-    QTest::newRow("data13") << QString::fromLatin1("b/../a.txt") << QString::fromLatin1("file:a.txt") << QString::fromLatin1("a.txt");
-    QTest::newRow("data14") << QString::fromLatin1("/b/../a.txt") << QString::fromLatin1("file:///a.txt") << QString::fromLatin1("/a.txt");
 }
 
 void tst_QUrl::fromLocalFile()
@@ -1266,6 +1258,41 @@ void tst_QUrl::fromLocalFile()
     QCOMPARE(url.path(), thePath);
 }
 
+void tst_QUrl::fromLocalFileNormalize_data()
+{
+    QTest::addColumn<QString>("theFile"); // should support the fromLocalFile/toLocalFile roundtrip (so no //host or windows path)
+    QTest::addColumn<QString>("theUrl");
+    QTest::addColumn<QString>("urlWithNormalizedPath");
+
+    QTest::newRow("data0") << QString::fromLatin1("/a.txt") << QString::fromLatin1("file:///a.txt") << QString::fromLatin1("file:///a.txt");
+    QTest::newRow("data1") << QString::fromLatin1("a.txt") << QString::fromLatin1("file:a.txt") << QString::fromLatin1("file:a.txt");
+    QTest::newRow("data8") << QString::fromLatin1("/a%.txt") << QString::fromLatin1("file:///a%25.txt")
+                           << QString::fromLatin1("file:///a%25.txt");
+    QTest::newRow("data9") << QString::fromLatin1("/a%25.txt") << QString::fromLatin1("file:///a%2525.txt")
+                           << QString::fromLatin1("file:///a%2525.txt");
+    QTest::newRow("data10") << QString::fromLatin1("/%80.txt") << QString::fromLatin1("file:///%2580.txt")
+                            << QString::fromLatin1("file:///%2580.txt");
+    QTest::newRow("data11") << QString::fromLatin1("./a.txt") << QString::fromLatin1("file:./a.txt") << QString::fromLatin1("file:a.txt");
+    QTest::newRow("data12") << QString::fromLatin1("././a.txt") << QString::fromLatin1("file:././a.txt") << QString::fromLatin1("file:a.txt");
+    QTest::newRow("data13") << QString::fromLatin1("b/../a.txt") << QString::fromLatin1("file:b/../a.txt") << QString::fromLatin1("file:a.txt");
+    QTest::newRow("data14") << QString::fromLatin1("/b/../a.txt") << QString::fromLatin1("file:///b/../a.txt") << QString::fromLatin1("file:///a.txt");
+    QTest::newRow("data15") << QString::fromLatin1("/b/.") << QString::fromLatin1("file:///b/.") << QString::fromLatin1("file:///b");
+}
+
+void tst_QUrl::fromLocalFileNormalize()
+{
+    QFETCH(QString, theFile);
+    QFETCH(QString, theUrl);
+    QFETCH(QString, urlWithNormalizedPath);
+
+    QUrl url = QUrl::fromLocalFile(theFile);
+
+    QCOMPARE(url.toString(QUrl::DecodeReserved), theUrl);
+    QCOMPARE(url.toLocalFile(), theFile); // roundtrip
+    QCOMPARE(url.path(), theFile); // works as well as long as we don't test windows paths
+    QCOMPARE(url.toString(QUrl::NormalizePathSegments), urlWithNormalizedPath);
+}
+
 void tst_QUrl::macTypes()
 {
 #ifndef Q_OS_MAC
@@ -2961,6 +2988,9 @@ void tst_QUrl::fromUserInputWithCwd_data()
     while (it.hasNext()) {
         it.next();
         QUrl url = QUrl::fromLocalFile(it.filePath());
+        if (it.fileName() == QLatin1String(".")) {
+            url = QUrl::fromLocalFile(QDir::currentPath()); // fromUserInput cleans the path
+        }
         QTest::newRow(("file-" + QByteArray::number(c++)).constData())
                       << it.fileName() << QDir::currentPath() << url << url;
     }
@@ -3023,6 +3053,8 @@ void tst_QUrl::fileName_data()
                               << QString() << "tmp.txt" << "tmp.txt";
     QTest::newRow("encoded") << "print:/specials/Print%20To%20File%20(PDF%252FAcrobat)"
                               << "/specials/" << "Print To File (PDF%252FAcrobat)" << "Print To File (PDF%2FAcrobat)";
+    QTest::newRow("endsWithDot") << "file:///temp/."
+                              << "/temp/" << "." << ".";
 }
 
 void tst_QUrl::fileName()
@@ -3515,7 +3547,7 @@ void tst_QUrl::setComponents_data()
                                       << PrettyDecoded << "/path" << "trash:/path";
     QTest::newRow("path-withdotdot") << QUrl("file:///tmp")
                                       << int(Path) << "//tmp/..///root/." << Tolerant << true
-                                      << PrettyDecoded << "/root" << "file:///root";
+                                      << PrettyDecoded << "/tmp/..///root/." << "file:///tmp/..///root/.";
 
     // the other fields can be present and be empty
     // that is, their delimiters would be present, but there would be nothing to one side
diff --git a/tests/auto/corelib/json/tst_qtjson.cpp b/tests/auto/corelib/json/tst_qtjson.cpp
index 165464e7b9..8b2cee5e2f 100644
--- a/tests/auto/corelib/json/tst_qtjson.cpp
+++ b/tests/auto/corelib/json/tst_qtjson.cpp
@@ -1116,6 +1116,12 @@ void tst_QtJson::fromVariant()
     QCOMPARE(QJsonValue::fromVariant(QVariant(stringList)), QJsonValue(jsonArray_string));
     QCOMPARE(QJsonValue::fromVariant(QVariant(variantList)), QJsonValue(jsonArray_variant));
     QCOMPARE(QJsonValue::fromVariant(QVariant(variantMap)), QJsonValue(jsonObject));
+
+    QVERIFY(QJsonValue::fromVariant(QVariant(QJsonValue(true))).isBool());
+    QVERIFY(QJsonValue::fromVariant(QVariant(jsonArray_string)).isArray());
+    QVERIFY(QJsonValue::fromVariant(QVariant(QJsonDocument(jsonArray_string))).isArray());
+    QVERIFY(QJsonValue::fromVariant(QVariant(jsonObject)).isObject());
+    QVERIFY(QJsonValue::fromVariant(QVariant(QJsonDocument(jsonObject))).isObject());
 }
 
 void tst_QtJson::fromVariantMap()
diff --git a/tests/auto/corelib/mimetypes/qmimedatabase/tst_qmimedatabase.cpp b/tests/auto/corelib/mimetypes/qmimedatabase/tst_qmimedatabase.cpp
index 0171c4ac5a..1b4dc020f2 100644
--- a/tests/auto/corelib/mimetypes/qmimedatabase/tst_qmimedatabase.cpp
+++ b/tests/auto/corelib/mimetypes/qmimedatabase/tst_qmimedatabase.cpp
@@ -35,6 +35,11 @@
 
 #include "qstandardpaths.h"
 
+#ifdef Q_OS_UNIX
+#include <sys/types.h>
+#include <sys/stat.h>
+#endif
+
 #include <QtCore/QElapsedTimer>
 #include <QtCore/QFile>
 #include <QtCore/QFileInfo>
@@ -646,6 +651,28 @@ void tst_QMimeDatabase::knownSuffix()
     QCOMPARE(db.suffixForFileName(QString::fromLatin1("foo.tar.bz2")), QString::fromLatin1("tar.bz2"));
 }
 
+void tst_QMimeDatabase::symlinkToFifo() // QTBUG-48529
+{
+#ifdef Q_OS_UNIX
+    QTemporaryDir tempDir;
+    QVERIFY(tempDir.isValid());
+    const QString dir = tempDir.path();
+    const QString fifo = dir + "/fifo";
+    QCOMPARE(mkfifo(QFile::encodeName(fifo), 0006), 0);
+
+    QMimeDatabase db;
+    QCOMPARE(db.mimeTypeForFile(fifo).name(), QString::fromLatin1("inode/fifo"));
+
+    // Now make a symlink to the fifo
+    const QString link = dir + "/link";
+    QVERIFY(QFile::link(fifo, link));
+    QCOMPARE(db.mimeTypeForFile(link).name(), QString::fromLatin1("inode/fifo"));
+
+#else
+    QSKIP("This test requires pipes and symlinks");
+#endif
+}
+
 void tst_QMimeDatabase::findByFileName_data()
 {
     QTest::addColumn<QString>("filePath");
diff --git a/tests/auto/corelib/mimetypes/qmimedatabase/tst_qmimedatabase.h b/tests/auto/corelib/mimetypes/qmimedatabase/tst_qmimedatabase.h
index 2827bd2dc4..4b703f15d7 100644
--- a/tests/auto/corelib/mimetypes/qmimedatabase/tst_qmimedatabase.h
+++ b/tests/auto/corelib/mimetypes/qmimedatabase/tst_qmimedatabase.h
@@ -70,6 +70,7 @@ private slots:
     void suffixes_data();
     void suffixes();
     void knownSuffix();
+    void symlinkToFifo();
     void fromThreads();
 
     // shared-mime-info test suite
diff --git a/tests/auto/corelib/tools/qtimeline/tst_qtimeline.cpp b/tests/auto/corelib/tools/qtimeline/tst_qtimeline.cpp
index 507f7e3992..b588e1fe82 100644
--- a/tests/auto/corelib/tools/qtimeline/tst_qtimeline.cpp
+++ b/tests/auto/corelib/tools/qtimeline/tst_qtimeline.cpp
@@ -93,29 +93,20 @@ void tst_QTimeLine::range()
     QCOMPARE(timeLine.endFrame(), 16);
 
     // Verify that you can change the range in the timeLine
-    timeLine.setFrameRange(10, 20);
+    timeLine.setFrameRange(1000, 2000);
     QSignalSpy spy(&timeLine, &QTimeLine::frameChanged);
     QVERIFY(spy.isValid());
-    timeLine.start();
-#ifdef Q_OS_WINCE
-    QTest::qWait(1000);
-#else
-    QTest::qWait(100);
-#endif
-    QCOMPARE(timeLine.state(), QTimeLine::Running);
+    timeLine.start();  // make sure that the logic works for a running timeline
+    QTRY_COMPARE(timeLine.state(), QTimeLine::Running);
+    timeLine.setCurrentTime(timeLine.duration()/2);
     int oldValue = timeLine.currentFrame();
-    timeLine.setFrameRange(0, 5);
+    timeLine.setFrameRange(0, 500);
     QVERIFY(timeLine.currentFrame() < oldValue);
-    timeLine.setEndFrame(100);
-    timeLine.setStartFrame(50);
+    timeLine.setEndFrame(10000);
+    timeLine.setStartFrame(5000);
     QVERIFY(timeLine.currentFrame() > oldValue);
-    timeLine.setFrameRange(0, 5);
-#ifdef Q_OS_WINCE
-    QTest::qWait(500);
-#else
-    QTest::qWait(50);
-#endif
-    QVERIFY(spy.count() > 1);
+    timeLine.setFrameRange(0, 500);
+    QTRY_VERIFY(spy.count() > 1);
     QVERIFY(timeLine.currentFrame() < oldValue);
 }
 
@@ -123,19 +114,17 @@ void tst_QTimeLine::currentTime()
 {
     QTimeLine timeLine(2000);
     timeLine.setUpdateInterval((timeLine.duration()/2) / 33);
-    QSignalSpy spy(&timeLine, &QTimeLine::valueChanged);
-    QVERIFY(spy.isValid());
     timeLine.setFrameRange(10, 20);
     QCOMPARE(timeLine.currentTime(), 0);
     timeLine.start();
-    QTest::qWait(timeLine.duration()/2);
-    QCOMPARE(timeLine.state(), QTimeLine::Running);
-    QVERIFY(timeLine.currentTime() > timeLine.duration()/2 - timeLine.duration()/10);
-    QVERIFY(timeLine.currentTime() < timeLine.duration()/2 + timeLine.duration()/10);
-    QTest::qWait(timeLine.duration()/4 + timeLine.duration());
-    QCOMPARE(timeLine.state(), QTimeLine::NotRunning);
+    QTRY_COMPARE(timeLine.state(), QTimeLine::Running);
+    QTRY_VERIFY(timeLine.currentTime() > timeLine.duration()/2 - timeLine.duration()/4);
+    QVERIFY(timeLine.currentTime() < timeLine.duration()/2 + timeLine.duration()/4);
+    QTRY_COMPARE(timeLine.state(), QTimeLine::NotRunning);
     QCOMPARE(timeLine.currentTime(), timeLine.duration());
 
+    QSignalSpy spy(&timeLine, &QTimeLine::valueChanged);
+    QVERIFY(spy.isValid());
     spy.clear();
     timeLine.setCurrentTime(timeLine.duration()/2);
     timeLine.setCurrentTime(timeLine.duration()/2);
@@ -144,24 +133,22 @@ void tst_QTimeLine::currentTime()
     QCOMPARE(timeLine.currentTime(), timeLine.duration()/2);
     timeLine.resume();
     // Let it update on its own
-    QTest::qWait(timeLine.duration()/4);
     QCOMPARE(timeLine.state(), QTimeLine::Running);
-    QVERIFY(timeLine.currentTime() > timeLine.duration()/2);
+    QTRY_VERIFY(timeLine.currentTime() > timeLine.duration()/2);
     QVERIFY(timeLine.currentTime() < timeLine.duration());
-    QTest::qWait(timeLine.duration()/4 + timeLine.duration());
-    QCOMPARE(timeLine.state(), QTimeLine::NotRunning);
-    QVERIFY(timeLine.currentTime() == timeLine.duration());
+    QTRY_COMPARE(timeLine.state(), QTimeLine::NotRunning);
+    QCOMPARE(timeLine.currentTime(), timeLine.duration());
 
     // Reverse should decrease the currentTime
     timeLine.setCurrentTime(timeLine.duration()/2);
     timeLine.start();
     // Let it update on its own
-    QTest::qWait(timeLine.duration()/4);
-    QCOMPARE(timeLine.state(), QTimeLine::Running);
     int currentTime = timeLine.currentTime();
+    QTRY_VERIFY(timeLine.currentTime() > currentTime);
+    QCOMPARE(timeLine.state(), QTimeLine::Running);
+    currentTime = timeLine.currentTime();
     timeLine.setDirection(QTimeLine::Backward);
-    QTest::qWait(timeLine.duration()/4);
-    QVERIFY(timeLine.currentTime() < currentTime);
+    QTRY_VERIFY(timeLine.currentTime() < currentTime);
     timeLine.stop();
 }
 
@@ -174,11 +161,9 @@ void tst_QTimeLine::duration()
     QCOMPARE(timeLine.duration(), 1000);
 
     timeLine.start();
-    QTest::qWait(999);
-    QCOMPARE(timeLine.state(), QTimeLine::Running);
-    QVERIFY(timeLine.currentTime() > 900);
-    QTest::qWait(100);
-    QCOMPARE(timeLine.state(), QTimeLine::NotRunning);
+    QTRY_COMPARE(timeLine.state(), QTimeLine::Running);
+    QTRY_VERIFY(timeLine.currentTime() > 0);
+    QTRY_COMPARE(timeLine.state(), QTimeLine::NotRunning);
     QCOMPARE(timeLine.currentTime(), 1000);
     // The duration shouldn't change
     QCOMPARE(timeLine.duration(), 1000);
@@ -187,7 +172,7 @@ void tst_QTimeLine::duration()
 void tst_QTimeLine::frameRate()
 {
     QTimeLine timeLine;
-    timeLine.setFrameRange(10, 20);
+    timeLine.setFrameRange(100, 2000);
     QCOMPARE(timeLine.updateInterval(), 1000 / 25);
     timeLine.setUpdateInterval(1000 / 60);
     QCOMPARE(timeLine.updateInterval(), 1000 / 60);
@@ -213,31 +198,27 @@ void tst_QTimeLine::frameRate()
 
 void tst_QTimeLine::value()
 {
-    QTimeLine timeLine(2000);
-    QVERIFY(timeLine.currentValue() == 0.0);
+    QTimeLine timeLine(5000);
+    QCOMPARE(timeLine.currentValue(), 0.0);
 
     // Default speed
     QSignalSpy spy(&timeLine, &QTimeLine::valueChanged);
     QVERIFY(spy.isValid());
     timeLine.start();
-    QTest::qWait(timeLine.duration()/3);
-    QVERIFY(timeLine.currentValue() > 0);
-    QTest::qWait(timeLine.duration());
-    QCOMPARE(timeLine.state(), QTimeLine::NotRunning);
-    qreal currentValue = timeLine.currentValue();
-    QVERIFY(currentValue == 1);
+    QTRY_VERIFY(timeLine.currentValue() > 0);
+    QTRY_COMPARE(timeLine.state(), QTimeLine::NotRunning);
+    QCOMPARE(timeLine.currentValue(), 1.0);
     QVERIFY(spy.count() > 0);
 
     // Reverse should decrease the value
     timeLine.setCurrentTime(100);
     timeLine.start();
     // Let it update on its own
-    QTest::qWait(500);
     QCOMPARE(timeLine.state(), QTimeLine::Running);
+    QTRY_VERIFY(timeLine.currentValue());
     qreal value = timeLine.currentValue();
     timeLine.setDirection(QTimeLine::Backward);
-    QTest::qWait(1000);
-    QVERIFY(timeLine.currentValue() < value);
+    QTRY_VERIFY(timeLine.currentValue() < value);
     timeLine.stop();
 }
 
@@ -251,22 +232,19 @@ void tst_QTimeLine::currentFrame()
     QSignalSpy spy(&timeLine, &QTimeLine::frameChanged);
     QVERIFY(spy.isValid());
     timeLine.start();
-    QTest::qWait(timeLine.duration()/3);
-    QVERIFY(timeLine.currentFrame() > 10);
-    QTest::qWait(timeLine.duration());
-    QCOMPARE(timeLine.state(), QTimeLine::NotRunning);
+    QTRY_VERIFY(timeLine.currentFrame() > 10);
+    QTRY_COMPARE(timeLine.state(), QTimeLine::NotRunning);
     QCOMPARE(timeLine.currentFrame(), 20);
 
     // Reverse should decrease the value
     timeLine.setCurrentTime(timeLine.duration()/2);
     timeLine.start();
     // Let it update on its own
-    QTest::qWait(timeLine.duration()/4);
     QCOMPARE(timeLine.state(), QTimeLine::Running);
+    QTRY_VERIFY(timeLine.currentTime() > timeLine.duration()/2); // wait for continuation
     int value = timeLine.currentFrame();
     timeLine.setDirection(QTimeLine::Backward);
-    QTest::qWait(timeLine.duration()/2);
-    QVERIFY(timeLine.currentFrame() < value);
+    QTRY_VERIFY(timeLine.currentFrame() < value);
     timeLine.stop();
 }
 
@@ -505,9 +483,8 @@ void tst_QTimeLine::finished()
     QSignalSpy spy(&timeLine, &QTimeLine::finished);
     QVERIFY(spy.isValid());
     timeLine.start();
-    QTest::qWait(timeLine.duration()*2);
+    QTRY_COMPARE(spy.count(), 1);
     QCOMPARE(timeLine.state(), QTimeLine::NotRunning);
-    QCOMPARE(spy.count(), 1);
 
     spy.clear();
     timeLine.start();
@@ -606,16 +583,15 @@ void tst_QTimeLine::resume()
     {
         QCOMPARE(timeLine.currentTime(), 0);
         timeLine.start();
-        QTest::qWait(250);
+        QTRY_VERIFY(timeLine.currentTime() > 0);
         timeLine.stop();
         int oldCurrentTime = timeLine.currentTime();
         QVERIFY(oldCurrentTime > 0);
         QVERIFY(oldCurrentTime < 1000);
         timeLine.resume();
-        QTest::qWait(250);
+        QTRY_VERIFY(timeLine.currentTime() > oldCurrentTime);
         timeLine.stop();
         int currentTime = timeLine.currentTime();
-        QVERIFY(currentTime > oldCurrentTime);
         QVERIFY(currentTime < 1000);
     }
     timeLine.setDirection(QTimeLine::Backward);
@@ -623,13 +599,13 @@ void tst_QTimeLine::resume()
         timeLine.setCurrentTime(1000);
         QCOMPARE(timeLine.currentTime(), 1000);
         timeLine.start();
-        QTest::qWait(250);
+        QTRY_VERIFY(timeLine.currentTime() < 1000);
         timeLine.stop();
         int oldCurrentTime = timeLine.currentTime();
         QVERIFY(oldCurrentTime < 1000);
         QVERIFY(oldCurrentTime > 0);
         timeLine.resume();
-        QTest::qWait(250);
+        QTRY_VERIFY(timeLine.currentTime() < oldCurrentTime);
         timeLine.stop();
         int currentTime = timeLine.currentTime();
         QVERIFY(currentTime < oldCurrentTime);
@@ -643,8 +619,7 @@ void tst_QTimeLine::restart()
     timeLine.setFrameRange(0,9);
 
     timeLine.start();
-    QTest::qWait(timeLine.duration()*2);
-    QCOMPARE(timeLine.currentFrame(), timeLine.endFrame());
+    QTRY_COMPARE(timeLine.currentFrame(), timeLine.endFrame());
     QCOMPARE(timeLine.state(), QTimeLine::NotRunning);
 
     // A restart with the same duration
@@ -652,8 +627,7 @@ void tst_QTimeLine::restart()
     QCOMPARE(timeLine.state(), QTimeLine::Running);
     QCOMPARE(timeLine.currentFrame(), timeLine.startFrame());
     QCOMPARE(timeLine.currentTime(), 0);
-    QTest::qWait(250);
-    QCOMPARE(timeLine.currentFrame(), timeLine.endFrame());
+    QTRY_COMPARE(timeLine.currentFrame(), timeLine.endFrame());
     QCOMPARE(timeLine.state(), QTimeLine::NotRunning);
 
     // Set a smaller duration and restart
@@ -662,8 +636,7 @@ void tst_QTimeLine::restart()
     QCOMPARE(timeLine.state(), QTimeLine::Running);
     QCOMPARE(timeLine.currentFrame(), timeLine.startFrame());
     QCOMPARE(timeLine.currentTime(), 0);
-    QTest::qWait(250);
-    QCOMPARE(timeLine.currentFrame(), timeLine.endFrame());
+    QTRY_COMPARE(timeLine.currentFrame(), timeLine.endFrame());
     QCOMPARE(timeLine.state(), QTimeLine::NotRunning);
 
     // Set a longer duration and restart