1 /* 2 $Id: PropertyFindMatchTest.cpp 851 2002-08-22 03:15:35Z jrand $ 3 4 This file implements the FindMatch test for the OpenBeOS BPropertyInfo 5 code. This class tests the following usecases: 6 - Find Match 7 8 */ 9 10 11 #include "PropertyFindMatchTest.h" 12 13 #include <assert.h> 14 15 #include <Message.h> 16 17 18 /* 19 * Method: PropertyFindMatchTest::PropertyFindMatchTest() 20 * Descr: This is the constructor for this class. 21 */ 22 23 24 PropertyFindMatchTest::PropertyFindMatchTest(std::string name) : 25 PropertyTestcase(name) 26 { 27 } 28 29 30 /* 31 * Method: PropertyFindMatchTest::~PropertyFindMatchTest() 32 * Descr: This is the destructor for this class. 33 */ 34 35 36 PropertyFindMatchTest::~PropertyFindMatchTest() 37 { 38 } 39 40 41 /* 42 * Method: PropertyFindMatchTest::TestProperty() 43 * Descr: This member function performs this test. 44 */ 45 46 47 void PropertyFindMatchTest::TestProperty( 48 BPropertyInfo *propTest, 49 const property_info *prop_list, 50 const value_info *value_list, 51 int32 prop_count, 52 int32 value_count, 53 ssize_t flat_size, 54 const char *lflat_data, 55 const char *bflat_data) 56 { 57 const uint32 *commands; 58 const uint32 *specifiers; 59 const property_info *theProps = propTest->Properties(); 60 int i, j, k; 61 bool wildcardCommand, wildcardSpec; 62 63 ExecFindMatch(propTest, uniquePropName, uniqueCommand, uniqueSpecifier, false, -1); 64 ExecFindMatch(propTest, commonPropName, uniqueCommand, uniqueSpecifier, false, -1); 65 ExecFindMatch(propTest, uniquePropName, commonCommand, uniqueSpecifier, false, -1); 66 ExecFindMatch(propTest, uniquePropName, uniqueCommand, commonSpecifier, false, -1); 67 68 for (i=0; i < prop_count; i++) { 69 wildcardCommand = (theProps[i].commands[0] == 0); 70 wildcardSpec = (theProps[i].specifiers[0] == 0); 71 if (wildcardCommand) { 72 commands = wildcardCommandTests; 73 } else { 74 commands = theProps[i].commands; 75 } 76 if (wildcardSpec) { 77 specifiers = wildcardSpecifierTests; 78 } else { 79 specifiers = theProps[i].specifiers; 80 } 81 for(j=0; j<10; j++) { 82 if (commands[j] == 0) { 83 break; 84 } 85 if (!wildcardSpec) { 86 ExecFindMatch(propTest, theProps[i].name, commands[j], uniqueSpecifier, 87 wildcardCommand, -1); 88 } 89 for(k=0; k<10; k++) { 90 if (specifiers[k] == 0) { 91 break; 92 } 93 if (!wildcardCommand) { 94 ExecFindMatch(propTest, theProps[i].name, uniqueCommand, specifiers[k], 95 wildcardCommand, -1); 96 } 97 ExecFindMatch(propTest, theProps[i].name, commands[j], specifiers[k], 98 wildcardCommand, i); 99 } 100 } 101 } 102 } 103 104 105 /* 106 * Method: PropertyFindMatchTest::ExecFindMatch() 107 * Descr: This member function executes the FindMatch() member on the 108 * BPropertyInfo instance and ensures that the result is what is 109 * expected. It calls FindMatch() normally with a zero index 110 * (meaning to match wildcard and non-wildcard command instances) 111 * and with a non-NULL specifier message. The extra_data member 112 * is checked to make sure it is what is expected if a match is 113 * returned. 114 * 115 * The Be implementation takes a pointer to a BMessage specifier 116 * but it doesn't seem to need it. So, the FindMatch() is called 117 * again with a NULL BMessage specifier and we expect the same 118 * result. 119 * 120 * Finally, the result is checked with a non-zero index. If index 121 * is non-zero, a match will only be found if the property uses 122 * a wildcard for the command. Depending on whether we are testing 123 * a wildcard command (from the wildcardCommand flag), we check the 124 * result with and without a BMessage specifier. 125 */ 126 127 128 void PropertyFindMatchTest::ExecFindMatch( 129 BPropertyInfo *propTest, 130 const char *prop, 131 uint32 comm, 132 uint32 spec, 133 bool wildcardCommand, 134 int32 result 135 ) 136 { 137 BMessage msg(comm); 138 BMessage specMsg(spec); 139 specMsg.AddString("property", prop); 140 msg.AddSpecifier(&specMsg); 141 uint32 extra_data; 142 143 assert(propTest->FindMatch(&msg, 0, &specMsg, spec, prop, &extra_data) == result); 144 if (result >= 0) { 145 assert((propTest->Properties())[result].extra_data == extra_data); 146 } 147 assert(propTest->FindMatch(&msg, 0, NULL, spec, prop, &extra_data) == result); 148 if (wildcardCommand) { 149 assert(propTest->FindMatch(&msg, 1, &specMsg, spec, prop, &extra_data) == result); 150 assert(propTest->FindMatch(&msg, 1, NULL, spec, prop, &extra_data) == result); 151 } else { 152 assert(propTest->FindMatch(&msg, 1, &specMsg, spec, prop, &extra_data) == -1); 153 assert(propTest->FindMatch(&msg, 1, NULL, spec, prop, &extra_data) == -1); 154 } 155 } 156 157 158 /* 159 * Method: PropertyFindMatchTest::suite() 160 * Descr: This static member function returns a test caller for performing 161 * all combinations of "PropertyFindMatchTest". The test 162 * is created as a ThreadedTestCase (typedef'd as 163 * PropertyFindMatchTestCaller) with only one thread. 164 */ 165 166 Test *PropertyFindMatchTest::suite(void) 167 { 168 typedef CppUnit::TestCaller<PropertyFindMatchTest> 169 PropertyFindMatchTestCaller; 170 171 return(new PropertyFindMatchTestCaller("BPropertyInfo::FindMatch Test", &PropertyFindMatchTest::PerformTest)); 172 } 173 174 175