1 /* 2 ******************************************************************************* 3 * Copyright (C) 2007-2008, International Business Machines Corporation and 4 * others. All Rights Reserved. 5 ******************************************************************************** 6 7 * File PLURRULTS.cpp 8 * 9 ******************************************************************************** 10 */ 11 12 #include "unicode/utypes.h" 13 14 #if !UCONFIG_NO_FORMATTING 15 16 #include "plurults.h" 17 #include "unicode/plurrule.h" 18 19 20 21 void setupResult(const int32_t testSource[], char result[], int32_t* max); 22 UBool checkEqual(PluralRules *test, char *result, int32_t max); 23 UBool testEquality(PluralRules *test); 24 25 // This is an API test, not a unit test. It doesn't test very many cases, and doesn't 26 // try to test the full functionality. It just calls each function in the class and 27 // verifies that it works on a basic level. 28 29 void PluralRulesTest::runIndexedTest( int32_t index, UBool exec, const char* &name, char* /*par*/ ) 30 { 31 if (exec) logln("TestSuite PluralRulesAPI"); 32 switch (index) { 33 TESTCASE(0, testAPI); 34 default: name = ""; break; 35 } 36 } 37 38 #define PLURAL_TEST_NUM 18 39 /** 40 * Test various generic API methods of PluralRules for API coverage. 41 */ 42 void PluralRulesTest::testAPI(/*char *par*/) 43 { 44 UnicodeString pluralTestData[PLURAL_TEST_NUM] = { 45 UNICODE_STRING_SIMPLE("a: n is 1"), 46 UNICODE_STRING_SIMPLE("a: n mod 10 is 2"), 47 UNICODE_STRING_SIMPLE("a: n is not 1"), 48 UNICODE_STRING_SIMPLE("a: n mod 3 is not 1"), 49 UNICODE_STRING_SIMPLE("a: n in 2..5"), 50 UNICODE_STRING_SIMPLE("a: n within 2..5"), 51 UNICODE_STRING_SIMPLE("a: n not in 2..5"), 52 UNICODE_STRING_SIMPLE("a: n not within 2..5"), 53 UNICODE_STRING_SIMPLE("a: n mod 10 in 2..5"), 54 UNICODE_STRING_SIMPLE("a: n mod 10 within 2..5"), 55 UNICODE_STRING_SIMPLE("a: n mod 10 is 2 and n is not 12"), 56 UNICODE_STRING_SIMPLE("a: n mod 10 in 2..3 or n mod 10 is 5"), 57 UNICODE_STRING_SIMPLE("a: n mod 10 within 2..3 or n mod 10 is 5"), 58 UNICODE_STRING_SIMPLE("a: n is 1 or n is 4 or n is 23"), 59 UNICODE_STRING_SIMPLE("a: n mod 2 is 1 and n is not 3 and n in 1..11"), 60 UNICODE_STRING_SIMPLE("a: n mod 2 is 1 and n is not 3 and n within 1..11"), 61 UNICODE_STRING_SIMPLE("a: n mod 2 is 1 or n mod 5 is 1 and n is not 6"), 62 "", 63 }; 64 static const int32_t pluralTestResult[PLURAL_TEST_NUM][30] = { 65 {1, 0}, 66 {2,12,22, 0}, 67 {0,2,3,4,5,0}, 68 {0,2,3,5,6,8,9,0}, 69 {2,3,4,5,0}, 70 {2,3,4,5,0}, 71 {0,1,6,7,8, 0}, 72 {0,1,6,7,8, 0}, 73 {2,3,4,5,12,13,14,15,22,23,24,25,0}, 74 {2,3,4,5,12,13,14,15,22,23,24,25,0}, 75 {2,22,32,42,0}, 76 {2,3,5,12,13,15,22,23,25,0}, 77 {2,3,5,12,13,15,22,23,25,0}, 78 {1,4,23,0}, 79 {1,5,7,9,11,0}, 80 {1,5,7,9,11,0}, 81 {1,3,5,7,9,11,13,15,16,0}, 82 }; 83 UErrorCode status = U_ZERO_ERROR; 84 85 // ======= Test constructors 86 logln("Testing PluralRules constructors"); 87 88 89 logln("\n start default locale test case ..\n"); 90 91 PluralRules defRule(status); 92 PluralRules* test=new PluralRules(status); 93 PluralRules* newEnPlural= test->forLocale(Locale::getEnglish(), status); 94 if(U_FAILURE(status)) { 95 dataerrln("ERROR: Could not create PluralRules (default) - exitting"); 96 delete test; 97 return; 98 } 99 100 // ======= Test clone, assignment operator && == operator. 101 PluralRules *dupRule = defRule.clone(); 102 if (dupRule!=NULL) { 103 if ( *dupRule != defRule ) { 104 errln("ERROR: clone plural rules test failed!"); 105 } 106 } 107 *dupRule = *newEnPlural; 108 if (dupRule!=NULL) { 109 if ( *dupRule != *newEnPlural ) { 110 errln("ERROR: clone plural rules test failed!"); 111 } 112 delete dupRule; 113 } 114 115 delete newEnPlural; 116 117 // ======= Test empty plural rules 118 logln("Testing Simple PluralRules"); 119 120 PluralRules* empRule = test->createRules(UNICODE_STRING_SIMPLE("a:n"), status); 121 UnicodeString key; 122 for (int32_t i=0; i<10; ++i) { 123 key = empRule->select(i); 124 if ( key.charAt(0)!= 0x61 ) { // 'a' 125 errln("ERROR: empty plural rules test failed! - exitting"); 126 } 127 } 128 if (empRule!=NULL) { 129 delete empRule; 130 } 131 132 // ======= Test simple plural rules 133 logln("Testing Simple PluralRules"); 134 135 char result[100]; 136 int32_t max; 137 138 for (int32_t i=0; i<PLURAL_TEST_NUM-1; ++i) { 139 PluralRules *newRules = test->createRules(pluralTestData[i], status); 140 setupResult(pluralTestResult[i], result, &max); 141 if ( !checkEqual(newRules, result, max) ) { 142 errln("ERROR: simple plural rules failed! - exitting"); 143 delete test; 144 return; 145 } 146 if (newRules!=NULL) { 147 delete newRules; 148 } 149 } 150 151 152 // ======= Test complex plural rules 153 logln("Testing Complex PluralRules"); 154 // TODO: the complex test data is hard coded. It's better to implement 155 // a parser to parse the test data. 156 UnicodeString complexRule = UNICODE_STRING_SIMPLE("a: n in 2..5; b: n in 5..8; c: n mod 2 is 1"); 157 UnicodeString complexRule2 = UNICODE_STRING_SIMPLE("a: n within 2..5; b: n within 5..8; c: n mod 2 is 1"); 158 char cRuleResult[] = 159 { 160 0x6F, // 'o' 161 0x63, // 'c' 162 0x61, // 'a' 163 0x61, // 'a' 164 0x61, // 'a' 165 0x61, // 'a' 166 0x62, // 'b' 167 0x62, // 'b' 168 0x62, // 'b' 169 0x63, // 'c' 170 0x6F, // 'o' 171 0x63 // 'c' 172 }; 173 PluralRules *newRules = test->createRules(complexRule, status); 174 if ( !checkEqual(newRules, cRuleResult, 12) ) { 175 errln("ERROR: complex plural rules failed! - exitting"); 176 delete test; 177 return; 178 } 179 if (newRules!=NULL) { 180 delete newRules; 181 newRules=NULL; 182 } 183 newRules = test->createRules(complexRule2, status); 184 if ( !checkEqual(newRules, cRuleResult, 12) ) { 185 errln("ERROR: complex plural rules failed! - exitting"); 186 delete test; 187 return; 188 } 189 if (newRules!=NULL) { 190 delete newRules; 191 newRules=NULL; 192 } 193 194 // ======= Test decimal fractions plural rules 195 UnicodeString decimalRule= UNICODE_STRING_SIMPLE("a: n not in 0..100;"); 196 UnicodeString KEYWORD_A = UNICODE_STRING_SIMPLE("a"); 197 status = U_ZERO_ERROR; 198 newRules = test->createRules(decimalRule, status); 199 if (U_FAILURE(status)) { 200 dataerrln("ERROR: Could not create PluralRules for testing fractions - exitting"); 201 delete test; 202 return; 203 } 204 double fData[10] = {-100, -1, -0.0, 0, 0.1, 1, 1.999, 2.0, 100, 100.001 }; 205 UBool isKeywordA[10] = { 206 TRUE, TRUE, FALSE, FALSE, TRUE, FALSE, TRUE, FALSE, FALSE, TRUE }; 207 for (int32_t i=0; i<10; i++) { 208 if ((newRules->select(fData[i])== KEYWORD_A) != isKeywordA[i]) { 209 errln("ERROR: plural rules for decimal fractions test failed!"); 210 } 211 } 212 if (newRules!=NULL) { 213 delete newRules; 214 newRules=NULL; 215 } 216 217 218 219 // ======= Test Equality 220 logln("Testing Equality of PluralRules"); 221 222 223 if ( !testEquality(test) ) { 224 errln("ERROR: complex plural rules failed! - exitting"); 225 delete test; 226 return; 227 } 228 229 230 // ======= Test getStaticClassID() 231 logln("Testing getStaticClassID()"); 232 233 if(test->getDynamicClassID() != PluralRules::getStaticClassID()) { 234 errln("ERROR: getDynamicClassID() didn't return the expected value"); 235 } 236 // ====== Test fallback to parent locale 237 PluralRules *en_UK = test->forLocale(Locale::getUK(), status); 238 PluralRules *en = test->forLocale(Locale::getEnglish(), status); 239 if (en_UK != NULL && en != NULL) { 240 if ( *en_UK != *en ) { 241 errln("ERROR: test locale fallback failed!"); 242 } 243 } 244 delete en; 245 delete en_UK; 246 247 PluralRules *zh_Hant = test->forLocale(Locale::getTaiwan(), status); 248 PluralRules *zh = test->forLocale(Locale::getChinese(), status); 249 if (zh_Hant != NULL && zh != NULL) { 250 if ( *zh_Hant != *zh ) { 251 errln("ERROR: test locale fallback failed!"); 252 } 253 } 254 delete zh_Hant; 255 delete zh; 256 delete test; 257 } 258 259 void setupResult(const int32_t testSource[], char result[], int32_t* max) { 260 int32_t i=0; 261 int32_t curIndex=0; 262 263 do { 264 while (curIndex < testSource[i]) { 265 result[curIndex++]=0x6F; //'o' other 266 } 267 result[curIndex++]=0x61; // 'a' 268 269 } while(testSource[++i]>0); 270 *max=curIndex; 271 } 272 273 274 UBool checkEqual(PluralRules *test, char *result, int32_t max) { 275 UnicodeString key; 276 UBool isEqual = TRUE; 277 for (int32_t i=0; i<max; ++i) { 278 key= test->select(i); 279 if ( key.charAt(0)!=result[i] ) { 280 isEqual = FALSE; 281 } 282 } 283 return isEqual; 284 } 285 286 #define MAX_EQ_ROW 2 287 #define MAX_EQ_COL 5 288 UBool testEquality(PluralRules *test) { 289 UnicodeString testEquRules[MAX_EQ_ROW][MAX_EQ_COL] = { 290 { UNICODE_STRING_SIMPLE("a: n in 2..3"), 291 UNICODE_STRING_SIMPLE("a: n is 2 or n is 3"), 292 UNICODE_STRING_SIMPLE( "a:n is 3 and n in 2..5 or n is 2"), 293 "", 294 }, 295 { UNICODE_STRING_SIMPLE("a: n is 12; b:n mod 10 in 2..3"), 296 UNICODE_STRING_SIMPLE("b: n mod 10 in 2..3 and n is not 12; a: n in 12..12"), 297 UNICODE_STRING_SIMPLE("b: n is 13; a: n in 12..13; b: n mod 10 is 2 or n mod 10 is 3"), 298 "", 299 } 300 }; 301 UErrorCode status = U_ZERO_ERROR; 302 UnicodeString key[MAX_EQ_COL]; 303 UBool ret=TRUE; 304 for (int32_t i=0; i<MAX_EQ_ROW; ++i) { 305 PluralRules* rules[MAX_EQ_COL]; 306 307 for (int32_t j=0; j<MAX_EQ_COL; ++j) { 308 rules[j]=NULL; 309 } 310 int32_t totalRules=0; 311 while((totalRules<MAX_EQ_COL) && (testEquRules[i][totalRules].length()>0) ) { 312 rules[totalRules]=test->createRules(testEquRules[i][totalRules], status); 313 totalRules++; 314 } 315 for (int32_t n=0; n<300 && ret ; ++n) { 316 for(int32_t j=0; j<totalRules;++j) { 317 key[j] = rules[j]->select(n); 318 } 319 for(int32_t j=0; j<totalRules-1;++j) { 320 if (key[j]!=key[j+1]) { 321 ret= FALSE; 322 break; 323 } 324 } 325 326 } 327 for (int32_t j=0; j<MAX_EQ_COL; ++j) { 328 if (rules[j]!=NULL) { 329 delete rules[j]; 330 } 331 } 332 } 333 334 return ret; 335 } 336 #endif /* #if !UCONFIG_NO_FORMATTING */ 337 338
