1/*
2 *******************************************************************************
3 * Copyright (C) 2002-2010, International Business Machines Corporation and    *
4 * others. All Rights Reserved.                                                *
5 *******************************************************************************
6 */
7package com.ibm.icu.dev.test.calendar;
8
9import java.text.ParseException;
10import java.text.ParsePosition;
11import java.util.Date;
12import java.util.Locale;
13
14import com.ibm.icu.impl.LocaleUtility;
15import com.ibm.icu.text.DateFormat;
16import com.ibm.icu.text.SimpleDateFormat;
17import com.ibm.icu.util.Calendar;
18import com.ibm.icu.util.JapaneseCalendar;
19import com.ibm.icu.util.TimeZone;
20import com.ibm.icu.util.ULocale;
21
22/**
23 * Tests for the <code>JapaneseCalendar</code> class.
24 */
25public class JapaneseTest extends CalendarTest {
26    public static void main(String args[]) throws Exception {
27        new JapaneseTest().run(args);
28    }
29
30    public void TestCoverage() {
31    {
32        // new JapaneseCalendar(TimeZone)
33        JapaneseCalendar cal = new JapaneseCalendar(TimeZone.getDefault());
34        if(cal == null){
35            errln("could not create JapaneseCalendar with TimeZone");
36        }
37    }
38
39    {
40        // new JapaneseCalendar(ULocale)
41        JapaneseCalendar cal = new JapaneseCalendar(ULocale.getDefault());
42        if(cal == null){
43            errln("could not create JapaneseCalendar with ULocale");
44        }
45    }
46
47    {
48        // new JapaneseCalendar(TimeZone, ULocale)
49        JapaneseCalendar cal = new JapaneseCalendar(TimeZone.getDefault(), ULocale.getDefault());
50        if(cal == null){
51            errln("could not create JapaneseCalendar with TimeZone ULocale");
52        }
53    }
54
55    {
56        // new JapaneseCalendar(Locale)
57        JapaneseCalendar cal = new JapaneseCalendar(Locale.getDefault());
58        if(cal == null){
59            errln("could not create JapaneseCalendar with Locale");
60        }
61    }
62
63    {
64        // new JapaneseCalendar(TimeZone, Locale)
65        JapaneseCalendar cal = new JapaneseCalendar(TimeZone.getDefault(), Locale.getDefault());
66        if(cal == null){
67            errln("could not create JapaneseCalendar with TimeZone Locale");
68        }
69    }
70
71    {
72        // new JapaneseCalendar(Date)
73        JapaneseCalendar cal = new JapaneseCalendar(new Date());
74        if(cal == null){
75            errln("could not create JapaneseCalendar with Date");
76        }
77    }
78
79    {
80        // new JapaneseCalendar(int year, int month, int date)
81        JapaneseCalendar cal = new JapaneseCalendar(1868, Calendar.JANUARY, 1);
82        if(cal == null){
83            errln("could not create JapaneseCalendar with year,month,date");
84        }
85    }
86
87    {
88        // new JapaneseCalendar(int era, int year, int month, int date)
89        JapaneseCalendar cal = new JapaneseCalendar(JapaneseCalendar.MEIJI, 43, Calendar.JANUARY, 1);
90        if(cal == null){
91            errln("could not create JapaneseCalendar with era,year,month,date");
92        }
93    }
94
95    {
96        // new JapaneseCalendar(int year, int month, int date, int hour, int minute, int second)
97        JapaneseCalendar cal = new JapaneseCalendar(1868, Calendar.JANUARY, 1, 1, 1, 1);
98        if(cal == null){
99            errln("could not create JapaneseCalendar with year,month,date,hour,min,second");
100        }
101    }
102
103    {
104        // limits
105        JapaneseCalendar cal = new JapaneseCalendar();
106        DateFormat fmt = cal.getDateTimeFormat(DateFormat.FULL, DateFormat.FULL, Locale.ENGLISH);
107
108        cal.set(Calendar.ERA, JapaneseCalendar.MEIJI);
109        logln("date: " + cal.getTime());
110        logln("min era: " + cal.getMinimum(Calendar.ERA));
111        logln("min year: " + cal.getMinimum(Calendar.YEAR));
112        cal.set(Calendar.YEAR, cal.getActualMaximum(Calendar.YEAR));
113        logln("date: " + fmt.format(cal.getTime()));
114        cal.add(Calendar.YEAR, 1);
115        logln("date: " + fmt.format(cal.getTime()));
116    }
117
118    {
119        // data
120        JapaneseCalendar cal = new JapaneseCalendar(1868, Calendar.JANUARY, 1);
121        Date time = cal.getTime();
122
123        String[] calendarLocales = {
124        "en", "ja_JP"
125        };
126
127        String[] formatLocales = {
128        "en", "ja"
129        };
130        for (int i = 0; i < calendarLocales.length; ++i) {
131            String calLocName = calendarLocales[i];
132            Locale calLocale = LocaleUtility.getLocaleFromName(calLocName);
133            cal = new JapaneseCalendar(calLocale);
134
135            for (int j = 0; j < formatLocales.length; ++j) {
136                String locName = formatLocales[j];
137                Locale formatLocale = LocaleUtility.getLocaleFromName(locName);
138                DateFormat format = DateFormat.getDateTimeInstance(cal, DateFormat.FULL, DateFormat.FULL, formatLocale);
139                logln(calLocName + "/" + locName + " --> " + format.format(time));
140            }
141        }
142    }
143    }
144
145    public void Test3860()
146    {
147        ULocale loc = new ULocale("ja_JP@calendar=japanese");
148        Calendar cal = new JapaneseCalendar(loc);
149        DateFormat enjformat = cal.getDateTimeFormat(0,0,new ULocale("en_JP@calendar=japanese"));
150        DateFormat format = cal.getDateTimeFormat(0,0,loc);
151        ((SimpleDateFormat)format).applyPattern("y.M.d");  // Note: just 'y' doesn't work here.
152        ParsePosition pos = new ParsePosition(0);
153        Date aDate = format.parse("1.1.9", pos); // after the start of heisei accession.  Jan 1, 1H wouldn't work  because it is actually showa 64
154        String inEn = enjformat.format(aDate);
155
156        cal.clear();
157        cal.setTime(aDate);
158        int gotYear = cal.get(Calendar.YEAR);
159        int gotEra = cal.get(Calendar.ERA);
160
161        int expectYear = 1;
162        int expectEra = JapaneseCalendar.CURRENT_ERA;
163
164        if((gotYear != expectYear) || (gotEra != expectEra)) {
165            errln("Expected year " + expectYear + ", era " + expectEra +", but got year " + gotYear + " and era " + gotEra + ", == " + inEn);
166        } else {
167            logln("Got year " + gotYear + " and era " + gotEra + ", == " + inEn);
168        }
169
170        // Test parse with missing era (should default to current era, heisei)
171        // Test parse with incomplete information
172        logln("Testing parse w/ just year...");
173        Calendar cal2 = new JapaneseCalendar(loc);
174        SimpleDateFormat fmt = new SimpleDateFormat("y", loc);
175        SimpleDateFormat fmt2 = new SimpleDateFormat("HH:mm:ss.S MMMM d, yyyy G", new ULocale("en_US@calendar=gregorian"));
176        cal2.clear();
177        String samplestr = "1";
178        logln("Test Year: " + samplestr);
179        try {
180            aDate = fmt.parse(samplestr);
181        } catch (ParseException pe) {
182            errln("Error parsing " + samplestr);
183        }
184        ParsePosition pp = new ParsePosition(0);
185        fmt.parse(samplestr, cal2, pp);
186        logln("cal2 after 1 parse:");
187        String str = fmt2.format(aDate);
188        logln("as Gregorian Calendar: " + str);
189
190        cal2.setTime(aDate);
191        gotYear = cal2.get(Calendar.YEAR);
192        gotEra = cal2.get(Calendar.ERA);
193        expectYear = 1;
194        expectEra = JapaneseCalendar.CURRENT_ERA;
195        if((gotYear != 1) || (gotEra != expectEra)) {
196            errln("parse "+ samplestr + " of 'y' as Japanese Calendar, expected year " + expectYear +
197                " and era " + expectEra + ", but got year " + gotYear + " and era " + gotEra + " (Gregorian:" + str +")");
198        } else {
199            logln(" year: " + gotYear + ", era: " + gotEra);
200        }
201    }
202
203    public void Test5345parse() {
204        // Test parse with incomplete information
205        DateFormat fmt2= DateFormat.getDateInstance(); //DateFormat.LONG, Locale.US);
206        JapaneseCalendar c = new JapaneseCalendar(TimeZone.getDefault(), new ULocale("en_US"));
207        SimpleDateFormat fmt = (SimpleDateFormat)c.getDateTimeFormat(1,1,new ULocale("en_US@calendar=japanese"));
208        fmt.applyPattern("G y");
209        logln("fmt's locale = " + fmt.getLocale(ULocale.ACTUAL_LOCALE));
210        //SimpleDateFormat fmt = new SimpleDateFormat("G y", new Locale("en_US@calendar=japanese"));
211        long aDateLong = -3197117222000L; // 1868-09-08 00:00 Pacific Time (GMT-07:52:58)
212        if (TimeZone.getDefaultTimeZoneType() == TimeZone.TIMEZONE_JDK) {
213            // Java time zone implementation does not support LMTs
214            aDateLong = -3197116800000L; // 1868-09-08 00:00 Pacific Time (GMT-08:00)
215        }
216        Date aDate = new Date(aDateLong);
217        logln("aDate: " + aDate.toString() +", from " + aDateLong);
218        String str;
219        str = fmt2.format(aDate);
220        logln("Test Date: " + str);
221        str = fmt.format(aDate);
222        logln("as Japanese Calendar: " + str);
223        String expected = "Meiji 1";
224        if(!str.equals(expected)) {
225            errln("FAIL: Expected " + expected + " but got " + str);
226        }
227        Date otherDate;
228        try {
229            otherDate = fmt.parse(expected);
230            if(!otherDate.equals(aDate)) {
231                String str3;
232    //            ParsePosition pp;
233                Date dd = fmt.parse(expected);
234                str3 = fmt.format(otherDate);
235                long oLong = otherDate.getTime();
236                long aLong = otherDate.getTime();
237
238                errln("FAIL: Parse incorrect of " + expected + ":  wanted " + aDate + " ("+aLong+"), but got " +  " " +
239                    otherDate + " ("+oLong+") = " + str3 + " not " + dd.toString() );
240
241
242            } else {
243                logln("Parsed OK: " + expected);
244            }
245        } catch(java.text.ParseException pe) {
246            errln("FAIL: ParseException: " + pe.toString());
247            pe.printStackTrace();
248        }
249    }
250
251
252    private void checkExpected(Calendar c, int expected[] ) {
253        final String[] FIELD_NAME = {
254            "ERA", "YEAR", "MONTH", "WEEK_OF_YEAR", "WEEK_OF_MONTH",
255            "DAY_OF_MONTH", "DAY_OF_YEAR", "DAY_OF_WEEK",
256            "DAY_OF_WEEK_IN_MONTH", "AM_PM", "HOUR", "HOUR_OF_DAY",
257            "MINUTE", "SECOND", "MILLISECOND", "ZONE_OFFSET",
258            "DST_OFFSET", "YEAR_WOY", "DOW_LOCAL", "EXTENDED_YEAR",
259            "JULIAN_DAY", "MILLISECONDS_IN_DAY",
260        };
261
262        for(int i= 0;i<expected.length;i += 2) {
263            int fieldNum = expected[i+0];
264            int expectedVal = expected[i+1];
265            int actualVal = c.get(fieldNum);
266
267            if(expectedVal == actualVal) {
268                logln(FIELD_NAME[fieldNum]+": "+ actualVal);
269            } else {
270                errln("FAIL: "+FIELD_NAME[fieldNum]+": expected "+ expectedVal + " got " +  actualVal);
271            }
272        }
273    }
274
275    public void Test5345calendar() {
276        logln("** testIncompleteCalendar()");
277        // Test calendar with incomplete information
278        JapaneseCalendar c = new JapaneseCalendar(TimeZone.getDefault());
279        logln("test clear");
280        c.clear();
281
282        // Showa 45 = Gregorian 1970
283        int expected0[] = {   Calendar.ERA, 234,
284                              Calendar.YEAR, 45 };
285        checkExpected(c, expected0);
286
287        logln("test setting era");
288        c.clear();
289        c.set(Calendar.ERA, JapaneseCalendar.MEIJI);
290
291
292        int expectedA[] = {   Calendar.ERA, JapaneseCalendar.MEIJI };
293        checkExpected(c, expectedA);
294
295
296        logln("test setting era and year and month and date");
297        c.clear();
298        c.set(Calendar.ERA, JapaneseCalendar.MEIJI);
299        c.set(Calendar.YEAR, 1);
300        c.set(Calendar.MONTH, Calendar.JANUARY);
301        c.set(Calendar.DATE, 1);
302
303
304        int expectedC[] = {   Calendar.ERA, JapaneseCalendar.MEIJI -1};
305        checkExpected(c, expectedC);
306
307
308        logln("test setting  year and month and date THEN era");
309        c.clear();
310        c.set(Calendar.YEAR, 1);
311        c.set(Calendar.MONTH, Calendar.JANUARY);
312        c.set(Calendar.DATE, 1);
313        c.set(Calendar.ERA, JapaneseCalendar.MEIJI);
314
315
316        checkExpected(c, expectedC);
317
318
319        logln("test setting era and year");
320        c.clear();
321        c.set(Calendar.YEAR, 1);
322        c.set(Calendar.ERA, JapaneseCalendar.MEIJI);
323
324
325        int expectedB[] = { Calendar.ERA, JapaneseCalendar.MEIJI,
326                            Calendar.YEAR, 1 };
327        checkExpected(c, expectedB);
328
329    }
330
331
332    public void TestJapaneseYear3282() {
333        Calendar c = Calendar.getInstance(ULocale.ENGLISH);
334        c.set(2003,Calendar.SEPTEMBER,25);
335        JapaneseCalendar jcal = new JapaneseCalendar();
336        //jcal.setTime(new Date(1187906308151L));  alternate value
337        jcal.setTime(c.getTime());
338        logln("Now is: " + jcal.getTime());
339        c.setTime(jcal.getTime());
340        int nowYear = c.get(Calendar.YEAR);
341        logln("Now year: "+nowYear);
342        SimpleDateFormat jdf = (SimpleDateFormat) SimpleDateFormat.getDateInstance(jcal,
343                SimpleDateFormat.DEFAULT, Locale.getDefault());
344        jdf.applyPattern("G yy/MM/dd");
345        String text = jdf.format(jcal.getTime());
346        logln("Now is: " + text + " (in Japan)");
347        try {
348            Date date = jdf.parse(text);
349            logln("But is this not the date?: " + date);
350            c.setTime(date);
351            int thenYear = c.get(Calendar.YEAR);
352            logln("Then year: "+thenYear);
353            if(thenYear != nowYear) {
354                errln("Nowyear "+nowYear +" is not thenyear "+thenYear);
355            } else {
356                logln("Nowyear "+nowYear +" == thenyear "+thenYear);
357            }
358        } catch (java.text.ParseException ex) {
359            ex.printStackTrace();
360        }
361    }
362
363    /**
364     * Test limits of the Japanese calendar
365     */
366    public void TestLimits() {
367        Calendar cal = Calendar.getInstance();
368        cal.set(1988, Calendar.DECEMBER, 1);
369        JapaneseCalendar jcal = new JapaneseCalendar();
370        doLimitsTest(jcal, null, cal.getTime());
371        doTheoreticalLimitsTest(jcal, true);
372    }
373}
374
375