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: 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 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 243 void RelativeDateTimeFormatterTest::TestEnglish() { 244 RunTest("en", kEnglish, LENGTHOF(kEnglish)); 245 } 246 247 void RelativeDateTimeFormatterTest::TestSerbian() { 248 RunTest("sr", kSerbian, LENGTHOF(kSerbian)); 249 } 250 251 void RelativeDateTimeFormatterTest::TestEnglishNoQuantity() { 252 RunTest("en", kEnglishNoQuantity, LENGTHOF(kEnglishNoQuantity)); 253 } 254 255 void RelativeDateTimeFormatterTest::TestSpanishNoQuantity() { 256 RunTest("es", kSpanishNoQuantity, LENGTHOF(kSpanishNoQuantity)); 257 } 258 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 552 extern IntlTest *createRelativeDateTimeFormatterTest() { 553 return new RelativeDateTimeFormatterTest(); 554 } 555 556 #endif 557
