icuSources/test/intltest/plurfmts.cpp

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