Merge remote-tracking branch 'origin/5.14' into 5.15

Change-Id: I851c0328c3c38ea67b5ad115b205ac6a1262706e

2 files changed, 64 insertions, 33 deletions

diff --git a/tests/auto/corelib/kernel/qdeadlinetimer/tst_qdeadlinetimer.cpp b/tests/auto/corelib/kernel/qdeadlinetimer/tst_qdeadlinetimer.cpp
index 35c5e7cb75..db53c3f20c 100644
--- a/tests/auto/corelib/kernel/qdeadlinetimer/tst_qdeadlinetimer.cpp
+++ b/tests/auto/corelib/kernel/qdeadlinetimer/tst_qdeadlinetimer.cpp
@@ -573,12 +573,32 @@ void tst_QDeadlineTimer::stdchrono()
 
     QCOMPARE(deadline.remainingTimeAsDuration(), nanoseconds::zero());
 
+    /*
+        Call QTest::qSleep, and return true if the time actually slept is
+        within \a deviationPercent percent of the requested sleep time.
+        Otherwise, return false, in which case the test should to abort.
+    */
+    auto sleepHelper = [](int ms, int deviationPercent = 10) -> bool {
+        auto before = steady_clock::now();
+        QTest::qSleep(ms);
+        auto after = steady_clock::now();
+        auto diff = duration_cast<milliseconds>(after - before).count();
+        bool inRange = qAbs(diff - ms) < ms * deviationPercent/100.0;
+        if (!inRange)
+            qWarning() << "sleeping" << diff << "instead of" << ms << inRange;
+        return inRange;
+    };
+
     auto steady_before = steady_clock::now();
     auto system_before = system_clock::now();
 
-    QTest::qSleep(minResolution);
+    if (!sleepHelper(minResolution))
+        QSKIP("Slept too long");
     auto now = QDeadlineTimer::current(timerType);
-    QTest::qSleep(minResolution);
+    auto steady_reference = steady_clock::now();
+    auto system_reference = system_clock::now();
+    if (!sleepHelper(minResolution))
+        QSKIP("Slept too long");
 
     auto sampling_start = steady_clock::now();
     auto steady_deadline = now.deadline<steady_clock>();
@@ -599,35 +619,33 @@ void tst_QDeadlineTimer::stdchrono()
     }
 
     {
-        auto diff = duration_cast<milliseconds>(steady_after - steady_deadline);
-        QVERIFY2(diff.count() > minResolution/2, QByteArray::number(qint64(diff.count())));
-        QVERIFY2(diff.count() < 3*minResolution/2, QByteArray::number(qint64(diff.count())));
+        auto reference = duration_cast<milliseconds>(steady_after - steady_reference).count();
+        auto diff = duration_cast<milliseconds>(steady_after - steady_deadline).count();
+        QVERIFY2(diff > reference * 0.9 && diff < reference*1.1, QByteArray::number(qint64(diff)));
         QDeadlineTimer dt_after(steady_after, timerType);
         QVERIFY2(now < dt_after,
                  ("now = " + QLocale().toString(now.deadlineNSecs()) +
                  "; after = " + QLocale().toString(dt_after.deadlineNSecs())).toLatin1());
 
-        diff = duration_cast<milliseconds>(steady_deadline - steady_before);
-        QVERIFY2(diff.count() > minResolution/2, QByteArray::number(qint64(diff.count())));
-        QVERIFY2(diff.count() < 3*minResolution/2, QByteArray::number(qint64(diff.count())));
+        reference = duration_cast<milliseconds>(steady_reference - steady_before).count();
+        diff = duration_cast<milliseconds>(steady_deadline - steady_before).count();
+        QVERIFY2(diff > reference * 0.9 && diff < reference*1.1, QByteArray::number(qint64(diff)));
         QDeadlineTimer dt_before(steady_before, timerType);
         QVERIFY2(now > dt_before,
                  ("now = " + QLocale().toString(now.deadlineNSecs()) +
                  "; before = " + QLocale().toString(dt_before.deadlineNSecs())).toLatin1());
     }
     {
-        auto diff = duration_cast<milliseconds>(system_after - system_deadline);
-        QVERIFY2(diff.count() > minResolution/2, QByteArray::number(qint64(diff.count())));
-        QVERIFY2(diff.count() < 3*minResolution/2, QByteArray::number(qint64(diff.count())));
-        QDeadlineTimer dt_after(system_after, timerType);
+        auto reference = duration_cast<milliseconds>(system_after - system_reference).count();
+        auto diff = duration_cast<milliseconds>(system_after - system_deadline).count();
+        QVERIFY2(diff > reference * 0.9 && diff < reference*1.1, QByteArray::number(qint64(diff)));        QDeadlineTimer dt_after(system_after, timerType);
         QVERIFY2(now < dt_after,
                  ("now = " + QLocale().toString(now.deadlineNSecs()) +
                  "; after = " + QLocale().toString(dt_after.deadlineNSecs())).toLatin1());
 
-        diff = duration_cast<milliseconds>(system_deadline - system_before);
-        QVERIFY2(diff.count() > minResolution/2, QByteArray::number(qint64(diff.count())));
-        QVERIFY2(diff.count() < 3*minResolution/2, QByteArray::number(qint64(diff.count())));
-        QDeadlineTimer dt_before(system_before, timerType);
+        reference = duration_cast<milliseconds>(system_reference - system_before).count();
+        diff = duration_cast<milliseconds>(steady_deadline - steady_before).count();
+        QVERIFY2(diff > reference * 0.9 && diff < reference*1.1, QByteArray::number(qint64(diff)));        QDeadlineTimer dt_before(system_before, timerType);
         QVERIFY2(now > dt_before,
                  ("now = " + QLocale().toString(now.deadlineNSecs()) +
                  "; before = " + QLocale().toString(dt_before.deadlineNSecs())).toLatin1());
diff --git a/tests/auto/corelib/kernel/qelapsedtimer/tst_qelapsedtimer.cpp b/tests/auto/corelib/kernel/qelapsedtimer/tst_qelapsedtimer.cpp
index 4ee3ca361f..bfc4f2ca36 100644
--- a/tests/auto/corelib/kernel/qelapsedtimer/tst_qelapsedtimer.cpp
+++ b/tests/auto/corelib/kernel/qelapsedtimer/tst_qelapsedtimer.cpp
@@ -48,6 +48,7 @@ private Q_SLOTS:
     void validity();
     void basics();
     void elapsed();
+    void msecsTo();
 };
 
 void tst_QElapsedTimer::statics()
