]> git.saurik.com Git - apple/icu.git/blame - icuSources/test/intltest/measfmttest.cpp
projects / apple / icu.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
ICU-531.48.tar.gz
[apple/icu.git] / icuSources / test / intltest / measfmttest.cpp
CommitLineData
57a6839d
A		 1/*
2*******************************************************************************
3* Copyright (C) 2014, International Business Machines Corporation and *
4* others. All Rights Reserved. *
5*******************************************************************************
6*
7* File MEASFMTTEST.CPP
8*
9*******************************************************************************
10*/
11#include <stdio.h>
12#include <stdlib.h>
13
14#include "intltest.h"
15
16#if !UCONFIG_NO_FORMATTING
17
18#include "unicode/decimfmt.h"
19#include "unicode/measfmt.h"
20#include "unicode/measure.h"
21#include "unicode/measunit.h"
22#include "unicode/tmunit.h"
23#include "charstr.h"
24
25#define LENGTHOF(array) (int32_t)(sizeof(array) / sizeof((array)[0]))
26
27struct ExpectedResult {
28 const Measure *measures;
29 int32_t count;
30 const char *expected;
31};
32
33class MeasureFormatTest : public IntlTest {
34public:
35 MeasureFormatTest() {
36 }
37
38 void runIndexedTest(int32_t index, UBool exec, const char *&name, char *par=0);
39private:
40 void TestBasic();
41 void TestGetAvailable();
42 void TestExamplesInDocs();
43 void TestFormatPeriodEn();
44 void Test10219FractionalPlurals();
45 void TestGreek();
46 void TestFormatSingleArg();
47 void TestFormatMeasuresZeroArg();
48 void TestMultiples();
49 void TestGram();
50 void TestCurrencies();
51 void TestFieldPosition();
52 void TestFieldPositionMultiple();
53 void TestBadArg();
54 void TestEquality();
55 void TestDoubleZero();
56 void verifyFormat(
57 const char *description,
58 const MeasureFormat &fmt,
59 const Measure *measures,
60 int32_t measureCount,
61 const char *expected);
62 void verifyFormatWithPrefix(
63 const char *description,
64 const MeasureFormat &fmt,
65 const UnicodeString &prefix,
66 const Measure *measures,
67 int32_t measureCount,
68 const char *expected);
69 void verifyFormat(
70 const char *description,
71 const MeasureFormat &fmt,
72 const ExpectedResult *expectedResults,
73 int32_t count);
74 void helperTestMultiples(
75 const Locale &locale,
76 UMeasureFormatWidth width,
77 const char *expected);
78 void verifyFieldPosition(
79 const char *description,
80 const MeasureFormat &fmt,
81 const UnicodeString &prefix,
82 const Measure *measures,
83 int32_t measureCount,
84 NumberFormat::EAlignmentFields field,
85 int32_t start,
86 int32_t end);
87};
88
89void MeasureFormatTest::runIndexedTest(
90 int32_t index, UBool exec, const char *&name, char *) {
91 if (exec) {
92 logln("TestSuite MeasureFormatTest: ");
93 }
94 TESTCASE_AUTO_BEGIN;
95 TESTCASE_AUTO(TestBasic);
96 TESTCASE_AUTO(TestGetAvailable);
97 TESTCASE_AUTO(TestExamplesInDocs);
98 TESTCASE_AUTO(TestFormatPeriodEn);
99 TESTCASE_AUTO(Test10219FractionalPlurals);
100 TESTCASE_AUTO(TestGreek);
101 TESTCASE_AUTO(TestFormatSingleArg);
102 TESTCASE_AUTO(TestFormatMeasuresZeroArg);
103 TESTCASE_AUTO(TestMultiples);
104 TESTCASE_AUTO(TestGram);
105 TESTCASE_AUTO(TestCurrencies);
106 TESTCASE_AUTO(TestFieldPosition);
107 TESTCASE_AUTO(TestFieldPositionMultiple);
108 TESTCASE_AUTO(TestBadArg);
109 TESTCASE_AUTO(TestEquality);
110 TESTCASE_AUTO(TestDoubleZero);
111 TESTCASE_AUTO_END;
112}
113
114void MeasureFormatTest::TestBasic() {
115 UErrorCode status = U_ZERO_ERROR;
116 MeasureUnit *ptr1 = MeasureUnit::createArcMinute(status);
117 MeasureUnit *ptr2 = MeasureUnit::createArcMinute(status);
118 if (!(*ptr1 == *ptr2)) {
119 errln("Expect == to work.");
120 }
121 if (*ptr1 != *ptr2) {
122 errln("Expect != to work.");
123 }
124 MeasureUnit *ptr3 = MeasureUnit::createMeter(status);
125 if (*ptr1 == *ptr3) {
126 errln("Expect == to work.");
127 }
128 if (!(*ptr1 != *ptr3)) {
129 errln("Expect != to work.");
130 }
131 MeasureUnit *ptr4 = (MeasureUnit *) ptr1->clone();
132 if (*ptr1 != *ptr4) {
133 errln("Expect clone to work.");
134 }
135 MeasureUnit stack;
136 stack = *ptr1;
137 if (*ptr1 != stack) {
138 errln("Expect assignment to work.");
139 }
140
141 delete ptr1;
142 delete ptr2;
143 delete ptr3;
144 delete ptr4;
145}
146
147void MeasureFormatTest::TestGetAvailable() {
148 MeasureUnit *units = NULL;
149 UErrorCode status = U_ZERO_ERROR;
150 int32_t totalCount = MeasureUnit::getAvailable(units, 0, status);
151 while (status == U_BUFFER_OVERFLOW_ERROR) {
152 status = U_ZERO_ERROR;
153 delete [] units;
154 units = new MeasureUnit[totalCount];
155 totalCount = MeasureUnit::getAvailable(units, totalCount, status);
156 }
157 if (U_FAILURE(status)) {
158 dataerrln("Failure creating format object - %s", u_errorName(status));
159 delete [] units;
160 return;
161 }
162 if (totalCount < 200) {
163 errln("Expect at least 200 measure units including currencies.");
164 }
165 delete [] units;
166 StringEnumeration *types = MeasureUnit::getAvailableTypes(status);
167 if (U_FAILURE(status)) {
168 dataerrln("Failure getting types - %s", u_errorName(status));
169 delete types;
170 return;
171 }
172 if (types->count(status) < 10) {
173 errln("Expect at least 10 distinct unit types.");
174 }
175 units = NULL;
176 int32_t unitCapacity = 0;
177 int32_t unitCountSum = 0;
178 for (
179 const char* type = types->next(NULL, status);
180 type != NULL;
181 type = types->next(NULL, status)) {
182 int32_t unitCount = MeasureUnit::getAvailable(type, units, unitCapacity, status);
183 while (status == U_BUFFER_OVERFLOW_ERROR) {
184 status = U_ZERO_ERROR;
185 delete [] units;
186 units = new MeasureUnit[unitCount];
187 unitCapacity = unitCount;
188 unitCount = MeasureUnit::getAvailable(type, units, unitCapacity, status);
189 }
190 if (U_FAILURE(status)) {
191 dataerrln("Failure getting units - %s", u_errorName(status));
192 delete [] units;
193 delete types;
194 return;
195 }
196 if (unitCount < 1) {
197 errln("Expect at least one unit count per type.");
198 }
199 unitCountSum += unitCount;
200 }
201 if (unitCountSum != totalCount) {
202 errln("Expected total unit count to equal sum of unit counts by type.");
203 }
204 delete [] units;
205 delete types;
206}
207
208void MeasureFormatTest::TestExamplesInDocs() {
209 UErrorCode status = U_ZERO_ERROR;
210 MeasureFormat fmtFr(Locale::getFrench(), UMEASFMT_WIDTH_SHORT, status);
211 MeasureFormat fmtFrFull(
212 Locale::getFrench(), UMEASFMT_WIDTH_WIDE, status);
213 MeasureFormat fmtFrNarrow(
214 Locale::getFrench(), UMEASFMT_WIDTH_NARROW, status);
215 MeasureFormat fmtEn(Locale::getUS(), UMEASFMT_WIDTH_WIDE, status);
216 if (!assertSuccess("Error creating formatters", status)) {
217 return;
218 }
219 Measure measureC(23, MeasureUnit::createCelsius(status), status);
220 Measure measureF(70, MeasureUnit::createFahrenheit(status), status);
221 Measure feetAndInches[] = {
222 Measure(70, MeasureUnit::createFoot(status), status),
223 Measure(5.3, MeasureUnit::createInch(status), status)};
224 Measure footAndInch[] = {
225 Measure(1, MeasureUnit::createFoot(status), status),
226 Measure(1, MeasureUnit::createInch(status), status)};
227 Measure inchAndFeet[] = {
228 Measure(1, MeasureUnit::createInch(status), status),
229 Measure(2, MeasureUnit::createFoot(status), status)};
230 if (!assertSuccess("Error creating measurements.", status)) {
231 return;
232 }
233 verifyFormat(
234 "Celsius",
235 fmtFr,
236 &measureC,
237 1,
238 "23 \\u00B0C");
239 verifyFormatWithPrefix(
240 "Celsius",
241 fmtFr,
242 "Prefix: ",
243 &measureC,
244 1,
245 "Prefix: 23 \\u00B0C");
246 verifyFormat(
247 "Fahrenheit",
248 fmtFr,
249 &measureF,
250 1,
251 "70 \\u00B0F");
252 verifyFormat(
253 "Feet and inches",
254 fmtFrFull,
255 feetAndInches,
256 LENGTHOF(feetAndInches),
257 "70 pieds et 5,3 pouces");
258 verifyFormatWithPrefix(
259 "Feet and inches",
260 fmtFrFull,
261 "Prefix: ",
262 feetAndInches,
263 LENGTHOF(feetAndInches),
264 "Prefix: 70 pieds et 5,3 pouces");
265 verifyFormat(
266 "Foot and inch",
267 fmtFrFull,
268 footAndInch,
269 LENGTHOF(footAndInch),
270 "1 pied et 1 pouce");
271 verifyFormat(
272 "Foot and inch narrow",
273 fmtFrNarrow,
274 footAndInch,
275 LENGTHOF(footAndInch),
276 "1\\u2032 1\\u2033");
277 verifyFormat(
278 "Inch and feet",
279 fmtEn,
280 inchAndFeet,
281 LENGTHOF(inchAndFeet),
282 "1 inch, 2 feet");
283}
284
285void MeasureFormatTest::TestFormatPeriodEn() {
286 UErrorCode status = U_ZERO_ERROR;
287 Measure t_19m[] = {Measure(19, MeasureUnit::createMinute(status), status)};
288 Measure t_1h_23_5s[] = {
289 Measure(1.0, MeasureUnit::createHour(status), status),
290 Measure(23.5, MeasureUnit::createSecond(status), status)
291 };
292 Measure t_1h_23_5m[] = {
293 Measure(1.0, MeasureUnit::createHour(status), status),
294 Measure(23.5, MeasureUnit::createMinute(status), status)
295 };
296 Measure t_1h_0m_23s[] = {
297 Measure(
298 1.0,
299 TimeUnit::createInstance(
300 TimeUnit::UTIMEUNIT_HOUR, status),
301 status),
302 Measure(
303 0.0,
304 TimeUnit::createInstance(
305 TimeUnit::UTIMEUNIT_MINUTE, status),
306 status),
307 Measure(
308 23,
309 TimeUnit::createInstance(
310 TimeUnit::UTIMEUNIT_SECOND, status),
311 status)
312 };
313 Measure t_2y_5M_3w_4d[] = {
314 Measure(2.0, MeasureUnit::createYear(status), status),
315 Measure(5.0, MeasureUnit::createMonth(status), status),
316 Measure(3.0, MeasureUnit::createWeek(status), status),
317 Measure(4.0, MeasureUnit::createDay(status), status)
318 };
319 Measure t_1m_59_9996s[] = {
320 Measure(1.0, MeasureUnit::createMinute(status), status),
321 Measure(59.9996, MeasureUnit::createSecond(status), status)
322 };
323 Measure t_5h_17m[] = {
324 Measure(5.0, MeasureUnit::createHour(status), status),
325 Measure(17.0, MeasureUnit::createMinute(status), status)
326 };
327 Measure t_neg5h_17m[] = {
328 Measure(-5.0, MeasureUnit::createHour(status), status),
329 Measure(17.0, MeasureUnit::createMinute(status), status)
330 };
331 Measure t_19m_28s[] = {
332 Measure(19.0, MeasureUnit::createMinute(status), status),
333 Measure(28.0, MeasureUnit::createSecond(status), status)
334 };
335 Measure t_0h_0m_9s[] = {
336 Measure(0.0, MeasureUnit::createHour(status), status),
337 Measure(0.0, MeasureUnit::createMinute(status), status),
338 Measure(9.0, MeasureUnit::createSecond(status), status)
339 };
340 Measure t_0h_0m_17s[] = {
341 Measure(0.0, MeasureUnit::createHour(status), status),
342 Measure(0.0, MeasureUnit::createMinute(status), status),
343 Measure(17.0, MeasureUnit::createSecond(status), status)
344 };
345 Measure t_6h_56_92m[] = {
346 Measure(6.0, MeasureUnit::createHour(status), status),
347 Measure(56.92, MeasureUnit::createMinute(status), status)
348 };
349 Measure t_3h_4s_5m[] = {
350 Measure(3.0, MeasureUnit::createHour(status), status),
351 Measure(4.0, MeasureUnit::createSecond(status), status),
352 Measure(5.0, MeasureUnit::createMinute(status), status)
353 };
354 Measure t_6_7h_56_92m[] = {
355 Measure(6.7, MeasureUnit::createHour(status), status),
356 Measure(56.92, MeasureUnit::createMinute(status), status)
357 };
358
359 Measure t_3h_5h[] = {
360 Measure(3.0, MeasureUnit::createHour(status), status),
361 Measure(5.0, MeasureUnit::createHour(status), status)
362 };
363
364 if (!assertSuccess("Error creating Measure objects", status)) {
365 return;
366 }
367
368 ExpectedResult fullData[] = {
369 {t_1m_59_9996s, LENGTHOF(t_1m_59_9996s), "1 minute, 59.9996 seconds"},
370 {t_19m, LENGTHOF(t_19m), "19 minutes"},
371 {t_1h_23_5s, LENGTHOF(t_1h_23_5s), "1 hour, 23.5 seconds"},
372 {t_1h_23_5m, LENGTHOF(t_1h_23_5m), "1 hour, 23.5 minutes"},
373 {t_1h_0m_23s, LENGTHOF(t_1h_0m_23s), "1 hour, 0 minutes, 23 seconds"},
374 {t_2y_5M_3w_4d, LENGTHOF(t_2y_5M_3w_4d), "2 years, 5 months, 3 weeks, 4 days"}};
375
376 ExpectedResult abbrevData[] = {
377 {t_1m_59_9996s, LENGTHOF(t_1m_59_9996s), "1 min, 59.9996 secs"},
08b89b0a 378 {t_19m, LENGTHOF(t_19m), "19 min"},
57a6839d 379 {t_1h_23_5s, LENGTHOF(t_1h_23_5s), "1 hr, 23.5 secs"},
08b89b0a
A		 380 {t_1h_23_5m, LENGTHOF(t_1h_23_5m), "1 hr, 23.5 min"},
381 {t_1h_0m_23s, LENGTHOF(t_1h_0m_23s), "1 hr, 0 min, 23 secs"},
57a6839d
A		 382 {t_2y_5M_3w_4d, LENGTHOF(t_2y_5M_3w_4d), "2 yrs, 5 mths, 3 wks, 4 days"}};
383
384 ExpectedResult narrowData[] = {
385 {t_1m_59_9996s, LENGTHOF(t_1m_59_9996s), "1m 59.9996s"},
386 {t_19m, LENGTHOF(t_19m), "19m"},
387 {t_1h_23_5s, LENGTHOF(t_1h_23_5s), "1h 23.5s"},
388 {t_1h_23_5m, LENGTHOF(t_1h_23_5m), "1h 23.5m"},
389 {t_1h_0m_23s, LENGTHOF(t_1h_0m_23s), "1h 0m 23s"},
390 {t_2y_5M_3w_4d, LENGTHOF(t_2y_5M_3w_4d), "2y 5m 3w 4d"}};
391
392 ExpectedResult numericData[] = {
393 {t_1m_59_9996s, LENGTHOF(t_1m_59_9996s), "1:59.9996"},
394 {t_19m, LENGTHOF(t_19m), "19m"},
395 {t_1h_23_5s, LENGTHOF(t_1h_23_5s), "1:00:23.5"},
396 {t_1h_23_5m, LENGTHOF(t_1h_23_5m), "1:23.5"},
397 {t_1h_0m_23s, LENGTHOF(t_1h_0m_23s), "1:00:23"},
398 {t_5h_17m, LENGTHOF(t_5h_17m), "5:17"},
399 {t_neg5h_17m, LENGTHOF(t_neg5h_17m), "-5h 17m"},
400 {t_19m_28s, LENGTHOF(t_19m_28s), "19:28"},
401 {t_2y_5M_3w_4d, LENGTHOF(t_2y_5M_3w_4d), "2y 5m 3w 4d"},
402 {t_0h_0m_9s, LENGTHOF(t_0h_0m_9s), "0:00:09"},
403 {t_6h_56_92m, LENGTHOF(t_6h_56_92m), "6:56.92"},
404 {t_6_7h_56_92m, LENGTHOF(t_6_7h_56_92m), "6:56.92"},
405 {t_3h_4s_5m, LENGTHOF(t_3h_4s_5m), "3h 4s 5m"},
406 {t_3h_5h, LENGTHOF(t_3h_5h), "3h 5h"}};
407
408 ExpectedResult fullDataDe[] = {
409 {t_1m_59_9996s, LENGTHOF(t_1m_59_9996s), "1 Minute und 59,9996 Sekunden"},
410 {t_19m, LENGTHOF(t_19m), "19 Minuten"},
411 {t_1h_23_5s, LENGTHOF(t_1h_23_5s), "1 Stunde und 23,5 Sekunden"},
412 {t_1h_23_5m, LENGTHOF(t_1h_23_5m), "1 Stunde und 23,5 Minuten"},
413 {t_1h_0m_23s, LENGTHOF(t_1h_0m_23s), "1 Stunde, 0 Minuten und 23 Sekunden"},
414 {t_2y_5M_3w_4d, LENGTHOF(t_2y_5M_3w_4d), "2 Jahre, 5 Monate, 3 Wochen und 4 Tage"}};
415
416 ExpectedResult numericDataDe[] = {
417 {t_1m_59_9996s, LENGTHOF(t_1m_59_9996s), "1:59,9996"},
418 {t_19m, LENGTHOF(t_19m), "19 Min."},
419 {t_1h_23_5s, LENGTHOF(t_1h_23_5s), "1:00:23,5"},
420 {t_1h_23_5m, LENGTHOF(t_1h_23_5m), "1:23,5"},
421 {t_1h_0m_23s, LENGTHOF(t_1h_0m_23s), "1:00:23"},
422 {t_5h_17m, LENGTHOF(t_5h_17m), "5:17"},
423 {t_19m_28s, LENGTHOF(t_19m_28s), "19:28"},
424 {t_2y_5M_3w_4d, LENGTHOF(t_2y_5M_3w_4d), "2 J, 5 M, 3 W und 4 T"},
425 {t_0h_0m_17s, LENGTHOF(t_0h_0m_17s), "0:00:17"},
426 {t_6h_56_92m, LENGTHOF(t_6h_56_92m), "6:56,92"},
427 {t_3h_5h, LENGTHOF(t_3h_5h), "3 Std., 5 Std."}};
428
429 Locale en(Locale::getEnglish());
430 LocalPointer<NumberFormat> nf(NumberFormat::createInstance(en, status));
431 if (U_FAILURE(status)) {
432 dataerrln("Error creating number format en object - %s", u_errorName(status));
433 return;
434 }
435 nf->setMaximumFractionDigits(4);
436 MeasureFormat mf(en, UMEASFMT_WIDTH_WIDE, (NumberFormat *) nf->clone(), status);
437 if (!assertSuccess("Error creating measure format en WIDE", status)) {
438 return;
439 }
440 verifyFormat("en WIDE", mf, fullData, LENGTHOF(fullData));
441
442 // exercise copy constructor
443 {
444 MeasureFormat mf2(mf);
445 verifyFormat("en WIDE copy", mf2, fullData, LENGTHOF(fullData));
446 }
447 // exercise clone
448 {
449 MeasureFormat *mf3 = (MeasureFormat *) mf.clone();
450 verifyFormat("en WIDE copy", *mf3, fullData, LENGTHOF(fullData));
451 delete mf3;
452 }
453 mf = MeasureFormat(en, UMEASFMT_WIDTH_SHORT, (NumberFormat *) nf->clone(), status);
454 if (!assertSuccess("Error creating measure format en SHORT", status)) {
455 return;
456 }
457 verifyFormat("en SHORT", mf, abbrevData, LENGTHOF(abbrevData));
458 mf = MeasureFormat(en, UMEASFMT_WIDTH_NARROW, (NumberFormat *) nf->clone(), status);
459 if (!assertSuccess("Error creating measure format en NARROW", status)) {
460 return;
461 }
462 verifyFormat("en NARROW", mf, narrowData, LENGTHOF(narrowData));
463 mf = MeasureFormat(en, UMEASFMT_WIDTH_NUMERIC, (NumberFormat *) nf->clone(), status);
464 if (!assertSuccess("Error creating measure format en NUMERIC", status)) {
465 return;
466 }
467 verifyFormat("en NUMERIC", mf, numericData, LENGTHOF(numericData));
468
469 Locale de(Locale::getGerman());
470 nf.adoptInstead(NumberFormat::createInstance(de, status));
471 if (!assertSuccess("Error creating number format de object", status)) {
472 return;
473 }
474 nf->setMaximumFractionDigits(4);
475 mf = MeasureFormat(de, UMEASFMT_WIDTH_WIDE, (NumberFormat *) nf->clone(), status);
476 if (!assertSuccess("Error creating measure format de WIDE", status)) {
477 return;
478 }
479 verifyFormat("de WIDE", mf, fullDataDe, LENGTHOF(fullDataDe));
480 mf = MeasureFormat(de, UMEASFMT_WIDTH_NUMERIC, (NumberFormat *) nf->clone(), status);
481 if (!assertSuccess("Error creating measure format de NUMERIC", status)) {
482 return;
483 }
484 verifyFormat("de NUMERIC", mf, numericDataDe, LENGTHOF(numericDataDe));
485}
486
487void MeasureFormatTest::Test10219FractionalPlurals() {
488 Locale en(Locale::getEnglish());
489 double values[] = {1.588, 1.011};
490 const char *expected[2][3] = {
491 {"1 minute", "1.5 minutes", "1.58 minutes"},
492 {"1 minute", "1.0 minutes", "1.01 minutes"}
493 };
494 UErrorCode status = U_ZERO_ERROR;
495 for (int j = 0; j < LENGTHOF(values); j++) {
496 for (int i = 0; i < LENGTHOF(expected[j]); i++) {
497 DecimalFormat *df =
498 (DecimalFormat *) NumberFormat::createInstance(en, status);
499 if (U_FAILURE(status)) {
500 dataerrln("Error creating Number format - %s", u_errorName(status));
501 return;
502 }
503 df->setRoundingMode(DecimalFormat::kRoundDown);
504 df->setMinimumFractionDigits(i);
505 df->setMaximumFractionDigits(i);
506 MeasureFormat mf(en, UMEASFMT_WIDTH_WIDE, df, status);
507 if (!assertSuccess("Error creating Measure format", status)) {
508 return;
509 }
510 Measure measure(values[j], MeasureUnit::createMinute(status), status);
511 if (!assertSuccess("Error creating Measure unit", status)) {
512 return;
513 }
514 verifyFormat("Test10219", mf, &measure, 1, expected[j][i]);
515 }
516 }
517}
518
519static MeasureUnit toMeasureUnit(MeasureUnit *adopted) {
520 MeasureUnit result(*adopted);
521 delete adopted;
522 return result;
523}
524
525void MeasureFormatTest::TestGreek() {
526 Locale locales[] = {Locale("el_GR"), Locale("el")};
527 UErrorCode status = U_ZERO_ERROR;
528 MeasureUnit units[] = {
529 toMeasureUnit(MeasureUnit::createSecond(status)),
530 toMeasureUnit(MeasureUnit::createMinute(status)),
531 toMeasureUnit(MeasureUnit::createHour(status)),
532 toMeasureUnit(MeasureUnit::createDay(status)),
533 toMeasureUnit(MeasureUnit::createWeek(status)),
534 toMeasureUnit(MeasureUnit::createMonth(status)),
535 toMeasureUnit(MeasureUnit::createYear(status))};
536 if (!assertSuccess("Error creating Measure units", status)) {
537 return;
538 }
539 UMeasureFormatWidth styles[] = {
540 UMEASFMT_WIDTH_WIDE,
541 UMEASFMT_WIDTH_SHORT};
542 int32_t numbers[] = {1, 7};
543 const char *expected[] = {
544 "1 \\u03B4\\u03B5\\u03C5\\u03C4\\u03B5\\u03C1\\u03CC\\u03BB\\u03B5\\u03C0\\u03C4\\u03BF",
545 "1 \\u03BB\\u03B5\\u03C0\\u03C4\\u03CC",
546 "1 \\u03CE\\u03C1\\u03B1",
547 "1 \\u03B7\\u03BC\\u03AD\\u03C1\\u03B1",
548 "1 \\u03B5\\u03B2\\u03B4\\u03BF\\u03BC\\u03AC\\u03B4\\u03B1",
549 "1 \\u03BC\\u03AE\\u03BD\\u03B1\\u03C2",
550 "1 \\u03AD\\u03C4\\u03BF\\u03C2",
551 "1 \\u03B4\\u03B5\\u03C5\\u03C4.",
552 "1 \\u03BB\\u03B5\\u03C0.",
553 "1 \\u03CE\\u03C1\\u03B1",
554 "1 \\u03B7\\u03BC\\u03AD\\u03C1\\u03B1",
555 "1 \\u03B5\\u03B2\\u03B4.",
556 "1 \\u03BC\\u03AE\\u03BD.",
557 "1 \\u03AD\\u03C4\\u03BF\\u03C2",
558 "7 \\u03B4\\u03B5\\u03C5\\u03C4\\u03B5\\u03C1\\u03CC\\u03BB\\u03B5\\u03C0\\u03C4\\u03B1",
559 "7 \\u03BB\\u03B5\\u03C0\\u03C4\\u03AC",
560 "7 \\u03CE\\u03C1\\u03B5\\u03C2",
561 "7 \\u03B7\\u03BC\\u03AD\\u03C1\\u03B5\\u03C2",
562 "7 \\u03B5\\u03B2\\u03B4\\u03BF\\u03BC\\u03AC\\u03B4\\u03B5\\u03C2",
563 "7 \\u03BC\\u03AE\\u03BD\\u03B5\\u03C2",
564 "7 \\u03AD\\u03C4\\u03B7",
565 "7 \\u03B4\\u03B5\\u03C5\\u03C4.",
566 "7 \\u03BB\\u03B5\\u03C0.",
567 "7 \\u03CE\\u03C1\\u03B5\\u03C2",
568 "7 \\u03B7\\u03BC\\u03AD\\u03C1\\u03B5\\u03C2",
569 "7 \\u03B5\\u03B2\\u03B4.",
570 "7 \\u03BC\\u03AE\\u03BD.",
571 "7 \\u03AD\\u03C4\\u03B7",
572 "1 \\u03B4\\u03B5\\u03C5\\u03C4\\u03B5\\u03C1\\u03CC\\u03BB\\u03B5\\u03C0\\u03C4\\u03BF",
573 "1 \\u03BB\\u03B5\\u03C0\\u03C4\\u03CC",
574 "1 \\u03CE\\u03C1\\u03B1",
575 "1 \\u03B7\\u03BC\\u03AD\\u03C1\\u03B1",
576 "1 \\u03B5\\u03B2\\u03B4\\u03BF\\u03BC\\u03AC\\u03B4\\u03B1",
577 "1 \\u03BC\\u03AE\\u03BD\\u03B1\\u03C2",
578 "1 \\u03AD\\u03C4\\u03BF\\u03C2",
579 "1 \\u03B4\\u03B5\\u03C5\\u03C4.",
580 "1 \\u03BB\\u03B5\\u03C0.",
581 "1 \\u03CE\\u03C1\\u03B1",
582 "1 \\u03B7\\u03BC\\u03AD\\u03C1\\u03B1",
583 "1 \\u03B5\\u03B2\\u03B4.",
584 "1 \\u03BC\\u03AE\\u03BD.",
585 "1 \\u03AD\\u03C4\\u03BF\\u03C2",
586 "7 \\u03B4\\u03B5\\u03C5\\u03C4\\u03B5\\u03C1\\u03CC\\u03BB\\u03B5\\u03C0\\u03C4\\u03B1",
587 "7 \\u03BB\\u03B5\\u03C0\\u03C4\\u03AC",
588 "7 \\u03CE\\u03C1\\u03B5\\u03C2",
589 "7 \\u03B7\\u03BC\\u03AD\\u03C1\\u03B5\\u03C2",
590 "7 \\u03B5\\u03B2\\u03B4\\u03BF\\u03BC\\u03AC\\u03B4\\u03B5\\u03C2",
591 "7 \\u03BC\\u03AE\\u03BD\\u03B5\\u03C2",
592 "7 \\u03AD\\u03C4\\u03B7",
593 "7 \\u03B4\\u03B5\\u03C5\\u03C4.",
594 "7 \\u03BB\\u03B5\\u03C0.",
595 "7 \\u03CE\\u03C1\\u03B5\\u03C2",
596 "7 \\u03B7\\u03BC\\u03AD\\u03C1\\u03B5\\u03C2",
597 "7 \\u03B5\\u03B2\\u03B4.",
598 "7 \\u03BC\\u03AE\\u03BD.",
599 "7 \\u03AD\\u03C4\\u03B7"};
600
601 int32_t counter = 0;
602 for (int32_t locIndex = 0; locIndex < LENGTHOF(locales); ++locIndex ) {
603 for( int32_t numIndex = 0; numIndex < LENGTHOF(numbers); ++numIndex ) {
604 for ( int32_t styleIndex = 0; styleIndex < LENGTHOF(styles); ++styleIndex ) {
605 for ( int32_t unitIndex = 0; unitIndex < LENGTHOF(units); ++unitIndex ) {
606 Measure measure(numbers[numIndex], new MeasureUnit(units[unitIndex]), status);
607 if (!assertSuccess("Error creating Measure", status)) {
608 return;
609 }
610 MeasureFormat fmt(locales[locIndex], styles[styleIndex], status);
611 if (!assertSuccess("Error creating Measure format", status)) {
612 return;
613 }
614 verifyFormat("TestGreek", fmt, &measure, 1, expected[counter]);
615 ++counter;
616 }
617 }
618 }
619 }
620}
621
622void MeasureFormatTest::TestFormatSingleArg() {
623 UErrorCode status = U_ZERO_ERROR;
624 MeasureFormat fmt("en", UMEASFMT_WIDTH_WIDE, status);
625 if (!assertSuccess("Error creating formatter", status)) {
626 return;
627 }
628 UnicodeString buffer;
629 FieldPosition pos(0);
630 fmt.format(
631 new Measure(3.5, MeasureUnit::createFoot(status), status),
632 buffer,
633 pos,
634 status);
635 if (!assertSuccess("Error formatting", status)) {
636 return;
637 }
638 assertEquals(
639 "TestFormatSingleArg",
640 UnicodeString("3.5 feet"),
641 buffer);
642}
643
644void MeasureFormatTest::TestFormatMeasuresZeroArg() {
645 UErrorCode status = U_ZERO_ERROR;
646 MeasureFormat fmt("en", UMEASFMT_WIDTH_WIDE, status);
647 verifyFormat("TestFormatMeasuresZeroArg", fmt, NULL, 0, "");
648}
649
650void MeasureFormatTest::TestMultiples() {
651 Locale ru("ru");
652 Locale en("en");
653 helperTestMultiples(en, UMEASFMT_WIDTH_WIDE, "2 miles, 1 foot, 2.3 inches");
654 helperTestMultiples(en, UMEASFMT_WIDTH_SHORT, "2 mi, 1 ft, 2.3 in");
655 helperTestMultiples(en, UMEASFMT_WIDTH_NARROW, "2mi 1\\u2032 2.3\\u2033");
656 helperTestMultiples(ru, UMEASFMT_WIDTH_WIDE, "2 \\u043C\\u0438\\u043B\\u0438, 1 \\u0444\\u0443\\u0442 \\u0438 2,3 \\u0434\\u044E\\u0439\\u043C\\u0430");
657 helperTestMultiples(ru, UMEASFMT_WIDTH_SHORT, "2 \\u043C\\u0438\\u043B\\u0438, 1 \\u0444\\u0443\\u0442, 2,3 \\u0434\\u044E\\u0439\\u043C\\u0430");
658 helperTestMultiples(ru, UMEASFMT_WIDTH_NARROW, "2 \\u043C\\u0438\\u043B\\u044C 1 \\u0444\\u0443\\u0442 2,3 \\u0434\\u044E\\u0439\\u043C\\u0430");
659}
660
661void MeasureFormatTest::helperTestMultiples(
662 const Locale &locale,
663 UMeasureFormatWidth width,
664 const char *expected) {
665 UErrorCode status = U_ZERO_ERROR;
666 FieldPosition pos(0);
667 MeasureFormat fmt(locale, width, status);
668 if (!assertSuccess("Error creating format object", status)) {
669 return;
670 }
671 Measure measures[] = {
672 Measure(2, MeasureUnit::createMile(status), status),
673 Measure(1, MeasureUnit::createFoot(status), status),
674 Measure(2.3, MeasureUnit::createInch(status), status)};
675 if (!assertSuccess("Error creating measures", status)) {
676 return;
677 }
678 UnicodeString buffer;
679 fmt.formatMeasures(measures, LENGTHOF(measures), buffer, pos, status);
680 if (!assertSuccess("Error formatting measures", status)) {
681 return;
682 }
683 assertEquals("TestMultiples", UnicodeString(expected).unescape(), buffer);
684}
685
686void MeasureFormatTest::TestGram() {
687 UErrorCode status = U_ZERO_ERROR;
688 MeasureFormat fmt("en", UMEASFMT_WIDTH_SHORT, status);
689 if (!assertSuccess("Error creating format object", status)) {
690 return;
691 }
692 Measure gram(1, MeasureUnit::createGram(status), status);
693 Measure gforce(1, MeasureUnit::createGForce(status), status);
694 if (!assertSuccess("Error creating measures", status)) {
695 return;
696 }
697 verifyFormat("TestGram", fmt, &gram, 1, "1 g");
698 verifyFormat("TestGram", fmt, &gforce, 1, "1 G");
699}
700
701void MeasureFormatTest::TestCurrencies() {
702 UChar USD[] = {'U', 'S', 'D', 0};
703 UErrorCode status = U_ZERO_ERROR;
704 CurrencyAmount USD_1(1.0, USD, status);
705 CurrencyAmount USD_2(2.0, USD, status);
706 CurrencyAmount USD_NEG_1(-1.0, USD, status);
707 if (!assertSuccess("Error creating measures", status)) {
708 return;
709 }
710 Locale en("en");
711 MeasureFormat fmt(en, UMEASFMT_WIDTH_WIDE, status);
712 if (!assertSuccess("Error creating format object", status)) {
713 return;
714 }
715 verifyFormat("TestCurrenciesWide", fmt, &USD_NEG_1, 1, "-1.00 US dollars");
716 verifyFormat("TestCurrenciesWide", fmt, &USD_1, 1, "1.00 US dollars");
717 verifyFormat("TestCurrenciesWide", fmt, &USD_2, 1, "2.00 US dollars");
718 fmt = MeasureFormat(en, UMEASFMT_WIDTH_SHORT, status);
719 if (!assertSuccess("Error creating format object", status)) {
720 return;
721 }
722 verifyFormat("TestCurrenciesShort", fmt, &USD_NEG_1, 1, "-USD1.00");
723 verifyFormat("TestCurrenciesShort", fmt, &USD_1, 1, "USD1.00");
724 verifyFormat("TestCurrenciesShort", fmt, &USD_2, 1, "USD2.00");
725 fmt = MeasureFormat(en, UMEASFMT_WIDTH_NARROW, status);
726 if (!assertSuccess("Error creating format object", status)) {
727 return;
728 }
729 verifyFormat("TestCurrenciesNarrow", fmt, &USD_NEG_1, 1, "-$1.00");
730 verifyFormat("TestCurrenciesNarrow", fmt, &USD_1, 1, "$1.00");
731 verifyFormat("TestCurrenciesNarrow", fmt, &USD_2, 1, "$2.00");
732 fmt = MeasureFormat(en, UMEASFMT_WIDTH_NUMERIC, status);
733 if (!assertSuccess("Error creating format object", status)) {
734 return;
735 }
736 verifyFormat("TestCurrenciesNumeric", fmt, &USD_NEG_1, 1, "-$1.00");
737 verifyFormat("TestCurrenciesNumeric", fmt, &USD_1, 1, "$1.00");
738 verifyFormat("TestCurrenciesNumeric", fmt, &USD_2, 1, "$2.00");
739}
740
741void MeasureFormatTest::TestFieldPosition() {
742 UErrorCode status = U_ZERO_ERROR;
743 MeasureFormat fmt("en", UMEASFMT_WIDTH_SHORT, status);
744 if (!assertSuccess("Error creating format object", status)) {
745 return;
746 }
747 Measure measure(43.5, MeasureUnit::createFoot(status), status);
748 if (!assertSuccess("Error creating measure object 1", status)) {
749 return;
750 }
751 UnicodeString prefix("123456: ");
752 verifyFieldPosition(
753 "",
754 fmt,
755 prefix,
756 &measure,
757 1,
758 NumberFormat::kDecimalSeparatorField,
759 10,
760 11);
761 measure = Measure(43, MeasureUnit::createFoot(status), status);
762 if (!assertSuccess("Error creating measure object 2", status)) {
763 return;
764 }
765 verifyFieldPosition(
766 "",
767 fmt,
768 prefix,
769 &measure,
770 1,
771 NumberFormat::kDecimalSeparatorField,
772 0,
773 0);
774}
775
776void MeasureFormatTest::TestFieldPositionMultiple() {
777 UErrorCode status = U_ZERO_ERROR;
778 MeasureFormat fmt("en", UMEASFMT_WIDTH_SHORT, status);
779 if (!assertSuccess("Error creating format object", status)) {
780 return;
781 }
782 Measure first[] = {
783 Measure(354, MeasureUnit::createMeter(status), status),
784 Measure(23, MeasureUnit::createCentimeter(status), status)};
785 Measure second[] = {
786 Measure(354, MeasureUnit::createMeter(status), status),
787 Measure(23, MeasureUnit::createCentimeter(status), status),
788 Measure(5.4, MeasureUnit::createMillimeter(status), status)};
789 Measure third[] = {
790 Measure(3, MeasureUnit::createMeter(status), status),
791 Measure(23, MeasureUnit::createCentimeter(status), status),
792 Measure(5, MeasureUnit::createMillimeter(status), status)};
793 if (!assertSuccess("Error creating measure objects", status)) {
794 return;
795 }
796 UnicodeString prefix("123456: ");
797 verifyFieldPosition(
798 "Integer",
799 fmt,
800 prefix,
801 first,
802 LENGTHOF(first),
803 NumberFormat::kIntegerField,
804 8,
805 11);
806 verifyFieldPosition(
807 "Decimal separator",
808 fmt,
809 prefix,
810 second,
811 LENGTHOF(second),
812 NumberFormat::kDecimalSeparatorField,
813 23,
814 24);
815 verifyFieldPosition(
816 "no decimal separator",
817 fmt,
818 prefix,
819 third,
820 LENGTHOF(third),
821 NumberFormat::kDecimalSeparatorField,
822 0,
823 0);
824}
825
826void MeasureFormatTest::TestBadArg() {
827 UErrorCode status = U_ZERO_ERROR;
828 MeasureFormat fmt("en", UMEASFMT_WIDTH_SHORT, status);
829 if (!assertSuccess("Error creating format object", status)) {
830 return;
831 }
832 FieldPosition pos(0);
833 UnicodeString buffer;
834 fmt.format(
835 9.3,
836 buffer,
837 pos,
838 status);
839 if (status != U_ILLEGAL_ARGUMENT_ERROR) {
840 errln("Expected ILLEGAL_ARGUMENT_ERROR");
841 }
842}
843
844void MeasureFormatTest::TestEquality() {
845 UErrorCode status = U_ZERO_ERROR;
846 NumberFormat* nfeq = NumberFormat::createInstance("en", status);
847 NumberFormat* nfne = NumberFormat::createInstance("fr", status);
848 MeasureFormat fmt("en", UMEASFMT_WIDTH_SHORT, status);
849 MeasureFormat fmtEq2("en", UMEASFMT_WIDTH_SHORT, nfeq, status);
850 MeasureFormat fmtne1("en", UMEASFMT_WIDTH_WIDE, status);
851 MeasureFormat fmtne2("fr", UMEASFMT_WIDTH_SHORT, status);
852 MeasureFormat fmtne3("en", UMEASFMT_WIDTH_SHORT, nfne, status);
853 if (U_FAILURE(status)) {
854 dataerrln("Error creating MeasureFormats - %s", u_errorName(status));
855 return;
856 }
857 MeasureFormat fmtEq(fmt);
858 assertTrue("Equal", fmt == fmtEq);
859 assertTrue("Equal2", fmt == fmtEq2);
860 assertFalse("Equal Neg", fmt != fmtEq);
861 assertTrue("Not Equal 1", fmt != fmtne1);
862 assertFalse("Not Equal Neg 1", fmt == fmtne1);
863 assertTrue("Not Equal 2", fmt != fmtne2);
864 assertTrue("Not Equal 3", fmt != fmtne3);
865}
866
867void MeasureFormatTest::TestDoubleZero() {
868 UErrorCode status = U_ZERO_ERROR;
869 Measure measures[] = {
870 Measure(4.7, MeasureUnit::createHour(status), status),
871 Measure(23, MeasureUnit::createMinute(status), status),
872 Measure(16, MeasureUnit::createSecond(status), status)};
873 Locale en("en");
874 NumberFormat *nf = NumberFormat::createInstance(en, status);
875 MeasureFormat fmt("en", UMEASFMT_WIDTH_WIDE, nf, status);
876 UnicodeString appendTo;
877 FieldPosition pos(FieldPosition::DONT_CARE);
878 if (U_FAILURE(status)) {
879 dataerrln("Error creating formatter - %s", u_errorName(status));
880 return;
881 }
882 nf->setMinimumFractionDigits(2);
883 nf->setMaximumFractionDigits(2);
884 fmt.formatMeasures(measures, LENGTHOF(measures), appendTo, pos, status);
885 if (!assertSuccess("Error formatting", status)) {
886 return;
887 }
888 assertEquals(
889 "TestDoubleZero",
890 UnicodeString("4 hours, 23 minutes, 16.00 seconds"),
891 appendTo);
892 measures[0] = Measure(-4.7, MeasureUnit::createHour(status), status);
893 appendTo.remove();
894 fmt.formatMeasures(measures, LENGTHOF(measures), appendTo, pos, status);
895 if (!assertSuccess("Error formatting", status)) {
896 return;
897 }
898 assertEquals(
899 "TestDoubleZero",
900 UnicodeString("-4 hours, 23 minutes, 16.00 seconds"),
901 appendTo);
902}
903
904void MeasureFormatTest::verifyFieldPosition(
905 const char *description,
906 const MeasureFormat &fmt,
907 const UnicodeString &prefix,
908 const Measure *measures,
909 int32_t measureCount,
910 NumberFormat::EAlignmentFields field,
911 int32_t start,
912 int32_t end) {
913 // 8 char lead
914 UnicodeString result(prefix);
915 FieldPosition pos(field);
916 UErrorCode status = U_ZERO_ERROR;
917 CharString ch;
918 const char *descPrefix = ch.append(description, status)
919 .append(": ", status).data();
920 CharString beginIndex;
921 beginIndex.append(descPrefix, status).append("beginIndex", status);
922 CharString endIndex;
923 endIndex.append(descPrefix, status).append("endIndex", status);
924 fmt.formatMeasures(measures, measureCount, result, pos, status);
925 if (!assertSuccess("Error formatting", status)) {
926 return;
927 }
928 assertEquals(beginIndex.data(), start, pos.getBeginIndex());
929 assertEquals(endIndex.data(), end, pos.getEndIndex());
930}
931
932void MeasureFormatTest::verifyFormat(
933 const char *description,
934 const MeasureFormat &fmt,
935 const Measure *measures,
936 int32_t measureCount,
937 const char *expected) {
938 verifyFormatWithPrefix(
939 description,
940 fmt,
941 "",
942 measures,
943 measureCount,
944 expected);
945}
946
947void MeasureFormatTest::verifyFormatWithPrefix(
948 const char *description,
949 const MeasureFormat &fmt,
950 const UnicodeString &prefix,
951 const Measure *measures,
952 int32_t measureCount,
953 const char *expected) {
954 UnicodeString result(prefix);
955 FieldPosition pos(0);
956 UErrorCode status = U_ZERO_ERROR;
957 fmt.formatMeasures(measures, measureCount, result, pos, status);
958 if (!assertSuccess("Error formatting", status)) {
959 return;
960 }
961 assertEquals(description, UnicodeString(expected).unescape(), result);
962}
963
964void MeasureFormatTest::verifyFormat(
965 const char *description,
966 const MeasureFormat &fmt,
967 const ExpectedResult *expectedResults,
968 int32_t count) {
969 for (int32_t i = 0; i < count; ++i) {
970 verifyFormat(description, fmt, expectedResults[i].measures, expectedResults[i].count, expectedResults[i].expected);
971 }
972}
973
974extern IntlTest *createMeasureFormatTest() {
975 return new MeasureFormatTest();
976}
977
978#endif
979
mirror of ICU