src/testcases/ThreadTest.cpp

#include "ThreadTest.h"

#include <iostream>

CPPUNIT_TEST_SUITE_REGISTRATION(ThreadTest);

using namespace std;

static ThreadTest::DummyThread dummythread;


// DummyThread

ThreadTest::DummyThread::DummyThread() : LinuxSampler::Thread(false, false, 0, -4) {
    wasRunning = false;
}

int ThreadTest::DummyThread::Main() {
    wasRunning = true;
    while (true) {
                someVariable = -1;
#if CONFIG_PTHREAD_TESTCANCEL
                TestCancel();
#endif
        }
        return 0;
}


// HelperThread

ThreadTest::HelperThread::HelperThread(DummyThread* pDummyThread) : LinuxSampler::Thread(false, false, 0, -4) {
    returnedFromDummyStop = false;
    this->pDummyThread = pDummyThread;
}

int ThreadTest::HelperThread::Main() {
    pDummyThread->StopThread();
    pDummyThread->someVariable = 0; // we set this to another value than -1 so we can check if the DummyThread was still running
    returnedFromDummyStop = true;
    return 0;
}

bool ThreadTest::HelperThread::dummyThreadWasNotRunningAnymoreAfter_StopThread_call() {
    return (pDummyThread->someVariable == 0);
}


// WaitingThread

ThreadTest::WaitingThread::WaitingThread() : LinuxSampler::Thread(false, false, 0, -4) {
}

int ThreadTest::WaitingThread::Main() {
    while (true) condition.WaitIf(false);
}


// ThreadTest

void ThreadTest::printTestSuiteName() {
    cout << "\b \nRunning Thread Tests: " << flush;
}

// Check if Thread class actually deploys a thread
void ThreadTest::testThreadRunning() {
    dummythread.StartThread();
    usleep(25000); // wait 25ms
    CPPUNIT_ASSERT(dummythread.wasRunning);
    CPPUNIT_ASSERT(dummythread.IsRunning());
}

// Check if SignalStopThread() method actually stops the thread
void ThreadTest::testSignalStopThread() {
    CPPUNIT_ASSERT(dummythread.wasRunning);
    CPPUNIT_ASSERT(dummythread.IsRunning());
    dummythread.SignalStopThread();
    usleep(80000); // wait 40ms
    CPPUNIT_ASSERT(!dummythread.IsRunning());
}

// Check if the thread can be relaunched
void ThreadTest::testRelaunchThread() {
    dummythread.StartThread();
    usleep(25000); // wait 25ms
    CPPUNIT_ASSERT(dummythread.wasRunning);
    CPPUNIT_ASSERT(dummythread.IsRunning());
    dummythread.StopThread();
    usleep(25000); // wait 25ms
    dummythread.wasRunning = false;
    dummythread.StartThread();
    usleep(25000); // wait 25ms
    CPPUNIT_ASSERT(dummythread.wasRunning);
    CPPUNIT_ASSERT(dummythread.IsRunning());
}

// Check if the StopThread() method actually stops the thread and doesn't freeze the calling thread which wants to stop it and also check if the thread was still running after the StopThread() method was called.
void ThreadTest::testStopThread() {
    HelperThread* phelper = new HelperThread(&dummythread);
    phelper->StartThread(); // let the helper thread kill the dummy thread
    usleep(25000); // wait 25ms
    CPPUNIT_ASSERT(!dummythread.IsRunning());
    CPPUNIT_ASSERT(phelper->returnedFromDummyStop);
    bool wasnotrunning = phelper->dummyThreadWasNotRunningAnymoreAfter_StopThread_call();
    if (wasnotrunning && phelper) delete phelper;
    CPPUNIT_ASSERT(wasnotrunning);
}

