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

Side by Side Diff: source/test/intltest/dtfmtrtts.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.

Jump to:

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

2 * COPYRIGHT:

3 * Copyright (c) 1997-2015, International Business Machines Corporation

4 * and others. All Rights Reserved.

5 ***********************************************************************/

6

7 #include "unicode/utypes.h"

8

9 #if !UCONFIG_NO_FORMATTING

10

11 #include "unicode/datefmt.h"

12 #include "unicode/smpdtfmt.h"

13 #include "unicode/gregocal.h"

14 #include "dtfmtrtts.h"

15 #include "caltest.h"

16 #include "cstring.h"

17

18 #include <stdio.h>

19 #include <string.h>

20

21 // *****************************************************************************

22 // class DateFormatRoundTripTest

23 // *****************************************************************************

24

25 // Useful for turning up subtle bugs: Change the following to TRUE, recompile,

26 // and run while at lunch.

27 // Warning -- makes test run infinite loop!!!

28 #ifndef INFINITE

29 #define INFINITE 0

30 #endif

31

32 // Define this to test just a single locale

33 //#define TEST_ONE_LOC "cs_CZ"

34

35 // If SPARSENESS is > 0, we don't run each exhaustive possibility.

36 // There are 24 total possible tests per each locale. A SPARSENESS

37 // of 12 means we run half of them. A SPARSENESS of 23 means we run

38 // 1 of them. SPARSENESS _must_ be in the range 0..23.

39 int32_t DateFormatRoundTripTest::SPARSENESS = 0;

40 int32_t DateFormatRoundTripTest::TRIALS = 4;

41 int32_t DateFormatRoundTripTest::DEPTH = 5;

42

43 DateFormatRoundTripTest::DateFormatRoundTripTest() : dateFormat(0) {

44 }

45

46 DateFormatRoundTripTest::~DateFormatRoundTripTest() {

47 delete dateFormat;

48 }

49

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

51

52 void

53 DateFormatRoundTripTest::runIndexedTest( int32_t index, UBool exec, const char* &name, char* par )

54 {

55 optionv = (par && *par=='v');

56 switch (index) {

57 CASE(0,TestDateFormatRoundTrip)

58 CASE(1, TestCentury)

59 default: name = ""; break;

60 }

61 }

62

63 UBool

64 DateFormatRoundTripTest::failure(UErrorCode status, const char* msg)

65 {

66 if(U_FAILURE(status)) {

67 errln(UnicodeString("FAIL: ") + msg + " failed, error " + u_errorName(st atus));

68 return TRUE;

69 }

70

71 return FALSE;

72 }

73

74 UBool

75 DateFormatRoundTripTest::failure(UErrorCode status, const char* msg, const Unico deString& str)

76 {

77 if(U_FAILURE(status)) {

78 UnicodeString escaped;

79 escape(str,escaped);

80 errln(UnicodeString("FAIL: ") + msg + " failed, error " + u_errorName(st atus) + ", str=" + escaped);

81 return TRUE;

82 }

83

84 return FALSE;

85 }

86

87 void DateFormatRoundTripTest::TestCentury()

88 {

89 UErrorCode status = U_ZERO_ERROR;

90 Locale locale("es_PA");

91 UnicodeString pattern = "MM/dd/yy hh:mm:ss a z";

92 SimpleDateFormat fmt(pattern, locale, status);

93 if (U_FAILURE(status)) {

94 dataerrln("Fail: construct SimpleDateFormat: %s", u_errorName(status));

95 return;

96 }

97 UDate date[] = {-55018555891590.05, 0, 0};

98 UnicodeString result[2];

99

100 fmt.format(date[0], result[0]);

101 date[1] = fmt.parse(result[0], status);

102 fmt.format(date[1], result[1]);

103 date[2] = fmt.parse(result[1], status);

104

105 /* This test case worked OK by accident before. date[1] != date[0],

106 * because we use -80/+20 year window for 2-digit year parsing.

107 * (date[0] is in year 1926, date[1] is in year 2026.) result[1] set

108 * by the first format call returns "07/13/26 07:48:28 p.m. PST",

109 * which is correct, because DST was not used in year 1926 in zone

110 * America/Los_Angeles. When this is parsed, date[1] becomes a time

111 * in 2026, which is "07/13/26 08:48:28 p.m. PDT". There was a zone

112 * offset calculation bug that observed DST in 1926, which was resolved.

113 * Before the bug was resolved, result[0] == result[1] was true,

114 * but after the bug fix, the expected result is actually

115 * result[0] != result[1]. -Yoshito

116 */

117 /* TODO: We need to review this code and clarify what we really

118 * want to test here.

119 */

120 //if (date[1] != date[2] \|\| result[0] != result[1]) {

121 if (date[1] != date[2]) {

122 errln("Round trip failure: \"%S\" (%f), \"%S\" (%f)", result[0].getBuffe r(), date[1], result[1].getBuffer(), date[2]);

123 }

124 }

