1 /********************************************************************
2 * COPYRIGHT:
3 * Copyright (c) 2007-2010, 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/plurrule.h"
15 #include "unicode/plurfmt.h"
16
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 switch (index) {
35 TESTCASE(0, pluralFormatBasicTest);
36 TESTCASE(1, pluralFormatUnitTest);
37 TESTCASE(2, pluralFormatLocaleTest);
38 default: name = "";
39 break;
40 }
41 }
42
43 /**
44 * Test various generic API methods of PluralFormat for Basic usage.
45 */
pluralFormatBasicTest()46 void PluralFormatTest::pluralFormatBasicTest(/*char *par*/)
47 {
48 UErrorCode status[8];
49 PluralFormat* plFmt[8];
50 Locale locale = Locale::getDefault();
51 UnicodeString otherPattern = UnicodeString("other{#}");
52 UnicodeString message=UnicodeString("ERROR: PluralFormat basic test");
53
54 // ========= Test constructors
55 logln(" Testing PluralFormat constructors ...");
56 status[0] = U_ZERO_ERROR;
57 PluralRules* plRules = PluralRules::createDefaultRules(status[0]);
58
59 status[0] = U_ZERO_ERROR;
60 NumberFormat *numFmt = NumberFormat::createInstance(status[0]);
61 if (U_FAILURE(status[0])) {
62 dataerrln("ERROR: Could not create NumberFormat instance with default locale ");
63 }
64
65 for (int32_t i=0; i< 8; ++i) {
66 status[i] = U_ZERO_ERROR;
67 }
68 plFmt[0] = new PluralFormat(status[0]);
69 plFmt[1] = new PluralFormat(*plRules, status[1]);
70 plFmt[2] = new PluralFormat(locale, status[2]);
71 plFmt[3] = new PluralFormat(locale, *plRules, status[3]);
72 plFmt[4] = new PluralFormat(otherPattern, status[4]);
73 plFmt[5] = new PluralFormat(*plRules, otherPattern, status[5]);
74 plFmt[6] = new PluralFormat(locale, otherPattern, status[6]);
75 plFmt[7] = new PluralFormat(locale, *plRules, otherPattern, status[7]);
76
77 for (int32_t i=0; i< 8; ++i) {
78 if (U_SUCCESS(status[i])) {
79 numberFormatTest(plFmt[i], numFmt, 1, 12, NULL, NULL, FALSE, &message);
80 numberFormatTest(plFmt[i], numFmt, 100, 112, NULL, NULL, FALSE, &message);
81 }
82 else {
83 dataerrln("ERROR: PluralFormat constructor failed!");
84 }
85 delete plFmt[i];
86 }
87 // ======= Test clone, assignment operator && == operator.
88 plFmt[0]= new PluralFormat(status[0]);
89 plFmt[0]->setNumberFormat(numFmt,status[0]);
90 UnicodeString us = UnicodeString("");
91 plFmt[0]->toPattern(us);
92 plFmt[1]= new PluralFormat(locale, status[1]);
93 if ( U_SUCCESS(status[0]) && U_SUCCESS(status[1]) ) {
94 *plFmt[1] = *plFmt[0];
95 if (plFmt[1]!=NULL) {
96 if ( *plFmt[1] != *plFmt[0] ) {
97 errln("ERROR: clone plural format test failed!");
98 }
99 }
100 }
101 else {
102 dataerrln("ERROR: PluralFormat constructor failed! - [0]%s [1]%s", u_errorName(status[0]), u_errorName(status[1]));
103 }
104 delete plFmt[0];
105
106 status[0] = U_ZERO_ERROR;
107 plFmt[0]= new PluralFormat(locale, status[0]);
108 if ( U_SUCCESS(status[0]) ) {
109 *plFmt[1] = *plFmt[0];
110 if (plFmt[1]!=NULL) {
111 if ( *plFmt[1] != *plFmt[0] ) {
112 errln("ERROR: assignment operator test failed!");
113 }
114 }
115 }
116 else {
117 dataerrln("ERROR: PluralFormat constructor failed! - %s", u_errorName(status[1]));
118 }
119
120 if ( U_SUCCESS(status[1]) ) {
121 plFmt[2] = (PluralFormat*) plFmt[1]->clone();
122
123 if (plFmt[1]!=NULL) {
124 if ( *plFmt[1] != *plFmt[2] ) {
125 errln("ERROR: clone function test failed!");
126 }
127 }
128 delete plFmt[1];
129 delete plFmt[2];
130 }
131 else {
132 dataerrln("ERROR: PluralFormat clone failed! - %s", u_errorName(status[1]));
133 }
134
135 delete plFmt[0];
136 delete numFmt;
137 delete plRules;
138
139 // Tests parseObject
140 UErrorCode stat = U_ZERO_ERROR;
141 PluralFormat *pf = new PluralFormat(stat);
142 Formattable *f = new Formattable();
143 ParsePosition *pp = new ParsePosition();
144 pf->parseObject((UnicodeString)"",*f,*pp);
145 if(U_FAILURE(stat)) {
146 dataerrln("ERROR: PluralFormat::parseObject: %s", u_errorName(stat));
147 }
148 delete pf;
149 delete f;
150 delete pp;
151 }
152
153 /**
154 * Unit tests of PluralFormat class.
155 */
pluralFormatUnitTest()156 void PluralFormatTest::pluralFormatUnitTest(/*char *par*/)
157 {
158 UnicodeString patternTestData[PLURAL_PATTERN_DATA] = {
159 UNICODE_STRING_SIMPLE("odd {# is odd.} other{# is even.}"),
160 UNICODE_STRING_SIMPLE("other{# is odd or even.}"),
161 UNICODE_STRING_SIMPLE("odd{The number {0, number, #.#0} is odd.}other{The number {0, number, #.#0} is even.}"),
162 UNICODE_STRING_SIMPLE("odd{The number {#} is odd.}other{The number {#} is even.}"),
163 };
164 UnicodeString patternOddTestResult[PLURAL_PATTERN_DATA] = {
165 UNICODE_STRING_SIMPLE(" is odd."),
166 UNICODE_STRING_SIMPLE(" is odd or even."),
167 UNICODE_STRING_SIMPLE("The number {0, number, #.#0} is odd."),
168 UNICODE_STRING_SIMPLE("The number {#} is odd."),
169 };
170 UnicodeString patternEvenTestResult[PLURAL_PATTERN_DATA] = {
171 UNICODE_STRING_SIMPLE(" is even."),
172 UNICODE_STRING_SIMPLE(" is odd or even."),
173 UNICODE_STRING_SIMPLE("The number {0, number, #.#0} is even."),
174 UNICODE_STRING_SIMPLE("The number {#} is even."),
175 };
176 UnicodeString checkSyntaxtData[PLURAL_SYNTAX_DATA] = {
177 UNICODE_STRING_SIMPLE("odd{foo} odd{bar} other{foobar}"),
178 UNICODE_STRING_SIMPLE("odd{foo} other{bar} other{foobar}"),
179 UNICODE_STRING_SIMPLE("odd{foo}"),
180 UNICODE_STRING_SIMPLE("otto{foo} other{bar}"),
181 UNICODE_STRING_SIMPLE("1odd{foo} other{bar}"),
182 UNICODE_STRING_SIMPLE("odd{foo},other{bar}"),
183 UNICODE_STRING_SIMPLE("od d{foo} other{bar}"),
184 UNICODE_STRING_SIMPLE("odd{foo}{foobar}other{foo}"),
185 };
186
187 UErrorCode status = U_ZERO_ERROR;
188 UnicodeString oddAndEvenRule = UNICODE_STRING_SIMPLE("odd: n mod 2 is 1");
189 PluralRules* plRules = PluralRules::createRules(oddAndEvenRule, status);
190 if (U_FAILURE(status)) {
191 dataerrln("ERROR: create PluralRules instance failed in unit tests.- exitting");
192 return;
193 }
194
195 // ======= Test PluralRules pattern syntax.
196 logln("Testing PluralRules pattern syntax.");
197 for (int32_t i=0; i<PLURAL_SYNTAX_DATA; ++i) {
198 status = U_ZERO_ERROR;
199
200 PluralFormat plFmt=PluralFormat(*plRules, status);
201 if (U_FAILURE(status)) {
202 dataerrln("ERROR: PluralFormat constructor failed in unit tests.- exitting");
203 return;
204 }
205 plFmt.applyPattern(checkSyntaxtData[i], status);
206 if (U_SUCCESS(status)) {
207 errln("ERROR: PluralFormat failed to detect syntax error with pattern: "+checkSyntaxtData[i]);
208 }
209 }
210
211
212
213 // ======= Test applying various pattern
214 logln("Testing various patterns");
215 status = U_ZERO_ERROR;
216 UBool overwrite[PLURAL_PATTERN_DATA] = {FALSE, FALSE, TRUE, TRUE};
217
218 NumberFormat *numFmt = NumberFormat::createInstance(status);
219 UnicodeString message=UnicodeString("ERROR: PluralFormat tests various pattern ...");
220 if (U_FAILURE(status)) {
221 dataerrln("ERROR: Could not create NumberFormat instance with default locale ");
222 }
223 for(int32_t i=0; i<PLURAL_PATTERN_DATA; ++i) {
224 status = U_ZERO_ERROR;
225 PluralFormat plFmt=PluralFormat(*plRules, status);
226 if (U_FAILURE(status)) {
227 dataerrln("ERROR: PluralFormat constructor failed in unit tests.- exitting");
228 return;
229 }
230 plFmt.applyPattern(patternTestData[i], status);
231 if (U_FAILURE(status)) {
232 errln("ERROR: PluralFormat failed to apply pattern- "+patternTestData[i]);
233 continue;
234 }
235 numberFormatTest(&plFmt, numFmt, 1, 10, (UnicodeString *)&patternOddTestResult[i],
236 (UnicodeString *)&patternEvenTestResult[i], overwrite[i], &message);
237 }
238 delete plRules;
239 delete numFmt;
240
241 // ======= Test set locale
242 status = U_ZERO_ERROR;
243 plRules = PluralRules::createRules(UNICODE_STRING_SIMPLE("odd: n mod 2 is 1"), status);
244 PluralFormat pluralFmt = PluralFormat(*plRules, status);
245 if (U_FAILURE(status)) {
246 dataerrln("ERROR: Could not create PluralFormat instance in setLocale() test - exitting. ");
247 delete plRules;
248 return;
249 }
250 pluralFmt.applyPattern(UNICODE_STRING_SIMPLE("odd{odd} other{even}"), status);
251 pluralFmt.setLocale(Locale::getEnglish(), status);
252 if (U_FAILURE(status)) {
253 dataerrln("ERROR: Could not setLocale() with English locale ");
254 delete plRules;
255 return;
256 }
257 message = UNICODE_STRING_SIMPLE("Error set locale: pattern is not reset!");
258
259 // Check that pattern gets deleted.
260 logln("\n Test setLocale() ..\n");
261 numFmt = NumberFormat::createInstance(Locale::getEnglish(), status);
262 if (U_FAILURE(status)) {
263 dataerrln("ERROR: Could not create NumberFormat instance with English locale ");
264 }
265 numberFormatTest(&pluralFmt, numFmt, 5, 5, NULL, NULL, FALSE, &message);
266 pluralFmt.applyPattern(UNICODE_STRING_SIMPLE("odd__{odd} other{even}"), status);
267 if (U_SUCCESS(status)) {
268 errln("SetLocale should reset rules but did not.");
269 }
270 status = U_ZERO_ERROR;
271 pluralFmt.applyPattern(UNICODE_STRING_SIMPLE("one{one} other{not one}"), status);
272 if (U_FAILURE(status)) {
273 errln("SetLocale should reset rules but did not.");
274 }
275 UnicodeString one = UNICODE_STRING_SIMPLE("one");
276 UnicodeString notOne = UNICODE_STRING_SIMPLE("not one");
277 UnicodeString plResult, numResult;
278 for (int32_t i=0; i<20; ++i) {
279 plResult = pluralFmt.format(i, status);
280 if ( i==1 ) {
281 numResult = one;
282 }
283 else {
284 numResult = notOne;
285 }
286 if ( numResult != plResult ) {
287 errln("Wrong ruleset loaded by setLocale() - got:"+plResult+ UnicodeString(" expecting:")+numResult);
288 }
289 }
290
291 // =========== Test copy constructor
292 logln("Test copy constructor and == operator of PluralFormat");
293 PluralFormat dupPFmt = PluralFormat(pluralFmt);
294 if (pluralFmt != dupPFmt) {
295 errln("Failed in PluralFormat copy constructor or == operator");
296 }
297
298 delete plRules;
299 delete numFmt;
300 }
301
302
303
304 /**
305 * Test locale data used in PluralFormat class.
306 */
307 void
pluralFormatLocaleTest()308 PluralFormatTest::pluralFormatLocaleTest(/*char *par*/)
309 {
310 int8_t pluralResults[PLURAL_TEST_ARRAY_SIZE]; // 0: is for default
311
312 // ======= Test DefaultRule
313 logln("Testing PluralRules with no rule.");
314 const char* oneRuleLocales[4] = {"ja", "ko", "tr", "vi"};
315 UnicodeString testPattern = UNICODE_STRING_SIMPLE("other{other}");
316 uprv_memset(pluralResults, -1, sizeof(pluralResults));
317 pluralResults[0]= PFT_OTHER; // other
318 helperTestRusults(oneRuleLocales, 4, testPattern, pluralResults);
319
320 // ====== Test Singular1 locales.
321 logln("Testing singular1 locales.");
322 const char* singular1Locales[52] = {"bem","da","de","el","en","eo","es","et","fi",
323 "fo","gl","he","it","nb","nl","nn","no","pt","pt_PT","sv","af","bg","bn","ca","eu","fur","fy",
324 "gu","ha","is","ku","lb","ml","mr","nah","ne","om","or","pa","pap","ps","so","sq","sw","ta",
325 "te","tk","ur","zu","mn","gsw","rm"};
326 testPattern = UNICODE_STRING_SIMPLE("one{one} other{other}");
327 uprv_memset(pluralResults, -1, sizeof(pluralResults));
328 pluralResults[0]= PFT_OTHER;
329 pluralResults[1]= PFT_ONE;
330 pluralResults[2]= PFT_OTHER;
331 helperTestRusults(singular1Locales, 52, testPattern, pluralResults);
332
333 // ======== Test Singular01 locales.
334 logln("Testing singular1 locales.");
335 const char* singular01Locales[3] = {"ff","fr","kab"};
336 testPattern = UNICODE_STRING_SIMPLE("one{one} other{other}");
337 uprv_memset(pluralResults, -1, sizeof(pluralResults));
338 pluralResults[0]= PFT_ONE;
339 pluralResults[2]= PFT_OTHER;
340 helperTestRusults(singular01Locales, 3, testPattern, pluralResults);
341
342 // ======== Test ZeroSingular locales.
343 logln("Testing singular1 locales.");
344 const char* zeroSingularLocales[1] = {"lv"};
345 testPattern = UNICODE_STRING_SIMPLE("zero{zero} one{one} other{other}");
346 uprv_memset(pluralResults, -1, sizeof(pluralResults));
347 pluralResults[0]= PFT_ZERO;
348 pluralResults[1]= PFT_ONE;
349 pluralResults[2]= PFT_OTHER;
350 for (int32_t i=2; i<20; ++i) {
351 if (i==11) continue;
352 pluralResults[i*10+1] = PFT_ONE;
353 pluralResults[i*10+2] = PFT_OTHER;
354 }
355 helperTestRusults(zeroSingularLocales, 1, testPattern, pluralResults);
356
357 // ======== Test singular dual locales.
358 logln("Testing singular1 locales.");
359 const char* singularDualLocales[1] = {"ga"};
360 testPattern = UNICODE_STRING_SIMPLE("one{one} two{two} other{other}");
361 uprv_memset(pluralResults, -1, sizeof(pluralResults));
362 pluralResults[0]= PFT_OTHER;
363 pluralResults[1]= PFT_ONE;
364 pluralResults[2]= PFT_TWO;
365 pluralResults[3]= PFT_OTHER;
366 helperTestRusults(singularDualLocales, 1, testPattern, pluralResults);
367
368 // ======== Test Singular Zero Some locales.
369 logln("Testing singular1 locales.");
370 const char* singularZeroSomeLocales[1] = {"ro"};
371 testPattern = UNICODE_STRING_SIMPLE("few{few} one{one} other{other}");
372 uprv_memset(pluralResults, -1, sizeof(pluralResults));
373 pluralResults[0]= PFT_FEW;
374 for (int32_t i=1; i<20; ++i) {
375 if (i==11) continue;
376 pluralResults[i] = PFT_FEW;
377 pluralResults[100+i] = PFT_FEW;
378 }
379 pluralResults[1]= PFT_ONE;
380 helperTestRusults(singularZeroSomeLocales, 1, testPattern, pluralResults);
381
382 // ======== Test Special 12/19.
383 logln("Testing special 12 and 19.");
384 const char* special12_19Locales[1] = {"lt"};
385 testPattern = UNICODE_STRING_SIMPLE("one{one} few{few} other{other}");
386 uprv_memset(pluralResults, -1, sizeof(pluralResults));
387 pluralResults[0]= PFT_OTHER;
388 pluralResults[1]= PFT_ONE;
389 pluralResults[2]= PFT_FEW;
390 pluralResults[10]= PFT_OTHER;
391 for (int32_t i=2; i<20; ++i) {
392 if (i==11) continue;
393 pluralResults[i*10+1] = PFT_ONE;
394 pluralResults[i*10+2] = PFT_FEW;
395 pluralResults[(i+1)*10] = PFT_OTHER;
396 }
397 helperTestRusults(special12_19Locales, 1, testPattern, pluralResults);
398
399 // ======== Test Paucal Except 11 14.
400 logln("Testing Paucal Except 11 and 14.");
401 const char* paucal01Locales[4] = {"hr","ru","sr","uk"};
402 testPattern = UNICODE_STRING_SIMPLE("one{one} many{many} few{few} other{other}");
403 uprv_memset(pluralResults, -1, sizeof(pluralResults));
404 pluralResults[0]= PFT_MANY;
405 pluralResults[1]= PFT_ONE;
406 pluralResults[2]= PFT_FEW;
407 pluralResults[5]= PFT_MANY;
408 pluralResults[6]= PFT_MANY;
409 pluralResults[7]= PFT_MANY;
410 pluralResults[8]= PFT_MANY;
411 pluralResults[9]= PFT_MANY;
412 for (int32_t i=2; i<20; ++i) {
413 if (i==11) continue;
414 pluralResults[i*10+1] = PFT_ONE;
415 pluralResults[i*10+2] = PFT_FEW;
416 pluralResults[i*10+5] = PFT_MANY;
417 pluralResults[i*10+6] = PFT_MANY;
418 pluralResults[i*10+7] = PFT_MANY;
419 pluralResults[i*10+8] = PFT_MANY;
420 pluralResults[i*10+9] = PFT_MANY;
421 }
422 helperTestRusults(paucal01Locales, 4, testPattern, pluralResults);
423
424 // ======== Test Singular Paucal.
425 logln("Testing Singular Paucal.");
426 const char* singularPaucalLocales[2] = {"cs","sk"};
427 testPattern = UNICODE_STRING_SIMPLE("one{one} few{few} other{other}");
428 uprv_memset(pluralResults, -1, sizeof(pluralResults));
429 pluralResults[0]= PFT_OTHER;
430 pluralResults[1]= PFT_ONE;
431 pluralResults[2]= PFT_FEW;
432 pluralResults[5]= PFT_OTHER;
433 helperTestRusults(singularPaucalLocales, 2, testPattern, pluralResults);
434
435 // ======== Test Paucal (1), (2,3,4).
436 logln("Testing Paucal (1), (2,3,4).");
437 const char* paucal02Locales[1] = {"pl"};
438 testPattern = UNICODE_STRING_SIMPLE("one{one} few{few} other{other}");
439 uprv_memset(pluralResults, -1, sizeof(pluralResults));
440 pluralResults[0]= PFT_OTHER;
441 pluralResults[1]= PFT_ONE;
442 pluralResults[5]= PFT_OTHER;
443 for (int32_t i=0; i<20; ++i) {
444 if ((i==1)||(i==11)) {
445 pluralResults[i*10+2] = PFT_OTHER;
446 pluralResults[i*10+3] = PFT_OTHER;
447 pluralResults[i*10+4] = PFT_OTHER;
448 }
449 else {
450 pluralResults[i*10+2] = PFT_FEW;
451 pluralResults[i*10+3] = PFT_FEW;
452 pluralResults[i*10+4] = PFT_FEW;
453 pluralResults[i*10+5] = PFT_OTHER;
454 }
455 }
456 helperTestRusults(paucal02Locales, 1, testPattern, pluralResults);
457
458 // ======== Test Paucal (1), (2), (3,4).
459 logln("Testing Paucal (1), (2), (3,4).");
460 const char* paucal03Locales[1] = {"sl"};
461 testPattern = UNICODE_STRING_SIMPLE("one{one} two{two} few{few} other{other}");
462 uprv_memset(pluralResults, -1, sizeof(pluralResults));
463 pluralResults[0]= PFT_OTHER;
464 pluralResults[1]= PFT_ONE;
465 pluralResults[2]= PFT_TWO;
466 pluralResults[3]= PFT_FEW;
467 pluralResults[5]= PFT_OTHER;
468 pluralResults[101]= PFT_ONE;
469 pluralResults[102]= PFT_TWO;
470 pluralResults[103]= PFT_FEW;
471 pluralResults[105]= PFT_OTHER;
472 helperTestRusults(paucal03Locales, 1, testPattern, pluralResults);
473
474 // TODO: move this test to Unit Test after CLDR 1.6 is final and we support float
475 // ======= Test French "WITHIN rule
476 logln("Testing PluralRules with fr rule.");
477 testPattern = UNICODE_STRING_SIMPLE("one{one} other{other}");
478 Locale ulocale((const char *)"fr");
479 UErrorCode status = U_ZERO_ERROR;
480 PluralFormat plFmt(ulocale, testPattern, status);
481 if (U_FAILURE(status)) {
482 dataerrln("Failed to apply pattern to fr locale - %s", u_errorName(status));
483 }
484 else {
485 status = U_ZERO_ERROR;
486 UnicodeString plResult = plFmt.format(0.0, status); // retrun ONE
487 plResult = plFmt.format(0.5, status); // retrun ONE
488 plResult = plFmt.format(1.0, status); // retrun ONE
489 plResult = plFmt.format(1.9, status); // retrun ONE
490 plResult = plFmt.format(2.0, status); // retrun OTHER
491 }
492 }
493
494 void
numberFormatTest(PluralFormat * plFmt,NumberFormat * numFmt,int32_t start,int32_t end,UnicodeString * numOddAppendStr,UnicodeString * numEvenAppendStr,UBool overwrite,UnicodeString * message)495 PluralFormatTest::numberFormatTest(PluralFormat* plFmt,
496 NumberFormat *numFmt,
497 int32_t start,
498 int32_t end,
499 UnicodeString *numOddAppendStr,
500 UnicodeString *numEvenAppendStr,
501 UBool overwrite, // overwrite the numberFormat.format result
502 UnicodeString *message) {
503 UErrorCode status = U_ZERO_ERROR;
504
505 if ( (plFmt==NULL) || (numFmt==NULL) ) {
506 dataerrln("ERROR: Could not create PluralFormat or NumberFormat - exitting");
507 return;
508 }
509 UnicodeString plResult, numResult ;
510
511 for (int32_t i=start; i<= end; ++i ) {
512 numResult.remove();
513 numResult = numFmt->format(i, numResult);
514 plResult = plFmt->format(i, status);
515 if ((numOddAppendStr!= NULL)&&(numEvenAppendStr!=NULL)) {
516 if (overwrite) {
517 if (i&1) {
518 numResult = *numOddAppendStr;
519 }
520 else {
521 numResult = *numEvenAppendStr;
522 }
523 }
524 else { // Append the string
525 if (i&1) {
526 numResult += *numOddAppendStr;
527 }
528 else{
529 numResult += *numEvenAppendStr;
530 }
531 }
532 }
533 if ( (numResult!=plResult) || U_FAILURE(status) ) {
534 if ( message == NULL ) {
535 errln("ERROR: Unexpected plural format - got:"+plResult+ UnicodeString(" expecting:")+numResult);
536 }
537 else {
538 errln( *message+UnicodeString(" got:")+plResult+UnicodeString(" expecting:")+numResult);
539
540 }
541 }
542 }
543 return;
544 }
545
546
547 void
helperTestRusults(const char ** localeArray,int32_t capacityOfArray,UnicodeString & testPattern,int8_t * expResults)548 PluralFormatTest::helperTestRusults(const char** localeArray,
549 int32_t capacityOfArray,
550 UnicodeString& testPattern,
551 int8_t *expResults) {
552 UErrorCode status;
553 UnicodeString plResult;
554 const UnicodeString PLKeywordLookups[6] = {
555 UNICODE_STRING_SIMPLE("zero"),
556 UNICODE_STRING_SIMPLE("one"),
557 UNICODE_STRING_SIMPLE("two"),
558 UNICODE_STRING_SIMPLE("few"),
559 UNICODE_STRING_SIMPLE("many"),
560 UNICODE_STRING_SIMPLE("other"),
561 };
562
563 for (int32_t i=0; i<capacityOfArray; ++i) {
564 const char *locale = localeArray[i];
565 Locale ulocale((const char *)locale);
566 status = U_ZERO_ERROR;
567 PluralFormat plFmt(ulocale, testPattern, status);
568 if (U_FAILURE(status)) {
569 dataerrln("Failed to apply pattern to locale:"+UnicodeString(localeArray[i]) + " - " + u_errorName(status));
570 continue;
571 }
572 for (int32_t n=0; n<PLURAL_TEST_ARRAY_SIZE; ++n) {
573 if (expResults[n]!=-1) {
574 status = U_ZERO_ERROR;
575 plResult = plFmt.format(n, status);
576 if (U_FAILURE(status)) {
577 errln("ERROR: Failed to format number in locale data tests with locale: "+
578 UnicodeString(localeArray[i]));
579 }
580 if (plResult != PLKeywordLookups[expResults[n]]){
581 plResult = plFmt.format(n, status);
582 errln("ERROR: Unexpected format result in locale: "+UnicodeString(localeArray[i])+
583 UnicodeString(" got:")+plResult+ UnicodeString(" expecting:")+
584 PLKeywordLookups[expResults[n]]);
585 }
586 }
587 }
588 }
589 }
590
591 #endif /* #if !UCONFIG_NO_FORMATTING */
592