@@ -108,30 +109,42 @@ void tst_QElapsedTimer::elapsed()
     t1.start();
 
     QTest::qSleep(2*minResolution);
-    QElapsedTimer t2;
-    t2.start();
-
-    QVERIFY(t1 != t2);
-    QVERIFY(!(t1 == t2));
-    QVERIFY(t1 < t2);
-    QVERIFY(t1.msecsTo(t2) > 0);
 
-    QVERIFY(t1.nsecsElapsed() > 0);
-    QVERIFY(t1.elapsed() > 0);
+    auto nsecs = t1.nsecsElapsed();
+    auto msecs = t1.elapsed();
+    QVERIFY(nsecs > 0);
+    QVERIFY(msecs > 0);
     // the number of elapsed nanoseconds and milliseconds should match
-    QVERIFY(t1.nsecsElapsed() - t1.elapsed() * 1000000 < 1000000);
+    QVERIFY(nsecs - msecs * 1000000 < 1000000);
+
+    if (msecs > 8 * minResolution)
+        QSKIP("Sampling timer took too long, aborting test");
+
     QVERIFY(t1.hasExpired(minResolution));
     QVERIFY(!t1.hasExpired(8*minResolution));
-    QVERIFY(!t2.hasExpired(minResolution));
-
     QVERIFY(!t1.hasExpired(-1));
-    QVERIFY(!t2.hasExpired(-1));
 
     qint64 elapsed = t1.restart();
-    QVERIFY(elapsed > minResolution);
-    QVERIFY(elapsed < 3*minResolution);
-    qint64 diff = t2.msecsTo(t1);
-    QVERIFY(diff < minResolution);
+    QVERIFY(elapsed >= msecs);
+    QVERIFY(elapsed < msecs + 3*minResolution);
+}
+
+void tst_QElapsedTimer::msecsTo()
+{
+    QElapsedTimer t1;
+    t1.start();
+    QTest::qSleep(minResolution);
+    QElapsedTimer t2;
+    t2.start();
+
+    QVERIFY(t1 != t2);
+    QVERIFY(!(t1 == t2));
+    QVERIFY(t1 < t2);
+
+    auto diff = t1.msecsTo(t2);
+    QVERIFY2(diff > 0, QString("difference t1 and t2 is %1").arg(diff).toLatin1());
+    diff = t2.msecsTo(t1);
+    QVERIFY2(diff < 0, QString("difference t2 and t1 is %1").arg(diff).toLatin1());
 }
 
 QTEST_MAIN(tst_QElapsedTimer);