haiku.git

// MessageRunnerTestHelpers.cpp

#include <stdio.h>

#include <Autolock.h>

#include "MessageRunnerTestHelpers.h"

enum {
	JITTER	= 10000,
};

// constructor
MessageRunnerTestHandler::MessageRunnerTestHandler()
	: BHandler("message runner test handler"),
	  fReplyCount()
{
}

// destructor
MessageRunnerTestHandler::~MessageRunnerTestHandler()
{
}

// MessageReceived
void
MessageRunnerTestHandler::MessageReceived(BMessage *message)
{
	switch (message->what) {
		case MSG_REPLY:
			fReplyCount++;
			break;
	}
}


///////////////////////////
// MessageRunnerTestLooper

struct MessageRunnerTestLooper::MessageInfo {
	bigtime_t	time;
};

// constructor
MessageRunnerTestLooper::MessageRunnerTestLooper()
	: BLooper(),
	  fMessageInfos()
{
}

// destructor
MessageRunnerTestLooper::~MessageRunnerTestLooper()
{
	for (int32 i = 0; MessageInfo *info = MessageInfoAt(i); i++)
		delete info;
}

// MessageReceived
void
MessageRunnerTestLooper::MessageReceived(BMessage *message)
{
	switch (message->what) {
		case MSG_RUNNER_MESSAGE:
		{
			MessageInfo *info = new MessageInfo;
			info->time = system_time();
			fMessageInfos.AddItem(info);
			message->SendReply(MSG_REPLY);
			break;
		}
	}
}

// CheckMessages
bool
MessageRunnerTestLooper::CheckMessages(bigtime_t startTime, bigtime_t interval,
									   int32 count)
{
	return CheckMessages(0, startTime, interval, count);
}

// CheckMessages
bool
MessageRunnerTestLooper::CheckMessages(int32 skip, bigtime_t startTime,
									   bigtime_t interval, int32 count)
{
	BAutolock _lock(this);
	bool result = (fMessageInfos.CountItems() == count + skip);
if (!result) {
printf("message counts don't match: %ld vs. %ld\n", fMessageInfos.CountItems(),
count + skip);
}
	for (int32 i = 0; result && i < count; i++) {
		MessageInfo *info = MessageInfoAt(i + skip);
		bigtime_t expectedTime = startTime + (i + 1) * interval;
		result = (expectedTime - JITTER < info->time
				  && info->time < expectedTime + JITTER);
if (!result)
printf("message out of time: %lld vs. %lld\n", info->time, expectedTime);
	}
	return result;
}

// MessageInfoAt
MessageRunnerTestLooper::MessageInfo*
MessageRunnerTestLooper::MessageInfoAt(int32 index) const
{
	return static_cast<MessageInfo*>(fMessageInfos.ItemAt(index));
}


////////////////////////
// MessageRunnerTestApp

// constructor
MessageRunnerTestApp::MessageRunnerTestApp(const char *signature)
	: BApplication(signature),
	  fThread(-1),
	  fReplyCount(0),
	  fLooper(NULL),
	  fHandler(NULL)
{
	// create a looper
	fLooper = new MessageRunnerTestLooper;
	fLooper->Run();
	// create a handler
	fHandler = new MessageRunnerTestHandler;
	AddHandler(fHandler);
	// start out message loop in a different thread
	Unlock();
	fThread = spawn_thread(_ThreadEntry, "message runner app thread",
						   B_NORMAL_PRIORITY, this);
	resume_thread(fThread);
}

// destructor
MessageRunnerTestApp::~MessageRunnerTestApp()
{
	// quit the looper
	fLooper->Lock();
	fLooper->Quit();
	// shut down our message loop
	BMessage reply;
	PostMessage(B_QUIT_REQUESTED);
	int32 dummy;
	wait_for_thread(fThread, &dummy);
	// delete the handler
	Lock();
	RemoveHandler(fHandler);
	delete fHandler;
}

// MessageReceived
void
MessageRunnerTestApp::MessageReceived(BMessage *message)
{
	switch (message->what) {
		case MSG_REPLY:
			fReplyCount++;
			break;
	}
}

// QuitRequested
bool
MessageRunnerTestApp::QuitRequested()
{
	return true;
}

// _ThreadEntry
int32
MessageRunnerTestApp::_ThreadEntry(void *data)
{
	MessageRunnerTestApp *app = static_cast<MessageRunnerTestApp*>(data);
	app->Lock();
	app->Run();
	return 0;
}