125

126 // ==

127

128 void DateFormatRoundTripTest::TestDateFormatRoundTrip()

129 {

130 UErrorCode status = U_ZERO_ERROR;

131

132 getFieldCal = Calendar::createInstance(status);

133 if (U_FAILURE(status)) {

134 dataerrln("Fail: Calendar::createInstance: %s", u_errorName(status));

135 return;

136 }

137

138

139 int32_t locCount = 0;

140 const Locale *avail = DateFormat::getAvailableLocales(locCount);

141 logln("DateFormat available locales: %d", locCount);

142 if(quick) {

143 SPARSENESS = 18;

144 logln("Quick mode: only testing SPARSENESS = 18");

145 }

146 TimeZone *tz = TimeZone::createDefault();

147 UnicodeString temp;

148 logln("Default TimeZone: " + tz->getID(temp));

149 delete tz;

150

151 #ifdef TEST_ONE_LOC // define this to just test ONE locale.

152 Locale loc(TEST_ONE_LOC);

153 test(loc);

154 #if INFINITE

155 for(;;) {

156 test(loc);

157 }

158 #endif

159

160 #else

161 # if INFINITE

162 // Special infinite loop test mode for finding hard to reproduce errors

163 Locale loc = Locale::getDefault();

164 logln("ENTERING INFINITE TEST LOOP FOR Locale: " + loc.getDisplayName(temp)) ;

165 for(;;)

166 test(loc);

167 # else

168 test(Locale::getDefault());

169

170 #if 1

171 // installed locales

172 for (int i=0; i < locCount; ++i) {

173 test(avail[i]);

174 }

175 #endif

176

177 #if 1

178 // special locales

179 int32_t jCount = CalendarTest::testLocaleCount();

180 for (int32_t j=0; j < jCount; ++j) {

181 test(Locale(CalendarTest::testLocaleID(j)));

182 }

183 #endif

184

185 # endif

186 #endif

187

188 delete getFieldCal;

189 }

190

191 static const char *styleName(DateFormat::EStyle s)

192 {

193 switch(s)

194 {

195 case DateFormat::SHORT: return "SHORT";

196 case DateFormat::MEDIUM: return "MEDIUM";

197 case DateFormat::LONG: return "LONG";

198 case DateFormat::FULL: return "FULL";

199 // case DateFormat::DEFAULT: return "DEFAULT";

200 case DateFormat::DATE_OFFSET: return "DATE_OFFSET";

201 case DateFormat::NONE: return "NONE";

202 case DateFormat::DATE_TIME: return "DATE_TIME";

203 default: return "Unknown";

204 }

205 }

206

207 void DateFormatRoundTripTest::test(const Locale& loc)

