Added BMessageRunner tests.

git-svn-id: file:///srv/svn/repos/haiku/trunk/current@1465 a95241bf-73f2-0310-859d-f6bbb57e9c96

src/tests/kits/app/AppKitTestAddon.cpp

@@ -6,6 +6,7 @@
 #include "bhandler/HandlerTest.h"
 #include "blooper/LooperTest.h"
 #include "bmessagequeue/MessageQueueTest.h"
+#include "bmessagerunner/MessageRunnerTest.h"
 #include "bmessenger/MessengerTest.h"
 #include "bpropertyinfo/PropertyInfoTest.h"
 #include "broster/RosterTest.h"
@@ -19,6 +20,7 @@ BTestSuite* getTestSuite() {
 	suite->addTest("BHandler", HandlerTestSuite());
 	suite->addTest("BLooper", LooperTestSuite());
 	suite->addTest("BMessageQueue", MessageQueueTestSuite());
+	suite->addTest("BMessageRunner", MessageRunnerTestSuite());
 	suite->addTest("BMessenger", MessengerTestSuite());
 	suite->addTest("BPropertyInfo", PropertyInfoTestSuite());
 	suite->addTest("BRoster", RosterTestSuite());

src/tests/kits/app/Jamfile

@@ -7,6 +7,7 @@ SEARCH_SOURCE += [ FDirName $(SUBDIR) bapplication ] ;
 SEARCH_SOURCE += [ FDirName $(SUBDIR) bhandler ] ;
 SEARCH_SOURCE += [ FDirName $(SUBDIR) blooper ] ;
 SEARCH_SOURCE += [ FDirName $(SUBDIR) bmessagequeue ] ;
+SEARCH_SOURCE += [ FDirName $(SUBDIR) bmessagerunner ] ;
 SEARCH_SOURCE += [ FDirName $(SUBDIR) bmessenger ] ;
 SEARCH_SOURCE += [ FDirName $(SUBDIR) bpropertyinfo ] ;
 SEARCH_SOURCE += [ FDirName $(SUBDIR) broster ] ;
@@ -63,6 +64,13 @@ CommonTestLib libapptest.so
 		FindMessageTest1.cpp
 		MessageQueueTestCase.cpp
 		
+		# BMessageRunner
+		MessageRunnerTest.cpp
+		BMessageRunnerTester.cpp
+		MessageRunnerTestHelpers.cpp
+		SetCountTester.cpp
+		SetIntervalTester.cpp
+
 		# BMessenger
 		MessengerTest.cpp
 		BMessengerTester.cpp

src/tests/kits/app/bmessagerunner/BMessageRunnerCases

@@ -0,0 +1,142 @@
+BMessageRunner(BMessenger target, const BMessage *message, bigtime_t interval,
+			   int32 count)
+case 1:	target is invalid, message is valid, interval > 0, count > 0 =>
+		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.
+case 2:	target is valid, message is NULL, interval > 0, count > 0 =>
+		InitCheck() should return B_BAD_VALUE.
+		GetInfo() should return B_BAD_VALUE.
+case 3:	target is valid, message is valid, interval == 0, count > 0 =>
+		R5: InitCheck() should return B_ERROR.
+			GetInfo() should return B_BAD_VALUE.
+		OBOS: InitCheck() should return B_OK.
+			  GetInfo() should return B_OK.
+			  A minimal time interval is used (50000).
+case 4:	target is valid, message is valid, interval < 0, count > 0 =>
+		InitCheck() should return B_OK.
+		GetInfo() should return B_OK.
+		A minimal time interval is used (50000).
+case 5:	target is valid, message is valid, interval == LONGLONG_MAX,
+		count > 0 =>
+		InitCheck() should return B_OK.
+		GetInfo() should return B_OK.
+		No message should be delivered.
+case 6:	target is valid, message is valid, interval > 0, count == 0 =>
+		InitCheck() should return B_ERROR.
+		GetInfo() should return B_BAD_VALUE.
+case 7:	target is valid, message is valid, interval > 0, count < 0 =>
+		InitCheck() should return B_OK.
+		GetInfo() should return B_OK.
+		Unlimited number of messages.
+case 8:	target is valid, message is valid, interval > 0, count > 0 =>
+		InitCheck() should return B_OK.
+		GetInfo() should return B_OK.
+		count messages are sent.
+
+BMessageRunner(BMessenger target, const BMessage *message,
+			   bigtime_t interval, int32 count, BMessenger replyTo)
+cases 1-8 from first constructor
+case 9:	target is valid, message is valid, interval > 0, count > 0,
+		replyTo is invalid =>
+		InitCheck() should return B_OK.
+		GetInfo() should return B_OK.
+		count messages are sent. The replies go to the registrar!
+case 10:target is valid, message is valid, interval > 0, count > 0,
+		replyTo targets a different handler than be_app_messenger =>
+		InitCheck() should return B_OK.
+		GetInfo() should return B_OK.
+		count messages are sent. The replies go to the handler.
+
+status_t SetInterval(bigtime_t interval)
+case 1:	object is not properly initialized, interval > 0 =>
+		Should return B_BAD_VALUE.
+		InitCheck() should return B_ERROR.
+		GetInfo() should return B_BAD_VALUE.
+case 2:	object was properly initialized, but has already delivered all its
+		messages and thus became unusable, interval > 0 =>
+		Should return B_BAD_VALUE.
+		InitCheck() should return B_OK.
+		GetInfo() should return B_BAD_VALUE.
+case 3:	object is properly initialized and has still one message to deliver,
+		interval > 0 =>
+		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.
+case 4:	object is properly initialized and has still some messages to deliver,
+		interval > 0 =>
+		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.
+case 5:	object is properly initialized and has still an unlimited number of
+		messages to deliver, interval > 0 =>
+		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.
+case 6:	object is properly initialized and has still some messages to deliver,
+		interval == 0 =>
+		Should return B_OK.
+		InitCheck() should return B_OK.
+		R5: GetInfo() should return B_BAD_VALUE.
+			All messages are delivered, but at weird times.
+		OBOS: 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.
+case 7:	object is properly initialized and has still some messages to deliver,
+		interval < 0 =>
+		Should return B_OK.
+		InitCheck() should return B_OK.
+		R5: GetInfo() should return B_BAD_VALUE.
+			All messages are delivered, but at weird times.
+		OBOS: 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.
+
+status_t SetCount(int32 count)
+case 1:	object is not properly initialized, count > 0 =>
+		Should return B_BAD_VALUE.
+		InitCheck() should return B_ERROR.
+		GetInfo() should return B_BAD_VALUE.
+case 2:	object was properly initialized, but has already delivered all its
+		messages and thus became unusable, count > 0 =>
+		Should return B_BAD_VALUE.
+		InitCheck() should return B_OK.
+		GetInfo() should return B_BAD_VALUE.
+case 3:	object is properly initialized and has still one message to deliver,
+		count > 0 =>
+		Should return B_OK.
+		InitCheck() should return B_OK.
+		GetInfo() should return B_OK and the new count.
+		The timer is NOT reset. count messages should arrive.
+case 4:	object is properly initialized and has still some messages to deliver,
+		count > 0 =>
+		Should return B_OK.
+		InitCheck() should return B_OK.
+		GetInfo() should return B_OK and the new count.
+		The timer is NOT reset. count messages should arrive.
+case 5:	object is properly initialized and has still an unlimited number of
+		messages to deliver, count > 0 =>
+		Should return B_OK.
+		InitCheck() should return B_OK.
+		GetInfo() should return B_OK and the new count.
+		The timer is NOT reset. count messages should arrive.
+case 6:	object is properly initialized and has still some messages to deliver,
+		count == 0 =>
+		Should return B_OK.
+		InitCheck() should return B_OK.
+		R5: GetInfo() should return B_OK and count 0!
+			The timer is NOT reset and a message arives after the time specified
+			by the interval!
+		OBOS: GetInfo() should return B_BAD_VALUE.
+case 7:	object is properly initialized and has still some messages to deliver,
+		count < 0 =>
+		Should return B_OK.
+		InitCheck() should return B_OK.
+		GetInfo() should return B_OK and the new count.
+		The timer is NOT reset. Unlimited number of messages.

src/tests/kits/app/bmessagerunner/BMessageRunnerTester.cpp

@@ -0,0 +1,571 @@
+//------------------------------------------------------------------------------
+//	BMessageRunnerTester.cpp
+//
+//------------------------------------------------------------------------------
+
+// Standard Includes -----------------------------------------------------------
+#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 ---------------------------------------------------------------------
+
+//------------------------------------------------------------------------------
+
+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.
+					OBOS: 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() == 0);
+	CHK(handler->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, &message, 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.
+					OBOS: 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,
+			  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,
+			  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;
+}
+

