//------------------------------------------------------------------------------
//	BMessageRunnerTester.cpp
//
//------------------------------------------------------------------------------

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

// System Includes -------------------------------------------------------------
#include <Application.h>
#include <Handler.h>
#include <Looper.h>
#include <Message.h>
#include <MessageRunner.h>
#include <Messenger.h>
#include <OS.h>

// Project Includes ------------------------------------------------------------
#include <TestShell.h>
#include <TestUtils.h>
#include <cppunit/TestAssert.h>

// Local Includes --------------------------------------------------------------
#include "BMessageRunnerTester.h"
#include "MessageRunnerTestHelpers.h"

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

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

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


using namespace std;


static const char *kTesterSignature
	= "application/x-vnd.obos-messagerunner-constructor-test";

static const bigtime_t kMinTimeInterval = 50000;

// check_message_runner_info
static
void
check_message_runner_info(const BMessageRunner &runner, status_t error,
						  bigtime_t interval = 0, int32 count = 0)
{
	bigtime_t runnerInterval = 0;
	int32 runnerCount = 0;
	CHK(runner.GetInfo(&runnerInterval, &runnerCount) == error);
	if (error == B_OK) {
		CHK(runnerInterval == interval);
		CHK(runnerCount == count);
	}
}

/*
	BMessageRunner(BMessenger target, const BMessage *message,
				   bigtime_t interval, int32 count)
	@case 1			target is invalid, message is valid, interval > 0,
					count > 0
	@results		InitCheck() should return B_OK. The message runner turns
					to unusable as soon as the first message had to be sent.
					GetInfo() should return B_OK.
 */
void TBMessageRunnerTester::BMessageRunnerA1()
{
	MessageRunnerTestApp app(kTesterSignature);
	BMessenger target;
	BMessage message(MSG_RUNNER_MESSAGE);
	bigtime_t interval = 100000;
	int32 count = 5;
	BMessageRunner runner(target, &message, interval, count);
	CHK(runner.InitCheck() == B_OK);
	check_message_runner_info(runner, B_OK, interval, count);
	snooze(interval + 10000);
	check_message_runner_info(runner, B_BAD_VALUE);
	CHK(app.CountReplies() == 0);
}

/*
	BMessageRunner(BMessenger target, const BMessage *message,
				   bigtime_t interval, int32 count)
	@case 2			target is valid, message is NULL, interval > 0, count > 0
	@results		InitCheck() should return B_BAD_VALUE.
					GetInfo() should return B_BAD_VALUE.
 */
void TBMessageRunnerTester::BMessageRunnerA2()
{
// R5: chrashes when passing a NULL message
#ifndef TEST_R5
	MessageRunnerTestApp app(kTesterSignature);
	MessageRunnerTestLooper *looper = app.TestLooper();
	BMessenger target(looper);
	bigtime_t interval = 100000;
	int32 count = 5;
	BMessageRunner runner(target, NULL, interval, count);
	CHK(runner.InitCheck() == B_BAD_VALUE);
	check_message_runner_info(runner, B_BAD_VALUE);
#endif
}

/*
	BMessageRunner(BMessenger target, const BMessage *message,
				   bigtime_t interval, int32 count)
	@case 3			target is valid, message is valid, interval == 0, count > 0
	@results		R5: InitCheck() should return B_ERROR.
						GetInfo() should return B_BAD_VALUE.
					Haiku: InitCheck() should return B_OK.
						  GetInfo() should return B_OK.
						  A minimal time interval is used (50000).
 */
