haiku.git

//------------------------------------------------------------------------------
//	MessengerComparissonTester.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 "MessengerComparissonTester.h"
#include "SMTarget.h"

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

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

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

struct FakeMessenger {
	port_id	fPort;
	int32	fHandlerToken;
	team_id	fTeam;
	int32	extra0;
	int32	extra1;
	bool	fPreferredTarget;
	bool	extra2;
	bool	extra3;
	bool	extra4;
};

static
bool
operator<(const FakeMessenger& a, const FakeMessenger& b)
{
	// significance:
	// * fPort
	// * fHandlerToken
	// * fPreferredTarget
	// fTeam is insignificant
	return (a.fPort < b.fPort
			|| a.fPort == b.fPort
				&& (a.fHandlerToken < b.fHandlerToken
					|| a.fHandlerToken == b.fHandlerToken
						&& !a.fPreferredTarget && b.fPreferredTarget));
}

static
bool
operator!=(const FakeMessenger& a, const FakeMessenger& b)
{
	return (a < b || b < a);
}

static
bool
operator==(const FakeMessenger& a, const FakeMessenger& b)
{
	return !(a != b);
}

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

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

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

/*
	bool operator==(const BMessenger &other) const
	bool operator!=(const BMessenger &a, const BMessenger &b)
	@case 1			this (a) and other (b) are uninitialized
	@results		should return true/false.
 */
void MessengerComparissonTester::ComparissonTest1()
{
	BMessenger a;
	BMessenger b;
	CHK(a == b);
	CHK(b == a);
	CHK(!(a != b));
	CHK(!(b != a));
}

/*
	bool operator==(const BMessenger &other) const
	bool operator!=(const BMessenger &a, const BMessenger &b)
	@case 1			this (a) is initialized, other (b) is uninitialized,
					and vice versa
	@results		should return false/true.
 */
void MessengerComparissonTester::ComparissonTest2()
{
	// create looper
	BLooper *looper = new BLooper;
	looper->Run();
	LooperQuitter quitter(looper);
	// create messenger
	BMessenger a(NULL, looper);
	BMessenger b;
	CHK(a != b);
	CHK(b != a);
	CHK(!(a == b));
	CHK(!(b == a));
}

/*
	bool operator==(const BMessenger &other) const
	bool operator!=(const BMessenger &a, const BMessenger &b)
	bool operator<(const BMessenger &a, const BMessenger &b)
	@case 3			this and other are initialized, different cases:
					- same object => true
					- different objects same target => true
					- looper preferred handler vs. same looper but the looper
					  itself as handler => false
					- looper preferred handler vs. other looper preferred
					  handler => false
					- looper preferred handler vs. other looper specific
					  handler => false
					- local looper vs. remote looper => false
 */
void MessengerComparissonTester::ComparissonTest3()
{
	// messenger1: looper and handler
	BLooper *looper1 = new BLooper;
	looper1->Run();
	LooperQuitter quitter1(looper1);
	BHandler *handler1 = new BHandler;
	HandlerDeleter deleter1(handler1);
	CHK(looper1->Lock());
	looper1->AddHandler(handler1);
	looper1->Unlock();
	BMessenger messenger1(handler1, looper1);
	BMessenger messenger1a(handler1, looper1);
	// messenger2: looper (1)
	BMessenger messenger2(NULL, looper1);
	BMessenger messenger2a(NULL, looper1);
	// messenger3: looper and handler
	BLooper *looper2 = new BLooper;
	looper2->Run();
	LooperQuitter quitter2(looper2);
	BHandler *handler2 = new BHandler;
	HandlerDeleter deleter2(handler2);
	CHK(looper2->Lock());
	looper2->AddHandler(handler2);
	looper2->Unlock();
	BMessenger messenger3(handler2, looper2);
	BMessenger messenger3a(handler2, looper2);
	// messenger4: looper (2)
	BMessenger messenger4(NULL, looper2);
	BMessenger messenger4a(NULL, looper2);
	// remote targets
	RemoteSMTarget remoteTarget1(false);
	RemoteSMTarget remoteTarget2(true);
	BMessenger messenger5(remoteTarget1.Messenger());
	BMessenger messenger5a(remoteTarget1.Messenger());
	BMessenger messenger6(remoteTarget2.Messenger());
	BMessenger messenger6a(remoteTarget2.Messenger());

	// targets -- test data
	struct target {
		BMessenger	&messenger;
		int32		id;			// identifies the target
	} targets[] = {
		{ messenger1,	1 },
		{ messenger1a,	1 },
		{ messenger2,	2 },
		{ messenger2,	2 },
		{ messenger3,	3 },
		{ messenger3a,	3 },
		{ messenger4,	4 },
		{ messenger4a,	4 },
		{ messenger5,	5 },
		{ messenger5a,	5 },
		{ messenger6,	6 },
		{ messenger6a,	6 },
	};
	int32 targetCount = sizeof(targets) / sizeof(target);

	// test
	for (int32 i = 0; i < targetCount; i++) {
		NextSubTest();
		const target &target1 = targets[i];
		const BMessenger &a = target1.messenger;
		for (int32 k = 0; k < targetCount; k++) {
			const target &target2 = targets[k];
			const BMessenger &b = target2.messenger;
			bool areEqual = (target1.id == target2.id);
			CHK((a == b) == areEqual);
			CHK((b == a) == areEqual);
			CHK((a != b) == !areEqual);
			CHK((b != a) == !areEqual);
		}
	}
}

