icuSources/test/intltest/incaltst.cpp

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