208 {

209 UnicodeString temp;

210 #if !INFINITE

211 logln("Locale: " + loc.getDisplayName(temp));

212 #endif

213

214 // Total possibilities = 24

215 // 4 date

216 // 4 time

217 // 16 date-time

218 UBool TEST_TABLE [24];//= new boolean[24];

219 int32_t i = 0;

220 for(i = 0; i < 24; ++i)

221 TEST_TABLE[i] = TRUE;

222

223 // If we have some sparseness, implement it here. Sparseness decreases

224 // test time by eliminating some tests, up to 23.

225 for(i = 0; i < SPARSENESS; ) {

226 int random = (int)(randFraction() * 24);

227 if (random >= 0 && random < 24 && TEST_TABLE[i]) {

228 TEST_TABLE[i] = FALSE;

229 ++i;

230 }

231 }

232

233 int32_t itable = 0;

234 int32_t style = 0;

235 for(style = DateFormat::FULL; style <= DateFormat::SHORT; ++style) {

236 if(TEST_TABLE[itable++]) {

237 logln("Testing style " + UnicodeString(styleName((DateFormat::EStyle )style)));

238 DateFormat *df = DateFormat::createDateInstance((DateFormat::EStyle) style, loc);

239 if(df == NULL) {

240 errln(UnicodeString("Could not DF::createDateInstance ") + Unicode String(styleName((DateFormat::EStyle)style)) + " Locale: " + loc.getDisplay Name(temp));

241 } else {

242 test(df, loc);

243 delete df;

244 }

245 }

246 }

247

248 for(style = DateFormat::FULL; style <= DateFormat::SHORT; ++style) {

249 if (TEST_TABLE[itable++]) {

250 logln("Testing style " + UnicodeString(styleName((DateFormat::EStyle)s tyle)));

251 DateFormat *df = DateFormat::createTimeInstance((DateFormat::EStyle) style, loc);

252 if(df == NULL) {

253 errln(UnicodeString("Could not DF::createTimeInstance ") + Unicode String(styleName((DateFormat::EStyle)style)) + " Locale: " + loc.getDisplayName( temp));

254 } else {

255 test(df, loc, TRUE);

256 delete df;

257 }

258 }

259 }

260

261 for(int32_t dstyle = DateFormat::FULL; dstyle <= DateFormat::SHORT; ++dstyle ) {

262 for(int32_t tstyle = DateFormat::FULL; tstyle <= DateFormat::SHORT; ++ts tyle) {

263 if(TEST_TABLE[itable++]) {

264 logln("Testing dstyle" + UnicodeString(styleName((DateFormat::ES tyle)dstyle)) + ", tstyle" + UnicodeString(styleName((DateFormat::EStyle)tstyle) ) );

265 DateFormat *df = DateFormat::createDateTimeInstance((DateFormat: :EStyle)dstyle, (DateFormat::EStyle)tstyle, loc);

266 if(df == NULL) {

267 dataerrln(UnicodeString("Could not DF::createDateTimeInstanc e ") + UnicodeString(styleName((DateFormat::EStyle)dstyle)) + ", tstyle" + Unico deString(styleName((DateFormat::EStyle)tstyle)) + "Locale: " + loc.getDisplay Name(temp));

268 } else {

269 test(df, loc);

270 delete df;

271 }

272 }

273 }

274 }

275 }

276

277 void DateFormatRoundTripTest::test(DateFormat *fmt, const Locale &origLocale, UB ool timeOnly)

