]> git.saurik.com Git - apple/icu.git/blob - icuSources/test/intltest/tufmtts.cpp
projects / apple / icu.git / blob
? search:


3a0d7b65f878ce723866937d4daed60480bd287c
[apple/icu.git] / icuSources / test / intltest / tufmtts.cpp
1 // © 2016 and later: Unicode, Inc. and others.
2 // License & terms of use: http://www.unicode.org/copyright.html
3 /********************************************************************
4 * Copyright (c) 2008-2016, International Business Machines Corporation and
5 * others. All Rights Reserved.
6 ********************************************************************/
7
8 #include "unicode/utypes.h"
9
10 #if !UCONFIG_NO_FORMATTING
11
12 #include "unicode/decimfmt.h"
13 #include "unicode/tmunit.h"
14 #include "unicode/tmutamt.h"
15 #include "unicode/tmutfmt.h"
16 #include "unicode/ustring.h"
17 #include "cmemory.h"
18 #include "intltest.h"
19
20 //TODO: put as compilation flag
21 //#define TUFMTTS_DEBUG 1
22
23 #ifdef TUFMTTS_DEBUG
24 #include <iostream>
25 #endif
26
27 class TimeUnitTest : public IntlTest {
28 void runIndexedTest(int32_t index, UBool exec, const char* &name, char* /*par*/ ) {
29 if (exec) logln("TestSuite TimeUnitTest");
30 TESTCASE_AUTO_BEGIN;
31 TESTCASE_AUTO(testBasic);
32 TESTCASE_AUTO(testAPI);
33 TESTCASE_AUTO(testGreekWithFallback);
34 TESTCASE_AUTO(testGreekWithSanitization);
35 TESTCASE_AUTO(test10219Plurals);
36 TESTCASE_AUTO(TestBritishShortHourFallback);
37 TESTCASE_AUTO_END;
38 }
39
40 public:
41 /**
42 * Performs basic tests
43 **/
44 void testBasic();
45
46 /**
47 * Performs API tests
48 **/
49 void testAPI();
50
51 /**
52 * Performs tests for Greek
53 * This tests that requests for short unit names correctly fall back
54 * to long unit names for a locale where the locale data does not
55 * provide short unit names. As of CLDR 1.9, Greek is one such language.
56 **/
57 void testGreekWithFallback();
58
59 /**
60 * Performs tests for Greek
61 * This tests that if the plural count listed in time unit format does not
62 * match those in the plural rules for the locale, those plural count in
63 * time unit format will be ingored and subsequently, fall back will kick in
64 * which is tested above.
65 * Without data sanitization, setNumberFormat() would crash.
66 * As of CLDR shiped in ICU4.8, Greek is one such language.
67 */
68 void testGreekWithSanitization();
69
70 /**
71 * Performs unit test for ticket 10219 making sure that plurals work
72 * correctly with rounding.
73 */
74 void test10219Plurals();
75
76 void TestBritishShortHourFallback();
77 };
78
79 extern IntlTest *createTimeUnitTest() {
80 return new TimeUnitTest();
81 }
82
83 // This function is more lenient than equals operator as it considers integer 3 hours and
84 // double 3.0 hours to be equal
85 static UBool tmaEqual(const TimeUnitAmount& left, const TimeUnitAmount& right) {
86 if (left.getTimeUnitField() != right.getTimeUnitField()) {
87 return FALSE;
88 }
89 UErrorCode status = U_ZERO_ERROR;
90 if (!left.getNumber().isNumeric() || !right.getNumber().isNumeric()) {
91 return FALSE;
92 }
93 UBool result = left.getNumber().getDouble(status) == right.getNumber().getDouble(status);
94 if (U_FAILURE(status)) {
95 return FALSE;
96 }
97 return result;
98 }
99
100 /**
101 * Test basic
102 */
103 void TimeUnitTest::testBasic() {
104 const char* locales[] = {"en", "sl", "fr", "zh", "ar", "ru", "zh_Hant", "pa"};
105 for ( unsigned int locIndex = 0;
106 locIndex < UPRV_LENGTHOF(locales);
107 ++locIndex ) {
108 UErrorCode status = U_ZERO_ERROR;
109 Locale loc(locales[locIndex]);
110 TimeUnitFormat** formats = new TimeUnitFormat*[2];
111 formats[UTMUTFMT_FULL_STYLE] = new TimeUnitFormat(loc, status);
112 if (!assertSuccess("TimeUnitFormat(full)", status, TRUE)) return;
113 formats[UTMUTFMT_ABBREVIATED_STYLE] = new TimeUnitFormat(loc, UTMUTFMT_ABBREVIATED_STYLE, status);
114 if (!assertSuccess("TimeUnitFormat(short)", status)) return;
115 #ifdef TUFMTTS_DEBUG
116 std::cout << "locale: " << locales[locIndex] << "\n";
117 #endif
118 for (int style = UTMUTFMT_FULL_STYLE;
119 style <= UTMUTFMT_ABBREVIATED_STYLE;
120 ++style) {
121 for (TimeUnit::UTimeUnitFields j = TimeUnit::UTIMEUNIT_YEAR;
122 j < TimeUnit::UTIMEUNIT_FIELD_COUNT;
123 j = (TimeUnit::UTimeUnitFields)(j+1)) {
124 #ifdef TUFMTTS_DEBUG
125 std::cout << "time unit: " << j << "\n";
126 #endif
127 double tests[] = {0, 0.5, 1, 1.5, 2, 2.5, 3, 3.5, 5, 10, 100, 101.35};
128 for (unsigned int i = 0; i < UPRV_LENGTHOF(tests); ++i) {
129 #ifdef TUFMTTS_DEBUG
130 std::cout << "number: " << tests[i] << "\n";
131 #endif
132 TimeUnitAmount* source = new TimeUnitAmount(tests[i], j, status);
133 if (!assertSuccess("TimeUnitAmount()", status)) return;
134 UnicodeString formatted;
135 Formattable formattable;
136 formattable.adoptObject(source);
137 formatted = ((Format*)formats[style])->format(formattable, formatted, status);
138 if (!assertSuccess("format()", status)) return;
139 #ifdef TUFMTTS_DEBUG
140 char formatResult[1000];
141 formatted.extract(0, formatted.length(), formatResult, "UTF-8");
142 std::cout << "format result: " << formatResult << "\n";
143 #endif
144 Formattable result;
145 ((Format*)formats[style])->parseObject(formatted, result, status);
146 if (!assertSuccess("parseObject()", status)) return;
147 if (!tmaEqual(*((TimeUnitAmount *)result.getObject()), *((TimeUnitAmount *) formattable.getObject()))) {
148 dataerrln("No round trip: ");
149 }
150 // other style parsing
151 Formattable result_1;
152 ((Format*)formats[1-style])->parseObject(formatted, result_1, status);
153 if (!assertSuccess("parseObject()", status)) return;
154 if (!tmaEqual(*((TimeUnitAmount *)result_1.getObject()), *((TimeUnitAmount *) formattable.getObject()))) {
155 dataerrln("No round trip: ");
156 }
157 }
158 }
159 }
160 delete formats[UTMUTFMT_FULL_STYLE];
161 delete formats[UTMUTFMT_ABBREVIATED_STYLE];
162 delete[] formats;
163 }
164 }
165
166
167 void TimeUnitTest::testAPI() {
168 //================= TimeUnit =================
169 UErrorCode status = U_ZERO_ERROR;
170
171 TimeUnit* tmunit = TimeUnit::createInstance(TimeUnit::UTIMEUNIT_YEAR, status);
172 if (!assertSuccess("TimeUnit::createInstance", status)) return;
173
174 TimeUnit* another = tmunit->clone();
175 TimeUnit third(*tmunit);
176 TimeUnit fourth = third;
177
178 assertTrue("orig and clone are equal", (*tmunit == *another));
179 assertTrue("copied and assigned are equal", (third == fourth));
180
181 TimeUnit* tmunit_m = TimeUnit::createInstance(TimeUnit::UTIMEUNIT_MONTH, status);
182 assertTrue("year != month", (*tmunit != *tmunit_m));
183
184 TimeUnit::UTimeUnitFields field = tmunit_m->getTimeUnitField();
185 assertTrue("field of month time unit is month", (field == TimeUnit::UTIMEUNIT_MONTH));
186
187 //===== Interoperability with MeasureUnit ======
188 MeasureUnit **ptrs = new MeasureUnit *[TimeUnit::UTIMEUNIT_FIELD_COUNT];
189
190 ptrs[TimeUnit::UTIMEUNIT_YEAR] = MeasureUnit::createYear(status);
191 ptrs[TimeUnit::UTIMEUNIT_MONTH] = MeasureUnit::createMonth(status);
192 ptrs[TimeUnit::UTIMEUNIT_DAY] = MeasureUnit::createDay(status);
193 ptrs[TimeUnit::UTIMEUNIT_WEEK] = MeasureUnit::createWeek(status);
194 ptrs[TimeUnit::UTIMEUNIT_HOUR] = MeasureUnit::createHour(status);
195 ptrs[TimeUnit::UTIMEUNIT_MINUTE] = MeasureUnit::createMinute(status);
196 ptrs[TimeUnit::UTIMEUNIT_SECOND] = MeasureUnit::createSecond(status);
197 if (!assertSuccess("TimeUnit::createInstance", status)) return;
198
199 for (TimeUnit::UTimeUnitFields j = TimeUnit::UTIMEUNIT_YEAR;
200 j < TimeUnit::UTIMEUNIT_FIELD_COUNT;
201 j = (TimeUnit::UTimeUnitFields)(j+1)) {
202 MeasureUnit *ptr = TimeUnit::createInstance(j, status);
203 if (!assertSuccess("TimeUnit::createInstance", status)) return;
204 // We have to convert *ptr to a MeasureUnit or else == will fail over
205 // differing types (TimeUnit vs. MeasureUnit).
206 assertTrue(
207 "Time unit should be equal to corresponding MeasureUnit",
208 MeasureUnit(*ptr) == *ptrs[j]);
209 delete ptr;
210 }
211 delete tmunit;
212 delete another;
213 delete tmunit_m;
214 for (int i = 0; i < TimeUnit::UTIMEUNIT_FIELD_COUNT; ++i) {
215 delete ptrs[i];
216 }
217 delete [] ptrs;
218
219 //
220 //================= TimeUnitAmount =================
221
222 Formattable formattable((int32_t)2);
223 TimeUnitAmount tma_long(formattable, TimeUnit::UTIMEUNIT_DAY, status);
224 if (!assertSuccess("TimeUnitAmount(formattable...)", status)) return;
225
226 formattable.setDouble(2);
227 TimeUnitAmount tma_double(formattable, TimeUnit::UTIMEUNIT_DAY, status);
228 if (!assertSuccess("TimeUnitAmount(formattable...)", status)) return;
229
230 formattable.setDouble(3);
231 TimeUnitAmount tma_double_3(formattable, TimeUnit::UTIMEUNIT_DAY, status);
232 if (!assertSuccess("TimeUnitAmount(formattable...)", status)) return;
233
234 TimeUnitAmount tma(2, TimeUnit::UTIMEUNIT_DAY, status);
235 if (!assertSuccess("TimeUnitAmount(number...)", status)) return;
236
237 TimeUnitAmount tma_h(2, TimeUnit::UTIMEUNIT_HOUR, status);
238 if (!assertSuccess("TimeUnitAmount(number...)", status)) return;
239
240 TimeUnitAmount second(tma);
241 TimeUnitAmount third_tma = tma;
242 TimeUnitAmount* fourth_tma = tma.clone();
243
244 assertTrue("orig and copy are equal", (second == tma));
245 assertTrue("clone and assigned are equal", (third_tma == *fourth_tma));
246 assertTrue("different if number diff", (tma_double != tma_double_3));
247 assertTrue("different if number type diff", (tma_double != tma_long));
248 assertTrue("different if time unit diff", (tma != tma_h));
249 assertTrue("same even different constructor", (tma_double == tma));
250
251 assertTrue("getTimeUnitField", (tma.getTimeUnitField() == TimeUnit::UTIMEUNIT_DAY));
252 delete fourth_tma;
253 //
254 //================= TimeUnitFormat =================
255 //
256 TimeUnitFormat* tmf_en = new TimeUnitFormat(Locale("en"), status);
257 if (!assertSuccess("TimeUnitFormat(en...)", status, TRUE)) return;
258 TimeUnitFormat tmf_fr(Locale("fr"), status);
259 if (!assertSuccess("TimeUnitFormat(fr...)", status)) return;
260
261 assertTrue("TimeUnitFormat: en and fr diff", (*tmf_en != tmf_fr));
262
263 TimeUnitFormat tmf_assign = *tmf_en;
264 assertTrue("TimeUnitFormat: orig and assign are equal", (*tmf_en == tmf_assign));
265
266 TimeUnitFormat tmf_copy(tmf_fr);
267 assertTrue("TimeUnitFormat: orig and copy are equal", (tmf_fr == tmf_copy));
268
269 TimeUnitFormat* tmf_clone = tmf_en->clone();
270 assertTrue("TimeUnitFormat: orig and clone are equal", (*tmf_en == *tmf_clone));
271 delete tmf_clone;
272
273 tmf_en->setLocale(Locale("fr"), status);
274 if (!assertSuccess("setLocale(fr...)", status)) return;
275
276 NumberFormat* numberFmt = NumberFormat::createInstance(
277 Locale("fr"), status);
278 if (!assertSuccess("NumberFormat::createInstance()", status)) return;
279 tmf_en->setNumberFormat(*numberFmt, status);
280 if (!assertSuccess("setNumberFormat(en...)", status)) return;
281 assertTrue("TimeUnitFormat: setLocale", (*tmf_en == tmf_fr));
282
283 delete tmf_en;
284
285 TimeUnitFormat* en_long = new TimeUnitFormat(Locale("en"), UTMUTFMT_FULL_STYLE, status);
286 if (!assertSuccess("TimeUnitFormat(en...)", status)) return;
287 delete en_long;
288
289 TimeUnitFormat* en_short = new TimeUnitFormat(Locale("en"), UTMUTFMT_ABBREVIATED_STYLE, status);
290 if (!assertSuccess("TimeUnitFormat(en...)", status)) return;
291 delete en_short;
292
293 TimeUnitFormat* format = new TimeUnitFormat(status);
294 format->setLocale(Locale("zh"), status);
295 format->setNumberFormat(*numberFmt, status);
296 if (!assertSuccess("TimeUnitFormat(en...)", status)) return;
297 delete numberFmt;
298 delete format;
299 }
300
301 /* @bug 7902
302 * Tests for Greek Language.
303 * This tests that requests for short unit names correctly fall back
304 * to long unit names for a locale where the locale data does not
305 * provide short unit names. As of CLDR 1.9, Greek is one such language.
306 */
307 void TimeUnitTest::testGreekWithFallback() {
308 UErrorCode status = U_ZERO_ERROR;
309
310 const char* locales[] = {"el-GR", "el"};
311 TimeUnit::UTimeUnitFields tunits[] = {TimeUnit::UTIMEUNIT_SECOND, TimeUnit::UTIMEUNIT_MINUTE, TimeUnit::UTIMEUNIT_HOUR, TimeUnit::UTIMEUNIT_DAY, TimeUnit::UTIMEUNIT_MONTH, TimeUnit::UTIMEUNIT_YEAR};
312 UTimeUnitFormatStyle styles[] = {UTMUTFMT_FULL_STYLE, UTMUTFMT_ABBREVIATED_STYLE};
313 const int numbers[] = {1, 7};
314
315 const UChar oneSecond[] = {0x0031, 0x0020, 0x03b4, 0x03b5, 0x03c5, 0x03c4, 0x03b5, 0x03c1, 0x03cc, 0x03bb, 0x03b5, 0x03c0, 0x03c4, 0x03bf, 0};
316 const UChar oneSecondShort[] = {0x0031, 0x0020, 0x03b4, 0x03b5, 0x03c5, 0x03c4, 0x002e, 0};
317 const UChar oneMinute[] = {0x0031, 0x0020, 0x03bb, 0x03b5, 0x03c0, 0x03c4, 0x03cc, 0};
318 const UChar oneMinuteShort[] = {0x0031, 0x0020, 0x03bb, 0x03b5, 0x03c0, 0x002e, 0};
319 const UChar oneHour[] = {0x0031, 0x0020, 0x03ce, 0x03c1, 0x03b1, 0};
320 const UChar oneDay[] = {0x0031, 0x0020, 0x03b7, 0x03bc, 0x03ad, 0x03c1, 0x03b1, 0};
321 const UChar oneMonth[] = {0x0031, 0x0020, 0x03bc, 0x03ae, 0x03bd, 0x03b1, 0x03c2, 0};
322 const UChar oneMonthShort[] = {0x0031, 0x0020, 0x03bc, 0x03ae, 0x03bd, 0x002e, 0};
323 const UChar oneYear[] = {0x0031, 0x0020, 0x03ad, 0x03c4, 0x03bf, 0x03c2, 0};
324 const UChar oneYearShort[] = {0x0031, 0x0020, 0x03ad, 0x03c4, 0x002e, 0};
325 const UChar sevenSeconds[] = {0x0037, 0x0020, 0x03b4, 0x03b5, 0x03c5, 0x03c4, 0x03b5, 0x03c1, 0x03cc, 0x03bb, 0x03b5, 0x03c0, 0x03c4, 0x03b1, 0};
326 const UChar sevenSecondsShort[] = {0x0037, 0x0020, 0x03b4, 0x03b5, 0x03c5, 0x03c4, 0x002e, 0};
327 const UChar sevenMinutes[] = {0x0037, 0x0020, 0x03bb, 0x03b5, 0x03c0, 0x03c4, 0x03ac, 0};
328 const UChar sevenMinutesShort[] = {0x0037, 0x0020, 0x03bb, 0x03b5, 0x03c0, 0x002e, 0};
329 const UChar sevenHours[] = {0x0037, 0x0020, 0x03ce, 0x03c1, 0x03b5, 0x03c2, 0};
330 const UChar sevenHoursShort[] = {0x0037, 0x0020, 0x03ce, 0x03c1, 0x002e, 0};
331 const UChar sevenDays[] = {0x0037, 0x0020, 0x03b7, 0x03bc, 0x03ad, 0x03c1, 0x03b5, 0x03c2, 0};
332 const UChar sevenMonths[] = {0x0037, 0x0020, 0x03bc, 0x03ae, 0x03bd, 0x03b5, 0x3c2, 0};
333 const UChar sevenMonthsShort[] = {0x0037, 0x0020, 0x03bc, 0x03ae, 0x03bd, 0x002e, 0};
334 const UChar sevenYears[] = {0x0037, 0x0020, 0x03ad, 0x03c4, 0x03b7, 0};
335 const UChar sevenYearsShort[] = {0x0037, 0x0020, 0x03ad, 0x03c4, 0x002e, 0};
336
337 const UnicodeString oneSecondStr(oneSecond);
338 const UnicodeString oneSecondShortStr(oneSecondShort);
339 const UnicodeString oneMinuteStr(oneMinute);
340 const UnicodeString oneMinuteShortStr(oneMinuteShort);
341 const UnicodeString oneHourStr(oneHour);
342 const UnicodeString oneDayStr(oneDay);
343 const UnicodeString oneMonthStr(oneMonth);
344 const UnicodeString oneMonthShortStr(oneMonthShort);
345 const UnicodeString oneYearStr(oneYear);
346 const UnicodeString oneYearShortStr(oneYearShort);
347 const UnicodeString sevenSecondsStr(sevenSeconds);
348 const UnicodeString sevenSecondsShortStr(sevenSecondsShort);
349 const UnicodeString sevenMinutesStr(sevenMinutes);
350 const UnicodeString sevenMinutesShortStr(sevenMinutesShort);
351 const UnicodeString sevenHoursStr(sevenHours);
352 const UnicodeString sevenHoursShortStr(sevenHoursShort);
353 const UnicodeString sevenDaysStr(sevenDays);
354 const UnicodeString sevenMonthsStr(sevenMonths);
355 const UnicodeString sevenMonthsShortStr(sevenMonthsShort);
356 const UnicodeString sevenYearsStr(sevenYears);
357 const UnicodeString sevenYearsShortStr(sevenYearsShort);
358
359 const UnicodeString expected[] = {
360 oneSecondStr, oneMinuteStr, oneHourStr, oneDayStr, oneMonthStr, oneYearStr,
361 oneSecondShortStr, oneMinuteShortStr, oneHourStr, oneDayStr, oneMonthShortStr, oneYearShortStr,
362 sevenSecondsStr, sevenMinutesStr, sevenHoursStr, sevenDaysStr, sevenMonthsStr, sevenYearsStr,
363 sevenSecondsShortStr, sevenMinutesShortStr, sevenHoursShortStr, sevenDaysStr, sevenMonthsShortStr, sevenYearsShortStr,
364
365 oneSecondStr, oneMinuteStr, oneHourStr, oneDayStr, oneMonthStr, oneYearStr,
366 oneSecondShortStr, oneMinuteShortStr, oneHourStr, oneDayStr, oneMonthShortStr, oneYearShortStr,
367 sevenSecondsStr, sevenMinutesStr, sevenHoursStr, sevenDaysStr, sevenMonthsStr, sevenYearsStr,
368 sevenSecondsShortStr, sevenMinutesShortStr, sevenHoursShortStr, sevenDaysStr, sevenMonthsShortStr, sevenYearsShortStr};
369
370 int counter = 0;
371 for ( unsigned int locIndex = 0;
372 locIndex < UPRV_LENGTHOF(locales);
373 ++locIndex ) {
374
375 Locale l = Locale::createFromName(locales[locIndex]);
376
377 for ( unsigned int numberIndex = 0;
378 numberIndex < UPRV_LENGTHOF(numbers);
379 ++numberIndex ) {
380
381 for ( unsigned int styleIndex = 0;
382 styleIndex < UPRV_LENGTHOF(styles);
383 ++styleIndex ) {
384
385 for ( unsigned int unitIndex = 0;
386 unitIndex < UPRV_LENGTHOF(tunits);
387 ++unitIndex ) {
388
389 LocalPointer<TimeUnitAmount>tamt(new TimeUnitAmount(numbers[numberIndex], tunits[unitIndex], status));
390 if (U_FAILURE(status)) {
391 dataerrln("generating TimeUnitAmount Object failed.");
392 #ifdef TUFMTTS_DEBUG
393 std::cout << "Failed to get TimeUnitAmount for " << tunits[unitIndex] << "\n";
394 #endif
395 return;
396 }
397
398 LocalPointer<TimeUnitFormat> tfmt(new TimeUnitFormat(l, styles[styleIndex], status));
399 if (U_FAILURE(status)) {
400 dataerrln("generating TimeUnitAmount Object failed.");
401 #ifdef TUFMTTS_DEBUG
402 std::cout << "Failed to get TimeUnitFormat for " << locales[locIndex] << "\n";
403 #endif
404 return;
405 }
406
407 Formattable fmt;
408 UnicodeString str;
409
410 fmt.adoptObject(tamt.orphan());
411 str = ((Format *)tfmt.getAlias())->format(fmt, str, status);
412 if (!assertSuccess("formatting relative time failed", status)) {
413 #ifdef TUFMTTS_DEBUG
414 std::cout << "Failed to format" << "\n";
415 #endif
416 return;
417 }
418
419 #ifdef TUFMTTS_DEBUG
420 char tmp[128]; //output
421 char tmp1[128]; //expected
422 int len = 0;
423 u_strToUTF8(tmp, 128, &len, str.getTerminatedBuffer(), str.length(), &status);
424 u_strToUTF8(tmp1, 128, &len, expected[counter].unescape().getTerminatedBuffer(), expected[counter].unescape().length(), &status);
425 std::cout << "Formatted string : " << tmp << " expected : " << tmp1 << "\n";
426 #endif
427 if (!assertEquals("formatted time string is not expected, locale: " + UnicodeString(locales[locIndex]) + " style: " + (int)styles[styleIndex] + " units: " + (int)tunits[unitIndex], expected[counter], str)) {
428 str.remove();
429 return;
430 }
431 str.remove();
432 ++counter;
433 }
434 }
435 }
436 }
437 }
438
439 // Test bug9042
440 void TimeUnitTest::testGreekWithSanitization() {
441
442 UErrorCode status = U_ZERO_ERROR;
443 Locale elLoc("el");
444 NumberFormat* numberFmt = NumberFormat::createInstance(Locale("el"), status);
445 if (!assertSuccess("NumberFormat::createInstance for el locale", status, TRUE)) return;
446 numberFmt->setMaximumFractionDigits(1);
447
448 TimeUnitFormat* timeUnitFormat = new TimeUnitFormat(elLoc, status);
449 if (!assertSuccess("TimeUnitFormat::TimeUnitFormat for el locale", status)) return;
450
451 timeUnitFormat->setNumberFormat(*numberFmt, status);
452
453 delete numberFmt;
454 delete timeUnitFormat;
455 }
456
457 void TimeUnitTest::test10219Plurals() {
458 Locale usLocale("en_US");
459 double values[2] = {1.588, 1.011};
460 UnicodeString expected[2][3] = {
461 {"1 minute", "1.5 minutes", "1.58 minutes"},
462 {"1 minute", "1.0 minutes", "1.01 minutes"}
463 };
464 UErrorCode status = U_ZERO_ERROR;
465 TimeUnitFormat tuf(usLocale, status);
466 if (U_FAILURE(status)) {
467 dataerrln("generating TimeUnitFormat Object failed: %s", u_errorName(status));
468 return;
469 }
470 LocalPointer<DecimalFormat> nf((DecimalFormat *) NumberFormat::createInstance(usLocale, status));
471 if (U_FAILURE(status)) {
472 dataerrln("generating NumberFormat Object failed: %s", u_errorName(status));
473 return;
474 }
475 for (int32_t j = 0; j < UPRV_LENGTHOF(values); ++j) {
476 for (int32_t i = 0; i < UPRV_LENGTHOF(expected[j]); ++i) {
477 nf->setMinimumFractionDigits(i);
478 nf->setMaximumFractionDigits(i);
479 nf->setRoundingMode(DecimalFormat::kRoundDown);
480 tuf.setNumberFormat(*nf, status);
481 if (U_FAILURE(status)) {
482 dataerrln("setting NumberFormat failed: %s", u_errorName(status));
483 return;
484 }
485 UnicodeString actual;
486 Formattable fmt;
487 LocalPointer<TimeUnitAmount> tamt(
488 new TimeUnitAmount(values[j], TimeUnit::UTIMEUNIT_MINUTE, status), status);
489 if (U_FAILURE(status)) {
490 dataerrln("generating TimeUnitAmount Object failed: %s", u_errorName(status));
491 return;
492 }
493 fmt.adoptObject(tamt.orphan());
494 tuf.format(fmt, actual, status);
495 if (U_FAILURE(status)) {
496 dataerrln("Actual formatting failed: %s", u_errorName(status));
497 return;
498 }
499 if (expected[j][i] != actual) {
500 errln("Expected " + expected[j][i] + ", got " + actual);
501 }
502 }
503 }
504
505 // test parsing
506 Formattable result;
507 ParsePosition pos;
508 UnicodeString formattedString = "1 minutes";
509 tuf.parseObject(formattedString, result, pos);
510 if (formattedString.length() != pos.getIndex()) {
511 errln("Expect parsing to go all the way to the end of the string.");
512 }
513 }
514
515 void TimeUnitTest::TestBritishShortHourFallback() {
516 // See ticket #11986 "incomplete fallback in MeasureFormat".
517 UErrorCode status = U_ZERO_ERROR;
518 Formattable oneHour(new TimeUnitAmount(1, TimeUnit::UTIMEUNIT_HOUR, status));
519 Locale en_GB("en_GB");
520 TimeUnitFormat formatter(en_GB, UTMUTFMT_ABBREVIATED_STYLE, status);
521 UnicodeString result;
522 formatter.format(oneHour, result, status);
523 assertSuccess("TestBritishShortHourFallback()", status);
524 assertEquals("TestBritishShortHourFallback()", UNICODE_STRING_SIMPLE("1 hr"), result, TRUE);
525 }
526
527 #endif
mirror of ICU