haiku.git

//------------------------------------------------------------------------------
//	LockTargetTester.cpp
//
//------------------------------------------------------------------------------

// Standard Includes -----------------------------------------------------------
#include <stdio.h>

// System Includes -------------------------------------------------------------
#include <Message.h>
#include <OS.h>

#include <Handler.h>
#include <Looper.h>
#include <Messenger.h>

// Project Includes ------------------------------------------------------------
#include <TestUtils.h>
#include <ThreadedTestCaller.h>
#include <cppunit/TestSuite.h>

// Local Includes --------------------------------------------------------------
#include "Helpers.h"
#include "LockTargetTester.h"
#include "SMTarget.h"

// Local Defines ---------------------------------------------------------------

// Globals ---------------------------------------------------------------------

//------------------------------------------------------------------------------

// constructor
LockTargetTester::LockTargetTester()
	: BThreadedTestCase(),
	  fHandler(NULL),
	  fLooper(NULL)
{
}

// constructor
LockTargetTester::LockTargetTester(std::string name)
	: BThreadedTestCase(name),
	  fHandler(NULL),
	  fLooper(NULL)
{
}

// destructor
LockTargetTester::~LockTargetTester()
{
	if (fLooper) {
		fLooper->Lock();
		if (fHandler) {
			fLooper->RemoveHandler(fHandler);
			delete fHandler;
		}
		fLooper->Quit();
	}
}

/*
	bool LockTarget() const
	@case 1			this is uninitialized
	@results		should return false.
 */
void LockTargetTester::LockTargetTest1()
{
	BMessenger messenger;
	CHK(messenger.LockTarget() == false);
}

/*
	bool LockTarget() const
	@case 2			this is initialized to local target with preferred handler,
					looper is not locked
	@results		should lock the looper and return true.
 */
void LockTargetTester::LockTargetTest2()
{
	status_t result = B_OK;
	BLooper *looper = new BLooper;
	looper->Run();
	LooperQuitter quitter(looper);
	BMessenger messenger(NULL, looper, &result);
	CHK(messenger.LockTarget() == true);
	CHK(looper->IsLocked() == true);
	looper->Unlock();
	CHK(looper->IsLocked() == false);
}

/*
	bool LockTarget() const
	@case 3			this is initialized to local target with specific handler,
					looper is not locked
	@results		should lock the looper and return true.
 */
void LockTargetTester::LockTargetTest3()
{
	// create looper and handler
	status_t result = B_OK;
	BLooper *looper = new BLooper;
	looper->Run();
	LooperQuitter quitter(looper);
	BHandler *handler = new BHandler;
	HandlerDeleter deleter(handler);
	CHK(looper->Lock());
	looper->AddHandler(handler);
	looper->Unlock();
	// create the messenger and do the checks
	BMessenger messenger(handler, NULL, &result);
	CHK(messenger.LockTarget() == true);
	CHK(looper->IsLocked() == true);
	looper->Unlock();
	CHK(looper->IsLocked() == false);
}

/*
	bool LockTarget() const
	@case 4			this is initialized to local target with preferred handler,
					looper is locked by another thread
	@results		should block until the looper is unlocked, lock it and
					return true.
	@thread A		- locks the looper
					- waits 100ms
					- unlocks the looper
 */
void LockTargetTester::LockTargetTest4A()
{
	CHK(fLooper->Lock() == true);
	snooze(100000);
	fLooper->Unlock();
}

/*
	bool LockTarget() const
	@case 4			this is initialized to local target with preferred handler,
					looper is locked by another thread
	@results		should block until the looper is unlocked, lock it and
					return true.
	@thread B		- waits 50ms (until thread A has acquired the looper lock)
					- tries to lock the looper via messenger and blocks
					- acquires the lock successfully after 50ms
					- unlocks the looper
 */
void LockTargetTester::LockTargetTest4B()
{
	enum { JITTER = 10000 };	// Maybe critical on slow machines.
	snooze(50000);
	BMessenger messenger(NULL, fLooper);
	bigtime_t time = system_time();
	CHK(messenger.LockTarget() == true);
	time = system_time() - time - 50000;
	CHK(fLooper->IsLocked() == true);
	fLooper->Unlock();
	CHK(fLooper->IsLocked() == false);
	CHK(time > -JITTER && time < JITTER);
}

