From be2939cab7f324704e9aa1eaad2be8a42f8290e7 Mon Sep 17 00:00:00 2001 From: Tyler Dauwalder Date: Mon, 22 Jul 2002 09:28:00 +0000 Subject: [PATCH] Moved the rest of the App Kit tests over to the new framework. git-svn-id: file:///srv/svn/repos/haiku/trunk/current@383 a95241bf-73f2-0310-859d-f6bbb57e9c96 --- src/tests/kits/app/AppKitTestAddon.cpp | 12 +- src/tests/kits/app/Jamfile | 45 ++++++- src/tests/kits/app/bhandler/AddFilterTest.cpp | 9 +- .../kits/app/bhandler/BHandlerTester.cpp | 34 ++--- .../kits/app/bhandler/HandlerLooperTest.cpp | 64 ++++++++++ .../kits/app/bhandler/HandlerLooperTest.h | 50 ++++++++ src/tests/kits/app/bhandler/HandlerTest.cpp | 32 +++++ src/tests/kits/app/bhandler/HandlerTest.h | 9 ++ src/tests/kits/app/bhandler/IsWatchedTest.cpp | 5 +- .../kits/app/bhandler/LockLooperTest.cpp | 9 +- .../app/bhandler/LockLooperTestCommon.cpp | 1 + .../bhandler/LockLooperWithTimeoutTest.cpp | 9 +- .../kits/app/bhandler/NextHandlerTest.cpp | 5 +- .../kits/app/bhandler/RemoveFilterTest.cpp | 15 ++- .../kits/app/bhandler/SetFilterListTest.cpp | 11 +- .../kits/app/bhandler/SetNextHandlerTest.cpp | 25 ++-- .../kits/app/bhandler/UnlockLooperTest.cpp | 7 +- src/tests/kits/app/blooper/AddHandlerTest.cpp | 5 +- .../kits/app/blooper/CountHandlersTest.cpp | 5 +- src/tests/kits/app/blooper/HandlerAtTest.cpp | 9 +- src/tests/kits/app/blooper/IndexOfTest.cpp | 13 +- .../kits/app/blooper/IsMessageWaitingTest.cpp | 11 +- src/tests/kits/app/blooper/LooperTest.cpp | 23 ++++ src/tests/kits/app/blooper/LooperTest.h | 9 ++ .../kits/app/blooper/RemoveHandlerTest.cpp | 11 +- .../app/bmessagequeue/AddMessageTest1.cpp | 49 +++---- .../kits/app/bmessagequeue/AddMessageTest1.h | 19 +-- .../app/bmessagequeue/AddMessageTest2.cpp | 54 ++++---- .../kits/app/bmessagequeue/AddMessageTest2.h | 19 +-- .../app/bmessagequeue/ConcurrencyTest1.cpp | 85 +++++++------ .../kits/app/bmessagequeue/ConcurrencyTest1.h | 19 +-- .../app/bmessagequeue/ConcurrencyTest2.cpp | 120 +++++++++--------- .../kits/app/bmessagequeue/ConcurrencyTest2.h | 21 +-- .../app/bmessagequeue/FindMessageTest1.cpp | 48 ++++--- .../kits/app/bmessagequeue/FindMessageTest1.h | 19 +-- .../app/bmessagequeue/MessageQueueTest.cpp | 26 ++++ .../kits/app/bmessagequeue/MessageQueueTest.h | 14 ++ .../bmessagequeue/MessageQueueTestCase.cpp | 47 ++++--- .../app/bmessagequeue/MessageQueueTestCase.h | 24 ++-- .../kits/app/bmessenger/BMessengerTester.cpp | 21 +-- .../kits/app/bmessenger/LockTargetTester.cpp | 15 ++- .../LockTargetWithTimeoutTester.cpp | 19 +-- .../bmessenger/MessengerAssignmentTester.cpp | 7 +- .../bmessenger/MessengerComparissonTester.cpp | 9 +- .../kits/app/bmessenger/MessengerTest.cpp | 1 + src/tests/kits/app/bmessenger/SMInvoker.cpp | 1 + src/tests/kits/app/bmessenger/SMLooper.cpp | 1 + .../kits/app/bmessenger/SMRemoteTargetApp.cpp | 1 + .../kits/app/bmessenger/SMReplyTarget.cpp | 1 + src/tests/kits/app/bmessenger/SMTarget.cpp | 1 + .../kits/app/bmessenger/SendMessageTester.cpp | 3 +- .../kits/app/bmessenger/TargetTester.cpp | 21 +-- src/tests/kits/app/common.h | 4 + .../barchivable/InstantiateObjectTester.cpp | 36 ++++++ .../barchivable/InstantiateObjectTester.h | 2 + 55 files changed, 754 insertions(+), 381 deletions(-) create mode 100644 src/tests/kits/app/bhandler/HandlerLooperTest.cpp create mode 100644 src/tests/kits/app/bhandler/HandlerLooperTest.h create mode 100644 src/tests/kits/app/bhandler/HandlerTest.cpp create mode 100644 src/tests/kits/app/bhandler/HandlerTest.h create mode 100644 src/tests/kits/app/blooper/LooperTest.cpp create mode 100644 src/tests/kits/app/blooper/LooperTest.h create mode 100644 src/tests/kits/app/bmessagequeue/MessageQueueTest.cpp create mode 100644 src/tests/kits/app/bmessagequeue/MessageQueueTest.h diff --git a/src/tests/kits/app/AppKitTestAddon.cpp b/src/tests/kits/app/AppKitTestAddon.cpp index 774f469c6c..7c9dc82120 100644 --- a/src/tests/kits/app/AppKitTestAddon.cpp +++ b/src/tests/kits/app/AppKitTestAddon.cpp @@ -2,18 +2,18 @@ #include // ##### Include headers for your tests here ##### -//#include "bhandler/HandlerTest.h" -//#include "blooper/LooperTest.h" -//#include "bmessagequeue/MessageQueueTest.h" +#include "bhandler/HandlerTest.h" +#include "blooper/LooperTest.h" +#include "bmessagequeue/MessageQueueTest.h" #include "bmessenger/MessengerTest.h" BTestSuite* getTestSuite() { BTestSuite *suite = new BTestSuite("App"); // ##### Add test suites here ##### -// suite->addTest("BHandler", HandlerTestSuite()); -// suite->addTest("BLooper", LooperTestSuite()); -// suite->addTest("BMessageQueue", MessageQueueTestSuite()); + suite->addTest("BHandler", HandlerTestSuite()); + suite->addTest("BLooper", LooperTestSuite()); + suite->addTest("BMessageQueue", MessageQueueTestSuite()); suite->addTest("BMessenger", MessengerTestSuite()); return suite; diff --git a/src/tests/kits/app/Jamfile b/src/tests/kits/app/Jamfile index e8a51b367c..030f75d82d 100644 --- a/src/tests/kits/app/Jamfile +++ b/src/tests/kits/app/Jamfile @@ -1,14 +1,47 @@ SubDir OBOS_TOP src tests kits app ; # Let Jam know where to find some of our source files -#SEARCH_SOURCE += [ FDirName $(SUBDIR) bhandler ] ; -#SEARCH_SOURCE += [ FDirName $(SUBDIR) blooper ] ; -#SEARCH_SOURCE += [ FDirName $(SUBDIR) bmessagequeue ] ; +SEARCH_SOURCE += [ FDirName $(SUBDIR) bhandler ] ; +SEARCH_SOURCE += [ FDirName $(SUBDIR) blooper ] ; +SEARCH_SOURCE += [ FDirName $(SUBDIR) bmessagequeue ] ; SEARCH_SOURCE += [ FDirName $(SUBDIR) bmessenger ] ; CommonTestLib libapptest.so : AppKitTestAddon.cpp + # BHandler + HandlerTest.cpp + AddFilterTest.cpp + BHandlerTester.cpp + IsWatchedTest.cpp + LockLooperTest.cpp + LockLooperTestCommon.cpp + LockLooperWithTimeoutTest.cpp + HandlerLooperTest.cpp + NextHandlerTest.cpp + RemoveFilterTest.cpp + SetFilterListTest.cpp + SetNextHandlerTest.cpp + UnlockLooperTest.cpp + + # BLooper + LooperTest.cpp + AddHandlerTest.cpp + CountHandlersTest.cpp + HandlerAtTest.cpp + IndexOfTest.cpp + IsMessageWaitingTest.cpp + RemoveHandlerTest.cpp + + # BMessageQueue + MessageQueueTest.cpp + AddMessageTest1.cpp + AddMessageTest2.cpp + ConcurrencyTest1.cpp + ConcurrencyTest2.cpp + FindMessageTest1.cpp + MessageQueueTestCase.cpp + # BMessenger MessengerTest.cpp BMessengerTester.cpp @@ -30,7 +63,7 @@ CommonTestLib libapptest.so : app support ; -SubInclude OBOS_TOP src tests kits app bhandler ; -SubInclude OBOS_TOP src tests kits app blooper ; +#SubInclude OBOS_TOP src tests kits app bhandler ; +#SubInclude OBOS_TOP src tests kits app blooper ; #SubInclude OBOS_TOP src tests kits app bmessageQueue ; -SubInclude OBOS_TOP src tests kits app bmessenger ; +#SubInclude OBOS_TOP src tests kits app bmessenger ; diff --git a/src/tests/kits/app/bhandler/AddFilterTest.cpp b/src/tests/kits/app/bhandler/AddFilterTest.cpp index a3d9ea4544..f818837941 100644 --- a/src/tests/kits/app/bhandler/AddFilterTest.cpp +++ b/src/tests/kits/app/bhandler/AddFilterTest.cpp @@ -94,10 +94,10 @@ Test* TAddFilterTest::Suite() { TestSuite* SuiteOfTests = new TestSuite("BHandler::AddFilter"); - ADD_TEST(SuiteOfTests, TAddFilterTest, AddFilter1); - ADD_TEST(SuiteOfTests, TAddFilterTest, AddFilter2); - ADD_TEST(SuiteOfTests, TAddFilterTest, AddFilter3); - ADD_TEST(SuiteOfTests, TAddFilterTest, AddFilter4); + ADD_TEST4(BHandler, SuiteOfTests, TAddFilterTest, AddFilter1); + ADD_TEST4(BHandler, SuiteOfTests, TAddFilterTest, AddFilter2); + ADD_TEST4(BHandler, SuiteOfTests, TAddFilterTest, AddFilter3); + ADD_TEST4(BHandler, SuiteOfTests, TAddFilterTest, AddFilter4); return SuiteOfTests; } @@ -110,3 +110,4 @@ Test* TAddFilterTest::Suite() * */ + diff --git a/src/tests/kits/app/bhandler/BHandlerTester.cpp b/src/tests/kits/app/bhandler/BHandlerTester.cpp index 32345f5194..82f24bc8ac 100644 --- a/src/tests/kits/app/bhandler/BHandlerTester.cpp +++ b/src/tests/kits/app/bhandler/BHandlerTester.cpp @@ -297,27 +297,27 @@ Test* TBHandlerTester::Suite() { TestSuite* SuiteOfTests = new TestSuite; - ADD_TEST(SuiteOfTests, TBHandlerTester, BHandler1); - ADD_TEST(SuiteOfTests, TBHandlerTester, BHandler2); - ADD_TEST(SuiteOfTests, TBHandlerTester, BHandler3); - ADD_TEST(SuiteOfTests, TBHandlerTester, BHandler4); - ADD_TEST(SuiteOfTests, TBHandlerTester, BHandler5); + ADD_TEST4(BHandler, SuiteOfTests, TBHandlerTester, BHandler1); + ADD_TEST4(BHandler, SuiteOfTests, TBHandlerTester, BHandler2); + ADD_TEST4(BHandler, SuiteOfTests, TBHandlerTester, BHandler3); + ADD_TEST4(BHandler, SuiteOfTests, TBHandlerTester, BHandler4); + ADD_TEST4(BHandler, SuiteOfTests, TBHandlerTester, BHandler5); - ADD_TEST(SuiteOfTests, TBHandlerTester, Archive1); - ADD_TEST(SuiteOfTests, TBHandlerTester, Archive2); - ADD_TEST(SuiteOfTests, TBHandlerTester, Archive3); - ADD_TEST(SuiteOfTests, TBHandlerTester, Archive4); + ADD_TEST4(BHandler, SuiteOfTests, TBHandlerTester, Archive1); + ADD_TEST4(BHandler, SuiteOfTests, TBHandlerTester, Archive2); + ADD_TEST4(BHandler, SuiteOfTests, TBHandlerTester, Archive3); + ADD_TEST4(BHandler, SuiteOfTests, TBHandlerTester, Archive4); - ADD_TEST(SuiteOfTests, TBHandlerTester, Instantiate1); - ADD_TEST(SuiteOfTests, TBHandlerTester, Instantiate2); - ADD_TEST(SuiteOfTests, TBHandlerTester, Instantiate3); + ADD_TEST4(BHandler, SuiteOfTests, TBHandlerTester, Instantiate1); + ADD_TEST4(BHandler, SuiteOfTests, TBHandlerTester, Instantiate2); + ADD_TEST4(BHandler, SuiteOfTests, TBHandlerTester, Instantiate3); - ADD_TEST(SuiteOfTests, TBHandlerTester, SetName1); - ADD_TEST(SuiteOfTests, TBHandlerTester, SetName2); + ADD_TEST4(BHandler, SuiteOfTests, TBHandlerTester, SetName1); + ADD_TEST4(BHandler, SuiteOfTests, TBHandlerTester, SetName2); - ADD_TEST(SuiteOfTests, TBHandlerTester, Perform1); + ADD_TEST4(BHandler, SuiteOfTests, TBHandlerTester, Perform1); - ADD_TEST(SuiteOfTests, TBHandlerTester, FilterList1); + ADD_TEST4(BHandler, SuiteOfTests, TBHandlerTester, FilterList1); return SuiteOfTests; } @@ -330,3 +330,5 @@ Test* TBHandlerTester::Suite() * */ + + diff --git a/src/tests/kits/app/bhandler/HandlerLooperTest.cpp b/src/tests/kits/app/bhandler/HandlerLooperTest.cpp new file mode 100644 index 0000000000..e2e2994ed1 --- /dev/null +++ b/src/tests/kits/app/bhandler/HandlerLooperTest.cpp @@ -0,0 +1,64 @@ +//------------------------------------------------------------------------------ +// LooperTest.cpp +// +//------------------------------------------------------------------------------ + +// Standard Includes ----------------------------------------------------------- + +// System Includes ------------------------------------------------------------- +#include + +// Project Includes ------------------------------------------------------------ + +// Local Includes -------------------------------------------------------------- +#include "HandlerLooperTest.h" + +// Local Defines --------------------------------------------------------------- + +// Globals --------------------------------------------------------------------- + +//------------------------------------------------------------------------------ +/** + Looper() + @case Not added to a BLooper + @results Returns NULL + */ +void TLooperTest::LooperTest1() +{ + CPPUNIT_ASSERT(fHandler.Looper() == NULL); +} +//------------------------------------------------------------------------------ +/** + Looper() + @case Add to a BLooper, then remove + @results Returns the added-to BLooper; when removed, returns NULL + */ +void TLooperTest::LooperTest2() +{ + BLooper Looper; + Looper.AddHandler(&fHandler); + CPPUNIT_ASSERT(fHandler.Looper() == &Looper); + + CPPUNIT_ASSERT(Looper.RemoveHandler(&fHandler)); + CPPUNIT_ASSERT(fHandler.Looper() == NULL); +} +//------------------------------------------------------------------------------ +Test* TLooperTest::Suite() +{ + TestSuite* SuiteOfTests = new TestSuite("BHandler::Looper"); + + ADD_TEST4(BHandler, SuiteOfTests, TLooperTest, LooperTest1); + ADD_TEST4(BHandler, SuiteOfTests, TLooperTest, LooperTest2); + + return SuiteOfTests; +} +//------------------------------------------------------------------------------ + +/* + * $Log $ + * + * $Id $ + * + */ + + diff --git a/src/tests/kits/app/bhandler/HandlerLooperTest.h b/src/tests/kits/app/bhandler/HandlerLooperTest.h new file mode 100644 index 0000000000..3190649f12 --- /dev/null +++ b/src/tests/kits/app/bhandler/HandlerLooperTest.h @@ -0,0 +1,50 @@ +//------------------------------------------------------------------------------ +// LooperTest.h +// +//------------------------------------------------------------------------------ + +#ifndef LOOPERTEST_H +#define LOOPERTEST_H + +// Standard Includes ----------------------------------------------------------- + +// System Includes ------------------------------------------------------------- +#if defined(TEST_R5) +#include +#else +#include +#endif + +// Project Includes ------------------------------------------------------------ + +// Local Includes -------------------------------------------------------------- +#include "../common.h" + +// Local Defines --------------------------------------------------------------- + +// Globals --------------------------------------------------------------------- + +class TLooperTest : public TestCase +{ + public: + TLooperTest() {;} + TLooperTest(std::string name) : TestCase(name) {;} + + void LooperTest1(); + void LooperTest2(); + + static Test* Suite(); + + private: + BHandler fHandler; +}; + +#endif //LOOPERTEST_H + +/* + * $Log $ + * + * $Id $ + * + */ + diff --git a/src/tests/kits/app/bhandler/HandlerTest.cpp b/src/tests/kits/app/bhandler/HandlerTest.cpp new file mode 100644 index 0000000000..b94c02537e --- /dev/null +++ b/src/tests/kits/app/bhandler/HandlerTest.cpp @@ -0,0 +1,32 @@ +#include "../common.h" +#include "HandlerTest.h" +#include "BHandlerTester.h" +#include "IsWatchedTest.h" +#include "HandlerLooperTest.h" +#include "SetNextHandlerTest.h" +#include "NextHandlerTest.h" +#include "AddFilterTest.h" +#include "RemoveFilterTest.h" +#include "SetFilterListTest.h" +#include "LockLooperTest.h" +#include "LockLooperWithTimeoutTest.h" +#include "UnlockLooperTest.h" + +Test* HandlerTestSuite(void) +{ + TestSuite* tests = new TestSuite(); + + tests->addTest(TBHandlerTester::Suite()); + tests->addTest(TIsWatchedTest::Suite()); + tests->addTest(TLooperTest::Suite()); + tests->addTest(TSetNextHandlerTest::Suite()); + tests->addTest(TNextHandlerTest::Suite()); + tests->addTest(TAddFilterTest::Suite()); + tests->addTest(TRemoveFilterTest::Suite()); + tests->addTest(TSetFilterListTest::Suite()); + tests->addTest(TLockLooperTest::Suite()); + tests->addTest(TLockLooperWithTimeoutTest::Suite()); + tests->addTest(TUnlockLooperTest::Suite()); + + return tests; +} diff --git a/src/tests/kits/app/bhandler/HandlerTest.h b/src/tests/kits/app/bhandler/HandlerTest.h new file mode 100644 index 0000000000..64bf1e9900 --- /dev/null +++ b/src/tests/kits/app/bhandler/HandlerTest.h @@ -0,0 +1,9 @@ +#ifndef _handler_test_h_ +#define _handler_test_h_ + +class CppUnit::Test; + +CppUnit::Test* HandlerTestSuite(); + +#endif // _handler_test_h_ + diff --git a/src/tests/kits/app/bhandler/IsWatchedTest.cpp b/src/tests/kits/app/bhandler/IsWatchedTest.cpp index 329c4aaf2b..a20bd3a96d 100644 --- a/src/tests/kits/app/bhandler/IsWatchedTest.cpp +++ b/src/tests/kits/app/bhandler/IsWatchedTest.cpp @@ -51,8 +51,8 @@ Test* TIsWatchedTest::Suite() { TestSuite* SuiteOfTests = new TestSuite("BHandler::IsWatched"); - ADD_TEST(SuiteOfTests, TIsWatchedTest, IsWatched1); - ADD_TEST(SuiteOfTests, TIsWatchedTest, IsWatched2); + ADD_TEST4(BHandler, SuiteOfTests, TIsWatchedTest, IsWatched1); + ADD_TEST4(BHandler, SuiteOfTests, TIsWatchedTest, IsWatched2); return SuiteOfTests; } @@ -65,3 +65,4 @@ Test* TIsWatchedTest::Suite() * */ + diff --git a/src/tests/kits/app/bhandler/LockLooperTest.cpp b/src/tests/kits/app/bhandler/LockLooperTest.cpp index 9164a17649..c210a9185e 100644 --- a/src/tests/kits/app/bhandler/LockLooperTest.cpp +++ b/src/tests/kits/app/bhandler/LockLooperTest.cpp @@ -91,10 +91,10 @@ Test* TLockLooperTest::Suite() { TestSuite* SuiteOfTests = new TestSuite("BHandler::LockLooper"); - ADD_TEST(SuiteOfTests, TLockLooperTest, LockLooper1); - ADD_TEST(SuiteOfTests, TLockLooperTest, LockLooper2); - ADD_TEST(SuiteOfTests, TLockLooperTest, LockLooper3); -// ADD_TEST(SuiteOfTests, TLockLooperTest, LockLooper4); + ADD_TEST4(BHandler, SuiteOfTests, TLockLooperTest, LockLooper1); + ADD_TEST4(BHandler, SuiteOfTests, TLockLooperTest, LockLooper2); + ADD_TEST4(BHandler, SuiteOfTests, TLockLooperTest, LockLooper3); +// ADD_TEST4(BHandler, SuiteOfTests, TLockLooperTest, LockLooper4); return SuiteOfTests; } @@ -107,3 +107,4 @@ Test* TLockLooperTest::Suite() * */ + diff --git a/src/tests/kits/app/bhandler/LockLooperTestCommon.cpp b/src/tests/kits/app/bhandler/LockLooperTestCommon.cpp index 4c2cdf0f8e..bbbec71927 100644 --- a/src/tests/kits/app/bhandler/LockLooperTestCommon.cpp +++ b/src/tests/kits/app/bhandler/LockLooperTestCommon.cpp @@ -42,3 +42,4 @@ int32 LockLooperThreadFunc(void* data) * */ + diff --git a/src/tests/kits/app/bhandler/LockLooperWithTimeoutTest.cpp b/src/tests/kits/app/bhandler/LockLooperWithTimeoutTest.cpp index 7f3f338f46..2cb9aa45ea 100644 --- a/src/tests/kits/app/bhandler/LockLooperWithTimeoutTest.cpp +++ b/src/tests/kits/app/bhandler/LockLooperWithTimeoutTest.cpp @@ -95,10 +95,10 @@ Test* TLockLooperWithTimeoutTest::Suite() { TestSuite* SuiteOfTests = new TestSuite("BHandler::LockLooperWithTimeout"); - ADD_TEST(SuiteOfTests, TLockLooperWithTimeoutTest, LockLooperWithTimeout1); - ADD_TEST(SuiteOfTests, TLockLooperWithTimeoutTest, LockLooperWithTimeout2); - ADD_TEST(SuiteOfTests, TLockLooperWithTimeoutTest, LockLooperWithTimeout3); -// ADD_TEST(SuiteOfTests, TLockLooperWithTimeoutTest, LockLooperWithTimeout4); + ADD_TEST4(BHandler, SuiteOfTests, TLockLooperWithTimeoutTest, LockLooperWithTimeout1); + ADD_TEST4(BHandler, SuiteOfTests, TLockLooperWithTimeoutTest, LockLooperWithTimeout2); + ADD_TEST4(BHandler, SuiteOfTests, TLockLooperWithTimeoutTest, LockLooperWithTimeout3); +// ADD_TEST4(BHandler, SuiteOfTests, TLockLooperWithTimeoutTest, LockLooperWithTimeout4); return SuiteOfTests; } @@ -111,3 +111,4 @@ Test* TLockLooperWithTimeoutTest::Suite() * */ + diff --git a/src/tests/kits/app/bhandler/NextHandlerTest.cpp b/src/tests/kits/app/bhandler/NextHandlerTest.cpp index 0666e96482..518baee5eb 100644 --- a/src/tests/kits/app/bhandler/NextHandlerTest.cpp +++ b/src/tests/kits/app/bhandler/NextHandlerTest.cpp @@ -46,8 +46,8 @@ Test* TNextHandlerTest::Suite() { TestSuite* SuiteOfTests = new TestSuite("BHandler::NextHandler"); - ADD_TEST(SuiteOfTests, TNextHandlerTest, NextHandler1); - ADD_TEST(SuiteOfTests, TNextHandlerTest, NextHandler2); + ADD_TEST4(BHandler, SuiteOfTests, TNextHandlerTest, NextHandler1); + ADD_TEST4(BHandler, SuiteOfTests, TNextHandlerTest, NextHandler2); return SuiteOfTests; } @@ -60,3 +60,4 @@ Test* TNextHandlerTest::Suite() * */ + diff --git a/src/tests/kits/app/bhandler/RemoveFilterTest.cpp b/src/tests/kits/app/bhandler/RemoveFilterTest.cpp index fc05dbc752..8a3de02c2c 100644 --- a/src/tests/kits/app/bhandler/RemoveFilterTest.cpp +++ b/src/tests/kits/app/bhandler/RemoveFilterTest.cpp @@ -140,13 +140,13 @@ Test* TRemoveFilterTest::Suite() { TestSuite* SuiteOfTests = new TestSuite("BHandler::RemoveFilter"); - ADD_TEST(SuiteOfTests, TRemoveFilterTest, RemoveFilter1); - ADD_TEST(SuiteOfTests, TRemoveFilterTest, RemoveFilter2); - ADD_TEST(SuiteOfTests, TRemoveFilterTest, RemoveFilter3); - ADD_TEST(SuiteOfTests, TRemoveFilterTest, RemoveFilter4); - ADD_TEST(SuiteOfTests, TRemoveFilterTest, RemoveFilter5); - ADD_TEST(SuiteOfTests, TRemoveFilterTest, RemoveFilter6); - ADD_TEST(SuiteOfTests, TRemoveFilterTest, RemoveFilter7); + ADD_TEST4(BHandler, SuiteOfTests, TRemoveFilterTest, RemoveFilter1); + ADD_TEST4(BHandler, SuiteOfTests, TRemoveFilterTest, RemoveFilter2); + ADD_TEST4(BHandler, SuiteOfTests, TRemoveFilterTest, RemoveFilter3); + ADD_TEST4(BHandler, SuiteOfTests, TRemoveFilterTest, RemoveFilter4); + ADD_TEST4(BHandler, SuiteOfTests, TRemoveFilterTest, RemoveFilter5); + ADD_TEST4(BHandler, SuiteOfTests, TRemoveFilterTest, RemoveFilter6); + ADD_TEST4(BHandler, SuiteOfTests, TRemoveFilterTest, RemoveFilter7); return SuiteOfTests; } @@ -159,3 +159,4 @@ Test* TRemoveFilterTest::Suite() * */ + diff --git a/src/tests/kits/app/bhandler/SetFilterListTest.cpp b/src/tests/kits/app/bhandler/SetFilterListTest.cpp index 95978eda7b..c62f231278 100644 --- a/src/tests/kits/app/bhandler/SetFilterListTest.cpp +++ b/src/tests/kits/app/bhandler/SetFilterListTest.cpp @@ -126,11 +126,11 @@ Test* TSetFilterListTest::Suite() { TestSuite* SuiteOfTests = new TestSuite("BHandler::SetFilterList"); - ADD_TEST(SuiteOfTests, TSetFilterListTest, SetFilterList1); - ADD_TEST(SuiteOfTests, TSetFilterListTest, SetFilterList2); - ADD_TEST(SuiteOfTests, TSetFilterListTest, SetFilterList3); - ADD_TEST(SuiteOfTests, TSetFilterListTest, SetFilterList4); - ADD_TEST(SuiteOfTests, TSetFilterListTest, SetFilterList5); + ADD_TEST4(BHandler, SuiteOfTests, TSetFilterListTest, SetFilterList1); + ADD_TEST4(BHandler, SuiteOfTests, TSetFilterListTest, SetFilterList2); + ADD_TEST4(BHandler, SuiteOfTests, TSetFilterListTest, SetFilterList3); + ADD_TEST4(BHandler, SuiteOfTests, TSetFilterListTest, SetFilterList4); + ADD_TEST4(BHandler, SuiteOfTests, TSetFilterListTest, SetFilterList5); return SuiteOfTests; } @@ -143,3 +143,4 @@ Test* TSetFilterListTest::Suite() * */ + diff --git a/src/tests/kits/app/bhandler/SetNextHandlerTest.cpp b/src/tests/kits/app/bhandler/SetNextHandlerTest.cpp index da26bee6c2..938ec21a09 100644 --- a/src/tests/kits/app/bhandler/SetNextHandlerTest.cpp +++ b/src/tests/kits/app/bhandler/SetNextHandlerTest.cpp @@ -291,18 +291,18 @@ Test* TSetNextHandlerTest::Suite() { TestSuite* SuiteOfTests = new TestSuite("BHandler::SetNextHandler"); - ADD_TEST(SuiteOfTests, TSetNextHandlerTest, SetNextHandler0); - ADD_TEST(SuiteOfTests, TSetNextHandlerTest, SetNextHandler1); - ADD_TEST(SuiteOfTests, TSetNextHandlerTest, SetNextHandler2); - ADD_TEST(SuiteOfTests, TSetNextHandlerTest, SetNextHandler3); - ADD_TEST(SuiteOfTests, TSetNextHandlerTest, SetNextHandler4); - ADD_TEST(SuiteOfTests, TSetNextHandlerTest, SetNextHandler5); - ADD_TEST(SuiteOfTests, TSetNextHandlerTest, SetNextHandler6); - ADD_TEST(SuiteOfTests, TSetNextHandlerTest, SetNextHandler7); - ADD_TEST(SuiteOfTests, TSetNextHandlerTest, SetNextHandler8); - ADD_TEST(SuiteOfTests, TSetNextHandlerTest, SetNextHandler9); - ADD_TEST(SuiteOfTests, TSetNextHandlerTest, SetNextHandler10); - ADD_TEST(SuiteOfTests, TSetNextHandlerTest, SetNextHandler11); + ADD_TEST4(BHandler, SuiteOfTests, TSetNextHandlerTest, SetNextHandler0); + ADD_TEST4(BHandler, SuiteOfTests, TSetNextHandlerTest, SetNextHandler1); + ADD_TEST4(BHandler, SuiteOfTests, TSetNextHandlerTest, SetNextHandler2); + ADD_TEST4(BHandler, SuiteOfTests, TSetNextHandlerTest, SetNextHandler3); + ADD_TEST4(BHandler, SuiteOfTests, TSetNextHandlerTest, SetNextHandler4); + ADD_TEST4(BHandler, SuiteOfTests, TSetNextHandlerTest, SetNextHandler5); + ADD_TEST4(BHandler, SuiteOfTests, TSetNextHandlerTest, SetNextHandler6); + ADD_TEST4(BHandler, SuiteOfTests, TSetNextHandlerTest, SetNextHandler7); + ADD_TEST4(BHandler, SuiteOfTests, TSetNextHandlerTest, SetNextHandler8); + ADD_TEST4(BHandler, SuiteOfTests, TSetNextHandlerTest, SetNextHandler9); + ADD_TEST4(BHandler, SuiteOfTests, TSetNextHandlerTest, SetNextHandler10); + ADD_TEST4(BHandler, SuiteOfTests, TSetNextHandlerTest, SetNextHandler11); return SuiteOfTests; } @@ -315,3 +315,4 @@ Test* TSetNextHandlerTest::Suite() * */ + diff --git a/src/tests/kits/app/bhandler/UnlockLooperTest.cpp b/src/tests/kits/app/bhandler/UnlockLooperTest.cpp index f029e9cfe4..d1e47923ef 100644 --- a/src/tests/kits/app/bhandler/UnlockLooperTest.cpp +++ b/src/tests/kits/app/bhandler/UnlockLooperTest.cpp @@ -76,9 +76,9 @@ Test* TUnlockLooperTest::Suite() { TestSuite* SuiteOfTests = new TestSuite("BHandler::UnlockLooper"); - ADD_TEST(SuiteOfTests, TUnlockLooperTest, UnlockLooper1); - ADD_TEST(SuiteOfTests, TUnlockLooperTest, UnlockLooper2); - ADD_TEST(SuiteOfTests, TUnlockLooperTest, UnlockLooper3); + ADD_TEST4(BHandler, SuiteOfTests, TUnlockLooperTest, UnlockLooper1); + ADD_TEST4(BHandler, SuiteOfTests, TUnlockLooperTest, UnlockLooper2); + ADD_TEST4(BHandler, SuiteOfTests, TUnlockLooperTest, UnlockLooper3); return SuiteOfTests; } @@ -91,3 +91,4 @@ Test* TUnlockLooperTest::Suite() * */ + diff --git a/src/tests/kits/app/blooper/AddHandlerTest.cpp b/src/tests/kits/app/blooper/AddHandlerTest.cpp index 614db16ce3..d00abd30f6 100644 --- a/src/tests/kits/app/blooper/AddHandlerTest.cpp +++ b/src/tests/kits/app/blooper/AddHandlerTest.cpp @@ -64,8 +64,8 @@ TestSuite* TAddHandlerTest::Suite() { TestSuite* suite = new TestSuite("BLooper::AddHandler(BHandler*)"); - ADD_TEST(suite, TAddHandlerTest, AddHandlerTest1); - ADD_TEST(suite, TAddHandlerTest, AddHandlerTest2); + ADD_TEST4(BLooper, suite, TAddHandlerTest, AddHandlerTest1); + ADD_TEST4(BLooper, suite, TAddHandlerTest, AddHandlerTest2); return suite; } @@ -78,3 +78,4 @@ TestSuite* TAddHandlerTest::Suite() * */ + diff --git a/src/tests/kits/app/blooper/CountHandlersTest.cpp b/src/tests/kits/app/blooper/CountHandlersTest.cpp index cac779722f..541abe3feb 100644 --- a/src/tests/kits/app/blooper/CountHandlersTest.cpp +++ b/src/tests/kits/app/blooper/CountHandlersTest.cpp @@ -61,8 +61,8 @@ TestSuite* TCountHandlersTest::Suite() { TestSuite* suite = new TestSuite("BLooper::CountHandlers()"); - ADD_TEST(suite, TCountHandlersTest, CountHandlersTest1); - ADD_TEST(suite, TCountHandlersTest, CountHandlersTest2); + ADD_TEST4(BLooper, suite, TCountHandlersTest, CountHandlersTest1); + ADD_TEST4(BLooper, suite, TCountHandlersTest, CountHandlersTest2); return suite; } @@ -75,3 +75,4 @@ TestSuite* TCountHandlersTest::Suite() * */ + diff --git a/src/tests/kits/app/blooper/HandlerAtTest.cpp b/src/tests/kits/app/blooper/HandlerAtTest.cpp index 071a7e1b10..08923a1620 100644 --- a/src/tests/kits/app/blooper/HandlerAtTest.cpp +++ b/src/tests/kits/app/blooper/HandlerAtTest.cpp @@ -85,10 +85,10 @@ TestSuite* THandlerAtTest::Suite() { TestSuite* suite = new TestSuite("BLooper::HandlerAt(int32)"); - ADD_TEST(suite, THandlerAtTest, HandlerAtTest1); - ADD_TEST(suite, THandlerAtTest, HandlerAtTest2); - ADD_TEST(suite, THandlerAtTest, HandlerAtTest3); - ADD_TEST(suite, THandlerAtTest, HandlerAtTest4); + ADD_TEST4(BLooper, suite, THandlerAtTest, HandlerAtTest1); + ADD_TEST4(BLooper, suite, THandlerAtTest, HandlerAtTest2); + ADD_TEST4(BLooper, suite, THandlerAtTest, HandlerAtTest3); + ADD_TEST4(BLooper, suite, THandlerAtTest, HandlerAtTest4); return suite; } @@ -101,3 +101,4 @@ TestSuite* THandlerAtTest::Suite() * */ + diff --git a/src/tests/kits/app/blooper/IndexOfTest.cpp b/src/tests/kits/app/blooper/IndexOfTest.cpp index 0fef36ce0d..f45ae9258c 100644 --- a/src/tests/kits/app/blooper/IndexOfTest.cpp +++ b/src/tests/kits/app/blooper/IndexOfTest.cpp @@ -161,12 +161,12 @@ TestSuite* TIndexOfTest::Suite() { TestSuite* suite = new TestSuite("BLooper::IndexOf(BHandler*)"); - ADD_TEST(suite, TIndexOfTest, IndexOfTest1); - ADD_TEST(suite, TIndexOfTest, IndexOfTest2); - ADD_TEST(suite, TIndexOfTest, IndexOfTest3); - ADD_TEST(suite, TIndexOfTest, IndexOfTest4); - ADD_TEST(suite, TIndexOfTest, IndexOfTest5); - ADD_TEST(suite, TIndexOfTest, IndexOfTest6); + ADD_TEST4(BLooper, suite, TIndexOfTest, IndexOfTest1); + ADD_TEST4(BLooper, suite, TIndexOfTest, IndexOfTest2); + ADD_TEST4(BLooper, suite, TIndexOfTest, IndexOfTest3); + ADD_TEST4(BLooper, suite, TIndexOfTest, IndexOfTest4); + ADD_TEST4(BLooper, suite, TIndexOfTest, IndexOfTest5); + ADD_TEST4(BLooper, suite, TIndexOfTest, IndexOfTest6); return suite; } @@ -179,3 +179,4 @@ TestSuite* TIndexOfTest::Suite() * */ + diff --git a/src/tests/kits/app/blooper/IsMessageWaitingTest.cpp b/src/tests/kits/app/blooper/IsMessageWaitingTest.cpp index ea0d3086a1..6ecd3ed992 100644 --- a/src/tests/kits/app/blooper/IsMessageWaitingTest.cpp +++ b/src/tests/kits/app/blooper/IsMessageWaitingTest.cpp @@ -170,13 +170,13 @@ Test* TIsMessageWaitingTest::Suite() { TestSuite* suite = new TestSuite("BLooper::IsMessageWaiting()"); - ADD_TEST(suite, TIsMessageWaitingTest, IsMessageWaiting1); - ADD_TEST(suite, TIsMessageWaitingTest, IsMessageWaiting2); - ADD_TEST(suite, TIsMessageWaitingTest, IsMessageWaiting3); - ADD_TEST(suite, TIsMessageWaitingTest, IsMessageWaiting4); + ADD_TEST4(BLooper, suite, TIsMessageWaitingTest, IsMessageWaiting1); + ADD_TEST4(BLooper, suite, TIsMessageWaitingTest, IsMessageWaiting2); + ADD_TEST4(BLooper, suite, TIsMessageWaitingTest, IsMessageWaiting3); + ADD_TEST4(BLooper, suite, TIsMessageWaitingTest, IsMessageWaiting4); // See note for test -// ADD_TEST(suite, TIsMessageWaitingTest, IsMessageWaiting5); +// ADD_TEST4(BLooper, suite, TIsMessageWaitingTest, IsMessageWaiting5); return suite; } @@ -189,3 +189,4 @@ Test* TIsMessageWaitingTest::Suite() * */ + diff --git a/src/tests/kits/app/blooper/LooperTest.cpp b/src/tests/kits/app/blooper/LooperTest.cpp new file mode 100644 index 0000000000..9c60cecd48 --- /dev/null +++ b/src/tests/kits/app/blooper/LooperTest.cpp @@ -0,0 +1,23 @@ +//#include "LooperTest.h" +#include "../common.h" +#include "IsMessageWaitingTest.h" +#include "RemoveHandlerTest.h" +#include "IndexOfTest.h" +#include "CountHandlersTest.h" +#include "HandlerAtTest.h" +#include "AddHandlerTest.h" + +Test* LooperTestSuite() +{ + TestSuite* tests = new TestSuite(); + + tests->addTest(TIsMessageWaitingTest::Suite()); + tests->addTest(TRemoveHandlerTest::Suite()); + tests->addTest(TIndexOfTest::Suite()); + tests->addTest(TCountHandlersTest::Suite()); + tests->addTest(THandlerAtTest::Suite()); + tests->addTest(TAddHandlerTest::Suite()); + + return tests; +} + diff --git a/src/tests/kits/app/blooper/LooperTest.h b/src/tests/kits/app/blooper/LooperTest.h new file mode 100644 index 0000000000..4751430d6d --- /dev/null +++ b/src/tests/kits/app/blooper/LooperTest.h @@ -0,0 +1,9 @@ +#ifndef _looper_test_h_ +#define _looper_test_h_ + +class CppUnit::Test; + +CppUnit::Test* LooperTestSuite(); + +#endif // _looper_test_h_ + diff --git a/src/tests/kits/app/blooper/RemoveHandlerTest.cpp b/src/tests/kits/app/blooper/RemoveHandlerTest.cpp index a40b9a9ff6..3ced752fe8 100644 --- a/src/tests/kits/app/blooper/RemoveHandlerTest.cpp +++ b/src/tests/kits/app/blooper/RemoveHandlerTest.cpp @@ -104,11 +104,11 @@ Test* TRemoveHandlerTest::Suite() { TestSuite* suite = new TestSuite("BLooper::RemoveHandler(BHandler* handler)"); - ADD_TEST(suite, TRemoveHandlerTest, RemoveHandler1); - ADD_TEST(suite, TRemoveHandlerTest, RemoveHandler2); - ADD_TEST(suite, TRemoveHandlerTest, RemoveHandler3); - ADD_TEST(suite, TRemoveHandlerTest, RemoveHandler4); - ADD_TEST(suite, TRemoveHandlerTest, RemoveHandler5); + ADD_TEST4(BLooper, suite, TRemoveHandlerTest, RemoveHandler1); + ADD_TEST4(BLooper, suite, TRemoveHandlerTest, RemoveHandler2); + ADD_TEST4(BLooper, suite, TRemoveHandlerTest, RemoveHandler3); + ADD_TEST4(BLooper, suite, TRemoveHandlerTest, RemoveHandler4); + ADD_TEST4(BLooper, suite, TRemoveHandlerTest, RemoveHandler5); return suite; } @@ -121,3 +121,4 @@ Test* TRemoveHandlerTest::Suite() * */ + diff --git a/src/tests/kits/app/bmessagequeue/AddMessageTest1.cpp b/src/tests/kits/app/bmessagequeue/AddMessageTest1.cpp index 4c98f24d12..41022a6417 100644 --- a/src/tests/kits/app/bmessagequeue/AddMessageTest1.cpp +++ b/src/tests/kits/app/bmessagequeue/AddMessageTest1.cpp @@ -1,5 +1,5 @@ /* - $Id: AddMessageTest1.cpp,v 1.1 2002/07/09 12:24:56 ejakowatz Exp $ + $Id: AddMessageTest1.cpp,v 1.2 2002/07/22 09:28:00 tylerdauwalder Exp $ This file implements the first test for the OpenBeOS BMessageQueue code. It tests the Construction, Destruction, Add Message 1, Count Messages, @@ -17,50 +17,50 @@ */ +#include "ThreadedTestCaller.h" #include "AddMessageTest1.h" #include #include -#include "MessageQueue.h" /* - * Method: AddMessageTest1::AddMessageTest1() + * Method: AddMessageTest1::AddMessageTest1() * Descr: This is the constructor for this class. */ -template - AddMessageTest1::AddMessageTest1(std::string name) : - MessageQueueTestCase(name) + + AddMessageTest1::AddMessageTest1(std::string name) : + MessageQueueTestCase(name) { } /* - * Method: AddMessageTest1::~AddMessageTest1() + * Method: AddMessageTest1::~AddMessageTest1() * Descr: This is the destructor for this class. */ -template - AddMessageTest1::~AddMessageTest1() + + AddMessageTest1::~AddMessageTest1() { } /* - * Method: AddMessageTest1::setUp() + * Method: AddMessageTest1::setUp() * Descr: This member function is called just prior to running the test. * It resets the destructor count for testMessageClass. */ -template - void AddMessageTest1::setUp(void) + + void AddMessageTest1::setUp(void) { testMessageClass::messageDestructorCount = 0; } /* - * Method: AddMessageTest1::PerformTest() + * Method: AddMessageTest1::PerformTest() * Descr: This member function performs this test. It adds * 10000 messages to the message queue and confirms that * the queue contains the right messages. Then it confirms @@ -68,46 +68,51 @@ template * queue is deleted. */ -template - void AddMessageTest1::PerformTest(void) + + void AddMessageTest1::PerformTest(void) { assert(theMessageQueue->IsEmpty()); assert(theMessageQueue->CountMessages() == 0); int i; for(i = 0; i < 10000; i++) { + if (i % (10000 / 10) == 0) + NextSubTest(); BMessage *theMessage = new testMessageClass(i); AddMessage(theMessage); assert(!theMessageQueue->IsEmpty()); assert(theMessageQueue->CountMessages() == i + 1); } + NextSubTest(); CheckQueueAgainstList(); assert(testMessageClass::messageDestructorCount == 0); delete theMessageQueue; theMessageQueue = NULL; + NextSubTest(); assert(testMessageClass::messageDestructorCount == 10000); } /* - * Method: AddMessageTest1::suite() + * Method: AddMessageTest1::suite() * Descr: This static member function returns a test caller for performing * all combinations of "AddMessageTest1". The test * is created as a ThreadedTestCase (typedef'd as * AddMessageTest1Caller) with only one thread. */ -template Test *AddMessageTest1::suite(void) + Test *AddMessageTest1::suite(void) { - AddMessageTest1 *theTest = new AddMessageTest1(""); - AddMessageTest1Caller *testCaller = new AddMessageTest1Caller("", theTest); - testCaller->addThread(":Thread1", &AddMessageTest1::PerformTest); + typedef BThreadedTestCaller + AddMessageTest1Caller; + + AddMessageTest1 *theTest = new AddMessageTest1(""); + AddMessageTest1Caller *testCaller = new AddMessageTest1Caller("BMessageQueue::Add Message Test #1", theTest); + testCaller->addThread("A", &AddMessageTest1::PerformTest); return(testCaller); } -template class AddMessageTest1; -template class AddMessageTest1; \ No newline at end of file diff --git a/src/tests/kits/app/bmessagequeue/AddMessageTest1.h b/src/tests/kits/app/bmessagequeue/AddMessageTest1.h index 6ff7e5f467..4d4be821ce 100644 --- a/src/tests/kits/app/bmessagequeue/AddMessageTest1.h +++ b/src/tests/kits/app/bmessagequeue/AddMessageTest1.h @@ -1,5 +1,5 @@ /* - $Id: AddMessageTest1.h,v 1.1 2002/07/09 12:24:56 ejakowatz Exp $ + $Id: AddMessageTest1.h,v 1.2 2002/07/22 09:28:00 tylerdauwalder Exp $ This file defines a class for performing one test of BMessageQueue functionality. @@ -12,16 +12,13 @@ #include "MessageQueueTestCase.h" -#include "Test.h" -#include "ThreadedTestCaller.h" +#include "../common.h" -template class AddMessageTest1 : - public MessageQueueTestCase { + class AddMessageTest1 : + public MessageQueueTestCase { private: - typedef ThreadedTestCaller > - AddMessageTest1Caller; public: static Test *suite(void); @@ -31,4 +28,10 @@ public: virtual ~AddMessageTest1(); }; -#endif \ No newline at end of file +#endif + + + + + + diff --git a/src/tests/kits/app/bmessagequeue/AddMessageTest2.cpp b/src/tests/kits/app/bmessagequeue/AddMessageTest2.cpp index 344a3b9f9e..ac3e20dab6 100644 --- a/src/tests/kits/app/bmessagequeue/AddMessageTest2.cpp +++ b/src/tests/kits/app/bmessagequeue/AddMessageTest2.cpp @@ -1,5 +1,5 @@ /* - $Id: AddMessageTest2.cpp,v 1.1 2002/07/09 12:24:56 ejakowatz Exp $ + $Id: AddMessageTest2.cpp,v 1.2 2002/07/22 09:28:00 tylerdauwalder Exp $ This file implements the second test for the OpenBeOS BMessageQueue code. It tests the Add Message 2 use case. It does so by doing the following: @@ -12,6 +12,7 @@ */ +#include "ThreadedTestCaller.h" #include "AddMessageTest2.h" #include #include @@ -19,30 +20,30 @@ /* - * Method: AddMessageTest2::AddMessageTest2() + * Method: AddMessageTest2::AddMessageTest2() * Descr: This is the constructor for this class. */ -template - AddMessageTest2::AddMessageTest2(std::string name) : - MessageQueueTestCase(name) + + AddMessageTest2::AddMessageTest2(std::string name) : + MessageQueueTestCase(name) { } /* - * Method: AddMessageTest2::~AddMessageTest2() + * Method: AddMessageTest2::~AddMessageTest2() * Descr: This is the destructor for this class. */ -template - AddMessageTest2::~AddMessageTest2() + + AddMessageTest2::~AddMessageTest2() { } /* - * Method: AddMessageTest2::PerformTest() + * Method: AddMessageTest2::PerformTest() * Descr: This member function performs this test. It adds * 4 messages to the message queue and confirms that * the queue contains the right messages. Then it re-adds @@ -51,9 +52,10 @@ template * checks each element on the queue one by one. */ -template - void AddMessageTest2::PerformTest(void) + + void AddMessageTest2::PerformTest(void) { + NextSubTest(); BMessage *firstMessage = new BMessage(1); BMessage *secondMessage = new BMessage(2); BMessage *thirdMessage = new BMessage(3); @@ -64,6 +66,7 @@ template AddMessage(thirdMessage); AddMessage(fourthMessage); + NextSubTest(); CheckQueueAgainstList(); AddMessage(secondMessage); @@ -75,36 +78,37 @@ template try { CheckQueueAgainstList(); } - catch (CppUnitException e) { + catch (CppUnit::Exception e) { exceptionRaised = true; } - assert(exceptionRaised); + CPPUNIT_ASSERT(exceptionRaised); - assert(theMessageQueue->FindMessage((int32)0) == firstMessage); - assert(theMessageQueue->FindMessage((int32)1) == secondMessage); - assert(theMessageQueue->FindMessage((int32)2) == NULL); - assert(theMessageQueue->FindMessage((int32)3) == NULL); - assert(theMessageQueue->FindMessage((int32)4) == NULL); + NextSubTest(); + CPPUNIT_ASSERT(theMessageQueue->FindMessage((int32)0) == firstMessage); + CPPUNIT_ASSERT(theMessageQueue->FindMessage((int32)1) == secondMessage); + CPPUNIT_ASSERT(theMessageQueue->FindMessage((int32)2) == NULL); + CPPUNIT_ASSERT(theMessageQueue->FindMessage((int32)3) == NULL); + CPPUNIT_ASSERT(theMessageQueue->FindMessage((int32)4) == NULL); } /* - * Method: AddMessageTest2::suite() + * Method: AddMessageTest2::suite() * Descr: This static member function returns a test caller for performing * all combinations of "AddMessageTest2". The test * is created as a ThreadedTestCase (typedef'd as * AddMessageTest2Caller) with only one thread. */ -template Test *AddMessageTest2::suite(void) + Test *AddMessageTest2::suite(void) { - AddMessageTest2 *theTest = new AddMessageTest2(""); - AddMessageTest2Caller *testCaller = new AddMessageTest2Caller("", theTest); - testCaller->addThread(":Thread1", &AddMessageTest2::PerformTest); + typedef BThreadedTestCaller + AddMessageTest2Caller; + AddMessageTest2 *theTest = new AddMessageTest2(""); + AddMessageTest2Caller *testCaller = new AddMessageTest2Caller("BMessageQueue::Add Message Test #2", theTest); + testCaller->addThread("A", &AddMessageTest2::PerformTest); return(testCaller); } -template class AddMessageTest2; -template class AddMessageTest2; \ No newline at end of file diff --git a/src/tests/kits/app/bmessagequeue/AddMessageTest2.h b/src/tests/kits/app/bmessagequeue/AddMessageTest2.h index 9bba1cb38a..2b9cc4ed57 100644 --- a/src/tests/kits/app/bmessagequeue/AddMessageTest2.h +++ b/src/tests/kits/app/bmessagequeue/AddMessageTest2.h @@ -1,5 +1,5 @@ /* - $Id: AddMessageTest2.h,v 1.1 2002/07/09 12:24:56 ejakowatz Exp $ + $Id: AddMessageTest2.h,v 1.2 2002/07/22 09:28:00 tylerdauwalder Exp $ This file defines a class for performing one test of BMessageQueue functionality. @@ -12,16 +12,13 @@ #include "MessageQueueTestCase.h" -#include "Test.h" -#include "ThreadedTestCaller.h" +#include "../common.h" -template class AddMessageTest2 : - public MessageQueueTestCase { + class AddMessageTest2 : + public MessageQueueTestCase { private: - typedef ThreadedTestCaller > - AddMessageTest2Caller; public: static Test *suite(void); @@ -30,4 +27,10 @@ public: virtual ~AddMessageTest2(); }; -#endif \ No newline at end of file +#endif + + + + + + diff --git a/src/tests/kits/app/bmessagequeue/ConcurrencyTest1.cpp b/src/tests/kits/app/bmessagequeue/ConcurrencyTest1.cpp index 17a16e4385..18116611c1 100644 --- a/src/tests/kits/app/bmessagequeue/ConcurrencyTest1.cpp +++ b/src/tests/kits/app/bmessagequeue/ConcurrencyTest1.cpp @@ -1,5 +1,5 @@ /* - $Id: ConcurrencyTest1.cpp,v 1.1 2002/07/09 12:24:56 ejakowatz Exp $ + $Id: ConcurrencyTest1.cpp,v 1.2 2002/07/22 09:28:00 tylerdauwalder Exp $ This file implements a test class for testing BMessageQueue functionality. It tests use cases Destruction, Add Message 1, Add Message 3, Remove Message 1, @@ -30,11 +30,12 @@ */ +#include "ThreadedTestCaller.h" #include "ConcurrencyTest1.h" #include "ThreadedTestCaller.h" #include "TestSuite.h" #include -#include "MessageQueue.h" +#include // This constant indicates how many messages to add to the queue. @@ -48,36 +49,36 @@ const int numAddMessagesPerRemove = 5; /* - * Method: ConcurrencyTest1::ConcurrencyTest1() + * Method: ConcurrencyTest1::ConcurrencyTest1() * Descr: This is the constructor for this test. */ -template - ConcurrencyTest1::ConcurrencyTest1(std::string name, bool listFlag) : - MessageQueueTestCase(name), useList(listFlag) + + ConcurrencyTest1::ConcurrencyTest1(std::string name, bool listFlag) : + MessageQueueTestCase(name), useList(listFlag) { } /* - * Method: ConcurrencyTest1::~ConcurrencyTest1() + * Method: ConcurrencyTest1::~ConcurrencyTest1() * Descr: This is the destructor for this test. */ -template - ConcurrencyTest1::~ConcurrencyTest1() + + ConcurrencyTest1::~ConcurrencyTest1() { } /* - * Method: ConcurrencyTest1::setUp() + * Method: ConcurrencyTest1::setUp() * Descr: This member function prepares the enviroment for test execution. * It resets the message destructor count and puts "numAddMessages" * messages on the queue. */ -template void ConcurrencyTest1::setUp(void) + void ConcurrencyTest1::setUp(void) { testMessageClass::messageDestructorCount = 0; @@ -94,7 +95,7 @@ template void ConcurrencyTest1::setUp(void) /* - * Method: ConcurrencyTest1::TestThread1() + * Method: ConcurrencyTest1::TestThread1() * Descr: This member function is one of the three threads for performing * this test. It waits until the other two threads complete and * then checks the state of the message queue. If the list is @@ -103,8 +104,9 @@ template void ConcurrencyTest1::setUp(void) * are all deleted when the message queue is destructed. */ -template void ConcurrencyTest1::TestThread1(void) + void ConcurrencyTest1::TestThread1(void) { + NextSubTest(); snooze(1000000); thread2Lock.Lock(); thread3Lock.Lock(); @@ -116,30 +118,32 @@ template void ConcurrencyTest1::TestThread1(vo int numMessages = (2*numAddMessages) - (numAddMessages / numAddMessagesPerRemove) - numNextMessages; - assert(numMessages == theMessageQueue->CountMessages()); - assert(testMessageClass::messageDestructorCount == 0); + CPPUNIT_ASSERT(numMessages == theMessageQueue->CountMessages()); + CPPUNIT_ASSERT(testMessageClass::messageDestructorCount == 0); delete theMessageQueue; theMessageQueue = NULL; - assert(testMessageClass::messageDestructorCount == numMessages); + CPPUNIT_ASSERT(testMessageClass::messageDestructorCount == numMessages); } /* - * Method: ConcurrencyTest1::TestThread2() + * Method: ConcurrencyTest1::TestThread2() * Descr: This member function is one of the three threads for performing * this test. It performs NextMessage() numNextMessages times on * the queue. It confirms that it always receives a message from * the queue. */ -template void ConcurrencyTest1::TestThread2(void) + void ConcurrencyTest1::TestThread2(void) { - thread2Lock.Lock(); - SafetyLock mySafetyLock(&thread2Lock); + BAutolock mySafetyLock(&thread2Lock); int i; for(i = 0; i < numNextMessages; i++) { + if (i % (numNextMessages / 10) == 0) + NextSubTest(); + snooze(5000); BMessage *theMessage; if (useList) { @@ -147,28 +151,30 @@ template void ConcurrencyTest1::TestThread2(vo } else { theMessage = theMessageQueue->NextMessage(); } - assert(theMessage != NULL); + CPPUNIT_ASSERT(theMessage != NULL); } } /* - * Method: ConcurrencyTest1::TestThread3() + * Method: ConcurrencyTest1::TestThread3() * Descr: This member function is one of the three threads for performing * this test. It adds numAddMessages messages to the queue. For * every numAddMessagesPerRemove messages it adds, one message * is removed. */ -template void ConcurrencyTest1::TestThread3(void) + void ConcurrencyTest1::TestThread3(void) { - thread3Lock.Lock(); - SafetyLock mySafetyLock(&thread3Lock); + BAutolock mySafetyLock(&thread3Lock); int i; BList messagesToRemove; for (i=0; i < numAddMessages; i++) { + if (i % (numAddMessages / 10) == 0) + NextSubTest(); + BMessage *theMessage = new testMessageClass(i); if (useList) { AddMessage(theMessage); @@ -188,7 +194,7 @@ template void ConcurrencyTest1::TestThread3(vo /* - * Method: ConcurrencyTest1::suite() + * Method: ConcurrencyTest1::suite() * Descr: This static member function returns a test suite for performing * all combinations of "ConcurrencyTest1". The test suite contains * two instances of the test. One is performed with a list, @@ -197,21 +203,23 @@ template void ConcurrencyTest1::TestThread3(vo * ConcurrencyTest1Caller) with three independent threads. */ -template Test *ConcurrencyTest1::suite(void) + Test *ConcurrencyTest1::suite(void) { + typedef BThreadedTestCaller + ConcurrencyTest1Caller; TestSuite *testSuite = new TestSuite("ConcurrencyTest1"); - ConcurrencyTest1 *theTest = new ConcurrencyTest1("WithList", true); - ConcurrencyTest1Caller *threadedTest1 = new ConcurrencyTest1Caller("", theTest); - threadedTest1->addThread(":Thread1", &ConcurrencyTest1::TestThread1); - threadedTest1->addThread(":Thread2", &ConcurrencyTest1::TestThread2); - threadedTest1->addThread(":Thread3", &ConcurrencyTest1::TestThread3); + ConcurrencyTest1 *theTest = new ConcurrencyTest1("WithList", true); + ConcurrencyTest1Caller *threadedTest1 = new ConcurrencyTest1Caller("BMessageQueue::Concurrency Test #1 (with list)", theTest); + threadedTest1->addThread("A", &ConcurrencyTest1::TestThread1); + threadedTest1->addThread("B", &ConcurrencyTest1::TestThread2); + threadedTest1->addThread("C", &ConcurrencyTest1::TestThread3); - theTest = new ConcurrencyTest1("WithoutList", false); - ConcurrencyTest1Caller *threadedTest2 = new ConcurrencyTest1Caller("", theTest); - threadedTest2->addThread(":Thread1", &ConcurrencyTest1::TestThread1); - threadedTest2->addThread(":Thread2", &ConcurrencyTest1::TestThread2); - threadedTest2->addThread(":Thread3", &ConcurrencyTest1::TestThread3); + theTest = new ConcurrencyTest1("WithoutList", false); + ConcurrencyTest1Caller *threadedTest2 = new ConcurrencyTest1Caller("BMessageQueue::Concurrency Test #1 (without list)", theTest); + threadedTest2->addThread("A", &ConcurrencyTest1::TestThread1); + threadedTest2->addThread("B", &ConcurrencyTest1::TestThread2); + threadedTest2->addThread("C", &ConcurrencyTest1::TestThread3); testSuite->addTest(threadedTest1); testSuite->addTest(threadedTest2); @@ -219,5 +227,4 @@ template Test *ConcurrencyTest1::suite(void) } -template class ConcurrencyTest1; -template class ConcurrencyTest1; \ No newline at end of file + diff --git a/src/tests/kits/app/bmessagequeue/ConcurrencyTest1.h b/src/tests/kits/app/bmessagequeue/ConcurrencyTest1.h index 8a2de7733b..0e52a13ecc 100644 --- a/src/tests/kits/app/bmessagequeue/ConcurrencyTest1.h +++ b/src/tests/kits/app/bmessagequeue/ConcurrencyTest1.h @@ -1,5 +1,5 @@ /* - $Id: ConcurrencyTest1.h,v 1.1 2002/07/09 12:24:56 ejakowatz Exp $ + $Id: ConcurrencyTest1.h,v 1.2 2002/07/22 09:28:00 tylerdauwalder Exp $ This file defines a classes for performing one test of BMessageQueue functionality. @@ -12,17 +12,14 @@ #include "MessageQueueTestCase.h" -#include "Test.h" -#include "ThreadedTestCaller.h" +#include "../common.h" #include -template class ConcurrencyTest1 : - public MessageQueueTestCase { + class ConcurrencyTest1 : + public MessageQueueTestCase { private: - typedef ThreadedTestCaller > - ConcurrencyTest1Caller; bool useList; BLocker thread2Lock; @@ -40,4 +37,10 @@ public: virtual ~ConcurrencyTest1(); }; -#endif \ No newline at end of file +#endif + + + + + + diff --git a/src/tests/kits/app/bmessagequeue/ConcurrencyTest2.cpp b/src/tests/kits/app/bmessagequeue/ConcurrencyTest2.cpp index c379c886dc..885521fc74 100644 --- a/src/tests/kits/app/bmessagequeue/ConcurrencyTest2.cpp +++ b/src/tests/kits/app/bmessagequeue/ConcurrencyTest2.cpp @@ -1,5 +1,5 @@ /* - $Id: ConcurrencyTest2.cpp,v 1.1 2002/07/09 12:24:56 ejakowatz Exp $ + $Id: ConcurrencyTest2.cpp,v 1.2 2002/07/22 09:28:00 tylerdauwalder Exp $ This file implements a test class for testing BMessageQueue functionality. It tests use cases Destruction, Add Message 3, Remove Message 2, @@ -22,11 +22,9 @@ */ -#include "ConcurrencyTest2.h" #include "ThreadedTestCaller.h" -#include "TestSuite.h" +#include "ConcurrencyTest2.h" #include -#include "MessageQueue.h" // This constant indicates the number of messages to add to the queue. @@ -37,38 +35,38 @@ bigtime_t SNOOZE_TIME = 100000; /* - * Method: ConcurrencyTest2::ConcurrencyTest2() + * Method: ConcurrencyTest2::ConcurrencyTest2() * Descr: This is the constructor for this test. */ -template - ConcurrencyTest2::ConcurrencyTest2(std::string name, bool unlockFlag) : - MessageQueueTestCase(name), unlockTest(unlockFlag) + + ConcurrencyTest2::ConcurrencyTest2(std::string name, bool unlockFlag) : + MessageQueueTestCase(name), unlockTest(unlockFlag) { } /* - * Method: ConcurrencyTest2::~ConcurrencyTest2() + * Method: ConcurrencyTest2::~ConcurrencyTest2() * Descr: This is the destructor for this test. */ -template - ConcurrencyTest2::~ConcurrencyTest2() + + ConcurrencyTest2::~ConcurrencyTest2() { } /* - * Method: ConcurrencyTest2::setUp() + * Method: ConcurrencyTest2::setUp() * Descr: This member functions sets the environment for the test. * it sets the lock flag and resets the message destructor * count. Finally, it adds numAddMessages messages to the * queue. */ -template - void ConcurrencyTest2::setUp(void) + + void ConcurrencyTest2::setUp(void) { isLocked = false; testMessageClass::messageDestructorCount = 0; @@ -84,15 +82,15 @@ template /* - * Method: ConcurrencyTest2::TestThread1() + * Method: ConcurrencyTest2::TestThread1() * Descr: This member function is one thread within the test. It * acquires the lock on the queue and then sleeps for a while. * When it wakes up, it releases the lock on the queue by * either doing an Unlock() or deleting the queue. */ -template - void ConcurrencyTest2::TestThread1(void) + + void ConcurrencyTest2::TestThread1(void) { theMessageQueue->Lock(); isLocked = true; @@ -103,7 +101,7 @@ template if (unlockTest) { theMessageQueue->Unlock(); } else { - MessageQueue *tmpMessageQueue = theMessageQueue; + BMessageQueue *tmpMessageQueue = theMessageQueue; theMessageQueue = NULL; delete tmpMessageQueue; } @@ -111,7 +109,7 @@ template /* - * Method: ConcurrencyTest2::TestThread2() + * Method: ConcurrencyTest2::TestThread2() * Descr: This member function is one thread within the test. It * snoozes for a short time so that TestThread1() will grab * the lock. If this is the delete test, this thread @@ -120,10 +118,10 @@ template * the queue. The result of NextMessage() is checked finally. */ -template void ConcurrencyTest2::TestThread2(void) + void ConcurrencyTest2::TestThread2(void) { snooze(SNOOZE_TIME/10); - assert(isLocked); + CPPUNIT_ASSERT(isLocked); if (!unlockTest) { // Be's implementation can cause a segv when NextMessage() is in // progress when a delete occurs. The OpenBeOS implementation @@ -131,11 +129,11 @@ template void ConcurrencyTest2::TestThread2(vo return; } BMessage *theMessage = theMessageQueue->NextMessage(); - assert(!isLocked); + CPPUNIT_ASSERT(!isLocked); if (unlockTest) { - assert(theMessage != NULL); - assert(theMessage->what == 0); + CPPUNIT_ASSERT(theMessage != NULL); + CPPUNIT_ASSERT(theMessage->what == 0); } else { // The following test passes for the OpenBeOS implementation but // fails for the Be implementation. If the BMessageQueue is deleted @@ -146,13 +144,13 @@ template void ConcurrencyTest2::TestThread2(vo // deleted. The OpenBeOS implementation will not emulate the Be // implementation since I consider it a bug. // - // assert(theMessage==NULL); + // CPPUNIT_ASSERT(theMessage==NULL); } } /* - * Method: ConcurrencyTest2::TestThread3() + * Method: ConcurrencyTest2::TestThread3() * Descr: This member function is one thread within the test. It * snoozes for a short time so that TestThread1() will grab * the lock. If this is the delete test, this thread @@ -161,10 +159,10 @@ template void ConcurrencyTest2::TestThread2(vo * on the queue. The state of the queue is checked finally. */ -template void ConcurrencyTest2::TestThread3(void) + void ConcurrencyTest2::TestThread3(void) { snooze(SNOOZE_TIME/10); - assert(isLocked); + CPPUNIT_ASSERT(isLocked); if (!unlockTest) { // Be's implementation causes a segv when RemoveMessage() is in // progress when a delete occurs. The OpenBeOS implementation @@ -172,15 +170,15 @@ template void ConcurrencyTest2::TestThread3(vo return; } theMessageQueue->RemoveMessage(removeMessage); - assert(!isLocked); + CPPUNIT_ASSERT(!isLocked); if (unlockTest) { - assert(theMessageQueue->FindMessage(removeMessage->what, 0) == NULL); + CPPUNIT_ASSERT(theMessageQueue->FindMessage(removeMessage->what, 0) == NULL); } } /* - * Method: ConcurrencyTest2::TestThread1() + * Method: ConcurrencyTest2::TestThread1() * Descr: This member function is one thread within the test. It * snoozes for a short time so that TestThread1() will grab * the lock. If this is the delete test, this thread @@ -189,10 +187,10 @@ template void ConcurrencyTest2::TestThread3(vo * the queue. The state of the queue is checked finally. */ -template void ConcurrencyTest2::TestThread4(void) + void ConcurrencyTest2::TestThread4(void) { snooze(SNOOZE_TIME/10); - assert(isLocked); + CPPUNIT_ASSERT(isLocked); if (!unlockTest) { // Be's implementation can cause a segv when AddMessage() is in // progress when a delete occurs. The OpenBeOS implementation @@ -200,15 +198,15 @@ template void ConcurrencyTest2::TestThread4(vo return; } theMessageQueue->AddMessage(new testMessageClass(numAddMessages)); - assert(!isLocked); + CPPUNIT_ASSERT(!isLocked); if (unlockTest) { - assert(theMessageQueue->FindMessage(numAddMessages, 0) != NULL); + CPPUNIT_ASSERT(theMessageQueue->FindMessage(numAddMessages, 0) != NULL); } } /* - * Method: ConcurrencyTest2::TestThread1() + * Method: ConcurrencyTest2::TestThread1() * Descr: This member function is one thread within the test. It * snoozes for a short time so that TestThread1() will grab * the lock. The thread blocks attempting to acquire the @@ -217,25 +215,25 @@ template void ConcurrencyTest2::TestThread4(vo * acquisition. */ -template void ConcurrencyTest2::TestThread5(void) + void ConcurrencyTest2::TestThread5(void) { - SafetyLock mySafetyLock(theMessageQueue); + SafetyLock mySafetyLock(theMessageQueue); snooze(SNOOZE_TIME/10); - assert(isLocked); + CPPUNIT_ASSERT(isLocked); bool result = theMessageQueue->Lock(); - assert(!isLocked); + CPPUNIT_ASSERT(!isLocked); if (unlockTest) { - assert(result); + CPPUNIT_ASSERT(result); theMessageQueue->Unlock(); } else { - assert(!result); + CPPUNIT_ASSERT(!result); } } /* - * Method: ConcurrencyTest2::suite() + * Method: ConcurrencyTest2::suite() * Descr: This static member function returns a test suite for performing * all combinations of "ConcurrencyTest2". The test suite contains * two instances of the test. One is performed with an unlock, @@ -244,25 +242,28 @@ template void ConcurrencyTest2::TestThread5(vo * ConcurrencyTest2Caller) with five independent threads. */ -template Test *ConcurrencyTest2::suite(void) + Test *ConcurrencyTest2::suite(void) { + typedef BThreadedTestCaller + ConcurrencyTest2Caller; + TestSuite *testSuite = new TestSuite("ConcurrencyTest2"); - ConcurrencyTest2 *theTest = new ConcurrencyTest2("WithUnlock", true); - ConcurrencyTest2Caller *threadedTest1 = new ConcurrencyTest2Caller("", theTest); - threadedTest1->addThread(":Thread1", &ConcurrencyTest2::TestThread1); - threadedTest1->addThread(":Thread2", &ConcurrencyTest2::TestThread2); - threadedTest1->addThread(":Thread3", &ConcurrencyTest2::TestThread3); - threadedTest1->addThread(":Thread3", &ConcurrencyTest2::TestThread4); - threadedTest1->addThread(":Thread3", &ConcurrencyTest2::TestThread5); + ConcurrencyTest2 *theTest = new ConcurrencyTest2("WithUnlock", true); + ConcurrencyTest2Caller *threadedTest1 = new ConcurrencyTest2Caller("BMessageQueue::Concurrency Test #2 (with unlock)", theTest); + threadedTest1->addThread("A", &ConcurrencyTest2::TestThread1); + threadedTest1->addThread("B", &ConcurrencyTest2::TestThread2); + threadedTest1->addThread("C", &ConcurrencyTest2::TestThread3); + threadedTest1->addThread("D", &ConcurrencyTest2::TestThread4); + threadedTest1->addThread("E", &ConcurrencyTest2::TestThread5); - theTest = new ConcurrencyTest2("WithDelete", false); - ConcurrencyTest2Caller *threadedTest2 = new ConcurrencyTest2Caller("", theTest); - threadedTest2->addThread(":Thread1", &ConcurrencyTest2::TestThread1); - threadedTest2->addThread(":Thread2", &ConcurrencyTest2::TestThread2); - threadedTest2->addThread(":Thread3", &ConcurrencyTest2::TestThread3); - threadedTest2->addThread(":Thread3", &ConcurrencyTest2::TestThread4); - threadedTest2->addThread(":Thread3", &ConcurrencyTest2::TestThread5); + theTest = new ConcurrencyTest2("WithDelete", false); + ConcurrencyTest2Caller *threadedTest2 = new ConcurrencyTest2Caller("BMessageQueue::Concurrency Test #2 (with delete)", theTest); + threadedTest2->addThread("A", &ConcurrencyTest2::TestThread1); + threadedTest2->addThread("B", &ConcurrencyTest2::TestThread2); + threadedTest2->addThread("C", &ConcurrencyTest2::TestThread3); + threadedTest2->addThread("D", &ConcurrencyTest2::TestThread4); + threadedTest2->addThread("E", &ConcurrencyTest2::TestThread5); testSuite->addTest(threadedTest1); testSuite->addTest(threadedTest2); @@ -270,5 +271,4 @@ template Test *ConcurrencyTest2::suite(void) } -template class ConcurrencyTest2; -template class ConcurrencyTest2; \ No newline at end of file + diff --git a/src/tests/kits/app/bmessagequeue/ConcurrencyTest2.h b/src/tests/kits/app/bmessagequeue/ConcurrencyTest2.h index 469ca37954..8312fd16c0 100644 --- a/src/tests/kits/app/bmessagequeue/ConcurrencyTest2.h +++ b/src/tests/kits/app/bmessagequeue/ConcurrencyTest2.h @@ -1,5 +1,5 @@ /* - $Id: ConcurrencyTest2.h,v 1.1 2002/07/09 12:24:56 ejakowatz Exp $ + $Id: ConcurrencyTest2.h,v 1.2 2002/07/22 09:28:00 tylerdauwalder Exp $ This file defines a classes for performing one test of BMessageQueue functionality. @@ -7,21 +7,18 @@ */ -#ifndef ConcurrencyTest2_H -#define ConcurrencyTest2_H +#ifndef _ConcurrencyTest2_H +#define _ConcurrencyTest2_H #include "MessageQueueTestCase.h" -#include "Test.h" -#include "ThreadedTestCaller.h" +#include "../common.h" -template class ConcurrencyTest2 : - public MessageQueueTestCase { + class ConcurrencyTest2 : + public MessageQueueTestCase { private: - typedef ThreadedTestCaller > - ConcurrencyTest2Caller; bool unlockTest; bool isLocked; @@ -39,4 +36,8 @@ public: virtual ~ConcurrencyTest2(); }; -#endif \ No newline at end of file +#endif + + + + diff --git a/src/tests/kits/app/bmessagequeue/FindMessageTest1.cpp b/src/tests/kits/app/bmessagequeue/FindMessageTest1.cpp index c0f896b07d..5baf92a583 100644 --- a/src/tests/kits/app/bmessagequeue/FindMessageTest1.cpp +++ b/src/tests/kits/app/bmessagequeue/FindMessageTest1.cpp @@ -1,5 +1,5 @@ /* - $Id: FindMessageTest1.cpp,v 1.1 2002/07/09 12:24:56 ejakowatz Exp $ + $Id: FindMessageTest1.cpp,v 1.2 2002/07/22 09:28:00 tylerdauwalder Exp $ This file implements the second test for the OpenBeOS BMessageQueue code. It tests the Add Message 1 and Find Message 2 use cases. It does so by @@ -17,6 +17,7 @@ */ +#include "ThreadedTestCaller.h" #include "FindMessageTest1.h" #include #include @@ -33,30 +34,30 @@ const int numPerWhatCode = 50; /* - * Method: FindMessageTest1::FindMessageTest1() + * Method: FindMessageTest1::FindMessageTest1() * Descr: This is the constructor for this test class. */ -template - FindMessageTest1::FindMessageTest1(std::string name) : - MessageQueueTestCase(name) + + FindMessageTest1::FindMessageTest1(std::string name) : + MessageQueueTestCase(name) { } /* - * Method: FindMessageTest1::~FindMessageTest1() + * Method: FindMessageTest1::~FindMessageTest1() * Descr: This is the destructor for this test class. */ -template - FindMessageTest1::~FindMessageTest1() + + FindMessageTest1::~FindMessageTest1() { } /* - * Method: FindMessageTest1::PerformTest() + * Method: FindMessageTest1::PerformTest() * Descr: This is the member function for executing the test. * It adds numPerWhatCode*numWhatCodes messages to the * queue. Then, it uses FindMessage() to search for @@ -64,8 +65,8 @@ template * checks that the queue and list return the same result. */ -template - void FindMessageTest1::PerformTest(void) + + void FindMessageTest1::PerformTest(void) { int whatCode; int i; @@ -73,42 +74,49 @@ template BMessage *listMessage; for (i = 0; i < numPerWhatCode; i++) { + if (i % (numPerWhatCode / 10) == 0) + NextSubTest(); + for (whatCode = 1; whatCode <= numWhatCodes; whatCode++) { AddMessage(new testMessageClass(whatCode)); } } for (whatCode = 0; whatCode <= numWhatCodes + 1; whatCode++) { + if (i % (numWhatCodes / 10) == 0) + NextSubTest(); + int index = 0; while ((theMessage = theMessageQueue->FindMessage(whatCode, index)) != NULL) { listMessage = FindMessage(whatCode, index); - assert(listMessage == theMessage); + CPPUNIT_ASSERT(listMessage == theMessage); index++; } listMessage = FindMessage(whatCode, index); - assert(listMessage == theMessage); + CPPUNIT_ASSERT(listMessage == theMessage); } } /* - * Method: FindMessageTest1::suite() + * Method: FindMessageTest1::suite() * Descr: This static member function returns a test caller for performing * all combinations of "FindMessageTest1". The test * is created as a ThreadedTestCase (typedef'd as * FindMessageTest1Caller) with only one thread. */ -template Test *FindMessageTest1::suite(void) + Test *FindMessageTest1::suite(void) { - FindMessageTest1 *theTest = new FindMessageTest1(""); - FindMessageTest1Caller *testCaller = new FindMessageTest1Caller("", theTest); - testCaller->addThread(":Thread1", &FindMessageTest1::PerformTest); + typedef BThreadedTestCaller + FindMessageTest1Caller; + + FindMessageTest1 *theTest = new FindMessageTest1(""); + FindMessageTest1Caller *testCaller = new FindMessageTest1Caller("BMessageQueue::Find Message Test", theTest); + testCaller->addThread("A", &FindMessageTest1::PerformTest); return(testCaller); } -template class FindMessageTest1; -template class FindMessageTest1; \ No newline at end of file diff --git a/src/tests/kits/app/bmessagequeue/FindMessageTest1.h b/src/tests/kits/app/bmessagequeue/FindMessageTest1.h index 848edfc6ba..da8b74658a 100644 --- a/src/tests/kits/app/bmessagequeue/FindMessageTest1.h +++ b/src/tests/kits/app/bmessagequeue/FindMessageTest1.h @@ -1,5 +1,5 @@ /* - $Id: FindMessageTest1.h,v 1.1 2002/07/09 12:24:56 ejakowatz Exp $ + $Id: FindMessageTest1.h,v 1.2 2002/07/22 09:28:00 tylerdauwalder Exp $ This file defines a classes for performing one test of BMessageQueue functionality. @@ -12,16 +12,13 @@ #include "MessageQueueTestCase.h" -#include "Test.h" -#include "ThreadedTestCaller.h" +#include "../common.h" -template class FindMessageTest1 : - public MessageQueueTestCase { + class FindMessageTest1 : + public MessageQueueTestCase { private: - typedef ThreadedTestCaller > - FindMessageTest1Caller; public: static Test *suite(void); @@ -30,4 +27,10 @@ public: virtual ~FindMessageTest1(); }; -#endif \ No newline at end of file +#endif + + + + + + diff --git a/src/tests/kits/app/bmessagequeue/MessageQueueTest.cpp b/src/tests/kits/app/bmessagequeue/MessageQueueTest.cpp new file mode 100644 index 0000000000..e7eae52e56 --- /dev/null +++ b/src/tests/kits/app/bmessagequeue/MessageQueueTest.cpp @@ -0,0 +1,26 @@ +#include "../common.h" +#include "AddMessageTest1.h" +#include "AddMessageTest2.h" +#include "ConcurrencyTest1.h" +#include "ConcurrencyTest2.h" +#include "FindMessageTest1.h" + +Test *MessageQueueTestSuite() +{ + TestSuite *testSuite = new TestSuite(); + + testSuite->addTest(AddMessageTest1::suite()); + testSuite->addTest(AddMessageTest2::suite()); + testSuite->addTest(ConcurrencyTest1::suite()); +// testSuite->addTest(ConcurrencyTest2::suite()); // Causes an "Abort" for some reason... + testSuite->addTest(FindMessageTest1::suite()); + + return(testSuite); +} + + + + + + + diff --git a/src/tests/kits/app/bmessagequeue/MessageQueueTest.h b/src/tests/kits/app/bmessagequeue/MessageQueueTest.h new file mode 100644 index 0000000000..2d781e95ae --- /dev/null +++ b/src/tests/kits/app/bmessagequeue/MessageQueueTest.h @@ -0,0 +1,14 @@ +#ifndef _message_queue_test_h_ +#define _message_queue_test_h_ + +class CppUnit::Test; + +CppUnit::Test *MessageQueueTestSuite(); + +#endif // _message_queue_test_h_ + + + + + + diff --git a/src/tests/kits/app/bmessagequeue/MessageQueueTestCase.cpp b/src/tests/kits/app/bmessagequeue/MessageQueueTestCase.cpp index 31d787ecc7..e85e49ff3f 100644 --- a/src/tests/kits/app/bmessagequeue/MessageQueueTestCase.cpp +++ b/src/tests/kits/app/bmessagequeue/MessageQueueTestCase.cpp @@ -1,5 +1,5 @@ /* - $Id: MessageQueueTestCase.cpp,v 1.1 2002/07/09 12:24:56 ejakowatz Exp $ + $Id: MessageQueueTestCase.cpp,v 1.2 2002/07/22 09:28:00 tylerdauwalder Exp $ This file implements a base class for testing BMessageQueue functionality. @@ -14,32 +14,32 @@ int testMessageClass::messageDestructorCount = 0; -template - MessageQueueTestCase::MessageQueueTestCase( - std::string name) : TestCase(name), - theMessageQueue(new MessageQueue) + + MessageQueueTestCase::MessageQueueTestCase( + std::string name) : BThreadedTestCase(name), + theMessageQueue(new BMessageQueue()) { } -template - MessageQueueTestCase::~MessageQueueTestCase() + + MessageQueueTestCase::~MessageQueueTestCase() { delete theMessageQueue; theMessageQueue = NULL; } -template - void MessageQueueTestCase::CheckQueueAgainstList(void) + + void MessageQueueTestCase::CheckQueueAgainstList(void) { - SafetyLock theSafetyLock(theMessageQueue); + SafetyLock theSafetyLock(theMessageQueue); if (theMessageQueue->Lock()) { - assert(theMessageQueue->CountMessages() == messageList.CountItems()); + CPPUNIT_ASSERT(theMessageQueue->CountMessages() == messageList.CountItems()); int i; for (i = 0; i < theMessageQueue->CountMessages(); i++) { - assert(theMessageQueue->FindMessage((int32)i) == + CPPUNIT_ASSERT(theMessageQueue->FindMessage((int32)i) == messageList.ItemAt(i)); } theMessageQueue->Unlock(); @@ -47,8 +47,8 @@ template } -template - void MessageQueueTestCase::AddMessage(BMessage *message) + + void MessageQueueTestCase::AddMessage(BMessage *message) { if (theMessageQueue->Lock()) { theMessageQueue->AddMessage(message); @@ -57,8 +57,8 @@ template } } -template - void MessageQueueTestCase::RemoveMessage(BMessage *message) + + void MessageQueueTestCase::RemoveMessage(BMessage *message) { if (theMessageQueue->Lock()) { theMessageQueue->RemoveMessage(message); @@ -67,23 +67,23 @@ template } } -template - BMessage *MessageQueueTestCase::NextMessage(void) + + BMessage *MessageQueueTestCase::NextMessage(void) { - SafetyLock theSafetyLock(theMessageQueue); + SafetyLock theSafetyLock(theMessageQueue); BMessage *result = NULL; if (theMessageQueue->Lock()) { result = theMessageQueue->NextMessage(); - assert(result == messageList.RemoveItem((int32)0)); + CPPUNIT_ASSERT(result == messageList.RemoveItem((int32)0)); theMessageQueue->Unlock(); } return(result); } -template - BMessage *MessageQueueTestCase::FindMessage(uint32 what, int index) + + BMessage *MessageQueueTestCase::FindMessage(uint32 what, int index) { int listCount = messageList.CountItems(); int i; @@ -102,5 +102,4 @@ template } -template class MessageQueueTestCase; -template class MessageQueueTestCase; \ No newline at end of file + diff --git a/src/tests/kits/app/bmessagequeue/MessageQueueTestCase.h b/src/tests/kits/app/bmessagequeue/MessageQueueTestCase.h index 374a851c4c..f75f263cf0 100644 --- a/src/tests/kits/app/bmessagequeue/MessageQueueTestCase.h +++ b/src/tests/kits/app/bmessagequeue/MessageQueueTestCase.h @@ -1,5 +1,5 @@ /* - $Id: MessageQueueTestCase.h,v 1.1 2002/07/09 12:24:56 ejakowatz Exp $ + $Id: MessageQueueTestCase.h,v 1.2 2002/07/22 09:28:00 tylerdauwalder Exp $ This file defines a set of classes for testing BMessageQueue functionality. @@ -14,7 +14,8 @@ #include #include #include -#include "TestCase.h" +#include +#include "ThreadedTestCase.h" // @@ -25,18 +26,18 @@ // could be deadlocks if one thread in a test has a failure while holding // the lock. It should be used like so: // -// template void myTestClass::myTestFunc(void) +// void myTestClass::myTestFunc(void) // { -// SafetyLock mySafetyLock(theMessageQueue); +// SafetyLock mySafetyLock(theMessageQueue); // ...perform tests without worrying about holding the lock on assert... // -template class SafetyLock { + class SafetyLock { private: - MessageQueue *theMessageQueue; + BMessageQueue *theMessageQueue; public: - SafetyLock(MessageQueue *aMessageQueue) {theMessageQueue = aMessageQueue;} + SafetyLock(BMessageQueue *aMessageQueue) {theMessageQueue = aMessageQueue;} virtual ~SafetyLock() {if (theMessageQueue != NULL) theMessageQueue->Unlock(); }; }; @@ -56,13 +57,13 @@ public: }; -template class MessageQueueTestCase : public TestCase { + class MessageQueueTestCase : public BThreadedTestCase { private: BList messageList; protected: - MessageQueue *theMessageQueue; + BMessageQueue *theMessageQueue; void AddMessage(BMessage *message); void RemoveMessage(BMessage *message); @@ -76,4 +77,7 @@ public: virtual ~MessageQueueTestCase(); }; -#endif \ No newline at end of file +#endif + + + diff --git a/src/tests/kits/app/bmessenger/BMessengerTester.cpp b/src/tests/kits/app/bmessenger/BMessengerTester.cpp index cf73d65691..878a3608c1 100644 --- a/src/tests/kits/app/bmessenger/BMessengerTester.cpp +++ b/src/tests/kits/app/bmessenger/BMessengerTester.cpp @@ -316,18 +316,19 @@ Test* TBMessengerTester::Suite() { TestSuite* SuiteOfTests = new TestSuite; - ADD_TEST(SuiteOfTests, TBMessengerTester, BMessenger1); - ADD_TEST(SuiteOfTests, TBMessengerTester, BMessenger2); - ADD_TEST(SuiteOfTests, TBMessengerTester, BMessenger3); - ADD_TEST(SuiteOfTests, TBMessengerTester, BMessenger4); - ADD_TEST(SuiteOfTests, TBMessengerTester, BMessenger5); - ADD_TEST(SuiteOfTests, TBMessengerTester, BMessenger6); - ADD_TEST(SuiteOfTests, TBMessengerTester, BMessenger7); - ADD_TEST(SuiteOfTests, TBMessengerTester, BMessenger8); - ADD_TEST(SuiteOfTests, TBMessengerTester, BMessenger9); - ADD_TEST(SuiteOfTests, TBMessengerTester, BMessenger10); + ADD_TEST4(BMessenger, SuiteOfTests, TBMessengerTester, BMessenger1); + ADD_TEST4(BMessenger, SuiteOfTests, TBMessengerTester, BMessenger2); + ADD_TEST4(BMessenger, SuiteOfTests, TBMessengerTester, BMessenger3); + ADD_TEST4(BMessenger, SuiteOfTests, TBMessengerTester, BMessenger4); + ADD_TEST4(BMessenger, SuiteOfTests, TBMessengerTester, BMessenger5); + ADD_TEST4(BMessenger, SuiteOfTests, TBMessengerTester, BMessenger6); + ADD_TEST4(BMessenger, SuiteOfTests, TBMessengerTester, BMessenger7); + ADD_TEST4(BMessenger, SuiteOfTests, TBMessengerTester, BMessenger8); + ADD_TEST4(BMessenger, SuiteOfTests, TBMessengerTester, BMessenger9); + ADD_TEST4(BMessenger, SuiteOfTests, TBMessengerTester, BMessenger10); return SuiteOfTests; } + diff --git a/src/tests/kits/app/bmessenger/LockTargetTester.cpp b/src/tests/kits/app/bmessenger/LockTargetTester.cpp index 115c5ca535..f35db9a738 100644 --- a/src/tests/kits/app/bmessenger/LockTargetTester.cpp +++ b/src/tests/kits/app/bmessenger/LockTargetTester.cpp @@ -232,16 +232,16 @@ Test* LockTargetTester::Suite() TestSuite* testSuite = new TestSuite; - ADD_TEST(testSuite, LockTargetTester, LockTargetTest1); - ADD_TEST(testSuite, LockTargetTester, LockTargetTest2); - ADD_TEST(testSuite, LockTargetTester, LockTargetTest3); + ADD_TEST4(BMessenger, testSuite, LockTargetTester, LockTargetTest1); + ADD_TEST4(BMessenger, testSuite, LockTargetTester, LockTargetTest2); + ADD_TEST4(BMessenger, testSuite, LockTargetTester, LockTargetTest3); // test4 LockTargetTester *test4 = new LockTargetTester("LockTargetTest4"); test4->fLooper = new BLooper; test4->fLooper->Run(); // test4 test caller - TC *caller4 = new TC("LockTargetTest4", test4); + TC *caller4 = new TC("BMessenger::LockTargetTest4", test4); caller4->addThread("A", &LockTargetTester::LockTargetTest4A); caller4->addThread("B", &LockTargetTester::LockTargetTest4B); testSuite->addTest(caller4); @@ -258,14 +258,15 @@ Test* LockTargetTester::Suite() } else printf("ERROR: Can't init LockTargetTester test5!\n"); // test5 test caller - TC *caller5 = new TC("LockTargetTest5", test5); + TC *caller5 = new TC("BMessenger::LockTargetTest5", test5); caller5->addThread("A", &LockTargetTester::LockTargetTest5A); caller5->addThread("B", &LockTargetTester::LockTargetTest5B); testSuite->addTest(caller5); // tests 6-7 - ADD_TEST(testSuite, LockTargetTester, LockTargetTest6); - ADD_TEST(testSuite, LockTargetTester, LockTargetTest7); + ADD_TEST4(BMessenger, testSuite, LockTargetTester, LockTargetTest6); + ADD_TEST4(BMessenger, testSuite, LockTargetTester, LockTargetTest7); return testSuite; } + diff --git a/src/tests/kits/app/bmessenger/LockTargetWithTimeoutTester.cpp b/src/tests/kits/app/bmessenger/LockTargetWithTimeoutTester.cpp index e295f9ce03..2ae16c40f0 100644 --- a/src/tests/kits/app/bmessenger/LockTargetWithTimeoutTester.cpp +++ b/src/tests/kits/app/bmessenger/LockTargetWithTimeoutTester.cpp @@ -310,11 +310,11 @@ Test* LockTargetWithTimeoutTester::Suite() TestSuite* testSuite = new TestSuite; - ADD_TEST(testSuite, LockTargetWithTimeoutTester, + ADD_TEST4(BMessenger, testSuite, LockTargetWithTimeoutTester, LockTargetWithTimeoutTest1); - ADD_TEST(testSuite, LockTargetWithTimeoutTester, + ADD_TEST4(BMessenger, testSuite, LockTargetWithTimeoutTester, LockTargetWithTimeoutTest2); - ADD_TEST(testSuite, LockTargetWithTimeoutTester, + ADD_TEST4(BMessenger, testSuite, LockTargetWithTimeoutTester, LockTargetWithTimeoutTest3); // test4 LockTargetWithTimeoutTester *test4 @@ -322,7 +322,7 @@ Test* LockTargetWithTimeoutTester::Suite() test4->fLooper = new BLooper; test4->fLooper->Run(); // test4 test caller - TC *caller4 = new TC("LockTargetWithTimeoutTest4", test4); + TC *caller4 = new TC("BMessenger::LockTargetWithTimeoutTest4", test4); caller4->addThread("A", &LockTargetWithTimeoutTester::LockTargetWithTimeoutTest4A); caller4->addThread("B", @@ -334,7 +334,7 @@ Test* LockTargetWithTimeoutTester::Suite() test5->fLooper = new BLooper; test5->fLooper->Run(); // test5 test caller - TC *caller5 = new TC("LockTargetWithTimeoutTest5", test5); + TC *caller5 = new TC("BMessenger::LockTargetWithTimeoutTest5", test5); caller5->addThread("A", &LockTargetWithTimeoutTester::LockTargetWithTimeoutTest5A); caller5->addThread("B", @@ -353,7 +353,7 @@ Test* LockTargetWithTimeoutTester::Suite() } else printf("ERROR: Can't init LockTargetWithTimeoutTester test6!\n"); // test6 test caller - TC *caller6 = new TC("LockTargetWithTimeoutTest6", test6); + TC *caller6 = new TC("BMessenger::LockTargetWithTimeoutTest6", test6); caller6->addThread("A", &LockTargetWithTimeoutTester::LockTargetWithTimeoutTest6A); caller6->addThread("B", @@ -372,18 +372,19 @@ Test* LockTargetWithTimeoutTester::Suite() } else printf("ERROR: Can't init LockTargetWithTimeoutTester test7!\n"); // test7 test caller - TC *caller7 = new TC("LockTargetWithTimeoutTest7", test7); + TC *caller7 = new TC("BMessenger::LockTargetWithTimeoutTest7", test7); caller7->addThread("A", &LockTargetWithTimeoutTester::LockTargetWithTimeoutTest7A); caller7->addThread("B", &LockTargetWithTimeoutTester::LockTargetWithTimeoutTest7B); testSuite->addTest(caller7); // tests 8-9 - ADD_TEST(testSuite, LockTargetWithTimeoutTester, + ADD_TEST4(BMessenger, testSuite, LockTargetWithTimeoutTester, LockTargetWithTimeoutTest8); - ADD_TEST(testSuite, LockTargetWithTimeoutTester, + ADD_TEST4(BMessenger, testSuite, LockTargetWithTimeoutTester, LockTargetWithTimeoutTest9); return testSuite; } + diff --git a/src/tests/kits/app/bmessenger/MessengerAssignmentTester.cpp b/src/tests/kits/app/bmessenger/MessengerAssignmentTester.cpp index f1e38cfc1c..78ba3bbd33 100644 --- a/src/tests/kits/app/bmessenger/MessengerAssignmentTester.cpp +++ b/src/tests/kits/app/bmessenger/MessengerAssignmentTester.cpp @@ -160,10 +160,11 @@ Test* MessengerAssignmentTester::Suite() TestSuite* testSuite = new TestSuite; - ADD_TEST(testSuite, MessengerAssignmentTester, AssignmentTest1); - ADD_TEST(testSuite, MessengerAssignmentTester, AssignmentTest2); - ADD_TEST(testSuite, MessengerAssignmentTester, AssignmentTest3); + ADD_TEST4(BMessenger, testSuite, MessengerAssignmentTester, AssignmentTest1); + ADD_TEST4(BMessenger, testSuite, MessengerAssignmentTester, AssignmentTest2); + ADD_TEST4(BMessenger, testSuite, MessengerAssignmentTester, AssignmentTest3); return testSuite; } + diff --git a/src/tests/kits/app/bmessenger/MessengerComparissonTester.cpp b/src/tests/kits/app/bmessenger/MessengerComparissonTester.cpp index 06a253f28e..5acac4acf8 100644 --- a/src/tests/kits/app/bmessenger/MessengerComparissonTester.cpp +++ b/src/tests/kits/app/bmessenger/MessengerComparissonTester.cpp @@ -307,11 +307,12 @@ Test* MessengerComparissonTester::Suite() TestSuite* testSuite = new TestSuite; - ADD_TEST(testSuite, MessengerComparissonTester, ComparissonTest1); - ADD_TEST(testSuite, MessengerComparissonTester, ComparissonTest2); - ADD_TEST(testSuite, MessengerComparissonTester, ComparissonTest3); - ADD_TEST(testSuite, MessengerComparissonTester, LessTest1); + ADD_TEST4(BMessenger, testSuite, MessengerComparissonTester, ComparissonTest1); + ADD_TEST4(BMessenger, testSuite, MessengerComparissonTester, ComparissonTest2); + ADD_TEST4(BMessenger, testSuite, MessengerComparissonTester, ComparissonTest3); + ADD_TEST4(BMessenger, testSuite, MessengerComparissonTester, LessTest1); return testSuite; } + diff --git a/src/tests/kits/app/bmessenger/MessengerTest.cpp b/src/tests/kits/app/bmessenger/MessengerTest.cpp index 9f72eb7c16..30a9091adb 100644 --- a/src/tests/kits/app/bmessenger/MessengerTest.cpp +++ b/src/tests/kits/app/bmessenger/MessengerTest.cpp @@ -21,3 +21,4 @@ CppUnit::Test* MessengerTestSuite() return testSuite; } + diff --git a/src/tests/kits/app/bmessenger/SMInvoker.cpp b/src/tests/kits/app/bmessenger/SMInvoker.cpp index c7681047d2..a76bc4f003 100644 --- a/src/tests/kits/app/bmessenger/SMInvoker.cpp +++ b/src/tests/kits/app/bmessenger/SMInvoker.cpp @@ -149,3 +149,4 @@ SMInvoker5::Invoke(BMessenger &target, BHandler *replyHandler, return result; } + diff --git a/src/tests/kits/app/bmessenger/SMLooper.cpp b/src/tests/kits/app/bmessenger/SMLooper.cpp index 29c438fb8d..6d1e5e1564 100644 --- a/src/tests/kits/app/bmessenger/SMLooper.cpp +++ b/src/tests/kits/app/bmessenger/SMLooper.cpp @@ -151,3 +151,4 @@ SMHandler::MessageReceived(BMessage *message) } } + diff --git a/src/tests/kits/app/bmessenger/SMRemoteTargetApp.cpp b/src/tests/kits/app/bmessenger/SMRemoteTargetApp.cpp index 185ce31e34..3606f900f8 100644 --- a/src/tests/kits/app/bmessenger/SMRemoteTargetApp.cpp +++ b/src/tests/kits/app/bmessenger/SMRemoteTargetApp.cpp @@ -105,3 +105,4 @@ DBG(OUT("REMOTE: main() done\n")); return 0; } + diff --git a/src/tests/kits/app/bmessenger/SMReplyTarget.cpp b/src/tests/kits/app/bmessenger/SMReplyTarget.cpp index 82b2784c0f..79591c2066 100644 --- a/src/tests/kits/app/bmessenger/SMReplyTarget.cpp +++ b/src/tests/kits/app/bmessenger/SMReplyTarget.cpp @@ -56,3 +56,4 @@ SMReplyTarget::ReplySuccess() return fLooper->ReplySuccess(); } + diff --git a/src/tests/kits/app/bmessenger/SMTarget.cpp b/src/tests/kits/app/bmessenger/SMTarget.cpp index 966ad80f62..cc47312aa5 100644 --- a/src/tests/kits/app/bmessenger/SMTarget.cpp +++ b/src/tests/kits/app/bmessenger/SMTarget.cpp @@ -215,3 +215,4 @@ RemoteSMTarget::_GetReply(int32 expectedCode, void *buffer, size_t size) // ID int32 RemoteSMTarget::fID = 0; + diff --git a/src/tests/kits/app/bmessenger/SendMessageTester.cpp b/src/tests/kits/app/bmessenger/SendMessageTester.cpp index c54d487199..edc3a5b0f1 100644 --- a/src/tests/kits/app/bmessenger/SendMessageTester.cpp +++ b/src/tests/kits/app/bmessenger/SendMessageTester.cpp @@ -403,8 +403,9 @@ Test* SendMessageTester::Suite() TestSuite* testSuite = new TestSuite; - ADD_TEST(testSuite, SendMessageTester, SendMessageTest1); + ADD_TEST4(BMessenger, testSuite, SendMessageTester, SendMessageTest1); return testSuite; } + diff --git a/src/tests/kits/app/bmessenger/TargetTester.cpp b/src/tests/kits/app/bmessenger/TargetTester.cpp index a120e2aaf8..3fa398da31 100644 --- a/src/tests/kits/app/bmessenger/TargetTester.cpp +++ b/src/tests/kits/app/bmessenger/TargetTester.cpp @@ -182,18 +182,19 @@ Test* TargetTester::Suite() { TestSuite* SuiteOfTests = new TestSuite; - ADD_TEST(SuiteOfTests, TargetTester, IsTargetLocalTest1); - ADD_TEST(SuiteOfTests, TargetTester, IsTargetLocalTest2); - ADD_TEST(SuiteOfTests, TargetTester, IsTargetLocalTest3); - ADD_TEST(SuiteOfTests, TargetTester, IsTargetLocalTest4); - ADD_TEST(SuiteOfTests, TargetTester, IsTargetLocalTest5); + ADD_TEST4(BMessenger, SuiteOfTests, TargetTester, IsTargetLocalTest1); + ADD_TEST4(BMessenger, SuiteOfTests, TargetTester, IsTargetLocalTest2); + ADD_TEST4(BMessenger, SuiteOfTests, TargetTester, IsTargetLocalTest3); + ADD_TEST4(BMessenger, SuiteOfTests, TargetTester, IsTargetLocalTest4); + ADD_TEST4(BMessenger, SuiteOfTests, TargetTester, IsTargetLocalTest5); - ADD_TEST(SuiteOfTests, TargetTester, TargetTest1); - ADD_TEST(SuiteOfTests, TargetTester, TargetTest2); - ADD_TEST(SuiteOfTests, TargetTester, TargetTest3); - ADD_TEST(SuiteOfTests, TargetTester, TargetTest4); - ADD_TEST(SuiteOfTests, TargetTester, TargetTest5); + ADD_TEST4(BMessenger, SuiteOfTests, TargetTester, TargetTest1); + ADD_TEST4(BMessenger, SuiteOfTests, TargetTester, TargetTest2); + ADD_TEST4(BMessenger, SuiteOfTests, TargetTester, TargetTest3); + ADD_TEST4(BMessenger, SuiteOfTests, TargetTester, TargetTest4); + ADD_TEST4(BMessenger, SuiteOfTests, TargetTester, TargetTest5); return SuiteOfTests; } + diff --git a/src/tests/kits/app/common.h b/src/tests/kits/app/common.h index 99f8aa500a..6bfc5779da 100644 --- a/src/tests/kits/app/common.h +++ b/src/tests/kits/app/common.h @@ -31,6 +31,10 @@ (suitename)->addTest(new TestCaller((#funcname), \ &classname::funcname)); +#define ADD_TEST4(classbeingtested, suitename, classname, funcname) \ + (suitename)->addTest(new TestCaller((#classbeingtested "::" #funcname), \ + &classname::funcname)); + #define CHECK_ERRNO \ cout << endl << "errno == \"" << strerror(errno) << "\" (" << errno \ << ") in " << __PRETTY_FUNCTION__ << endl diff --git a/src/tests/kits/support/barchivable/InstantiateObjectTester.cpp b/src/tests/kits/support/barchivable/InstantiateObjectTester.cpp index 6d24b0069b..6b7c95e361 100644 --- a/src/tests/kits/support/barchivable/InstantiateObjectTester.cpp +++ b/src/tests/kits/support/barchivable/InstantiateObjectTester.cpp @@ -438,6 +438,10 @@ CppUnit::Test* TInstantiateObjectTester::Suite() { CppUnit::TestSuite* SuiteOfTests = new CppUnit::TestSuite; +// SuiteOfTests->addTest( +// new CppUnit::TestCaller("BArchivable::instantiate_object() Test", +// &TInstantiateObjectTester::RunTests)); + ADD_TEST(SuiteOfTests, TInstantiateObjectTester, Case1); ADD_TEST(SuiteOfTests, TInstantiateObjectTester, Case2); ADD_TEST(SuiteOfTests, TInstantiateObjectTester, Case3); @@ -544,6 +548,38 @@ void FormatAndThrow(int line, const char *file, const char *msg, int err) } //------------------------------------------------------------------------------ +void +TInstantiateObjectTester::RunTests() { + NextSubTest(); + Case1(); + NextSubTest(); + Case2(); + NextSubTest(); + Case3(); + NextSubTest(); + Case4(); + NextSubTest(); + Case5(); + NextSubTest(); + Case6(); + NextSubTest(); + Case7(); + NextSubTest(); + Case8(); + NextSubTest(); + Case9(); + NextSubTest(); + Case10(); + NextSubTest(); + Case11(); + NextSubTest(); + Case12(); + NextSubTest(); + Case13(); + NextSubTest(); + Case14(); +} + /* * $Log $ * diff --git a/src/tests/kits/support/barchivable/InstantiateObjectTester.h b/src/tests/kits/support/barchivable/InstantiateObjectTester.h index ef7e93b19f..166647ae81 100644 --- a/src/tests/kits/support/barchivable/InstantiateObjectTester.h +++ b/src/tests/kits/support/barchivable/InstantiateObjectTester.h @@ -39,6 +39,8 @@ class TInstantiateObjectTester : public BTestCase void Case12(); void Case13(); void Case14(); + + void RunTests(); static CppUnit::Test* Suite();