278 {

279 UnicodeString pat;

280 if(fmt->getDynamicClassID() != SimpleDateFormat::getStaticClassID()) {

281 errln("DateFormat wasn't a SimpleDateFormat");

282 return;

283 }

284

285 UBool isGregorian = FALSE;

286 UErrorCode minStatus = U_ZERO_ERROR;

287 if(fmt->getCalendar() == NULL) {

288 errln((UnicodeString)"DateFormatRoundTripTest::test, DateFormat getCalenda r() returns null for " + origLocale.getName());

289 return;

290 }

291 UDate minDate = CalendarTest::minDateOfCalendar(*fmt->getCalendar(), isGrego rian, minStatus);

292 if(U_FAILURE(minStatus)) {

293 errln((UnicodeString)"Failure getting min date for " + origLocale.getName( ));

294 return;

295 }

296 //logln(UnicodeString("Min date is ") + fullFormat(minDate) + " for " + ori gLocale.getName());

297

298 pat = ((SimpleDateFormat*)fmt)->toPattern(pat);

299

300 // NOTE TO MAINTAINER

301 // This indexOf check into the pattern needs to be refined to ignore

302 // quoted characters. Currently, this isn't a problem with the locale

303 // patterns we have, but it may be a problem later.

304

305 UBool hasEra = (pat.indexOf(UnicodeString("G")) != -1);

306 UBool hasZoneDisplayName = (pat.indexOf(UnicodeString("z")) != -1) \|\| (pat.i ndexOf(UnicodeString("v")) != -1)

307 \|\| (pat.indexOf(UnicodeString("V")) != -1);

308

309 // Because patterns contain incomplete data representing the Date,

310 // we must be careful of how we do the roundtrip. We start with

311 // a randomly generated Date because they're easier to generate.

312 // From this we get a string. The string is our real starting point,

313 // because this string should parse the same way all the time. Note

314 // that it will not necessarily parse back to the original date because

315 // of incompleteness in patterns. For example, a time-only pattern won't

316 // parse back to the same date.

317

318 //try {

319 for(int i = 0; i < TRIALS; ++i) {

320 UDate *d = new UDate [DEPTH];

321 UnicodeString *s = new UnicodeString[DEPTH];

322

323 if(isGregorian == TRUE) {

324 d[0] = generateDate();

325 } else {

326 d[0] = generateDate(minDate);

327 }

328

329 UErrorCode status = U_ZERO_ERROR;

330

331 // We go through this loop until we achieve a match or until

332 // the maximum loop count is reached. We record the points at

333 // which the date and the string starts to match. Once matching

334 // starts, it should continue.

335 int loop;

336 int dmatch = 0; // d[dmatch].getTime() == d[dmatch-1].getTime()

337 int smatch = 0; // s[smatch].equals(s[smatch-1])

338 for(loop = 0; loop < DEPTH; ++loop) {

339 if (loop > 0) {

340 d[loop] = fmt->parse(s[loop-1], status);

341 failure(status, "fmt->parse", s[loop-1]+" in locale: " + ori gLocale.getName() + " with pattern: " + pat);

342 status = U_ZERO_ERROR; /* any error would have been reported */

343 }

344

345 s[loop] = fmt->format(d[loop], s[loop]);

346

347 // For displaying which date is being tested

348 //logln(s[loop] + " = " + fullFormat(d[loop]));

349

350 if(s[loop].length() == 0) {

351 errln("FAIL: fmt->format gave 0-length string in " + pat + " w ith number " + d[loop] + " in locale " + origLocale.getName());

352 }

353

354 if(loop > 0) {

355 if(smatch == 0) {

356 UBool match = s[loop] == s[loop-1];

357 if(smatch == 0) {

358 if(match)

359 smatch = loop;

360 }

361 else if( ! match)

362 errln("FAIL: String mismatch after match");

363 }

364

365 if(dmatch == 0) {

366 // {sfb} watch out here, this might not work

367 UBool match = d[loop]/.getTime()/ == d[loop-1]/.getTi me()/;

368 if(dmatch == 0) {

369 if(match)

370 dmatch = loop;

371 }

372 else if( ! match)

373 errln("FAIL: Date mismatch after match");

374 }

375

376 if(smatch != 0 && dmatch != 0)

377 break;

378 }

379 }

380 // At this point loop == DEPTH if we've failed, otherwise loop is th e

381 // max(smatch, dmatch), that is, the index at which we have string a nd

382 // date matching.

383

384 // Date usually matches in 2. Exceptions handled below.

385 int maxDmatch = 2;

386 int maxSmatch = 1;

387 if (dmatch > maxDmatch) {

388 // Time-only pattern with zone information and a starting date i n PST.

389 if(timeOnly && hasZoneDisplayName) {

390 int32_t startRaw, startDst;

391 fmt->getTimeZone().getOffset(d[0], FALSE, startRaw, startDst , status);

392 failure(status, "TimeZone::getOffset");

393 // if the start offset is greater than the offset on Jan 1, 1970

394 // in PST, then need one more round trip. There are two cas es

395 // fall into this category. The start date is 1) DST or

396 // 2) LMT (GMT-07:52:58).

397 if (startRaw + startDst > -28800000) {

398 maxDmatch = 3;

399 maxSmatch = 2;

400 }

401 }

402 }

403

404 // String usually matches in 1. Exceptions are checked for here.

405 if(smatch > maxSmatch) { // Don't compute unless necessary

406 UBool in0;

407 // Starts in BC, with no era in pattern

408 if( ! hasEra && getField(d[0], UCAL_ERA) == GregorianCalendar::B C)

409 maxSmatch = 2;

410 // Starts in DST, no year in pattern

411 else if((in0=fmt->getTimeZone().inDaylightTime(d[0], status)) && ! failure(status, "gettingDaylightTime") &&

412 pat.indexOf(UnicodeString("yyyy")) == -1)

413 maxSmatch = 2;

414 // If we start not in DST, but transition into DST

415 else if (!in0 &&

416 fmt->getTimeZone().inDaylightTime(d[1], status) && !fai lure(status, "gettingDaylightTime"))

417 maxSmatch = 2;

418 // Two digit year with no time zone change,

419 // unless timezone isn't used or we aren't close to the DST chan gover

420 else if (pat.indexOf(UnicodeString("y")) != -1

421 && pat.indexOf(UnicodeString("yyyy")) == -1

422 && getField(d[0], UCAL_YEAR)

423 != getField(d[dmatch], UCAL_YEAR)

424 && !failure(status, "error status [smatch>maxSmatch]")

425 && ((hasZoneDisplayName

426 && (fmt->getTimeZone().inDaylightTime(d[0], status)

427 == fmt->getTimeZone().inDaylightTime(d[dmatch], status)

428 \|\| getField(d[0], UCAL_MONTH) == UCAL_APRIL

429 \|\| getField(d[0], UCAL_MONTH) == UCAL_OCTOBER))

430 \|\| !hasZoneDisplayName)

431 )

432 {

433 maxSmatch = 2;

434 }

435 // If zone display name is used, fallback format might be used b efore 1970

436 else if (hasZoneDisplayName && d[0] < 0) {

437 maxSmatch = 2;

438 }

439 else if (timeOnly && !isGregorian && hasZoneDisplayName && maxSm atch == 1) {

440 int32_t startRaw, startDst;

441 fmt->getTimeZone().getOffset(d[1], FALSE, startRaw, startDst , status);

442 failure(status, "TimeZone::getOffset");

443 // If the calendar type is not Gregorian and the pattern is time only,

444 // the calendar implementation may use a date before 1970 as day 0.

445 // In this case, time zone offset of the default year might be

446 // different from the one at 1970-01-01 in PST and string ma tch requires

447 // one more iteration.

448 if (startRaw + startDst != -28800000) {

449 maxSmatch = 2;

450 }

451 }

452 }

453

454 /*

455 * Special case for Japanese and Buddhist (could have large negative years)

456 * Also, Hebrew calendar need help handling leap month.

457 */

458 if(dmatch > maxDmatch \|\| smatch > maxSmatch) {

459 const char *type = fmt->getCalendar()->getType();

460 if(!strcmp(type,"japanese") \|\| (!strcmp(type,"buddhist"))) {

461 maxSmatch = 4;

462 maxDmatch = 4;

463 } else if(!strcmp(type,"hebrew")) {

464 maxSmatch = 3;

465 maxDmatch = 3;

466 }

467 }

468

469 // Use @v to see verbose results on successful cases

470 UBool fail = (dmatch > maxDmatch \|\| smatch > maxSmatch);

471 if (optionv \|\| fail) {

472 if (fail) {

473 errln(UnicodeString("\nFAIL: Pattern: ") + pat +

474 " in Locale: " + origLocale.getName());

475 } else {

476 errln(UnicodeString("\nOk: Pattern: ") + pat +

477 " in Locale: " + origLocale.getName());

478 }

479

480 logln("Date iters until match=%d (max allowed=%d), string iters until match=%d (max allowed=%d)",

481 dmatch,maxDmatch, smatch, maxSmatch);

482

483 for(int j = 0; j <= loop && j < DEPTH; ++j) {

484 UnicodeString temp;

485 FieldPosition pos(FieldPosition::DONT_CARE);

486 errln((j>0?" P> ":" ") + fullFormat(d[j]) + " F> " +

487 escape(s[j], temp) + UnicodeString(" d=") + d[j] +

488 (j > 0 && d[j]/.getTime()/==d[j-1]/.getTime()/?" d ==":"") +

489 (j > 0 && s[j] == s[j-1]?" s==":""));

490 }

491 }

492 delete[] d;

493 delete[] s;

494 }

495 /*}

496 catch (ParseException e) {

497 errln("Exception: " + e.getMessage());

498 logln(e.toString());

499 }*/

500 }

