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