jars/icu4j-4_2_1-src/src/com/ibm/icu/dev/test/format/DateFormatRegressionTest.java

   1 /*\r
   2  *******************************************************************************\r
   3  * Copyright (C) 2001-2009, International Business Machines Corporation and    *\r
   4  * others. All Rights Reserved.                                                *\r
   5  *******************************************************************************\r
   6  */\r
   7 \r
   8 /** \r
   9  * Port From:   ICU4C v1.8.1 : format : DateFormatRegressionTest\r
  10  * Source File: $ICU4CRoot/source/test/intltest/dtfmrgts.cpp\r
  11  **/\r
  12 \r
  13 package com.ibm.icu.dev.test.format;\r
  14 \r
  15 import com.ibm.icu.text.*;\r
  16 import com.ibm.icu.util.*;\r
  17 \r
  18 import java.io.*;\r
  19 import java.text.FieldPosition;\r
  20 import java.text.Format;\r
  21 import java.text.ParseException;\r
  22 import java.text.ParsePosition;\r
  23 import java.util.Date;\r
  24 import java.util.Locale;\r
  25 \r
  26 /** \r
  27  * Performs regression test for DateFormat\r
  28  **/\r
  29 public class DateFormatRegressionTest extends com.ibm.icu.dev.test.TestFmwk {\r
  30 \r
  31     public static void main(String[] args) throws Exception{\r
  32         new DateFormatRegressionTest().run(args);\r
  33     }\r
  34     \r
  35     /**\r
  36      * @bug 4029195\r
  37      */\r
  38     public void Test4029195() {\r
  39         Calendar cal = Calendar.getInstance();\r
  40         Date today = cal.getTime();\r
  41         logln("today: " + today);\r
  42         SimpleDateFormat sdf = (SimpleDateFormat) DateFormat.getDateInstance();\r
  43         String pat = sdf.toPattern();\r
  44         logln("pattern: " + pat);\r
  45         StringBuffer fmtd = new StringBuffer("");\r
  46         FieldPosition pos = new FieldPosition(0);\r
  47         fmtd = sdf.format(today, fmtd, pos);\r
  48         logln("today: " + fmtd);\r
  49     \r
  50         sdf.applyPattern("G yyyy DDD");\r
  51         StringBuffer todayS = new StringBuffer("");\r
  52         todayS = sdf.format(today, todayS, pos);\r
  53         logln("today: " + todayS);\r
  54         try {\r
  55             today = sdf.parse(todayS.toString());\r
  56             logln("today date: " + today);\r
  57         } catch (Exception e) {\r
  58             errln("Error reparsing date: " + e.getMessage());\r
  59         }\r
  60     \r
  61         try {\r
  62             StringBuffer rt = new StringBuffer("");\r
  63             rt = sdf.format(sdf.parse(todayS.toString()), rt, pos);\r
  64             logln("round trip: " + rt);\r
  65             if (!rt.toString().equals(todayS.toString()))\r
  66                 errln("Fail: Want " + todayS + " Got " + rt);\r
  67         } catch (ParseException e) {\r
  68             errln("Fail: " + e);\r
  69             e.printStackTrace();\r
  70         }\r
  71     }\r
  72     \r
  73     /**\r
  74      * @bug 4052408\r
  75      */\r
  76     public void Test4052408() {\r
  77     \r
  78         DateFormat fmt = DateFormat.getDateTimeInstance(DateFormat.SHORT, DateFormat.SHORT, Locale.US); \r
  79         Calendar cal = Calendar.getInstance();\r
  80         cal.clear();\r
  81         cal.set(97 + 1900, Calendar.MAY, 3, 8, 55);\r
  82         Date dt = cal.getTime();\r
  83         String str = fmt.format(dt);\r
  84         logln(str);\r
  85         \r
  86         if (!str.equals("5/3/97 8:55 AM"))\r
  87             errln("Fail: Test broken; Want 5/3/97 8:55 AM Got " + str);\r
  88     \r
  89         String expected[] = {\r
  90             "", //"ERA_FIELD",\r
  91             "97", //"YEAR_FIELD",\r
  92             "5", //"MONTH_FIELD",\r
  93             "3", //"DATE_FIELD",\r
  94             "", //"HOUR_OF_DAY1_FIELD",\r
  95             "", //"HOUR_OF_DAY0_FIELD",\r
  96             "55", //"MINUTE_FIELD",\r
  97             "", //"SECOND_FIELD",\r
  98             "", //"MILLISECOND_FIELD",\r
  99             "", //"DAY_OF_WEEK_FIELD",\r
 100             "", //"DAY_OF_YEAR_FIELD",\r
 101             "", //"DAY_OF_WEEK_IN_MONTH_FIELD",\r
 102             "", //"WEEK_OF_YEAR_FIELD",\r
 103             "", //"WEEK_OF_MONTH_FIELD",\r
 104             "AM", //"AM_PM_FIELD",\r
 105             "8", //"HOUR1_FIELD",\r
 106             "", //"HOUR0_FIELD",\r
 107             "" //"TIMEZONE_FIELD"\r
 108             };        \r
 109         String fieldNames[] = {\r
 110                 "ERA_FIELD", \r
 111                 "YEAR_FIELD", \r
 112                 "MONTH_FIELD", \r
 113                 "DATE_FIELD", \r
 114                 "HOUR_OF_DAY1_FIELD", \r
 115                 "HOUR_OF_DAY0_FIELD", \r
 116                 "MINUTE_FIELD", \r
 117                 "SECOND_FIELD", \r
 118                 "MILLISECOND_FIELD", \r
 119                 "DAY_OF_WEEK_FIELD", \r
 120                 "DAY_OF_YEAR_FIELD", \r
 121                 "DAY_OF_WEEK_IN_MONTH_FIELD", \r
 122                 "WEEK_OF_YEAR_FIELD", \r
 123                 "WEEK_OF_MONTH_FIELD", \r
 124                 "AM_PM_FIELD", \r
 125                 "HOUR1_FIELD", \r
 126                 "HOUR0_FIELD", \r
 127                 "TIMEZONE_FIELD"}; \r
 128     \r
 129         boolean pass = true;\r
 130         for (int i = 0; i <= 17; ++i) {\r
 131             FieldPosition pos = new FieldPosition(i);\r
 132             StringBuffer buf = new StringBuffer("");\r
 133             fmt.format(dt, buf, pos);\r
 134             //char[] dst = new char[pos.getEndIndex() - pos.getBeginIndex()];\r
 135             String dst = buf.substring(pos.getBeginIndex(), pos.getEndIndex());\r
 136             str = dst;\r
 137             log(i + ": " + fieldNames[i] + ", \"" + str + "\", "\r
 138                     + pos.getBeginIndex() + ", " + pos.getEndIndex()); \r
 139             String exp = expected[i];\r
 140             if ((exp.length() == 0 && str.length() == 0) || str.equals(exp))\r
 141                 logln(" ok");\r
 142             else {\r
 143                 logln(" expected " + exp);\r
 144                 pass = false;\r
 145             }\r
 146         }\r
 147         if (!pass)\r
 148             errln("Fail: FieldPosition not set right by DateFormat");\r
 149     }\r
 150     \r
 151     /**\r
 152      * @bug 4056591\r
 153      * Verify the function of the [s|g]et2DigitYearStart() API.\r
 154      */\r
 155     public void Test4056591() {\r
 156     \r
 157         try {\r
 158             SimpleDateFormat fmt = new SimpleDateFormat("yyMMdd", Locale.US);\r
 159             Calendar cal = Calendar.getInstance();\r
 160             cal.clear();\r
 161             cal.set(1809, Calendar.DECEMBER, 25);\r
 162             Date start = cal.getTime();\r
 163             fmt.set2DigitYearStart(start);\r
 164             if ((fmt.get2DigitYearStart() != start))\r
 165                 errln("get2DigitYearStart broken");\r
 166             cal.clear();\r
 167             cal.set(1809, Calendar.DECEMBER, 25);\r
 168             Date d1 = cal.getTime();\r
 169             cal.clear();\r
 170             cal.set(1909, Calendar.DECEMBER, 24);\r
 171             Date d2 = cal.getTime();\r
 172             cal.clear();\r
 173             cal.set(1809, Calendar.DECEMBER, 26);\r
 174             Date d3 = cal.getTime();\r
 175             cal.clear();\r
 176             cal.set(1861, Calendar.DECEMBER, 25);\r
 177             Date d4 = cal.getTime();\r
 178             \r
 179             Date dates[] = {d1, d2, d3, d4};\r
 180     \r
 181             String strings[] = {"091225", "091224", "091226", "611225"};            \r
 182     \r
 183             for (int i = 0; i < 4; i++) {\r
 184                 String s = strings[i];\r
 185                 Date exp = dates[i];\r
 186                 Date got = fmt.parse(s);\r
 187                 logln(s + " . " + got + "; exp " + exp);\r
 188                 if (got.getTime() != exp.getTime())\r
 189                     errln("set2DigitYearStart broken");\r
 190             }\r
 191         } catch (ParseException e) {\r
 192             errln("Fail: " + e);\r
 193             e.printStackTrace();\r
 194         }\r
 195     }\r
 196     \r
 197     /**\r
 198      * @bug 4059917\r
 199      */\r
 200     public void Test4059917() {        \r
 201         SimpleDateFormat fmt;\r
 202         String myDate;\r
 203         fmt = new SimpleDateFormat("yyyy/MM/dd");\r
 204         myDate = "1997/01/01";\r
 205         aux917( fmt, myDate );        \r
 206         fmt = new SimpleDateFormat("yyyyMMdd");\r
 207         myDate = "19970101";\r
 208         aux917( fmt, myDate );\r
 209     }\r
 210     \r
 211     public void aux917(SimpleDateFormat fmt, String str) {\r
 212     \r
 213         String pat = fmt.toPattern();\r
 214         logln("==================");\r
 215         logln("testIt: pattern=" + pat + " string=" + str);\r
 216         ParsePosition pos = new ParsePosition(0);\r
 217         Object o = fmt.parseObject(str, pos);\r
 218         //logln( UnicodeString("Parsed object: ") + o );\r
 219     \r
 220         StringBuffer formatted = new StringBuffer("");\r
 221         FieldPosition poss = new FieldPosition(0);\r
 222         formatted = fmt.format(o, formatted, poss);\r
 223     \r
 224         logln("Formatted string: " + formatted);\r
 225         if (!formatted.toString().equals(str))\r
 226             errln("Fail: Want " + str + " Got " + formatted);\r
 227     }\r
 228     \r
 229     /**\r
 230      * @bug 4060212\r
 231      */\r
 232     public void Test4060212() {\r
 233         String dateString = "1995-040.05:01:29";\r
 234         logln("dateString= " + dateString);\r
 235         logln("Using yyyy-DDD.hh:mm:ss");\r
 236         SimpleDateFormat formatter = new SimpleDateFormat("yyyy-DDD.hh:mm:ss");\r
 237         ParsePosition pos = new ParsePosition(0);\r
 238         Date myDate = formatter.parse(dateString, pos);\r
 239         DateFormat fmt = DateFormat.getDateTimeInstance(DateFormat.FULL, DateFormat.LONG); \r
 240         String myString = fmt.format(myDate);\r
 241         logln(myString);\r
 242         Calendar cal = new GregorianCalendar();\r
 243         cal.setTime(myDate);\r
 244         if ((cal.get(Calendar.DAY_OF_YEAR) != 40))\r
 245             errln("Fail: Got " + cal.get(Calendar.DAY_OF_YEAR) + " Want 40");\r
 246     \r
 247         logln("Using yyyy-ddd.hh:mm:ss");\r
 248         formatter = new SimpleDateFormat("yyyy-ddd.hh:mm:ss");\r
 249         pos.setIndex(0);\r
 250         myDate = formatter.parse(dateString, pos);\r
 251         myString = fmt.format(myDate);\r
 252         logln(myString);\r
 253         cal.setTime(myDate);\r
 254         if ((cal.get(Calendar.DAY_OF_YEAR) != 40))\r
 255             errln("Fail: Got " + cal.get(Calendar.DAY_OF_YEAR) + " Want 40");\r
 256     }\r
 257     /**\r
 258      * @bug 4061287\r
 259      */\r
 260     public void Test4061287() {\r
 261     \r
 262         SimpleDateFormat df = new SimpleDateFormat("dd/MM/yyyy");\r
 263         try {\r
 264             logln(df.parse("35/01/1971").toString());\r
 265         } catch (ParseException e) {\r
 266             errln("Fail: " + e);\r
 267             e.printStackTrace();\r
 268         }\r
 269         df.setLenient(false);\r
 270         boolean ok = false;\r
 271         try {\r
 272             logln(df.parse("35/01/1971").toString());\r
 273         } catch (ParseException e) {\r
 274             ok = true;\r
 275         }\r
 276         if (!ok)\r
 277             errln("Fail: Lenient not working");\r
 278     }\r
 279     \r
 280     /**\r
 281      * @bug 4065240\r
 282      */\r
 283     public void Test4065240() {\r
 284         Date curDate;\r
 285         DateFormat shortdate, fulldate;\r
 286         String strShortDate, strFullDate;\r
 287         Locale saveLocale = Locale.getDefault();\r
 288         TimeZone saveZone = TimeZone.getDefault();\r
 289     \r
 290         try {\r
 291             Locale curLocale = new Locale("de", "DE");\r
 292             Locale.setDefault(curLocale);\r
 293             // {sfb} adoptDefault instead of setDefault\r
 294             //TimeZone.setDefault(TimeZone.createTimeZone("EST"));\r
 295             TimeZone.setDefault(TimeZone.getTimeZone("EST"));\r
 296             Calendar cal = Calendar.getInstance();\r
 297             cal.clear();\r
 298             cal.set(98 + 1900, 0, 1);\r
 299             curDate = cal.getTime();\r
 300             shortdate = DateFormat.getDateInstance(DateFormat.SHORT);\r
 301             fulldate = DateFormat.getDateTimeInstance(DateFormat.LONG, DateFormat.LONG);\r
 302             strShortDate = "The current date (short form) is ";\r
 303             String temp;\r
 304             temp = shortdate.format(curDate);\r
 305             strShortDate += temp;\r
 306             strFullDate = "The current date (long form) is ";\r
 307             String temp2 = fulldate.format(curDate);\r
 308             strFullDate += temp2;\r
 309     \r
 310             logln(strShortDate);\r
 311             logln(strFullDate);\r
 312     \r
 313             // {sfb} What to do with resource bundle stuff?????\r
 314     \r
 315             // Check to see if the resource is present; if not, we can't test\r
 316             //ResourceBundle bundle = //The variable is never used\r
 317             //    ICULocaleData.getBundle("DateFormatZoneData", curLocale); \r
 318     \r
 319             // {sfb} API change to ResourceBundle -- add getLocale()\r
 320             /*if (bundle.getLocale().getLanguage().equals("de")) {\r
 321                 // UPDATE THIS AS ZONE NAME RESOURCE FOR <EST> in de_DE is updated\r
 322                 if (!strFullDate.endsWith("GMT-05:00"))\r
 323                     errln("Fail: Want GMT-05:00");\r
 324             } else {\r
 325                 logln("*** TEST COULD NOT BE COMPLETED BECAUSE DateFormatZoneData ***");\r
 326                 logln("*** FOR LOCALE de OR de_DE IS MISSING ***");\r
 327             }*/\r
 328         } catch (Exception e) {\r
 329             logln(e.getMessage());\r
 330         } finally {\r
 331             Locale.setDefault(saveLocale);\r
 332             TimeZone.setDefault(saveZone);\r
 333         }\r
 334     \r
 335     }\r
 336     \r
 337     /*\r
 338       DateFormat.equals is too narrowly defined.  As a result, MessageFormat\r
 339       does not work correctly.  DateFormat.equals needs to be written so\r
 340       that the Calendar sub-object is not compared using Calendar.equals,\r
 341       but rather compared for equivalency.  This may necessitate adding a\r
 342       (package private) method to Calendar to test for equivalency.\r
 343       \r
 344       Currently this bug breaks MessageFormat.toPattern\r
 345       */\r
 346     /**\r
 347      * @bug 4071441\r
 348      */\r
 349     public void Test4071441() {\r
 350         DateFormat fmtA = DateFormat.getInstance();\r
 351         DateFormat fmtB = DateFormat.getInstance();\r
 352     \r
 353         // {sfb} Is it OK to cast away const here?\r
 354         Calendar calA = fmtA.getCalendar();\r
 355         Calendar calB = fmtB.getCalendar();\r
 356         calA.clear();\r
 357         calA.set(1900, 0 ,0);\r
 358         calB.clear();\r
 359         calB.set(1900, 0, 0);\r
 360         if (!calA.equals(calB))\r
 361             errln("Fail: Can't complete test; Calendar instances unequal");\r
 362         if (!fmtA.equals(fmtB))\r
 363             errln("Fail: DateFormat unequal when Calendars equal");\r
 364         calB.clear();\r
 365         calB.set(1961, Calendar.DECEMBER, 25);\r
 366         if (calA.equals(calB))\r
 367             errln("Fail: Can't complete test; Calendar instances equal");\r
 368         if (!fmtA.equals(fmtB))\r
 369             errln("Fail: DateFormat unequal when Calendars equivalent");\r
 370         logln("DateFormat.equals ok");\r
 371     }\r
 372         \r
 373     /* The java.text.DateFormat.parse(String) method expects for the\r
 374       US locale a string formatted according to mm/dd/yy and parses it\r
 375       correctly.\r
 376     \r
 377       When given a string mm/dd/yyyy it only parses up to the first\r
 378       two y's, typically resulting in a date in the year 1919.\r
 379       \r
 380       Please extend the parsing method(s) to handle strings with\r
 381       four-digit year values (probably also applicable to various\r
 382       other locales.  */\r
 383     /**\r
 384      * @bug 4073003\r
 385      */\r
 386     public void Test4073003() {\r
 387         try {\r
 388             DateFormat fmt = DateFormat.getDateInstance(DateFormat.SHORT, Locale.US);\r
 389             String tests[] = {"12/25/61", "12/25/1961", "4/3/2010", "4/3/10"};\r
 390             for (int i = 0; i < 4; i += 2) {\r
 391                 Date d = fmt.parse(tests[i]);\r
 392                 Date dd = fmt.parse(tests[i + 1]);\r
 393                 String s;\r
 394                 s = fmt.format(d);\r
 395                 String ss;\r
 396                 ss = fmt.format(dd);\r
 397                 if (d.getTime() != dd.getTime())\r
 398                     errln("Fail: " + d + " != " + dd);\r
 399                 if (!s.equals(ss))\r
 400                     errln("Fail: " + s + " != " + ss);\r
 401                 logln("Ok: " + s + " " + d);\r
 402             }\r
 403         } catch (ParseException e) {\r
 404             errln("Fail: " + e);\r
 405             e.printStackTrace();\r
 406         }    \r
 407     }\r
 408     \r
 409     /**\r
 410      * @bug 4089106\r
 411      */\r
 412     public void Test4089106() {\r
 413         TimeZone def = TimeZone.getDefault();\r
 414         try {\r
 415             TimeZone z = new SimpleTimeZone((int) (1.25 * 3600000), "FAKEZONE");\r
 416             TimeZone.setDefault(z);\r
 417             SimpleDateFormat f = new SimpleDateFormat();\r
 418             if (!f.getTimeZone().equals(z))\r
 419                 errln("Fail: SimpleTimeZone should use TimeZone.getDefault()");\r
 420         } finally {\r
 421             TimeZone.setDefault(def);\r
 422         }\r
 423     }\r
 424     \r
 425     /**\r
 426      * @bug 4100302\r
 427      */\r
 428     public void Test4100302() {\r
 429         \r
 430         Locale locales[] = {\r
 431             Locale.CANADA, Locale.CANADA_FRENCH, Locale.CHINA, \r
 432             Locale.CHINESE, Locale.ENGLISH, Locale.FRANCE, Locale.FRENCH, \r
 433             Locale.GERMAN, Locale.GERMANY, Locale.ITALIAN, Locale.ITALY, \r
 434             Locale.JAPAN, Locale.JAPANESE, Locale.KOREA, Locale.KOREAN, \r
 435             Locale.PRC, Locale.SIMPLIFIED_CHINESE, Locale.TAIWAN, \r
 436             Locale.TRADITIONAL_CHINESE, Locale.UK, Locale.US}; \r
 437         try {\r
 438             boolean pass = true;\r
 439             for (int i = 0; i < 21; i++) {\r
 440                 Format format = DateFormat.getDateTimeInstance(DateFormat.FULL, DateFormat.FULL, locales[i]); \r
 441                 byte[] bytes;\r
 442                 ByteArrayOutputStream baos = new ByteArrayOutputStream();\r
 443                 ObjectOutputStream oos = new ObjectOutputStream(baos);\r
 444                 oos.writeObject(format);\r
 445                 oos.flush();\r
 446                 baos.close();\r
 447                 bytes = baos.toByteArray();\r
 448                 ObjectInputStream ois = new ObjectInputStream(new ByteArrayInputStream(bytes));\r
 449                 Object o = ois.readObject();\r
 450                 if (!format.equals(o)) {\r
 451                     pass = false;\r
 452                     logln("DateFormat instance for locale " + locales[i] + " is incorrectly serialized/deserialized."); \r
 453                 } else {\r
 454                     logln("DateFormat instance for locale " + locales[i] + " is OKAY.");\r
 455                 }\r
 456             }\r
 457             if (!pass)\r
 458                 errln("Fail: DateFormat serialization/equality bug");\r
 459         } catch (OptionalDataException e) {\r
 460             errln("Fail: " + e);\r
 461         } catch (IOException e) {\r
 462             errln("Fail: " + e);\r
 463         } catch (ClassNotFoundException e) {\r
 464             errln("Fail: " + e);\r
 465         }\r
 466     \r
 467     }\r
 468     \r
 469     /**\r
 470      * @bug 4101483\r
 471      */\r
 472     public void Test4101483() {\r
 473         SimpleDateFormat sdf = new SimpleDateFormat("z", Locale.US);\r
 474         FieldPosition fp = new FieldPosition(DateFormat.TIMEZONE_FIELD);\r
 475         Date d = new Date(9234567890L);\r
 476         StringBuffer buf = new StringBuffer("");\r
 477         sdf.format(d, buf, fp);\r
 478         logln(sdf.format(d, buf, fp).toString());\r
 479         logln("beginIndex = " + fp.getBeginIndex());\r
 480         logln("endIndex = " + fp.getEndIndex());\r
 481         if (fp.getBeginIndex() == fp.getEndIndex())\r
 482             errln("Fail: Empty field");\r
 483     }\r
 484     \r
 485     /**\r
 486      * @bug 4103340\r
 487      * @bug 4138203\r
 488      * This bug really only works in Locale.US, since that's what the locale\r
 489      * used for Date.toString() is.  Bug 4138203 reports that it fails on Korean\r
 490      * NT; it would actually have failed on any non-US locale.  Now it should\r
 491      * work on all locales.\r
 492      */\r
 493     public void Test4103340() {\r
 494     \r
 495         // choose a date that is the FIRST of some month \r
 496         // and some arbitrary time\r
 497         Calendar cal = Calendar.getInstance();\r
 498         cal.clear();\r
 499         cal.set(1997, 3, 1, 1, 1, 1);\r
 500         Date d = cal.getTime(); \r
 501         SimpleDateFormat df = new SimpleDateFormat("MMMM", Locale.US);\r
 502         String s = d.toString();\r
 503         StringBuffer s2 = new StringBuffer("");\r
 504         FieldPosition pos = new FieldPosition(0);\r
 505         s2 = df.format(d, s2, pos);\r
 506         logln("Date=" + s); \r
 507         logln("DF=" + s2);\r
 508         String substr = s2.substring(0,2);\r
 509         if (s.indexOf(substr) == -1)\r
 510           errln("Months should match");\r
 511     }\r
 512     \r
 513     /**\r
 514      * @bug 4103341\r
 515      */\r
 516     public void Test4103341() {\r
 517         TimeZone saveZone = TimeZone.getDefault();\r
 518         try {\r
 519             // {sfb} changed from adoptDefault to setDefault\r
 520             TimeZone.setDefault(TimeZone.getTimeZone("CST"));\r
 521             SimpleDateFormat simple = new SimpleDateFormat("MM/dd/yyyy HH:mm");\r
 522             TimeZone temp = TimeZone.getDefault();\r
 523             if (!simple.getTimeZone().equals(temp))\r
 524                 errln("Fail: SimpleDateFormat not using default zone");\r
 525         } finally {\r
 526             TimeZone.setDefault(saveZone);\r
 527         }\r
 528     }\r
 529     \r
 530     /**\r
 531      * @bug 4104136\r
 532      */\r
 533     public void Test4104136() {\r
 534         SimpleDateFormat sdf = new SimpleDateFormat();\r
 535         String pattern = "'time' hh:mm";\r
 536         sdf.applyPattern(pattern);\r
 537         logln("pattern: \"" + pattern + "\"");\r
 538         String strings[] = {"time 10:30", "time 10:x", "time 10x"};\r
 539         ParsePosition ppos[] = {new ParsePosition(10), new ParsePosition(0), new ParsePosition(0)};\r
 540         Calendar cal = Calendar.getInstance();\r
 541         cal.clear();\r
 542         cal.set(1970, Calendar.JANUARY, 1, 10, 30);\r
 543         Date dates[] = {cal.getTime(), new Date(-1), new Date(-1)};\r
 544         for (int i = 0; i < 3; i++) {\r
 545             String text = strings[i];\r
 546             ParsePosition finish = ppos[i];\r
 547             Date exp = dates[i];\r
 548             ParsePosition pos = new ParsePosition(0);\r
 549             Date d = sdf.parse(text, pos);\r
 550             logln(" text: \"" + text + "\"");\r
 551             logln(" index: %d" + pos.getIndex());\r
 552             logln(" result: " + d);\r
 553             if (pos.getIndex() != finish.getIndex())\r
 554                 errln("Fail: Expected pos " + finish.getIndex());\r
 555             if (!((d == null && exp.equals(new Date(-1))) || (d.equals(exp))))\r
 556                 errln( "Fail: Expected result " + exp);\r
 557         }\r
 558     }\r
 559     \r
 560     /**\r
 561      * @bug 4104522\r
 562      * CANNOT REPRODUCE\r
 563      * According to the bug report, this test should throw a\r
 564      * StringIndexOutOfBoundsException during the second parse.  However,\r
 565      * this is not seen.\r
 566      */\r
 567     public void Test4104522() {\r
 568         SimpleDateFormat sdf = new SimpleDateFormat();\r
 569         String pattern = "'time' hh:mm";\r
 570         sdf.applyPattern(pattern);\r
 571         logln("pattern: \"" + pattern + "\"");\r
 572         // works correctly\r
 573         ParsePosition pp = new ParsePosition(0);\r
 574         String text = "time ";\r
 575         Date dt = sdf.parse(text, pp);\r
 576         logln(" text: \"" + text + "\"" + " date: " + dt);\r
 577         // works wrong\r
 578         pp.setIndex(0);\r
 579         text = "time";\r
 580         dt = sdf.parse(text, pp);\r
 581         logln(" text: \"" + text + "\"" + " date: " + dt);    \r
 582     }\r
 583     \r
 584     /**\r
 585      * @bug 4106807\r
 586      */\r
 587     public void Test4106807() {\r
 588         Date dt;\r
 589         DateFormat df = DateFormat.getDateTimeInstance();\r
 590     \r
 591         SimpleDateFormat sdfs[] = {\r
 592                 new SimpleDateFormat("yyyyMMddHHmmss"), \r
 593                 new SimpleDateFormat("yyyyMMddHHmmss'Z'"), \r
 594                 new SimpleDateFormat("yyyyMMddHHmmss''"), \r
 595                 new SimpleDateFormat("yyyyMMddHHmmss'a''a'"), \r
 596                 new SimpleDateFormat("yyyyMMddHHmmss %")}; \r
 597         String strings[] = {\r
 598                 "19980211140000", \r
 599                 "19980211140000", \r
 600                 "19980211140000", \r
 601                 "19980211140000a", \r
 602                 "19980211140000 "}; \r
 603         GregorianCalendar gc = new GregorianCalendar();\r
 604         TimeZone timeZone = TimeZone.getDefault();\r
 605         TimeZone gmt = (TimeZone) timeZone.clone();\r
 606         gmt.setRawOffset(0);\r
 607         for (int i = 0; i < 5; i++) {\r
 608             SimpleDateFormat format = sdfs[i];\r
 609             String dateString = strings[i];\r
 610             try {\r
 611                 format.setTimeZone(gmt);\r
 612                 dt = format.parse(dateString);\r
 613                 // {sfb} some of these parses will fail purposely\r
 614     \r
 615                 StringBuffer fmtd = new StringBuffer("");\r
 616                 FieldPosition pos = new FieldPosition(0);\r
 617                 fmtd = df.format(dt, fmtd, pos);\r
 618                 logln(fmtd.toString());\r
 619                 //logln(df.format(dt)); \r
 620                 gc.setTime(dt);\r
 621                 logln("" + gc.get(Calendar.ZONE_OFFSET));\r
 622                 StringBuffer s = new StringBuffer("");\r
 623                 s = format.format(dt, s, pos);\r
 624                 logln(s.toString());\r
 625             } catch (ParseException e) {\r
 626                 logln("No way Jose");\r
 627             }\r
 628         }\r
 629     }\r
 630     \r
 631     /*\r
 632       Synopsis: Chinese time zone CTT is not recogonized correctly.\r
 633       Description: Platform Chinese Windows 95 - ** Time zone set to CST ** \r
 634       */\r
 635     /**\r
 636      * @bug 4108407\r
 637      */\r
 638     \r
 639     // {sfb} what to do with this one ?? \r
 640     public void Test4108407() {\r
 641         /*\r
 642     // TODO user.timezone is a protected system property, catch securityexception and warn\r
 643     // if this is reenabled\r
 644         long l = System.currentTimeMillis(); \r
 645         logln("user.timezone = " + System.getProperty("user.timezone", "?"));\r
 646         logln("Time Zone :" + \r
 647                            DateFormat.getDateInstance().getTimeZone().getID()); \r
 648         logln("Default format :" + \r
 649                            DateFormat.getDateInstance().format(new Date(l))); \r
 650         logln("Full format :" + \r
 651                            DateFormat.getDateInstance(DateFormat.FULL).format(new \r
 652                                                                               Date(l))); \r
 653         logln("*** Set host TZ to CST ***");\r
 654         logln("*** THE RESULTS OF THIS TEST MUST BE VERIFIED MANUALLY ***");\r
 655         */\r
 656     }\r
 657     \r
 658     /**\r
 659      * @bug 4134203\r
 660      * SimpleDateFormat won't parse "GMT"\r
 661      */\r
 662     public void Test4134203() {\r
 663         String dateFormat = "MM/dd/yy HH:mm:ss zzz";\r
 664         SimpleDateFormat fmt = new SimpleDateFormat(dateFormat);\r
 665     \r
 666         ParsePosition p0 = new ParsePosition(0);\r
 667         Date d = fmt.parse("01/22/92 04:52:00 GMT", p0);\r
 668         logln(d.toString());\r
 669         if(p0.equals(new ParsePosition(0)))\r
 670             errln("Fail: failed to parse 'GMT'");\r
 671         // In the failure case an exception is thrown by parse();\r
 672         // if no exception is thrown, the test passes.\r
 673     }\r
 674     \r
 675     /**\r
 676      * @bug 4151631\r
 677      * SimpleDateFormat incorrect handling of 2 single quotes in format()\r
 678      */\r
 679     public void Test4151631() {\r
 680         String pattern = \r
 681             "'TO_DATE('''dd'-'MM'-'yyyy HH:mm:ss''' , ''DD-MM-YYYY HH:MI:SS'')'"; \r
 682         logln("pattern=" + pattern);\r
 683         SimpleDateFormat format = new SimpleDateFormat(pattern, Locale.US);\r
 684         StringBuffer result = new StringBuffer("");\r
 685         FieldPosition pos = new FieldPosition(0);\r
 686         Calendar cal = Calendar.getInstance();\r
 687         cal.clear();\r
 688         cal.set(1998, Calendar.JUNE, 30, 13, 30, 0);\r
 689         Date d = cal.getTime();\r
 690         result = format.format(d, result, pos); \r
 691         if (!result.toString().equals("TO_DATE('30-06-1998 13:30:00' , 'DD-MM-YYYY HH:MI:SS')")) {\r
 692             errln("Fail: result=" + result);\r
 693         } else {\r
 694             logln("Pass: result=" + result);\r
 695         }\r
 696     }\r
 697     \r
 698     /**\r
 699      * @bug 4151706\r
 700      * 'z' at end of date format throws index exception in SimpleDateFormat\r
 701      * CANNOT REPRODUCE THIS BUG ON 1.2FCS\r
 702      */\r
 703     public void Test4151706() {\r
 704         String dateString = "Thursday, 31-Dec-98 23:00:00 GMT";\r
 705         SimpleDateFormat fmt = new SimpleDateFormat("EEEE, dd-MMM-yy HH:mm:ss z", Locale.US);\r
 706         Calendar cal = Calendar.getInstance(TimeZone.getTimeZone("UTC"), Locale.US);\r
 707         cal.clear();\r
 708         cal.set(1998, Calendar.DECEMBER, 31, 23, 0, 0);\r
 709         Date d = new Date();\r
 710         try {\r
 711             d = fmt.parse(dateString);\r
 712             // {sfb} what about next two lines?\r
 713             if (d.getTime() != cal.getTime().getTime())\r
 714                 errln("Incorrect value: " + d);\r
 715         } catch (Exception e) {\r
 716             errln("Fail: " + e);\r
 717         }\r
 718         StringBuffer temp = new StringBuffer("");\r
 719         FieldPosition pos = new FieldPosition(0);\r
 720         logln(dateString + " . " + fmt.format(d, temp, pos));\r
 721     }\r
 722     \r
 723     /**\r
 724      * @bug 4162071\r
 725      * Cannot reproduce this bug under 1.2 FCS -- it may be a convoluted duplicate\r
 726      * of some other bug that has been fixed.\r
 727      */\r
 728     public void Test4162071() {\r
 729         String dateString = "Thu, 30-Jul-1999 11:51:14 GMT";\r
 730         String format = "EEE', 'dd-MMM-yyyy HH:mm:ss z"; // RFC 822/1123\r
 731         SimpleDateFormat df = new SimpleDateFormat(format, Locale.US);\r
 732         try {\r
 733             Date x = df.parse(dateString);\r
 734             StringBuffer temp = new StringBuffer("");\r
 735             FieldPosition pos = new FieldPosition(0);\r
 736             logln(dateString + " -> " + df.format(x, temp, pos));\r
 737         } catch (Exception e) {\r
 738             errln("Parse format \"" + format + "\" failed.");\r
 739         }\r
 740     }\r
 741     \r
 742     /**\r
 743      * DateFormat shouldn't parse year "-1" as a two-digit year (e.g., "-1" . 1999).\r
 744      */\r
 745     public void Test4182066() {\r
 746         SimpleDateFormat fmt = new SimpleDateFormat("MM/dd/yy", Locale.US);\r
 747         SimpleDateFormat dispFmt = new SimpleDateFormat("MMM dd yyyy HH:mm:ss GG", Locale.US);\r
 748         /* We expect 2-digit year formats to put 2-digit years in the right\r
 749          * window.  Out of range years, that is, anything less than "00" or\r
 750          * greater than "99", are treated as literal years.  So "1/2/3456"\r
 751          * becomes 3456 AD.  Likewise, "1/2/-3" becomes -3 AD == 2 BC.\r
 752          */\r
 753         final String STRINGS[] = \r
 754             {"02/29/00", "01/23/01", "04/05/-1", "01/23/-9", "11/12/1314", "10/31/1", "09/12/+1", "09/12/001",}; \r
 755         int STRINGS_COUNT = STRINGS.length;\r
 756                 \r
 757         Calendar cal = Calendar.getInstance();\r
 758         Date FAIL_DATE = cal.getTime();\r
 759         cal.clear();\r
 760         cal.set(2000, Calendar.FEBRUARY, 29);\r
 761         Date d0 = cal.getTime();\r
 762         cal.clear();\r
 763         cal.set(2001, Calendar.JANUARY, 23);\r
 764         Date d1 = cal.getTime();\r
 765         cal.clear();\r
 766         cal.set(-1, Calendar.APRIL, 5);\r
 767         Date d2 = cal.getTime();\r
 768         cal.clear();\r
 769         cal.set(-9, Calendar.JANUARY, 23);\r
 770         Date d3 = cal.getTime();\r
 771         cal.clear();\r
 772         cal.set(1314, Calendar.NOVEMBER, 12);\r
 773         Date d4 = cal.getTime();\r
 774         cal.clear();\r
 775         cal.set(1, Calendar.OCTOBER, 31);\r
 776         Date d5 = cal.getTime();\r
 777         cal.clear();        \r
 778         cal.set(1, Calendar.SEPTEMBER, 12);\r
 779         Date d7 = cal.getTime();\r
 780         Date DATES[] = {d0, d1, d2, d3, d4, d5, FAIL_DATE, d7};\r
 781     \r
 782         String out = "";\r
 783         boolean pass = true;\r
 784         for (int i = 0; i < STRINGS_COUNT; ++i) {\r
 785             String str = STRINGS[i];\r
 786             Date expected = DATES[i];            \r
 787             Date actual = null;\r
 788             try {\r
 789                 actual = fmt.parse(str);\r
 790             } catch (ParseException e) {\r
 791                 actual = FAIL_DATE;\r
 792             }\r
 793             String actStr = "";\r
 794             if ((actual.getTime()) == FAIL_DATE.getTime()) {\r
 795                 actStr += "null";\r
 796             } else {\r
 797                 // Yuck: See j25\r
 798                 actStr = ((DateFormat) dispFmt).format(actual);\r
 799             }\r
 800                                \r
 801             if (expected.getTime() == (actual.getTime())) {\r
 802                 out += str + " => " + actStr + "\n";\r
 803             } else {\r
 804                 String expStr = "";\r
 805                 if (expected.getTime() == FAIL_DATE.getTime()) {\r
 806                     expStr += "null";\r
 807                 } else {\r
 808                     // Yuck: See j25\r
 809                     expStr = ((DateFormat) dispFmt).format(expected);\r
 810                 }\r
 811                 out += "FAIL: " + str + " => " + actStr + ", expected " + expStr + "\n";\r
 812                 pass = false;\r
 813             }\r
 814         }\r
 815         if (pass) {\r
 816             log(out);\r
 817         } else {\r
 818             err(out);\r
 819         }\r
 820     }\r
 821     \r
 822     /**\r
 823      * j32 {JDK Bug 4210209 4209272}\r
 824      * DateFormat cannot parse Feb 29 2000 when setLenient(false)\r
 825      */\r
 826     public void Test4210209() {\r
 827     \r
 828         String pattern = "MMM d, yyyy";\r
 829         DateFormat fmt = new SimpleDateFormat(pattern, Locale.US);\r
 830         DateFormat disp = new SimpleDateFormat("MMM dd yyyy GG", Locale.US);\r
 831     \r
 832         Calendar calx = fmt.getCalendar();\r
 833         calx.setLenient(false);\r
 834         Calendar calendar = Calendar.getInstance();\r
 835         calendar.clear();\r
 836         calendar.set(2000, Calendar.FEBRUARY, 29);\r
 837         Date d = calendar.getTime();\r
 838         String s = fmt.format(d);\r
 839         logln(disp.format(d) + " f> " + pattern + " => \"" + s + "\"");\r
 840         ParsePosition pos = new ParsePosition(0);\r
 841         d = fmt.parse(s, pos);\r
 842         logln("\"" + s + "\" p> " + pattern + " => " +\r
 843               (d!=null?disp.format(d):"null"));\r
 844         logln("Parse pos = " + pos.getIndex() + ", error pos = " + pos.getErrorIndex());\r
 845         if (pos.getErrorIndex() != -1) {\r
 846             errln("FAIL: Error index should be -1");\r
 847         }\r
 848     \r
 849         // The underlying bug is in GregorianCalendar.  If the following lines\r
 850         // succeed, the bug is fixed.  If the bug isn't fixed, they will throw\r
 851         // an exception.\r
 852         GregorianCalendar cal = new GregorianCalendar();\r
 853         cal.clear();\r
 854         cal.setLenient(false);\r
 855         cal.set(2000, Calendar.FEBRUARY, 29); // This should work!\r
 856         d = cal.getTime();\r
 857         logln("Attempt to set Calendar to Feb 29 2000: " + disp.format(d));\r
 858     }\r
 859     \r
 860     public void Test714() {\r
 861         //TimeZone Offset\r
 862         TimeZone defaultTZ = TimeZone.getDefault();\r
 863         TimeZone PST = TimeZone.getTimeZone("PST");\r
 864         int defaultOffset = defaultTZ.getRawOffset();\r
 865         int PSTOffset = PST.getRawOffset();\r
 866         Date d = new Date(978103543000l - (defaultOffset - PSTOffset));\r
 867         d = new Date(d.getTime() - (defaultTZ.inDaylightTime(d) ? 3600000 : 0));\r
 868         DateFormat fmt = DateFormat.getDateTimeInstance(-1, DateFormat.MEDIUM, Locale.US);\r
 869         String tests = "7:25:43 AM";\r
 870         String s = fmt.format(d);\r
 871         if (!s.equals(tests)) {\r
 872             errln("Fail: " + s + " != " + tests);\r
 873         } else {\r
 874             logln("OK: " + s + " == " + tests);\r
 875         }\r
 876     }\r
 877 \r
 878     public void Test_GEec() {\r
 879         class PatternAndResult {\r
 880             private String pattern;\r
 881             private String result;\r
 882             PatternAndResult(String pat, String res) {\r
 883                 pattern = pat;\r
 884                 result = res;\r
 885             }\r
 886             public String getPattern()  { return pattern; }\r
 887             public String getResult()  { return result; }\r
 888         }\r
 889         final PatternAndResult[] tests = {\r
 890             new PatternAndResult( "dd MMM yyyy GGG",   "02 Jul 2008 AD" ),\r
 891             new PatternAndResult( "dd MMM yyyy GGGGG", "02 Jul 2008 A" ),\r
 892             new PatternAndResult( "e dd MMM yyyy",     "3 02 Jul 2008" ),\r
 893             new PatternAndResult( "ee dd MMM yyyy",    "03 02 Jul 2008" ),\r
 894             new PatternAndResult( "c dd MMM yyyy",     "3 02 Jul 2008" ),\r
 895             new PatternAndResult( "cc dd MMM yyyy",    "3 02 Jul 2008" ),\r
 896             new PatternAndResult( "eee dd MMM yyyy",   "Wed 02 Jul 2008" ),\r
 897             new PatternAndResult( "EEE dd MMM yyyy",   "Wed 02 Jul 2008" ),\r
 898             new PatternAndResult( "EE dd MMM yyyy",    "Wed 02 Jul 2008" ),\r
 899             new PatternAndResult( "eeee dd MMM yyyy",  "Wednesday 02 Jul 2008" ),\r
 900             new PatternAndResult( "eeeee dd MMM yyyy", "W 02 Jul 2008" ),\r
 901             new PatternAndResult( "e ww YYYY",         "3 27 2008" ),\r
 902             new PatternAndResult( "c ww YYYY",         "3 27 2008" ),\r
 903         };\r
 904         ULocale loc = ULocale.ENGLISH;\r
 905         TimeZone tz = TimeZone.getTimeZone("America/Los_Angeles");\r
 906         Calendar cal = new GregorianCalendar(tz, loc);\r
 907         SimpleDateFormat dateFormat = new SimpleDateFormat("yyyy-MMM-dd", loc);\r
 908         for ( int i = 0; i < tests.length; i++ ) {\r
 909             PatternAndResult item = tests[i];\r
 910             dateFormat.applyPattern( item.getPattern() );\r
 911             cal.set(2008, 6, 2, 5, 0); // 2008 July 02 5 AM PDT\r
 912             StringBuffer buf = new StringBuffer(32);\r
 913             FieldPosition fp = new FieldPosition(DateFormat.YEAR_FIELD);\r
 914             dateFormat.format(cal, buf, fp);\r
 915             if ( buf.toString().compareTo(item.getResult()) != 0 ) {\r
 916                 errln("for pattern " + item.getPattern() + ", expected " + item.getResult() + ", got " + buf );\r
 917             }\r
 918             ParsePosition pos = new ParsePosition(0);\r
 919             dateFormat.parse( item.getResult(), cal, pos);\r
 920             int year = cal.get(Calendar.YEAR);\r
 921             int month = cal.get(Calendar.MONTH);\r
 922             int day = cal.get(Calendar.DATE);\r
 923             if ( year != 2008 || month != 6 || day != 2 ) {\r
 924                 errln("use pattern " + item.getPattern() + " to parse " + item.getResult() +\r
 925                         ", expected y2008 m6 d2, got " + year + " " + month + " " + day );\r
 926             }\r
 927         }\r
 928     }\r
 929 \r
 930     static final char kArabicZero = 0x0660;\r
 931     static final char kHindiZero  = 0x0966;\r
 932     static final char kLatinZero  = 0x0030;\r
 933 \r
 934     public void TestHindiArabicDigits()\r
 935     {\r
 936         String s;\r
 937         char first;\r
 938         String what;\r
 939 \r
 940         {\r
 941             DateFormat df = DateFormat.getInstance(new GregorianCalendar(), new Locale("hi","IN"));\r
 942             what = "Gregorian Calendar, hindi";\r
 943             s = df.format(new Date(0)); /* 31/12/1969 */\r
 944             logln(what + "=" + s);\r
 945             first = s.charAt(0);\r
 946             if(first<kHindiZero || first>(kHindiZero+9)) {\r
 947                 errln(what + "- wrong digit,  got " + s + " (integer digit value " + new Integer((int)first).toString());\r
 948             }\r
 949         }\r
 950 \r
 951         {\r
 952             DateFormat df = DateFormat.getInstance(new IslamicCalendar(), new Locale("ar","IQ"));\r
 953             s = df.format(new Date(0)); /* 21/10/1989 */\r
 954             what = "Islamic Calendar, Arabic";\r
 955             logln(what + ": " + s);\r
 956             first = s.charAt(0);\r
 957             if(first<kArabicZero || first>(kArabicZero+9)) {\r
 958                 errln(what + " wrong digit, got " + s + " (integer digit value " + new Integer((int)first).toString());\r
 959             }\r
 960         }\r
 961 \r
 962         {\r
 963             DateFormat df = DateFormat.getInstance(new GregorianCalendar(), new Locale("ar","IQ"));\r
 964             s = df.format(new Date(0)); /* 31/12/1969 */\r
 965             what = "Gregorian,  ar_IQ, df.getInstance";\r
 966             logln(what + ": " + s);\r
 967             first = s.charAt(0);\r
 968             if(first<kArabicZero || first>(kArabicZero+9)) {\r
 969                 errln(what + " wrong  digit but got " + s + " (integer digit value " + new Integer((int)first).toString());\r
 970             }\r
 971         }\r
 972         {\r
 973             DateFormat df = DateFormat.getInstance(new GregorianCalendar(), new Locale("mt","MT"));\r
 974             s = df.format(new Date(0)); /* 31/12/1969 */\r
 975             what = "Gregorian,  mt_MT, df.getInstance";\r
 976             logln(what + ": " + s);\r
 977             first = s.charAt(0);\r
 978             if(first<kLatinZero || first>(kLatinZero+9)) {\r
 979                 errln(what + " wrong  digit but got " + s + " (integer digit value " + new Integer((int)first).toString());\r
 980             }\r
 981         }\r
 982 \r
 983         {\r
 984             DateFormat df = DateFormat.getInstance(new IslamicCalendar(), new Locale("ar","IQ"));\r
 985             s = df.format(new Date(0)); /* 31/12/1969 */\r
 986             what = "Islamic calendar, ar_IQ, df.getInstance";\r
 987             logln(what+ ": " + s);\r
 988             first = s.charAt(0);\r
 989             if(first<kArabicZero || first>(kArabicZero+9)) {\r
 990                 errln(what + " wrong  digit but got " + s + " (integer digit value " + new Integer((int)first).toString());\r
 991             }\r
 992         }\r
 993 \r
 994         {\r
 995             DateFormat df = DateFormat.getDateTimeInstance(DateFormat.SHORT, DateFormat.SHORT, new Locale("ar","IQ"));\r
 996             s = df.format(new Date(0)); /* 31/12/1969 */\r
 997             what = "ar_IQ, getDateTimeInstance";\r
 998             logln(what+ ": " + s);\r
 999             first = s.charAt(0);\r
1000             if(first<kArabicZero || first>(kArabicZero+9)) {\r
1001                 errln(what + " wrong  digit but got " + s + " (integer digit value " + new Integer((int)first).toString());\r
1002             }\r
1003         }\r
1004 \r
1005         {\r
1006             DateFormat df = DateFormat.getInstance(new JapaneseCalendar(), new Locale("ar","IQ"));\r
1007             s = df.format(new Date(0)); /* 31/12/1969 */\r
1008             what = "ar_IQ, Japanese Calendar, getInstance";\r
1009             logln(what+ ": " + s);\r
1010             // Note: The default date pattern for Japanese calendar starts with era in CLDR 1.7\r
1011             char last = s.charAt(s.length() - 1);\r
1012             if(last<kArabicZero || last>(kArabicZero+9)) {\r
1013                 errln(what + " wrong  digit but got " + s + " (integer digit value " + new Integer((int)last).toString());\r
1014             }\r
1015         }\r
1016     }\r
1017 \r
1018     // Ticket#5683\r
1019     // Some ICU4J 3.6 data files contain garbage data which prevent the code to resolve another\r
1020     // bundle as an alias.  zh_TW should be equivalent to zh_Hant_TW\r
1021     public void TestT5683() {\r
1022         Locale[] aliasLocales = {\r
1023             new Locale("zh", "CN"),\r
1024             new Locale("zh", "TW"),\r
1025             new Locale("zh", "HK"),\r
1026             new Locale("zh", "SG"),\r
1027             new Locale("zh", "MO")\r
1028         };\r
1029 \r
1030         ULocale[] canonicalLocales = {\r
1031             new ULocale("zh_Hans_CN"),\r
1032             new ULocale("zh_Hant_TW"),\r
1033             new ULocale("zh_Hant_HK"),\r
1034             new ULocale("zh_Hans_SG"),\r
1035             new ULocale("zh_Hant_MO")\r
1036         };\r
1037 \r
1038         Date d = new Date(0);\r
1039 \r
1040         for (int i = 0; i < aliasLocales.length; i++) {\r
1041             DateFormat dfAlias = DateFormat.getDateTimeInstance(DateFormat.FULL, DateFormat.FULL, aliasLocales[i]);\r
1042             DateFormat dfCanonical = DateFormat.getDateTimeInstance(DateFormat.FULL, DateFormat.FULL, canonicalLocales[i]);\r
1043 \r
1044             String sAlias = dfAlias.format(d);\r
1045             String sCanonical = dfCanonical.format(d);\r
1046 \r
1047             if (!sAlias.equals(sCanonical)) {\r
1048                 errln("Fail: The format result for locale " + aliasLocales[i] + " is different from the result for locale " + canonicalLocales[i]\r
1049                         + ": " + sAlias + "[" + aliasLocales[i] + "] / " + sCanonical + "[" + canonicalLocales[i] + "]");\r
1050             }\r
1051         }\r
1052     }\r
1053     \r
1054     \r
1055     public void Test5006GetShortMonths() throws Exception {\r
1056 \r
1057         // Currently supported NLV locales\r
1058         Locale ENGLISH = new Locale("en", "US"); // We don't support 'en' alone\r
1059         Locale ARABIC = new Locale("ar", "");\r
1060         Locale CZECH = new Locale("cs", "");\r
1061         Locale GERMAN = new Locale("de", "");\r
1062         Locale GREEK = new Locale("el", "");\r
1063         Locale SPANISH = new Locale("es", "");\r
1064         Locale FRENCH = new Locale("fr", "");\r
1065         Locale HUNGARIAN = new Locale("hu", "");\r
1066         Locale ITALIAN = new Locale("it", "");\r
1067         Locale HEBREW = new Locale("iw", "");\r
1068         Locale JAPANESE = new Locale("ja", "");\r
1069         Locale KOREAN = new Locale("ko", "");\r
1070         Locale POLISH = new Locale("pl", "");\r
1071         Locale PORTUGUESE = new Locale("pt", "BR");\r
1072         Locale RUSSIAN = new Locale("ru", "");\r
1073         Locale TURKISH = new Locale("tr", "");\r
1074         Locale CHINESE_SIMPLIFIED = new Locale("zh", "CN");\r
1075         Locale CHINESE_TRADITIONAL = new Locale("zh", "TW");\r
1076 \r
1077         Locale[] locales = new Locale[] { ENGLISH, ARABIC, CZECH, GERMAN, GREEK, SPANISH, FRENCH,\r
1078                 HUNGARIAN, ITALIAN, HEBREW, JAPANESE, KOREAN, POLISH, PORTUGUESE, RUSSIAN, TURKISH,\r
1079                 CHINESE_SIMPLIFIED, CHINESE_TRADITIONAL };\r
1080 \r
1081         String[] islamicTwelfthMonthLocalized = new String[locales.length];\r
1082         String[] gregorianTwelfthMonthLocalized = new String[locales.length];\r
1083 \r
1084         for (int i = 0; i < locales.length; i++) {\r
1085 \r
1086             Locale locale = locales[i];\r
1087 \r
1088             // Islamic\r
1089             com.ibm.icu.util.Calendar islamicCalendar = new com.ibm.icu.util.IslamicCalendar(locale);\r
1090             com.ibm.icu.text.SimpleDateFormat islamicDateFormat = (com.ibm.icu.text.SimpleDateFormat) islamicCalendar\r
1091                     .getDateTimeFormat(com.ibm.icu.text.DateFormat.FULL, -1, locale);\r
1092             com.ibm.icu.text.DateFormatSymbols islamicDateFormatSymbols = islamicDateFormat\r
1093                     .getDateFormatSymbols();\r
1094 \r
1095             String[] shortMonths = islamicDateFormatSymbols.getShortMonths();\r
1096             String twelfthMonthLocalized = shortMonths[11];\r
1097 \r
1098             islamicTwelfthMonthLocalized[i] = twelfthMonthLocalized;\r
1099 \r
1100             // Gregorian\r
1101             com.ibm.icu.util.Calendar gregorianCalendar = new com.ibm.icu.util.GregorianCalendar(\r
1102                     locale);\r
1103             com.ibm.icu.text.SimpleDateFormat gregorianDateFormat = (com.ibm.icu.text.SimpleDateFormat) gregorianCalendar\r
1104                     .getDateTimeFormat(com.ibm.icu.text.DateFormat.FULL, -1, locale);\r
1105 \r
1106             com.ibm.icu.text.DateFormatSymbols gregorianDateFormatSymbols = gregorianDateFormat\r
1107                     .getDateFormatSymbols();\r
1108             shortMonths = gregorianDateFormatSymbols.getShortMonths();\r
1109             twelfthMonthLocalized = shortMonths[11];\r
1110 \r
1111             gregorianTwelfthMonthLocalized[i] = twelfthMonthLocalized;\r
1112 \r
1113         }\r
1114 \r
1115         // Compare\r
1116         for (int i = 0; i < locales.length; i++) {\r
1117 \r
1118             String gregorianTwelfthMonth = gregorianTwelfthMonthLocalized[i];\r
1119             String islamicTwelfthMonth = islamicTwelfthMonthLocalized[i];\r
1120 \r
1121             logln(locales[i] + ": " + gregorianTwelfthMonth + ", " + islamicTwelfthMonth);\r
1122             if (gregorianTwelfthMonth.equalsIgnoreCase(islamicTwelfthMonth)) {\r
1123                 errln(locales[i] + ": gregorian and islamic are same: " + gregorianTwelfthMonth\r
1124                         + ", " + islamicTwelfthMonth);\r
1125             }\r
1126         }\r
1127     }\r
1128 }\r