1 files changed, 75 insertions, 16 deletions

diff --git a/tests/auto/corelib/thread/qthread/tst_qthread.cpp b/tests/auto/corelib/thread/qthread/tst_qthread.cpp
index 1cade32545..b163235d81 100644
--- a/tests/auto/corelib/thread/qthread/tst_qthread.cpp
+++ b/tests/auto/corelib/thread/qthread/tst_qthread.cpp
@@ -1,5 +1,5 @@
 // Copyright (C) 2021 The Qt Company Ltd.
-// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0-only WITH Qt-GPL-exception-1.0
+// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0-only
 
 #include <QTest>
 #include <QTestEventLoop>
@@ -38,6 +38,8 @@
 
 #include <QtTest/private/qemulationdetector_p.h>
 
+using namespace std::chrono_literals;
+
 class tst_QThread : public QObject
 {
     Q_OBJECT
@@ -51,6 +53,7 @@ private slots:
     void setStackSize();
     void exit();
     void start();
+    void startSlotUsedInStringBasedLookups();
     void terminate();
     void quit();
     void started();
@@ -134,11 +137,13 @@ class Current_Thread : public QThread
 public:
     Qt::HANDLE id;
     QThread *thread;
+    bool runCalledInCurrentThread = false;
 
     void run() override
     {
         id = QThread::currentThreadId();
         thread = QThread::currentThread();
+        runCalledInCurrentThread = thread->isCurrentThread();
     }
 };
 
@@ -245,17 +250,19 @@ public:
         elapsed = 0;
         QElapsedTimer timer;
         timer.start();
+        std::chrono::nanoseconds dur{0};
         switch (sleepType) {
         case Second:
-            sleep(interval);
+            dur = std::chrono::seconds{interval};
             break;
         case Millisecond:
-            msleep(interval);
+            dur = std::chrono::milliseconds{interval};
             break;
         case Microsecond:
-            usleep(interval);
+            dur = std::chrono::microseconds{interval};
             break;
         }
+        sleep(dur);
         elapsed = timer.elapsed();
 
         cond.wakeOne();
@@ -271,6 +278,11 @@ void tst_QThread::currentThreadId()
     QVERIFY(thread.wait(five_minutes));
     QVERIFY(thread.id != nullptr);
     QVERIFY(thread.id != QThread::currentThreadId());
+    QVERIFY(!thread.isCurrentThread());
+    QVERIFY(!thread.thread->isCurrentThread());
+    QVERIFY(thread.QThread::thread()->isCurrentThread());
+    QVERIFY(thread.runCalledInCurrentThread);
+    QVERIFY(qApp->thread()->isCurrentThread());
 }
 
 void tst_QThread::currentThread()
@@ -462,6 +474,56 @@ void tst_QThread::start()
     }
 }
 
+class QThreadStarter : public QObject
+{
+    Q_OBJECT
+public:
+    using QObject::QObject;
+Q_SIGNALS:
+    void start(QThread::Priority);
+};
+
+class QThreadSelfStarter : public QThread
+{
+    Q_OBJECT
+public:
+    using QThread::QThread;
+
+    void check()
+    {
+        QVERIFY(connect(this, SIGNAL(starting(Priority)),
+                        this, SLOT(start(Priority))));
+        QVERIFY(QMetaObject::invokeMethod(this, "start", Q_ARG(Priority, IdlePriority)));
+    }
+
+Q_SIGNALS:
+    void starting(Priority);
+};
+
+void tst_QThread::startSlotUsedInStringBasedLookups()
+{
+    // QTBUG-124723
+
+    QThread thread;
+    {
+        QThreadStarter starter;
+        QVERIFY(QObject::connect(&starter, SIGNAL(start(QThread::Priority)),
+                                 &thread, SLOT(start(QThread::Priority))));
+    }
+    {
+        QThreadSelfStarter selfStarter;
+        selfStarter.check();
+        if (QTest::currentTestFailed())
+            return;
+        selfStarter.exit();
+        selfStarter.wait(30s);
+    }
+    QVERIFY(QMetaObject::invokeMethod(&thread, "start",
+                                      Q_ARG(QThread::Priority, QThread::IdlePriority)));
+    thread.exit();
+    thread.wait(30s);
+}
+
 void tst_QThread::terminate()
 {
 #if defined(Q_OS_ANDROID)
@@ -1225,9 +1287,10 @@ void tst_QThread::isRunningInFinished()
     }
 }
 
-class DummyEventDispatcher : public QAbstractEventDispatcher {
+class DummyEventDispatcher : public QAbstractEventDispatcherV2
+{
+    Q_OBJECT
 public:
-    DummyEventDispatcher() : QAbstractEventDispatcher() {}
     bool processEvents(QEventLoop::ProcessEventsFlags) override {
         visited.storeRelaxed(true);
         emit awake();
@@ -1236,11 +1299,11 @@ public:
     }
     void registerSocketNotifier(QSocketNotifier *) override {}
     void unregisterSocketNotifier(QSocketNotifier *) override {}
-    void registerTimer(int, qint64, Qt::TimerType, QObject *) override {}
-    bool unregisterTimer(int) override { return false; }
+    void registerTimer(Qt::TimerId, Duration, Qt::TimerType, QObject *) override {}
+    bool unregisterTimer(Qt::TimerId) override { return false; }
     bool unregisterTimers(QObject *) override { return false; }
-    QList<TimerInfo> registeredTimers(QObject *) const override { return QList<TimerInfo>(); }
-    int remainingTime(int) override { return 0; }
+    QList<TimerInfoV2> timersForObject(QObject *) const override { return {}; }
+    Duration remainingTime(Qt::TimerId) const override { return 0s; }
     void wakeUp() override {}
     void interrupt() override {}
 
@@ -1351,9 +1414,6 @@ void tst_QThread::quitLock()
 
 void tst_QThread::create()
 {
-#if !QT_CONFIG(cxx11_future)
-    QSKIP("This test requires QThread::create");
-#else
     {
         const auto &function = [](){};
         QScopedPointer<QThread> thread(QThread::create(function));
@@ -1593,7 +1653,6 @@ void tst_QThread::create()
         QVERIFY(!thread);
     }
 #endif // QT_NO_EXCEPTIONS
-#endif // QT_CONFIG(cxx11_future)
 }
 
 void tst_QThread::createDestruction()
@@ -1603,7 +1662,7 @@ void tst_QThread::createDestruction()
             for (;;) {
                 if (QThread::currentThread()->isInterruptionRequested())
                     return;
-                QThread::msleep(1);
+                QThread::sleep(1ms);
             }
         };
 
@@ -1722,7 +1781,7 @@ void tst_QThread::threadIdReuse()
     bool threadIdReused = false;
 
     for (int i = 0; i < 42; i++) {
-        QThread::msleep(1);
+        QThread::sleep(1ms);
 
         Qt::HANDLE threadId2;
         bool waitOk = false;