/****************************************************************************

**

** 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$

** No Commercial Usage

** This file contains pre-release code and may not be distributed.

** You may use this file in accordance with the terms and conditions

** contained in the Technology Preview License Agreement accompanying

** this package.

**

** GNU Lesser General Public License Usage

** Alternatively, 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.

**

** If you have questions regarding the use of this file, please contact

** Nokia at qt-info@nokia.com.

**

**

**

**

**

**

**

**

** $QT_END_LICENSE$

**

****************************************************************************/

#include <QtTest/QtTest>

#include <qcoreapplication.h>

#include <qreadwritelock.h>

#include <qmutex.h>

#include <qthread.h>

#include <qwaitcondition.h>

#ifdef Q_OS_UNIX

#include <unistd.h>

#endif

#if defined(Q_OS_WIN32) || defined(Q_OS_WINCE)

#include <windows.h>

#define sleep(X) Sleep(X)

#endif

//on solaris, threads that loop one the release bool variable

//needs to sleep more than 1 usec.

#ifdef Q_OS_SOLARIS

# define RWTESTSLEEP usleep(10);

#else

# define RWTESTSLEEP usleep(1);

#endif

#include <stdio.h>

//TESTED_CLASS=

//TESTED_FILES=

class tst_QReadWriteLock : public QObject

{

    Q_OBJECT

public:

    tst_QReadWriteLock();

    virtual ~tst_QReadWriteLock();

/*

    Singlethreaded tests

*/

private slots:

void constructDestruct();

void readLockUnlock();

void writeLockUnlock();

void readLockUnlockLoop();

void writeLockUnlockLoop();

void readLockLoop();

void writeLockLoop();

void readWriteLockUnlockLoop();

void tryReadLock();

void tryWriteLock();

/*

    Multithreaded tests

*/

private slots:

void readLockBlockRelease();

void writeLockBlockRelease();

void multipleReadersBlockRelease();

void multipleReadersLoop();

void multipleWritersLoop();

void multipleReadersWritersLoop();

void countingTest();

void limitedReaders();

void deleteOnUnlock();

/*

    Performance tests

*/

private slots:

void uncontendedLocks();

    // recursive locking tests

    void recursiveReadLock();

    void recursiveWriteLock();

};

tst_QReadWriteLock::tst_QReadWriteLock()

{

}

tst_QReadWriteLock::~tst_QReadWriteLock()

{

}

void tst_QReadWriteLock::constructDestruct()

{

    {

        QReadWriteLock rwlock;

    }

}

void tst_QReadWriteLock::readLockUnlock()

{

     QReadWriteLock rwlock;

     rwlock.lockForRead();

     rwlock.unlock();

}

void tst_QReadWriteLock::writeLockUnlock()

{

     QReadWriteLock rwlock;

     rwlock.lockForWrite();

     rwlock.unlock();

}

void tst_QReadWriteLock::readLockUnlockLoop()

{

    QReadWriteLock rwlock;

    int runs=10000;

    int i;

    for (i=0; i<runs; ++i) {

        rwlock.lockForRead();

        rwlock.unlock();

    }

}

void tst_QReadWriteLock::writeLockUnlockLoop()

{

    QReadWriteLock rwlock;

    int runs=10000;

    int i;

    for (i=0; i<runs; ++i) {

        rwlock.lockForWrite();

        rwlock.unlock();

    }

}

void tst_QReadWriteLock::readLockLoop()

{

    QReadWriteLock rwlock;

    int runs=10000;

    int i;

    for (i=0; i<runs; ++i) {

        rwlock.lockForRead();

    }

    for (i=0; i<runs; ++i) {

        rwlock.unlock();

    }

}

void tst_QReadWriteLock::writeLockLoop()

{

    /*

        If you include this, the test should print one line

        and then block.

    */

#if 0

    QReadWriteLock rwlock;

    int runs=10000;

    int i;

    for (i=0; i<runs; ++i) {

        rwlock.lockForWrite();

        qDebug("I am going to block now.");

    }

#endif

}

void tst_QReadWriteLock::readWriteLockUnlockLoop()

