haiku.git

//------------------------------------------------------------------------------
//	SetIntervalTester.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 "MessageRunnerTestHelpers.h"
#include "SetIntervalTester.h"

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

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

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


using namespace std;


static const char *kTesterSignature
	= "application/x-vnd.obos-messagerunner-setinterval-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);
	}
}

/*
	status_t SetInterval(bigtime_t interval)
	@case 1			object is not properly initialized, interval > 0
	@results		Should return B_BAD_VALUE.
					InitCheck() should return B_ERROR.
					GetInfo() should return B_BAD_VALUE.
 */
void SetIntervalTester::SetInterval1()
{
	MessageRunnerTestApp app(kTesterSignature);
	BMessenger target;
	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);
	bigtime_t newInterval = 100000;
	CHK(runner.SetInterval(newInterval) == B_BAD_VALUE);
	CHK(runner.InitCheck() == B_ERROR);
	check_message_runner_info(runner, B_BAD_VALUE);
}

/*
	status_t SetInterval(bigtime_t interval)
	@case 2			object was properly initialized, but has already delivered
					all its messages and thus became unusable, interval > 0
	@results		Should return B_BAD_VALUE.
					InitCheck() should return B_OK.
					GetInfo() should return B_BAD_VALUE.
 */
void SetIntervalTester::SetInterval2()
{
	MessageRunnerTestApp app(kTesterSignature);
	BMessenger target;
	BMessage message(MSG_RUNNER_MESSAGE);
	bigtime_t interval = 50000;
	int32 count = 1;
	BMessageRunner runner(target, &message, interval, count);
	CHK(runner.InitCheck() == B_OK);
	check_message_runner_info(runner, B_OK, interval, count);
	snooze(count * interval + 10000);
	// set new interval
	bigtime_t newInterval = 100000;
	CHK(runner.SetInterval(newInterval) == B_BAD_VALUE);
	CHK(runner.InitCheck() == B_OK);
	check_message_runner_info(runner, B_BAD_VALUE);
}

/*
	status_t SetInterval(bigtime_t interval)
	@case 3			object is properly initialized and has still one message
					to deliver, interval > 0
	@results		Should return B_OK.
					InitCheck() should return B_OK.
					GetInfo() should return B_OK and the new interval.
					The timer is reset. The last message arives after the time
					specified by interval has passed.
 */
void SetIntervalTester::SetInterval3()
{
	MessageRunnerTestApp app(kTesterSignature);
	MessageRunnerTestLooper *looper = app.TestLooper();
	BMessenger target(looper);
	BMessage message(MSG_RUNNER_MESSAGE);
	bigtime_t interval = 50000;
	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 - 1));
	CHK(app.CountReplies() == count - 1);
	// set new interval
	bigtime_t newInterval = 100000;
	CHK(runner.SetInterval(newInterval) == B_OK);
	CHK(runner.InitCheck() == B_OK);
	check_message_runner_info(runner, B_OK, newInterval, 1);
	startTime = system_time();
	snooze(2 * newInterval + 10000);
	CHK(looper->CheckMessages(count - 1, startTime, newInterval, 1));
	CHK(app.CountReplies() == count);
}

/*
	status_t SetInterval(bigtime_t interval)
	@case 4			object is properly initialized and has still some messages
					to deliver, interval > 0
	@results		Should return B_OK.
					InitCheck() should return B_OK.
					GetInfo() should return B_OK and the new interval.
					The timer is reset. The messages start to arive after
					the time specified by interval.
 */
void SetIntervalTester::SetInterval4()
{
	MessageRunnerTestApp app(kTesterSignature);
	MessageRunnerTestLooper *looper = app.TestLooper();
	BMessenger target(looper);
	BMessage message(MSG_RUNNER_MESSAGE);
	bigtime_t interval = 50000;
	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(1 * interval + 10000);
	CHK(looper->CheckMessages(startTime, interval, 1));
	CHK(app.CountReplies() == 1);
	// set new interval
	bigtime_t newInterval = 70000;
	CHK(runner.SetInterval(newInterval) == B_OK);
	CHK(runner.InitCheck() == B_OK);
	check_message_runner_info(runner, B_OK, newInterval, count - 1);
	startTime = system_time();
	snooze(count * newInterval + 10000);
	CHK(looper->CheckMessages(1, startTime, newInterval, count - 1));
	CHK(app.CountReplies() == count);
}

/*
	status_t SetInterval(bigtime_t interval)
	@case 5			object is properly initialized and has still an unlimited
					number of messages to deliver, interval > 0
	@results		Should return B_OK.
					InitCheck() should return B_OK.
					GetInfo() should return B_OK and the new interval.
					The timer is reset. The messages start to arive after
					the time specified by interval.
 */
