From dace24c6255b30ff7f266dd08e43441f517851d3 Mon Sep 17 00:00:00 2001 From: Ingo Weinhold Date: Tue, 8 Oct 2002 21:57:22 +0000 Subject: [PATCH] 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 | 2 + src/tests/kits/app/Jamfile | 8 + .../app/bmessagerunner/BMessageRunnerCases | 142 +++++ .../bmessagerunner/BMessageRunnerTester.cpp | 571 ++++++++++++++++++ .../app/bmessagerunner/BMessageRunnerTester.h | 50 ++ .../app/bmessagerunner/MessageRunnerTest.cpp | 16 + .../app/bmessagerunner/MessageRunnerTest.h | 9 + .../MessageRunnerTestHelpers.cpp | 180 ++++++ .../bmessagerunner/MessageRunnerTestHelpers.h | 74 +++ .../app/bmessagerunner/SetCountTester.cpp | 308 ++++++++++ .../kits/app/bmessagerunner/SetCountTester.h | 39 ++ .../app/bmessagerunner/SetIntervalTester.cpp | 321 ++++++++++ .../app/bmessagerunner/SetIntervalTester.h | 39 ++ 13 files changed, 1759 insertions(+) create mode 100644 src/tests/kits/app/bmessagerunner/BMessageRunnerCases create mode 100644 src/tests/kits/app/bmessagerunner/BMessageRunnerTester.cpp create mode 100644 src/tests/kits/app/bmessagerunner/BMessageRunnerTester.h create mode 100644 src/tests/kits/app/bmessagerunner/MessageRunnerTest.cpp create mode 100644 src/tests/kits/app/bmessagerunner/MessageRunnerTest.h create mode 100644 src/tests/kits/app/bmessagerunner/MessageRunnerTestHelpers.cpp create mode 100644 src/tests/kits/app/bmessagerunner/MessageRunnerTestHelpers.h create mode 100644 src/tests/kits/app/bmessagerunner/SetCountTester.cpp create mode 100644 src/tests/kits/app/bmessagerunner/SetCountTester.h create mode 100644 src/tests/kits/app/bmessagerunner/SetIntervalTester.cpp create mode 100644 src/tests/kits/app/bmessagerunner/SetIntervalTester.h diff --git a/src/tests/kits/app/AppKitTestAddon.cpp b/src/tests/kits/app/AppKitTestAddon.cpp index 0178dcb35f..163132bbe4 100644 --- a/src/tests/kits/app/AppKitTestAddon.cpp +++ b/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()); diff --git a/src/tests/kits/app/Jamfile b/src/tests/kits/app/Jamfile index fa80182434..dd8a720f04 100644 --- a/src/tests/kits/app/Jamfile +++ b/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 diff --git a/src/tests/kits/app/bmessagerunner/BMessageRunnerCases b/src/tests/kits/app/bmessagerunner/BMessageRunnerCases new file mode 100644 index 0000000000..a084c4cd2f --- /dev/null +++ b/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. diff --git a/src/tests/kits/app/bmessagerunner/BMessageRunnerTester.cpp b/src/tests/kits/app/bmessagerunner/BMessageRunnerTester.cpp new file mode 100644 index 0000000000..271c3c9786 --- /dev/null +++ b/src/tests/kits/app/bmessagerunner/BMessageRunnerTester.cpp @@ -0,0 +1,571 @@ +//------------------------------------------------------------------------------ +// BMessageRunnerTester.cpp +// +//------------------------------------------------------------------------------ + +// Standard Includes ----------------------------------------------------------- +#include + +// System Includes ------------------------------------------------------------- +#include +#include +#include +#include +#include +#include +#include + +// Project Includes ------------------------------------------------------------ +#include +#include +#include + +// 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; +} + diff --git a/src/tests/kits/app/bmessagerunner/BMessageRunnerTester.h b/src/tests/kits/app/bmessagerunner/BMessageRunnerTester.h new file mode 100644 index 0000000000..c052d4a2ca --- /dev/null +++ b/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 diff --git a/src/tests/kits/app/bmessagerunner/MessageRunnerTest.cpp b/src/tests/kits/app/bmessagerunner/MessageRunnerTest.cpp new file mode 100644 index 0000000000..af7679186c --- /dev/null +++ b/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; +} + diff --git a/src/tests/kits/app/bmessagerunner/MessageRunnerTest.h b/src/tests/kits/app/bmessagerunner/MessageRunnerTest.h new file mode 100644 index 0000000000..9babc8a7fc --- /dev/null +++ b/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_ + diff --git a/src/tests/kits/app/bmessagerunner/MessageRunnerTestHelpers.cpp b/src/tests/kits/app/bmessagerunner/MessageRunnerTestHelpers.cpp new file mode 100644 index 0000000000..70a4c2cbe6 --- /dev/null +++ b/src/tests/kits/app/bmessagerunner/MessageRunnerTestHelpers.cpp @@ -0,0 +1,180 @@ +// MessageRunnerTestHelpers.cpp + +#include + +#include + +#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(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(data); + app->Lock(); + app->Run(); + return 0; +} + diff --git a/src/tests/kits/app/bmessagerunner/MessageRunnerTestHelpers.h b/src/tests/kits/app/bmessagerunner/MessageRunnerTestHelpers.h new file mode 100644 index 0000000000..4d26955654 --- /dev/null +++ b/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 +#include + +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 diff --git a/src/tests/kits/app/bmessagerunner/SetCountTester.cpp b/src/tests/kits/app/bmessagerunner/SetCountTester.cpp new file mode 100644 index 0000000000..179c80d676 --- /dev/null +++ b/src/tests/kits/app/bmessagerunner/SetCountTester.cpp @@ -0,0 +1,308 @@ +//------------------------------------------------------------------------------ +// SetCountTester.cpp +// +//------------------------------------------------------------------------------ + +// Standard Includes ----------------------------------------------------------- +#include + +// System Includes ------------------------------------------------------------- +#include +#include +#include +#include +#include +#include +#include + +// Project Includes ------------------------------------------------------------ +#include +#include +#include + +// 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; +} + diff --git a/src/tests/kits/app/bmessagerunner/SetCountTester.h b/src/tests/kits/app/bmessagerunner/SetCountTester.h new file mode 100644 index 0000000000..802d25523a --- /dev/null +++ b/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 diff --git a/src/tests/kits/app/bmessagerunner/SetIntervalTester.cpp b/src/tests/kits/app/bmessagerunner/SetIntervalTester.cpp new file mode 100644 index 0000000000..a3cf8c753a --- /dev/null +++ b/src/tests/kits/app/bmessagerunner/SetIntervalTester.cpp @@ -0,0 +1,321 @@ +//------------------------------------------------------------------------------ +// SetIntervalTester.cpp +// +//------------------------------------------------------------------------------ + +// Standard Includes ----------------------------------------------------------- +#include + +// System Includes ------------------------------------------------------------- +#include +#include +#include +#include +#include +#include +#include + +// Project Includes ------------------------------------------------------------ +#include +#include +#include + +// 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; +} + diff --git a/src/tests/kits/app/bmessagerunner/SetIntervalTester.h b/src/tests/kits/app/bmessagerunner/SetIntervalTester.h new file mode 100644 index 0000000000..604cb1384a --- /dev/null +++ b/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