501

502 const UnicodeString& DateFormatRoundTripTest::fullFormat(UDate d) {

503 UErrorCode ec = U_ZERO_ERROR;

504 if (dateFormat == 0) {

505 dateFormat = new SimpleDateFormat((UnicodeString)"EEE MMM dd HH:mm:ss.SS S zzz yyyy G", ec);

506 if (U_FAILURE(ec) \|\| dateFormat == 0) {

507 fgStr = "[FAIL: SimpleDateFormat constructor]";

508 delete dateFormat;

509 dateFormat = 0;

510 return fgStr;

511 }

512 }

513 fgStr.truncate(0);

514 dateFormat->format(d, fgStr);

515 return fgStr;

516 }

517

518 /**

519 * Return a field of the given date

520 */

521 int32_t DateFormatRoundTripTest::getField(UDate d, int32_t f) {

522 // Should be synchronized, but we're single threaded so it's ok

523 UErrorCode status = U_ZERO_ERROR;

524 getFieldCal->setTime(d, status);

525 failure(status, "getfieldCal->setTime");

526 int32_t ret = getFieldCal->get((UCalendarDateFields)f, status);

527 failure(status, "getfieldCal->get");

528 return ret;

529 }

530

531 UnicodeString& DateFormatRoundTripTest::escape(const UnicodeString& src, Unicode String& dst )

