jars/icu4j-4_4_2-src/main/tests/core/src/com/ibm/icu/dev/test/format/DateFormatRegressionTest.java

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