source/test/intltest/incaltst.cpp - Issue 2435373002: Delete source/test

Side by Side Diff: source/test/intltest/incaltst.cpp

Issue 2435373002: Delete source/test (Closed)

Patch Set: Created 4 years, 2 months ago

Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.

Jump to:

OLD	NEW
	(Empty)
1 /***********************************************************************

2 * COPYRIGHT:

3 * Copyright (c) 1997-2014, 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(" : " ) )+ m sg); \

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 // Turn this on to dump the calendar fields

58 #define U_DEBUG_DUMPCALS

59

60

61 #define CASE(id,test) case id: name = #test; if (exec) { logln(#test "---"); log ln((UnicodeString)""); test(); } break

62

63

64 void IntlCalendarTest::runIndexedTest( int32_t index, UBool exec, const char* &n ame, char* /par/ )

65 {

66 if (exec) logln("TestSuite IntlCalendarTest");

67 switch (index) {

68 CASE(0,TestTypes);

69 CASE(1,TestGregorian);

70 CASE(2,TestBuddhist);

71 CASE(3,TestJapanese);

72 CASE(4,TestBuddhistFormat);

73 CASE(5,TestJapaneseFormat);

74 CASE(6,TestJapanese3860);

75 CASE(7,TestPersian);

76 CASE(8,TestPersianFormat);

77 CASE(9,TestTaiwan);

78 default: name = ""; break;

79 }

80 }

81

82 #undef CASE

83

84 // ----------------------------------------------------------------------------- ----

85

86

87 /**

88 * Test various API methods for API completeness.

89 */

90 void

91 IntlCalendarTest::TestTypes()

92 {

93 Calendar *c = NULL;

94 UErrorCode status = U_ZERO_ERROR;

95 int j;

96 const char *locs [40] = { "en_US_VALLEYGIRL",

97 "en_US_VALLEYGIRL@collation=phonebook;calendar=japan ese",

98 "en_US_VALLEYGIRL@collation=phonebook;calendar=grego rian",

99 "ja_JP@calendar=japanese",

100 "th_TH@calendar=buddhist",

101 "ja_JP_TRADITIONAL",

102 "th_TH_TRADITIONAL",

103 "th_TH_TRADITIONAL@calendar=gregorian",

104 "en_US",

105 "th_TH", // Default calendar for th_TH is buddhis t

106 "th", // th's default region is TH and buddhis t is used as default for TH

107 "en_TH", // Default calendar for any locales with region TH is buddhist

108 "en-TH-u-ca-gregory",

109 NULL };

110 const char *types[40] = { "gregorian",

111 "japanese",

112 "gregorian",

113 "japanese",

114 "buddhist",

115 "japanese",

116 "buddhist",

117 "gregorian",

118 "gregorian",

119 "buddhist",

120 "buddhist",

121 "buddhist",

122 "gregorian",

123 NULL };

124

125 for(j=0;locs[j];j++) {

126 logln(UnicodeString("Creating calendar of locale ") + locs[j]);

127 status = U_ZERO_ERROR;

128 c = Calendar::createInstance(locs[j], status);

129 CHECK(status, "creating '" + UnicodeString(locs[j]) + "' calendar");

130 if(U_SUCCESS(status)) {

131 logln(UnicodeString(" type is ") + c->getType());

132 if(strcmp(c->getType(), types[j])) {

133 dataerrln(UnicodeString(locs[j]) + UnicodeString("Calendar type ") + c-> getType() + " instead of " + types[j]);

134 }

135 }

136 delete c;

137 }

138 }

139

140

141

142 /**

143 * Run a test of a quasi-Gregorian calendar. This is a calendar

144 * that behaves like a Gregorian but has different year/era mappings.

145 * The int[] data array should have the format:

146 *

147 * { era, year, gregorianYear, month, dayOfMonth, ... ... , -1 }

148 */

