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.BuddhistChronology;
33  import org.joda.time.chrono.CopticChronology;
34  import org.joda.time.chrono.GJChronology;
35  import org.joda.time.chrono.GregorianChronology;
36  import org.joda.time.chrono.ISOChronology;
37  import org.joda.time.field.UnsupportedDateTimeField;
38  import org.joda.time.field.UnsupportedDurationField;
39  import org.joda.time.format.DateTimeFormat;
40  import org.joda.time.format.DateTimeFormatter;
41  
42  /**
43   * This class is a Junit unit test for DateMidnight.
44   *
45   * @author Stephen Colebourne
46   */
47  public class TestDateMidnight_Basics extends TestCase {
48      // Test in 2002/03 as time zones are more well known
49      // (before the late 90's they were all over the place)
50  
51      private static final DateTimeZone PARIS = DateTimeZone.forID("Europe/Paris");
52      private static final DateTimeZone LONDON = DateTimeZone.forID("Europe/London");
53      private static final DateTimeZone NEWYORK = DateTimeZone.forID("America/New_York");
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_DEFAULT = ISOChronology.getInstance(LONDON);
59      private static final ISOChronology ISO_PARIS = ISOChronology.getInstance(PARIS);
60      private static final GJChronology GJ_DEFAULT = GJChronology.getInstance(LONDON);
61      private static final GregorianChronology GREGORIAN_DEFAULT = GregorianChronology.getInstance(LONDON);
62      private static final GregorianChronology GREGORIAN_PARIS = GregorianChronology.getInstance(PARIS);
63      private static final BuddhistChronology BUDDHIST_DEFAULT = BuddhistChronology.getInstance(LONDON);
64      private static final CopticChronology COPTIC_DEFAULT = CopticChronology.getInstance(LONDON);
65  
66      long y2002days = 365 + 365 + 366 + 365 + 365 + 365 + 366 + 365 + 365 + 365 + 
67                       366 + 365 + 365 + 365 + 366 + 365 + 365 + 365 + 366 + 365 + 
68                       365 + 365 + 366 + 365 + 365 + 365 + 366 + 365 + 365 + 365 +
69                       366 + 365;
70      long y2003days = 365 + 365 + 366 + 365 + 365 + 365 + 366 + 365 + 365 + 365 + 
71                       366 + 365 + 365 + 365 + 366 + 365 + 365 + 365 + 366 + 365 + 
72                       365 + 365 + 366 + 365 + 365 + 365 + 366 + 365 + 365 + 365 +
73                       366 + 365 + 365;
74      
75      // 2002-06-09
76      private long TEST_TIME_NOW_UTC =
77              (y2002days + 31L + 28L + 31L + 30L + 31L + 9L -1L) * DateTimeConstants.MILLIS_PER_DAY;
78      private long TEST_TIME_NOW_LONDON =
79              TEST_TIME_NOW_UTC - DateTimeConstants.MILLIS_PER_HOUR;
80  //    private long TEST_TIME_NOW_PARIS =
81  //            TEST_TIME_NOW_UTC - 2*DateTimeConstants.MILLIS_PER_HOUR;
82              
83      // 2002-04-05
84      private long TEST_TIME1_UTC =
85              (y2002days + 31L + 28L + 31L + 5L -1L) * DateTimeConstants.MILLIS_PER_DAY
86              + 12L * DateTimeConstants.MILLIS_PER_HOUR
87              + 24L * DateTimeConstants.MILLIS_PER_MINUTE;
88      private long TEST_TIME1_LONDON =
89              (y2002days + 31L + 28L + 31L + 5L -1L) * DateTimeConstants.MILLIS_PER_DAY
90              - DateTimeConstants.MILLIS_PER_HOUR;
91      private long TEST_TIME1_PARIS =
92              (y2002days + 31L + 28L + 31L + 5L -1L) * DateTimeConstants.MILLIS_PER_DAY
93              - 2*DateTimeConstants.MILLIS_PER_HOUR;
94          
95      // 2003-05-06
96      private long TEST_TIME2_UTC =
97              (y2003days + 31L + 28L + 31L + 30L + 6L -1L) * DateTimeConstants.MILLIS_PER_DAY
98              + 14L * DateTimeConstants.MILLIS_PER_HOUR
99              + 28L * DateTimeConstants.MILLIS_PER_MINUTE;
100     private long TEST_TIME2_LONDON =
101             (y2003days + 31L + 28L + 31L + 30L + 6L -1L) * DateTimeConstants.MILLIS_PER_DAY
102              - DateTimeConstants.MILLIS_PER_HOUR;
103     private long TEST_TIME2_PARIS =
104             (y2003days + 31L + 28L + 31L + 30L + 6L -1L) * DateTimeConstants.MILLIS_PER_DAY
105              - 2*DateTimeConstants.MILLIS_PER_HOUR;
106     
107     private DateTimeZone originalDateTimeZone = null;
108     private TimeZone originalTimeZone = null;
109     private Locale originalLocale = null;
110 
111     public static void main(String[] args) {
112         junit.textui.TestRunner.run(suite());
113     }
114 
115     public static TestSuite suite() {
116         return new TestSuite(TestDateMidnight_Basics.class);
117     }
118 
119     public TestDateMidnight_Basics(String name) {
120         super(name);
121     }
122 
123     protected void setUp() throws Exception {
124         DateTimeUtils.setCurrentMillisFixed(TEST_TIME_NOW_UTC);
125         originalDateTimeZone = DateTimeZone.getDefault();
126         originalTimeZone = TimeZone.getDefault();
127         originalLocale = Locale.getDefault();
128         DateTimeZone.setDefault(LONDON);
129         TimeZone.setDefault(TimeZone.getTimeZone("Europe/London"));
130         Locale.setDefault(Locale.UK);
131     }
132 
133     protected void tearDown() throws Exception {
134         DateTimeUtils.setCurrentMillisSystem();
135         DateTimeZone.setDefault(originalDateTimeZone);
136         TimeZone.setDefault(originalTimeZone);
137         Locale.setDefault(originalLocale);
138         originalDateTimeZone = null;
139         originalTimeZone = null;
140         originalLocale = null;
141     }
142 
143     //-----------------------------------------------------------------------
144     public void testTest() {
145         assertEquals("2002-06-09T00:00:00.000Z", new Instant(TEST_TIME_NOW_UTC).toString());
146         assertEquals("2002-04-05T12:24:00.000Z", new Instant(TEST_TIME1_UTC).toString());
147         assertEquals("2003-05-06T14:28:00.000Z", new Instant(TEST_TIME2_UTC).toString());
148     }
149 
150     //-----------------------------------------------------------------------
151     public void testGet_DateTimeField() {
152         DateMidnight test = new DateMidnight();
153         assertEquals(1, test.get(ISO_DEFAULT.era()));
154         assertEquals(20, test.get(ISO_DEFAULT.centuryOfEra()));
155         assertEquals(2, test.get(ISO_DEFAULT.yearOfCentury()));
156         assertEquals(2002, test.get(ISO_DEFAULT.yearOfEra()));
157         assertEquals(2002, test.get(ISO_DEFAULT.year()));
158         assertEquals(6, test.get(ISO_DEFAULT.monthOfYear()));
159         assertEquals(9, test.get(ISO_DEFAULT.dayOfMonth()));
160         assertEquals(2002, test.get(ISO_DEFAULT.weekyear()));
161         assertEquals(23, test.get(ISO_DEFAULT.weekOfWeekyear()));
162         assertEquals(7, test.get(ISO_DEFAULT.dayOfWeek()));
163         assertEquals(160, test.get(ISO_DEFAULT.dayOfYear()));
164         assertEquals(0, test.get(ISO_DEFAULT.halfdayOfDay()));
165         assertEquals(0, test.get(ISO_DEFAULT.hourOfHalfday()));
166         assertEquals(24, test.get(ISO_DEFAULT.clockhourOfDay()));
167         assertEquals(12, test.get(ISO_DEFAULT.clockhourOfHalfday()));
168         assertEquals(0, test.get(ISO_DEFAULT.hourOfDay()));
169         assertEquals(0, test.get(ISO_DEFAULT.minuteOfHour()));
170         assertEquals(0, test.get(ISO_DEFAULT.minuteOfDay()));
171         assertEquals(0, test.get(ISO_DEFAULT.secondOfMinute()));
172         assertEquals(0, test.get(ISO_DEFAULT.secondOfDay()));
173         assertEquals(0, test.get(ISO_DEFAULT.millisOfSecond()));
174         assertEquals(0, test.get(ISO_DEFAULT.millisOfDay()));
175         try {
176             test.get((DateTimeField) null);
177             fail();
178         } catch (IllegalArgumentException ex) {}
179     }
180 
181     public void testGet_DateTimeFieldType() {
182         DateMidnight test = new DateMidnight();
183         assertEquals(1, test.get(DateTimeFieldType.era()));
184         assertEquals(20, test.get(DateTimeFieldType.centuryOfEra()));
185         assertEquals(2, test.get(DateTimeFieldType.yearOfCentury()));
186         assertEquals(2002, test.get(DateTimeFieldType.yearOfEra()));
187         assertEquals(2002, test.get(DateTimeFieldType.year()));
188         assertEquals(6, test.get(DateTimeFieldType.monthOfYear()));
189         assertEquals(9, test.get(DateTimeFieldType.dayOfMonth()));
190         assertEquals(2002, test.get(DateTimeFieldType.weekyear()));
191         assertEquals(23, test.get(DateTimeFieldType.weekOfWeekyear()));
192         assertEquals(7, test.get(DateTimeFieldType.dayOfWeek()));
193         assertEquals(160, test.get(DateTimeFieldType.dayOfYear()));
194         assertEquals(0, test.get(DateTimeFieldType.halfdayOfDay()));
195         assertEquals(0, test.get(DateTimeFieldType.hourOfHalfday()));
196         assertEquals(24, test.get(DateTimeFieldType.clockhourOfDay()));
197         assertEquals(12, test.get(DateTimeFieldType.clockhourOfHalfday()));
198         assertEquals(0, test.get(DateTimeFieldType.hourOfDay()));
199         assertEquals(0, test.get(DateTimeFieldType.minuteOfHour()));
200         assertEquals(0, test.get(DateTimeFieldType.minuteOfDay()));
201         assertEquals(0, test.get(DateTimeFieldType.secondOfMinute()));
202         assertEquals(0, test.get(DateTimeFieldType.secondOfDay()));
203         assertEquals(0, test.get(DateTimeFieldType.millisOfSecond()));
204         assertEquals(0, test.get(DateTimeFieldType.millisOfDay()));
205         try {
206             test.get((DateTimeFieldType) null);
207             fail();
208         } catch (IllegalArgumentException ex) {}
209     }
210 
211     //-----------------------------------------------------------------------
212     public void testGetters() {
213         DateMidnight test = new DateMidnight();
214         
215         assertEquals(ISO_DEFAULT, test.getChronology());
216         assertEquals(LONDON, test.getZone());
217         assertEquals(TEST_TIME_NOW_LONDON, test.getMillis());
218         
219         assertEquals(1, test.getEra());
220         assertEquals(20, test.getCenturyOfEra());
221         assertEquals(2, test.getYearOfCentury());
222         assertEquals(2002, test.getYearOfEra());
223         assertEquals(2002, test.getYear());
224         assertEquals(6, test.getMonthOfYear());
225         assertEquals(9, test.getDayOfMonth());
226         assertEquals(2002, test.getWeekyear());
227         assertEquals(23, test.getWeekOfWeekyear());
228         assertEquals(7, test.getDayOfWeek());
229         assertEquals(160, test.getDayOfYear());
230         assertEquals(0, test.getHourOfDay());
231         assertEquals(0, test.getMinuteOfHour());
232         assertEquals(0, test.getMinuteOfDay());
233         assertEquals(0, test.getSecondOfMinute());
234         assertEquals(0, test.getSecondOfDay());
235         assertEquals(0, test.getMillisOfSecond());
236         assertEquals(0, test.getMillisOfDay());
237     }
238 
239     public void testWithers() {
240         DateMidnight test = new DateMidnight(1970, 6, 9, GJ_DEFAULT);
241         check(test.withYear(2000), 2000, 6, 9);
242         check(test.withMonthOfYear(2), 1970, 2, 9);
243         check(test.withDayOfMonth(2), 1970, 6, 2);
244         check(test.withDayOfYear(6), 1970, 1, 6);
245         check(test.withDayOfWeek(6), 1970, 6, 13);
246         check(test.withWeekOfWeekyear(6), 1970, 2, 3);
247         check(test.withWeekyear(1971), 1971, 6, 15);
248         check(test.withYearOfCentury(60), 1960, 6, 9);
249         check(test.withCenturyOfEra(21), 2070, 6, 9);
250         check(test.withYearOfEra(1066), 1066, 6, 9);
251         check(test.withEra(DateTimeConstants.BC), -1970, 6, 9);
252         
253         try {
254             test.withMonthOfYear(0);
255             fail();
256         } catch (IllegalArgumentException ex) {}
257         try {
258             test.withMonthOfYear(13);
259             fail();
260         } catch (IllegalArgumentException ex) {}
261     }
262 
263     //-----------------------------------------------------------------------
264     public void testEqualsHashCode() {
265         DateMidnight test1 = new DateMidnight(TEST_TIME1_UTC);
266         DateMidnight test2 = new DateMidnight(TEST_TIME1_UTC);
267         assertEquals(true, test1.equals(test2));
268         assertEquals(true, test2.equals(test1));
269         assertEquals(true, test1.equals(test1));
270         assertEquals(true, test2.equals(test2));
271         assertEquals(true, test1.hashCode() == test2.hashCode());
272         assertEquals(true, test1.hashCode() == test1.hashCode());
273         assertEquals(true, test2.hashCode() == test2.hashCode());
274         
275         DateMidnight test3 = new DateMidnight(TEST_TIME2_UTC);
276         assertEquals(false, test1.equals(test3));
277         assertEquals(false, test2.equals(test3));
278         assertEquals(false, test3.equals(test1));
279         assertEquals(false, test3.equals(test2));
280         assertEquals(false, test1.hashCode() == test3.hashCode());
281         assertEquals(false, test2.hashCode() == test3.hashCode());
282         
283         assertEquals(false, test1.equals("Hello"));
284         assertEquals(true, test1.equals(new MockInstant()));
285         assertEquals(false, test1.equals(new DateMidnight(TEST_TIME1_UTC, GREGORIAN_DEFAULT)));
286     }
287     
288     class MockInstant extends AbstractInstant {
289         public String toString() {
290             return null;
291         }
292         public long getMillis() {
293             return TEST_TIME1_LONDON;
294         }
295         public Chronology getChronology() {
296             return ISO_DEFAULT;
297         }
298     }
299 
300     public void testCompareTo() {
301         DateMidnight test1 = new DateMidnight(TEST_TIME1_UTC);
302         DateMidnight test1a = new DateMidnight(TEST_TIME1_UTC);
303         assertEquals(0, test1.compareTo(test1a));
304         assertEquals(0, test1a.compareTo(test1));
305         assertEquals(0, test1.compareTo(test1));
306         assertEquals(0, test1a.compareTo(test1a));
307         
308         DateMidnight test2 = new DateMidnight(TEST_TIME2_UTC);
309         assertEquals(-1, test1.compareTo(test2));
310         assertEquals(+1, test2.compareTo(test1));
311         
312         DateMidnight test3 = new DateMidnight(TEST_TIME2_UTC, GREGORIAN_PARIS);
313         assertEquals(-1, test1.compareTo(test3));
314         assertEquals(+1, test3.compareTo(test1));
315         assertEquals(-1, test3.compareTo(test2));  // midnight paris before london
316         
317         assertEquals(+1, test2.compareTo(new MockInstant()));
318         assertEquals(0, test1.compareTo(new MockInstant()));
319         
320         try {
321             test1.compareTo(null);
322             fail();
323         } catch (NullPointerException ex) {}
324 //        try {
325 //            test1.compareTo(new Date());
326 //            fail();
327 //        } catch (ClassCastException ex) {}
328     }
329     
330     public void testIsEqual() {
331         DateMidnight test1 = new DateMidnight(TEST_TIME1_UTC);
332         DateMidnight test1a = new DateMidnight(TEST_TIME1_UTC);
333         assertEquals(true, test1.isEqual(test1a));
334         assertEquals(true, test1a.isEqual(test1));
335         assertEquals(true, test1.isEqual(test1));
336         assertEquals(true, test1a.isEqual(test1a));
337         
338         DateMidnight test2 = new DateMidnight(TEST_TIME2_UTC);
339         assertEquals(false, test1.isEqual(test2));
340         assertEquals(false, test2.isEqual(test1));
341         
342         DateMidnight test3 = new DateMidnight(TEST_TIME2_UTC, GREGORIAN_PARIS);
343         assertEquals(false, test1.isEqual(test3));
344         assertEquals(false, test3.isEqual(test1));
345         assertEquals(false, test3.isEqual(test2));  // midnight paris before london
346         
347         assertEquals(false, test2.isEqual(new MockInstant()));
348         assertEquals(true, test1.isEqual(new MockInstant()));
349         
350         assertEquals(false, new DateMidnight(TEST_TIME_NOW_UTC + DateTimeConstants.MILLIS_PER_DAY, DateTimeZone.UTC).isEqual(null));
351         assertEquals(true, new DateMidnight(TEST_TIME_NOW_UTC, DateTimeZone.UTC).isEqual(null));
352         assertEquals(false, new DateMidnight(TEST_TIME_NOW_UTC - DateTimeConstants.MILLIS_PER_DAY, DateTimeZone.UTC).isEqual(null));
353         
354         assertEquals(false, new DateMidnight(2004, 6, 9).isEqual(new DateTime(2004, 6, 8, 23, 59, 59, 999)));
355         assertEquals(true, new DateMidnight(2004, 6, 9).isEqual(new DateTime(2004, 6, 9, 0, 0, 0, 0)));
356         assertEquals(false, new DateMidnight(2004, 6, 9).isEqual(new DateTime(2004, 6, 9, 0, 0, 0, 1)));
357     }
358     
359     public void testIsBefore() {
360         DateMidnight test1 = new DateMidnight(TEST_TIME1_UTC);
361         DateMidnight test1a = new DateMidnight(TEST_TIME1_UTC);
362         assertEquals(false, test1.isBefore(test1a));
363         assertEquals(false, test1a.isBefore(test1));
364         assertEquals(false, test1.isBefore(test1));
365         assertEquals(false, test1a.isBefore(test1a));
366         
367         DateMidnight test2 = new DateMidnight(TEST_TIME2_UTC);
368         assertEquals(true, test1.isBefore(test2));
369         assertEquals(false, test2.isBefore(test1));
370         
371         DateMidnight test3 = new DateMidnight(TEST_TIME2_UTC, GREGORIAN_PARIS);
372         assertEquals(true, test1.isBefore(test3));
373         assertEquals(false, test3.isBefore(test1));
374         assertEquals(true, test3.isBefore(test2));  // midnight paris before london
375         
376         assertEquals(false, test2.isBefore(new MockInstant()));
377         assertEquals(false, test1.isBefore(new MockInstant()));
378         
379         assertEquals(false, new DateMidnight(TEST_TIME_NOW_UTC + DateTimeConstants.MILLIS_PER_DAY, DateTimeZone.UTC).isBefore(null));
380         assertEquals(false, new DateMidnight(TEST_TIME_NOW_UTC, DateTimeZone.UTC).isBefore(null));
381         assertEquals(true, new DateMidnight(TEST_TIME_NOW_UTC - DateTimeConstants.MILLIS_PER_DAY, DateTimeZone.UTC).isBefore(null));
382         
383         assertEquals(false, new DateMidnight(2004, 6, 9).isBefore(new DateTime(2004, 6, 8, 23, 59, 59, 999)));
384         assertEquals(false, new DateMidnight(2004, 6, 9).isBefore(new DateTime(2004, 6, 9, 0, 0, 0, 0)));
385         assertEquals(true, new DateMidnight(2004, 6, 9).isBefore(new DateTime(2004, 6, 9, 0, 0, 0, 1)));
386     }
387     
388     public void testIsAfter() {
389         DateMidnight test1 = new DateMidnight(TEST_TIME1_UTC);
390         DateMidnight test1a = new DateMidnight(TEST_TIME1_UTC);
391         assertEquals(false, test1.isAfter(test1a));
392         assertEquals(false, test1a.isAfter(test1));
393         assertEquals(false, test1.isAfter(test1));
394         assertEquals(false, test1a.isAfter(test1a));
395         
396         DateMidnight test2 = new DateMidnight(TEST_TIME2_UTC);
397         assertEquals(false, test1.isAfter(test2));
398         assertEquals(true, test2.isAfter(test1));
399         
400         DateMidnight test3 = new DateMidnight(TEST_TIME2_UTC, GREGORIAN_PARIS);
401         assertEquals(false, test1.isAfter(test3));
402         assertEquals(true, test3.isAfter(test1));
403         assertEquals(false, test3.isAfter(test2));  // midnight paris before london
404         
405         assertEquals(true, test2.isAfter(new MockInstant()));
406         assertEquals(false, test1.isAfter(new MockInstant()));
407         
408         assertEquals(true, new DateMidnight(TEST_TIME_NOW_UTC + DateTimeConstants.MILLIS_PER_DAY, DateTimeZone.UTC).isAfter(null));
409         assertEquals(false, new DateMidnight(TEST_TIME_NOW_UTC, DateTimeZone.UTC).isAfter(null));
410         assertEquals(false, new DateMidnight(TEST_TIME_NOW_UTC - DateTimeConstants.MILLIS_PER_DAY, DateTimeZone.UTC).isAfter(null));
411         
412         assertEquals(true, new DateMidnight(2004, 6, 9).isAfter(new DateTime(2004, 6, 8, 23, 59, 59, 999)));
413         assertEquals(false, new DateMidnight(2004, 6, 9).isAfter(new DateTime(2004, 6, 9, 0, 0, 0, 0)));
414         assertEquals(false, new DateMidnight(2004, 6, 9).isAfter(new DateTime(2004, 6, 9, 0, 0, 0, 1)));
415     }
416     
417     //-----------------------------------------------------------------------
418     public void testSerialization() throws Exception {
419         DateMidnight test = new DateMidnight(TEST_TIME_NOW_UTC);
420         
421         ByteArrayOutputStream baos = new ByteArrayOutputStream();
422         ObjectOutputStream oos = new ObjectOutputStream(baos);
423         oos.writeObject(test);
424         byte[] bytes = baos.toByteArray();
425         oos.close();
426         
427         ByteArrayInputStream bais = new ByteArrayInputStream(bytes);
428         ObjectInputStream ois = new ObjectInputStream(bais);
429         DateMidnight result = (DateMidnight) ois.readObject();
430         ois.close();
431         
432         assertEquals(test, result);
433     }
434 
435     //-----------------------------------------------------------------------
436     public void testToString() {
437         DateMidnight test = new DateMidnight(TEST_TIME_NOW_UTC);
438         assertEquals("2002-06-09T00:00:00.000+01:00", test.toString());
439         
440         test = new DateMidnight(TEST_TIME_NOW_UTC, PARIS);
441         assertEquals("2002-06-09T00:00:00.000+02:00", test.toString());
442         
443         test = new DateMidnight(TEST_TIME_NOW_UTC, NEWYORK);
444         assertEquals("2002-06-08T00:00:00.000-04:00", test.toString());  // the 8th
445     }
446 
447     public void testToString_String() {
448         DateMidnight test = new DateMidnight(TEST_TIME_NOW_UTC);
449         assertEquals("2002 00", test.toString("yyyy HH"));
450         assertEquals("2002-06-09T00:00:00.000+01:00", test.toString((String) null));
451     }
452 
453     public void testToString_String_String() {
454         DateMidnight test = new DateMidnight(TEST_TIME_NOW_UTC);
455         assertEquals("Sun 9/6", test.toString("EEE d/M", Locale.ENGLISH));
456         assertEquals("dim. 9/6", test.toString("EEE d/M", Locale.FRENCH));
457         assertEquals("2002-06-09T00:00:00.000+01:00", test.toString(null, Locale.ENGLISH));
458         assertEquals("Sun 9/6", test.toString("EEE d/M", null));
459         assertEquals("2002-06-09T00:00:00.000+01:00", test.toString(null, null));
460     }
461 
462     public void testToString_DTFormatter() {
463         DateMidnight test = new DateMidnight(TEST_TIME_NOW_UTC);
464         assertEquals("2002 00", test.toString(DateTimeFormat.forPattern("yyyy HH")));
465         assertEquals("2002-06-09T00:00:00.000+01:00", test.toString((DateTimeFormatter) null));
466     }
467 
468     //-----------------------------------------------------------------------
469     public void testToInstant() {
470         DateMidnight test = new DateMidnight(TEST_TIME1_UTC);
471         Instant result = test.toInstant();
472         assertEquals(TEST_TIME1_LONDON, result.getMillis());
473     }
474 
475     public void testToDateTime() {
476         DateMidnight test = new DateMidnight(TEST_TIME1_UTC, PARIS);
477         DateTime result = test.toDateTime();
478         assertEquals(test.getMillis(), result.getMillis());
479         assertEquals(TEST_TIME1_PARIS, result.getMillis());
480         assertEquals(PARIS, result.getZone());
481     }
482 
483     public void testToDateTimeISO() {
484         DateMidnight test = new DateMidnight(TEST_TIME1_UTC, PARIS);
485         DateTime result = test.toDateTimeISO();
486         assertSame(DateTime.class, result.getClass());
487         assertSame(ISOChronology.class, result.getChronology().getClass());
488         assertEquals(test.getMillis(), result.getMillis());
489         assertEquals(ISO_PARIS, result.getChronology());
490     }
491 
492     public void testToDateTime_DateTimeZone() {
493         DateMidnight test = new DateMidnight(TEST_TIME1_UTC);
494         DateTime result = test.toDateTime(LONDON);
495         assertEquals(test.getMillis(), result.getMillis());
496         assertEquals(TEST_TIME1_LONDON, result.getMillis());
497         assertEquals(LONDON, result.getZone());
498 
499         test = new DateMidnight(TEST_TIME1_UTC);
500         result = test.toDateTime(PARIS);
501         assertEquals(test.getMillis(), result.getMillis());
502         assertEquals(TEST_TIME1_LONDON, result.getMillis());
503         assertEquals(PARIS, result.getZone());
504 
505         test = new DateMidnight(TEST_TIME1_UTC, PARIS);
506         result = test.toDateTime((DateTimeZone) null);
507         assertEquals(test.getMillis(), result.getMillis());
508         assertEquals(TEST_TIME1_PARIS, result.getMillis());
509         assertEquals(LONDON, result.getZone());
510 
511         test = new DateMidnight(TEST_TIME1_UTC);
512         result = test.toDateTime((DateTimeZone) null);
513         assertEquals(test.getMillis(), result.getMillis());
514         assertEquals(TEST_TIME1_LONDON, result.getMillis());
515         assertEquals(LONDON, result.getZone());
516     }
517 
518     public void testToDateTime_Chronology() {
519         DateMidnight test = new DateMidnight(TEST_TIME1_UTC);
520         DateTime result = test.toDateTime(ISO_DEFAULT);
521         assertEquals(test.getMillis(), result.getMillis());
522         assertEquals(TEST_TIME1_LONDON, result.getMillis());
523         assertEquals(LONDON, result.getZone());
524 
525         test = new DateMidnight(TEST_TIME1_UTC);
526         result = test.toDateTime(GREGORIAN_PARIS);
527         assertEquals(test.getMillis(), result.getMillis());
528         assertEquals(TEST_TIME1_LONDON, result.getMillis());
529         assertEquals(GREGORIAN_PARIS, result.getChronology());
530 
531         test = new DateMidnight(TEST_TIME1_UTC, GREGORIAN_PARIS);
532         result = test.toDateTime((Chronology) null);
533         assertEquals(test.getMillis(), result.getMillis());
534         assertEquals(TEST_TIME1_PARIS, result.getMillis());
535         assertEquals(ISO_DEFAULT, result.getChronology());
536 
537         test = new DateMidnight(TEST_TIME1_UTC);
538         result = test.toDateTime((Chronology) null);
539         assertEquals(test.getMillis(), result.getMillis());
540         assertEquals(TEST_TIME1_LONDON, result.getMillis());
541         assertEquals(ISO_DEFAULT, result.getChronology());
542     }
543 
544     public void testToMutableDateTime() {
545         DateMidnight test = new DateMidnight(TEST_TIME1_UTC, PARIS);
546         MutableDateTime result = test.toMutableDateTime();
547         assertEquals(test.getMillis(), result.getMillis());
548         assertEquals(ISO_PARIS, result.getChronology());
549     }
550 
551     public void testToMutableDateTimeISO() {
552         DateMidnight test = new DateMidnight(TEST_TIME1_UTC, PARIS);
553         MutableDateTime result = test.toMutableDateTimeISO();
554         assertSame(MutableDateTime.class, result.getClass());
555         assertSame(ISOChronology.class, result.getChronology().getClass());
556         assertEquals(test.getMillis(), result.getMillis());
557         assertEquals(ISO_PARIS, result.getChronology());
558     }
559 
560     public void testToMutableDateTime_DateTimeZone() {
561         DateMidnight test = new DateMidnight(TEST_TIME1_UTC);
562         MutableDateTime result = test.toMutableDateTime(LONDON);
563         assertEquals(test.getMillis(), result.getMillis());
564         assertEquals(ISO_DEFAULT, result.getChronology());
565 
566         test = new DateMidnight(TEST_TIME1_UTC);
567         result = test.toMutableDateTime(PARIS);
568         assertEquals(test.getMillis(), result.getMillis());
569         assertEquals(ISO_PARIS, result.getChronology());
570 
571         test = new DateMidnight(TEST_TIME1_UTC, PARIS);
572         result = test.toMutableDateTime((DateTimeZone) null);
573         assertEquals(test.getMillis(), result.getMillis());
574         assertEquals(ISO_DEFAULT, result.getChronology());
575 
576         test = new DateMidnight(TEST_TIME1_UTC);
577         result = test.toMutableDateTime((DateTimeZone) null);
578         assertEquals(test.getMillis(), result.getMillis());
579         assertEquals(ISO_DEFAULT, result.getChronology());
580     }
581 
582     public void testToMutableDateTime_Chronology() {
583         DateMidnight test = new DateMidnight(TEST_TIME1_UTC);
584         MutableDateTime result = test.toMutableDateTime(ISO_DEFAULT);
585         assertEquals(test.getMillis(), result.getMillis());
586         assertEquals(ISO_DEFAULT, result.getChronology());
587 
588         test = new DateMidnight(TEST_TIME1_UTC);
589         result = test.toMutableDateTime(GREGORIAN_PARIS);
590         assertEquals(test.getMillis(), result.getMillis());
591         assertEquals(GREGORIAN_PARIS, result.getChronology());
592 
593         test = new DateMidnight(TEST_TIME1_UTC, GREGORIAN_PARIS);
594         result = test.toMutableDateTime((Chronology) null);
595         assertEquals(test.getMillis(), result.getMillis());
596         assertEquals(ISO_DEFAULT, result.getChronology());
597 
598         test = new DateMidnight(TEST_TIME1_UTC);
599         result = test.toMutableDateTime((Chronology) null);
600         assertEquals(test.getMillis(), result.getMillis());
601         assertEquals(ISO_DEFAULT, result.getChronology());
602     }
603 
604     public void testToDate() {
605         DateMidnight test = new DateMidnight(TEST_TIME1_UTC);
606         Date result = test.toDate();
607         assertEquals(test.getMillis(), result.getTime());
608     }
609 
610     public void testToCalendar_Locale() {
611         DateMidnight test = new DateMidnight(TEST_TIME1_UTC);
612         Calendar result = test.toCalendar(null);
613         assertEquals(test.getMillis(), result.getTime().getTime());
614         assertEquals(TimeZone.getTimeZone("Europe/London"), result.getTimeZone());
615 
616         test = new DateMidnight(TEST_TIME1_UTC, PARIS);
617         result = test.toCalendar(null);
618         assertEquals(test.getMillis(), result.getTime().getTime());
619         assertEquals(TimeZone.getTimeZone("Europe/Paris"), result.getTimeZone());
620 
621         test = new DateMidnight(TEST_TIME1_UTC, PARIS);
622         result = test.toCalendar(Locale.UK);
623         assertEquals(test.getMillis(), result.getTime().getTime());
624         assertEquals(TimeZone.getTimeZone("Europe/Paris"), result.getTimeZone());
625     }
626 
627     public void testToGregorianCalendar() {
628         DateMidnight test = new DateMidnight(TEST_TIME1_UTC);
629         GregorianCalendar result = test.toGregorianCalendar();
630         assertEquals(test.getMillis(), result.getTime().getTime());
631         assertEquals(TimeZone.getTimeZone("Europe/London"), result.getTimeZone());
632 
633         test = new DateMidnight(TEST_TIME1_UTC, PARIS);
634         result = test.toGregorianCalendar();
635         assertEquals(test.getMillis(), result.getTime().getTime());
636         assertEquals(TimeZone.getTimeZone("Europe/Paris"), result.getTimeZone());
637     }
638 
639     //-----------------------------------------------------------------------
640     public void testToYearMonthDay() {
641         DateMidnight base = new DateMidnight(TEST_TIME1_UTC, COPTIC_DEFAULT);
642         YearMonthDay test = base.toYearMonthDay();
643         assertEquals(new YearMonthDay(TEST_TIME1_UTC, COPTIC_DEFAULT), test);
644     }
645 
646     public void testToLocalDate() {
647         DateMidnight base = new DateMidnight(TEST_TIME1_UTC, COPTIC_DEFAULT);
648         LocalDate test = base.toLocalDate();
649         assertEquals(new LocalDate(TEST_TIME1_UTC, COPTIC_DEFAULT), test);
650     }
651 
652     public void testToInterval() {
653         DateMidnight base = new DateMidnight(TEST_TIME1_UTC, COPTIC_DEFAULT);
654         Interval test = base.toInterval();
655         DateMidnight end = base.plus(Period.days(1));
656         assertEquals(new Interval(base, end), test);
657     }
658 
659     //-----------------------------------------------------------------------
660     public void testWithMillis_long() {
661         DateMidnight test = new DateMidnight(TEST_TIME1_UTC);
662         DateMidnight result = test.withMillis(TEST_TIME2_UTC);
663         assertEquals(TEST_TIME2_LONDON, result.getMillis());
664         assertEquals(test.getChronology(), result.getChronology());
665         
666         test = new DateMidnight(TEST_TIME1_UTC, GREGORIAN_PARIS);
667         result = test.withMillis(TEST_TIME2_UTC);
668         assertEquals(TEST_TIME2_PARIS, result.getMillis());
669         assertEquals(test.getChronology(), result.getChronology());
670         
671         test = new DateMidnight(TEST_TIME1_UTC);
672         result = test.withMillis(TEST_TIME1_UTC);
673         assertSame(test, result);
674     }
675 
676     public void testWithChronology_Chronology() {
677         DateMidnight test = new DateMidnight(TEST_TIME1_UTC);
678         DateMidnight result = test.withChronology(GREGORIAN_PARIS);
679         assertEquals(TEST_TIME1_LONDON, test.getMillis());
680         assertEquals(TEST_TIME1_PARIS, result.getMillis());
681         assertEquals(GREGORIAN_PARIS, result.getChronology());
682         
683         test = new DateMidnight(TEST_TIME1_UTC, GREGORIAN_PARIS);
684         result = test.withChronology(null);
685         assertEquals(TEST_TIME1_PARIS, test.getMillis());
686         // midnight Paris is previous day in London
687         assertEquals(TEST_TIME1_LONDON - DateTimeConstants.MILLIS_PER_DAY, result.getMillis());
688         assertEquals(ISO_DEFAULT, result.getChronology());
689         
690         test = new DateMidnight(TEST_TIME1_UTC);
691         result = test.withChronology(null);
692         assertEquals(test.getMillis(), result.getMillis());
693         assertEquals(ISO_DEFAULT, result.getChronology());
694         
695         test = new DateMidnight(TEST_TIME1_UTC);
696         result = test.withChronology(ISO_DEFAULT);
697         assertSame(test, result);
698     }
699 
700     public void testWithZoneRetainFields_DateTimeZone() {
701         DateMidnight test = new DateMidnight(TEST_TIME1_UTC);
702         DateMidnight result = test.withZoneRetainFields(PARIS);
703         assertEquals(TEST_TIME1_LONDON, test.getMillis());
704         assertEquals(TEST_TIME1_PARIS, result.getMillis());
705         assertEquals(ISO_PARIS, result.getChronology());
706         
707         test = new DateMidnight(TEST_TIME1_UTC, GREGORIAN_PARIS);
708         result = test.withZoneRetainFields(null);
709         assertEquals(TEST_TIME1_PARIS, test.getMillis());
710         assertEquals(TEST_TIME1_LONDON, result.getMillis());
711         assertEquals(GREGORIAN_DEFAULT, result.getChronology());
712         
713         test = new DateMidnight(TEST_TIME1_UTC);
714         result = test.withZoneRetainFields(LONDON);
715         assertSame(test, result);
716         
717         test = new DateMidnight(TEST_TIME1_UTC);
718         result = test.withZoneRetainFields(null);
719         assertSame(test, result);
720         
721         test = new DateMidnight(TEST_TIME1_UTC, new MockNullZoneChronology());
722         result = test.withZoneRetainFields(LONDON);
723         assertSame(test, result);
724     }
725 
726     //-----------------------------------------------------------------------
727     public void testWithFields_RPartial() {
728         DateMidnight test = new DateMidnight(2004, 5, 6);
729         DateMidnight result = test.withFields(new YearMonthDay(2003, 4, 5));
730         DateMidnight expected = new DateMidnight(2003, 4, 5);
731         assertEquals(expected, result);
732         
733         test = new DateMidnight(TEST_TIME1_UTC);
734         result = test.withFields(null);
735         assertSame(test, result);
736     }
737 
738     //-----------------------------------------------------------------------
739     public void testWithField1() {
740         DateMidnight test = new DateMidnight(2004, 6, 9);
741         DateMidnight result = test.withField(DateTimeFieldType.year(), 2006);
742         
743         assertEquals(new DateMidnight(2004, 6, 9), test);
744         assertEquals(new DateMidnight(2006, 6, 9), result);
745     }
746 
747     public void testWithField2() {
748         DateMidnight test = new DateMidnight(2004, 6, 9);
749         try {
750             test.withField(null, 6);
751             fail();
752         } catch (IllegalArgumentException ex) {}
753     }
754 
755     //-----------------------------------------------------------------------
756     public void testWithFieldAdded1() {
757         DateMidnight test = new DateMidnight(2004, 6, 9);
758         DateMidnight result = test.withFieldAdded(DurationFieldType.years(), 6);
759         
760         assertEquals(new DateMidnight(2004, 6, 9), test);
761         assertEquals(new DateMidnight(2010, 6, 9), result);
762     }
763 
764     public void testWithFieldAdded2() {
765         DateMidnight test = new DateMidnight(2004, 6, 9);
766         try {
767             test.withFieldAdded(null, 0);
768             fail();
769         } catch (IllegalArgumentException ex) {}
770     }
771 
772     public void testWithFieldAdded3() {
773         DateMidnight test = new DateMidnight(2004, 6, 9);
774         try {
775             test.withFieldAdded(null, 6);
776             fail();
777         } catch (IllegalArgumentException ex) {}
778     }
779 
780     public void testWithFieldAdded4() {
781         DateMidnight test = new DateMidnight(2004, 6, 9);
782         DateMidnight result = test.withFieldAdded(DurationFieldType.years(), 0);
783         assertSame(test, result);
784     }
785 
786     //-----------------------------------------------------------------------
787     public void testWithDurationAdded_long_int() {
788         DateMidnight test = new DateMidnight(TEST_TIME1_UTC, BUDDHIST_DEFAULT);
789         DateMidnight result = test.withDurationAdded(123456789L, 1);
790         DateMidnight expected = new DateMidnight(test.getMillis() + 123456789L, BUDDHIST_DEFAULT);
791         assertEquals(expected, result);
792         
793         result = test.withDurationAdded(123456789L, 0);
794         assertSame(test, result);
795         
796         result = test.withDurationAdded(123456789L, 2);
797         expected = new DateMidnight(test.getMillis() + (2L * 123456789L), BUDDHIST_DEFAULT);
798         assertEquals(expected, result);
799         
800         result = test.withDurationAdded(123456789L, -3);
801         expected = new DateMidnight(test.getMillis() - (3L * 123456789L), BUDDHIST_DEFAULT);
802         assertEquals(expected, result);
803     }
804     
805     //-----------------------------------------------------------------------
806     public void testWithDurationAdded_RD_int() {
807         DateMidnight test = new DateMidnight(TEST_TIME1_UTC, BUDDHIST_DEFAULT);
808         DateMidnight result = test.withDurationAdded(new Duration(123456789L), 1);
809         DateMidnight expected = new DateMidnight(test.getMillis() + 123456789L, BUDDHIST_DEFAULT);
810         assertEquals(expected, result);
811         
812         result = test.withDurationAdded(null, 1);
813         assertSame(test, result);
814         
815         result = test.withDurationAdded(new Duration(123456789L), 0);
816         assertSame(test, result);
817         
818         result = test.withDurationAdded(new Duration(123456789L), 2);
819         expected = new DateMidnight(test.getMillis() + (2L * 123456789L), BUDDHIST_DEFAULT);
820         assertEquals(expected, result);
821         
822         result = test.withDurationAdded(new Duration(123456789L), -3);
823         expected = new DateMidnight(test.getMillis() - (3L * 123456789L), BUDDHIST_DEFAULT);
824         assertEquals(expected, result);
825     }
826 
827     //-----------------------------------------------------------------------
828     public void testWithDurationAdded_RP_int() {
829         DateMidnight test = new DateMidnight(2002, 5, 3, BUDDHIST_DEFAULT);
830         DateMidnight result = test.withPeriodAdded(new Period(1, 2, 3, 4, 5, 6, 7, 8), 1);
831         DateMidnight expected = new DateMidnight(2003, 7, 28, BUDDHIST_DEFAULT);
832         assertEquals(expected, result);
833         
834         result = test.withPeriodAdded(null, 1);
835         assertSame(test, result);
836         
837         result = test.withPeriodAdded(new Period(1, 2, 3, 4, 5, 6, 7, 8), 0);
838         assertSame(test, result);
839         
840         result = test.withPeriodAdded(new Period(1, 2, 0, 4, 5, 6, 7, 8), 3);
841         expected = new DateMidnight(2005, 11, 15, BUDDHIST_DEFAULT);
842         assertEquals(expected, result);
843         
844         result = test.withPeriodAdded(new Period(1, 2, 0, 1, 1, 2, 3, 4), -1);
845         expected = new DateMidnight(2001, 3, 1, BUDDHIST_DEFAULT);
846         assertEquals(expected, result);
847     }
848 
849     //-----------------------------------------------------------------------    
850     public void testPlus_long() {
851         DateMidnight test = new DateMidnight(TEST_TIME1_UTC, BUDDHIST_DEFAULT);
852         DateMidnight result = test.plus(123456789L);
853         DateMidnight expected = new DateMidnight(test.getMillis() + 123456789L, BUDDHIST_DEFAULT);
854         assertEquals(expected, result);
855     }
856     
857     public void testPlus_RD() {
858         DateMidnight test = new DateMidnight(TEST_TIME1_UTC, BUDDHIST_DEFAULT);
859         DateMidnight result = test.plus(new Duration(123456789L));
860         DateMidnight expected = new DateMidnight(test.getMillis() + 123456789L, BUDDHIST_DEFAULT);
861         assertEquals(expected, result);
862         
863         result = test.plus((ReadableDuration) null);
864         assertSame(test, result);
865     }
866 
867     public void testPlus_RP() {
868         DateMidnight test = new DateMidnight(2002, 5, 3, BUDDHIST_DEFAULT);
869         DateMidnight result = test.plus(new Period(1, 2, 3, 4, 5, 6, 7, 8));
870         DateMidnight expected = new DateMidnight(2003, 7, 28, BUDDHIST_DEFAULT);
871         assertEquals(expected, result);
872         
873         result = test.plus((ReadablePeriod) null);
874         assertSame(test, result);
875     }
876 
877     public void testPlusYears_int() {
878         DateMidnight test = new DateMidnight(2002, 5, 3, BUDDHIST_DEFAULT);
879         DateMidnight result = test.plusYears(1);
880         DateMidnight expected = new DateMidnight(2003, 5, 3, BUDDHIST_DEFAULT);
881         assertEquals(expected, result);
882         
883         result = test.plusYears(0);
884         assertSame(test, result);
885     }
886 
887     public void testPlusMonths_int() {
888         DateMidnight test = new DateMidnight(2002, 5, 3, BUDDHIST_DEFAULT);
889         DateMidnight result = test.plusMonths(1);
890         DateMidnight expected = new DateMidnight(2002, 6, 3, BUDDHIST_DEFAULT);
891         assertEquals(expected, result);
892         
893         result = test.plusMonths(0);
894         assertSame(test, result);
895     }
896 
897     public void testPlusWeeks_int() {
898         DateMidnight test = new DateMidnight(2002, 5, 3, BUDDHIST_DEFAULT);
899         DateMidnight result = test.plusWeeks(1);
900         DateMidnight expected = new DateMidnight(2002, 5, 10, BUDDHIST_DEFAULT);
901         assertEquals(expected, result);
902         
903         result = test.plusWeeks(0);
904         assertSame(test, result);
905     }
906 
907     public void testPlusDays_int() {
908         DateMidnight test = new DateMidnight(2002, 5, 3, BUDDHIST_DEFAULT);
909         DateMidnight result = test.plusDays(1);
910         DateMidnight expected = new DateMidnight(2002, 5, 4, BUDDHIST_DEFAULT);
911         assertEquals(expected, result);
912         
913         result = test.plusDays(0);
914         assertSame(test, result);
915     }
916 
917     //-----------------------------------------------------------------------    
918     public void testMinus_long() {
919         DateMidnight test = new DateMidnight(TEST_TIME1_UTC, BUDDHIST_DEFAULT);
920         DateMidnight result = test.minus(123456789L);
921         DateMidnight expected = new DateMidnight(test.getMillis() - 123456789L, BUDDHIST_DEFAULT);
922         assertEquals(expected, result);
923     }
924 
925     public void testMinus_RD() {
926         DateMidnight test = new DateMidnight(TEST_TIME1_UTC, BUDDHIST_DEFAULT);
927         DateMidnight result = test.minus(new Duration(123456789L));
928         DateMidnight expected = new DateMidnight(test.getMillis() - 123456789L, BUDDHIST_DEFAULT);
929         assertEquals(expected, result);
930         
931         result = test.minus((ReadableDuration) null);
932         assertSame(test, result);
933     }
934 
935     public void testMinus_RP() {
936         DateMidnight test = new DateMidnight(2002, 5, 3, BUDDHIST_DEFAULT);
937         DateMidnight result = test.minus(new Period(1, 1, 1, 1, 1, 1, 1, 1));
938         DateMidnight expected = new DateMidnight(2001, 3, 25, BUDDHIST_DEFAULT);
939         assertEquals(expected, result);
940         
941         result = test.minus((ReadablePeriod) null);
942         assertSame(test, result);
943     }
944 
945     public void testMinusYears_int() {
946         DateMidnight test = new DateMidnight(2002, 5, 3, BUDDHIST_DEFAULT);
947         DateMidnight result = test.minusYears(1);
948         DateMidnight expected = new DateMidnight(2001, 5, 3, BUDDHIST_DEFAULT);
949         assertEquals(expected, result);
950         
951         result = test.minusYears(0);
952         assertSame(test, result);
953     }
954 
955     public void testMinusMonths_int() {
956         DateMidnight test = new DateMidnight(2002, 5, 3, BUDDHIST_DEFAULT);
957         DateMidnight result = test.minusMonths(1);
958         DateMidnight expected = new DateMidnight(2002, 4, 3, BUDDHIST_DEFAULT);
959         assertEquals(expected, result);
960         
961         result = test.minusMonths(0);
962         assertSame(test, result);
963     }
964 
965     public void testMinusWeeks_int() {
966         DateMidnight test = new DateMidnight(2002, 5, 3, BUDDHIST_DEFAULT);
967         DateMidnight result = test.minusWeeks(1);
968         DateMidnight expected = new DateMidnight(2002, 4, 26, BUDDHIST_DEFAULT);
969         assertEquals(expected, result);
970         
971         result = test.minusWeeks(0);
972         assertSame(test, result);
973     }
974 
975     public void testMinusDays_int() {
976         DateMidnight test = new DateMidnight(2002, 5, 3, BUDDHIST_DEFAULT);
977         DateMidnight result = test.minusDays(1);
978         DateMidnight expected = new DateMidnight(2002, 5, 2, BUDDHIST_DEFAULT);
979         assertEquals(expected, result);
980         
981         result = test.minusDays(0);
982         assertSame(test, result);
983     }
984 
985     //-----------------------------------------------------------------------
986     public void testProperty() {
987         DateMidnight test = new DateMidnight();
988         assertEquals(test.year(), test.property(DateTimeFieldType.year()));
989         assertEquals(test.dayOfWeek(), test.property(DateTimeFieldType.dayOfWeek()));
990         assertEquals(test.weekOfWeekyear(), test.property(DateTimeFieldType.weekOfWeekyear()));
991         assertEquals(test.property(DateTimeFieldType.millisOfSecond()), test.property(DateTimeFieldType.millisOfSecond()));
992         DateTimeFieldType bad = new DateTimeFieldType("bad") {
993             public DurationFieldType getDurationType() {
994                 return DurationFieldType.weeks();
995             }
996             public DurationFieldType getRangeDurationType() {
997                 return null;
998             }
999             public DateTimeField getField(Chronology chronology) {
1000                 return UnsupportedDateTimeField.getInstance(this, UnsupportedDurationField.getInstance(getDurationType()));
1001             }
1002         };
1003         try {
1004             test.property(bad);
1005             fail();
1006         } catch (IllegalArgumentException ex) {}
1007         try {
1008             test.property(null);
1009             fail();
1010         } catch (IllegalArgumentException ex) {}
1011     }
1012 
1013     //-----------------------------------------------------------------------
1014     private void check(DateMidnight test, int year, int month, int day) {
1015         assertEquals(year, test.getYear());
1016         assertEquals(month, test.getMonthOfYear());
1017         assertEquals(day, test.getDayOfMonth());
1018     }
1019 
1020 }