Chromium Code Reviews
chromiumcodereview-hr@appspot.gserviceaccount.com (chromiumcodereview-hr) | Please choose your nickname with Settings | Help | Chromium Project | Gerrit Changes | Sign out
(351)

Issues Search
    My Issues | Starred     Open | Closed | All

Side by Side Diff: source/test/intltest/itrbnf.cpp

Issue 2435373002: Delete source/test (Closed)
Patch Set: Created 4 years, 1 month ago
Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.
Jump to:
View unified diff | Download patch
« no previous file with comments | « source/test/intltest/itrbnf.h ('k') | source/test/intltest/itrbnfp.h » ('j') | no next file with comments »
Toggle Intra-line Diffs ('i') | Expand Comments ('e') | Collapse Comments ('c') | Show Comments Hide Comments ('s')
OLDNEW
(Empty)
1 /*
2 *******************************************************************************
3 * Copyright (C) 1996-2015, International Business Machines Corporation and *
4 * others. All Rights Reserved. *
5 *******************************************************************************
6 */
7
8 #include "unicode/utypes.h"
9
10 #if !UCONFIG_NO_FORMATTING
11
12 #include "itrbnf.h"
13
14 #include "unicode/umachine.h"
15
16 #include "unicode/tblcoll.h"
17 #include "unicode/coleitr.h"
18 #include "unicode/ures.h"
19 #include "unicode/ustring.h"
20 #include "unicode/decimfmt.h"
21 #include "unicode/udata.h"
22 #include "putilimp.h"
23 #include "testutil.h"
24
25 #include <string.h>
26
27 // import com.ibm.text.RuleBasedNumberFormat;
28 // import com.ibm.test.TestFmwk;
29
30 // import java.util.Locale;
31 // import java.text.NumberFormat;
32
33 // current macro not in icu1.8.1
34 #define TESTCASE(id,test) \
35 case id: \
36 name = #test; \
37 if (exec) { \
38 logln(#test "---"); \
39 logln(); \
40 test(); \
41 } \
42 break
43
44 void IntlTestRBNF::runIndexedTest(int32_t index, UBool exec, const char* &name, char* /*par*/)
45 {
46 if (exec) logln("TestSuite RuleBasedNumberFormat");
47 switch (index) {
48 #if U_HAVE_RBNF
49 TESTCASE(0, TestEnglishSpellout);
50 TESTCASE(1, TestOrdinalAbbreviations);
51 TESTCASE(2, TestDurations);
52 TESTCASE(3, TestSpanishSpellout);
53 TESTCASE(4, TestFrenchSpellout);
54 TESTCASE(5, TestSwissFrenchSpellout);
55 TESTCASE(6, TestItalianSpellout);
56 TESTCASE(7, TestGermanSpellout);
57 TESTCASE(8, TestThaiSpellout);
58 TESTCASE(9, TestAPI);
59 TESTCASE(10, TestFractionalRuleSet);
60 TESTCASE(11, TestSwedishSpellout);
61 TESTCASE(12, TestBelgianFrenchSpellout);
62 TESTCASE(13, TestSmallValues);
63 TESTCASE(14, TestLocalizations);
64 TESTCASE(15, TestAllLocales);
65 TESTCASE(16, TestHebrewFraction);
66 TESTCASE(17, TestPortugueseSpellout);
67 TESTCASE(18, TestMultiplierSubstitution);
68 TESTCASE(19, TestSetDecimalFormatSymbols);
69 TESTCASE(20, TestPluralRules);
70 TESTCASE(21, TestMultiplePluralRules);
71 TESTCASE(22, TestInfinityNaN);
72 TESTCASE(23, TestVariableDecimalPoint);
73 #else
74 TESTCASE(0, TestRBNFDisabled);
75 #endif
76 default:
77 name = "";
78 break;
79 }
80 }
81
82 #if U_HAVE_RBNF
83
84 void IntlTestRBNF::TestHebrewFraction() {
85
86 // this is the expected output for 123.45, with no '<' in it.
87 UChar text1[] = {
88 0x05de, 0x05d0, 0x05d4, 0x0020,
89 0x05e2, 0x05e9, 0x05e8, 0x05d9, 0x05dd, 0x0020,
90 0x05d5, 0x05e9, 0x05dc, 0x05d5, 0x05e9, 0x0020,
91 0x05e0, 0x05e7, 0x05d5, 0x05d3, 0x05d4, 0x0020,
92 0x05d0, 0x05e8, 0x05d1, 0x05e2, 0x0020,
93 0x05d7, 0x05de, 0x05e9, 0x0000,
94 };
95 UChar text2[] = {
96 0x05DE, 0x05D0, 0x05D4, 0x0020,
97 0x05E2, 0x05E9, 0x05E8, 0x05D9, 0x05DD, 0x0020,
98 0x05D5, 0x05E9, 0x05DC, 0x05D5, 0x05E9, 0x0020,
99 0x05E0, 0x05E7, 0x05D5, 0x05D3, 0x05D4, 0x0020,
100 0x05D0, 0x05E4, 0x05E1, 0x0020,
101 0x05D0, 0x05E4, 0x05E1, 0x0020,
102 0x05D0, 0x05E8, 0x05D1, 0x05E2, 0x0020,
103 0x05D7, 0x05DE, 0x05E9, 0x0000,
104 };
105 UErrorCode status = U_ZERO_ERROR;
106 RuleBasedNumberFormat* formatter = new RuleBasedNumberFormat(URBNF_SPELLOUT, "he_IL", status);
107 if (status == U_MISSING_RESOURCE_ERROR || status == U_FILE_ACCESS_ERROR) {
108 errcheckln(status, "Failed in constructing RuleBasedNumberFormat - %s", u_errorName(status));
109 delete formatter;
110 return;
111 }
112 UnicodeString result;
113 Formattable parseResult;
114 ParsePosition pp(0);
115 {
116 UnicodeString expected(text1);
117 formatter->format(123.45, result);
118 if (result != expected) {
119 errln((UnicodeString)"expected '" + TestUtility::hex(expected) + "'\ nbut got: '" + TestUtility::hex(result) + "'");
120 } else {
121 // formatter->parse(result, parseResult, pp);
122 // if (parseResult.getDouble() != 123.45) {
123 // errln("expected 123.45 but got: %g", parseResult.getDouble());
124 // }
125 }
126 }
127 {
128 UnicodeString expected(text2);
129 result.remove();
130 formatter->format(123.0045, result);
131 if (result != expected) {
132 errln((UnicodeString)"expected '" + TestUtility::hex(expected) + "'\ nbut got: '" + TestUtility::hex(result) + "'");
133 } else {
134 pp.setIndex(0);
135 // formatter->parse(result, parseResult, pp);
136 // if (parseResult.getDouble() != 123.0045) {
137 // errln("expected 123.0045 but got: %g", parseResult.getDouble() );
138 // }
139 }
140 }
141 delete formatter;
142 }
143
144 void
145 IntlTestRBNF::TestAPI() {
146 // This test goes through the APIs that were not tested before.
147 // These tests are too small to have separate test classes/functions
148
149 UErrorCode status = U_ZERO_ERROR;
150 RuleBasedNumberFormat* formatter
151 = new RuleBasedNumberFormat(URBNF_SPELLOUT, Locale::getUS(), status);
152 if (status == U_MISSING_RESOURCE_ERROR || status == U_FILE_ACCESS_ERROR) {
153 dataerrln("Unable to create formatter. - %s", u_errorName(status));
154 delete formatter;
155 return;
156 }
157
158 logln("RBNF API test starting");
159 // test clone
160 {
161 logln("Testing Clone");
162 RuleBasedNumberFormat* rbnfClone = (RuleBasedNumberFormat *)formatter->clone ();
163 if(rbnfClone != NULL) {
164 if(!(*rbnfClone == *formatter)) {
165 errln("Clone should be semantically equivalent to the original!");
166 }
167 delete rbnfClone;
168 } else {
169 errln("Cloning failed!");
170 }
171 }
172
173 // test assignment
174 {
175 logln("Testing assignment operator");
176 RuleBasedNumberFormat assignResult(URBNF_SPELLOUT, Locale("es", "ES", ""), s tatus);
177 assignResult = *formatter;
178 if(!(assignResult == *formatter)) {
179 errln("Assignment result should be semantically equivalent to the original !");
180 }
181 }
182
183 // test rule constructor
184 {
185 logln("Testing rule constructor");
186 LocalUResourceBundlePointer en(ures_open(U_ICUDATA_NAME U_TREE_SEPARATOR_STR ING "rbnf", "en", &status));
187 if(U_FAILURE(status)) {
188 errln("Unable to access resource bundle with data!");
189 } else {
190 int32_t ruleLen = 0;
191 int32_t len = 0;
192 LocalUResourceBundlePointer rbnfRules(ures_getByKey(en.getAlias(), "RBNFRu les", NULL, &status));
193 LocalUResourceBundlePointer ruleSets(ures_getByKey(rbnfRules.getAlias(), " SpelloutRules", NULL, &status));
194 UnicodeString desc;
195 while (ures_hasNext(ruleSets.getAlias())) {
196 const UChar* currentString = ures_getNextString(ruleSets.getAlias(), &len, NULL, &status);
197 ruleLen += len;
198 desc.append(currentString);
199 }
200
201 const UChar *spelloutRules = desc.getTerminatedBuffer();
202
203 if(U_FAILURE(status) || ruleLen == 0 || spelloutRules == NULL) {
204 errln("Unable to access the rules string!");
205 } else {
206 UParseError perror;
207 RuleBasedNumberFormat ruleCtorResult(spelloutRules, Locale::getUS(), per ror, status);
208 if(!(ruleCtorResult == *formatter)) {
209 errln("Formatter constructed from the original rules should be semanti cally equivalent to the original!");
210 }
211
212 // Jitterbug 4452, for coverage
213 RuleBasedNumberFormat nf(spelloutRules, (UnicodeString)"", Locale::getUS (), perror, status);
214 if(!(nf == *formatter)) {
215 errln("Formatter constructed from the original rules should be semanti cally equivalent to the original!");
216 }
217 }
218 }
219 }
220
221 // test getRules
222 {
223 logln("Testing getRules function");
224 UnicodeString rules = formatter->getRules();
225 UParseError perror;
226 RuleBasedNumberFormat fromRulesResult(rules, Locale::getUS(), perror, status );
227
228 if(!(fromRulesResult == *formatter)) {
229 errln("Formatter constructed from rules obtained by getRules should be sem antically equivalent to the original!");
230 }
231 }
232
233
234 {
235 logln("Testing copy constructor");
236 RuleBasedNumberFormat copyCtorResult(*formatter);
237 if(!(copyCtorResult == *formatter)) {
238 errln("Copy constructor result result should be semantically equivalent to the original!");
239 }
240 }
241
242 #if !UCONFIG_NO_COLLATION
243 // test ruleset names
244 {
245 logln("Testing getNumberOfRuleSetNames, getRuleSetName and format using rule set names");
246 int32_t noOfRuleSetNames = formatter->getNumberOfRuleSetNames();
247 if(noOfRuleSetNames == 0) {
248 errln("Number of rule set names should be more than zero");
249 }
250 UnicodeString ruleSetName;
251 int32_t i = 0;
252 int32_t intFormatNum = 34567;
253 double doubleFormatNum = 893411.234;
254 logln("number of rule set names is %i", noOfRuleSetNames);
255 for(i = 0; i < noOfRuleSetNames; i++) {
256 FieldPosition pos1, pos2;
257 UnicodeString intFormatResult, doubleFormatResult;
258 Formattable intParseResult, doubleParseResult;
259
260 ruleSetName = formatter->getRuleSetName(i);
261 log("Rule set name %i is ", i);
262 log(ruleSetName);
263 logln(". Format results are: ");
264 intFormatResult = formatter->format(intFormatNum, ruleSetName, intFormatRe sult, pos1, status);
265 doubleFormatResult = formatter->format(doubleFormatNum, ruleSetName, doubl eFormatResult, pos2, status);
266 if(U_FAILURE(status)) {
267 errln("Format using a rule set failed");
268 break;
269 }
270 logln(intFormatResult);
271 logln(doubleFormatResult);
272 formatter->setLenient(TRUE);
273 formatter->parse(intFormatResult, intParseResult, status);
274 formatter->parse(doubleFormatResult, doubleParseResult, status);
275
276 logln("Parse results for lenient = TRUE, %i, %f", intParseResult.getLong() , doubleParseResult.getDouble());
277
278 formatter->setLenient(FALSE);
279 formatter->parse(intFormatResult, intParseResult, status);
280 formatter->parse(doubleFormatResult, doubleParseResult, status);
281
282 logln("Parse results for lenient = FALSE, %i, %f", intParseResult.getLong( ), doubleParseResult.getDouble());
283
284 if(U_FAILURE(status)) {
285 errln("Error during parsing");
286 }
287
288 intFormatResult = formatter->format(intFormatNum, "BLABLA", intFormatResul t, pos1, status);
289 if(U_SUCCESS(status)) {
290 errln("Using invalid rule set name should have failed");
291 break;
292 }
293 status = U_ZERO_ERROR;
294 doubleFormatResult = formatter->format(doubleFormatNum, "TRUC", doubleForm atResult, pos2, status);
295 if(U_SUCCESS(status)) {
296 errln("Using invalid rule set name should have failed");
297 break;
298 }
299 status = U_ZERO_ERROR;
300 }
301 status = U_ZERO_ERROR;
302 }
303 #endif
304
305 // test API
306 UnicodeString expected("four point five","");
307 logln("Testing format(double)");
308 UnicodeString result;
309 formatter->format(4.5,result);
310 if(result != expected) {
311 errln("Formatted 4.5, expected " + expected + " got " + result);
312 } else {
313 logln("Formatted 4.5, expected " + expected + " got " + result);
314 }
315 result.remove();
316 expected = "four";
317 formatter->format((int32_t)4,result);
318 if(result != expected) {
319 errln("Formatted 4, expected " + expected + " got " + result);
320 } else {
321 logln("Formatted 4, expected " + expected + " got " + result);
322 }
323
324 result.remove();
325 FieldPosition pos;
326 formatter->format((int64_t)4, result, pos, status = U_ZERO_ERROR);
327 if(result != expected) {
328 errln("Formatted 4 int64_t, expected " + expected + " got " + result);
329 } else {
330 logln("Formatted 4 int64_t, expected " + expected + " got " + result);
331 }
332
333 //Jitterbug 4452, for coverage
334 result.remove();
335 FieldPosition pos2;
336 formatter->format((int64_t)4, formatter->getRuleSetName(0), result, pos2, stat us = U_ZERO_ERROR);
337 if(result != expected) {
338 errln("Formatted 4 int64_t, expected " + expected + " got " + result);
339 } else {
340 logln("Formatted 4 int64_t, expected " + expected + " got " + result);
341 }
342
343 // clean up
344 logln("Cleaning up");
345 delete formatter;
346 }
347
348 /**
349 * Perform a simple spot check on the parsing going into an infinite loop for al ternate rules.
350 */
351 void IntlTestRBNF::TestMultiplePluralRules() {
352 // This is trying to model the feminine form, but don't worry about the deta ils too much.
353 // We're trying to test the plural rules where there are different prefixes.
354 UnicodeString rules("%spellout-cardinal-feminine-genitive:"
355 "0: zero;"
356 "1: ono;"
357 "2: two;"
358 "1000: << $(cardinal,one{thousand}few{thousanF}other{thousanO})$ [ >>];"
359 "%spellout-cardinal-feminine:"
360 "x.x: [<< $(cardinal,one{singleton}other{plurality})$ ]>%%fracti ons>;"
361 "0: zero;"
362 "1: one;"
363 "2: two;"
364 "1000: << $(cardinal,one{thousand}few{thousanF}other{thousanO})$ [ >>];"
365 "%%fractions:"
366 "10: <%spellout-cardinal-feminine< $(cardinal,one{oneth}other{te nth})$;"
367 "100: <%spellout-cardinal-feminine< $(cardinal,one{1hundredth}ot her{hundredth})$;");
368 UErrorCode status = U_ZERO_ERROR;
369 UParseError pError;
370 RuleBasedNumberFormat formatter(rules, Locale("ru"), pError, status);
371 Formattable result;
372 UnicodeString resultStr;
373 FieldPosition pos;
374
375 if (U_FAILURE(status)) {
376 dataerrln("Unable to create formatter - %s", u_errorName(status));
377 return;
378 }
379
380 formatter.parse(formatter.format(1000.0, resultStr, pos, status), result, st atus);
381 if (1000 != result.getLong() || resultStr != UNICODE_STRING_SIMPLE("one thou sand")) {
382 errln("RuleBasedNumberFormat did not return the correct value. Got: %d", result.getLong());
383 errln(resultStr);
384 }
385 resultStr.remove();
386 formatter.parse(formatter.format(1000.0, UnicodeString("%spellout-cardinal-f eminine-genitive"), resultStr, pos, status), result, status);
387 if (1000 != result.getLong() || resultStr != UNICODE_STRING_SIMPLE("ono thou sand")) {
388 errln("RuleBasedNumberFormat(cardinal-feminine-genitive) did not return the correct value. Got: %d", result.getLong());
389 errln(resultStr);
390 }
391 resultStr.remove();
392 formatter.parse(formatter.format(1000.0, UnicodeString("%spellout-cardinal-f eminine"), resultStr, pos, status), result, status);
393 if (1000 != result.getLong() || resultStr != UNICODE_STRING_SIMPLE("one thou sand")) {
394 errln("RuleBasedNumberFormat(spellout-cardinal-feminine) did not return the correct value. Got: %d", result.getLong());
395 errln(resultStr);
396 }
397 static const char* const testData[][2] = {
398 { "0", "zero" },
399 { "1", "one" },
400 { "2", "two" },
401 { "0.1", "one oneth" },
402 { "0.2", "two tenth" },
403 { "1.1", "one singleton one oneth" },
404 { "1.2", "one singleton two tenth" },
405 { "2.1", "two plurality one oneth" },
406 { "2.2", "two plurality two tenth" },
407 { "0.01", "one 1hundredth" },
408 { "0.02", "two hundredth" },
409 { NULL, NULL }
410 };
411 doTest(&formatter, testData, TRUE);
412 }
413
414 void IntlTestRBNF::TestFractionalRuleSet()
415 {
416 UnicodeString fracRules(
417 "%main:\n"
418 // this rule formats the number if it's 1 or more. It formats
419 // the integral part using a DecimalFormat ("#,##0" puts
420 // thousands separators in the right places) and the fractional
421 // part using %%frac. If there is no fractional part, it
422 // just shows the integral part.
423 " x.0: <#,##0<[ >%%frac>];\n"
424 // this rule formats the number if it's between 0 and 1. It
425 // shows only the fractional part (0.5 shows up as "1/2," not
426 // "0 1/2")
427 " 0.x: >%%frac>;\n"
428 // the fraction rule set. This works the same way as the one in the
429 // preceding example: We multiply the fractional part of the number
430 // being formatted by each rule's base value and use the rule that
431 // produces the result closest to 0 (or the first rule that produces 0).
432 // Since we only provide rules for the numbers from 2 to 10, we know
433 // we'll get a fraction with a denominator between 2 and 10.
434 // "<0<" causes the numerator of the fraction to be formatted
435 // using numerals
436 "%%frac:\n"
437 " 2: 1/2;\n"
438 " 3: <0</3;\n"
439 " 4: <0</4;\n"
440 " 5: <0</5;\n"
441 " 6: <0</6;\n"
442 " 7: <0</7;\n"
443 " 8: <0</8;\n"
444 " 9: <0</9;\n"
445 " 10: <0</10;\n");
446
447 // mondo hack
448 int len = fracRules.length();
449 int change = 2;
450 for (int i = 0; i < len; ++i) {
451 UChar ch = fracRules.charAt(i);
452 if (ch == '\n') {
453 change = 2; // change ok
454 } else if (ch == ':') {
455 change = 1; // change, but once we hit a non-space char, don't chang e
456 } else if (ch == ' ') {
457 if (change != 0) {
458 fracRules.setCharAt(i, (UChar)0x200e);
459 }
460 } else {
461 if (change == 1) {
462 change = 0;
463 }
464 }
465 }
466
467 UErrorCode status = U_ZERO_ERROR;
468 UParseError perror;
469 RuleBasedNumberFormat formatter(fracRules, Locale::getEnglish(), perror, sta tus);
470 if (U_FAILURE(status)) {
471 errcheckln(status, "FAIL: could not construct formatter - %s", u_errorNa me(status));
472 } else {
473 static const char* const testData[][2] = {
474 { "0", "0" },
475 { ".1", "1/10" },
476 { ".11", "1/9" },
477 { ".125", "1/8" },
478 { ".1428", "1/7" },
479 { ".1667", "1/6" },
480 { ".2", "1/5" },
481 { ".25", "1/4" },
482 { ".333", "1/3" },
483 { ".5", "1/2" },
484 { "1.1", "1 1/10" },
485 { "2.11", "2 1/9" },
486 { "3.125", "3 1/8" },
487 { "4.1428", "4 1/7" },
488 { "5.1667", "5 1/6" },
489 { "6.2", "6 1/5" },
490 { "7.25", "7 1/4" },
491 { "8.333", "8 1/3" },
492 { "9.5", "9 1/2" },
493 { ".2222", "2/9" },
494 { ".4444", "4/9" },
495 { ".5555", "5/9" },
496 { "1.2856", "1 2/7" },
497 { NULL, NULL }
498 };
499 doTest(&formatter, testData, FALSE); // exact values aren't parsable fro m fractions
500 }
501 }
502
503 #if 0
504 #define LLAssert(a) \
505 if (!(a)) errln("FAIL: " #a)
506
507 void IntlTestRBNF::TestLLongConstructors()
508 {
509 logln("Testing constructors");
510
511 // constant (shouldn't really be public)
512 LLAssert(llong(llong::kD32).asDouble() == llong::kD32);
513
514 // internal constructor (shouldn't really be public)
515 LLAssert(llong(0, 1).asDouble() == 1);
516 LLAssert(llong(1, 0).asDouble() == llong::kD32);
517 LLAssert(llong((uint32_t)-1, (uint32_t)-1).asDouble() == -1);
518
519 // public empty constructor
520 LLAssert(llong().asDouble() == 0);
521
522 // public int32_t constructor
523 LLAssert(llong((int32_t)0).asInt() == (int32_t)0);
524 LLAssert(llong((int32_t)1).asInt() == (int32_t)1);
525 LLAssert(llong((int32_t)-1).asInt() == (int32_t)-1);
526 LLAssert(llong((int32_t)0x7fffffff).asInt() == (int32_t)0x7fffffff);
527 LLAssert(llong((int32_t)0xffffffff).asInt() == (int32_t)-1);
528 LLAssert(llong((int32_t)0x80000000).asInt() == (int32_t)0x80000000);
529
530 // public int16_t constructor
531 LLAssert(llong((int16_t)0).asInt() == (int16_t)0);
532 LLAssert(llong((int16_t)1).asInt() == (int16_t)1);
533 LLAssert(llong((int16_t)-1).asInt() == (int16_t)-1);
534 LLAssert(llong((int16_t)0x7fff).asInt() == (int16_t)0x7fff);
535 LLAssert(llong((int16_t)0xffff).asInt() == (int16_t)0xffff);
536 LLAssert(llong((int16_t)0x8000).asInt() == (int16_t)0x8000);
537
538 // public int8_t constructor
539 LLAssert(llong((int8_t)0).asInt() == (int8_t)0);
540 LLAssert(llong((int8_t)1).asInt() == (int8_t)1);
541 LLAssert(llong((int8_t)-1).asInt() == (int8_t)-1);
542 LLAssert(llong((int8_t)0x7f).asInt() == (int8_t)0x7f);
543 LLAssert(llong((int8_t)0xff).asInt() == (int8_t)0xff);
544 LLAssert(llong((int8_t)0x80).asInt() == (int8_t)0x80);
545
546 // public uint16_t constructor
547 LLAssert(llong((uint16_t)0).asUInt() == (uint16_t)0);
548 LLAssert(llong((uint16_t)1).asUInt() == (uint16_t)1);
549 LLAssert(llong((uint16_t)-1).asUInt() == (uint16_t)-1);
550 LLAssert(llong((uint16_t)0x7fff).asUInt() == (uint16_t)0x7fff);
551 LLAssert(llong((uint16_t)0xffff).asUInt() == (uint16_t)0xffff);
552 LLAssert(llong((uint16_t)0x8000).asUInt() == (uint16_t)0x8000);
553
554 // public uint32_t constructor
555 LLAssert(llong((uint32_t)0).asUInt() == (uint32_t)0);
556 LLAssert(llong((uint32_t)1).asUInt() == (uint32_t)1);
557 LLAssert(llong((uint32_t)-1).asUInt() == (uint32_t)-1);
558 LLAssert(llong((uint32_t)0x7fffffff).asUInt() == (uint32_t)0x7fffffff);
559 LLAssert(llong((uint32_t)0xffffffff).asUInt() == (uint32_t)-1);
560 LLAssert(llong((uint32_t)0x80000000).asUInt() == (uint32_t)0x80000000);
561
562 // public double constructor
563 LLAssert(llong((double)0).asDouble() == (double)0);
564 LLAssert(llong((double)1).asDouble() == (double)1);
565 LLAssert(llong((double)0x7fffffff).asDouble() == (double)0x7fffffff);
566 LLAssert(llong((double)0x80000000).asDouble() == (double)0x80000000);
567 LLAssert(llong((double)0x80000001).asDouble() == (double)0x80000001);
568
569 // can't access uprv_maxmantissa, so fake it
570 double maxmantissa = (llong((int32_t)1) << 40).asDouble();
571 LLAssert(llong(maxmantissa).asDouble() == maxmantissa);
572 LLAssert(llong(-maxmantissa).asDouble() == -maxmantissa);
573
574 // copy constructor
575 LLAssert(llong(llong(0, 1)).asDouble() == 1);
576 LLAssert(llong(llong(1, 0)).asDouble() == llong::kD32);
577 LLAssert(llong(llong(-1, (uint32_t)-1)).asDouble() == -1);
578
579 // asInt - test unsigned to signed narrowing conversion
580 LLAssert(llong((uint32_t)-1).asInt() == (int32_t)0x7fffffff);
581 LLAssert(llong(-1, 0).asInt() == (int32_t)0x80000000);
582
583 // asUInt - test signed to unsigned narrowing conversion
584 LLAssert(llong((int32_t)-1).asUInt() == (uint32_t)-1);
585 LLAssert(llong((int32_t)0x80000000).asUInt() == (uint32_t)0x80000000);
586
587 // asDouble already tested
588
589 }
590
591 void IntlTestRBNF::TestLLongSimpleOperators()
592 {
593 logln("Testing simple operators");
594
595 // operator==
596 LLAssert(llong() == llong(0, 0));
597 LLAssert(llong(1,0) == llong(1, 0));
598 LLAssert(llong(0,1) == llong(0, 1));
599
600 // operator!=
601 LLAssert(llong(1,0) != llong(1,1));
602 LLAssert(llong(0,1) != llong(1,1));
603 LLAssert(llong(0xffffffff,0xffffffff) != llong(0x7fffffff, 0xffffffff));
604
605 // unsigned >
606 LLAssert(llong((int32_t)-1).ugt(llong(0x7fffffff, 0xffffffff)));
607
608 // unsigned <
609 LLAssert(llong(0x7fffffff, 0xffffffff).ult(llong((int32_t)-1)));
610
611 // unsigned >=
612 LLAssert(llong((int32_t)-1).uge(llong(0x7fffffff, 0xffffffff)));
613 LLAssert(llong((int32_t)-1).uge(llong((int32_t)-1)));
614
615 // unsigned <=
616 LLAssert(llong(0x7fffffff, 0xffffffff).ule(llong((int32_t)-1)));
617 LLAssert(llong((int32_t)-1).ule(llong((int32_t)-1)));
618
619 // operator>
620 LLAssert(llong(1, 1) > llong(1, 0));
621 LLAssert(llong(0, 0x80000000) > llong(0, 0x7fffffff));
622 LLAssert(llong(0x80000000, 1) > llong(0x80000000, 0));
623 LLAssert(llong(1, 0) > llong(0, 0x7fffffff));
624 LLAssert(llong(1, 0) > llong(0, 0xffffffff));
625 LLAssert(llong(0, 0) > llong(0x80000000, 1));
626
627 // operator<
628 LLAssert(llong(1, 0) < llong(1, 1));
629 LLAssert(llong(0, 0x7fffffff) < llong(0, 0x80000000));
630 LLAssert(llong(0x80000000, 0) < llong(0x80000000, 1));
631 LLAssert(llong(0, 0x7fffffff) < llong(1, 0));
632 LLAssert(llong(0, 0xffffffff) < llong(1, 0));
633 LLAssert(llong(0x80000000, 1) < llong(0, 0));
634
635 // operator>=
636 LLAssert(llong(1, 1) >= llong(1, 0));
637 LLAssert(llong(0, 0x80000000) >= llong(0, 0x7fffffff));
638 LLAssert(llong(0x80000000, 1) >= llong(0x80000000, 0));
639 LLAssert(llong(1, 0) >= llong(0, 0x7fffffff));
640 LLAssert(llong(1, 0) >= llong(0, 0xffffffff));
641 LLAssert(llong(0, 0) >= llong(0x80000000, 1));
642 LLAssert(llong() >= llong(0, 0));
643 LLAssert(llong(1,0) >= llong(1, 0));
644 LLAssert(llong(0,1) >= llong(0, 1));
645
646 // operator<=
647 LLAssert(llong(1, 0) <= llong(1, 1));
648 LLAssert(llong(0, 0x7fffffff) <= llong(0, 0x80000000));
649 LLAssert(llong(0x80000000, 0) <= llong(0x80000000, 1));
650 LLAssert(llong(0, 0x7fffffff) <= llong(1, 0));
651 LLAssert(llong(0, 0xffffffff) <= llong(1, 0));
652 LLAssert(llong(0x80000000, 1) <= llong(0, 0));
653 LLAssert(llong() <= llong(0, 0));
654 LLAssert(llong(1,0) <= llong(1, 0));
655 LLAssert(llong(0,1) <= llong(0, 1));
656
657 // operator==(int32)
658 LLAssert(llong() == (int32_t)0);
659 LLAssert(llong(0,1) == (int32_t)1);
660
661 // operator!=(int32)
662 LLAssert(llong(1,0) != (int32_t)0);
663 LLAssert(llong(0,1) != (int32_t)2);
664 LLAssert(llong(0,0xffffffff) != (int32_t)-1);
665
666 llong negOne(0xffffffff, 0xffffffff);
667
668 // operator>(int32)
669 LLAssert(llong(0, 0x80000000) > (int32_t)0x7fffffff);
670 LLAssert(negOne > (int32_t)-2);
671 LLAssert(llong(1, 0) > (int32_t)0x7fffffff);
672 LLAssert(llong(0, 0) > (int32_t)-1);
673
674 // operator<(int32)
675 LLAssert(llong(0, 0x7ffffffe) < (int32_t)0x7fffffff);
676 LLAssert(llong(0xffffffff, 0xfffffffe) < (int32_t)-1);
677
678 // operator>=(int32)
679 LLAssert(llong(0, 0x80000000) >= (int32_t)0x7fffffff);
680 LLAssert(negOne >= (int32_t)-2);
681 LLAssert(llong(1, 0) >= (int32_t)0x7fffffff);
682 LLAssert(llong(0, 0) >= (int32_t)-1);
683 LLAssert(llong() >= (int32_t)0);
684 LLAssert(llong(0,1) >= (int32_t)1);
685
686 // operator<=(int32)
687 LLAssert(llong(0, 0x7ffffffe) <= (int32_t)0x7fffffff);
688 LLAssert(llong(0xffffffff, 0xfffffffe) <= (int32_t)-1);
689 LLAssert(llong() <= (int32_t)0);
690 LLAssert(llong(0,1) <= (int32_t)1);
691
692 // operator=
693 LLAssert((llong(2,3) = llong((uint32_t)-1)).asUInt() == (uint32_t)-1);
694
695 // operator <<=
696 LLAssert((llong(1, 1) <<= 0) == llong(1, 1));
697 LLAssert((llong(1, 1) <<= 31) == llong(0x80000000, 0x80000000));
698 LLAssert((llong(1, 1) <<= 32) == llong(1, 0));
699 LLAssert((llong(1, 1) <<= 63) == llong(0x80000000, 0));
700 LLAssert((llong(1, 1) <<= 64) == llong(1, 1)); // only lower 6 bits are used
701 LLAssert((llong(1, 1) <<= -1) == llong(0x80000000, 0)); // only lower 6 bits are used
702
703 // operator <<
704 LLAssert((llong((int32_t)1) << 5).asUInt() == 32);
705
706 // operator >>= (sign extended)
707 LLAssert((llong(0x7fffa0a0, 0xbcbcdfdf) >>= 16) == llong(0x7fff,0xa0a0bcbc)) ;
708 LLAssert((llong(0x8000789a, 0xbcde0000) >>= 16) == llong(0xffff8000,0x789abc de));
709 LLAssert((llong(0x80000000, 0) >>= 63) == llong(0xffffffff, 0xffffffff));
710 LLAssert((llong(0x80000000, 0) >>= 47) == llong(0xffffffff, 0xffff0000));
711 LLAssert((llong(0x80000000, 0x80000000) >> 64) == llong(0x80000000, 0x800000 00)); // only lower 6 bits are used
712 LLAssert((llong(0x80000000, 0) >>= -1) == llong(0xffffffff, 0xffffffff)); // only lower 6 bits are used
713
714 // operator >> sign extended)
715 LLAssert((llong(0x8000789a, 0xbcde0000) >> 16) == llong(0xffff8000,0x789abcd e));
716
717 // ushr (right shift without sign extension)
718 LLAssert(llong(0x7fffa0a0, 0xbcbcdfdf).ushr(16) == llong(0x7fff,0xa0a0bcbc)) ;
719 LLAssert(llong(0x8000789a, 0xbcde0000).ushr(16) == llong(0x00008000,0x789abc de));
720 LLAssert(llong(0x80000000, 0).ushr(63) == llong(0, 1));
721 LLAssert(llong(0x80000000, 0).ushr(47) == llong(0, 0x10000));
722 LLAssert(llong(0x80000000, 0x80000000).ushr(64) == llong(0x80000000, 0x80000 000)); // only lower 6 bits are used
723 LLAssert(llong(0x80000000, 0).ushr(-1) == llong(0, 1)); // only lower 6 bits are used
724
725 // operator&(llong)
726 LLAssert((llong(0x55555555, 0x55555555) & llong(0xaaaaffff, 0xffffaaaa)) == llong(0x00005555, 0x55550000));
727
728 // operator|(llong)
729 LLAssert((llong(0x55555555, 0x55555555) | llong(0xaaaaffff, 0xffffaaaa)) == llong(0xffffffff, 0xffffffff));
730
731 // operator^(llong)
732 LLAssert((llong(0x55555555, 0x55555555) ^ llong(0xaaaaffff, 0xffffaaaa)) == llong(0xffffaaaa, 0xaaaaffff));
733
734 // operator&(uint32)
735 LLAssert((llong(0x55555555, 0x55555555) & (uint32_t)0xffffaaaa) == llong(0, 0x55550000));
736
737 // operator|(uint32)
738 LLAssert((llong(0x55555555, 0x55555555) | (uint32_t)0xffffaaaa) == llong(0x5 5555555, 0xffffffff));
739
740 // operator^(uint32)
741 LLAssert((llong(0x55555555, 0x55555555) ^ (uint32_t)0xffffaaaa) == llong(0x5 5555555, 0xaaaaffff));
742
743 // operator~
744 LLAssert(~llong(0x55555555, 0x55555555) == llong(0xaaaaaaaa, 0xaaaaaaaa));
745
746 // operator&=(llong)
747 LLAssert((llong(0x55555555, 0x55555555) &= llong(0xaaaaffff, 0xffffaaaa)) == llong(0x00005555, 0x55550000));
748
749 // operator|=(llong)
750 LLAssert((llong(0x55555555, 0x55555555) |= llong(0xaaaaffff, 0xffffaaaa)) == llong(0xffffffff, 0xffffffff));
751
752 // operator^=(llong)
753 LLAssert((llong(0x55555555, 0x55555555) ^= llong(0xaaaaffff, 0xffffaaaa)) == llong(0xffffaaaa, 0xaaaaffff));
754
755 // operator&=(uint32)
756 LLAssert((llong(0x55555555, 0x55555555) &= (uint32_t)0xffffaaaa) == llong(0, 0x55550000));
757
758 // operator|=(uint32)
759 LLAssert((llong(0x55555555, 0x55555555) |= (uint32_t)0xffffaaaa) == llong(0x 55555555, 0xffffffff));
760
761 // operator^=(uint32)
762 LLAssert((llong(0x55555555, 0x55555555) ^= (uint32_t)0xffffaaaa) == llong(0x 55555555, 0xaaaaffff));
763
764 // prefix inc
765 LLAssert(llong(1, 0) == ++llong(0,0xffffffff));
766
767 // prefix dec
768 LLAssert(llong(0,0xffffffff) == --llong(1, 0));
769
770 // postfix inc
771 {
772 llong n(0, 0xffffffff);
773 LLAssert(llong(0, 0xffffffff) == n++);
774 LLAssert(llong(1, 0) == n);
775 }
776
777 // postfix dec
778 {
779 llong n(1, 0);
780 LLAssert(llong(1, 0) == n--);
781 LLAssert(llong(0, 0xffffffff) == n);
782 }
783
784 // unary minus
785 LLAssert(llong(0, 0) == -llong(0, 0));
786 LLAssert(llong(0xffffffff, 0xffffffff) == -llong(0, 1));
787 LLAssert(llong(0, 1) == -llong(0xffffffff, 0xffffffff));
788 LLAssert(llong(0x7fffffff, 0xffffffff) == -llong(0x80000000, 1));
789 LLAssert(llong(0x80000000, 0) == -llong(0x80000000, 0)); // !!! we don't han dle overflow
790
791 // operator-=
792 {
793 llong n;
794 LLAssert((n -= llong(0, 1)) == llong(0xffffffff, 0xffffffff));
795 LLAssert(n == llong(0xffffffff, 0xffffffff));
796
797 n = llong(1, 0);
798 LLAssert((n -= llong(0, 1)) == llong(0, 0xffffffff));
799 LLAssert(n == llong(0, 0xffffffff));
800 }
801
802 // operator-
803 {
804 llong n;
805 LLAssert((n - llong(0, 1)) == llong(0xffffffff, 0xffffffff));
806 LLAssert(n == llong(0, 0));
807
808 n = llong(1, 0);
809 LLAssert((n - llong(0, 1)) == llong(0, 0xffffffff));
810 LLAssert(n == llong(1, 0));
811 }
812
813 // operator+=
814 {
815 llong n(0xffffffff, 0xffffffff);
816 LLAssert((n += llong(0, 1)) == llong(0, 0));
817 LLAssert(n == llong(0, 0));
818
819 n = llong(0, 0xffffffff);
820 LLAssert((n += llong(0, 1)) == llong(1, 0));
821 LLAssert(n == llong(1, 0));
822 }
823
824 // operator+
825 {
826 llong n(0xffffffff, 0xffffffff);
827 LLAssert((n + llong(0, 1)) == llong(0, 0));
828 LLAssert(n == llong(0xffffffff, 0xffffffff));
829
830 n = llong(0, 0xffffffff);
831 LLAssert((n + llong(0, 1)) == llong(1, 0));
832 LLAssert(n == llong(0, 0xffffffff));
833 }
834
835 }
836
837 void IntlTestRBNF::TestLLong()
838 {
839 logln("Starting TestLLong");
840
841 TestLLongConstructors();
842
843 TestLLongSimpleOperators();
844
845 logln("Testing operator*=, operator*");
846
847 // operator*=, operator*
848 // small and large values, positive, &NEGative, zero
849 // also test commutivity
850 {
851 const llong ZERO;
852 const llong ONE(0, 1);
853 const llong NEG_ONE((int32_t)-1);
854 const llong THREE(0, 3);
855 const llong NEG_THREE((int32_t)-3);
856 const llong TWO_TO_16(0, 0x10000);
857 const llong NEG_TWO_TO_16 = -TWO_TO_16;
858 const llong TWO_TO_32(1, 0);
859 const llong NEG_TWO_TO_32 = -TWO_TO_32;
860
861 const llong NINE(0, 9);
862 const llong NEG_NINE = -NINE;
863
864 const llong TWO_TO_16X3(0, 0x00030000);
865 const llong NEG_TWO_TO_16X3 = -TWO_TO_16X3;
866
867 const llong TWO_TO_32X3(3, 0);
868 const llong NEG_TWO_TO_32X3 = -TWO_TO_32X3;
869
870 const llong TWO_TO_48(0x10000, 0);
871 const llong NEG_TWO_TO_48 = -TWO_TO_48;
872
873 const int32_t VALUE_WIDTH = 9;
874 const llong* values[VALUE_WIDTH] = {
875 &ZERO, &ONE, &NEG_ONE, &THREE, &NEG_THREE, &TWO_TO_16, &NEG_TWO_TO_1 6, &TWO_TO_32, &NEG_TWO_TO_32
876 };
877
878 const llong* answers[VALUE_WIDTH*VALUE_WIDTH] = {
879 &ZERO, &ZERO, &ZERO, &ZERO, &ZERO, &ZERO, &ZERO, &ZERO, &ZERO,
880 &ZERO, &ONE, &NEG_ONE, &THREE, &NEG_THREE, &TWO_TO_16, &NEG_TWO_TO _16, &TWO_TO_32, &NEG_TWO_TO_32,
881 &ZERO, &NEG_ONE, &ONE, &NEG_THREE, &THREE, &NEG_TWO_TO_16, &TWO_TO_1 6, &NEG_TWO_TO_32, &TWO_TO_32,
882 &ZERO, &THREE, &NEG_THREE, &NINE, &NEG_NINE, &TWO_TO_16X3, &NEG_TWO_ TO_16X3, &TWO_TO_32X3, &NEG_TWO_TO_32X3,
883 &ZERO, &NEG_THREE, &THREE, &NEG_NINE, &NINE, &NEG_TWO_TO_16X3, &TWO_ TO_16X3, &NEG_TWO_TO_32X3, &TWO_TO_32X3,
884 &ZERO, &TWO_TO_16, &NEG_TWO_TO_16, &TWO_TO_16X3, &NEG_TWO_TO_16X3, & TWO_TO_32, &NEG_TWO_TO_32, &TWO_TO_48, &NEG_TWO_TO_48,
885 &ZERO, &NEG_TWO_TO_16, &TWO_TO_16, &NEG_TWO_TO_16X3, &TWO_TO_16X3, & NEG_TWO_TO_32, &TWO_TO_32, &NEG_TWO_TO_48, &TWO_TO_48,
886 &ZERO, &TWO_TO_32, &NEG_TWO_TO_32, &TWO_TO_32X3, &NEG_TWO_TO_32X3, & TWO_TO_48, &NEG_TWO_TO_48, &ZERO, &ZERO,
887 &ZERO, &NEG_TWO_TO_32, &TWO_TO_32, &NEG_TWO_TO_32X3, &TWO_TO_32X3, & NEG_TWO_TO_48, &TWO_TO_48, &ZERO, &ZERO
888 };
889
890 for (int i = 0; i < VALUE_WIDTH; ++i) {
891 for (int j = 0; j < VALUE_WIDTH; ++j) {
892 llong lhs = *values[i];
893 llong rhs = *values[j];
894 llong ans = *answers[i*VALUE_WIDTH + j];
895
896 llong n = lhs;
897
898 LLAssert((n *= rhs) == ans);
899 LLAssert(n == ans);
900
901 n = lhs;
902 LLAssert((n * rhs) == ans);
903 LLAssert(n == lhs);
904 }
905 }
906 }
907
908 logln("Testing operator/=, operator/");
909 // operator/=, operator/
910 // test num = 0, div = 0, pos/neg, > 2^32, div > num
911 {
912 const llong ZERO;
913 const llong ONE(0, 1);
914 const llong NEG_ONE = -ONE;
915 const llong MAX(0x7fffffff, 0xffffffff);
916 const llong MIN(0x80000000, 0);
917 const llong TWO(0, 2);
918 const llong NEG_TWO = -TWO;
919 const llong FIVE(0, 5);
920 const llong NEG_FIVE = -FIVE;
921 const llong TWO_TO_32(1, 0);
922 const llong NEG_TWO_TO_32 = -TWO_TO_32;
923 const llong TWO_TO_32d5 = llong(TWO_TO_32.asDouble()/5.0);
924 const llong NEG_TWO_TO_32d5 = -TWO_TO_32d5;
925 const llong TWO_TO_32X5 = TWO_TO_32 * FIVE;
926 const llong NEG_TWO_TO_32X5 = -TWO_TO_32X5;
927
928 const llong* tuples[] = { // lhs, rhs, ans
929 &ZERO, &ZERO, &ZERO,
930 &ONE, &ZERO,&MAX,
931 &NEG_ONE, &ZERO, &MIN,
932 &ONE, &ONE, &ONE,
933 &ONE, &NEG_ONE, &NEG_ONE,
934 &NEG_ONE, &ONE, &NEG_ONE,
935 &NEG_ONE, &NEG_ONE, &ONE,
936 &FIVE, &TWO, &TWO,
937 &FIVE, &NEG_TWO, &NEG_TWO,
938 &NEG_FIVE, &TWO, &NEG_TWO,
939 &NEG_FIVE, &NEG_TWO, &TWO,
940 &TWO, &FIVE, &ZERO,
941 &TWO, &NEG_FIVE, &ZERO,
942 &NEG_TWO, &FIVE, &ZERO,
943 &NEG_TWO, &NEG_FIVE, &ZERO,
944 &TWO_TO_32, &TWO_TO_32, &ONE,
945 &TWO_TO_32, &NEG_TWO_TO_32, &NEG_ONE,
946 &NEG_TWO_TO_32, &TWO_TO_32, &NEG_ONE,
947 &NEG_TWO_TO_32, &NEG_TWO_TO_32, &ONE,
948 &TWO_TO_32, &FIVE, &TWO_TO_32d5,
949 &TWO_TO_32, &NEG_FIVE, &NEG_TWO_TO_32d5,
950 &NEG_TWO_TO_32, &FIVE, &NEG_TWO_TO_32d5,
951 &NEG_TWO_TO_32, &NEG_FIVE, &TWO_TO_32d5,
952 &TWO_TO_32X5, &FIVE, &TWO_TO_32,
953 &TWO_TO_32X5, &NEG_FIVE, &NEG_TWO_TO_32,
954 &NEG_TWO_TO_32X5, &FIVE, &NEG_TWO_TO_32,
955 &NEG_TWO_TO_32X5, &NEG_FIVE, &TWO_TO_32,
956 &TWO_TO_32X5, &TWO_TO_32, &FIVE,
957 &TWO_TO_32X5, &NEG_TWO_TO_32, &NEG_FIVE,
958 &NEG_TWO_TO_32X5, &NEG_TWO_TO_32, &FIVE,
959 &NEG_TWO_TO_32X5, &TWO_TO_32, &NEG_FIVE
960 };
961 const int TUPLE_WIDTH = 3;
962 const int TUPLE_COUNT = (int)(sizeof(tuples)/sizeof(tuples[0]))/TUPLE_WI DTH;
963 for (int i = 0; i < TUPLE_COUNT; ++i) {
964 const llong lhs = *tuples[i*TUPLE_WIDTH+0];
965 const llong rhs = *tuples[i*TUPLE_WIDTH+1];
966 const llong ans = *tuples[i*TUPLE_WIDTH+2];
967
968 llong n = lhs;
969 if (!((n /= rhs) == ans)) {
970 errln("fail: (n /= rhs) == ans");
971 }
972 LLAssert(n == ans);
973
974 n = lhs;
975 LLAssert((n / rhs) == ans);
976 LLAssert(n == lhs);
977 }
978 }
979
980 logln("Testing operator%%=, operator%%");
981 //operator%=, operator%
982 {
983 const llong ZERO;
984 const llong ONE(0, 1);
985 const llong TWO(0, 2);
986 const llong THREE(0,3);
987 const llong FOUR(0, 4);
988 const llong FIVE(0, 5);
989 const llong SIX(0, 6);
990
991 const llong NEG_ONE = -ONE;
992 const llong NEG_TWO = -TWO;
993 const llong NEG_THREE = -THREE;
994 const llong NEG_FOUR = -FOUR;
995 const llong NEG_FIVE = -FIVE;
996 const llong NEG_SIX = -SIX;
997
998 const llong NINETY_NINE(0, 99);
999 const llong HUNDRED(0, 100);
1000 const llong HUNDRED_ONE(0, 101);
1001
1002 const llong BIG(0x12345678, 0x9abcdef0);
1003 const llong BIG_FIVE(BIG * FIVE);
1004 const llong BIG_FIVEm1 = BIG_FIVE - ONE;
1005 const llong BIG_FIVEp1 = BIG_FIVE + ONE;
1006
1007 const llong* tuples[] = {
1008 &ZERO, &FIVE, &ZERO,
1009 &ONE, &FIVE, &ONE,
1010 &TWO, &FIVE, &TWO,
1011 &THREE, &FIVE, &THREE,
1012 &FOUR, &FIVE, &FOUR,
1013 &FIVE, &FIVE, &ZERO,
1014 &SIX, &FIVE, &ONE,
1015 &ZERO, &NEG_FIVE, &ZERO,
1016 &ONE, &NEG_FIVE, &ONE,
1017 &TWO, &NEG_FIVE, &TWO,
1018 &THREE, &NEG_FIVE, &THREE,
1019 &FOUR, &NEG_FIVE, &FOUR,
1020 &FIVE, &NEG_FIVE, &ZERO,
1021 &SIX, &NEG_FIVE, &ONE,
1022 &NEG_ONE, &FIVE, &NEG_ONE,
1023 &NEG_TWO, &FIVE, &NEG_TWO,
1024 &NEG_THREE, &FIVE, &NEG_THREE,
1025 &NEG_FOUR, &FIVE, &NEG_FOUR,
1026 &NEG_FIVE, &FIVE, &ZERO,
1027 &NEG_SIX, &FIVE, &NEG_ONE,
1028 &NEG_ONE, &NEG_FIVE, &NEG_ONE,
1029 &NEG_TWO, &NEG_FIVE, &NEG_TWO,
1030 &NEG_THREE, &NEG_FIVE, &NEG_THREE,
1031 &NEG_FOUR, &NEG_FIVE, &NEG_FOUR,
1032 &NEG_FIVE, &NEG_FIVE, &ZERO,
1033 &NEG_SIX, &NEG_FIVE, &NEG_ONE,
1034 &NINETY_NINE, &FIVE, &FOUR,
1035 &HUNDRED, &FIVE, &ZERO,
1036 &HUNDRED_ONE, &FIVE, &ONE,
1037 &BIG_FIVEm1, &FIVE, &FOUR,
1038 &BIG_FIVE, &FIVE, &ZERO,
1039 &BIG_FIVEp1, &FIVE, &ONE
1040 };
1041 const int TUPLE_WIDTH = 3;
1042 const int TUPLE_COUNT = (int)(sizeof(tuples)/sizeof(tuples[0]))/TUPLE_WI DTH;
1043 for (int i = 0; i < TUPLE_COUNT; ++i) {
1044 const llong lhs = *tuples[i*TUPLE_WIDTH+0];
1045 const llong rhs = *tuples[i*TUPLE_WIDTH+1];
1046 const llong ans = *tuples[i*TUPLE_WIDTH+2];
1047
1048 llong n = lhs;
1049 if (!((n %= rhs) == ans)) {
1050 errln("fail: (n %= rhs) == ans");
1051 }
1052 LLAssert(n == ans);
1053
1054 n = lhs;
1055 LLAssert((n % rhs) == ans);
1056 LLAssert(n == lhs);
1057 }
1058 }
1059
1060 logln("Testing pow");
1061 // pow
1062 LLAssert(llong(0, 0).pow(0) == llong(0, 0));
1063 LLAssert(llong(0, 0).pow(2) == llong(0, 0));
1064 LLAssert(llong(0, 2).pow(0) == llong(0, 1));
1065 LLAssert(llong(0, 2).pow(2) == llong(0, 4));
1066 LLAssert(llong(0, 2).pow(32) == llong(1, 0));
1067 LLAssert(llong(0, 5).pow(10) == llong((double)5.0 * 5 * 5 * 5 * 5 * 5 * 5 * 5 * 5 * 5));
1068
1069 // absolute value
1070 {
1071 const llong n(0xffffffff,0xffffffff);
1072 LLAssert(n.abs() == llong(0, 1));
1073 }
1074
1075 #ifdef RBNF_DEBUG
1076 logln("Testing atoll");
1077 // atoll
1078 const char empty[] = "";
1079 const char zero[] = "0";
1080 const char neg_one[] = "-1";
1081 const char neg_12345[] = "-12345";
1082 const char big1[] = "123456789abcdef0";
1083 const char big2[] = "fFfFfFfFfFfFfFfF";
1084 LLAssert(llong::atoll(empty) == llong(0, 0));
1085 LLAssert(llong::atoll(zero) == llong(0, 0));
1086 LLAssert(llong::atoll(neg_one) == llong(0xffffffff, 0xffffffff));
1087 LLAssert(llong::atoll(neg_12345) == -llong(0, 12345));
1088 LLAssert(llong::atoll(big1, 16) == llong(0x12345678, 0x9abcdef0));
1089 LLAssert(llong::atoll(big2, 16) == llong(0xffffffff, 0xffffffff));
1090 #endif
1091
1092 // u_atoll
1093 const UChar uempty[] = { 0 };
1094 const UChar uzero[] = { 0x30, 0 };
1095 const UChar uneg_one[] = { 0x2d, 0x31, 0 };
1096 const UChar uneg_12345[] = { 0x2d, 0x31, 0x32, 0x33, 0x34, 0x35, 0 };
1097 const UChar ubig1[] = { 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39 , 0x61, 0x62, 0x63, 0x64, 0x65, 0x66, 0x30, 0 };
1098 const UChar ubig2[] = { 0x66, 0x46, 0x66, 0x46, 0x66, 0x46, 0x66, 0x46, 0x66 , 0x46, 0x66, 0x46, 0x66, 0x46, 0x66, 0x46, 0 };
1099 LLAssert(llong::utoll(uempty) == llong(0, 0));
1100 LLAssert(llong::utoll(uzero) == llong(0, 0));
1101 LLAssert(llong::utoll(uneg_one) == llong(0xffffffff, 0xffffffff));
1102 LLAssert(llong::utoll(uneg_12345) == -llong(0, 12345));
1103 LLAssert(llong::utoll(ubig1, 16) == llong(0x12345678, 0x9abcdef0));
1104 LLAssert(llong::utoll(ubig2, 16) == llong(0xffffffff, 0xffffffff));
1105
1106 #ifdef RBNF_DEBUG
1107 logln("Testing lltoa");
1108 // lltoa
1109 {
1110 char buf[64]; // ascii
1111 LLAssert((llong(0, 0).lltoa(buf, (uint32_t)sizeof(buf)) == 1) && (strcmp (buf, zero) == 0));
1112 LLAssert((llong(0xffffffff, 0xffffffff).lltoa(buf, (uint32_t)sizeof(buf) ) == 2) && (strcmp(buf, neg_one) == 0));
1113 LLAssert(((-llong(0, 12345)).lltoa(buf, (uint32_t)sizeof(buf)) == 6) && (strcmp(buf, neg_12345) == 0));
1114 LLAssert((llong(0x12345678, 0x9abcdef0).lltoa(buf, (uint32_t)sizeof(buf) , 16) == 16) && (strcmp(buf, big1) == 0));
1115 }
1116 #endif
1117
1118 logln("Testing u_lltoa");
1119 // u_lltoa
1120 {
1121 UChar buf[64];
1122 LLAssert((llong(0, 0).lltou(buf, (uint32_t)sizeof(buf)) == 1) && (u_strc mp(buf, uzero) == 0));
1123 LLAssert((llong(0xffffffff, 0xffffffff).lltou(buf, (uint32_t)sizeof(buf) ) == 2) && (u_strcmp(buf, uneg_one) == 0));
1124 LLAssert(((-llong(0, 12345)).lltou(buf, (uint32_t)sizeof(buf)) == 6) && (u_strcmp(buf, uneg_12345) == 0));
1125 LLAssert((llong(0x12345678, 0x9abcdef0).lltou(buf, (uint32_t)sizeof(buf) , 16) == 16) && (u_strcmp(buf, ubig1) == 0));
1126 }
1127 }
1128
1129 /* if 0 */
1130 #endif
1131
1132 void
1133 IntlTestRBNF::TestEnglishSpellout()
1134 {
1135 UErrorCode status = U_ZERO_ERROR;
1136 RuleBasedNumberFormat* formatter
1137 = new RuleBasedNumberFormat(URBNF_SPELLOUT, Locale::getUS(), status);
1138 if (U_FAILURE(status)) {
1139 errcheckln(status, "FAIL: could not construct formatter - %s", u_errorNa me(status));
1140 } else {
1141 static const char* const testData[][2] = {
1142 { "1", "one" },
1143 { "2", "two" },
1144 { "15", "fifteen" },
1145 { "20", "twenty" },
1146 { "23", "twenty-three" },
1147 { "73", "seventy-three" },
1148 { "88", "eighty-eight" },
1149 { "100", "one hundred" },
1150 { "106", "one hundred six" },
1151 { "127", "one hundred twenty-seven" },
1152 { "200", "two hundred" },
1153 { "579", "five hundred seventy-nine" },
1154 { "1,000", "one thousand" },
1155 { "2,000", "two thousand" },
1156 { "3,004", "three thousand four" },
1157 { "4,567", "four thousand five hundred sixty-seven" },
1158 { "15,943", "fifteen thousand nine hundred forty-three" },
1159 { "2,345,678", "two million three hundred forty-five thousand six hu ndred seventy-eight" },
1160 { "-36", "minus thirty-six" },
1161 { "234.567", "two hundred thirty-four point five six seven" },
1162 { NULL, NULL}
1163 };
1164
1165 doTest(formatter, testData, TRUE);
1166
1167 #if !UCONFIG_NO_COLLATION
1168 if( !logKnownIssue("9503") ) {
1169 formatter->setLenient(TRUE);
1170 static const char* lpTestData[][2] = {
1171 { "fifty-7", "57" },
1172 { " fifty-7", "57" },
1173 { " fifty-7", "57" },
1174 { "2 thousand six HUNDRED fifty-7", "2,657" },
1175 { "fifteen hundred and zero", "1,500" },
1176 { "FOurhundred thiRTY six", "436" },
1177 { NULL, NULL}
1178 };
1179 doLenientParseTest(formatter, lpTestData);
1180 }
1181 #endif
1182 }
1183 delete formatter;
1184 }
1185
1186 void
1187 IntlTestRBNF::TestOrdinalAbbreviations()
1188 {
1189 UErrorCode status = U_ZERO_ERROR;
1190 RuleBasedNumberFormat* formatter
1191 = new RuleBasedNumberFormat(URBNF_ORDINAL, Locale::getUS(), status);
1192
1193 if (U_FAILURE(status)) {
1194 errcheckln(status, "FAIL: could not construct formatter - %s", u_errorNa me(status));
1195 } else {
1196 static const char* const testData[][2] = {
1197 { "1", "1st" },
1198 { "2", "2nd" },
1199 { "3", "3rd" },
1200 { "4", "4th" },
1201 { "7", "7th" },
1202 { "10", "10th" },
1203 { "11", "11th" },
1204 { "13", "13th" },
1205 { "20", "20th" },
1206 { "21", "21st" },
1207 { "22", "22nd" },
1208 { "23", "23rd" },
1209 { "24", "24th" },
1210 { "33", "33rd" },
1211 { "102", "102nd" },
1212 { "312", "312th" },
1213 { "12,345", "12,345th" },
1214 { NULL, NULL}
1215 };
1216
1217 doTest(formatter, testData, FALSE);
1218 }
1219 delete formatter;
1220 }
1221
1222 void
1223 IntlTestRBNF::TestDurations()
1224 {
1225 UErrorCode status = U_ZERO_ERROR;
1226 RuleBasedNumberFormat* formatter
1227 = new RuleBasedNumberFormat(URBNF_DURATION, Locale::getUS(), status);
1228
1229 if (U_FAILURE(status)) {
1230 errcheckln(status, "FAIL: could not construct formatter - %s", u_errorNa me(status));
1231 } else {
1232 static const char* const testData[][2] = {
1233 { "3,600", "1:00:00" }, //move me and I fail
1234 { "0", "0 sec." },
1235 { "1", "1 sec." },
1236 { "24", "24 sec." },
1237 { "60", "1:00" },
1238 { "73", "1:13" },
1239 { "145", "2:25" },
1240 { "666", "11:06" },
1241 // { "3,600", "1:00:00" },
1242 { "3,740", "1:02:20" },
1243 { "10,293", "2:51:33" },
1244 { NULL, NULL}
1245 };
1246
1247 doTest(formatter, testData, TRUE);
1248
1249 #if !UCONFIG_NO_COLLATION
1250 formatter->setLenient(TRUE);
1251 static const char* lpTestData[][2] = {
1252 { "2-51-33", "10,293" },
1253 { NULL, NULL}
1254 };
1255 doLenientParseTest(formatter, lpTestData);
1256 #endif
1257 }
1258 delete formatter;
1259 }
1260
1261 void
1262 IntlTestRBNF::TestSpanishSpellout()
1263 {
1264 UErrorCode status = U_ZERO_ERROR;
1265 RuleBasedNumberFormat* formatter
1266 = new RuleBasedNumberFormat(URBNF_SPELLOUT, Locale("es", "ES", ""), stat us);
1267
1268 if (U_FAILURE(status)) {
1269 errcheckln(status, "FAIL: could not construct formatter - %s", u_errorNa me(status));
1270 } else {
1271 static const char* const testData[][2] = {
1272 { "1", "uno" },
1273 { "6", "seis" },
1274 { "16", "diecis\\u00e9is" },
1275 { "20", "veinte" },
1276 { "24", "veinticuatro" },
1277 { "26", "veintis\\u00e9is" },
1278 { "73", "setenta y tres" },
1279 { "88", "ochenta y ocho" },
1280 { "100", "cien" },
1281 { "106", "ciento seis" },
1282 { "127", "ciento veintisiete" },
1283 { "200", "doscientos" },
1284 { "579", "quinientos setenta y nueve" },
1285 { "1,000", "mil" },
1286 { "2,000", "dos mil" },
1287 { "3,004", "tres mil cuatro" },
1288 { "4,567", "cuatro mil quinientos sesenta y siete" },
1289 { "15,943", "quince mil novecientos cuarenta y tres" },
1290 { "2,345,678", "dos millones trescientos cuarenta y cinco mil seisci entos setenta y ocho"},
1291 { "-36", "menos treinta y seis" },
1292 { "234.567", "doscientos treinta y cuatro coma cinco seis siete" },
1293 { NULL, NULL}
1294 };
1295
1296 doTest(formatter, testData, TRUE);
1297 }
1298 delete formatter;
1299 }
1300
1301 void
1302 IntlTestRBNF::TestFrenchSpellout()
1303 {
1304 UErrorCode status = U_ZERO_ERROR;
1305 RuleBasedNumberFormat* formatter
1306 = new RuleBasedNumberFormat(URBNF_SPELLOUT, Locale::getFrance(), status) ;
1307
1308 if (U_FAILURE(status)) {
1309 errcheckln(status, "FAIL: could not construct formatter - %s", u_errorNa me(status));
1310 } else {
1311 static const char* const testData[][2] = {
1312 { "1", "un" },
1313 { "15", "quinze" },
1314 { "20", "vingt" },
1315 { "21", "vingt-et-un" },
1316 { "23", "vingt-trois" },
1317 { "62", "soixante-deux" },
1318 { "70", "soixante-dix" },
1319 { "71", "soixante-et-onze" },
1320 { "73", "soixante-treize" },
1321 { "80", "quatre-vingts" },
1322 { "88", "quatre-vingt-huit" },
1323 { "100", "cent" },
1324 { "106", "cent six" },
1325 { "127", "cent vingt-sept" },
1326 { "200", "deux cents" },
1327 { "579", "cinq cent soixante-dix-neuf" },
1328 { "1,000", "mille" },
1329 { "1,123", "mille cent vingt-trois" },
1330 { "1,594", "mille cinq cent quatre-vingt-quatorze" },
1331 { "2,000", "deux mille" },
1332 { "3,004", "trois mille quatre" },
1333 { "4,567", "quatre mille cinq cent soixante-sept" },
1334 { "15,943", "quinze mille neuf cent quarante-trois" },
1335 { "2,345,678", "deux millions trois cent quarante-cinq mille six cen t soixante-dix-huit" },
1336 { "-36", "moins trente-six" },
1337 { "234.567", "deux cent trente-quatre virgule cinq six sept" },
1338 { NULL, NULL}
1339 };
1340
1341 doTest(formatter, testData, TRUE);
1342
1343 #if !UCONFIG_NO_COLLATION
1344 formatter->setLenient(TRUE);
1345 static const char* lpTestData[][2] = {
1346 { "trente-et-un", "31" },
1347 { "un cent quatre vingt dix huit", "198" },
1348 { NULL, NULL}
1349 };
1350 doLenientParseTest(formatter, lpTestData);
1351 #endif
1352 }
1353 delete formatter;
1354 }
1355
1356 static const char* const swissFrenchTestData[][2] = {
1357 { "1", "un" },
1358 { "15", "quinze" },
1359 { "20", "vingt" },
1360 { "21", "vingt-et-un" },
1361 { "23", "vingt-trois" },
1362 { "62", "soixante-deux" },
1363 { "70", "septante" },
1364 { "71", "septante-et-un" },
1365 { "73", "septante-trois" },
1366 { "80", "huitante" },
1367 { "88", "huitante-huit" },
1368 { "100", "cent" },
1369 { "106", "cent six" },
1370 { "127", "cent vingt-sept" },
1371 { "200", "deux cents" },
1372 { "579", "cinq cent septante-neuf" },
1373 { "1,000", "mille" },
1374 { "1,123", "mille cent vingt-trois" },
1375 { "1,594", "mille cinq cent nonante-quatre" },
1376 { "2,000", "deux mille" },
1377 { "3,004", "trois mille quatre" },
1378 { "4,567", "quatre mille cinq cent soixante-sept" },
1379 { "15,943", "quinze mille neuf cent quarante-trois" },
1380 { "2,345,678", "deux millions trois cent quarante-cinq mille six cent septan te-huit" },
1381 { "-36", "moins trente-six" },
1382 { "234.567", "deux cent trente-quatre virgule cinq six sept" },
1383 { NULL, NULL}
1384 };
1385
1386 void
1387 IntlTestRBNF::TestSwissFrenchSpellout()
1388 {
1389 UErrorCode status = U_ZERO_ERROR;
1390 RuleBasedNumberFormat* formatter
1391 = new RuleBasedNumberFormat(URBNF_SPELLOUT, Locale("fr", "CH", ""), stat us);
1392
1393 if (U_FAILURE(status)) {
1394 errcheckln(status, "FAIL: could not construct formatter - %s", u_errorNa me(status));
1395 } else {
1396 doTest(formatter, swissFrenchTestData, TRUE);
1397 }
1398 delete formatter;
1399 }
1400
1401 static const char* const belgianFrenchTestData[][2] = {
1402 { "1", "un" },
1403 { "15", "quinze" },
1404 { "20", "vingt" },
1405 { "21", "vingt-et-un" },
1406 { "23", "vingt-trois" },
1407 { "62", "soixante-deux" },
1408 { "70", "septante" },
1409 { "71", "septante-et-un" },
1410 { "73", "septante-trois" },
1411 { "80", "quatre-vingts" },
1412 { "88", "quatre-vingt huit" },
1413 { "90", "nonante" },
1414 { "91", "nonante-et-un" },
1415 { "95", "nonante-cinq" },
1416 { "100", "cent" },
1417 { "106", "cent six" },
1418 { "127", "cent vingt-sept" },
1419 { "200", "deux cents" },
1420 { "579", "cinq cent septante-neuf" },
1421 { "1,000", "mille" },
1422 { "1,123", "mille cent vingt-trois" },
1423 { "1,594", "mille cinq cent nonante-quatre" },
1424 { "2,000", "deux mille" },
1425 { "3,004", "trois mille quatre" },
1426 { "4,567", "quatre mille cinq cent soixante-sept" },
1427 { "15,943", "quinze mille neuf cent quarante-trois" },
1428 { "2,345,678", "deux millions trois cent quarante-cinq mille six cent septan te-huit" },
1429 { "-36", "moins trente-six" },
1430 { "234.567", "deux cent trente-quatre virgule cinq six sept" },
1431 { NULL, NULL}
1432 };
1433
1434
1435 void
1436 IntlTestRBNF::TestBelgianFrenchSpellout()
1437 {
1438 UErrorCode status = U_ZERO_ERROR;
1439 RuleBasedNumberFormat* formatter
1440 = new RuleBasedNumberFormat(URBNF_SPELLOUT, Locale("fr", "BE", ""), stat us);
1441
1442 if (U_FAILURE(status)) {
1443 errcheckln(status, "rbnf status: 0x%x (%s)\n", status, u_errorName(statu s));
1444 errcheckln(status, "FAIL: could not construct formatter - %s", u_errorNa me(status));
1445 } else {
1446 // Belgian french should match Swiss french.
1447 doTest(formatter, belgianFrenchTestData, TRUE);
1448 }
1449 delete formatter;
1450 }
1451
1452 void
1453 IntlTestRBNF::TestItalianSpellout()
1454 {
1455 UErrorCode status = U_ZERO_ERROR;
1456 RuleBasedNumberFormat* formatter
1457 = new RuleBasedNumberFormat(URBNF_SPELLOUT, Locale::getItalian(), status );
1458
1459 if (U_FAILURE(status)) {
1460 errcheckln(status, "FAIL: could not construct formatter - %s", u_errorNa me(status));
1461 } else {
1462 static const char* const testData[][2] = {
1463 { "1", "uno" },
1464 { "15", "quindici" },
1465 { "20", "venti" },
1466 { "23", "venti\\u00ADtr\\u00E9" },
1467 { "73", "settanta\\u00ADtr\\u00E9" },
1468 { "88", "ottant\\u00ADotto" },
1469 { "100", "cento" },
1470 { "101", "cento\\u00ADuno" },
1471 { "103", "cento\\u00ADtr\\u00E9" },
1472 { "106", "cento\\u00ADsei" },
1473 { "108", "cent\\u00ADotto" },
1474 { "127", "cento\\u00ADventi\\u00ADsette" },
1475 { "181", "cent\\u00ADottant\\u00ADuno" },
1476 { "200", "due\\u00ADcento" },
1477 { "579", "cinque\\u00ADcento\\u00ADsettanta\\u00ADnove" },
1478 { "1,000", "mille" },
1479 { "2,000", "due\\u00ADmila" },
1480 { "3,004", "tre\\u00ADmila\\u00ADquattro" },
1481 { "4,567", "quattro\\u00ADmila\\u00ADcinque\\u00ADcento\\u00ADsessan ta\\u00ADsette" },
1482 { "15,943", "quindici\\u00ADmila\\u00ADnove\\u00ADcento\\u00ADquaran ta\\u00ADtr\\u00E9" },
1483 { "-36", "meno trenta\\u00ADsei" },
1484 { "234.567", "due\\u00ADcento\\u00ADtrenta\\u00ADquattro virgola cin que sei sette" },
1485 { NULL, NULL}
1486 };
1487
1488 doTest(formatter, testData, TRUE);
1489 }
1490 delete formatter;
1491 }
1492
1493 void
1494 IntlTestRBNF::TestPortugueseSpellout()
1495 {
1496 UErrorCode status = U_ZERO_ERROR;
1497 RuleBasedNumberFormat* formatter
1498 = new RuleBasedNumberFormat(URBNF_SPELLOUT, Locale("pt","BR",""), status );
1499
1500 if (U_FAILURE(status)) {
1501 errcheckln(status, "FAIL: could not construct formatter - %s", u_errorNa me(status));
1502 } else {
1503 static const char* const testData[][2] = {
1504 { "1", "um" },
1505 { "15", "quinze" },
1506 { "20", "vinte" },
1507 { "23", "vinte e tr\\u00EAs" },
1508 { "73", "setenta e tr\\u00EAs" },
1509 { "88", "oitenta e oito" },
1510 { "100", "cem" },
1511 { "106", "cento e seis" },
1512 { "108", "cento e oito" },
1513 { "127", "cento e vinte e sete" },
1514 { "181", "cento e oitenta e um" },
1515 { "200", "duzentos" },
1516 { "579", "quinhentos e setenta e nove" },
1517 { "1,000", "mil" },
1518 { "2,000", "dois mil" },
1519 { "3,004", "tr\\u00EAs mil e quatro" },
1520 { "4,567", "quatro mil e quinhentos e sessenta e sete" },
1521 { "15,943", "quinze mil e novecentos e quarenta e tr\\u00EAs" },
1522 { "-36", "menos trinta e seis" },
1523 { "234.567", "duzentos e trinta e quatro v\\u00EDrgula cinco seis se te" },
1524 { NULL, NULL}
1525 };
1526
1527 doTest(formatter, testData, TRUE);
1528 }
1529 delete formatter;
1530 }
1531 void
1532 IntlTestRBNF::TestGermanSpellout()
1533 {
1534 UErrorCode status = U_ZERO_ERROR;
1535 RuleBasedNumberFormat* formatter
1536 = new RuleBasedNumberFormat(URBNF_SPELLOUT, Locale::getGermany(), status );
1537
1538 if (U_FAILURE(status)) {
1539 errcheckln(status, "FAIL: could not construct formatter - %s", u_errorNa me(status));
1540 } else {
1541 static const char* const testData[][2] = {
1542 { "1", "eins" },
1543 { "15", "f\\u00fcnfzehn" },
1544 { "20", "zwanzig" },
1545 { "23", "drei\\u00ADund\\u00ADzwanzig" },
1546 { "73", "drei\\u00ADund\\u00ADsiebzig" },
1547 { "88", "acht\\u00ADund\\u00ADachtzig" },
1548 { "100", "ein\\u00ADhundert" },
1549 { "106", "ein\\u00ADhundert\\u00ADsechs" },
1550 { "127", "ein\\u00ADhundert\\u00ADsieben\\u00ADund\\u00ADzwanzig" },
1551 { "200", "zwei\\u00ADhundert" },
1552 { "579", "f\\u00fcnf\\u00ADhundert\\u00ADneun\\u00ADund\\u00ADsiebzi g" },
1553 { "1,000", "ein\\u00ADtausend" },
1554 { "2,000", "zwei\\u00ADtausend" },
1555 { "3,004", "drei\\u00ADtausend\\u00ADvier" },
1556 { "4,567", "vier\\u00ADtausend\\u00ADf\\u00fcnf\\u00ADhundert\\u00AD sieben\\u00ADund\\u00ADsechzig" },
1557 { "15,943", "f\\u00fcnfzehn\\u00ADtausend\\u00ADneun\\u00ADhundert\\ u00ADdrei\\u00ADund\\u00ADvierzig" },
1558 { "2,345,678", "zwei Millionen drei\\u00ADhundert\\u00ADf\\u00fcnf\\ u00ADund\\u00ADvierzig\\u00ADtausend\\u00ADsechs\\u00ADhundert\\u00ADacht\\u00AD und\\u00ADsiebzig" },
1559 { NULL, NULL}
1560 };
1561
1562 doTest(formatter, testData, TRUE);
1563
1564 #if !UCONFIG_NO_COLLATION
1565 formatter->setLenient(TRUE);
1566 static const char* lpTestData[][2] = {
1567 { "ein Tausend sechs Hundert fuenfunddreissig", "1,635" },
1568 { NULL, NULL}
1569 };
1570 doLenientParseTest(formatter, lpTestData);
1571 #endif
1572 }
1573 delete formatter;
1574 }
1575
1576 void
1577 IntlTestRBNF::TestThaiSpellout()
1578 {
1579 UErrorCode status = U_ZERO_ERROR;
1580 RuleBasedNumberFormat* formatter
1581 = new RuleBasedNumberFormat(URBNF_SPELLOUT, Locale("th"), status);
1582
1583 if (U_FAILURE(status)) {
1584 errcheckln(status, "FAIL: could not construct formatter - %s", u_errorNa me(status));
1585 } else {
1586 static const char* const testData[][2] = {
1587 { "0", "\\u0e28\\u0e39\\u0e19\\u0e22\\u0e4c" },
1588 { "1", "\\u0e2b\\u0e19\\u0e36\\u0e48\\u0e07" },
1589 { "10", "\\u0e2a\\u0e34\\u0e1a" },
1590 { "11", "\\u0e2a\\u0e34\\u0e1a\\u200b\\u0e40\\u0e2d\\u0e47\\u0e14" } ,
1591 { "21", "\\u0e22\\u0e35\\u0e48\\u200b\\u0e2a\\u0e34\\u0e1a\\u200b\\u 0e40\\u0e2d\\u0e47\\u0e14" },
1592 { "101", "\\u0e2b\\u0e19\\u0e36\\u0e48\\u0e07\\u200b\\u0e23\\u0e49\\ u0e2d\\u0e22\\u200b\\u0e2b\\u0e19\\u0e36\\u0e48\\u0e07" },
1593 { "1.234", "\\u0e2b\\u0e19\\u0e36\\u0e48\\u0e07\\u200b\\u0e08\\u0e38 \\u0e14\\u200b\\u0e2a\\u0e2d\\u0e07\\u0e2a\\u0e32\\u0e21\\u0e2a\\u0e35\\u0e48" } ,
1594 { NULL, NULL}
1595 };
1596
1597 doTest(formatter, testData, TRUE);
1598 }
1599 delete formatter;
1600 }
1601
1602 void
1603 IntlTestRBNF::TestSwedishSpellout()
1604 {
1605 UErrorCode status = U_ZERO_ERROR;
1606 RuleBasedNumberFormat* formatter
1607 = new RuleBasedNumberFormat(URBNF_SPELLOUT, Locale("sv"), status);
1608
1609 if (U_FAILURE(status)) {
1610 errcheckln(status, "FAIL: could not construct formatter - %s", u_errorNa me(status));
1611 } else {
1612 static const char* testDataDefault[][2] = {
1613 { "101", "ett\\u00adhundra\\u00adett" },
1614 { "123", "ett\\u00adhundra\\u00adtjugo\\u00adtre" },
1615 { "1,001", "et\\u00adtusen ett" },
1616 { "1,100", "et\\u00adtusen ett\\u00adhundra" },
1617 { "1,101", "et\\u00adtusen ett\\u00adhundra\\u00adett" },
1618 { "1,234", "et\\u00adtusen tv\\u00e5\\u00adhundra\\u00adtrettio\\u00 adfyra" },
1619 { "10,001", "tio\\u00adtusen ett" },
1620 { "11,000", "elva\\u00adtusen" },
1621 { "12,000", "tolv\\u00adtusen" },
1622 { "20,000", "tjugo\\u00adtusen" },
1623 { "21,000", "tjugo\\u00adet\\u00adtusen" },
1624 { "21,001", "tjugo\\u00adet\\u00adtusen ett" },
1625 { "200,000", "tv\\u00e5\\u00adhundra\\u00adtusen" },
1626 { "201,000", "tv\\u00e5\\u00adhundra\\u00adet\\u00adtusen" },
1627 { "200,200", "tv\\u00e5\\u00adhundra\\u00adtusen tv\\u00e5\\u00adhun dra" },
1628 { "2,002,000", "tv\\u00e5 miljoner tv\\u00e5\\u00adtusen" },
1629 { "12,345,678", "tolv miljoner tre\\u00adhundra\\u00adfyrtio\\u00adf em\\u00adtusen sex\\u00adhundra\\u00adsjuttio\\u00ad\\u00e5tta" },
1630 { "123,456.789", "ett\\u00adhundra\\u00adtjugo\\u00adtre\\u00adtusen fyra\\u00adhundra\\u00adfemtio\\u00adsex komma sju \\u00e5tta nio" },
1631 { "-12,345.678", "minus tolv\\u00adtusen tre\\u00adhundra\\u00adfyrt io\\u00adfem komma sex sju \\u00e5tta" },
1632 { NULL, NULL }
1633 };
1634 doTest(formatter, testDataDefault, TRUE);
1635
1636 static const char* testDataNeutrum[][2] = {
1637 { "101", "ett\\u00adhundra\\u00adett" },
1638 { "1,001", "et\\u00adtusen ett" },
1639 { "1,101", "et\\u00adtusen ett\\u00adhundra\\u00adett" },
1640 { "10,001", "tio\\u00adtusen ett" },
1641 { "21,001", "tjugo\\u00adet\\u00adtusen ett" },
1642 { NULL, NULL }
1643 };
1644
1645 formatter->setDefaultRuleSet("%spellout-cardinal-neuter", status);
1646 if (U_SUCCESS(status)) {
1647 logln(" testing spellout-cardinal-neuter rules");
1648 doTest(formatter, testDataNeutrum, TRUE);
1649 }
1650 else {
1651 errln("Can't test spellout-cardinal-neuter rules");
1652 }
1653
1654 static const char* testDataYear[][2] = {
1655 { "101", "ett\\u00adhundra\\u00adett" },
1656 { "900", "nio\\u00adhundra" },
1657 { "1,001", "et\\u00adtusen ett" },
1658 { "1,100", "elva\\u00adhundra" },
1659 { "1,101", "elva\\u00adhundra\\u00adett" },
1660 { "1,234", "tolv\\u00adhundra\\u00adtrettio\\u00adfyra" },
1661 { "2,001", "tjugo\\u00adhundra\\u00adett" },
1662 { "10,001", "tio\\u00adtusen ett" },
1663 { NULL, NULL }
1664 };
1665
1666 status = U_ZERO_ERROR;
1667 formatter->setDefaultRuleSet("%spellout-numbering-year", status);
1668 if (U_SUCCESS(status)) {
1669 logln("testing year rules");
1670 doTest(formatter, testDataYear, TRUE);
1671 }
1672 else {
1673 errln("Can't test year rules");
1674 }
1675
1676 }
1677 delete formatter;
1678 }
1679
1680 void
1681 IntlTestRBNF::TestSmallValues()
1682 {
1683 UErrorCode status = U_ZERO_ERROR;
1684 RuleBasedNumberFormat* formatter
1685 = new RuleBasedNumberFormat(URBNF_SPELLOUT, Locale("en_US"), status);
1686
1687 if (U_FAILURE(status)) {
1688 errcheckln(status, "FAIL: could not construct formatter - %s", u_errorNa me(status));
1689 } else {
1690 static const char* const testDataDefault[][2] = {
1691 { "0.001", "zero point zero zero one" },
1692 { "0.0001", "zero point zero zero zero one" },
1693 { "0.00001", "zero point zero zero zero zero one" },
1694 { "0.000001", "zero point zero zero zero zero zero one" },
1695 { "0.0000001", "zero point zero zero zero zero zero zero one" },
1696 { "0.00000001", "zero point zero zero zero zero zero zero zero one" },
1697 { "0.000000001", "zero point zero zero zero zero zero zero zero zero one " },
1698 { "0.0000000001", "zero point zero zero zero zero zero zero zero zero ze ro one" },
1699 { "0.00000000001", "zero point zero zero zero zero zero zero zero zero z ero zero one" },
1700 { "0.000000000001", "zero point zero zero zero zero zero zero zero zero zero zero zero one" },
1701 { "0.0000000000001", "zero point zero zero zero zero zero zero zero zero zero zero zero zero one" },
1702 { "0.00000000000001", "zero point zero zero zero zero zero zero zero zer o zero zero zero zero zero one" },
1703 { "0.000000000000001", "zero point zero zero zero zero zero zero zero ze ro zero zero zero zero zero zero one" },
1704 { "10,000,000.001", "ten million point zero zero one" },
1705 { "10,000,000.0001", "ten million point zero zero zero one" },
1706 { "10,000,000.00001", "ten million point zero zero zero zero one" },
1707 { "10,000,000.000001", "ten million point zero zero zero zero zero one" },
1708 { "10,000,000.0000001", "ten million point zero zero zero zero zero zero one" },
1709 // { "10,000,000.00000001", "ten million point zero zero zero zero zero z ero zero one" },
1710 // { "10,000,000.000000002", "ten million point zero zero zero zero zero zero zero zero two" },
1711 { "10,000,000", "ten million" },
1712 // { "1,234,567,890.0987654", "one billion, two hundred and thirty-four m illion, five hundred and sixty-seven thousand, eight hundred and ninety point ze ro nine eight seven six five four" },
1713 // { "123,456,789.9876543", "one hundred and twenty-three million, four h undred and fifty-six thousand, seven hundred and eighty-nine point nine eight se ven six five four three" },
1714 // { "12,345,678.87654321", "twelve million, three hundred and forty-five thousand, six hundred and seventy-eight point eight seven six five four three t wo one" },
1715 { "1,234,567.7654321", "one million two hundred thirty-four thousand fiv e hundred sixty-seven point seven six five four three two one" },
1716 { "123,456.654321", "one hundred twenty-three thousand four hundred fift y-six point six five four three two one" },
1717 { "12,345.54321", "twelve thousand three hundred forty-five point five f our three two one" },
1718 { "1,234.4321", "one thousand two hundred thirty-four point four three t wo one" },
1719 { "123.321", "one hundred twenty-three point three two one" },
1720 { "0.0000000011754944", "zero point zero zero zero zero zero zero zero z ero one one seven five four nine four four" },
1721 { "0.000001175494351", "zero point zero zero zero zero zero one one seve n five four nine four three five one" },
1722 { NULL, NULL }
1723 };
1724
1725 doTest(formatter, testDataDefault, TRUE);
1726
1727 delete formatter;
1728 }
1729 }
1730
1731 void
1732 IntlTestRBNF::TestLocalizations(void)
1733 {
1734 int i;
1735 UnicodeString rules("%main:0:no;1:some;100:a lot;1000:tons;\n"
1736 "%other:0:nada;1:yah, some;100:plenty;1000:more'n you'll ever need");
1737
1738 UErrorCode status = U_ZERO_ERROR;
1739 UParseError perror;
1740 RuleBasedNumberFormat formatter(rules, perror, status);
1741 if (U_FAILURE(status)) {
1742 errcheckln(status, "FAIL: could not construct formatter - %s", u_errorNa me(status));
1743 } else {
1744 {
1745 static const char* const testData[][2] = {
1746 { "0", "nada" },
1747 { "5", "yah, some" },
1748 { "423", "plenty" },
1749 { "12345", "more'n you'll ever need" },
1750 { NULL, NULL }
1751 };
1752 doTest(&formatter, testData, FALSE);
1753 }
1754
1755 {
1756 UnicodeString loc("<<%main, %other>,<en, Main, Other>,<fr, leMain, l eOther>,<de, 'das Main', 'etwas anderes'>>");
1757 static const char* const testData[][2] = {
1758 { "0", "no" },
1759 { "5", "some" },
1760 { "423", "a lot" },
1761 { "12345", "tons" },
1762 { NULL, NULL }
1763 };
1764 RuleBasedNumberFormat formatter0(rules, loc, perror, status);
1765 if (U_FAILURE(status)) {
1766 errln("failed to build second formatter");
1767 } else {
1768 doTest(&formatter0, testData, FALSE);
1769
1770 {
1771 // exercise localization info
1772 Locale locale0("en__VALLEY@turkey=gobblegobble");
1773 Locale locale1("de_DE_FOO");
1774 Locale locale2("ja_JP");
1775 UnicodeString name = formatter0.getRuleSetName(0);
1776 if ( formatter0.getRuleSetDisplayName(0, locale0) == "Main"
1777 && formatter0.getRuleSetDisplayName(0, locale1) == "das Ma in"
1778 && formatter0.getRuleSetDisplayName(0, locale2) == "%main"
1779 && formatter0.getRuleSetDisplayName(name, locale0) == "Mai n"
1780 && formatter0.getRuleSetDisplayName(name, locale1) == "das Main"
1781 && formatter0.getRuleSetDisplayName(name, locale2) == "%ma in"){
1782 logln("getRuleSetDisplayName tested");
1783 }else {
1784 errln("failed to getRuleSetDisplayName");
1785 }
1786 }
1787
1788 for (i = 0; i < formatter0.getNumberOfRuleSetDisplayNameLocales( ); ++i) {
1789 Locale locale = formatter0.getRuleSetDisplayNameLocale(i, st atus);
1790 if (U_SUCCESS(status)) {
1791 for (int j = 0; j < formatter0.getNumberOfRuleSetNames() ; ++j) {
1792 UnicodeString name = formatter0.getRuleSetName(j);
1793 UnicodeString lname = formatter0.getRuleSetDisplayNa me(j, locale);
1794 UnicodeString msg = locale.getName();
1795 msg.append(": ");
1796 msg.append(name);
1797 msg.append(" = ");
1798 msg.append(lname);
1799 logln(msg);
1800 }
1801 }
1802 }
1803 }
1804 }
1805
1806 {
1807 static const char* goodLocs[] = {
1808 "", // zero-length ok, same as providing no localization data
1809 "<<>>", // no public rule sets ok
1810 "<<%main>>", // no localizations ok
1811 "<<%main,>,<en, Main,>>", // comma before close angle ok
1812 "<<%main>,<en, ',<>\" '>>", // quotes everything until next quot e
1813 "<<%main>,<'en', \"it's ok\">>", // double quotes work too
1814 " \n <\n <\n %main\n >\n , \t <\t en\t , \tfoo \t\t > \ n\n > \n ", // Pattern_White_Space ok
1815 };
1816 int32_t goodLocsLen = sizeof(goodLocs)/sizeof(goodLocs[0]);
1817
1818 static const char* badLocs[] = {
1819 " ", // non-zero length
1820 "<>", // empty array
1821 "<", // unclosed outer array
1822 "<<", // unclosed inner array
1823 "<<,>>", // unexpected comma
1824 "<<''>>", // empty string
1825 " x<<%main>>", // first non space char not open angle bracket
1826 "<%main>", // missing inner array
1827 "<<%main %other>>", // elements missing separating commma (space s must be quoted)
1828 "<<%main><en, Main>>", // arrays missing separating comma
1829 "<<%main>,<en, main, foo>>", // too many elements in locale data
1830 "<<%main>,<en>>", // too few elements in locale data
1831 "<<<%main>>>", // unexpected open angle
1832 "<<%main<>>>", // unexpected open angle
1833 "<<%main, %other>,<en,,>>", // implicit empty strings
1834 "<<%main>,<en,''>>", // empty string
1835 "<<%main>, < en, '>>", // unterminated quote
1836 "<<%main>, < en, \"<>>", // unterminated quote
1837 "<<%main\">>", // quote in string
1838 "<<%main'>>", // quote in string
1839 "<<%main<>>", // open angle in string
1840 "<<%main>> x", // extra non-space text at end
1841
1842 };
1843 int32_t badLocsLen = sizeof(badLocs)/sizeof(badLocs[0]);
1844
1845 for (i = 0; i < goodLocsLen; ++i) {
1846 logln("[%d] '%s'", i, goodLocs[i]);
1847 UErrorCode status = U_ZERO_ERROR;
1848 UnicodeString loc(goodLocs[i]);
1849 RuleBasedNumberFormat fmt(rules, loc, perror, status);
1850 if (U_FAILURE(status)) {
1851 errln("Failed parse of good localization string: '%s'", good Locs[i]);
1852 }
1853 }
1854
1855 for (i = 0; i < badLocsLen; ++i) {
1856 logln("[%d] '%s'", i, badLocs[i]);
1857 UErrorCode status = U_ZERO_ERROR;
1858 UnicodeString loc(badLocs[i]);
1859 RuleBasedNumberFormat fmt(rules, loc, perror, status);
1860 if (U_SUCCESS(status)) {
1861 errln("Successful parse of bad localization string: '%s'", b adLocs[i]);
1862 }
1863 }
1864 }
1865 }
1866 }
1867
1868 void
1869 IntlTestRBNF::TestAllLocales()
1870 {
1871 const char* names[] = {
1872 " (spellout) ",
1873 " (ordinal) "
1874 // " (duration) " // This is English only, and it's not really supported in CLDR anymore.
1875 };
1876 double numbers[] = {45.678, 1, 2, 10, 11, 100, 110, 200, 1000, 1111, -1111};
1877
1878 int32_t count = 0;
1879 const Locale* locales = Locale::getAvailableLocales(count);
1880 for (int i = 0; i < count; ++i) {
1881 const Locale* loc = &locales[i];
1882
1883 for (int j = 0; j < 2; ++j) {
1884 UErrorCode status = U_ZERO_ERROR;
1885 RuleBasedNumberFormat* f = new RuleBasedNumberFormat((URBNFRuleSetTa g)j, *loc, status);
1886
1887 if (status == U_USING_DEFAULT_WARNING || status == U_USING_FALLBACK_ WARNING) {
1888 // Skip it.
1889 delete f;
1890 break;
1891 }
1892 if (U_FAILURE(status)) {
1893 errln(UnicodeString(loc->getName()) + names[j]
1894 + "ERROR could not instantiate -> " + u_errorName(status));
1895 continue;
1896 }
1897 #if !UCONFIG_NO_COLLATION
1898 for (unsigned int numidx = 0; numidx < sizeof(numbers)/sizeof(double ); numidx++) {
1899 double n = numbers[numidx];
1900 UnicodeString str;
1901 f->format(n, str);
1902
1903 if (verbose) {
1904 logln(UnicodeString(loc->getName()) + names[j]
1905 + "success: " + n + " -> " + str);
1906 }
1907
1908 // We do not validate the result in this test case,
1909 // because there are cases which do not round trip by design.
1910 Formattable num;
1911
1912 // regular parse
1913 status = U_ZERO_ERROR;
1914 f->setLenient(FALSE);
1915 f->parse(str, num, status);
1916 if (U_FAILURE(status)) {
1917 errln(UnicodeString(loc->getName()) + names[j]
1918 + "ERROR could not parse '" + str + "' -> " + u_errorNam e(status));
1919 }
1920 // We only check the spellout. The behavior is undefined for num bers < 1 and fractional numbers.
1921 if (j == 0) {
1922 if (num.getType() == Formattable::kLong && num.getLong() != n) {
1923 errln(UnicodeString(loc->getName()) + names[j]
1924 + UnicodeString("ERROR could not roundtrip ") + n
1925 + UnicodeString(" -> ") + str + UnicodeString(" -> " ) + num.getLong());
1926 }
1927 else if (num.getType() == Formattable::kDouble && (int64_t)( num.getDouble() * 1000) != (int64_t)(n*1000)) {
1928 // The epsilon difference is too high.
1929 errln(UnicodeString(loc->getName()) + names[j]
1930 + UnicodeString("ERROR could not roundtrip ") + n
1931 + UnicodeString(" -> ") + str + UnicodeString(" -> " ) + num.getDouble());
1932 }
1933 }
1934 if (!quick && !logKnownIssue("9503") ) {
1935 // lenient parse
1936 status = U_ZERO_ERROR;
1937 f->setLenient(TRUE);
1938 f->parse(str, num, status);
1939 if (U_FAILURE(status)) {
1940 errln(UnicodeString(loc->getName()) + names[j]
1941 + "ERROR could not parse(lenient) '" + str + "' -> " + u_errorName(status));
1942 }
1943 // We only check the spellout. The behavior is undefined for numbers < 1 and fractional numbers.
1944 if (j == 0) {
1945 if (num.getType() == Formattable::kLong && num.getLong() != n) {
1946 errln(UnicodeString(loc->getName()) + names[j]
1947 + UnicodeString("ERROR could not roundtrip ") + n
1948 + UnicodeString(" -> ") + str + UnicodeString(" -> ") + num.getLong());
1949 }
1950 else if (num.getType() == Formattable::kDouble && (int64 _t)(num.getDouble() * 1000) != (int64_t)(n*1000)) {
1951 // The epsilon difference is too high.
1952 errln(UnicodeString(loc->getName()) + names[j]
1953 + UnicodeString("ERROR could not roundtrip ") + n
1954 + UnicodeString(" -> ") + str + UnicodeString(" -> ") + num.getDouble());
1955 }
1956 }
1957 }
1958 }
1959 #endif
1960 delete f;
1961 }
1962 }
1963 }
1964
1965 void
1966 IntlTestRBNF::TestMultiplierSubstitution(void) {
1967 UnicodeString rules("=#,##0=;1,000,000: <##0.###< million;");
1968 UErrorCode status = U_ZERO_ERROR;
1969 UParseError parse_error;
1970 RuleBasedNumberFormat *rbnf =
1971 new RuleBasedNumberFormat(rules, Locale::getUS(), parse_error, status);
1972 if (U_SUCCESS(status)) {
1973 UnicodeString res;
1974 FieldPosition pos;
1975 double n = 1234000.0;
1976 rbnf->format(n, res, pos);
1977 delete rbnf;
1978
1979 UnicodeString expected(UNICODE_STRING_SIMPLE("1.234 million"));
1980 if (expected != res) {
1981 UnicodeString msg = "Expected: ";
1982 msg.append(expected);
1983 msg.append(" but got ");
1984 msg.append(res);
1985 errln(msg);
1986 }
1987 }
1988 }
1989
1990 void
1991 IntlTestRBNF::TestSetDecimalFormatSymbols() {
1992 UErrorCode status = U_ZERO_ERROR;
1993
1994 RuleBasedNumberFormat rbnf(URBNF_ORDINAL, Locale::getEnglish(), status);
1995 if (U_FAILURE(status)) {
1996 dataerrln("Unable to create RuleBasedNumberFormat - " + UnicodeString(u_ errorName(status)));
1997 return;
1998 }
1999
2000 DecimalFormatSymbols dfs(Locale::getEnglish(), status);
2001 if (U_FAILURE(status)) {
2002 errln("Unable to create DecimalFormatSymbols - " + UnicodeString(u_error Name(status)));
2003 return;
2004 }
2005
2006 UnicodeString expected[] = {
2007 UnicodeString("1,001st"),
2008 UnicodeString("1&001st")
2009 };
2010
2011 double number = 1001;
2012
2013 UnicodeString result;
2014
2015 rbnf.format(number, result);
2016 if (result != expected[0]) {
2017 errln("Format Error - Got: " + result + " Expected: " + expected[0]);
2018 }
2019
2020 result.remove();
2021
2022 /* Set new symbol for testing */
2023 dfs.setSymbol(DecimalFormatSymbols::kGroupingSeparatorSymbol, UnicodeString( "&"), TRUE);
2024 rbnf.setDecimalFormatSymbols(dfs);
2025
2026 rbnf.format(number, result);
2027 if (result != expected[1]) {
2028 errln("Format Error - Got: " + result + " Expected: " + expected[1]);
2029 }
2030 }
2031
2032 void IntlTestRBNF::TestPluralRules() {
2033 UErrorCode status = U_ZERO_ERROR;
2034 UnicodeString enRules("%digits-ordinal:-x: ->>;0: =#,##0=$(ordinal,one{st}tw o{nd}few{rd}other{th})$;");
2035 UParseError parseError;
2036 RuleBasedNumberFormat enFormatter(enRules, Locale::getEnglish(), parseError, status);
2037 if (U_FAILURE(status)) {
2038 dataerrln("Unable to create RuleBasedNumberFormat - " + UnicodeString(u_ errorName(status)));
2039 return;
2040 }
2041 const char* const enTestData[][2] = {
2042 { "1", "1st" },
2043 { "2", "2nd" },
2044 { "3", "3rd" },
2045 { "4", "4th" },
2046 { "11", "11th" },
2047 { "12", "12th" },
2048 { "13", "13th" },
2049 { "14", "14th" },
2050 { "21", "21st" },
2051 { "22", "22nd" },
2052 { "23", "23rd" },
2053 { "24", "24th" },
2054 { NULL, NULL }
2055 };
2056
2057 doTest(&enFormatter, enTestData, TRUE);
2058
2059 // This is trying to model the feminine form, but don't worry about the deta ils too much.
2060 // We're trying to test the plural rules.
2061 UnicodeString ruRules("%spellout-numbering:"
2062 "-x: minus >>;"
2063 "x.x: << point >>;"
2064 "0: zero;"
2065 "1: one;"
2066 "2: two;"
2067 "3: three;"
2068 "4: four;"
2069 "5: five;"
2070 "6: six;"
2071 "7: seven;"
2072 "8: eight;"
2073 "9: nine;"
2074 "10: ten;"
2075 "11: eleven;"
2076 "12: twelve;"
2077 "13: thirteen;"
2078 "14: fourteen;"
2079 "15: fifteen;"
2080 "16: sixteen;"
2081 "17: seventeen;"
2082 "18: eighteen;"
2083 "19: nineteen;"
2084 "20: twenty[->>];"
2085 "30: thirty[->>];"
2086 "40: forty[->>];"
2087 "50: fifty[->>];"
2088 "60: sixty[->>];"
2089 "70: seventy[->>];"
2090 "80: eighty[->>];"
2091 "90: ninety[->>];"
2092 "100: hundred[ >>];"
2093 "200: << hundred[ >>];"
2094 "300: << hundreds[ >>];"
2095 "500: << hundredss[ >>];"
2096 "1000: << $(cardinal,one{thousand}few{thousands}other{thousandss})$[ >>];"
2097 "1000000: << $(cardinal,one{million}few{millions}other{millionss})$[ >>];");
2098 RuleBasedNumberFormat ruFormatter(ruRules, Locale("ru"), parseError, status) ;
2099 const char* const ruTestData[][2] = {
2100 { "1", "one" },
2101 { "100", "hundred" },
2102 { "125", "hundred twenty-five" },
2103 { "399", "three hundreds ninety-nine" },
2104 { "1,000", "one thousand" },
2105 { "1,001", "one thousand one" },
2106 { "2,000", "two thousands" },
2107 { "2,001", "two thousands one" },
2108 { "2,002", "two thousands two" },
2109 { "3,333", "three thousands three hundreds thirty-three" },
2110 { "5,000", "five thousandss" },
2111 { "11,000", "eleven thousandss" },
2112 { "21,000", "twenty-one thousand" },
2113 { "22,000", "twenty-two thousands" },
2114 { "25,001", "twenty-five thousandss one" },
2115 { NULL, NULL }
2116 };
2117
2118 if (U_FAILURE(status)) {
2119 errln("Unable to create RuleBasedNumberFormat - " + UnicodeString(u_erro rName(status)));
2120 return;
2121 }
2122 doTest(&ruFormatter, ruTestData, TRUE);
2123
2124 // Make sure there are no divide by 0 errors.
2125 UnicodeString result;
2126 RuleBasedNumberFormat(ruRules, Locale("ru"), parseError, status).format(2100 0, result);
2127 if (result.compare(UNICODE_STRING_SIMPLE("twenty-one thousand")) != 0) {
2128 errln("Got " + result + " for 21000");
2129 }
2130
2131 }
2132
2133 void IntlTestRBNF::TestInfinityNaN() {
2134 UErrorCode status = U_ZERO_ERROR;
2135 UParseError parseError;
2136 UnicodeString enRules("%default:"
2137 "-x: minus >>;"
2138 "Inf: infinite;"
2139 "NaN: not a number;"
2140 "0: =#,##0=;");
2141 RuleBasedNumberFormat enFormatter(enRules, Locale::getEnglish(), parseError, status);
2142 const char * const enTestData[][2] = {
2143 {"1", "1"},
2144 {"\\u221E", "infinite"},
2145 {"-\\u221E", "minus infinite"},
2146 {"NaN", "not a number"},
2147 { NULL, NULL }
2148 };
2149 if (U_FAILURE(status)) {
2150 dataerrln("Unable to create RuleBasedNumberFormat - " + UnicodeString(u_ errorName(status)));
2151 return;
2152 }
2153
2154 doTest(&enFormatter, enTestData, true);
2155
2156 // Test the default behavior when the rules are undefined.
2157 UnicodeString enRules2("%default:"
2158 "-x: ->>;"
2159 "0: =#,##0=;");
2160 RuleBasedNumberFormat enFormatter2(enRules2, Locale::getEnglish(), parseErro r, status);
2161 if (U_FAILURE(status)) {
2162 errln("Unable to create RuleBasedNumberFormat - " + UnicodeString(u_erro rName(status)));
2163 return;
2164 }
2165 const char * const enDefaultTestData[][2] = {
2166 {"1", "1"},
2167 {"\\u221E", "\\u221E"},
2168 {"-\\u221E", "-\\u221E"},
2169 {"NaN", "NaN"},
2170 { NULL, NULL }
2171 };
2172
2173 doTest(&enFormatter2, enDefaultTestData, true);
2174 }
2175
2176 void IntlTestRBNF::TestVariableDecimalPoint() {
2177 UErrorCode status = U_ZERO_ERROR;
2178 UParseError parseError;
2179 UnicodeString enRules("%spellout-numbering:"
2180 "-x: minus >>;"
2181 "x.x: << point >>;"
2182 "x,x: << comma >>;"
2183 "0.x: xpoint >>;"
2184 "0,x: xcomma >>;"
2185 "0: zero;"
2186 "1: one;"
2187 "2: two;"
2188 "3: three;"
2189 "4: four;"
2190 "5: five;"
2191 "6: six;"
2192 "7: seven;"
2193 "8: eight;"
2194 "9: nine;");
2195 RuleBasedNumberFormat enFormatter(enRules, Locale::getEnglish(), parseError, status);
2196 const char * const enTestPointData[][2] = {
2197 {"1.1", "one point one"},
2198 {"1.23", "one point two three"},
2199 {"0.4", "xpoint four"},
2200 { NULL, NULL }
2201 };
2202 if (U_FAILURE(status)) {
2203 dataerrln("Unable to create RuleBasedNumberFormat - " + UnicodeString(u_ errorName(status)));
2204 return;
2205 }
2206 doTest(&enFormatter, enTestPointData, true);
2207
2208 DecimalFormatSymbols decimalFormatSymbols(Locale::getEnglish(), status);
2209 decimalFormatSymbols.setSymbol(DecimalFormatSymbols::kDecimalSeparatorSymbol , UNICODE_STRING_SIMPLE(","));
2210 enFormatter.setDecimalFormatSymbols(decimalFormatSymbols);
2211 const char * const enTestCommaData[][2] = {
2212 {"1.1", "one comma one"},
2213 {"1.23", "one comma two three"},
2214 {"0.4", "xcomma four"},
2215 { NULL, NULL }
2216 };
2217 doTest(&enFormatter, enTestCommaData, true);
2218 }
2219
2220 void
2221 IntlTestRBNF::doTest(RuleBasedNumberFormat* formatter, const char* const testDat a[][2], UBool testParsing)
2222 {
2223 // man, error reporting would be easier with printf-style syntax for unicode s tring and formattable
2224
2225 UErrorCode status = U_ZERO_ERROR;
2226 DecimalFormatSymbols dfs("en", status);
2227 // NumberFormat* decFmt = NumberFormat::createInstance(Locale::getUS(), stat us);
2228 DecimalFormat decFmt("#,###.################", dfs, status);
2229 if (U_FAILURE(status)) {
2230 errcheckln(status, "FAIL: could not create NumberFormat - %s", u_errorNa me(status));
2231 } else {
2232 for (int i = 0; testData[i][0]; ++i) {
2233 const char* numString = testData[i][0];
2234 const char* expectedWords = testData[i][1];
2235
2236 log("[%i] %s = ", i, numString);
2237 Formattable expectedNumber;
2238 UnicodeString escapedNumString = UnicodeString(numString, -1, US_INV ).unescape();
2239 decFmt.parse(escapedNumString, expectedNumber, status);
2240 if (U_FAILURE(status)) {
2241 errln("FAIL: decFmt could not parse %s", numString);
2242 break;
2243 } else {
2244 UnicodeString actualString;
2245 FieldPosition pos;
2246 formatter->format(expectedNumber, actualString/* , pos*/, status );
2247 if (U_FAILURE(status)) {
2248 UnicodeString msg = "Fail: formatter could not format ";
2249 decFmt.format(expectedNumber, msg, status);
2250 errln(msg);
2251 break;
2252 } else {
2253 UnicodeString expectedString = UnicodeString(expectedWords, -1, US_INV).unescape();
2254 if (actualString != expectedString) {
2255 UnicodeString msg = "FAIL: check failed for ";
2256 decFmt.format(expectedNumber, msg, status);
2257 msg.append(", expected ");
2258 msg.append(expectedString);
2259 msg.append(" but got ");
2260 msg.append(actualString);
2261 errln(msg);
2262 break;
2263 } else {
2264 logln(actualString);
2265 if (testParsing) {
2266 Formattable parsedNumber;
2267 formatter->parse(actualString, parsedNumber, status) ;
2268 if (U_FAILURE(status)) {
2269 UnicodeString msg = "FAIL: formatter could not p arse ";
2270 msg.append(actualString);
2271 msg.append(" status code: " );
2272 msg.append(u_errorName(status));
2273 errln(msg);
2274 break;
2275 } else {
2276 if (parsedNumber != expectedNumber
2277 && (!uprv_isNaN(parsedNumber.getDouble()) || !uprv_isNaN(expectedNumber.getDouble())))
2278 {
2279 UnicodeString msg = "FAIL: parse failed for ";
2280 msg.append(actualString);
2281 msg.append(", expected ");
2282 decFmt.format(expectedNumber, msg, status);
2283 msg.append(", but got ");
2284 decFmt.format(parsedNumber, msg, status);
2285 errln(msg);
2286 break;
2287 }
2288 }
2289 }
2290 }
2291 }
2292 }
2293 }
2294 }
2295 }
2296
2297 void
2298 IntlTestRBNF::doLenientParseTest(RuleBasedNumberFormat* formatter, const char* t estData[][2])
2299 {
2300 UErrorCode status = U_ZERO_ERROR;
2301 NumberFormat* decFmt = NumberFormat::createInstance(Locale::getUS(), status) ;
2302 if (U_FAILURE(status)) {
2303 errcheckln(status, "FAIL: could not create NumberFormat - %s", u_errorNa me(status));
2304 } else {
2305 for (int i = 0; testData[i][0]; ++i) {
2306 const char* spelledNumber = testData[i][0]; // spelled-out number
2307 const char* asciiUSNumber = testData[i][1]; // number as ascii digit s formatted for US locale
2308
2309 UnicodeString spelledNumberString = UnicodeString(spelledNumber).une scape();
2310 Formattable actualNumber;
2311 formatter->parse(spelledNumberString, actualNumber, status);
2312 if (U_FAILURE(status)) {
2313 UnicodeString msg = "FAIL: formatter could not parse ";
2314 msg.append(spelledNumberString);
2315 errln(msg);
2316 break;
2317 } else {
2318 // I changed the logic of this test somewhat from Java-- instead of comparing the
2319 // strings, I compare the Formattables. Hmmm, but the Formattab les don't compare,
2320 // so change it back.
2321
2322 UnicodeString asciiUSNumberString = asciiUSNumber;
2323 Formattable expectedNumber;
2324 decFmt->parse(asciiUSNumberString, expectedNumber, status);
2325 if (U_FAILURE(status)) {
2326 UnicodeString msg = "FAIL: decFmt could not parse ";
2327 msg.append(asciiUSNumberString);
2328 errln(msg);
2329 break;
2330 } else {
2331 UnicodeString actualNumberString;
2332 UnicodeString expectedNumberString;
2333 decFmt->format(actualNumber, actualNumberString, status);
2334 decFmt->format(expectedNumber, expectedNumberString, status) ;
2335 if (actualNumberString != expectedNumberString) {
2336 UnicodeString msg = "FAIL: parsing";
2337 msg.append(asciiUSNumberString);
2338 msg.append("\n");
2339 msg.append(" lenient parse failed for ");
2340 msg.append(spelledNumberString);
2341 msg.append(", expected ");
2342 msg.append(expectedNumberString);
2343 msg.append(", but got ");
2344 msg.append(actualNumberString);
2345 errln(msg);
2346 break;
2347 }
2348 }
2349 }
2350 }
2351 delete decFmt;
2352 }
2353 }
2354
2355 /* U_HAVE_RBNF */
2356 #else
2357
2358 void
2359 IntlTestRBNF::TestRBNFDisabled() {
2360 errln("*** RBNF currently disabled on this platform ***\n");
2361 }
2362
2363 /* U_HAVE_RBNF */
2364 #endif
2365
2366 #endif /* #if !UCONFIG_NO_FORMATTING */
OLDNEW
« no previous file with comments | « source/test/intltest/itrbnf.h ('k') | source/test/intltest/itrbnfp.h » ('j') | no next file with comments »

Powered by Google App Engine
This is Rietveld 408576698