1
2
3
4
5
6
7
8
9
10
11
12
13
14
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
40
41
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
60
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
75 private long TEST_TIME_NOW =
76 (y2002days + 31L + 28L + 31L + 30L + 31L + 9L -1L) * DateTimeConstants.MILLIS_PER_DAY;
77
78
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
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
94 RESTRICT = new Policy() {
95 public PermissionCollection getPermissions(CodeSource codesource) {
96 Permissions p = new Permissions();
97 p.add(new AllPermission());
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
108 }
109 };
110 ALLOW = new Policy() {
111 public PermissionCollection getPermissions(CodeSource codesource) {
112 Permissions p = new Permissions();
113 p.add(new AllPermission());
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
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
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
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
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
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
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
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;
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;
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 }