| /* |
| * Copyright (c) 1998, 2016, Oracle and/or its affiliates. All rights reserved. |
| * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. |
| * |
| * This code is free software; you can redistribute it and/or modify it |
| * under the terms of the GNU General Public License version 2 only, as |
| * published by the Free Software Foundation. |
| * |
| * This code is distributed in the hope that it will be useful, but WITHOUT |
| * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or |
| * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License |
| * version 2 for more details (a copy is included in the LICENSE file that |
| * accompanied this code). |
| * |
| * You should have received a copy of the GNU General Public License version |
| * 2 along with this work; if not, write to the Free Software Foundation, |
| * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. |
| * |
| * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA |
| * or visit www.oracle.com if you need additional information or have any |
| * questions. |
| */ |
| |
| /* |
| * @test |
| * @bug 4052967 4073209 4073215 4084933 4096952 4109314 4126678 4151406 4151429 |
| * 4154525 4154537 4154542 4154650 4159922 4162593 4173604 4176686 4184229 4208960 |
| * 4966229 6433179 6851214 8007520 8008577 |
| * @library /java/text/testlib |
| * @run main/othervm -Djava.locale.providers=COMPAT,SPI TimeZoneRegression |
| */ |
| |
| import java.util.*; |
| import java.io.*; |
| import java.text.*; |
| |
| public class TimeZoneRegression extends IntlTest { |
| |
| public static void main(String[] args) throws Exception { |
| new TimeZoneRegression().run(args); |
| } |
| |
| public void Test4073209() { |
| TimeZone z1 = TimeZone.getTimeZone("PST"); |
| TimeZone z2 = TimeZone.getTimeZone("PST"); |
| if (z1 == z2) { |
| errln("Fail: TimeZone should return clones"); |
| } |
| } |
| |
| @SuppressWarnings("deprecation") |
| public void Test4073215() { |
| SimpleTimeZone z = new SimpleTimeZone(0, "GMT"); |
| if (z.useDaylightTime()) { |
| errln("Fail: Fix test to start with non-DST zone"); |
| } |
| z.setStartRule(Calendar.FEBRUARY, 1, Calendar.SUNDAY, 0); |
| z.setEndRule(Calendar.MARCH, -1, Calendar.SUNDAY, 0); |
| if (!z.useDaylightTime()) { |
| errln("Fail: DST not active"); |
| } |
| if (z.inDaylightTime(new Date(97, Calendar.JANUARY, 31)) || |
| !z.inDaylightTime(new Date(97, Calendar.MARCH, 1)) || |
| z.inDaylightTime(new Date(97, Calendar.MARCH, 31))) { |
| errln("Fail: DST not working as expected"); |
| } |
| } |
| |
| /** |
| * The expected behavior of TimeZone around the boundaries is: |
| * (Assume transition time of 2:00 AM) |
| * day of onset 1:59 AM STD = display name 1:59 AM ST |
| * 2:00 AM STD = display name 3:00 AM DT |
| * day of end 0:59 AM STD = display name 1:59 AM DT |
| * 1:00 AM STD = display name 1:00 AM ST |
| */ |
| public void Test4084933() { |
| // test both SimpleTimeZone and ZoneInfo objects. |
| // @since 1.4 |
| sub4084933(getPST()); |
| sub4084933(TimeZone.getTimeZone("PST")); |
| } |
| |
| private void sub4084933(TimeZone tz) { |
| long offset1 = tz.getOffset(1, |
| 1997, Calendar.OCTOBER, 26, Calendar.SUNDAY, (2*60*60*1000)); |
| long offset2 = tz.getOffset(1, |
| 1997, Calendar.OCTOBER, 26, Calendar.SUNDAY, (2*60*60*1000)-1); |
| |
| long offset3 = tz.getOffset(1, |
| 1997, Calendar.OCTOBER, 26, Calendar.SUNDAY, (1*60*60*1000)); |
| long offset4 = tz.getOffset(1, |
| 1997, Calendar.OCTOBER, 26, Calendar.SUNDAY, (1*60*60*1000)-1); |
| |
| /* |
| * The following was added just for consistency. It shows that going *to* Daylight |
| * Savings Time (PDT) does work at 2am. |
| */ |
| |
| long offset5 = tz.getOffset(1, |
| 1997, Calendar.APRIL, 6, Calendar.SUNDAY, (2*60*60*1000)); |
| long offset6 = tz.getOffset(1, |
| 1997, Calendar.APRIL, 6, Calendar.SUNDAY, (2*60*60*1000)-1); |
| |
| long offset7 = tz.getOffset(1, |
| 1997, Calendar.APRIL, 6, Calendar.SUNDAY, (1*60*60*1000)); |
| long offset8 = tz.getOffset(1, |
| 1997, Calendar.APRIL, 6, Calendar.SUNDAY, (1*60*60*1000)-1); |
| |
| long SToffset = -8 * 60*60*1000L; |
| long DToffset = -7 * 60*60*1000L; |
| if (offset1 != SToffset || offset2 != SToffset || |
| offset3 != SToffset || offset4 != DToffset || |
| offset5 != DToffset || offset6 != SToffset || |
| offset7 != SToffset || offset8 != SToffset) |
| errln("Fail: TimeZone misbehaving"); { |
| } |
| } |
| |
| public void Test4096952() { |
| String[] ZONES = { "GMT", "MET", "IST" }; |
| boolean pass = true; |
| try { |
| for (int i=0; i<ZONES.length; ++i) { |
| TimeZone zone = TimeZone.getTimeZone(ZONES[i]); |
| if (!zone.getID().equals(ZONES[i])) |
| errln("Fail: Test broken; zones not instantiating"); |
| |
| ByteArrayOutputStream baos; |
| ObjectOutputStream ostream = |
| new ObjectOutputStream(baos = new |
| ByteArrayOutputStream()); |
| ostream.writeObject(zone); |
| ostream.close(); |
| baos.close(); |
| ObjectInputStream istream = |
| new ObjectInputStream(new |
| ByteArrayInputStream(baos.toByteArray())); |
| TimeZone frankenZone = (TimeZone) istream.readObject(); |
| //logln("Zone: " + zone); |
| //logln("FrankenZone: " + frankenZone); |
| if (!zone.equals(frankenZone)) { |
| logln("TimeZone " + zone.getID() + |
| " not equal to serialized/deserialized one"); |
| pass = false; |
| } |
| } |
| if (!pass) errln("Fail: TimeZone serialization/equality bug"); |
| } |
| catch (IOException e) { |
| errln("Fail: " + e); |
| e.printStackTrace(); |
| } |
| catch (ClassNotFoundException e) { |
| errln("Fail: " + e); |
| e.printStackTrace(); |
| } |
| } |
| |
| public void Test4109314() { |
| Locale locale = Locale.getDefault(); |
| if (!TestUtils.usesGregorianCalendar(locale)) { |
| logln("Skipping this test because locale is " + locale); |
| return; |
| } |
| |
| // test both SimpleTimeZone and ZoneInfo objects. |
| // @since 1.4 |
| sub4109314(getPST()); |
| sub4109314(TimeZone.getTimeZone("PST")); |
| } |
| |
| |
| @SuppressWarnings("deprecation") |
| private void sub4109314(TimeZone PST) { |
| GregorianCalendar testCal = (GregorianCalendar)Calendar.getInstance(); |
| Object[] testData = { |
| PST, new Date(98,Calendar.APRIL,4,22,0), new Date(98, Calendar.APRIL, 5,6,0), |
| PST, new Date(98,Calendar.OCTOBER,24,22,0), new Date(98,Calendar.OCTOBER,25,6,0), |
| }; |
| boolean pass=true; |
| for (int i=0; i<testData.length; i+=3) { |
| testCal.setTimeZone((TimeZone) testData[i]); |
| long t = ((Date)testData[i+1]).getTime(); |
| Date end = (Date) testData[i+2]; |
| while (t < end.getTime()) { |
| testCal.setTime(new Date(t)); |
| if (!checkCalendar314(testCal, (TimeZone) testData[i])) |
| pass = false; |
| t += 60*60*1000L; |
| } |
| } |
| if (!pass) errln("Fail: TZ API inconsistent"); |
| } |
| |
| boolean checkCalendar314(GregorianCalendar testCal, TimeZone testTZ) { |
| // GregorianCalendar testCal = (GregorianCalendar)aCal.clone(); |
| |
| final int ONE_DAY = 24*60*60*1000; |
| |
| int tzOffset, tzRawOffset; |
| Float tzOffsetFloat,tzRawOffsetFloat; |
| // Here is where the user made an error. They were passing in the value of |
| // the MILLSECOND field; you need to pass in the millis in the day in STANDARD |
| // time. |
| int millis = testCal.get(Calendar.MILLISECOND) + |
| 1000 * (testCal.get(Calendar.SECOND) + |
| 60 * (testCal.get(Calendar.MINUTE) + |
| 60 * (testCal.get(Calendar.HOUR_OF_DAY)))) - |
| testCal.get(Calendar.DST_OFFSET); |
| |
| /* Fix up millis to be in range. ASSUME THAT WE ARE NOT AT THE |
| * BEGINNING OR END OF A MONTH. We must add this code because |
| * getOffset() has been changed to be more strict about the parameters |
| * it receives -- it turns out that this test was passing in illegal |
| * values. */ |
| int date = testCal.get(Calendar.DATE); |
| int dow = testCal.get(Calendar.DAY_OF_WEEK); |
| while (millis < 0) { |
| millis += ONE_DAY; |
| --date; |
| dow = Calendar.SUNDAY + ((dow - Calendar.SUNDAY + 6) % 7); |
| } |
| while (millis >= ONE_DAY) { |
| millis -= ONE_DAY; |
| ++date; |
| dow = Calendar.SUNDAY + ((dow - Calendar.SUNDAY + 1) % 7); |
| } |
| |
| tzOffset = testTZ.getOffset(testCal.get(Calendar.ERA), |
| testCal.get(Calendar.YEAR), |
| testCal.get(Calendar.MONTH), |
| date, |
| dow, |
| millis); |
| tzRawOffset = testTZ.getRawOffset(); |
| tzOffsetFloat = new Float((float)tzOffset/(float)3600000); |
| tzRawOffsetFloat = new Float((float)tzRawOffset/(float)3600000); |
| |
| Date testDate = testCal.getTime(); |
| |
| boolean inDaylightTime = testTZ.inDaylightTime(testDate); |
| SimpleDateFormat sdf = new SimpleDateFormat("MM/dd/yyyy HH:mm"); |
| sdf.setCalendar(testCal); |
| String inDaylightTimeString; |
| |
| boolean passed; |
| |
| if (inDaylightTime) |
| { |
| inDaylightTimeString = " DST "; |
| passed = (tzOffset == (tzRawOffset + 3600000)); |
| } |
| else |
| { |
| inDaylightTimeString = " "; |
| passed = (tzOffset == tzRawOffset); |
| } |
| |
| String output = testTZ.getID() + " " + sdf.format(testDate) + |
| " Offset(" + tzOffsetFloat + ")" + |
| " RawOffset(" + tzRawOffsetFloat + ")" + |
| " " + millis/(float)3600000 + " " + |
| inDaylightTimeString; |
| |
| if (passed) |
| output += " "; |
| else |
| output += "ERROR"; |
| |
| if (passed) logln(output); else errln(output); |
| return passed; |
| } |
| |
| /** |
| * CANNOT REPRODUDE |
| * |
| * Yet another _alleged_ bug in TimeZone.getOffset(), a method that never |
| * should have been made public. It's simply too hard to use correctly. |
| * |
| * The original test code failed to do the following: |
| * (1) Call Calendar.setTime() before getting the fields! |
| * (2) Use the right millis (as usual) for getOffset(); they were passing |
| * in the MILLIS field, instead of the STANDARD MILLIS IN DAY. |
| * When you fix these two problems, the test passes, as expected. |
| */ |
| public void Test4126678() { |
| Locale locale = Locale.getDefault(); |
| if (!TestUtils.usesGregorianCalendar(locale)) { |
| logln("Skipping this test because locale is " + locale); |
| return; |
| } |
| |
| // Note: this test depends on the PST time zone. |
| TimeZone initialZone = TimeZone.getDefault(); |
| |
| // test both SimpleTimeZone and ZoneInfo objects. |
| // @since 1.4 |
| sub4126678(getPST()); |
| sub4126678(TimeZone.getTimeZone("PST")); |
| |
| // restore the initial time zone so that this test case |
| // doesn't affect the others. |
| TimeZone.setDefault(initialZone); |
| } |
| |
| @SuppressWarnings("deprecation") |
| private void sub4126678(TimeZone tz) { |
| Calendar cal = Calendar.getInstance(); |
| TimeZone.setDefault(tz); |
| cal.setTimeZone(tz); |
| |
| Date dt = new Date(1998-1900, Calendar.APRIL, 5, 10, 0); |
| // the dt value is local time in PST. |
| if (!tz.inDaylightTime(dt)) |
| errln("We're not in Daylight Savings Time and we should be.\n"); |
| |
| cal.setTime(dt); |
| int era = cal.get(Calendar.ERA); |
| int year = cal.get(Calendar.YEAR); |
| int month = cal.get(Calendar.MONTH); |
| int day = cal.get(Calendar.DATE); |
| int dayOfWeek = cal.get(Calendar.DAY_OF_WEEK); |
| int millis = cal.get(Calendar.MILLISECOND) + |
| (cal.get(Calendar.SECOND) + |
| (cal.get(Calendar.MINUTE) + |
| (cal.get(Calendar.HOUR) * 60) * 60) * 1000) - |
| cal.get(Calendar.DST_OFFSET); |
| |
| long offset = tz.getOffset(era, year, month, day, dayOfWeek, millis); |
| long raw_offset = tz.getRawOffset(); |
| if (offset == raw_offset) { |
| errln("Offsets should not match when in DST"); |
| } |
| } |
| |
| /** |
| * TimeZone.getAvailableIDs(int) throws exception for certain values, |
| * due to a faulty constant in TimeZone.java. |
| */ |
| public void Test4151406() { |
| int max = 0; |
| for (int h=-28; h<=30; ++h) { |
| // h is in half-hours from GMT; rawoffset is in millis |
| int rawoffset = h * 1800000; |
| int hh = (h<0) ? -h : h; |
| String hname = ((h<0) ? "GMT-" : "GMT+") + |
| ((hh/2 < 10) ? "0" : "") + |
| (hh/2) + ':' + |
| ((hh%2==0) ? "00" : "30"); |
| try { |
| String[] ids = TimeZone.getAvailableIDs(rawoffset); |
| if (ids.length > max) max = ids.length; |
| logln(hname + ' ' + ids.length + |
| ((ids.length > 0) ? (" e.g. " + ids[0]) : "")); |
| } catch (Exception e) { |
| errln(hname + ' ' + "Fail: " + e); |
| } |
| } |
| logln("Maximum zones per offset = " + max); |
| } |
| |
| public void Test4151429() { |
| try { |
| TimeZone tz = TimeZone.getTimeZone("GMT"); |
| String name = tz.getDisplayName(true, Integer.MAX_VALUE, |
| Locale.getDefault()); |
| errln("IllegalArgumentException not thrown by TimeZone.getDisplayName()"); |
| } catch(IllegalArgumentException e) {} |
| } |
| |
| /** |
| * SimpleTimeZone accepts illegal DST savings values. These values |
| * must be non-zero. There is no upper limit at this time. |
| */ |
| public void Test4154525() { |
| final int GOOD = 1, BAD = 0; |
| int[] DATA = { |
| 1, GOOD, |
| 0, BAD, |
| -1, BAD, |
| 60*60*1000, GOOD, |
| Integer.MIN_VALUE, BAD, |
| // Integer.MAX_VALUE, ?, // no upper limit on DST savings at this time |
| }; |
| for (int i=0; i<DATA.length; i+=2) { |
| int savings = DATA[i]; |
| boolean valid = DATA[i+1] == GOOD; |
| String method = null; |
| for (int j=0; j<2; ++j) { |
| try { |
| switch (j) { |
| case 0: |
| method = "constructor"; |
| SimpleTimeZone z = new SimpleTimeZone(0, "id", |
| Calendar.JANUARY, 1, 0, 0, |
| Calendar.MARCH, 1, 0, 0, |
| savings); // <- what we're interested in |
| break; |
| case 1: |
| method = "setDSTSavings()"; |
| z = new SimpleTimeZone(0, "GMT"); |
| z.setDSTSavings(savings); |
| break; |
| } |
| if (valid) { |
| logln("Pass: DST savings of " + savings + " accepted by " + method); |
| } else { |
| errln("Fail: DST savings of " + savings + " accepted by " + method); |
| } |
| } catch (IllegalArgumentException e) { |
| if (valid) { |
| errln("Fail: DST savings of " + savings + " to " + method + " gave " + e); |
| } else { |
| logln("Pass: DST savings of " + savings + " to " + method + " gave " + e); |
| } |
| } |
| } |
| } |
| } |
| |
| /** |
| * SimpleTimeZone.hasSameRules() doesn't work for zones with no DST |
| * and different DST parameters. |
| */ |
| public void Test4154537() { |
| // tz1 and tz2 have no DST and different rule parameters |
| SimpleTimeZone tz1 = new SimpleTimeZone(0, "1", 0, 0, 0, 0, 2, 0, 0, 0); |
| SimpleTimeZone tz2 = new SimpleTimeZone(0, "2", 1, 0, 0, 0, 3, 0, 0, 0); |
| // tza and tzA have the same rule params |
| SimpleTimeZone tza = new SimpleTimeZone(0, "a", 0, 1, 0, 0, 3, 2, 0, 0); |
| SimpleTimeZone tzA = new SimpleTimeZone(0, "A", 0, 1, 0, 0, 3, 2, 0, 0); |
| // tzb differs from tza |
| SimpleTimeZone tzb = new SimpleTimeZone(0, "b", 0, 1, 0, 0, 3, 1, 0, 0); |
| if (tz1.useDaylightTime() || tz2.useDaylightTime() || |
| !tza.useDaylightTime() || !tzA.useDaylightTime() || |
| !tzb.useDaylightTime()) { |
| errln("Test is broken -- rewrite it"); |
| } |
| if (!tza.hasSameRules(tzA) || tza.hasSameRules(tzb)) { |
| errln("Fail: hasSameRules() broken for zones with rules"); |
| } |
| if (!tz1.hasSameRules(tz2)) { |
| errln("Fail: hasSameRules() returns false for zones without rules"); |
| errln("zone 1 = " + tz1); |
| errln("zone 2 = " + tz2); |
| } |
| } |
| |
| /** |
| * SimpleTimeZone constructors, setStartRule(), and setEndRule() don't |
| * check for out-of-range arguments. |
| */ |
| public void Test4154542() { |
| final int GOOD = 1; |
| final int BAD = 0; |
| |
| final int GOOD_MONTH = Calendar.JANUARY; |
| final int GOOD_DAY = 1; |
| final int GOOD_DAY_OF_WEEK = Calendar.SUNDAY; |
| final int GOOD_TIME = 0; |
| |
| int[] DATA = { |
| GOOD, Integer.MIN_VALUE, 0, Integer.MAX_VALUE, Integer.MIN_VALUE, |
| GOOD, Calendar.JANUARY, -5, Calendar.SUNDAY, 0, |
| GOOD, Calendar.DECEMBER, 5, Calendar.SATURDAY, 24*60*60*1000-1, |
| GOOD, Calendar.DECEMBER, 5, Calendar.SATURDAY, 24*60*60*1000, |
| BAD, Calendar.DECEMBER, 5, Calendar.SATURDAY, 24*60*60*1000+1, |
| BAD, Calendar.DECEMBER, 5, Calendar.SATURDAY, -1, |
| BAD, Calendar.JANUARY, -6, Calendar.SUNDAY, 0, |
| BAD, Calendar.DECEMBER, 6, Calendar.SATURDAY, 24*60*60*1000, |
| GOOD, Calendar.DECEMBER, 1, 0, 0, |
| GOOD, Calendar.DECEMBER, 31, 0, 0, |
| BAD, Calendar.APRIL, 31, 0, 0, |
| BAD, Calendar.DECEMBER, 32, 0, 0, |
| BAD, Calendar.JANUARY-1, 1, Calendar.SUNDAY, 0, |
| BAD, Calendar.DECEMBER+1, 1, Calendar.SUNDAY, 0, |
| GOOD, Calendar.DECEMBER, 31, -Calendar.SUNDAY, 0, |
| GOOD, Calendar.DECEMBER, 31, -Calendar.SATURDAY, 0, |
| BAD, Calendar.DECEMBER, 32, -Calendar.SATURDAY, 0, |
| BAD, Calendar.DECEMBER, -32, -Calendar.SATURDAY, 0, |
| BAD, Calendar.DECEMBER, 31, -Calendar.SATURDAY-1, 0, |
| }; |
| SimpleTimeZone zone = new SimpleTimeZone(0, "Z"); |
| for (int i=0; i<DATA.length; i+=5) { |
| boolean shouldBeGood = (DATA[i] == GOOD); |
| int month = DATA[i+1]; |
| int day = DATA[i+2]; |
| int dayOfWeek = DATA[i+3]; |
| int time = DATA[i+4]; |
| |
| Exception ex = null; |
| try { |
| zone.setStartRule(month, day, dayOfWeek, time); |
| } catch (IllegalArgumentException e) { |
| ex = e; |
| } |
| if ((ex == null) != shouldBeGood) { |
| errln("setStartRule(month=" + month + ", day=" + day + |
| ", dayOfWeek=" + dayOfWeek + ", time=" + time + |
| (shouldBeGood ? (") should work but throws " + ex) |
| : ") should fail but doesn't")); |
| } |
| |
| ex = null; |
| try { |
| zone.setEndRule(month, day, dayOfWeek, time); |
| } catch (IllegalArgumentException e) { |
| ex = e; |
| } |
| if ((ex == null) != shouldBeGood) { |
| errln("setEndRule(month=" + month + ", day=" + day + |
| ", dayOfWeek=" + dayOfWeek + ", time=" + time + |
| (shouldBeGood ? (") should work but throws " + ex) |
| : ") should fail but doesn't")); |
| } |
| |
| ex = null; |
| try { |
| SimpleTimeZone temp = new SimpleTimeZone(0, "Z", |
| month, day, dayOfWeek, time, |
| GOOD_MONTH, GOOD_DAY, GOOD_DAY_OF_WEEK, GOOD_TIME); |
| } catch (IllegalArgumentException e) { |
| ex = e; |
| } |
| if ((ex == null) != shouldBeGood) { |
| errln("SimpleTimeZone(month=" + month + ", day=" + day + |
| ", dayOfWeek=" + dayOfWeek + ", time=" + time + |
| (shouldBeGood ? (", <end>) should work but throws " + ex) |
| : ", <end>) should fail but doesn't")); |
| } |
| |
| ex = null; |
| try { |
| SimpleTimeZone temp = new SimpleTimeZone(0, "Z", |
| GOOD_MONTH, GOOD_DAY, GOOD_DAY_OF_WEEK, GOOD_TIME, |
| month, day, dayOfWeek, time); |
| } catch (IllegalArgumentException e) { |
| ex = e; |
| } |
| if ((ex == null) != shouldBeGood) { |
| errln("SimpleTimeZone(<start>, month=" + month + ", day=" + day + |
| ", dayOfWeek=" + dayOfWeek + ", time=" + time + |
| (shouldBeGood ? (") should work but throws " + ex) |
| : ") should fail but doesn't")); |
| } |
| } |
| } |
| |
| /** |
| * SimpleTimeZone.getOffset accepts illegal arguments. |
| */ |
| public void Test4154650() { |
| final int GOOD=1, BAD=0; |
| final int GOOD_ERA=GregorianCalendar.AD, GOOD_YEAR=1998, GOOD_MONTH=Calendar.AUGUST; |
| final int GOOD_DAY=2, GOOD_DOW=Calendar.SUNDAY, GOOD_TIME=16*3600000; |
| int[] DATA = { |
| GOOD, GOOD_ERA, GOOD_YEAR, GOOD_MONTH, GOOD_DAY, GOOD_DOW, GOOD_TIME, |
| |
| GOOD, GregorianCalendar.BC, GOOD_YEAR, GOOD_MONTH, GOOD_DAY, GOOD_DOW, GOOD_TIME, |
| GOOD, GregorianCalendar.AD, GOOD_YEAR, GOOD_MONTH, GOOD_DAY, GOOD_DOW, GOOD_TIME, |
| BAD, GregorianCalendar.BC-1, GOOD_YEAR, GOOD_MONTH, GOOD_DAY, GOOD_DOW, GOOD_TIME, |
| BAD, GregorianCalendar.AD+1, GOOD_YEAR, GOOD_MONTH, GOOD_DAY, GOOD_DOW, GOOD_TIME, |
| |
| GOOD, GOOD_ERA, GOOD_YEAR, Calendar.JANUARY, GOOD_DAY, GOOD_DOW, GOOD_TIME, |
| GOOD, GOOD_ERA, GOOD_YEAR, Calendar.DECEMBER, GOOD_DAY, GOOD_DOW, GOOD_TIME, |
| BAD, GOOD_ERA, GOOD_YEAR, Calendar.JANUARY-1, GOOD_DAY, GOOD_DOW, GOOD_TIME, |
| BAD, GOOD_ERA, GOOD_YEAR, Calendar.DECEMBER+1, GOOD_DAY, GOOD_DOW, GOOD_TIME, |
| |
| GOOD, GOOD_ERA, GOOD_YEAR, Calendar.JANUARY, 1, GOOD_DOW, GOOD_TIME, |
| GOOD, GOOD_ERA, GOOD_YEAR, Calendar.JANUARY, 31, GOOD_DOW, GOOD_TIME, |
| BAD, GOOD_ERA, GOOD_YEAR, Calendar.JANUARY, 0, GOOD_DOW, GOOD_TIME, |
| BAD, GOOD_ERA, GOOD_YEAR, Calendar.JANUARY, 32, GOOD_DOW, GOOD_TIME, |
| |
| GOOD, GOOD_ERA, GOOD_YEAR, GOOD_MONTH, GOOD_DAY, Calendar.SUNDAY, GOOD_TIME, |
| GOOD, GOOD_ERA, GOOD_YEAR, GOOD_MONTH, GOOD_DAY, Calendar.SATURDAY, GOOD_TIME, |
| BAD, GOOD_ERA, GOOD_YEAR, GOOD_MONTH, GOOD_DAY, Calendar.SUNDAY-1, GOOD_TIME, |
| BAD, GOOD_ERA, GOOD_YEAR, GOOD_MONTH, GOOD_DAY, Calendar.SATURDAY+1, GOOD_TIME, |
| |
| GOOD, GOOD_ERA, GOOD_YEAR, GOOD_MONTH, GOOD_DAY, GOOD_DOW, 0, |
| GOOD, GOOD_ERA, GOOD_YEAR, GOOD_MONTH, GOOD_DAY, GOOD_DOW, 24*3600000-1, |
| BAD, GOOD_ERA, GOOD_YEAR, GOOD_MONTH, GOOD_DAY, GOOD_DOW, -1, |
| BAD, GOOD_ERA, GOOD_YEAR, GOOD_MONTH, GOOD_DAY, GOOD_DOW, 24*3600000, |
| }; |
| |
| TimeZone tz = TimeZone.getDefault(); |
| for (int i=0; i<DATA.length; i+=7) { |
| boolean good = DATA[i] == GOOD; |
| IllegalArgumentException e = null; |
| try { |
| int offset = tz.getOffset(DATA[i+1], DATA[i+2], DATA[i+3], |
| DATA[i+4], DATA[i+5], DATA[i+6]); |
| } catch (IllegalArgumentException ex) { |
| e = ex; |
| } |
| if (good != (e == null)) { |
| errln("Fail: getOffset(" + |
| DATA[i+1] + ", " + DATA[i+2] + ", " + DATA[i+3] + ", " + |
| DATA[i+4] + ", " + DATA[i+5] + ", " + DATA[i+6] + |
| (good ? (") threw " + e) : ") accepts invalid args")); |
| } |
| } |
| } |
| |
| /** |
| * TimeZone constructors allow null IDs. |
| */ |
| public void Test4159922() { |
| TimeZone z = null; |
| |
| // TimeZone API. Only hasSameRules() and setDefault() should |
| // allow null. |
| try { |
| z = TimeZone.getTimeZone((String)null); |
| errln("FAIL: Null allowed in getTimeZone"); |
| } catch (NullPointerException e) {} |
| z = TimeZone.getTimeZone("GMT"); |
| try { |
| z.getDisplayName(false, TimeZone.SHORT, null); |
| errln("FAIL: Null allowed in getDisplayName(3)"); |
| } catch (NullPointerException e) {} |
| try { |
| z.getDisplayName(null); |
| errln("FAIL: Null allowed in getDisplayName(1)"); |
| } catch (NullPointerException e) {} |
| try { |
| if (z.hasSameRules(null)) { |
| errln("FAIL: hasSameRules returned true"); |
| } |
| } catch (NullPointerException e) { |
| errln("FAIL: Null NOT allowed in hasSameRules"); |
| } |
| try { |
| z.inDaylightTime(null); |
| errln("FAIL: Null allowed in inDaylightTime"); |
| } catch (NullPointerException e) {} |
| try { |
| z.setID(null); |
| errln("FAIL: Null allowed in setID"); |
| } catch (NullPointerException e) {} |
| |
| TimeZone save = TimeZone.getDefault(); |
| try { |
| TimeZone.setDefault(null); |
| } catch (NullPointerException e) { |
| errln("FAIL: Null NOT allowed in setDefault"); |
| } finally { |
| TimeZone.setDefault(save); |
| } |
| |
| // SimpleTimeZone API |
| SimpleTimeZone s = null; |
| try { |
| s = new SimpleTimeZone(0, null); |
| errln("FAIL: Null allowed in SimpleTimeZone(2)"); |
| } catch (NullPointerException e) {} |
| try { |
| s = new SimpleTimeZone(0, null, 0, 1, 0, 0, 0, 1, 0, 0); |
| errln("FAIL: Null allowed in SimpleTimeZone(10)"); |
| } catch (NullPointerException e) {} |
| try { |
| s = new SimpleTimeZone(0, null, 0, 1, 0, 0, 0, 1, 0, 0, 1000); |
| errln("FAIL: Null allowed in SimpleTimeZone(11)"); |
| } catch (NullPointerException e) {} |
| } |
| |
| /** |
| * TimeZone broken at midnight. The TimeZone code fails to handle |
| * transitions at midnight correctly. |
| */ |
| @SuppressWarnings("deprecation") |
| public void Test4162593() { |
| SimpleDateFormat fmt = new SimpleDateFormat("z", Locale.US); |
| final int ONE_HOUR = 60*60*1000; |
| TimeZone initialZone = TimeZone.getDefault(); |
| |
| SimpleTimeZone asuncion = new SimpleTimeZone(-4*ONE_HOUR, "America/Asuncion" /*PY%sT*/, |
| Calendar.OCTOBER, 1, 0 /*DOM*/, 0*ONE_HOUR, |
| Calendar.MARCH, 1, 0 /*DOM*/, 0*ONE_HOUR, 1*ONE_HOUR); |
| |
| /* Zone |
| * Starting time |
| * Transition expected between start+1H and start+2H |
| */ |
| Object[] DATA = { |
| new SimpleTimeZone(2*ONE_HOUR, "Asia/Damascus" /*EE%sT*/, |
| Calendar.APRIL, 1, 0 /*DOM*/, 0*ONE_HOUR, |
| Calendar.OCTOBER, 1, 0 /*DOM*/, 0*ONE_HOUR, 1*ONE_HOUR), |
| new int[] {98, Calendar.SEPTEMBER, 30, 22, 0}, |
| Boolean.TRUE, |
| |
| asuncion, |
| new int[] {100, Calendar.FEBRUARY, 28, 22, 0}, |
| Boolean.FALSE, |
| |
| asuncion, |
| new int[] {100, Calendar.FEBRUARY, 29, 22, 0}, |
| Boolean.TRUE, |
| }; |
| |
| String[] zone = new String[4]; |
| |
| try { |
| for (int j=0; j<DATA.length; j+=3) { |
| TimeZone tz = (TimeZone)DATA[j]; |
| TimeZone.setDefault(tz); |
| fmt.setTimeZone(tz); |
| |
| // Must construct the Date object AFTER setting the default zone |
| int[] p = (int[])DATA[j+1]; |
| Date d = new Date(p[0], p[1], p[2], p[3], p[4]); |
| boolean transitionExpected = ((Boolean)DATA[j+2]).booleanValue(); |
| |
| logln(tz.getID() + ":"); |
| for (int i=0; i<4; ++i) { |
| zone[i] = fmt.format(d); |
| logln("" + i + ": " + d); |
| d = new Date(d.getTime() + ONE_HOUR); |
| } |
| if (zone[0].equals(zone[1]) && |
| (zone[1].equals(zone[2]) != transitionExpected) && |
| zone[2].equals(zone[3])) { |
| logln("Ok: transition " + transitionExpected); |
| } else { |
| errln("Fail: boundary transition incorrect"); |
| } |
| } |
| } |
| finally { |
| // restore the initial time zone so that this test case |
| // doesn't affect the others. |
| TimeZone.setDefault(initialZone); |
| } |
| } |
| |
| /** |
| * TimeZone broken in last hour of year |
| */ |
| public void Test4173604() { |
| // test both SimpleTimeZone and ZoneInfo objects. |
| // @since 1.4 |
| sub4173604(getPST()); |
| sub4173604(TimeZone.getTimeZone("PST")); |
| } |
| |
| private void sub4173604(TimeZone pst) { |
| int o22 = pst.getOffset(1, 1998, 11, 31, Calendar.THURSDAY, 22*60*60*1000); |
| int o23 = pst.getOffset(1, 1998, 11, 31, Calendar.THURSDAY, 23*60*60*1000); |
| int o00 = pst.getOffset(1, 1999, 0, 1, Calendar.FRIDAY, 0); |
| if (o22 != o23 || o22 != o00) { |
| errln("Offsets should be the same (for PST), but got: " + |
| "12/31 22:00 " + o22 + |
| ", 12/31 23:00 " + o23 + |
| ", 01/01 00:00 " + o00); |
| } |
| |
| GregorianCalendar cal = new GregorianCalendar(); |
| cal.setTimeZone(pst); |
| cal.clear(); |
| cal.set(1998, Calendar.JANUARY, 1); |
| int lastDST = cal.get(Calendar.DST_OFFSET); |
| int transitions = 0; |
| int delta = 5; |
| while (cal.get(Calendar.YEAR) < 2000) { |
| cal.add(Calendar.MINUTE, delta); |
| if (cal.get(Calendar.DST_OFFSET) != lastDST) { |
| ++transitions; |
| Calendar t = (Calendar)cal.clone(); |
| t.add(Calendar.MINUTE, -delta); |
| logln(t.getTime() + " " + t.get(Calendar.DST_OFFSET)); |
| logln(cal.getTime() + " " + (lastDST=cal.get(Calendar.DST_OFFSET))); |
| } |
| } |
| if (transitions != 4) { |
| errln("Saw " + transitions + " transitions; should have seen 4"); |
| } |
| } |
| |
| /** |
| * getDisplayName doesn't work with unusual savings/offsets. |
| */ |
| @SuppressWarnings("deprecation") |
| public void Test4176686() { |
| // Construct a zone that does not observe DST but |
| // that does have a DST savings (which should be ignored). |
| int offset = 90 * 60000; // 1:30 |
| SimpleTimeZone z1 = new SimpleTimeZone(offset, "_std_zone_"); |
| z1.setDSTSavings(45 * 60000); // 0:45 |
| |
| // Construct a zone that observes DST for the first 6 months. |
| SimpleTimeZone z2 = new SimpleTimeZone(offset, "_dst_zone_"); |
| z2.setDSTSavings(45 * 60000); // 0:45 |
| z2.setStartRule(Calendar.JANUARY, 1, 0); |
| z2.setEndRule(Calendar.JULY, 1, 0); |
| |
| // Also check DateFormat |
| DateFormat fmt1 = new SimpleDateFormat("z"); |
| fmt1.setTimeZone(z1); // Format uses standard zone |
| DateFormat fmt2 = new SimpleDateFormat("z"); |
| fmt2.setTimeZone(z2); // Format uses DST zone |
| Date dst = new Date(1970-1900, Calendar.FEBRUARY, 1); // Time in DST |
| Date std = new Date(1970-1900, Calendar.AUGUST, 1); // Time in standard |
| |
| // Description, Result, Expected Result |
| String[] DATA = { |
| "getDisplayName(false, SHORT)/std zone", |
| z1.getDisplayName(false, TimeZone.SHORT), "GMT+01:30", |
| "getDisplayName(false, LONG)/std zone", |
| z1.getDisplayName(false, TimeZone.LONG ), "GMT+01:30", |
| "getDisplayName(true, SHORT)/std zone", |
| z1.getDisplayName(true, TimeZone.SHORT), "GMT+01:30", |
| "getDisplayName(true, LONG)/std zone", |
| z1.getDisplayName(true, TimeZone.LONG ), "GMT+01:30", |
| "getDisplayName(false, SHORT)/dst zone", |
| z2.getDisplayName(false, TimeZone.SHORT), "GMT+01:30", |
| "getDisplayName(false, LONG)/dst zone", |
| z2.getDisplayName(false, TimeZone.LONG ), "GMT+01:30", |
| "getDisplayName(true, SHORT)/dst zone", |
| z2.getDisplayName(true, TimeZone.SHORT), "GMT+02:15", |
| "getDisplayName(true, LONG)/dst zone", |
| z2.getDisplayName(true, TimeZone.LONG ), "GMT+02:15", |
| "DateFormat.format(std)/std zone", fmt1.format(std), "GMT+01:30", |
| "DateFormat.format(dst)/std zone", fmt1.format(dst), "GMT+01:30", |
| "DateFormat.format(std)/dst zone", fmt2.format(std), "GMT+01:30", |
| "DateFormat.format(dst)/dst zone", fmt2.format(dst), "GMT+02:15", |
| }; |
| |
| for (int i=0; i<DATA.length; i+=3) { |
| if (!DATA[i+1].equals(DATA[i+2])) { |
| errln("FAIL: " + DATA[i] + " -> " + DATA[i+1] + ", exp " + DATA[i+2]); |
| } |
| } |
| } |
| |
| /** |
| * SimpleTimeZone allows invalid DOM values. |
| */ |
| public void Test4184229() { |
| SimpleTimeZone zone = null; |
| try { |
| zone = new SimpleTimeZone(0, "A", 0, -1, 0, 0, 0, 0, 0, 0); |
| errln("Failed. No exception has been thrown for DOM -1 startDay"); |
| } catch(IllegalArgumentException e) { |
| logln("(a) " + e.getMessage()); |
| } |
| try { |
| zone = new SimpleTimeZone(0, "A", 0, 0, 0, 0, 0, -1, 0, 0); |
| errln("Failed. No exception has been thrown for DOM -1 endDay"); |
| } catch(IllegalArgumentException e) { |
| logln("(b) " + e.getMessage()); |
| } |
| try { |
| zone = new SimpleTimeZone(0, "A", 0, -1, 0, 0, 0, 0, 0, 0, 1000); |
| errln("Failed. No exception has been thrown for DOM -1 startDay +savings"); |
| } catch(IllegalArgumentException e) { |
| logln("(c) " + e.getMessage()); |
| } |
| try { |
| zone = new SimpleTimeZone(0, "A", 0, 0, 0, 0, 0, -1, 0, 0, 1000); |
| errln("Failed. No exception has been thrown for DOM -1 endDay +savings"); |
| } catch(IllegalArgumentException e) { |
| logln("(d) " + e.getMessage()); |
| } |
| // Make a valid constructor call for subsequent tests. |
| zone = new SimpleTimeZone(0, "A", 0, 1, 0, 0, 0, 1, 0, 0); |
| try { |
| zone.setStartRule(0, -1, 0, 0); |
| errln("Failed. No exception has been thrown for DOM -1 setStartRule +savings"); |
| } catch(IllegalArgumentException e) { |
| logln("(e) " + e.getMessage()); |
| } |
| try { |
| zone.setStartRule(0, -1, 0); |
| errln("Failed. No exception has been thrown for DOM -1 setStartRule"); |
| } catch(IllegalArgumentException e) { |
| logln("(f) " + e.getMessage()); |
| } |
| try { |
| zone.setEndRule(0, -1, 0, 0); |
| errln("Failed. No exception has been thrown for DOM -1 setEndRule +savings"); |
| } catch(IllegalArgumentException e) { |
| logln("(g) " + e.getMessage()); |
| } |
| try { |
| zone.setEndRule(0, -1, 0); |
| errln("Failed. No exception has been thrown for DOM -1 setEndRule"); |
| } catch(IllegalArgumentException e) { |
| logln("(h) " + e.getMessage()); |
| } |
| } |
| |
| /** |
| * SimpleTimeZone.getOffset() throws IllegalArgumentException when to get |
| * of 2/29/1996 (leap day). |
| */ |
| public void Test4208960 () { |
| // test both SimpleTimeZone and ZoneInfo objects. |
| // @since 1.4 |
| sub4208960(getPST()); |
| sub4208960(TimeZone.getTimeZone("PST")); |
| } |
| |
| private void sub4208960(TimeZone tz) { |
| try { |
| int offset = tz.getOffset(GregorianCalendar.AD, 1996, Calendar.FEBRUARY, 29, |
| Calendar.THURSDAY, 0); |
| } catch (IllegalArgumentException e) { |
| errln("FAILED: to get TimeZone.getOffset(2/29/96)"); |
| } |
| try { |
| int offset = tz.getOffset(GregorianCalendar.AD, 1997, Calendar.FEBRUARY, 29, |
| Calendar.THURSDAY, 0); |
| errln("FAILED: TimeZone.getOffset(2/29/97) expected to throw Exception."); |
| } catch (IllegalArgumentException e) { |
| logln("got IllegalArgumentException"); |
| } |
| } |
| |
| /** |
| * 4966229: java.util.Date methods may works incorrect. |
| * sun.util.calendar.ZoneInfo doesn't clone properly. |
| */ |
| @SuppressWarnings("deprecation") |
| public void Test4966229() { |
| TimeZone savedTZ = TimeZone.getDefault(); |
| try { |
| TimeZone.setDefault(TimeZone.getTimeZone("GMT")); |
| Date d = new Date(2100-1900, 5, 1); // specify year >2037 |
| TimeZone tz = TimeZone.getTimeZone("America/Los_Angeles"); |
| |
| Calendar cal = new GregorianCalendar(tz); |
| cal.setTime(d); |
| |
| // Change the raw offset in tz |
| int offset = tz.getRawOffset(); |
| tz.setRawOffset(0); |
| |
| TimeZone tz2 = (TimeZone) tz.clone(); |
| Calendar cal2 = new GregorianCalendar(tz2); |
| cal2.setTime(d); |
| int expectedHourOfDay = cal2.get(cal.HOUR_OF_DAY); |
| |
| // Restore the GMT offset in tz which shouldn't affect tz2 |
| tz.setRawOffset(offset); |
| cal2.setTime(d); |
| int hourOfDay = cal2.get(cal.HOUR_OF_DAY); |
| if (hourOfDay != expectedHourOfDay) { |
| errln("wrong hour of day: got: " + hourOfDay |
| + ", expected: " + expectedHourOfDay); |
| } |
| } finally { |
| TimeZone.setDefault(savedTZ); |
| } |
| } |
| |
| /** |
| * 6433179: (tz) Incorrect DST end for America/Winnipeg and Canada/Central in 2038+ |
| */ |
| public void Test6433179() { |
| // Use the old America/Winnipeg rule for testing. Note that |
| // startMode is WALL_TIME for testing. It's actually |
| // STANDARD_TIME, though. |
| //Rule Winn 1966 2005 - Oct lastSun 2:00s 0 S |
| //Rule Winn 1987 2005 - Apr Sun>=1 2:00s 1:00 D |
| TimeZone tz = new SimpleTimeZone(-6*ONE_HOUR, "America/Winnipeg", |
| Calendar.APRIL, 1, -Calendar.SUNDAY, 2*ONE_HOUR, SimpleTimeZone.WALL_TIME, |
| Calendar.OCTOBER, -1, Calendar.SUNDAY, 2*ONE_HOUR, SimpleTimeZone.STANDARD_TIME, |
| 1*ONE_HOUR); |
| Calendar cal = Calendar.getInstance(tz, Locale.US); |
| cal.clear(); |
| cal.set(2039, Calendar.OCTOBER, 1); |
| cal.getTime(); |
| cal.set(cal.DAY_OF_WEEK, cal.SUNDAY); |
| cal.set(cal.DAY_OF_WEEK_IN_MONTH, -1); |
| cal.add(Calendar.HOUR_OF_DAY, 2); |
| if (cal.get(cal.DST_OFFSET) == 0) { |
| errln("Should still be in DST."); |
| } |
| } |
| |
| private static final int ONE_HOUR = 60 * 60 * 1000; |
| /** |
| * Returns an instance of SimpleTimeZone for |
| * "PST". (TimeZone.getTimeZone() no longer returns a |
| * SimpleTimeZone object.) |
| * @since 1.4 |
| */ |
| private SimpleTimeZone getPST() { |
| return new SimpleTimeZone(-8*ONE_HOUR, "PST", |
| Calendar.APRIL, 1, -Calendar.SUNDAY, 2*ONE_HOUR, |
| Calendar.OCTOBER, -1, Calendar.SUNDAY, 2*ONE_HOUR, |
| 1*ONE_HOUR); |
| } |
| } |
| //eof |