src/tests/kits/app/bmessagerunner/BMessageRunnerTester.h

@@ -0,0 +1,50 @@
+//------------------------------------------------------------------------------
+//	BMessageRunnerTester.h
+//
+//------------------------------------------------------------------------------
+
+#ifndef B_MESSAGE_RUNNER_TESTER_H
+#define B_MESSAGE_RUNNER_TESTER_H
+
+// Standard Includes -----------------------------------------------------------
+
+// System Includes -------------------------------------------------------------
+
+// Project Includes ------------------------------------------------------------
+
+// Local Includes --------------------------------------------------------------
+#include "../common.h"
+
+// Local Defines ---------------------------------------------------------------
+
+// Globals ---------------------------------------------------------------------
+
+class TBMessageRunnerTester : public TestCase
+{
+	public:
+		TBMessageRunnerTester() {;}
+		TBMessageRunnerTester(std::string name) : TestCase(name) {;}
+
+		void BMessageRunnerA1();
+		void BMessageRunnerA2();
+		void BMessageRunnerA3();
+		void BMessageRunnerA4();
+		void BMessageRunnerA5();
+		void BMessageRunnerA6();
+		void BMessageRunnerA7();
+		void BMessageRunnerA8();
+
+		void BMessageRunnerB1();
+		void BMessageRunnerB2();
+		void BMessageRunnerB3();
+		void BMessageRunnerB4();
+		void BMessageRunnerB5();
+		void BMessageRunnerB6();
+		void BMessageRunnerB7();
+		void BMessageRunnerB8();
+		void BMessageRunnerB9();
+
+		static Test* Suite();
+};
+
+#endif	// B_MESSAGE_RUNNER_TESTER_H

