From 6fcfae99d3615c7a850e4933691763097078c8e4 Mon Sep 17 00:00:00 2001 From: "Bradley T. Hughes" Date: Mon, 7 Nov 2011 13:39:35 +0100 Subject: Remove warnings from deprecated atomic operators in autotests Use QAtomic*::load() and ::store() instead of the deprecated cast, assignment, and comparison operators. These will be removed in the near future. The tests for these particular operators have not been changed, though, as the change to remove the operators will also remove the respective tests. Change-Id: I2f24d18992af0c6e0f487d707218e4e84f4bdd12 Reviewed-by: Friedemann Kleint --- .../corelib/thread/qatomicint/tst_qatomicint.cpp | 44 ++--- .../thread/qatomicpointer/tst_qatomicpointer.cpp | 186 ++++++++++----------- tests/auto/corelib/thread/qmutex/tst_qmutex.cpp | 4 +- tests/auto/corelib/thread/qthread/tst_qthread.cpp | 9 +- 4 files changed, 123 insertions(+), 120 deletions(-) (limited to 'tests/auto/corelib/thread') diff --git a/tests/auto/corelib/thread/qatomicint/tst_qatomicint.cpp b/tests/auto/corelib/thread/qatomicint/tst_qatomicint.cpp index bc80a5af4d..3c67f989f8 100644 --- a/tests/auto/corelib/thread/qatomicint/tst_qatomicint.cpp +++ b/tests/auto/corelib/thread/qatomicint/tst_qatomicint.cpp @@ -161,9 +161,9 @@ void tst_QAtomicInt::constructor() { QFETCH(int, value); QAtomicInt atomic1(value); - QCOMPARE(int(atomic1), value); + QCOMPARE(atomic1.load(), value); QAtomicInt atomic2 = value; - QCOMPARE(int(atomic2), value); + QCOMPARE(atomic2.load(), value); } void tst_QAtomicInt::copy_constructor_data() @@ -173,16 +173,16 @@ void tst_QAtomicInt::copy_constructor() { QFETCH(int, value); QAtomicInt atomic1(value); - QCOMPARE(int(atomic1), value); + QCOMPARE(atomic1.load(), value); QAtomicInt atomic2(atomic1); - QCOMPARE(int(atomic2), value); + QCOMPARE(atomic2.load(), value); QAtomicInt atomic3 = atomic1; - QCOMPARE(int(atomic3), value); + QCOMPARE(atomic3.load(), value); QAtomicInt atomic4(atomic2); - QCOMPARE(int(atomic4), value); + QCOMPARE(atomic4.load(), value); QAtomicInt atomic5 = atomic2; - QCOMPARE(int(atomic5), value); + QCOMPARE(atomic5.load(), value); } void tst_QAtomicInt::equality_operator_data() @@ -274,9 +274,10 @@ void tst_QAtomicInt::assignment_operator() QCOMPARE(int(atomic1), newval); atomic1 = value; QCOMPARE(int(atomic1), value); + QAtomicInt atomic2 = newval; atomic1 = atomic2; - QCOMPARE(atomic1, atomic2); + QCOMPARE(atomic1.load(), atomic2.load()); } } @@ -344,7 +345,7 @@ void tst_QAtomicInt::ref() QFETCH(int, value); QAtomicInt x = value; QTEST(x.ref() ? 1 : 0, "result"); - QTEST(int(x), "expected"); + QTEST(x.load(), "expected"); } void tst_QAtomicInt::deref_data() @@ -363,7 +364,7 @@ void tst_QAtomicInt::deref() QFETCH(int, value); QAtomicInt x = value; QTEST(x.deref() ? 1 : 0, "result"); - QTEST(int(x), "expected"); + QTEST(x.load(), "expected"); } void tst_QAtomicInt::isTestAndSetNative() @@ -542,25 +543,25 @@ void tst_QAtomicInt::fetchAndStore() { QAtomicInt atomic = value; QCOMPARE(atomic.fetchAndStoreRelaxed(newval), value); - QCOMPARE(int(atomic), newval); + QCOMPARE(atomic.load(), newval); } { QAtomicInt atomic = value; QCOMPARE(atomic.fetchAndStoreAcquire(newval), value); - QCOMPARE(int(atomic), newval); + QCOMPARE(atomic.load(), newval); } { QAtomicInt atomic = value; QCOMPARE(atomic.fetchAndStoreRelease(newval), value); - QCOMPARE(int(atomic), newval); + QCOMPARE(atomic.load(), newval); } { QAtomicInt atomic = value; QCOMPARE(atomic.fetchAndStoreOrdered(newval), value); - QCOMPARE(int(atomic), newval); + QCOMPARE(atomic.load(), newval); } } @@ -679,28 +680,28 @@ void tst_QAtomicInt::fetchAndAdd() QAtomicInt atomic = value1; result = atomic.fetchAndAddRelaxed(value2); QCOMPARE(result, value1); - QCOMPARE(int(atomic), value1 + value2); + QCOMPARE(atomic.load(), value1 + value2); } { QAtomicInt atomic = value1; result = atomic.fetchAndAddAcquire(value2); QCOMPARE(result, value1); - QCOMPARE(int(atomic), value1 + value2); + QCOMPARE(atomic.load(), value1 + value2); } { QAtomicInt atomic = value1; result = atomic.fetchAndAddRelease(value2); QCOMPARE(result, value1); - QCOMPARE(int(atomic), value1 + value2); + QCOMPARE(atomic.load(), value1 + value2); } { QAtomicInt atomic = value1; result = atomic.fetchAndAddOrdered(value2); QCOMPARE(result, value1); - QCOMPARE(int(atomic), value1 + value2); + QCOMPARE(atomic.load(), value1 + value2); } } @@ -713,7 +714,8 @@ void tst_QAtomicInt::testAndSet_loop() QAtomicInt val=0; for (int i = 0; i < iterations; ++i) { - QVERIFY(val.testAndSetRelaxed(val, val+1)); + int v = val.load(); + QVERIFY(val.testAndSetRelaxed(v, v+1)); if ((i % 1000) == 999) { if (stopWatch.elapsed() > 60 * 1000) { // This test shouldn't run for more than two minutes. @@ -735,7 +737,7 @@ void tst_QAtomicInt::fetchAndAdd_loop() QAtomicInt val=0; for (int i = 0; i < iterations; ++i) { const int prev = val.fetchAndAddRelaxed(1); - QCOMPARE(prev, int(val) -1); + QCOMPARE(prev, val.load() -1); } } @@ -773,7 +775,7 @@ void tst_QAtomicInt::fetchAndAdd_threadedLoop() t1.wait(); t2.wait(); - QCOMPARE(int(val), 0); + QCOMPARE(val.load(), 0); } QTEST_MAIN(tst_QAtomicInt) diff --git a/tests/auto/corelib/thread/qatomicpointer/tst_qatomicpointer.cpp b/tests/auto/corelib/thread/qatomicpointer/tst_qatomicpointer.cpp index 9dde4d2b74..377cdd5544 100644 --- a/tests/auto/corelib/thread/qatomicpointer/tst_qatomicpointer.cpp +++ b/tests/auto/corelib/thread/qatomicpointer/tst_qatomicpointer.cpp @@ -124,15 +124,15 @@ void tst_QAtomicPointer::constructor() { void *one = this; QAtomicPointer atomic1 = one; - QVERIFY(atomic1 == one); + QVERIFY(atomic1.load() == one); void *two = &one; QAtomicPointer atomic2 = two; - QVERIFY(atomic2 == two); + QVERIFY(atomic2.load() == two); void *three = &two; QAtomicPointer atomic3 = three; - QVERIFY(atomic3 == three); + QVERIFY(atomic3.load() == three); } void tst_QAtomicPointer::copy_constructor() @@ -140,20 +140,20 @@ void tst_QAtomicPointer::copy_constructor() void *one = this; QAtomicPointer atomic1 = one; QAtomicPointer atomic1_copy = atomic1; - QVERIFY(atomic1_copy == one); - QCOMPARE(atomic1_copy, atomic1); + QVERIFY(atomic1_copy.load() == one); + QCOMPARE(atomic1_copy.load(), atomic1.load()); void *two = &one; QAtomicPointer atomic2 = two; QAtomicPointer atomic2_copy = atomic2; - QVERIFY(atomic2_copy == two); - QCOMPARE(atomic2_copy, atomic2); + QVERIFY(atomic2_copy.load() == two); + QCOMPARE(atomic2_copy.load(), atomic2.load()); void *three = &two; QAtomicPointer atomic3 = three; QAtomicPointer atomic3_copy = atomic3; - QVERIFY(atomic3_copy == three); - QCOMPARE(atomic3_copy, atomic3); + QVERIFY(atomic3_copy.load() == three); + QCOMPARE(atomic3_copy.load(), atomic3.load()); } void tst_QAtomicPointer::equality_operator() @@ -305,17 +305,17 @@ void tst_QAtomicPointer::testAndSet() QAtomicPointer atomic2 = two; QAtomicPointer atomic3 = three; - QVERIFY(atomic1 == one); - QVERIFY(atomic2 == two); - QVERIFY(atomic3 == three); + QCOMPARE(atomic1.load(), one); + QCOMPARE(atomic2.load(), two); + QVERIFY(atomic3.load() == three); QVERIFY(atomic1.testAndSetRelaxed(one, two)); QVERIFY(atomic2.testAndSetRelaxed(two, three)); QVERIFY(atomic3.testAndSetRelaxed(three, one)); - QVERIFY(atomic1 == two); - QVERIFY(atomic2 == three); - QVERIFY(atomic3 == one); + QVERIFY(atomic1.load() == two); + QVERIFY(atomic2.load() == three); + QVERIFY(atomic3.load() == one); } { @@ -323,17 +323,17 @@ void tst_QAtomicPointer::testAndSet() QAtomicPointer atomic2 = two; QAtomicPointer atomic3 = three; - QVERIFY(atomic1 == one); - QVERIFY(atomic2 == two); - QVERIFY(atomic3 == three); + QCOMPARE(atomic1.load(), one); + QCOMPARE(atomic2.load(), two); + QVERIFY(atomic3.load() == three); QVERIFY(atomic1.testAndSetAcquire(one, two)); QVERIFY(atomic2.testAndSetAcquire(two, three)); QVERIFY(atomic3.testAndSetAcquire(three, one)); - QVERIFY(atomic1 == two); - QVERIFY(atomic2 == three); - QVERIFY(atomic3 == one); + QVERIFY(atomic1.load() == two); + QVERIFY(atomic2.load() == three); + QVERIFY(atomic3.load() == one); } { @@ -341,17 +341,17 @@ void tst_QAtomicPointer::testAndSet() QAtomicPointer atomic2 = two; QAtomicPointer atomic3 = three; - QVERIFY(atomic1 == one); - QVERIFY(atomic2 == two); - QVERIFY(atomic3 == three); + QCOMPARE(atomic1.load(), one); + QCOMPARE(atomic2.load(), two); + QVERIFY(atomic3.load() == three); QVERIFY(atomic1.testAndSetRelease(one, two)); QVERIFY(atomic2.testAndSetRelease(two, three)); QVERIFY(atomic3.testAndSetRelease(three, one)); - QVERIFY(atomic1 == two); - QVERIFY(atomic2 == three); - QVERIFY(atomic3 == one); + QVERIFY(atomic1.load() == two); + QVERIFY(atomic2.load() == three); + QVERIFY(atomic3.load() == one); } { @@ -359,17 +359,17 @@ void tst_QAtomicPointer::testAndSet() QAtomicPointer atomic2 = two; QAtomicPointer atomic3 = three; - QVERIFY(atomic1 == one); - QVERIFY(atomic2 == two); - QVERIFY(atomic3 == three); + QCOMPARE(atomic1.load(), one); + QCOMPARE(atomic2.load(), two); + QVERIFY(atomic3.load() == three); QVERIFY(atomic1.testAndSetOrdered(one, two)); QVERIFY(atomic2.testAndSetOrdered(two, three)); QVERIFY(atomic3.testAndSetOrdered(three, one)); - QVERIFY(atomic1 == two); - QVERIFY(atomic2 == three); - QVERIFY(atomic3 == one); + QVERIFY(atomic1.load() == two); + QVERIFY(atomic2.load() == three); + QVERIFY(atomic3.load() == one); } } @@ -433,17 +433,17 @@ void tst_QAtomicPointer::fetchAndStore() QAtomicPointer atomic2 = two; QAtomicPointer atomic3 = three; - QVERIFY(atomic1 == one); - QVERIFY(atomic2 == two); - QVERIFY(atomic3 == three); + QCOMPARE(atomic1.load(), one); + QCOMPARE(atomic2.load(), two); + QVERIFY(atomic3.load() == three); QCOMPARE(atomic1.fetchAndStoreRelaxed(two), one); QCOMPARE(atomic2.fetchAndStoreRelaxed(three), two); QCOMPARE(atomic3.fetchAndStoreRelaxed(one), three); - QVERIFY(atomic1 == two); - QVERIFY(atomic2 == three); - QVERIFY(atomic3 == one); + QVERIFY(atomic1.load() == two); + QVERIFY(atomic2.load() == three); + QVERIFY(atomic3.load() == one); } { @@ -451,17 +451,17 @@ void tst_QAtomicPointer::fetchAndStore() QAtomicPointer atomic2 = two; QAtomicPointer atomic3 = three; - QVERIFY(atomic1 == one); - QVERIFY(atomic2 == two); - QVERIFY(atomic3 == three); + QCOMPARE(atomic1.load(), one); + QCOMPARE(atomic2.load(), two); + QVERIFY(atomic3.load() == three); QCOMPARE(atomic1.fetchAndStoreAcquire(two), one); QCOMPARE(atomic2.fetchAndStoreAcquire(three), two); QCOMPARE(atomic3.fetchAndStoreAcquire(one), three); - QVERIFY(atomic1 == two); - QVERIFY(atomic2 == three); - QVERIFY(atomic3 == one); + QVERIFY(atomic1.load() == two); + QVERIFY(atomic2.load() == three); + QVERIFY(atomic3.load() == one); } { @@ -469,17 +469,17 @@ void tst_QAtomicPointer::fetchAndStore() QAtomicPointer atomic2 = two; QAtomicPointer atomic3 = three; - QVERIFY(atomic1 == one); - QVERIFY(atomic2 == two); - QVERIFY(atomic3 == three); + QCOMPARE(atomic1.load(), one); + QCOMPARE(atomic2.load(), two); + QVERIFY(atomic3.load() == three); QCOMPARE(atomic1.fetchAndStoreRelease(two), one); QCOMPARE(atomic2.fetchAndStoreRelease(three), two); QCOMPARE(atomic3.fetchAndStoreRelease(one), three); - QVERIFY(atomic1 == two); - QVERIFY(atomic2 == three); - QVERIFY(atomic3 == one); + QVERIFY(atomic1.load() == two); + QVERIFY(atomic2.load() == three); + QVERIFY(atomic3.load() == one); } { @@ -487,17 +487,17 @@ void tst_QAtomicPointer::fetchAndStore() QAtomicPointer atomic2 = two; QAtomicPointer atomic3 = three; - QVERIFY(atomic1 == one); - QVERIFY(atomic2 == two); - QVERIFY(atomic3 == three); + QCOMPARE(atomic1.load(), one); + QCOMPARE(atomic2.load(), two); + QVERIFY(atomic3.load() == three); QCOMPARE(atomic1.fetchAndStoreOrdered(two), one); QCOMPARE(atomic2.fetchAndStoreOrdered(three), two); QCOMPARE(atomic3.fetchAndStoreOrdered(one), three); - QVERIFY(atomic1 == two); - QVERIFY(atomic2 == three); - QVERIFY(atomic3 == one); + QVERIFY(atomic1.load() == two); + QVERIFY(atomic2.load() == three); + QVERIFY(atomic3.load() == one); } } @@ -598,62 +598,62 @@ void tst_QAtomicPointer::fetchAndAdd() { QAtomicPointer pointer1 = pc; - QCOMPARE(quintptr(pointer1.fetchAndAddRelaxed(valueToAdd)), quintptr(pc)); - QCOMPARE(quintptr(pointer1.fetchAndAddRelaxed(-valueToAdd)), quintptr(pc + valueToAdd)); - QCOMPARE(quintptr(static_cast(pointer1)), quintptr(pc)); + QCOMPARE(pointer1.fetchAndAddRelaxed(valueToAdd), pc); + QCOMPARE(pointer1.fetchAndAddRelaxed(-valueToAdd), pc + valueToAdd); + QCOMPARE(pointer1.load(), pc); QAtomicPointer pointer2 = ps; - QCOMPARE(quintptr(pointer2.fetchAndAddRelaxed(valueToAdd)), quintptr(ps)); - QCOMPARE(quintptr(pointer2.fetchAndAddRelaxed(-valueToAdd)), quintptr(ps + valueToAdd)); - QCOMPARE(quintptr(static_cast(pointer2)), quintptr(ps)); + QCOMPARE(pointer2.fetchAndAddRelaxed(valueToAdd), ps); + QCOMPARE(pointer2.fetchAndAddRelaxed(-valueToAdd), ps + valueToAdd); + QCOMPARE(pointer2.load(), ps); QAtomicPointer pointer3 = pi; - QCOMPARE(quintptr(pointer3.fetchAndAddRelaxed(valueToAdd)), quintptr(pi)); - QCOMPARE(quintptr(pointer3.fetchAndAddRelaxed(-valueToAdd)), quintptr(pi + valueToAdd)); - QCOMPARE(quintptr(static_cast(pointer3)), quintptr(pi)); + QCOMPARE(pointer3.fetchAndAddRelaxed(valueToAdd), pi); + QCOMPARE(pointer3.fetchAndAddRelaxed(-valueToAdd), pi + valueToAdd); + QCOMPARE(pointer3.load(), pi); } { QAtomicPointer pointer1 = pc; - QCOMPARE(quintptr(pointer1.fetchAndAddAcquire(valueToAdd)), quintptr(pc)); - QCOMPARE(quintptr(pointer1.fetchAndAddAcquire(-valueToAdd)), quintptr(pc + valueToAdd)); - QCOMPARE(quintptr(static_cast(pointer1)), quintptr(pc)); + QCOMPARE(pointer1.fetchAndAddAcquire(valueToAdd), pc); + QCOMPARE(pointer1.fetchAndAddAcquire(-valueToAdd), pc + valueToAdd); + QCOMPARE(pointer1.load(), pc); QAtomicPointer pointer2 = ps; - QCOMPARE(quintptr(pointer2.fetchAndAddAcquire(valueToAdd)), quintptr(ps)); - QCOMPARE(quintptr(pointer2.fetchAndAddAcquire(-valueToAdd)), quintptr(ps + valueToAdd)); - QCOMPARE(quintptr(static_cast(pointer2)), quintptr(ps)); + QCOMPARE(pointer2.fetchAndAddAcquire(valueToAdd), ps); + QCOMPARE(pointer2.fetchAndAddAcquire(-valueToAdd), ps + valueToAdd); + QCOMPARE(pointer2.load(), ps); QAtomicPointer pointer3 = pi; - QCOMPARE(quintptr(pointer3.fetchAndAddAcquire(valueToAdd)), quintptr(pi)); - QCOMPARE(quintptr(pointer3.fetchAndAddAcquire(-valueToAdd)), quintptr(pi + valueToAdd)); - QCOMPARE(quintptr(static_cast(pointer3)), quintptr(pi)); + QCOMPARE(pointer3.fetchAndAddAcquire(valueToAdd), pi); + QCOMPARE(pointer3.fetchAndAddAcquire(-valueToAdd), pi + valueToAdd); + QCOMPARE(pointer3.load(), pi); } { QAtomicPointer pointer1 = pc; - QCOMPARE(quintptr(pointer1.fetchAndAddRelease(valueToAdd)), quintptr(pc)); - QCOMPARE(quintptr(pointer1.fetchAndAddRelease(-valueToAdd)), quintptr(pc + valueToAdd)); - QCOMPARE(quintptr(static_cast(pointer1)), quintptr(pc)); + QCOMPARE(pointer1.fetchAndAddRelease(valueToAdd), pc); + QCOMPARE(pointer1.fetchAndAddRelease(-valueToAdd), pc + valueToAdd); + QCOMPARE(pointer1.load(), pc); QAtomicPointer pointer2 = ps; - QCOMPARE(quintptr(pointer2.fetchAndAddRelease(valueToAdd)), quintptr(ps)); - QCOMPARE(quintptr(pointer2.fetchAndAddRelease(-valueToAdd)), quintptr(ps + valueToAdd)); - QCOMPARE(quintptr(static_cast(pointer2)), quintptr(ps)); + QCOMPARE(pointer2.fetchAndAddRelease(valueToAdd), ps); + QCOMPARE(pointer2.fetchAndAddRelease(-valueToAdd), ps + valueToAdd); + QCOMPARE(pointer2.load(), ps); QAtomicPointer pointer3 = pi; - QCOMPARE(quintptr(pointer3.fetchAndAddRelease(valueToAdd)), quintptr(pi)); - QCOMPARE(quintptr(pointer3.fetchAndAddRelease(-valueToAdd)), quintptr(pi + valueToAdd)); - QCOMPARE(quintptr(static_cast(pointer3)), quintptr(pi)); + QCOMPARE(pointer3.fetchAndAddRelease(valueToAdd), pi); + QCOMPARE(pointer3.fetchAndAddRelease(-valueToAdd), pi + valueToAdd); + QCOMPARE(pointer3.load(), pi); } { QAtomicPointer pointer1 = pc; - QCOMPARE(quintptr(pointer1.fetchAndAddOrdered(valueToAdd)), quintptr(pc)); - QCOMPARE(quintptr(pointer1.fetchAndAddOrdered(-valueToAdd)), quintptr(pc + valueToAdd)); - QCOMPARE(quintptr(static_cast(pointer1)), quintptr(pc)); + QCOMPARE(pointer1.fetchAndAddOrdered(valueToAdd), pc); + QCOMPARE(pointer1.fetchAndAddOrdered(-valueToAdd), pc + valueToAdd); + QCOMPARE(pointer1.load(), pc); QAtomicPointer pointer2 = ps; - QCOMPARE(quintptr(pointer2.fetchAndAddOrdered(valueToAdd)), quintptr(ps)); - QCOMPARE(quintptr(pointer2.fetchAndAddOrdered(-valueToAdd)), quintptr(ps + valueToAdd)); - QCOMPARE(quintptr(static_cast(pointer2)), quintptr(ps)); + QCOMPARE(pointer2.fetchAndAddOrdered(valueToAdd), ps); + QCOMPARE(pointer2.fetchAndAddOrdered(-valueToAdd), ps + valueToAdd); + QCOMPARE(pointer2.load(), ps); QAtomicPointer pointer3 = pi; - QCOMPARE(quintptr(pointer3.fetchAndAddOrdered(valueToAdd)), quintptr(pi)); - QCOMPARE(quintptr(pointer3.fetchAndAddOrdered(-valueToAdd)), quintptr(pi + valueToAdd)); - QCOMPARE(quintptr(static_cast(pointer3)), quintptr(pi)); + QCOMPARE(pointer3.fetchAndAddOrdered(valueToAdd), pi); + QCOMPARE(pointer3.fetchAndAddOrdered(-valueToAdd), pi + valueToAdd); + QCOMPARE(pointer3.load(), pi); } } diff --git a/tests/auto/corelib/thread/qmutex/tst_qmutex.cpp b/tests/auto/corelib/thread/qmutex/tst_qmutex.cpp index cc2fe653b7..cc36af8b56 100644 --- a/tests/auto/corelib/thread/qmutex/tst_qmutex.cpp +++ b/tests/auto/corelib/thread/qmutex/tst_qmutex.cpp @@ -617,8 +617,8 @@ void tst_QMutex::moreStress() QVERIFY(threads[0].wait(one_minute + 10000)); for (int i = 1; i < threadCount; ++i) QVERIFY(threads[i].wait(10000)); - qDebug("locked %d times", int(MoreStressTestThread::lockCount)); - QCOMPARE(int(MoreStressTestThread::errorCount), 0); + qDebug("locked %d times", MoreStressTestThread::lockCount.load()); + QCOMPARE(MoreStressTestThread::errorCount.load(), 0); } diff --git a/tests/auto/corelib/thread/qthread/tst_qthread.cpp b/tests/auto/corelib/thread/qthread/tst_qthread.cpp index fcf993bb7b..7c0d8cdc48 100644 --- a/tests/auto/corelib/thread/qthread/tst_qthread.cpp +++ b/tests/auto/corelib/thread/qthread/tst_qthread.cpp @@ -123,10 +123,11 @@ public: QAtomicInt activationCount; inline SignalRecorder() - { activationCount = 0; } + : activationCount(0) + { } bool wasActivated() - { return activationCount > 0; } + { return activationCount.load() > 0; } public slots: void slot(); @@ -907,7 +908,7 @@ void tst_QThread::adoptMultipleThreads() QTestEventLoop::instance().enterLoop(5); QVERIFY(!QTestEventLoop::instance().timeout()); - QCOMPARE(int(recorder.activationCount), numThreads); + QCOMPARE(recorder.activationCount.load(), numThreads); } void tst_QThread::adoptMultipleThreadsOverlap() @@ -949,7 +950,7 @@ void tst_QThread::adoptMultipleThreadsOverlap() QTestEventLoop::instance().enterLoop(5); QVERIFY(!QTestEventLoop::instance().timeout()); - QCOMPARE(int(recorder.activationCount), numThreads); + QCOMPARE(recorder.activationCount.load(), numThreads); } // Disconnects on WinCE, so skip this test. -- cgit v1.2.3