1 /******************************************************************** 2 * COPYRIGHT: 3 * Copyright (c) 2007-2012, International Business Machines Corporation and 4 * others. All Rights Reserved. 5 ********************************************************************/ 6 7 #include "unicode/utypes.h" 8 9 #if !UCONFIG_NO_FORMATTING 10 11 #include "plurults.h" 12 #include "plurfmts.h" 13 #include "cmemory.h" 14 #include "unicode/msgfmt.h" 15 #include "unicode/plurrule.h" 16 #include "unicode/plurfmt.h" 17 18 #define PLURAL_PATTERN_DATA 4 19 #define PLURAL_TEST_ARRAY_SIZE 256 20 21 #define PLURAL_SYNTAX_DATA 8 22 23 // The value must be same as PLKeywordLookups[] order. 24 #define PFT_ZERO 0 25 #define PFT_ONE 1 26 #define PFT_TWO 2 27 #define PFT_FEW 3 28 #define PFT_MANY 4 29 #define PFT_OTHER 5 30 31 void PluralFormatTest::runIndexedTest( int32_t index, UBool exec, const char* &name, char* /*par*/ ) 32 { 33 if (exec) logln("TestSuite PluralFormat"); 34 TESTCASE_AUTO_BEGIN; 35 TESTCASE_AUTO(pluralFormatBasicTest); 36 TESTCASE_AUTO(pluralFormatUnitTest); 37 TESTCASE_AUTO(pluralFormatLocaleTest); 38 TESTCASE_AUTO(pluralFormatExtendedTest); 39 TESTCASE_AUTO(pluralFormatExtendedParseTest); 40 TESTCASE_AUTO(ordinalFormatTest); 41 TESTCASE_AUTO_END; 42 } 43 44 /** 45 * Test various generic API methods of PluralFormat for Basic usage. 46 */ 47 void PluralFormatTest::pluralFormatBasicTest(/*char *par*/) 48 { 49 UErrorCode status[8]; 50 PluralFormat* plFmt[8]; 51 Locale locale = Locale::getDefault(); 52 UnicodeString otherPattern = UnicodeString("other{#}"); 53 UnicodeString message=UnicodeString("ERROR: PluralFormat basic test"); 54 55 // ========= Test constructors 56 logln(" Testing PluralFormat constructors ..."); 57 status[0] = U_ZERO_ERROR; 58 PluralRules* plRules = PluralRules::createDefaultRules(status[0]); 59 60 status[0] = U_ZERO_ERROR; 61 NumberFormat *numFmt = NumberFormat::createInstance(status[0]); 62 if (U_FAILURE(status[0])) { 63 dataerrln("ERROR: Could not create NumberFormat instance with default locale "); 64 } 65 66 for (int32_t i=0; i< 8; ++i) { 67 status[i] = U_ZERO_ERROR; 68 } 69 plFmt[0] = new PluralFormat(status[0]); 70 plFmt[1] = new PluralFormat(*plRules, status[1]); 71 plFmt[2] = new PluralFormat(locale, status[2]); 72 plFmt[3] = new PluralFormat(locale, *plRules, status[3]); 73 plFmt[4] = new PluralFormat(otherPattern, status[4]); 74 plFmt[5] = new PluralFormat(*plRules, otherPattern, status[5]); 75 plFmt[6] = new PluralFormat(locale, otherPattern, status[6]); 76 plFmt[7] = new PluralFormat(locale, *plRules, otherPattern, status[7]); 77 78 for (int32_t i=0; i< 8; ++i) { 79 if (U_SUCCESS(status[i])) { 80 numberFormatTest(plFmt[i], numFmt, 1, 12, NULL, NULL, FALSE, &message); 81 numberFormatTest(plFmt[i], numFmt, 100, 112, NULL, NULL, FALSE, &message); 82 } 83 else { 84 dataerrln("ERROR: PluralFormat constructor failed!"); 85 } 86 delete plFmt[i]; 87 } 88 // ======= Test clone, assignment operator && == operator. 89 plFmt[0]= new PluralFormat(status[0]); 90 plFmt[0]->setNumberFormat(numFmt,status[0]); 91 UnicodeString us = UnicodeString(""); 92 plFmt[0]->toPattern(us); 93 plFmt[1]= new PluralFormat(locale, status[1]); 94 if ( U_SUCCESS(status[0]) && U_SUCCESS(status[1]) ) { 95 *plFmt[1] = *plFmt[0]; 96 if (plFmt[1]!=NULL) { 97 if ( *plFmt[1] != *plFmt[0] ) { 98 errln("ERROR: clone plural format test failed!"); 99 } 100 } 101 } 102 else { 103 dataerrln("ERROR: PluralFormat constructor failed! - [0]%s [1]%s", u_errorName(status[0]), u_errorName(status[1])); 104 } 105 delete plFmt[0]; 106 107 status[0] = U_ZERO_ERROR; 108 plFmt[0]= new PluralFormat(locale, status[0]); 109 if ( U_SUCCESS(status[0]) ) { 110 *plFmt[1] = *plFmt[0]; 111 if (plFmt[1]!=NULL) { 112 if ( *plFmt[1] != *plFmt[0] ) { 113 errln("ERROR: assignment operator test failed!"); 114 } 115 } 116 } 117 else { 118 dataerrln("ERROR: PluralFormat constructor failed! - %s", u_errorName(status[1])); 119 } 120 121 if ( U_SUCCESS(status[1]) ) { 122 plFmt[2] = (PluralFormat*) plFmt[1]->clone(); 123 124 if (plFmt[1]!=NULL) { 125 if ( *plFmt[1] != *plFmt[2] ) { 126 errln("ERROR: clone function test failed!"); 127 } 128 } 129 delete plFmt[1]; 130 delete plFmt[2]; 131 } 132 else { 133 dataerrln("ERROR: PluralFormat clone failed! - %s", u_errorName(status[1])); 134 } 135 136 delete plFmt[0]; 137 delete numFmt; 138 delete plRules; 139 140 // Tests parseObject 141 UErrorCode stat = U_ZERO_ERROR; 142 PluralFormat *pf = new PluralFormat(stat); 143 Formattable *f = new Formattable(); 144 ParsePosition *pp = new ParsePosition(); 145 pf->parseObject((UnicodeString)"",*f,*pp); 146 if(U_FAILURE(stat)) { 147 dataerrln("ERROR: PluralFormat::parseObject: %s", u_errorName(stat)); 148 } 149 delete pf; 150 delete f; 151 delete pp; 152 } 153 154 /** 155 * Unit tests of PluralFormat class. 156 */ 157 void PluralFormatTest::pluralFormatUnitTest(/*char *par*/) 158 { 159 UnicodeString patternTestData[PLURAL_PATTERN_DATA] = { 160 UNICODE_STRING_SIMPLE("odd {# is odd.} other{# is even.}"), 161 UNICODE_STRING_SIMPLE("other{# is odd or even.}"), 162 UNICODE_STRING_SIMPLE("odd{The number {0, number, #.#0} is odd.}other{The number {0, number, #.#0} is even.}"), 163 UNICODE_STRING_SIMPLE("odd{The number {1, number, #} is odd.}other{The number {2, number, #} is even.}"), 164 }; 165 UnicodeString patternOddTestResult[PLURAL_PATTERN_DATA] = { 166 UNICODE_STRING_SIMPLE(" is odd."), 167 UNICODE_STRING_SIMPLE(" is odd or even."), 168 UNICODE_STRING_SIMPLE("The number {0, number, #.#0} is odd."), 169 UNICODE_STRING_SIMPLE("The number {1, number, #} is odd."), 170 }; 171 UnicodeString patternEvenTestResult[PLURAL_PATTERN_DATA] = { 172 UNICODE_STRING_SIMPLE(" is even."), 173 UNICODE_STRING_SIMPLE(" is odd or even."), 174 UNICODE_STRING_SIMPLE("The number {0, number, #.#0} is even."), 175 UNICODE_STRING_SIMPLE("The number {2, number, #} is even."), 176 }; 177 UnicodeString checkSyntaxtData[PLURAL_SYNTAX_DATA] = { 178 // ICU 4.8 does not check for duplicate keywords any more. 179 //UNICODE_STRING_SIMPLE("odd{foo} odd{bar} other{foobar}"), 180 //UNICODE_STRING_SIMPLE("odd{foo} other{bar} other{foobar}"), 181 UNICODE_STRING_SIMPLE("odd{foo}"), 182 // ICU 4.8 does not check for unknown keywords any more. 183 //UNICODE_STRING_SIMPLE("otto{foo} other{bar}"), 184 UNICODE_STRING_SIMPLE("*odd{foo} other{bar}"), 185 UNICODE_STRING_SIMPLE("odd{foo},other{bar}"), 186 UNICODE_STRING_SIMPLE("od d{foo} other{bar}"), 187 UNICODE_STRING_SIMPLE("odd{foo}{foobar}other{foo}"), 188 }; 189 190 UErrorCode status = U_ZERO_ERROR; 191 UnicodeString oddAndEvenRule = UNICODE_STRING_SIMPLE("odd: n mod 2 is 1"); 192 PluralRules* plRules = PluralRules::createRules(oddAndEvenRule, status); 193 if (U_FAILURE(status)) { 194 dataerrln("ERROR: create PluralRules instance failed in unit tests.- exitting"); 195 return; 196 } 197 198 // ======= Test PluralRules pattern syntax. 199 logln("Testing PluralRules pattern syntax."); 200 for (int32_t i=0; i<PLURAL_SYNTAX_DATA; ++i) { 201 status = U_ZERO_ERROR; 202 203 PluralFormat plFmt=PluralFormat(*plRules, status); 204 if (U_FAILURE(status)) { 205 dataerrln("ERROR: PluralFormat constructor failed in unit tests.- exitting"); 206 return; 207 } 208 plFmt.applyPattern(checkSyntaxtData[i], status); 209 if (U_SUCCESS(status)) { 210 errln("ERROR: PluralFormat failed to detect syntax error with pattern: "+checkSyntaxtData[i]); 211 } 212 } 213 214 215 216 // ======= Test applying various pattern 217 logln("Testing various patterns"); 218 status = U_ZERO_ERROR; 219 UBool overwrite[PLURAL_PATTERN_DATA] = {FALSE, FALSE, TRUE, TRUE}; 220 221 NumberFormat *numFmt = NumberFormat::createInstance(status); 222 UnicodeString message=UnicodeString("ERROR: PluralFormat tests various pattern ..."); 223 if (U_FAILURE(status)) { 224 dataerrln("ERROR: Could not create NumberFormat instance with default locale "); 225 } 226 for(int32_t i=0; i<PLURAL_PATTERN_DATA; ++i) { 227 status = U_ZERO_ERROR; 228 PluralFormat plFmt=PluralFormat(*plRules, status); 229 if (U_FAILURE(status)) { 230 dataerrln("ERROR: PluralFormat constructor failed in unit tests.- exitting"); 231 return; 232 } 233 plFmt.applyPattern(patternTestData[i], status); 234 if (U_FAILURE(status)) { 235 errln("ERROR: PluralFormat failed to apply pattern- "+patternTestData[i]); 236 continue; 237 } 238 numberFormatTest(&plFmt, numFmt, 1, 10, (UnicodeString *)&patternOddTestResult[i], 239 (UnicodeString *)&patternEvenTestResult[i], overwrite[i], &message); 240 } 241 delete plRules; 242 delete numFmt; 243 244 // ======= Test set locale 245 status = U_ZERO_ERROR; 246 plRules = PluralRules::createRules(UNICODE_STRING_SIMPLE("odd: n mod 2 is 1"), status); 247 PluralFormat pluralFmt = PluralFormat(*plRules, status); 248 if (U_FAILURE(status)) { 249 dataerrln("ERROR: Could not create PluralFormat instance in setLocale() test - exitting. "); 250 delete plRules; 251 return; 252 } 253 pluralFmt.applyPattern(UNICODE_STRING_SIMPLE("odd{odd} other{even}"), status); 254 pluralFmt.setLocale(Locale::getEnglish(), status); 255 if (U_FAILURE(status)) { 256 dataerrln("ERROR: Could not setLocale() with English locale "); 257 delete plRules; 258 return; 259 } 260 message = UNICODE_STRING_SIMPLE("Error set locale: pattern is not reset!"); 261 262 // Check that pattern gets deleted. 263 logln("\n Test setLocale() ..\n"); 264 numFmt = NumberFormat::createInstance(Locale::getEnglish(), status); 265 if (U_FAILURE(status)) { 266 dataerrln("ERROR: Could not create NumberFormat instance with English locale "); 267 } 268 numberFormatTest(&pluralFmt, numFmt, 5, 5, NULL, NULL, FALSE, &message); 269 pluralFmt.applyPattern(UNICODE_STRING_SIMPLE("odd__{odd} other{even}"), status); 270 if (pluralFmt.format((int32_t)1, status) != UNICODE_STRING_SIMPLE("even")) { 271 errln("SetLocale should reset rules but did not."); 272 } 273 status = U_ZERO_ERROR; 274 pluralFmt.applyPattern(UNICODE_STRING_SIMPLE("one{one} other{not one}"), status); 275 if (U_FAILURE(status)) { 276 errln("SetLocale should reset rules but did not."); 277 } 278 UnicodeString one = UNICODE_STRING_SIMPLE("one"); 279 UnicodeString notOne = UNICODE_STRING_SIMPLE("not one"); 280 UnicodeString plResult, numResult; 281 for (int32_t i=0; i<20; ++i) { 282 plResult = pluralFmt.format(i, status); 283 if ( i==1 ) { 284 numResult = one; 285 } 286 else { 287 numResult = notOne; 288 } 289 if ( numResult != plResult ) { 290 errln("Wrong ruleset loaded by setLocale() - got:"+plResult+ UnicodeString(" expecting:")+numResult); 291 } 292 } 293 294 // =========== Test copy constructor 295 logln("Test copy constructor and == operator of PluralFormat"); 296 PluralFormat dupPFmt = PluralFormat(pluralFmt); 297 if (pluralFmt != dupPFmt) { 298 errln("Failed in PluralFormat copy constructor or == operator"); 299 } 300 301 delete plRules; 302 delete numFmt; 303 } 304 305 306 307 /** 308 * Test locale data used in PluralFormat class. 309 */ 310 void 311 PluralFormatTest::pluralFormatLocaleTest(/*char *par*/) 312 { 313 int8_t pluralResults[PLURAL_TEST_ARRAY_SIZE]; // 0: is for default 314 315 // ======= Test DefaultRule 316 logln("Testing PluralRules with no rule."); 317 const char* oneRuleLocales[4] = {"ja", "ko", "tr", "vi"}; 318 UnicodeString testPattern = UNICODE_STRING_SIMPLE("other{other}"); 319 uprv_memset(pluralResults, -1, sizeof(pluralResults)); 320 pluralResults[0]= PFT_OTHER; // other 321 helperTestResults(oneRuleLocales, 4, testPattern, pluralResults); 322 323 // ====== Test Singular1 locales. 324 logln("Testing singular1 locales."); 325 const char* singular1Locales[52] = {"bem","da","de","el","en","eo","es","et","fi", 326 "fo","gl","he","it","nb","nl","nn","no","pt","pt_PT","sv","af","bg","bn","ca","eu","fur","fy", 327 "gu","ha","is","ku","lb","ml","mr","nah","ne","om","or","pa","pap","ps","so","sq","sw","ta", 328 "te","tk","ur","zu","mn","gsw","rm"}; 329 testPattern = UNICODE_STRING_SIMPLE("one{one} other{other}"); 330 uprv_memset(pluralResults, -1, sizeof(pluralResults)); 331 pluralResults[0]= PFT_OTHER; 332 pluralResults[1]= PFT_ONE; 333 pluralResults[2]= PFT_OTHER; 334 helperTestResults(singular1Locales, 52, testPattern, pluralResults); 335 336 // ======== Test Singular01 locales. 337 logln("Testing singular1 locales."); 338 const char* singular01Locales[3] = {"ff","fr","kab"}; 339 testPattern = UNICODE_STRING_SIMPLE("one{one} other{other}"); 340 uprv_memset(pluralResults, -1, sizeof(pluralResults)); 341 pluralResults[0]= PFT_ONE; 342 pluralResults[2]= PFT_OTHER; 343 helperTestResults(singular01Locales, 3, testPattern, pluralResults); 344 345 // ======== Test ZeroSingular locales. 346 logln("Testing singular1 locales."); 347 const char* zeroSingularLocales[1] = {"lv"}; 348 testPattern = UNICODE_STRING_SIMPLE("zero{zero} one{one} other{other}"); 349 uprv_memset(pluralResults, -1, sizeof(pluralResults)); 350 pluralResults[0]= PFT_ZERO; 351 pluralResults[1]= PFT_ONE; 352 pluralResults[2]= PFT_OTHER; 353 for (int32_t i=2; i<20; ++i) { 354 if (i==11) continue; 355 pluralResults[i*10+1] = PFT_ONE; 356 pluralResults[i*10+2] = PFT_OTHER; 357 } 358 helperTestResults(zeroSingularLocales, 1, testPattern, pluralResults); 359 360 // ======== Test singular dual locales. 361 logln("Testing singular1 locales."); 362 const char* singularDualLocales[1] = {"ga"}; 363 testPattern = UNICODE_STRING_SIMPLE("one{one} two{two} other{other}"); 364 uprv_memset(pluralResults, -1, sizeof(pluralResults)); 365 pluralResults[0]= PFT_OTHER; 366 pluralResults[1]= PFT_ONE; 367 pluralResults[2]= PFT_TWO; 368 pluralResults[3]= PFT_OTHER; 369 helperTestResults(singularDualLocales, 1, testPattern, pluralResults); 370 371 // ======== Test Singular Zero Some locales. 372 logln("Testing singular1 locales."); 373 const char* singularZeroSomeLocales[1] = {"ro"}; 374 testPattern = UNICODE_STRING_SIMPLE("few{few} one{one} other{other}"); 375 uprv_memset(pluralResults, -1, sizeof(pluralResults)); 376 pluralResults[0]= PFT_FEW; 377 for (int32_t i=1; i<20; ++i) { 378 if (i==11) continue; 379 pluralResults[i] = PFT_FEW; 380 pluralResults[100+i] = PFT_FEW; 381 } 382 pluralResults[1]= PFT_ONE; 383 helperTestResults(singularZeroSomeLocales, 1, testPattern, pluralResults); 384 385 // ======== Test Special 12/19. 386 logln("Testing special 12 and 19."); 387 const char* special12_19Locales[1] = {"lt"}; 388 testPattern = UNICODE_STRING_SIMPLE("one{one} few{few} other{other}"); 389 uprv_memset(pluralResults, -1, sizeof(pluralResults)); 390 pluralResults[0]= PFT_OTHER; 391 pluralResults[1]= PFT_ONE; 392 pluralResults[2]= PFT_FEW; 393 pluralResults[10]= PFT_OTHER; 394 for (int32_t i=2; i<20; ++i) { 395 if (i==11) continue; 396 pluralResults[i*10+1] = PFT_ONE; 397 pluralResults[i*10+2] = PFT_FEW; 398 pluralResults[(i+1)*10] = PFT_OTHER; 399 } 400 helperTestResults(special12_19Locales, 1, testPattern, pluralResults); 401 402 // ======== Test Paucal Except 11 14. 403 logln("Testing Paucal Except 11 and 14."); 404 const char* paucal01Locales[4] = {"hr","ru","sr","uk"}; 405 testPattern = UNICODE_STRING_SIMPLE("one{one} many{many} few{few} other{other}"); 406 uprv_memset(pluralResults, -1, sizeof(pluralResults)); 407 pluralResults[0]= PFT_MANY; 408 pluralResults[1]= PFT_ONE; 409 pluralResults[2]= PFT_FEW; 410 pluralResults[5]= PFT_MANY; 411 pluralResults[6]= PFT_MANY; 412 pluralResults[7]= PFT_MANY; 413 pluralResults[8]= PFT_MANY; 414 pluralResults[9]= PFT_MANY; 415 for (int32_t i=2; i<20; ++i) { 416 if (i==11) continue; 417 pluralResults[i*10+1] = PFT_ONE; 418 pluralResults[i*10+2] = PFT_FEW; 419 pluralResults[i*10+5] = PFT_MANY; 420 pluralResults[i*10+6] = PFT_MANY; 421 pluralResults[i*10+7] = PFT_MANY; 422 pluralResults[i*10+8] = PFT_MANY; 423 pluralResults[i*10+9] = PFT_MANY; 424 } 425 helperTestResults(paucal01Locales, 4, testPattern, pluralResults); 426 427 // ======== Test Singular Paucal. 428 logln("Testing Singular Paucal."); 429 const char* singularPaucalLocales[2] = {"cs","sk"}; 430 testPattern = UNICODE_STRING_SIMPLE("one{one} few{few} other{other}"); 431 uprv_memset(pluralResults, -1, sizeof(pluralResults)); 432 pluralResults[0]= PFT_OTHER; 433 pluralResults[1]= PFT_ONE; 434 pluralResults[2]= PFT_FEW; 435 pluralResults[5]= PFT_OTHER; 436 helperTestResults(singularPaucalLocales, 2, testPattern, pluralResults); 437 438 // ======== Test Paucal (1), (2,3,4). 439 logln("Testing Paucal (1), (2,3,4)."); 440 const char* paucal02Locales[1] = {"pl"}; 441 testPattern = UNICODE_STRING_SIMPLE("one{one} few{few} other{other}"); 442 uprv_memset(pluralResults, -1, sizeof(pluralResults)); 443 pluralResults[0]= PFT_OTHER; 444 pluralResults[1]= PFT_ONE; 445 pluralResults[5]= PFT_OTHER; 446 for (int32_t i=0; i<20; ++i) { 447 if ((i==1)||(i==11)) { 448 pluralResults[i*10+2] = PFT_OTHER; 449 pluralResults[i*10+3] = PFT_OTHER; 450 pluralResults[i*10+4] = PFT_OTHER; 451 } 452 else { 453 pluralResults[i*10+2] = PFT_FEW; 454 pluralResults[i*10+3] = PFT_FEW; 455 pluralResults[i*10+4] = PFT_FEW; 456 pluralResults[i*10+5] = PFT_OTHER; 457 } 458 } 459 helperTestResults(paucal02Locales, 1, testPattern, pluralResults); 460 461 // ======== Test Paucal (1), (2), (3,4). 462 logln("Testing Paucal (1), (2), (3,4)."); 463 const char* paucal03Locales[1] = {"sl"}; 464 testPattern = UNICODE_STRING_SIMPLE("one{one} two{two} few{few} other{other}"); 465 uprv_memset(pluralResults, -1, sizeof(pluralResults)); 466 pluralResults[0]= PFT_OTHER; 467 pluralResults[1]= PFT_ONE; 468 pluralResults[2]= PFT_TWO; 469 pluralResults[3]= PFT_FEW; 470 pluralResults[5]= PFT_OTHER; 471 pluralResults[101]= PFT_ONE; 472 pluralResults[102]= PFT_TWO; 473 pluralResults[103]= PFT_FEW; 474 pluralResults[105]= PFT_OTHER; 475 helperTestResults(paucal03Locales, 1, testPattern, pluralResults); 476 477 // TODO: move this test to Unit Test after CLDR 1.6 is final and we support float 478 // ======= Test French "WITHIN rule 479 logln("Testing PluralRules with fr rule."); 480 testPattern = UNICODE_STRING_SIMPLE("one{one} other{other}"); 481 Locale ulocale((const char *)"fr"); 482 UErrorCode status = U_ZERO_ERROR; 483 PluralFormat plFmt(ulocale, testPattern, status); 484 if (U_FAILURE(status)) { 485 dataerrln("Failed to apply pattern to fr locale - %s", u_errorName(status)); 486 } 487 else { 488 status = U_ZERO_ERROR; 489 UnicodeString plResult = plFmt.format(0.0, status); // retrun ONE 490 plResult = plFmt.format(0.5, status); // retrun ONE 491 plResult = plFmt.format(1.0, status); // retrun ONE 492 plResult = plFmt.format(1.9, status); // retrun ONE 493 plResult = plFmt.format(2.0, status); // retrun OTHER 494 } 495 } 496 497 void 498 PluralFormatTest::pluralFormatExtendedTest(void) { 499 const char *targets[] = { 500 "There are no widgets.", 501 "There is one widget.", 502 "There is a bling widget and one other widget.", 503 "There is a bling widget and 2 other widgets.", 504 "There is a bling widget and 3 other widgets.", 505 "Widgets, five (5-1=4) there be.", 506 "There is a bling widget and 5 other widgets.", 507 "There is a bling widget and 6 other widgets.", 508 }; 509 510 const char* fmt = 511 "offset:1.0 " 512 "=0 {There are no widgets.} " 513 "=1.0 {There is one widget.} " 514 "=5 {Widgets, five (5-1=#) there be.} " 515 "one {There is a bling widget and one other widget.} " 516 "other {There is a bling widget and # other widgets.}"; 517 518 UErrorCode status = U_ZERO_ERROR; 519 UnicodeString fmtString(fmt, -1, US_INV); 520 PluralFormat pf(Locale::getEnglish(), fmtString, status); 521 MessageFormat mf(UNICODE_STRING_SIMPLE("{0,plural,").append(fmtString).append((UChar)0x7d /* '}' */), 522 Locale::getEnglish(), status); 523 Formattable args; 524 FieldPosition ignore; 525 if (U_FAILURE(status)) { 526 dataerrln("Failed to apply pattern - %s", u_errorName(status)); 527 return; 528 } 529 for (int32_t i = 0; i < 7; ++i) { 530 UnicodeString result = pf.format(i, status); 531 if (U_FAILURE(status)) { 532 errln("PluralFormat.format(value %d) failed - %s", i, u_errorName(status)); 533 return; 534 } 535 UnicodeString expected(targets[i], -1, US_INV); 536 if (expected != result) { 537 UnicodeString message("PluralFormat.format(): Expected '", -1, US_INV); 538 message.append(expected); 539 message.append(UnicodeString("' but got '", -1, US_INV)); 540 message.append(result); 541 message.append("'", -1, US_INV); 542 errln(message); 543 } 544 args.setLong(i); 545 mf.format(&args, 1, result.remove(), ignore, status); 546 if (U_FAILURE(status)) { 547 errln("MessageFormat.format(value %d) failed - %s", i, u_errorName(status)); 548 return; 549 } 550 if (expected != result) { 551 UnicodeString message("MessageFormat.format(): Expected '", -1, US_INV); 552 message.append(expected); 553 message.append(UnicodeString("' but got '", -1, US_INV)); 554 message.append(result); 555 message.append("'", -1, US_INV); 556 errln(message); 557 } 558 } 559 } 560 561 void 562 PluralFormatTest::pluralFormatExtendedParseTest(void) { 563 const char *failures[] = { 564 "offset:1..0 =0 {Foo}", 565 "offset:1.0 {Foo}", 566 "=0= {Foo}", 567 "=0 {Foo} =0.0 {Bar}", 568 " = {Foo}", 569 }; 570 int len = sizeof(failures)/sizeof(failures[0]); 571 572 for (int i = 0; i < len; ++i) { 573 UErrorCode status = U_ZERO_ERROR; 574 UnicodeString fmt(failures[i], -1, US_INV); 575 PluralFormat pf(fmt, status); 576 if (U_SUCCESS(status)) { 577 errln("expected failure when parsing '" + fmt + "'"); 578 } 579 } 580 } 581 582 void 583 PluralFormatTest::ordinalFormatTest(void) { 584 IcuTestErrorCode errorCode(*this, "ordinalFormatTest"); 585 UnicodeString pattern("one{#st file}two{#nd file}few{#rd file}other{#th file}"); 586 PluralFormat pf(Locale::getEnglish(), UPLURAL_TYPE_ORDINAL, pattern, errorCode); 587 if (errorCode.logDataIfFailureAndReset("PluralFormat(en, UPLURAL_TYPE_ORDINAL, pattern) failed")) { 588 return; 589 } 590 UnicodeString result = pf.format((int32_t)321, errorCode); 591 if (!errorCode.logIfFailureAndReset("PluralFormat.format(321) failed") && 592 result != UNICODE_STRING_SIMPLE("321st file")) { 593 errln(UnicodeString("PluralFormat.format(321) wrong result string: ") + result); 594 } 595 result = pf.format((int32_t)22, errorCode); 596 if (!errorCode.logIfFailureAndReset("PluralFormat.format(22) failed") && 597 result != UNICODE_STRING_SIMPLE("22nd file")) { 598 errln(UnicodeString("PluralFormat.format(22) wrong result string: ") + result); 599 } 600 result = pf.format((int32_t)3, errorCode); 601 if (!errorCode.logIfFailureAndReset("PluralFormat.format(3) failed") && 602 result != UNICODE_STRING_SIMPLE("3rd file")) { 603 errln(UnicodeString("PluralFormat.format(3) wrong result string: ") + result); 604 } 605 606 // Code coverage: Use the other new-for-UPluralType constructor as well. 607 PluralFormat pf2(Locale::getEnglish(), UPLURAL_TYPE_ORDINAL, errorCode); 608 pf2.applyPattern(pattern, errorCode); 609 if (errorCode.logIfFailureAndReset("PluralFormat(en, UPLURAL_TYPE_ORDINAL, pattern) failed")) { 610 return; 611 } 612 result = pf2.format((int32_t)456, errorCode); 613 if (!errorCode.logIfFailureAndReset("PluralFormat.format(456) failed") && 614 result != UNICODE_STRING_SIMPLE("456th file")) { 615 errln(UnicodeString("PluralFormat.format(456) wrong result string: ") + result); 616 } 617 result = pf2.format((int32_t)111, errorCode); 618 if (!errorCode.logIfFailureAndReset("PluralFormat.format(111) failed") && 619 result != UNICODE_STRING_SIMPLE("111th file")) { 620 errln(UnicodeString("PluralFormat.format(111) wrong result string: ") + result); 621 } 622 } 623 624 void 625 PluralFormatTest::numberFormatTest(PluralFormat* plFmt, 626 NumberFormat *numFmt, 627 int32_t start, 628 int32_t end, 629 UnicodeString *numOddAppendStr, 630 UnicodeString *numEvenAppendStr, 631 UBool overwrite, // overwrite the numberFormat.format result 632 UnicodeString *message) { 633 UErrorCode status = U_ZERO_ERROR; 634 635 if ( (plFmt==NULL) || (numFmt==NULL) ) { 636 dataerrln("ERROR: Could not create PluralFormat or NumberFormat - exitting"); 637 return; 638 } 639 UnicodeString plResult, numResult ; 640 641 for (int32_t i=start; i<= end; ++i ) { 642 numResult.remove(); 643 numResult = numFmt->format(i, numResult); 644 plResult = plFmt->format(i, status); 645 if ((numOddAppendStr!= NULL)&&(numEvenAppendStr!=NULL)) { 646 if (overwrite) { 647 if (i&1) { 648 numResult = *numOddAppendStr; 649 } 650 else { 651 numResult = *numEvenAppendStr; 652 } 653 } 654 else { // Append the string 655 if (i&1) { 656 numResult += *numOddAppendStr; 657 } 658 else{ 659 numResult += *numEvenAppendStr; 660 } 661 } 662 } 663 if ( (numResult!=plResult) || U_FAILURE(status) ) { 664 if ( message == NULL ) { 665 errln("ERROR: Unexpected plural format - got:"+plResult+ UnicodeString(" expecting:")+numResult); 666 } 667 else { 668 errln( *message+UnicodeString(" got:")+plResult+UnicodeString(" expecting:")+numResult); 669 670 } 671 } 672 } 673 return; 674 } 675 676 677 void 678 PluralFormatTest::helperTestResults(const char** localeArray, 679 int32_t capacityOfArray, 680 UnicodeString& testPattern, 681 int8_t *expResults) { 682 UErrorCode status; 683 UnicodeString plResult; 684 const UnicodeString PLKeywordLookups[6] = { 685 UNICODE_STRING_SIMPLE("zero"), 686 UNICODE_STRING_SIMPLE("one"), 687 UNICODE_STRING_SIMPLE("two"), 688 UNICODE_STRING_SIMPLE("few"), 689 UNICODE_STRING_SIMPLE("many"), 690 UNICODE_STRING_SIMPLE("other"), 691 }; 692 693 for (int32_t i=0; i<capacityOfArray; ++i) { 694 const char *locale = localeArray[i]; 695 Locale ulocale((const char *)locale); 696 status = U_ZERO_ERROR; 697 PluralFormat plFmt(ulocale, testPattern, status); 698 if (U_FAILURE(status)) { 699 dataerrln("Failed to apply pattern to locale:"+UnicodeString(localeArray[i]) + " - " + u_errorName(status)); 700 continue; 701 } 702 for (int32_t n=0; n<PLURAL_TEST_ARRAY_SIZE; ++n) { 703 if (expResults[n]!=-1) { 704 status = U_ZERO_ERROR; 705 plResult = plFmt.format(n, status); 706 if (U_FAILURE(status)) { 707 errln("ERROR: Failed to format number in locale data tests with locale: "+ 708 UnicodeString(localeArray[i])); 709 } 710 if (plResult != PLKeywordLookups[expResults[n]]){ 711 plResult = plFmt.format(n, status); 712 errln("ERROR: Unexpected format result in locale: "+UnicodeString(localeArray[i])+ 713 UnicodeString(" got:")+plResult+ UnicodeString(" expecting:")+ 714 PLKeywordLookups[expResults[n]]); 715 } 716 } 717 } 718 } 719 } 720 721 #endif /* #if !UCONFIG_NO_FORMATTING */ 722
