src/testcases/MutexTest.cpp

#include "MutexTest.h"

#include <iostream>

CPPUNIT_TEST_SUITE_REGISTRATION(MutexTest);


// ConcurrentThread

MutexTest::ConcurrentThread::ConcurrentThread() : Thread(false, 0, -4) {
    resource = 0;
}

int MutexTest::ConcurrentThread::Main() {
    mutex.Lock();
    resource++;
    mutex.Unlock();
}


// DummyThread

MutexTest::DummyThread::DummyThread() : Thread(false, 0, -4) {
    resource = 0;
}

int MutexTest::DummyThread::Main() {
    mutex.Lock();
    mutex.Lock();
    resource++;
    mutex.Unlock();
}


// MutexTest

void MutexTest::setUp() {
}

void MutexTest::tearDown() {
}

// Check with only one thread (thus no concurrency) if locking and unlocking the Mutex works without getting the thread to be locked falsely.
void MutexTest::testLockAndUnlockBySingleThread() {
    ConcurrentThread t;
    t.StartThread();
    usleep(200000); // wait 200ms
    CPPUNIT_ASSERT(t.resource == 1);
}

// Now check with two concurrent threads if one thread can block the other one by using the Mutex.
void MutexTest::testLock() {
    ConcurrentThread t;
    t.mutex.Lock();
    t.SignalStartThread();
    usleep(400000); // wait 400ms
    CPPUNIT_ASSERT(t.resource == 0);
    t.mutex.Unlock();
}

// Now check if the blocked thread get unblocked when thread that owns the Mutex unlocks the Mutex again.
void MutexTest::testUnlock() {
    ConcurrentThread t;
    t.mutex.Lock();
    t.SignalStartThread();
    usleep(400000); // wait 400ms
    t.mutex.Unlock();
    usleep(400000); // wait 400ms
    CPPUNIT_ASSERT(t.resource == 1);
}

// Check if the same thread can lock the Mutex twice in a row without unlocking it and without getting blocked itself.
void MutexTest::testDoubleLock() {
    DummyThread t;
    t.SignalStartThread();
    usleep(200000); // wait 200ms
    CPPUNIT_ASSERT(t.resource == 1);
    doubleLockSucceeded = (t.resource == 1);
}

// Check if the previous tests namely 'testLock()' and 'testUnlock()' still work with double locking previously
void MutexTest::testDoubleLockStillBlocksConcurrentThread() {
  bool success = false;
  // check if testDoubleLock() succeeds, otherwise this test doesnt make sense anyway
  doubleLockSucceeded = false;
  testDoubleLock();
  if (doubleLockSucceeded) {
      ConcurrentThread t;
      t.mutex.Lock();
      t.mutex.Lock();
      t.SignalStartThread();
      usleep(400000); // wait 400ms
      success = (t.resource == 0);
      t.mutex.Unlock();

      if (success) {
          usleep(200000); // wait 200ms
          success = (t.resource == 1);
      }
  }
  CPPUNIT_ASSERT(success);
}
1	schoenebeck	57	#include "MutexTest.h"
2
3			#include <iostream>
4
5			CPPUNIT_TEST_SUITE_REGISTRATION(MutexTest);
6
7
8			// ConcurrentThread
9
10			MutexTest::ConcurrentThread::ConcurrentThread() : Thread(false, 0, -4) {
11			resource = 0;
12			}
13
14			int MutexTest::ConcurrentThread::Main() {
15			mutex.Lock();
16			resource++;
17			mutex.Unlock();
18			}
19
20
21	schoenebeck	63	// DummyThread
22
23			MutexTest::DummyThread::DummyThread() : Thread(false, 0, -4) {
24			resource = 0;
25			}
26
27			int MutexTest::DummyThread::Main() {
28			mutex.Lock();
29			mutex.Lock();
30			resource++;
31			mutex.Unlock();
32			}
33
34
35	schoenebeck	57	// MutexTest
36
37			void MutexTest::setUp() {
38			}
39
40			void MutexTest::tearDown() {
41			}
42
43	schoenebeck	63	// Check with only one thread (thus no concurrency) if locking and unlocking the Mutex works without getting the thread to be locked falsely.
44	schoenebeck	57	void MutexTest::testLockAndUnlockBySingleThread() {
45			ConcurrentThread t;
46			t.StartThread();
47			usleep(200000); // wait 200ms
48			CPPUNIT_ASSERT(t.resource == 1);
49			}
50
51	schoenebeck	63	// Now check with two concurrent threads if one thread can block the other one by using the Mutex.
52	schoenebeck	57	void MutexTest::testLock() {
53			ConcurrentThread t;
54			t.mutex.Lock();
55			t.SignalStartThread();
56			usleep(400000); // wait 400ms
57			CPPUNIT_ASSERT(t.resource == 0);
58			t.mutex.Unlock();
59			}
60
61	schoenebeck	63	// Now check if the blocked thread get unblocked when thread that owns the Mutex unlocks the Mutex again.
62	schoenebeck	57	void MutexTest::testUnlock() {
63	schoenebeck	63	ConcurrentThread t;
64			t.mutex.Lock();
65			t.SignalStartThread();
66			usleep(400000); // wait 400ms
67			t.mutex.Unlock();
68			usleep(400000); // wait 400ms
69			CPPUNIT_ASSERT(t.resource == 1);
70	schoenebeck	57	}
71
72	schoenebeck	63	// Check if the same thread can lock the Mutex twice in a row without unlocking it and without getting blocked itself.
73	schoenebeck	57	void MutexTest::testDoubleLock() {
74	schoenebeck	63	DummyThread t;
75			t.SignalStartThread();
76			usleep(200000); // wait 200ms
77			CPPUNIT_ASSERT(t.resource == 1);
78			doubleLockSucceeded = (t.resource == 1);
79	schoenebeck	57	}
80	schoenebeck	63
81			// Check if the previous tests namely 'testLock()' and 'testUnlock()' still work with double locking previously
82			void MutexTest::testDoubleLockStillBlocksConcurrentThread() {
83			bool success = false;
84			// check if testDoubleLock() succeeds, otherwise this test doesnt make sense anyway
85			doubleLockSucceeded = false;
86			testDoubleLock();
87			if (doubleLockSucceeded) {
88			ConcurrentThread t;
89			t.mutex.Lock();
90			t.mutex.Lock();
91			t.SignalStartThread();
92			usleep(400000); // wait 400ms
93			success = (t.resource == 0);
94			t.mutex.Unlock();
95
96			if (success) {
97			usleep(200000); // wait 200ms
98			success = (t.resource == 1);
99			}
100			}
101			CPPUNIT_ASSERT(success);
102			}