]> git.saurik.com Git - apple/icu.git/blob - icuSources/test/intltest/dtfmrgts.cpp
projects / apple / icu.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
ICU-62108.0.1.tar.gz
[apple/icu.git] / icuSources / test / intltest / dtfmrgts.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-2016, International Business Machines Corporation and
6 * others. All Rights Reserved.
7 ********************************************************************/
8
9 #include "unicode/utypes.h"
10
11 #if !UCONFIG_NO_FORMATTING
12 #include "dtfmrgts.h"
13
14 #include "unicode/timezone.h"
15 #include "unicode/gregocal.h"
16 #include "unicode/smpdtfmt.h"
17 #include "unicode/datefmt.h"
18 #include "unicode/simpletz.h"
19 #include "unicode/resbund.h"
20 #include "cmemory.h"
21
22 // *****************************************************************************
23 // class DateFormatRegressionTest
24 // *****************************************************************************
25
26 #define CASE(id,test) case id: name = #test; if (exec) { logln(#test "---"); logln((UnicodeString)""); test(); } break;
27
28 void
29 DateFormatRegressionTest::runIndexedTest( int32_t index, UBool exec, const char* &name, char* /*par*/ )
30 {
31 // if (exec) logln((UnicodeString)"TestSuite DateFormatRegressionTest");
32 switch (index) {
33 CASE(0,Test4029195)
34 CASE(1,Test4052408)
35 CASE(2,Test4056591)
36 CASE(3,Test4059917)
37 CASE(4,Test4060212)
38 CASE(5,Test4061287)
39 CASE(6,Test4065240)
40 CASE(7,Test4071441)
41 CASE(8,Test4073003)
42 CASE(9,Test4089106)
43 CASE(10,Test4100302)
44 CASE(11,Test4101483)
45 CASE(12,Test4103340)
46 CASE(13,Test4103341)
47 CASE(14,Test4104136)
48 CASE(15,Test4104522)
49 CASE(16,Test4106807)
50 CASE(17,Test4108407)
51 CASE(18,Test4134203)
52 CASE(19,Test4151631)
53 CASE(20,Test4151706)
54 CASE(21,Test4162071)
55 CASE(22,Test4182066)
56 CASE(23,Test4210209)
57 CASE(24,Test714)
58 CASE(25,Test1684)
59 CASE(26,Test5554)
60 CASE(27,Test9237)
61 CASE(28,TestParsing)
62 CASE(29,TestT10334)
63 CASE(30,TestT10619)
64 CASE(31,TestT10855)
65 CASE(32,TestT10906)
66 CASE(33,TestT13380)
67 default: name = ""; break;
68 }
69 }
70
71 /**
72 * @bug 4029195
73 */
74 void DateFormatRegressionTest::Test4029195(void)
75 {
76 UErrorCode status = U_ZERO_ERROR;
77
78 UDate today = Calendar::getNow();
79 logln((UnicodeString) "today: " + today);
80
81 SimpleDateFormat *sdf = (SimpleDateFormat*) DateFormat::createDateInstance();
82 if (failure(status, "SimpleDateFormat::createDateInstance")) {
83 return;
84 }
85 UnicodeString pat;
86 if(sdf == NULL){
87 dataerrln("Error calling DateFormat::createDateTimeInstance");
88 return;
89 }
90
91 pat = sdf->toPattern(pat);
92 logln("pattern: " + pat);
93 UnicodeString fmtd;
94
95 FieldPosition pos(FieldPosition::DONT_CARE);
96 fmtd = sdf->format(today, fmtd, pos);
97 logln("today: " + fmtd);
98
99 sdf->applyPattern("G yyyy DDD");
100 UnicodeString todayS;
101 todayS = sdf->format(today, todayS, pos);
102 logln("today: " + todayS);
103 //try {
104 today = sdf->parse(todayS, status);
105 failure(status, "sdf->parse");
106 logln((UnicodeString)"today date: " + today);
107 /*} catch(Exception e) {
108 logln("Error reparsing date: " + e.getMessage());
109 }*/
110
111 //try {
112 UnicodeString rt;
113 rt = sdf->format(sdf->parse(todayS, status), rt, pos);
114 failure(status, "sdf->parse");
115 logln("round trip: " + rt);
116 if(rt != todayS)
117 errln("Fail: Want " + todayS + " Got " + rt);
118 /*}
119 catch (ParseException e) {
120 errln("Fail: " + e);
121 e.printStackTrace();
122 }*/
123
124 delete sdf;
125 }
126
127 /**
128 * @bug 4052408
129 */
130 void DateFormatRegressionTest::Test4052408(void)
131 {
132
133 DateFormat *fmt = DateFormat::createDateTimeInstance(DateFormat::SHORT,
134 DateFormat::SHORT, Locale::getUS());
135 if (fmt == NULL) {
136 dataerrln("Error calling DateFormat::createDateTimeInstance");
137 return;
138 }
139
140 UDate dt = date(97, UCAL_MAY, 3, 8, 55);
141 UnicodeString str;
142 str = fmt->format(dt, str);
143 logln(str);
144
145 if(str != "5/3/97, 8:55 AM")
146 errln("Fail: Test broken; Want 5/3/97, 8:55 AM Got " + str);
147
148 UnicodeString expected[] = {
149 (UnicodeString) "", //"ERA_FIELD",
150 (UnicodeString) "97", //"YEAR_FIELD",
151 (UnicodeString) "5", //"MONTH_FIELD",
152 (UnicodeString) "3", //"DATE_FIELD",
153 (UnicodeString) "", //"HOUR_OF_DAY1_FIELD",
154 (UnicodeString) "", //"HOUR_OF_DAY0_FIELD",
155 (UnicodeString) "55", //"MINUTE_FIELD",
156 (UnicodeString) "", //"SECOND_FIELD",
157 (UnicodeString) "", //"MILLISECOND_FIELD",
158 (UnicodeString) "", //"DAY_OF_WEEK_FIELD",
159 (UnicodeString) "", //"DAY_OF_YEAR_FIELD",
160 (UnicodeString) "", //"DAY_OF_WEEK_IN_MONTH_FIELD",
161 (UnicodeString) "", //"WEEK_OF_YEAR_FIELD",
162 (UnicodeString) "", //"WEEK_OF_MONTH_FIELD",
163 (UnicodeString) "AM", //"AM_PM_FIELD",
164 (UnicodeString) "8", //"HOUR1_FIELD",
165 (UnicodeString) "", //"HOUR0_FIELD",
166 (UnicodeString) "" //"TIMEZONE_FIELD"
167 };
168
169 //Hashtable expected;// = new Hashtable();
170 //expected.put(new LongKey(DateFormat.MONTH_FIELD), "5");
171 //expected.put(new LongKey(DateFormat.DATE_FIELD), "3");
172 //expected.put(new LongKey(DateFormat.YEAR_FIELD), "97");
173 //expected.put(new LongKey(DateFormat.HOUR1_FIELD), "8");
174 //expected.put(new LongKey(DateFormat.MINUTE_FIELD), "55");
175 //expected.put(new LongKey(DateFormat.AM_PM_FIELD), "AM");
176
177 //StringBuffer buf = new StringBuffer();
178 UnicodeString fieldNames[] = {
179 (UnicodeString) "ERA_FIELD",
180 (UnicodeString) "YEAR_FIELD",
181 (UnicodeString) "MONTH_FIELD",
182 (UnicodeString) "DATE_FIELD",
183 (UnicodeString) "HOUR_OF_DAY1_FIELD",
184 (UnicodeString) "HOUR_OF_DAY0_FIELD",
185 (UnicodeString) "MINUTE_FIELD",
186 (UnicodeString) "SECOND_FIELD",
187 (UnicodeString) "MILLISECOND_FIELD",
188 (UnicodeString) "DAY_OF_WEEK_FIELD",
189 (UnicodeString) "DAY_OF_YEAR_FIELD",
190 (UnicodeString) "DAY_OF_WEEK_IN_MONTH_FIELD",
191 (UnicodeString) "WEEK_OF_YEAR_FIELD",
192 (UnicodeString) "WEEK_OF_MONTH_FIELD",
193 (UnicodeString) "AM_PM_FIELD",
194 (UnicodeString) "HOUR1_FIELD",
195 (UnicodeString) "HOUR0_FIELD",
196 (UnicodeString) "TIMEZONE_FIELD"
197 };
198
199 UBool pass = TRUE;
200 for(int i = 0; i <= 17; ++i) {
201 FieldPosition pos(i);
202 UnicodeString buf;
203 fmt->format(dt, buf, pos);
204 //char[] dst = new char[pos.getEndIndex() - pos.getBeginIndex()];
205 UnicodeString dst;
206 buf.extractBetween(pos.getBeginIndex(), pos.getEndIndex(), dst);
207 UnicodeString str(dst);
208 logln((UnicodeString)"" + i + (UnicodeString)": " + fieldNames[i] +
209 (UnicodeString)", \"" + str + (UnicodeString)"\", " +
210 pos.getBeginIndex() + (UnicodeString)", " +
211 pos.getEndIndex());
212 UnicodeString exp = expected[i];
213 if((exp.length() == 0 && str.length() == 0) || str == exp)
214 logln(" ok");
215 else {
216 errln(UnicodeString(" expected ") + exp);
217 pass = FALSE;
218 }
219
220 }
221 if( ! pass)
222 errln("Fail: FieldPosition not set right by DateFormat");
223
224 delete fmt;
225 }
226
227 /**
228 * @bug 4056591
229 * Verify the function of the [s|g]et2DigitYearStart() API.
230 */
231 void DateFormatRegressionTest::Test4056591(void)
232 {
233 UErrorCode status = U_ZERO_ERROR;
234
235 //try {
236 SimpleDateFormat *fmt = new SimpleDateFormat(UnicodeString("yyMMdd"), Locale::getUS(), status);
237 if (failure(status, "new SimpleDateFormat", TRUE)) {
238 delete fmt;
239 return;
240 }
241 UDate start = date(1809-1900, UCAL_DECEMBER, 25);
242 fmt->set2DigitYearStart(start, status);
243 failure(status, "fmt->setTwoDigitStartDate");
244 if( (fmt->get2DigitYearStart(status) != start) || failure(status, "get2DigitStartDate"))
245 errln("get2DigitYearStart broken");
246 UDate dates [] = {
247 date(1809-1900, UCAL_DECEMBER, 25),
248 date(1909-1900, UCAL_DECEMBER, 24),
249 date(1809-1900, UCAL_DECEMBER, 26),
250 date(1861-1900, UCAL_DECEMBER, 25),
251 };
252
253 UnicodeString strings [] = {
254 (UnicodeString) "091225",
255 (UnicodeString) "091224",
256 (UnicodeString) "091226",
257 (UnicodeString) "611225"
258 };
259
260 /*Object[] DATA = {
261 "091225", new Date(1809-1900, Calendar.DECEMBER, 25),
262 "091224", new Date(1909-1900, Calendar.DECEMBER, 24),
263 "091226", new Date(1809-1900, Calendar.DECEMBER, 26),
264 "611225", new Date(1861-1900, Calendar.DECEMBER, 25),
265 };*/
266
267 for(int i = 0; i < 4; i++) {
268 UnicodeString s = strings[i];
269 UDate exp = dates[i];
270 UDate got = fmt->parse(s, status);
271 failure(status, "fmt->parse");
272 logln(s + " -> " + got + "; exp " + exp);
273 if(got != exp)
274 errln("set2DigitYearStart broken");
275 }
276 /*}
277 catch (ParseException e) {
278 errln("Fail: " + e);
279 e.printStackTrace();
280 }*/
281
282 delete fmt;
283 }
284
285 /**
286 * @bug 4059917
287 */
288 void DateFormatRegressionTest::Test4059917(void)
289 {
290 UErrorCode status = U_ZERO_ERROR;
291
292 SimpleDateFormat *fmt;
293 UnicodeString myDate;
294
295 fmt = new SimpleDateFormat( UnicodeString("yyyy/MM/dd"), status );
296 if (failure(status, "new SimpleDateFormat", TRUE)) return;
297 myDate = "1997/01/01";
298 aux917( fmt, myDate );
299
300 delete fmt;
301 fmt = NULL;
302
303 fmt = new SimpleDateFormat( UnicodeString("yyyyMMdd"), status );
304 if(failure(status, "new SimpleDateFormat")) return;
305 myDate = "19970101";
306 aux917( fmt, myDate );
307
308 delete fmt;
309 }
310
311 void DateFormatRegressionTest::aux917( SimpleDateFormat *fmt, UnicodeString& str ) {
312 //try {
313 UnicodeString pat;
314 pat = fmt->toPattern(pat);
315 logln( "==================" );
316 logln( "testIt: pattern=" + pat +
317 " string=" + str );
318
319
320 Formattable o;
321 //Object o;
322 ParsePosition pos(0);
323 fmt->parseObject( str, o, pos );
324 //logln( UnicodeString("Parsed object: ") + o );
325
326 UErrorCode status = U_ZERO_ERROR;
327 UnicodeString formatted;
328 FieldPosition poss(FieldPosition::DONT_CARE);
329 formatted = fmt->format( o, formatted, poss, status );
330 failure(status, "fmt->format");
331 logln( "Formatted string: " + formatted );
332 if( formatted != str)
333 errln("Fail: Want " + str + " Got " + formatted);
334 /*}
335 catch (ParseException e) {
336 errln("Fail: " + e);
337 e.printStackTrace();
338 }*/
339 }
340
341 /**
342 * @bug 4060212
343 */
344 void DateFormatRegressionTest::Test4060212(void)
345 {
346 UnicodeString dateString = "1995-040.05:01:29";
347
348 logln( "dateString= " + dateString );
349 logln("Using yyyy-DDD.hh:mm:ss");
350 UErrorCode status = U_ZERO_ERROR;
351 SimpleDateFormat *formatter = new SimpleDateFormat(UnicodeString("yyyy-DDD.hh:mm:ss"), status);
352 if (failure(status, "new SimpleDateFormat", TRUE)) return;
353 ParsePosition pos(0);
354 UDate myDate = formatter->parse( dateString, pos );
355 UnicodeString myString;
356 DateFormat *fmt = DateFormat::createDateTimeInstance( DateFormat::FULL,
357 DateFormat::LONG);
358 if (fmt == NULL) {
359 dataerrln("Error calling DateFormat::createDateTimeInstance");
360 delete formatter;
361 return;
362 }
363
364 myString = fmt->format( myDate, myString);
365 logln( myString );
366
367 Calendar *cal = new GregorianCalendar(status);
368 failure(status, "new GregorianCalendar");
369 cal->setTime(myDate, status);
370 failure(status, "cal->setTime");
371 if ((cal->get(UCAL_DAY_OF_YEAR, status) != 40) || failure(status, "cal->get"))
372 errln((UnicodeString) "Fail: Got " + cal->get(UCAL_DAY_OF_YEAR, status) +
373 " Want 40");
374
375 // this is an odd usage of "ddd" and it doesn't
376 // work now that date values are range checked per #3579.
377 logln("Using yyyy-ddd.hh:mm:ss");
378 delete formatter;
379 formatter = NULL;
380 formatter = new SimpleDateFormat(UnicodeString("yyyy-ddd.hh:mm:ss"), status);
381 if(failure(status, "new SimpleDateFormat")) return;
382 pos.setIndex(0);
383 myDate = formatter->parse( dateString, pos );
384 myString = fmt->format( myDate, myString );
385 logln( myString );
386 cal->setTime(myDate, status);
387 failure(status, "cal->setTime");
388 if ((cal->get(UCAL_DAY_OF_YEAR, status) != 40) || failure(status, "cal->get"))
389 errln((UnicodeString) "Fail: Got " + cal->get(UCAL_DAY_OF_YEAR, status) +
390 " Want 40");
391
392 delete formatter;
393 delete fmt;
394 delete cal;
395 }
396
397 /**
398 * @bug 4061287
399 */
400 void DateFormatRegressionTest::Test4061287(void)
401 {
402 UErrorCode status = U_ZERO_ERROR;
403
404 SimpleDateFormat *df = new SimpleDateFormat(UnicodeString("dd/MM/yyyy"), status);
405 if (U_FAILURE(status)) {
406 dataerrln("Fail new SimpleDateFormat: %s", u_errorName(status));
407 delete df;
408 return;
409 }
410 failure(status, "new SimpleDateFormat");
411 //try {
412 logln(UnicodeString("") + df->parse("35/01/1971", status));
413 failure(status, "df->parse(\"35/01/1971\")");
414 //logln(df.parse("35/01/1971").toString());
415 //}
416 /*catch (ParseException e) {
417 errln("Fail: " + e);
418 e.printStackTrace();
419 }*/
420 df->setLenient(FALSE);
421 UBool ok = FALSE;
422 //try {
423 logln(UnicodeString("") + df->parse("35/01/1971", status));
424 if(U_FAILURE(status))
425 ok = TRUE;
426 //logln(df.parse("35/01/1971").toString());
427 //} catch (ParseException e) {ok=TRUE;}
428 if(!ok)
429 errln("Fail: Lenient not working");
430 delete df;
431 }
432
433 /**
434 * @bug 4065240
435 */
436 void DateFormatRegressionTest::Test4065240(void)
437 {
438 UDate curDate;
439 DateFormat *shortdate, *fulldate;
440 UnicodeString strShortDate, strFullDate;
441 Locale saveLocale = Locale::getDefault();
442 TimeZone *saveZone = TimeZone::createDefault();
443
444 UErrorCode status = U_ZERO_ERROR;
445 //try {
446 Locale *curLocale = new Locale("de","DE");
447 Locale::setDefault(*curLocale, status);
448 failure(status, "Locale::setDefault");
449 // {sfb} adoptDefault instead of setDefault
450 //TimeZone::setDefault(TimeZone::createTimeZone("EST"));
451 TimeZone::adoptDefault(TimeZone::createTimeZone("EST"));
452 curDate = date(98, 0, 1);
453 shortdate = DateFormat::createDateInstance(DateFormat::SHORT);
454 if (shortdate == NULL){
455 dataerrln("Error calling DateFormat::createDateInstance");
456 return;
457 }
458
459 fulldate = DateFormat::createDateTimeInstance(DateFormat::LONG, DateFormat::LONG);
460 if (fulldate == NULL){
461 dataerrln("Error calling DateFormat::createDateTimeInstance");
462 return;
463 }
464 strShortDate = "The current date (short form) is ";
465 UnicodeString temp;
466 temp = shortdate->format(curDate, temp);
467 strShortDate += temp;
468 strFullDate = "The current date (long form) is ";
469 UnicodeString temp2;
470 fulldate->format(curDate, temp2);
471 strFullDate += temp2;
472
473 logln(strShortDate);
474 logln(strFullDate);
475
476 // {sfb} What to do with resource bundle stuff?????
477
478 // Check to see if the resource is present; if not, we can't test
479 ResourceBundle *bundle = new ResourceBundle(
480 NULL, *curLocale, status);
481 failure(status, "new ResourceBundle");
482 //(UnicodeString) "java.text.resources.DateFormatZoneData", curLocale);
483
484 // {sfb} API change to ResourceBundle -- add getLocale()
485 /*if (bundle->getLocale().getLanguage(temp) == UnicodeString("de")) {
486 // UPDATE THIS AS ZONE NAME RESOURCE FOR <EST> in de_DE is updated
487 if (!strFullDate.endsWith(UnicodeString("GMT-05:00")))
488 errln("Fail: Want GMT-05:00");
489 }
490 else {
491 logln("*** TEST COULD NOT BE COMPLETED BECAUSE DateFormatZoneData ***");
492 logln("*** FOR LOCALE de OR de_DE IS MISSING ***");
493 }*/
494 //}
495 //finally {
496 Locale::setDefault(saveLocale, status);
497 failure(status, "Locale::setDefault");
498 TimeZone::setDefault(*saveZone);
499 //}
500 delete shortdate;
501 delete fulldate;
502 delete saveZone;
503 delete curLocale;
504 delete bundle;
505 }
506
507 /*
508 DateFormat.equals is too narrowly defined. As a result, MessageFormat
509 does not work correctly. DateFormat.equals needs to be written so
510 that the Calendar sub-object is not compared using Calendar.equals,
511 but rather compared for equivalency. This may necessitate adding a
512 (package private) method to Calendar to test for equivalency.
513
514 Currently this bug breaks MessageFormat.toPattern
515 */
516 /**
517 * @bug 4071441
518 */
519 void DateFormatRegressionTest::Test4071441(void)
520 {
521 DateFormat *fmtA = DateFormat::createInstance();
522 DateFormat *fmtB = DateFormat::createInstance();
523
524 if (fmtA == NULL || fmtB == NULL){
525 dataerrln("Error calling DateFormat::createInstance");
526 delete fmtA;
527 delete fmtB;
528 return;
529 }
530
531 // {sfb} Is it OK to cast away const here?
532 Calendar *calA = (Calendar*) fmtA->getCalendar();
533 Calendar *calB = (Calendar*) fmtB->getCalendar();
534 if(!calA || !calB) {
535 errln("Couldn't get proper calendars, exiting");
536 delete fmtA;
537 delete fmtB;
538 return;
539 }
540 UDate epoch = date(0, 0, 0);
541 UDate xmas = date(61, UCAL_DECEMBER, 25);
542
543 UErrorCode status = U_ZERO_ERROR;
544 calA->setTime(epoch, status);
545 failure(status, "calA->setTime");
546 calB->setTime(epoch, status);
547 failure(status, "calB->setTime");
548 if (*calA != *calB)
549 errln("Fail: Can't complete test; Calendar instances unequal");
550 if (*fmtA != *fmtB)
551 errln("Fail: DateFormat unequal when Calendars equal");
552 calB->setTime(xmas, status);
553 failure(status, "calB->setTime");
554 if (*calA == *calB)
555 errln("Fail: Can't complete test; Calendar instances equal");
556 if (*fmtA != *fmtB)
557 errln("Fail: DateFormat unequal when Calendars equivalent");
558
559 logln("DateFormat.equals ok");
560
561 delete fmtA;
562 delete fmtB;
563 }
564
565 /* The java.text.DateFormat.parse(String) method expects for the
566 US locale a string formatted according to mm/dd/yy and parses it
567 correctly.
568
569 When given a string mm/dd/yyyy [sic] it only parses up to the first
570 two y's, typically resulting in a date in the year 1919.
571
572 Please extend the parsing method(s) to handle strings with
573 four-digit year values (probably also applicable to various
574 other locales. */
575 /**
576 * @bug 4073003
577 */
578 void DateFormatRegressionTest::Test4073003(void)
579 {
580 //try {
581 UErrorCode ec = U_ZERO_ERROR;
582 SimpleDateFormat fmt("MM/dd/yy", Locale::getUK(), ec);
583 if (U_FAILURE(ec)) {
584 dataerrln("FAIL: SimpleDateFormat constructor - %s", u_errorName(ec));
585 return;
586 }
587 UnicodeString tests [] = {
588 (UnicodeString) "12/25/61",
589 (UnicodeString) "12/25/1961",
590 (UnicodeString) "4/3/2010",
591 (UnicodeString) "4/3/10"
592 };
593 UErrorCode status = U_ZERO_ERROR;
594 for(int i= 0; i < 4; i+=2) {
595 UDate d = fmt.parse(tests[i], status);
596 failure(status, "fmt.parse");
597 UDate dd = fmt.parse(tests[i+1], status);
598 failure(status, "fmt.parse");
599 UnicodeString s;
600 s = fmt.format(d, s);
601 UnicodeString ss;
602 ss = fmt.format(dd, ss);
603 if (d != dd)
604 errln((UnicodeString) "Fail: " + d + " != " + dd);
605 if (s != ss)
606 errln((UnicodeString)"Fail: " + s + " != " + ss);
607 logln("Ok: " + s + " " + d);
608 }
609 }
610
611 /**
612 * @bug 4089106
613 */
614 void DateFormatRegressionTest::Test4089106(void)
615 {
616 TimeZone *def = TimeZone::createDefault();
617 //try {
618 TimeZone *z = new SimpleTimeZone((int)(1.25 * 3600000), "FAKEZONE");
619 TimeZone::setDefault(*z);
620 UErrorCode status = U_ZERO_ERROR;
621 SimpleDateFormat *f = new SimpleDateFormat(status);
622 if(U_FAILURE(status)) {
623 dataerrln("Couldn't create SimpleDateFormat, error %s", u_errorName(status));
624 delete f;
625 delete def;
626 delete z;
627 return;
628 }
629 failure(status, "new SimpleDateFormat");
630 if (f->getTimeZone()!= *z)
631 errln("Fail: SimpleTimeZone should use TimeZone.getDefault()");
632
633 //}
634 //finally {
635 TimeZone::setDefault(*def);
636 //}
637
638 delete z;
639 delete f;
640 delete def;
641 }
642
643 /**
644 * @bug 4100302
645 */
646
647 // {sfb} not applicable in C++??
648
649 void DateFormatRegressionTest::Test4100302(void)
650 {
651 /* Locale locales [] = {
652 Locale::CANADA,
653 Locale::CANADA_FRENCH,
654 Locale::CHINA,
655 Locale::CHINESE,
656 Locale::ENGLISH,
657 Locale::FRANCE,
658 Locale::FRENCH,
659 Locale::GERMAN,
660 Locale::GERMANY,
661 Locale::ITALIAN,
662 Locale::ITALY,
663 Locale::JAPAN,
664 Locale::JAPANESE,
665 Locale::KOREA,
666 Locale::KOREAN,
667 Locale::PRC,
668 Locale::SIMPLIFIED_CHINESE,
669 Locale::TAIWAN,
670 Locale::TRADITIONAL_CHINESE,
671 Locale::UK,
672 Locale::US
673 };
674 //try {
675 UBool pass = TRUE;
676 for(int i = 0; i < 21; i++) {
677
678 Format *format = DateFormat::createDateTimeInstance(DateFormat::FULL,
679 DateFormat::FULL, locales[i]);
680 byte[] bytes;
681
682 ByteArrayOutputStream baos = new ByteArrayOutputStream();
683 ObjectOutputStream oos = new ObjectOutputStream(baos);
684
685 oos.writeObject(format);
686 oos.flush();
687
688 baos.close();
689 bytes = baos.toByteArray();
690
691 ObjectInputStream ois =
692 new ObjectInputStream(new ByteArrayInputStream(bytes));
693
694 if (!format.equals(ois.readObject())) {
695 pass = FALSE;
696 logln("DateFormat instance for locale " +
697 locales[i] + " is incorrectly serialized/deserialized.");
698 } else {
699 logln("DateFormat instance for locale " +
700 locales[i] + " is OKAY.");
701 }
702 }
703 if (!pass) errln("Fail: DateFormat serialization/equality bug");
704 }
705 catch (IOException e) {
706 errln("Fail: " + e);
707 e.printStackTrace();
708 }
709 catch (ClassNotFoundException e) {
710 errln("Fail: " + e);
711 e.printStackTrace();
712 }
713 */}
714
715 /**
716 * @bug 4101483
717 */
718 void DateFormatRegressionTest::Test4101483(void)
719 {
720 UErrorCode status = U_ZERO_ERROR;
721 SimpleDateFormat *sdf = new SimpleDateFormat(UnicodeString("z"), Locale::getUS(), status);
722 if (failure(status, "new SimpleDateFormat", TRUE)) return;
723 FieldPosition fp(UDAT_TIMEZONE_FIELD);
724 //Date d = date(9234567890L);
725 UDate d = 9234567890.0;
726 //StringBuffer buf = new StringBuffer("");
727 UnicodeString buf;
728 sdf->format(d, buf, fp);
729 //logln(sdf.format(d, buf, fp).toString());
730 logln(dateToString(d) + " => " + buf);
731 logln(UnicodeString("beginIndex = ") + fp.getBeginIndex());
732 logln(UnicodeString("endIndex = ") + fp.getEndIndex());
733 if (fp.getBeginIndex() == fp.getEndIndex())
734 errln("Fail: Empty field");
735
736 delete sdf;
737 }
738
739 /**
740 * @bug 4103340
741 * @bug 4138203
742 * This bug really only works in Locale.US, since that's what the locale
743 * used for Date.toString() is. Bug 4138203 reports that it fails on Korean
744 * NT; it would actually have failed on any non-US locale. Now it should
745 * work on all locales.
746 */
747 void DateFormatRegressionTest::Test4103340(void)
748 {
749 UErrorCode status = U_ZERO_ERROR;
750
751 // choose a date that is the FIRST of some month
752 // and some arbitrary time
753 UDate d = date(97, 3, 1, 1, 1, 1);
754 SimpleDateFormat *df = new SimpleDateFormat(UnicodeString("MMMM"), Locale::getUS(), status);
755 if (failure(status, "new SimpleDateFormat", TRUE)) return;
756
757 UnicodeString s;
758 s = dateToString(d, s);
759 UnicodeString s2;
760 FieldPosition pos(FieldPosition::DONT_CARE);
761 s2 = df->format(d, s2, pos);
762 logln("Date=" + s);
763 logln("DF=" + s2);
764 UnicodeString substr;
765 s2.extract(0,2, substr);
766 if (s.indexOf(substr) == -1)
767 errln("Months should match");
768
769 delete df;
770 }
771
772 /**
773 * @bug 4103341
774 */
775 void DateFormatRegressionTest::Test4103341(void)
776 {
777 TimeZone *saveZone =TimeZone::createDefault();
778 //try {
779
780 // {sfb} changed from setDefault to adoptDefault
781 TimeZone::adoptDefault(TimeZone::createTimeZone("CST"));
782 UErrorCode status = U_ZERO_ERROR;
783 SimpleDateFormat *simple = new SimpleDateFormat(UnicodeString("MM/dd/yyyy HH:mm"), status);
784 if(U_FAILURE(status)) {
785 dataerrln("Couldn't create SimpleDateFormat, error %s", u_errorName(status));
786 delete simple;
787 return;
788 }
789 failure(status, "new SimpleDateFormat");
790 TimeZone *temp = TimeZone::createDefault();
791 if(simple->getTimeZone() != *temp)
792 errln("Fail: SimpleDateFormat not using default zone");
793 //}
794 //finally {
795 TimeZone::adoptDefault(saveZone);
796 //}
797
798 delete temp;
799 delete simple;
800 }
801
802 /**
803 * @bug 4104136
804 */
805 void DateFormatRegressionTest::Test4104136(void)
806 {
807 UErrorCode status = U_ZERO_ERROR;
808 SimpleDateFormat *sdf = new SimpleDateFormat(status);
809 if(U_FAILURE(status)) {
810 dataerrln("Couldn't create SimpleDateFormat, error %s", u_errorName(status));
811 delete sdf;
812 return;
813 }
814 if(failure(status, "new SimpleDateFormat")) return;
815 UnicodeString pattern = "'time' hh:mm";
816 sdf->applyPattern(pattern);
817 logln("pattern: \"" + pattern + "\"");
818
819 UnicodeString strings [] = {
820 (UnicodeString)"time 10:30",
821 (UnicodeString) "time 10:x",
822 (UnicodeString) "time 10x"
823 };
824
825 ParsePosition ppos [] = {
826 ParsePosition(10),
827 ParsePosition(0),
828 ParsePosition(0)
829 };
830
831 UDate dates [] = {
832 date(70, UCAL_JANUARY, 1, 10, 30),
833 -1,
834 -1
835 };
836
837 /*Object[] DATA = {
838 "time 10:30", new ParsePosition(10), new Date(70, Calendar.JANUARY, 1, 10, 30),
839 "time 10:x", new ParsePosition(0), null,
840 "time 10x", new ParsePosition(0), null,
841 };*/
842
843 for(int i = 0; i < 3; i++) {
844 UnicodeString text = strings[i];
845 ParsePosition finish = ppos[i];
846 UDate exp = dates[i];
847
848 ParsePosition pos(0);
849 UDate d = sdf->parse(text, pos);
850 logln(" text: \"" + text + "\"");
851 logln(" index: %d", pos.getIndex());
852 logln((UnicodeString) " result: " + d);
853 if(pos.getIndex() != finish.getIndex())
854 errln(UnicodeString("Fail: Expected pos ") + finish.getIndex());
855 if (! ((d == 0 && exp == -1) || (d == exp)))
856 errln((UnicodeString) "Fail: Expected result " + exp);
857 }
858
859 delete sdf;
860 }
861
862 /**
863 * @bug 4104522
864 * CANNOT REPRODUCE
865 * According to the bug report, this test should throw a
866 * StringIndexOutOfBoundsException during the second parse. However,
867 * this is not seen.
868 */
869 void DateFormatRegressionTest::Test4104522(void)
870 {
871 UErrorCode status = U_ZERO_ERROR;
872
873 SimpleDateFormat *sdf = new SimpleDateFormat(status);
874 if(U_FAILURE(status)) {
875 dataerrln("Couldn't create SimpleDateFormat, error %s", u_errorName(status));
876 delete sdf;
877 return;
878 }
879 failure(status, "new SimpleDateFormat");
880 UnicodeString pattern = "'time' hh:mm";
881 sdf->applyPattern(pattern);
882 logln("pattern: \"" + pattern + "\"");
883
884 // works correctly
885 ParsePosition pp(0);
886 UnicodeString text = "time ";
887 UDate dt = sdf->parse(text, pp);
888 logln(" text: \"" + text + "\"" +
889 " date: " + dt);
890
891 // works wrong
892 pp.setIndex(0);
893 text = "time";
894 dt = sdf->parse(text, pp);
895 logln(" text: \"" + text + "\"" +
896 " date: " + dt);
897
898 delete sdf;
899 }
900
901 /**
902 * @bug 4106807
903 */
904 void DateFormatRegressionTest::Test4106807(void)
905 {
906 UDate dt;
907 DateFormat *df = DateFormat::createDateTimeInstance();
908
909 UErrorCode status = U_ZERO_ERROR;
910 SimpleDateFormat *sdfs [] = {
911 new SimpleDateFormat(UnicodeString("yyyyMMddHHmmss"), status),
912 new SimpleDateFormat(UnicodeString("yyyyMMddHHmmss'Z'"), status),
913 new SimpleDateFormat(UnicodeString("yyyyMMddHHmmss''"), status),
914 new SimpleDateFormat(UnicodeString("yyyyMMddHHmmss'a''a'"), status),
915 new SimpleDateFormat(UnicodeString("yyyyMMddHHmmss %"), status)
916 };
917 if(U_FAILURE(status)) {
918 dataerrln("Couldn't create SimpleDateFormat, error %s", u_errorName(status));
919 delete sdfs[0];
920 delete sdfs[1];
921 delete sdfs[2];
922 delete sdfs[3];
923 delete sdfs[4];
924 return;
925 }
926
927 failure(status, "new SimpleDateFormat");
928
929 UnicodeString strings [] = {
930 (UnicodeString) "19980211140000",
931 (UnicodeString) "19980211140000",
932 (UnicodeString) "19980211140000",
933 (UnicodeString) "19980211140000a",
934 (UnicodeString) "19980211140000 "
935 };
936
937 /*Object[] data = {
938 new SimpleDateFormat("yyyyMMddHHmmss"), "19980211140000",
939 new SimpleDateFormat("yyyyMMddHHmmss'Z'"), "19980211140000",
940 new SimpleDateFormat("yyyyMMddHHmmss''"), "19980211140000",
941 new SimpleDateFormat("yyyyMMddHHmmss'a''a'"), "19980211140000a",
942 new SimpleDateFormat("yyyyMMddHHmmss %"), "19980211140000 ",
943 };*/
944 GregorianCalendar *gc = new GregorianCalendar(status);
945 failure(status, "new GregorianCalendar");
946 TimeZone *timeZone = TimeZone::createDefault();
947
948 TimeZone *gmt = timeZone->clone();
949
950 gmt->setRawOffset(0);
951
952 for(int32_t i = 0; i < 5; i++) {
953 SimpleDateFormat *format = sdfs[i];
954 UnicodeString dateString = strings[i];
955 //try {
956 format->setTimeZone(*gmt);
957 dt = format->parse(dateString, status);
958 // {sfb} some of these parses will fail purposely
959 if(U_FAILURE(status))
960 break;
961 status = U_ZERO_ERROR;
962 UnicodeString fmtd;
963 FieldPosition pos(FieldPosition::DONT_CARE);
964 fmtd = df->format(dt, fmtd, pos);
965 logln(fmtd);
966 //logln(df->format(dt));
967 gc->setTime(dt, status);
968 failure(status, "gc->getTime");
969 logln(UnicodeString("") + gc->get(UCAL_ZONE_OFFSET, status));
970 failure(status, "gc->get");
971 UnicodeString s;
972 s = format->format(dt, s, pos);
973 logln(s);
974 /*}
975 catch (ParseException e) {
976 logln("No way Jose");
977 }*/
978 }
979
980 delete timeZone;
981 delete df;
982 for(int32_t j = 0; j < 5; j++)
983 delete sdfs [j];
984 delete gc;
985 delete gmt;
986 }
987
988 /*
989 Synopsis: Chinese time zone CTT is not recogonized correctly.
990 Description: Platform Chinese Windows 95 - ** Time zone set to CST **
991 */
992 /**
993 * @bug 4108407
994 */
995
996 // {sfb} what to do with this one ??
997 void DateFormatRegressionTest::Test4108407(void)
998 {
999 /*long l = System.currentTimeMillis();
1000 logln("user.timezone = " + System.getProperty("user.timezone", "?"));
1001 logln("Time Zone :" +
1002 DateFormat.getDateInstance().getTimeZone().getID());
1003 logln("Default format :" +
1004 DateFormat.getDateInstance().format(new Date(l)));
1005 logln("Full format :" +
1006 DateFormat.getDateInstance(DateFormat.FULL).format(new
1007 Date(l)));
1008 logln("*** Set host TZ to CST ***");
1009 logln("*** THE RESULTS OF THIS TEST MUST BE VERIFIED MANUALLY ***");*/
1010 }
1011
1012 /**
1013 * @bug 4134203
1014 * SimpleDateFormat won't parse "GMT"
1015 */
1016 void DateFormatRegressionTest::Test4134203(void)
1017 {
1018 UErrorCode status = U_ZERO_ERROR;
1019 UnicodeString dateFormat = "MM/dd/yy HH:mm:ss zzz";
1020 SimpleDateFormat *fmt = new SimpleDateFormat(dateFormat, status);
1021 if (failure(status, "new SimpleDateFormat", TRUE)) return;
1022 ParsePosition p0(0);
1023 UDate d = fmt->parse("01/22/92 04:52:00 GMT", p0);
1024 logln(dateToString(d));
1025 if(p0 == ParsePosition(0))
1026 errln("Fail: failed to parse 'GMT'");
1027 // In the failure case an exception is thrown by parse();
1028 // if no exception is thrown, the test passes.
1029
1030 delete fmt;
1031 }
1032
1033 /**
1034 * @bug 4151631
1035 * SimpleDateFormat incorrect handling of 2 single quotes in format()
1036 */
1037 void DateFormatRegressionTest::Test4151631(void)
1038 {
1039 UnicodeString pattern = "'TO_DATE('''dd'-'MM'-'yyyy HH:mm:ss''' , ''DD-MM-YYYY HH:MI:SS'')'";
1040 logln("pattern=" + pattern);
1041 UErrorCode status = U_ZERO_ERROR;
1042 SimpleDateFormat *format = new SimpleDateFormat(pattern, Locale::getUS(), status);
1043 if (failure(status, "new SimpleDateFormat", TRUE)) return;
1044 UnicodeString result;
1045 FieldPosition pos(FieldPosition::DONT_CARE);
1046 result = format->format(date(1998-1900, UCAL_JUNE, 30, 13, 30, 0), result, pos);
1047 if (result != "TO_DATE('30-06-1998 13:30:00' , 'DD-MM-YYYY HH:MI:SS')") {
1048 errln("Fail: result=" + result);
1049 }
1050 else {
1051 logln("Pass: result=" + result);
1052 }
1053
1054 delete format;
1055 }
1056
1057 /**
1058 * @bug 4151706
1059 * 'z' at end of date format throws index exception in SimpleDateFormat
1060 * CANNOT REPRODUCE THIS BUG ON 1.2FCS
1061 */
1062 void DateFormatRegressionTest::Test4151706(void)
1063 {
1064 UnicodeString dateString("Thursday, 31-Dec-98 23:00:00 GMT");
1065 UErrorCode status = U_ZERO_ERROR;
1066 SimpleDateFormat fmt(UnicodeString("EEEE, dd-MMM-yy HH:mm:ss z"), Locale::getUS(), status);
1067 if (failure(status, "new SimpleDateFormat", TRUE)) return;
1068 //try {
1069 UDate d = fmt.parse(dateString, status);
1070 failure(status, "fmt->parse");
1071 // {sfb} what about next two lines?
1072 //if (d.getTime() != Date.UTC(1998-1900, Calendar.DECEMBER, 31, 23, 0, 0))
1073 // errln("Incorrect value: " + d);
1074 /*} catch (Exception e) {
1075 errln("Fail: " + e);
1076 }*/
1077 UnicodeString temp;
1078 FieldPosition pos(FieldPosition::DONT_CARE);
1079 logln(dateString + " -> " + fmt.format(d, temp, pos));
1080 }
1081
1082 /**
1083 * @bug 4162071
1084 * Cannot reproduce this bug under 1.2 FCS -- it may be a convoluted duplicate
1085 * of some other bug that has been fixed.
1086 */
1087 void
1088 DateFormatRegressionTest::Test4162071(void)
1089 {
1090 UnicodeString dateString("Thu, 30-Jul-1999 11:51:14 GMT");
1091 UnicodeString format("EEE', 'dd-MMM-yyyy HH:mm:ss z"); // RFC 822/1123
1092 UErrorCode status = U_ZERO_ERROR;
1093 SimpleDateFormat df(format, Locale::getUS(), status);
1094 if(U_FAILURE(status)) {
1095 dataerrln("Couldn't create SimpleDateFormat - %s", u_errorName(status));
1096 return;
1097 }
1098
1099 //try {
1100 UDate x = df.parse(dateString, status);
1101 if(U_SUCCESS(status))
1102 logln("Parse format \"" + format + "\" ok");
1103 else
1104 errln("Parse format \"" + format + "\" failed.");
1105 UnicodeString temp;
1106 FieldPosition pos(FieldPosition::DONT_CARE);
1107 logln(dateString + " -> " + df.format(x, temp, pos));
1108 //} catch (Exception e) {
1109 // errln("Parse format \"" + format + "\" failed.");
1110 //}
1111 }
1112
1113 /**
1114 * DateFormat shouldn't parse year "-1" as a two-digit year (e.g., "-1" -> 1999).
1115 */
1116 void DateFormatRegressionTest::Test4182066(void) {
1117 UErrorCode status = U_ZERO_ERROR;
1118 SimpleDateFormat fmt("MM/dd/yy", Locale::getUS(), status);
1119 SimpleDateFormat dispFmt("MMM dd yyyy GG", Locale::getUS(), status);
1120 if (U_FAILURE(status)) {
1121 dataerrln("Couldn't create SimpleDateFormat - %s", u_errorName(status));
1122 return;
1123 }
1124
1125 /* We expect 2-digit year formats to put 2-digit years in the right
1126 * window. Out of range years, that is, anything less than "00" or
1127 * greater than "99", are treated as literal years. So "1/2/3456"
1128 * becomes 3456 AD. Likewise, "1/2/-3" becomes -3 AD == 2 BC.
1129 */
1130 const char* STRINGS[] = {
1131 "02/29/00",
1132 "01/23/01",
1133 "04/05/-1",
1134 "01/23/-9",
1135 "11/12/1314",
1136 "10/31/1",
1137 "09/12/+1",
1138 "09/12/001",
1139 };
1140 int32_t STRINGS_COUNT = UPRV_LENGTHOF(STRINGS);
1141 UDate FAIL_DATE = (UDate) 0;
1142 UDate DATES[] = {
1143 date(2000-1900, UCAL_FEBRUARY, 29),
1144 date(2001-1900, UCAL_JANUARY, 23),
1145 date( -1-1900, UCAL_APRIL, 5),
1146 date( -9-1900, UCAL_JANUARY, 23),
1147 date(1314-1900, UCAL_NOVEMBER, 12),
1148 date( 1-1900, UCAL_OCTOBER, 31),
1149 FAIL_DATE, // "+1" isn't recognized by US NumberFormat
1150 date( 1-1900, UCAL_SEPTEMBER,12),
1151 };
1152
1153 UnicodeString out;
1154 UBool pass = TRUE;
1155 for (int32_t i=0; i<STRINGS_COUNT; ++i) {
1156 UnicodeString str(STRINGS[i]);
1157 UDate expected = DATES[i];
1158 status = U_ZERO_ERROR;
1159 UDate actual = fmt.parse(str, status);
1160 if (U_FAILURE(status)) {
1161 actual = FAIL_DATE;
1162 }
1163 UnicodeString actStr;
1164 if (actual == FAIL_DATE) {
1165 actStr.append("null");
1166 } else {
1167 // Yuck: See j25
1168 ((DateFormat*)&dispFmt)->format(actual, actStr);
1169 }
1170
1171 if (expected == actual) {
1172 out.append(str + " => " + actStr + "\n");
1173 } else {
1174 UnicodeString expStr;
1175 if (expected == FAIL_DATE) {
1176 expStr.append("null");
1177 } else {
1178 // Yuck: See j25
1179 ((DateFormat*)&dispFmt)->format(expected, expStr);
1180 }
1181 out.append("FAIL: " + str + " => " + actStr
1182 + ", expected " + expStr + "\n");
1183 pass = FALSE;
1184 }
1185 }
1186 if (pass) {
1187 log(out);
1188 } else {
1189 err(out);
1190 }
1191 }
1192
1193 /**
1194 * j32 {JDK Bug 4210209 4209272}
1195 * DateFormat cannot parse Feb 29 2000 when setLenient(false)
1196 */
1197 void
1198 DateFormatRegressionTest::Test4210209(void) {
1199 UErrorCode status = U_ZERO_ERROR;
1200 UnicodeString pattern("MMM d, yyyy");
1201 SimpleDateFormat sfmt(pattern, Locale::getUS(), status);
1202 SimpleDateFormat sdisp("MMM dd yyyy GG", Locale::getUS(), status);
1203 DateFormat& fmt = *(DateFormat*)&sfmt; // Yuck: See j25
1204 DateFormat& disp = *(DateFormat*)&sdisp; // Yuck: See j25
1205 if (U_FAILURE(status)) {
1206 dataerrln("Couldn't create SimpleDateFormat - %s", u_errorName(status));
1207 return;
1208 }
1209 Calendar* calx = (Calendar*)fmt.getCalendar(); // cast away const!
1210 calx->setLenient(FALSE);
1211 UDate d = date(2000-1900, UCAL_FEBRUARY, 29);
1212 UnicodeString s, ss;
1213 fmt.format(d, s);
1214 logln(disp.format(d, ss.remove()) + " f> " + pattern +
1215 " => \"" + s + "\"");
1216 ParsePosition pos(0);
1217 d = fmt.parse(s, pos);
1218 logln(UnicodeString("\"") + s + "\" p> " + pattern +
1219 " => " + disp.format(d, ss.remove()));
1220 logln(UnicodeString("Parse pos = ") + pos.getIndex() +
1221 ", error pos = " + pos.getErrorIndex());
1222 if (pos.getErrorIndex() != -1) {
1223 errln(UnicodeString("FAIL: Error index should be -1"));
1224 }
1225
1226 // The underlying bug is in GregorianCalendar. If the following lines
1227 // succeed, the bug is fixed. If the bug isn't fixed, they will throw
1228 // an exception.
1229 GregorianCalendar cal(status);
1230 if (U_FAILURE(status)) {
1231 errln("FAIL: Unable to create Calendar");
1232 return;
1233 }
1234 cal.clear();
1235 cal.setLenient(FALSE);
1236 cal.set(2000, UCAL_FEBRUARY, 29); // This should work!
1237 logln(UnicodeString("Attempt to set Calendar to Feb 29 2000: ") +
1238 disp.format(cal.getTime(status), ss.remove()));
1239 if (U_FAILURE(status)) {
1240 errln("FAIL: Unable to set Calendar to Feb 29 2000");
1241 }
1242 }
1243
1244 void DateFormatRegressionTest::Test714(void)
1245 {
1246 //try {
1247 UDate d(978103543000.);
1248 DateFormat *fmt = DateFormat::createDateTimeInstance(DateFormat::NONE,
1249 DateFormat::MEDIUM,
1250 Locale::getUS());
1251 if (fmt == NULL) {
1252 dataerrln("Error calling DateFormat::createDateTimeInstance");
1253 return;
1254 }
1255
1256 UnicodeString s;
1257 UnicodeString tests =
1258 (UnicodeString) "7:25:43 AM" ;
1259 UErrorCode status = U_ZERO_ERROR;
1260 fmt->format (d,s);
1261 if(U_FAILURE(status))
1262 {
1263 errln((UnicodeString) "Fail, errmsg " + u_errorName(status));
1264 return;
1265 }
1266
1267 if(s != tests)
1268 {
1269 errln((UnicodeString) "Fail: " + s + " != " + tests);
1270 }
1271 else
1272 {
1273 logln("OK: " + s + " == " + tests);
1274 }
1275
1276 delete fmt;
1277 }
1278
1279 class Test1684Data {
1280 public:
1281 int32_t year;
1282 int32_t month;
1283 int32_t date;
1284 int32_t womyear;
1285 int32_t wommon;
1286 int32_t wom;
1287 int32_t dow;
1288 UnicodeString data;
1289 UnicodeString normalized;
1290
1291 Test1684Data(int32_t xyear, int32_t xmonth, int32_t xdate,
1292 int32_t xwomyear, int32_t xwommon, int32_t xwom, int32_t xdow,
1293 const char *xdata, const char *xnormalized) :
1294 year(xyear),
1295 month(xmonth-1),
1296 date(xdate),
1297 womyear(xwomyear),
1298 wommon(xwommon-1),
1299 wom(xwom),
1300 dow(xdow),
1301 data(xdata,""),
1302 normalized((xnormalized==NULL)?xdata:xnormalized,"")
1303 { }
1304 };
1305
1306 void DateFormatRegressionTest::Test1684(void)
1307 {
1308 // July 2001 August 2001 January 2002
1309 // Su Mo Tu We Th Fr Sa Su Mo Tu We Th Fr Sa Su Mo Tu We Th Fr Sa
1310 // 1 2 3 4 5 6 7 1 2 3 4 1 2 3 4 5
1311 // 8 9 10 11 12 13 14 5 6 7 8 9 10 11 6 7 8 9 10 11 12
1312 // 15 16 17 18 19 20 21 12 13 14 15 16 17 18 13 14 15 16 17 18 19
1313 // 22 23 24 25 26 27 28 19 20 21 22 23 24 25 20 21 22 23 24 25 26
1314 // 29 30 31 26 27 28 29 30 31 27 28 29 30 31
1315 Test1684Data *tests[] = {
1316 new Test1684Data(2001, 8, 6, 2001,8,2,UCAL_MONDAY, "2001 08 02 Mon", NULL),
1317 new Test1684Data(2001, 8, 7, 2001,8,2,UCAL_TUESDAY, "2001 08 02 Tue", NULL),
1318 new Test1684Data(2001, 8, 5,/*12,*/ 2001,8,2,UCAL_SUNDAY, "2001 08 02 Sun", NULL),
1319 new Test1684Data(2001, 8,6, /*7, 30,*/ 2001,7,6,UCAL_MONDAY, "2001 07 06 Mon", "2001 08 02 Mon"),
1320 new Test1684Data(2001, 8,7, /*7, 31,*/ 2001,7,6,UCAL_TUESDAY, "2001 07 06 Tue", "2001 08 02 Tue"),
1321 new Test1684Data(2001, 8, 5, 2001,7,6,UCAL_SUNDAY, "2001 07 06 Sun", "2001 08 02 Sun"),
1322 new Test1684Data(2001, 7, 30, 2001,8,1,UCAL_MONDAY, "2001 08 01 Mon", "2001 07 05 Mon"),
1323 new Test1684Data(2001, 7, 31, 2001,8,1,UCAL_TUESDAY, "2001 08 01 Tue", "2001 07 05 Tue"),
1324 new Test1684Data(2001, 7,29, /*8, 5,*/ 2001,8,1,UCAL_SUNDAY, "2001 08 01 Sun", "2001 07 05 Sun"),
1325 new Test1684Data(2001, 12, 31, 2001,12,6,UCAL_MONDAY, "2001 12 06 Mon", NULL),
1326 new Test1684Data(2002, 1, 1, 2002,1,1,UCAL_TUESDAY, "2002 01 01 Tue", NULL),
1327 new Test1684Data(2002, 1, 2, 2002,1,1,UCAL_WEDNESDAY, "2002 01 01 Wed", NULL),
1328 new Test1684Data(2002, 1, 3, 2002,1,1,UCAL_THURSDAY, "2002 01 01 Thu", NULL),
1329 new Test1684Data(2002, 1, 4, 2002,1,1,UCAL_FRIDAY, "2002 01 01 Fri", NULL),
1330 new Test1684Data(2002, 1, 5, 2002,1,1,UCAL_SATURDAY, "2002 01 01 Sat", NULL),
1331 new Test1684Data(2001,12,30, /*2002, 1, 6,*/ 2002,1,1,UCAL_SUNDAY, "2002 01 01 Sun", "2001 12 06 Sun")
1332 };
1333
1334 #define kTest1684Count UPRV_LENGTHOF(tests)
1335
1336 int32_t pass = 0, error = 0, warning = 0;
1337 int32_t i;
1338
1339 UErrorCode status = U_ZERO_ERROR;
1340 UnicodeString pattern("yyyy MM WW EEE","");
1341 Calendar *cal = new GregorianCalendar(status);
1342 SimpleDateFormat *sdf = new SimpleDateFormat(pattern,status);
1343 if (U_FAILURE(status)) {
1344 dataerrln("Error constructing SimpleDateFormat");
1345 for(i=0;i<kTest1684Count;i++) {
1346 delete tests[i];
1347 }
1348 delete cal;
1349 delete sdf;
1350 return;
1351 }
1352 cal->setFirstDayOfWeek(UCAL_SUNDAY);
1353 cal->setMinimalDaysInFirstWeek(1);
1354
1355 sdf->adoptCalendar(cal);
1356
1357 cal = sdf->getCalendar()->clone(); // sdf may have deleted calendar
1358
1359 if(!cal || !sdf || U_FAILURE(status)) {
1360 errln(UnicodeString("Error setting up test: ") + u_errorName(status));
1361 }
1362
1363 for (i = 0; i < kTest1684Count; ++i) {
1364 Test1684Data &test = *(tests[i]);
1365 logln(UnicodeString("#") + i + UnicodeString("\n-----\nTesting round trip of ") + test.year +
1366 " " + (test.month + 1) +
1367 " " + test.date +
1368 " (written as) " + test.data);
1369
1370 cal->clear();
1371 cal->set(test.year, test.month, test.date);
1372 UDate ms = cal->getTime(status);
1373
1374 cal->clear();
1375 cal->set(UCAL_YEAR, test.womyear);
1376 cal->set(UCAL_MONTH, test.wommon);
1377 cal->set(UCAL_WEEK_OF_MONTH, test.wom);
1378 cal->set(UCAL_DAY_OF_WEEK, test.dow);
1379 UDate ms2 = cal->getTime(status);
1380
1381 if (ms2 != ms) {
1382 errln((UnicodeString)"\nError: GregorianUCAL_DOM gave " + ms +
1383 "\n GregorianUCAL_WOM gave " + ms2);
1384 error++;
1385 } else {
1386 pass++;
1387 }
1388
1389 ms2 = sdf->parse(test.data, status);
1390 if(U_FAILURE(status)) {
1391 errln("parse exception: " + UnicodeString(u_errorName(status)));
1392 }
1393
1394 if (ms2!=ms) {
1395 errln((UnicodeString)"\nError: GregorianCalendar gave " + ms +
1396 "\n SimpleDateFormat.parse gave " + ms2);
1397 error++;
1398 } else {
1399 pass++;
1400 }
1401
1402 UnicodeString result;
1403 sdf->format(ms, result);
1404 if (result != test.normalized) {
1405 errln("\nWarning: format of '" + test.data + "' gave" +
1406 "\n '" + result + "'" +
1407 "\n expected '" + test.normalized + "'");
1408 warning++;
1409 } else {
1410 pass++;
1411 }
1412
1413 UDate ms3;
1414 ms3 = sdf->parse(result, status);
1415 if(U_FAILURE(status)) {
1416 errln("parse exception 2: " + (UnicodeString)u_errorName(status));
1417 }
1418
1419 if (ms3!=ms) {
1420 error++;
1421 errln((UnicodeString)"\nError: Re-parse of '" + result + "' gave time of " +
1422 "\n " + ms3 +
1423 "\n not " + ms);
1424 } else {
1425 pass++;
1426 }
1427 }
1428
1429 UnicodeString info
1430 = UnicodeString("Passed: ") + pass + ", Warnings: " + warning + ", Errors: " + error;
1431 if (error > 0) {
1432 errln(info);
1433 } else {
1434 logln(info);
1435 }
1436
1437 for(i=0;i<kTest1684Count;i++) {
1438 delete tests[i];
1439 }
1440 delete cal;
1441 delete sdf;
1442 }
1443
1444 void DateFormatRegressionTest::Test5554(void)
1445 {
1446 UErrorCode status = U_ZERO_ERROR;
1447 UnicodeString pattern("Z","");
1448 UnicodeString newfoundland("Canada/Newfoundland", "");
1449 TimeZone *zone = TimeZone::createTimeZone(newfoundland);
1450 Calendar *cal = new GregorianCalendar(zone, status);
1451 SimpleDateFormat *sdf = new SimpleDateFormat(pattern,status);
1452 if (U_FAILURE(status)) {
1453 dataerrln("Error constructing SimpleDateFormat");
1454 delete cal;
1455 delete sdf;
1456 return;
1457 }
1458 cal->set(2007, 1, 14);
1459 UDate date = cal->getTime(status);
1460 if (U_FAILURE(status)) {
1461 errln("Error getting time to format");
1462 return;
1463 };
1464 sdf->adoptCalendar(cal);
1465 UnicodeString result;
1466 UnicodeString correct("-0330", "");
1467 sdf->format(date, result);
1468 if (result != correct) {
1469 errln("\nError: Newfoundland Z of Jan 14, 2007 gave '" + result + "', expected '" + correct + "'");
1470 }
1471 delete sdf;
1472 }
1473
1474 void DateFormatRegressionTest::Test9237(void)
1475 {
1476 UErrorCode status = U_ZERO_ERROR;
1477 UnicodeString pattern("VVVV");
1478
1479 SimpleDateFormat fmt(pattern, status); // default locale
1480 SimpleDateFormat fmtDE(pattern, Locale("de_DE"), status);
1481 if (U_FAILURE(status)) {
1482 dataerrln("Error constructing SimpleDateFormat");
1483 return;
1484 }
1485
1486 // copy constructor
1487 SimpleDateFormat fmtCopyDE(fmtDE);
1488 UnicodeString resDE, resCopyDE;
1489
1490 fmtDE.format(0.0, resDE);
1491 fmtCopyDE.format(0.0, resCopyDE);
1492
1493 if (resDE != resCopyDE) {
1494 errln(UnicodeString("Error: different result by the copied instance - org:") + resDE + " copy:" + resCopyDE);
1495 }
1496
1497 // test for assignment operator
1498 fmt = fmtDE;
1499
1500 UnicodeString resAssigned;
1501 fmt.format(0.0, resAssigned);
1502
1503 if (resDE != resAssigned) {
1504 errln(UnicodeString("Error: different results by the assigned instance - org:") + resDE + " assigned:" + resAssigned);
1505 }
1506 }
1507
1508 void DateFormatRegressionTest::TestParsing(void) {
1509 UErrorCode status = U_ZERO_ERROR;
1510 UnicodeString pattern("EEE-WW-MMMM-yyyy");
1511 UnicodeString text("mon-02-march-2011");
1512 int32_t expectedDay = 7;
1513
1514 SimpleDateFormat format(pattern, status);
1515 if (U_FAILURE(status)) {
1516 dataerrln("Unable to create SimpleDateFormat - %s", u_errorName(status));
1517 return;
1518 }
1519
1520 Calendar *cal = new GregorianCalendar(status);
1521 if (cal == NULL || U_FAILURE(status)) {
1522 errln("Unable to create calendar - %s", u_errorName(status));
1523 return;
1524 }
1525
1526 ParsePosition pos(0);
1527 format.parse(text, *cal, pos);
1528
1529 if (cal->get(UCAL_DAY_OF_MONTH, status) != expectedDay) {
1530 errln("Parsing failed: day of month should be '7' with pattern: \"" + pattern + "\" for text: \"" + text + "\"");
1531 }
1532
1533 delete cal;
1534 }
1535
1536 void DateFormatRegressionTest::TestT10334(void) {
1537 UErrorCode status = U_ZERO_ERROR;
1538 UnicodeString pattern("'--: 'EEE-WW-MMMM-yyyy");
1539 UnicodeString text("--mon-02-march-2011");
1540 SimpleDateFormat format(pattern, status);
1541
1542 logln("pattern["+pattern+"] text["+text+"]");
1543
1544 if (U_FAILURE(status)) {
1545 dataerrln("Fail creating SimpleDateFormat object - %s", u_errorName(status));
1546 return;
1547 }
1548
1549 format.setBooleanAttribute(UDAT_PARSE_PARTIAL_LITERAL_MATCH, FALSE, status);
1550 format.parse(text, status);
1551 if (!U_FAILURE(status)) {
1552 errln("parse partial match did NOT fail in strict mode - %s", u_errorName(status));
1553 }
1554
1555 status = U_ZERO_ERROR;
1556 format.setBooleanAttribute(UDAT_PARSE_PARTIAL_LITERAL_MATCH, TRUE, status);
1557 format.parse(text, status);
1558 if (U_FAILURE(status)) {
1559 errln("parse partial match failure in lenient mode - %s", u_errorName(status));
1560 }
1561
1562 status = U_ZERO_ERROR;
1563 pattern = UnicodeString("YYYY MM dd");
1564 text = UnicodeString("2013 12 10");
1565 format.applyPattern(pattern);
1566 UDate referenceDate = format.parse(text, status);
1567
1568 FieldPosition fp(FieldPosition::DONT_CARE);
1569 UnicodeString formattedString("");
1570 pattern = UnicodeString("YYYY LL dd ee cc qq QQ");
1571 format.applyPattern(pattern);
1572 format.format(referenceDate, formattedString, fp, status);
1573 logln("ref date: " + formattedString);
1574
1575
1576 char patternArray[] = "YYYY LLL dd eee ccc qqq QQQ";
1577 pattern = UnicodeString(patternArray);
1578 text = UnicodeString("2013 12 10 03 3 04 04");
1579 status = U_ZERO_ERROR;
1580 format.setBooleanAttribute(UDAT_PARSE_ALLOW_NUMERIC, TRUE, status);
1581 format.applyPattern(pattern);
1582 ParsePosition pp(0);
1583 format.parse(text, pp);
1584 if (pp.getErrorIndex() != -1) {
1585 errln("numeric parse error");
1586 }
1587
1588 status = U_ZERO_ERROR;
1589 format.setBooleanAttribute(UDAT_PARSE_ALLOW_NUMERIC, FALSE, status);
1590 format.parse(text, status);
1591 if (!U_FAILURE(status)) {
1592 errln("numeric parse did NOT fail in strict mode", u_errorName(status));
1593 }
1594
1595 }
1596
1597
1598 typedef struct {
1599 const char * locale;
1600 UBool leniency;
1601 UnicodeString parseString;
1602 UnicodeString pattern;
1603 UnicodeString expectedResult; // null indicates expected error
1604 } TestDateFormatLeniencyItem;
1605
1606
1607 void DateFormatRegressionTest::TestT10619(void) {
1608 const UDate july022008 = 1215000001979.0;
1609 const TestDateFormatLeniencyItem items[] = {
1610 //locale leniency parse String pattern expected result
1611 { "en", true, UnicodeString("2008-07 02"), UnicodeString("yyyy-LLLL dd"), UnicodeString("2008-July 02") },
1612 { "en", false, UnicodeString("2008-07 03"), UnicodeString("yyyy-LLLL dd"), UnicodeString("") },
1613 { "en", true, UnicodeString("2008-Jan. 04"), UnicodeString("yyyy-LLL dd"), UnicodeString("2008-Jan 04") },
1614 { "en", false, UnicodeString("2008-Jan. 05"), UnicodeString("yyyy-LLL dd"), UnicodeString("") },
1615 { "en", true, UnicodeString("2008-Jan--06"), UnicodeString("yyyy-MMM -- dd"), UnicodeString("2008-Jan 06") },
1616 { "en", false, UnicodeString("2008-Jan--07"), UnicodeString("yyyy-MMM -- dd"), UnicodeString("") },
1617 { "en", true, UnicodeString("6 Jan 08 2008"), UnicodeString("eee MMM dd yyyy"), UnicodeString("Sat Jan 08 2008") },
1618 { "en", false, UnicodeString("6 Jan 09 2008"), UnicodeString("eee MMM dd yyyy"), UnicodeString("") },
1619 // terminator
1620 { NULL, true, UnicodeString(""), UnicodeString(""), UnicodeString("") }
1621 };
1622 UErrorCode status = U_ZERO_ERROR;
1623 Calendar* cal = Calendar::createInstance(status);
1624 if (U_FAILURE(status)) {
1625 dataerrln(UnicodeString("FAIL: Unable to create Calendar for default timezone and locale."));
1626 } else {
1627 cal->setTime(july022008, status);
1628 const TestDateFormatLeniencyItem * itemPtr;
1629 for (itemPtr = items; itemPtr->locale != NULL; itemPtr++ ) {
1630
1631 Locale locale = Locale::createFromName(itemPtr->locale);
1632 status = U_ZERO_ERROR;
1633 ParsePosition pos(0);
1634 SimpleDateFormat * sdmft = new SimpleDateFormat(itemPtr->pattern, locale, status);
1635 if (U_FAILURE(status)) {
1636 dataerrln("Unable to create SimpleDateFormat - %s", u_errorName(status));
1637 continue;
1638 }
1639 logln("parsing " + itemPtr->parseString);
1640 sdmft->setLenient(itemPtr->leniency);
1641 sdmft->setBooleanAttribute(UDAT_PARSE_ALLOW_WHITESPACE, itemPtr->leniency, status);
1642 sdmft->setBooleanAttribute(UDAT_PARSE_ALLOW_NUMERIC, itemPtr->leniency, status);
1643 sdmft->setBooleanAttribute(UDAT_PARSE_PARTIAL_LITERAL_MATCH, itemPtr->leniency, status);
1644 sdmft->parse(itemPtr->parseString, pos);
1645
1646 delete sdmft;
1647 if(pos.getErrorIndex() > -1) {
1648 if(itemPtr->expectedResult.length() != 0) {
1649 errln("error: unexpected error - " + itemPtr->parseString + " - error index " + pos.getErrorIndex() +
1650 " - leniency " + itemPtr->leniency);
1651 continue;
1652 } else {
1653 continue;
1654 }
1655 }
1656 }
1657 }
1658 delete cal;
1659
1660 }
1661
1662
1663 typedef struct {
1664 UnicodeString text;
1665 UnicodeString pattern;
1666 int initialParsePos;
1667 } T10855Data;
1668
1669 void DateFormatRegressionTest::TestT10855(void) {
1670 // NOTE: these should NOT parse
1671 const T10855Data items[] = {
1672 //parse String pattern initial parse pos
1673 // { UnicodeString("September 30, 1998"), UnicodeString("MM-dd-yyyy"), 0}, // for Apple, this can succeed
1674 { UnicodeString("123-73-1950"), UnicodeString("MM-dd-yyyy"), -1},
1675 { UnicodeString("12-23-1950"), UnicodeString("MM-dd-yyyy"), -1},
1676 // terminator
1677 { UnicodeString(""), UnicodeString(""), 0}
1678 };
1679 UErrorCode status = U_ZERO_ERROR;
1680
1681 int x = 0;
1682 while(items[x].pattern.length() > 0)
1683 {
1684 status = U_ZERO_ERROR;
1685 logln("Date to parse: \""+items[x].text+"\"");
1686 logln("Starting Index: %d", items[x].initialParsePos);
1687
1688 SimpleDateFormat dateFmt(items[x].pattern, status);
1689 if(U_FAILURE(status)) {
1690 errcheckln(status, "Failed dateFmt: %s", u_errorName(status));
1691 ++x;
1692 continue;
1693 }
1694 status = U_ZERO_ERROR;
1695
1696 dateFmt.setLenient(false);
1697 dateFmt.setTimeZone(*TimeZone::getGMT());
1698
1699 ParsePosition position(items[x].initialParsePos);
1700 logln("set position is now: %d", position.getIndex());
1701 UDate d = dateFmt.parse(items[x].text, position);
1702 if (position.getErrorIndex() != -1 || position.getIndex() == items[x].initialParsePos) {
1703 logln("Parse Failed. ErrorIndex is %d - Index is %d", position.getErrorIndex(), position.getIndex());
1704 } else {
1705 errln("Parse Succeeded...should have failed. Index is %d - ErrorIndex is %d", position.getIndex(), position.getErrorIndex());
1706 }
1707 logln("Parsed date returns %d\n", d);
1708
1709 ++x;
1710 }
1711 }
1712
1713 void DateFormatRegressionTest::TestT10906(void) {
1714
1715 UErrorCode status = U_ZERO_ERROR;
1716 UnicodeString pattern = "MM-dd-yyyy";
1717 UnicodeString text = "06-10-2014";
1718 SimpleDateFormat format(pattern, status);
1719 int32_t errorIdx = 0;
1720 ParsePosition pp(-1);
1721 format.parse(text, pp);
1722 errorIdx = pp.getErrorIndex();
1723 if (errorIdx == -1) {
1724 errln("failed to report invalid (negative) starting parse position");
1725 }
1726 }
1727
1728 void DateFormatRegressionTest::TestT13380(void) {
1729 UErrorCode errorCode = U_ZERO_ERROR;
1730 LocalPointer<DateFormat> enFmt(DateFormat::createDateInstance(DateFormat::kShort, Locale("en")), errorCode);
1731 if (U_FAILURE(errorCode)) {
1732 errln("failure creating 'en' DateFormat");
1733 }
1734
1735 errorCode = U_ZERO_ERROR;
1736 LocalPointer<DateFormat> tgFmt(DateFormat::createDateInstance(DateFormat::kShort, Locale("tg")), errorCode);
1737 if (U_FAILURE(errorCode)) {
1738 errln("failure creating 'tg' DateFormat");
1739 }
1740 }
1741
1742 #endif /* #if !UCONFIG_NO_FORMATTING */
1743
1744 //eof
mirror of ICU