1 /*
   2  * Copyright (c) 2012, 2013, Oracle and/or its affiliates. All rights reserved.
   3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4  *
   5  * This code is free software; you can redistribute it and/or modify it
   6  * under the terms of the GNU General Public License version 2 only, as
   7  * published by the Free Software Foundation.
   8  *
   9  * This code is distributed in the hope that it will be useful, but WITHOUT
  10  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  11  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  12  * version 2 for more details (a copy is included in the LICENSE file that
  13  * accompanied this code).
  14  *
  15  * You should have received a copy of the GNU General Public License version
  16  * 2 along with this work; if not, write to the Free Software Foundation,
  17  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
  18  *
  19  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
  20  * or visit www.oracle.com if you need additional information or have any
  21  * questions.
  22  */
  23 
  24 /*
  25  * This file is available under and governed by the GNU General Public
  26  * License version 2 only, as published by the Free Software Foundation.
  27  * However, the following notice accompanied the original version of this
  28  * file:
  29  *
  30  * Copyright (c) 2008-2012, Stephen Colebourne & Michael Nascimento Santos
  31  *
  32  * All rights reserved.
  33  *
  34  * Redistribution and use in source and binary forms, with or without
  35  * modification, are permitted provided that the following conditions are met:
  36  *
  37  *  * Redistributions of source code must retain the above copyright notice,
  38  *    this list of conditions and the following disclaimer.
  39  *
  40  *  * Redistributions in binary form must reproduce the above copyright notice,
  41  *    this list of conditions and the following disclaimer in the documentation
  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 test.java.time;
  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.lang.reflect.Field;
  68 import java.lang.reflect.Modifier;
  69 import java.time.DateTimeException;
  70 import java.time.Instant;
  71 import java.time.LocalDateTime;
  72 import java.time.ZoneId;
  73 import java.time.ZoneOffset;
  74 import java.time.ZonedDateTime;
  75 import java.time.format.TextStyle;
  76 import java.time.zone.ZoneOffsetTransition;
  77 import java.time.zone.ZoneRules;
  78 import java.time.zone.ZoneRulesException;
  79 import java.util.List;
  80 import java.util.Locale;
  81 import java.util.SimpleTimeZone;
  82 import java.util.TimeZone;
  83 
  84 import org.testng.annotations.Test;
  85 
  86 /**
  87  * Test ZoneId.
  88  */
  89 @Test
  90 public class TestZoneId extends AbstractTest {
  91 
  92     private static final int OVERLAP = 2;
  93     private static final int GAP = 0;
  94 
  95     //-----------------------------------------------------------------------
  96     // Basics
  97     //-----------------------------------------------------------------------
  98     public void test_immutable() {
  99         // cannot use standard test as ZoneId is abstract
 100         Class<ZoneId> cls = ZoneId.class;
 101         assertTrue(Modifier.isPublic(cls.getModifiers()));
 102         Field[] fields = cls.getDeclaredFields();
 103         for (Field field : fields) {
 104             if (Modifier.isStatic(field.getModifiers()) == false) {
 105                 assertTrue(Modifier.isPrivate(field.getModifiers()));
 106                 assertTrue(Modifier.isFinal(field.getModifiers()) ||
 107                         (Modifier.isVolatile(field.getModifiers()) && Modifier.isTransient(field.getModifiers())));
 108             }
 109         }
 110     }
 111 
 112     //-----------------------------------------------------------------------
 113     // UTC
 114     //-----------------------------------------------------------------------
 115     public void test_constant_UTC() {
 116         ZoneId test = ZoneOffset.UTC;
 117         assertEquals(test.getId(), "Z");
 118         assertEquals(test.getDisplayName(TextStyle.FULL, Locale.UK), "Z");
 119         assertEquals(test.getRules().isFixedOffset(), true);
 120         assertEquals(test.getRules().getOffset(Instant.ofEpochSecond(0L)), ZoneOffset.UTC);
 121         checkOffset(test.getRules(), createLDT(2008, 6, 30), ZoneOffset.UTC, 1);
 122     }
 123 
 124     //-----------------------------------------------------------------------
 125     // system default
 126     //-----------------------------------------------------------------------
 127     public void test_systemDefault() {
 128         ZoneId test = ZoneId.systemDefault();
 129         assertEquals(test.getId(), TimeZone.getDefault().getID());
 130     }
 131 
 132     @Test(expectedExceptions = DateTimeException.class)
 133     public void test_systemDefault_unableToConvert_badFormat() {
 134         TimeZone current = TimeZone.getDefault();
 135         try {
 136             TimeZone.setDefault(new SimpleTimeZone(127, "Something Weird"));
 137             ZoneId.systemDefault();
 138         } finally {
 139             TimeZone.setDefault(current);
 140         }
 141     }
 142 
 143     @Test(expectedExceptions = ZoneRulesException.class)
 144     public void test_systemDefault_unableToConvert_unknownId() {
 145         TimeZone current = TimeZone.getDefault();
 146         try {
 147             TimeZone.setDefault(new SimpleTimeZone(127, "SomethingWeird"));
 148             ZoneId.systemDefault();
 149         } finally {
 150             TimeZone.setDefault(current);
 151         }
 152     }
 153 
 154     //-----------------------------------------------------------------------
 155     // Europe/London
 156     //-----------------------------------------------------------------------
 157     public void test_London() {
 158         ZoneId test = ZoneId.of("Europe/London");
 159         assertEquals(test.getId(), "Europe/London");
 160         assertEquals(test.getRules().isFixedOffset(), false);
 161     }
 162 
 163     public void test_London_getOffset() {
 164         ZoneId test = ZoneId.of("Europe/London");
 165         assertEquals(test.getRules().getOffset(createInstant(2008, 1, 1, ZoneOffset.UTC)), ZoneOffset.ofHours(0));
 166         assertEquals(test.getRules().getOffset(createInstant(2008, 2, 1, ZoneOffset.UTC)), ZoneOffset.ofHours(0));
 167         assertEquals(test.getRules().getOffset(createInstant(2008, 3, 1, ZoneOffset.UTC)), ZoneOffset.ofHours(0));
 168         assertEquals(test.getRules().getOffset(createInstant(2008, 4, 1, ZoneOffset.UTC)), ZoneOffset.ofHours(1));
 169         assertEquals(test.getRules().getOffset(createInstant(2008, 5, 1, ZoneOffset.UTC)), ZoneOffset.ofHours(1));
 170         assertEquals(test.getRules().getOffset(createInstant(2008, 6, 1, ZoneOffset.UTC)), ZoneOffset.ofHours(1));
 171         assertEquals(test.getRules().getOffset(createInstant(2008, 7, 1, ZoneOffset.UTC)), ZoneOffset.ofHours(1));
 172         assertEquals(test.getRules().getOffset(createInstant(2008, 8, 1, ZoneOffset.UTC)), ZoneOffset.ofHours(1));
 173         assertEquals(test.getRules().getOffset(createInstant(2008, 9, 1, ZoneOffset.UTC)), ZoneOffset.ofHours(1));
 174         assertEquals(test.getRules().getOffset(createInstant(2008, 10, 1, ZoneOffset.UTC)), ZoneOffset.ofHours(1));
 175         assertEquals(test.getRules().getOffset(createInstant(2008, 11, 1, ZoneOffset.UTC)), ZoneOffset.ofHours(0));
 176         assertEquals(test.getRules().getOffset(createInstant(2008, 12, 1, ZoneOffset.UTC)), ZoneOffset.ofHours(0));
 177     }
 178 
 179     public void test_London_getOffset_toDST() {
 180         ZoneId test = ZoneId.of("Europe/London");
 181         assertEquals(test.getRules().getOffset(createInstant(2008, 3, 24, ZoneOffset.UTC)), ZoneOffset.ofHours(0));
 182         assertEquals(test.getRules().getOffset(createInstant(2008, 3, 25, ZoneOffset.UTC)), ZoneOffset.ofHours(0));
 183         assertEquals(test.getRules().getOffset(createInstant(2008, 3, 26, ZoneOffset.UTC)), ZoneOffset.ofHours(0));
 184         assertEquals(test.getRules().getOffset(createInstant(2008, 3, 27, ZoneOffset.UTC)), ZoneOffset.ofHours(0));
 185         assertEquals(test.getRules().getOffset(createInstant(2008, 3, 28, ZoneOffset.UTC)), ZoneOffset.ofHours(0));
 186         assertEquals(test.getRules().getOffset(createInstant(2008, 3, 29, ZoneOffset.UTC)), ZoneOffset.ofHours(0));
 187         assertEquals(test.getRules().getOffset(createInstant(2008, 3, 30, ZoneOffset.UTC)), ZoneOffset.ofHours(0));
 188         assertEquals(test.getRules().getOffset(createInstant(2008, 3, 31, ZoneOffset.UTC)), ZoneOffset.ofHours(1));
 189         // cutover at 01:00Z
 190         assertEquals(test.getRules().getOffset(createInstant(2008, 3, 30, 0, 59, 59, 999999999, ZoneOffset.UTC)), ZoneOffset.ofHours(0));
 191         assertEquals(test.getRules().getOffset(createInstant(2008, 3, 30, 1, 0, 0, 0, ZoneOffset.UTC)), ZoneOffset.ofHours(1));
 192     }
 193 
 194     public void test_London_getOffset_fromDST() {
 195         ZoneId test = ZoneId.of("Europe/London");
 196         assertEquals(test.getRules().getOffset(createInstant(2008, 10, 24, ZoneOffset.UTC)), ZoneOffset.ofHours(1));
 197         assertEquals(test.getRules().getOffset(createInstant(2008, 10, 25, ZoneOffset.UTC)), ZoneOffset.ofHours(1));
 198         assertEquals(test.getRules().getOffset(createInstant(2008, 10, 26, ZoneOffset.UTC)), ZoneOffset.ofHours(1));
 199         assertEquals(test.getRules().getOffset(createInstant(2008, 10, 27, ZoneOffset.UTC)), ZoneOffset.ofHours(0));
 200         assertEquals(test.getRules().getOffset(createInstant(2008, 10, 28, ZoneOffset.UTC)), ZoneOffset.ofHours(0));
 201         assertEquals(test.getRules().getOffset(createInstant(2008, 10, 29, ZoneOffset.UTC)), ZoneOffset.ofHours(0));
 202         assertEquals(test.getRules().getOffset(createInstant(2008, 10, 30, ZoneOffset.UTC)), ZoneOffset.ofHours(0));
 203         assertEquals(test.getRules().getOffset(createInstant(2008, 10, 31, ZoneOffset.UTC)), ZoneOffset.ofHours(0));
 204         // cutover at 01:00Z
 205         assertEquals(test.getRules().getOffset(createInstant(2008, 10, 26, 0, 59, 59, 999999999, ZoneOffset.UTC)), ZoneOffset.ofHours(1));
 206         assertEquals(test.getRules().getOffset(createInstant(2008, 10, 26, 1, 0, 0, 0, ZoneOffset.UTC)), ZoneOffset.ofHours(0));
 207     }
 208 
 209     public void test_London_getOffsetInfo() {
 210         ZoneId test = ZoneId.of("Europe/London");
 211         checkOffset(test.getRules(), createLDT(2008, 1, 1), ZoneOffset.ofHours(0), 1);
 212         checkOffset(test.getRules(), createLDT(2008, 2, 1), ZoneOffset.ofHours(0), 1);
 213         checkOffset(test.getRules(), createLDT(2008, 3, 1), ZoneOffset.ofHours(0), 1);
 214         checkOffset(test.getRules(), createLDT(2008, 4, 1), ZoneOffset.ofHours(1), 1);
 215         checkOffset(test.getRules(), createLDT(2008, 5, 1), ZoneOffset.ofHours(1), 1);
 216         checkOffset(test.getRules(), createLDT(2008, 6, 1), ZoneOffset.ofHours(1), 1);
 217         checkOffset(test.getRules(), createLDT(2008, 7, 1), ZoneOffset.ofHours(1), 1);
 218         checkOffset(test.getRules(), createLDT(2008, 8, 1), ZoneOffset.ofHours(1), 1);
 219         checkOffset(test.getRules(), createLDT(2008, 9, 1), ZoneOffset.ofHours(1), 1);
 220         checkOffset(test.getRules(), createLDT(2008, 10, 1), ZoneOffset.ofHours(1), 1);
 221         checkOffset(test.getRules(), createLDT(2008, 11, 1), ZoneOffset.ofHours(0), 1);
 222         checkOffset(test.getRules(), createLDT(2008, 12, 1), ZoneOffset.ofHours(0), 1);
 223     }
 224 
 225     public void test_London_getOffsetInfo_toDST() {
 226         ZoneId test = ZoneId.of("Europe/London");
 227         checkOffset(test.getRules(), createLDT(2008, 3, 24), ZoneOffset.ofHours(0), 1);
 228         checkOffset(test.getRules(), createLDT(2008, 3, 25), ZoneOffset.ofHours(0), 1);
 229         checkOffset(test.getRules(), createLDT(2008, 3, 26), ZoneOffset.ofHours(0), 1);
 230         checkOffset(test.getRules(), createLDT(2008, 3, 27), ZoneOffset.ofHours(0), 1);
 231         checkOffset(test.getRules(), createLDT(2008, 3, 28), ZoneOffset.ofHours(0), 1);
 232         checkOffset(test.getRules(), createLDT(2008, 3, 29), ZoneOffset.ofHours(0), 1);
 233         checkOffset(test.getRules(), createLDT(2008, 3, 30), ZoneOffset.ofHours(0), 1);
 234         checkOffset(test.getRules(), createLDT(2008, 3, 31), ZoneOffset.ofHours(1), 1);
 235         // cutover at 01:00Z
 236         checkOffset(test.getRules(), LocalDateTime.of(2008, 3, 30, 0, 59, 59, 999999999), ZoneOffset.ofHours(0), 1);
 237         checkOffset(test.getRules(), LocalDateTime.of(2008, 3, 30, 1, 30, 0, 0), ZoneOffset.ofHours(0), GAP);
 238         checkOffset(test.getRules(), LocalDateTime.of(2008, 3, 30, 2, 0, 0, 0), ZoneOffset.ofHours(1), 1);
 239     }
 240 
 241     public void test_London_getOffsetInfo_fromDST() {
 242         ZoneId test = ZoneId.of("Europe/London");
 243         checkOffset(test.getRules(), createLDT(2008, 10, 24), ZoneOffset.ofHours(1), 1);
 244         checkOffset(test.getRules(), createLDT(2008, 10, 25), ZoneOffset.ofHours(1), 1);
 245         checkOffset(test.getRules(), createLDT(2008, 10, 26), ZoneOffset.ofHours(1), 1);
 246         checkOffset(test.getRules(), createLDT(2008, 10, 27), ZoneOffset.ofHours(0), 1);
 247         checkOffset(test.getRules(), createLDT(2008, 10, 28), ZoneOffset.ofHours(0), 1);
 248         checkOffset(test.getRules(), createLDT(2008, 10, 29), ZoneOffset.ofHours(0), 1);
 249         checkOffset(test.getRules(), createLDT(2008, 10, 30), ZoneOffset.ofHours(0), 1);
 250         checkOffset(test.getRules(), createLDT(2008, 10, 31), ZoneOffset.ofHours(0), 1);
 251         // cutover at 01:00Z
 252         checkOffset(test.getRules(), LocalDateTime.of(2008, 10, 26, 0, 59, 59, 999999999), ZoneOffset.ofHours(1), 1);
 253         checkOffset(test.getRules(), LocalDateTime.of(2008, 10, 26, 1, 30, 0, 0), ZoneOffset.ofHours(1), OVERLAP);
 254         checkOffset(test.getRules(), LocalDateTime.of(2008, 10, 26, 2, 0, 0, 0), ZoneOffset.ofHours(0), 1);
 255     }
 256 
 257     public void test_London_getOffsetInfo_gap() {
 258         ZoneId test = ZoneId.of("Europe/London");
 259         final LocalDateTime dateTime = LocalDateTime.of(2008, 3, 30, 1, 0, 0, 0);
 260         ZoneOffsetTransition trans = checkOffset(test.getRules(), dateTime, ZoneOffset.ofHours(0), GAP);
 261         assertEquals(trans.isGap(), true);
 262         assertEquals(trans.isOverlap(), false);
 263         assertEquals(trans.getOffsetBefore(), ZoneOffset.ofHours(0));
 264         assertEquals(trans.getOffsetAfter(), ZoneOffset.ofHours(1));
 265         assertEquals(trans.getInstant(), dateTime.toInstant(ZoneOffset.UTC));
 266         assertEquals(trans.getDateTimeBefore(), LocalDateTime.of(2008, 3, 30, 1, 0));
 267         assertEquals(trans.getDateTimeAfter(), LocalDateTime.of(2008, 3, 30, 2, 0));
 268         assertEquals(trans.isValidOffset(ZoneOffset.ofHours(-1)), false);
 269         assertEquals(trans.isValidOffset(ZoneOffset.ofHours(0)), false);
 270         assertEquals(trans.isValidOffset(ZoneOffset.ofHours(1)), false);
 271         assertEquals(trans.isValidOffset(ZoneOffset.ofHours(2)), false);
 272         assertEquals(trans.toString(), "Transition[Gap at 2008-03-30T01:00Z to +01:00]");
 273 
 274         assertFalse(trans.equals(null));
 275         assertFalse(trans.equals(ZoneOffset.ofHours(0)));
 276         assertTrue(trans.equals(trans));
 277 
 278         final ZoneOffsetTransition otherTrans = test.getRules().getTransition(dateTime);
 279         assertTrue(trans.equals(otherTrans));
 280         assertEquals(trans.hashCode(), otherTrans.hashCode());
 281     }
 282 
 283     public void test_London_getOffsetInfo_overlap() {
 284         ZoneId test = ZoneId.of("Europe/London");
 285         final LocalDateTime dateTime = LocalDateTime.of(2008, 10, 26, 1, 0, 0, 0);
 286         ZoneOffsetTransition trans = checkOffset(test.getRules(), dateTime, ZoneOffset.ofHours(1), OVERLAP);
 287         assertEquals(trans.isGap(), false);
 288         assertEquals(trans.isOverlap(), true);
 289         assertEquals(trans.getOffsetBefore(), ZoneOffset.ofHours(1));
 290         assertEquals(trans.getOffsetAfter(), ZoneOffset.ofHours(0));
 291         assertEquals(trans.getInstant(), dateTime.toInstant(ZoneOffset.UTC));
 292         assertEquals(trans.getDateTimeBefore(), LocalDateTime.of(2008, 10, 26, 2, 0));
 293         assertEquals(trans.getDateTimeAfter(), LocalDateTime.of(2008, 10, 26, 1, 0));
 294         assertEquals(trans.isValidOffset(ZoneOffset.ofHours(-1)), false);
 295         assertEquals(trans.isValidOffset(ZoneOffset.ofHours(0)), true);
 296         assertEquals(trans.isValidOffset(ZoneOffset.ofHours(1)), true);
 297         assertEquals(trans.isValidOffset(ZoneOffset.ofHours(2)), false);
 298         assertEquals(trans.toString(), "Transition[Overlap at 2008-10-26T02:00+01:00 to Z]");
 299 
 300         assertFalse(trans.equals(null));
 301         assertFalse(trans.equals(ZoneOffset.ofHours(1)));
 302         assertTrue(trans.equals(trans));
 303 
 304         final ZoneOffsetTransition otherTrans = test.getRules().getTransition(dateTime);
 305         assertTrue(trans.equals(otherTrans));
 306         assertEquals(trans.hashCode(), otherTrans.hashCode());
 307     }
 308 
 309     //-----------------------------------------------------------------------
 310     // Europe/Paris
 311     //-----------------------------------------------------------------------
 312     public void test_Paris() {
 313         ZoneId test = ZoneId.of("Europe/Paris");
 314         assertEquals(test.getId(), "Europe/Paris");
 315         assertEquals(test.getRules().isFixedOffset(), false);
 316     }
 317 
 318     public void test_Paris_getOffset() {
 319         ZoneId test = ZoneId.of("Europe/Paris");
 320         assertEquals(test.getRules().getOffset(createInstant(2008, 1, 1, ZoneOffset.UTC)), ZoneOffset.ofHours(1));
 321         assertEquals(test.getRules().getOffset(createInstant(2008, 2, 1, ZoneOffset.UTC)), ZoneOffset.ofHours(1));
 322         assertEquals(test.getRules().getOffset(createInstant(2008, 3, 1, ZoneOffset.UTC)), ZoneOffset.ofHours(1));
 323         assertEquals(test.getRules().getOffset(createInstant(2008, 4, 1, ZoneOffset.UTC)), ZoneOffset.ofHours(2));
 324         assertEquals(test.getRules().getOffset(createInstant(2008, 5, 1, ZoneOffset.UTC)), ZoneOffset.ofHours(2));
 325         assertEquals(test.getRules().getOffset(createInstant(2008, 6, 1, ZoneOffset.UTC)), ZoneOffset.ofHours(2));
 326         assertEquals(test.getRules().getOffset(createInstant(2008, 7, 1, ZoneOffset.UTC)), ZoneOffset.ofHours(2));
 327         assertEquals(test.getRules().getOffset(createInstant(2008, 8, 1, ZoneOffset.UTC)), ZoneOffset.ofHours(2));
 328         assertEquals(test.getRules().getOffset(createInstant(2008, 9, 1, ZoneOffset.UTC)), ZoneOffset.ofHours(2));
 329         assertEquals(test.getRules().getOffset(createInstant(2008, 10, 1, ZoneOffset.UTC)), ZoneOffset.ofHours(2));
 330         assertEquals(test.getRules().getOffset(createInstant(2008, 11, 1, ZoneOffset.UTC)), ZoneOffset.ofHours(1));
 331         assertEquals(test.getRules().getOffset(createInstant(2008, 12, 1, ZoneOffset.UTC)), ZoneOffset.ofHours(1));
 332     }
 333 
 334     public void test_Paris_getOffset_toDST() {
 335         ZoneId test = ZoneId.of("Europe/Paris");
 336         assertEquals(test.getRules().getOffset(createInstant(2008, 3, 24, ZoneOffset.UTC)), ZoneOffset.ofHours(1));
 337         assertEquals(test.getRules().getOffset(createInstant(2008, 3, 25, ZoneOffset.UTC)), ZoneOffset.ofHours(1));
 338         assertEquals(test.getRules().getOffset(createInstant(2008, 3, 26, ZoneOffset.UTC)), ZoneOffset.ofHours(1));
 339         assertEquals(test.getRules().getOffset(createInstant(2008, 3, 27, ZoneOffset.UTC)), ZoneOffset.ofHours(1));
 340         assertEquals(test.getRules().getOffset(createInstant(2008, 3, 28, ZoneOffset.UTC)), ZoneOffset.ofHours(1));
 341         assertEquals(test.getRules().getOffset(createInstant(2008, 3, 29, ZoneOffset.UTC)), ZoneOffset.ofHours(1));
 342         assertEquals(test.getRules().getOffset(createInstant(2008, 3, 30, ZoneOffset.UTC)), ZoneOffset.ofHours(1));
 343         assertEquals(test.getRules().getOffset(createInstant(2008, 3, 31, ZoneOffset.UTC)), ZoneOffset.ofHours(2));
 344         // cutover at 01:00Z
 345         assertEquals(test.getRules().getOffset(createInstant(2008, 3, 30, 0, 59, 59, 999999999, ZoneOffset.UTC)), ZoneOffset.ofHours(1));
 346         assertEquals(test.getRules().getOffset(createInstant(2008, 3, 30, 1, 0, 0, 0, ZoneOffset.UTC)), ZoneOffset.ofHours(2));
 347     }
 348 
 349     public void test_Paris_getOffset_fromDST() {
 350         ZoneId test = ZoneId.of("Europe/Paris");
 351         assertEquals(test.getRules().getOffset(createInstant(2008, 10, 24, ZoneOffset.UTC)), ZoneOffset.ofHours(2));
 352         assertEquals(test.getRules().getOffset(createInstant(2008, 10, 25, ZoneOffset.UTC)), ZoneOffset.ofHours(2));
 353         assertEquals(test.getRules().getOffset(createInstant(2008, 10, 26, ZoneOffset.UTC)), ZoneOffset.ofHours(2));
 354         assertEquals(test.getRules().getOffset(createInstant(2008, 10, 27, ZoneOffset.UTC)), ZoneOffset.ofHours(1));
 355         assertEquals(test.getRules().getOffset(createInstant(2008, 10, 28, ZoneOffset.UTC)), ZoneOffset.ofHours(1));
 356         assertEquals(test.getRules().getOffset(createInstant(2008, 10, 29, ZoneOffset.UTC)), ZoneOffset.ofHours(1));
 357         assertEquals(test.getRules().getOffset(createInstant(2008, 10, 30, ZoneOffset.UTC)), ZoneOffset.ofHours(1));
 358         assertEquals(test.getRules().getOffset(createInstant(2008, 10, 31, ZoneOffset.UTC)), ZoneOffset.ofHours(1));
 359         // cutover at 01:00Z
 360         assertEquals(test.getRules().getOffset(createInstant(2008, 10, 26, 0, 59, 59, 999999999, ZoneOffset.UTC)), ZoneOffset.ofHours(2));
 361         assertEquals(test.getRules().getOffset(createInstant(2008, 10, 26, 1, 0, 0, 0, ZoneOffset.UTC)), ZoneOffset.ofHours(1));
 362     }
 363 
 364     public void test_Paris_getOffsetInfo() {
 365         ZoneId test = ZoneId.of("Europe/Paris");
 366         checkOffset(test.getRules(), createLDT(2008, 1, 1), ZoneOffset.ofHours(1), 1);
 367         checkOffset(test.getRules(), createLDT(2008, 2, 1), ZoneOffset.ofHours(1), 1);
 368         checkOffset(test.getRules(), createLDT(2008, 3, 1), ZoneOffset.ofHours(1), 1);
 369         checkOffset(test.getRules(), createLDT(2008, 4, 1), ZoneOffset.ofHours(2), 1);
 370         checkOffset(test.getRules(), createLDT(2008, 5, 1), ZoneOffset.ofHours(2), 1);
 371         checkOffset(test.getRules(), createLDT(2008, 6, 1), ZoneOffset.ofHours(2), 1);
 372         checkOffset(test.getRules(), createLDT(2008, 7, 1), ZoneOffset.ofHours(2), 1);
 373         checkOffset(test.getRules(), createLDT(2008, 8, 1), ZoneOffset.ofHours(2), 1);
 374         checkOffset(test.getRules(), createLDT(2008, 9, 1), ZoneOffset.ofHours(2), 1);
 375         checkOffset(test.getRules(), createLDT(2008, 10, 1), ZoneOffset.ofHours(2), 1);
 376         checkOffset(test.getRules(), createLDT(2008, 11, 1), ZoneOffset.ofHours(1), 1);
 377         checkOffset(test.getRules(), createLDT(2008, 12, 1), ZoneOffset.ofHours(1), 1);
 378     }
 379 
 380     public void test_Paris_getOffsetInfo_toDST() {
 381         ZoneId test = ZoneId.of("Europe/Paris");
 382         checkOffset(test.getRules(), createLDT(2008, 3, 24), ZoneOffset.ofHours(1), 1);
 383         checkOffset(test.getRules(), createLDT(2008, 3, 25), ZoneOffset.ofHours(1), 1);
 384         checkOffset(test.getRules(), createLDT(2008, 3, 26), ZoneOffset.ofHours(1), 1);
 385         checkOffset(test.getRules(), createLDT(2008, 3, 27), ZoneOffset.ofHours(1), 1);
 386         checkOffset(test.getRules(), createLDT(2008, 3, 28), ZoneOffset.ofHours(1), 1);
 387         checkOffset(test.getRules(), createLDT(2008, 3, 29), ZoneOffset.ofHours(1), 1);
 388         checkOffset(test.getRules(), createLDT(2008, 3, 30), ZoneOffset.ofHours(1), 1);
 389         checkOffset(test.getRules(), createLDT(2008, 3, 31), ZoneOffset.ofHours(2), 1);
 390         // cutover at 01:00Z which is 02:00+01:00(local Paris time)
 391         checkOffset(test.getRules(), LocalDateTime.of(2008, 3, 30, 1, 59, 59, 999999999), ZoneOffset.ofHours(1), 1);
 392         checkOffset(test.getRules(), LocalDateTime.of(2008, 3, 30, 2, 30, 0, 0), ZoneOffset.ofHours(1), GAP);
 393         checkOffset(test.getRules(), LocalDateTime.of(2008, 3, 30, 3, 0, 0, 0), ZoneOffset.ofHours(2), 1);
 394     }
 395 
 396     public void test_Paris_getOffsetInfo_fromDST() {
 397         ZoneId test = ZoneId.of("Europe/Paris");
 398         checkOffset(test.getRules(), createLDT(2008, 10, 24), ZoneOffset.ofHours(2), 1);
 399         checkOffset(test.getRules(), createLDT(2008, 10, 25), ZoneOffset.ofHours(2), 1);
 400         checkOffset(test.getRules(), createLDT(2008, 10, 26), ZoneOffset.ofHours(2), 1);
 401         checkOffset(test.getRules(), createLDT(2008, 10, 27), ZoneOffset.ofHours(1), 1);
 402         checkOffset(test.getRules(), createLDT(2008, 10, 28), ZoneOffset.ofHours(1), 1);
 403         checkOffset(test.getRules(), createLDT(2008, 10, 29), ZoneOffset.ofHours(1), 1);
 404         checkOffset(test.getRules(), createLDT(2008, 10, 30), ZoneOffset.ofHours(1), 1);
 405         checkOffset(test.getRules(), createLDT(2008, 10, 31), ZoneOffset.ofHours(1), 1);
 406         // cutover at 01:00Z which is 02:00+01:00(local Paris time)
 407         checkOffset(test.getRules(), LocalDateTime.of(2008, 10, 26, 1, 59, 59, 999999999), ZoneOffset.ofHours(2), 1);
 408         checkOffset(test.getRules(), LocalDateTime.of(2008, 10, 26, 2, 30, 0, 0), ZoneOffset.ofHours(2), OVERLAP);
 409         checkOffset(test.getRules(), LocalDateTime.of(2008, 10, 26, 3, 0, 0, 0), ZoneOffset.ofHours(1), 1);
 410     }
 411 
 412     public void test_Paris_getOffsetInfo_gap() {
 413         ZoneId test = ZoneId.of("Europe/Paris");
 414         final LocalDateTime dateTime = LocalDateTime.of(2008, 3, 30, 2, 0, 0, 0);
 415         ZoneOffsetTransition trans = checkOffset(test.getRules(), dateTime, ZoneOffset.ofHours(1), GAP);
 416         assertEquals(trans.isGap(), true);
 417         assertEquals(trans.isOverlap(), false);
 418         assertEquals(trans.getOffsetBefore(), ZoneOffset.ofHours(1));
 419         assertEquals(trans.getOffsetAfter(), ZoneOffset.ofHours(2));
 420         assertEquals(trans.getInstant(), createInstant(2008, 3, 30, 1, 0, 0, 0, ZoneOffset.UTC));
 421         assertEquals(trans.isValidOffset(ZoneOffset.ofHours(0)), false);
 422         assertEquals(trans.isValidOffset(ZoneOffset.ofHours(1)), false);
 423         assertEquals(trans.isValidOffset(ZoneOffset.ofHours(2)), false);
 424         assertEquals(trans.isValidOffset(ZoneOffset.ofHours(3)), false);
 425         assertEquals(trans.toString(), "Transition[Gap at 2008-03-30T02:00+01:00 to +02:00]");
 426 
 427         assertFalse(trans.equals(null));
 428         assertFalse(trans.equals(ZoneOffset.ofHours(1)));
 429         assertTrue(trans.equals(trans));
 430 
 431         final ZoneOffsetTransition otherDis = test.getRules().getTransition(dateTime);
 432         assertTrue(trans.equals(otherDis));
 433         assertEquals(trans.hashCode(), otherDis.hashCode());
 434     }
 435 
 436     public void test_Paris_getOffsetInfo_overlap() {
 437         ZoneId test = ZoneId.of("Europe/Paris");
 438         final LocalDateTime dateTime = LocalDateTime.of(2008, 10, 26, 2, 0, 0, 0);
 439         ZoneOffsetTransition trans = checkOffset(test.getRules(), dateTime, ZoneOffset.ofHours(2), OVERLAP);
 440         assertEquals(trans.isGap(), false);
 441         assertEquals(trans.isOverlap(), true);
 442         assertEquals(trans.getOffsetBefore(), ZoneOffset.ofHours(2));
 443         assertEquals(trans.getOffsetAfter(), ZoneOffset.ofHours(1));
 444         assertEquals(trans.getInstant(), createInstant(2008, 10, 26, 1, 0, 0, 0, ZoneOffset.UTC));
 445         assertEquals(trans.isValidOffset(ZoneOffset.ofHours(0)), false);
 446         assertEquals(trans.isValidOffset(ZoneOffset.ofHours(1)), true);
 447         assertEquals(trans.isValidOffset(ZoneOffset.ofHours(2)), true);
 448         assertEquals(trans.isValidOffset(ZoneOffset.ofHours(3)), false);
 449         assertEquals(trans.toString(), "Transition[Overlap at 2008-10-26T03:00+02:00 to +01:00]");
 450 
 451         assertFalse(trans.equals(null));
 452         assertFalse(trans.equals(ZoneOffset.ofHours(2)));
 453         assertTrue(trans.equals(trans));
 454 
 455         final ZoneOffsetTransition otherDis = test.getRules().getTransition(dateTime);
 456         assertTrue(trans.equals(otherDis));
 457         assertEquals(trans.hashCode(), otherDis.hashCode());
 458     }
 459 
 460     //-----------------------------------------------------------------------
 461     // America/New_York
 462     //-----------------------------------------------------------------------
 463     public void test_NewYork() {
 464         ZoneId test = ZoneId.of("America/New_York");
 465         assertEquals(test.getId(), "America/New_York");
 466         assertEquals(test.getRules().isFixedOffset(), false);
 467     }
 468 
 469     public void test_NewYork_getOffset() {
 470         ZoneId test = ZoneId.of("America/New_York");
 471         ZoneOffset offset = ZoneOffset.ofHours(-5);
 472         assertEquals(test.getRules().getOffset(createInstant(2008, 1, 1, offset)), ZoneOffset.ofHours(-5));
 473         assertEquals(test.getRules().getOffset(createInstant(2008, 2, 1, offset)), ZoneOffset.ofHours(-5));
 474         assertEquals(test.getRules().getOffset(createInstant(2008, 3, 1, offset)), ZoneOffset.ofHours(-5));
 475         assertEquals(test.getRules().getOffset(createInstant(2008, 4, 1, offset)), ZoneOffset.ofHours(-4));
 476         assertEquals(test.getRules().getOffset(createInstant(2008, 5, 1, offset)), ZoneOffset.ofHours(-4));
 477         assertEquals(test.getRules().getOffset(createInstant(2008, 6, 1, offset)), ZoneOffset.ofHours(-4));
 478         assertEquals(test.getRules().getOffset(createInstant(2008, 7, 1, offset)), ZoneOffset.ofHours(-4));
 479         assertEquals(test.getRules().getOffset(createInstant(2008, 8, 1, offset)), ZoneOffset.ofHours(-4));
 480         assertEquals(test.getRules().getOffset(createInstant(2008, 9, 1, offset)), ZoneOffset.ofHours(-4));
 481         assertEquals(test.getRules().getOffset(createInstant(2008, 10, 1, offset)), ZoneOffset.ofHours(-4));
 482         assertEquals(test.getRules().getOffset(createInstant(2008, 11, 1, offset)), ZoneOffset.ofHours(-4));
 483         assertEquals(test.getRules().getOffset(createInstant(2008, 12, 1, offset)), ZoneOffset.ofHours(-5));
 484         assertEquals(test.getRules().getOffset(createInstant(2008, 1, 28, offset)), ZoneOffset.ofHours(-5));
 485         assertEquals(test.getRules().getOffset(createInstant(2008, 2, 28, offset)), ZoneOffset.ofHours(-5));
 486         assertEquals(test.getRules().getOffset(createInstant(2008, 3, 28, offset)), ZoneOffset.ofHours(-4));
 487         assertEquals(test.getRules().getOffset(createInstant(2008, 4, 28, offset)), ZoneOffset.ofHours(-4));
 488         assertEquals(test.getRules().getOffset(createInstant(2008, 5, 28, offset)), ZoneOffset.ofHours(-4));
 489         assertEquals(test.getRules().getOffset(createInstant(2008, 6, 28, offset)), ZoneOffset.ofHours(-4));
 490         assertEquals(test.getRules().getOffset(createInstant(2008, 7, 28, offset)), ZoneOffset.ofHours(-4));
 491         assertEquals(test.getRules().getOffset(createInstant(2008, 8, 28, offset)), ZoneOffset.ofHours(-4));
 492         assertEquals(test.getRules().getOffset(createInstant(2008, 9, 28, offset)), ZoneOffset.ofHours(-4));
 493         assertEquals(test.getRules().getOffset(createInstant(2008, 10, 28, offset)), ZoneOffset.ofHours(-4));
 494         assertEquals(test.getRules().getOffset(createInstant(2008, 11, 28, offset)), ZoneOffset.ofHours(-5));
 495         assertEquals(test.getRules().getOffset(createInstant(2008, 12, 28, offset)), ZoneOffset.ofHours(-5));
 496     }
 497 
 498     public void test_NewYork_getOffset_toDST() {
 499         ZoneId test = ZoneId.of("America/New_York");
 500         ZoneOffset offset = ZoneOffset.ofHours(-5);
 501         assertEquals(test.getRules().getOffset(createInstant(2008, 3, 8, offset)), ZoneOffset.ofHours(-5));
 502         assertEquals(test.getRules().getOffset(createInstant(2008, 3, 9, offset)), ZoneOffset.ofHours(-5));
 503         assertEquals(test.getRules().getOffset(createInstant(2008, 3, 10, offset)), ZoneOffset.ofHours(-4));
 504         assertEquals(test.getRules().getOffset(createInstant(2008, 3, 11, offset)), ZoneOffset.ofHours(-4));
 505         assertEquals(test.getRules().getOffset(createInstant(2008, 3, 12, offset)), ZoneOffset.ofHours(-4));
 506         assertEquals(test.getRules().getOffset(createInstant(2008, 3, 13, offset)), ZoneOffset.ofHours(-4));
 507         assertEquals(test.getRules().getOffset(createInstant(2008, 3, 14, offset)), ZoneOffset.ofHours(-4));
 508         // cutover at 02:00 local
 509         assertEquals(test.getRules().getOffset(createInstant(2008, 3, 9, 1, 59, 59, 999999999, offset)), ZoneOffset.ofHours(-5));
 510         assertEquals(test.getRules().getOffset(createInstant(2008, 3, 9, 2, 0, 0, 0, offset)), ZoneOffset.ofHours(-4));
 511     }
 512 
 513     public void test_NewYork_getOffset_fromDST() {
 514         ZoneId test = ZoneId.of("America/New_York");
 515         ZoneOffset offset = ZoneOffset.ofHours(-4);
 516         assertEquals(test.getRules().getOffset(createInstant(2008, 11, 1, offset)), ZoneOffset.ofHours(-4));
 517         assertEquals(test.getRules().getOffset(createInstant(2008, 11, 2, offset)), ZoneOffset.ofHours(-4));
 518         assertEquals(test.getRules().getOffset(createInstant(2008, 11, 3, offset)), ZoneOffset.ofHours(-5));
 519         assertEquals(test.getRules().getOffset(createInstant(2008, 11, 4, offset)), ZoneOffset.ofHours(-5));
 520         assertEquals(test.getRules().getOffset(createInstant(2008, 11, 5, offset)), ZoneOffset.ofHours(-5));
 521         assertEquals(test.getRules().getOffset(createInstant(2008, 11, 6, offset)), ZoneOffset.ofHours(-5));
 522         assertEquals(test.getRules().getOffset(createInstant(2008, 11, 7, offset)), ZoneOffset.ofHours(-5));
 523         // cutover at 02:00 local
 524         assertEquals(test.getRules().getOffset(createInstant(2008, 11, 2, 1, 59, 59, 999999999, offset)), ZoneOffset.ofHours(-4));
 525         assertEquals(test.getRules().getOffset(createInstant(2008, 11, 2, 2, 0, 0, 0, offset)), ZoneOffset.ofHours(-5));
 526     }
 527 
 528     public void test_NewYork_getOffsetInfo() {
 529         ZoneId test = ZoneId.of("America/New_York");
 530         checkOffset(test.getRules(), createLDT(2008, 1, 1), ZoneOffset.ofHours(-5), 1);
 531         checkOffset(test.getRules(), createLDT(2008, 2, 1), ZoneOffset.ofHours(-5), 1);
 532         checkOffset(test.getRules(), createLDT(2008, 3, 1), ZoneOffset.ofHours(-5), 1);
 533         checkOffset(test.getRules(), createLDT(2008, 4, 1), ZoneOffset.ofHours(-4), 1);
 534         checkOffset(test.getRules(), createLDT(2008, 5, 1), ZoneOffset.ofHours(-4), 1);
 535         checkOffset(test.getRules(), createLDT(2008, 6, 1), ZoneOffset.ofHours(-4), 1);
 536         checkOffset(test.getRules(), createLDT(2008, 7, 1), ZoneOffset.ofHours(-4), 1);
 537         checkOffset(test.getRules(), createLDT(2008, 8, 1), ZoneOffset.ofHours(-4), 1);
 538         checkOffset(test.getRules(), createLDT(2008, 9, 1), ZoneOffset.ofHours(-4), 1);
 539         checkOffset(test.getRules(), createLDT(2008, 10, 1), ZoneOffset.ofHours(-4), 1);
 540         checkOffset(test.getRules(), createLDT(2008, 11, 1), ZoneOffset.ofHours(-4), 1);
 541         checkOffset(test.getRules(), createLDT(2008, 12, 1), ZoneOffset.ofHours(-5), 1);
 542         checkOffset(test.getRules(), createLDT(2008, 1, 28), ZoneOffset.ofHours(-5), 1);
 543         checkOffset(test.getRules(), createLDT(2008, 2, 28), ZoneOffset.ofHours(-5), 1);
 544         checkOffset(test.getRules(), createLDT(2008, 3, 28), ZoneOffset.ofHours(-4), 1);
 545         checkOffset(test.getRules(), createLDT(2008, 4, 28), ZoneOffset.ofHours(-4), 1);
 546         checkOffset(test.getRules(), createLDT(2008, 5, 28), ZoneOffset.ofHours(-4), 1);
 547         checkOffset(test.getRules(), createLDT(2008, 6, 28), ZoneOffset.ofHours(-4), 1);
 548         checkOffset(test.getRules(), createLDT(2008, 7, 28), ZoneOffset.ofHours(-4), 1);
 549         checkOffset(test.getRules(), createLDT(2008, 8, 28), ZoneOffset.ofHours(-4), 1);
 550         checkOffset(test.getRules(), createLDT(2008, 9, 28), ZoneOffset.ofHours(-4), 1);
 551         checkOffset(test.getRules(), createLDT(2008, 10, 28), ZoneOffset.ofHours(-4), 1);
 552         checkOffset(test.getRules(), createLDT(2008, 11, 28), ZoneOffset.ofHours(-5), 1);
 553         checkOffset(test.getRules(), createLDT(2008, 12, 28), ZoneOffset.ofHours(-5), 1);
 554     }
 555 
 556     public void test_NewYork_getOffsetInfo_toDST() {
 557         ZoneId test = ZoneId.of("America/New_York");
 558         checkOffset(test.getRules(), createLDT(2008, 3, 8), ZoneOffset.ofHours(-5), 1);
 559         checkOffset(test.getRules(), createLDT(2008, 3, 9), ZoneOffset.ofHours(-5), 1);
 560         checkOffset(test.getRules(), createLDT(2008, 3, 10), ZoneOffset.ofHours(-4), 1);
 561         checkOffset(test.getRules(), createLDT(2008, 3, 11), ZoneOffset.ofHours(-4), 1);
 562         checkOffset(test.getRules(), createLDT(2008, 3, 12), ZoneOffset.ofHours(-4), 1);
 563         checkOffset(test.getRules(), createLDT(2008, 3, 13), ZoneOffset.ofHours(-4), 1);
 564         checkOffset(test.getRules(), createLDT(2008, 3, 14), ZoneOffset.ofHours(-4), 1);
 565         // cutover at 02:00 local
 566         checkOffset(test.getRules(), LocalDateTime.of(2008, 3, 9, 1, 59, 59, 999999999), ZoneOffset.ofHours(-5), 1);
 567         checkOffset(test.getRules(), LocalDateTime.of(2008, 3, 9, 2, 30, 0, 0), ZoneOffset.ofHours(-5), GAP);
 568         checkOffset(test.getRules(), LocalDateTime.of(2008, 3, 9, 3, 0, 0, 0), ZoneOffset.ofHours(-4), 1);
 569     }
 570 
 571     public void test_NewYork_getOffsetInfo_fromDST() {
 572         ZoneId test = ZoneId.of("America/New_York");
 573         checkOffset(test.getRules(), createLDT(2008, 11, 1), ZoneOffset.ofHours(-4), 1);
 574         checkOffset(test.getRules(), createLDT(2008, 11, 2), ZoneOffset.ofHours(-4), 1);
 575         checkOffset(test.getRules(), createLDT(2008, 11, 3), ZoneOffset.ofHours(-5), 1);
 576         checkOffset(test.getRules(), createLDT(2008, 11, 4), ZoneOffset.ofHours(-5), 1);
 577         checkOffset(test.getRules(), createLDT(2008, 11, 5), ZoneOffset.ofHours(-5), 1);
 578         checkOffset(test.getRules(), createLDT(2008, 11, 6), ZoneOffset.ofHours(-5), 1);
 579         checkOffset(test.getRules(), createLDT(2008, 11, 7), ZoneOffset.ofHours(-5), 1);
 580         // cutover at 02:00 local
 581         checkOffset(test.getRules(), LocalDateTime.of(2008, 11, 2, 0, 59, 59, 999999999), ZoneOffset.ofHours(-4), 1);
 582         checkOffset(test.getRules(), LocalDateTime.of(2008, 11, 2, 1, 30, 0, 0), ZoneOffset.ofHours(-4), OVERLAP);
 583         checkOffset(test.getRules(), LocalDateTime.of(2008, 11, 2, 2, 0, 0, 0), ZoneOffset.ofHours(-5), 1);
 584     }
 585 
 586     public void test_NewYork_getOffsetInfo_gap() {
 587         ZoneId test = ZoneId.of("America/New_York");
 588         final LocalDateTime dateTime = LocalDateTime.of(2008, 3, 9, 2, 0, 0, 0);
 589         ZoneOffsetTransition trans = checkOffset(test.getRules(), dateTime, ZoneOffset.ofHours(-5), GAP);
 590         assertEquals(trans.getOffsetBefore(), ZoneOffset.ofHours(-5));
 591         assertEquals(trans.getOffsetAfter(), ZoneOffset.ofHours(-4));
 592         assertEquals(trans.getInstant(), createInstant(2008, 3, 9, 2, 0, 0, 0, ZoneOffset.ofHours(-5)));
 593         assertEquals(trans.isValidOffset(ZoneOffset.ofHours(-6)), false);
 594         assertEquals(trans.isValidOffset(ZoneOffset.ofHours(-5)), false);
 595         assertEquals(trans.isValidOffset(ZoneOffset.ofHours(-4)), false);
 596         assertEquals(trans.isValidOffset(ZoneOffset.ofHours(-3)), false);
 597         assertEquals(trans.toString(), "Transition[Gap at 2008-03-09T02:00-05:00 to -04:00]");
 598 
 599         assertFalse(trans.equals(null));
 600         assertFalse(trans.equals(ZoneOffset.ofHours(-5)));
 601         assertTrue(trans.equals(trans));
 602 
 603         final ZoneOffsetTransition otherTrans = test.getRules().getTransition(dateTime);
 604         assertTrue(trans.equals(otherTrans));
 605 
 606         assertEquals(trans.hashCode(), otherTrans.hashCode());
 607     }
 608 
 609     public void test_NewYork_getOffsetInfo_overlap() {
 610         ZoneId test = ZoneId.of("America/New_York");
 611         final LocalDateTime dateTime = LocalDateTime.of(2008, 11, 2, 1, 0, 0, 0);
 612         ZoneOffsetTransition trans = checkOffset(test.getRules(), dateTime, ZoneOffset.ofHours(-4), OVERLAP);
 613         assertEquals(trans.getOffsetBefore(), ZoneOffset.ofHours(-4));
 614         assertEquals(trans.getOffsetAfter(), ZoneOffset.ofHours(-5));
 615         assertEquals(trans.getInstant(), createInstant(2008, 11, 2, 2, 0, 0, 0, ZoneOffset.ofHours(-4)));
 616         assertEquals(trans.isValidOffset(ZoneOffset.ofHours(-1)), false);
 617         assertEquals(trans.isValidOffset(ZoneOffset.ofHours(-5)), true);
 618         assertEquals(trans.isValidOffset(ZoneOffset.ofHours(-4)), true);
 619         assertEquals(trans.isValidOffset(ZoneOffset.ofHours(2)), false);
 620         assertEquals(trans.toString(), "Transition[Overlap at 2008-11-02T02:00-04:00 to -05:00]");
 621 
 622         assertFalse(trans.equals(null));
 623         assertFalse(trans.equals(ZoneOffset.ofHours(-4)));
 624         assertTrue(trans.equals(trans));
 625 
 626         final ZoneOffsetTransition otherTrans = test.getRules().getTransition(dateTime);
 627         assertTrue(trans.equals(otherTrans));
 628 
 629         assertEquals(trans.hashCode(), otherTrans.hashCode());
 630     }
 631 
 632     //-----------------------------------------------------------------------
 633     // getXxx() isXxx()
 634     //-----------------------------------------------------------------------
 635     public void test_get_Tzdb() {
 636         ZoneId test = ZoneId.of("Europe/London");
 637         assertEquals(test.getId(), "Europe/London");
 638         assertEquals(test.getRules().isFixedOffset(), false);
 639     }
 640 
 641     public void test_get_TzdbFixed() {
 642         ZoneId test = ZoneId.of("+01:30");
 643         assertEquals(test.getId(), "+01:30");
 644         assertEquals(test.getRules().isFixedOffset(), true);
 645     }
 646 
 647     //-----------------------------------------------------------------------
 648     //-----------------------------------------------------------------------
 649     //-----------------------------------------------------------------------
 650     private Instant createInstant(int year, int month, int day, ZoneOffset offset) {
 651         return LocalDateTime.of(year, month, day, 0, 0).toInstant(offset);
 652     }
 653 
 654     private Instant createInstant(int year, int month, int day, int hour, int min, int sec, int nano, ZoneOffset offset) {
 655         return LocalDateTime.of(year, month, day, hour, min, sec, nano).toInstant(offset);
 656     }
 657 
 658     private ZonedDateTime createZDT(int year, int month, int day, int hour, int min, int sec, int nano, ZoneId zone) {
 659         return LocalDateTime.of(year, month, day, hour, min, sec, nano).atZone(zone);
 660     }
 661 
 662     private LocalDateTime createLDT(int year, int month, int day) {
 663         return LocalDateTime.of(year, month, day, 0, 0);
 664     }
 665 
 666     private ZoneOffsetTransition checkOffset(ZoneRules rules, LocalDateTime dateTime, ZoneOffset offset, int type) {
 667         List<ZoneOffset> validOffsets = rules.getValidOffsets(dateTime);
 668         assertEquals(validOffsets.size(), type);
 669         assertEquals(rules.getOffset(dateTime), offset);
 670         if (type == 1) {
 671             assertEquals(validOffsets.get(0), offset);
 672             return null;
 673         } else {
 674             ZoneOffsetTransition zot = rules.getTransition(dateTime);
 675             assertNotNull(zot);
 676             assertEquals(zot.isOverlap(), type == 2);
 677             assertEquals(zot.isGap(), type == 0);
 678             assertEquals(zot.isValidOffset(offset), type == 2);
 679             return zot;
 680         }
 681     }
 682 
 683 }