haiku/headers/tools/cppunit/ThreadedTestCaller.h

273 lines
8.7 KiB
C
Raw Normal View History

#ifndef _beos_threaded_test_caller_h_
#define _beos_threaded_test_caller_h_
//#include <memory>
#include <cppunit/TestCase.h>
#include <cppunit/TestResult.h>
#include <cppunit/TestCaller.h>
#include <TestShell.h>
#include <ThreadManager.h>
#include <map>
#include <vector>
#include <stdio.h>
class TestResult;
template <class TestClass, class ExpectedException = CppUnit::NoExceptionExpected>
class CPPUNIT_API BThreadedTestCaller : public CppUnit::TestCase {
public:
/*! \brief Pointer to a test function in the given class.
Each ThreadMethod added with addThread() is run in its own thread.
*/
typedef void (TestClass::*ThreadMethod)();
BThreadedTestCaller(std::string name);
BThreadedTestCaller(std::string name, TestClass &object);
BThreadedTestCaller(std::string name, TestClass *object);
virtual ~BThreadedTestCaller();
virtual CppUnit::TestResult *run();
virtual void run(CppUnit::TestResult *result);
//! Adds a thread to the test. \c threadName must be unique to this BThreadedTestCaller.
void addThread(std::string threadName, ThreadMethod method);
protected:
virtual void setUp();
virtual void tearDown();
virtual std::string toString() const;
typedef std::map<std::string, BThreadManager<TestClass, ExpectedException> *> ThreadManagerMap;
bool fOwnObject;
TestClass *fObject;
ThreadManagerMap fThreads;
sem_id fThreadSem;
};
template <class TestClass, class ExpectedException>
BThreadedTestCaller<TestClass, ExpectedException>::BThreadedTestCaller(std::string name)
: TestCase(name)
, fOwnObject(true)
, fObject(new TestClass())
, fThreadSem(-1)
{
}
template <class TestClass, class ExpectedException>
BThreadedTestCaller<TestClass, ExpectedException>::BThreadedTestCaller(std::string name, TestClass &object)
: TestCase(name)
, fOwnObject(false)
, fObject(&object)
, fThreadSem(-1)
{
}
template <class TestClass, class ExpectedException>
BThreadedTestCaller<TestClass, ExpectedException>::BThreadedTestCaller(std::string name, TestClass *object)
: TestCase(name)
, fOwnObject(true)
, fObject(object)
, fThreadSem(-1)
{
}
template <class TestClass, class ExpectedException>
BThreadedTestCaller<TestClass, ExpectedException>::~BThreadedTestCaller() {
if (fOwnObject)
delete fObject;
for (ThreadManagerMap::iterator it = fThreads.begin(); it != fThreads.end (); ++it) {
delete it->second;
}
}
template <class TestClass, class ExpectedException>
void
BThreadedTestCaller<TestClass, ExpectedException>::addThread(std::string threadName, ThreadMethod method) {
if (fThreads.find(threadName) == fThreads.end()) {
// Unused name, go ahead and add
fThreads[threadName] = new BThreadManager<TestClass, ExpectedException>(threadName, fObject, method, fThreadSem);
} else {
// Duplicate name, throw an exception
throw CppUnit::Exception("BThreadedTestCaller::addThread() - Attempt to add thread under duplicated name ('"
+ threadName + "')");
}
}
template <class TestClass, class ExpectedException>
CppUnit::TestResult *
BThreadedTestCaller<TestClass, ExpectedException>::run() {
CppUnit::TestResult *result = new CppUnit::TestResult;
run(result);
return result;
}
template <class TestClass, class ExpectedException>
void
BThreadedTestCaller<TestClass, ExpectedException>::run(CppUnit::TestResult *result) {
result->startTest(this);
if (fThreads.size() <= 0)
throw CppUnit::Exception("BThreadedTestCaller::run() -- No threads added to BThreadedTestCaller()");
try {
setUp();
// This try/catch block should never actually have to catch
// anything (unless some bonehead passes in a NULL pointer to
// the constructor). Each BThreadManager object catches and
// handles exceptions for its respective thread, so as not
// to disrupt the others.
try {
// Create our thread semaphore. This semaphore is used to
// determine when all the threads have finished executing,
// while still allowing *this* thread to handle printing
// out NextSubTest() info (since other threads don't appear
// to be able to output text while the main thread is
// blocked; their output appears later...).
//
// Each thread will acquire the semaphore once when launched,
// thus the initial thread count is equal the number of threads.
fThreadSem = create_sem(fThreads.size(), "ThreadSem");
if (fThreadSem < B_OK)
throw CppUnit::Exception("BThreadedTestCaller::run() -- Error creating fThreadSem");
// Launch all the threads.
for (ThreadManagerMap::iterator i = fThreads.begin();
i != fThreads.end ();
++i)
{
status_t err = i->second->LaunchThread(result);
if (err != B_OK)
result->addError(this, new CppUnit::Exception("Error launching thread '" + i->second->getName() + "'"));
// printf("Launch(%s)\n", i->second->getName().c_str());
}
// Now we loop. Before you faint, there is a reason for this:
// Calls to NextSubTest() from other threads don't actually
// print anything while the main thread is blocked waiting
// for another thread. Thus, we have NextSubTest() add the
// information to be printed into a queue. The main thread
// (this code right here), blocks on a semaphore that it
// can only acquire after all the test threads have terminated.
// If it times out, it checks the NextSubTest() queue, prints
// any pending updates, and tries to acquire the semaphore
// again. When it finally manages to acquire it, all the
// test threads have terminated, and it's safe to clean up.
status_t err;
do {
// Try to acquire the semaphore
err = acquire_sem_etc(fThreadSem, fThreads.size(), B_RELATIVE_TIMEOUT, 500000);
// Empty the UpdateList
std::vector<std::string> &list = fObject->AcquireUpdateList();
for (std::vector<std::string>::iterator i = list.begin();
i != list.end();
i++)
{
// Only print to standard out if the current global shell
// lets us (or if no global shell is designated).
if (BTestShell::GlobalBeVerbose()) {
printf("%s", (*i).c_str());
fflush(stdout);
}
}
list.clear();
fObject->ReleaseUpdateList();
} while (err != B_OK);
// If we get this far, we actually managed to acquire the semaphore,
// so we should release it now.
release_sem_etc(fThreadSem, fThreads.size(), 0);
// Print out a newline for asthetics :-)
printf("\n");
/*
// Wait for them all to finish, then clean up
for (ThreadManagerMap::iterator i = fThreads.begin();
i != fThreads.end ();
++i)
{
// printf("Wait(%s)...", i->second->getName().c_str());
fflush(stdout);
i->second->WaitForThread();
// printf("done\n");
delete i->second;
}
*/
fThreads.clear();
} catch ( CppUnit::Exception &e ) {
// Add on the a note that this exception was caught by the
// thread caller (which is a bad thing), then note the exception
CppUnit::Exception *threadException = new CppUnit::Exception(
std::string(e.what()) + " (NOTE: caught by BThreadedTestCaller)",
e.sourceLine()
);
result->addFailure( fObject, threadException );
}
catch ( std::exception &e ) {
// Add on the thread name, then note the exception
CppUnit::Exception *threadException = new CppUnit::Exception(
std::string(e.what()) + " (NOTE: caught by BThreadedTestCaller)"
);
result->addError( fObject, threadException );
}
catch (...) {
// Add on the thread name, then note the exception
CppUnit::Exception *threadException = new CppUnit::Exception(
"caught unknown exception (NOTE: caught by BThreadedTestCaller)"
);
result->addError( fObject, threadException );
}
snooze(50000);
try {
tearDown();
} catch (...) {
result->addError(this, new CppUnit::Exception("tearDown() failed"));
}
} catch (...) {
result->addError(this, new CppUnit::Exception("setUp() failed"));
} // setUp() try/catch block
result->endTest(this);
}
template <class TestClass, class ExpectedException>
void
BThreadedTestCaller<TestClass, ExpectedException>::setUp() {
// Verify we have a valid object that's not currently in use first.
if (!fObject)
throw CppUnit::Exception("BThreadedTestCaller::runTest() -- NULL fObject pointer");
if (!fObject->RegisterForUse())
throw CppUnit::Exception("BThreadedTestCaller::runTest() -- Attempt to reuse ThreadedTestCase object already in use");
fObject->setUp();
}
template <class TestClass, class ExpectedException>
void
BThreadedTestCaller<TestClass, ExpectedException>::tearDown() {
fObject->tearDown();
}
template <class TestClass, class ExpectedException>
std::string
BThreadedTestCaller<TestClass, ExpectedException>::toString() const {
return std::string("BThreadedTestCaller for ") + getName();
}
#endif // _beos_threaded_test_caller_h_