// Compare
//
// Helper function for LessTest1().
static inline
void
Compare(const FakeMessenger &fake1, const FakeMessenger &fake2,
		const BMessenger &messenger1, const BMessenger &messenger2)
{
	CHK((messenger1 == messenger2) == (fake1 == fake2));
	CHK((messenger1 != messenger2) == (fake1 != fake2));
	CHK((messenger1 < messenger2) == (fake1 < fake2));
}

/*
	bool operator<(const BMessenger &a, const BMessenger &b)
	@case 1			set fields of a and b manually
	@results		should return whatever the reference implementation
					returns.
 */
void MessengerComparissonTester::LessTest1()
{
	port_id ports[] = { -1, 0, 1 } ;
	int32 tokens[] = { -1, 0, 1 } ;
	team_id teams[] = { -1, 0, 1 } ;
	bool preferreds[] = { false, true } ;
	int32 portCount = sizeof(ports) / sizeof(port_id);
	int32 tokenCount = sizeof(tokens) / sizeof(int32);
	int32 teamCount = sizeof(teams) / sizeof(team_id);
	int32 preferredCount = 2;
	for (int32 p1 = 0; p1 < portCount; p1++) {
		port_id port1 = ports[p1];
		for (int32 to1 = 0; to1 < tokenCount; to1++) {
			int32 token1 = tokens[to1];
			for (int32 te1 = 0; te1 < teamCount; te1++) {
				team_id team1 = teams[te1];
				for (int32 pr1 = 0; pr1 < preferredCount; pr1++) {
					bool preferred1 = preferreds[pr1];
					FakeMessenger fake1;
					fake1.fPort = port1;
					fake1.fHandlerToken = token1;
					fake1.fTeam = team1;
					fake1.fPreferredTarget = preferred1;
					BMessenger &messenger1 = *(BMessenger*)&fake1;
					for (int32 p2 = 0; p2 < portCount; p2++) {
						port_id port2 = ports[p2];
						for (int32 to2 = 0; to2 < tokenCount; to2++) {
							int32 token2 = tokens[to2];
							for (int32 te2 = 0; te2 < teamCount; te2++) {
								team_id team2 = teams[te2];
								for (int32 pr2 = 0; pr2 < preferredCount;
									 pr2++) {
									bool preferred2 = preferreds[pr2];
									FakeMessenger fake2;
									fake2.fPort = port2;
									fake2.fHandlerToken = token2;
									fake2.fTeam = team2;
									fake2.fPreferredTarget = preferred2;
									BMessenger &messenger2
										= *(BMessenger*)&fake2;
									Compare(fake1, fake2, messenger1,
											messenger2);
								}
							}
						}
					}
				}
			}
		}
	}
}


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

	TestSuite* testSuite = new TestSuite;

	ADD_TEST4(BMessenger, testSuite, MessengerComparissonTester, ComparissonTest1);
	ADD_TEST4(BMessenger, testSuite, MessengerComparissonTester, ComparissonTest2);
	ADD_TEST4(BMessenger, testSuite, MessengerComparissonTester, ComparissonTest3);
	ADD_TEST4(BMessenger, testSuite, MessengerComparissonTester, LessTest1);

	return testSuite;
}