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;
}


// 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;
}

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