{

    QReadWriteLock rwlock;

    int runs=10000;

    int i;

    for (i=0; i<runs; ++i) {

        rwlock.lockForRead();

        rwlock.unlock();

        rwlock.lockForWrite();

        rwlock.unlock();

    }

}

QAtomicInt lockCount(0);

QReadWriteLock readWriteLock;

QSemaphore testsTurn;

QSemaphore threadsTurn;

void tst_QReadWriteLock::tryReadLock()

{

    QReadWriteLock rwlock;

    QVERIFY(rwlock.tryLockForRead());

    rwlock.unlock();

    QVERIFY(rwlock.tryLockForRead());

    rwlock.unlock();

    rwlock.lockForRead();

    rwlock.lockForRead();

    QVERIFY(rwlock.tryLockForRead());

    rwlock.unlock();

    rwlock.unlock();

    rwlock.unlock();

    rwlock.lockForWrite();

    QVERIFY(!rwlock.tryLockForRead());

    rwlock.unlock();

    // functionality test

    {

        class Thread : public QThread

        {

        public:

            void run()

            {

                testsTurn.release();

                threadsTurn.acquire();

                QVERIFY(!readWriteLock.tryLockForRead());

                testsTurn.release();

                threadsTurn.acquire();

                QVERIFY(readWriteLock.tryLockForRead());

                lockCount.ref();

                QVERIFY(readWriteLock.tryLockForRead());

                lockCount.ref();

                lockCount.deref();

                readWriteLock.unlock();

                lockCount.deref();

                readWriteLock.unlock();

                testsTurn.release();

                threadsTurn.acquire();

                QTime timer;

                timer.start();

                QVERIFY(!readWriteLock.tryLockForRead(1000));

                QVERIFY(timer.elapsed() >= 1000);

                testsTurn.release();

                threadsTurn.acquire();

                timer.start();

                QVERIFY(readWriteLock.tryLockForRead(1000));

                QVERIFY(timer.elapsed() <= 1000);

                lockCount.ref();

                QVERIFY(readWriteLock.tryLockForRead(1000));

                lockCount.ref();

                lockCount.deref();

                readWriteLock.unlock();

                lockCount.deref();

                readWriteLock.unlock();

                testsTurn.release();

                threadsTurn.acquire();

            }

        };

        Thread thread;

        thread.start();

        testsTurn.acquire();

        readWriteLock.lockForWrite();

        QVERIFY(lockCount.testAndSetRelaxed(0, 1));

        threadsTurn.release();

        testsTurn.acquire();

        QVERIFY(lockCount.testAndSetRelaxed(1, 0));

        readWriteLock.unlock();

        threadsTurn.release();

        testsTurn.acquire();

        readWriteLock.lockForWrite();

        QVERIFY(lockCount.testAndSetRelaxed(0, 1));

        threadsTurn.release();

        testsTurn.acquire();

        QVERIFY(lockCount.testAndSetRelaxed(1, 0));

        readWriteLock.unlock();

        threadsTurn.release();

        // stop thread

        testsTurn.acquire();

        threadsTurn.release();

        thread.wait();

    }

}

void tst_QReadWriteLock::tryWriteLock()