/*
	bool LockTarget() const
	@case 5			this is initialized to local target with specific handler,
					looper is locked by another thread
	@results		should block until the looper is unlocked, lock it and
					return true.
	@thread A		- locks the looper
					- waits 100ms
					- unlocks the looper
 */
void LockTargetTester::LockTargetTest5A()
{
	CHK(fLooper->Lock() == true);
	snooze(100000);
	fLooper->Unlock();
}

/*
	bool LockTarget() const
	@case 5			this is initialized to local target with specific handler,
					looper is locked by another thread
	@results		should block until the looper is unlocked, lock it and
					return true.
	@thread B		- waits 50ms (until thread A has acquired the looper lock)
					- tries to lock the looper via messenger and blocks
					- acquires the lock successfully after 50ms
					- unlocks the looper
 */
void LockTargetTester::LockTargetTest5B()
{
	enum { JITTER = 10000 };	// Maybe critical on slow machines.
	snooze(50000);
	BMessenger messenger(fHandler, NULL);
	bigtime_t time = system_time();
	CHK(messenger.LockTarget() == true);
	time = system_time() - time - 50000;
	CHK(fLooper->IsLocked() == true);
	fLooper->Unlock();
	CHK(fLooper->IsLocked() == false);
	CHK(time > -JITTER && time < JITTER);
}

/*
	bool LockTarget() const
	@case 6			this is initialized to remote target with preferred
					handler, looper is not locked
	@results		should not lock the looper and return false.
 */
void LockTargetTester::LockTargetTest6()
{
	RemoteSMTarget target(true);
	BMessenger messenger(target.Messenger());
	CHK(messenger.LockTarget() == false);
}

/*
	bool LockTarget() const
	@case 7			this is initialized to remote target with specific handler,
					looper is not locked
	@results		should not lock the looper and return false.
 */
void LockTargetTester::LockTargetTest7()
{
	RemoteSMTarget target(false);
	BMessenger messenger(target.Messenger());
	CHK(messenger.LockTarget() == false);
}


Test* LockTargetTester::Suite()
{
	typedef BThreadedTestCaller<LockTargetTester> TC;

	TestSuite* testSuite = new TestSuite;

	ADD_TEST4(BMessenger, testSuite, LockTargetTester, LockTargetTest1);
	ADD_TEST4(BMessenger, testSuite, LockTargetTester, LockTargetTest2);
	ADD_TEST4(BMessenger, testSuite, LockTargetTester, LockTargetTest3);
	// test4
	LockTargetTester *test4
		= new LockTargetTester("LockTargetTest4");
	test4->fLooper = new BLooper;
	test4->fLooper->Run();
	// test4 test caller
	TC *caller4 = new TC("BMessenger::LockTargetTest4", test4);
	caller4->addThread("A", &LockTargetTester::LockTargetTest4A);
	caller4->addThread("B", &LockTargetTester::LockTargetTest4B);
	testSuite->addTest(caller4);	
	// test5
	LockTargetTester *test5
		= new LockTargetTester("LockTargetTest5");
	// create looper and handler
	test5->fLooper = new BLooper;
	test5->fLooper->Run();
	test5->fHandler = new BHandler;
	if (test5->fLooper->Lock()) {
		test5->fLooper->AddHandler(test5->fHandler);
		test5->fLooper->Unlock();
	} else
		printf("ERROR: Can't init LockTargetTester test5!\n");
	// test5 test caller
	TC *caller5 = new TC("BMessenger::LockTargetTest5", test5);
	caller5->addThread("A", &LockTargetTester::LockTargetTest5A);
	caller5->addThread("B", &LockTargetTester::LockTargetTest5B);
	testSuite->addTest(caller5);	
	// tests 6-7
	ADD_TEST4(BMessenger, testSuite, LockTargetTester, LockTargetTest6);
	ADD_TEST4(BMessenger, testSuite, LockTargetTester, LockTargetTest7);

	return testSuite;
}