View Javadoc

1   /*
2    *  Copyright 2001-2012 Stephen Colebourne
3    *
4    *  Licensed under the Apache License, Version 2.0 (the "License");
5    *  you may not use this file except in compliance with the License.
6    *  You may obtain a copy of the License at
7    *
8    *      http://www.apache.org/licenses/LICENSE-2.0
9    *
10   *  Unless required by applicable law or agreed to in writing, software
11   *  distributed under the License is distributed on an "AS IS" BASIS,
12   *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13   *  See the License for the specific language governing permissions and
14   *  limitations under the License.
15   */
16  package org.joda.time;
17  
18  import java.lang.reflect.Modifier;
19  import java.security.AllPermission;
20  import java.security.CodeSource;
21  import java.security.Permission;
22  import java.security.PermissionCollection;
23  import java.security.Permissions;
24  import java.security.Policy;
25  import java.security.ProtectionDomain;
26  
27  import junit.framework.TestCase;
28  import junit.framework.TestSuite;
29  
30  import org.joda.time.DateTimeUtils.MillisProvider;
31  import org.joda.time.base.AbstractInstant;
32  import org.joda.time.chrono.BuddhistChronology;
33  import org.joda.time.chrono.CopticChronology;
34  import org.joda.time.chrono.GJChronology;
35  import org.joda.time.chrono.ISOChronology;
36  import org.joda.time.chrono.JulianChronology;
37  
38  /**
39   * This class is a Junit unit test for DateTimeUtils.
40   *
41   * @author Stephen Colebourne
42   */
43  public class TestDateTimeUtils extends TestCase {
44  
45      private static final GJChronology GJ = GJChronology.getInstance();
46      private static final boolean OLD_JDK;
47      static {
48          String str = System.getProperty("java.version");
49          boolean old = true;
50          if (str.length() > 3 &&
51              str.charAt(0) == '1' &&
52              str.charAt(1) == '.' &&
53              (str.charAt(2) == '4' || str.charAt(2) == '5' || str.charAt(2) == '6')) {
54              old = false;
55          }
56          OLD_JDK = old;
57      }
58  
59      // Test in 2002/03 as time zones are more well known
60      // (before the late 90's they were all over the place)
61  
62      private static final DateTimeZone PARIS = DateTimeZone.forID("Europe/Paris");
63      private static final DateTimeZone LONDON = DateTimeZone.forID("Europe/London");
64      
65      long y2002days = 365 + 365 + 366 + 365 + 365 + 365 + 366 + 365 + 365 + 365 + 
66                       366 + 365 + 365 + 365 + 366 + 365 + 365 + 365 + 366 + 365 + 
67                       365 + 365 + 366 + 365 + 365 + 365 + 366 + 365 + 365 + 365 +
68                       366 + 365;
69      long y2003days = 365 + 365 + 366 + 365 + 365 + 365 + 366 + 365 + 365 + 365 + 
70                       366 + 365 + 365 + 365 + 366 + 365 + 365 + 365 + 366 + 365 + 
71                       365 + 365 + 366 + 365 + 365 + 365 + 366 + 365 + 365 + 365 +
72                       366 + 365 + 365;
73      
74      // 2002-06-09
75      private long TEST_TIME_NOW =
76              (y2002days + 31L + 28L + 31L + 30L + 31L + 9L -1L) * DateTimeConstants.MILLIS_PER_DAY;
77              
78      // 2002-04-05
79      private long TEST_TIME1 =
80              (y2002days + 31L + 28L + 31L + 5L -1L) * DateTimeConstants.MILLIS_PER_DAY
81              + 12L * DateTimeConstants.MILLIS_PER_HOUR
82              + 24L * DateTimeConstants.MILLIS_PER_MINUTE;
83          
84      // 2003-05-06
85      private long TEST_TIME2 =
86              (y2003days + 31L + 28L + 31L + 30L + 6L -1L) * DateTimeConstants.MILLIS_PER_DAY
87              + 14L * DateTimeConstants.MILLIS_PER_HOUR
88              + 28L * DateTimeConstants.MILLIS_PER_MINUTE;
89          
90      private static final Policy RESTRICT;
91      private static final Policy ALLOW;
92      static {
93          // don't call Policy.getPolicy()
94          RESTRICT = new Policy() {
95              public PermissionCollection getPermissions(CodeSource codesource) {
96                  Permissions p = new Permissions();
97                  p.add(new AllPermission());  // enable everything
98                  return p;
99              }
100             public void refresh() {
101             }
102             public boolean implies(ProtectionDomain domain, Permission permission) {
103                 if (permission instanceof JodaTimePermission) {
104                     return false;
105                 }
106                 return true;
107 //                return super.implies(domain, permission);
108             }
109         };
110         ALLOW = new Policy() {
111             public PermissionCollection getPermissions(CodeSource codesource) {
112                 Permissions p = new Permissions();
113                 p.add(new AllPermission());  // enable everything
114                 return p;
115             }
116             public void refresh() {
117             }
118         };
119     }
120     
121     public static void main(String[] args) {
122         junit.textui.TestRunner.run(suite());
123     }
124 
125     public static TestSuite suite() {
126         return new TestSuite(TestDateTimeUtils.class);
127     }
128 
129     public TestDateTimeUtils(String name) {
130         super(name);
131     }
132 
133     protected void setUp() throws Exception {
134     }
135 
136     protected void tearDown() throws Exception {
137     }
138 
139     //-----------------------------------------------------------------------
140     public void testTest() {
141         assertEquals("2002-06-09T00:00:00.000Z", new Instant(TEST_TIME_NOW).toString());
142         assertEquals("2002-04-05T12:24:00.000Z", new Instant(TEST_TIME1).toString());
143         assertEquals("2003-05-06T14:28:00.000Z", new Instant(TEST_TIME2).toString());
144     }
145 
146     //-----------------------------------------------------------------------
147     public void testClass() {
148         Class cls = DateTimeUtils.class;
149         assertEquals(true, Modifier.isPublic(cls.getModifiers()));
150         assertEquals(false, Modifier.isFinal(cls.getModifiers()));
151         
152         assertEquals(1, cls.getDeclaredConstructors().length);
153         assertEquals(true, Modifier.isProtected(cls.getDeclaredConstructors()[0].getModifiers()));
154         
155         DateTimeUtils utils = new DateTimeUtils() {};
156     }
157     
158     //-----------------------------------------------------------------------
159     public void testSystemMillis() {
160         long nowSystem = System.currentTimeMillis();
161         long now = DateTimeUtils.currentTimeMillis();
162         assertTrue((now >= nowSystem));
163         assertTrue((now - nowSystem) < 10000L);
164     }
165 
166     //-----------------------------------------------------------------------
167     public void testSystemMillisSecurity() {
168         if (OLD_JDK) {
169             return;
170         }
171         try {
172             try {
173                 Policy.setPolicy(RESTRICT);
174                 System.setSecurityManager(new SecurityManager());
175                 DateTimeUtils.setCurrentMillisSystem();
176                 fail();
177             } catch (SecurityException ex) {
178                 // ok
179             } finally {
180                 System.setSecurityManager(null);
181                 Policy.setPolicy(ALLOW);
182             }
183         } finally {
184             DateTimeUtils.setCurrentMillisSystem();
185         }
186     }
187 
188     //-----------------------------------------------------------------------
189     public void testFixedMillis() {
190         try {
191             DateTimeUtils.setCurrentMillisFixed(0L);
192             assertEquals(0L, DateTimeUtils.currentTimeMillis());
193             assertEquals(0L, DateTimeUtils.currentTimeMillis());
194             assertEquals(0L, DateTimeUtils.currentTimeMillis());
195         } finally {
196             DateTimeUtils.setCurrentMillisSystem();
197         }
198         long nowSystem = System.currentTimeMillis();
199         long now = DateTimeUtils.currentTimeMillis();
200         assertTrue((now >= nowSystem));
201         assertTrue((now - nowSystem) < 10000L);
202     }
203 
204     //-----------------------------------------------------------------------
205     public void testFixedMillisSecurity() {
206         if (OLD_JDK) {
207             return;
208         }
209         try {
210             try {
211                 Policy.setPolicy(RESTRICT);
212                 System.setSecurityManager(new SecurityManager());
213                 DateTimeUtils.setCurrentMillisFixed(0L);
214                 fail();
215             } catch (SecurityException ex) {
216                 // ok
217             } finally {
218                 System.setSecurityManager(null);
219                 Policy.setPolicy(ALLOW);
220             }
221         } finally {
222             DateTimeUtils.setCurrentMillisSystem();
223         }
224     }
225 
226     //-----------------------------------------------------------------------
227     public void testOffsetMillis() {
228         try {
229             // set time to one day ago
230             DateTimeUtils.setCurrentMillisOffset(-24 * 60 *  60 * 1000);
231             long nowSystem = System.currentTimeMillis();
232             long now = DateTimeUtils.currentTimeMillis();
233             long nowAdjustDay = now + (24 * 60 *  60 * 1000);
234             assertTrue((now < nowSystem));
235             assertTrue((nowAdjustDay >= nowSystem));
236             assertTrue((nowAdjustDay - nowSystem) < 10000L);
237         } finally {
238             DateTimeUtils.setCurrentMillisSystem();
239         }
240         long nowSystem = System.currentTimeMillis();
241         long now = DateTimeUtils.currentTimeMillis();
242         assertTrue((now >= nowSystem));
243         assertTrue((now - nowSystem) < 10000L);
244     }
245 
246     //-----------------------------------------------------------------------
247     public void testOffsetMillisToZero() {
248         long now1 = 0L;
249         try {
250             // set time to one day ago
251             DateTimeUtils.setCurrentMillisOffset(0);
252             now1 = DateTimeUtils.currentTimeMillis();
253         } finally {
254             DateTimeUtils.setCurrentMillisSystem();
255         }
256         long now2 = DateTimeUtils.currentTimeMillis();
257         assertEquals(now1, now2);
258     }
259 
260     //-----------------------------------------------------------------------
261     public void testOffsetMillisSecurity() {
262         if (OLD_JDK) {
263             return;
264         }
265         try {
266             try {
267                 Policy.setPolicy(RESTRICT);
268                 System.setSecurityManager(new SecurityManager());
269                 DateTimeUtils.setCurrentMillisOffset(-24 * 60 *  60 * 1000);
270                 fail();
271             } catch (SecurityException ex) {
272                 // ok
273             } finally {
274                 System.setSecurityManager(null);
275                 Policy.setPolicy(ALLOW);
276             }
277         } finally {
278             DateTimeUtils.setCurrentMillisSystem();
279         }
280     }
281 
282     //-----------------------------------------------------------------------
283     public void testMillisProvider() {
284         try {
285             DateTimeUtils.setCurrentMillisProvider(new MillisProvider() {
286                 public long getMillis() {
287                     return 1L;
288                 }
289             });
290             assertEquals(1L, DateTimeUtils.currentTimeMillis());
291         } finally {
292             DateTimeUtils.setCurrentMillisSystem();
293         }
294     }
295 
296     public void testMillisProvider_null() {
297         try {
298             DateTimeUtils.setCurrentMillisProvider(null);
299         } catch (IllegalArgumentException ex) {
300             // expected
301         }
302     }
303 
304     //-----------------------------------------------------------------------
305     public void testMillisProviderSecurity() {
306         if (OLD_JDK) {
307             return;
308         }
309         try {
310             try {
311                 Policy.setPolicy(RESTRICT);
312                 System.setSecurityManager(new SecurityManager());
313                 DateTimeUtils.setCurrentMillisProvider(new MillisProvider() {
314                     public long getMillis() {
315                         return 0L;
316                     }
317                 });
318                 fail();
319             } catch (SecurityException ex) {
320                 // ok
321             } finally {
322                 System.setSecurityManager(null);
323                 Policy.setPolicy(ALLOW);
324             }
325         } finally {
326             DateTimeUtils.setCurrentMillisSystem();
327         }
328     }
329 
330     //-----------------------------------------------------------------------
331     public void testGetInstantMillis_RI() {
332         Instant i = new Instant(123L);
333         assertEquals(123L, DateTimeUtils.getInstantMillis(i));
334         try {
335             DateTimeUtils.setCurrentMillisFixed(TEST_TIME_NOW);
336             assertEquals(TEST_TIME_NOW, DateTimeUtils.getInstantMillis(null));
337         } finally {
338             DateTimeUtils.setCurrentMillisSystem();
339         }
340     }
341 
342     //-----------------------------------------------------------------------
343     public void testGetInstantChronology_RI() {
344         DateTime dt = new DateTime(123L, BuddhistChronology.getInstance());
345         assertEquals(BuddhistChronology.getInstance(), DateTimeUtils.getInstantChronology(dt));
346         
347         Instant i = new Instant(123L);
348         assertEquals(ISOChronology.getInstanceUTC(), DateTimeUtils.getInstantChronology(i));
349         
350         AbstractInstant ai = new AbstractInstant() {
351             public long getMillis() {
352                 return 0L;
353             }
354             public Chronology getChronology() {
355                 return null; // testing for this
356             }
357         };
358         assertEquals(ISOChronology.getInstance(), DateTimeUtils.getInstantChronology(ai));
359         
360         assertEquals(ISOChronology.getInstance(), DateTimeUtils.getInstantChronology(null));
361     }
362 
363     //-----------------------------------------------------------------------
364     public void testGetIntervalChronology_RInterval() {
365         Interval dt = new Interval(123L, 456L, BuddhistChronology.getInstance());
366         assertEquals(BuddhistChronology.getInstance(), DateTimeUtils.getIntervalChronology(dt));
367         
368         assertEquals(ISOChronology.getInstance(), DateTimeUtils.getIntervalChronology(null));
369         
370         MutableInterval ai = new MutableInterval() {
371             public Chronology getChronology() {
372                 return null; // testing for this
373             }
374         };
375         assertEquals(ISOChronology.getInstance(), DateTimeUtils.getIntervalChronology(ai));
376     }
377 
378     //-----------------------------------------------------------------------
379     public void testGetIntervalChronology_RI_RI() {
380         DateTime dt1 = new DateTime(123L, BuddhistChronology.getInstance());
381         DateTime dt2 = new DateTime(123L, CopticChronology.getInstance());
382         assertEquals(BuddhistChronology.getInstance(), DateTimeUtils.getIntervalChronology(dt1, dt2));
383         assertEquals(BuddhistChronology.getInstance(), DateTimeUtils.getIntervalChronology(dt1, null));
384         assertEquals(CopticChronology.getInstance(), DateTimeUtils.getIntervalChronology(null, dt2));
385         assertEquals(ISOChronology.getInstance(), DateTimeUtils.getIntervalChronology(null, null));
386     }
387 
388     //-----------------------------------------------------------------------
389     public void testGetReadableInterval_ReadableInterval() {
390         ReadableInterval input = new Interval(0, 100L);
391         assertEquals(input, DateTimeUtils.getReadableInterval(input));
392         
393         try {
394             DateTimeUtils.setCurrentMillisFixed(TEST_TIME_NOW);
395             assertEquals(new Interval(TEST_TIME_NOW, TEST_TIME_NOW), DateTimeUtils.getReadableInterval(null));
396         } finally {
397             DateTimeUtils.setCurrentMillisSystem();
398         }
399     }
400 
401     //-----------------------------------------------------------------------
402     public void testGetChronology_Chronology() {
403         assertEquals(BuddhistChronology.getInstance(), DateTimeUtils.getChronology(BuddhistChronology.getInstance()));
404         assertEquals(ISOChronology.getInstance(), DateTimeUtils.getChronology(null));
405     }
406 
407     //-----------------------------------------------------------------------
408     public void testGetZone_Zone() {
409         assertEquals(PARIS, DateTimeUtils.getZone(PARIS));
410         assertEquals(DateTimeZone.getDefault(), DateTimeUtils.getZone(null));
411     }
412 
413     //-----------------------------------------------------------------------
414     public void testGetPeriodType_PeriodType() {
415         assertEquals(PeriodType.dayTime(), DateTimeUtils.getPeriodType(PeriodType.dayTime()));
416         assertEquals(PeriodType.standard(), DateTimeUtils.getPeriodType(null));
417     }
418 
419     //-----------------------------------------------------------------------
420     public void testGetDurationMillis_RI() {
421         Duration dur = new Duration(123L);
422         assertEquals(123L, DateTimeUtils.getDurationMillis(dur));
423         assertEquals(0L, DateTimeUtils.getDurationMillis(null));
424     }
425 
426     //-----------------------------------------------------------------------
427     public void testIsContiguous_RP() {
428         YearMonthDay ymd = new YearMonthDay(2005, 6, 9);
429         assertEquals(true, DateTimeUtils.isContiguous(ymd));
430         TimeOfDay tod = new TimeOfDay(12, 20, 30, 0);
431         assertEquals(true, DateTimeUtils.isContiguous(tod));
432         Partial year = new Partial(DateTimeFieldType.year(), 2005);
433         assertEquals(true, DateTimeUtils.isContiguous(year));
434         Partial hourOfDay = new Partial(DateTimeFieldType.hourOfDay(), 12);
435         assertEquals(true, DateTimeUtils.isContiguous(hourOfDay));
436         Partial yearHour = year.with(DateTimeFieldType.hourOfDay(), 12);
437         assertEquals(false, DateTimeUtils.isContiguous(yearHour));
438         Partial ymdd = new Partial(ymd).with(DateTimeFieldType.dayOfWeek(), 2);
439         assertEquals(false, DateTimeUtils.isContiguous(ymdd));
440         Partial dd = new Partial(DateTimeFieldType.dayOfMonth(), 13).with(DateTimeFieldType.dayOfWeek(), 5);
441         assertEquals(false, DateTimeUtils.isContiguous(dd));
442         
443         try {
444             DateTimeUtils.isContiguous((ReadablePartial) null);
445             fail();
446         } catch (IllegalArgumentException ex) {}
447     }
448 
449     //-----------------------------------------------------------------------
450     public void testIsContiguous_RP_GJChronology() {
451         YearMonthDay ymd = new YearMonthDay(2005, 6, 9, GJ);
452         assertEquals(true, DateTimeUtils.isContiguous(ymd));
453         TimeOfDay tod = new TimeOfDay(12, 20, 30, 0, GJ);
454         assertEquals(true, DateTimeUtils.isContiguous(tod));
455         Partial year = new Partial(DateTimeFieldType.year(), 2005, GJ);
456         assertEquals(true, DateTimeUtils.isContiguous(year));
457         Partial hourOfDay = new Partial(DateTimeFieldType.hourOfDay(), 12, GJ);
458         assertEquals(true, DateTimeUtils.isContiguous(hourOfDay));
459         Partial yearHour = year.with(DateTimeFieldType.hourOfDay(), 12);
460         assertEquals(false, DateTimeUtils.isContiguous(yearHour));
461         Partial ymdd = new Partial(ymd).with(DateTimeFieldType.dayOfWeek(), 2);
462         assertEquals(false, DateTimeUtils.isContiguous(ymdd));
463         Partial dd = new Partial(DateTimeFieldType.dayOfMonth(), 13).with(DateTimeFieldType.dayOfWeek(), 5);
464         assertEquals(false, DateTimeUtils.isContiguous(dd));
465         
466         try {
467             DateTimeUtils.isContiguous((ReadablePartial) null);
468             fail();
469         } catch (IllegalArgumentException ex) {}
470     }
471 
472     //-----------------------------------------------------------------------
473     public void test_julianDay() {
474         DateTime base = new DateTime(1970, 1, 1, 0, 0, DateTimeZone.UTC);
475         
476         assertEquals(2440587.5d, DateTimeUtils.toJulianDay(base.getMillis()), 0.0001d);
477         assertEquals(2440588, DateTimeUtils.toJulianDayNumber(base.getMillis()));
478         assertEquals(base.getMillis(), DateTimeUtils.fromJulianDay(2440587.5d));
479         
480         base = base.plusHours(6);
481         assertEquals(2440587.75d, DateTimeUtils.toJulianDay(base.getMillis()), 0.0001d);
482         assertEquals(2440588, DateTimeUtils.toJulianDayNumber(base.getMillis()));
483         assertEquals(base.getMillis(), DateTimeUtils.fromJulianDay(2440587.75d));
484         
485         base = base.plusHours(6);
486         assertEquals(2440588d, DateTimeUtils.toJulianDay(base.getMillis()), 0.0001d);
487         assertEquals(2440588, DateTimeUtils.toJulianDayNumber(base.getMillis()));
488         assertEquals(base.getMillis(), DateTimeUtils.fromJulianDay(2440588d));
489         
490         base = base.plusHours(6);
491         assertEquals(2440588.25d, DateTimeUtils.toJulianDay(base.getMillis()), 0.0001d);
492         assertEquals(2440588, DateTimeUtils.toJulianDayNumber(base.getMillis()));
493         assertEquals(base.getMillis(), DateTimeUtils.fromJulianDay(2440588.25d));
494         
495         base = base.plusHours(6);
496         assertEquals(2440588.5d, DateTimeUtils.toJulianDay(base.getMillis()), 0.0001d);
497         assertEquals(2440589, DateTimeUtils.toJulianDayNumber(base.getMillis()));
498         assertEquals(base.getMillis(), DateTimeUtils.fromJulianDay(2440588.5d));
499         
500         base = new DateTime(2012, 8, 31, 23, 50, DateTimeZone.UTC);
501         assertEquals(2456171.4930555555, DateTimeUtils.toJulianDay(base.getMillis()), 0.0001d);
502         assertEquals(2456171, DateTimeUtils.toJulianDayNumber(base.getMillis()));
503         
504         base = new DateTime(-4713, 1, 1, 12, 0, JulianChronology.getInstanceUTC());
505         assertEquals(0d, DateTimeUtils.toJulianDay(base.getMillis()), 0.0001d);
506         assertEquals(0, DateTimeUtils.toJulianDayNumber(base.getMillis()));
507         assertEquals(base.getMillis(), DateTimeUtils.fromJulianDay(0d));
508         
509         base = new DateTime(-4713, 1, 1, 0, 0, JulianChronology.getInstanceUTC());
510         assertEquals(-0.5d, DateTimeUtils.toJulianDay(base.getMillis()), 0.0001d);
511         assertEquals(0, DateTimeUtils.toJulianDayNumber(base.getMillis()));
512         assertEquals(base.getMillis(), DateTimeUtils.fromJulianDay(-0.5d));
513     }
514 
515 }