void TBMessageRunnerTester::BMessageRunnerA3()
{
	MessageRunnerTestApp app(kTesterSignature);
	MessageRunnerTestLooper *looper = app.TestLooper();
	BMessenger target(looper);
	BMessage message(MSG_RUNNER_MESSAGE);
	bigtime_t interval = 0;
	int32 count = 5;
	BMessageRunner runner(target, &message, interval, count);
#ifdef TEST_R5
	CHK(runner.InitCheck() == B_ERROR);
	check_message_runner_info(runner, B_BAD_VALUE);
#else
	bigtime_t startTime = system_time();
	CHK(runner.InitCheck() == B_OK);
	interval = max(interval, kMinTimeInterval);
	check_message_runner_info(runner, B_OK, interval, count);
	snooze((count + 1) * interval + 10000);
	CHK(looper->CheckMessages(startTime, interval, count));
	CHK(app.CountReplies() == count);
#endif
}

/*
	BMessageRunner(BMessenger target, const BMessage *message,
				   bigtime_t interval, int32 count)
	@case 4			target is valid, message is valid, interval < 0, count > 0
	@results		InitCheck() should return B_OK.
					GetInfo() should return B_OK.
					A minimal time interval is used (50000).
 */
void TBMessageRunnerTester::BMessageRunnerA4()
{
	MessageRunnerTestApp app(kTesterSignature);
	MessageRunnerTestLooper *looper = app.TestLooper();
	BMessenger target(looper);
	BMessage message(MSG_RUNNER_MESSAGE);
	bigtime_t interval = -1;
	int32 count = 5;
	BMessageRunner runner(target, &message, interval, count);
	bigtime_t startTime = system_time();
	CHK(runner.InitCheck() == B_OK);
	interval = max(interval, kMinTimeInterval);
	check_message_runner_info(runner, B_OK, interval, count);
	snooze((count + 1) * interval + 10000);
	CHK(looper->CheckMessages(startTime, interval, count));
	CHK(app.CountReplies() == count);
}

/*
	BMessageRunner(BMessenger target, const BMessage *message,
				   bigtime_t interval, int32 count)
	@case 5			target is valid, message is valid,
					interval == LONGLONG_MAX, count > 0
	@results		InitCheck() should return B_OK.
					GetInfo() should return B_OK.
					No message should be delivered.
 */
void TBMessageRunnerTester::BMessageRunnerA5()
{
// R5: doesn't behave very well. In worst case registrar time loop gets
// locked up and system wide message runners don't get messages anymore.
#ifndef TEST_R5
	MessageRunnerTestApp app(kTesterSignature);
	MessageRunnerTestLooper *looper = app.TestLooper();
	BMessenger target(looper);
	BMessage message(MSG_RUNNER_MESSAGE);
	bigtime_t interval = LONGLONG_MAX;
	int32 count = 5;
	BMessageRunner runner(target, &message, interval, count);
	bigtime_t startTime = system_time();
	CHK(runner.InitCheck() == B_OK);
	interval = max(interval, kMinTimeInterval);
	check_message_runner_info(runner, B_OK, interval, count);
	snooze(10000);
	CHK(looper->CheckMessages(startTime, interval, 0));
	CHK(app.CountReplies() == 0);
#endif
}

/*
	BMessageRunner(BMessenger target, const BMessage *message,
				   bigtime_t interval, int32 count)
	@case 6			target is valid, message is valid, interval > 0, count == 0
	@results		InitCheck() should return B_ERROR.
					GetInfo() should return B_BAD_VALUE.
 */
void TBMessageRunnerTester::BMessageRunnerA6()
{
	MessageRunnerTestApp app(kTesterSignature);
	MessageRunnerTestLooper *looper = app.TestLooper();
	BMessenger target(looper);
	BMessage message(MSG_RUNNER_MESSAGE);
	bigtime_t interval = 100000;
	int32 count = 0;
	BMessageRunner runner(target, &message, interval, count);
	CHK(runner.InitCheck() == B_ERROR);
	check_message_runner_info(runner, B_BAD_VALUE);
}

/*
	BMessageRunner(BMessenger target, const BMessage *message,
				   bigtime_t interval, int32 count)
	@case 7			target is valid, message is valid, interval > 0, count < 0
	@results		InitCheck() should return B_OK.
					GetInfo() should return B_OK.
					Unlimited number of messages.
 */