149 void IntlCalendarTest::quasiGregorianTest(Calendar& cal, const Locale& gcl, cons t int32_t *data) {

150 UErrorCode status = U_ZERO_ERROR;

151 // As of JDK 1.4.1_01, using the Sun JDK GregorianCalendar as

152 // a reference throws us off by one hour. This is most likely

153 // due to the JDK 1.4 incorporation of historical time zones.

154 //java.util.Calendar grego = java.util.Calendar.getInstance();

155 Calendar *grego = Calendar::createInstance(gcl, status);

156 if (U_FAILURE(status)) {

157 dataerrln("Error calling Calendar::createInstance");

158 return;

159 }

160

161 int32_t tz1 = cal.get(UCAL_ZONE_OFFSET,status);

162 int32_t tz2 = grego -> get (UCAL_ZONE_OFFSET, status);

163 if(tz1 != tz2) {

164 errln((UnicodeString)"cal's tz " + tz1 + " != grego's tz " + tz2);

165 }

166

167 for (int32_t i=0; data[i]!=-1; ) {

168 int32_t era = data[i++];

169 int32_t year = data[i++];

170 int32_t gregorianYear = data[i++];

171 int32_t month = data[i++];

172 int32_t dayOfMonth = data[i++];

173

174 grego->clear();

175 grego->set(gregorianYear, month, dayOfMonth);

176 UDate D = grego->getTime(status);

177

178 cal.clear();

179 cal.set(UCAL_ERA, era);

180 cal.set(year, month, dayOfMonth);

181 UDate d = cal.getTime(status);

182 #ifdef U_DEBUG_DUMPCALS

183 logln((UnicodeString)"cal : " + CalendarTest::calToStr(cal));

184 logln((UnicodeString)"grego: " + CalendarTest::calToStr(*grego));

185 #endif

186 if (d == D) {

187 logln(UnicodeString("OK: ") + era + ":" + year + "/" + (month+1) + "/" + d ayOfMonth +

188 " => " + d + " (" + UnicodeString(cal.getType()) + ")");

189 } else {

190 errln(UnicodeString("Fail: (fields to millis)") + era + ":" + year + "/" + (month+1) + "/" + dayOfMonth +

191 " => " + d + ", expected " + D + " (" + UnicodeString(cal.getType()) + "Off by: " + (d-D));

192 }

193

194 // Now, set the gregorian millis on the other calendar

195 cal.clear();

196 cal.setTime(D, status);

197 int e = cal.get(UCAL_ERA, status);

198 int y = cal.get(UCAL_YEAR, status);

199 #ifdef U_DEBUG_DUMPCALS

200 logln((UnicodeString)"cal : " + CalendarTest::calToStr(cal));

201 logln((UnicodeString)"grego: " + CalendarTest::calToStr(*grego));

202 #endif

203 if (y == year && e == era) {

204 logln((UnicodeString)"OK: " + D + " => " + cal.get(UCAL_ERA, status) + ":" +

205 cal.get(UCAL_YEAR, status) + "/" +

206 (cal.get(UCAL_MONTH, status)+1) + "/" + cal.get(UCAL_DATE, status) + " (" + UnicodeString(cal.getType()) + ")");

207 } else {

208 errln((UnicodeString)"Fail: (millis to fields)" + D + " => " + cal.get(UCA L_ERA, status) + ":" +

209 cal.get(UCAL_YEAR, status) + "/" +

210 (cal.get(UCAL_MONTH, status)+1) + "/" + cal.get(UCAL_DATE, status) +

211 ", expected " + era + ":" + year + "/" + (month+1) + "/" +

212 dayOfMonth + " (" + UnicodeString(cal.getType()));

213 }

214 }

215 delete grego;

216 CHECK(status, "err during quasiGregorianTest()");

217 }

218

219 // Verify that Gregorian works like Gregorian

220 void IntlCalendarTest::TestGregorian() {

221 UDate timeA = Calendar::getNow();

222 int32_t data[] = {

223 GregorianCalendar::AD, 1868, 1868, UCAL_SEPTEMBER, 8,

224 GregorianCalendar::AD, 1868, 1868, UCAL_SEPTEMBER, 9,

225 GregorianCalendar::AD, 1869, 1869, UCAL_JUNE, 4,

226 GregorianCalendar::AD, 1912, 1912, UCAL_JULY, 29,

227 GregorianCalendar::AD, 1912, 1912, UCAL_JULY, 30,

228 GregorianCalendar::AD, 1912, 1912, UCAL_AUGUST, 1,

229 -1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1

230 };

231

232 Calendar *cal;

233 UErrorCode status = U_ZERO_ERROR;

234 cal = Calendar::createInstance(/"de_DE", / status);

235 CHECK(status, UnicodeString("Creating de_CH calendar"));

236 // Sanity check the calendar

237 UDate timeB = Calendar::getNow();

238 UDate timeCal = cal->getTime(status);

239

240 if(!(timeA <= timeCal) \|\| !(timeCal <= timeB)) {

241 errln((UnicodeString)"Error: Calendar time " + timeCal +

242 " is not within sampled times [" + timeA + " to " + timeB + "]!");

243 }

244 // end sanity check

245

246 // Note, the following is a good way to test the sanity of the constructed c alendars,

247 // using Collation as a delay-loop:

248 //

249 // $ intltest format/IntlCalendarTest collate/G7CollationTest format/IntlC alendarTest

250

251 quasiGregorianTest(*cal,Locale("fr_FR"),data);

252 delete cal;

253 }

254

255 /**

256 * Verify that BuddhistCalendar shifts years to Buddhist Era but otherwise

257 * behaves like GregorianCalendar.

258 */

