Added BMessageRunner tests.
git-svn-id: file:///srv/svn/repos/haiku/trunk/current@1465 a95241bf-73f2-0310-859d-f6bbb57e9c96
This commit is contained in:
Ingo Weinhold
@@ -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());
|
||||
|
||||
@@ -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
|
||||
|
||||
@@ -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.
|
||||
|
After Width: | Height: | Size: 6.0 KiB |
@@ -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;
|
||||
}
|
||||
|
||||
@@ -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
|
||||
@@ -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;
|
||||
}
|
||||
|
||||
@@ -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_
|
||||
|
||||
@@ -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;
|
||||
}
|
||||
|
||||
@@ -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
|
||||
@@ -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;
|
||||
}
|
||||
|
||||
@@ -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
|
||||
@@ -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;
|
||||
}
|
||||
|
||||
@@ -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
|
||||
Reference in New Issue
Block a user