From 82e715b2770258fa2c536aeae1f46c7fccdcdecf Mon Sep 17 00:00:00 2001 From: Holger Ihrig Date: Fri, 26 Aug 2011 12:56:14 +0200 Subject: Moving relevant tests to corelib/thread Task-number: QTBUG-21066 Change-Id: Ia16fa8961f1a73f4da6709197b5dd9929c16583f Reviewed-on: http://codereview.qt.nokia.com/3663 Reviewed-by: Qt Sanity Bot Reviewed-by: Rohan McGovern Reviewed-by: Jason McDonald --- tests/auto/corelib/thread/qreadlocker/.gitignore | 1 + .../corelib/thread/qreadlocker/qreadlocker.pro | 4 + .../corelib/thread/qreadlocker/tst_qreadlocker.cpp | 231 +++++++++++++++++++++ 3 files changed, 236 insertions(+) create mode 100644 tests/auto/corelib/thread/qreadlocker/.gitignore create mode 100644 tests/auto/corelib/thread/qreadlocker/qreadlocker.pro create mode 100644 tests/auto/corelib/thread/qreadlocker/tst_qreadlocker.cpp (limited to 'tests/auto/corelib/thread/qreadlocker') diff --git a/tests/auto/corelib/thread/qreadlocker/.gitignore b/tests/auto/corelib/thread/qreadlocker/.gitignore new file mode 100644 index 0000000000..2539362670 --- /dev/null +++ b/tests/auto/corelib/thread/qreadlocker/.gitignore @@ -0,0 +1 @@ +tst_qreadlocker diff --git a/tests/auto/corelib/thread/qreadlocker/qreadlocker.pro b/tests/auto/corelib/thread/qreadlocker/qreadlocker.pro new file mode 100644 index 0000000000..ee533070a7 --- /dev/null +++ b/tests/auto/corelib/thread/qreadlocker/qreadlocker.pro @@ -0,0 +1,4 @@ +load(qttest_p4) +SOURCES += tst_qreadlocker.cpp +QT = core +CONFIG += parallel_test diff --git a/tests/auto/corelib/thread/qreadlocker/tst_qreadlocker.cpp b/tests/auto/corelib/thread/qreadlocker/tst_qreadlocker.cpp new file mode 100644 index 0000000000..3ec9f1cb25 --- /dev/null +++ b/tests/auto/corelib/thread/qreadlocker/tst_qreadlocker.cpp @@ -0,0 +1,231 @@ +/**************************************************************************** +** +** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies). +** All rights reserved. +** Contact: Nokia Corporation (qt-info@nokia.com) +** +** This file is part of the test suite of the Qt Toolkit. +** +** $QT_BEGIN_LICENSE:LGPL$ +** GNU Lesser General Public License Usage +** This file may be used under the terms of the GNU Lesser General Public +** License version 2.1 as published by the Free Software Foundation and +** appearing in the file LICENSE.LGPL included in the packaging of this +** file. Please review the following information to ensure the GNU Lesser +** General Public License version 2.1 requirements will be met: +** http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html. +** +** In addition, as a special exception, Nokia gives you certain additional +** rights. These rights are described in the Nokia Qt LGPL Exception +** version 1.1, included in the file LGPL_EXCEPTION.txt in this package. +** +** GNU General Public License Usage +** Alternatively, this file may be used under the terms of the GNU General +** Public License version 3.0 as published by the Free Software Foundation +** and appearing in the file LICENSE.GPL included in the packaging of this +** file. Please review the following information to ensure the GNU General +** Public License version 3.0 requirements will be met: +** http://www.gnu.org/copyleft/gpl.html. +** +** Other Usage +** Alternatively, this file may be used in accordance with the terms and +** conditions contained in a signed written agreement between you and Nokia. +** +** +** +** +** +** $QT_END_LICENSE$ +** +****************************************************************************/ + + +#include + +#include +#include +#include +#include + +//TESTED_CLASS= +//TESTED_FILES= + +class tst_QReadLockerThread : public QThread +{ +public: + QReadWriteLock lock; + QSemaphore semaphore, testSemaphore; + + void waitForTest() + { + semaphore.release(); + testSemaphore.acquire(); + } +}; + +class tst_QReadLocker : public QObject +{ + Q_OBJECT + +public: + tst_QReadLocker(); + ~tst_QReadLocker(); + + tst_QReadLockerThread *thread; + + void waitForThread() + { + thread->semaphore.acquire(); + } + void releaseThread() + { + thread->testSemaphore.release(); + } + +private slots: + void scopeTest(); + void unlockAndRelockTest(); + void lockerStateTest(); +}; + +tst_QReadLocker::tst_QReadLocker() +{ +} + +tst_QReadLocker::~tst_QReadLocker() +{ +} + +void tst_QReadLocker::scopeTest() +{ + class ScopeTestThread : public tst_QReadLockerThread + { + public: + void run() + { + waitForTest(); + + { + QReadLocker locker(&lock); + waitForTest(); + } + + waitForTest(); + } + }; + + thread = new ScopeTestThread; + thread->start(); + + waitForThread(); + // lock should be unlocked before entering the scope that creates the QReadLocker + QVERIFY(thread->lock.tryLockForWrite()); + thread->lock.unlock(); + releaseThread(); + + waitForThread(); + // lock should be locked by the QReadLocker + QVERIFY(!thread->lock.tryLockForWrite()); + releaseThread(); + + waitForThread(); + // lock should be unlocked when the QReadLocker goes out of scope + QVERIFY(thread->lock.tryLockForWrite()); + thread->lock.unlock(); + releaseThread(); + + QVERIFY(thread->wait()); + + delete thread; + thread = 0; +} + + +void tst_QReadLocker::unlockAndRelockTest() +{ + class UnlockAndRelockThread : public tst_QReadLockerThread + { + public: + void run() + { + QReadLocker locker(&lock); + + waitForTest(); + + locker.unlock(); + + waitForTest(); + + locker.relock(); + + waitForTest(); + } + }; + + thread = new UnlockAndRelockThread; + thread->start(); + + waitForThread(); + // lock should be locked by the QReadLocker + QVERIFY(!thread->lock.tryLockForWrite()); + releaseThread(); + + waitForThread(); + // lock has been explicitly unlocked via QReadLocker + QVERIFY(thread->lock.tryLockForWrite()); + thread->lock.unlock(); + releaseThread(); + + waitForThread(); + // lock has been explicitly relocked via QReadLocker + QVERIFY(!thread->lock.tryLockForWrite()); + releaseThread(); + + QVERIFY(thread->wait()); + + delete thread; + thread = 0; +} + +void tst_QReadLocker::lockerStateTest() +{ + class LockerStateThread : public tst_QReadLockerThread + { + public: + void run() + { + { + QReadLocker locker(&lock); + locker.relock(); + locker.unlock(); + + waitForTest(); + } + + waitForTest(); + } + }; + + thread = new LockerStateThread; + thread->start(); + + waitForThread(); + // even though we relock() after creating the QReadLocker, it shouldn't lock the lock more than once + QVERIFY(thread->lock.tryLockForWrite()); + thread->lock.unlock(); + releaseThread(); + + waitForThread(); + // if we call QReadLocker::unlock(), its destructor should do nothing + QVERIFY(thread->lock.tryLockForWrite()); + thread->lock.unlock(); + releaseThread(); + + QVERIFY(thread->wait()); + + delete thread; + thread = 0; +} + +QTEST_MAIN(tst_QReadLocker) +#include "tst_qreadlocker.moc" -- cgit v1.2.3