void TBMessageRunnerTester::BMessageRunnerA7()
{
	MessageRunnerTestApp app(kTesterSignature);
	MessageRunnerTestLooper *looper = app.TestLooper();
	BMessenger target(looper);
	BMessage message(MSG_RUNNER_MESSAGE);
	bigtime_t interval = 100000;
	int32 count = 5;
	BMessageRunner runner(target, &message, interval, count);
	bigtime_t startTime = system_time();
	CHK(runner.InitCheck() == B_OK);
	interval = max(interval, kMinTimeInterval);
	check_message_runner_info(runner, B_OK, interval, count);
	int32 checkCount = 5;
	snooze(checkCount * interval + 10000);
	CHK(looper->CheckMessages(startTime, interval, checkCount));
	CHK(app.CountReplies() == checkCount);
}

/*
	BMessageRunner(BMessenger target, const BMessage *message,
				   bigtime_t interval, int32 count)
	@case 8			target is valid, message is valid, interval > 0, count > 0
	@results		InitCheck() should return B_OK.
					GetInfo() should return B_OK.
					count messages are sent.
 */
void TBMessageRunnerTester::BMessageRunnerA8()
{
	MessageRunnerTestApp app(kTesterSignature);
	MessageRunnerTestLooper *looper = app.TestLooper();
	BMessenger target(looper);
	BMessage message(MSG_RUNNER_MESSAGE);
	bigtime_t interval = 100000;
	int32 count = 5;
	BMessageRunner runner(target, &message, interval, count);
	bigtime_t startTime = system_time();
	CHK(runner.InitCheck() == B_OK);
	interval = max(interval, kMinTimeInterval);
	check_message_runner_info(runner, B_OK, interval, count);
	snooze((count + 1) * interval + 10000);
	CHK(looper->CheckMessages(startTime, interval, count));
	CHK(app.CountReplies() == count);
}

/*
	BMessageRunner(BMessenger target, const BMessage *message,
				   bigtime_t interval, int32 count, BMessenger replyTo)
	@case 1			target is invalid, message is valid, interval > 0,
					count > 0
	@results		InitCheck() should return B_OK. The message runner turns
					to unusable as soon as the first message had to be sent.
					GetInfo() should return B_OK.
 */
void TBMessageRunnerTester::BMessageRunnerB1()
{
	MessageRunnerTestApp app(kTesterSignature);
	BMessenger target;
	BMessage message(MSG_RUNNER_MESSAGE);
	bigtime_t interval = 100000;
	int32 count = 5;
	MessageRunnerTestHandler *handler = app.TestHandler();
	BMessenger replyTo(handler);
	BMessageRunner runner(target, &message, interval, count, replyTo);
	CHK(runner.InitCheck() == B_OK);
	check_message_runner_info(runner, B_OK, interval, count);
	snooze(interval + 10000);
	check_message_runner_info(runner, B_BAD_VALUE);
	CHK(app.CountReplies() == 0);
	CHK(handler->CountReplies() == 0);
}

/*
	BMessageRunner(BMessenger target, const BMessage *message,
				   bigtime_t interval, int32 count, BMessenger replyTo)
	@case 2			target is valid, message is NULL, interval > 0, count > 0
	@results		InitCheck() should return B_BAD_VALUE.
					GetInfo() should return B_BAD_VALUE.
 */
void TBMessageRunnerTester::BMessageRunnerB2()
{
// R5: chrashes when passing a NULL message
#ifndef TEST_R5
	MessageRunnerTestApp app(kTesterSignature);
	MessageRunnerTestLooper *looper = app.TestLooper();
	BMessenger target(looper);
	bigtime_t interval = 100000;
	int32 count = 5;
	MessageRunnerTestHandler *handler = app.TestHandler();
	BMessenger replyTo(handler);
	BMessageRunner runner(target, NULL, interval, count, replyTo);
	CHK(runner.InitCheck() == B_BAD_VALUE);
	check_message_runner_info(runner, B_BAD_VALUE);
#endif
}

