Port QThreadPool to the new property system

Ported all properties, except activeThreadCount. Marking it dirty may
cause a re-evaluation of properties depending on it, which may reault in
a deadlock in case of trying to read activeThreadCount property which is
being marked as dirty.

Task-number: QTBUG-85520
Change-Id: Id073b0895c89a9e6b05b57ad520db994e550a1c9
Reviewed-by: Fabian Kosmale <fabian.kosmale@qt.io>

1 files changed, 78 insertions, 14 deletions

diff --git a/tests/auto/corelib/thread/qthreadpool/tst_qthreadpool.cpp b/tests/auto/corelib/thread/qthreadpool/tst_qthreadpool.cpp
index 5960ac20a3..00c8a84ca7 100644
--- a/tests/auto/corelib/thread/qthreadpool/tst_qthreadpool.cpp
+++ b/tests/auto/corelib/thread/qthreadpool/tst_qthreadpool.cpp
@@ -104,8 +104,23 @@ private slots:
     void stressTest();
     void takeAllAndIncreaseMaxThreadCount();
     void waitForDoneAfterTake();
+    void bindings();
 
 private:
+    class WaitingTask : public QRunnable
+    {
+    public:
+        QSemaphore waitForStarted, waitToFinish;
+
+        WaitingTask() { setAutoDelete(false); }
+
+        void run() override
+        {
+            waitForStarted.release();
+            waitToFinish.acquire();
+        }
+    };
+
     QMutex m_functionTestMutex;
 };
 
@@ -471,20 +486,6 @@ void tst_QThreadPool::setMaxThreadCount()
 
 void tst_QThreadPool::setMaxThreadCountStartsAndStopsThreads()
 {
-    class WaitingTask : public QRunnable
-    {
-    public:
-        QSemaphore waitForStarted, waitToFinish;
-
-        WaitingTask() { setAutoDelete(false); }
-
-        void run() override
-        {
-            waitForStarted.release();
-            waitToFinish.acquire();
-        }
-    };
-
     QThreadPool threadPool;
     threadPool.setMaxThreadCount(1);
 
@@ -1305,5 +1306,68 @@ void tst_QThreadPool::waitForDoneAfterTake()
 
 }
 
+void tst_QThreadPool::bindings()
+{
+    {
+        QThreadPool pool;
+
+        // expiryTimeout property
+        QProperty<int> expiryTimeout;
+        pool.bindableExpiryTimeout().setBinding(Qt::makePropertyBinding(expiryTimeout));
+        expiryTimeout = 1000;
+        QCOMPARE(pool.expiryTimeout(), 1000);
+
+        QProperty<int> expiryTimeoutObserver;
+        expiryTimeoutObserver.setBinding(pool.bindableExpiryTimeout().makeBinding());
+        pool.setExpiryTimeout(100);
+        QCOMPARE(expiryTimeoutObserver, 100);
+
+        // stackSize property
+        QProperty<uint> stackSize;
+        pool.bindableStackSize().setBinding(Qt::makePropertyBinding(stackSize));
+        stackSize = 1000;
+        QCOMPARE(pool.stackSize(), 1000);
+
+        QProperty<uint> stackSizeObserver;
+        stackSizeObserver.setBinding(pool.bindableStackSize().makeBinding());
+        pool.setStackSize(100);
+        QCOMPARE(stackSizeObserver, 100);
+    }
+
+    // maxThreadCount property
+    {
+        // Make sure changing the max thread count via binding starts new threads
+        QThreadPool pool;
+        WaitingTask task;
+
+        pool.setMaxThreadCount(1);
+        pool.start(&task);
+        pool.start(&task);
+        QVERIFY(task.waitForStarted.tryAcquire(1, 1000));
+
+        // thread limit is 1, cannot start more tasks
+        QVERIFY(!task.waitForStarted.tryAcquire(1, 1000));
+        QCOMPARE(pool.activeThreadCount(), 1);
+
+        QProperty<int> maxThreadCount;
+        pool.bindableMaxThreadCount().setBinding(Qt::makePropertyBinding(maxThreadCount));
+
+        maxThreadCount = 2;
+        QCOMPARE(pool.maxThreadCount(), 2);
+
+        // increasing thread count should allow starting more tasks
+        QVERIFY(task.waitForStarted.tryAcquire(1, 1000));
+        QCOMPARE(pool.activeThreadCount(), 2);
+
+        task.waitToFinish.release(2);
+        pool.waitForDone();
+
+        QProperty<int> maxThreadCountObserver;
+        maxThreadCountObserver.setBinding(pool.bindableMaxThreadCount().makeBinding());
+        pool.setMaxThreadCount(10);
+        QCOMPARE(maxThreadCountObserver, 10);
+    }
+}
+
 QTEST_MAIN(tst_QThreadPool);
 #include "tst_qthreadpool.moc"