{

    {

        QReadWriteLock rwlock;

        QVERIFY(rwlock.tryLockForWrite());

        rwlock.unlock();

        QVERIFY(rwlock.tryLockForWrite());

        rwlock.unlock();

        rwlock.lockForWrite();

        QVERIFY(!rwlock.tryLockForWrite());

        QVERIFY(!rwlock.tryLockForWrite());

        rwlock.unlock();

        rwlock.lockForRead();

        QVERIFY(!rwlock.tryLockForWrite());

        rwlock.unlock();

    }

    {

        QReadWriteLock rwlock(QReadWriteLock::Recursive);

        QVERIFY(rwlock.tryLockForWrite());

        rwlock.unlock();

        QVERIFY(rwlock.tryLockForWrite());

        rwlock.unlock();

        rwlock.lockForWrite();

        QVERIFY(rwlock.tryLockForWrite());

        QVERIFY(rwlock.tryLockForWrite());

        rwlock.unlock();

        rwlock.unlock();

        rwlock.unlock();

        rwlock.lockForRead();

        QVERIFY(!rwlock.tryLockForWrite());

        rwlock.unlock();

    }

    // functionality test

    {

        class Thread : public QThread

        {

        public:

            void run()

            {

                testsTurn.release();

                threadsTurn.acquire();

                Q_ASSERT(!readWriteLock.tryLockForWrite());

                testsTurn.release();

                threadsTurn.acquire();

                Q_ASSERT(readWriteLock.tryLockForWrite());

                Q_ASSERT(lockCount.testAndSetRelaxed(0, 1));

                Q_ASSERT(lockCount.testAndSetRelaxed(1, 0));

                readWriteLock.unlock();

                testsTurn.release();

                threadsTurn.acquire();

                Q_ASSERT(!readWriteLock.tryLockForWrite(1000));

                testsTurn.release();

                threadsTurn.acquire();

                Q_ASSERT(readWriteLock.tryLockForWrite(1000));

                Q_ASSERT(lockCount.testAndSetRelaxed(0, 1));

                Q_ASSERT(lockCount.testAndSetRelaxed(1, 0));

                readWriteLock.unlock();

                testsTurn.release();

                threadsTurn.acquire();

            }

        };

        Thread thread;

        thread.start();

        testsTurn.acquire();

        readWriteLock.lockForRead();

        lockCount.ref();

        threadsTurn.release();

        testsTurn.acquire();

        lockCount.deref();

        readWriteLock.unlock();

        threadsTurn.release();

        testsTurn.acquire();

        readWriteLock.lockForRead();

        lockCount.ref();

        threadsTurn.release();

        testsTurn.acquire();

        lockCount.deref();

        readWriteLock.unlock();

        threadsTurn.release();

        // stop thread

        testsTurn.acquire();

        threadsTurn.release();

        thread.wait();

    }

}

bool threadDone;

volatile bool release;

/*

    write-lock

    unlock

    set threadone

*/

class WriteLockThread : public QThread

{

public:

    QReadWriteLock &testRwlock;

    inline WriteLockThread(QReadWriteLock &l) : testRwlock(l) { }

    void run()

    {

        testRwlock.lockForWrite();

        testRwlock.unlock();

        threadDone=true;

    }

};

/*

    read-lock

    unlock

    set threadone

*/

class ReadLockThread : public QThread

{

public:

    QReadWriteLock &testRwlock;

    inline ReadLockThread(QReadWriteLock &l) : testRwlock(l) { }

    void run()

    {

        testRwlock.lockForRead();

        testRwlock.unlock();

        threadDone=true;

    }

};

/*

    write-lock

    wait for release==true

    unlock

*/

class WriteLockReleasableThread : public QThread

{

public:

    QReadWriteLock &testRwlock;

    inline WriteLockReleasableThread(QReadWriteLock &l) : testRwlock(l) { }

    void run()

    {

        testRwlock.lockForWrite();

        while(release==false) {

            RWTESTSLEEP

        }

        testRwlock.unlock();

    }

};

/*

    read-lock

    wait for release==true

    unlock

*/

class ReadLockReleasableThread : public QThread

{

public:

    QReadWriteLock &testRwlock;

    inline ReadLockReleasableThread(QReadWriteLock &l) : testRwlock(l) { }

    void run()

    {

        testRwlock.lockForRead();

        while(release==false) {

            RWTESTSLEEP

        }

        testRwlock.unlock();

    }

};

/*

    for(runTime msecs)

        read-lock

        msleep(holdTime msecs)

        release lock

        msleep(waitTime msecs)

*/

class ReadLockLoopThread : public QThread

{

public:

    QReadWriteLock &testRwlock;

    int runTime;

    int holdTime;

    int waitTime;

    bool print;

    QTime t;

    inline ReadLockLoopThread(QReadWriteLock &l, int runTime, int holdTime=0, int waitTime=0, bool print=false)

    :testRwlock(l)

    ,runTime(runTime)

    ,holdTime(holdTime)

    ,waitTime(waitTime)

    ,print(print)

    { }

    void run()

    {