42 * and/or other materials provided with the distribution.
43 *
44 * * Neither the name of JSR-310 nor the names of its contributors
45 * may be used to endorse or promote products derived from this software
46 * without specific prior written permission.
47 *
48 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
49 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
50 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
51 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
52 * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
53 * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
54 * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
55 * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
56 * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
57 * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
58 * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
59 */
60 package tck.java.time.zone;
61
62 import java.time.temporal.Year;
63 import java.time.zone.*;
64
65 import static org.testng.Assert.assertEquals;
66 import static org.testng.Assert.assertFalse;
67 import static org.testng.Assert.assertNotNull;
68 import static org.testng.Assert.assertTrue;
69
70 import java.io.ByteArrayInputStream;
71 import java.io.ByteArrayOutputStream;
72 import java.io.ObjectInputStream;
73 import java.io.ObjectOutputStream;
74 import java.util.Iterator;
75 import java.util.List;
76
77 import java.time.DayOfWeek;
78 import java.time.Duration;
79 import java.time.Instant;
80 import java.time.LocalDate;
81 import java.time.LocalDateTime;
82 import java.time.LocalTime;
83 import java.time.Month;
84 import java.time.ZoneId;
85 import java.time.ZoneOffset;
86 import java.time.ZonedDateTime;
87 import java.time.zone.ZoneOffsetTransitionRule.TimeDefinition;
88
89 import org.testng.annotations.Test;
90
91 /**
92 * Test ZoneRules.
93 */
94 @Test
95 public class TCKZoneRules {
96
97 private static final ZoneOffset OFFSET_ZERO = ZoneOffset.ofHours(0);
98 private static final ZoneOffset OFFSET_PONE = ZoneOffset.ofHours(1);
99 private static final ZoneOffset OFFSET_PTWO = ZoneOffset.ofHours(2);
100 public static final String LATEST_TZDB = "2009b";
101 private static final int OVERLAP = 2;
102 private static final int GAP = 0;
103
104 //-----------------------------------------------------------------------
105 // Basics
106 //-----------------------------------------------------------------------
107 public void test_serialization_loaded() throws Exception {
125 }
126
127 //-----------------------------------------------------------------------
128 // Europe/London
129 //-----------------------------------------------------------------------
130 private ZoneRules europeLondon() {
131 return ZoneId.of("Europe/London").getRules();
132 }
133
134 public void test_London() {
135 ZoneRules test = europeLondon();
136 assertEquals(test.isFixedOffset(), false);
137 }
138
139 public void test_London_preTimeZones() {
140 ZoneRules test = europeLondon();
141 ZonedDateTime old = createZDT(1800, 1, 1, ZoneOffset.UTC);
142 Instant instant = old.toInstant();
143 ZoneOffset offset = ZoneOffset.ofHoursMinutesSeconds(0, -1, -15);
144 assertEquals(test.getOffset(instant), offset);
145 checkOffset(test, old.getDateTime(), offset, 1);
146 assertEquals(test.getStandardOffset(instant), offset);
147 assertEquals(test.getDaylightSavings(instant), Duration.ZERO);
148 assertEquals(test.isDaylightSavings(instant), false);
149 }
150
151 public void test_London_getOffset() {
152 ZoneRules test = europeLondon();
153 assertEquals(test.getOffset(createInstant(2008, 1, 1, ZoneOffset.UTC)), OFFSET_ZERO);
154 assertEquals(test.getOffset(createInstant(2008, 2, 1, ZoneOffset.UTC)), OFFSET_ZERO);
155 assertEquals(test.getOffset(createInstant(2008, 3, 1, ZoneOffset.UTC)), OFFSET_ZERO);
156 assertEquals(test.getOffset(createInstant(2008, 4, 1, ZoneOffset.UTC)), OFFSET_PONE);
157 assertEquals(test.getOffset(createInstant(2008, 5, 1, ZoneOffset.UTC)), OFFSET_PONE);
158 assertEquals(test.getOffset(createInstant(2008, 6, 1, ZoneOffset.UTC)), OFFSET_PONE);
159 assertEquals(test.getOffset(createInstant(2008, 7, 1, ZoneOffset.UTC)), OFFSET_PONE);
160 assertEquals(test.getOffset(createInstant(2008, 8, 1, ZoneOffset.UTC)), OFFSET_PONE);
161 assertEquals(test.getOffset(createInstant(2008, 9, 1, ZoneOffset.UTC)), OFFSET_PONE);
162 assertEquals(test.getOffset(createInstant(2008, 10, 1, ZoneOffset.UTC)), OFFSET_PONE);
163 assertEquals(test.getOffset(createInstant(2008, 11, 1, ZoneOffset.UTC)), OFFSET_ZERO);
164 assertEquals(test.getOffset(createInstant(2008, 12, 1, ZoneOffset.UTC)), OFFSET_ZERO);
165 }
505 }
506
507 //-----------------------------------------------------------------------
508 // Europe/Paris
509 //-----------------------------------------------------------------------
510 private ZoneRules europeParis() {
511 return ZoneId.of("Europe/Paris").getRules();
512 }
513
514 public void test_Paris() {
515 ZoneRules test = europeParis();
516 assertEquals(test.isFixedOffset(), false);
517 }
518
519 public void test_Paris_preTimeZones() {
520 ZoneRules test = europeParis();
521 ZonedDateTime old = createZDT(1800, 1, 1, ZoneOffset.UTC);
522 Instant instant = old.toInstant();
523 ZoneOffset offset = ZoneOffset.ofHoursMinutesSeconds(0, 9, 21);
524 assertEquals(test.getOffset(instant), offset);
525 checkOffset(test, old.getDateTime(), offset, 1);
526 assertEquals(test.getStandardOffset(instant), offset);
527 assertEquals(test.getDaylightSavings(instant), Duration.ZERO);
528 assertEquals(test.isDaylightSavings(instant), false);
529 }
530
531 public void test_Paris_getOffset() {
532 ZoneRules test = europeParis();
533 assertEquals(test.getOffset(createInstant(2008, 1, 1, ZoneOffset.UTC)), OFFSET_PONE);
534 assertEquals(test.getOffset(createInstant(2008, 2, 1, ZoneOffset.UTC)), OFFSET_PONE);
535 assertEquals(test.getOffset(createInstant(2008, 3, 1, ZoneOffset.UTC)), OFFSET_PONE);
536 assertEquals(test.getOffset(createInstant(2008, 4, 1, ZoneOffset.UTC)), OFFSET_PTWO);
537 assertEquals(test.getOffset(createInstant(2008, 5, 1, ZoneOffset.UTC)), OFFSET_PTWO);
538 assertEquals(test.getOffset(createInstant(2008, 6, 1, ZoneOffset.UTC)), OFFSET_PTWO);
539 assertEquals(test.getOffset(createInstant(2008, 7, 1, ZoneOffset.UTC)), OFFSET_PTWO);
540 assertEquals(test.getOffset(createInstant(2008, 8, 1, ZoneOffset.UTC)), OFFSET_PTWO);
541 assertEquals(test.getOffset(createInstant(2008, 9, 1, ZoneOffset.UTC)), OFFSET_PTWO);
542 assertEquals(test.getOffset(createInstant(2008, 10, 1, ZoneOffset.UTC)), OFFSET_PTWO);
543 assertEquals(test.getOffset(createInstant(2008, 11, 1, ZoneOffset.UTC)), OFFSET_PONE);
544 assertEquals(test.getOffset(createInstant(2008, 12, 1, ZoneOffset.UTC)), OFFSET_PONE);
545 }
655 assertEquals(trans.isValidOffset(OFFSET_ZERO), false);
656 assertEquals(trans.isValidOffset(OFFSET_PONE), true);
657 assertEquals(trans.isValidOffset(OFFSET_PTWO), true);
658 assertEquals(trans.isValidOffset(ZoneOffset.ofHours(3)), false);
659 assertEquals(trans.toString(), "Transition[Overlap at 2008-10-26T03:00+02:00 to +01:00]");
660
661 assertFalse(trans.equals(null));
662 assertFalse(trans.equals(OFFSET_PTWO));
663 assertTrue(trans.equals(trans));
664
665 final ZoneOffsetTransition otherTrans = test.getTransition(dateTime);
666 assertTrue(trans.equals(otherTrans));
667 assertEquals(trans.hashCode(), otherTrans.hashCode());
668 }
669
670 public void test_Paris_getStandardOffset() {
671 ZoneRules test = europeParis();
672 ZonedDateTime zdt = createZDT(1840, 1, 1, ZoneOffset.UTC);
673 while (zdt.getYear() < 2010) {
674 Instant instant = zdt.toInstant();
675 if (zdt.getDate().isBefore(LocalDate.of(1911, 3, 11))) {
676 assertEquals(test.getStandardOffset(instant), ZoneOffset.ofHoursMinutesSeconds(0, 9, 21));
677 } else if (zdt.getDate().isBefore(LocalDate.of(1940, 6, 14))) {
678 assertEquals(test.getStandardOffset(instant), OFFSET_ZERO);
679 } else if (zdt.getDate().isBefore(LocalDate.of(1944, 8, 25))) {
680 assertEquals(test.getStandardOffset(instant), OFFSET_PONE);
681 } else if (zdt.getDate().isBefore(LocalDate.of(1945, 9, 16))) {
682 assertEquals(test.getStandardOffset(instant), OFFSET_ZERO);
683 } else {
684 assertEquals(test.getStandardOffset(instant), OFFSET_PONE);
685 }
686 zdt = zdt.plusMonths(6);
687 }
688 }
689
690 //-----------------------------------------------------------------------
691 // America/New_York
692 //-----------------------------------------------------------------------
693 private ZoneRules americaNewYork() {
694 return ZoneId.of("America/New_York").getRules();
695 }
696
697 public void test_NewYork() {
698 ZoneRules test = americaNewYork();
699 assertEquals(test.isFixedOffset(), false);
700 }
701
702 public void test_NewYork_preTimeZones() {
703 ZoneRules test = americaNewYork();
704 ZonedDateTime old = createZDT(1800, 1, 1, ZoneOffset.UTC);
705 Instant instant = old.toInstant();
706 ZoneOffset offset = ZoneOffset.of("-04:56:02");
707 assertEquals(test.getOffset(instant), offset);
708 checkOffset(test, old.getDateTime(), offset, 1);
709 assertEquals(test.getStandardOffset(instant), offset);
710 assertEquals(test.getDaylightSavings(instant), Duration.ZERO);
711 assertEquals(test.isDaylightSavings(instant), false);
712 }
713
714 public void test_NewYork_getOffset() {
715 ZoneRules test = americaNewYork();
716 ZoneOffset offset = ZoneOffset.ofHours(-5);
717 assertEquals(test.getOffset(createInstant(2008, 1, 1, offset)), ZoneOffset.ofHours(-5));
718 assertEquals(test.getOffset(createInstant(2008, 2, 1, offset)), ZoneOffset.ofHours(-5));
719 assertEquals(test.getOffset(createInstant(2008, 3, 1, offset)), ZoneOffset.ofHours(-5));
720 assertEquals(test.getOffset(createInstant(2008, 4, 1, offset)), ZoneOffset.ofHours(-4));
721 assertEquals(test.getOffset(createInstant(2008, 5, 1, offset)), ZoneOffset.ofHours(-4));
722 assertEquals(test.getOffset(createInstant(2008, 6, 1, offset)), ZoneOffset.ofHours(-4));
723 assertEquals(test.getOffset(createInstant(2008, 7, 1, offset)), ZoneOffset.ofHours(-4));
724 assertEquals(test.getOffset(createInstant(2008, 8, 1, offset)), ZoneOffset.ofHours(-4));
725 assertEquals(test.getOffset(createInstant(2008, 9, 1, offset)), ZoneOffset.ofHours(-4));
726 assertEquals(test.getOffset(createInstant(2008, 10, 1, offset)), ZoneOffset.ofHours(-4));
727 assertEquals(test.getOffset(createInstant(2008, 11, 1, offset)), ZoneOffset.ofHours(-4));
728 assertEquals(test.getOffset(createInstant(2008, 12, 1, offset)), ZoneOffset.ofHours(-5));
861 assertEquals(trans.isValidOffset(ZoneOffset.ofHours(-1)), false);
862 assertEquals(trans.isValidOffset(ZoneOffset.ofHours(-5)), true);
863 assertEquals(trans.isValidOffset(ZoneOffset.ofHours(-4)), true);
864 assertEquals(trans.isValidOffset(OFFSET_PTWO), false);
865 assertEquals(trans.toString(), "Transition[Overlap at 2008-11-02T02:00-04:00 to -05:00]");
866
867 assertFalse(trans.equals(null));
868 assertFalse(trans.equals(ZoneOffset.ofHours(-4)));
869 assertTrue(trans.equals(trans));
870
871 final ZoneOffsetTransition otherTrans = test.getTransition(dateTime);
872 assertTrue(trans.equals(otherTrans));
873 assertEquals(trans.hashCode(), otherTrans.hashCode());
874 }
875
876 public void test_NewYork_getStandardOffset() {
877 ZoneRules test = americaNewYork();
878 ZonedDateTime dateTime = createZDT(1860, 1, 1, ZoneOffset.UTC);
879 while (dateTime.getYear() < 2010) {
880 Instant instant = dateTime.toInstant();
881 if (dateTime.getDate().isBefore(LocalDate.of(1883, 11, 18))) {
882 assertEquals(test.getStandardOffset(instant), ZoneOffset.of("-04:56:02"));
883 } else {
884 assertEquals(test.getStandardOffset(instant), ZoneOffset.ofHours(-5));
885 }
886 dateTime = dateTime.plusMonths(6);
887 }
888 }
889
890 //-----------------------------------------------------------------------
891 // Kathmandu
892 //-----------------------------------------------------------------------
893 private ZoneRules asiaKathmandu() {
894 return ZoneId.of("Asia/Kathmandu").getRules();
895 }
896
897 public void test_Kathmandu_nextTransition_historic() {
898 ZoneRules test = asiaKathmandu();
899 List<ZoneOffsetTransition> trans = test.getTransitions();
900
901 ZoneOffsetTransition first = trans.get(0);
|
42 * and/or other materials provided with the distribution.
43 *
44 * * Neither the name of JSR-310 nor the names of its contributors
45 * may be used to endorse or promote products derived from this software
46 * without specific prior written permission.
47 *
48 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
49 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
50 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
51 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
52 * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
53 * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
54 * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
55 * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
56 * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
57 * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
58 * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
59 */
60 package tck.java.time.zone;
61
62 import static org.testng.Assert.assertEquals;
63 import static org.testng.Assert.assertFalse;
64 import static org.testng.Assert.assertNotNull;
65 import static org.testng.Assert.assertTrue;
66
67 import java.io.ByteArrayInputStream;
68 import java.io.ByteArrayOutputStream;
69 import java.io.ObjectInputStream;
70 import java.io.ObjectOutputStream;
71 import java.util.Iterator;
72 import java.util.List;
73
74 import java.time.DayOfWeek;
75 import java.time.Duration;
76 import java.time.Instant;
77 import java.time.LocalDate;
78 import java.time.LocalDateTime;
79 import java.time.LocalTime;
80 import java.time.Month;
81 import java.time.Year;
82 import java.time.ZoneId;
83 import java.time.ZoneOffset;
84 import java.time.ZonedDateTime;
85 import java.time.zone.ZoneOffsetTransition;
86 import java.time.zone.ZoneOffsetTransitionRule;
87 import java.time.zone.ZoneOffsetTransitionRule.TimeDefinition;
88 import java.time.zone.ZoneRules;
89
90 import org.testng.annotations.Test;
91
92 /**
93 * Test ZoneRules.
94 */
95 @Test
96 public class TCKZoneRules {
97
98 private static final ZoneOffset OFFSET_ZERO = ZoneOffset.ofHours(0);
99 private static final ZoneOffset OFFSET_PONE = ZoneOffset.ofHours(1);
100 private static final ZoneOffset OFFSET_PTWO = ZoneOffset.ofHours(2);
101 public static final String LATEST_TZDB = "2009b";
102 private static final int OVERLAP = 2;
103 private static final int GAP = 0;
104
105 //-----------------------------------------------------------------------
106 // Basics
107 //-----------------------------------------------------------------------
108 public void test_serialization_loaded() throws Exception {
126 }
127
128 //-----------------------------------------------------------------------
129 // Europe/London
130 //-----------------------------------------------------------------------
131 private ZoneRules europeLondon() {
132 return ZoneId.of("Europe/London").getRules();
133 }
134
135 public void test_London() {
136 ZoneRules test = europeLondon();
137 assertEquals(test.isFixedOffset(), false);
138 }
139
140 public void test_London_preTimeZones() {
141 ZoneRules test = europeLondon();
142 ZonedDateTime old = createZDT(1800, 1, 1, ZoneOffset.UTC);
143 Instant instant = old.toInstant();
144 ZoneOffset offset = ZoneOffset.ofHoursMinutesSeconds(0, -1, -15);
145 assertEquals(test.getOffset(instant), offset);
146 checkOffset(test, old.toLocalDateTime(), offset, 1);
147 assertEquals(test.getStandardOffset(instant), offset);
148 assertEquals(test.getDaylightSavings(instant), Duration.ZERO);
149 assertEquals(test.isDaylightSavings(instant), false);
150 }
151
152 public void test_London_getOffset() {
153 ZoneRules test = europeLondon();
154 assertEquals(test.getOffset(createInstant(2008, 1, 1, ZoneOffset.UTC)), OFFSET_ZERO);
155 assertEquals(test.getOffset(createInstant(2008, 2, 1, ZoneOffset.UTC)), OFFSET_ZERO);
156 assertEquals(test.getOffset(createInstant(2008, 3, 1, ZoneOffset.UTC)), OFFSET_ZERO);
157 assertEquals(test.getOffset(createInstant(2008, 4, 1, ZoneOffset.UTC)), OFFSET_PONE);
158 assertEquals(test.getOffset(createInstant(2008, 5, 1, ZoneOffset.UTC)), OFFSET_PONE);
159 assertEquals(test.getOffset(createInstant(2008, 6, 1, ZoneOffset.UTC)), OFFSET_PONE);
160 assertEquals(test.getOffset(createInstant(2008, 7, 1, ZoneOffset.UTC)), OFFSET_PONE);
161 assertEquals(test.getOffset(createInstant(2008, 8, 1, ZoneOffset.UTC)), OFFSET_PONE);
162 assertEquals(test.getOffset(createInstant(2008, 9, 1, ZoneOffset.UTC)), OFFSET_PONE);
163 assertEquals(test.getOffset(createInstant(2008, 10, 1, ZoneOffset.UTC)), OFFSET_PONE);
164 assertEquals(test.getOffset(createInstant(2008, 11, 1, ZoneOffset.UTC)), OFFSET_ZERO);
165 assertEquals(test.getOffset(createInstant(2008, 12, 1, ZoneOffset.UTC)), OFFSET_ZERO);
166 }
506 }
507
508 //-----------------------------------------------------------------------
509 // Europe/Paris
510 //-----------------------------------------------------------------------
511 private ZoneRules europeParis() {
512 return ZoneId.of("Europe/Paris").getRules();
513 }
514
515 public void test_Paris() {
516 ZoneRules test = europeParis();
517 assertEquals(test.isFixedOffset(), false);
518 }
519
520 public void test_Paris_preTimeZones() {
521 ZoneRules test = europeParis();
522 ZonedDateTime old = createZDT(1800, 1, 1, ZoneOffset.UTC);
523 Instant instant = old.toInstant();
524 ZoneOffset offset = ZoneOffset.ofHoursMinutesSeconds(0, 9, 21);
525 assertEquals(test.getOffset(instant), offset);
526 checkOffset(test, old.toLocalDateTime(), offset, 1);
527 assertEquals(test.getStandardOffset(instant), offset);
528 assertEquals(test.getDaylightSavings(instant), Duration.ZERO);
529 assertEquals(test.isDaylightSavings(instant), false);
530 }
531
532 public void test_Paris_getOffset() {
533 ZoneRules test = europeParis();
534 assertEquals(test.getOffset(createInstant(2008, 1, 1, ZoneOffset.UTC)), OFFSET_PONE);
535 assertEquals(test.getOffset(createInstant(2008, 2, 1, ZoneOffset.UTC)), OFFSET_PONE);
536 assertEquals(test.getOffset(createInstant(2008, 3, 1, ZoneOffset.UTC)), OFFSET_PONE);
537 assertEquals(test.getOffset(createInstant(2008, 4, 1, ZoneOffset.UTC)), OFFSET_PTWO);
538 assertEquals(test.getOffset(createInstant(2008, 5, 1, ZoneOffset.UTC)), OFFSET_PTWO);
539 assertEquals(test.getOffset(createInstant(2008, 6, 1, ZoneOffset.UTC)), OFFSET_PTWO);
540 assertEquals(test.getOffset(createInstant(2008, 7, 1, ZoneOffset.UTC)), OFFSET_PTWO);
541 assertEquals(test.getOffset(createInstant(2008, 8, 1, ZoneOffset.UTC)), OFFSET_PTWO);
542 assertEquals(test.getOffset(createInstant(2008, 9, 1, ZoneOffset.UTC)), OFFSET_PTWO);
543 assertEquals(test.getOffset(createInstant(2008, 10, 1, ZoneOffset.UTC)), OFFSET_PTWO);
544 assertEquals(test.getOffset(createInstant(2008, 11, 1, ZoneOffset.UTC)), OFFSET_PONE);
545 assertEquals(test.getOffset(createInstant(2008, 12, 1, ZoneOffset.UTC)), OFFSET_PONE);
546 }
656 assertEquals(trans.isValidOffset(OFFSET_ZERO), false);
657 assertEquals(trans.isValidOffset(OFFSET_PONE), true);
658 assertEquals(trans.isValidOffset(OFFSET_PTWO), true);
659 assertEquals(trans.isValidOffset(ZoneOffset.ofHours(3)), false);
660 assertEquals(trans.toString(), "Transition[Overlap at 2008-10-26T03:00+02:00 to +01:00]");
661
662 assertFalse(trans.equals(null));
663 assertFalse(trans.equals(OFFSET_PTWO));
664 assertTrue(trans.equals(trans));
665
666 final ZoneOffsetTransition otherTrans = test.getTransition(dateTime);
667 assertTrue(trans.equals(otherTrans));
668 assertEquals(trans.hashCode(), otherTrans.hashCode());
669 }
670
671 public void test_Paris_getStandardOffset() {
672 ZoneRules test = europeParis();
673 ZonedDateTime zdt = createZDT(1840, 1, 1, ZoneOffset.UTC);
674 while (zdt.getYear() < 2010) {
675 Instant instant = zdt.toInstant();
676 if (zdt.toLocalDate().isBefore(LocalDate.of(1911, 3, 11))) {
677 assertEquals(test.getStandardOffset(instant), ZoneOffset.ofHoursMinutesSeconds(0, 9, 21));
678 } else if (zdt.toLocalDate().isBefore(LocalDate.of(1940, 6, 14))) {
679 assertEquals(test.getStandardOffset(instant), OFFSET_ZERO);
680 } else if (zdt.toLocalDate().isBefore(LocalDate.of(1944, 8, 25))) {
681 assertEquals(test.getStandardOffset(instant), OFFSET_PONE);
682 } else if (zdt.toLocalDate().isBefore(LocalDate.of(1945, 9, 16))) {
683 assertEquals(test.getStandardOffset(instant), OFFSET_ZERO);
684 } else {
685 assertEquals(test.getStandardOffset(instant), OFFSET_PONE);
686 }
687 zdt = zdt.plusMonths(6);
688 }
689 }
690
691 //-----------------------------------------------------------------------
692 // America/New_York
693 //-----------------------------------------------------------------------
694 private ZoneRules americaNewYork() {
695 return ZoneId.of("America/New_York").getRules();
696 }
697
698 public void test_NewYork() {
699 ZoneRules test = americaNewYork();
700 assertEquals(test.isFixedOffset(), false);
701 }
702
703 public void test_NewYork_preTimeZones() {
704 ZoneRules test = americaNewYork();
705 ZonedDateTime old = createZDT(1800, 1, 1, ZoneOffset.UTC);
706 Instant instant = old.toInstant();
707 ZoneOffset offset = ZoneOffset.of("-04:56:02");
708 assertEquals(test.getOffset(instant), offset);
709 checkOffset(test, old.toLocalDateTime(), offset, 1);
710 assertEquals(test.getStandardOffset(instant), offset);
711 assertEquals(test.getDaylightSavings(instant), Duration.ZERO);
712 assertEquals(test.isDaylightSavings(instant), false);
713 }
714
715 public void test_NewYork_getOffset() {
716 ZoneRules test = americaNewYork();
717 ZoneOffset offset = ZoneOffset.ofHours(-5);
718 assertEquals(test.getOffset(createInstant(2008, 1, 1, offset)), ZoneOffset.ofHours(-5));
719 assertEquals(test.getOffset(createInstant(2008, 2, 1, offset)), ZoneOffset.ofHours(-5));
720 assertEquals(test.getOffset(createInstant(2008, 3, 1, offset)), ZoneOffset.ofHours(-5));
721 assertEquals(test.getOffset(createInstant(2008, 4, 1, offset)), ZoneOffset.ofHours(-4));
722 assertEquals(test.getOffset(createInstant(2008, 5, 1, offset)), ZoneOffset.ofHours(-4));
723 assertEquals(test.getOffset(createInstant(2008, 6, 1, offset)), ZoneOffset.ofHours(-4));
724 assertEquals(test.getOffset(createInstant(2008, 7, 1, offset)), ZoneOffset.ofHours(-4));
725 assertEquals(test.getOffset(createInstant(2008, 8, 1, offset)), ZoneOffset.ofHours(-4));
726 assertEquals(test.getOffset(createInstant(2008, 9, 1, offset)), ZoneOffset.ofHours(-4));
727 assertEquals(test.getOffset(createInstant(2008, 10, 1, offset)), ZoneOffset.ofHours(-4));
728 assertEquals(test.getOffset(createInstant(2008, 11, 1, offset)), ZoneOffset.ofHours(-4));
729 assertEquals(test.getOffset(createInstant(2008, 12, 1, offset)), ZoneOffset.ofHours(-5));
862 assertEquals(trans.isValidOffset(ZoneOffset.ofHours(-1)), false);
863 assertEquals(trans.isValidOffset(ZoneOffset.ofHours(-5)), true);
864 assertEquals(trans.isValidOffset(ZoneOffset.ofHours(-4)), true);
865 assertEquals(trans.isValidOffset(OFFSET_PTWO), false);
866 assertEquals(trans.toString(), "Transition[Overlap at 2008-11-02T02:00-04:00 to -05:00]");
867
868 assertFalse(trans.equals(null));
869 assertFalse(trans.equals(ZoneOffset.ofHours(-4)));
870 assertTrue(trans.equals(trans));
871
872 final ZoneOffsetTransition otherTrans = test.getTransition(dateTime);
873 assertTrue(trans.equals(otherTrans));
874 assertEquals(trans.hashCode(), otherTrans.hashCode());
875 }
876
877 public void test_NewYork_getStandardOffset() {
878 ZoneRules test = americaNewYork();
879 ZonedDateTime dateTime = createZDT(1860, 1, 1, ZoneOffset.UTC);
880 while (dateTime.getYear() < 2010) {
881 Instant instant = dateTime.toInstant();
882 if (dateTime.toLocalDate().isBefore(LocalDate.of(1883, 11, 18))) {
883 assertEquals(test.getStandardOffset(instant), ZoneOffset.of("-04:56:02"));
884 } else {
885 assertEquals(test.getStandardOffset(instant), ZoneOffset.ofHours(-5));
886 }
887 dateTime = dateTime.plusMonths(6);
888 }
889 }
890
891 //-----------------------------------------------------------------------
892 // Kathmandu
893 //-----------------------------------------------------------------------
894 private ZoneRules asiaKathmandu() {
895 return ZoneId.of("Asia/Kathmandu").getRules();
896 }
897
898 public void test_Kathmandu_nextTransition_historic() {
899 ZoneRules test = asiaKathmandu();
900 List<ZoneOffsetTransition> trans = test.getTransitions();
901
902 ZoneOffsetTransition first = trans.get(0);
|