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

@@ -2,18 +2,18 @@
 #include <TestSuiteAddon.h>
 
 // ##### 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;

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 ;

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()
  *
  */
 
+

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()
  *
  */
 
+
+

src/tests/kits/app/bhandler/HandlerLooperTest.cpp

@@ -0,0 +1,64 @@
+//------------------------------------------------------------------------------
+//	LooperTest.cpp
+//
+//------------------------------------------------------------------------------
+
+// Standard Includes -----------------------------------------------------------
+
+// System Includes -------------------------------------------------------------
+#include <be/app/Looper.h>
+
+// 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  $
+ *
+ */
+
+

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 <be/app/Handler.h>
+#else
+#include <Handler.h>
+#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  $
+ *
+ */
+

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;
+}

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_
+

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()
  *
  */
 
+

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()
  *
  */
 
+

src/tests/kits/app/bhandler/LockLooperTestCommon.cpp

@@ -42,3 +42,4 @@ int32 LockLooperThreadFunc(void* data)
  *
  */
 
+

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()
  *
  */
 
+

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()
  *
  */
 
+

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()
  *
  */
 
+

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()
  *
  */
 
+

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()
  *
  */
 
+

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()
  *
  */
 
+

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()
  *
  */
 
+

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()
  *
  */
 
+

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()
  *
  */
 
+

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()
  *
  */
 
+

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()
  *
  */
 
+

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;
+}
+

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_
+

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()
  *
  */
 
+

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 <Message.h>
 #include <MessageQueue.h>
-#include "MessageQueue.h"
 
 
 /*
- *  Method:  AddMessageTest1<MessageQueue>::AddMessageTest1()
+ *  Method:  AddMessageTest1::AddMessageTest1()
  *   Descr:  This is the constructor for this class.
  */
 		
-template<class MessageQueue>
-	AddMessageTest1<MessageQueue>::AddMessageTest1(std::string name) :
-		MessageQueueTestCase<MessageQueue>(name)
+
+	AddMessageTest1::AddMessageTest1(std::string name) :
+		MessageQueueTestCase(name)
 {
 	}
 
 
 /*
- *  Method:  AddMessageTest1<MessageQueue>::~AddMessageTest1()
+ *  Method:  AddMessageTest1::~AddMessageTest1()
  *   Descr:  This is the destructor for this class.
  */
  
-template<class MessageQueue>
-	AddMessageTest1<MessageQueue>::~AddMessageTest1()
+
+	AddMessageTest1::~AddMessageTest1()
 {
 	}
 	
 	
 /*
- *  Method:  AddMessageTest1<MessageQueue>::setUp()
+ *  Method:  AddMessageTest1::setUp()
  *   Descr:  This member function is called just prior to running the test.
  *           It resets the destructor count for testMessageClass.
  */
 
-template<class MessageQueue>
-	void AddMessageTest1<MessageQueue>::setUp(void)
+
+	void AddMessageTest1::setUp(void)
 {
 	testMessageClass::messageDestructorCount = 0;
 	}
 
 
 /*
- *  Method:  AddMessageTest1<MessageQueue>::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<class MessageQueue>
  *           queue is deleted.
  */	
 
