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