/*
	BMessageRunner(BMessenger target, const BMessage *message,
				   bigtime_t interval, int32 count, BMessenger replyTo)
	@case 3			target is valid, message is valid, interval == 0, count > 0
	@results		R5: InitCheck() should return B_ERROR.
						GetInfo() should return B_BAD_VALUE.
					Haiku: InitCheck() should return B_OK.
						  GetInfo() should return B_OK.
						  A minimal time interval is used (50000).
 */
void TBMessageRunnerTester::BMessageRunnerB3()
{
	MessageRunnerTestApp app(kTesterSignature);
	MessageRunnerTestLooper *looper = app.TestLooper();
	BMessenger target(looper);
	BMessage message(MSG_RUNNER_MESSAGE);
	bigtime_t interval = 0;
	int32 count = 5;
	MessageRunnerTestHandler *handler = app.TestHandler();
	BMessenger replyTo(handler);
	BMessageRunner runner(target, &message, interval, count, replyTo);
#ifdef TEST_R5
	CHK(runner.InitCheck() == B_ERROR);
	check_message_runner_info(runner, B_BAD_VALUE);
#else
	bigtime_t startTime = system_time();
	CHK(runner.InitCheck() == B_OK);
	interval = max(interval, kMinTimeInterval);
	check_message_runner_info(runner, B_OK, interval, count);
	snooze((count + 1) * interval + 10000);
	CHK(looper->CheckMessages(startTime, interval, count));
	CHK(app.CountReplies() == 0);
	CHK(handler->CountReplies() == count);
#endif
}

/*
	BMessageRunner(BMessenger target, const BMessage *message,
				   bigtime_t interval, int32 count, BMessenger replyTo)
	@case 4			target is valid, message is valid, interval < 0, count > 0
	@results		InitCheck() should return B_OK.
					GetInfo() should return B_OK.
					A minimal time interval is used (50000).
 */
void TBMessageRunnerTester::BMessageRunnerB4()
{
	MessageRunnerTestApp app(kTesterSignature);
	MessageRunnerTestLooper *looper = app.TestLooper();
	BMessenger target(looper);
	BMessage message(MSG_RUNNER_MESSAGE);
	bigtime_t interval = -1;
	int32 count = 5;
	MessageRunnerTestHandler *handler = app.TestHandler();
	BMessenger replyTo(handler);
	BMessageRunner runner(target, &message, interval, count, replyTo);
	bigtime_t startTime = system_time();
	CHK(runner.InitCheck() == B_OK);
	interval = max(interval, kMinTimeInterval);
	check_message_runner_info(runner, B_OK, interval, count);
	snooze((count + 1) * interval + 10000);
	CHK(looper->CheckMessages(startTime, interval, count));
	CHK(app.CountReplies() == 0);
	CHK(handler->CountReplies() == count);
}

/*
	BMessageRunner(BMessenger target, const BMessage *message,
				   bigtime_t interval, int32 count, BMessenger replyTo)
	@case 5			target is valid, message is valid,
					interval == LONGLONG_MAX, count > 0
	@results		InitCheck() should return B_OK.
					GetInfo() should return B_OK.
					No message should be delivered.
 */
void TBMessageRunnerTester::BMessageRunnerB5()
{
// R5: doesn't behave very well. In worst case registrar time loop gets
// locked up and system wide message runners don't get messages anymore.
#ifndef TEST_R5
	MessageRunnerTestApp app(kTesterSignature);
	MessageRunnerTestLooper *looper = app.TestLooper();
	BMessenger target(looper);
	BMessage message(MSG_RUNNER_MESSAGE);
	bigtime_t interval = LONGLONG_MAX;
	int32 count = 5;
	MessageRunnerTestHandler *handler = app.TestHandler();
	BMessenger replyTo(handler);
	BMessageRunner runner(target, &message, interval, count, replyTo);
	bigtime_t startTime = system_time();
	CHK(runner.InitCheck() == B_OK);
	interval = max(interval, kMinTimeInterval);
	check_message_runner_info(runner, B_OK, interval, count);
	snooze(10000);
	CHK(looper->CheckMessages(startTime, interval, 0));
	CHK(app.CountReplies() == 0);
	CHK(handler->CountReplies() == 0);
#endif
}

