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; 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.assertTrue; 38 39 import java.io.IOException; 40 import java.lang.reflect.Field; 41 import java.lang.reflect.Modifier; 42 import java.util.HashMap; 43 import java.util.List; 44 import java.util.Locale; 45 import java.util.Map; 46 import java.util.SimpleTimeZone; 47 import java.util.TimeZone; 48 49 import org.testng.annotations.DataProvider; 50 import org.testng.annotations.Test; 51 import org.threeten.bp.format.TextStyle; 52 import org.threeten.bp.temporal.TemporalAccessor; 53 import org.threeten.bp.zone.ZoneOffsetTransition; 54 import org.threeten.bp.zone.ZoneRules; 55 import org.threeten.bp.zone.ZoneRulesException; 56 57 /** 58 * Test ZoneId. 59 */ 60 @Test 61 public class TestZoneId extends AbstractTest { 62 63 private static final ZoneId ZONE_PARIS = ZoneId.of("Europe/Paris"); 64 public static final String LATEST_TZDB = "2010i"; 65 private static final int OVERLAP = 2; 66 private static final int GAP = 0; 67 68 //----------------------------------------------------------------------- 69 // Basics 70 //----------------------------------------------------------------------- test_immutable()71 public void test_immutable() { 72 Class<ZoneId> cls = ZoneId.class; 73 assertTrue(Modifier.isPublic(cls.getModifiers())); 74 Field[] fields = cls.getDeclaredFields(); 75 for (Field field : fields) { 76 if (Modifier.isStatic(field.getModifiers()) == false) { 77 assertTrue(Modifier.isPrivate(field.getModifiers())); 78 assertTrue(Modifier.isFinal(field.getModifiers()) || 79 (Modifier.isVolatile(field.getModifiers()) && Modifier.isTransient(field.getModifiers()))); 80 } 81 } 82 } 83 test_serialization_UTC()84 public void test_serialization_UTC() throws Exception { 85 ZoneId test = ZoneOffset.UTC; 86 assertSerializableAndSame(test); 87 } 88 test_serialization_fixed()89 public void test_serialization_fixed() throws Exception { 90 ZoneId test = ZoneId.of("UTC+01:30"); 91 assertSerializable(test); 92 } 93 test_serialization_Europe()94 public void test_serialization_Europe() throws Exception { 95 ZoneId test = ZoneId.of("Europe/London"); 96 assertSerializable(test); 97 } 98 test_serialization_America()99 public void test_serialization_America() throws Exception { 100 ZoneId test = ZoneId.of("America/Chicago"); 101 assertSerializable(test); 102 } 103 104 @Test test_serialization_format()105 public void test_serialization_format() throws ClassNotFoundException, IOException { 106 assertEqualsSerialisedForm(ZoneId.of("Europe/London"), ZoneId.class); 107 } 108 109 //----------------------------------------------------------------------- 110 // UTC 111 //----------------------------------------------------------------------- test_constant_UTC()112 public void test_constant_UTC() { 113 ZoneId test = ZoneOffset.UTC; 114 assertEquals(test.getId(), "Z"); 115 assertEquals(test.getDisplayName(TextStyle.FULL, Locale.UK), "Z"); 116 assertEquals(test.getRules().isFixedOffset(), true); 117 assertEquals(test.getRules().getOffset(Instant.ofEpochSecond(0L)), ZoneOffset.UTC); 118 checkOffset(test.getRules(), createLDT(2008, 6, 30), ZoneOffset.UTC, 1); 119 } 120 121 //----------------------------------------------------------------------- 122 // SHORT_IDS 123 //----------------------------------------------------------------------- test_constant_SHORT_IDS()124 public void test_constant_SHORT_IDS() { 125 Map<String, String> ids = ZoneId.SHORT_IDS; 126 assertEquals(ids.get("EST"), "-05:00"); 127 assertEquals(ids.get("MST"), "-07:00"); 128 assertEquals(ids.get("HST"), "-10:00"); 129 assertEquals(ids.get("ACT"), "Australia/Darwin"); 130 assertEquals(ids.get("AET"), "Australia/Sydney"); 131 assertEquals(ids.get("AGT"), "America/Argentina/Buenos_Aires"); 132 assertEquals(ids.get("ART"), "Africa/Cairo"); 133 assertEquals(ids.get("AST"), "America/Anchorage"); 134 assertEquals(ids.get("BET"), "America/Sao_Paulo"); 135 assertEquals(ids.get("BST"), "Asia/Dhaka"); 136 assertEquals(ids.get("CAT"), "Africa/Harare"); 137 assertEquals(ids.get("CNT"), "America/St_Johns"); 138 assertEquals(ids.get("CST"), "America/Chicago"); 139 assertEquals(ids.get("CTT"), "Asia/Shanghai"); 140 assertEquals(ids.get("EAT"), "Africa/Addis_Ababa"); 141 assertEquals(ids.get("ECT"), "Europe/Paris"); 142 assertEquals(ids.get("IET"), "America/Indiana/Indianapolis"); 143 assertEquals(ids.get("IST"), "Asia/Kolkata"); 144 assertEquals(ids.get("JST"), "Asia/Tokyo"); 145 assertEquals(ids.get("MIT"), "Pacific/Apia"); 146 assertEquals(ids.get("NET"), "Asia/Yerevan"); 147 assertEquals(ids.get("NST"), "Pacific/Auckland"); 148 assertEquals(ids.get("PLT"), "Asia/Karachi"); 149 assertEquals(ids.get("PNT"), "America/Phoenix"); 150 assertEquals(ids.get("PRT"), "America/Puerto_Rico"); 151 assertEquals(ids.get("PST"), "America/Los_Angeles"); 152 assertEquals(ids.get("SST"), "Pacific/Guadalcanal"); 153 assertEquals(ids.get("VST"), "Asia/Ho_Chi_Minh"); 154 } 155 156 @Test(expectedExceptions=UnsupportedOperationException.class) test_constant_SHORT_IDS_immutable()157 public void test_constant_SHORT_IDS_immutable() { 158 Map<String, String> ids = ZoneId.SHORT_IDS; 159 ids.clear(); 160 } 161 162 //----------------------------------------------------------------------- 163 // system default 164 //----------------------------------------------------------------------- test_systemDefault()165 public void test_systemDefault() { 166 ZoneId test = ZoneId.systemDefault(); 167 assertEquals(test.getId(), TimeZone.getDefault().getID()); 168 } 169 170 @Test(expectedExceptions = DateTimeException.class) test_systemDefault_unableToConvert_badFormat()171 public void test_systemDefault_unableToConvert_badFormat() { 172 TimeZone current = TimeZone.getDefault(); 173 try { 174 TimeZone.setDefault(new SimpleTimeZone(127, "Something Weird")); 175 ZoneId.systemDefault(); 176 } finally { 177 TimeZone.setDefault(current); 178 } 179 } 180 181 @Test(expectedExceptions = ZoneRulesException.class) test_systemDefault_unableToConvert_unknownId()182 public void test_systemDefault_unableToConvert_unknownId() { 183 TimeZone current = TimeZone.getDefault(); 184 try { 185 TimeZone.setDefault(new SimpleTimeZone(127, "SomethingWeird")); 186 ZoneId.systemDefault(); 187 } finally { 188 TimeZone.setDefault(current); 189 } 190 } 191 192 //----------------------------------------------------------------------- 193 // mapped factory 194 //----------------------------------------------------------------------- test_of_string_Map()195 public void test_of_string_Map() { 196 Map<String, String> map = new HashMap<String, String>(); 197 map.put("LONDON", "Europe/London"); 198 map.put("PARIS", "Europe/Paris"); 199 ZoneId test = ZoneId.of("LONDON", map); 200 assertEquals(test.getId(), "Europe/London"); 201 } 202 test_of_string_Map_lookThrough()203 public void test_of_string_Map_lookThrough() { 204 Map<String, String> map = new HashMap<String, String>(); 205 map.put("LONDON", "Europe/London"); 206 map.put("PARIS", "Europe/Paris"); 207 ZoneId test = ZoneId.of("Europe/Madrid", map); 208 assertEquals(test.getId(), "Europe/Madrid"); 209 } 210 test_of_string_Map_emptyMap()211 public void test_of_string_Map_emptyMap() { 212 Map<String, String> map = new HashMap<String, String>(); 213 ZoneId test = ZoneId.of("Europe/Madrid", map); 214 assertEquals(test.getId(), "Europe/Madrid"); 215 } 216 217 @Test(expectedExceptions=DateTimeException.class) test_of_string_Map_badFormat()218 public void test_of_string_Map_badFormat() { 219 Map<String, String> map = new HashMap<String, String>(); 220 ZoneId.of("Not kknown", map); 221 } 222 223 @Test(expectedExceptions=ZoneRulesException.class) test_of_string_Map_unknown()224 public void test_of_string_Map_unknown() { 225 Map<String, String> map = new HashMap<String, String>(); 226 ZoneId.of("Unknown", map); 227 } 228 229 //----------------------------------------------------------------------- 230 // regular factory 231 //----------------------------------------------------------------------- 232 @DataProvider(name="String_UTC") data_of_string_UTC()233 Object[][] data_of_string_UTC() { 234 return new Object[][] { 235 {""}, 236 {"+00"},{"+0000"},{"+00:00"},{"+000000"},{"+00:00:00"}, 237 {"-00"},{"-0000"},{"-00:00"},{"-000000"},{"-00:00:00"}, 238 }; 239 } 240 241 @Test(dataProvider="String_UTC") test_of_string_UTC(String id)242 public void test_of_string_UTC(String id) { 243 ZoneId test = ZoneId.of("UTC" + id); 244 assertEquals(test.getId(), "UTC"); 245 assertEquals(test.normalized(), ZoneOffset.UTC); 246 } 247 248 @Test(dataProvider="String_UTC") test_of_string_GMT(String id)249 public void test_of_string_GMT(String id) { 250 ZoneId test = ZoneId.of("GMT" + id); 251 assertEquals(test.getId(), "GMT"); 252 assertEquals(test.normalized(), ZoneOffset.UTC); 253 } 254 255 @Test(dataProvider="String_UTC") test_of_string_UT(String id)256 public void test_of_string_UT(String id) { 257 ZoneId test = ZoneId.of("UT" + id); 258 assertEquals(test.getId(), "UT"); 259 assertEquals(test.normalized(), ZoneOffset.UTC); 260 } 261 262 //----------------------------------------------------------------------- 263 @DataProvider(name="String_Fixed") data_of_string_Fixed()264 Object[][] data_of_string_Fixed() { 265 return new Object[][] { 266 {"+0", ""}, 267 {"+5", "+05:00"}, 268 {"+01", "+01:00"}, 269 {"+0100", "+01:00"},{"+01:00", "+01:00"}, 270 {"+010000", "+01:00"},{"+01:00:00", "+01:00"}, 271 {"+12", "+12:00"}, 272 {"+1234", "+12:34"},{"+12:34", "+12:34"}, 273 {"+123456", "+12:34:56"},{"+12:34:56", "+12:34:56"}, 274 {"-02", "-02:00"}, 275 {"-5", "-05:00"}, 276 {"-0200", "-02:00"},{"-02:00", "-02:00"}, 277 {"-020000", "-02:00"},{"-02:00:00", "-02:00"}, 278 }; 279 } 280 281 @Test(dataProvider="String_Fixed") test_of_string_offset(String input, String id)282 public void test_of_string_offset(String input, String id) { 283 ZoneId test = ZoneId.of(input); 284 ZoneOffset offset = ZoneOffset.of(id.isEmpty() ? "Z" : id); 285 assertEquals(test, offset); 286 } 287 288 @Test(dataProvider="String_Fixed") test_of_string_FixedUTC(String input, String id)289 public void test_of_string_FixedUTC(String input, String id) { 290 ZoneId test = ZoneId.of("UTC" + input); 291 assertEquals(test.getId(), "UTC" + id); 292 assertEquals(test.getDisplayName(TextStyle.FULL, Locale.UK), "UTC" + id); 293 assertEquals(test.getRules().isFixedOffset(), true); 294 ZoneOffset offset = ZoneOffset.of(id.isEmpty() ? "Z" : id); 295 assertEquals(test.getRules().getOffset(Instant.ofEpochSecond(0L)), offset); 296 checkOffset(test.getRules(), createLDT(2008, 6, 30), offset, 1); 297 } 298 299 @Test(dataProvider="String_Fixed") test_of_string_FixedGMT(String input, String id)300 public void test_of_string_FixedGMT(String input, String id) { 301 ZoneId test = ZoneId.of("GMT" + input); 302 assertEquals(test.getId(), "GMT" + id); 303 assertEquals(test.getDisplayName(TextStyle.FULL, Locale.UK), "GMT" + id); 304 assertEquals(test.getRules().isFixedOffset(), true); 305 ZoneOffset offset = ZoneOffset.of(id.isEmpty() ? "Z" : id); 306 assertEquals(test.getRules().getOffset(Instant.ofEpochSecond(0L)), offset); 307 checkOffset(test.getRules(), createLDT(2008, 6, 30), offset, 1); 308 } 309 310 @Test(dataProvider="String_Fixed") test_of_string_FixedUT(String input, String id)311 public void test_of_string_FixedUT(String input, String id) { 312 ZoneId test = ZoneId.of("UT" + input); 313 assertEquals(test.getId(), "UT" + id); 314 assertEquals(test.getDisplayName(TextStyle.FULL, Locale.UK), "UT" + id); 315 assertEquals(test.getRules().isFixedOffset(), true); 316 ZoneOffset offset = ZoneOffset.of(id.isEmpty() ? "Z" : id); 317 assertEquals(test.getRules().getOffset(Instant.ofEpochSecond(0L)), offset); 318 checkOffset(test.getRules(), createLDT(2008, 6, 30), offset, 1); 319 } 320 321 //----------------------------------------------------------------------- 322 @DataProvider(name="String_UTC_Invalid") data_of_string_UTC_invalid()323 Object[][] data_of_string_UTC_invalid() { 324 return new Object[][] { 325 {"A"}, {"B"}, {"C"}, {"D"}, {"E"}, {"F"}, {"G"}, {"H"}, {"I"}, {"J"}, {"K"}, {"L"}, {"M"}, 326 {"N"}, {"O"}, {"P"}, {"Q"}, {"R"}, {"S"}, {"T"}, {"U"}, {"V"}, {"W"}, {"X"}, {"Y"}, 327 {"+0:00"}, {"+00:0"}, {"+0:0"}, 328 {"+000"}, {"+00000"}, 329 {"+0:00:00"}, {"+00:0:00"}, {"+00:00:0"}, {"+0:0:0"}, {"+0:0:00"}, {"+00:0:0"}, {"+0:00:0"}, 330 {"+01_00"}, {"+01;00"}, {"+01@00"}, {"+01:AA"}, 331 {"+19"}, {"+19:00"}, {"+18:01"}, {"+18:00:01"}, {"+1801"}, {"+180001"}, 332 {"-0:00"}, {"-00:0"}, {"-0:0"}, 333 {"-000"}, {"-00000"}, 334 {"-0:00:00"}, {"-00:0:00"}, {"-00:00:0"}, {"-0:0:0"}, {"-0:0:00"}, {"-00:0:0"}, {"-0:00:0"}, 335 {"-19"}, {"-19:00"}, {"-18:01"}, {"-18:00:01"}, {"-1801"}, {"-180001"}, 336 {"-01_00"}, {"-01;00"}, {"-01@00"}, {"-01:AA"}, 337 {"@01:00"}, 338 }; 339 } 340 341 @Test(dataProvider="String_UTC_Invalid", expectedExceptions=DateTimeException.class) test_of_string_UTC_invalid(String id)342 public void test_of_string_UTC_invalid(String id) { 343 ZoneId.of("UTC" + id); 344 } 345 346 @Test(dataProvider="String_UTC_Invalid", expectedExceptions=DateTimeException.class) test_of_string_GMT_invalid(String id)347 public void test_of_string_GMT_invalid(String id) { 348 ZoneId.of("GMT" + id); 349 } 350 351 //----------------------------------------------------------------------- 352 @DataProvider(name="String_Invalid") data_of_string_invalid()353 Object[][] data_of_string_invalid() { 354 // \u00ef is a random unicode character 355 return new Object[][] { 356 {""}, {":"}, {"#"}, 357 {"\u00ef"}, {"`"}, {"!"}, {"\""}, {"\u00ef"}, {"$"}, {"^"}, {"&"}, {"*"}, {"("}, {")"}, {"="}, 358 {"\\"}, {"|"}, {","}, {"<"}, {">"}, {"?"}, {";"}, {"'"}, {"["}, {"]"}, {"{"}, {"}"}, 359 {"\u00ef:A"}, {"`:A"}, {"!:A"}, {"\":A"}, {"\u00ef:A"}, {"$:A"}, {"^:A"}, {"&:A"}, {"*:A"}, {"(:A"}, {"):A"}, {"=:A"}, {"+:A"}, 360 {"\\:A"}, {"|:A"}, {",:A"}, {"<:A"}, {">:A"}, {"?:A"}, {";:A"}, {"::A"}, {"':A"}, {"@:A"}, {"~:A"}, {"[:A"}, {"]:A"}, {"{:A"}, {"}:A"}, 361 {"A:B#\u00ef"}, {"A:B#`"}, {"A:B#!"}, {"A:B#\""}, {"A:B#\u00ef"}, {"A:B#$"}, {"A:B#^"}, {"A:B#&"}, {"A:B#*"}, 362 {"A:B#("}, {"A:B#)"}, {"A:B#="}, {"A:B#+"}, 363 {"A:B#\\"}, {"A:B#|"}, {"A:B#,"}, {"A:B#<"}, {"A:B#>"}, {"A:B#?"}, {"A:B#;"}, {"A:B#:"}, 364 {"A:B#'"}, {"A:B#@"}, {"A:B#~"}, {"A:B#["}, {"A:B#]"}, {"A:B#{"}, {"A:B#}"}, 365 }; 366 } 367 368 @Test(dataProvider="String_Invalid", expectedExceptions=DateTimeException.class) test_of_string_invalid(String id)369 public void test_of_string_invalid(String id) { 370 ZoneId.of(id); 371 } 372 373 //----------------------------------------------------------------------- test_of_string_GMT0()374 public void test_of_string_GMT0() { 375 ZoneId test = ZoneId.of("GMT0"); 376 assertEquals(test.getId(), "GMT0"); 377 assertEquals(test.getRules().isFixedOffset(), true); 378 assertEquals(test.normalized(), ZoneOffset.UTC); 379 } 380 381 //----------------------------------------------------------------------- test_of_string_London()382 public void test_of_string_London() { 383 ZoneId test = ZoneId.of("Europe/London"); 384 assertEquals(test.getId(), "Europe/London"); 385 assertEquals(test.getRules().isFixedOffset(), false); 386 } 387 388 //----------------------------------------------------------------------- 389 @Test(expectedExceptions=NullPointerException.class) test_of_string_null()390 public void test_of_string_null() { 391 ZoneId.of((String) null); 392 } 393 394 @Test(expectedExceptions=ZoneRulesException.class) test_of_string_unknown_simple()395 public void test_of_string_unknown_simple() { 396 ZoneId.of("Unknown"); 397 } 398 399 //------------------------------------------------------------------------- 400 // TODO: test by deserialization 401 // public void test_ofUnchecked_string_invalidNotChecked() { 402 // ZoneRegion test = ZoneRegion.ofLenient("Unknown"); 403 // assertEquals(test.getId(), "Unknown"); 404 // } 405 // 406 // public void test_ofUnchecked_string_invalidNotChecked_unusualCharacters() { 407 // ZoneRegion test = ZoneRegion.ofLenient("QWERTYUIOPASDFGHJKLZXCVBNM~/._+-"); 408 // assertEquals(test.getId(), "QWERTYUIOPASDFGHJKLZXCVBNM~/._+-"); 409 // } 410 411 //----------------------------------------------------------------------- 412 // from() 413 //----------------------------------------------------------------------- test_factory_CalendricalObject()414 public void test_factory_CalendricalObject() { 415 assertEquals(ZoneId.from(createZDT(2007, 7, 15, 17, 30, 0, 0, ZONE_PARIS)), ZONE_PARIS); 416 } 417 418 @Test(expectedExceptions=DateTimeException.class) test_factory_CalendricalObject_invalid_noDerive()419 public void test_factory_CalendricalObject_invalid_noDerive() { 420 ZoneId.from(LocalTime.of(12, 30)); 421 } 422 423 @Test(expectedExceptions=NullPointerException.class) test_factory_CalendricalObject_null()424 public void test_factory_CalendricalObject_null() { 425 ZoneId.from((TemporalAccessor) null); 426 } 427 428 //----------------------------------------------------------------------- 429 // Europe/London 430 //----------------------------------------------------------------------- test_London()431 public void test_London() { 432 ZoneId test = ZoneId.of("Europe/London"); 433 assertEquals(test.getId(), "Europe/London"); 434 assertEquals(test.getRules().isFixedOffset(), false); 435 } 436 test_London_getOffset()437 public void test_London_getOffset() { 438 ZoneId test = ZoneId.of("Europe/London"); 439 assertEquals(test.getRules().getOffset(createInstant(2008, 1, 1, ZoneOffset.UTC)), ZoneOffset.ofHours(0)); 440 assertEquals(test.getRules().getOffset(createInstant(2008, 2, 1, ZoneOffset.UTC)), ZoneOffset.ofHours(0)); 441 assertEquals(test.getRules().getOffset(createInstant(2008, 3, 1, ZoneOffset.UTC)), ZoneOffset.ofHours(0)); 442 assertEquals(test.getRules().getOffset(createInstant(2008, 4, 1, ZoneOffset.UTC)), ZoneOffset.ofHours(1)); 443 assertEquals(test.getRules().getOffset(createInstant(2008, 5, 1, ZoneOffset.UTC)), ZoneOffset.ofHours(1)); 444 assertEquals(test.getRules().getOffset(createInstant(2008, 6, 1, ZoneOffset.UTC)), ZoneOffset.ofHours(1)); 445 assertEquals(test.getRules().getOffset(createInstant(2008, 7, 1, ZoneOffset.UTC)), ZoneOffset.ofHours(1)); 446 assertEquals(test.getRules().getOffset(createInstant(2008, 8, 1, ZoneOffset.UTC)), ZoneOffset.ofHours(1)); 447 assertEquals(test.getRules().getOffset(createInstant(2008, 9, 1, ZoneOffset.UTC)), ZoneOffset.ofHours(1)); 448 assertEquals(test.getRules().getOffset(createInstant(2008, 10, 1, ZoneOffset.UTC)), ZoneOffset.ofHours(1)); 449 assertEquals(test.getRules().getOffset(createInstant(2008, 11, 1, ZoneOffset.UTC)), ZoneOffset.ofHours(0)); 450 assertEquals(test.getRules().getOffset(createInstant(2008, 12, 1, ZoneOffset.UTC)), ZoneOffset.ofHours(0)); 451 } 452 test_London_getOffset_toDST()453 public void test_London_getOffset_toDST() { 454 ZoneId test = ZoneId.of("Europe/London"); 455 assertEquals(test.getRules().getOffset(createInstant(2008, 3, 24, ZoneOffset.UTC)), ZoneOffset.ofHours(0)); 456 assertEquals(test.getRules().getOffset(createInstant(2008, 3, 25, ZoneOffset.UTC)), ZoneOffset.ofHours(0)); 457 assertEquals(test.getRules().getOffset(createInstant(2008, 3, 26, ZoneOffset.UTC)), ZoneOffset.ofHours(0)); 458 assertEquals(test.getRules().getOffset(createInstant(2008, 3, 27, ZoneOffset.UTC)), ZoneOffset.ofHours(0)); 459 assertEquals(test.getRules().getOffset(createInstant(2008, 3, 28, ZoneOffset.UTC)), ZoneOffset.ofHours(0)); 460 assertEquals(test.getRules().getOffset(createInstant(2008, 3, 29, ZoneOffset.UTC)), ZoneOffset.ofHours(0)); 461 assertEquals(test.getRules().getOffset(createInstant(2008, 3, 30, ZoneOffset.UTC)), ZoneOffset.ofHours(0)); 462 assertEquals(test.getRules().getOffset(createInstant(2008, 3, 31, ZoneOffset.UTC)), ZoneOffset.ofHours(1)); 463 // cutover at 01:00Z 464 assertEquals(test.getRules().getOffset(createInstant(2008, 3, 30, 0, 59, 59, 999999999, ZoneOffset.UTC)), ZoneOffset.ofHours(0)); 465 assertEquals(test.getRules().getOffset(createInstant(2008, 3, 30, 1, 0, 0, 0, ZoneOffset.UTC)), ZoneOffset.ofHours(1)); 466 } 467 test_London_getOffset_fromDST()468 public void test_London_getOffset_fromDST() { 469 ZoneId test = ZoneId.of("Europe/London"); 470 assertEquals(test.getRules().getOffset(createInstant(2008, 10, 24, ZoneOffset.UTC)), ZoneOffset.ofHours(1)); 471 assertEquals(test.getRules().getOffset(createInstant(2008, 10, 25, ZoneOffset.UTC)), ZoneOffset.ofHours(1)); 472 assertEquals(test.getRules().getOffset(createInstant(2008, 10, 26, ZoneOffset.UTC)), ZoneOffset.ofHours(1)); 473 assertEquals(test.getRules().getOffset(createInstant(2008, 10, 27, ZoneOffset.UTC)), ZoneOffset.ofHours(0)); 474 assertEquals(test.getRules().getOffset(createInstant(2008, 10, 28, ZoneOffset.UTC)), ZoneOffset.ofHours(0)); 475 assertEquals(test.getRules().getOffset(createInstant(2008, 10, 29, ZoneOffset.UTC)), ZoneOffset.ofHours(0)); 476 assertEquals(test.getRules().getOffset(createInstant(2008, 10, 30, ZoneOffset.UTC)), ZoneOffset.ofHours(0)); 477 assertEquals(test.getRules().getOffset(createInstant(2008, 10, 31, ZoneOffset.UTC)), ZoneOffset.ofHours(0)); 478 // cutover at 01:00Z 479 assertEquals(test.getRules().getOffset(createInstant(2008, 10, 26, 0, 59, 59, 999999999, ZoneOffset.UTC)), ZoneOffset.ofHours(1)); 480 assertEquals(test.getRules().getOffset(createInstant(2008, 10, 26, 1, 0, 0, 0, ZoneOffset.UTC)), ZoneOffset.ofHours(0)); 481 } 482 test_London_getOffsetInfo()483 public void test_London_getOffsetInfo() { 484 ZoneId test = ZoneId.of("Europe/London"); 485 checkOffset(test.getRules(), createLDT(2008, 1, 1), ZoneOffset.ofHours(0), 1); 486 checkOffset(test.getRules(), createLDT(2008, 2, 1), ZoneOffset.ofHours(0), 1); 487 checkOffset(test.getRules(), createLDT(2008, 3, 1), ZoneOffset.ofHours(0), 1); 488 checkOffset(test.getRules(), createLDT(2008, 4, 1), ZoneOffset.ofHours(1), 1); 489 checkOffset(test.getRules(), createLDT(2008, 5, 1), ZoneOffset.ofHours(1), 1); 490 checkOffset(test.getRules(), createLDT(2008, 6, 1), ZoneOffset.ofHours(1), 1); 491 checkOffset(test.getRules(), createLDT(2008, 7, 1), ZoneOffset.ofHours(1), 1); 492 checkOffset(test.getRules(), createLDT(2008, 8, 1), ZoneOffset.ofHours(1), 1); 493 checkOffset(test.getRules(), createLDT(2008, 9, 1), ZoneOffset.ofHours(1), 1); 494 checkOffset(test.getRules(), createLDT(2008, 10, 1), ZoneOffset.ofHours(1), 1); 495 checkOffset(test.getRules(), createLDT(2008, 11, 1), ZoneOffset.ofHours(0), 1); 496 checkOffset(test.getRules(), createLDT(2008, 12, 1), ZoneOffset.ofHours(0), 1); 497 } 498 test_London_getOffsetInfo_toDST()499 public void test_London_getOffsetInfo_toDST() { 500 ZoneId test = ZoneId.of("Europe/London"); 501 checkOffset(test.getRules(), createLDT(2008, 3, 24), ZoneOffset.ofHours(0), 1); 502 checkOffset(test.getRules(), createLDT(2008, 3, 25), ZoneOffset.ofHours(0), 1); 503 checkOffset(test.getRules(), createLDT(2008, 3, 26), ZoneOffset.ofHours(0), 1); 504 checkOffset(test.getRules(), createLDT(2008, 3, 27), ZoneOffset.ofHours(0), 1); 505 checkOffset(test.getRules(), createLDT(2008, 3, 28), ZoneOffset.ofHours(0), 1); 506 checkOffset(test.getRules(), createLDT(2008, 3, 29), ZoneOffset.ofHours(0), 1); 507 checkOffset(test.getRules(), createLDT(2008, 3, 30), ZoneOffset.ofHours(0), 1); 508 checkOffset(test.getRules(), createLDT(2008, 3, 31), ZoneOffset.ofHours(1), 1); 509 // cutover at 01:00Z 510 checkOffset(test.getRules(), LocalDateTime.of(2008, 3, 30, 0, 59, 59, 999999999), ZoneOffset.ofHours(0), 1); 511 checkOffset(test.getRules(), LocalDateTime.of(2008, 3, 30, 1, 30, 0, 0), ZoneOffset.ofHours(0), GAP); 512 checkOffset(test.getRules(), LocalDateTime.of(2008, 3, 30, 2, 0, 0, 0), ZoneOffset.ofHours(1), 1); 513 } 514 test_London_getOffsetInfo_fromDST()515 public void test_London_getOffsetInfo_fromDST() { 516 ZoneId test = ZoneId.of("Europe/London"); 517 checkOffset(test.getRules(), createLDT(2008, 10, 24), ZoneOffset.ofHours(1), 1); 518 checkOffset(test.getRules(), createLDT(2008, 10, 25), ZoneOffset.ofHours(1), 1); 519 checkOffset(test.getRules(), createLDT(2008, 10, 26), ZoneOffset.ofHours(1), 1); 520 checkOffset(test.getRules(), createLDT(2008, 10, 27), ZoneOffset.ofHours(0), 1); 521 checkOffset(test.getRules(), createLDT(2008, 10, 28), ZoneOffset.ofHours(0), 1); 522 checkOffset(test.getRules(), createLDT(2008, 10, 29), ZoneOffset.ofHours(0), 1); 523 checkOffset(test.getRules(), createLDT(2008, 10, 30), ZoneOffset.ofHours(0), 1); 524 checkOffset(test.getRules(), createLDT(2008, 10, 31), ZoneOffset.ofHours(0), 1); 525 // cutover at 01:00Z 526 checkOffset(test.getRules(), LocalDateTime.of(2008, 10, 26, 0, 59, 59, 999999999), ZoneOffset.ofHours(1), 1); 527 checkOffset(test.getRules(), LocalDateTime.of(2008, 10, 26, 1, 30, 0, 0), ZoneOffset.ofHours(1), OVERLAP); 528 checkOffset(test.getRules(), LocalDateTime.of(2008, 10, 26, 2, 0, 0, 0), ZoneOffset.ofHours(0), 1); 529 } 530 test_London_getOffsetInfo_gap()531 public void test_London_getOffsetInfo_gap() { 532 ZoneId test = ZoneId.of("Europe/London"); 533 final LocalDateTime dateTime = LocalDateTime.of(2008, 3, 30, 1, 0, 0, 0); 534 ZoneOffsetTransition trans = checkOffset(test.getRules(), dateTime, ZoneOffset.ofHours(0), GAP); 535 assertEquals(trans.isGap(), true); 536 assertEquals(trans.isOverlap(), false); 537 assertEquals(trans.getOffsetBefore(), ZoneOffset.ofHours(0)); 538 assertEquals(trans.getOffsetAfter(), ZoneOffset.ofHours(1)); 539 assertEquals(trans.getInstant(), dateTime.toInstant(ZoneOffset.UTC)); 540 assertEquals(trans.getDateTimeBefore(), LocalDateTime.of(2008, 3, 30, 1, 0)); 541 assertEquals(trans.getDateTimeAfter(), LocalDateTime.of(2008, 3, 30, 2, 0)); 542 assertEquals(trans.isValidOffset(ZoneOffset.ofHours(-1)), false); 543 assertEquals(trans.isValidOffset(ZoneOffset.ofHours(0)), false); 544 assertEquals(trans.isValidOffset(ZoneOffset.ofHours(1)), false); 545 assertEquals(trans.isValidOffset(ZoneOffset.ofHours(2)), false); 546 assertEquals(trans.toString(), "Transition[Gap at 2008-03-30T01:00Z to +01:00]"); 547 548 assertFalse(trans.equals(null)); 549 assertFalse(trans.equals(ZoneOffset.ofHours(0))); 550 assertTrue(trans.equals(trans)); 551 552 final ZoneOffsetTransition otherTrans = test.getRules().getTransition(dateTime); 553 assertTrue(trans.equals(otherTrans)); 554 assertEquals(trans.hashCode(), otherTrans.hashCode()); 555 } 556 test_London_getOffsetInfo_overlap()557 public void test_London_getOffsetInfo_overlap() { 558 ZoneId test = ZoneId.of("Europe/London"); 559 final LocalDateTime dateTime = LocalDateTime.of(2008, 10, 26, 1, 0, 0, 0); 560 ZoneOffsetTransition trans = checkOffset(test.getRules(), dateTime, ZoneOffset.ofHours(1), OVERLAP); 561 assertEquals(trans.isGap(), false); 562 assertEquals(trans.isOverlap(), true); 563 assertEquals(trans.getOffsetBefore(), ZoneOffset.ofHours(1)); 564 assertEquals(trans.getOffsetAfter(), ZoneOffset.ofHours(0)); 565 assertEquals(trans.getInstant(), dateTime.toInstant(ZoneOffset.UTC)); 566 assertEquals(trans.getDateTimeBefore(), LocalDateTime.of(2008, 10, 26, 2, 0)); 567 assertEquals(trans.getDateTimeAfter(), LocalDateTime.of(2008, 10, 26, 1, 0)); 568 assertEquals(trans.isValidOffset(ZoneOffset.ofHours(-1)), false); 569 assertEquals(trans.isValidOffset(ZoneOffset.ofHours(0)), true); 570 assertEquals(trans.isValidOffset(ZoneOffset.ofHours(1)), true); 571 assertEquals(trans.isValidOffset(ZoneOffset.ofHours(2)), false); 572 assertEquals(trans.toString(), "Transition[Overlap at 2008-10-26T02:00+01:00 to Z]"); 573 574 assertFalse(trans.equals(null)); 575 assertFalse(trans.equals(ZoneOffset.ofHours(1))); 576 assertTrue(trans.equals(trans)); 577 578 final ZoneOffsetTransition otherTrans = test.getRules().getTransition(dateTime); 579 assertTrue(trans.equals(otherTrans)); 580 assertEquals(trans.hashCode(), otherTrans.hashCode()); 581 } 582 583 //----------------------------------------------------------------------- 584 // Europe/Paris 585 //----------------------------------------------------------------------- test_Paris()586 public void test_Paris() { 587 ZoneId test = ZoneId.of("Europe/Paris"); 588 assertEquals(test.getId(), "Europe/Paris"); 589 assertEquals(test.getRules().isFixedOffset(), false); 590 } 591 test_Paris_getOffset()592 public void test_Paris_getOffset() { 593 ZoneId test = ZoneId.of("Europe/Paris"); 594 assertEquals(test.getRules().getOffset(createInstant(2008, 1, 1, ZoneOffset.UTC)), ZoneOffset.ofHours(1)); 595 assertEquals(test.getRules().getOffset(createInstant(2008, 2, 1, ZoneOffset.UTC)), ZoneOffset.ofHours(1)); 596 assertEquals(test.getRules().getOffset(createInstant(2008, 3, 1, ZoneOffset.UTC)), ZoneOffset.ofHours(1)); 597 assertEquals(test.getRules().getOffset(createInstant(2008, 4, 1, ZoneOffset.UTC)), ZoneOffset.ofHours(2)); 598 assertEquals(test.getRules().getOffset(createInstant(2008, 5, 1, ZoneOffset.UTC)), ZoneOffset.ofHours(2)); 599 assertEquals(test.getRules().getOffset(createInstant(2008, 6, 1, ZoneOffset.UTC)), ZoneOffset.ofHours(2)); 600 assertEquals(test.getRules().getOffset(createInstant(2008, 7, 1, ZoneOffset.UTC)), ZoneOffset.ofHours(2)); 601 assertEquals(test.getRules().getOffset(createInstant(2008, 8, 1, ZoneOffset.UTC)), ZoneOffset.ofHours(2)); 602 assertEquals(test.getRules().getOffset(createInstant(2008, 9, 1, ZoneOffset.UTC)), ZoneOffset.ofHours(2)); 603 assertEquals(test.getRules().getOffset(createInstant(2008, 10, 1, ZoneOffset.UTC)), ZoneOffset.ofHours(2)); 604 assertEquals(test.getRules().getOffset(createInstant(2008, 11, 1, ZoneOffset.UTC)), ZoneOffset.ofHours(1)); 605 assertEquals(test.getRules().getOffset(createInstant(2008, 12, 1, ZoneOffset.UTC)), ZoneOffset.ofHours(1)); 606 } 607 test_Paris_getOffset_toDST()608 public void test_Paris_getOffset_toDST() { 609 ZoneId test = ZoneId.of("Europe/Paris"); 610 assertEquals(test.getRules().getOffset(createInstant(2008, 3, 24, ZoneOffset.UTC)), ZoneOffset.ofHours(1)); 611 assertEquals(test.getRules().getOffset(createInstant(2008, 3, 25, ZoneOffset.UTC)), ZoneOffset.ofHours(1)); 612 assertEquals(test.getRules().getOffset(createInstant(2008, 3, 26, ZoneOffset.UTC)), ZoneOffset.ofHours(1)); 613 assertEquals(test.getRules().getOffset(createInstant(2008, 3, 27, ZoneOffset.UTC)), ZoneOffset.ofHours(1)); 614 assertEquals(test.getRules().getOffset(createInstant(2008, 3, 28, ZoneOffset.UTC)), ZoneOffset.ofHours(1)); 615 assertEquals(test.getRules().getOffset(createInstant(2008, 3, 29, ZoneOffset.UTC)), ZoneOffset.ofHours(1)); 616 assertEquals(test.getRules().getOffset(createInstant(2008, 3, 30, ZoneOffset.UTC)), ZoneOffset.ofHours(1)); 617 assertEquals(test.getRules().getOffset(createInstant(2008, 3, 31, ZoneOffset.UTC)), ZoneOffset.ofHours(2)); 618 // cutover at 01:00Z 619 assertEquals(test.getRules().getOffset(createInstant(2008, 3, 30, 0, 59, 59, 999999999, ZoneOffset.UTC)), ZoneOffset.ofHours(1)); 620 assertEquals(test.getRules().getOffset(createInstant(2008, 3, 30, 1, 0, 0, 0, ZoneOffset.UTC)), ZoneOffset.ofHours(2)); 621 } 622 test_Paris_getOffset_fromDST()623 public void test_Paris_getOffset_fromDST() { 624 ZoneId test = ZoneId.of("Europe/Paris"); 625 assertEquals(test.getRules().getOffset(createInstant(2008, 10, 24, ZoneOffset.UTC)), ZoneOffset.ofHours(2)); 626 assertEquals(test.getRules().getOffset(createInstant(2008, 10, 25, ZoneOffset.UTC)), ZoneOffset.ofHours(2)); 627 assertEquals(test.getRules().getOffset(createInstant(2008, 10, 26, ZoneOffset.UTC)), ZoneOffset.ofHours(2)); 628 assertEquals(test.getRules().getOffset(createInstant(2008, 10, 27, ZoneOffset.UTC)), ZoneOffset.ofHours(1)); 629 assertEquals(test.getRules().getOffset(createInstant(2008, 10, 28, ZoneOffset.UTC)), ZoneOffset.ofHours(1)); 630 assertEquals(test.getRules().getOffset(createInstant(2008, 10, 29, ZoneOffset.UTC)), ZoneOffset.ofHours(1)); 631 assertEquals(test.getRules().getOffset(createInstant(2008, 10, 30, ZoneOffset.UTC)), ZoneOffset.ofHours(1)); 632 assertEquals(test.getRules().getOffset(createInstant(2008, 10, 31, ZoneOffset.UTC)), ZoneOffset.ofHours(1)); 633 // cutover at 01:00Z 634 assertEquals(test.getRules().getOffset(createInstant(2008, 10, 26, 0, 59, 59, 999999999, ZoneOffset.UTC)), ZoneOffset.ofHours(2)); 635 assertEquals(test.getRules().getOffset(createInstant(2008, 10, 26, 1, 0, 0, 0, ZoneOffset.UTC)), ZoneOffset.ofHours(1)); 636 } 637 test_Paris_getOffsetInfo()638 public void test_Paris_getOffsetInfo() { 639 ZoneId test = ZoneId.of("Europe/Paris"); 640 checkOffset(test.getRules(), createLDT(2008, 1, 1), ZoneOffset.ofHours(1), 1); 641 checkOffset(test.getRules(), createLDT(2008, 2, 1), ZoneOffset.ofHours(1), 1); 642 checkOffset(test.getRules(), createLDT(2008, 3, 1), ZoneOffset.ofHours(1), 1); 643 checkOffset(test.getRules(), createLDT(2008, 4, 1), ZoneOffset.ofHours(2), 1); 644 checkOffset(test.getRules(), createLDT(2008, 5, 1), ZoneOffset.ofHours(2), 1); 645 checkOffset(test.getRules(), createLDT(2008, 6, 1), ZoneOffset.ofHours(2), 1); 646 checkOffset(test.getRules(), createLDT(2008, 7, 1), ZoneOffset.ofHours(2), 1); 647 checkOffset(test.getRules(), createLDT(2008, 8, 1), ZoneOffset.ofHours(2), 1); 648 checkOffset(test.getRules(), createLDT(2008, 9, 1), ZoneOffset.ofHours(2), 1); 649 checkOffset(test.getRules(), createLDT(2008, 10, 1), ZoneOffset.ofHours(2), 1); 650 checkOffset(test.getRules(), createLDT(2008, 11, 1), ZoneOffset.ofHours(1), 1); 651 checkOffset(test.getRules(), createLDT(2008, 12, 1), ZoneOffset.ofHours(1), 1); 652 } 653 test_Paris_getOffsetInfo_toDST()654 public void test_Paris_getOffsetInfo_toDST() { 655 ZoneId test = ZoneId.of("Europe/Paris"); 656 checkOffset(test.getRules(), createLDT(2008, 3, 24), ZoneOffset.ofHours(1), 1); 657 checkOffset(test.getRules(), createLDT(2008, 3, 25), ZoneOffset.ofHours(1), 1); 658 checkOffset(test.getRules(), createLDT(2008, 3, 26), ZoneOffset.ofHours(1), 1); 659 checkOffset(test.getRules(), createLDT(2008, 3, 27), ZoneOffset.ofHours(1), 1); 660 checkOffset(test.getRules(), createLDT(2008, 3, 28), ZoneOffset.ofHours(1), 1); 661 checkOffset(test.getRules(), createLDT(2008, 3, 29), ZoneOffset.ofHours(1), 1); 662 checkOffset(test.getRules(), createLDT(2008, 3, 30), ZoneOffset.ofHours(1), 1); 663 checkOffset(test.getRules(), createLDT(2008, 3, 31), ZoneOffset.ofHours(2), 1); 664 // cutover at 01:00Z which is 02:00+01:00(local Paris time) 665 checkOffset(test.getRules(), LocalDateTime.of(2008, 3, 30, 1, 59, 59, 999999999), ZoneOffset.ofHours(1), 1); 666 checkOffset(test.getRules(), LocalDateTime.of(2008, 3, 30, 2, 30, 0, 0), ZoneOffset.ofHours(1), GAP); 667 checkOffset(test.getRules(), LocalDateTime.of(2008, 3, 30, 3, 0, 0, 0), ZoneOffset.ofHours(2), 1); 668 } 669 test_Paris_getOffsetInfo_fromDST()670 public void test_Paris_getOffsetInfo_fromDST() { 671 ZoneId test = ZoneId.of("Europe/Paris"); 672 checkOffset(test.getRules(), createLDT(2008, 10, 24), ZoneOffset.ofHours(2), 1); 673 checkOffset(test.getRules(), createLDT(2008, 10, 25), ZoneOffset.ofHours(2), 1); 674 checkOffset(test.getRules(), createLDT(2008, 10, 26), ZoneOffset.ofHours(2), 1); 675 checkOffset(test.getRules(), createLDT(2008, 10, 27), ZoneOffset.ofHours(1), 1); 676 checkOffset(test.getRules(), createLDT(2008, 10, 28), ZoneOffset.ofHours(1), 1); 677 checkOffset(test.getRules(), createLDT(2008, 10, 29), ZoneOffset.ofHours(1), 1); 678 checkOffset(test.getRules(), createLDT(2008, 10, 30), ZoneOffset.ofHours(1), 1); 679 checkOffset(test.getRules(), createLDT(2008, 10, 31), ZoneOffset.ofHours(1), 1); 680 // cutover at 01:00Z which is 02:00+01:00(local Paris time) 681 checkOffset(test.getRules(), LocalDateTime.of(2008, 10, 26, 1, 59, 59, 999999999), ZoneOffset.ofHours(2), 1); 682 checkOffset(test.getRules(), LocalDateTime.of(2008, 10, 26, 2, 30, 0, 0), ZoneOffset.ofHours(2), OVERLAP); 683 checkOffset(test.getRules(), LocalDateTime.of(2008, 10, 26, 3, 0, 0, 0), ZoneOffset.ofHours(1), 1); 684 } 685 test_Paris_getOffsetInfo_gap()686 public void test_Paris_getOffsetInfo_gap() { 687 ZoneId test = ZoneId.of("Europe/Paris"); 688 final LocalDateTime dateTime = LocalDateTime.of(2008, 3, 30, 2, 0, 0, 0); 689 ZoneOffsetTransition trans = checkOffset(test.getRules(), dateTime, ZoneOffset.ofHours(1), GAP); 690 assertEquals(trans.isGap(), true); 691 assertEquals(trans.isOverlap(), false); 692 assertEquals(trans.getOffsetBefore(), ZoneOffset.ofHours(1)); 693 assertEquals(trans.getOffsetAfter(), ZoneOffset.ofHours(2)); 694 assertEquals(trans.getInstant(), createInstant(2008, 3, 30, 1, 0, 0, 0, ZoneOffset.UTC)); 695 assertEquals(trans.isValidOffset(ZoneOffset.ofHours(0)), false); 696 assertEquals(trans.isValidOffset(ZoneOffset.ofHours(1)), false); 697 assertEquals(trans.isValidOffset(ZoneOffset.ofHours(2)), false); 698 assertEquals(trans.isValidOffset(ZoneOffset.ofHours(3)), false); 699 assertEquals(trans.toString(), "Transition[Gap at 2008-03-30T02:00+01:00 to +02:00]"); 700 701 assertFalse(trans.equals(null)); 702 assertFalse(trans.equals(ZoneOffset.ofHours(1))); 703 assertTrue(trans.equals(trans)); 704 705 final ZoneOffsetTransition otherDis = test.getRules().getTransition(dateTime); 706 assertTrue(trans.equals(otherDis)); 707 assertEquals(trans.hashCode(), otherDis.hashCode()); 708 } 709 test_Paris_getOffsetInfo_overlap()710 public void test_Paris_getOffsetInfo_overlap() { 711 ZoneId test = ZoneId.of("Europe/Paris"); 712 final LocalDateTime dateTime = LocalDateTime.of(2008, 10, 26, 2, 0, 0, 0); 713 ZoneOffsetTransition trans = checkOffset(test.getRules(), dateTime, ZoneOffset.ofHours(2), OVERLAP); 714 assertEquals(trans.isGap(), false); 715 assertEquals(trans.isOverlap(), true); 716 assertEquals(trans.getOffsetBefore(), ZoneOffset.ofHours(2)); 717 assertEquals(trans.getOffsetAfter(), ZoneOffset.ofHours(1)); 718 assertEquals(trans.getInstant(), createInstant(2008, 10, 26, 1, 0, 0, 0, ZoneOffset.UTC)); 719 assertEquals(trans.isValidOffset(ZoneOffset.ofHours(0)), false); 720 assertEquals(trans.isValidOffset(ZoneOffset.ofHours(1)), true); 721 assertEquals(trans.isValidOffset(ZoneOffset.ofHours(2)), true); 722 assertEquals(trans.isValidOffset(ZoneOffset.ofHours(3)), false); 723 assertEquals(trans.toString(), "Transition[Overlap at 2008-10-26T03:00+02:00 to +01:00]"); 724 725 assertFalse(trans.equals(null)); 726 assertFalse(trans.equals(ZoneOffset.ofHours(2))); 727 assertTrue(trans.equals(trans)); 728 729 final ZoneOffsetTransition otherDis = test.getRules().getTransition(dateTime); 730 assertTrue(trans.equals(otherDis)); 731 assertEquals(trans.hashCode(), otherDis.hashCode()); 732 } 733 734 //----------------------------------------------------------------------- 735 // America/New_York 736 //----------------------------------------------------------------------- test_NewYork()737 public void test_NewYork() { 738 ZoneId test = ZoneId.of("America/New_York"); 739 assertEquals(test.getId(), "America/New_York"); 740 assertEquals(test.getRules().isFixedOffset(), false); 741 } 742 test_NewYork_getOffset()743 public void test_NewYork_getOffset() { 744 ZoneId test = ZoneId.of("America/New_York"); 745 ZoneOffset offset = ZoneOffset.ofHours(-5); 746 assertEquals(test.getRules().getOffset(createInstant(2008, 1, 1, offset)), ZoneOffset.ofHours(-5)); 747 assertEquals(test.getRules().getOffset(createInstant(2008, 2, 1, offset)), ZoneOffset.ofHours(-5)); 748 assertEquals(test.getRules().getOffset(createInstant(2008, 3, 1, offset)), ZoneOffset.ofHours(-5)); 749 assertEquals(test.getRules().getOffset(createInstant(2008, 4, 1, offset)), ZoneOffset.ofHours(-4)); 750 assertEquals(test.getRules().getOffset(createInstant(2008, 5, 1, offset)), ZoneOffset.ofHours(-4)); 751 assertEquals(test.getRules().getOffset(createInstant(2008, 6, 1, offset)), ZoneOffset.ofHours(-4)); 752 assertEquals(test.getRules().getOffset(createInstant(2008, 7, 1, offset)), ZoneOffset.ofHours(-4)); 753 assertEquals(test.getRules().getOffset(createInstant(2008, 8, 1, offset)), ZoneOffset.ofHours(-4)); 754 assertEquals(test.getRules().getOffset(createInstant(2008, 9, 1, offset)), ZoneOffset.ofHours(-4)); 755 assertEquals(test.getRules().getOffset(createInstant(2008, 10, 1, offset)), ZoneOffset.ofHours(-4)); 756 assertEquals(test.getRules().getOffset(createInstant(2008, 11, 1, offset)), ZoneOffset.ofHours(-4)); 757 assertEquals(test.getRules().getOffset(createInstant(2008, 12, 1, offset)), ZoneOffset.ofHours(-5)); 758 assertEquals(test.getRules().getOffset(createInstant(2008, 1, 28, offset)), ZoneOffset.ofHours(-5)); 759 assertEquals(test.getRules().getOffset(createInstant(2008, 2, 28, offset)), ZoneOffset.ofHours(-5)); 760 assertEquals(test.getRules().getOffset(createInstant(2008, 3, 28, offset)), ZoneOffset.ofHours(-4)); 761 assertEquals(test.getRules().getOffset(createInstant(2008, 4, 28, offset)), ZoneOffset.ofHours(-4)); 762 assertEquals(test.getRules().getOffset(createInstant(2008, 5, 28, offset)), ZoneOffset.ofHours(-4)); 763 assertEquals(test.getRules().getOffset(createInstant(2008, 6, 28, offset)), ZoneOffset.ofHours(-4)); 764 assertEquals(test.getRules().getOffset(createInstant(2008, 7, 28, offset)), ZoneOffset.ofHours(-4)); 765 assertEquals(test.getRules().getOffset(createInstant(2008, 8, 28, offset)), ZoneOffset.ofHours(-4)); 766 assertEquals(test.getRules().getOffset(createInstant(2008, 9, 28, offset)), ZoneOffset.ofHours(-4)); 767 assertEquals(test.getRules().getOffset(createInstant(2008, 10, 28, offset)), ZoneOffset.ofHours(-4)); 768 assertEquals(test.getRules().getOffset(createInstant(2008, 11, 28, offset)), ZoneOffset.ofHours(-5)); 769 assertEquals(test.getRules().getOffset(createInstant(2008, 12, 28, offset)), ZoneOffset.ofHours(-5)); 770 } 771 test_NewYork_getOffset_toDST()772 public void test_NewYork_getOffset_toDST() { 773 ZoneId test = ZoneId.of("America/New_York"); 774 ZoneOffset offset = ZoneOffset.ofHours(-5); 775 assertEquals(test.getRules().getOffset(createInstant(2008, 3, 8, offset)), ZoneOffset.ofHours(-5)); 776 assertEquals(test.getRules().getOffset(createInstant(2008, 3, 9, offset)), ZoneOffset.ofHours(-5)); 777 assertEquals(test.getRules().getOffset(createInstant(2008, 3, 10, offset)), ZoneOffset.ofHours(-4)); 778 assertEquals(test.getRules().getOffset(createInstant(2008, 3, 11, offset)), ZoneOffset.ofHours(-4)); 779 assertEquals(test.getRules().getOffset(createInstant(2008, 3, 12, offset)), ZoneOffset.ofHours(-4)); 780 assertEquals(test.getRules().getOffset(createInstant(2008, 3, 13, offset)), ZoneOffset.ofHours(-4)); 781 assertEquals(test.getRules().getOffset(createInstant(2008, 3, 14, offset)), ZoneOffset.ofHours(-4)); 782 // cutover at 02:00 local 783 assertEquals(test.getRules().getOffset(createInstant(2008, 3, 9, 1, 59, 59, 999999999, offset)), ZoneOffset.ofHours(-5)); 784 assertEquals(test.getRules().getOffset(createInstant(2008, 3, 9, 2, 0, 0, 0, offset)), ZoneOffset.ofHours(-4)); 785 } 786 test_NewYork_getOffset_fromDST()787 public void test_NewYork_getOffset_fromDST() { 788 ZoneId test = ZoneId.of("America/New_York"); 789 ZoneOffset offset = ZoneOffset.ofHours(-4); 790 assertEquals(test.getRules().getOffset(createInstant(2008, 11, 1, offset)), ZoneOffset.ofHours(-4)); 791 assertEquals(test.getRules().getOffset(createInstant(2008, 11, 2, offset)), ZoneOffset.ofHours(-4)); 792 assertEquals(test.getRules().getOffset(createInstant(2008, 11, 3, offset)), ZoneOffset.ofHours(-5)); 793 assertEquals(test.getRules().getOffset(createInstant(2008, 11, 4, offset)), ZoneOffset.ofHours(-5)); 794 assertEquals(test.getRules().getOffset(createInstant(2008, 11, 5, offset)), ZoneOffset.ofHours(-5)); 795 assertEquals(test.getRules().getOffset(createInstant(2008, 11, 6, offset)), ZoneOffset.ofHours(-5)); 796 assertEquals(test.getRules().getOffset(createInstant(2008, 11, 7, offset)), ZoneOffset.ofHours(-5)); 797 // cutover at 02:00 local 798 assertEquals(test.getRules().getOffset(createInstant(2008, 11, 2, 1, 59, 59, 999999999, offset)), ZoneOffset.ofHours(-4)); 799 assertEquals(test.getRules().getOffset(createInstant(2008, 11, 2, 2, 0, 0, 0, offset)), ZoneOffset.ofHours(-5)); 800 } 801 test_NewYork_getOffsetInfo()802 public void test_NewYork_getOffsetInfo() { 803 ZoneId test = ZoneId.of("America/New_York"); 804 checkOffset(test.getRules(), createLDT(2008, 1, 1), ZoneOffset.ofHours(-5), 1); 805 checkOffset(test.getRules(), createLDT(2008, 2, 1), ZoneOffset.ofHours(-5), 1); 806 checkOffset(test.getRules(), createLDT(2008, 3, 1), ZoneOffset.ofHours(-5), 1); 807 checkOffset(test.getRules(), createLDT(2008, 4, 1), ZoneOffset.ofHours(-4), 1); 808 checkOffset(test.getRules(), createLDT(2008, 5, 1), ZoneOffset.ofHours(-4), 1); 809 checkOffset(test.getRules(), createLDT(2008, 6, 1), ZoneOffset.ofHours(-4), 1); 810 checkOffset(test.getRules(), createLDT(2008, 7, 1), ZoneOffset.ofHours(-4), 1); 811 checkOffset(test.getRules(), createLDT(2008, 8, 1), ZoneOffset.ofHours(-4), 1); 812 checkOffset(test.getRules(), createLDT(2008, 9, 1), ZoneOffset.ofHours(-4), 1); 813 checkOffset(test.getRules(), createLDT(2008, 10, 1), ZoneOffset.ofHours(-4), 1); 814 checkOffset(test.getRules(), createLDT(2008, 11, 1), ZoneOffset.ofHours(-4), 1); 815 checkOffset(test.getRules(), createLDT(2008, 12, 1), ZoneOffset.ofHours(-5), 1); 816 checkOffset(test.getRules(), createLDT(2008, 1, 28), ZoneOffset.ofHours(-5), 1); 817 checkOffset(test.getRules(), createLDT(2008, 2, 28), ZoneOffset.ofHours(-5), 1); 818 checkOffset(test.getRules(), createLDT(2008, 3, 28), ZoneOffset.ofHours(-4), 1); 819 checkOffset(test.getRules(), createLDT(2008, 4, 28), ZoneOffset.ofHours(-4), 1); 820 checkOffset(test.getRules(), createLDT(2008, 5, 28), ZoneOffset.ofHours(-4), 1); 821 checkOffset(test.getRules(), createLDT(2008, 6, 28), ZoneOffset.ofHours(-4), 1); 822 checkOffset(test.getRules(), createLDT(2008, 7, 28), ZoneOffset.ofHours(-4), 1); 823 checkOffset(test.getRules(), createLDT(2008, 8, 28), ZoneOffset.ofHours(-4), 1); 824 checkOffset(test.getRules(), createLDT(2008, 9, 28), ZoneOffset.ofHours(-4), 1); 825 checkOffset(test.getRules(), createLDT(2008, 10, 28), ZoneOffset.ofHours(-4), 1); 826 checkOffset(test.getRules(), createLDT(2008, 11, 28), ZoneOffset.ofHours(-5), 1); 827 checkOffset(test.getRules(), createLDT(2008, 12, 28), ZoneOffset.ofHours(-5), 1); 828 } 829 test_NewYork_getOffsetInfo_toDST()830 public void test_NewYork_getOffsetInfo_toDST() { 831 ZoneId test = ZoneId.of("America/New_York"); 832 checkOffset(test.getRules(), createLDT(2008, 3, 8), ZoneOffset.ofHours(-5), 1); 833 checkOffset(test.getRules(), createLDT(2008, 3, 9), ZoneOffset.ofHours(-5), 1); 834 checkOffset(test.getRules(), createLDT(2008, 3, 10), ZoneOffset.ofHours(-4), 1); 835 checkOffset(test.getRules(), createLDT(2008, 3, 11), ZoneOffset.ofHours(-4), 1); 836 checkOffset(test.getRules(), createLDT(2008, 3, 12), ZoneOffset.ofHours(-4), 1); 837 checkOffset(test.getRules(), createLDT(2008, 3, 13), ZoneOffset.ofHours(-4), 1); 838 checkOffset(test.getRules(), createLDT(2008, 3, 14), ZoneOffset.ofHours(-4), 1); 839 // cutover at 02:00 local 840 checkOffset(test.getRules(), LocalDateTime.of(2008, 3, 9, 1, 59, 59, 999999999), ZoneOffset.ofHours(-5), 1); 841 checkOffset(test.getRules(), LocalDateTime.of(2008, 3, 9, 2, 30, 0, 0), ZoneOffset.ofHours(-5), GAP); 842 checkOffset(test.getRules(), LocalDateTime.of(2008, 3, 9, 3, 0, 0, 0), ZoneOffset.ofHours(-4), 1); 843 } 844 test_NewYork_getOffsetInfo_fromDST()845 public void test_NewYork_getOffsetInfo_fromDST() { 846 ZoneId test = ZoneId.of("America/New_York"); 847 checkOffset(test.getRules(), createLDT(2008, 11, 1), ZoneOffset.ofHours(-4), 1); 848 checkOffset(test.getRules(), createLDT(2008, 11, 2), ZoneOffset.ofHours(-4), 1); 849 checkOffset(test.getRules(), createLDT(2008, 11, 3), ZoneOffset.ofHours(-5), 1); 850 checkOffset(test.getRules(), createLDT(2008, 11, 4), ZoneOffset.ofHours(-5), 1); 851 checkOffset(test.getRules(), createLDT(2008, 11, 5), ZoneOffset.ofHours(-5), 1); 852 checkOffset(test.getRules(), createLDT(2008, 11, 6), ZoneOffset.ofHours(-5), 1); 853 checkOffset(test.getRules(), createLDT(2008, 11, 7), ZoneOffset.ofHours(-5), 1); 854 // cutover at 02:00 local 855 checkOffset(test.getRules(), LocalDateTime.of(2008, 11, 2, 0, 59, 59, 999999999), ZoneOffset.ofHours(-4), 1); 856 checkOffset(test.getRules(), LocalDateTime.of(2008, 11, 2, 1, 30, 0, 0), ZoneOffset.ofHours(-4), OVERLAP); 857 checkOffset(test.getRules(), LocalDateTime.of(2008, 11, 2, 2, 0, 0, 0), ZoneOffset.ofHours(-5), 1); 858 } 859 test_NewYork_getOffsetInfo_gap()860 public void test_NewYork_getOffsetInfo_gap() { 861 ZoneId test = ZoneId.of("America/New_York"); 862 final LocalDateTime dateTime = LocalDateTime.of(2008, 3, 9, 2, 0, 0, 0); 863 ZoneOffsetTransition trans = checkOffset(test.getRules(), dateTime, ZoneOffset.ofHours(-5), GAP); 864 assertEquals(trans.getOffsetBefore(), ZoneOffset.ofHours(-5)); 865 assertEquals(trans.getOffsetAfter(), ZoneOffset.ofHours(-4)); 866 assertEquals(trans.getInstant(), createInstant(2008, 3, 9, 2, 0, 0, 0, ZoneOffset.ofHours(-5))); 867 assertEquals(trans.isValidOffset(ZoneOffset.ofHours(-6)), false); 868 assertEquals(trans.isValidOffset(ZoneOffset.ofHours(-5)), false); 869 assertEquals(trans.isValidOffset(ZoneOffset.ofHours(-4)), false); 870 assertEquals(trans.isValidOffset(ZoneOffset.ofHours(-3)), false); 871 assertEquals(trans.toString(), "Transition[Gap at 2008-03-09T02:00-05:00 to -04:00]"); 872 873 assertFalse(trans.equals(null)); 874 assertFalse(trans.equals(ZoneOffset.ofHours(-5))); 875 assertTrue(trans.equals(trans)); 876 877 final ZoneOffsetTransition otherTrans = test.getRules().getTransition(dateTime); 878 assertTrue(trans.equals(otherTrans)); 879 880 assertEquals(trans.hashCode(), otherTrans.hashCode()); 881 } 882 test_NewYork_getOffsetInfo_overlap()883 public void test_NewYork_getOffsetInfo_overlap() { 884 ZoneId test = ZoneId.of("America/New_York"); 885 final LocalDateTime dateTime = LocalDateTime.of(2008, 11, 2, 1, 0, 0, 0); 886 ZoneOffsetTransition trans = checkOffset(test.getRules(), dateTime, ZoneOffset.ofHours(-4), OVERLAP); 887 assertEquals(trans.getOffsetBefore(), ZoneOffset.ofHours(-4)); 888 assertEquals(trans.getOffsetAfter(), ZoneOffset.ofHours(-5)); 889 assertEquals(trans.getInstant(), createInstant(2008, 11, 2, 2, 0, 0, 0, ZoneOffset.ofHours(-4))); 890 assertEquals(trans.isValidOffset(ZoneOffset.ofHours(-1)), false); 891 assertEquals(trans.isValidOffset(ZoneOffset.ofHours(-5)), true); 892 assertEquals(trans.isValidOffset(ZoneOffset.ofHours(-4)), true); 893 assertEquals(trans.isValidOffset(ZoneOffset.ofHours(2)), false); 894 assertEquals(trans.toString(), "Transition[Overlap at 2008-11-02T02:00-04:00 to -05:00]"); 895 896 assertFalse(trans.equals(null)); 897 assertFalse(trans.equals(ZoneOffset.ofHours(-4))); 898 assertTrue(trans.equals(trans)); 899 900 final ZoneOffsetTransition otherTrans = test.getRules().getTransition(dateTime); 901 assertTrue(trans.equals(otherTrans)); 902 903 assertEquals(trans.hashCode(), otherTrans.hashCode()); 904 } 905 906 //----------------------------------------------------------------------- 907 // getXxx() isXxx() 908 //----------------------------------------------------------------------- test_get_Tzdb()909 public void test_get_Tzdb() { 910 ZoneId test = ZoneId.of("Europe/London"); 911 assertEquals(test.getId(), "Europe/London"); 912 assertEquals(test.getRules().isFixedOffset(), false); 913 } 914 test_get_TzdbFixed()915 public void test_get_TzdbFixed() { 916 ZoneId test = ZoneId.of("+01:30"); 917 assertEquals(test.getId(), "+01:30"); 918 assertEquals(test.getRules().isFixedOffset(), true); 919 } 920 921 //----------------------------------------------------------------------- 922 // equals() / hashCode() 923 //----------------------------------------------------------------------- test_equals()924 public void test_equals() { 925 ZoneId test1 = ZoneId.of("Europe/London"); 926 ZoneId test2 = ZoneId.of("Europe/Paris"); 927 ZoneId test2b = ZoneId.of("Europe/Paris"); 928 assertEquals(test1.equals(test2), false); 929 assertEquals(test2.equals(test1), false); 930 931 assertEquals(test1.equals(test1), true); 932 assertEquals(test2.equals(test2), true); 933 assertEquals(test2.equals(test2b), true); 934 935 assertEquals(test1.hashCode() == test1.hashCode(), true); 936 assertEquals(test2.hashCode() == test2.hashCode(), true); 937 assertEquals(test2.hashCode() == test2b.hashCode(), true); 938 } 939 test_equals_null()940 public void test_equals_null() { 941 assertEquals(ZoneId.of("Europe/London").equals(null), false); 942 } 943 test_equals_notTimeZone()944 public void test_equals_notTimeZone() { 945 assertEquals(ZoneId.of("Europe/London").equals("Europe/London"), false); 946 } 947 948 //----------------------------------------------------------------------- 949 // toString() 950 //----------------------------------------------------------------------- 951 @DataProvider(name="ToString") data_toString()952 Object[][] data_toString() { 953 return new Object[][] { 954 {"Europe/London", "Europe/London"}, 955 {"Europe/Paris", "Europe/Paris"}, 956 {"Europe/Berlin", "Europe/Berlin"}, 957 {"Z", "Z"}, 958 {"UTC", "UTC"}, 959 {"UTC+01:00", "UTC+01:00"}, 960 {"GMT+01:00", "GMT+01:00"}, 961 {"UT+01:00", "UT+01:00"}, 962 }; 963 } 964 965 @Test(dataProvider="ToString") test_toString(String id, String expected)966 public void test_toString(String id, String expected) { 967 ZoneId test = ZoneId.of(id); 968 assertEquals(test.toString(), expected); 969 } 970 971 //----------------------------------------------------------------------- 972 //----------------------------------------------------------------------- 973 //----------------------------------------------------------------------- createInstant(int year, int month, int day, ZoneOffset offset)974 private Instant createInstant(int year, int month, int day, ZoneOffset offset) { 975 return LocalDateTime.of(year, month, day, 0, 0).toInstant(offset); 976 } 977 createInstant(int year, int month, int day, int hour, int min, int sec, int nano, ZoneOffset offset)978 private Instant createInstant(int year, int month, int day, int hour, int min, int sec, int nano, ZoneOffset offset) { 979 return LocalDateTime.of(year, month, day, hour, min, sec, nano).toInstant(offset); 980 } 981 createZDT(int year, int month, int day, int hour, int min, int sec, int nano, ZoneId zone)982 private ZonedDateTime createZDT(int year, int month, int day, int hour, int min, int sec, int nano, ZoneId zone) { 983 return LocalDateTime.of(year, month, day, hour, min, sec, nano).atZone(zone); 984 } 985 createLDT(int year, int month, int day)986 private LocalDateTime createLDT(int year, int month, int day) { 987 return LocalDateTime.of(year, month, day, 0, 0); 988 } 989 checkOffset(ZoneRules rules, LocalDateTime dateTime, ZoneOffset offset, int type)990 private ZoneOffsetTransition checkOffset(ZoneRules rules, LocalDateTime dateTime, ZoneOffset offset, int type) { 991 List<ZoneOffset> validOffsets = rules.getValidOffsets(dateTime); 992 assertEquals(validOffsets.size(), type); 993 assertEquals(rules.getOffset(dateTime), offset); 994 if (type == 1) { 995 assertEquals(validOffsets.get(0), offset); 996 return null; 997 } else { 998 ZoneOffsetTransition zot = rules.getTransition(dateTime); 999 assertNotNull(zot); 1000 assertEquals(zot.isOverlap(), type == 2); 1001 assertEquals(zot.isGap(), type == 0); 1002 assertEquals(zot.isValidOffset(offset), type == 2); 1003 return zot; 1004 } 1005 } 1006 1007 } 1008