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
runIndexedTest(int32_t index,UBool exec,const char * & name,char *)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 */
pluralFormatBasicTest()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 */
pluralFormatUnitTest()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
pluralFormatLocaleTest()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
pluralFormatExtendedTest(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
pluralFormatExtendedParseTest(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
ordinalFormatTest(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
numberFormatTest(PluralFormat * plFmt,NumberFormat * numFmt,int32_t start,int32_t end,UnicodeString * numOddAppendStr,UnicodeString * numEvenAppendStr,UBool overwrite,UnicodeString * message)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
helperTestResults(const char ** localeArray,int32_t capacityOfArray,UnicodeString & testPattern,int8_t * expResults)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