/*
	BMessageRunner(BMessenger target, const BMessage *message,
				   bigtime_t interval, int32 count, BMessenger replyTo)
	@case 6			target is valid, message is valid, interval > 0, count == 0
	@results		InitCheck() should return B_ERROR.
					GetInfo() should return B_BAD_VALUE.
 */
void TBMessageRunnerTester::BMessageRunnerB6()
{
	MessageRunnerTestApp app(kTesterSignature);
	MessageRunnerTestLooper *looper = app.TestLooper();
	BMessenger target(looper);
	BMessage message(MSG_RUNNER_MESSAGE);
	bigtime_t interval = 100000;
	int32 count = 0;
	MessageRunnerTestHandler *handler = app.TestHandler();
	BMessenger replyTo(handler);
	BMessageRunner runner(target, &message, interval, count, replyTo);
	CHK(runner.InitCheck() == B_ERROR);
	check_message_runner_info(runner, B_BAD_VALUE);
}

/*
	BMessageRunner(BMessenger target, const BMessage *message,
				   bigtime_t interval, int32 count, BMessenger replyTo)
	@case 7			target is valid, message is valid, interval > 0, count < 0
	@results		InitCheck() should return B_OK.
					GetInfo() should return B_OK.
					Unlimited number of messages.
 */
void TBMessageRunnerTester::BMessageRunnerB7()
{
	MessageRunnerTestApp app(kTesterSignature);
	MessageRunnerTestLooper *looper = app.TestLooper();
	BMessenger target(looper);
	BMessage message(MSG_RUNNER_MESSAGE);
	bigtime_t interval = 100000;
	int32 count = 5;
	MessageRunnerTestHandler *handler = app.TestHandler();
	BMessenger replyTo(handler);
	BMessageRunner runner(target, &message, interval, count, replyTo);
	bigtime_t startTime = system_time();
	CHK(runner.InitCheck() == B_OK);
	interval = max(interval, kMinTimeInterval);
	check_message_runner_info(runner, B_OK, interval, count);
	int32 checkCount = 5;
	snooze(checkCount * interval + 10000);
	CHK(looper->CheckMessages(startTime, interval, checkCount));
	CHK(app.CountReplies() == 0);
	CHK(handler->CountReplies() == checkCount);
}

/*
	BMessageRunner(BMessenger target, const BMessage *message,
				   bigtime_t interval, int32 count, BMessenger replyTo)
	@case 8			target is valid, message is valid, interval > 0, count > 0
	@results		InitCheck() should return B_OK.
					GetInfo() should return B_OK.
					count messages are sent.
 */
void TBMessageRunnerTester::BMessageRunnerB8()
{
	MessageRunnerTestApp app(kTesterSignature);
	MessageRunnerTestLooper *looper = app.TestLooper();
	BMessenger target(looper);
	BMessage message(MSG_RUNNER_MESSAGE);
	bigtime_t interval = 100000;
	int32 count = 5;
	MessageRunnerTestHandler *handler = app.TestHandler();
	BMessenger replyTo(handler);
	BMessageRunner runner(target, &message, interval, count, replyTo);
	bigtime_t startTime = system_time();
	CHK(runner.InitCheck() == B_OK);
	interval = max(interval, kMinTimeInterval);
	check_message_runner_info(runner, B_OK, interval, count);
	snooze((count + 1) * interval + 10000);
	CHK(looper->CheckMessages(startTime, interval, count));
	CHK(app.CountReplies() == 0);
	CHK(handler->CountReplies() == count);
}

