1 //------------------------------------------------------------------------------ 2 // MessageItemTest.h 3 // 4 //------------------------------------------------------------------------------ 5 6 #ifndef MESSAGEITEMTEST_H 7 #define MESSAGEITEMTEST_H 8 9 // A sad attempt to get rid of the horrible and pathetic vector<bool> specialization 10 #define __SGI_STL_INTERNAL_BVECTOR_H 11 12 // Standard Includes ----------------------------------------------------------- 13 #include <iostream> 14 #include <stdio.h> 15 #ifdef TEST_OBOS 16 #include <posix/typeinfo> 17 #else 18 #include <typeinfo> 19 #endif 20 #include <posix/string.h> 21 22 // System Includes ------------------------------------------------------------- 23 #include <Message.h> 24 25 // Project Includes ------------------------------------------------------------ 26 27 // Local Includes -------------------------------------------------------------- 28 #include "../common.h" 29 30 // Local Defines --------------------------------------------------------------- 31 #define TEMPLATE_TEST_PARAMS <Type, TypeCode, FuncPolicy, InitPolicy, AssertPolicy, ComparePolicy> 32 #define ADD_TEMPLATE_TEST(classbeingtested, suitename, classname, funcname) \ 33 (suitename)->addTest(new TestCaller<classname>(((string(#classbeingtested) + "::" + #funcname + "::" + typeid(Type).name()).c_str() ), \ 34 &classname::funcname)); 35 36 // Globals --------------------------------------------------------------------- 37 template 38 < 39 class Type, // int32 40 type_code TypeCode, // B_INT32_TYPE 41 class FuncPolicy, // status_t Add(BMessage&, const char*, Type&) 42 // status_t Find(BMessage&, const char*, int32, Type*) 43 // Type QuickFind(BMessage&, const char*, int32) 44 // bool Has(BMessage&, const char*, int32) 45 // status_t Replace(BMessage&, const char*, int32, Type) 46 class InitPolicy, // Type Zero() 47 // Type Test1() 48 // Type Test2() 49 // size_t SizeOf(const Type&) 50 // ArrayType Array() 51 // typedef XXX ArrayType 52 class AssertPolicy, // Type Zero() 53 // Type Invalid() 54 class ComparePolicy // bool Compare(const Type& lhs, const Type& rhs) 55 > 56 class TMessageItemTest; 57 58 59 //------------------------------------------------------------------------------ 60 template<class T> 61 struct ArrayTypeBase 62 { 63 typedef vector<T> ArrayType; 64 typedef typename ArrayType::size_type SizeType; 65 static SizeType Size(ArrayType& array) { return array.size(); } 66 }; 67 //------------------------------------------------------------------------------ 68 template<class Type> 69 struct TypePolicy 70 { 71 typedef Type* TypePtr; 72 enum { FixedSize = true }; 73 inline Type& Dereference(TypePtr p) 74 { 75 return *p; 76 } 77 inline TypePtr AddressOf(Type& t) { return &t; } 78 }; 79 //------------------------------------------------------------------------------ 80 template 81 < 82 typename Type, 83 status_t (BMessage::*AddFunc)(const char*, Type), 84 status_t (BMessage::*FindFunc)(const char*, int32, Type*) const, 85 status_t (BMessage::*ShortFindFunc)(const char*, Type*) const, 86 Type (BMessage::*QuickFindFunc)(const char*, int32) const, 87 bool (BMessage::*HasFunc)(const char*, int32) const, 88 status_t (BMessage::*ReplaceFunc)(const char*, int32, Type), 89 status_t (BMessage::*AddDataFunc)(const char*, type_code, const void*, 90 ssize_t, bool, int32) = &BMessage::AddData, 91 status_t (BMessage::*FindDataFunc)(const char*, type_code, int32, 92 const void**, ssize_t*) const = &BMessage::FindData 93 > 94 struct TMessageItemFuncPolicy : public TypePolicy<Type> 95 { 96 static status_t Add(BMessage& msg, const char* name, Type& val) 97 { 98 return (msg.*AddFunc)(name, val); 99 } 100 static status_t AddData(BMessage& msg, const char* name, type_code type, 101 TypePtr val, ssize_t size, bool fixedSize = true) 102 { 103 return (msg.*AddDataFunc)(name, type, (const void*)val, size, fixedSize); 104 } 105 static status_t Find(BMessage& msg, const char* name, int32 index, Type* val) 106 { 107 return (msg.*FindFunc)(name, index, val); 108 } 109 static status_t ShortFind(BMessage& msg, const char* name, Type* val) 110 { 111 return (msg.*ShortFindFunc)(name, val); 112 } 113 static Type QuickFind(BMessage& msg, const char* name, int32 index) 114 { 115 return (msg.*QuickFindFunc)(name, index); 116 } 117 static bool Has(BMessage& msg, const char* name, int32 index) 118 { 119 return (msg.*HasFunc)(name, index); 120 } 121 static status_t Replace(BMessage& msg, const char* name, int32 index, Type& val) 122 { 123 return (msg.*ReplaceFunc)(name, index, val); 124 } 125 static status_t FindData(BMessage& msg, const char* name, type_code type, 126 int32 index, const void** data, ssize_t* size) 127 { 128 return (msg.*FindDataFunc)(name, type, index, data, size); 129 } 130 }; 131 //------------------------------------------------------------------------------ 132 template<class T, T zero = T(), T invalid = T()> 133 struct TMessageItemAssertPolicy 134 { 135 inline static T Zero() { return zero; } 136 inline static T Invalid() { return invalid; } 137 inline static bool Size(size_t size, T& t) 138 { return size == sizeof (t); } 139 }; 140 //------------------------------------------------------------------------------ 141 template<class T> 142 struct TMessageItemComparePolicy 143 { 144 inline static bool Compare(const T& lhs, const T& rhs); 145 // { return lhs == rhs; } 146 }; 147 template<class T> 148 bool 149 TMessageItemComparePolicy<T>::Compare(const T &lhs, const T &rhs) 150 { 151 return lhs == rhs; 152 } 153 //------------------------------------------------------------------------------ 154 template 155 < 156 class Type, // int32 157 type_code TypeCode, // B_INT32_TYPE 158 class FuncPolicy, // status_t Add(BMessage&, const char*, Type&) 159 // status_t Find(BMessage&, const char*, int32, Type*) 160 // Type QuickFind(BMessage&, const char*, int32) 161 // bool Has(BMessage&, const char*, int32) 162 // status_t Replace(BMessage&, const char*, int32, Type) 163 // status_t FindData(BMessage&, const char*, type_code, int32, const void**, ssize_t*) 164 class InitPolicy, // Type Zero() 165 // Type Test1() 166 // Type Test2() 167 // size_t SizeOf(const Type&) 168 // ArrayType Array() 169 // typedef XXX ArrayType 170 class AssertPolicy, // Type Zero() 171 // Type Invalid() 172 // bool Size(size_t, T&) 173 class ComparePolicy // bool Compare(const Type& lhs, const Type& rhs) 174 = TMessageItemComparePolicy<Type> 175 > 176 class TMessageItemTest : public TestCase, public TypePolicy<Type> 177 { 178 public: 179 TMessageItemTest() {;} 180 TMessageItemTest(std::string name) : TestCase(name) {;} 181 182 void MessageItemTest1(); 183 void MessageItemTest2(); 184 void MessageItemTest3(); 185 void MessageItemTest4(); 186 void MessageItemTest5(); 187 void MessageItemTest6(); 188 void MessageItemTest7(); 189 void MessageItemTest8(); 190 void MessageItemTest9(); 191 void MessageItemTest10(); 192 193 static TestSuite* Suite(); 194 195 typedef typename InitPolicy::ArrayType ArrayType; 196 }; 197 198 199 //------------------------------------------------------------------------------ 200 template 201 < 202 class Type, 203 type_code TypeCode, 204 class FuncPolicy, 205 class InitPolicy, 206 class AssertPolicy, 207 class ComparePolicy 208 > 209 void 210 TMessageItemTest<Type, TypeCode, FuncPolicy, InitPolicy, AssertPolicy, ComparePolicy>:: 211 MessageItemTest1() 212 { 213 BMessage msg; 214 Type out = InitPolicy::Zero(); 215 CPPUNIT_ASSERT(FuncPolicy::ShortFind(msg, "item", &out) == B_NAME_NOT_FOUND); 216 CPPUNIT_ASSERT(FuncPolicy::Find(msg, "item", 0, &out) == B_NAME_NOT_FOUND); 217 CPPUNIT_ASSERT(ComparePolicy::Compare(out, AssertPolicy::Invalid())); 218 CPPUNIT_ASSERT(ComparePolicy::Compare(FuncPolicy::QuickFind(msg, "item", 0), 219 AssertPolicy::Invalid())); 220 CPPUNIT_ASSERT(!FuncPolicy::Has(msg, "item", 0)); 221 const void* ptr = &out; 222 ssize_t size; 223 CPPUNIT_ASSERT(FuncPolicy::FindData(msg, "item", TypeCode, 0, &ptr, &size) == 224 B_NAME_NOT_FOUND); 225 CPPUNIT_ASSERT(ptr == NULL); 226 } 227 //------------------------------------------------------------------------------ 228 template 229 < 230 class Type, 231 type_code TypeCode, 232 class FuncPolicy, 233 class InitPolicy, 234 class AssertPolicy, 235 class ComparePolicy 236 > 237 void 238 TMessageItemTest<Type, TypeCode, FuncPolicy, InitPolicy, AssertPolicy, ComparePolicy>:: 239 MessageItemTest2() 240 { 241 BMessage msg; 242 Type in = InitPolicy::Test1(); 243 Type out = InitPolicy::Zero(); 244 CPPUNIT_ASSERT(FuncPolicy::Add(msg, "item", in) == B_OK); 245 CPPUNIT_ASSERT(FuncPolicy::Has(msg, "item", 0)); 246 CPPUNIT_ASSERT(ComparePolicy::Compare(FuncPolicy::QuickFind(msg, "item", 0), in)); 247 CPPUNIT_ASSERT(FuncPolicy::ShortFind(msg, "item", &out) == B_OK); 248 CPPUNIT_ASSERT(FuncPolicy::Find(msg, "item", 0, &out) == B_OK); 249 CPPUNIT_ASSERT(ComparePolicy::Compare(out, in)); 250 TypePtr pout = NULL; 251 ssize_t size; 252 status_t err = FuncPolicy::FindData(msg, "item", TypeCode, 0, 253 (const void**)&pout, &size); 254 CPPUNIT_ASSERT(err == B_OK); 255 CPPUNIT_ASSERT(ComparePolicy::Compare(Dereference(pout), in)); 256 CPPUNIT_ASSERT(AssertPolicy::Size(size, Dereference(pout))); 257 } 258 //------------------------------------------------------------------------------ 259 template 260 < 261 class Type, 262 type_code TypeCode, 263 class FuncPolicy, 264 class InitPolicy, 265 class AssertPolicy, 266 class ComparePolicy 267 > 268 void 269 TMessageItemTest<Type, TypeCode, FuncPolicy, InitPolicy, AssertPolicy, ComparePolicy>:: 270 MessageItemTest3() 271 { 272 BMessage msg; 273 Type in = InitPolicy::Test1(); 274 Type in2 = InitPolicy::Test2(); 275 Type out = InitPolicy::Zero(); 276 CPPUNIT_ASSERT(FuncPolicy::Add(msg, "item", in) == B_OK); 277 CPPUNIT_ASSERT(FuncPolicy::Replace(msg, "item", 0, in2) == B_OK); 278 CPPUNIT_ASSERT(FuncPolicy::Has(msg, "item", 0)); 279 CPPUNIT_ASSERT(ComparePolicy::Compare(FuncPolicy::QuickFind(msg, "item", 0), in2)); 280 CPPUNIT_ASSERT(FuncPolicy::ShortFind(msg, "item", &out) == B_OK); 281 CPPUNIT_ASSERT(FuncPolicy::Find(msg, "item", 0, &out) == B_OK); 282 CPPUNIT_ASSERT(ComparePolicy::Compare(out, in2)); 283 out = InitPolicy::Zero(); 284 TypePtr pout; 285 ssize_t size; 286 CPPUNIT_ASSERT(FuncPolicy::FindData(msg, "item", TypeCode, 0, 287 (const void**)&pout, &size) == B_OK); 288 CPPUNIT_ASSERT(ComparePolicy::Compare(Dereference(pout), in2)); 289 CPPUNIT_ASSERT(AssertPolicy::Size(size, Dereference(pout))); 290 } 291 //------------------------------------------------------------------------------ 292 template 293 < 294 class Type, 295 type_code TypeCode, 296 class FuncPolicy, 297 class InitPolicy, 298 class AssertPolicy, 299 class ComparePolicy 300 > 301 void 302 TMessageItemTest<Type, TypeCode, FuncPolicy, InitPolicy, AssertPolicy, ComparePolicy>:: 303 MessageItemTest4() 304 { 305 BMessage msg; 306 Type out = InitPolicy::Zero(); 307 CPPUNIT_ASSERT(FuncPolicy::Find(msg, "item", 1, &out) == B_NAME_NOT_FOUND); 308 CPPUNIT_ASSERT(ComparePolicy::Compare(out, AssertPolicy::Invalid())); 309 CPPUNIT_ASSERT(ComparePolicy::Compare(FuncPolicy::QuickFind(msg, "item", 1), 310 AssertPolicy::Invalid())); 311 CPPUNIT_ASSERT(!FuncPolicy::Has(msg, "item", 1)); 312 const void* ptr = &out; 313 ssize_t size; 314 CPPUNIT_ASSERT(FuncPolicy::FindData(msg, "item", TypeCode, 1, &ptr, &size) == 315 B_NAME_NOT_FOUND); 316 CPPUNIT_ASSERT(ptr == NULL); 317 } 318 //------------------------------------------------------------------------------ 319 template 320 < 321 class Type, 322 type_code TypeCode, 323 class FuncPolicy, 324 class InitPolicy, 325 class AssertPolicy, 326 class ComparePolicy 327 > 328 void 329 TMessageItemTest<Type, TypeCode, FuncPolicy, InitPolicy, AssertPolicy, ComparePolicy>:: 330 MessageItemTest5() 331 { 332 BMessage msg; 333 ArrayType in = InitPolicy::Array(); 334 Type out = InitPolicy::Zero(); 335 TypePtr pout; 336 ssize_t size; 337 338 for (uint32 i = 0; i < InitPolicy::Size(in); ++i) 339 { 340 CPPUNIT_ASSERT(FuncPolicy::Add(msg, "item", in[i]) == B_OK); 341 } 342 343 for (uint32 i = 0; i < InitPolicy::Size(in); ++i) 344 { 345 CPPUNIT_ASSERT(FuncPolicy::Has(msg, "item", i)); 346 CPPUNIT_ASSERT(ComparePolicy::Compare(FuncPolicy::QuickFind(msg, "item", i), 347 in[i])); 348 CPPUNIT_ASSERT(FuncPolicy::Find(msg, "item", i, &out) == B_OK); 349 CPPUNIT_ASSERT(ComparePolicy::Compare(out, in[i])); 350 CPPUNIT_ASSERT(FuncPolicy::FindData(msg, "item", TypeCode, i, 351 (const void**)&pout, &size) == B_OK); 352 CPPUNIT_ASSERT(ComparePolicy::Compare(Dereference(pout), in[i])); 353 CPPUNIT_ASSERT(AssertPolicy::Size(size, Dereference(pout))); 354 } 355 } 356 //------------------------------------------------------------------------------ 357 template 358 < 359 class Type, 360 type_code TypeCode, 361 class FuncPolicy, 362 class InitPolicy, 363 class AssertPolicy, 364 class ComparePolicy 365 > 366 void 367 TMessageItemTest<Type, TypeCode, FuncPolicy, InitPolicy, AssertPolicy, ComparePolicy>:: 368 MessageItemTest6() 369 { 370 BMessage msg; 371 ArrayType in = InitPolicy::Array(); 372 Type in2 = InitPolicy::Test2(); 373 Type out = InitPolicy::Zero(); 374 const int rIndex = 2; 375 376 for (uint32 i = 0; i < InitPolicy::Size(in); ++i) 377 { 378 CPPUNIT_ASSERT(FuncPolicy::Add(msg, "item", in[i]) == B_OK); 379 } 380 381 CPPUNIT_ASSERT(FuncPolicy::Replace(msg, "item", rIndex, in2) == B_OK); 382 CPPUNIT_ASSERT(FuncPolicy::Has(msg, "item", rIndex)); 383 CPPUNIT_ASSERT(ComparePolicy::Compare(FuncPolicy::QuickFind(msg, "item", rIndex), 384 in2)); 385 CPPUNIT_ASSERT(FuncPolicy::Find(msg, "item", rIndex, &out) == B_OK); 386 CPPUNIT_ASSERT(ComparePolicy::Compare(out, in2)); 387 out = InitPolicy::Zero(); 388 TypePtr pout; 389 ssize_t size; 390 CPPUNIT_ASSERT(FuncPolicy::FindData(msg, "item", TypeCode, rIndex, 391 (const void**)&pout, &size) == B_OK); 392 CPPUNIT_ASSERT(ComparePolicy::Compare(Dereference(pout), in2)); 393 CPPUNIT_ASSERT(AssertPolicy::Size(size, Dereference(pout))); 394 } 395 //------------------------------------------------------------------------------ 396 template 397 < 398 class Type, 399 type_code TypeCode, 400 class FuncPolicy, 401 class InitPolicy, 402 class AssertPolicy, 403 class ComparePolicy 404 > 405 void 406 TMessageItemTest<Type, TypeCode, FuncPolicy, InitPolicy, AssertPolicy, ComparePolicy>:: 407 MessageItemTest7() 408 { 409 BMessage msg; 410 Type in = InitPolicy::Test1(); 411 Type out = InitPolicy::Zero(); 412 CPPUNIT_ASSERT(FuncPolicy::AddData(msg, "item", TypeCode, AddressOf(in), 413 InitPolicy::SizeOf(in), 414 TypePolicy<Type>::FixedSize) == B_OK); 415 CPPUNIT_ASSERT(FuncPolicy::Has(msg, "item", 0)); 416 CPPUNIT_ASSERT(ComparePolicy::Compare(FuncPolicy::QuickFind(msg, "item", 0), 417 in)); 418 CPPUNIT_ASSERT(FuncPolicy::ShortFind(msg, "item", &out) == B_OK); 419 CPPUNIT_ASSERT(FuncPolicy::Find(msg, "item", 0, &out) == B_OK); 420 CPPUNIT_ASSERT(ComparePolicy::Compare(out, in)); 421 TypePtr pout = NULL; 422 ssize_t size; 423 CPPUNIT_ASSERT(FuncPolicy::FindData(msg, "item", TypeCode, 0, 424 (const void**)&pout, &size) == B_OK); 425 CPPUNIT_ASSERT(ComparePolicy::Compare(Dereference(pout), in)); 426 CPPUNIT_ASSERT(AssertPolicy::Size(size, Dereference(pout))); 427 } 428 //------------------------------------------------------------------------------ 429 #include <stdio.h> 430 template 431 < 432 class Type, 433 type_code TypeCode, 434 class FuncPolicy, 435 class InitPolicy, 436 class AssertPolicy, 437 class ComparePolicy 438 > 439 void 440 TMessageItemTest<Type, TypeCode, FuncPolicy, InitPolicy, AssertPolicy, ComparePolicy>:: 441 MessageItemTest8() 442 { 443 BMessage msg; 444 ArrayType in = InitPolicy::Array(); 445 Type out = InitPolicy::Zero(); 446 TypePtr pout; 447 ssize_t size; 448 for (uint32 i = 0; i < InitPolicy::Size(in); ++i) 449 { 450 CPPUNIT_ASSERT(FuncPolicy::AddData(msg, "item", TypeCode, 451 AddressOf(in[i]), InitPolicy::SizeOf(in[i]), 452 TypePolicy<Type>::FixedSize) == B_OK); 453 } 454 455 for (uint32 i = 0; i < InitPolicy::Size(in); ++i) 456 { 457 CPPUNIT_ASSERT(FuncPolicy::Has(msg, "item", i)); 458 CPPUNIT_ASSERT(ComparePolicy::Compare(FuncPolicy::QuickFind(msg, "item", i), 459 in[i])); 460 CPPUNIT_ASSERT(FuncPolicy::Find(msg, "item", i, &out) == B_OK); 461 CPPUNIT_ASSERT(ComparePolicy::Compare(out, in[i])); 462 CPPUNIT_ASSERT(FuncPolicy::FindData(msg, "item", TypeCode, i, 463 (const void**)&pout, &size) == B_OK); 464 CPPUNIT_ASSERT(ComparePolicy::Compare(Dereference(pout), in[i])); 465 CPPUNIT_ASSERT(AssertPolicy::Size(size, Dereference(pout))); 466 } 467 } 468 //------------------------------------------------------------------------------ 469 template 470 < 471 class Type, 472 type_code TypeCode, 473 class FuncPolicy, 474 class InitPolicy, 475 class AssertPolicy, 476 class ComparePolicy 477 > 478 void 479 TMessageItemTest<Type, TypeCode, FuncPolicy, InitPolicy, AssertPolicy, ComparePolicy>:: 480 MessageItemTest9() 481 { 482 BMessage msg; 483 Type in = InitPolicy::Test1(); 484 CPPUNIT_ASSERT(FuncPolicy::Add(msg, NULL, in) == B_BAD_VALUE); 485 } 486 //------------------------------------------------------------------------------ 487 template 488 < 489 class Type, 490 type_code TypeCode, 491 class FuncPolicy, 492 class InitPolicy, 493 class AssertPolicy, 494 class ComparePolicy 495 > 496 void 497 TMessageItemTest<Type, TypeCode, FuncPolicy, InitPolicy, AssertPolicy, ComparePolicy>:: 498 MessageItemTest10() 499 { 500 BMessage msg; 501 Type in = InitPolicy::Test1(); 502 Type out = InitPolicy::Zero(); 503 CPPUNIT_ASSERT(FuncPolicy::Add(msg, "item", in) == B_OK); 504 CPPUNIT_ASSERT(FuncPolicy::Has(msg, NULL, 0) == false); 505 CPPUNIT_ASSERT(ComparePolicy::Compare(FuncPolicy::QuickFind(msg, NULL, 0), 506 AssertPolicy::Invalid())); 507 CPPUNIT_ASSERT(FuncPolicy::ShortFind(msg, NULL, &out) == B_BAD_VALUE); 508 CPPUNIT_ASSERT(FuncPolicy::Find(msg, NULL, 0, &out) == B_BAD_VALUE); 509 TypePtr pout = NULL; 510 ssize_t size; 511 status_t err = FuncPolicy::FindData(msg, NULL, TypeCode, 0, 512 (const void**)&pout, &size); 513 CPPUNIT_ASSERT(err = B_BAD_VALUE); 514 } 515 //------------------------------------------------------------------------------ 516 template 517 < 518 class Type, 519 type_code TypeCode, 520 class FuncPolicy, 521 class InitPolicy, 522 class AssertPolicy, 523 class ComparePolicy 524 > 525 TestSuite* 526 TMessageItemTest<Type, TypeCode, FuncPolicy, InitPolicy, AssertPolicy, ComparePolicy>:: 527 Suite() 528 { 529 TestSuite* suite = new TestSuite("BMessage::Add/Find/Replace/HasRect()"); 530 531 ADD_TEMPLATE_TEST(BMessage, suite, TMessageItemTest TEMPLATE_TEST_PARAMS, MessageItemTest1); 532 ADD_TEMPLATE_TEST(BMessage, suite, TMessageItemTest TEMPLATE_TEST_PARAMS, MessageItemTest2); 533 ADD_TEMPLATE_TEST(BMessage, suite, TMessageItemTest TEMPLATE_TEST_PARAMS, MessageItemTest3); 534 ADD_TEMPLATE_TEST(BMessage, suite, TMessageItemTest TEMPLATE_TEST_PARAMS, MessageItemTest4); 535 ADD_TEMPLATE_TEST(BMessage, suite, TMessageItemTest TEMPLATE_TEST_PARAMS, MessageItemTest5); 536 ADD_TEMPLATE_TEST(BMessage, suite, TMessageItemTest TEMPLATE_TEST_PARAMS, MessageItemTest6); 537 ADD_TEMPLATE_TEST(BMessage, suite, TMessageItemTest TEMPLATE_TEST_PARAMS, MessageItemTest7); 538 ADD_TEMPLATE_TEST(BMessage, suite, TMessageItemTest TEMPLATE_TEST_PARAMS, MessageItemTest8); 539 #ifndef TEST_R5 540 ADD_TEMPLATE_TEST(BMessage, suite, TMessageItemTest TEMPLATE_TEST_PARAMS, MessageItemTest9); 541 ADD_TEMPLATE_TEST(BMessage, suite, TMessageItemTest TEMPLATE_TEST_PARAMS, MessageItemTest10); 542 #endif 543 544 return suite; 545 } 546 //------------------------------------------------------------------------------ 547 548 #endif // MESSAGEITEMTEST_H 549 550 /* 551 * $Log $ 552 * 553 * $Id $ 554 * 555 556 */