• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1 /*
2  * Copyright (c) 2007-present, Stephen Colebourne & Michael Nascimento Santos
3  *
4  * All rights reserved.
5  *
6  * Redistribution and use in source and binary forms, with or without
7  * modification, are permitted provided that the following conditions are met:
8  *
9  *  * Redistributions of source code must retain the above copyright notice,
10  *    this list of conditions and the following disclaimer.
11  *
12  *  * Redistributions in binary form must reproduce the above copyright notice,
13  *    this list of conditions and the following disclaimer in the documentation
14  *    and/or other materials provided with the distribution.
15  *
16  *  * Neither the name of JSR-310 nor the names of its contributors
17  *    may be used to endorse or promote products derived from this software
18  *    without specific prior written permission.
19  *
20  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
21  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
22  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
23  * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
24  * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
25  * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
26  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
27  * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
28  * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
29  * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
30  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
31  */
32 package org.threeten.bp.zone;
33 
34 import static org.testng.Assert.assertEquals;
35 import static org.testng.Assert.assertFalse;
36 import static org.testng.Assert.assertNotNull;
37 import static org.testng.Assert.assertNull;
38 import static org.testng.Assert.assertTrue;
39 
40 import java.io.ByteArrayInputStream;
41 import java.io.ByteArrayOutputStream;
42 import java.io.ObjectInputStream;
43 import java.io.ObjectOutputStream;
44 import java.util.ArrayList;
45 import java.util.Iterator;
46 import java.util.List;
47 
48 import org.testng.annotations.Test;
49 import org.threeten.bp.DayOfWeek;
50 import org.threeten.bp.Duration;
51 import org.threeten.bp.Instant;
52 import org.threeten.bp.LocalDate;
53 import org.threeten.bp.LocalDateTime;
54 import org.threeten.bp.LocalTime;
55 import org.threeten.bp.Month;
56 import org.threeten.bp.Year;
57 import org.threeten.bp.ZoneId;
58 import org.threeten.bp.ZoneOffset;
59 import org.threeten.bp.ZonedDateTime;
60 import org.threeten.bp.format.DateTimeFormatter;
61 import org.threeten.bp.format.DateTimeFormatterBuilder;
62 import org.threeten.bp.format.TextStyle;
63 import org.threeten.bp.zone.ZoneOffsetTransitionRule.TimeDefinition;
64 
65 /**
66  * Test ZoneRules.
67  */
68 @Test
69 public class TestStandardZoneRules {
70 
71     private static final ZoneOffset OFFSET_ZERO = ZoneOffset.ofHours(0);
72     private static final ZoneOffset OFFSET_PONE = ZoneOffset.ofHours(1);
73     private static final ZoneOffset OFFSET_PTWO = ZoneOffset.ofHours(2);
74     public static final String LATEST_TZDB = "2009b";
75     private static final int OVERLAP = 2;
76     private static final int GAP = 0;
77 
78     //-----------------------------------------------------------------------
79     // Basics
80     //-----------------------------------------------------------------------
test_serialization_loaded()81     public void test_serialization_loaded() throws Exception {
82         assertSerialization(europeLondon());
83         assertSerialization(europeParis());
84         assertSerialization(americaNewYork());
85     }
86 
assertSerialization(ZoneRules test)87     private void assertSerialization(ZoneRules test) throws Exception {
88         ByteArrayOutputStream baos = new ByteArrayOutputStream();
89         ObjectOutputStream out = new ObjectOutputStream(baos);
90         out.writeObject(test);
91         baos.close();
92         byte[] bytes = baos.toByteArray();
93 
94         ByteArrayInputStream bais = new ByteArrayInputStream(bytes);
95         ObjectInputStream in = new ObjectInputStream(bais);
96         ZoneRules result = (ZoneRules) in.readObject();
97 
98         assertEquals(result, test);
99     }
100 
101     //-----------------------------------------------------------------------
102     // Etc/GMT
103     //-----------------------------------------------------------------------
etcGmt()104     private ZoneRules etcGmt() {
105         return ZoneId.of("Etc/GMT").getRules();
106     }
107 
test_EtcGmt_nextTransition()108     public void test_EtcGmt_nextTransition() {
109         assertNull(etcGmt().nextTransition(Instant.EPOCH));
110     }
111 
test_EtcGmt_previousTransition()112     public void test_EtcGmt_previousTransition() {
113         assertNull(etcGmt().previousTransition(Instant.EPOCH));
114     }
115 
116     //-----------------------------------------------------------------------
117     // Europe/London
118     //-----------------------------------------------------------------------
europeLondon()119     private ZoneRules europeLondon() {
120         return ZoneId.of("Europe/London").getRules();
121     }
122 
test_London()123     public void test_London() {
124         ZoneRules test = europeLondon();
125         assertEquals(test.isFixedOffset(), false);
126     }
127 
test_London_preTimeZones()128     public void test_London_preTimeZones() {
129         ZoneRules test = europeLondon();
130         ZonedDateTime old = createZDT(1800, 1, 1, ZoneOffset.UTC);
131         Instant instant = old.toInstant();
132         ZoneOffset offset = ZoneOffset.ofHoursMinutesSeconds(0, -1, -15);
133         assertEquals(test.getOffset(instant), offset);
134         checkOffset(test, old.toLocalDateTime(), offset, 1);
135         assertEquals(test.getStandardOffset(instant), offset);
136         assertEquals(test.getDaylightSavings(instant), Duration.ZERO);
137         assertEquals(test.isDaylightSavings(instant), false);
138     }
139 
test_London_getOffset()140     public void test_London_getOffset() {
141         ZoneRules test = europeLondon();
142         assertEquals(test.getOffset(createInstant(2008, 1, 1, ZoneOffset.UTC)), OFFSET_ZERO);
143         assertEquals(test.getOffset(createInstant(2008, 2, 1, ZoneOffset.UTC)), OFFSET_ZERO);
144         assertEquals(test.getOffset(createInstant(2008, 3, 1, ZoneOffset.UTC)), OFFSET_ZERO);
145         assertEquals(test.getOffset(createInstant(2008, 4, 1, ZoneOffset.UTC)), OFFSET_PONE);
146         assertEquals(test.getOffset(createInstant(2008, 5, 1, ZoneOffset.UTC)), OFFSET_PONE);
147         assertEquals(test.getOffset(createInstant(2008, 6, 1, ZoneOffset.UTC)), OFFSET_PONE);
148         assertEquals(test.getOffset(createInstant(2008, 7, 1, ZoneOffset.UTC)), OFFSET_PONE);
149         assertEquals(test.getOffset(createInstant(2008, 8, 1, ZoneOffset.UTC)), OFFSET_PONE);
150         assertEquals(test.getOffset(createInstant(2008, 9, 1, ZoneOffset.UTC)), OFFSET_PONE);
151         assertEquals(test.getOffset(createInstant(2008, 10, 1, ZoneOffset.UTC)), OFFSET_PONE);
152         assertEquals(test.getOffset(createInstant(2008, 11, 1, ZoneOffset.UTC)), OFFSET_ZERO);
153         assertEquals(test.getOffset(createInstant(2008, 12, 1, ZoneOffset.UTC)), OFFSET_ZERO);
154     }
155 
test_London_getOffset_toDST()156     public void test_London_getOffset_toDST() {
157         ZoneRules test = europeLondon();
158         assertEquals(test.getOffset(createInstant(2008, 3, 24, ZoneOffset.UTC)), OFFSET_ZERO);
159         assertEquals(test.getOffset(createInstant(2008, 3, 25, ZoneOffset.UTC)), OFFSET_ZERO);
160         assertEquals(test.getOffset(createInstant(2008, 3, 26, ZoneOffset.UTC)), OFFSET_ZERO);
161         assertEquals(test.getOffset(createInstant(2008, 3, 27, ZoneOffset.UTC)), OFFSET_ZERO);
162         assertEquals(test.getOffset(createInstant(2008, 3, 28, ZoneOffset.UTC)), OFFSET_ZERO);
163         assertEquals(test.getOffset(createInstant(2008, 3, 29, ZoneOffset.UTC)), OFFSET_ZERO);
164         assertEquals(test.getOffset(createInstant(2008, 3, 30, ZoneOffset.UTC)), OFFSET_ZERO);
165         assertEquals(test.getOffset(createInstant(2008, 3, 31, ZoneOffset.UTC)), OFFSET_PONE);
166         // cutover at 01:00Z
167         assertEquals(test.getOffset(createInstant(2008, 3, 30, 0, 59, 59, 999999999, ZoneOffset.UTC)), OFFSET_ZERO);
168         assertEquals(test.getOffset(createInstant(2008, 3, 30, 1, 0, 0, 0, ZoneOffset.UTC)), OFFSET_PONE);
169     }
170 
test_London_getOffset_fromDST()171     public void test_London_getOffset_fromDST() {
172         ZoneRules test = europeLondon();
173         assertEquals(test.getOffset(createInstant(2008, 10, 24, ZoneOffset.UTC)), OFFSET_PONE);
174         assertEquals(test.getOffset(createInstant(2008, 10, 25, ZoneOffset.UTC)), OFFSET_PONE);
175         assertEquals(test.getOffset(createInstant(2008, 10, 26, ZoneOffset.UTC)), OFFSET_PONE);
176         assertEquals(test.getOffset(createInstant(2008, 10, 27, ZoneOffset.UTC)), OFFSET_ZERO);
177         assertEquals(test.getOffset(createInstant(2008, 10, 28, ZoneOffset.UTC)), OFFSET_ZERO);
178         assertEquals(test.getOffset(createInstant(2008, 10, 29, ZoneOffset.UTC)), OFFSET_ZERO);
179         assertEquals(test.getOffset(createInstant(2008, 10, 30, ZoneOffset.UTC)), OFFSET_ZERO);
180         assertEquals(test.getOffset(createInstant(2008, 10, 31, ZoneOffset.UTC)), OFFSET_ZERO);
181         // cutover at 01:00Z
182         assertEquals(test.getOffset(createInstant(2008, 10, 26, 0, 59, 59, 999999999, ZoneOffset.UTC)), OFFSET_PONE);
183         assertEquals(test.getOffset(createInstant(2008, 10, 26, 1, 0, 0, 0, ZoneOffset.UTC)), OFFSET_ZERO);
184     }
185 
test_London_getOffsetInfo()186     public void test_London_getOffsetInfo() {
187         ZoneRules test = europeLondon();
188         checkOffset(test, createLDT(2008, 1, 1), OFFSET_ZERO, 1);
189         checkOffset(test, createLDT(2008, 2, 1), OFFSET_ZERO, 1);
190         checkOffset(test, createLDT(2008, 3, 1), OFFSET_ZERO, 1);
191         checkOffset(test, createLDT(2008, 4, 1), OFFSET_PONE, 1);
192         checkOffset(test, createLDT(2008, 5, 1), OFFSET_PONE, 1);
193         checkOffset(test, createLDT(2008, 6, 1), OFFSET_PONE, 1);
194         checkOffset(test, createLDT(2008, 7, 1), OFFSET_PONE, 1);
195         checkOffset(test, createLDT(2008, 8, 1), OFFSET_PONE, 1);
196         checkOffset(test, createLDT(2008, 9, 1), OFFSET_PONE, 1);
197         checkOffset(test, createLDT(2008, 10, 1), OFFSET_PONE, 1);
198         checkOffset(test, createLDT(2008, 11, 1), OFFSET_ZERO, 1);
199         checkOffset(test, createLDT(2008, 12, 1), OFFSET_ZERO, 1);
200     }
201 
test_London_getOffsetInfo_toDST()202     public void test_London_getOffsetInfo_toDST() {
203         ZoneRules test = europeLondon();
204         checkOffset(test, createLDT(2008, 3, 24), OFFSET_ZERO, 1);
205         checkOffset(test, createLDT(2008, 3, 25), OFFSET_ZERO, 1);
206         checkOffset(test, createLDT(2008, 3, 26), OFFSET_ZERO, 1);
207         checkOffset(test, createLDT(2008, 3, 27), OFFSET_ZERO, 1);
208         checkOffset(test, createLDT(2008, 3, 28), OFFSET_ZERO, 1);
209         checkOffset(test, createLDT(2008, 3, 29), OFFSET_ZERO, 1);
210         checkOffset(test, createLDT(2008, 3, 30), OFFSET_ZERO, 1);
211         checkOffset(test, createLDT(2008, 3, 31), OFFSET_PONE, 1);
212         // cutover at 01:00Z
213         checkOffset(test, LocalDateTime.of(2008, 3, 30, 0, 59, 59, 999999999), OFFSET_ZERO, 1);
214         checkOffset(test, LocalDateTime.of(2008, 3, 30, 2, 0, 0, 0), OFFSET_PONE, 1);
215     }
216 
test_London_getOffsetInfo_fromDST()217     public void test_London_getOffsetInfo_fromDST() {
218         ZoneRules test = europeLondon();
219         checkOffset(test, createLDT(2008, 10, 24), OFFSET_PONE, 1);
220         checkOffset(test, createLDT(2008, 10, 25), OFFSET_PONE, 1);
221         checkOffset(test, createLDT(2008, 10, 26), OFFSET_PONE, 1);
222         checkOffset(test, createLDT(2008, 10, 27), OFFSET_ZERO, 1);
223         checkOffset(test, createLDT(2008, 10, 28), OFFSET_ZERO, 1);
224         checkOffset(test, createLDT(2008, 10, 29), OFFSET_ZERO, 1);
225         checkOffset(test, createLDT(2008, 10, 30), OFFSET_ZERO, 1);
226         checkOffset(test, createLDT(2008, 10, 31), OFFSET_ZERO, 1);
227         // cutover at 01:00Z
228         checkOffset(test, LocalDateTime.of(2008, 10, 26, 0, 59, 59, 999999999), OFFSET_PONE, 1);
229         checkOffset(test, LocalDateTime.of(2008, 10, 26, 2, 0, 0, 0), OFFSET_ZERO, 1);
230     }
231 
test_London_getOffsetInfo_gap()232     public void test_London_getOffsetInfo_gap() {
233         ZoneRules test = europeLondon();
234         final LocalDateTime dateTime = LocalDateTime.of(2008, 3, 30, 1, 0, 0, 0);
235         ZoneOffsetTransition trans = checkOffset(test, dateTime, OFFSET_ZERO, GAP);
236         assertEquals(trans.isGap(), true);
237         assertEquals(trans.isOverlap(), false);
238         assertEquals(trans.getOffsetBefore(), OFFSET_ZERO);
239         assertEquals(trans.getOffsetAfter(), OFFSET_PONE);
240         assertEquals(trans.getInstant(), createInstant(2008, 3, 30, 1, 0, ZoneOffset.UTC));
241         assertEquals(trans.getDateTimeBefore(), LocalDateTime.of(2008, 3, 30, 1, 0));
242         assertEquals(trans.getDateTimeAfter(), LocalDateTime.of(2008, 3, 30, 2, 0));
243         assertEquals(trans.isValidOffset(OFFSET_ZERO), false);
244         assertEquals(trans.isValidOffset(OFFSET_PONE), false);
245         assertEquals(trans.isValidOffset(OFFSET_PTWO), false);
246         assertEquals(trans.toString(), "Transition[Gap at 2008-03-30T01:00Z to +01:00]");
247 
248         assertFalse(trans.equals(null));
249         assertFalse(trans.equals(OFFSET_ZERO));
250         assertTrue(trans.equals(trans));
251 
252         final ZoneOffsetTransition otherTrans = test.getTransition(dateTime);
253         assertTrue(trans.equals(otherTrans));
254         assertEquals(trans.hashCode(), otherTrans.hashCode());
255     }
256 
test_London_getOffsetInfo_overlap()257     public void test_London_getOffsetInfo_overlap() {
258         ZoneRules test = europeLondon();
259         final LocalDateTime dateTime = LocalDateTime.of(2008, 10, 26, 1, 0, 0, 0);
260         ZoneOffsetTransition trans = checkOffset(test, dateTime, OFFSET_PONE, OVERLAP);
261         assertEquals(trans.isGap(), false);
262         assertEquals(trans.isOverlap(), true);
263         assertEquals(trans.getOffsetBefore(), OFFSET_PONE);
264         assertEquals(trans.getOffsetAfter(), OFFSET_ZERO);
265         assertEquals(trans.getInstant(), createInstant(2008, 10, 26, 1, 0, ZoneOffset.UTC));
266         assertEquals(trans.getDateTimeBefore(), LocalDateTime.of(2008, 10, 26, 2, 0));
267         assertEquals(trans.getDateTimeAfter(), LocalDateTime.of(2008, 10, 26, 1, 0));
268         assertEquals(trans.isValidOffset(ZoneOffset.ofHours(-1)), false);
269         assertEquals(trans.isValidOffset(OFFSET_ZERO), true);
270         assertEquals(trans.isValidOffset(OFFSET_PONE), true);
271         assertEquals(trans.isValidOffset(OFFSET_PTWO), false);
272         assertEquals(trans.toString(), "Transition[Overlap at 2008-10-26T02:00+01:00 to Z]");
273 
274         assertFalse(trans.equals(null));
275         assertFalse(trans.equals(OFFSET_PONE));
276         assertTrue(trans.equals(trans));
277 
278         final ZoneOffsetTransition otherTrans = test.getTransition(dateTime);
279         assertTrue(trans.equals(otherTrans));
280         assertEquals(trans.hashCode(), otherTrans.hashCode());
281     }
282 
test_London_getStandardOffset()283     public void test_London_getStandardOffset() {
284         ZoneRules test = europeLondon();
285         ZonedDateTime zdt = createZDT(1840, 1, 1, ZoneOffset.UTC);
286         while (zdt.getYear() < 2010) {
287             Instant instant = zdt.toInstant();
288             if (zdt.getYear() < 1848) {
289                 assertEquals(test.getStandardOffset(instant), ZoneOffset.ofHoursMinutesSeconds(0, -1, -15));
290             } else if (zdt.getYear() >= 1969 && zdt.getYear() < 1972) {
291                 assertEquals(test.getStandardOffset(instant), OFFSET_PONE);
292             } else {
293                 assertEquals(test.getStandardOffset(instant), OFFSET_ZERO);
294             }
295             zdt = zdt.plusMonths(6);
296         }
297     }
298 
test_London_getTransitions()299     public void test_London_getTransitions() {
300         ZoneRules test = europeLondon();
301         List<ZoneOffsetTransition> trans = test.getTransitions();
302 
303         ZoneOffsetTransition first = trans.get(0);
304         assertEquals(first.getDateTimeBefore(), LocalDateTime.of(1847, 12, 1, 0, 0));
305         assertEquals(first.getOffsetBefore(), ZoneOffset.ofHoursMinutesSeconds(0, -1, -15));
306         assertEquals(first.getOffsetAfter(), OFFSET_ZERO);
307 
308         ZoneOffsetTransition spring1916 = trans.get(1);
309         assertEquals(spring1916.getDateTimeBefore(), LocalDateTime.of(1916, 5, 21, 2, 0));
310         assertEquals(spring1916.getOffsetBefore(), OFFSET_ZERO);
311         assertEquals(spring1916.getOffsetAfter(), OFFSET_PONE);
312 
313         ZoneOffsetTransition autumn1916 = trans.get(2);
314         assertEquals(autumn1916.getDateTimeBefore(), LocalDateTime.of(1916, 10, 1, 3, 0));
315         assertEquals(autumn1916.getOffsetBefore(), OFFSET_PONE);
316         assertEquals(autumn1916.getOffsetAfter(), OFFSET_ZERO);
317 
318         ZoneOffsetTransition zot = null;
319         Iterator<ZoneOffsetTransition> it = trans.iterator();
320         while (it.hasNext()) {
321             zot = it.next();
322             if (zot.getDateTimeBefore().getYear() == 1990) {
323                 break;
324             }
325         }
326         assertEquals(zot.getDateTimeBefore(), LocalDateTime.of(1990, 3, 25, 1, 0));
327         assertEquals(zot.getOffsetBefore(), OFFSET_ZERO);
328         zot = it.next();
329         assertEquals(zot.getDateTimeBefore(), LocalDateTime.of(1990, 10, 28, 2, 0));
330         assertEquals(zot.getOffsetBefore(), OFFSET_PONE);
331         zot = it.next();
332         assertEquals(zot.getDateTimeBefore(), LocalDateTime.of(1991, 3, 31, 1, 0));
333         assertEquals(zot.getOffsetBefore(), OFFSET_ZERO);
334         zot = it.next();
335         assertEquals(zot.getDateTimeBefore(), LocalDateTime.of(1991, 10, 27, 2, 0));
336         assertEquals(zot.getOffsetBefore(), OFFSET_PONE);
337         zot = it.next();
338         assertEquals(zot.getDateTimeBefore(), LocalDateTime.of(1992, 3, 29, 1, 0));
339         assertEquals(zot.getOffsetBefore(), OFFSET_ZERO);
340         zot = it.next();
341         assertEquals(zot.getDateTimeBefore(), LocalDateTime.of(1992, 10, 25, 2, 0));
342         assertEquals(zot.getOffsetBefore(), OFFSET_PONE);
343         zot = it.next();
344         assertEquals(zot.getDateTimeBefore(), LocalDateTime.of(1993, 3, 28, 1, 0));
345         assertEquals(zot.getOffsetBefore(), OFFSET_ZERO);
346         zot = it.next();
347         assertEquals(zot.getDateTimeBefore(), LocalDateTime.of(1993, 10, 24, 2, 0));
348         assertEquals(zot.getOffsetBefore(), OFFSET_PONE);
349         zot = it.next();
350         assertEquals(zot.getDateTimeBefore(), LocalDateTime.of(1994, 3, 27, 1, 0));
351         assertEquals(zot.getOffsetBefore(), OFFSET_ZERO);
352         zot = it.next();
353         assertEquals(zot.getDateTimeBefore(), LocalDateTime.of(1994, 10, 23, 2, 0));
354         assertEquals(zot.getOffsetBefore(), OFFSET_PONE);
355         zot = it.next();
356         assertEquals(zot.getDateTimeBefore(), LocalDateTime.of(1995, 3, 26, 1, 0));
357         assertEquals(zot.getOffsetBefore(), OFFSET_ZERO);
358         zot = it.next();
359         assertEquals(zot.getDateTimeBefore(), LocalDateTime.of(1995, 10, 22, 2, 0));
360         assertEquals(zot.getOffsetBefore(), OFFSET_PONE);
361         zot = it.next();
362         assertEquals(zot.getDateTimeBefore(), LocalDateTime.of(1996, 3, 31, 1, 0));
363         assertEquals(zot.getOffsetBefore(), OFFSET_ZERO);
364         zot = it.next();
365         assertEquals(zot.getDateTimeBefore(), LocalDateTime.of(1996, 10, 27, 2, 0));
366         assertEquals(zot.getOffsetBefore(), OFFSET_PONE);
367         zot = it.next();
368         assertEquals(zot.getDateTimeBefore(), LocalDateTime.of(1997, 3, 30, 1, 0));
369         assertEquals(zot.getOffsetBefore(), OFFSET_ZERO);
370         zot = it.next();
371         assertEquals(zot.getDateTimeBefore(), LocalDateTime.of(1997, 10, 26, 2, 0));
372         assertEquals(zot.getOffsetBefore(), OFFSET_PONE);
373         assertEquals(it.hasNext(), false);
374     }
375 
test_London_getTransitionRules()376     public void test_London_getTransitionRules() {
377         ZoneRules test = europeLondon();
378         List<ZoneOffsetTransitionRule> rules = test.getTransitionRules();
379         assertEquals(rules.size(), 2);
380 
381         ZoneOffsetTransitionRule in = rules.get(0);
382         assertEquals(in.getMonth(), Month.MARCH);
383         assertEquals(in.getDayOfMonthIndicator(), 25);  // optimized from -1
384         assertEquals(in.getDayOfWeek(), DayOfWeek.SUNDAY);
385         assertEquals(in.getLocalTime(), LocalTime.of(1, 0));
386         assertEquals(in.getTimeDefinition(), TimeDefinition.UTC);
387         assertEquals(in.getStandardOffset(), OFFSET_ZERO);
388         assertEquals(in.getOffsetBefore(), OFFSET_ZERO);
389         assertEquals(in.getOffsetAfter(), OFFSET_PONE);
390 
391         ZoneOffsetTransitionRule out = rules.get(1);
392         assertEquals(out.getMonth(), Month.OCTOBER);
393         assertEquals(out.getDayOfMonthIndicator(), 25);  // optimized from -1
394         assertEquals(out.getDayOfWeek(), DayOfWeek.SUNDAY);
395         assertEquals(out.getLocalTime(), LocalTime.of(1, 0));
396         assertEquals(out.getTimeDefinition(), TimeDefinition.UTC);
397         assertEquals(out.getStandardOffset(), OFFSET_ZERO);
398         assertEquals(out.getOffsetBefore(), OFFSET_PONE);
399         assertEquals(out.getOffsetAfter(), OFFSET_ZERO);
400     }
401 
402     //-----------------------------------------------------------------------
test_London_nextTransition_historic()403     public void test_London_nextTransition_historic() {
404         ZoneRules test = europeLondon();
405         List<ZoneOffsetTransition> trans = test.getTransitions();
406 
407         ZoneOffsetTransition first = trans.get(0);
408         assertEquals(test.nextTransition(first.getInstant().minusNanos(1)), first);
409 
410         for (int i = 0; i < trans.size() - 1; i++) {
411             ZoneOffsetTransition cur = trans.get(i);
412             ZoneOffsetTransition next = trans.get(i + 1);
413 
414             assertEquals(test.nextTransition(cur.getInstant()), next);
415             assertEquals(test.nextTransition(next.getInstant().minusNanos(1)), next);
416         }
417     }
418 
test_London_nextTransition_rulesBased()419     public void test_London_nextTransition_rulesBased() {
420         ZoneRules test = europeLondon();
421         List<ZoneOffsetTransitionRule> rules = test.getTransitionRules();
422         List<ZoneOffsetTransition> trans = test.getTransitions();
423 
424         ZoneOffsetTransition last = trans.get(trans.size() - 1);
425         assertEquals(test.nextTransition(last.getInstant()), rules.get(0).createTransition(1998));
426 
427         for (int year = 1998; year < 2010; year++) {
428             ZoneOffsetTransition a = rules.get(0).createTransition(year);
429             ZoneOffsetTransition b = rules.get(1).createTransition(year);
430             ZoneOffsetTransition c = rules.get(0).createTransition(year + 1);
431 
432             assertEquals(test.nextTransition(a.getInstant()), b);
433             assertEquals(test.nextTransition(b.getInstant().minusNanos(1)), b);
434 
435             assertEquals(test.nextTransition(b.getInstant()), c);
436             assertEquals(test.nextTransition(c.getInstant().minusNanos(1)), c);
437         }
438     }
439 
test_London_nextTransition_lastYear()440     public void test_London_nextTransition_lastYear() {
441         ZoneRules test = europeLondon();
442         List<ZoneOffsetTransitionRule> rules = test.getTransitionRules();
443         ZoneOffsetTransition zot = rules.get(1).createTransition(Year.MAX_VALUE);
444         assertEquals(test.nextTransition(zot.getInstant()), null);
445     }
446 
447     //-----------------------------------------------------------------------
test_London_previousTransition_historic()448     public void test_London_previousTransition_historic() {
449         ZoneRules test = europeLondon();
450         List<ZoneOffsetTransition> trans = test.getTransitions();
451 
452         ZoneOffsetTransition first = trans.get(0);
453         assertEquals(test.previousTransition(first.getInstant()), null);
454         assertEquals(test.previousTransition(first.getInstant().minusNanos(1)), null);
455 
456         for (int i = 0; i < trans.size() - 1; i++) {
457             ZoneOffsetTransition prev = trans.get(i);
458             ZoneOffsetTransition cur = trans.get(i + 1);
459 
460             assertEquals(test.previousTransition(cur.getInstant()), prev);
461             assertEquals(test.previousTransition(prev.getInstant().plusSeconds(1)), prev);
462             assertEquals(test.previousTransition(prev.getInstant().plusNanos(1)), prev);
463         }
464     }
465 
test_London_previousTransition_rulesBased()466     public void test_London_previousTransition_rulesBased() {
467         ZoneRules test = europeLondon();
468         List<ZoneOffsetTransitionRule> rules = test.getTransitionRules();
469         List<ZoneOffsetTransition> trans = test.getTransitions();
470 
471         ZoneOffsetTransition last = trans.get(trans.size() - 1);
472         assertEquals(test.previousTransition(last.getInstant().plusSeconds(1)), last);
473         assertEquals(test.previousTransition(last.getInstant().plusNanos(1)), last);
474 
475         // Jan 1st of year between transitions and rules
476         ZonedDateTime odt = ZonedDateTime.ofInstant(last.getInstant(), last.getOffsetAfter());
477         odt = odt.withDayOfYear(1).plusYears(1).with(LocalTime.MIDNIGHT);
478         assertEquals(test.previousTransition(odt.toInstant()), last);
479 
480         // later years
481         for (int year = 1998; year < 2010; year++) {
482             ZoneOffsetTransition a = rules.get(0).createTransition(year);
483             ZoneOffsetTransition b = rules.get(1).createTransition(year);
484             ZoneOffsetTransition c = rules.get(0).createTransition(year + 1);
485 
486             assertEquals(test.previousTransition(c.getInstant()), b);
487             assertEquals(test.previousTransition(b.getInstant().plusSeconds(1)), b);
488             assertEquals(test.previousTransition(b.getInstant().plusNanos(1)), b);
489 
490             assertEquals(test.previousTransition(b.getInstant()), a);
491             assertEquals(test.previousTransition(a.getInstant().plusSeconds(1)), a);
492             assertEquals(test.previousTransition(a.getInstant().plusNanos(1)), a);
493         }
494     }
495 
496     //-----------------------------------------------------------------------
497     // Europe/Dublin
498     //-----------------------------------------------------------------------
europeDublin()499     private ZoneRules europeDublin() {
500         return ZoneId.of("Europe/Dublin").getRules();
501     }
502 
test_Dublin()503     public void test_Dublin() {
504         ZoneRules test = europeDublin();
505         assertEquals(test.isFixedOffset(), false);
506     }
507 
test_Dublin_getOffset()508     public void test_Dublin_getOffset() {
509         ZoneRules test = europeDublin();
510         assertEquals(test.getOffset(createInstant(2008, 1, 1, ZoneOffset.UTC)), OFFSET_ZERO);
511         assertEquals(test.getOffset(createInstant(2008, 2, 1, ZoneOffset.UTC)), OFFSET_ZERO);
512         assertEquals(test.getOffset(createInstant(2008, 3, 1, ZoneOffset.UTC)), OFFSET_ZERO);
513         assertEquals(test.getOffset(createInstant(2008, 4, 1, ZoneOffset.UTC)), OFFSET_PONE);
514         assertEquals(test.getOffset(createInstant(2008, 5, 1, ZoneOffset.UTC)), OFFSET_PONE);
515         assertEquals(test.getOffset(createInstant(2008, 6, 1, ZoneOffset.UTC)), OFFSET_PONE);
516         assertEquals(test.getOffset(createInstant(2008, 7, 1, ZoneOffset.UTC)), OFFSET_PONE);
517         assertEquals(test.getOffset(createInstant(2008, 8, 1, ZoneOffset.UTC)), OFFSET_PONE);
518         assertEquals(test.getOffset(createInstant(2008, 9, 1, ZoneOffset.UTC)), OFFSET_PONE);
519         assertEquals(test.getOffset(createInstant(2008, 10, 1, ZoneOffset.UTC)), OFFSET_PONE);
520         assertEquals(test.getOffset(createInstant(2008, 11, 1, ZoneOffset.UTC)), OFFSET_ZERO);
521         assertEquals(test.getOffset(createInstant(2008, 12, 1, ZoneOffset.UTC)), OFFSET_ZERO);
522     }
523 
test_Dublin_getOffset_toDST()524     public void test_Dublin_getOffset_toDST() {
525         ZoneRules test = europeDublin();
526         assertEquals(test.getOffset(createInstant(2008, 3, 24, ZoneOffset.UTC)), OFFSET_ZERO);
527         assertEquals(test.getOffset(createInstant(2008, 3, 25, ZoneOffset.UTC)), OFFSET_ZERO);
528         assertEquals(test.getOffset(createInstant(2008, 3, 26, ZoneOffset.UTC)), OFFSET_ZERO);
529         assertEquals(test.getOffset(createInstant(2008, 3, 27, ZoneOffset.UTC)), OFFSET_ZERO);
530         assertEquals(test.getOffset(createInstant(2008, 3, 28, ZoneOffset.UTC)), OFFSET_ZERO);
531         assertEquals(test.getOffset(createInstant(2008, 3, 29, ZoneOffset.UTC)), OFFSET_ZERO);
532         assertEquals(test.getOffset(createInstant(2008, 3, 30, ZoneOffset.UTC)), OFFSET_ZERO);
533         assertEquals(test.getOffset(createInstant(2008, 3, 31, ZoneOffset.UTC)), OFFSET_PONE);
534         // cutover at 01:00Z
535         assertEquals(test.getOffset(createInstant(2008, 3, 30, 0, 59, 59, 999999999, ZoneOffset.UTC)), OFFSET_ZERO);
536         assertEquals(test.getOffset(createInstant(2008, 3, 30, 1, 0, 0, 0, ZoneOffset.UTC)), OFFSET_PONE);
537     }
538 
test_Dublin_getOffset_fromDST()539     public void test_Dublin_getOffset_fromDST() {
540         ZoneRules test = europeDublin();
541         assertEquals(test.getOffset(createInstant(2008, 10, 24, ZoneOffset.UTC)), OFFSET_PONE);
542         assertEquals(test.getOffset(createInstant(2008, 10, 25, ZoneOffset.UTC)), OFFSET_PONE);
543         assertEquals(test.getOffset(createInstant(2008, 10, 26, ZoneOffset.UTC)), OFFSET_PONE);
544         assertEquals(test.getOffset(createInstant(2008, 10, 27, ZoneOffset.UTC)), OFFSET_ZERO);
545         assertEquals(test.getOffset(createInstant(2008, 10, 28, ZoneOffset.UTC)), OFFSET_ZERO);
546         assertEquals(test.getOffset(createInstant(2008, 10, 29, ZoneOffset.UTC)), OFFSET_ZERO);
547         assertEquals(test.getOffset(createInstant(2008, 10, 30, ZoneOffset.UTC)), OFFSET_ZERO);
548         assertEquals(test.getOffset(createInstant(2008, 10, 31, ZoneOffset.UTC)), OFFSET_ZERO);
549         // cutover at 01:00Z
550         assertEquals(test.getOffset(createInstant(2008, 10, 26, 0, 59, 59, 999999999, ZoneOffset.UTC)), OFFSET_PONE);
551         assertEquals(test.getOffset(createInstant(2008, 10, 26, 1, 0, 0, 0, ZoneOffset.UTC)), OFFSET_ZERO);
552     }
553 
test_Dublin_getOffsetInfo()554     public void test_Dublin_getOffsetInfo() {
555         ZoneRules test = europeDublin();
556         checkOffset(test, createLDT(2008, 1, 1), OFFSET_ZERO, 1);
557         checkOffset(test, createLDT(2008, 2, 1), OFFSET_ZERO, 1);
558         checkOffset(test, createLDT(2008, 3, 1), OFFSET_ZERO, 1);
559         checkOffset(test, createLDT(2008, 4, 1), OFFSET_PONE, 1);
560         checkOffset(test, createLDT(2008, 5, 1), OFFSET_PONE, 1);
561         checkOffset(test, createLDT(2008, 6, 1), OFFSET_PONE, 1);
562         checkOffset(test, createLDT(2008, 7, 1), OFFSET_PONE, 1);
563         checkOffset(test, createLDT(2008, 8, 1), OFFSET_PONE, 1);
564         checkOffset(test, createLDT(2008, 9, 1), OFFSET_PONE, 1);
565         checkOffset(test, createLDT(2008, 10, 1), OFFSET_PONE, 1);
566         checkOffset(test, createLDT(2008, 11, 1), OFFSET_ZERO, 1);
567         checkOffset(test, createLDT(2008, 12, 1), OFFSET_ZERO, 1);
568     }
569 
test_Dublin_getOffsetInfo_toDST()570     public void test_Dublin_getOffsetInfo_toDST() {
571         ZoneRules test = europeDublin();
572         checkOffset(test, createLDT(2008, 3, 24), OFFSET_ZERO, 1);
573         checkOffset(test, createLDT(2008, 3, 25), OFFSET_ZERO, 1);
574         checkOffset(test, createLDT(2008, 3, 26), OFFSET_ZERO, 1);
575         checkOffset(test, createLDT(2008, 3, 27), OFFSET_ZERO, 1);
576         checkOffset(test, createLDT(2008, 3, 28), OFFSET_ZERO, 1);
577         checkOffset(test, createLDT(2008, 3, 29), OFFSET_ZERO, 1);
578         checkOffset(test, createLDT(2008, 3, 30), OFFSET_ZERO, 1);
579         checkOffset(test, createLDT(2008, 3, 31), OFFSET_PONE, 1);
580         // cutover at 01:00Z
581         checkOffset(test, LocalDateTime.of(2008, 3, 30, 0, 59, 59, 999999999), OFFSET_ZERO, 1);
582         checkOffset(test, LocalDateTime.of(2008, 3, 30, 2, 0, 0, 0), OFFSET_PONE, 1);
583     }
584 
test_Dublin_getOffsetInfo_fromDST()585     public void test_Dublin_getOffsetInfo_fromDST() {
586         ZoneRules test = europeDublin();
587         checkOffset(test, createLDT(2008, 10, 24), OFFSET_PONE, 1);
588         checkOffset(test, createLDT(2008, 10, 25), OFFSET_PONE, 1);
589         checkOffset(test, createLDT(2008, 10, 26), OFFSET_PONE, 1);
590         checkOffset(test, createLDT(2008, 10, 27), OFFSET_ZERO, 1);
591         checkOffset(test, createLDT(2008, 10, 28), OFFSET_ZERO, 1);
592         checkOffset(test, createLDT(2008, 10, 29), OFFSET_ZERO, 1);
593         checkOffset(test, createLDT(2008, 10, 30), OFFSET_ZERO, 1);
594         checkOffset(test, createLDT(2008, 10, 31), OFFSET_ZERO, 1);
595         // cutover at 01:00Z
596         checkOffset(test, LocalDateTime.of(2008, 10, 26, 0, 59, 59, 999999999), OFFSET_PONE, 1);
597         checkOffset(test, LocalDateTime.of(2008, 10, 26, 2, 0, 0, 0), OFFSET_ZERO, 1);
598     }
599 
test_Dublin_getOffsetInfo_gap()600     public void test_Dublin_getOffsetInfo_gap() {
601         ZoneRules test = europeDublin();
602         final LocalDateTime dateTime = LocalDateTime.of(2008, 3, 30, 1, 0, 0, 0);
603         ZoneOffsetTransition trans = checkOffset(test, dateTime, OFFSET_ZERO, GAP);
604         assertEquals(trans.isGap(), true);
605         assertEquals(trans.isOverlap(), false);
606         assertEquals(trans.getOffsetBefore(), OFFSET_ZERO);
607         assertEquals(trans.getOffsetAfter(), OFFSET_PONE);
608         assertEquals(trans.getInstant(), createInstant(2008, 3, 30, 1, 0, ZoneOffset.UTC));
609         assertEquals(trans.getDateTimeBefore(), LocalDateTime.of(2008, 3, 30, 1, 0));
610         assertEquals(trans.getDateTimeAfter(), LocalDateTime.of(2008, 3, 30, 2, 0));
611         assertEquals(trans.isValidOffset(OFFSET_ZERO), false);
612         assertEquals(trans.isValidOffset(OFFSET_PONE), false);
613         assertEquals(trans.isValidOffset(OFFSET_PTWO), false);
614         assertEquals(trans.toString(), "Transition[Gap at 2008-03-30T01:00Z to +01:00]");
615     }
616 
test_Dublin_getOffsetInfo_overlap()617     public void test_Dublin_getOffsetInfo_overlap() {
618         ZoneRules test = europeDublin();
619         final LocalDateTime dateTime = LocalDateTime.of(2008, 10, 26, 1, 0, 0, 0);
620         ZoneOffsetTransition trans = checkOffset(test, dateTime, OFFSET_PONE, OVERLAP);
621         assertEquals(trans.isGap(), false);
622         assertEquals(trans.isOverlap(), true);
623         assertEquals(trans.getOffsetBefore(), OFFSET_PONE);
624         assertEquals(trans.getOffsetAfter(), OFFSET_ZERO);
625         assertEquals(trans.getInstant(), createInstant(2008, 10, 26, 1, 0, ZoneOffset.UTC));
626         assertEquals(trans.getDateTimeBefore(), LocalDateTime.of(2008, 10, 26, 2, 0));
627         assertEquals(trans.getDateTimeAfter(), LocalDateTime.of(2008, 10, 26, 1, 0));
628         assertEquals(trans.isValidOffset(ZoneOffset.ofHours(-1)), false);
629         assertEquals(trans.isValidOffset(OFFSET_ZERO), true);
630         assertEquals(trans.isValidOffset(OFFSET_PONE), true);
631         assertEquals(trans.isValidOffset(OFFSET_PTWO), false);
632         assertEquals(trans.toString(), "Transition[Overlap at 2008-10-26T02:00+01:00 to Z]");
633     }
634 
test_Dublin_getStandardOffset()635     public void test_Dublin_getStandardOffset() {
636         ZoneRules test = europeDublin();
637         ZonedDateTime zdt = createZDT(1840, 1, 1, ZoneOffset.UTC);
638         while (zdt.getYear() < 2010) {
639             Instant instant = zdt.toInstant();
640             if (zdt.getYear() < 1917) {
641                 // skip
642             } else if (zdt.getYear() >= 1917 && zdt.getYear() < 1969) {
643                 assertEquals(test.getStandardOffset(instant), OFFSET_ZERO, zdt.toString());
644             } else if (zdt.getYear() >= 1969 && zdt.getYear() < 1972) {
645                 // from 1968-02-18 to 1971-10-31, permanent UTC+1
646                 assertEquals(test.getStandardOffset(instant), OFFSET_PONE);
647                 assertEquals(test.getOffset(instant), OFFSET_PONE, zdt.toString());
648             } else {
649                 assertEquals(test.getStandardOffset(instant), OFFSET_ZERO, zdt.toString());
650                 assertEquals(test.getOffset(instant), zdt.getMonth() == Month.JANUARY ? OFFSET_ZERO : OFFSET_PONE, zdt.toString());
651             }
652             zdt = zdt.plusMonths(6);
653         }
654     }
655 
test_Dublin_dst()656     public void test_Dublin_dst() {
657         ZoneRules test = europeDublin();
658         assertEquals(test.isDaylightSavings(createZDT(1960, 1, 1, ZoneOffset.UTC).toInstant()), false);
659         assertEquals(test.getDaylightSavings(createZDT(1960, 1, 1, ZoneOffset.UTC).toInstant()), Duration.ofHours(0));
660         assertEquals(test.isDaylightSavings(createZDT(1960, 7, 1, ZoneOffset.UTC).toInstant()), true);
661         assertEquals(test.getDaylightSavings(createZDT(1960, 7, 1, ZoneOffset.UTC).toInstant()), Duration.ofHours(1));
662         // check negative DST is correctly handled
663         assertEquals(test.isDaylightSavings(createZDT(2016, 1, 1, ZoneOffset.UTC).toInstant()), false);
664         assertEquals(test.getDaylightSavings(createZDT(2016, 1, 1, ZoneOffset.UTC).toInstant()), Duration.ofHours(0));
665         assertEquals(test.isDaylightSavings(createZDT(2016, 7, 1, ZoneOffset.UTC).toInstant()), true);
666         assertEquals(test.getDaylightSavings(createZDT(2016, 7, 1, ZoneOffset.UTC).toInstant()), Duration.ofHours(1));
667 
668         // TZDB data is messed up, comment out tests until better fix available
669         DateTimeFormatter formatter1 = new DateTimeFormatterBuilder().appendZoneText(TextStyle.FULL).toFormatter();
670         assertEquals(formatter1.format(createZDT(2016, 1, 1, ZoneId.of("Europe/Dublin"))), "Greenwich Mean Time");
671         assertEquals(formatter1.format(createZDT(2016, 7, 1, ZoneId.of("Europe/Dublin"))).startsWith("Irish S"), true);
672 
673         DateTimeFormatter formatter2 = new DateTimeFormatterBuilder().appendZoneText(TextStyle.SHORT).toFormatter();
674         assertEquals(formatter2.format(createZDT(2016, 1, 1, ZoneId.of("Europe/Dublin"))), "GMT");
675         assertEquals(formatter2.format(createZDT(2016, 7, 1, ZoneId.of("Europe/Dublin"))), "IST");
676     }
677 
678     //-----------------------------------------------------------------------
679     // Europe/Paris
680     //-----------------------------------------------------------------------
europeParis()681     private ZoneRules europeParis() {
682         return ZoneId.of("Europe/Paris").getRules();
683     }
684 
test_Paris()685     public void test_Paris() {
686         ZoneRules test = europeParis();
687         assertEquals(test.isFixedOffset(), false);
688     }
689 
test_Paris_preTimeZones()690     public void test_Paris_preTimeZones() {
691         ZoneRules test = europeParis();
692         ZonedDateTime old = createZDT(1800, 1, 1, ZoneOffset.UTC);
693         Instant instant = old.toInstant();
694         ZoneOffset offset = ZoneOffset.ofHoursMinutesSeconds(0, 9, 21);
695         assertEquals(test.getOffset(instant), offset);
696         checkOffset(test, old.toLocalDateTime(), offset, 1);
697         assertEquals(test.getStandardOffset(instant), offset);
698         assertEquals(test.getDaylightSavings(instant), Duration.ZERO);
699         assertEquals(test.isDaylightSavings(instant), false);
700     }
701 
test_Paris_getOffset()702     public void test_Paris_getOffset() {
703         ZoneRules test = europeParis();
704         assertEquals(test.getOffset(createInstant(2008, 1, 1, ZoneOffset.UTC)), OFFSET_PONE);
705         assertEquals(test.getOffset(createInstant(2008, 2, 1, ZoneOffset.UTC)), OFFSET_PONE);
706         assertEquals(test.getOffset(createInstant(2008, 3, 1, ZoneOffset.UTC)), OFFSET_PONE);
707         assertEquals(test.getOffset(createInstant(2008, 4, 1, ZoneOffset.UTC)), OFFSET_PTWO);
708         assertEquals(test.getOffset(createInstant(2008, 5, 1, ZoneOffset.UTC)), OFFSET_PTWO);
709         assertEquals(test.getOffset(createInstant(2008, 6, 1, ZoneOffset.UTC)), OFFSET_PTWO);
710         assertEquals(test.getOffset(createInstant(2008, 7, 1, ZoneOffset.UTC)), OFFSET_PTWO);
711         assertEquals(test.getOffset(createInstant(2008, 8, 1, ZoneOffset.UTC)), OFFSET_PTWO);
712         assertEquals(test.getOffset(createInstant(2008, 9, 1, ZoneOffset.UTC)), OFFSET_PTWO);
713         assertEquals(test.getOffset(createInstant(2008, 10, 1, ZoneOffset.UTC)), OFFSET_PTWO);
714         assertEquals(test.getOffset(createInstant(2008, 11, 1, ZoneOffset.UTC)), OFFSET_PONE);
715         assertEquals(test.getOffset(createInstant(2008, 12, 1, ZoneOffset.UTC)), OFFSET_PONE);
716     }
717 
test_Paris_getOffset_toDST()718     public void test_Paris_getOffset_toDST() {
719         ZoneRules test = europeParis();
720         assertEquals(test.getOffset(createInstant(2008, 3, 24, ZoneOffset.UTC)), OFFSET_PONE);
721         assertEquals(test.getOffset(createInstant(2008, 3, 25, ZoneOffset.UTC)), OFFSET_PONE);
722         assertEquals(test.getOffset(createInstant(2008, 3, 26, ZoneOffset.UTC)), OFFSET_PONE);
723         assertEquals(test.getOffset(createInstant(2008, 3, 27, ZoneOffset.UTC)), OFFSET_PONE);
724         assertEquals(test.getOffset(createInstant(2008, 3, 28, ZoneOffset.UTC)), OFFSET_PONE);
725         assertEquals(test.getOffset(createInstant(2008, 3, 29, ZoneOffset.UTC)), OFFSET_PONE);
726         assertEquals(test.getOffset(createInstant(2008, 3, 30, ZoneOffset.UTC)), OFFSET_PONE);
727         assertEquals(test.getOffset(createInstant(2008, 3, 31, ZoneOffset.UTC)), OFFSET_PTWO);
728         // cutover at 01:00Z
729         assertEquals(test.getOffset(createInstant(2008, 3, 30, 0, 59, 59, 999999999, ZoneOffset.UTC)), OFFSET_PONE);
730         assertEquals(test.getOffset(createInstant(2008, 3, 30, 1, 0, 0, 0, ZoneOffset.UTC)), OFFSET_PTWO);
731     }
732 
test_Paris_getOffset_fromDST()733     public void test_Paris_getOffset_fromDST() {
734         ZoneRules test = europeParis();
735         assertEquals(test.getOffset(createInstant(2008, 10, 24, ZoneOffset.UTC)), OFFSET_PTWO);
736         assertEquals(test.getOffset(createInstant(2008, 10, 25, ZoneOffset.UTC)), OFFSET_PTWO);
737         assertEquals(test.getOffset(createInstant(2008, 10, 26, ZoneOffset.UTC)), OFFSET_PTWO);
738         assertEquals(test.getOffset(createInstant(2008, 10, 27, ZoneOffset.UTC)), OFFSET_PONE);
739         assertEquals(test.getOffset(createInstant(2008, 10, 28, ZoneOffset.UTC)), OFFSET_PONE);
740         assertEquals(test.getOffset(createInstant(2008, 10, 29, ZoneOffset.UTC)), OFFSET_PONE);
741         assertEquals(test.getOffset(createInstant(2008, 10, 30, ZoneOffset.UTC)), OFFSET_PONE);
742         assertEquals(test.getOffset(createInstant(2008, 10, 31, ZoneOffset.UTC)), OFFSET_PONE);
743         // cutover at 01:00Z
744         assertEquals(test.getOffset(createInstant(2008, 10, 26, 0, 59, 59, 999999999, ZoneOffset.UTC)), OFFSET_PTWO);
745         assertEquals(test.getOffset(createInstant(2008, 10, 26, 1, 0, 0, 0, ZoneOffset.UTC)), OFFSET_PONE);
746     }
747 
test_Paris_getOffsetInfo()748     public void test_Paris_getOffsetInfo() {
749         ZoneRules test = europeParis();
750         checkOffset(test, createLDT(2008, 1, 1), OFFSET_PONE, 1);
751         checkOffset(test, createLDT(2008, 2, 1), OFFSET_PONE, 1);
752         checkOffset(test, createLDT(2008, 3, 1), OFFSET_PONE, 1);
753         checkOffset(test, createLDT(2008, 4, 1), OFFSET_PTWO, 1);
754         checkOffset(test, createLDT(2008, 5, 1), OFFSET_PTWO, 1);
755         checkOffset(test, createLDT(2008, 6, 1), OFFSET_PTWO, 1);
756         checkOffset(test, createLDT(2008, 7, 1), OFFSET_PTWO, 1);
757         checkOffset(test, createLDT(2008, 8, 1), OFFSET_PTWO, 1);
758         checkOffset(test, createLDT(2008, 9, 1), OFFSET_PTWO, 1);
759         checkOffset(test, createLDT(2008, 10, 1), OFFSET_PTWO, 1);
760         checkOffset(test, createLDT(2008, 11, 1), OFFSET_PONE, 1);
761         checkOffset(test, createLDT(2008, 12, 1), OFFSET_PONE, 1);
762     }
763 
test_Paris_getOffsetInfo_toDST()764     public void test_Paris_getOffsetInfo_toDST() {
765         ZoneRules test = europeParis();
766         checkOffset(test, createLDT(2008, 3, 24), OFFSET_PONE, 1);
767         checkOffset(test, createLDT(2008, 3, 25), OFFSET_PONE, 1);
768         checkOffset(test, createLDT(2008, 3, 26), OFFSET_PONE, 1);
769         checkOffset(test, createLDT(2008, 3, 27), OFFSET_PONE, 1);
770         checkOffset(test, createLDT(2008, 3, 28), OFFSET_PONE, 1);
771         checkOffset(test, createLDT(2008, 3, 29), OFFSET_PONE, 1);
772         checkOffset(test, createLDT(2008, 3, 30), OFFSET_PONE, 1);
773         checkOffset(test, createLDT(2008, 3, 31), OFFSET_PTWO, 1);
774         // cutover at 01:00Z which is 02:00+01:00(local Paris time)
775         checkOffset(test, LocalDateTime.of(2008, 3, 30, 1, 59, 59, 999999999), OFFSET_PONE, 1);
776         checkOffset(test, LocalDateTime.of(2008, 3, 30, 3, 0, 0, 0), OFFSET_PTWO, 1);
777     }
778 
test_Paris_getOffsetInfo_fromDST()779     public void test_Paris_getOffsetInfo_fromDST() {
780         ZoneRules test = europeParis();
781         checkOffset(test, createLDT(2008, 10, 24), OFFSET_PTWO, 1);
782         checkOffset(test, createLDT(2008, 10, 25), OFFSET_PTWO, 1);
783         checkOffset(test, createLDT(2008, 10, 26), OFFSET_PTWO, 1);
784         checkOffset(test, createLDT(2008, 10, 27), OFFSET_PONE, 1);
785         checkOffset(test, createLDT(2008, 10, 28), OFFSET_PONE, 1);
786         checkOffset(test, createLDT(2008, 10, 29), OFFSET_PONE, 1);
787         checkOffset(test, createLDT(2008, 10, 30), OFFSET_PONE, 1);
788         checkOffset(test, createLDT(2008, 10, 31), OFFSET_PONE, 1);
789         // cutover at 01:00Z which is 02:00+01:00(local Paris time)
790         checkOffset(test, LocalDateTime.of(2008, 10, 26, 1, 59, 59, 999999999), OFFSET_PTWO, 1);
791         checkOffset(test, LocalDateTime.of(2008, 10, 26, 3, 0, 0, 0), OFFSET_PONE, 1);
792     }
793 
test_Paris_getOffsetInfo_gap()794     public void test_Paris_getOffsetInfo_gap() {
795         ZoneRules test = europeParis();
796         final LocalDateTime dateTime = LocalDateTime.of(2008, 3, 30, 2, 0, 0, 0);
797         ZoneOffsetTransition trans = checkOffset(test, dateTime, OFFSET_PONE, GAP);
798         assertEquals(trans.isGap(), true);
799         assertEquals(trans.isOverlap(), false);
800         assertEquals(trans.getOffsetBefore(), OFFSET_PONE);
801         assertEquals(trans.getOffsetAfter(), OFFSET_PTWO);
802         assertEquals(trans.getInstant(), createInstant(2008, 3, 30, 1, 0, ZoneOffset.UTC));
803         assertEquals(trans.isValidOffset(OFFSET_ZERO), false);
804         assertEquals(trans.isValidOffset(OFFSET_PONE), false);
805         assertEquals(trans.isValidOffset(OFFSET_PTWO), false);
806         assertEquals(trans.toString(), "Transition[Gap at 2008-03-30T02:00+01:00 to +02:00]");
807 
808         assertFalse(trans.equals(null));
809         assertFalse(trans.equals(OFFSET_PONE));
810         assertTrue(trans.equals(trans));
811 
812         final ZoneOffsetTransition otherTrans = test.getTransition(dateTime);
813         assertTrue(trans.equals(otherTrans));
814         assertEquals(trans.hashCode(), otherTrans.hashCode());
815     }
816 
test_Paris_getOffsetInfo_overlap()817     public void test_Paris_getOffsetInfo_overlap() {
818         ZoneRules test = europeParis();
819         final LocalDateTime dateTime = LocalDateTime.of(2008, 10, 26, 2, 0, 0, 0);
820         ZoneOffsetTransition trans = checkOffset(test, dateTime, OFFSET_PTWO, OVERLAP);
821         assertEquals(trans.isGap(), false);
822         assertEquals(trans.isOverlap(), true);
823         assertEquals(trans.getOffsetBefore(), OFFSET_PTWO);
824         assertEquals(trans.getOffsetAfter(), OFFSET_PONE);
825         assertEquals(trans.getInstant(), createInstant(2008, 10, 26, 1, 0, ZoneOffset.UTC));
826         assertEquals(trans.isValidOffset(OFFSET_ZERO), false);
827         assertEquals(trans.isValidOffset(OFFSET_PONE), true);
828         assertEquals(trans.isValidOffset(OFFSET_PTWO), true);
829         assertEquals(trans.isValidOffset(ZoneOffset.ofHours(3)), false);
830         assertEquals(trans.toString(), "Transition[Overlap at 2008-10-26T03:00+02:00 to +01:00]");
831 
832         assertFalse(trans.equals(null));
833         assertFalse(trans.equals(OFFSET_PTWO));
834         assertTrue(trans.equals(trans));
835 
836         final ZoneOffsetTransition otherTrans = test.getTransition(dateTime);
837         assertTrue(trans.equals(otherTrans));
838         assertEquals(trans.hashCode(), otherTrans.hashCode());
839     }
840 
test_Paris_getStandardOffset()841     public void test_Paris_getStandardOffset() {
842         ZoneRules test = europeParis();
843         ZonedDateTime zdt = createZDT(1840, 1, 1, ZoneOffset.UTC);
844         while (zdt.getYear() < 2010) {
845             Instant instant = zdt.toInstant();
846             if (zdt.toLocalDate().isBefore(LocalDate.of(1911, 3, 11))) {
847                 assertEquals(test.getStandardOffset(instant), ZoneOffset.ofHoursMinutesSeconds(0, 9, 21));
848             } else if (zdt.toLocalDate().isBefore(LocalDate.of(1940, 6, 14))) {
849                 assertEquals(test.getStandardOffset(instant), OFFSET_ZERO);
850             } else if (zdt.toLocalDate().isBefore(LocalDate.of(1944, 8, 25))) {
851                 assertEquals(test.getStandardOffset(instant), OFFSET_PONE);
852             } else if (zdt.toLocalDate().isBefore(LocalDate.of(1945, 9, 16))) {
853                 assertEquals(test.getStandardOffset(instant), OFFSET_ZERO);
854             } else {
855                 assertEquals(test.getStandardOffset(instant), OFFSET_PONE);
856             }
857             zdt = zdt.plusMonths(6);
858         }
859     }
860 
861     //-----------------------------------------------------------------------
862     // America/New_York
863     //-----------------------------------------------------------------------
americaNewYork()864     private ZoneRules americaNewYork() {
865         return ZoneId.of("America/New_York").getRules();
866     }
867 
test_NewYork()868     public void test_NewYork() {
869         ZoneRules test = americaNewYork();
870         assertEquals(test.isFixedOffset(), false);
871     }
872 
test_NewYork_preTimeZones()873     public void test_NewYork_preTimeZones() {
874         ZoneRules test = americaNewYork();
875         ZonedDateTime old = createZDT(1800, 1, 1, ZoneOffset.UTC);
876         Instant instant = old.toInstant();
877         ZoneOffset offset = ZoneOffset.of("-04:56:02");
878         assertEquals(test.getOffset(instant), offset);
879         checkOffset(test, old.toLocalDateTime(), offset, 1);
880         assertEquals(test.getStandardOffset(instant), offset);
881         assertEquals(test.getDaylightSavings(instant), Duration.ZERO);
882         assertEquals(test.isDaylightSavings(instant), false);
883     }
884 
test_NewYork_getOffset()885     public void test_NewYork_getOffset() {
886         ZoneRules test = americaNewYork();
887         ZoneOffset offset = ZoneOffset.ofHours(-5);
888         assertEquals(test.getOffset(createInstant(2008, 1, 1, offset)), ZoneOffset.ofHours(-5));
889         assertEquals(test.getOffset(createInstant(2008, 2, 1, offset)), ZoneOffset.ofHours(-5));
890         assertEquals(test.getOffset(createInstant(2008, 3, 1, offset)), ZoneOffset.ofHours(-5));
891         assertEquals(test.getOffset(createInstant(2008, 4, 1, offset)), ZoneOffset.ofHours(-4));
892         assertEquals(test.getOffset(createInstant(2008, 5, 1, offset)), ZoneOffset.ofHours(-4));
893         assertEquals(test.getOffset(createInstant(2008, 6, 1, offset)), ZoneOffset.ofHours(-4));
894         assertEquals(test.getOffset(createInstant(2008, 7, 1, offset)), ZoneOffset.ofHours(-4));
895         assertEquals(test.getOffset(createInstant(2008, 8, 1, offset)), ZoneOffset.ofHours(-4));
896         assertEquals(test.getOffset(createInstant(2008, 9, 1, offset)), ZoneOffset.ofHours(-4));
897         assertEquals(test.getOffset(createInstant(2008, 10, 1, offset)), ZoneOffset.ofHours(-4));
898         assertEquals(test.getOffset(createInstant(2008, 11, 1, offset)), ZoneOffset.ofHours(-4));
899         assertEquals(test.getOffset(createInstant(2008, 12, 1, offset)), ZoneOffset.ofHours(-5));
900         assertEquals(test.getOffset(createInstant(2008, 1, 28, offset)), ZoneOffset.ofHours(-5));
901         assertEquals(test.getOffset(createInstant(2008, 2, 28, offset)), ZoneOffset.ofHours(-5));
902         assertEquals(test.getOffset(createInstant(2008, 3, 28, offset)), ZoneOffset.ofHours(-4));
903         assertEquals(test.getOffset(createInstant(2008, 4, 28, offset)), ZoneOffset.ofHours(-4));
904         assertEquals(test.getOffset(createInstant(2008, 5, 28, offset)), ZoneOffset.ofHours(-4));
905         assertEquals(test.getOffset(createInstant(2008, 6, 28, offset)), ZoneOffset.ofHours(-4));
906         assertEquals(test.getOffset(createInstant(2008, 7, 28, offset)), ZoneOffset.ofHours(-4));
907         assertEquals(test.getOffset(createInstant(2008, 8, 28, offset)), ZoneOffset.ofHours(-4));
908         assertEquals(test.getOffset(createInstant(2008, 9, 28, offset)), ZoneOffset.ofHours(-4));
909         assertEquals(test.getOffset(createInstant(2008, 10, 28, offset)), ZoneOffset.ofHours(-4));
910         assertEquals(test.getOffset(createInstant(2008, 11, 28, offset)), ZoneOffset.ofHours(-5));
911         assertEquals(test.getOffset(createInstant(2008, 12, 28, offset)), ZoneOffset.ofHours(-5));
912     }
913 
test_NewYork_getOffset_toDST()914     public void test_NewYork_getOffset_toDST() {
915         ZoneRules test = americaNewYork();
916         ZoneOffset offset = ZoneOffset.ofHours(-5);
917         assertEquals(test.getOffset(createInstant(2008, 3, 8, offset)), ZoneOffset.ofHours(-5));
918         assertEquals(test.getOffset(createInstant(2008, 3, 9, offset)), ZoneOffset.ofHours(-5));
919         assertEquals(test.getOffset(createInstant(2008, 3, 10, offset)), ZoneOffset.ofHours(-4));
920         assertEquals(test.getOffset(createInstant(2008, 3, 11, offset)), ZoneOffset.ofHours(-4));
921         assertEquals(test.getOffset(createInstant(2008, 3, 12, offset)), ZoneOffset.ofHours(-4));
922         assertEquals(test.getOffset(createInstant(2008, 3, 13, offset)), ZoneOffset.ofHours(-4));
923         assertEquals(test.getOffset(createInstant(2008, 3, 14, offset)), ZoneOffset.ofHours(-4));
924         // cutover at 02:00 local
925         assertEquals(test.getOffset(createInstant(2008, 3, 9, 1, 59, 59, 999999999, offset)), ZoneOffset.ofHours(-5));
926         assertEquals(test.getOffset(createInstant(2008, 3, 9, 2, 0, 0, 0, offset)), ZoneOffset.ofHours(-4));
927     }
928 
test_NewYork_getOffset_fromDST()929     public void test_NewYork_getOffset_fromDST() {
930         ZoneRules test = americaNewYork();
931         ZoneOffset offset = ZoneOffset.ofHours(-4);
932         assertEquals(test.getOffset(createInstant(2008, 11, 1, offset)), ZoneOffset.ofHours(-4));
933         assertEquals(test.getOffset(createInstant(2008, 11, 2, offset)), ZoneOffset.ofHours(-4));
934         assertEquals(test.getOffset(createInstant(2008, 11, 3, offset)), ZoneOffset.ofHours(-5));
935         assertEquals(test.getOffset(createInstant(2008, 11, 4, offset)), ZoneOffset.ofHours(-5));
936         assertEquals(test.getOffset(createInstant(2008, 11, 5, offset)), ZoneOffset.ofHours(-5));
937         assertEquals(test.getOffset(createInstant(2008, 11, 6, offset)), ZoneOffset.ofHours(-5));
938         assertEquals(test.getOffset(createInstant(2008, 11, 7, offset)), ZoneOffset.ofHours(-5));
939         // cutover at 02:00 local
940         assertEquals(test.getOffset(createInstant(2008, 11, 2, 1, 59, 59, 999999999, offset)), ZoneOffset.ofHours(-4));
941         assertEquals(test.getOffset(createInstant(2008, 11, 2, 2, 0, 0, 0, offset)), ZoneOffset.ofHours(-5));
942     }
943 
test_NewYork_getOffsetInfo()944     public void test_NewYork_getOffsetInfo() {
945         ZoneRules test = americaNewYork();
946         checkOffset(test, createLDT(2008, 1, 1), ZoneOffset.ofHours(-5), 1);
947         checkOffset(test, createLDT(2008, 2, 1), ZoneOffset.ofHours(-5), 1);
948         checkOffset(test, createLDT(2008, 3, 1), ZoneOffset.ofHours(-5), 1);
949         checkOffset(test, createLDT(2008, 4, 1), ZoneOffset.ofHours(-4), 1);
950         checkOffset(test, createLDT(2008, 5, 1), ZoneOffset.ofHours(-4), 1);
951         checkOffset(test, createLDT(2008, 6, 1), ZoneOffset.ofHours(-4), 1);
952         checkOffset(test, createLDT(2008, 7, 1), ZoneOffset.ofHours(-4), 1);
953         checkOffset(test, createLDT(2008, 8, 1), ZoneOffset.ofHours(-4), 1);
954         checkOffset(test, createLDT(2008, 9, 1), ZoneOffset.ofHours(-4), 1);
955         checkOffset(test, createLDT(2008, 10, 1), ZoneOffset.ofHours(-4), 1);
956         checkOffset(test, createLDT(2008, 11, 1), ZoneOffset.ofHours(-4), 1);
957         checkOffset(test, createLDT(2008, 12, 1), ZoneOffset.ofHours(-5), 1);
958         checkOffset(test, createLDT(2008, 1, 28), ZoneOffset.ofHours(-5), 1);
959         checkOffset(test, createLDT(2008, 2, 28), ZoneOffset.ofHours(-5), 1);
960         checkOffset(test, createLDT(2008, 3, 28), ZoneOffset.ofHours(-4), 1);
961         checkOffset(test, createLDT(2008, 4, 28), ZoneOffset.ofHours(-4), 1);
962         checkOffset(test, createLDT(2008, 5, 28), ZoneOffset.ofHours(-4), 1);
963         checkOffset(test, createLDT(2008, 6, 28), ZoneOffset.ofHours(-4), 1);
964         checkOffset(test, createLDT(2008, 7, 28), ZoneOffset.ofHours(-4), 1);
965         checkOffset(test, createLDT(2008, 8, 28), ZoneOffset.ofHours(-4), 1);
966         checkOffset(test, createLDT(2008, 9, 28), ZoneOffset.ofHours(-4), 1);
967         checkOffset(test, createLDT(2008, 10, 28), ZoneOffset.ofHours(-4), 1);
968         checkOffset(test, createLDT(2008, 11, 28), ZoneOffset.ofHours(-5), 1);
969         checkOffset(test, createLDT(2008, 12, 28), ZoneOffset.ofHours(-5), 1);
970     }
971 
test_NewYork_getOffsetInfo_toDST()972     public void test_NewYork_getOffsetInfo_toDST() {
973         ZoneRules test = americaNewYork();
974         checkOffset(test, createLDT(2008, 3, 8), ZoneOffset.ofHours(-5), 1);
975         checkOffset(test, createLDT(2008, 3, 9), ZoneOffset.ofHours(-5), 1);
976         checkOffset(test, createLDT(2008, 3, 10), ZoneOffset.ofHours(-4), 1);
977         checkOffset(test, createLDT(2008, 3, 11), ZoneOffset.ofHours(-4), 1);
978         checkOffset(test, createLDT(2008, 3, 12), ZoneOffset.ofHours(-4), 1);
979         checkOffset(test, createLDT(2008, 3, 13), ZoneOffset.ofHours(-4), 1);
980         checkOffset(test, createLDT(2008, 3, 14), ZoneOffset.ofHours(-4), 1);
981         // cutover at 02:00 local
982         checkOffset(test, LocalDateTime.of(2008, 3, 9, 1, 59, 59, 999999999), ZoneOffset.ofHours(-5), 1);
983         checkOffset(test, LocalDateTime.of(2008, 3, 9, 3, 0, 0, 0), ZoneOffset.ofHours(-4), 1);
984     }
985 
test_NewYork_getOffsetInfo_fromDST()986     public void test_NewYork_getOffsetInfo_fromDST() {
987         ZoneRules test = americaNewYork();
988         checkOffset(test, createLDT(2008, 11, 1), ZoneOffset.ofHours(-4), 1);
989         checkOffset(test, createLDT(2008, 11, 2), ZoneOffset.ofHours(-4), 1);
990         checkOffset(test, createLDT(2008, 11, 3), ZoneOffset.ofHours(-5), 1);
991         checkOffset(test, createLDT(2008, 11, 4), ZoneOffset.ofHours(-5), 1);
992         checkOffset(test, createLDT(2008, 11, 5), ZoneOffset.ofHours(-5), 1);
993         checkOffset(test, createLDT(2008, 11, 6), ZoneOffset.ofHours(-5), 1);
994         checkOffset(test, createLDT(2008, 11, 7), ZoneOffset.ofHours(-5), 1);
995         // cutover at 02:00 local
996         checkOffset(test, LocalDateTime.of(2008, 11, 2, 0, 59, 59, 999999999), ZoneOffset.ofHours(-4), 1);
997         checkOffset(test, LocalDateTime.of(2008, 11, 2, 2, 0, 0, 0), ZoneOffset.ofHours(-5), 1);
998     }
999 
test_NewYork_getOffsetInfo_gap()1000     public void test_NewYork_getOffsetInfo_gap() {
1001         ZoneRules test = americaNewYork();
1002         final LocalDateTime dateTime = LocalDateTime.of(2008, 3, 9, 2, 0, 0, 0);
1003         ZoneOffsetTransition trans = checkOffset(test, dateTime, ZoneOffset.ofHours(-5), GAP);
1004         assertEquals(trans.isGap(), true);
1005         assertEquals(trans.isOverlap(), false);
1006         assertEquals(trans.getOffsetBefore(), ZoneOffset.ofHours(-5));
1007         assertEquals(trans.getOffsetAfter(), ZoneOffset.ofHours(-4));
1008         assertEquals(trans.getInstant(), createInstant(2008, 3, 9, 2, 0, ZoneOffset.ofHours(-5)));
1009         assertEquals(trans.isValidOffset(OFFSET_PTWO), false);
1010         assertEquals(trans.isValidOffset(ZoneOffset.ofHours(-5)), false);
1011         assertEquals(trans.isValidOffset(ZoneOffset.ofHours(-4)), false);
1012         assertEquals(trans.toString(), "Transition[Gap at 2008-03-09T02:00-05:00 to -04:00]");
1013 
1014         assertFalse(trans.equals(null));
1015         assertFalse(trans.equals(ZoneOffset.ofHours(-5)));
1016         assertTrue(trans.equals(trans));
1017 
1018         final ZoneOffsetTransition otherTrans = test.getTransition(dateTime);
1019         assertTrue(trans.equals(otherTrans));
1020         assertEquals(trans.hashCode(), otherTrans.hashCode());
1021     }
1022 
test_NewYork_getOffsetInfo_overlap()1023     public void test_NewYork_getOffsetInfo_overlap() {
1024         ZoneRules test = americaNewYork();
1025         final LocalDateTime dateTime = LocalDateTime.of(2008, 11, 2, 1, 0, 0, 0);
1026         ZoneOffsetTransition trans = checkOffset(test, dateTime, ZoneOffset.ofHours(-4), OVERLAP);
1027         assertEquals(trans.isGap(), false);
1028         assertEquals(trans.isOverlap(), true);
1029         assertEquals(trans.getOffsetBefore(), ZoneOffset.ofHours(-4));
1030         assertEquals(trans.getOffsetAfter(), ZoneOffset.ofHours(-5));
1031         assertEquals(trans.getInstant(), createInstant(2008, 11, 2, 2, 0, ZoneOffset.ofHours(-4)));
1032         assertEquals(trans.isValidOffset(ZoneOffset.ofHours(-1)), false);
1033         assertEquals(trans.isValidOffset(ZoneOffset.ofHours(-5)), true);
1034         assertEquals(trans.isValidOffset(ZoneOffset.ofHours(-4)), true);
1035         assertEquals(trans.isValidOffset(OFFSET_PTWO), false);
1036         assertEquals(trans.toString(), "Transition[Overlap at 2008-11-02T02:00-04:00 to -05:00]");
1037 
1038         assertFalse(trans.equals(null));
1039         assertFalse(trans.equals(ZoneOffset.ofHours(-4)));
1040         assertTrue(trans.equals(trans));
1041 
1042         final ZoneOffsetTransition otherTrans = test.getTransition(dateTime);
1043         assertTrue(trans.equals(otherTrans));
1044         assertEquals(trans.hashCode(), otherTrans.hashCode());
1045     }
1046 
test_NewYork_getStandardOffset()1047     public void test_NewYork_getStandardOffset() {
1048         ZoneRules test = americaNewYork();
1049         ZonedDateTime dateTime = createZDT(1860, 1, 1, ZoneOffset.UTC);
1050         while (dateTime.getYear() < 2010) {
1051             Instant instant = dateTime.toInstant();
1052             if (dateTime.toLocalDate().isBefore(LocalDate.of(1883, 11, 18))) {
1053                 assertEquals(test.getStandardOffset(instant), ZoneOffset.of("-04:56:02"));
1054             } else {
1055                 assertEquals(test.getStandardOffset(instant), ZoneOffset.ofHours(-5));
1056             }
1057             dateTime = dateTime.plusMonths(6);
1058         }
1059     }
1060 
1061     //-----------------------------------------------------------------------
1062     // Kathmandu
1063     //-----------------------------------------------------------------------
asiaKathmandu()1064     private ZoneRules asiaKathmandu() {
1065         return ZoneId.of("Asia/Kathmandu").getRules();
1066     }
1067 
test_Kathmandu_nextTransition_historic()1068     public void test_Kathmandu_nextTransition_historic() {
1069         ZoneRules test = asiaKathmandu();
1070         List<ZoneOffsetTransition> trans = test.getTransitions();
1071 
1072         ZoneOffsetTransition first = trans.get(0);
1073         assertEquals(test.nextTransition(first.getInstant().minusNanos(1)), first);
1074 
1075         for (int i = 0; i < trans.size() - 1; i++) {
1076             ZoneOffsetTransition cur = trans.get(i);
1077             ZoneOffsetTransition next = trans.get(i + 1);
1078 
1079             assertEquals(test.nextTransition(cur.getInstant()), next);
1080             assertEquals(test.nextTransition(next.getInstant().minusNanos(1)), next);
1081         }
1082     }
1083 
test_Kathmandu_nextTransition_noRules()1084     public void test_Kathmandu_nextTransition_noRules() {
1085         ZoneRules test = asiaKathmandu();
1086         List<ZoneOffsetTransition> trans = test.getTransitions();
1087 
1088         ZoneOffsetTransition last = trans.get(trans.size() - 1);
1089         assertEquals(test.nextTransition(last.getInstant()), null);
1090     }
1091 
1092     //-------------------------------------------------------------------------
1093     @Test(expectedExceptions=UnsupportedOperationException.class)
test_getTransitions_immutable()1094     public void test_getTransitions_immutable() {
1095         ZoneRules test = europeParis();
1096         test.getTransitions().clear();
1097     }
1098 
1099     @Test(expectedExceptions=UnsupportedOperationException.class)
test_getTransitionRules_immutable()1100     public void test_getTransitionRules_immutable() {
1101         ZoneRules test = europeParis();
1102         test.getTransitionRules().clear();
1103     }
1104 
1105     //-------------------------------------------------------------------------
1106     @Test
test_rulesWithoutTransitions()1107     public void test_rulesWithoutTransitions() {
1108         // this was not intended to be a valid setup of ZoneRules
1109         List<ZoneOffsetTransitionRule> r = new ArrayList<ZoneOffsetTransitionRule>();
1110         r.add(ZoneOffsetTransitionRule.of(Month.MARCH, 25, DayOfWeek.SUNDAY, LocalTime.of(1, 0), false,
1111                 TimeDefinition.UTC, OFFSET_PONE, OFFSET_PONE, OFFSET_PTWO));
1112         r.add(ZoneOffsetTransitionRule.of(Month.OCTOBER, 25, DayOfWeek.SUNDAY, LocalTime.of(1, 0), false,
1113                 TimeDefinition.UTC, OFFSET_PONE, OFFSET_PTWO, OFFSET_PONE));
1114         ZoneRules test = ZoneRules.of(OFFSET_ZERO, OFFSET_ZERO, new ArrayList<ZoneOffsetTransition>(),
1115                 new ArrayList<ZoneOffsetTransition>(), r);
1116         LocalDateTime ldt = LocalDateTime.of(2008, 6, 30, 0, 0);
1117         test.getTransition(ldt);
1118         Instant instant = LocalDateTime.of(2008, 10, 26, 2, 30).toInstant(OFFSET_PONE);
1119         assertEquals(test.getOffset(instant), OFFSET_PONE);
1120         assertFalse(test.isFixedOffset());
1121     }
1122 
1123     //-----------------------------------------------------------------------
1124     // equals() / hashCode()
1125     //-----------------------------------------------------------------------
test_equals()1126     public void test_equals() {
1127         ZoneRules test1 = europeLondon();
1128         ZoneRules test2 = europeParis();
1129         ZoneRules test2b = europeParis();
1130         assertEquals(test1.equals(test2), false);
1131         assertEquals(test2.equals(test1), false);
1132 
1133         assertEquals(test1.equals(test1), true);
1134         assertEquals(test2.equals(test2), true);
1135         assertEquals(test2.equals(test2b), true);
1136 
1137         assertEquals(test1.hashCode() == test1.hashCode(), true);
1138         assertEquals(test2.hashCode() == test2.hashCode(), true);
1139         assertEquals(test2.hashCode() == test2b.hashCode(), true);
1140     }
1141 
test_equals_null()1142     public void test_equals_null() {
1143         assertEquals(europeLondon().equals(null), false);
1144     }
1145 
test_equals_notZoneRules()1146     public void test_equals_notZoneRules() {
1147         assertEquals(europeLondon().equals("Europe/London"), false);
1148     }
1149 
test_toString()1150     public void test_toString() {
1151         assertEquals(europeLondon().toString().contains("ZoneRules"), true);
1152     }
1153 
1154     //-----------------------------------------------------------------------
1155     //-----------------------------------------------------------------------
1156     //-----------------------------------------------------------------------
createInstant(int year, int month, int day, ZoneOffset offset)1157     private Instant createInstant(int year, int month, int day, ZoneOffset offset) {
1158         return LocalDateTime.of(year, month, day, 0, 0).toInstant(offset);
1159     }
1160 
createInstant(int year, int month, int day, int hour, int min, ZoneOffset offset)1161     private Instant createInstant(int year, int month, int day, int hour, int min, ZoneOffset offset) {
1162         return LocalDateTime.of(year, month, day, hour, min).toInstant(offset);
1163     }
1164 
createInstant(int year, int month, int day, int hour, int min, int sec, int nano, ZoneOffset offset)1165     private Instant createInstant(int year, int month, int day, int hour, int min, int sec, int nano, ZoneOffset offset) {
1166         return LocalDateTime.of(year, month, day, hour, min, sec, nano).toInstant(offset);
1167     }
1168 
createZDT(int year, int month, int day, ZoneId zone)1169     private ZonedDateTime createZDT(int year, int month, int day, ZoneId zone) {
1170         return LocalDateTime.of(year, month, day, 0, 0).atZone(zone);
1171     }
1172 
createLDT(int year, int month, int day)1173     private LocalDateTime createLDT(int year, int month, int day) {
1174         return LocalDateTime.of(year, month, day, 0, 0);
1175     }
1176 
checkOffset(ZoneRules rules, LocalDateTime dateTime, ZoneOffset offset, int type)1177     private ZoneOffsetTransition checkOffset(ZoneRules rules, LocalDateTime dateTime, ZoneOffset offset, int type) {
1178         List<ZoneOffset> validOffsets = rules.getValidOffsets(dateTime);
1179         assertEquals(validOffsets.size(), type);
1180         assertEquals(rules.getOffset(dateTime), offset);
1181         if (type == 1) {
1182             assertEquals(validOffsets.get(0), offset);
1183             return null;
1184         } else {
1185             ZoneOffsetTransition zot = rules.getTransition(dateTime);
1186             assertNotNull(zot);
1187             assertEquals(zot.isOverlap(), type == 2);
1188             assertEquals(zot.isGap(), type == 0);
1189             assertEquals(zot.isValidOffset(offset), type == 2);
1190             return zot;
1191         }
1192     }
1193 
1194 }
1195