1 //------------------------------------------------------------------------------ 2 // BMessageRunnerTester.cpp 3 // 4 //------------------------------------------------------------------------------ 5 6 // Standard Includes ----------------------------------------------------------- 7 #include <algorithm> 8 #include <stdio.h> 9 10 // System Includes ------------------------------------------------------------- 11 #include <Application.h> 12 #include <Handler.h> 13 #include <Looper.h> 14 #include <Message.h> 15 #include <MessageRunner.h> 16 #include <Messenger.h> 17 #include <OS.h> 18 19 // Project Includes ------------------------------------------------------------ 20 #include <TestShell.h> 21 #include <TestUtils.h> 22 #include <cppunit/TestAssert.h> 23 24 // Local Includes -------------------------------------------------------------- 25 #include "BMessageRunnerTester.h" 26 #include "MessageRunnerTestHelpers.h" 27 28 // Local Defines --------------------------------------------------------------- 29 30 // Globals --------------------------------------------------------------------- 31 32 //------------------------------------------------------------------------------ 33 34 35 using namespace std; 36 37 38 static const char *kTesterSignature 39 = "application/x-vnd.obos-messagerunner-constructor-test"; 40 41 static const bigtime_t kMinTimeInterval = 50000; 42 43 // check_message_runner_info 44 static 45 void 46 check_message_runner_info(const BMessageRunner &runner, status_t error, 47 bigtime_t interval = 0, int32 count = 0) 48 { 49 bigtime_t runnerInterval = 0; 50 int32 runnerCount = 0; 51 CHK(runner.GetInfo(&runnerInterval, &runnerCount) == error); 52 if (error == B_OK) { 53 CHK(runnerInterval == interval); 54 CHK(runnerCount == count); 55 } 56 } 57 58 /* 59 BMessageRunner(BMessenger target, const BMessage *message, 60 bigtime_t interval, int32 count) 61 @case 1 target is invalid, message is valid, interval > 0, 62 count > 0 63 @results InitCheck() should return B_OK. The message runner turns 64 to unusable as soon as the first message had to be sent. 65 GetInfo() should return B_OK. 66 */ 67 void TBMessageRunnerTester::BMessageRunnerA1() 68 { 69 MessageRunnerTestApp app(kTesterSignature); 70 BMessenger target; 71 BMessage message(MSG_RUNNER_MESSAGE); 72 bigtime_t interval = 100000; 73 int32 count = 5; 74 BMessageRunner runner(target, &message, interval, count); 75 CHK(runner.InitCheck() == B_OK); 76 check_message_runner_info(runner, B_OK, interval, count); 77 snooze(interval + 10000); 78 check_message_runner_info(runner, B_BAD_VALUE); 79 CHK(app.CountReplies() == 0); 80 } 81 82 /* 83 BMessageRunner(BMessenger target, const BMessage *message, 84 bigtime_t interval, int32 count) 85 @case 2 target is valid, message is NULL, interval > 0, count > 0 86 @results InitCheck() should return B_BAD_VALUE. 87 GetInfo() should return B_BAD_VALUE. 88 */ 89 void TBMessageRunnerTester::BMessageRunnerA2() 90 { 91 // R5: chrashes when passing a NULL message 92 #ifndef TEST_R5 93 MessageRunnerTestApp app(kTesterSignature); 94 MessageRunnerTestLooper *looper = app.TestLooper(); 95 BMessenger target(looper); 96 bigtime_t interval = 100000; 97 int32 count = 5; 98 BMessageRunner runner(target, NULL, interval, count); 99 CHK(runner.InitCheck() == B_BAD_VALUE); 100 check_message_runner_info(runner, B_BAD_VALUE); 101 #endif 102 } 103 104 /* 105 BMessageRunner(BMessenger target, const BMessage *message, 106 bigtime_t interval, int32 count) 107 @case 3 target is valid, message is valid, interval == 0, count > 0 108 @results R5: InitCheck() should return B_ERROR. 109 GetInfo() should return B_BAD_VALUE. 110 OBOS: InitCheck() should return B_OK. 111 GetInfo() should return B_OK. 112 A minimal time interval is used (50000). 113 */ 114 void TBMessageRunnerTester::BMessageRunnerA3() 115 { 116 MessageRunnerTestApp app(kTesterSignature); 117 MessageRunnerTestLooper *looper = app.TestLooper(); 118 BMessenger target(looper); 119 BMessage message(MSG_RUNNER_MESSAGE); 120 bigtime_t interval = 0; 121 int32 count = 5; 122 BMessageRunner runner(target, &message, interval, count); 123 #ifdef TEST_R5 124 CHK(runner.InitCheck() == B_ERROR); 125 check_message_runner_info(runner, B_BAD_VALUE); 126 #else 127 bigtime_t startTime = system_time(); 128 CHK(runner.InitCheck() == B_OK); 129 interval = max(interval, kMinTimeInterval); 130 check_message_runner_info(runner, B_OK, interval, count); 131 snooze((count + 1) * interval + 10000); 132 CHK(looper->CheckMessages(startTime, interval, count)); 133 CHK(app.CountReplies() == count); 134 #endif 135 } 136 137 /* 138 BMessageRunner(BMessenger target, const BMessage *message, 139 bigtime_t interval, int32 count) 140 @case 4 target is valid, message is valid, interval < 0, count > 0 141 @results InitCheck() should return B_OK. 142 GetInfo() should return B_OK. 143 A minimal time interval is used (50000). 144 */ 145 void TBMessageRunnerTester::BMessageRunnerA4() 146 { 147 MessageRunnerTestApp app(kTesterSignature); 148 MessageRunnerTestLooper *looper = app.TestLooper(); 149 BMessenger target(looper); 150 BMessage message(MSG_RUNNER_MESSAGE); 151 bigtime_t interval = -1; 152 int32 count = 5; 153 BMessageRunner runner(target, &message, interval, count); 154 bigtime_t startTime = system_time(); 155 CHK(runner.InitCheck() == B_OK); 156 interval = max(interval, kMinTimeInterval); 157 check_message_runner_info(runner, B_OK, interval, count); 158 snooze((count + 1) * interval + 10000); 159 CHK(looper->CheckMessages(startTime, interval, count)); 160 CHK(app.CountReplies() == count); 161 } 162 163 /* 164 BMessageRunner(BMessenger target, const BMessage *message, 165 bigtime_t interval, int32 count) 166 @case 5 target is valid, message is valid, 167 interval == LONGLONG_MAX, count > 0 168 @results InitCheck() should return B_OK. 169 GetInfo() should return B_OK. 170 No message should be delivered. 171 */ 172 void TBMessageRunnerTester::BMessageRunnerA5() 173 { 174 // R5: doesn't behave very well. In worst case registrar time loop gets 175 // locked up and system wide message runners don't get messages anymore. 176 #ifndef TEST_R5 177 MessageRunnerTestApp app(kTesterSignature); 178 MessageRunnerTestLooper *looper = app.TestLooper(); 179 BMessenger target(looper); 180 BMessage message(MSG_RUNNER_MESSAGE); 181 bigtime_t interval = LONGLONG_MAX; 182 int32 count = 5; 183 BMessageRunner runner(target, &message, interval, count); 184 bigtime_t startTime = system_time(); 185 CHK(runner.InitCheck() == B_OK); 186 interval = max(interval, kMinTimeInterval); 187 check_message_runner_info(runner, B_OK, interval, count); 188 snooze(10000); 189 CHK(looper->CheckMessages(startTime, interval, 0)); 190 CHK(app.CountReplies() == 0); 191 #endif 192 } 193 194 /* 195 BMessageRunner(BMessenger target, const BMessage *message, 196 bigtime_t interval, int32 count) 197 @case 6 target is valid, message is valid, interval > 0, count == 0 198 @results InitCheck() should return B_ERROR. 199 GetInfo() should return B_BAD_VALUE. 200 */ 201 void TBMessageRunnerTester::BMessageRunnerA6() 202 { 203 MessageRunnerTestApp app(kTesterSignature); 204 MessageRunnerTestLooper *looper = app.TestLooper(); 205 BMessenger target(looper); 206 BMessage message(MSG_RUNNER_MESSAGE); 207 bigtime_t interval = 100000; 208 int32 count = 0; 209 BMessageRunner runner(target, &message, interval, count); 210 CHK(runner.InitCheck() == B_ERROR); 211 check_message_runner_info(runner, B_BAD_VALUE); 212 } 213 214 /* 215 BMessageRunner(BMessenger target, const BMessage *message, 216 bigtime_t interval, int32 count) 217 @case 7 target is valid, message is valid, interval > 0, count < 0 218 @results InitCheck() should return B_OK. 219 GetInfo() should return B_OK. 220 Unlimited number of messages. 221 */ 222 void TBMessageRunnerTester::BMessageRunnerA7() 223 { 224 MessageRunnerTestApp app(kTesterSignature); 225 MessageRunnerTestLooper *looper = app.TestLooper(); 226 BMessenger target(looper); 227 BMessage message(MSG_RUNNER_MESSAGE); 228 bigtime_t interval = 100000; 229 int32 count = 5; 230 BMessageRunner runner(target, &message, interval, count); 231 bigtime_t startTime = system_time(); 232 CHK(runner.InitCheck() == B_OK); 233 interval = max(interval, kMinTimeInterval); 234 check_message_runner_info(runner, B_OK, interval, count); 235 int32 checkCount = 5; 236 snooze(checkCount * interval + 10000); 237 CHK(looper->CheckMessages(startTime, interval, checkCount)); 238 CHK(app.CountReplies() == checkCount); 239 } 240 241 /* 242 BMessageRunner(BMessenger target, const BMessage *message, 243 bigtime_t interval, int32 count) 244 @case 8 target is valid, message is valid, interval > 0, count > 0 245 @results InitCheck() should return B_OK. 246 GetInfo() should return B_OK. 247 count messages are sent. 248 */ 249 void TBMessageRunnerTester::BMessageRunnerA8() 250 { 251 MessageRunnerTestApp app(kTesterSignature); 252 MessageRunnerTestLooper *looper = app.TestLooper(); 253 BMessenger target(looper); 254 BMessage message(MSG_RUNNER_MESSAGE); 255 bigtime_t interval = 100000; 256 int32 count = 5; 257 BMessageRunner runner(target, &message, interval, count); 258 bigtime_t startTime = system_time(); 259 CHK(runner.InitCheck() == B_OK); 260 interval = max(interval, kMinTimeInterval); 261 check_message_runner_info(runner, B_OK, interval, count); 262 snooze((count + 1) * interval + 10000); 263 CHK(looper->CheckMessages(startTime, interval, count)); 264 CHK(app.CountReplies() == count); 265 } 266 267 /* 268 BMessageRunner(BMessenger target, const BMessage *message, 269 bigtime_t interval, int32 count, BMessenger replyTo) 270 @case 1 target is invalid, message is valid, interval > 0, 271 count > 0 272 @results InitCheck() should return B_OK. The message runner turns 273 to unusable as soon as the first message had to be sent. 274 GetInfo() should return B_OK. 275 */ 276 void TBMessageRunnerTester::BMessageRunnerB1() 277 { 278 MessageRunnerTestApp app(kTesterSignature); 279 BMessenger target; 280 BMessage message(MSG_RUNNER_MESSAGE); 281 bigtime_t interval = 100000; 282 int32 count = 5; 283 MessageRunnerTestHandler *handler = app.TestHandler(); 284 BMessenger replyTo(handler); 285 BMessageRunner runner(target, &message, interval, count, replyTo); 286 CHK(runner.InitCheck() == B_OK); 287 check_message_runner_info(runner, B_OK, interval, count); 288 snooze(interval + 10000); 289 check_message_runner_info(runner, B_BAD_VALUE); 290 CHK(app.CountReplies() == 0); 291 CHK(handler->CountReplies() == 0); 292 } 293 294 /* 295 BMessageRunner(BMessenger target, const BMessage *message, 296 bigtime_t interval, int32 count, BMessenger replyTo) 297 @case 2 target is valid, message is NULL, interval > 0, count > 0 298 @results InitCheck() should return B_BAD_VALUE. 299 GetInfo() should return B_BAD_VALUE. 300 */ 301 void TBMessageRunnerTester::BMessageRunnerB2() 302 { 303 // R5: chrashes when passing a NULL message 304 #ifndef TEST_R5 305 MessageRunnerTestApp app(kTesterSignature); 306 MessageRunnerTestLooper *looper = app.TestLooper(); 307 BMessenger target(looper); 308 bigtime_t interval = 100000; 309 int32 count = 5; 310 MessageRunnerTestHandler *handler = app.TestHandler(); 311 BMessenger replyTo(handler); 312 BMessageRunner runner(target, NULL, interval, count, replyTo); 313 CHK(runner.InitCheck() == B_BAD_VALUE); 314 check_message_runner_info(runner, B_BAD_VALUE); 315 #endif 316 } 317 318 /* 319 BMessageRunner(BMessenger target, const BMessage *message, 320 bigtime_t interval, int32 count, BMessenger replyTo) 321 @case 3 target is valid, message is valid, interval == 0, count > 0 322 @results R5: InitCheck() should return B_ERROR. 323 GetInfo() should return B_BAD_VALUE. 324 OBOS: InitCheck() should return B_OK. 325 GetInfo() should return B_OK. 326 A minimal time interval is used (50000). 327 */ 328 void TBMessageRunnerTester::BMessageRunnerB3() 329 { 330 MessageRunnerTestApp app(kTesterSignature); 331 MessageRunnerTestLooper *looper = app.TestLooper(); 332 BMessenger target(looper); 333 BMessage message(MSG_RUNNER_MESSAGE); 334 bigtime_t interval = 0; 335 int32 count = 5; 336 MessageRunnerTestHandler *handler = app.TestHandler(); 337 BMessenger replyTo(handler); 338 BMessageRunner runner(target, &message, interval, count, replyTo); 339 #ifdef TEST_R5 340 CHK(runner.InitCheck() == B_ERROR); 341 check_message_runner_info(runner, B_BAD_VALUE); 342 #else 343 bigtime_t startTime = system_time(); 344 CHK(runner.InitCheck() == B_OK); 345 interval = max(interval, kMinTimeInterval); 346 check_message_runner_info(runner, B_OK, interval, count); 347 snooze((count + 1) * interval + 10000); 348 CHK(looper->CheckMessages(startTime, interval, count)); 349 CHK(app.CountReplies() == 0); 350 CHK(handler->CountReplies() == count); 351 #endif 352 } 353 354 /* 355 BMessageRunner(BMessenger target, const BMessage *message, 356 bigtime_t interval, int32 count, BMessenger replyTo) 357 @case 4 target is valid, message is valid, interval < 0, count > 0 358 @results InitCheck() should return B_OK. 359 GetInfo() should return B_OK. 360 A minimal time interval is used (50000). 361 */ 362 void TBMessageRunnerTester::BMessageRunnerB4() 363 { 364 MessageRunnerTestApp app(kTesterSignature); 365 MessageRunnerTestLooper *looper = app.TestLooper(); 366 BMessenger target(looper); 367 BMessage message(MSG_RUNNER_MESSAGE); 368 bigtime_t interval = -1; 369 int32 count = 5; 370 MessageRunnerTestHandler *handler = app.TestHandler(); 371 BMessenger replyTo(handler); 372 BMessageRunner runner(target, &message, interval, count, replyTo); 373 bigtime_t startTime = system_time(); 374 CHK(runner.InitCheck() == B_OK); 375 interval = max(interval, kMinTimeInterval); 376 check_message_runner_info(runner, B_OK, interval, count); 377 snooze((count + 1) * interval + 10000); 378 CHK(looper->CheckMessages(startTime, interval, count)); 379 CHK(app.CountReplies() == 0); 380 CHK(handler->CountReplies() == count); 381 } 382 383 /* 384 BMessageRunner(BMessenger target, const BMessage *message, 385 bigtime_t interval, int32 count, BMessenger replyTo) 386 @case 5 target is valid, message is valid, 387 interval == LONGLONG_MAX, count > 0 388 @results InitCheck() should return B_OK. 389 GetInfo() should return B_OK. 390 No message should be delivered. 391 */ 392 void TBMessageRunnerTester::BMessageRunnerB5() 393 { 394 // R5: doesn't behave very well. In worst case registrar time loop gets 395 // locked up and system wide message runners don't get messages anymore. 396 #ifndef TEST_R5 397 MessageRunnerTestApp app(kTesterSignature); 398 MessageRunnerTestLooper *looper = app.TestLooper(); 399 BMessenger target(looper); 400 BMessage message(MSG_RUNNER_MESSAGE); 401 bigtime_t interval = LONGLONG_MAX; 402 int32 count = 5; 403 MessageRunnerTestHandler *handler = app.TestHandler(); 404 BMessenger replyTo(handler); 405 BMessageRunner runner(target, &message, interval, count, replyTo); 406 bigtime_t startTime = system_time(); 407 CHK(runner.InitCheck() == B_OK); 408 interval = max(interval, kMinTimeInterval); 409 check_message_runner_info(runner, B_OK, interval, count); 410 snooze(10000); 411 CHK(looper->CheckMessages(startTime, interval, 0)); 412 CHK(app.CountReplies() == 0); 413 CHK(handler->CountReplies() == 0); 414 #endif 415 } 416 417 /* 418 BMessageRunner(BMessenger target, const BMessage *message, 419 bigtime_t interval, int32 count, BMessenger replyTo) 420 @case 6 target is valid, message is valid, interval > 0, count == 0 421 @results InitCheck() should return B_ERROR. 422 GetInfo() should return B_BAD_VALUE. 423 */ 424 void TBMessageRunnerTester::BMessageRunnerB6() 425 { 426 MessageRunnerTestApp app(kTesterSignature); 427 MessageRunnerTestLooper *looper = app.TestLooper(); 428 BMessenger target(looper); 429 BMessage message(MSG_RUNNER_MESSAGE); 430 bigtime_t interval = 100000; 431 int32 count = 0; 432 MessageRunnerTestHandler *handler = app.TestHandler(); 433 BMessenger replyTo(handler); 434 BMessageRunner runner(target, &message, interval, count, replyTo); 435 CHK(runner.InitCheck() == B_ERROR); 436 check_message_runner_info(runner, B_BAD_VALUE); 437 } 438 439 /* 440 BMessageRunner(BMessenger target, const BMessage *message, 441 bigtime_t interval, int32 count, BMessenger replyTo) 442 @case 7 target is valid, message is valid, interval > 0, count < 0 443 @results InitCheck() should return B_OK. 444 GetInfo() should return B_OK. 445 Unlimited number of messages. 446 */ 447 void TBMessageRunnerTester::BMessageRunnerB7() 448 { 449 MessageRunnerTestApp app(kTesterSignature); 450 MessageRunnerTestLooper *looper = app.TestLooper(); 451 BMessenger target(looper); 452 BMessage message(MSG_RUNNER_MESSAGE); 453 bigtime_t interval = 100000; 454 int32 count = 5; 455 MessageRunnerTestHandler *handler = app.TestHandler(); 456 BMessenger replyTo(handler); 457 BMessageRunner runner(target, &message, interval, count, replyTo); 458 bigtime_t startTime = system_time(); 459 CHK(runner.InitCheck() == B_OK); 460 interval = max(interval, kMinTimeInterval); 461 check_message_runner_info(runner, B_OK, interval, count); 462 int32 checkCount = 5; 463 snooze(checkCount * interval + 10000); 464 CHK(looper->CheckMessages(startTime, interval, checkCount)); 465 CHK(app.CountReplies() == 0); 466 CHK(handler->CountReplies() == checkCount); 467 } 468 469 /* 470 BMessageRunner(BMessenger target, const BMessage *message, 471 bigtime_t interval, int32 count, BMessenger replyTo) 472 @case 8 target is valid, message is valid, interval > 0, count > 0 473 @results InitCheck() should return B_OK. 474 GetInfo() should return B_OK. 475 count messages are sent. 476 */ 477 void TBMessageRunnerTester::BMessageRunnerB8() 478 { 479 MessageRunnerTestApp app(kTesterSignature); 480 MessageRunnerTestLooper *looper = app.TestLooper(); 481 BMessenger target(looper); 482 BMessage message(MSG_RUNNER_MESSAGE); 483 bigtime_t interval = 100000; 484 int32 count = 5; 485 MessageRunnerTestHandler *handler = app.TestHandler(); 486 BMessenger replyTo(handler); 487 BMessageRunner runner(target, &message, interval, count, replyTo); 488 bigtime_t startTime = system_time(); 489 CHK(runner.InitCheck() == B_OK); 490 interval = max(interval, kMinTimeInterval); 491 check_message_runner_info(runner, B_OK, interval, count); 492 snooze((count + 1) * interval + 10000); 493 CHK(looper->CheckMessages(startTime, interval, count)); 494 CHK(app.CountReplies() == 0); 495 CHK(handler->CountReplies() == count); 496 } 497 498 /* 499 BMessageRunner(BMessenger target, const BMessage *message, 500 bigtime_t interval, int32 count, BMessenger replyTo) 501 @case 9 target is valid, message is valid, interval > 0, count > 0, 502 replyTo is invalid 503 @results InitCheck() should return B_OK. 504 GetInfo() should return B_OK. 505 count messages are sent. The replies go to the registrar! 506 */ 507 void TBMessageRunnerTester::BMessageRunnerB9() 508 { 509 MessageRunnerTestApp app(kTesterSignature); 510 MessageRunnerTestLooper *looper = app.TestLooper(); 511 BMessenger target(looper); 512 BMessage message(MSG_RUNNER_MESSAGE); 513 bigtime_t interval = 100000; 514 int32 count = 5; 515 MessageRunnerTestHandler *handler = app.TestHandler(); 516 BMessenger replyTo(handler); 517 BMessageRunner runner(target, &message, interval, count, replyTo); 518 bigtime_t startTime = system_time(); 519 CHK(runner.InitCheck() == B_OK); 520 interval = max(interval, kMinTimeInterval); 521 check_message_runner_info(runner, B_OK, interval, count); 522 snooze((count + 1) * interval + 10000); 523 CHK(looper->CheckMessages(startTime, interval, count)); 524 CHK(app.CountReplies() == 0); 525 CHK(handler->CountReplies() == count); 526 } 527 528 529 Test* TBMessageRunnerTester::Suite() 530 { 531 TestSuite* SuiteOfTests = new TestSuite; 532 533 ADD_TEST4(BMessageRunner, SuiteOfTests, TBMessageRunnerTester, 534 BMessageRunnerA1); 535 ADD_TEST4(BMessageRunner, SuiteOfTests, TBMessageRunnerTester, 536 BMessageRunnerA2); 537 ADD_TEST4(BMessageRunner, SuiteOfTests, TBMessageRunnerTester, 538 BMessageRunnerA3); 539 ADD_TEST4(BMessageRunner, SuiteOfTests, TBMessageRunnerTester, 540 BMessageRunnerA4); 541 ADD_TEST4(BMessageRunner, SuiteOfTests, TBMessageRunnerTester, 542 BMessageRunnerA5); 543 ADD_TEST4(BMessageRunner, SuiteOfTests, TBMessageRunnerTester, 544 BMessageRunnerA6); 545 ADD_TEST4(BMessageRunner, SuiteOfTests, TBMessageRunnerTester, 546 BMessageRunnerA7); 547 ADD_TEST4(BMessageRunner, SuiteOfTests, TBMessageRunnerTester, 548 BMessageRunnerA8); 549 550 ADD_TEST4(BMessageRunner, SuiteOfTests, TBMessageRunnerTester, 551 BMessageRunnerB1); 552 ADD_TEST4(BMessageRunner, SuiteOfTests, TBMessageRunnerTester, 553 BMessageRunnerB2); 554 ADD_TEST4(BMessageRunner, SuiteOfTests, TBMessageRunnerTester, 555 BMessageRunnerB3); 556 ADD_TEST4(BMessageRunner, SuiteOfTests, TBMessageRunnerTester, 557 BMessageRunnerB4); 558 ADD_TEST4(BMessageRunner, SuiteOfTests, TBMessageRunnerTester, 559 BMessageRunnerB5); 560 ADD_TEST4(BMessageRunner, SuiteOfTests, TBMessageRunnerTester, 561 BMessageRunnerB6); 562 ADD_TEST4(BMessageRunner, SuiteOfTests, TBMessageRunnerTester, 563 BMessageRunnerB7); 564 ADD_TEST4(BMessageRunner, SuiteOfTests, TBMessageRunnerTester, 565 BMessageRunnerB8); 566 ADD_TEST4(BMessageRunner, SuiteOfTests, TBMessageRunnerTester, 567 BMessageRunnerB9); 568 569 return SuiteOfTests; 570 } 571 572