/*
	BMessageRunner(BMessenger target, const BMessage *message,
				   bigtime_t interval, int32 count, BMessenger replyTo)
	@case 9			target is valid, message is valid, interval > 0, count > 0,
					replyTo is invalid
	@results		InitCheck() should return B_OK.
					GetInfo() should return B_OK.
					count messages are sent. The replies go to the registrar!
 */
void TBMessageRunnerTester::BMessageRunnerB9()
{
	MessageRunnerTestApp app(kTesterSignature);
	MessageRunnerTestLooper *looper = app.TestLooper();
	BMessenger target(looper);
	BMessage message(MSG_RUNNER_MESSAGE);
	bigtime_t interval = 100000;
	int32 count = 5;
	MessageRunnerTestHandler *handler = app.TestHandler();
	BMessenger replyTo(handler);
	BMessageRunner runner(target, &message, interval, count, replyTo);
	bigtime_t startTime = system_time();
	CHK(runner.InitCheck() == B_OK);
	interval = max(interval, kMinTimeInterval);
	check_message_runner_info(runner, B_OK, interval, count);
	snooze((count + 1) * interval + 10000);
	CHK(looper->CheckMessages(startTime, interval, count));
	CHK(app.CountReplies() == 0);
	CHK(handler->CountReplies() == count);
}


Test* TBMessageRunnerTester::Suite()
{
	TestSuite* SuiteOfTests = new TestSuite;

	ADD_TEST4(BMessageRunner, SuiteOfTests, TBMessageRunnerTester,
			  BMessageRunnerA1);
	ADD_TEST4(BMessageRunner, SuiteOfTests, TBMessageRunnerTester,
			  BMessageRunnerA2);
	ADD_TEST4(BMessageRunner, SuiteOfTests, TBMessageRunnerTester,
			  BMessageRunnerA3);
	ADD_TEST4(BMessageRunner, SuiteOfTests, TBMessageRunnerTester,
			  BMessageRunnerA4);
	ADD_TEST4(BMessageRunner, SuiteOfTests, TBMessageRunnerTester,
			  BMessageRunnerA5);
	ADD_TEST4(BMessageRunner, SuiteOfTests, TBMessageRunnerTester,
			  BMessageRunnerA6);
	ADD_TEST4(BMessageRunner, SuiteOfTests, TBMessageRunnerTester,
			  BMessageRunnerA7);
	ADD_TEST4(BMessageRunner, SuiteOfTests, TBMessageRunnerTester,
			  BMessageRunnerA8);

	ADD_TEST4(BMessageRunner, SuiteOfTests, TBMessageRunnerTester,
			  BMessageRunnerB1);
	ADD_TEST4(BMessageRunner, SuiteOfTests, TBMessageRunnerTester,
			  BMessageRunnerB2);
	ADD_TEST4(BMessageRunner, SuiteOfTests, TBMessageRunnerTester,
			  BMessageRunnerB3);
	ADD_TEST4(BMessageRunner, SuiteOfTests, TBMessageRunnerTester,
			  BMessageRunnerB4);
	ADD_TEST4(BMessageRunner, SuiteOfTests, TBMessageRunnerTester,
			  BMessageRunnerB5);
	ADD_TEST4(BMessageRunner, SuiteOfTests, TBMessageRunnerTester,
			  BMessageRunnerB6);
	ADD_TEST4(BMessageRunner, SuiteOfTests, TBMessageRunnerTester,
			  BMessageRunnerB7);
	ADD_TEST4(BMessageRunner, SuiteOfTests, TBMessageRunnerTester,
			  BMessageRunnerB8);
	ADD_TEST4(BMessageRunner, SuiteOfTests, TBMessageRunnerTester,
			  BMessageRunnerB9);

	return SuiteOfTests;
}