259 void IntlCalendarTest::TestBuddhist() {

260 // BE 2542 == 1999 CE

261 UDate timeA = Calendar::getNow();

262

263 int32_t data[] = {

264 0, // B. era [928479600000]

265 2542, // B. year

266 1999, // G. year

267 UCAL_JUNE, // month

268 4, // day

269

270 0, // B. era [-79204842000000]

271 3, // B. year

272 -540, // G. year

273 UCAL_FEBRUARY, // month

274 12, // day

275

276 0, // test month calculation: 4795 BE = 4252 AD is a leap yea r, but 4795 AD is not.

277 4795, // BE [72018057600000]

278 4252, // AD

279 UCAL_FEBRUARY,

280 29,

281

282 -1,-1,-1,-1,-1,-1,-1,-1,-1,-1

283 };

284 Calendar *cal;

285 UErrorCode status = U_ZERO_ERROR;

286 cal = Calendar::createInstance("th_TH@calendar=buddhist", status);

287 CHECK(status, UnicodeString("Creating th_TH@calendar=buddhist calendar"));

288

289 // Sanity check the calendar

290 UDate timeB = Calendar::getNow();

291 UDate timeCal = cal->getTime(status);

292

293 if(!(timeA <= timeCal) \|\| !(timeCal <= timeB)) {

294 errln((UnicodeString)"Error: Calendar time " + timeCal +

295 " is not within sampled times [" + timeA + " to " + timeB + "]!");

296 }

297 // end sanity check

298

299

300 quasiGregorianTest(*cal,Locale("th_TH@calendar=gregorian"),data);

301 delete cal;

302 }

303

304

305 /**

306 * Verify that TaiWanCalendar shifts years to Minguo Era but otherwise

307 * behaves like GregorianCalendar.

308 */

309 void IntlCalendarTest::TestTaiwan() {

310 // MG 1 == 1912 AD

311 UDate timeA = Calendar::getNow();

312

313 // TODO port these to the data items

314 int32_t data[] = {

315 1, // B. era [928479600000]

316 1, // B. year

317 1912, // G. year

318 UCAL_JUNE, // month

319 4, // day

320

321 1, // B. era [-79204842000000]

322 3, // B. year

323 1914, // G. year

324 UCAL_FEBRUARY, // month

325 12, // day

326

327 1, // B. era [-79204842000000]

328 96, // B. year

329 2007, // G. year

330 UCAL_FEBRUARY, // month

331 12, // day

332

333 -1,-1,-1,-1,-1,-1,-1,-1,-1,-1

334 };

335 Calendar *cal;

336 UErrorCode status = U_ZERO_ERROR;

337 cal = Calendar::createInstance("en_US@calendar=roc", status);

338 CHECK(status, UnicodeString("Creating en_US@calendar=roc calendar"));

339

340 // Sanity check the calendar

341 UDate timeB = Calendar::getNow();

342 UDate timeCal = cal->getTime(status);

343

344 if(!(timeA <= timeCal) \|\| !(timeCal <= timeB)) {

345 errln((UnicodeString)"Error: Calendar time " + timeCal +

346 " is not within sampled times [" + timeA + " to " + timeB + "]!");

347 }

348 // end sanity check

349

350

351 quasiGregorianTest(*cal,Locale("en_US"),data);

352 delete cal;

353 }

354

355

356

357 /**

358 * Verify that JapaneseCalendar shifts years to Japanese Eras but otherwise

359 * behaves like GregorianCalendar.

360 */

361 void IntlCalendarTest::TestJapanese() {

362 UDate timeA = Calendar::getNow();

363

364 /* Sorry.. japancal.h is private! */

365 #define JapaneseCalendar_MEIJI 232

366 #define JapaneseCalendar_TAISHO 233

367 #define JapaneseCalendar_SHOWA 234

368 #define JapaneseCalendar_HEISEI 235

369

370 // BE 2542 == 1999 CE

371 int32_t data[] = {

372 // Jera Jyr Gyear m d

373 JapaneseCalendar_MEIJI, 1, 1868, UCAL_SEPTEMBER, 8,

374 JapaneseCalendar_MEIJI, 1, 1868, UCAL_SEPTEMBER, 9,

375 JapaneseCalendar_MEIJI, 2, 1869, UCAL_JUNE, 4,

376 JapaneseCalendar_MEIJI, 45, 1912, UCAL_JULY, 29,

377 JapaneseCalendar_TAISHO, 1, 1912, UCAL_JULY, 30,

378 JapaneseCalendar_TAISHO, 1, 1912, UCAL_AUGUST, 1,

379

380 // new tests (not in java)

381 JapaneseCalendar_SHOWA, 64, 1989, UCAL_JANUARY, 7, // Test curre nt era transition (different code path than others)

382 JapaneseCalendar_HEISEI, 1, 1989, UCAL_JANUARY, 8,

383 JapaneseCalendar_HEISEI, 1, 1989, UCAL_JANUARY, 9,

384 JapaneseCalendar_HEISEI, 1, 1989, UCAL_DECEMBER, 20,

385 JapaneseCalendar_HEISEI, 15, 2003, UCAL_MAY, 22,

386 -1,-1,-1,-1,-1,-1,-1,-1,-1,-1

387 };

388

389 Calendar *cal;

390 UErrorCode status = U_ZERO_ERROR;

391 cal = Calendar::createInstance("ja_JP@calendar=japanese", status);

392 CHECK(status, UnicodeString("Creating ja_JP@calendar=japanese calendar"));

393 // Sanity check the calendar

394 UDate timeB = Calendar::getNow();

395 UDate timeCal = cal->getTime(status);

396

397 if(!(timeA <= timeCal) \|\| !(timeCal <= timeB)) {

398 errln((UnicodeString)"Error: Calendar time " + timeCal +

399 " is not within sampled times [" + timeA + " to " + timeB + "]!");

400 }

401 // end sanity check

402 quasiGregorianTest(*cal,Locale("ja_JP"),data);

403 delete cal;

404 }