// Check if the thread can be stopped even when it's waiting for a condition
void ThreadTest::testThreadKillableWhenWaiting() {
    WaitingThread* pwaitingthread = new WaitingThread;
    pwaitingthread->SignalStartThread();
    usleep(150000); // wait 150ms
    CPPUNIT_ASSERT(pwaitingthread->IsRunning());
    pwaitingthread->SignalStopThread();
    for (uint trials = 400; trials; trials--) {
        bool success = !pwaitingthread->IsRunning();
        if (success) {
            usleep(15000); // wait 15ms
            delete pwaitingthread;
            CPPUNIT_ASSERT(true); // success
            return;
        }
        else usleep(150000); // wait 150ms and try again
    }
    CPPUNIT_ASSERT(false); // failure
}
1	schoenebeck	57	#include "ThreadTest.h"
2
3			#include <iostream>
4
5			CPPUNIT_TEST_SUITE_REGISTRATION(ThreadTest);
6
7	schoenebeck	211	using namespace std;
8	schoenebeck	57
9	schoenebeck	1221	static ThreadTest::DummyThread dummythread;
10	schoenebeck	211
11	schoenebeck	1221
12	schoenebeck	57	// DummyThread
13
14	schoenebeck	1221	ThreadTest::DummyThread::DummyThread() : LinuxSampler::Thread(false, false, 0, -4) {
15	schoenebeck	57	wasRunning = false;
16			}
17
18			int ThreadTest::DummyThread::Main() {
19			wasRunning = true;
20	nagata	1649	while (true) {
21			someVariable = -1;
22			#if CONFIG_PTHREAD_TESTCANCEL
23			TestCancel();
24			#endif
25			}
26	schoenebeck	3552	return 0;
27	schoenebeck	57	}
28
29
30			// HelperThread
31
32	schoenebeck	1221	ThreadTest::HelperThread::HelperThread(DummyThread* pDummyThread) : LinuxSampler::Thread(false, false, 0, -4) {
33	schoenebeck	57	returnedFromDummyStop = false;
34			this->pDummyThread = pDummyThread;
35			}
36
37			int ThreadTest::HelperThread::Main() {
38			pDummyThread->StopThread();
39	schoenebeck	211	pDummyThread->someVariable = 0; // we set this to another value than -1 so we can check if the DummyThread was still running
40	schoenebeck	57	returnedFromDummyStop = true;
41	schoenebeck	3552	return 0;
42	schoenebeck	57	}
43
44	schoenebeck	211	bool ThreadTest::HelperThread::dummyThreadWasNotRunningAnymoreAfter_StopThread_call() {
45			return (pDummyThread->someVariable == 0);
46			}
47	schoenebeck	57
48	schoenebeck	211
49	schoenebeck	63	// WaitingThread
50
51	schoenebeck	1221	ThreadTest::WaitingThread::WaitingThread() : LinuxSampler::Thread(false, false, 0, -4) {
52	schoenebeck	63	}
53
54			int ThreadTest::WaitingThread::Main() {
55			while (true) condition.WaitIf(false);
56			}
57
58
59	schoenebeck	57	// ThreadTest
60
61	schoenebeck	211	void ThreadTest::printTestSuiteName() {
62			cout << "\b \nRunning Thread Tests: " << flush;
63			}
64
65	schoenebeck	63	// Check if Thread class actually deploys a thread
66	schoenebeck	57	void ThreadTest::testThreadRunning() {
67			dummythread.StartThread();
68			usleep(25000); // wait 25ms
69			CPPUNIT_ASSERT(dummythread.wasRunning);
70			CPPUNIT_ASSERT(dummythread.IsRunning());
71			}
72
73	schoenebeck	63	// Check if SignalStopThread() method actually stops the thread
74	schoenebeck	57	void ThreadTest::testSignalStopThread() {
75	schoenebeck	1221	CPPUNIT_ASSERT(dummythread.wasRunning);
76			CPPUNIT_ASSERT(dummythread.IsRunning());
77	schoenebeck	57	dummythread.SignalStopThread();
78	schoenebeck	1221	usleep(80000); // wait 40ms
79	schoenebeck	57	CPPUNIT_ASSERT(!dummythread.IsRunning());
80			}
81
82	schoenebeck	63	// Check if the thread can be relaunched
83	schoenebeck	57	void ThreadTest::testRelaunchThread() {
84	schoenebeck	63	dummythread.StartThread();
85			usleep(25000); // wait 25ms
86			CPPUNIT_ASSERT(dummythread.wasRunning);
87			CPPUNIT_ASSERT(dummythread.IsRunning());
88			dummythread.StopThread();
89			usleep(25000); // wait 25ms
90	schoenebeck	57	dummythread.wasRunning = false;
91			dummythread.StartThread();
92			usleep(25000); // wait 25ms
93			CPPUNIT_ASSERT(dummythread.wasRunning);
94			CPPUNIT_ASSERT(dummythread.IsRunning());
95			}
96
97	schoenebeck	211	// Check if the StopThread() method actually stops the thread and doesn't freeze the calling thread which wants to stop it and also check if the thread was still running after the StopThread() method was called.
98	schoenebeck	57	void ThreadTest::testStopThread() {
99			HelperThread* phelper = new HelperThread(&dummythread);
100			phelper->StartThread(); // let the helper thread kill the dummy thread
101			usleep(25000); // wait 25ms
102			CPPUNIT_ASSERT(!dummythread.IsRunning());
103			CPPUNIT_ASSERT(phelper->returnedFromDummyStop);
104	schoenebeck	211	bool wasnotrunning = phelper->dummyThreadWasNotRunningAnymoreAfter_StopThread_call();
105			if (wasnotrunning && phelper) delete phelper;
106			CPPUNIT_ASSERT(wasnotrunning);
107	schoenebeck	57	}
108	schoenebeck	63
109			// Check if the thread can be stopped even when it's waiting for a condition
110			void ThreadTest::testThreadKillableWhenWaiting() {
111	schoenebeck	211	WaitingThread* pwaitingthread = new WaitingThread;
112			pwaitingthread->SignalStartThread();
113			usleep(150000); // wait 150ms
114			CPPUNIT_ASSERT(pwaitingthread->IsRunning());
115			pwaitingthread->SignalStopThread();
116			for (uint trials = 400; trials; trials--) {
117			bool success = !pwaitingthread->IsRunning();
118			if (success) {
119			usleep(15000); // wait 15ms
120			delete pwaitingthread;
121			CPPUNIT_ASSERT(true); // success
122			return;
123			}
124			else usleep(150000); // wait 150ms and try again
125			}
126			CPPUNIT_ASSERT(false); // failure
127	schoenebeck	63	}