void SetIntervalTester::SetInterval5()
{
	MessageRunnerTestApp app(kTesterSignature);
	MessageRunnerTestLooper *looper = app.TestLooper();
	BMessenger target(looper);
	BMessage message(MSG_RUNNER_MESSAGE);
	bigtime_t interval = 50000;
	int32 count = -1;
	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(1 * interval + 10000);
	CHK(looper->CheckMessages(startTime, interval, 1));
	CHK(app.CountReplies() == 1);
	// set new interval
	bigtime_t newInterval = 70000;
	CHK(runner.SetInterval(newInterval) == B_OK);
	CHK(runner.InitCheck() == B_OK);
	check_message_runner_info(runner, B_OK, newInterval, -1);
	startTime = system_time();
	int32 checkCount = 5;
	snooze(checkCount * newInterval + 10000);
	CHK(looper->CheckMessages(1, startTime, newInterval, checkCount));
	CHK(app.CountReplies() == checkCount + 1);
}

/*
	status_t SetInterval(bigtime_t interval)
	@case 6			object is properly initialized and has still some messages
					to deliver, interval == 0
	@results		Should return B_OK.
					InitCheck() should return B_OK.
					R5: GetInfo() should return B_BAD_VALUE.
						All messages are delivered, but at weird times.
					Haiku: GetInfo() should return B_OK and the minimal
						  interval. The timer is reset. The messages start to
						  arive after the time specified by the minimal
						  interval.
 */
void SetIntervalTester::SetInterval6()
{
	MessageRunnerTestApp app(kTesterSignature);
	MessageRunnerTestLooper *looper = app.TestLooper();
	BMessenger target(looper);
	BMessage message(MSG_RUNNER_MESSAGE);
	bigtime_t interval = 70000;
	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(1 * interval + 10000);
	CHK(looper->CheckMessages(startTime, interval, 1));
	CHK(app.CountReplies() == 1);
	// set new interval
	bigtime_t newInterval = 0;
	CHK(runner.SetInterval(newInterval) == B_OK);
	newInterval = max(newInterval, kMinTimeInterval);
	CHK(runner.InitCheck() == B_OK);
#ifdef TEST_R5
	check_message_runner_info(runner, B_BAD_VALUE);
	snooze(count * interval + 10000);
#else
	check_message_runner_info(runner, B_OK, newInterval, count - 1);
	startTime = system_time();
	snooze(count * newInterval + 10000);
	CHK(looper->CheckMessages(1, startTime, newInterval, count - 1));
#endif
	CHK(app.CountReplies() == count);
}

/*
	status_t SetInterval(bigtime_t interval)
	@case 7			object is properly initialized and has still some messages
					to deliver, interval < 0
	@results		Should return B_OK.
					InitCheck() should return B_OK.
					R5: GetInfo() should return B_BAD_VALUE.
						All messages are delivered, but at weird times.
					Haiku: GetInfo() should return B_OK and the minimal
						  interval. The timer is reset. The messages start to
						  arive after the time specified by the minimal
						  interval.
 */
void SetIntervalTester::SetInterval7()
{
	MessageRunnerTestApp app(kTesterSignature);
	MessageRunnerTestLooper *looper = app.TestLooper();
	BMessenger target(looper);
	BMessage message(MSG_RUNNER_MESSAGE);
	bigtime_t interval = 70000;
	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(1 * interval + 10000);
	CHK(looper->CheckMessages(startTime, interval, 1));
	CHK(app.CountReplies() == 1);
	// set new interval
	bigtime_t newInterval = -1;
	CHK(runner.SetInterval(newInterval) == B_OK);
	newInterval = max(newInterval, kMinTimeInterval);
	CHK(runner.InitCheck() == B_OK);
#ifdef TEST_R5
	check_message_runner_info(runner, B_BAD_VALUE);
	snooze(count * interval + 10000);
#else
	check_message_runner_info(runner, B_OK, newInterval, count - 1);
	startTime = system_time();
	snooze(count * newInterval + 10000);
	CHK(looper->CheckMessages(1, startTime, newInterval, count - 1));
#endif
	CHK(app.CountReplies() == count);
}


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

	ADD_TEST4(BMessageRunner, SuiteOfTests, SetIntervalTester, SetInterval1);
	ADD_TEST4(BMessageRunner, SuiteOfTests, SetIntervalTester, SetInterval2);
	ADD_TEST4(BMessageRunner, SuiteOfTests, SetIntervalTester, SetInterval3);
	ADD_TEST4(BMessageRunner, SuiteOfTests, SetIntervalTester, SetInterval4);
	ADD_TEST4(BMessageRunner, SuiteOfTests, SetIntervalTester, SetInterval5);
	ADD_TEST4(BMessageRunner, SuiteOfTests, SetIntervalTester, SetInterval6);
	ADD_TEST4(BMessageRunner, SuiteOfTests, SetIntervalTester, SetInterval7);

	return SuiteOfTests;
}