src/contrib/libqxt-2007-10-24/tests/filelock/main.cpp

   1 /** ***** QxtFileLock test ***** */
   2 #include <QTest>
   3 #include <QFile>
   4 #include <QxtFileLock>
   5 #include <QxtJob>
   6 #include <QMutex>
   7 #include <QWaitCondition>
   8
   9 class QxtFileLockTest: public QObject
  10 {
  11     Q_OBJECT
  12 private:
  13     QFile * file1;
  14     QFile * file2;
  15
  16
  17 private slots:
  18     void initTestCase()
  19     {
  20         file1=new QFile("lock.file");
  21         file2=new QFile("lock.file");
  22         QVERIFY(file1->open(QIODevice::ReadWrite));
  23         QVERIFY(file2->open(QIODevice::ReadWrite));
  24     }
  25
  26
  27     ///read and write lock on the same handle
  28     void rw_same()
  29     {
  30         QxtFileLock lock1(file1,0x10,20,QxtFileLock::ReadLock);
  31         QVERIFY(lock1.lock());
  32         QxtFileLock lock2(file1,0x10,20,QxtFileLock::WriteLock);
  33         QVERIFY(lock2.lock());
  34     }
  35
  36     ///Trying to readlock the same region with DIFFERENT handles
  37     void rr_different()
  38     {
  39         QxtFileLock lock1(file1,0x10,20,QxtFileLock::ReadLock);
  40         QxtFileLock lock2(file2,0x10,20,QxtFileLock::ReadLock);
  41         QVERIFY(lock1.lock() && lock2.lock());
  42     }
  43
  44     ///Trying to lock the same region with DIFFERENT handles and different locks
  45     void rw_different()
  46     {
  47         QxtFileLock lock1(file1,0x10,20,QxtFileLock::ReadLock);
  48         QxtFileLock lock2(file2,0x10,20,QxtFileLock::WriteLock);
  49         QVERIFY(lock1.lock() && !lock2.lock());
  50     }
  51
  52     ///Trying to writelock the same region with DIFFERENT handles
  53     void ww_different()
  54     {
  55         QxtFileLock lock1(file1,0x10,20,QxtFileLock::WriteLock);
  56         QxtFileLock lock2(file2,0x10,20,QxtFileLock::WriteLock);
  57         QVERIFY(lock1.lock() && !lock2.lock());
  58     }
  59
  60     ///Trying to writelock the different regions with DIFFERENT handles
  61     void ww_different_region()
  62     {
  63         QxtFileLock lock1(file1,0x10   ,20,QxtFileLock::WriteLock);
  64         QxtFileLock lock2(file2,0x10+21,20,QxtFileLock::WriteLock);
  65         QVERIFY(lock1.lock() && lock2.lock());
  66     }
  67
  68     ///different region, different handles, different locks
  69     void rw_different_region()
  70     {
  71         QxtFileLock lock1(file1,0x10   ,20,QxtFileLock::ReadLock);
  72         QxtFileLock lock2(file2,0x10+21,20,QxtFileLock::WriteLock);
  73         QVERIFY(lock1.lock() && lock2.lock());
  74     }
  75     ///different region, same handles, different locks
  76     void rw_same_region()
  77     {
  78         QxtFileLock lock1(file1,0x10   ,20,QxtFileLock::ReadLock);
  79         QxtFileLock lock2(file1,0x10+21,20,QxtFileLock::WriteLock);
  80         QVERIFY(lock1.lock() && lock2.lock());
  81     }
  82     void cleanupTestCase()
  83     {
  84         delete file1;
  85         delete file2;
  86     }
  87
  88 };
  89 #include <QThread>
  90 #include <qxtsignalwaiter.h>
  91
  92 class Q43Thread : public QThread
  93 {
  94 public:
  95     void run()
  96     {
  97         exec();
  98     }
  99 }
 100 ; /// qt < 4.3 backwards compatibility
 101
 102 ///this is a job hack, not part of the testcase, ignore it if you don't what it is
 103
 104 ///here is the interesting part of the job. this executes one lock on a spefic thread and asserts the result
 105 class LockJob : public QxtJob
 106 {
 107 public:
 108     LockJob(QxtFileLock*f,bool expectedresult):QxtJob()
 109     {
 110         lock =f;
 111         expected=expectedresult;
 112     }
 113     QxtFileLock*lock ;
 114     bool expected;
 115     virtual void run()
 116     {
 117         qDebug("locking on %p",QThread::currentThread ());
 118         QVERIFY(lock ->lock ()==expected);
 119     }
 120     void exec(QThread * o)
 121     {
 122          QxtJob::exec(o);
 123          join();
 124      }
 125 };
 126
 127
 128 class QxtFileLockThreadTest : public QObject
 129 {
 130     Q_OBJECT
 131 private:
 132     Q43Thread t1;
 133     Q43Thread t2;
 134
 135 private slots:
 136     void initTestCase()
 137     {
 138         qDebug("main thread is %p",QThread::currentThread ());
 139
 140         QxtSignalWaiter w1(&t1,SIGNAL(started()));
 141         t1.start();
 142         QVERIFY(t1.isRunning());
 143         t2.start();
 144         QVERIFY(t2.isRunning());
 145     }
 146
 147
 148     ///Trying to writelock the same region twice
 149     void ww_same()
 150     {
 151         QFile file1("lock.file");
 152         QVERIFY(file1.open(QIODevice::ReadWrite));
 153         QFile file2("lock.file");
 154         QVERIFY(file2.open(QIODevice::ReadWrite));
 155
 156         QxtFileLock lock1(&file1,0x10,20,QxtFileLock::WriteLock);
 157         file1.moveToThread(&t1);
 158         LockJob l(&lock1,true);
 159         l.exec(&t1);
 160
 161         QxtFileLock lock2(&file2,0x10,20,QxtFileLock::WriteLock);
 162         file2.moveToThread(&t2);
 163         LockJob l2(&lock2,false);
 164         l2.exec(&t2);
 165         l2.join();
 166     }
 167
 168
 169     ///Trying to readlock the same region
 170     void rr_same()
 171     {
 172         QFile file1("lock.file");
 173         QVERIFY(file1.open(QIODevice::ReadWrite));
 174         QFile file2("lock.file");
 175         QVERIFY(file2.open(QIODevice::ReadWrite));
 176
 177         QxtFileLock lock1(&file1,0x10,20,QxtFileLock::ReadLock);
 178         file1.moveToThread(&t1);
 179         LockJob l1(&lock1,true);
 180         l1.exec(&t1);
 181         l1.join();
 182
 183         QxtFileLock lock2(&file2,0x10,20,QxtFileLock::ReadLock);
 184         file2.moveToThread(&t2);
 185         LockJob l2(&lock2,true);
 186         l2.exec(&t2);
 187         l2.join();
 188     }
 189
 190     ///Trying to lock the same region with different locks
 191     void rw_same()
 192     {
 193
 194         QFile file1("lock.file");
 195         QVERIFY(file1.open(QIODevice::ReadWrite));
 196         QFile file2("lock.file");
 197         QVERIFY(file2.open(QIODevice::ReadWrite));
 198
 199         QxtFileLock lock1(&file1,0x10,20,QxtFileLock::WriteLock);
 200         file1.moveToThread(&t1);
 201         LockJob(&lock1,true).exec(&t1);
 202
 203         QxtFileLock lock2(&file2,0x10,20,QxtFileLock::ReadLock);
 204         file2.moveToThread(&t2);
 205         LockJob(&lock2,false).exec(&t2);
 206     }
 207
 208     ///Trying to writelock different regions
 209     void ww_different()
 210     {
 211         QFile file1("lock.file");
 212         QVERIFY(file1.open(QIODevice::ReadWrite));
 213         QFile file2("lock.file");
 214         QVERIFY(file2.open(QIODevice::ReadWrite));
 215
 216         QxtFileLock lock1(&file1,0x10,20,QxtFileLock::WriteLock);
 217         file1.moveToThread(&t1);
 218         LockJob(&lock1,true).exec(&t1);
 219
 220         QxtFileLock lock2(&file2,0x10+21,20,QxtFileLock::WriteLock);
 221         file2.moveToThread(&t2);
 222         LockJob(&lock2,true).exec(&t2);
 223     }
 224     void cleanupTestCase()
 225     {
 226         t1.quit ();
 227         t1.wait ();
 228         t2.quit ();
 229         t2.wait ();
 230     }
 231 };
 232
 233
 234 int main(int argc, char ** argv)
 235 {
 236     QCoreApplication app(argc,argv);
 237     QxtFileLockTest test1;
 238     QxtFileLockThreadTest test2;
 239     return QTest::qExec(&test1,argc,argv)+QTest::qExec(&test2,argc,argv);
 240 }
 241
 242
 243 #include "main.moc"