src/tests/kits/app/bmessagerunner/MessageRunnerTest.cpp

@@ -0,0 +1,16 @@
+#include "../common.h"
+#include "BMessageRunnerTester.h"
+#include "SetCountTester.h"
+#include "SetIntervalTester.h"
+
+CppUnit::Test* MessageRunnerTestSuite()
+{
+	CppUnit::TestSuite *testSuite = new CppUnit::TestSuite();
+	
+	testSuite->addTest(SetCountTester::Suite());
+	testSuite->addTest(SetIntervalTester::Suite());
+	testSuite->addTest(TBMessageRunnerTester::Suite());
+
+	return testSuite;
+}
+

src/tests/kits/app/bmessagerunner/MessageRunnerTest.h

@@ -0,0 +1,9 @@
+#ifndef _message_runner_test_h_
+#define _message_runner_test_h_
+
+class CppUnit::Test;
+
+CppUnit::Test* MessageRunnerTestSuite();
+
+#endif	// _message_runner_test_h_
+

src/tests/kits/app/bmessagerunner/MessageRunnerTestHelpers.cpp

@@ -0,0 +1,180 @@
+// 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;
+}
+

src/tests/kits/app/bmessagerunner/MessageRunnerTestHelpers.h

@@ -0,0 +1,74 @@
+// MessageRunnerTestHelpers.h
+
+#ifndef MESSAGE_RUNNER_TEST_HELPERS_H
+#define MESSAGE_RUNNER_TEST_HELPERS_H
+
+#include <Application.h>
+#include <List.h>
+
+enum {
+	MSG_RUNNER_MESSAGE	= 'rmsg',
+	MSG_REPLY			= 'rply',
+};
+
+// MessageRunnerTestHandler
+class MessageRunnerTestHandler : public BHandler {
+public:
+	MessageRunnerTestHandler();
+	~MessageRunnerTestHandler();
+
+	virtual void MessageReceived(BMessage *message);
+
+	int32 CountReplies() const { return fReplyCount; }
+
+private:
+	int32					fReplyCount;
+};
+
+// MessageRunnerTestLooper
+class MessageRunnerTestLooper : public BLooper {
+public:
+	MessageRunnerTestLooper();
+	~MessageRunnerTestLooper();
+
+	virtual void MessageReceived(BMessage *message);
+
+	bool CheckMessages(bigtime_t startTime, bigtime_t interval, int32 count);
+	bool CheckMessages(int32 skip, bigtime_t startTime, bigtime_t interval,
+					   int32 count);
+
+private:
+	struct MessageInfo;
+
+private:
+	MessageInfo *MessageInfoAt(int32 index) const;
+
+private:
+	BList	fMessageInfos;
+};
+
+// MessageRunnerTestApp
+class MessageRunnerTestApp : public BApplication {
+public:
+	MessageRunnerTestApp(const char *signature);
+	~MessageRunnerTestApp();
+
+	virtual void MessageReceived(BMessage *message);
+	virtual bool QuitRequested();
+
+	int32 CountReplies() const { return fReplyCount; }
+
+	MessageRunnerTestLooper *TestLooper() const { return fLooper; }
+	MessageRunnerTestHandler *TestHandler() const { return fHandler; }
+
+private:
+	static int32 _ThreadEntry(void *data);
+
+private:
+	thread_id					fThread;
+	int32						fReplyCount;
+	MessageRunnerTestLooper		*fLooper;
+	MessageRunnerTestHandler	*fHandler;
+};
+
+#endif	// MESSAGE_RUNNER_TEST_HELPERS_H

