1 /*
2 *******************************************************************************
3 * Copyright (C) 2013-2014, International Business Machines Corporation and *
4 * others. All Rights Reserved. *
5 *******************************************************************************
6 *
7 * File RELDATEFMTTEST.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/localpointer.h"
19 #include "unicode/numfmt.h"
20 #include "unicode/reldatefmt.h"
21
22 #define LENGTHOF(array) (int32_t)(sizeof(array) / sizeof((array)[0]))
23
24 static const char *DirectionStr(UDateDirection direction);
25 static const char *RelativeUnitStr(UDateRelativeUnit unit);
26 static const char *AbsoluteUnitStr(UDateAbsoluteUnit unit);
27
28 typedef struct WithQuantityExpected {
29 double value;
30 UDateDirection direction;
31 UDateRelativeUnit unit;
32 const char *expected;
33 } WithQuantityExpected;
34
35 typedef struct WithoutQuantityExpected {
36 UDateDirection direction;
37 UDateAbsoluteUnit unit;
38 const char *expected;
39 } WithoutQuantityExpected;
40
41 static WithQuantityExpected kEnglish[] = {
42 {0.0, UDAT_DIRECTION_NEXT, UDAT_RELATIVE_SECONDS, "in 0 seconds"},
43 {0.5, UDAT_DIRECTION_NEXT, UDAT_RELATIVE_SECONDS, "in 0.5 seconds"},
44 {1.0, UDAT_DIRECTION_NEXT, UDAT_RELATIVE_SECONDS, "in 1 second"},
45 {2.0, UDAT_DIRECTION_NEXT, UDAT_RELATIVE_SECONDS, "in 2 seconds"},
46 {0.0, UDAT_DIRECTION_NEXT, UDAT_RELATIVE_MINUTES, "in 0 minutes"},
47 {0.5, UDAT_DIRECTION_NEXT, UDAT_RELATIVE_MINUTES, "in 0.5 minutes"},
48 {1.0, UDAT_DIRECTION_NEXT, UDAT_RELATIVE_MINUTES, "in 1 minute"},
49 {2.0, UDAT_DIRECTION_NEXT, UDAT_RELATIVE_MINUTES, "in 2 minutes"},
50 {0.0, UDAT_DIRECTION_NEXT, UDAT_RELATIVE_HOURS, "in 0 hours"},
51 {0.5, UDAT_DIRECTION_NEXT, UDAT_RELATIVE_HOURS, "in 0.5 hours"},
52 {1.0, UDAT_DIRECTION_NEXT, UDAT_RELATIVE_HOURS, "in 1 hour"},
53 {2.0, UDAT_DIRECTION_NEXT, UDAT_RELATIVE_HOURS, "in 2 hours"},
54 {0.0, UDAT_DIRECTION_NEXT, UDAT_RELATIVE_DAYS, "in 0 days"},
55 {0.5, UDAT_DIRECTION_NEXT, UDAT_RELATIVE_DAYS, "in 0.5 days"},
56 {1.0, UDAT_DIRECTION_NEXT, UDAT_RELATIVE_DAYS, "in 1 day"},
57 {2.0, UDAT_DIRECTION_NEXT, UDAT_RELATIVE_DAYS, "in 2 days"},
58 {0.0, UDAT_DIRECTION_NEXT, UDAT_RELATIVE_WEEKS, "in 0 weeks"},
59 {0.5, UDAT_DIRECTION_NEXT, UDAT_RELATIVE_WEEKS, "in 0.5 weeks"},
60 {1.0, UDAT_DIRECTION_NEXT, UDAT_RELATIVE_WEEKS, "in 1 week"},
61 {2.0, UDAT_DIRECTION_NEXT, UDAT_RELATIVE_WEEKS, "in 2 weeks"},
62 {0.0, UDAT_DIRECTION_NEXT, UDAT_RELATIVE_MONTHS, "in 0 months"},
63 {0.5, UDAT_DIRECTION_NEXT, UDAT_RELATIVE_MONTHS, "in 0.5 months"},
64 {1.0, UDAT_DIRECTION_NEXT, UDAT_RELATIVE_MONTHS, "in 1 month"},
65 {2.0, UDAT_DIRECTION_NEXT, UDAT_RELATIVE_MONTHS, "in 2 months"},
66 {0.0, UDAT_DIRECTION_NEXT, UDAT_RELATIVE_YEARS, "in 0 years"},
67 {0.5, UDAT_DIRECTION_NEXT, UDAT_RELATIVE_YEARS, "in 0.5 years"},
68 {1.0, UDAT_DIRECTION_NEXT, UDAT_RELATIVE_YEARS, "in 1 year"},
69 {2.0, UDAT_DIRECTION_NEXT, UDAT_RELATIVE_YEARS, "in 2 years"},
70
71 {0.0, UDAT_DIRECTION_LAST, UDAT_RELATIVE_SECONDS, "0 seconds ago"},
72 {0.5, UDAT_DIRECTION_LAST, UDAT_RELATIVE_SECONDS, "0.5 seconds ago"},
73 {1.0, UDAT_DIRECTION_LAST, UDAT_RELATIVE_SECONDS, "1 second ago"},
74 {2.0, UDAT_DIRECTION_LAST, UDAT_RELATIVE_SECONDS, "2 seconds ago"},
75 {0.0, UDAT_DIRECTION_LAST, UDAT_RELATIVE_MINUTES, "0 minutes ago"},
76 {0.5, UDAT_DIRECTION_LAST, UDAT_RELATIVE_MINUTES, "0.5 minutes ago"},
77 {1.0, UDAT_DIRECTION_LAST, UDAT_RELATIVE_MINUTES, "1 minute ago"},
78 {2.0, UDAT_DIRECTION_LAST, UDAT_RELATIVE_MINUTES, "2 minutes ago"},
79 {0.0, UDAT_DIRECTION_LAST, UDAT_RELATIVE_HOURS, "0 hours ago"},
80 {0.5, UDAT_DIRECTION_LAST, UDAT_RELATIVE_HOURS, "0.5 hours ago"},
81 {1.0, UDAT_DIRECTION_LAST, UDAT_RELATIVE_HOURS, "1 hour ago"},
82 {2.0, UDAT_DIRECTION_LAST, UDAT_RELATIVE_HOURS, "2 hours ago"},
83 {0.0, UDAT_DIRECTION_LAST, UDAT_RELATIVE_DAYS, "0 days ago"},
84 {0.5, UDAT_DIRECTION_LAST, UDAT_RELATIVE_DAYS, "0.5 days ago"},
85 {1.0, UDAT_DIRECTION_LAST, UDAT_RELATIVE_DAYS, "1 day ago"},
86 {2.0, UDAT_DIRECTION_LAST, UDAT_RELATIVE_DAYS, "2 days ago"},
87 {0.0, UDAT_DIRECTION_LAST, UDAT_RELATIVE_WEEKS, "0 weeks ago"},
88 {0.5, UDAT_DIRECTION_LAST, UDAT_RELATIVE_WEEKS, "0.5 weeks ago"},
89 {1.0, UDAT_DIRECTION_LAST, UDAT_RELATIVE_WEEKS, "1 week ago"},
90 {2.0, UDAT_DIRECTION_LAST, UDAT_RELATIVE_WEEKS, "2 weeks ago"},
91 {0.0, UDAT_DIRECTION_LAST, UDAT_RELATIVE_MONTHS, "0 months ago"},
92 {0.5, UDAT_DIRECTION_LAST, UDAT_RELATIVE_MONTHS, "0.5 months ago"},
93 {1.0, UDAT_DIRECTION_LAST, UDAT_RELATIVE_MONTHS, "1 month ago"},
94 {2.0, UDAT_DIRECTION_LAST, UDAT_RELATIVE_MONTHS, "2 months ago"},
95 {0.0, UDAT_DIRECTION_LAST, UDAT_RELATIVE_YEARS, "0 years ago"},
96 {0.5, UDAT_DIRECTION_LAST, UDAT_RELATIVE_YEARS, "0.5 years ago"},
97 {1.0, UDAT_DIRECTION_LAST, UDAT_RELATIVE_YEARS, "1 year ago"},
98 {2.0, UDAT_DIRECTION_LAST, UDAT_RELATIVE_YEARS, "2 years ago"}
99 };
100
101 static WithQuantityExpected kEnglishDecimal[] = {
102 {0.0, UDAT_DIRECTION_NEXT, UDAT_RELATIVE_SECONDS, "in 0.0 seconds"},
103 {0.5, UDAT_DIRECTION_NEXT, UDAT_RELATIVE_SECONDS, "in 0.5 seconds"},
104 {1.0, UDAT_DIRECTION_NEXT, UDAT_RELATIVE_SECONDS, "in 1.0 seconds"},
105 {2.0, UDAT_DIRECTION_NEXT, UDAT_RELATIVE_SECONDS, "in 2.0 seconds"}
106 };
107
108 static WithQuantityExpected kSerbian[] = {
109 {0.0, UDAT_DIRECTION_NEXT, UDAT_RELATIVE_MONTHS, "\\u0437\\u0430 0 \\u043c\\u0435\\u0441\\u0435\\u0446\\u0438"},
110 {1.2, UDAT_DIRECTION_NEXT, UDAT_RELATIVE_MONTHS, "\\u0437\\u0430 1,2 \\u043c\\u0435\\u0441\\u0435\\u0446\\u0430"},
111 {21.0, UDAT_DIRECTION_NEXT, UDAT_RELATIVE_MONTHS, "\\u0437\\u0430 21 \\u043c\\u0435\\u0441\\u0435\\u0446"}
112 };
113
114 static WithoutQuantityExpected kEnglishNoQuantity[] = {
115 {UDAT_DIRECTION_NEXT_2, UDAT_ABSOLUTE_DAY, ""},
116
117 {UDAT_DIRECTION_NEXT, UDAT_ABSOLUTE_DAY, "tomorrow"},
118 {UDAT_DIRECTION_NEXT, UDAT_ABSOLUTE_WEEK, "next week"},
119 {UDAT_DIRECTION_NEXT, UDAT_ABSOLUTE_MONTH, "next month"},
120 {UDAT_DIRECTION_NEXT, UDAT_ABSOLUTE_YEAR, "next year"},
121 {UDAT_DIRECTION_NEXT, UDAT_ABSOLUTE_MONDAY, "next Monday"},
122 {UDAT_DIRECTION_NEXT, UDAT_ABSOLUTE_TUESDAY, "next Tuesday"},
123 {UDAT_DIRECTION_NEXT, UDAT_ABSOLUTE_WEDNESDAY, "next Wednesday"},
124 {UDAT_DIRECTION_NEXT, UDAT_ABSOLUTE_THURSDAY, "next Thursday"},
125 {UDAT_DIRECTION_NEXT, UDAT_ABSOLUTE_FRIDAY, "next Friday"},
126 {UDAT_DIRECTION_NEXT, UDAT_ABSOLUTE_SATURDAY, "next Saturday"},
127 {UDAT_DIRECTION_NEXT, UDAT_ABSOLUTE_SUNDAY, "next Sunday"},
128
129 {UDAT_DIRECTION_LAST_2, UDAT_ABSOLUTE_DAY, ""},
130
131 {UDAT_DIRECTION_LAST, UDAT_ABSOLUTE_DAY, "yesterday"},
132 {UDAT_DIRECTION_LAST, UDAT_ABSOLUTE_WEEK, "last week"},
133 {UDAT_DIRECTION_LAST, UDAT_ABSOLUTE_MONTH, "last month"},
134 {UDAT_DIRECTION_LAST, UDAT_ABSOLUTE_YEAR, "last year"},
135 {UDAT_DIRECTION_LAST, UDAT_ABSOLUTE_MONDAY, "last Monday"},
136 {UDAT_DIRECTION_LAST, UDAT_ABSOLUTE_TUESDAY, "last Tuesday"},
137 {UDAT_DIRECTION_LAST, UDAT_ABSOLUTE_WEDNESDAY, "last Wednesday"},
138 {UDAT_DIRECTION_LAST, UDAT_ABSOLUTE_THURSDAY, "last Thursday"},
139 {UDAT_DIRECTION_LAST, UDAT_ABSOLUTE_FRIDAY, "last Friday"},
140 {UDAT_DIRECTION_LAST, UDAT_ABSOLUTE_SATURDAY, "last Saturday"},
141 {UDAT_DIRECTION_LAST, UDAT_ABSOLUTE_SUNDAY, "last Sunday"},
142
143 {UDAT_DIRECTION_THIS, UDAT_ABSOLUTE_DAY, "today"},
144 {UDAT_DIRECTION_THIS, UDAT_ABSOLUTE_WEEK, "this week"},
145 {UDAT_DIRECTION_THIS, UDAT_ABSOLUTE_MONTH, "this month"},
146 {UDAT_DIRECTION_THIS, UDAT_ABSOLUTE_YEAR, "this year"},
147 {UDAT_DIRECTION_THIS, UDAT_ABSOLUTE_MONDAY, "this Monday"},
148 {UDAT_DIRECTION_THIS, UDAT_ABSOLUTE_TUESDAY, "this Tuesday"},
149 {UDAT_DIRECTION_THIS, UDAT_ABSOLUTE_WEDNESDAY, "this Wednesday"},
150 {UDAT_DIRECTION_THIS, UDAT_ABSOLUTE_THURSDAY, "this Thursday"},
151 {UDAT_DIRECTION_THIS, UDAT_ABSOLUTE_FRIDAY, "this Friday"},
152 {UDAT_DIRECTION_THIS, UDAT_ABSOLUTE_SATURDAY, "this Saturday"},
153 {UDAT_DIRECTION_THIS, UDAT_ABSOLUTE_SUNDAY, "this Sunday"},
154
155 {UDAT_DIRECTION_PLAIN, UDAT_ABSOLUTE_DAY, "day"},
156 {UDAT_DIRECTION_PLAIN, UDAT_ABSOLUTE_WEEK, "week"},
157 {UDAT_DIRECTION_PLAIN, UDAT_ABSOLUTE_MONTH, "month"},
158 {UDAT_DIRECTION_PLAIN, UDAT_ABSOLUTE_YEAR, "year"},
159 {UDAT_DIRECTION_PLAIN, UDAT_ABSOLUTE_MONDAY, "Monday"},
160 {UDAT_DIRECTION_PLAIN, UDAT_ABSOLUTE_TUESDAY, "Tuesday"},
161 {UDAT_DIRECTION_PLAIN, UDAT_ABSOLUTE_WEDNESDAY, "Wednesday"},
162 {UDAT_DIRECTION_PLAIN, UDAT_ABSOLUTE_THURSDAY, "Thursday"},
163 {UDAT_DIRECTION_PLAIN, UDAT_ABSOLUTE_FRIDAY, "Friday"},
164 {UDAT_DIRECTION_PLAIN, UDAT_ABSOLUTE_SATURDAY, "Saturday"},
165 {UDAT_DIRECTION_PLAIN, UDAT_ABSOLUTE_SUNDAY, "Sunday"},
166
167 {UDAT_DIRECTION_PLAIN, UDAT_ABSOLUTE_NOW, "now"}
168 };
169
170 static WithoutQuantityExpected kSpanishNoQuantity[] = {
171 {UDAT_DIRECTION_NEXT_2, UDAT_ABSOLUTE_DAY, "pasado ma\\u00F1ana"},
172 {UDAT_DIRECTION_LAST_2, UDAT_ABSOLUTE_DAY, "antes de ayer"}
173 };
174
175 class RelativeDateTimeFormatterTest : public IntlTest {
176 public:
RelativeDateTimeFormatterTest()177 RelativeDateTimeFormatterTest() {
178 }
179
180 void runIndexedTest(int32_t index, UBool exec, const char *&name, char *par=0);
181 private:
182 void TestEnglish();
183 void TestSerbian();
184 void TestEnglishNoQuantity();
185 void TestSpanishNoQuantity();
186 void TestFormatWithQuantityIllegalArgument();
187 void TestFormatWithoutQuantityIllegalArgument();
188 void TestCustomNumberFormat();
189 void TestCombineDateAndTime();
190 void RunTest(
191 const Locale& locale,
192 const WithQuantityExpected* expectedResults,
193 int32_t expectedResultLength);
194 void RunTest(
195 const Locale& locale,
196 const WithoutQuantityExpected* expectedResults,
197 int32_t expectedResultLength);
198 void RunTest(
199 const RelativeDateTimeFormatter& fmt,
200 const WithQuantityExpected* expectedResults,
201 int32_t expectedResultLength,
202 const char *description);
203 void RunTest(
204 const RelativeDateTimeFormatter& fmt,
205 const WithoutQuantityExpected* expectedResults,
206 int32_t expectedResultLength,
207 const char *description);
208 void CheckExpectedResult(
209 const RelativeDateTimeFormatter& fmt,
210 const WithQuantityExpected& expectedResult,
211 const char* description);
212 void CheckExpectedResult(
213 const RelativeDateTimeFormatter& fmt,
214 const WithoutQuantityExpected& expectedResult,
215 const char* description);
216 void VerifyIllegalArgument(
217 const RelativeDateTimeFormatter& fmt,
218 UDateDirection direction,
219 UDateRelativeUnit unit);
220 void VerifyIllegalArgument(
221 const RelativeDateTimeFormatter& fmt,
222 UDateDirection direction,
223 UDateAbsoluteUnit unit);
224 };
225
runIndexedTest(int32_t index,UBool exec,const char * & name,char *)226 void RelativeDateTimeFormatterTest::runIndexedTest(
227 int32_t index, UBool exec, const char *&name, char *) {
228 if (exec) {
229 logln("TestSuite RelativeDateTimeFormatterTest: ");
230 }
231 TESTCASE_AUTO_BEGIN;
232 TESTCASE_AUTO(TestEnglish);
233 TESTCASE_AUTO(TestSerbian);
234 TESTCASE_AUTO(TestEnglishNoQuantity);
235 TESTCASE_AUTO(TestSpanishNoQuantity);
236 TESTCASE_AUTO(TestFormatWithQuantityIllegalArgument);
237 TESTCASE_AUTO(TestFormatWithoutQuantityIllegalArgument);
238 TESTCASE_AUTO(TestCustomNumberFormat);
239 TESTCASE_AUTO(TestCombineDateAndTime);
240 TESTCASE_AUTO_END;
241 }
242
TestEnglish()243 void RelativeDateTimeFormatterTest::TestEnglish() {
244 RunTest("en", kEnglish, LENGTHOF(kEnglish));
245 }
246
TestSerbian()247 void RelativeDateTimeFormatterTest::TestSerbian() {
248 RunTest("sr", kSerbian, LENGTHOF(kSerbian));
249 }
250
TestEnglishNoQuantity()251 void RelativeDateTimeFormatterTest::TestEnglishNoQuantity() {
252 RunTest("en", kEnglishNoQuantity, LENGTHOF(kEnglishNoQuantity));
253 }
254
TestSpanishNoQuantity()255 void RelativeDateTimeFormatterTest::TestSpanishNoQuantity() {
256 RunTest("es", kSpanishNoQuantity, LENGTHOF(kSpanishNoQuantity));
257 }
258
TestFormatWithQuantityIllegalArgument()259 void RelativeDateTimeFormatterTest::TestFormatWithQuantityIllegalArgument() {
260 UErrorCode status = U_ZERO_ERROR;
261 RelativeDateTimeFormatter fmt("en", status);
262 if (U_FAILURE(status)) {
263 dataerrln("Failure creating format object - %s", u_errorName(status));
264 return;
265 }
266 VerifyIllegalArgument(fmt, UDAT_DIRECTION_PLAIN, UDAT_RELATIVE_DAYS);
267 VerifyIllegalArgument(fmt, UDAT_DIRECTION_THIS, UDAT_RELATIVE_DAYS);
268 }
269
TestFormatWithoutQuantityIllegalArgument()270 void RelativeDateTimeFormatterTest::TestFormatWithoutQuantityIllegalArgument() {
271 UErrorCode status = U_ZERO_ERROR;
272 RelativeDateTimeFormatter fmt("en", status);
273 if (U_FAILURE(status)) {
274 dataerrln("Failure creating format object - %s", u_errorName(status));
275 return;
276 }
277 VerifyIllegalArgument(fmt, UDAT_DIRECTION_LAST, UDAT_ABSOLUTE_NOW);
278 VerifyIllegalArgument(fmt, UDAT_DIRECTION_NEXT, UDAT_ABSOLUTE_NOW);
279 VerifyIllegalArgument(fmt, UDAT_DIRECTION_THIS, UDAT_ABSOLUTE_NOW);
280 }
281
TestCustomNumberFormat()282 void RelativeDateTimeFormatterTest::TestCustomNumberFormat() {
283 NumberFormat *nf;
284 UErrorCode status = U_ZERO_ERROR;
285 {
286 RelativeDateTimeFormatter fmt("en", status);
287 if (U_FAILURE(status)) {
288 dataerrln(
289 "Failure creating format object - %s", u_errorName(status));
290 return;
291 }
292 nf = (NumberFormat *) fmt.getNumberFormat().clone();
293 }
294 nf->setMinimumFractionDigits(1);
295 nf->setMaximumFractionDigits(1);
296 RelativeDateTimeFormatter fmt("en", nf, status);
297
298 // Test copy constructor.
299 RelativeDateTimeFormatter fmt2(fmt);
300 RunTest(fmt2, kEnglishDecimal, LENGTHOF(kEnglishDecimal), "en decimal digits");
301
302 // Test assignment
303 fmt = RelativeDateTimeFormatter("es", status);
304 RunTest(fmt, kSpanishNoQuantity, LENGTHOF(kSpanishNoQuantity), "assignment operator");
305
306 }
307
TestCombineDateAndTime()308 void RelativeDateTimeFormatterTest::TestCombineDateAndTime() {
309 UErrorCode status = U_ZERO_ERROR;
310 RelativeDateTimeFormatter fmt("en", status);
311 if (U_FAILURE(status)) {
312 dataerrln("Failure creating format object - %s", u_errorName(status));
313 return;
314 }
315 UnicodeString actual;
316 fmt.combineDateAndTime(
317 UnicodeString("yesterday"),
318 UnicodeString("3:50"),
319 actual,
320 status);
321 UnicodeString expected("yesterday, 3:50");
322 if (expected != actual) {
323 errln("Expected "+expected+", got "+actual);
324 }
325 }
326
327
RunTest(const Locale & locale,const WithQuantityExpected * expectedResults,int32_t expectedResultLength)328 void RelativeDateTimeFormatterTest::RunTest(
329 const Locale& locale,
330 const WithQuantityExpected* expectedResults,
331 int32_t expectedResultLength) {
332 UErrorCode status = U_ZERO_ERROR;
333 RelativeDateTimeFormatter fmt(locale, status);
334 if (U_FAILURE(status)) {
335 dataerrln("Unable to create format object - %s", u_errorName(status));
336 return;
337 }
338 RunTest(fmt, expectedResults, expectedResultLength, locale.getName());
339 }
340
RunTest(const Locale & locale,const WithoutQuantityExpected * expectedResults,int32_t expectedResultLength)341 void RelativeDateTimeFormatterTest::RunTest(
342 const Locale& locale,
343 const WithoutQuantityExpected* expectedResults,
344 int32_t expectedResultLength) {
345 UErrorCode status = U_ZERO_ERROR;
346 RelativeDateTimeFormatter fmt(locale, status);
347 if (U_FAILURE(status)) {
348 dataerrln("Unable to create format object - %s", u_errorName(status));
349 return;
350 }
351 RunTest(fmt, expectedResults, expectedResultLength, locale.getName());
352 }
353
RunTest(const RelativeDateTimeFormatter & fmt,const WithQuantityExpected * expectedResults,int32_t expectedResultLength,const char * description)354 void RelativeDateTimeFormatterTest::RunTest(
355 const RelativeDateTimeFormatter& fmt,
356 const WithQuantityExpected* expectedResults,
357 int32_t expectedResultLength,
358 const char *description) {
359 for (int32_t i = 0; i < expectedResultLength; ++i) {
360 CheckExpectedResult(fmt, expectedResults[i], description);
361 }
362 }
363
RunTest(const RelativeDateTimeFormatter & fmt,const WithoutQuantityExpected * expectedResults,int32_t expectedResultLength,const char * description)364 void RelativeDateTimeFormatterTest::RunTest(
365 const RelativeDateTimeFormatter& fmt,
366 const WithoutQuantityExpected* expectedResults,
367 int32_t expectedResultLength,
368 const char *description) {
369 for (int32_t i = 0; i < expectedResultLength; ++i) {
370 CheckExpectedResult(fmt, expectedResults[i], description);
371 }
372 }
373
CheckExpectedResult(const RelativeDateTimeFormatter & fmt,const WithQuantityExpected & expectedResult,const char * description)374 void RelativeDateTimeFormatterTest::CheckExpectedResult(
375 const RelativeDateTimeFormatter& fmt,
376 const WithQuantityExpected& expectedResult,
377 const char* description) {
378 UErrorCode status = U_ZERO_ERROR;
379 UnicodeString actual;
380 fmt.format(expectedResult.value, expectedResult.direction, expectedResult.unit, actual, status);
381 UnicodeString expected(expectedResult.expected, -1, US_INV);
382 expected = expected.unescape();
383 char buffer[256];
384 sprintf(
385 buffer,
386 "%s, %f, %s, %s",
387 description,
388 expectedResult.value,
389 DirectionStr(expectedResult.direction),
390 RelativeUnitStr(expectedResult.unit));
391 if (actual != expected) {
392 errln(UnicodeString("Fail: Expected: ") + expected
393 + ", Got: " + actual
394 + ", For: " + buffer);
395 }
396 }
397
CheckExpectedResult(const RelativeDateTimeFormatter & fmt,const WithoutQuantityExpected & expectedResult,const char * description)398 void RelativeDateTimeFormatterTest::CheckExpectedResult(
399 const RelativeDateTimeFormatter& fmt,
400 const WithoutQuantityExpected& expectedResult,
401 const char* description) {
402 UErrorCode status = U_ZERO_ERROR;
403 UnicodeString actual;
404 fmt.format(expectedResult.direction, expectedResult.unit, actual, status);
405 UnicodeString expected(expectedResult.expected, -1, US_INV);
406 expected = expected.unescape();
407 char buffer[256];
408 sprintf(
409 buffer,
410 "%s, %s, %s",
411 description,
412 DirectionStr(expectedResult.direction),
413 AbsoluteUnitStr(expectedResult.unit));
414 if (actual != expected) {
415 errln(UnicodeString("Fail: Expected: ") + expected
416 + ", Got: " + actual
417 + ", For: " + buffer);
418 }
419 }
420
VerifyIllegalArgument(const RelativeDateTimeFormatter & fmt,UDateDirection direction,UDateRelativeUnit unit)421 void RelativeDateTimeFormatterTest::VerifyIllegalArgument(
422 const RelativeDateTimeFormatter& fmt,
423 UDateDirection direction,
424 UDateRelativeUnit unit) {
425 UnicodeString appendTo;
426 UErrorCode status = U_ZERO_ERROR;
427 fmt.format(1.0, direction, unit, appendTo, status);
428 if (status != U_ILLEGAL_ARGUMENT_ERROR) {
429 errln("Expected U_ILLEGAL_ARGUMENT_ERROR, got %s", u_errorName(status));
430 }
431 }
432
VerifyIllegalArgument(const RelativeDateTimeFormatter & fmt,UDateDirection direction,UDateAbsoluteUnit unit)433 void RelativeDateTimeFormatterTest::VerifyIllegalArgument(
434 const RelativeDateTimeFormatter& fmt,
435 UDateDirection direction,
436 UDateAbsoluteUnit unit) {
437 UnicodeString appendTo;
438 UErrorCode status = U_ZERO_ERROR;
439 fmt.format(direction, unit, appendTo, status);
440 if (status != U_ILLEGAL_ARGUMENT_ERROR) {
441 errln("Expected U_ILLEGAL_ARGUMENT_ERROR, got %s", u_errorName(status));
442 }
443 }
444
445 static const char *kLast2 = "Last_2";
446 static const char *kLast = "Last";
447 static const char *kThis = "This";
448 static const char *kNext = "Next";
449 static const char *kNext2 = "Next_2";
450 static const char *kPlain = "Plain";
451
452 static const char *kSeconds = "Seconds";
453 static const char *kMinutes = "Minutes";
454 static const char *kHours = "Hours";
455 static const char *kDays = "Days";
456 static const char *kWeeks = "Weeks";
457 static const char *kMonths = "Months";
458 static const char *kYears = "Years";
459
460 static const char *kSunday = "Sunday";
461 static const char *kMonday = "Monday";
462 static const char *kTuesday = "Tuesday";
463 static const char *kWednesday = "Wednesday";
464 static const char *kThursday = "Thursday";
465 static const char *kFriday = "Friday";
466 static const char *kSaturday = "Saturday";
467 static const char *kDay = "Day";
468 static const char *kWeek = "Week";
469 static const char *kMonth = "Month";
470 static const char *kYear = "Year";
471 static const char *kNow = "Now";
472
473 static const char *kUndefined = "Undefined";
474
DirectionStr(UDateDirection direction)475 static const char *DirectionStr(
476 UDateDirection direction) {
477 switch (direction) {
478 case UDAT_DIRECTION_LAST_2:
479 return kLast2;
480 case UDAT_DIRECTION_LAST:
481 return kLast;
482 case UDAT_DIRECTION_THIS:
483 return kThis;
484 case UDAT_DIRECTION_NEXT:
485 return kNext;
486 case UDAT_DIRECTION_NEXT_2:
487 return kNext2;
488 case UDAT_DIRECTION_PLAIN:
489 return kPlain;
490 default:
491 return kUndefined;
492 }
493 return kUndefined;
494 }
495
RelativeUnitStr(UDateRelativeUnit unit)496 static const char *RelativeUnitStr(
497 UDateRelativeUnit unit) {
498 switch (unit) {
499 case UDAT_RELATIVE_SECONDS:
500 return kSeconds;
501 case UDAT_RELATIVE_MINUTES:
502 return kMinutes;
503 case UDAT_RELATIVE_HOURS:
504 return kHours;
505 case UDAT_RELATIVE_DAYS:
506 return kDays;
507 case UDAT_RELATIVE_WEEKS:
508 return kWeeks;
509 case UDAT_RELATIVE_MONTHS:
510 return kMonths;
511 case UDAT_RELATIVE_YEARS:
512 return kYears;
513 default:
514 return kUndefined;
515 }
516 return kUndefined;
517 }
518
AbsoluteUnitStr(UDateAbsoluteUnit unit)519 static const char *AbsoluteUnitStr(
520 UDateAbsoluteUnit unit) {
521 switch (unit) {
522 case UDAT_ABSOLUTE_SUNDAY:
523 return kSunday;
524 case UDAT_ABSOLUTE_MONDAY:
525 return kMonday;
526 case UDAT_ABSOLUTE_TUESDAY:
527 return kTuesday;
528 case UDAT_ABSOLUTE_WEDNESDAY:
529 return kWednesday;
530 case UDAT_ABSOLUTE_THURSDAY:
531 return kThursday;
532 case UDAT_ABSOLUTE_FRIDAY:
533 return kFriday;
534 case UDAT_ABSOLUTE_SATURDAY:
535 return kSaturday;
536 case UDAT_ABSOLUTE_DAY:
537 return kDay;
538 case UDAT_ABSOLUTE_WEEK:
539 return kWeek;
540 case UDAT_ABSOLUTE_MONTH:
541 return kMonth;
542 case UDAT_ABSOLUTE_YEAR:
543 return kYear;
544 case UDAT_ABSOLUTE_NOW:
545 return kNow;
546 default:
547 return kUndefined;
548 }
549 return kUndefined;
550 }
551
createRelativeDateTimeFormatterTest()552 extern IntlTest *createRelativeDateTimeFormatterTest() {
553 return new RelativeDateTimeFormatterTest();
554 }
555
556 #endif
557