View Javadoc

1   /*
2    *  Copyright 2001-2009 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.io.ByteArrayInputStream;
19  import java.io.ByteArrayOutputStream;
20  import java.io.ObjectInputStream;
21  import java.io.ObjectOutputStream;
22  import java.util.Calendar;
23  import java.util.Date;
24  import java.util.GregorianCalendar;
25  import java.util.Locale;
26  import java.util.TimeZone;
27  
28  import junit.framework.TestCase;
29  import junit.framework.TestSuite;
30  
31  import org.joda.time.base.AbstractInstant;
32  import org.joda.time.chrono.BaseChronology;
33  import org.joda.time.chrono.BuddhistChronology;
34  import org.joda.time.chrono.CopticChronology;
35  import org.joda.time.chrono.GJChronology;
36  import org.joda.time.chrono.GregorianChronology;
37  import org.joda.time.chrono.ISOChronology;
38  import org.joda.time.field.UnsupportedDateTimeField;
39  import org.joda.time.field.UnsupportedDurationField;
40  import org.joda.time.format.DateTimeFormat;
41  import org.joda.time.format.DateTimeFormatter;
42  
43  /**
44   * This class is a Junit unit test for DateTime.
45   *
46   * @author Stephen Colebourne
47   */
48  public class TestDateTime_Basics extends TestCase {
49      // Test in 2002/03 as time zones are more well known
50      // (before the late 90's they were all over the place)
51  
52      private static final DateTimeZone PARIS = DateTimeZone.forID("Europe/Paris");
53      private static final DateTimeZone LONDON = DateTimeZone.forID("Europe/London");
54  
55      // the default time zone is set to LONDON in setUp()
56      // we have to hard code LONDON here (instead of ISOChronology.getInstance() etc.)
57      // as TestAll sets up a different time zone for better all-round testing
58      private static final ISOChronology ISO_UTC = ISOChronology.getInstanceUTC();
59      private static final ISOChronology ISO_DEFAULT = ISOChronology.getInstance(LONDON);
60      private static final ISOChronology ISO_PARIS = ISOChronology.getInstance(PARIS);
61      private static final GJChronology GJ_DEFAULT = GJChronology.getInstance(LONDON);
62      private static final GregorianChronology GREGORIAN_DEFAULT = GregorianChronology.getInstance(LONDON);
63      private static final GregorianChronology GREGORIAN_PARIS = GregorianChronology.getInstance(PARIS);
64      private static final BuddhistChronology BUDDHIST_UTC = BuddhistChronology.getInstanceUTC();
65      private static final BuddhistChronology BUDDHIST_DEFAULT = BuddhistChronology.getInstance(LONDON);
66      private static final CopticChronology COPTIC_DEFAULT = CopticChronology.getInstance(LONDON);
67      
68      long y2002days = 365 + 365 + 366 + 365 + 365 + 365 + 366 + 365 + 365 + 365 + 
69                       366 + 365 + 365 + 365 + 366 + 365 + 365 + 365 + 366 + 365 + 
70                       365 + 365 + 366 + 365 + 365 + 365 + 366 + 365 + 365 + 365 +
71                       366 + 365;
72      long y2003days = 365 + 365 + 366 + 365 + 365 + 365 + 366 + 365 + 365 + 365 + 
73                       366 + 365 + 365 + 365 + 366 + 365 + 365 + 365 + 366 + 365 + 
74                       365 + 365 + 366 + 365 + 365 + 365 + 366 + 365 + 365 + 365 +
75                       366 + 365 + 365;
76      
77      // 2002-06-09
78      private long TEST_TIME_NOW =
79              (y2002days + 31L + 28L + 31L + 30L + 31L + 9L -1L) * DateTimeConstants.MILLIS_PER_DAY;
80              
81      // 2002-04-05
82      private long TEST_TIME1 =
83              (y2002days + 31L + 28L + 31L + 5L -1L) * DateTimeConstants.MILLIS_PER_DAY
84              + 12L * DateTimeConstants.MILLIS_PER_HOUR
85              + 24L * DateTimeConstants.MILLIS_PER_MINUTE;
86          
87      // 2003-05-06
88      private long TEST_TIME2 =
89              (y2003days + 31L + 28L + 31L + 30L + 6L -1L) * DateTimeConstants.MILLIS_PER_DAY
90              + 14L * DateTimeConstants.MILLIS_PER_HOUR
91              + 28L * DateTimeConstants.MILLIS_PER_MINUTE;
92      
93      private DateTimeZone originalDateTimeZone = null;
94      private TimeZone originalTimeZone = null;
95      private Locale originalLocale = null;
96  
97      public static void main(String[] args) {
98          junit.textui.TestRunner.run(suite());
99      }
100 
101     public static TestSuite suite() {
102         return new TestSuite(TestDateTime_Basics.class);
103     }
104 
105     public TestDateTime_Basics(String name) {
106         super(name);
107     }
108 
109     protected void setUp() throws Exception {
110         DateTimeUtils.setCurrentMillisFixed(TEST_TIME_NOW);
111         originalDateTimeZone = DateTimeZone.getDefault();
112         originalTimeZone = TimeZone.getDefault();
113         originalLocale = Locale.getDefault();
114         DateTimeZone.setDefault(LONDON);
115         TimeZone.setDefault(TimeZone.getTimeZone("Europe/London"));
116         Locale.setDefault(Locale.UK);
117     }
118 
119     protected void tearDown() throws Exception {
120         DateTimeUtils.setCurrentMillisSystem();
121         DateTimeZone.setDefault(originalDateTimeZone);
122         TimeZone.setDefault(originalTimeZone);
123         Locale.setDefault(originalLocale);
124         originalDateTimeZone = null;
125         originalTimeZone = null;
126         originalLocale = null;
127     }
128 
129     //-----------------------------------------------------------------------
130     public void testTest() {
131         assertEquals("2002-06-09T00:00:00.000Z", new Instant(TEST_TIME_NOW).toString());
132         assertEquals("2002-04-05T12:24:00.000Z", new Instant(TEST_TIME1).toString());
133         assertEquals("2003-05-06T14:28:00.000Z", new Instant(TEST_TIME2).toString());
134     }
135 
136     //-----------------------------------------------------------------------
137     public void testGet_DateTimeField() {
138         DateTime test = new DateTime();
139         assertEquals(1, test.get(ISO_DEFAULT.era()));
140         assertEquals(20, test.get(ISO_DEFAULT.centuryOfEra()));
141         assertEquals(2, test.get(ISO_DEFAULT.yearOfCentury()));
142         assertEquals(2002, test.get(ISO_DEFAULT.yearOfEra()));
143         assertEquals(2002, test.get(ISO_DEFAULT.year()));
144         assertEquals(6, test.get(ISO_DEFAULT.monthOfYear()));
145         assertEquals(9, test.get(ISO_DEFAULT.dayOfMonth()));
146         assertEquals(2002, test.get(ISO_DEFAULT.weekyear()));
147         assertEquals(23, test.get(ISO_DEFAULT.weekOfWeekyear()));
148         assertEquals(7, test.get(ISO_DEFAULT.dayOfWeek()));
149         assertEquals(160, test.get(ISO_DEFAULT.dayOfYear()));
150         assertEquals(0, test.get(ISO_DEFAULT.halfdayOfDay()));
151         assertEquals(1, test.get(ISO_DEFAULT.hourOfHalfday()));
152         assertEquals(1, test.get(ISO_DEFAULT.clockhourOfDay()));
153         assertEquals(1, test.get(ISO_DEFAULT.clockhourOfHalfday()));
154         assertEquals(1, test.get(ISO_DEFAULT.hourOfDay()));
155         assertEquals(0, test.get(ISO_DEFAULT.minuteOfHour()));
156         assertEquals(60, test.get(ISO_DEFAULT.minuteOfDay()));
157         assertEquals(0, test.get(ISO_DEFAULT.secondOfMinute()));
158         assertEquals(60 * 60, test.get(ISO_DEFAULT.secondOfDay()));
159         assertEquals(0, test.get(ISO_DEFAULT.millisOfSecond()));
160         assertEquals(60 * 60 * 1000, test.get(ISO_DEFAULT.millisOfDay()));
161         try {
162             test.get((DateTimeField) null);
163             fail();
164         } catch (IllegalArgumentException ex) {}
165     }
166 
167     public void testGet_DateTimeFieldType() {
168         DateTime test = new DateTime();
169         assertEquals(1, test.get(DateTimeFieldType.era()));
170         assertEquals(20, test.get(DateTimeFieldType.centuryOfEra()));
171         assertEquals(2, test.get(DateTimeFieldType.yearOfCentury()));
172         assertEquals(2002, test.get(DateTimeFieldType.yearOfEra()));
173         assertEquals(2002, test.get(DateTimeFieldType.year()));
174         assertEquals(6, test.get(DateTimeFieldType.monthOfYear()));
175         assertEquals(9, test.get(DateTimeFieldType.dayOfMonth()));
176         assertEquals(2002, test.get(DateTimeFieldType.weekyear()));
177         assertEquals(23, test.get(DateTimeFieldType.weekOfWeekyear()));
178         assertEquals(7, test.get(DateTimeFieldType.dayOfWeek()));
179         assertEquals(160, test.get(DateTimeFieldType.dayOfYear()));
180         assertEquals(0, test.get(DateTimeFieldType.halfdayOfDay()));
181         assertEquals(1, test.get(DateTimeFieldType.hourOfHalfday()));
182         assertEquals(1, test.get(DateTimeFieldType.clockhourOfDay()));
183         assertEquals(1, test.get(DateTimeFieldType.clockhourOfHalfday()));
184         assertEquals(1, test.get(DateTimeFieldType.hourOfDay()));
185         assertEquals(0, test.get(DateTimeFieldType.minuteOfHour()));
186         assertEquals(60, test.get(DateTimeFieldType.minuteOfDay()));
187         assertEquals(0, test.get(DateTimeFieldType.secondOfMinute()));
188         assertEquals(60 * 60, test.get(DateTimeFieldType.secondOfDay()));
189         assertEquals(0, test.get(DateTimeFieldType.millisOfSecond()));
190         assertEquals(60 * 60 * 1000, test.get(DateTimeFieldType.millisOfDay()));
191         try {
192             test.get((DateTimeFieldType) null);
193             fail();
194         } catch (IllegalArgumentException ex) {}
195     }
196 
197     public void testIsSupported_DateTimeFieldType() {
198         DateTime test = new DateTime();
199         assertEquals(true, test.isSupported(DateTimeFieldType.era()));
200         assertEquals(true, test.isSupported(DateTimeFieldType.centuryOfEra()));
201         assertEquals(true, test.isSupported(DateTimeFieldType.yearOfCentury()));
202         assertEquals(true, test.isSupported(DateTimeFieldType.yearOfEra()));
203         assertEquals(true, test.isSupported(DateTimeFieldType.year()));
204         assertEquals(true, test.isSupported(DateTimeFieldType.monthOfYear()));
205         assertEquals(true, test.isSupported(DateTimeFieldType.dayOfMonth()));
206         assertEquals(true, test.isSupported(DateTimeFieldType.weekyear()));
207         assertEquals(true, test.isSupported(DateTimeFieldType.weekOfWeekyear()));
208         assertEquals(true, test.isSupported(DateTimeFieldType.dayOfWeek()));
209         assertEquals(true, test.isSupported(DateTimeFieldType.dayOfYear()));
210         assertEquals(true, test.isSupported(DateTimeFieldType.halfdayOfDay()));
211         assertEquals(true, test.isSupported(DateTimeFieldType.hourOfHalfday()));
212         assertEquals(true, test.isSupported(DateTimeFieldType.clockhourOfDay()));
213         assertEquals(true, test.isSupported(DateTimeFieldType.clockhourOfHalfday()));
214         assertEquals(true, test.isSupported(DateTimeFieldType.hourOfDay()));
215         assertEquals(true, test.isSupported(DateTimeFieldType.minuteOfHour()));
216         assertEquals(true, test.isSupported(DateTimeFieldType.minuteOfDay()));
217         assertEquals(true, test.isSupported(DateTimeFieldType.secondOfMinute()));
218         assertEquals(true, test.isSupported(DateTimeFieldType.secondOfDay()));
219         assertEquals(true, test.isSupported(DateTimeFieldType.millisOfSecond()));
220         assertEquals(true, test.isSupported(DateTimeFieldType.millisOfDay()));
221         assertEquals(false, test.isSupported(null));
222     }
223 
224     //-----------------------------------------------------------------------
225     public void testGetters() {
226         DateTime test = new DateTime();
227         
228         assertEquals(ISO_DEFAULT, test.getChronology());
229         assertEquals(LONDON, test.getZone());
230         assertEquals(TEST_TIME_NOW, test.getMillis());
231         
232         assertEquals(1, test.getEra());
233         assertEquals(20, test.getCenturyOfEra());
234         assertEquals(2, test.getYearOfCentury());
235         assertEquals(2002, test.getYearOfEra());
236         assertEquals(2002, test.getYear());
237         assertEquals(6, test.getMonthOfYear());
238         assertEquals(9, test.getDayOfMonth());
239         assertEquals(2002, test.getWeekyear());
240         assertEquals(23, test.getWeekOfWeekyear());
241         assertEquals(7, test.getDayOfWeek());
242         assertEquals(160, test.getDayOfYear());
243         assertEquals(1, test.getHourOfDay());
244         assertEquals(0, test.getMinuteOfHour());
245         assertEquals(60, test.getMinuteOfDay());
246         assertEquals(0, test.getSecondOfMinute());
247         assertEquals(60 * 60, test.getSecondOfDay());
248         assertEquals(0, test.getMillisOfSecond());
249         assertEquals(60 * 60 * 1000, test.getMillisOfDay());
250     }
251 
252     public void testWithers() {
253         DateTime test = new DateTime(1970, 6, 9, 10, 20, 30, 40, GJ_DEFAULT);
254         check(test.withYear(2000), 2000, 6, 9, 10, 20, 30, 40);
255         check(test.withMonthOfYear(2), 1970, 2, 9, 10, 20, 30, 40);
256         check(test.withDayOfMonth(2), 1970, 6, 2, 10, 20, 30, 40);
257         check(test.withDayOfYear(6), 1970, 1, 6, 10, 20, 30, 40);
258         check(test.withDayOfWeek(6), 1970, 6, 13, 10, 20, 30, 40);
259         check(test.withWeekOfWeekyear(6), 1970, 2, 3, 10, 20, 30, 40);
260         check(test.withWeekyear(1971), 1971, 6, 15, 10, 20, 30, 40);
261         check(test.withYearOfCentury(60), 1960, 6, 9, 10, 20, 30, 40);
262         check(test.withCenturyOfEra(21), 2070, 6, 9, 10, 20, 30, 40);
263         check(test.withYearOfEra(1066), 1066, 6, 9, 10, 20, 30, 40);
264         check(test.withEra(DateTimeConstants.BC), -1970, 6, 9, 10, 20, 30, 40);
265         check(test.withHourOfDay(6), 1970, 6, 9, 6, 20, 30, 40);
266         check(test.withMinuteOfHour(6), 1970, 6, 9, 10, 6, 30, 40);
267         check(test.withSecondOfMinute(6), 1970, 6, 9, 10, 20, 6, 40);
268         check(test.withMillisOfSecond(6), 1970, 6, 9, 10, 20, 30, 6);
269         check(test.withMillisOfDay(61234), 1970, 6, 9, 0, 1, 1, 234);
270         
271         try {
272             test.withMonthOfYear(0);
273             fail();
274         } catch (IllegalArgumentException ex) {}
275         try {
276             test.withMonthOfYear(13);
277             fail();
278         } catch (IllegalArgumentException ex) {}
279     }
280 
281     //-----------------------------------------------------------------------
282     public void testEqualsHashCode() {
283         DateTime test1 = new DateTime(TEST_TIME1);
284         DateTime test2 = new DateTime(TEST_TIME1);
285         assertEquals(true, test1.equals(test2));
286         assertEquals(true, test2.equals(test1));
287         assertEquals(true, test1.equals(test1));
288         assertEquals(true, test2.equals(test2));
289         assertEquals(true, test1.hashCode() == test2.hashCode());
290         assertEquals(true, test1.hashCode() == test1.hashCode());
291         assertEquals(true, test2.hashCode() == test2.hashCode());
292         
293         DateTime test3 = new DateTime(TEST_TIME2);
294         assertEquals(false, test1.equals(test3));
295         assertEquals(false, test2.equals(test3));
296         assertEquals(false, test3.equals(test1));
297         assertEquals(false, test3.equals(test2));
298         assertEquals(false, test1.hashCode() == test3.hashCode());
299         assertEquals(false, test2.hashCode() == test3.hashCode());
300         
301         assertEquals(false, test1.equals("Hello"));
302         assertEquals(true, test1.equals(new MockInstant()));
303         assertEquals(false, test1.equals(new DateTime(TEST_TIME1, GREGORIAN_DEFAULT)));
304         assertEquals(true, new DateTime(TEST_TIME1, new MockEqualsChronology()).equals(new DateTime(TEST_TIME1, new MockEqualsChronology())));
305         assertEquals(false, new DateTime(TEST_TIME1, new MockEqualsChronology()).equals(new DateTime(TEST_TIME1, ISO_DEFAULT)));
306     }
307     
308     class MockInstant extends AbstractInstant {
309         public String toString() {
310             return null;
311         }
312         public long getMillis() {
313             return TEST_TIME1;
314         }
315         public Chronology getChronology() {
316             return ISO_DEFAULT;
317         }
318     }
319 
320     class MockEqualsChronology extends BaseChronology {
321         public boolean equals(Object obj) {
322             return obj instanceof MockEqualsChronology;
323         }
324         public DateTimeZone getZone() {
325             return null;
326         }
327         public Chronology withUTC() {
328             return this;
329         }
330         public Chronology withZone(DateTimeZone zone) {
331             return this;
332         }
333         public String toString() {
334             return "";
335         }
336     }
337 
338     public void testCompareTo() {
339         DateTime test1 = new DateTime(TEST_TIME1);
340         DateTime test1a = new DateTime(TEST_TIME1);
341         assertEquals(0, test1.compareTo(test1a));
342         assertEquals(0, test1a.compareTo(test1));
343         assertEquals(0, test1.compareTo(test1));
344         assertEquals(0, test1a.compareTo(test1a));
345         
346         DateTime test2 = new DateTime(TEST_TIME2);
347         assertEquals(-1, test1.compareTo(test2));
348         assertEquals(+1, test2.compareTo(test1));
349         
350         DateTime test3 = new DateTime(TEST_TIME2, GREGORIAN_PARIS);
351         assertEquals(-1, test1.compareTo(test3));
352         assertEquals(+1, test3.compareTo(test1));
353         assertEquals(0, test3.compareTo(test2));
354         
355         assertEquals(+1, test2.compareTo(new MockInstant()));
356         assertEquals(0, test1.compareTo(new MockInstant()));
357         
358         try {
359             test1.compareTo(null);
360             fail();
361         } catch (NullPointerException ex) {}
362 //        try {
363 //            test1.compareTo(new Date());
364 //            fail();
365 //        } catch (ClassCastException ex) {}
366     }
367     
368     //-----------------------------------------------------------------------
369     public void testIsEqual_long() {
370         assertEquals(false, new DateTime(TEST_TIME1).isEqual(TEST_TIME2));
371         assertEquals(true, new DateTime(TEST_TIME1).isEqual(TEST_TIME1));
372         assertEquals(false, new DateTime(TEST_TIME2).isEqual(TEST_TIME1));
373     }
374     
375     public void testIsEqualNow() {
376         assertEquals(false, new DateTime(TEST_TIME_NOW - 1).isEqualNow());
377         assertEquals(true, new DateTime(TEST_TIME_NOW).isEqualNow());
378         assertEquals(false, new DateTime(TEST_TIME_NOW + 1).isEqualNow());
379     }
380     
381     public void testIsEqual_RI() {
382         DateTime test1 = new DateTime(TEST_TIME1);
383         DateTime test1a = new DateTime(TEST_TIME1);
384         assertEquals(true, test1.isEqual(test1a));
385         assertEquals(true, test1a.isEqual(test1));
386         assertEquals(true, test1.isEqual(test1));
387         assertEquals(true, test1a.isEqual(test1a));
388         
389         DateTime test2 = new DateTime(TEST_TIME2);
390         assertEquals(false, test1.isEqual(test2));
391         assertEquals(false, test2.isEqual(test1));
392         
393         DateTime test3 = new DateTime(TEST_TIME2, GREGORIAN_PARIS);
394         assertEquals(false, test1.isEqual(test3));
395         assertEquals(false, test3.isEqual(test1));
396         assertEquals(true, test3.isEqual(test2));
397         
398         assertEquals(false, test2.isEqual(new MockInstant()));
399         assertEquals(true, test1.isEqual(new MockInstant()));
400         
401         assertEquals(false, new DateTime(TEST_TIME_NOW + 1).isEqual(null));
402         assertEquals(true, new DateTime(TEST_TIME_NOW).isEqual(null));
403         assertEquals(false, new DateTime(TEST_TIME_NOW - 1).isEqual(null));
404     }
405     
406     //-----------------------------------------------------------------------
407     public void testIsBefore_long() {
408         assertEquals(true, new DateTime(TEST_TIME1).isBefore(TEST_TIME2));
409         assertEquals(false, new DateTime(TEST_TIME1).isBefore(TEST_TIME1));
410         assertEquals(false, new DateTime(TEST_TIME2).isBefore(TEST_TIME1));
411     }
412     
413     public void testIsBeforeNow() {
414         assertEquals(true, new DateTime(TEST_TIME_NOW - 1).isBeforeNow());
415         assertEquals(false, new DateTime(TEST_TIME_NOW).isBeforeNow());
416         assertEquals(false, new DateTime(TEST_TIME_NOW + 1).isBeforeNow());
417     }
418     
419     public void testIsBefore_RI() {
420         DateTime test1 = new DateTime(TEST_TIME1);
421         DateTime test1a = new DateTime(TEST_TIME1);
422         assertEquals(false, test1.isBefore(test1a));
423         assertEquals(false, test1a.isBefore(test1));
424         assertEquals(false, test1.isBefore(test1));
425         assertEquals(false, test1a.isBefore(test1a));
426         
427         DateTime test2 = new DateTime(TEST_TIME2);
428         assertEquals(true, test1.isBefore(test2));
429         assertEquals(false, test2.isBefore(test1));
430         
431         DateTime test3 = new DateTime(TEST_TIME2, GREGORIAN_PARIS);
432         assertEquals(true, test1.isBefore(test3));
433         assertEquals(false, test3.isBefore(test1));
434         assertEquals(false, test3.isBefore(test2));
435         
436         assertEquals(false, test2.isBefore(new MockInstant()));
437         assertEquals(false, test1.isBefore(new MockInstant()));
438         
439         assertEquals(false, new DateTime(TEST_TIME_NOW + 1).isBefore(null));
440         assertEquals(false, new DateTime(TEST_TIME_NOW).isBefore(null));
441         assertEquals(true, new DateTime(TEST_TIME_NOW - 1).isBefore(null));
442     }
443     
444     //-----------------------------------------------------------------------
445     public void testIsAfter_long() {
446         assertEquals(false, new DateTime(TEST_TIME1).isAfter(TEST_TIME2));
447         assertEquals(false, new DateTime(TEST_TIME1).isAfter(TEST_TIME1));
448         assertEquals(true, new DateTime(TEST_TIME2).isAfter(TEST_TIME1));
449     }
450     
451     public void testIsAfterNow() {
452         assertEquals(false, new DateTime(TEST_TIME_NOW - 1).isAfterNow());
453         assertEquals(false, new DateTime(TEST_TIME_NOW).isAfterNow());
454         assertEquals(true, new DateTime(TEST_TIME_NOW + 1).isAfterNow());
455     }
456     
457     public void testIsAfter_RI() {
458         DateTime test1 = new DateTime(TEST_TIME1);
459         DateTime test1a = new DateTime(TEST_TIME1);
460         assertEquals(false, test1.isAfter(test1a));
461         assertEquals(false, test1a.isAfter(test1));
462         assertEquals(false, test1.isAfter(test1));
463         assertEquals(false, test1a.isAfter(test1a));
464         
465         DateTime test2 = new DateTime(TEST_TIME2);
466         assertEquals(false, test1.isAfter(test2));
467         assertEquals(true, test2.isAfter(test1));
468         
469         DateTime test3 = new DateTime(TEST_TIME2, GREGORIAN_PARIS);
470         assertEquals(false, test1.isAfter(test3));
471         assertEquals(true, test3.isAfter(test1));
472         assertEquals(false, test3.isAfter(test2));
473         
474         assertEquals(true, test2.isAfter(new MockInstant()));
475         assertEquals(false, test1.isAfter(new MockInstant()));
476         
477         assertEquals(true, new DateTime(TEST_TIME_NOW + 1).isAfter(null));
478         assertEquals(false, new DateTime(TEST_TIME_NOW).isAfter(null));
479         assertEquals(false, new DateTime(TEST_TIME_NOW - 1).isAfter(null));
480     }
481     
482     //-----------------------------------------------------------------------
483     public void testSerialization() throws Exception {
484         DateTime test = new DateTime(TEST_TIME_NOW);
485         
486         ByteArrayOutputStream baos = new ByteArrayOutputStream();
487         ObjectOutputStream oos = new ObjectOutputStream(baos);
488         oos.writeObject(test);
489         byte[] bytes = baos.toByteArray();
490         oos.close();
491         
492         ByteArrayInputStream bais = new ByteArrayInputStream(bytes);
493         ObjectInputStream ois = new ObjectInputStream(bais);
494         DateTime result = (DateTime) ois.readObject();
495         ois.close();
496         
497         assertEquals(test, result);
498     }
499 
500     //-----------------------------------------------------------------------
501     public void testToString() {
502         DateTime test = new DateTime(TEST_TIME_NOW);
503         assertEquals("2002-06-09T01:00:00.000+01:00", test.toString());
504         
505         test = new DateTime(TEST_TIME_NOW, PARIS);
506         assertEquals("2002-06-09T02:00:00.000+02:00", test.toString());
507     }
508 
509     public void testToString_String() {
510         DateTime test = new DateTime(TEST_TIME_NOW);
511         assertEquals("2002 01", test.toString("yyyy HH"));
512         assertEquals("2002-06-09T01:00:00.000+01:00", test.toString((String) null));
513     }
514 
515     public void testToString_String_Locale() {
516         DateTime test = new DateTime(TEST_TIME_NOW);
517         assertEquals("Sun 9/6", test.toString("EEE d/M", Locale.ENGLISH));
518         assertEquals("dim. 9/6", test.toString("EEE d/M", Locale.FRENCH));
519         assertEquals("2002-06-09T01:00:00.000+01:00", test.toString(null, Locale.ENGLISH));
520         assertEquals("Sun 9/6", test.toString("EEE d/M", null));
521         assertEquals("2002-06-09T01:00:00.000+01:00", test.toString(null, null));
522     }
523 
524     public void testToString_DTFormatter() {
525         DateMidnight test = new DateMidnight(TEST_TIME_NOW);
526         assertEquals("2002 00", test.toString(DateTimeFormat.forPattern("yyyy HH")));
527         assertEquals("2002-06-09T00:00:00.000+01:00", test.toString((DateTimeFormatter) null));
528     }
529 
530     //-----------------------------------------------------------------------
531     public void testToInstant() {
532         DateTime test = new DateTime(TEST_TIME1);
533         Instant result = test.toInstant();
534         assertEquals(TEST_TIME1, result.getMillis());
535     }
536 
537     public void testToDateTime() {
538         DateTime test = new DateTime(TEST_TIME1);
539         DateTime result = test.toDateTime();
540         assertSame(test, result);
541     }
542 
543     public void testToDateTimeISO() {
544         DateTime test = new DateTime(TEST_TIME1);
545         DateTime result = test.toDateTimeISO();
546         assertSame(test, result);
547         
548         test = new DateTime(TEST_TIME1, ISO_PARIS);
549         result = test.toDateTimeISO();
550         assertSame(DateTime.class, result.getClass());
551         assertSame(ISOChronology.class, result.getChronology().getClass());
552         assertEquals(test.getMillis(), result.getMillis());
553         assertEquals(ISO_PARIS, result.getChronology());
554         assertNotSame(test, result);
555         
556         test = new DateTime(TEST_TIME1, BUDDHIST_DEFAULT);
557         result = test.toDateTimeISO();
558         assertSame(DateTime.class, result.getClass());
559         assertSame(ISOChronology.class, result.getChronology().getClass());
560         assertEquals(test.getMillis(), result.getMillis());
561         assertEquals(ISO_DEFAULT, result.getChronology());
562         assertNotSame(test, result);
563         
564         test = new DateTime(TEST_TIME1, new MockNullZoneChronology());
565         result = test.toDateTimeISO();
566         assertSame(DateTime.class, result.getClass());
567         assertSame(ISOChronology.class, result.getChronology().getClass());
568         assertEquals(test.getMillis(), result.getMillis());
569         assertEquals(ISO_DEFAULT, result.getChronology());
570         assertNotSame(test, result);
571     }
572 
573     public void testToDateTime_DateTimeZone() {
574         DateTime test = new DateTime(TEST_TIME1);
575         DateTime result = test.toDateTime(LONDON);
576         assertSame(test, result);
577 
578         test = new DateTime(TEST_TIME1);
579         result = test.toDateTime(PARIS);
580         assertEquals(test.getMillis(), result.getMillis());
581         assertEquals(PARIS, result.getZone());
582 
583         test = new DateTime(TEST_TIME1, PARIS);
584         result = test.toDateTime((DateTimeZone) null);
585         assertEquals(test.getMillis(), result.getMillis());
586         assertEquals(LONDON, result.getZone());
587 
588         test = new DateTime(TEST_TIME1);
589         result = test.toDateTime((DateTimeZone) null);
590         assertSame(test, result);
591     }
592 
593     public void testToDateTime_Chronology() {
594         DateTime test = new DateTime(TEST_TIME1);
595         DateTime result = test.toDateTime(ISO_DEFAULT);
596         assertSame(test, result);
597 
598         test = new DateTime(TEST_TIME1);
599         result = test.toDateTime(GREGORIAN_PARIS);
600         assertEquals(test.getMillis(), result.getMillis());
601         assertEquals(GREGORIAN_PARIS, result.getChronology());
602 
603         test = new DateTime(TEST_TIME1, GREGORIAN_PARIS);
604         result = test.toDateTime((Chronology) null);
605         assertEquals(test.getMillis(), result.getMillis());
606         assertEquals(ISO_DEFAULT, result.getChronology());
607 
608         test = new DateTime(TEST_TIME1);
609         result = test.toDateTime((Chronology) null);
610         assertSame(test, result);
611     }
612 
613     public void testToMutableDateTime() {
614         DateTime test = new DateTime(TEST_TIME1, PARIS);
615         MutableDateTime result = test.toMutableDateTime();
616         assertEquals(test.getMillis(), result.getMillis());
617         assertEquals(ISO_PARIS, result.getChronology());
618     }
619 
620     public void testToMutableDateTimeISO() {
621         DateTime test = new DateTime(TEST_TIME1, PARIS);
622         MutableDateTime result = test.toMutableDateTimeISO();
623         assertSame(MutableDateTime.class, result.getClass());
624         assertSame(ISOChronology.class, result.getChronology().getClass());
625         assertEquals(test.getMillis(), result.getMillis());
626         assertEquals(ISO_PARIS, result.getChronology());
627     }
628 
629     public void testToMutableDateTime_DateTimeZone() {
630         DateTime test = new DateTime(TEST_TIME1);
631         MutableDateTime result = test.toMutableDateTime(LONDON);
632         assertEquals(test.getMillis(), result.getMillis());
633         assertEquals(ISO_DEFAULT, result.getChronology());
634 
635         test = new DateTime(TEST_TIME1);
636         result = test.toMutableDateTime(PARIS);
637         assertEquals(test.getMillis(), result.getMillis());
638         assertEquals(ISO_PARIS, result.getChronology());
639 
640         test = new DateTime(TEST_TIME1, PARIS);
641         result = test.toMutableDateTime((DateTimeZone) null);
642         assertEquals(test.getMillis(), result.getMillis());
643         assertEquals(ISO_DEFAULT, result.getChronology());
644 
645         test = new DateTime(TEST_TIME1);
646         result = test.toMutableDateTime((DateTimeZone) null);
647         assertEquals(test.getMillis(), result.getMillis());
648         assertEquals(ISO_DEFAULT, result.getChronology());
649     }
650 
651     public void testToMutableDateTime_Chronology() {
652         DateTime test = new DateTime(TEST_TIME1);
653         MutableDateTime result = test.toMutableDateTime(ISO_DEFAULT);
654         assertEquals(test.getMillis(), result.getMillis());
655         assertEquals(ISO_DEFAULT, result.getChronology());
656 
657         test = new DateTime(TEST_TIME1);
658         result = test.toMutableDateTime(GREGORIAN_PARIS);
659         assertEquals(test.getMillis(), result.getMillis());
660         assertEquals(GREGORIAN_PARIS, result.getChronology());
661 
662         test = new DateTime(TEST_TIME1, GREGORIAN_PARIS);
663         result = test.toMutableDateTime((Chronology) null);
664         assertEquals(test.getMillis(), result.getMillis());
665         assertEquals(ISO_DEFAULT, result.getChronology());
666 
667         test = new DateTime(TEST_TIME1);
668         result = test.toMutableDateTime((Chronology) null);
669         assertEquals(test.getMillis(), result.getMillis());
670         assertEquals(ISO_DEFAULT, result.getChronology());
671     }
672 
673     public void testToDate() {
674         DateTime test = new DateTime(TEST_TIME1);
675         Date result = test.toDate();
676         assertEquals(test.getMillis(), result.getTime());
677     }
678 
679     public void testToCalendar_Locale() {
680         DateTime test = new DateTime(TEST_TIME1);
681         Calendar result = test.toCalendar(null);
682         assertEquals(test.getMillis(), result.getTime().getTime());
683         assertEquals(TimeZone.getTimeZone("Europe/London"), result.getTimeZone());
684 
685         test = new DateTime(TEST_TIME1, PARIS);
686         result = test.toCalendar(null);
687         assertEquals(test.getMillis(), result.getTime().getTime());
688         assertEquals(TimeZone.getTimeZone("Europe/Paris"), result.getTimeZone());
689 
690         test = new DateTime(TEST_TIME1, PARIS);
691         result = test.toCalendar(Locale.UK);
692         assertEquals(test.getMillis(), result.getTime().getTime());
693         assertEquals(TimeZone.getTimeZone("Europe/Paris"), result.getTimeZone());
694     }
695 
696     public void testToGregorianCalendar() {
697         DateTime test = new DateTime(TEST_TIME1);
698         GregorianCalendar result = test.toGregorianCalendar();
699         assertEquals(test.getMillis(), result.getTime().getTime());
700         assertEquals(TimeZone.getTimeZone("Europe/London"), result.getTimeZone());
701 
702         test = new DateTime(TEST_TIME1, PARIS);
703         result = test.toGregorianCalendar();
704         assertEquals(test.getMillis(), result.getTime().getTime());
705         assertEquals(TimeZone.getTimeZone("Europe/Paris"), result.getTimeZone());
706     }
707 
708     //-----------------------------------------------------------------------
709     public void testToDateMidnight() {
710         DateTime base = new DateTime(TEST_TIME1, COPTIC_DEFAULT);
711         DateMidnight test = base.toDateMidnight();
712         assertEquals(new DateMidnight(base, COPTIC_DEFAULT), test);
713     }
714 
715     public void testToYearMonthDay() {
716         DateTime base = new DateTime(TEST_TIME1, COPTIC_DEFAULT);
717         YearMonthDay test = base.toYearMonthDay();
718         assertEquals(new YearMonthDay(TEST_TIME1, COPTIC_DEFAULT), test);
719     }
720 
721     public void testToTimeOfDay() {
722         DateTime base = new DateTime(TEST_TIME1, COPTIC_DEFAULT);
723         TimeOfDay test = base.toTimeOfDay();
724         assertEquals(new TimeOfDay(TEST_TIME1, COPTIC_DEFAULT), test);
725     }
726 
727     public void testToLocalDateTime() {
728         DateTime base = new DateTime(TEST_TIME1, COPTIC_DEFAULT);
729         LocalDateTime test = base.toLocalDateTime();
730         assertEquals(new LocalDateTime(TEST_TIME1, COPTIC_DEFAULT), test);
731     }
732 
733     public void testToLocalDate() {
734         DateTime base = new DateTime(TEST_TIME1, COPTIC_DEFAULT);
735         LocalDate test = base.toLocalDate();
736         assertEquals(new LocalDate(TEST_TIME1, COPTIC_DEFAULT), test);
737     }
738 
739     public void testToLocalTime() {
740         DateTime base = new DateTime(TEST_TIME1, COPTIC_DEFAULT);
741         LocalTime test = base.toLocalTime();
742         assertEquals(new LocalTime(TEST_TIME1, COPTIC_DEFAULT), test);
743     }
744 
745     //-----------------------------------------------------------------------
746     public void testWithMillis_long() {
747         DateTime test = new DateTime(TEST_TIME1);
748         DateTime result = test.withMillis(TEST_TIME2);
749         assertEquals(TEST_TIME2, result.getMillis());
750         assertEquals(test.getChronology(), result.getChronology());
751         
752         test = new DateTime(TEST_TIME1, GREGORIAN_PARIS);
753         result = test.withMillis(TEST_TIME2);
754         assertEquals(TEST_TIME2, result.getMillis());
755         assertEquals(test.getChronology(), result.getChronology());
756         
757         test = new DateTime(TEST_TIME1);
758         result = test.withMillis(TEST_TIME1);
759         assertSame(test, result);
760     }
761 
762     public void testWithChronology_Chronology() {
763         DateTime test = new DateTime(TEST_TIME1);
764         DateTime result = test.withChronology(GREGORIAN_PARIS);
765         assertEquals(test.getMillis(), result.getMillis());
766         assertEquals(GREGORIAN_PARIS, result.getChronology());
767         
768         test = new DateTime(TEST_TIME1, GREGORIAN_PARIS);
769         result = test.withChronology(null);
770         assertEquals(test.getMillis(), result.getMillis());
771         assertEquals(ISO_DEFAULT, result.getChronology());
772         
773         test = new DateTime(TEST_TIME1);
774         result = test.withChronology(null);
775         assertEquals(test.getMillis(), result.getMillis());
776         assertEquals(ISO_DEFAULT, result.getChronology());
777         
778         test = new DateTime(TEST_TIME1);
779         result = test.withChronology(ISO_DEFAULT);
780         assertSame(test, result);
781     }
782 
783     public void testWithZone_DateTimeZone() {
784         DateTime test = new DateTime(TEST_TIME1);
785         DateTime result = test.withZone(PARIS);
786         assertEquals(test.getMillis(), result.getMillis());
787         assertEquals(ISO_PARIS, result.getChronology());
788         
789         test = new DateTime(TEST_TIME1, GREGORIAN_PARIS);
790         result = test.withZone(null);
791         assertEquals(test.getMillis(), result.getMillis());
792         assertEquals(GREGORIAN_DEFAULT, result.getChronology());
793         
794         test = new DateTime(TEST_TIME1);
795         result = test.withZone(null);
796         assertSame(test, result);
797     }
798 
799     public void testWithZoneRetainFields_DateTimeZone() {
800         DateTime test = new DateTime(TEST_TIME1);
801         DateTime result = test.withZoneRetainFields(PARIS);
802         assertEquals(test.getMillis() - DateTimeConstants.MILLIS_PER_HOUR, result.getMillis());
803         assertEquals(ISO_PARIS, result.getChronology());
804         
805         test = new DateTime(TEST_TIME1);
806         result = test.withZoneRetainFields(LONDON);
807         assertSame(test, result);
808         
809         test = new DateTime(TEST_TIME1);
810         result = test.withZoneRetainFields(null);
811         assertSame(test, result);
812         
813         test = new DateTime(TEST_TIME1, GREGORIAN_PARIS);
814         result = test.withZoneRetainFields(null);
815         assertEquals(test.getMillis() + DateTimeConstants.MILLIS_PER_HOUR, result.getMillis());
816         assertEquals(GREGORIAN_DEFAULT, result.getChronology());
817         
818         test = new DateTime(TEST_TIME1, new MockNullZoneChronology());
819         result = test.withZoneRetainFields(LONDON);
820         assertSame(test, result);
821     }
822     
823     //-----------------------------------------------------------------------
824     public void testWithDate_int_int_int() {
825         DateTime test = new DateTime(2002, 4, 5, 1, 2, 3, 4, ISO_UTC);
826         DateTime result = test.withDate(2003, 5, 6);
827         DateTime expected = new DateTime(2003, 5, 6, 1, 2, 3, 4, ISO_UTC);
828         assertEquals(expected, result);
829         
830         test = new DateTime(TEST_TIME1);
831         try {
832             test.withDate(2003, 13, 1);
833             fail();
834         } catch (IllegalArgumentException ex) {}
835     }
836     
837     public void testWithTime_int_int_int() {
838         DateTime test = new DateTime(TEST_TIME1 - 12345L, BUDDHIST_UTC);
839         DateTime result = test.withTime(12, 24, 0, 0);
840         assertEquals(TEST_TIME1, result.getMillis());
841         assertEquals(BUDDHIST_UTC, result.getChronology());
842         
843         test = new DateTime(TEST_TIME1);
844         try {
845             test.withTime(25, 1, 1, 1);
846             fail();
847         } catch (IllegalArgumentException ex) {}
848     }
849     
850     public void testWithFields_RPartial() {
851         DateTime test = new DateTime(2004, 5, 6, 7, 8, 9, 0);
852         DateTime result = test.withFields(new YearMonthDay(2003, 4, 5));
853         DateTime expected = new DateTime(2003, 4, 5, 7, 8, 9, 0);
854         assertEquals(expected, result);
855         
856         test = new DateTime(TEST_TIME1);
857         result = test.withFields(null);
858         assertSame(test, result);
859     }
860     
861     //-----------------------------------------------------------------------
862     public void testWithField1() {
863         DateTime test = new DateTime(2004, 6, 9, 0, 0, 0, 0);
864         DateTime result = test.withField(DateTimeFieldType.year(), 2006);
865         
866         assertEquals(new DateTime(2004, 6, 9, 0, 0, 0, 0), test);
867         assertEquals(new DateTime(2006, 6, 9, 0, 0, 0, 0), result);
868     }
869 
870     public void testWithField2() {
871         DateTime test = new DateTime(2004, 6, 9, 0, 0, 0, 0);
872         try {
873             test.withField(null, 6);
874             fail();
875         } catch (IllegalArgumentException ex) {}
876     }
877 
878     //-----------------------------------------------------------------------
879     public void testWithFieldAdded1() {
880         DateTime test = new DateTime(2004, 6, 9, 0, 0, 0, 0);
881         DateTime result = test.withFieldAdded(DurationFieldType.years(), 6);
882         
883         assertEquals(new DateTime(2004, 6, 9, 0, 0, 0, 0), test);
884         assertEquals(new DateTime(2010, 6, 9, 0, 0, 0, 0), result);
885     }
886 
887     public void testWithFieldAdded2() {
888         DateTime test = new DateTime(2004, 6, 9, 0, 0, 0, 0);
889         try {
890             test.withFieldAdded(null, 0);
891             fail();
892         } catch (IllegalArgumentException ex) {}
893     }
894 
895     public void testWithFieldAdded3() {
896         DateTime test = new DateTime(2004, 6, 9, 0, 0, 0, 0);
897         try {
898             test.withFieldAdded(null, 6);
899             fail();
900         } catch (IllegalArgumentException ex) {}
901     }
902 
903     public void testWithFieldAdded4() {
904         DateTime test = new DateTime(2004, 6, 9, 0, 0, 0, 0);
905         DateTime result = test.withFieldAdded(DurationFieldType.years(), 0);
906         assertSame(test, result);
907     }
908 
909     //-----------------------------------------------------------------------
910     public void testWithDurationAdded_long_int() {
911         DateTime test = new DateTime(TEST_TIME1, BUDDHIST_DEFAULT);
912         DateTime result = test.withDurationAdded(123456789L, 1);
913         DateTime expected = new DateTime(TEST_TIME1 + 123456789L, BUDDHIST_DEFAULT);
914         assertEquals(expected, result);
915         
916         result = test.withDurationAdded(123456789L, 0);
917         assertSame(test, result);
918         
919         result = test.withDurationAdded(123456789L, 2);
920         expected = new DateTime(TEST_TIME1 + (2L * 123456789L), BUDDHIST_DEFAULT);
921         assertEquals(expected, result);
922         
923         result = test.withDurationAdded(123456789L, -3);
924         expected = new DateTime(TEST_TIME1 - (3L * 123456789L), BUDDHIST_DEFAULT);
925         assertEquals(expected, result);
926     }
927     
928     //-----------------------------------------------------------------------
929     public void testWithDurationAdded_RD_int() {
930         DateTime test = new DateTime(TEST_TIME1, BUDDHIST_DEFAULT);
931         DateTime result = test.withDurationAdded(new Duration(123456789L), 1);
932         DateTime expected = new DateTime(TEST_TIME1 + 123456789L, BUDDHIST_DEFAULT);
933         assertEquals(expected, result);
934         
935         result = test.withDurationAdded(null, 1);
936         assertSame(test, result);
937         
938         result = test.withDurationAdded(new Duration(123456789L), 0);
939         assertSame(test, result);
940         
941         result = test.withDurationAdded(new Duration(123456789L), 2);
942         expected = new DateTime(TEST_TIME1 + (2L * 123456789L), BUDDHIST_DEFAULT);
943         assertEquals(expected, result);
944         
945         result = test.withDurationAdded(new Duration(123456789L), -3);
946         expected = new DateTime(TEST_TIME1 - (3L * 123456789L), BUDDHIST_DEFAULT);
947         assertEquals(expected, result);
948     }
949     
950     //-----------------------------------------------------------------------
951     public void testWithDurationAdded_RP_int() {
952         DateTime test = new DateTime(2002, 5, 3, 1, 2, 3, 4, BUDDHIST_DEFAULT);
953         DateTime result = test.withPeriodAdded(new Period(1, 2, 3, 4, 5, 6, 7, 8), 1);
954         DateTime expected = new DateTime(2003, 7, 28, 6, 8, 10, 12, BUDDHIST_DEFAULT);
955         assertEquals(expected, result);
956         
957         result = test.withPeriodAdded(null, 1);
958         assertSame(test, result);
959         
960         result = test.withPeriodAdded(new Period(1, 2, 3, 4, 5, 6, 7, 8), 0);
961         assertSame(test, result);
962         
963         result = test.withPeriodAdded(new Period(1, 2, 0, 4, 5, 6, 7, 8), 3);
964         expected = new DateTime(2005, 11, 15, 16, 20, 24, 28, BUDDHIST_DEFAULT);
965         assertEquals(expected, result);
966         
967         result = test.withPeriodAdded(new Period(1, 2, 0, 1, 1, 2, 3, 4), -1);
968         expected = new DateTime(2001, 3, 2, 0, 0, 0, 0, BUDDHIST_DEFAULT);
969         assertEquals(expected, result);
970     }
971 
972     //-----------------------------------------------------------------------    
973     public void testPlus_long() {
974         DateTime test = new DateTime(TEST_TIME1, BUDDHIST_DEFAULT);
975         DateTime result = test.plus(123456789L);
976         DateTime expected = new DateTime(TEST_TIME1 + 123456789L, BUDDHIST_DEFAULT);
977         assertEquals(expected, result);
978     }
979     
980     public void testPlus_RD() {
981         DateTime test = new DateTime(TEST_TIME1, BUDDHIST_DEFAULT);
982         DateTime result = test.plus(new Duration(123456789L));
983         DateTime expected = new DateTime(TEST_TIME1 + 123456789L, BUDDHIST_DEFAULT);
984         assertEquals(expected, result);
985         
986         result = test.plus((ReadableDuration) null);
987         assertSame(test, result);
988     }
989     
990     public void testPlus_RP() {
991         DateTime test = new DateTime(2002, 5, 3, 1, 2, 3, 4, BUDDHIST_DEFAULT);
992         DateTime result = test.plus(new Period(1, 2, 3, 4, 5, 6, 7, 8));
993         DateTime expected = new DateTime(2003, 7, 28, 6, 8, 10, 12, BUDDHIST_DEFAULT);
994         assertEquals(expected, result);
995         
996         result = test.plus((ReadablePeriod) null);
997         assertSame(test, result);
998     }
999 
1000     public void testPlusYears_int() {
1001         DateTime test = new DateTime(2002, 5, 3, 1, 2, 3, 4, BUDDHIST_DEFAULT);
1002         DateTime result = test.plusYears(1);
1003         DateTime expected = new DateTime(2003, 5, 3, 1, 2, 3, 4, BUDDHIST_DEFAULT);
1004         assertEquals(expected, result);
1005         
1006         result = test.plusYears(0);
1007         assertSame(test, result);
1008     }
1009 
1010     public void testPlusMonths_int() {
1011         DateTime test = new DateTime(2002, 5, 3, 1, 2, 3, 4, BUDDHIST_DEFAULT);
1012         DateTime result = test.plusMonths(1);
1013         DateTime expected = new DateTime(2002, 6, 3, 1, 2, 3, 4, BUDDHIST_DEFAULT);
1014         assertEquals(expected, result);
1015         
1016         result = test.plusMonths(0);
1017         assertSame(test, result);
1018     }
1019 
1020     public void testPlusWeeks_int() {
1021         DateTime test = new DateTime(2002, 5, 3, 1, 2, 3, 4, BUDDHIST_DEFAULT);
1022         DateTime result = test.plusWeeks(1);
1023         DateTime expected = new DateTime(2002, 5, 10, 1, 2, 3, 4, BUDDHIST_DEFAULT);
1024         assertEquals(expected, result);
1025         
1026         result = test.plusWeeks(0);
1027         assertSame(test, result);
1028     }
1029 
1030     public void testPlusDays_int() {
1031         DateTime test = new DateTime(2002, 5, 3, 1, 2, 3, 4, BUDDHIST_DEFAULT);
1032         DateTime result = test.plusDays(1);
1033         DateTime expected = new DateTime(2002, 5, 4, 1, 2, 3, 4, BUDDHIST_DEFAULT);
1034         assertEquals(expected, result);
1035         
1036         result = test.plusDays(0);
1037         assertSame(test, result);
1038     }
1039 
1040     public void testPlusHours_int() {
1041         DateTime test = new DateTime(2002, 5, 3, 1, 2, 3, 4, BUDDHIST_DEFAULT);
1042         DateTime result = test.plusHours(1);
1043         DateTime expected = new DateTime(2002, 5, 3, 2, 2, 3, 4, BUDDHIST_DEFAULT);
1044         assertEquals(expected, result);
1045         
1046         result = test.plusHours(0);
1047         assertSame(test, result);
1048     }
1049 
1050     public void testPlusMinutes_int() {
1051         DateTime test = new DateTime(2002, 5, 3, 1, 2, 3, 4, BUDDHIST_DEFAULT);
1052         DateTime result = test.plusMinutes(1);
1053         DateTime expected = new DateTime(2002, 5, 3, 1, 3, 3, 4, BUDDHIST_DEFAULT);
1054         assertEquals(expected, result);
1055         
1056         result = test.plusMinutes(0);
1057         assertSame(test, result);
1058     }
1059 
1060     public void testPlusSeconds_int() {
1061         DateTime test = new DateTime(2002, 5, 3, 1, 2, 3, 4, BUDDHIST_DEFAULT);
1062         DateTime result = test.plusSeconds(1);
1063         DateTime expected = new DateTime(2002, 5, 3, 1, 2, 4, 4, BUDDHIST_DEFAULT);
1064         assertEquals(expected, result);
1065         
1066         result = test.plusSeconds(0);
1067         assertSame(test, result);
1068     }
1069 
1070     public void testPlusMillis_int() {
1071         DateTime test = new DateTime(2002, 5, 3, 1, 2, 3, 4, BUDDHIST_DEFAULT);
1072         DateTime result = test.plusMillis(1);
1073         DateTime expected = new DateTime(2002, 5, 3, 1, 2, 3, 5, BUDDHIST_DEFAULT);
1074         assertEquals(expected, result);
1075         
1076         result = test.plusMillis(0);
1077         assertSame(test, result);
1078     }
1079 
1080     //-----------------------------------------------------------------------    
1081     public void testMinus_long() {
1082         DateTime test = new DateTime(TEST_TIME1, BUDDHIST_DEFAULT);
1083         DateTime result = test.minus(123456789L);
1084         DateTime expected = new DateTime(TEST_TIME1 - 123456789L, BUDDHIST_DEFAULT);
1085         assertEquals(expected, result);
1086     }
1087     
1088     public void testMinus_RD() {
1089         DateTime test = new DateTime(TEST_TIME1, BUDDHIST_DEFAULT);
1090         DateTime result = test.minus(new Duration(123456789L));
1091         DateTime expected = new DateTime(TEST_TIME1 - 123456789L, BUDDHIST_DEFAULT);
1092         assertEquals(expected, result);
1093         
1094         result = test.minus((ReadableDuration) null);
1095         assertSame(test, result);
1096     }
1097     
1098     public void testMinus_RP() {
1099         DateTime test = new DateTime(2002, 5, 3, 1, 2, 3, 4, BUDDHIST_DEFAULT);
1100         DateTime result = test.minus(new Period(1, 1, 1, 1, 1, 1, 1, 1));
1101         DateTime expected = new DateTime(2001, 3, 26, 0, 1, 2, 3, BUDDHIST_DEFAULT);
1102         assertEquals(expected, result);
1103         
1104         result = test.minus((ReadablePeriod) null);
1105         assertSame(test, result);
1106     }
1107 
1108     public void testMinusYears_int() {
1109         DateTime test = new DateTime(2002, 5, 3, 1, 2, 3, 4, BUDDHIST_DEFAULT);
1110         DateTime result = test.minusYears(1);
1111         DateTime expected = new DateTime(2001, 5, 3, 1, 2, 3, 4, BUDDHIST_DEFAULT);
1112         assertEquals(expected, result);
1113         
1114         result = test.minusYears(0);
1115         assertSame(test, result);
1116     }
1117 
1118     public void testMinusMonths_int() {
1119         DateTime test = new DateTime(2002, 5, 3, 1, 2, 3, 4, BUDDHIST_DEFAULT);
1120         DateTime result = test.minusMonths(1);
1121         DateTime expected = new DateTime(2002, 4, 3, 1, 2, 3, 4, BUDDHIST_DEFAULT);
1122         assertEquals(expected, result);
1123         
1124         result = test.minusMonths(0);
1125         assertSame(test, result);
1126     }
1127 
1128     public void testMinusWeeks_int() {
1129         DateTime test = new DateTime(2002, 5, 3, 1, 2, 3, 4, BUDDHIST_DEFAULT);
1130         DateTime result = test.minusWeeks(1);
1131         DateTime expected = new DateTime(2002, 4, 26, 1, 2, 3, 4, BUDDHIST_DEFAULT);
1132         assertEquals(expected, result);
1133         
1134         result = test.minusWeeks(0);
1135         assertSame(test, result);
1136     }
1137 
1138     public void testMinusDays_int() {
1139         DateTime test = new DateTime(2002, 5, 3, 1, 2, 3, 4, BUDDHIST_DEFAULT);
1140         DateTime result = test.minusDays(1);
1141         DateTime expected = new DateTime(2002, 5, 2, 1, 2, 3, 4, BUDDHIST_DEFAULT);
1142         assertEquals(expected, result);
1143         
1144         result = test.minusDays(0);
1145         assertSame(test, result);
1146     }
1147 
1148     public void testMinusHours_int() {
1149         DateTime test = new DateTime(2002, 5, 3, 1, 2, 3, 4, BUDDHIST_DEFAULT);
1150         DateTime result = test.minusHours(1);
1151         DateTime expected = new DateTime(2002, 5, 3, 0, 2, 3, 4, BUDDHIST_DEFAULT);
1152         assertEquals(expected, result);
1153         
1154         result = test.minusHours(0);
1155         assertSame(test, result);
1156     }
1157 
1158     public void testMinusMinutes_int() {
1159         DateTime test = new DateTime(2002, 5, 3, 1, 2, 3, 4, BUDDHIST_DEFAULT);
1160         DateTime result = test.minusMinutes(1);
1161         DateTime expected = new DateTime(2002, 5, 3, 1, 1, 3, 4, BUDDHIST_DEFAULT);
1162         assertEquals(expected, result);
1163         
1164         result = test.minusMinutes(0);
1165         assertSame(test, result);
1166     }
1167 
1168     public void testMinusSeconds_int() {
1169         DateTime test = new DateTime(2002, 5, 3, 1, 2, 3, 4, BUDDHIST_DEFAULT);
1170         DateTime result = test.minusSeconds(1);
1171         DateTime expected = new DateTime(2002, 5, 3, 1, 2, 2, 4, BUDDHIST_DEFAULT);
1172         assertEquals(expected, result);
1173         
1174         result = test.minusSeconds(0);
1175         assertSame(test, result);
1176     }
1177 
1178     public void testMinusMillis_int() {
1179         DateTime test = new DateTime(2002, 5, 3, 1, 2, 3, 4, BUDDHIST_DEFAULT);
1180         DateTime result = test.minusMillis(1);
1181         DateTime expected = new DateTime(2002, 5, 3, 1, 2, 3, 3, BUDDHIST_DEFAULT);
1182         assertEquals(expected, result);
1183         
1184         result = test.minusMillis(0);
1185         assertSame(test, result);
1186     }
1187 
1188     //-----------------------------------------------------------------------
1189     public void testProperty() {
1190         DateTime test = new DateTime();
1191         assertEquals(test.year(), test.property(DateTimeFieldType.year()));
1192         assertEquals(test.dayOfWeek(), test.property(DateTimeFieldType.dayOfWeek()));
1193         assertEquals(test.secondOfMinute(), test.property(DateTimeFieldType.secondOfMinute()));
1194         assertEquals(test.millisOfSecond(), test.property(DateTimeFieldType.millisOfSecond()));
1195         DateTimeFieldType bad = new DateTimeFieldType("bad") {
1196             public DurationFieldType getDurationType() {
1197                 return DurationFieldType.weeks();
1198             }
1199             public DurationFieldType getRangeDurationType() {
1200                 return null;
1201             }
1202             public DateTimeField getField(Chronology chronology) {
1203                 return UnsupportedDateTimeField.getInstance(this, UnsupportedDurationField.getInstance(getDurationType()));
1204             }
1205         };
1206         try {
1207             test.property(bad);
1208             fail();
1209         } catch (IllegalArgumentException ex) {}
1210         try {
1211             test.property(null);
1212             fail();
1213         } catch (IllegalArgumentException ex) {}
1214     }
1215 
1216     //-----------------------------------------------------------------------
1217     private void check(DateTime test, int year, int month, int day, int hour, int min, int sec, int mil) {
1218         assertEquals(year, test.getYear());
1219         assertEquals(month, test.getMonthOfYear());
1220         assertEquals(day, test.getDayOfMonth());
1221         assertEquals(hour, test.getHourOfDay());
1222         assertEquals(min, test.getMinuteOfHour());
1223         assertEquals(sec, test.getSecondOfMinute());
1224         assertEquals(mil, test.getMillisOfSecond());
1225     }
1226 
1227 }