src/tests/kits/app/bmessagerunner/SetCountTester.cpp

@@ -0,0 +1,308 @@
+//------------------------------------------------------------------------------
+//	SetCountTester.cpp
+//
+//------------------------------------------------------------------------------
+
+// Standard Includes -----------------------------------------------------------
+#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 "SetCountTester.h"
+
+// Local Defines ---------------------------------------------------------------
+
+// Globals ---------------------------------------------------------------------
+
+//------------------------------------------------------------------------------
+
+static const char *kTesterSignature
+	= "application/x-vnd.obos-messagerunner-setcount-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 SetCount(int32 count)
+	@case 1			object is not properly initialized, count > 0
+	@results		Should return B_BAD_VALUE.
+					InitCheck() should return B_ERROR.
+					GetInfo() should return B_BAD_VALUE.
+ */
+void SetCountTester::SetCount1()
+{
+	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);
+	int32 newCount = 100000;
+	CHK(runner.SetCount(newCount) == B_BAD_VALUE);
+	CHK(runner.InitCheck() == B_ERROR);
+	check_message_runner_info(runner, B_BAD_VALUE);
+}
+
+/*
+	status_t SetCount(int32 count)
+	@case 2			object was properly initialized, but has already delivered
+					all its messages and thus became unusable, count > 0
+	@results		Should return B_BAD_VALUE.
+					InitCheck() should return B_OK.
+					GetInfo() should return B_BAD_VALUE.
+ */
+void SetCountTester::SetCount2()
+{
+	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 count
+	int32 newCount = 100000;
+	CHK(runner.SetCount(newCount) == B_BAD_VALUE);
+	CHK(runner.InitCheck() == B_OK);
+	check_message_runner_info(runner, B_BAD_VALUE);
+}
+
+/*
+	status_t SetCount(int32 count)
+	@case 3			object is properly initialized and has still one message
+					to deliver, count > 0
+	@results		Should return B_OK.
+					InitCheck() should return B_OK.
+					GetInfo() should return B_OK and the new count.
+					The timer is NOT reset. count messages should arrive.
+ */
+void SetCountTester::SetCount3()
+{
+	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 count
+	bigtime_t newCount = 3;
+	CHK(runner.SetCount(newCount) == B_OK);
+	CHK(runner.InitCheck() == B_OK);
+	check_message_runner_info(runner, B_OK, interval, newCount);
+//	startTime += system_time();
+	startTime += (count - 1) * interval;
+	snooze((newCount + 1) * interval + 10000);
+	CHK(looper->CheckMessages(count - 1, startTime, interval, newCount));
+	CHK(app.CountReplies() == count - 1 + newCount);
+}
+
+/*
+	status_t SetCount(int32 count)
+	@case 4			object is properly initialized and has still some messages
+					to deliver, count > 0
+	@results		Should return B_OK.
+					InitCheck() should return B_OK.
+					GetInfo() should return B_OK and the new count.
+					The timer is NOT reset. count messages should arrive.
+ */
+void SetCountTester::SetCount4()
+{
+	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 count
+	bigtime_t newCount = 3;
+	CHK(runner.SetCount(newCount) == B_OK);
+	CHK(runner.InitCheck() == B_OK);
+	check_message_runner_info(runner, B_OK, interval, newCount);
+	startTime += 1 * interval;
+	snooze((newCount + 1) * interval + 10000);
+	CHK(looper->CheckMessages(1, startTime, interval, newCount));
+	CHK(app.CountReplies() == 1 + newCount);
+}
+
+/*
+	status_t SetCount(int32 count)
+	@case 5			object is properly initialized and has still an unlimited
+					number of messages to deliver, count > 0
+	@results		Should return B_OK.
+					InitCheck() should return B_OK.
+					GetInfo() should return B_OK and the new count.
+					The timer is NOT reset. count messages should arrive.
+ */
+void SetCountTester::SetCount5()
+{
+	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 count
+	bigtime_t newCount = 3;
+	CHK(runner.SetCount(newCount) == B_OK);
+	CHK(runner.InitCheck() == B_OK);
+	check_message_runner_info(runner, B_OK, interval, newCount);
+	startTime += 1 * interval;
+	snooze((newCount + 1) * interval + 10000);
+	CHK(looper->CheckMessages(1, startTime, interval, newCount));
+	CHK(app.CountReplies() == 1 + newCount);
+}
+
+/*
+	status_t SetCount(int32 count)
+	@case 6			object is properly initialized and has still some messages
+					to deliver, count == 0
+	@results		Should return B_OK.
+					InitCheck() should return B_OK.
+					R5: GetInfo() should return B_OK and count 0!
+						The timer is NOT reset and a message arives after the
+						time specified by the interval!
+					OBOS: GetInfo() should return B_BAD_VALUE.
+ */
+void SetCountTester::SetCount6()
+{
+	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 count
+	bigtime_t newCount = 0;
+	CHK(runner.SetCount(newCount) == B_OK);
+	CHK(runner.InitCheck() == B_OK);
+	startTime += 1 * interval;
+#ifdef TEST_R5
+	check_message_runner_info(runner, B_OK, interval, newCount);
+	snooze((newCount + 1) * interval + 10000);
+	CHK(looper->CheckMessages(1, startTime, interval, 1));
+	CHK(app.CountReplies() == 1 + 1);
+#else
+	check_message_runner_info(runner, B_BAD_VALUE);
+	snooze(1 * interval + 10000);
+	CHK(looper->CheckMessages(1, startTime, interval, 0));
+	CHK(app.CountReplies() == 1);
+#endif
+}
+
+/*
+	status_t SetCount(int32 count)
+	@case 7			object is properly initialized and has still some messages
+					to deliver, count < 0
+	@results		Should return B_OK.
+					InitCheck() should return B_OK.
+					GetInfo() should return B_OK and the new count.
+					The timer is NOT reset. Unlimited number of messages.
+ */
+void SetCountTester::SetCount7()
+{
+	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 count
+	bigtime_t newCount = -1;
+	CHK(runner.SetCount(newCount) == B_OK);
+	CHK(runner.InitCheck() == B_OK);
+	check_message_runner_info(runner, B_OK, interval, newCount);
+	startTime += 1 * interval;
+	int32 checkCount = 5;
+	snooze(checkCount * interval + 10000);
+	CHK(looper->CheckMessages(1, startTime, interval, checkCount));
+	CHK(app.CountReplies() == 1 + checkCount);
+}
+
+
+Test* SetCountTester::Suite()
+{
+	TestSuite* SuiteOfTests = new TestSuite;
+
+	ADD_TEST4(BMessageRunner, SuiteOfTests, SetCountTester, SetCount1);
+	ADD_TEST4(BMessageRunner, SuiteOfTests, SetCountTester, SetCount2);
+	ADD_TEST4(BMessageRunner, SuiteOfTests, SetCountTester, SetCount3);
+	ADD_TEST4(BMessageRunner, SuiteOfTests, SetCountTester, SetCount4);
+	ADD_TEST4(BMessageRunner, SuiteOfTests, SetCountTester, SetCount5);
+	ADD_TEST4(BMessageRunner, SuiteOfTests, SetCountTester, SetCount6);
+	ADD_TEST4(BMessageRunner, SuiteOfTests, SetCountTester, SetCount7);
+
+	return SuiteOfTests;
+}
+

