icuSources/test/intltest/incaltst.cpp

   1 // © 2016 and later: Unicode, Inc. and others.
   2 // License & terms of use: http://www.unicode.org/copyright.html
   3 /***********************************************************************
   4  * COPYRIGHT:
   5  * Copyright (c) 1997-2014, International Business Machines Corporation
   6  * and others. All Rights Reserved.
   7  ***********************************************************************/
   8
   9 /* Test Internationalized Calendars for C++ */
  10
  11 #include "unicode/utypes.h"
  12 #include "string.h"
  13 #include "unicode/locid.h"
  14 #include "japancal.h"
  15 #include "unicode/localpointer.h"
  16 #include "unicode/datefmt.h"
  17 #include "unicode/smpdtfmt.h"
  18 #include "unicode/dtptngen.h"
  19
  20 #if !UCONFIG_NO_FORMATTING
  21
  22 #include <stdio.h>
  23 #include "caltest.h"
  24
  25 #define CHECK(status, msg) UPRV_BLOCK_MACRO_BEGIN { \
  26     if (U_FAILURE(status)) { \
  27         dataerrln((UnicodeString(u_errorName(status)) + UnicodeString(" : " ) )+ msg); \
  28         return; \
  29     } \
  30 } UPRV_BLOCK_MACRO_END
  31
  32
  33 static UnicodeString escape( const UnicodeString&src)
  34 {
  35   UnicodeString dst;
  36     dst.remove();
  37     for (int32_t i = 0; i < src.length(); ++i) {
  38         UChar c = src[i];
  39         if(c < 0x0080)
  40             dst += c;
  41         else {
  42             dst += UnicodeString("[");
  43             char buf [8];
  44             sprintf(buf, "%#x", c);
  45             dst += UnicodeString(buf);
  46             dst += UnicodeString("]");
  47         }
  48     }
  49
  50     return dst;
  51 }
  52
  53
  54 #include "incaltst.h"
  55 #include "unicode/gregocal.h"
  56 #include "unicode/smpdtfmt.h"
  57 #include "unicode/simpletz.h"
  58
  59 // *****************************************************************************
  60 // class IntlCalendarTest
  61 // *****************************************************************************
  62 //--- move to CalendarTest?
  63
  64 // Turn this on to dump the calendar fields
  65 #define U_DEBUG_DUMPCALS
  66
  67
  68 #define CASE(id,test) case id: name = #test; if (exec) { logln(#test "---"); logln((UnicodeString)""); test(); } break
  69
  70
  71 void IntlCalendarTest::runIndexedTest( int32_t index, UBool exec, const char* &name, char* /*par*/ )
  72 {
  73     if (exec) logln("TestSuite IntlCalendarTest");
  74     switch (index) {
  75     CASE(0,TestTypes);
  76     CASE(1,TestGregorian);
  77     CASE(2,TestBuddhist);
  78     CASE(3,TestJapanese);
  79     CASE(4,TestBuddhistFormat);
  80     CASE(5,TestJapaneseFormat);
  81     CASE(6,TestJapanese3860);
  82     CASE(7,TestForceGannenNumbering);
  83     CASE(8,TestPersian);
  84     CASE(9,TestPersianFormat);
  85     CASE(10,TestTaiwan);
  86     default: name = ""; break;
  87     }
  88 }
  89
  90 #undef CASE
  91
  92 // ---------------------------------------------------------------------------------
  93
  94
  95 /**
  96  * Test various API methods for API completeness.
  97  */
  98 void
  99 IntlCalendarTest::TestTypes()
 100 {
 101   Calendar *c = NULL;
 102   UErrorCode status = U_ZERO_ERROR;
 103   int j;
 104   const char *locs [40] = { "en_US_VALLEYGIRL",
 105                             "en_US_VALLEYGIRL@collation=phonebook;calendar=japanese",
 106                             "en_US_VALLEYGIRL@collation=phonebook;calendar=gregorian",
 107                             "ja_JP@calendar=japanese",
 108                             "th_TH@calendar=buddhist",
 109                             "th_TH_TRADITIONAL",
 110                             "th_TH_TRADITIONAL@calendar=gregorian",
 111                             "en_US",
 112                             "th_TH",    // Default calendar for th_TH is buddhist
 113                             "th",       // th's default region is TH and buddhist is used as default for TH
 114                             "en_TH",    // Default calendar for any locales with region TH is buddhist
 115                             "en-TH-u-ca-gregory",
 116                             NULL };
 117   const char *types[40] = { "gregorian",
 118                             "japanese",
 119                             "gregorian",
 120                             "japanese",
 121                             "buddhist",
 122                             "buddhist",
 123                             "gregorian",
 124                             "gregorian",
 125                             "buddhist",
 126                             "buddhist",
 127                             "buddhist",
 128                             "gregorian",
 129                             NULL };
 130
 131   for(j=0;locs[j];j++) {
 132     logln(UnicodeString("Creating calendar of locale ")  + locs[j]);
 133     status = U_ZERO_ERROR;
 134     c = Calendar::createInstance(locs[j], status);
 135     CHECK(status, "creating '" + UnicodeString(locs[j]) + "' calendar");
 136     if(U_SUCCESS(status)) {
 137       logln(UnicodeString(" type is ") + c->getType());
 138       if(strcmp(c->getType(), types[j])) {
 139         dataerrln(UnicodeString(locs[j]) + UnicodeString("Calendar type ") + c->getType() + " instead of " + types[j]);
 140       }
 141     }
 142     delete c;
 143   }
 144 }
 145
 146
 147
 148 /**
 149  * Run a test of a quasi-Gregorian calendar.  This is a calendar
 150  * that behaves like a Gregorian but has different year/era mappings.
 151  * The int[] data array should have the format:
 152  *
 153  * { era, year, gregorianYear, month, dayOfMonth, ...  ... , -1 }
 154  */
 155 void IntlCalendarTest::quasiGregorianTest(Calendar& cal, const Locale& gcl, const int32_t *data) {
 156   UErrorCode status = U_ZERO_ERROR;
 157   // As of JDK 1.4.1_01, using the Sun JDK GregorianCalendar as
 158   // a reference throws us off by one hour.  This is most likely
 159   // due to the JDK 1.4 incorporation of historical time zones.
 160   //java.util.Calendar grego = java.util.Calendar.getInstance();
 161   Calendar *grego = Calendar::createInstance(gcl, status);
 162   if (U_FAILURE(status)) {
 163     dataerrln("Error calling Calendar::createInstance");
 164     return;
 165   }
 166
 167   int32_t tz1 = cal.get(UCAL_ZONE_OFFSET,status);
 168   int32_t tz2 = grego -> get (UCAL_ZONE_OFFSET, status);
 169   if(tz1 != tz2) {
 170     errln((UnicodeString)"cal's tz " + tz1 + " != grego's tz " + tz2);
 171   }
 172
 173   for (int32_t i=0; data[i]!=-1; ) {
 174     int32_t era = data[i++];
 175     int32_t year = data[i++];
 176     int32_t gregorianYear = data[i++];
 177     int32_t month = data[i++];
 178     int32_t dayOfMonth = data[i++];
 179
 180     grego->clear();
 181     grego->set(gregorianYear, month, dayOfMonth);
 182     UDate D = grego->getTime(status);
 183
 184     cal.clear();
 185     cal.set(UCAL_ERA, era);
 186     cal.set(year, month, dayOfMonth);
 187     UDate d = cal.getTime(status);
 188 #ifdef U_DEBUG_DUMPCALS
 189     logln((UnicodeString)"cal  : " + CalendarTest::calToStr(cal));
 190     logln((UnicodeString)"grego: " + CalendarTest::calToStr(*grego));
 191 #endif
 192     if (d == D) {
 193       logln(UnicodeString("OK: ") + era + ":" + year + "/" + (month+1) + "/" + dayOfMonth +
 194             " => " + d + " (" + UnicodeString(cal.getType()) + ")");
 195     } else {
 196       errln(UnicodeString("Fail: (fields to millis)") + era + ":" + year + "/" + (month+1) + "/" + dayOfMonth +
 197             " => " + d + ", expected " + D + " (" + UnicodeString(cal.getType()) + "Off by: " + (d-D));
 198     }
 199
 200     // Now, set the gregorian millis on the other calendar
 201     cal.clear();
 202     cal.setTime(D, status);
 203     int e = cal.get(UCAL_ERA, status);
 204     int y = cal.get(UCAL_YEAR, status);
 205 #ifdef U_DEBUG_DUMPCALS
 206     logln((UnicodeString)"cal  : " + CalendarTest::calToStr(cal));
 207     logln((UnicodeString)"grego: " + CalendarTest::calToStr(*grego));
 208 #endif
 209     if (y == year && e == era) {
 210       logln((UnicodeString)"OK: " + D + " => " + cal.get(UCAL_ERA, status) + ":" +
 211             cal.get(UCAL_YEAR, status) + "/" +
 212             (cal.get(UCAL_MONTH, status)+1) + "/" + cal.get(UCAL_DATE, status) +  " (" + UnicodeString(cal.getType()) + ")");
 213     } else {
 214       errln((UnicodeString)"Fail: (millis to fields)" + D + " => " + cal.get(UCAL_ERA, status) + ":" +
 215             cal.get(UCAL_YEAR, status) + "/" +
 216             (cal.get(UCAL_MONTH, status)+1) + "/" + cal.get(UCAL_DATE, status) +
 217             ", expected " + era + ":" + year + "/" + (month+1) + "/" +
 218             dayOfMonth +  " (" + UnicodeString(cal.getType()));
 219     }
 220   }
 221   delete grego;
 222   CHECK(status, "err during quasiGregorianTest()");
 223 }
 224
 225 // Verify that Gregorian works like Gregorian
 226 void IntlCalendarTest::TestGregorian() {
 227     UDate timeA = Calendar::getNow();
 228     int32_t data[] = {
 229         GregorianCalendar::AD, 1868, 1868, UCAL_SEPTEMBER, 8,
 230         GregorianCalendar::AD, 1868, 1868, UCAL_SEPTEMBER, 9,
 231         GregorianCalendar::AD, 1869, 1869, UCAL_JUNE, 4,
 232         GregorianCalendar::AD, 1912, 1912, UCAL_JULY, 29,
 233         GregorianCalendar::AD, 1912, 1912, UCAL_JULY, 30,
 234         GregorianCalendar::AD, 1912, 1912, UCAL_AUGUST, 1,
 235         -1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1
 236     };
 237
 238     Calendar *cal;
 239     UErrorCode status = U_ZERO_ERROR;
 240     cal = Calendar::createInstance(/*"de_DE", */ status);
 241     CHECK(status, UnicodeString("Creating de_CH calendar"));
 242     // Sanity check the calendar
 243     UDate timeB = Calendar::getNow();
 244     UDate timeCal = cal->getTime(status);
 245
 246     if(!(timeA <= timeCal) || !(timeCal <= timeB)) {
 247       errln((UnicodeString)"Error: Calendar time " + timeCal +
 248             " is not within sampled times [" + timeA + " to " + timeB + "]!");
 249     }
 250     // end sanity check
 251
 252     // Note, the following is a good way to test the sanity of the constructed calendars,
 253     // using Collation as a delay-loop:
 254     //
 255     // $ intltest  format/IntlCalendarTest  collate/G7CollationTest format/IntlCalendarTest
 256
 257     quasiGregorianTest(*cal,Locale("fr_FR"),data);
 258     delete cal;
 259 }
 260
 261 /**
 262  * Verify that BuddhistCalendar shifts years to Buddhist Era but otherwise
 263  * behaves like GregorianCalendar.
 264  */
 265 void IntlCalendarTest::TestBuddhist() {
 266     // BE 2542 == 1999 CE
 267     UDate timeA = Calendar::getNow();
 268
 269     int32_t data[] = {
 270         0,           // B. era   [928479600000]
 271         2542,        // B. year
 272         1999,        // G. year
 273         UCAL_JUNE,   // month
 274         4,           // day
 275
 276         0,           // B. era   [-79204842000000]
 277         3,           // B. year
 278         -540,        // G. year
 279         UCAL_FEBRUARY, // month
 280         12,          // day
 281
 282         0,           // test month calculation:  4795 BE = 4252 AD is a leap year, but 4795 AD is not.
 283         4795,        // BE [72018057600000]
 284         4252,        // AD
 285         UCAL_FEBRUARY,
 286         29,
 287
 288         -1,-1,-1,-1,-1,-1,-1,-1,-1,-1
 289     };
 290     Calendar *cal;
 291     UErrorCode status = U_ZERO_ERROR;
 292     cal = Calendar::createInstance("th_TH@calendar=buddhist", status);
 293     CHECK(status, UnicodeString("Creating th_TH@calendar=buddhist calendar"));
 294
 295     // Sanity check the calendar
 296     UDate timeB = Calendar::getNow();
 297     UDate timeCal = cal->getTime(status);
 298
 299     if(!(timeA <= timeCal) || !(timeCal <= timeB)) {
 300       errln((UnicodeString)"Error: Calendar time " + timeCal +
 301             " is not within sampled times [" + timeA + " to " + timeB + "]!");
 302     }
 303     // end sanity check
 304
 305
 306     quasiGregorianTest(*cal,Locale("th_TH@calendar=gregorian"),data);
 307     delete cal;
 308 }
 309
 310
 311 /**
 312  * Verify that TaiWanCalendar shifts years to Minguo Era but otherwise
 313  * behaves like GregorianCalendar.
 314  */
 315 void IntlCalendarTest::TestTaiwan() {
 316     // MG 1 == 1912 AD
 317     UDate timeA = Calendar::getNow();
 318
 319     // TODO port these to the data items
 320     int32_t data[] = {
 321         1,           // B. era   [928479600000]
 322         1,        // B. year
 323         1912,        // G. year
 324         UCAL_JUNE,   // month
 325         4,           // day
 326
 327         1,           // B. era   [-79204842000000]
 328         3,           // B. year
 329         1914,        // G. year
 330         UCAL_FEBRUARY, // month
 331         12,          // day
 332
 333         1,           // B. era   [-79204842000000]
 334         96,           // B. year
 335         2007,        // G. year
 336         UCAL_FEBRUARY, // month
 337         12,          // day
 338
 339         -1,-1,-1,-1,-1,-1,-1,-1,-1,-1
 340     };
 341     Calendar *cal;
 342     UErrorCode status = U_ZERO_ERROR;
 343     cal = Calendar::createInstance("en_US@calendar=roc", status);
 344     CHECK(status, UnicodeString("Creating en_US@calendar=roc calendar"));
 345
 346     // Sanity check the calendar
 347     UDate timeB = Calendar::getNow();
 348     UDate timeCal = cal->getTime(status);
 349
 350     if(!(timeA <= timeCal) || !(timeCal <= timeB)) {
 351       errln((UnicodeString)"Error: Calendar time " + timeCal +
 352             " is not within sampled times [" + timeA + " to " + timeB + "]!");
 353     }
 354     // end sanity check
 355
 356
 357     quasiGregorianTest(*cal,Locale("en_US"),data);
 358     delete cal;
 359 }
 360
 361
 362
 363 /**
 364  * Verify that JapaneseCalendar shifts years to Japanese Eras but otherwise
 365  * behaves like GregorianCalendar.
 366  */
 367 void IntlCalendarTest::TestJapanese() {
 368     UDate timeA = Calendar::getNow();
 369
 370     /* Sorry.. japancal.h is private! */
 371 #define JapaneseCalendar_MEIJI  232
 372 #define JapaneseCalendar_TAISHO 233
 373 #define JapaneseCalendar_SHOWA  234
 374 #define JapaneseCalendar_HEISEI 235
 375
 376     // BE 2542 == 1999 CE
 377     int32_t data[] = {
 378         //       Jera         Jyr  Gyear   m             d
 379         JapaneseCalendar_MEIJI, 1, 1868, UCAL_SEPTEMBER, 8,
 380         JapaneseCalendar_MEIJI, 1, 1868, UCAL_SEPTEMBER, 9,
 381         JapaneseCalendar_MEIJI, 2, 1869, UCAL_JUNE, 4,
 382         JapaneseCalendar_MEIJI, 45, 1912, UCAL_JULY, 29,
 383         JapaneseCalendar_TAISHO, 1, 1912, UCAL_JULY, 30,
 384         JapaneseCalendar_TAISHO, 1, 1912, UCAL_AUGUST, 1,
 385
 386         // new tests (not in java)
 387         JapaneseCalendar_SHOWA,     64,   1989,  UCAL_JANUARY, 7,  // Test current era transition (different code path than others)
 388         JapaneseCalendar_HEISEI,    1,   1989,  UCAL_JANUARY, 8,
 389         JapaneseCalendar_HEISEI,    1,   1989,  UCAL_JANUARY, 9,
 390         JapaneseCalendar_HEISEI,    1,   1989,  UCAL_DECEMBER, 20,
 391         JapaneseCalendar_HEISEI,  15,  2003,  UCAL_MAY, 22,
 392         -1,-1,-1,-1,-1,-1,-1,-1,-1,-1
 393     };
 394
 395     Calendar *cal;
 396     UErrorCode status = U_ZERO_ERROR;
 397     cal = Calendar::createInstance("ja_JP@calendar=japanese", status);
 398     CHECK(status, UnicodeString("Creating ja_JP@calendar=japanese calendar"));
 399     // Sanity check the calendar
 400     UDate timeB = Calendar::getNow();
 401     UDate timeCal = cal->getTime(status);
 402
 403     if(!(timeA <= timeCal) || !(timeCal <= timeB)) {
 404       errln((UnicodeString)"Error: Calendar time " + timeCal +
 405             " is not within sampled times [" + timeA + " to " + timeB + "]!");
 406     }
 407     // end sanity check
 408     quasiGregorianTest(*cal,Locale("ja_JP"),data);
 409     delete cal;
 410 }
 411
 412
 413
 414 void IntlCalendarTest::TestBuddhistFormat() {
 415     UErrorCode status = U_ZERO_ERROR;
 416
 417     // Test simple parse/format with adopt
 418
 419     // First, a contrived English test..
 420     UDate aDate = 999932400000.0;
 421     SimpleDateFormat fmt(UnicodeString("MMMM d, yyyy G"), Locale("en_US@calendar=buddhist"), status);
 422     CHECK(status, "creating date format instance");
 423     SimpleDateFormat fmt2(UnicodeString("MMMM d, yyyy G"), Locale("en_US@calendar=gregorian"), status);
 424     CHECK(status, "creating gregorian date format instance");
 425     UnicodeString str;
 426     fmt2.format(aDate, str);
 427     logln(UnicodeString() + "Test Date: " + str);
 428     str.remove();
 429     fmt.format(aDate, str);
 430     logln(UnicodeString() + "as Buddhist Calendar: " + escape(str));
 431     UnicodeString expected("September 8, 2544 BE");
 432     if(str != expected) {
 433         errln("Expected " + escape(expected) + " but got " + escape(str));
 434     }
 435     UDate otherDate = fmt.parse(expected, status);
 436     if(otherDate != aDate) {
 437         UnicodeString str3;
 438         fmt.format(otherDate, str3);
 439         errln("Parse incorrect of " + escape(expected) + " - wanted " + aDate + " but got " +  otherDate + ", " + escape(str3));
 440     } else {
 441         logln("Parsed OK: " + expected);
 442     }
 443
 444     CHECK(status, "Error occurred testing Buddhist Calendar in English ");
 445
 446     status = U_ZERO_ERROR;
 447     // Now, try in Thai
 448     {
 449         UnicodeString expect = CharsToUnicodeString("\\u0E27\\u0E31\\u0E19\\u0E40\\u0E2A\\u0E32\\u0E23\\u0E4C\\u0E17\\u0E35\\u0E48"
 450             " 8 \\u0E01\\u0E31\\u0e19\\u0e22\\u0e32\\u0e22\\u0e19 \\u0e1e.\\u0e28. 2544");
 451         UDate         expectDate = 999932400000.0;
 452         Locale        loc("th_TH_TRADITIONAL"); // legacy
 453
 454         simpleTest(loc, expect, expectDate, status);
 455     }
 456     status = U_ZERO_ERROR;
 457     {
 458         UnicodeString expect = CharsToUnicodeString("\\u0E27\\u0E31\\u0E19\\u0E40\\u0E2A\\u0E32\\u0E23\\u0E4C\\u0E17\\u0E35\\u0E48"
 459             " 8 \\u0E01\\u0E31\\u0e19\\u0e22\\u0e32\\u0e22\\u0e19 \\u0e1e.\\u0e28. 2544");
 460         UDate         expectDate = 999932400000.0;
 461         Locale        loc("th_TH@calendar=buddhist");
 462
 463         simpleTest(loc, expect, expectDate, status);
 464     }
 465     status = U_ZERO_ERROR;
 466     {
 467         UnicodeString expect = CharsToUnicodeString("\\u0E27\\u0E31\\u0E19\\u0E40\\u0E2A\\u0E32\\u0E23\\u0E4C\\u0E17\\u0E35\\u0E48"
 468             " 8 \\u0E01\\u0E31\\u0e19\\u0e22\\u0e32\\u0e22\\u0e19 \\u0e04.\\u0e28. 2001");
 469         UDate         expectDate = 999932400000.0;
 470         Locale        loc("th_TH@calendar=gregorian");
 471
 472         simpleTest(loc, expect, expectDate, status);
 473     }
 474     status = U_ZERO_ERROR;
 475     {
 476         UnicodeString expect = CharsToUnicodeString("\\u0E27\\u0E31\\u0E19\\u0E40\\u0E2A\\u0E32\\u0E23\\u0E4C\\u0E17\\u0E35\\u0E48"
 477             " 8 \\u0E01\\u0E31\\u0e19\\u0e22\\u0e32\\u0e22\\u0e19 \\u0e04.\\u0e28. 2001");
 478         UDate         expectDate = 999932400000.0;
 479         Locale        loc("th_TH_TRADITIONAL@calendar=gregorian");
 480
 481         simpleTest(loc, expect, expectDate, status);
 482     }
 483 }
 484
 485 // TaiwanFormat has been moved to testdata/format.txt
 486
 487
 488 void IntlCalendarTest::TestJapaneseFormat() {
 489     LocalPointer<Calendar> cal;
 490     UErrorCode status = U_ZERO_ERROR;
 491     cal.adoptInstead(Calendar::createInstance("ja_JP@calendar=japanese", status));
 492     CHECK(status, UnicodeString("Creating ja_JP@calendar=japanese calendar"));
 493
 494     LocalPointer<Calendar> cal2(cal->clone());
 495     cal.adoptInstead(nullptr);
 496
 497     // Test simple parse/format with adopt
 498
 499     UDate aDate = 999932400000.0;
 500     SimpleDateFormat fmt(UnicodeString("MMMM d, yy G"), Locale("en_US@calendar=japanese"), status);
 501     SimpleDateFormat fmt2(UnicodeString("MMMM d, yyyy G"), Locale("en_US@calendar=gregorian"), status);
 502     CHECK(status, "creating date format instance");
 503     UnicodeString str;
 504     fmt2.format(aDate, str);
 505     logln(UnicodeString() + "Test Date: " + str);
 506     str.remove();
 507     fmt.format(aDate, str);
 508     logln(UnicodeString() + "as Japanese Calendar: " + str);
 509     UnicodeString expected("September 8, 13 Heisei");
 510     if(str != expected) {
 511         errln("Expected " + expected + " but got " + str);
 512     }
 513     UDate otherDate = fmt.parse(expected, status);
 514     if(otherDate != aDate) {
 515         UnicodeString str3;
 516         ParsePosition pp;
 517         fmt.parse(expected, *cal2, pp);
 518         fmt.format(otherDate, str3);
 519         errln("Parse incorrect of " + expected + " - wanted " + aDate + " but got " +  " = " +   otherDate + ", " + str3 + " = " + CalendarTest::calToStr(*cal2) );
 520
 521     } else {
 522         logln("Parsed OK: " + expected);
 523     }
 524
 525     // Test parse with incomplete information
 526     SimpleDateFormat fmti(UnicodeString("G y"), Locale("en_US@calendar=japanese"), status);
 527     aDate = -3197117222000.0;
 528     CHECK(status, "creating date format instance");
 529     str.remove();
 530     fmt2.format(aDate, str);
 531     logln(UnicodeString() + "Test Date: " + str);
 532     str.remove();
 533     fmti.format(aDate, str);
 534     logln(UnicodeString() + "as Japanese Calendar: " + str);
 535     expected = u"Meiji 1";
 536     if(str != expected) {
 537         errln("Expected " + expected + " but got " + str);
 538     }
 539     otherDate = fmti.parse(expected, status);
 540     if(otherDate != aDate) {
 541         UnicodeString str3;
 542         ParsePosition pp;
 543         fmti.parse(expected, *cal2, pp);
 544         fmti.format(otherDate, str3);
 545         errln("Parse incorrect of " + expected + " - wanted " + aDate + " but got " +  " = " +
 546                 otherDate + ", " + str3 + " = " + CalendarTest::calToStr(*cal2) );
 547     } else {
 548         logln("Parsed OK: " + expected);
 549     }
 550
 551     CHECK(status, "Error occurred");
 552
 553     // Now, try in Japanese
 554     {
 555         UnicodeString expect = CharsToUnicodeString("\\u5e73\\u621013\\u5e749\\u67088\\u65e5 \\u571f\\u66dc\\u65e5");
 556         UDate         expectDate = 999932400000.0; // Testing a recent date
 557         Locale        loc("ja_JP@calendar=japanese");
 558
 559         status = U_ZERO_ERROR;
 560         simpleTest(loc, expect, expectDate, status);
 561     }
 562     {
 563         UnicodeString expect = CharsToUnicodeString("\\u5e73\\u621013\\u5e749\\u67088\\u65e5 \\u571f\\u66dc\\u65e5");
 564         UDate         expectDate = 999932400000.0; // Testing a recent date
 565         Locale        loc("ja_JP@calendar=japanese");
 566
 567         status = U_ZERO_ERROR;
 568         simpleTest(loc, expect, expectDate, status);
 569     }
 570     {
 571         UnicodeString expect = CharsToUnicodeString("\\u5b89\\u6c385\\u5e747\\u67084\\u65e5 \\u6728\\u66dc\\u65e5");
 572         UDate         expectDate = -6106032422000.0; // 1776-07-04T00:00:00Z-075258
 573         Locale        loc("ja_JP@calendar=japanese");
 574
 575         status = U_ZERO_ERROR;
 576         simpleTest(loc, expect, expectDate, status);
 577
 578     }
 579     {   // Jitterbug 1869 - this is an ambiguous era. (Showa 64 = Jan 6 1989, but Showa could be 2 other eras) )
 580         UnicodeString expect = CharsToUnicodeString("\\u662d\\u548c64\\u5e741\\u67086\\u65e5 \\u91d1\\u66dc\\u65e5");
 581         UDate         expectDate = 600076800000.0;
 582         Locale        loc("ja_JP@calendar=japanese");
 583
 584         status = U_ZERO_ERROR;
 585         simpleTest(loc, expect, expectDate, status);
 586
 587     }
 588     {   // 1989 Jan 9 Monday = Heisei 1; full is Gy年M月d日EEEE => 平成元年1月9日月曜日
 589         UnicodeString expect = CharsToUnicodeString("\\u5E73\\u6210\\u5143\\u5E741\\u67089\\u65E5 \\u6708\\u66DC\\u65E5");
 590         UDate         expectDate = 600336000000.0;
 591         Locale        loc("ja_JP@calendar=japanese");
 592
 593         status = U_ZERO_ERROR;
 594         simpleTest(loc, expect, expectDate, status);
 595
 596     }
 597     {   // This Feb 29th falls on a leap year by gregorian year, but not by Japanese year.
 598         UnicodeString expect = CharsToUnicodeString("\\u5EB7\\u6B632\\u5e742\\u670829\\u65e5 \\u65e5\\u66dc\\u65e5");
 599         UDate         expectDate =  -16214400422000.0;  // 1456-03-09T00:00Z-075258
 600         Locale        loc("ja_JP@calendar=japanese");
 601
 602         status = U_ZERO_ERROR;
 603         simpleTest(loc, expect, expectDate, status);
 604
 605     }
 606 }
 607
 608 void IntlCalendarTest::TestJapanese3860()
 609 {
 610     LocalPointer<Calendar> cal;
 611     UErrorCode status = U_ZERO_ERROR;
 612     cal.adoptInstead(Calendar::createInstance("ja_JP@calendar=japanese", status));
 613     CHECK(status, UnicodeString("Creating ja_JP@calendar=japanese calendar"));
 614     LocalPointer<Calendar> cal2(cal->clone());
 615     SimpleDateFormat fmt2(UnicodeString("HH:mm:ss.S MMMM d, yyyy G"), Locale("en_US@calendar=gregorian"), status);
 616     UnicodeString str;
 617
 618     {
 619         // Test simple parse/format with adopt
 620         UDate aDate = 0;
 621
 622         // Test parse with missing era (should default to current era, heisei)
 623         // Test parse with incomplete information
 624         logln("Testing parse w/ missing era...");
 625         SimpleDateFormat fmt(UnicodeString("y/M/d"), Locale("ja_JP@calendar=japanese"), status);
 626         CHECK(status, "creating date format instance");
 627         UErrorCode s2 = U_ZERO_ERROR;
 628         cal2->clear();
 629         UnicodeString samplestr("1/5/9");
 630         logln(UnicodeString() + "Test Year: " + samplestr);
 631         aDate = fmt.parse(samplestr, s2);
 632         ParsePosition pp=0;
 633         fmt.parse(samplestr, *cal2, pp);
 634         CHECK(s2, "parsing the 1/5/9 string");
 635         logln("*cal2 after 159 parse:");
 636         str.remove();
 637         fmt2.format(aDate, str);
 638         logln(UnicodeString() + "as Gregorian Calendar: " + str);
 639
 640         cal2->setTime(aDate, s2);
 641         int32_t gotYear = cal2->get(UCAL_YEAR, s2);
 642         int32_t gotEra = cal2->get(UCAL_ERA, s2);
 643         int32_t expectYear = 1;
 644         int32_t expectEra = JapaneseCalendar::getCurrentEra();
 645         if((gotYear!=1) || (gotEra != expectEra)) {
 646             errln(UnicodeString("parse "+samplestr+" of 'y/M/d' as Japanese Calendar, expected year ") + expectYear +
 647                     UnicodeString(" and era ") + expectEra +", but got year " + gotYear + " and era " + gotEra + " (Gregorian:" + str +")");
 648         } else {
 649             logln(UnicodeString() + " year: " + gotYear + ", era: " + gotEra);
 650         }
 651     }
 652
 653     {
 654         // Test simple parse/format with adopt
 655         UDate aDate = 0;
 656
 657         // Test parse with missing era (should default to current era, heisei)
 658         // Test parse with incomplete information
 659         logln("Testing parse w/ just year...");
 660         SimpleDateFormat fmt(UnicodeString("y"), Locale("ja_JP@calendar=japanese"), status);
 661         CHECK(status, "creating date format instance");
 662         UErrorCode s2 = U_ZERO_ERROR;
 663         cal2->clear();
 664         UnicodeString samplestr("1");
 665         logln(UnicodeString() + "Test Year: " + samplestr);
 666         aDate = fmt.parse(samplestr, s2);
 667         ParsePosition pp=0;
 668         fmt.parse(samplestr, *cal2, pp);
 669         CHECK(s2, "parsing the 1 string");
 670         logln("*cal2 after 1 parse:");
 671         str.remove();
 672         fmt2.format(aDate, str);
 673         logln(UnicodeString() + "as Gregorian Calendar: " + str);
 674
 675         cal2->setTime(aDate, s2);
 676         int32_t gotYear = cal2->get(UCAL_YEAR, s2);
 677         int32_t gotEra = cal2->get(UCAL_ERA, s2);
 678         int32_t expectYear = 1;
 679         int32_t expectEra = JapaneseCalendar::getCurrentEra();
 680         if((gotYear!=1) || (gotEra != expectEra)) {
 681             errln(UnicodeString("parse "+samplestr+" of 'y' as Japanese Calendar, expected year ") + expectYear +
 682                     UnicodeString(" and era ") + expectEra +", but got year " + gotYear + " and era " + gotEra + " (Gregorian:" + str +")");
 683         } else {
 684             logln(UnicodeString() + " year: " + gotYear + ", era: " + gotEra);
 685         }
 686     }
 687 }
 688
 689 void IntlCalendarTest::TestForceGannenNumbering()
 690 {
 691     UErrorCode status;
 692     const char* locID = "ja_JP@calendar=japanese";
 693     Locale loc(locID);
 694     UDate refDate = 600336000000.0; // 1989 Jan 9 Monday = Heisei 1
 695     UnicodeString patText(u"Gy年M月d日",-1);
 696     UnicodeString patNumr(u"GGGGGy/MM/dd",-1);
 697     UnicodeString skelText(u"yMMMM",-1);
 698
 699     // Test Gannen year forcing
 700     status = U_ZERO_ERROR;
 701     LocalPointer<SimpleDateFormat> testFmt1(new SimpleDateFormat(patText, loc, status));
 702     LocalPointer<SimpleDateFormat> testFmt2(new SimpleDateFormat(patNumr, loc, status));
 703     if (U_FAILURE(status)) {
 704         dataerrln("Fail in new SimpleDateFormat locale %s: %s", locID, u_errorName(status));
 705     } else {
 706         UnicodeString testString1, testString2;
 707         testString1 = testFmt1->format(refDate, testString1);
 708         if (testString1.length() < 3 || testString1.charAt(2) != 0x5143) {
 709             errln(UnicodeString("Formatting year 1 in created text style, got " + testString1 + " but expected 3rd char to be 0x5143"));
 710         }
 711         testString2 = testFmt2->format(refDate, testString2);
 712         if (testString2.length() < 2 || testString2.charAt(1) != 0x0031) {
 713             errln(UnicodeString("Formatting year 1 in created numeric style, got " + testString2 + " but expected 2nd char to be 1"));
 714         }
 715         // Now switch the patterns and verify that Gannen use follows the pattern
 716         testFmt1->applyPattern(patNumr);
 717         testString1.remove();
 718         testString1 = testFmt1->format(refDate, testString1);
 719         if (testString1.length() < 2 || testString1.charAt(1) != 0x0031) {
 720             errln(UnicodeString("Formatting year 1 in applied numeric style, got " + testString1 + " but expected 2nd char to be 1"));
 721         }
 722         testFmt2->applyPattern(patText);
 723         testString2.remove();
 724         testString2 = testFmt2->format(refDate, testString2);
 725         if (testString2.length() < 3 || testString2.charAt(2) != 0x5143) {
 726             errln(UnicodeString("Formatting year 1 in applied text style, got " + testString2 + " but expected 3rd char to be 0x5143"));
 727         }
 728     }
 729
 730     // Test disabling of Gannen year forcing
 731     status = U_ZERO_ERROR;
 732     LocalPointer<DateTimePatternGenerator> dtpgen(DateTimePatternGenerator::createInstance(loc, status));
 733     if (U_FAILURE(status)) {
 734         dataerrln("Fail in DateTimePatternGenerator::createInstance locale %s: %s", locID, u_errorName(status));
 735     } else {
 736         UnicodeString pattern = dtpgen->getBestPattern(skelText, status);
 737         if (U_FAILURE(status)) {
 738             dataerrln("Fail in DateTimePatternGenerator::getBestPattern locale %s: %s", locID, u_errorName(status));
 739         } else  {
 740             // Use override string of ""
 741             LocalPointer<SimpleDateFormat> testFmt3(new SimpleDateFormat(pattern, UnicodeString(""), loc, status));
 742             if (U_FAILURE(status)) {
 743                 dataerrln("Fail in new SimpleDateFormat locale %s: %s", locID, u_errorName(status));
 744             } else {
 745                 UnicodeString testString3;
 746                 testString3 = testFmt3->format(refDate, testString3);
 747                 if (testString3.length() < 3 || testString3.charAt(2) != 0x0031) {
 748                     errln(UnicodeString("Formatting year 1 with Gannen disabled, got " + testString3 + " but expected 3rd char to be 1"));
 749                 }
 750             }
 751         }
 752     }
 753 }
 754
 755 /**
 756  * Verify the Persian Calendar.
 757  */
 758 void IntlCalendarTest::TestPersian() {
 759     UDate timeA = Calendar::getNow();
 760
 761     Calendar *cal;
 762     UErrorCode status = U_ZERO_ERROR;
 763     cal = Calendar::createInstance("fa_IR@calendar=persian", status);
 764     CHECK(status, UnicodeString("Creating fa_IR@calendar=persian calendar"));
 765     // Sanity check the calendar
 766     UDate timeB = Calendar::getNow();
 767     UDate timeCal = cal->getTime(status);
 768
 769     if(!(timeA <= timeCal) || !(timeCal <= timeB)) {
 770       errln((UnicodeString)"Error: Calendar time " + timeCal +
 771             " is not within sampled times [" + timeA + " to " + timeB + "]!");
 772     }
 773     // end sanity check
 774
 775     // Test various dates to be sure of validity
 776     int32_t data[] = {
 777         1925, 4, 24, 1304, 2, 4,
 778         2011, 1, 11, 1389, 10, 21,
 779         1986, 2, 25, 1364, 12, 6,
 780         1934, 3, 14, 1312, 12, 23,
 781
 782         2090, 3, 19, 1468, 12, 29,
 783         2007, 2, 22, 1385, 12, 3,
 784         1969, 12, 31, 1348, 10, 10,
 785         1945, 11, 12, 1324, 8, 21,
 786         1925, 3, 31, 1304, 1, 11,
 787
 788         1996, 3, 19, 1374, 12, 29,
 789         1996, 3, 20, 1375, 1, 1,
 790         1997, 3, 20, 1375, 12, 30,
 791         1997, 3, 21, 1376, 1, 1,
 792
 793         2008, 3, 19, 1386, 12, 29,
 794         2008, 3, 20, 1387, 1, 1,
 795         2004, 3, 19, 1382, 12, 29,
 796         2004, 3, 20, 1383, 1, 1,
 797
 798         2006, 3, 20, 1384, 12, 29,
 799         2006, 3, 21, 1385, 1, 1,
 800
 801         2005, 4, 20, 1384, 1, 31,
 802         2005, 4, 21, 1384, 2, 1,
 803         2005, 5, 21, 1384, 2, 31,
 804         2005, 5, 22, 1384, 3, 1,
 805         2005, 6, 21, 1384, 3, 31,
 806         2005, 6, 22, 1384, 4, 1,
 807         2005, 7, 22, 1384, 4, 31,
 808         2005, 7, 23, 1384, 5, 1,
 809         2005, 8, 22, 1384, 5, 31,
 810         2005, 8, 23, 1384, 6, 1,
 811         2005, 9, 22, 1384, 6, 31,
 812         2005, 9, 23, 1384, 7, 1,
 813         2005, 10, 22, 1384, 7, 30,
 814         2005, 10, 23, 1384, 8, 1,
 815         2005, 11, 21, 1384, 8, 30,
 816         2005, 11, 22, 1384, 9, 1,
 817         2005, 12, 21, 1384, 9, 30,
 818         2005, 12, 22, 1384, 10, 1,
 819         2006, 1, 20, 1384, 10, 30,
 820         2006, 1, 21, 1384, 11, 1,
 821         2006, 2, 19, 1384, 11, 30,
 822         2006, 2, 20, 1384, 12, 1,
 823         2006, 3, 20, 1384, 12, 29,
 824         2006, 3, 21, 1385, 1, 1,
 825
 826         // The 2820-year cycle arithmetical algorithm would fail this one.
 827         2025, 3, 21, 1404, 1, 1,
 828
 829         -1,-1,-1,-1,-1,-1,-1,-1,-1,-1
 830     };
 831
 832     Calendar *grego = Calendar::createInstance("fa_IR@calendar=gregorian", status);
 833     for (int32_t i=0; data[i]!=-1; ) {
 834         int32_t gregYear = data[i++];
 835         int32_t gregMonth = data[i++]-1;
 836         int32_t gregDay = data[i++];
 837         int32_t persYear = data[i++];
 838         int32_t persMonth = data[i++]-1;
 839         int32_t persDay = data[i++];
 840
 841         // Test conversion from Persian dates
 842         grego->clear();
 843         grego->set(gregYear, gregMonth, gregDay);
 844
 845         cal->clear();
 846         cal->set(persYear, persMonth, persDay);
 847
 848         UDate persTime = cal->getTime(status);
 849         UDate gregTime = grego->getTime(status);
 850
 851         if (persTime != gregTime) {
 852           errln(UnicodeString("Expected ") + gregTime + " but got " + persTime);
 853         }
 854
 855         // Test conversion to Persian dates
 856         cal->clear();
 857         cal->setTime(gregTime, status);
 858
 859         int32_t computedYear = cal->get(UCAL_YEAR, status);
 860         int32_t computedMonth = cal->get(UCAL_MONTH, status);
 861         int32_t computedDay = cal->get(UCAL_DATE, status);
 862
 863         if ((persYear != computedYear) ||
 864             (persMonth != computedMonth) ||
 865             (persDay != computedDay)) {
 866           errln(UnicodeString("Expected ") + persYear + "/" + (persMonth+1) + "/" + persDay +
 867                 " but got " +  computedYear + "/" + (computedMonth+1) + "/" + computedDay);
 868         }
 869
 870     }
 871
 872     delete cal;
 873     delete grego;
 874 }
 875
 876 void IntlCalendarTest::TestPersianFormat() {
 877     UErrorCode status = U_ZERO_ERROR;
 878     SimpleDateFormat fmt(UnicodeString("MMMM d, yyyy G"), Locale(" en_US@calendar=persian"), status);
 879     CHECK(status, "creating date format instance");
 880     SimpleDateFormat fmt2(UnicodeString("MMMM d, yyyy G"), Locale("en_US@calendar=gregorian"), status);
 881     CHECK(status, "creating gregorian date format instance");
 882     UnicodeString gregorianDate("January 18, 2007 AD");
 883     UDate aDate = fmt2.parse(gregorianDate, status);
 884     UnicodeString str;
 885     fmt.format(aDate, str);
 886     logln(UnicodeString() + "as Persian Calendar: " + escape(str));
 887     UnicodeString expected("Dey 28, 1385 AP");
 888     if(str != expected) {
 889         errln("Expected " + escape(expected) + " but got " + escape(str));
 890     }
 891     UDate otherDate = fmt.parse(expected, status);
 892     if(otherDate != aDate) {
 893         UnicodeString str3;
 894         fmt.format(otherDate, str3);
 895         errln("Parse incorrect of " + escape(expected) + " - wanted " + aDate + " but got " +  otherDate + ", " + escape(str3));
 896     } else {
 897         logln("Parsed OK: " + expected);
 898     }
 899     // Two digit year parsing problem #4732
 900     fmt.applyPattern("yy-MM-dd");
 901     str.remove();
 902     fmt.format(aDate, str);
 903     expected.setTo("85-10-28");
 904     if(str != expected) {
 905         errln("Expected " + escape(expected) + " but got " + escape(str));
 906     }
 907     otherDate = fmt.parse(expected, status);
 908     if (otherDate != aDate) {
 909         errln("Parse incorrect of " + escape(expected) + " - wanted " + aDate + " but got " + otherDate);
 910     } else {
 911         logln("Parsed OK: " + expected);
 912     }
 913
 914     CHECK(status, "Error occured testing Persian Calendar in English ");
 915 }
 916
 917
 918 void IntlCalendarTest::simpleTest(const Locale& loc, const UnicodeString& expect, UDate expectDate, UErrorCode& status)
 919 {
 920     UnicodeString tmp;
 921     UDate         d;
 922     DateFormat *fmt0 = DateFormat::createDateTimeInstance(DateFormat::kFull, DateFormat::kFull);
 923
 924     logln("Try format/parse of " + (UnicodeString)loc.getName());
 925     DateFormat *fmt2 = DateFormat::createDateInstance(DateFormat::kFull, loc);
 926     if(fmt2) {
 927         fmt2->format(expectDate, tmp);
 928         logln(escape(tmp) + " ( in locale " + loc.getName() + ")");
 929         if(tmp != expect) {
 930             errln(UnicodeString("Failed to format " ) + loc.getName() + " expected " + escape(expect) + " got " + escape(tmp) );
 931         }
 932
 933         d = fmt2->parse(expect,status);
 934         CHECK(status, "Error occurred parsing " + UnicodeString(loc.getName()));
 935         if(d != expectDate) {
 936             fmt2->format(d,tmp);
 937             errln(UnicodeString("Failed to parse " ) + escape(expect) + ", " + loc.getName() + " expect " + (double)expectDate + " got " + (double)d  + " " + escape(tmp));
 938             logln( "wanted " + escape(fmt0->format(expectDate,tmp.remove())) + " but got " + escape(fmt0->format(d,tmp.remove())));
 939         }
 940         delete fmt2;
 941     } else {
 942         errln((UnicodeString)"Can't create " + loc.getName() + " date instance");
 943     }
 944     delete fmt0;
 945 }
 946
 947 #undef CHECK
 948
 949 #endif /* #if !UCONFIG_NO_FORMATTING */
 950
 951 //eof