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