src/testcases/ThreadTest.h

#ifndef __LS_THREADTEST_H__
#define __LS_THREADTEST_H__

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

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

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

// we need that to check if our thread is killable even if waiting for a condition
#include "../common/Condition.h"

class ThreadTest : public CppUnit::TestFixture {

    CPPUNIT_TEST_SUITE(ThreadTest);
    CPPUNIT_TEST(printTestSuiteName);
    CPPUNIT_TEST(testThreadRunning);
    CPPUNIT_TEST(testSignalStopThread);
    CPPUNIT_TEST(testRelaunchThread);
    CPPUNIT_TEST(testStopThread);
    CPPUNIT_TEST(testThreadKillableWhenWaiting);
    CPPUNIT_TEST_SUITE_END();

    public:
        // this is our test implementation of the abstract base class Thread which we will use to test class Thread
        class DummyThread : public LinuxSampler::Thread {
            public:
                bool wasRunning; // this variable is false on startup and will be switched to true by the thread, so we can check if the thread actually runs
                volatile int someVariable; // we constantly set this variable to -1 in the DummyThread Main() loop, so we can check in our main test thread if the DummyThread is still running by changing that value to something else than -1

                DummyThread();
                int Main();
        };

    private:
        // this is only a helper thread to avoid that the entire test case run hangs when we try to stop the dummy thread
        class HelperThread : public LinuxSampler::Thread {
            private:
                DummyThread* pDummyThread;
            public:
                bool returnedFromDummyStop;

                HelperThread(DummyThread* pDummyThread);
                int Main();
                bool dummyThreadWasNotRunningAnymoreAfter_StopThread_call();
        };

        // this simulates a thread that is waiting for a condition (thus sleeping til then)
        class WaitingThread : public LinuxSampler::Thread {
            public:
                WaitingThread();
                int Main();
            private:
                LinuxSampler::Condition condition;
        };
    public:
        void setUp() {
        }

        void tearDown() {
        }

        void printTestSuiteName();

        void testThreadRunning();
        void testSignalStopThread();
        void testRelaunchThread();
        void testStopThread();
        void testThreadKillableWhenWaiting();
};

#endif // __LS_THREADTEST_H__
1	#ifndef __LS_THREADTEST_H__
2	#define __LS_THREADTEST_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 Thread class we want to test
11	#include "../common/Thread.h"
12
13	// we need that to check if our thread is killable even if waiting for a condition
14	#include "../common/Condition.h"
15
16	class ThreadTest : public CppUnit::TestFixture {
17
18	CPPUNIT_TEST_SUITE(ThreadTest);
19	CPPUNIT_TEST(printTestSuiteName);
20	CPPUNIT_TEST(testThreadRunning);
21	CPPUNIT_TEST(testSignalStopThread);
22	CPPUNIT_TEST(testRelaunchThread);
23	CPPUNIT_TEST(testStopThread);
24	CPPUNIT_TEST(testThreadKillableWhenWaiting);
25	CPPUNIT_TEST_SUITE_END();
26
27	public:
28	// this is our test implementation of the abstract base class Thread which we will use to test class Thread
29	class DummyThread : public LinuxSampler::Thread {
30	public:
31	bool wasRunning; // this variable is false on startup and will be switched to true by the thread, so we can check if the thread actually runs
32	volatile int someVariable; // we constantly set this variable to -1 in the DummyThread Main() loop, so we can check in our main test thread if the DummyThread is still running by changing that value to something else than -1
33
34	DummyThread();
35	int Main();
36	};
37
38	private:
39	// this is only a helper thread to avoid that the entire test case run hangs when we try to stop the dummy thread
40	class HelperThread : public LinuxSampler::Thread {
41	private:
42	DummyThread* pDummyThread;
43	public:
44	bool returnedFromDummyStop;
45
46	HelperThread(DummyThread* pDummyThread);
47	int Main();
48	bool dummyThreadWasNotRunningAnymoreAfter_StopThread_call();
49	};
50
51	// this simulates a thread that is waiting for a condition (thus sleeping til then)
52	class WaitingThread : public LinuxSampler::Thread {
53	public:
54	WaitingThread();
55	int Main();
56	private:
57	LinuxSampler::Condition condition;
58	};
59	public:
60	void setUp() {
61	}
62
63	void tearDown() {
64	}
65
66	void printTestSuiteName();
67
68	void testThreadRunning();
69	void testSignalStopThread();
70	void testRelaunchThread();
71	void testStopThread();
72	void testThreadKillableWhenWaiting();
73	};
74
75	#endif // __LS_THREADTEST_H__