-template<class MessageQueue>
-	void AddMessageTest1<MessageQueue>::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<Locker>::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<class MessageQueue> Test *AddMessageTest1<MessageQueue>::suite(void)
+ Test *AddMessageTest1::suite(void)
 {	
-	AddMessageTest1<MessageQueue> *theTest = new AddMessageTest1<MessageQueue>("");
-	AddMessageTest1Caller *testCaller = new AddMessageTest1Caller("", theTest);
-	testCaller->addThread(":Thread1", &AddMessageTest1<MessageQueue>::PerformTest);
+	typedef BThreadedTestCaller<AddMessageTest1>
+		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<BMessageQueue>;
-template class AddMessageTest1<OpenBeOS::BMessageQueue>;

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 MessageQueue> class AddMessageTest1 :
-	public MessageQueueTestCase<MessageQueue> {
+ class AddMessageTest1 :
+	public MessageQueueTestCase {
 	
 private:
-	typedef ThreadedTestCaller <AddMessageTest1<MessageQueue> >
-		AddMessageTest1Caller;
 	
 public:
 	static Test *suite(void);
@@ -31,4 +28,10 @@ public:
 	virtual ~AddMessageTest1();
 	};
 	
-#endif
+#endif
+
+
+
+
+
+

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 <Message.h>
 #include <MessageQueue.h>
@@ -19,30 +20,30 @@
 
 
 /*
- *  Method:  AddMessageTest2<MessageQueue>::AddMessageTest2()
+ *  Method:  AddMessageTest2::AddMessageTest2()
  *   Descr:  This is the constructor for this class.
  */
 		
-template<class MessageQueue>
-	AddMessageTest2<MessageQueue>::AddMessageTest2(std::string name) :
-					MessageQueueTestCase<MessageQueue>(name)
+
+	AddMessageTest2::AddMessageTest2(std::string name) :
+					MessageQueueTestCase(name)
 {
 	}
 
 
 /*
- *  Method:  AddMessageTest2<MessageQueue>::~AddMessageTest2()
+ *  Method:  AddMessageTest2::~AddMessageTest2()
  *   Descr:  This is the destructor for this class.
  */
 
-template<class MessageQueue>
-	AddMessageTest2<MessageQueue>::~AddMessageTest2()
+
+	AddMessageTest2::~AddMessageTest2()
 {
 	}
 
 
 /*
- *  Method:  AddMessageTest2<MessageQueue>::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<class MessageQueue>
  *           checks each element on the queue one by one.
  */
 
-template<class MessageQueue>
-	void AddMessageTest2<MessageQueue>::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<class MessageQueue>
 	AddMessage(thirdMessage);
 	AddMessage(fourthMessage);
 	
+	NextSubTest();
 	CheckQueueAgainstList();
 	
 	AddMessage(secondMessage);
@@ -75,36 +78,37 @@ template<class MessageQueue>
 	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<Locker>::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<class MessageQueue> Test *AddMessageTest2<MessageQueue>::suite(void)
+ Test *AddMessageTest2::suite(void)
 {	
-	AddMessageTest2<MessageQueue> *theTest = new AddMessageTest2<MessageQueue>("");
-	AddMessageTest2Caller *testCaller = new AddMessageTest2Caller("", theTest);
-	testCaller->addThread(":Thread1", &AddMessageTest2<MessageQueue>::PerformTest);
+	typedef BThreadedTestCaller<AddMessageTest2>
+		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<BMessageQueue>;
-template class AddMessageTest2<OpenBeOS::BMessageQueue>;

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 MessageQueue> class AddMessageTest2 :
-	public MessageQueueTestCase<MessageQueue> {
+ class AddMessageTest2 :
+	public MessageQueueTestCase {
 	
 private:
-	typedef ThreadedTestCaller <AddMessageTest2<MessageQueue> >
-		AddMessageTest2Caller;
 	
 public:
 	static Test *suite(void);
@@ -30,4 +27,10 @@ public:
 	virtual ~AddMessageTest2();
 	};
 	
-#endif
+#endif
+
+
+
+
+
+

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 <MessageQueue.h>
-#include "MessageQueue.h"
+#include <Autolock.h>
 
 
 // This constant indicates how many messages to add to the queue.
@@ -48,36 +49,36 @@ const int numAddMessagesPerRemove = 5;
 
 
 /*
- *  Method:  ConcurrencyTest1<MessageQueue>::ConcurrencyTest1()
+ *  Method:  ConcurrencyTest1::ConcurrencyTest1()
  *   Descr:  This is the constructor for this test.
  */
 		
-template<class MessageQueue>
-	ConcurrencyTest1<MessageQueue>::ConcurrencyTest1(std::string name, bool listFlag) :
-		MessageQueueTestCase<MessageQueue>(name), useList(listFlag)
+
+	ConcurrencyTest1::ConcurrencyTest1(std::string name, bool listFlag) :
+		MessageQueueTestCase(name), useList(listFlag)
 {
 	}
 
 
 /*
- *  Method:  ConcurrencyTest1<MessageQueue>::~ConcurrencyTest1()
+ *  Method:  ConcurrencyTest1::~ConcurrencyTest1()
  *   Descr:  This is the destructor for this test.
  */
 
-template<class MessageQueue>
-	ConcurrencyTest1<MessageQueue>::~ConcurrencyTest1()
+
+	ConcurrencyTest1::~ConcurrencyTest1()
 {
 	}
 
 
 /*
- *  Method:  ConcurrencyTest1<MessageQueue>::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<class MessageQueue> void ConcurrencyTest1<MessageQueue>::setUp(void)
+ void ConcurrencyTest1::setUp(void)
 {
 	testMessageClass::messageDestructorCount = 0;
 
@@ -94,7 +95,7 @@ template<class MessageQueue> void ConcurrencyTest1<MessageQueue>::setUp(void)
 
 
 /*
- *  Method:  ConcurrencyTest1<MessageQueue>::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<class MessageQueue> void ConcurrencyTest1<MessageQueue>::setUp(void)
  *           are all deleted when the message queue is destructed.
  */
 
-template<class MessageQueue> void ConcurrencyTest1<MessageQueue>::TestThread1(void)
+ void ConcurrencyTest1::TestThread1(void)
 {
+	NextSubTest();
 	snooze(1000000);
 	thread2Lock.Lock();
 	thread3Lock.Lock();
@@ -116,30 +118,32 @@ template<class MessageQueue> void ConcurrencyTest1<MessageQueue>::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<MessageQueue>::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<class MessageQueue> void ConcurrencyTest1<MessageQueue>::TestThread2(void)
+ void ConcurrencyTest1::TestThread2(void)
 {
-	thread2Lock.Lock();
-	SafetyLock<BLocker> 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<class MessageQueue> void ConcurrencyTest1<MessageQueue>::TestThread2(vo
 		} else {
 			theMessage = theMessageQueue->NextMessage();
 		}
-		assert(theMessage != NULL);
+		CPPUNIT_ASSERT(theMessage != NULL);
 	}
 }
 
 
 /*
- *  Method:  ConcurrencyTest1<MessageQueue>::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<class MessageQueue> void ConcurrencyTest1<MessageQueue>::TestThread3(void)
+ void ConcurrencyTest1::TestThread3(void)
 {
-	thread3Lock.Lock();
-	SafetyLock<BLocker> 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<class MessageQueue> void ConcurrencyTest1<MessageQueue>::TestThread3(vo
 
 
 /*
- *  Method:  ConcurrencyTest1<MessageQueue>::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<class MessageQueue> void ConcurrencyTest1<MessageQueue>::TestThread3(vo
  *           ConcurrencyTest1Caller) with three independent threads.
  */
 
-template<class MessageQueue> Test *ConcurrencyTest1<MessageQueue>::suite(void)
+ Test *ConcurrencyTest1::suite(void)
 {	
+	typedef BThreadedTestCaller<ConcurrencyTest1>
+		ConcurrencyTest1Caller;
 	TestSuite *testSuite = new TestSuite("ConcurrencyTest1");
 	
-	ConcurrencyTest1<MessageQueue> *theTest = new ConcurrencyTest1<MessageQueue>("WithList", true);
-	ConcurrencyTest1Caller *threadedTest1 = new ConcurrencyTest1Caller("", theTest);
-	threadedTest1->addThread(":Thread1", &ConcurrencyTest1<MessageQueue>::TestThread1);
-	threadedTest1->addThread(":Thread2", &ConcurrencyTest1<MessageQueue>::TestThread2);
-	threadedTest1->addThread(":Thread3", &ConcurrencyTest1<MessageQueue>::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<MessageQueue>("WithoutList", false);
-	ConcurrencyTest1Caller *threadedTest2 = new ConcurrencyTest1Caller("", theTest);
-	threadedTest2->addThread(":Thread1", &ConcurrencyTest1<MessageQueue>::TestThread1);
-	threadedTest2->addThread(":Thread2", &ConcurrencyTest1<MessageQueue>::TestThread2);
-	threadedTest2->addThread(":Thread3", &ConcurrencyTest1<MessageQueue>::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<class MessageQueue> Test *ConcurrencyTest1<MessageQueue>::suite(void)
 	}
 	
 	
-template class ConcurrencyTest1<BMessageQueue>;
-template class ConcurrencyTest1<OpenBeOS::BMessageQueue>;
+

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 <Locker.h>
 
 	
-template<class MessageQueue> class ConcurrencyTest1 :
-	public MessageQueueTestCase<MessageQueue> {
+ class ConcurrencyTest1 :
+	public MessageQueueTestCase {
 	
 private:
-	typedef ThreadedTestCaller<ConcurrencyTest1<MessageQueue> >
-		ConcurrencyTest1Caller;
 
 	bool useList;
 	BLocker thread2Lock;
@@ -40,4 +37,10 @@ public:
 	virtual ~ConcurrencyTest1();
 	};
 	
-#endif
+#endif
+
+
+
+
+
+

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 <MessageQueue.h>
-#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<MessageQueue>::ConcurrencyTest2()
+ *  Method:  ConcurrencyTest2::ConcurrencyTest2()
  *   Descr:  This is the constructor for this test.
  */
 		
-template<class MessageQueue>
-	ConcurrencyTest2<MessageQueue>::ConcurrencyTest2(std::string name, bool unlockFlag) :
-		MessageQueueTestCase<MessageQueue>(name), unlockTest(unlockFlag)
+
+	ConcurrencyTest2::ConcurrencyTest2(std::string name, bool unlockFlag) :
+		MessageQueueTestCase(name), unlockTest(unlockFlag)
 {
 	}
 
 
 /*
- *  Method:  ConcurrencyTest2<MessageQueue>::~ConcurrencyTest2()
+ *  Method:  ConcurrencyTest2::~ConcurrencyTest2()
  *   Descr:  This is the destructor for this test.
  */
 
-template<class MessageQueue>
-	ConcurrencyTest2<MessageQueue>::~ConcurrencyTest2()
+
+	ConcurrencyTest2::~ConcurrencyTest2()
 {
 	}
 
 
 /*
- *  Method:  ConcurrencyTest2<MessageQueue>::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<class MessageQueue>
-	void ConcurrencyTest2<MessageQueue>::setUp(void)
+
+	void ConcurrencyTest2::setUp(void)
 {
 	isLocked = false;
 	testMessageClass::messageDestructorCount = 0;
@@ -84,15 +82,15 @@ template<class MessageQueue>
 
 
 /*
- *  Method:  ConcurrencyTest2<MessageQueue>::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<class MessageQueue>
-	void ConcurrencyTest2<MessageQueue>::TestThread1(void)
+
+	void ConcurrencyTest2::TestThread1(void)
 {
 	theMessageQueue->Lock();
 	isLocked = true;
@@ -103,7 +101,7 @@ template<class MessageQueue>
 	if (unlockTest) {
 		theMessageQueue->Unlock();
 	} else {
-		MessageQueue *tmpMessageQueue = theMessageQueue;
+		BMessageQueue *tmpMessageQueue = theMessageQueue;
 		theMessageQueue = NULL;
 		delete tmpMessageQueue;
 	}	
@@ -111,7 +109,7 @@ template<class MessageQueue>
 
 
 /*
- *  Method:  ConcurrencyTest2<MessageQueue>::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<class MessageQueue>
  *           the queue.  The result of NextMessage() is checked finally.
  */
 
-template<class MessageQueue> void ConcurrencyTest2<MessageQueue>::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<class MessageQueue> void ConcurrencyTest2<MessageQueue>::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<class MessageQueue> void ConcurrencyTest2<MessageQueue>::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<MessageQueue>::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<class MessageQueue> void ConcurrencyTest2<MessageQueue>::TestThread2(vo
  *           on the queue.  The state of the queue is checked finally.
  */
 
-template<class MessageQueue> void ConcurrencyTest2<MessageQueue>::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<class MessageQueue> void ConcurrencyTest2<MessageQueue>::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<MessageQueue>::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<class MessageQueue> void ConcurrencyTest2<MessageQueue>::TestThread3(vo
  *           the queue.  The state of the queue is checked finally.
  */
 
-template<class MessageQueue> void ConcurrencyTest2<MessageQueue>::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<class MessageQueue> void ConcurrencyTest2<MessageQueue>::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<MessageQueue>::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<class MessageQueue> void ConcurrencyTest2<MessageQueue>::TestThread4(vo
  *           acquisition.
  */
 
-template<class MessageQueue> void ConcurrencyTest2<MessageQueue>::TestThread5(void)
+ void ConcurrencyTest2::TestThread5(void)
 {
-	SafetyLock<MessageQueue> 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<MessageQueue>::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<class MessageQueue> void ConcurrencyTest2<MessageQueue>::TestThread5(vo
  *           ConcurrencyTest2Caller) with five independent threads.
  */
 
-template<class MessageQueue> Test *ConcurrencyTest2<MessageQueue>::suite(void)
+ Test *ConcurrencyTest2::suite(void)
 {	
+	typedef BThreadedTestCaller<ConcurrencyTest2>
+		ConcurrencyTest2Caller;
+
 	TestSuite *testSuite = new TestSuite("ConcurrencyTest2");
 	
-	ConcurrencyTest2<MessageQueue> *theTest = new ConcurrencyTest2<MessageQueue>("WithUnlock", true);
-	ConcurrencyTest2Caller *threadedTest1 = new ConcurrencyTest2Caller("", theTest);
-	threadedTest1->addThread(":Thread1", &ConcurrencyTest2<MessageQueue>::TestThread1);
-	threadedTest1->addThread(":Thread2", &ConcurrencyTest2<MessageQueue>::TestThread2);
-	threadedTest1->addThread(":Thread3", &ConcurrencyTest2<MessageQueue>::TestThread3);
-	threadedTest1->addThread(":Thread3", &ConcurrencyTest2<MessageQueue>::TestThread4);
-	threadedTest1->addThread(":Thread3", &ConcurrencyTest2<MessageQueue>::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<MessageQueue>("WithDelete", false);
-	ConcurrencyTest2Caller *threadedTest2 = new ConcurrencyTest2Caller("", theTest);
-	threadedTest2->addThread(":Thread1", &ConcurrencyTest2<MessageQueue>::TestThread1);
-	threadedTest2->addThread(":Thread2", &ConcurrencyTest2<MessageQueue>::TestThread2);
-	threadedTest2->addThread(":Thread3", &ConcurrencyTest2<MessageQueue>::TestThread3);
-	threadedTest2->addThread(":Thread3", &ConcurrencyTest2<MessageQueue>::TestThread4);
-	threadedTest2->addThread(":Thread3", &ConcurrencyTest2<MessageQueue>::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<class MessageQueue> Test *ConcurrencyTest2<MessageQueue>::suite(void)
 	}
 
 
-template class ConcurrencyTest2<BMessageQueue>;
-template class ConcurrencyTest2<OpenBeOS::BMessageQueue>;
+

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 MessageQueue> class ConcurrencyTest2 :
-	public MessageQueueTestCase<MessageQueue> {
+ class ConcurrencyTest2 :
+	public MessageQueueTestCase {
 	
 private:
-	typedef ThreadedTestCaller<ConcurrencyTest2<MessageQueue> >
-		ConcurrencyTest2Caller;
 		
 	bool unlockTest;
 	bool isLocked;
@@ -39,4 +36,8 @@ public:
 	virtual ~ConcurrencyTest2();
 	};
 	
-#endif
+#endif
+
+
+
+

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 <Message.h>
 #include <MessageQueue.h>
@@ -33,30 +34,30 @@ const int numPerWhatCode = 50;
 
 
 /*
- *  Method:  FindMessageTest1<MessageQueue>::FindMessageTest1()
+ *  Method:  FindMessageTest1::FindMessageTest1()
  *   Descr:  This is the constructor for this test class.
  */
 		
-template<class MessageQueue>
-	FindMessageTest1<MessageQueue>::FindMessageTest1(std::string name) :
-		MessageQueueTestCase<MessageQueue>(name)
+
+	FindMessageTest1::FindMessageTest1(std::string name) :
+		MessageQueueTestCase(name)
 {
 	}
 
 
 /*
- *  Method:  FindMessageTest1<MessageQueue>::~FindMessageTest1()
+ *  Method:  FindMessageTest1::~FindMessageTest1()
  *   Descr:  This is the destructor for this test class.
  */
 
-template<class MessageQueue>
-	FindMessageTest1<MessageQueue>::~FindMessageTest1()
+
+	FindMessageTest1::~FindMessageTest1()
 {
 	}
 
 
 /*
- *  Method:  FindMessageTest1<MessageQueue>::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<class MessageQueue>
  *           checks that the queue and list return the same result.
  */	
 
-template<class MessageQueue>
-	void FindMessageTest1<MessageQueue>::PerformTest(void)
+
+	void FindMessageTest1::PerformTest(void)
 {
 	int whatCode;
 	int i;
@@ -73,42 +74,49 @@ template<class MessageQueue>
 	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<Locker>::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<class MessageQueue> Test *FindMessageTest1<MessageQueue>::suite(void)
+ Test *FindMessageTest1::suite(void)
 {	
-	FindMessageTest1<MessageQueue> *theTest = new FindMessageTest1<MessageQueue>("");
-	FindMessageTest1Caller *testCaller = new FindMessageTest1Caller("", theTest);
-	testCaller->addThread(":Thread1", &FindMessageTest1<MessageQueue>::PerformTest);
+	typedef BThreadedTestCaller<FindMessageTest1>
+		FindMessageTest1Caller;
+
+	FindMessageTest1 *theTest = new FindMessageTest1("");
+	FindMessageTest1Caller *testCaller = new FindMessageTest1Caller("BMessageQueue::Find Message Test", theTest);
+	testCaller->addThread("A", &FindMessageTest1::PerformTest);
 				
 	return(testCaller);
 	}
 
 
-template class FindMessageTest1<BMessageQueue>;
-template class FindMessageTest1<OpenBeOS::BMessageQueue>;

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 MessageQueue> class FindMessageTest1 :
-	public MessageQueueTestCase<MessageQueue> {
+ class FindMessageTest1 :
+	public MessageQueueTestCase {
 	
 private:
-	typedef ThreadedTestCaller<FindMessageTest1<MessageQueue> >
-		FindMessageTest1Caller;
 	
 public:
 	static Test *suite(void);
@@ -30,4 +27,10 @@ public:
 	virtual ~FindMessageTest1();
 	};
 	
-#endif
+#endif
+
+
+
+
+
+

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);
+}
+
+
+
+
+
+
+

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_
+
+
+
+
+
+

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<class MessageQueue>
-	MessageQueueTestCase<MessageQueue>::MessageQueueTestCase(
-		std::string name) : TestCase(name),
-							theMessageQueue(new MessageQueue)
+
+	MessageQueueTestCase::MessageQueueTestCase(
+		std::string name) : BThreadedTestCase(name),
+							theMessageQueue(new BMessageQueue())
 {
 	}
 
 
-template<class MessageQueue>
-	MessageQueueTestCase<MessageQueue>::~MessageQueueTestCase()
+
+	MessageQueueTestCase::~MessageQueueTestCase()
 {
 	delete theMessageQueue;
 	theMessageQueue = NULL;
 	}
 	
 	
-template<class MessageQueue>
-	void MessageQueueTestCase<MessageQueue>::CheckQueueAgainstList(void)
+
+	void MessageQueueTestCase::CheckQueueAgainstList(void)
 {
-	SafetyLock<MessageQueue> 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<class MessageQueue>
 }
 
 
-template<class MessageQueue>
-	void MessageQueueTestCase<MessageQueue>::AddMessage(BMessage *message)
+
+	void MessageQueueTestCase::AddMessage(BMessage *message)
 {
 	if (theMessageQueue->Lock()) {
 		theMessageQueue->AddMessage(message);
@@ -57,8 +57,8 @@ template<class MessageQueue>
 	}
 }
 	
-template<class MessageQueue>
-	void MessageQueueTestCase<MessageQueue>::RemoveMessage(BMessage *message)
+
+	void MessageQueueTestCase::RemoveMessage(BMessage *message)
 {
 	if (theMessageQueue->Lock()) {
 		theMessageQueue->RemoveMessage(message);
@@ -67,23 +67,23 @@ template<class MessageQueue>
 	}
 }
 	
-template<class MessageQueue>
-	BMessage *MessageQueueTestCase<MessageQueue>::NextMessage(void)
+
+	BMessage *MessageQueueTestCase::NextMessage(void)
 {
-	SafetyLock<MessageQueue> 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<class MessageQueue>
-	BMessage *MessageQueueTestCase<MessageQueue>::FindMessage(uint32 what, int index)
+
+	BMessage *MessageQueueTestCase::FindMessage(uint32 what, int index)
 {
 	int listCount = messageList.CountItems();
 	int i;
@@ -102,5 +102,4 @@ template<class MessageQueue>
 }
 	
 
-template class MessageQueueTestCase<BMessageQueue>;
-template class MessageQueueTestCase<OpenBeOS::BMessageQueue>;
+

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 <List.h>
 #include <Locker.h>
 #include <Message.h>
-#include "TestCase.h"
+#include <MessageQueue.h>
+#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<class MessageQueue> void myTestClass<MessageQueue>::myTestFunc(void)
+//  void myTestClass::myTestFunc(void)
 // {
-//   SafetyLock<MessageQueue> mySafetyLock(theMessageQueue);
+//   SafetyLock mySafetyLock(theMessageQueue);
 //   ...perform tests without worrying about holding the lock on assert...
 //
 
-template<class MessageQueue> 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 MessageQueue> 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
+#endif
+
+
+

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;
 }
 
 
+

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;
 }
 
+

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;
 }
 
+

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;
 }
 
+

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;
 }
 
+

src/tests/kits/app/bmessenger/MessengerTest.cpp

@@ -21,3 +21,4 @@ CppUnit::Test* MessengerTestSuite()
 
 	return testSuite;
 }
+

src/tests/kits/app/bmessenger/SMInvoker.cpp

@@ -149,3 +149,4 @@ SMInvoker5::Invoke(BMessenger &target, BHandler *replyHandler,
 	return result;
 }
 
+

src/tests/kits/app/bmessenger/SMLooper.cpp

@@ -151,3 +151,4 @@ SMHandler::MessageReceived(BMessage *message)
 	}
 }
 
+

src/tests/kits/app/bmessenger/SMRemoteTargetApp.cpp

@@ -105,3 +105,4 @@ DBG(OUT("REMOTE: main() done\n"));
 	return 0;
 }
 
+

src/tests/kits/app/bmessenger/SMReplyTarget.cpp

@@ -56,3 +56,4 @@ SMReplyTarget::ReplySuccess()
 	return fLooper->ReplySuccess();
 }
 
+

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;
 
+

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;
 }
 
+

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;
 }
 
+

src/tests/kits/app/common.h

@@ -31,6 +31,10 @@
 	(suitename)->addTest(new TestCaller<classname>((#funcname),	\
 						 &classname::funcname));
 
+#define ADD_TEST4(classbeingtested, suitename, classname, funcname)				\
+	(suitename)->addTest(new TestCaller<classname>((#classbeingtested "::" #funcname),	\
+						 &classname::funcname));
+
 #define CHECK_ERRNO														\
 	cout << endl << "errno == \"" << strerror(errno) << "\" (" << errno	\
 		 << ") in " << __PRETTY_FUNCTION__ << endl

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<TInstantiateObjectTester>("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 $
  *

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();