|
1
16 package org.joda.time;
17
18 import java.io.ByteArrayInputStream  ;
19 import java.io.ByteArrayOutputStream ;
20 import java.io.ObjectInputStream ;
21 import java.io.ObjectOutputStream ;
22 import java.io.PrintStream ;
23 import java.lang.reflect.Modifier ;
24 import java.security.AllPermission ;
25 import java.security.CodeSource ;
26 import java.security.Permission ;
27 import java.security.PermissionCollection ;
28 import java.security.Permissions ;
29 import java.security.Policy ;
30 import java.security.ProtectionDomain ;
31 import java.util.HashSet ;
32 import java.util.Locale ;
33 import java.util.Set ;
34 import java.util.TimeZone ;
35
36 import junit.framework.TestCase;
37 import junit.framework.TestSuite;
38
39 import org.joda.time.tz.DefaultNameProvider;
40 import org.joda.time.tz.NameProvider;
41 import org.joda.time.tz.Provider;
42 import org.joda.time.tz.UTCProvider;
43 import org.joda.time.tz.ZoneInfoProvider;
44
45
50 public class TestDateTimeZone extends TestCase {
51 private static final boolean OLD_JDK;
52 static {
53 String str = System.getProperty("java.version");
54 boolean old = true;
55 if (str.length() > 3 &&
56 str.charAt(0) == '1' &&
57 str.charAt(1) == '.' &&
58 (str.charAt(2) == '4' || str.charAt(2) == '5' || str.charAt(2) == '6')) {
59 old = false;
60 }
61 OLD_JDK = old;
62 }
63
64
67 private static final DateTimeZone PARIS = DateTimeZone.forID("Europe/Paris");
68 private static final DateTimeZone LONDON = DateTimeZone.forID("Europe/London");
69
70 long y2002days = 365 + 365 + 366 + 365 + 365 + 365 + 366 + 365 + 365 + 365 +
71 366 + 365 + 365 + 365 + 366 + 365 + 365 + 365 + 366 + 365 +
72 365 + 365 + 366 + 365 + 365 + 365 + 366 + 365 + 365 + 365 +
73 366 + 365;
74 long y2003days = 365 + 365 + 366 + 365 + 365 + 365 + 366 + 365 + 365 + 365 +
75 366 + 365 + 365 + 365 + 366 + 365 + 365 + 365 + 366 + 365 +
76 365 + 365 + 366 + 365 + 365 + 365 + 366 + 365 + 365 + 365 +
77 366 + 365 + 365;
78
79 private long TEST_TIME_SUMMER =
81 (y2002days + 31L + 28L + 31L + 30L + 31L + 9L -1L) * DateTimeConstants.MILLIS_PER_DAY;
82
83 private long TEST_TIME_WINTER =
85 (y2002days + 9L -1L) * DateTimeConstants.MILLIS_PER_DAY;
86
87 private long TEST_TIME1 =
89 (y2002days + 31L + 28L + 31L + 5L -1L) * DateTimeConstants.MILLIS_PER_DAY
90 + 12L * DateTimeConstants.MILLIS_PER_HOUR
91 + 24L * DateTimeConstants.MILLIS_PER_MINUTE;
92
93 private long TEST_TIME2 =
95 (y2003days + 31L + 28L + 31L + 30L + 6L -1L) * DateTimeConstants.MILLIS_PER_DAY
96 + 14L * DateTimeConstants.MILLIS_PER_HOUR
97 + 28L * DateTimeConstants.MILLIS_PER_MINUTE;
98
99 private static final Policy RESTRICT;
100 private static final Policy ALLOW;
101 static {
102 RESTRICT = new Policy () {
104 public PermissionCollection getPermissions(CodeSource codesource) {
105 Permissions p = new Permissions ();
106 p.add(new AllPermission ()); return p;
108 }
109 public void refresh() {
110 }
111 public boolean implies(ProtectionDomain domain, Permission permission) {
112 if (permission instanceof JodaTimePermission) {
113 return false;
114 }
115 return true;
116 }
118 };
119 ALLOW = new Policy () {
120 public PermissionCollection getPermissions(CodeSource codesource) {
121 Permissions p = new Permissions ();
122 p.add(new AllPermission ()); return p;
124 }
125 public void refresh() {
126 }
127 };
128 }
129
130 private DateTimeZone zone;
131 private Locale locale;
132
133 public static void main(String [] args) {
134 junit.textui.TestRunner.run(suite());
135 }
136
137 public static TestSuite suite() {
138 return new TestSuite(TestDateTimeZone.class);
139 }
140
141 public TestDateTimeZone(String name) {
142 super(name);
143 }
144
145 protected void setUp() throws Exception {
146 locale = Locale.getDefault();
147 zone = DateTimeZone.getDefault();
148 Locale.setDefault(Locale.UK);
149 }
150
151 protected void tearDown() throws Exception {
152 Locale.setDefault(locale);
153 DateTimeZone.setDefault(zone);
154 }
155
156 public void testDefault() {
158 assertNotNull(DateTimeZone.getDefault());
159
160 DateTimeZone.setDefault(PARIS);
161 assertSame(PARIS, DateTimeZone.getDefault());
162
163 try {
164 DateTimeZone.setDefault(null);
165 fail();
166 } catch (IllegalArgumentException ex) {}
167 }
168
169 public void testDefaultSecurity() {
170 if (OLD_JDK) {
171 return;
172 }
173 try {
174 Policy.setPolicy(RESTRICT);
175 System.setSecurityManager(new SecurityManager ());
176 DateTimeZone.setDefault(PARIS);
177 fail();
178 } catch (SecurityException ex) {
179 } finally {
181 System.setSecurityManager(null);
182 Policy.setPolicy(ALLOW);
183 }
184 }
185
186 public void testForID_String() {
188 assertEquals(DateTimeZone.getDefault(), DateTimeZone.forID((String ) null));
189
190 DateTimeZone zone = DateTimeZone.forID("Europe/London");
191 assertEquals("Europe/London", zone.getID());
192
193 zone = DateTimeZone.forID("UTC");
194 assertSame(DateTimeZone.UTC, zone);
195
196 zone = DateTimeZone.forID("+00:00");
197 assertSame(DateTimeZone.UTC, zone);
198
199 zone = DateTimeZone.forID("+00");
200 assertSame(DateTimeZone.UTC, zone);
201
202 zone = DateTimeZone.forID("+01:23");
203 assertEquals("+01:23", zone.getID());
204 assertEquals(DateTimeConstants.MILLIS_PER_HOUR + (23L * DateTimeConstants.MILLIS_PER_MINUTE),
205 zone.getOffset(TEST_TIME_SUMMER));
206
207 zone = DateTimeZone.forID("-02:00");
208 assertEquals("-02:00", zone.getID());
209 assertEquals((-2L * DateTimeConstants.MILLIS_PER_HOUR),
210 zone.getOffset(TEST_TIME_SUMMER));
211
212 zone = DateTimeZone.forID("-07:05:34.0");
213 assertEquals("-07:05:34", zone.getID());
214 assertEquals((-7L * DateTimeConstants.MILLIS_PER_HOUR) +
215 (-5L * DateTimeConstants.MILLIS_PER_MINUTE) +
216 (-34L * DateTimeConstants.MILLIS_PER_SECOND),
217 zone.getOffset(TEST_TIME_SUMMER));
218
219 try {
220 DateTimeZone.forID("SST");
221 fail();
222 } catch (IllegalArgumentException ex) {}
223 try {
224 DateTimeZone.forID("Europe/UK");
225 fail();
226 } catch (IllegalArgumentException ex) {}
227 try {
228 DateTimeZone.forID("+");
229 fail();
230 } catch (IllegalArgumentException ex) {}
231 try {
232 DateTimeZone.forID("+0");
233 fail();
234 } catch (IllegalArgumentException ex) {}
235 }
236
237 public void testForOffsetHours_int() {
239 assertEquals(DateTimeZone.UTC, DateTimeZone.forOffsetHours(0));
240 assertEquals(DateTimeZone.forID("+03:00"), DateTimeZone.forOffsetHours(3));
241 assertEquals(DateTimeZone.forID("-02:00"), DateTimeZone.forOffsetHours(-2));
242 try {
243 DateTimeZone.forOffsetHours(999999);
244 fail();
245 } catch (IllegalArgumentException ex) {}
246 }
247
248 public void testForOffsetHoursMinutes_int_int() {
250 assertEquals(DateTimeZone.UTC, DateTimeZone.forOffsetHoursMinutes(0, 0));
251 assertEquals(DateTimeZone.forID("+03:15"), DateTimeZone.forOffsetHoursMinutes(3, 15));
252 assertEquals(DateTimeZone.forID("-02:00"), DateTimeZone.forOffsetHoursMinutes(-2, 0));
253 assertEquals(DateTimeZone.forID("-02:30"), DateTimeZone.forOffsetHoursMinutes(-2, 30));
254 try {
255 DateTimeZone.forOffsetHoursMinutes(2, 60);
256 fail();
257 } catch (IllegalArgumentException ex) {}
258 try {
259 DateTimeZone.forOffsetHoursMinutes(-2, 60);
260 fail();
261 } catch (IllegalArgumentException ex) {}
262 try {
263 DateTimeZone.forOffsetHoursMinutes(2, -1);
264 fail();
265 } catch (IllegalArgumentException ex) {}
266 try {
267 DateTimeZone.forOffsetHoursMinutes(-2, -1);
268 fail();
269 } catch (IllegalArgumentException ex) {}
270 try {
271 DateTimeZone.forOffsetHoursMinutes(999999, 0);
272 fail();
273 } catch (IllegalArgumentException ex) {}
274 }
275
276 public void testForOffsetMillis_int() {
278 assertSame(DateTimeZone.UTC, DateTimeZone.forOffsetMillis(0));
279 assertEquals(DateTimeZone.forID("+03:00"), DateTimeZone.forOffsetMillis(3 * 60 * 60 * 1000));
280 assertEquals(DateTimeZone.forID("-02:00"), DateTimeZone.forOffsetMillis(-2 * 60 * 60 * 1000));
281 assertEquals(DateTimeZone.forID("+04:45:17.045"),
282 DateTimeZone.forOffsetMillis(
283 4 * 60 * 60 * 1000 + 45 * 60 * 1000 + 17 * 1000 + 45));
284 }
285
286 public void testForTimeZone_TimeZone() {
288 assertEquals(DateTimeZone.getDefault(), DateTimeZone.forTimeZone((TimeZone ) null));
289
290 DateTimeZone zone = DateTimeZone.forTimeZone(TimeZone.getTimeZone("Europe/London"));
291 assertEquals("Europe/London", zone.getID());
292 assertSame(DateTimeZone.UTC, DateTimeZone.forTimeZone(TimeZone.getTimeZone("UTC")));
293
294 zone = DateTimeZone.forTimeZone(TimeZone.getTimeZone("+00:00"));
295 assertSame(DateTimeZone.UTC, zone);
296
297 zone = DateTimeZone.forTimeZone(TimeZone.getTimeZone("GMT+00:00"));
298 assertSame(DateTimeZone.UTC, zone);
299
300 zone = DateTimeZone.forTimeZone(TimeZone.getTimeZone("GMT+00:00"));
301 assertSame(DateTimeZone.UTC, zone);
302
303 zone = DateTimeZone.forTimeZone(TimeZone.getTimeZone("GMT+00"));
304 assertSame(DateTimeZone.UTC, zone);
305
306 zone = DateTimeZone.forTimeZone(TimeZone.getTimeZone("GMT+01:23"));
307 assertEquals("+01:23", zone.getID());
308 assertEquals(DateTimeConstants.MILLIS_PER_HOUR + (23L * DateTimeConstants.MILLIS_PER_MINUTE),
309 zone.getOffset(TEST_TIME_SUMMER));
310
311 zone = DateTimeZone.forTimeZone(TimeZone.getTimeZone("GMT-02:00"));
312 assertEquals("-02:00", zone.getID());
313 assertEquals((-2L * DateTimeConstants.MILLIS_PER_HOUR), zone.getOffset(TEST_TIME_SUMMER));
314
315 zone = DateTimeZone.forTimeZone(TimeZone.getTimeZone("EST"));
316 assertEquals("America/New_York", zone.getID());
317 }
318
319 public void testGetAvailableIDs() {
321 assertTrue(DateTimeZone.getAvailableIDs().contains("UTC"));
322 }
323
324 public void testProvider() {
326 try {
327 assertNotNull(DateTimeZone.getProvider());
328
329 Provider provider = DateTimeZone.getProvider();
330 DateTimeZone.setProvider(null);
331 assertEquals(provider.getClass(), DateTimeZone.getProvider().getClass());
332
333 try {
334 DateTimeZone.setProvider(new MockNullIDSProvider());
335 fail();
336 } catch (IllegalArgumentException ex) {}
337 try {
338 DateTimeZone.setProvider(new MockEmptyIDSProvider());
339 fail();
340 } catch (IllegalArgumentException ex) {}
341 try {
342 DateTimeZone.setProvider(new MockNoUTCProvider());
343 fail();
344 } catch (IllegalArgumentException ex) {}
345 try {
346 DateTimeZone.setProvider(new MockBadUTCProvider());
347 fail();
348 } catch (IllegalArgumentException ex) {}
349
350 Provider prov = new MockOKProvider();
351 DateTimeZone.setProvider(prov);
352 assertSame(prov, DateTimeZone.getProvider());
353 assertEquals(2, DateTimeZone.getAvailableIDs().size());
354 assertTrue(DateTimeZone.getAvailableIDs().contains("UTC"));
355 assertTrue(DateTimeZone.getAvailableIDs().contains("Europe/London"));
356 } finally {
357 DateTimeZone.setProvider(null);
358 assertEquals(ZoneInfoProvider.class, DateTimeZone.getProvider().getClass());
359 }
360
361 try {
362 System.setProperty("org.joda.time.DateTimeZone.Provider", "org.joda.time.tz.UTCProvider");
363 DateTimeZone.setProvider(null);
364 assertEquals(UTCProvider.class, DateTimeZone.getProvider().getClass());
365 } finally {
366 System.getProperties().remove("org.joda.time.DateTimeZone.Provider");
367 DateTimeZone.setProvider(null);
368 assertEquals(ZoneInfoProvider.class, DateTimeZone.getProvider().getClass());
369 }
370
371 PrintStream syserr = System.err;
372 try {
373 System.setProperty("org.joda.time.DateTimeZone.Provider", "xxx");
374 ByteArrayOutputStream baos = new ByteArrayOutputStream ();
375 System.setErr(new PrintStream (baos));
376
377 DateTimeZone.setProvider(null);
378
379 assertEquals(ZoneInfoProvider.class, DateTimeZone.getProvider().getClass());
380 String str = new String (baos.toByteArray());
381 assertTrue(str.indexOf("java.lang.ClassNotFoundException") >= 0);
382 } finally {
383 System.setErr(syserr);
384 System.getProperties().remove("org.joda.time.DateTimeZone.Provider");
385 DateTimeZone.setProvider(null);
386 assertEquals(ZoneInfoProvider.class, DateTimeZone.getProvider().getClass());
387 }
388 }
389
390 public void testProviderSecurity() {
391 if (OLD_JDK) {
392 return;
393 }
394 try {
395 Policy.setPolicy(RESTRICT);
396 System.setSecurityManager(new SecurityManager ());
397 DateTimeZone.setProvider(new MockOKProvider());
398 fail();
399 } catch (SecurityException ex) {
400 } finally {
402 System.setSecurityManager(null);
403 Policy.setPolicy(ALLOW);
404 }
405 }
406
407 static class MockNullIDSProvider implements Provider {
408 public Set getAvailableIDs() {
409 return null;
410 }
411 public DateTimeZone getZone(String id) {
412 return null;
413 }
414 }
415 static class MockEmptyIDSProvider implements Provider {
416 public Set getAvailableIDs() {
417 return new HashSet ();
418 }
419 public DateTimeZone getZone(String id) {
420 return null;
421 }
422 }
423 static class MockNoUTCProvider implements Provider {
424 public Set getAvailableIDs() {
425 Set set = new HashSet ();
426 set.add("Europe/London");
427 return set;
428 }
429 public DateTimeZone getZone(String id) {
430 return null;
431 }
432 }
433 static class MockBadUTCProvider implements Provider {
434 public Set getAvailableIDs() {
435 Set set = new HashSet ();
436 set.add("UTC");
437 set.add("Europe/London");
438 return set;
439 }
440 public DateTimeZone getZone(String id) {
441 return null;
442 }
443 }
444 static class MockOKProvider implements Provider {
445 public Set getAvailableIDs() {
446 Set set = new HashSet ();
447 set.add("UTC");
448 set.add("Europe/London");
449 return set;
450 }
451 public DateTimeZone getZone(String id) {
452 return DateTimeZone.UTC;
453 }
454 }
455
456 public void testNameProvider() {
458 try {
459 assertNotNull(DateTimeZone.getNameProvider());
460
461 NameProvider provider = DateTimeZone.getNameProvider();
462 DateTimeZone.setNameProvider(null);
463 assertEquals(provider.getClass(), DateTimeZone.getNameProvider().getClass());
464
465 provider = new MockOKButNullNameProvider();
466 DateTimeZone.setNameProvider(provider);
467 assertSame(provider, DateTimeZone.getNameProvider());
468
469 assertEquals("+00:00", DateTimeZone.UTC.getShortName(TEST_TIME_SUMMER));
470 assertEquals("+00:00", DateTimeZone.UTC.getName(TEST_TIME_SUMMER));
471 } finally {
472 DateTimeZone.setNameProvider(null);
473 }
474
475 try {
476 System.setProperty("org.joda.time.DateTimeZone.NameProvider", "org.joda.time.tz.DefaultNameProvider");
477 DateTimeZone.setNameProvider(null);
478 assertEquals(DefaultNameProvider.class, DateTimeZone.getNameProvider().getClass());
479 } finally {
480 System.getProperties().remove("org.joda.time.DateTimeZone.NameProvider");
481 DateTimeZone.setNameProvider(null);
482 assertEquals(DefaultNameProvider.class, DateTimeZone.getNameProvider().getClass());
483 }
484
485 PrintStream syserr = System.err;
486 try {
487 System.setProperty("org.joda.time.DateTimeZone.NameProvider", "xxx");
488 ByteArrayOutputStream baos = new ByteArrayOutputStream ();
489 System.setErr(new PrintStream (baos));
490
491 DateTimeZone.setNameProvider(null);
492
493 assertEquals(DefaultNameProvider.class, DateTimeZone.getNameProvider().getClass());
494 String str = new String (baos.toByteArray());
495 assertTrue(str.indexOf("java.lang.ClassNotFoundException") >= 0);
496 } finally {
497 System.setErr(syserr);
498 System.getProperties().remove("org.joda.time.DateTimeZone.NameProvider");
499 DateTimeZone.setNameProvider(null);
500 assertEquals(DefaultNameProvider.class, DateTimeZone.getNameProvider().getClass());
501 }
502 }
503
504 public void testNameProviderSecurity() {
505 if (OLD_JDK) {
506 return;
507 }
508 try {
509 Policy.setPolicy(RESTRICT);
510 System.setSecurityManager(new SecurityManager ());
511 DateTimeZone.setNameProvider(new MockOKButNullNameProvider());
512 fail();
513 } catch (SecurityException ex) {
514 } finally {
516 System.setSecurityManager(null);
517 Policy.setPolicy(ALLOW);
518 }
519 }
520
521 static class MockOKButNullNameProvider implements NameProvider {
522 public String getShortName(Locale locale, String id, String nameKey) {
523 return null;
524 }
525 public String getName(Locale locale, String id, String nameKey) {
526 return null;
527 }
528 }
529
530 public void testConstructor() {
532 assertEquals(1, DateTimeZone.class.getDeclaredConstructors().length);
533 assertTrue(Modifier.isProtected(DateTimeZone.class.getDeclaredConstructors()[0].getModifiers()));
534 try {
535 new DateTimeZone(null) {
536 public String getNameKey(long instant) {
537 return null;
538 }
539 public int getOffset(long instant) {
540 return 0;
541 }
542 public int getStandardOffset(long instant) {
543 return 0;
544 }
545 public boolean isFixed() {
546 return false;
547 }
548 public long nextTransition(long instant) {
549 return 0;
550 }
551 public long previousTransition(long instant) {
552 return 0;
553 }
554 public boolean equals(Object object) {
555 return false;
556 }
557 };
558 } catch (IllegalArgumentException ex) {}
559 }
560
561 public void testGetID() {
563 DateTimeZone zone = DateTimeZone.forID("Europe/Paris");
564 assertEquals("Europe/Paris", zone.getID());
565 }
566
567 public void testGetNameKey() {
568 DateTimeZone zone = DateTimeZone.forID("Europe/London");
569 assertEquals("BST", zone.getNameKey(TEST_TIME_SUMMER));
570 assertEquals("GMT", zone.getNameKey(TEST_TIME_WINTER));
571 }
572
573 public void testGetShortName() {
574 DateTimeZone zone = DateTimeZone.forID("Europe/London");
575 assertEquals("BST", zone.getShortName(TEST_TIME_SUMMER));
576 assertEquals("GMT", zone.getShortName(TEST_TIME_WINTER));
577 assertEquals("BST", zone.getShortName(TEST_TIME_SUMMER, Locale.ENGLISH));
578 }
579
580 public void testGetShortNameProviderName() {
581 assertEquals(null, DateTimeZone.getNameProvider().getShortName(null, "Europe/London", "BST"));
582 assertEquals(null, DateTimeZone.getNameProvider().getShortName(Locale.ENGLISH, null, "BST"));
583 assertEquals(null, DateTimeZone.getNameProvider().getShortName(Locale.ENGLISH, "Europe/London", null));
584 assertEquals(null, DateTimeZone.getNameProvider().getShortName(null, null, null));
585 }
586
587 public void testGetShortNameNullKey() {
588 DateTimeZone zone = new MockDateTimeZone("Europe/London");
589 assertEquals("Europe/London", zone.getShortName(TEST_TIME_SUMMER, Locale.ENGLISH));
590 }
591
592 public void testGetName() {
593 DateTimeZone zone = DateTimeZone.forID("Europe/London");
594 assertEquals("British Summer Time", zone.getName(TEST_TIME_SUMMER));
595 assertEquals("Greenwich Mean Time", zone.getName(TEST_TIME_WINTER));
596 assertEquals("British Summer Time", zone.getName(TEST_TIME_SUMMER, Locale.ENGLISH));
597
598 }
599
600 public void testGetNameProviderName() {
601 assertEquals(null, DateTimeZone.getNameProvider().getName(null, "Europe/London", "BST"));
602 assertEquals(null, DateTimeZone.getNameProvider().getName(Locale.ENGLISH, null, "BST"));
603 assertEquals(null, DateTimeZone.getNameProvider().getName(Locale.ENGLISH, "Europe/London", null));
604 assertEquals(null, DateTimeZone.getNameProvider().getName(null, null, null));
605 }
606
607 public void testGetNameNullKey() {
608 DateTimeZone zone = new MockDateTimeZone("Europe/London");
609 assertEquals("Europe/London", zone.getName(TEST_TIME_SUMMER, Locale.ENGLISH));
610 }
611
612 static class MockDateTimeZone extends DateTimeZone {
613 public MockDateTimeZone(String id) {
614 super(id);
615 }
616 public String getNameKey(long instant) {
617 return null; }
619 public int getOffset(long instant) {
620 return 0;
621 }
622 public int getStandardOffset(long instant) {
623 return 0;
624 }
625 public boolean isFixed() {
626 return false;
627 }
628 public long nextTransition(long instant) {
629 return 0;
630 }
631 public long previousTransition(long instant) {
632 return 0;
633 }
634 public boolean equals(Object object) {
635 return false;
636 }
637 }
638
639 public void testGetOffset() {
641 DateTimeZone zone = DateTimeZone.forID("Europe/Paris");
642 assertEquals(2L * DateTimeConstants.MILLIS_PER_HOUR, zone.getOffset(TEST_TIME_SUMMER));
643 assertEquals(1L * DateTimeConstants.MILLIS_PER_HOUR, zone.getOffset(TEST_TIME_WINTER));
644
645 assertEquals(2L * DateTimeConstants.MILLIS_PER_HOUR, zone.getOffset(new Instant(TEST_TIME_SUMMER)));
646 assertEquals(1L * DateTimeConstants.MILLIS_PER_HOUR, zone.getOffset(new Instant(TEST_TIME_WINTER)));
647
648 assertEquals(zone.getOffset(DateTimeUtils.currentTimeMillis()), zone.getOffset(null));
649
650 assertEquals(1L * DateTimeConstants.MILLIS_PER_HOUR, zone.getStandardOffset(TEST_TIME_SUMMER));
651 assertEquals(1L * DateTimeConstants.MILLIS_PER_HOUR, zone.getStandardOffset(TEST_TIME_WINTER));
652
653 assertEquals(2L * DateTimeConstants.MILLIS_PER_HOUR, zone.getOffsetFromLocal(TEST_TIME_SUMMER));
654 assertEquals(1L * DateTimeConstants.MILLIS_PER_HOUR, zone.getOffsetFromLocal(TEST_TIME_WINTER));
655 }
656
657 public void testGetOffsetFixed() {
658 DateTimeZone zone = DateTimeZone.forID("+01:00");
659 assertEquals(1L * DateTimeConstants.MILLIS_PER_HOUR, zone.getOffset(TEST_TIME_SUMMER));
660 assertEquals(1L * DateTimeConstants.MILLIS_PER_HOUR, zone.getOffset(TEST_TIME_WINTER));
661
662 assertEquals(1L * DateTimeConstants.MILLIS_PER_HOUR, zone.getOffset(new Instant(TEST_TIME_SUMMER)));
663 assertEquals(1L * DateTimeConstants.MILLIS_PER_HOUR, zone.getOffset(new Instant(TEST_TIME_WINTER)));
664
665 assertEquals(zone.getOffset(DateTimeUtils.currentTimeMillis()), zone.getOffset(null));
666
667 assertEquals(1L * DateTimeConstants.MILLIS_PER_HOUR, zone.getStandardOffset(TEST_TIME_SUMMER));
668 assertEquals(1L * DateTimeConstants.MILLIS_PER_HOUR, zone.getStandardOffset(TEST_TIME_WINTER));
669
670 assertEquals(1L * DateTimeConstants.MILLIS_PER_HOUR, zone.getOffsetFromLocal(TEST_TIME_SUMMER));
671 assertEquals(1L * DateTimeConstants.MILLIS_PER_HOUR, zone.getOffsetFromLocal(TEST_TIME_WINTER));
672 }
673
674 public void testGetMillisKeepLocal() {
676 long millisLondon = TEST_TIME_SUMMER;
677 long millisParis = TEST_TIME_SUMMER - 1L * DateTimeConstants.MILLIS_PER_HOUR;
678
679 assertEquals(millisLondon, LONDON.getMillisKeepLocal(LONDON, millisLondon));
680 assertEquals(millisParis, LONDON.getMillisKeepLocal(LONDON, millisParis));
681 assertEquals(millisLondon, PARIS.getMillisKeepLocal(PARIS, millisLondon));
682 assertEquals(millisParis, PARIS.getMillisKeepLocal(PARIS, millisParis));
683
684 assertEquals(millisParis, LONDON.getMillisKeepLocal(PARIS, millisLondon));
685 assertEquals(millisLondon, PARIS.getMillisKeepLocal(LONDON, millisParis));
686
687 DateTimeZone zone = DateTimeZone.getDefault();
688 try {
689 DateTimeZone.setDefault(LONDON);
690 assertEquals(millisLondon, PARIS.getMillisKeepLocal(null, millisParis));
691 } finally {
692 DateTimeZone.setDefault(zone);
693 }
694 }
695
696 public void testIsFixed() {
698 DateTimeZone zone = DateTimeZone.forID("Europe/Paris");
699 assertEquals(false, zone.isFixed());
700 assertEquals(true, DateTimeZone.UTC.isFixed());
701 }
702
703 public void testTransitionFixed() {
705 DateTimeZone zone = DateTimeZone.forID("+01:00");
706 assertEquals(TEST_TIME_SUMMER, zone.nextTransition(TEST_TIME_SUMMER));
707 assertEquals(TEST_TIME_WINTER, zone.nextTransition(TEST_TIME_WINTER));
708 assertEquals(TEST_TIME_SUMMER, zone.previousTransition(TEST_TIME_SUMMER));
709 assertEquals(TEST_TIME_WINTER, zone.previousTransition(TEST_TIME_WINTER));
710 }
711
712 public void testToTimeZone() {
714 DateTimeZone zone = DateTimeZone.forID("Europe/Paris");
715 TimeZone tz = zone.toTimeZone();
716 assertEquals("Europe/Paris", tz.getID());
717 }
718
719 public void testEqualsHashCode() {
721 DateTimeZone zone1 = DateTimeZone.forID("Europe/Paris");
722 DateTimeZone zone2 = DateTimeZone.forID("Europe/Paris");
723 assertEquals(true, zone1.equals(zone1));
724 assertEquals(true, zone1.equals(zone2));
725 assertEquals(true, zone2.equals(zone1));
726 assertEquals(true, zone2.equals(zone2));
727 assertEquals(true, zone1.hashCode() == zone2.hashCode());
728
729 DateTimeZone zone3 = DateTimeZone.forID("Europe/London");
730 assertEquals(true, zone3.equals(zone3));
731 assertEquals(false, zone1.equals(zone3));
732 assertEquals(false, zone2.equals(zone3));
733 assertEquals(false, zone3.equals(zone1));
734 assertEquals(false, zone3.equals(zone2));
735 assertEquals(false, zone1.hashCode() == zone3.hashCode());
736 assertEquals(true, zone3.hashCode() == zone3.hashCode());
737
738 DateTimeZone zone4 = DateTimeZone.forID("+01:00");
739 assertEquals(true, zone4.equals(zone4));
740 assertEquals(false, zone1.equals(zone4));
741 assertEquals(false, zone2.equals(zone4));
742 assertEquals(false, zone3.equals(zone4));
743 assertEquals(false, zone4.equals(zone1));
744 assertEquals(false, zone4.equals(zone2));
745 assertEquals(false, zone4.equals(zone3));
746 assertEquals(false, zone1.hashCode() == zone4.hashCode());
747 assertEquals(true, zone4.hashCode() == zone4.hashCode());
748
749 DateTimeZone zone5 = DateTimeZone.forID("+02:00");
750 assertEquals(true, zone5.equals(zone5));
751 assertEquals(false, zone1.equals(zone5));
752 assertEquals(false, zone2.equals(zone5));
753 assertEquals(false, zone3.equals(zone5));
754 assertEquals(false, zone4.equals(zone5));
755 assertEquals(false, zone5.equals(zone1));
756 assertEquals(false, zone5.equals(zone2));
757 assertEquals(false, zone5.equals(zone3));
758 assertEquals(false, zone5.equals(zone4));
759 assertEquals(false, zone1.hashCode() == zone5.hashCode());
760 assertEquals(true, zone5.hashCode() == zone5.hashCode());
761 }
762
763 public void testToString() {
765 DateTimeZone zone = DateTimeZone.forID("Europe/Paris");
766 assertEquals("Europe/Paris", zone.toString());
767 assertEquals("UTC", DateTimeZone.UTC.toString());
768 }
769
770 public void testSerialization1() throws Exception {
772 DateTimeZone zone = DateTimeZone.forID("Europe/Paris");
773
774 ByteArrayOutputStream baos = new ByteArrayOutputStream ();
775 ObjectOutputStream oos = new ObjectOutputStream (baos);
776 oos.writeObject(zone);
777 byte[] bytes = baos.toByteArray();
778 oos.close();
779
780 ByteArrayInputStream bais = new ByteArrayInputStream (bytes);
781 ObjectInputStream ois = new ObjectInputStream (bais);
782 DateTimeZone result = (DateTimeZone) ois.readObject();
783 ois.close();
784
785 assertSame(zone, result);
786 }
787
788 public void testSerialization2() throws Exception {
790 DateTimeZone zone = DateTimeZone.forID("+01:00");
791
792 ByteArrayOutputStream baos = new ByteArrayOutputStream ();
793 ObjectOutputStream oos = new ObjectOutputStream (baos);
794 oos.writeObject(zone);
795 byte[] bytes = baos.toByteArray();
796 oos.close();
797
798 ByteArrayInputStream bais = new ByteArrayInputStream (bytes);
799 ObjectInputStream ois = new ObjectInputStream (bais);
800 DateTimeZone result = (DateTimeZone) ois.readObject();
801 ois.close();
802
803 assertSame(zone, result);
804 }
805
806 public void testCommentParse() throws Exception {
807
810 DateTimeZone zone = DateTimeZone.forID("Europe/Athens");
811 DateTime dt = new DateTime(2005, 5, 5, 20, 10, 15, 0, zone);
812 assertEquals(1115313015000L, dt.getMillis());
813 }
814
815 }
816 |
Popular Tags |
Java API By Example, From Geeks To Geeks.