1 files changed, 131 insertions, 9 deletions

diff --git a/tests/auto/corelib/kernel/qtimer/tst_qtimer.cpp b/tests/auto/corelib/kernel/qtimer/tst_qtimer.cpp
index 3b10547dc4..262dbea913 100644
--- a/tests/auto/corelib/kernel/qtimer/tst_qtimer.cpp
+++ b/tests/auto/corelib/kernel/qtimer/tst_qtimer.cpp
@@ -38,6 +38,7 @@
 
 #include <qtimer.h>
 #include <qthread.h>
+#include <qelapsedtimer.h>
 
 #if defined Q_OS_UNIX
 #include <unistd.h>
@@ -73,7 +74,12 @@ private slots:
     void recurseOnTimeoutAndStopTimer();
     void singleShotToFunctors();
     void singleShot_chrono();
+    void singleShot_static();
     void crossThreadSingleShotToFunctor();
+    void timerOrder();
+    void timerOrder_data();
+    void timerOrderBackgroundThread();
+    void timerOrderBackgroundThread_data() { timerOrder_data(); }
 
     void dontBlockEvents();
     void postedEventsShouldNotStarveTimers();
@@ -521,7 +527,7 @@ public:
     QBasicTimer m_timer;
 
     int m_interval;
-    QTime m_startedTime;
+    QElapsedTimer m_elapsedTimer;
     QEventLoop eventLoop;
 
     inline RestartedTimerFiresTooSoonObject()
@@ -533,7 +539,7 @@ public:
         static int interval = 1000;
 
         m_interval = interval;
-        m_startedTime.start();
+        m_elapsedTimer.start();
         m_timer.start(interval, this);
 
         // alternate between single-shot and 1 sec
@@ -547,7 +553,7 @@ public:
 
         m_timer.stop();
 
-        int elapsed = m_startedTime.elapsed();
+        int elapsed = m_elapsedTimer.elapsed();
 
         if (elapsed < m_interval / 2) {
             // severely too early!
@@ -585,10 +591,10 @@ public:
 public slots:
     void longLastingSlot()
     {
-        // Don't use timers for this, because we are testing them.
-        QTime time;
-        time.start();
-        while (time.elapsed() < 200) {
+        // Don't use QTimer for this, because we are testing it.
+        QElapsedTimer control;
+        control.start();
+        while (control.elapsed() < 200) {
             for (int c = 0; c < 100000; c++) {} // Mindless looping.
         }
         if (++count >= 2) {
@@ -768,7 +774,7 @@ public:
         quitEventLoop_noexcept();
     }
 
-    static void quitEventLoop_noexcept() Q_DECL_NOTHROW
+    static void quitEventLoop_noexcept() noexcept
     {
         QVERIFY(!_e.isNull());
         _e->quit();
@@ -1033,5 +1039,121 @@ void tst_QTimer::callOnTimeout()
     QVERIFY(!connection);
 }
 
-QTEST_MAIN(tst_QTimer)
+class OrderHelper : public QObject
+{
+    Q_OBJECT
+public:
+    enum CallType
+    {
+        String,
+        PMF,
+        Functor,
+        FunctorNoCtx
+    };
+    Q_ENUM(CallType)
+    QVector<CallType> calls;
+
+    void triggerCall(CallType callType)
+    {
+        switch (callType)
+        {
+        case String:
+            QTimer::singleShot(0, this, SLOT(stringSlot()));
+            break;
+        case PMF:
+            QTimer::singleShot(0, this, &OrderHelper::pmfSlot);
+            break;
+        case Functor:
+            QTimer::singleShot(0, this, [this]() { functorSlot(); });
+            break;
+        case FunctorNoCtx:
+            QTimer::singleShot(0, [this]() { functorNoCtxSlot(); });
+            break;
+        }
+    }
+
+public slots:
+    void stringSlot() { calls << String; }
+    void pmfSlot() { calls << PMF; }
+    void functorSlot() { calls << Functor; }
+    void functorNoCtxSlot() { calls << FunctorNoCtx; }
+};
+
+Q_DECLARE_METATYPE(OrderHelper::CallType)
+
+void tst_QTimer::timerOrder()
+{
+    QFETCH(QVector<OrderHelper::CallType>, calls);
+
+    OrderHelper helper;
+
+    for (const auto call : calls)
+        helper.triggerCall(call);
+
+    QTRY_COMPARE(helper.calls, calls);
+}
+
+void tst_QTimer::timerOrder_data()
+{
+    QTest::addColumn<QVector<OrderHelper::CallType>>("calls");
+
+    QVector<OrderHelper::CallType> calls = {
+        OrderHelper::String, OrderHelper::PMF,
+        OrderHelper::Functor, OrderHelper::FunctorNoCtx
+    };
+    std::sort(calls.begin(), calls.end());
+
+    int permutation = 0;
+    do {
+        QTest::addRow("permutation=%d", permutation) << calls;
+        ++permutation;
+    } while (std::next_permutation(calls.begin(), calls.end()));
+}
+
+void tst_QTimer::timerOrderBackgroundThread()
+{
+#if !QT_CONFIG(cxx11_future)
+    QSKIP("This test requires QThread::create");
+#else
+    auto *thread = QThread::create([this]() { timerOrder(); });
+    thread->start();
+    QVERIFY(thread->wait());
+    delete thread;
+#endif
+}
+
+struct StaticSingleShotUser
+{
+    StaticSingleShotUser()
+    {
+        for (auto call : calls())
+            helper.triggerCall(call);
+    }
+    OrderHelper helper;
+
+    static QVector<OrderHelper::CallType> calls()
+    {
+        return {OrderHelper::String, OrderHelper::PMF,
+                OrderHelper::Functor, OrderHelper::FunctorNoCtx};
+    }
+};
+
+static StaticSingleShotUser *s_staticSingleShotUser = nullptr;
+
+void tst_QTimer::singleShot_static()
+{
+    QCoreApplication::processEvents();
+    QCOMPARE(s_staticSingleShotUser->helper.calls, s_staticSingleShotUser->calls());
+}
+
+// NOTE: to prevent any static initialization order fiasco, we handle QTEST_MAIN
+//       ourselves, but instantiate the staticSingleShotUser before qApp
+
+int main(int argc, char *argv[])
+{
+    StaticSingleShotUser staticSingleShotUser;
+    s_staticSingleShotUser = &staticSingleShotUser;
+    QTEST_MAIN_IMPL(tst_QTimer)
+}
+
 #include "tst_qtimer.moc"