405

406

407

408 void IntlCalendarTest::TestBuddhistFormat() {

409 UErrorCode status = U_ZERO_ERROR;

410

411 // Test simple parse/format with adopt

412

413 // First, a contrived english test..

414 UDate aDate = 999932400000.0;

415 SimpleDateFormat *fmt = new SimpleDateFormat(UnicodeString("MMMM d, yyyy G") , Locale("en_US@calendar=buddhist"), status);

416 CHECK(status, "creating date format instance");

417 SimpleDateFormat *fmt2 = new SimpleDateFormat(UnicodeString("MMMM d, yyyy G" ), Locale("en_US@calendar=gregorian"), status);

418 CHECK(status, "creating gregorian date format instance");

419 if(!fmt) {

420 errln("Coudln't create en_US instance");

421 } else {

422 UnicodeString str;

423 fmt2->format(aDate, str);

424 logln(UnicodeString() + "Test Date: " + str);

425 str.remove();

426 fmt->format(aDate, str);

427 logln(UnicodeString() + "as Buddhist Calendar: " + escape(str));

428 UnicodeString expected("September 8, 2544 BE");

429 if(str != expected) {

430 errln("Expected " + escape(expected) + " but got " + escape(str));

431 }

432 UDate otherDate = fmt->parse(expected, status);

433 if(otherDate != aDate) {

434 UnicodeString str3;

435 fmt->format(otherDate, str3);

436 errln("Parse incorrect of " + escape(expected) + " - wanted " + aDat e + " but got " + otherDate + ", " + escape(str3));

437 } else {

438 logln("Parsed OK: " + expected);

439 }

440 delete fmt;

441 }

442 delete fmt2;

443

444 CHECK(status, "Error occured testing Buddhist Calendar in English ");

445

446 status = U_ZERO_ERROR;

447 // Now, try in Thai

448 {

449 UnicodeString expect = CharsToUnicodeString("\\u0E27\\u0E31\\u0E19\\u0E4 0\\u0E2A\\u0E32\\u0E23\\u0E4C\\u0E17\\u0E35\\u0E48"

450 " 8 \\u0E01\\u0E31\\u0e19\\u0e22\\u0e32\\u0e22\\u0e19 \\u0e1e.\\u0e2 8. 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\\u0E4 0\\u0E2A\\u0E32\\u0E23\\u0E4C\\u0E17\\u0E35\\u0E48"

459 " 8 \\u0E01\\u0E31\\u0e19\\u0e22\\u0e32\\u0e22\\u0e19 \\u0e1e.\\u0e2 8. 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\\u0E4 0\\u0E2A\\u0E32\\u0E23\\u0E4C\\u0E17\\u0E35\\u0E48"

468 " 8 \\u0E01\\u0E31\\u0e19\\u0e22\\u0e32\\u0e22\\u0e19 \\u0e04.\\u0e2 8. 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\\u0E4 0\\u0E2A\\u0E32\\u0E23\\u0E4C\\u0E17\\u0E35\\u0E48"

477 " 8 \\u0E01\\u0E31\\u0e19\\u0e22\\u0e32\\u0e22\\u0e19 \\u0e04.\\u0e2 8. 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 Calendar *cal;

490 UErrorCode status = U_ZERO_ERROR;

491 cal = Calendar::createInstance("ja_JP_TRADITIONAL", status);

492 CHECK(status, UnicodeString("Creating ja_JP_TRADITIONAL calendar"));

493

494 Calendar *cal2 = cal->clone();

495 delete cal;

496 cal = NULL;

497

498 // Test simple parse/format with adopt

499

500 UDate aDate = 999932400000.0;

501 SimpleDateFormat *fmt = new SimpleDateFormat(UnicodeString("MMMM d, yy G"), Locale("en_US@calendar=japanese"), status);

502 SimpleDateFormat *fmt2 = new SimpleDateFormat(UnicodeString("MMMM d, yyyy G" ), Locale("en_US@calendar=gregorian"), status);

503 CHECK(status, "creating date format instance");

504 if(!fmt) {

505 errln("Coudln't create en_US instance");

506 } else {

507 UnicodeString str;

508 fmt2->format(aDate, str);

509 logln(UnicodeString() + "Test Date: " + str);

510 str.remove();

511 fmt->format(aDate, str);

512 logln(UnicodeString() + "as Japanese Calendar: " + str);

513 UnicodeString expected("September 8, 13 Heisei");

514 if(str != expected) {

515 errln("Expected " + expected + " but got " + str);

516 }

517 UDate otherDate = fmt->parse(expected, status);

518 if(otherDate != aDate) {

519 UnicodeString str3;

520 ParsePosition pp;

521 fmt->parse(expected, *cal2, pp);

522 fmt->format(otherDate, str3);

523 errln("Parse incorrect of " + expected + " - wanted " + aDate + " bu t got " + " = " + otherDate + ", " + str3 + " = " + CalendarTest::calToStr(*c al2) );

524

525 } else {

526 logln("Parsed OK: " + expected);

527 }

528 delete fmt;

529 }

530

531 // Test parse with incomplete information

532 fmt = new SimpleDateFormat(UnicodeString("G y"), Locale("en_US@calendar=japa nese"), status);

533 aDate = -3197117222000.0;

534 CHECK(status, "creating date format instance");

535 if(!fmt) {

536 errln("Coudln't create en_US instance");

537 } else {

538 UnicodeString str;

539 fmt2->format(aDate, str);

540 logln(UnicodeString() + "Test Date: " + str);

541 str.remove();

542 fmt->format(aDate, str);

543 logln(UnicodeString() + "as Japanese Calendar: " + str);

544 UnicodeString expected("Meiji 1");

545 if(str != expected) {

546 errln("Expected " + expected + " but got " + str);

547 }

548 UDate otherDate = fmt->parse(expected, status);

549 if(otherDate != aDate) {

550 UnicodeString str3;

551 ParsePosition pp;

552 fmt->parse(expected, *cal2, pp);

553 fmt->format(otherDate, str3);

554 errln("Parse incorrect of " + expected + " - wanted " + aDate + " bu t got " + " = " +

555 otherDate + ", " + str3 + " = " + CalendarTest::calToStr(*cal2) );

556 } else {

557 logln("Parsed OK: " + expected);

558 }

559 delete fmt;

560 }

561

562 delete cal2;

563 delete fmt2;

564 CHECK(status, "Error occured");

565

566 // Now, try in Japanese

567 {

568 UnicodeString expect = CharsToUnicodeString("\\u5e73\\u621013\\u5e749\\u 67088\\u65e5\\u571f\\u66dc\\u65e5");

569 UDate expectDate = 999932400000.0; // Testing a recent date

570 Locale loc("ja_JP@calendar=japanese");

571

572 status = U_ZERO_ERROR;

573 simpleTest(loc, expect, expectDate, status);

574 }

575 {

576 UnicodeString expect = CharsToUnicodeString("\\u5e73\\u621013\\u5e749\\u 67088\\u65e5\\u571f\\u66dc\\u65e5");

577 UDate expectDate = 999932400000.0; // Testing a recent date

578 Locale loc("ja_JP_TRADITIONAL"); // legacy

579

580 status = U_ZERO_ERROR;

581 simpleTest(loc, expect, expectDate, status);

582 }

583 {

584 UnicodeString expect = CharsToUnicodeString("\\u5b89\\u6c385\\u5e747\\u6 7084\\u65e5\\u6728\\u66dc\\u65e5");

585 UDate expectDate = -6106032422000.0; // 1776-07-04T00:00:00Z-075 258

586 Locale loc("ja_JP@calendar=japanese");

587

588 status = U_ZERO_ERROR;

589 simpleTest(loc, expect, expectDate, status);

590

591 }

592 { // Jitterbug 1869 - this is an ambiguous era. (Showa 64 = Jan 6 1989, bu t Showa could be 2 other eras) )

593 UnicodeString expect = CharsToUnicodeString("\\u662d\\u548c64\\u5e741\\u 67086\\u65e5\\u91d1\\u66dc\\u65e5");

594 UDate expectDate = 600076800000.0;

595 Locale loc("ja_JP@calendar=japanese");

596

597 status = U_ZERO_ERROR;

598 simpleTest(loc, expect, expectDate, status);

599

600 }

601 { // This Feb 29th falls on a leap year by gregorian year, but not by Japa nese year.

602 UnicodeString expect = CharsToUnicodeString("\\u5EB7\\u6B632\\u5e742\\u6 70829\\u65e5\\u65e5\\u66dc\\u65e5");

603 UDate expectDate = -16214400422000.0; // 1456-03-09T00:00Z-075 258

604 Locale loc("ja_JP@calendar=japanese");

605

606 status = U_ZERO_ERROR;

607 simpleTest(loc, expect, expectDate, status);

608

609 }

610 }

611

612 void IntlCalendarTest::TestJapanese3860()

613 {

614 Calendar *cal;

615 UErrorCode status = U_ZERO_ERROR;

616 cal = Calendar::createInstance("ja_JP@calendar=japanese", status);

617 CHECK(status, UnicodeString("Creating ja_JP@calendar=japanese calendar"));

618 Calendar *cal2 = cal->clone();

619 SimpleDateFormat *fmt2 = new SimpleDateFormat(UnicodeString("HH:mm:ss.S MMMM d, yyyy G"), Locale("en_US@calendar=gregorian"), status);

620 UnicodeString str;

621

622

623 {

624 // Test simple parse/format with adopt

625 UDate aDate = 0;

626

627 // Test parse with missing era (should default to current era, heisei)

628 // Test parse with incomplete information

629 logln("Testing parse w/ missing era...");

630 SimpleDateFormat *fmt = new SimpleDateFormat(UnicodeString("y.M.d"), Loc ale("ja_JP@calendar=japanese"), status);

631 CHECK(status, "creating date format instance");

632 if(!fmt) {

633 errln("Coudln't create en_US instance");

634 } else {

635 UErrorCode s2 = U_ZERO_ERROR;

636 cal2->clear();

637 UnicodeString samplestr("1.1.9");

638 logln(UnicodeString() + "Test Year: " + samplestr);

639 aDate = fmt->parse(samplestr, s2);

640 ParsePosition pp=0;

641 fmt->parse(samplestr, *cal2, pp);

642 CHECK(s2, "parsing the 1.1.9 string");

643 logln("*cal2 after 119 parse:");

644 str.remove();

645 fmt2->format(aDate, str);

646 logln(UnicodeString() + "as Gregorian Calendar: " + str);

647

648 cal2->setTime(aDate, s2);

649 int32_t gotYear = cal2->get(UCAL_YEAR, s2);

650 int32_t gotEra = cal2->get(UCAL_ERA, s2);

651 int32_t expectYear = 1;

652 int32_t expectEra = JapaneseCalendar::getCurrentEra();

653 if((gotYear!=1) \|\| (gotEra != expectEra)) {

654 errln(UnicodeString("parse "+samplestr+" of 'y.m.d' as Japanese Calendar, expected year ") + expectYear +

655 UnicodeString(" and era ") + expectEra +", but got year " + gotYear + " and era " + gotEra + " (Gregorian:" + str +")");

656 } else {

657 logln(UnicodeString() + " year: " + gotYear + ", era: " + gotEra );

658 }

659 delete fmt;

660 }

661 }

662

663 {

664 // Test simple parse/format with adopt

665 UDate aDate = 0;

666

667 // Test parse with missing era (should default to current era, heisei)

668 // Test parse with incomplete information

669 logln("Testing parse w/ just year...");

670 SimpleDateFormat *fmt = new SimpleDateFormat(UnicodeString("y"), Locale( "ja_JP@calendar=japanese"), status);

671 CHECK(status, "creating date format instance");

672 if(!fmt) {

673 errln("Coudln't create en_US instance");

674 } else {

675 UErrorCode s2 = U_ZERO_ERROR;

676 cal2->clear();

677 UnicodeString samplestr("1");

678 logln(UnicodeString() + "Test Year: " + samplestr);

679 aDate = fmt->parse(samplestr, s2);

680 ParsePosition pp=0;

681 fmt->parse(samplestr, *cal2, pp);

682 CHECK(s2, "parsing the 1 string");

683 logln("*cal2 after 1 parse:");

684 str.remove();

685 fmt2->format(aDate, str);

686 logln(UnicodeString() + "as Gregorian Calendar: " + str);

687

688 cal2->setTime(aDate, s2);

689 int32_t gotYear = cal2->get(UCAL_YEAR, s2);

690 int32_t gotEra = cal2->get(UCAL_ERA, s2);

691 int32_t expectYear = 1;

692 int32_t expectEra = 235; //JapaneseCalendar::kCurrentEra;

693 if((gotYear!=1) \|\| (gotEra != expectEra)) {

694 errln(UnicodeString("parse "+samplestr+" of 'y' as Japanese Cale ndar, expected year ") + expectYear +

695 UnicodeString(" and era ") + expectEra +", but got year " + gotYear + " and era " + gotEra + " (Gregorian:" + str +")");

696 } else {

697 logln(UnicodeString() + " year: " + gotYear + ", era: " + gotEra );

698 }

699 delete fmt;

700 }

701 }

702

703 delete cal2;

704 delete cal;

705 delete fmt2;

706 }

707

708

709

710

711 /**

712 * Verify the Persian Calendar.

713 */

714 void IntlCalendarTest::TestPersian() {

715 UDate timeA = Calendar::getNow();

716

717 Calendar *cal;

718 UErrorCode status = U_ZERO_ERROR;

719 cal = Calendar::createInstance("fa_IR@calendar=persian", status);

720 CHECK(status, UnicodeString("Creating fa_IR@calendar=persian calendar"));

721 // Sanity check the calendar

722 UDate timeB = Calendar::getNow();

723 UDate timeCal = cal->getTime(status);

724

725 if(!(timeA <= timeCal) \|\| !(timeCal <= timeB)) {

726 errln((UnicodeString)"Error: Calendar time " + timeCal +

727 " is not within sampled times [" + timeA + " to " + timeB + "]!");

728 }

729 // end sanity check

730

731 // Test various dates to be sure of validity

732 int32_t data[] = {

733 1925, 4, 24, 1304, 2, 4,

734 2011, 1, 11, 1389, 10, 21,

735 1986, 2, 25, 1364, 12, 6,

736 1934, 3, 14, 1312, 12, 23,

737

738 2090, 3, 19, 1468, 12, 29,

739 2007, 2, 22, 1385, 12, 3,

740 1969, 12, 31, 1348, 10, 10,

741 1945, 11, 12, 1324, 8, 21,

742 1925, 3, 31, 1304, 1, 11,

743

744 1996, 3, 19, 1374, 12, 29,

745 1996, 3, 20, 1375, 1, 1,

746 1997, 3, 20, 1375, 12, 30,

747 1997, 3, 21, 1376, 1, 1,

748

749 2008, 3, 19, 1386, 12, 29,

750 2008, 3, 20, 1387, 1, 1,

751 2004, 3, 19, 1382, 12, 29,

752 2004, 3, 20, 1383, 1, 1,

753

754 2006, 3, 20, 1384, 12, 29,

755 2006, 3, 21, 1385, 1, 1,

756

757 2005, 4, 20, 1384, 1, 31,

758 2005, 4, 21, 1384, 2, 1,

759 2005, 5, 21, 1384, 2, 31,

760 2005, 5, 22, 1384, 3, 1,

761 2005, 6, 21, 1384, 3, 31,

762 2005, 6, 22, 1384, 4, 1,

763 2005, 7, 22, 1384, 4, 31,

764 2005, 7, 23, 1384, 5, 1,

765 2005, 8, 22, 1384, 5, 31,

766 2005, 8, 23, 1384, 6, 1,

767 2005, 9, 22, 1384, 6, 31,

768 2005, 9, 23, 1384, 7, 1,

769 2005, 10, 22, 1384, 7, 30,

770 2005, 10, 23, 1384, 8, 1,

771 2005, 11, 21, 1384, 8, 30,

772 2005, 11, 22, 1384, 9, 1,

773 2005, 12, 21, 1384, 9, 30,

774 2005, 12, 22, 1384, 10, 1,

775 2006, 1, 20, 1384, 10, 30,

776 2006, 1, 21, 1384, 11, 1,

777 2006, 2, 19, 1384, 11, 30,

778 2006, 2, 20, 1384, 12, 1,

779 2006, 3, 20, 1384, 12, 29,

780 2006, 3, 21, 1385, 1, 1,

781

782 // The 2820-year cycle arithmetical algorithm would fail this one.

783 2025, 3, 21, 1404, 1, 1,

784

785 -1,-1,-1,-1,-1,-1,-1,-1,-1,-1

786 };

787

788 Calendar *grego = Calendar::createInstance("fa_IR@calendar=gregorian", statu s);

789 for (int32_t i=0; data[i]!=-1; ) {

790 int32_t gregYear = data[i++];

791 int32_t gregMonth = data[i++]-1;

792 int32_t gregDay = data[i++];

793 int32_t persYear = data[i++];

794 int32_t persMonth = data[i++]-1;

795 int32_t persDay = data[i++];

796

797 // Test conversion from Persian dates

798 grego->clear();

799 grego->set(gregYear, gregMonth, gregDay);

800

801 cal->clear();

802 cal->set(persYear, persMonth, persDay);

803

804 UDate persTime = cal->getTime(status);

805 UDate gregTime = grego->getTime(status);

806

807 if (persTime != gregTime) {

808 errln(UnicodeString("Expected ") + gregTime + " but got " + persTime);

809 }

810

811 // Test conversion to Persian dates

812 cal->clear();

813 cal->setTime(gregTime, status);

814

815 int32_t computedYear = cal->get(UCAL_YEAR, status);

816 int32_t computedMonth = cal->get(UCAL_MONTH, status);

817 int32_t computedDay = cal->get(UCAL_DATE, status);

818

819 if ((persYear != computedYear) \|\|

820 (persMonth != computedMonth) \|\|

821 (persDay != computedDay)) {

822 errln(UnicodeString("Expected ") + persYear + "/" + (persMonth+1) + "/ " + persDay +

823 " but got " + computedYear + "/" + (computedMonth+1) + "/" + co mputedDay);

824 }

825

826 }

827

828 delete cal;

829 delete grego;

830 }

831

832 void IntlCalendarTest::TestPersianFormat() {

833 UErrorCode status = U_ZERO_ERROR;

834 SimpleDateFormat *fmt = new SimpleDateFormat(UnicodeString("MMMM d, yyyy G") , Locale(" en_US@calendar=persian"), status);

835 CHECK(status, "creating date format instance");

836 SimpleDateFormat *fmt2 = new SimpleDateFormat(UnicodeString("MMMM d, yyyy G" ), Locale("en_US@calendar=gregorian"), status);

837 CHECK(status, "creating gregorian date format instance");

838 UnicodeString gregorianDate("January 18, 2007 AD");

839 UDate aDate = fmt2->parse(gregorianDate, status);

840 if(!fmt) {

841 errln("Coudln't create en_US instance");

842 } else {

843 UnicodeString str;

844 fmt->format(aDate, str);

845 logln(UnicodeString() + "as Persian Calendar: " + escape(str));

846 UnicodeString expected("Dey 28, 1385 AP");

847 if(str != expected) {

848 errln("Expected " + escape(expected) + " but got " + escape(str));

849 }

850 UDate otherDate = fmt->parse(expected, status);

851 if(otherDate != aDate) {

852 UnicodeString str3;

853 fmt->format(otherDate, str3);

854 errln("Parse incorrect of " + escape(expected) + " - wanted " + aDat e + " but got " + otherDate + ", " + escape(str3));

855 } else {

856 logln("Parsed OK: " + expected);

857 }

858 // Two digit year parsing problem #4732

859 fmt->applyPattern("yy-MM-dd");

860 str.remove();

861 fmt->format(aDate, str);

862 expected.setTo("85-10-28");

863 if(str != expected) {

864 errln("Expected " + escape(expected) + " but got " + escape(str));

865 }

866 otherDate = fmt->parse(expected, status);

867 if (otherDate != aDate) {

868 errln("Parse incorrect of " + escape(expected) + " - wanted " + aDat e + " but got " + otherDate);

869 } else {

870 logln("Parsed OK: " + expected);

871 }

872 delete fmt;

873 }

874 delete fmt2;

875

876 CHECK(status, "Error occured testing Persian Calendar in English ");

877 }

878

879

880 void IntlCalendarTest::simpleTest(const Locale& loc, const UnicodeString& expect , UDate expectDate, UErrorCode& status)

881 {

882 UnicodeString tmp;

883 UDate d;

884 DateFormat *fmt0 = DateFormat::createDateTimeInstance(DateFormat::kFull, Dat eFormat::kFull);

885

886 logln("Try format/parse of " + (UnicodeString)loc.getName());

887 DateFormat *fmt2 = DateFormat::createDateInstance(DateFormat::kFull, loc);

888 if(fmt2) {

889 fmt2->format(expectDate, tmp);

890 logln(escape(tmp) + " ( in locale " + loc.getName() + ")");

891 if(tmp != expect) {

892 errln(UnicodeString("Failed to format " ) + loc.getName() + " expect ed " + escape(expect) + " got " + escape(tmp) );

893 }

894

895 d = fmt2->parse(expect,status);

896 CHECK(status, "Error occured parsing " + UnicodeString(loc.getName()));

897 if(d != expectDate) {

898 fmt2->format(d,tmp);

899 errln(UnicodeString("Failed to parse " ) + escape(expect) + ", " + l oc.getName() + " expect " + (double)expectDate + " got " + (double)d + " " + es cape(tmp));

900 logln( "wanted " + escape(fmt0->format(expectDate,tmp.remove())) + " but got " + escape(fmt0->format(d,tmp.remove())));

901 }

902 delete fmt2;

903 } else {

904 errln((UnicodeString)"Can't create " + loc.getName() + " date instance") ;

905 }

906 delete fmt0;

907 }

908

909 #undef CHECK

910

911 #endif /* #if !UCONFIG_NO_FORMATTING */

912

913 //eof

OLD	NEW

« no previous file with comments | « source/test/intltest/incaltst.h ('k') | source/test/intltest/intltest.h » ('j') | no next file with comments »