$Id: PropertyFindMatchTest.cpp 851 2002-08-22 03:15:35Z jrand $
This file implements the FindMatch test for the Haiku BPropertyInfo
code. This class tests the following usecases:
- Find Match
*/
#include "PropertyFindMatchTest.h"
#include <assert.h>
#include <Message.h>
* Method: PropertyFindMatchTest::PropertyFindMatchTest()
* Descr: This is the constructor for this class.
*/
PropertyFindMatchTest::PropertyFindMatchTest(std::string name) :
PropertyTestcase(name)
{
}
* Method: PropertyFindMatchTest::~PropertyFindMatchTest()
* Descr: This is the destructor for this class.
*/
PropertyFindMatchTest::~PropertyFindMatchTest()
{
}
* Method: PropertyFindMatchTest::TestProperty()
* Descr: This member function performs this test.
*/
void PropertyFindMatchTest::TestProperty(
BPropertyInfo *propTest,
const property_info *prop_list,
const value_info *value_list,
int32 prop_count,
int32 value_count,
ssize_t flat_size,
const char *lflat_data,
const char *bflat_data)
{
const uint32 *commands;
const uint32 *specifiers;
const property_info *theProps = propTest->Properties();
int i, j, k;
bool wildcardCommand, wildcardSpec;
ExecFindMatch(propTest, uniquePropName, uniqueCommand, uniqueSpecifier, false, -1);
ExecFindMatch(propTest, commonPropName, uniqueCommand, uniqueSpecifier, false, -1);
ExecFindMatch(propTest, uniquePropName, commonCommand, uniqueSpecifier, false, -1);
ExecFindMatch(propTest, uniquePropName, uniqueCommand, commonSpecifier, false, -1);
for (i=0; i < prop_count; i++) {
wildcardCommand = (theProps[i].commands[0] == 0);
wildcardSpec = (theProps[i].specifiers[0] == 0);
if (wildcardCommand) {
commands = wildcardCommandTests;
} else {
commands = theProps[i].commands;
}
if (wildcardSpec) {
specifiers = wildcardSpecifierTests;
} else {
specifiers = theProps[i].specifiers;
}
for(j=0; j<10; j++) {
if (commands[j] == 0) {
break;
}
if (!wildcardSpec) {
ExecFindMatch(propTest, theProps[i].name, commands[j], uniqueSpecifier,
wildcardCommand, -1);
}
for(k=0; k<10; k++) {
if (specifiers[k] == 0) {
break;
}
if (!wildcardCommand) {
ExecFindMatch(propTest, theProps[i].name, uniqueCommand, specifiers[k],
wildcardCommand, -1);
}
ExecFindMatch(propTest, theProps[i].name, commands[j], specifiers[k],
wildcardCommand, i);
}
}
}
}
* Method: PropertyFindMatchTest::ExecFindMatch()
* Descr: This member function executes the FindMatch() member on the
* BPropertyInfo instance and ensures that the result is what is
* expected. It calls FindMatch() normally with a zero index
* (meaning to match wildcard and non-wildcard command instances)
* and with a non-NULL specifier message. The extra_data member
* is checked to make sure it is what is expected if a match is
* returned.
*
* The Be implementation takes a pointer to a BMessage specifier
* but it doesn't seem to need it. So, the FindMatch() is called
* again with a NULL BMessage specifier and we expect the same
* result.
*
* Finally, the result is checked with a non-zero index. If index
* is non-zero, a match will only be found if the property uses
* a wildcard for the command. Depending on whether we are testing
* a wildcard command (from the wildcardCommand flag), we check the
* result with and without a BMessage specifier.
*/
void PropertyFindMatchTest::ExecFindMatch(
BPropertyInfo *propTest,
const char *prop,
uint32 comm,
uint32 spec,
bool wildcardCommand,
int32 result
)
{
BMessage msg(comm);
BMessage specMsg(spec);
specMsg.AddString("property", prop);
msg.AddSpecifier(&specMsg);
uint32 extra_data;
assert(propTest->FindMatch(&msg, 0, &specMsg, spec, prop, &extra_data) == result);
if (result >= 0) {
assert((propTest->Properties())[result].extra_data == extra_data);
}
assert(propTest->FindMatch(&msg, 0, NULL, spec, prop, &extra_data) == result);
if (wildcardCommand) {
assert(propTest->FindMatch(&msg, 1, &specMsg, spec, prop, &extra_data) == result);
assert(propTest->FindMatch(&msg, 1, NULL, spec, prop, &extra_data) == result);
} else {
assert(propTest->FindMatch(&msg, 1, &specMsg, spec, prop, &extra_data) == -1);
assert(propTest->FindMatch(&msg, 1, NULL, spec, prop, &extra_data) == -1);
}
}
* Method: PropertyFindMatchTest::suite()
* Descr: This static member function returns a test caller for performing
* all combinations of "PropertyFindMatchTest". The test
* is created as a ThreadedTestCase (typedef'd as
* PropertyFindMatchTestCaller) with only one thread.
*/
Test *PropertyFindMatchTest::suite(void)
{
typedef CppUnit::TestCaller<PropertyFindMatchTest>
PropertyFindMatchTestCaller;
return(new PropertyFindMatchTestCaller("BPropertyInfo::FindMatch Test", &PropertyFindMatchTest::PerformTest));
}