532 {

533 dst.remove();

534 for (int32_t i = 0; i < src.length(); ++i) {

535 UChar c = src[i];

536 if(c < 0x0080)

537 dst += c;

538 else {

539 dst += UnicodeString("[");

540 char buf [8];

541 sprintf(buf, "%#x", c);

542 dst += UnicodeString(buf);

543 dst += UnicodeString("]");

544 }

545 }

546

547 return dst;

548 }

549

550 #define U_MILLIS_PER_YEAR (365.25 * 24 * 60 * 60 * 1000)

551

552 UDate DateFormatRoundTripTest::generateDate(UDate minDate)

553 {

554 // Bring range in conformance to generateDate() below.

555 if(minDate < (U_MILLIS_PER_YEAR * -(4000-1970))) {

556 minDate = (U_MILLIS_PER_YEAR * -(4000-1970));

557 }

558 for(int i=0;i<8;i++) {

559 double a = randFraction();

560

561 // Range from (min) to (8000-1970) AD

562 double dateRange = (0.0 - minDate) + (U_MILLIS_PER_YEAR + (8000-1970));

563

564 a *= dateRange;

565

566 // Now offset from minDate

567 a += minDate;

568

569 // Last sanity check

570 if(a>=minDate) {

571 return a;

572 }

573 }

574 return minDate;

575 }

576

577 UDate DateFormatRoundTripTest::generateDate()

578 {

579 double a = randFraction();

580

581 // Now 'a' ranges from 0..1; scale it to range from 0 to 8000 years

582 a *= 8000;

583

584 // Range from (4000-1970) BC to (8000-1970) AD

585 a -= 4000;

586

587 // Now scale up to ms

588 a = 365.25 24 * 60 * 60 * 1000;

589

590 //return new Date((long)a);

591 return a;

592 }

593

594 #endif /* #if !UCONFIG_NO_FORMATTING */

595

596 //eof

OLD	NEW

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