src/tests/kits/app/bmessagerunner/SetCountTester.h

@@ -0,0 +1,39 @@
+//------------------------------------------------------------------------------
+//	SetCountTester.h
+//
+//------------------------------------------------------------------------------
+
+#ifndef SET_COUNT_TESTER_H
+#define SET_COUNT_TESTER_H
+
+// Standard Includes -----------------------------------------------------------
+
+// System Includes -------------------------------------------------------------
+
+// Project Includes ------------------------------------------------------------
+
+// Local Includes --------------------------------------------------------------
+#include "../common.h"
+
+// Local Defines ---------------------------------------------------------------
+
+// Globals ---------------------------------------------------------------------
+
+class SetCountTester : public TestCase
+{
+	public:
+		SetCountTester() {;}
+		SetCountTester(std::string name) : TestCase(name) {;}
+
+		void SetCount1();
+		void SetCount2();
+		void SetCount3();
+		void SetCount4();
+		void SetCount5();
+		void SetCount6();
+		void SetCount7();
+
+		static Test* Suite();
+};
+
+#endif	// SET_COUNT_TESTER_H

src/tests/kits/app/bmessagerunner/SetIntervalTester.cpp

@@ -0,0 +1,321 @@
+//------------------------------------------------------------------------------
+//	SetIntervalTester.cpp
+//
+//------------------------------------------------------------------------------
+
+// Standard Includes -----------------------------------------------------------
+#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 ---------------------------------------------------------------------
+
+//------------------------------------------------------------------------------
+
+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.
+					OBOS: 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.
+					OBOS: 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;
+}
+

src/tests/kits/app/bmessagerunner/SetIntervalTester.h

@@ -0,0 +1,39 @@
+//------------------------------------------------------------------------------
+//	SetIntervalTester.h
+//
+//------------------------------------------------------------------------------
+
+#ifndef SET_INTERVAL_TESTER_H
+#define SET_INTERVAL_TESTER_H
+
+// Standard Includes -----------------------------------------------------------
+
+// System Includes -------------------------------------------------------------
+
+// Project Includes ------------------------------------------------------------
+
+// Local Includes --------------------------------------------------------------
+#include "../common.h"
+
+// Local Defines ---------------------------------------------------------------
+
+// Globals ---------------------------------------------------------------------
+
+class SetIntervalTester : public TestCase
+{
+	public:
+		SetIntervalTester() {;}
+		SetIntervalTester(std::string name) : TestCase(name) {;}
+
+		void SetInterval1();
+		void SetInterval2();
+		void SetInterval3();
+		void SetInterval4();
+		void SetInterval5();
+		void SetInterval6();
+		void SetInterval7();
+
+		static Test* Suite();
+};
+
+#endif	// SET_INTERVAL_TESTER_H