src/testcases/MutexTest.h

#ifndef __LS_MUTEXTEST_H__
#define __LS_MUTEXTEST_H__

#include <cppunit/TestFixture.h>
#include <cppunit/extensions/HelperMacros.h>

// needed for sleep() and usleep() calls
#include <unistd.h>

// the Mutex class we want to test
#include "../common/Mutex.h"

// we need an additional thread to test the Mutex class
#include "../common/Thread.h"

using namespace LinuxSampler;

class MutexTest : public CppUnit::TestFixture {

    CPPUNIT_TEST_SUITE(MutexTest);
    CPPUNIT_TEST(printTestSuiteName);
    CPPUNIT_TEST(testLockAndUnlockBySingleThread);
    CPPUNIT_TEST(testLock);
    CPPUNIT_TEST(testUnlock);
    CPPUNIT_TEST(testDoubleLock);
    CPPUNIT_TEST(testDoubleLockStillBlocksConcurrentThread);
    CPPUNIT_TEST_SUITE_END();

    private:
        // dummy thread to simulate usage of a shared resource
        class ConcurrentThread : public Thread {
            public:
                int resource;
                Mutex mutex;

                ConcurrentThread();
                int Main();
                using Thread::SignalStartThread; // make method public
        };

        // dummy thread we use to check if the Mutex falsely blcoks if we do a double lock and to avoid that our unit test main thread gets blocked
        class DummyThread : public Thread {
            public:
                int resource;

                DummyThread();
                int Main();
                using Thread::SignalStartThread; // make method public
            private:
                Mutex mutex;
        };

        bool doubleLockSucceeded; // true if testDoubleLock() was successful
    public:
        void setUp();
        void tearDown();

        void printTestSuiteName();

        void testLockAndUnlockBySingleThread();
        void testLock();
        void testUnlock();
        void testDoubleLock();
        void testDoubleLockStillBlocksConcurrentThread();
};

#endif // __LS_MUTEXTEST_H__
1	schoenebeck	57	#ifndef __LS_MUTEXTEST_H__
2			#define __LS_MUTEXTEST_H__
3
4			#include <cppunit/TestFixture.h>
5			#include <cppunit/extensions/HelperMacros.h>
6
7			// needed for sleep() and usleep() calls
8			#include <unistd.h>
9
10			// the Mutex class we want to test
11			#include "../common/Mutex.h"
12
13			// we need an additional thread to test the Mutex class
14			#include "../common/Thread.h"
15
16	schoenebeck	1221	using namespace LinuxSampler;
17
18	schoenebeck	57	class MutexTest : public CppUnit::TestFixture {
19
20			CPPUNIT_TEST_SUITE(MutexTest);
21	schoenebeck	211	CPPUNIT_TEST(printTestSuiteName);
22	schoenebeck	57	CPPUNIT_TEST(testLockAndUnlockBySingleThread);
23			CPPUNIT_TEST(testLock);
24			CPPUNIT_TEST(testUnlock);
25			CPPUNIT_TEST(testDoubleLock);
26	schoenebeck	63	CPPUNIT_TEST(testDoubleLockStillBlocksConcurrentThread);
27	schoenebeck	57	CPPUNIT_TEST_SUITE_END();
28
29			private:
30	schoenebeck	63	// dummy thread to simulate usage of a shared resource
31	schoenebeck	57	class ConcurrentThread : public Thread {
32			public:
33			int resource;
34			Mutex mutex;
35
36			ConcurrentThread();
37			int Main();
38	schoenebeck	3548	using Thread::SignalStartThread; // make method public
39	schoenebeck	57	};
40	schoenebeck	63
41			// dummy thread we use to check if the Mutex falsely blcoks if we do a double lock and to avoid that our unit test main thread gets blocked
42			class DummyThread : public Thread {
43			public:
44			int resource;
45
46			DummyThread();
47			int Main();
48	schoenebeck	3548	using Thread::SignalStartThread; // make method public
49	schoenebeck	63	private:
50			Mutex mutex;
51			};
52
53			bool doubleLockSucceeded; // true if testDoubleLock() was successful
54	schoenebeck	57	public:
55			void setUp();
56			void tearDown();
57
58	schoenebeck	211	void printTestSuiteName();
59
60	schoenebeck	57	void testLockAndUnlockBySingleThread();
61			void testLock();
62			void testUnlock();
63			void testDoubleLock();
64	schoenebeck	63	void testDoubleLockStillBlocksConcurrentThread();
65	schoenebeck	57	};
66
67			#endif // __LS_MUTEXTEST_H__