#include <Message.h>
#include <OS.h>
#include <Handler.h>
#include <Looper.h>
#include <MessageFilter.h>
#include "BHandlerTester.h"
#include "LockLooperTestCommon.h"
BHandler(const char* name)
@case Construct with NULL name
@param name NULL
@results BHandler::Name() should return NULL
*/
void TBHandlerTester::BHandler1()
{
BHandler Handler((const char*)NULL);
CPPUNIT_ASSERT(Handler.Name() == NULL);
}
BHandler(const char* name)
@case Construct with valid name
@param name valid string
@results BHandler::Name() returns name
*/
void TBHandlerTester::BHandler2()
{
BHandler Handler("name");
CPPUNIT_ASSERT(string("name") == Handler.Name());
}
BHandler(BMessage* archive)
@case archive is valid and has field "_name"
@param archive valid BMessage pointer
@results BHandler::Name() returns _name
*/
void TBHandlerTester::BHandler3()
{
BMessage Archive;
Archive.AddString("_name", "the name");
BHandler Handler(&Archive);
CPPUNIT_ASSERT(string("the name") == Handler.Name());
}
BHandler(BMessage* archive)
@case archive is valid, but has no field "_name"
@param archive valid BMessage pointer
@results BHandler::Name() returns NULL
*/
void TBHandlerTester::BHandler4()
{
BMessage Archive;
BHandler Handler(&Archive);
CPPUNIT_ASSERT(Handler.Name() == NULL);
}
BHandler(BMessage* archive)
@case archive is NULL
@param archive NULL
@results BHandler::Name() returns NULL
@note This test is not enabled against the original implementation
as it doesn't check for a NULL parameter and seg faults.
*/
void TBHandlerTester::BHandler5()
{
#if !defined(TEST_R5)
BHandler Handler((BMessage*)NULL);
CPPUNIT_ASSERT(Handler.Name() == NULL);
#endif
}
Archive(BMessage* data, bool deep = true)
@case data is NULL, deep is false
@param data NULL
@param deep false
@results Returns B_BAD_VALUE
@note This test is not enabled against the original implementation
as it doesn't check for NULL parameters and seg faults
*/
void TBHandlerTester::Archive1()
{
#if !defined(TEST_R5)
BHandler Handler;
CPPUNIT_ASSERT(Handler.Archive(NULL, false) == B_BAD_VALUE);
#endif
}
Archive(BMessage* data, bool deep = true)
@case data is NULL, deep is true
@param data NULL
@param deep false
@results Returns B_BAD_VALUE
@note This test is not enabled against the original implementation
as it doesn't check for NULL parameters and seg faults
*/
void TBHandlerTester::Archive2()
{
#if !defined(TEST_R5)
BHandler Handler;
CPPUNIT_ASSERT(Handler.Archive(NULL) == B_BAD_VALUE);
#endif
}
Archive(BMessage* data, bool deep = true)
@case data is valid, deep is false
@param data valid BMessage pointer
@param deep false
@results Returns B_OK
Resultant archive has string field labeled "_name"
Field "_name" contains the string "a name"
Resultant archive has string field labeled "class"
Field "class" contains the string "BHandler"
*/
void TBHandlerTester::Archive3()
{
BMessage Archive;
BHandler Handler("a name");
CPPUNIT_ASSERT(Handler.Archive(&Archive, false) == B_OK);
const char* data;
CPPUNIT_ASSERT(Archive.FindString("_name", &data) == B_OK);
CPPUNIT_ASSERT(string("a name") == data);
CPPUNIT_ASSERT(Archive.FindString("class", &data) == B_OK);
CPPUNIT_ASSERT(string("BHandler") == data);
}
Archive(BMessage *data, bool deep = true)
@case data is valid, deep is true
@param data valid BMessage pointer
@param deep true
@results Returns B_OK
Resultant archive has string field labeled "_name"
Field "_name" contains the string "a name"
Resultant archive has string field labeled "class"
Field "class" contains the string "BHandler"
*/
void TBHandlerTester::Archive4()
{
BMessage Archive;
BHandler Handler("another name");
CPPUNIT_ASSERT(Handler.Archive(&Archive) == B_OK);
const char* data;
CPPUNIT_ASSERT(Archive.FindString("_name", &data) == B_OK);
CPPUNIT_ASSERT(string("another name") == data);
CPPUNIT_ASSERT(Archive.FindString("class", &data) == B_OK);
CPPUNIT_ASSERT(string("BHandler") == data);
}
Instantiate(BMessage* data)
@case data is NULL
@param data NULL
@results
@note This test is not enabled against the original implementation
as it doesn't check for NULL parameters and seg faults
*/
void TBHandlerTester::Instantiate1()
{
#if !defined(TEST_R5)
CPPUNIT_ASSERT(BHandler::Instantiate(NULL) == NULL);
CPPUNIT_ASSERT(errno == B_BAD_VALUE);
#endif
}
Instantiate(BMessage* data)
@case data is valid, has field "_name"
@param data Valid BMessage pointer with string field "class" containing
string "BHandler" and with string field "_name" containing
string "a name"
@results BHandler::Name() returns "a name"
*/
void TBHandlerTester::Instantiate2()
{
BMessage Archive;
Archive.AddString("class", "BHandler");
Archive.AddString("_name", "a name");
BHandler* Handler =
dynamic_cast<BHandler*>(BHandler::Instantiate(&Archive));
CPPUNIT_ASSERT(Handler != NULL);
CPPUNIT_ASSERT(string("a name") == Handler->Name());
CPPUNIT_ASSERT(errno == B_OK);
}
Instantiate(BMessage *data)
@case data is valid, has no field "_name"
@param data valid BMessage pointer with string field "class" containing
string "BHandler"
@results BHandler::Name() returns NULL
*/
void TBHandlerTester::Instantiate3()
{
BMessage Archive;
Archive.AddString("class", "BHandler");
BHandler* Handler =
dynamic_cast<BHandler*>(BHandler::Instantiate(&Archive));
CPPUNIT_ASSERT(Handler != NULL);
CPPUNIT_ASSERT(Handler->Name() == NULL);
CPPUNIT_ASSERT(errno == B_OK);
}
SetName(const char* name)
Name()
@case name is NULL
@param name NULL
@results BHandler::Name() returns NULL
*/
void TBHandlerTester::SetName1()
{
BHandler Handler("a name");
CPPUNIT_ASSERT(string("a name") == Handler.Name());
Handler.SetName(NULL);
CPPUNIT_ASSERT(Handler.Name() == NULL);
}
SetName(const char *name)
Name()
@case name is valid
@param name Valid string pointer
@results BHandler::Name returns name
*/
void TBHandlerTester::SetName2()
{
BHandler Handler("a name");
CPPUNIT_ASSERT(string("a name") == Handler.Name());
Handler.SetName("another name");
CPPUNIT_ASSERT(string("another name") == Handler.Name());
}
Perform(perform_code d, void *arg)
@case feed meaningless data, should return B_NAME_NOT_FOUND
@param d N/A
@param arg NULL
@results Returns B_NAME_NOT_FOUND
*/
void TBHandlerTester::Perform1()
{
BHandler Handler;
CPPUNIT_ASSERT(Handler.Perform(0, NULL) == B_NAME_NOT_FOUND);
}
FilterList();
@case Default constructed BHandler
@results FilterList() returns NULL
*/
void TBHandlerTester::FilterList1()
{
BHandler Handler;
CPPUNIT_ASSERT(!Handler.FilterList());
}
Test* TBHandlerTester::Suite()
{
TestSuite* SuiteOfTests = new TestSuite;
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_TEST4(BHandler, SuiteOfTests, TBHandlerTester, Archive1);
ADD_TEST4(BHandler, SuiteOfTests, TBHandlerTester, Archive2);
ADD_TEST4(BHandler, SuiteOfTests, TBHandlerTester, Archive3);
ADD_TEST4(BHandler, SuiteOfTests, TBHandlerTester, Archive4);
ADD_TEST4(BHandler, SuiteOfTests, TBHandlerTester, Instantiate1);
ADD_TEST4(BHandler, SuiteOfTests, TBHandlerTester, Instantiate2);
ADD_TEST4(BHandler, SuiteOfTests, TBHandlerTester, Instantiate3);
ADD_TEST4(BHandler, SuiteOfTests, TBHandlerTester, SetName1);
ADD_TEST4(BHandler, SuiteOfTests, TBHandlerTester, SetName2);
ADD_TEST4(BHandler, SuiteOfTests, TBHandlerTester, Perform1);
ADD_TEST4(BHandler, SuiteOfTests, TBHandlerTester, FilterList1);
return SuiteOfTests;
}
* $Log $
*
* $Id $
*
*/
