View Javadoc

1   /*
2    *  Copyright 2001-2005 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.util.Locale;
19  
20  import junit.framework.TestCase;
21  import junit.framework.TestSuite;
22  
23  import org.joda.time.chrono.CopticChronology;
24  import org.joda.time.chrono.LenientChronology;
25  import org.joda.time.chrono.StrictChronology;
26  
27  /**
28   * This class is a Junit unit test for DateTime.
29   *
30   * @author Stephen Colebourne
31   * @author Mike Schrag
32   */
33  public class TestDateMidnight_Properties extends TestCase {
34      // Test in 2002/03 as time zones are more well known
35      // (before the late 90's they were all over the place)
36  
37      private static final DateTimeZone PARIS = DateTimeZone.forID("Europe/Paris");
38      private static final Chronology COPTIC_PARIS = CopticChronology.getInstance(PARIS);
39  
40      //private static final DateTimeZone PARIS = DateTimeZone.forID("Europe/Paris");
41      private static final DateTimeZone LONDON = DateTimeZone.forID("Europe/London");
42      
43      long y2002days = 365 + 365 + 366 + 365 + 365 + 365 + 366 + 365 + 365 + 365 + 
44                       366 + 365 + 365 + 365 + 366 + 365 + 365 + 365 + 366 + 365 + 
45                       365 + 365 + 366 + 365 + 365 + 365 + 366 + 365 + 365 + 365 +
46                       366 + 365;
47      long y2003days = 365 + 365 + 366 + 365 + 365 + 365 + 366 + 365 + 365 + 365 + 
48                       366 + 365 + 365 + 365 + 366 + 365 + 365 + 365 + 366 + 365 + 
49                       365 + 365 + 366 + 365 + 365 + 365 + 366 + 365 + 365 + 365 +
50                       366 + 365 + 365;
51      
52      // 2002-06-09
53      private long TEST_TIME_NOW =
54              (y2002days + 31L + 28L + 31L + 30L + 31L + 9L -1L) * DateTimeConstants.MILLIS_PER_DAY;
55              
56      // 2002-04-05 Fri
57      private long TEST_TIME1 =
58              (y2002days + 31L + 28L + 31L + 5L -1L) * DateTimeConstants.MILLIS_PER_DAY
59              + 12L * DateTimeConstants.MILLIS_PER_HOUR
60              + 24L * DateTimeConstants.MILLIS_PER_MINUTE;
61          
62      // 2003-05-06 Tue
63      private long TEST_TIME2 =
64              (y2003days + 31L + 28L + 31L + 30L + 6L -1L) * DateTimeConstants.MILLIS_PER_DAY
65              + 14L * DateTimeConstants.MILLIS_PER_HOUR
66              + 28L * DateTimeConstants.MILLIS_PER_MINUTE;
67          
68      private DateTimeZone zone = null;
69      private Locale locale = null;
70  
71      public static void main(String[] args) {
72          junit.textui.TestRunner.run(suite());
73      }
74  
75      public static TestSuite suite() {
76          return new TestSuite(TestDateMidnight_Properties.class);
77      }
78  
79      public TestDateMidnight_Properties(String name) {
80          super(name);
81      }
82  
83      protected void setUp() throws Exception {
84          DateTimeUtils.setCurrentMillisFixed(TEST_TIME_NOW);
85          zone = DateTimeZone.getDefault();
86          locale = Locale.getDefault();
87          DateTimeZone.setDefault(LONDON);
88          Locale.setDefault(Locale.UK);
89      }
90  
91      protected void tearDown() throws Exception {
92          DateTimeUtils.setCurrentMillisSystem();
93          DateTimeZone.setDefault(zone);
94          Locale.setDefault(locale);
95          zone = null;
96      }
97  
98      //-----------------------------------------------------------------------
99      public void testTest() {
100         assertEquals("2002-06-09T00:00:00.000Z", new Instant(TEST_TIME_NOW).toString());
101         assertEquals("2002-04-05T12:24:00.000Z", new Instant(TEST_TIME1).toString());
102         assertEquals("2003-05-06T14:28:00.000Z", new Instant(TEST_TIME2).toString());
103     }
104 
105     //-----------------------------------------------------------------------
106     public void testPropertyGetEra() {
107         DateMidnight test = new DateMidnight(2004, 6, 9);
108         assertSame(test.getChronology().era(), test.era().getField());
109         assertEquals("era", test.era().getName());
110         assertEquals("Property[era]", test.era().toString());
111         assertSame(test, test.era().getDateMidnight());
112         assertEquals(1, test.era().get());
113         assertEquals("AD", test.era().getAsText());
114         assertEquals("ap. J.-C.", test.era().getAsText(Locale.FRENCH));
115         assertEquals("AD", test.era().getAsShortText());
116         assertEquals("ap. J.-C.", test.era().getAsShortText(Locale.FRENCH));
117         assertEquals(test.getChronology().eras(), test.era().getDurationField());
118         assertEquals(null, test.era().getRangeDurationField());
119         assertEquals(2, test.era().getMaximumTextLength(null));
120         assertEquals(9, test.era().getMaximumTextLength(Locale.FRENCH));
121         assertEquals(2, test.era().getMaximumShortTextLength(null));
122         assertEquals(9, test.era().getMaximumShortTextLength(Locale.FRENCH));
123     }
124 
125     //-----------------------------------------------------------------------
126     public void testPropertyGetYearOfEra() {
127         DateMidnight test = new DateMidnight(2004, 6, 9);
128         assertSame(test.getChronology().yearOfEra(), test.yearOfEra().getField());
129         assertEquals("yearOfEra", test.yearOfEra().getName());
130         assertEquals("Property[yearOfEra]", test.yearOfEra().toString());
131         assertSame(test, test.yearOfEra().getDateMidnight());
132         assertEquals(2004, test.yearOfEra().get());
133         assertEquals("2004", test.yearOfEra().getAsText());
134         assertEquals("2004", test.yearOfEra().getAsText(Locale.FRENCH));
135         assertEquals("2004", test.yearOfEra().getAsShortText());
136         assertEquals("2004", test.yearOfEra().getAsShortText(Locale.FRENCH));
137         assertEquals(test.getChronology().years(), test.yearOfEra().getDurationField());
138         assertEquals(null, test.yearOfEra().getRangeDurationField());
139         assertEquals(9, test.yearOfEra().getMaximumTextLength(null));
140         assertEquals(9, test.yearOfEra().getMaximumShortTextLength(null));
141     }
142 
143     //-----------------------------------------------------------------------
144     public void testPropertyGetCenturyOfEra() {
145         DateMidnight test = new DateMidnight(2004, 6, 9);
146         assertSame(test.getChronology().centuryOfEra(), test.centuryOfEra().getField());
147         assertEquals("centuryOfEra", test.centuryOfEra().getName());
148         assertEquals("Property[centuryOfEra]", test.centuryOfEra().toString());
149         assertSame(test, test.centuryOfEra().getDateMidnight());
150         assertEquals(20, test.centuryOfEra().get());
151         assertEquals("20", test.centuryOfEra().getAsText());
152         assertEquals("20", test.centuryOfEra().getAsText(Locale.FRENCH));
153         assertEquals("20", test.centuryOfEra().getAsShortText());
154         assertEquals("20", test.centuryOfEra().getAsShortText(Locale.FRENCH));
155         assertEquals(test.getChronology().centuries(), test.centuryOfEra().getDurationField());
156         assertEquals(null, test.centuryOfEra().getRangeDurationField());
157         assertEquals(7, test.centuryOfEra().getMaximumTextLength(null));
158         assertEquals(7, test.centuryOfEra().getMaximumShortTextLength(null));
159     }
160 
161     //-----------------------------------------------------------------------
162     public void testPropertyGetYearOfCentury() {
163         DateMidnight test = new DateMidnight(2004, 6, 9);
164         assertSame(test.getChronology().yearOfCentury(), test.yearOfCentury().getField());
165         assertEquals("yearOfCentury", test.yearOfCentury().getName());
166         assertEquals("Property[yearOfCentury]", test.yearOfCentury().toString());
167         assertSame(test, test.yearOfCentury().getDateMidnight());
168         assertEquals(4, test.yearOfCentury().get());
169         assertEquals("4", test.yearOfCentury().getAsText());
170         assertEquals("4", test.yearOfCentury().getAsText(Locale.FRENCH));
171         assertEquals("4", test.yearOfCentury().getAsShortText());
172         assertEquals("4", test.yearOfCentury().getAsShortText(Locale.FRENCH));
173         assertEquals(test.getChronology().years(), test.yearOfCentury().getDurationField());
174         assertEquals(test.getChronology().centuries(), test.yearOfCentury().getRangeDurationField());
175         assertEquals(2, test.yearOfCentury().getMaximumTextLength(null));
176         assertEquals(2, test.yearOfCentury().getMaximumShortTextLength(null));
177     }
178 
179     //-----------------------------------------------------------------------
180     public void testPropertyGetWeekyear() {
181         DateMidnight test = new DateMidnight(2004, 6, 9);
182         assertSame(test.getChronology().weekyear(), test.weekyear().getField());
183         assertEquals("weekyear", test.weekyear().getName());
184         assertEquals("Property[weekyear]", test.weekyear().toString());
185         assertSame(test, test.weekyear().getDateMidnight());
186         assertEquals(2004, test.weekyear().get());
187         assertEquals("2004", test.weekyear().getAsText());
188         assertEquals("2004", test.weekyear().getAsText(Locale.FRENCH));
189         assertEquals("2004", test.weekyear().getAsShortText());
190         assertEquals("2004", test.weekyear().getAsShortText(Locale.FRENCH));
191         assertEquals(test.getChronology().weekyears(), test.weekyear().getDurationField());
192         assertEquals(null, test.weekyear().getRangeDurationField());
193         assertEquals(9, test.weekyear().getMaximumTextLength(null));
194         assertEquals(9, test.weekyear().getMaximumShortTextLength(null));
195     }
196 
197     //-----------------------------------------------------------------------
198     public void testPropertyGetYear() {
199         DateMidnight test = new DateMidnight(2004, 6, 9);
200         assertSame(test.getChronology().year(), test.year().getField());
201         assertEquals("year", test.year().getName());
202         assertEquals("Property[year]", test.year().toString());
203         assertSame(test, test.year().getDateMidnight());
204         assertEquals(2004, test.year().get());
205         assertEquals("2004", test.year().getAsText());
206         assertEquals("2004", test.year().getAsText(Locale.FRENCH));
207         assertEquals("2004", test.year().getAsShortText());
208         assertEquals("2004", test.year().getAsShortText(Locale.FRENCH));
209         assertEquals(test.getChronology().years(), test.year().getDurationField());
210         assertEquals(null, test.year().getRangeDurationField());
211         assertEquals(9, test.year().getMaximumTextLength(null));
212         assertEquals(9, test.year().getMaximumShortTextLength(null));
213         assertEquals(-292275054, test.year().getMinimumValue());
214         assertEquals(-292275054, test.year().getMinimumValueOverall());
215         assertEquals(292278993, test.year().getMaximumValue());
216         assertEquals(292278993, test.year().getMaximumValueOverall());
217     }
218 
219     //-----------------------------------------------------------------------
220     public void testPropertyGetMonthOfYear() {
221         DateMidnight test = new DateMidnight(2004, 6, 9);
222         assertSame(test.getChronology().monthOfYear(), test.monthOfYear().getField());
223         assertEquals("monthOfYear", test.monthOfYear().getName());
224         assertEquals("Property[monthOfYear]", test.monthOfYear().toString());
225         assertSame(test, test.monthOfYear().getDateMidnight());
226         assertEquals(6, test.monthOfYear().get());
227         assertEquals("6", test.monthOfYear().getAsString());
228         assertEquals("June", test.monthOfYear().getAsText());
229         assertEquals("juin", test.monthOfYear().getAsText(Locale.FRENCH));
230         assertEquals("Jun", test.monthOfYear().getAsShortText());
231         assertEquals("juin", test.monthOfYear().getAsShortText(Locale.FRENCH));
232         assertEquals(test.getChronology().months(), test.monthOfYear().getDurationField());
233         assertEquals(test.getChronology().years(), test.monthOfYear().getRangeDurationField());
234         assertEquals(9, test.monthOfYear().getMaximumTextLength(null));
235         assertEquals(3, test.monthOfYear().getMaximumShortTextLength(null));
236         test = new DateMidnight(2004, 7, 9);
237         assertEquals("juillet", test.monthOfYear().getAsText(Locale.FRENCH));
238         assertEquals("juil.", test.monthOfYear().getAsShortText(Locale.FRENCH));
239         assertEquals(1, test.monthOfYear().getMinimumValue());
240         assertEquals(1, test.monthOfYear().getMinimumValueOverall());
241         assertEquals(12, test.monthOfYear().getMaximumValue());
242         assertEquals(12, test.monthOfYear().getMaximumValueOverall());
243         assertEquals(1, test.monthOfYear().getMinimumValue());
244         assertEquals(1, test.monthOfYear().getMinimumValueOverall());
245         assertEquals(12, test.monthOfYear().getMaximumValue());
246         assertEquals(12, test.monthOfYear().getMaximumValueOverall());
247     }
248 
249     public void testPropertySetMonthOfYear() {
250         DateMidnight test = new DateMidnight(2004, 6, 9);
251         DateMidnight copy = test.monthOfYear().setCopy(8);
252         assertEquals(2004, copy.getYear());
253         assertEquals(8, copy.getMonthOfYear());
254         assertEquals(9, copy.getDayOfMonth());
255     }
256 
257     public void testPropertySetTextMonthOfYear() {
258         DateMidnight test = new DateMidnight(2004, 6, 9);
259         DateMidnight copy = test.monthOfYear().setCopy("8");
260         assertEquals(2004, copy.getYear());
261         assertEquals(8, copy.getMonthOfYear());
262         assertEquals(9, copy.getDayOfMonth());
263     }
264 
265     public void testPropertySetTextLocaleMonthOfYear() {
266         DateMidnight test = new DateMidnight(2004, 6, 9);
267         DateMidnight copy = test.monthOfYear().setCopy("mars", Locale.FRENCH);
268         assertEquals(2004, copy.getYear());
269         assertEquals(3, copy.getMonthOfYear());
270         assertEquals(9, copy.getDayOfMonth());
271     }
272 
273     public void testPropertyAddMonthOfYear() {
274         DateMidnight test = new DateMidnight(2004, 6, 9);
275         DateMidnight copy = test.monthOfYear().addToCopy(8);
276         assertEquals(2005, copy.getYear());
277         assertEquals(2, copy.getMonthOfYear());
278         assertEquals(9, copy.getDayOfMonth());
279     }
280 
281     public void testPropertyAddLongMonthOfYear() {
282         DateMidnight test = new DateMidnight(2004, 6, 9);
283         DateMidnight copy = test.monthOfYear().addToCopy(8L);
284         assertEquals(2005, copy.getYear());
285         assertEquals(2, copy.getMonthOfYear());
286         assertEquals(9, copy.getDayOfMonth());
287     }
288 
289     public void testPropertyAddWrapFieldMonthOfYear() {
290         DateMidnight test = new DateMidnight(2004, 6, 9);
291         DateMidnight copy = test.monthOfYear().addWrapFieldToCopy(8);
292         assertEquals(2004, copy.getYear());
293         assertEquals(2, copy.getMonthOfYear());
294         assertEquals(9, copy.getDayOfMonth());
295     }
296 
297     public void testPropertyGetDifferenceMonthOfYear() {
298         DateMidnight test1 = new DateMidnight(2004, 6, 9);
299         DateMidnight test2 = new DateMidnight(2004, 8, 9);
300         assertEquals(-2, test1.monthOfYear().getDifference(test2));
301         assertEquals(2, test2.monthOfYear().getDifference(test1));
302         assertEquals(-2L, test1.monthOfYear().getDifferenceAsLong(test2));
303         assertEquals(2L, test2.monthOfYear().getDifferenceAsLong(test1));
304     }
305 
306     public void testPropertyRoundFloorMonthOfYear() {
307         DateMidnight test = new DateMidnight(2004, 6, 16);
308         DateMidnight copy = test.monthOfYear().roundFloorCopy();
309         assertEquals("2004-06-01T00:00:00.000+01:00", copy.toString());
310     }
311 
312     public void testPropertyRoundCeilingMonthOfYear() {
313         DateMidnight test = new DateMidnight(2004, 6, 16);
314         DateMidnight copy = test.monthOfYear().roundCeilingCopy();
315         assertEquals("2004-07-01T00:00:00.000+01:00", copy.toString());
316     }
317 
318     public void testPropertyRoundHalfFloorMonthOfYear() {
319         DateMidnight test = new DateMidnight(2004, 6, 16);
320         DateMidnight copy = test.monthOfYear().roundHalfFloorCopy();
321         assertEquals("2004-06-01T00:00:00.000+01:00", copy.toString());
322         
323         test = new DateMidnight(2004, 6, 17);
324         copy = test.monthOfYear().roundHalfFloorCopy();
325         assertEquals("2004-07-01T00:00:00.000+01:00", copy.toString());
326         
327         test = new DateMidnight(2004, 6, 15);
328         copy = test.monthOfYear().roundHalfFloorCopy();
329         assertEquals("2004-06-01T00:00:00.000+01:00", copy.toString());
330     }
331 
332     public void testPropertyRoundHalfCeilingMonthOfYear() {
333         DateMidnight test = new DateMidnight(2004, 6, 16);
334         DateMidnight copy = test.monthOfYear().roundHalfCeilingCopy();
335         assertEquals("2004-07-01T00:00:00.000+01:00", copy.toString());
336         
337         test = new DateMidnight(2004, 6, 17);
338         copy = test.monthOfYear().roundHalfCeilingCopy();
339         assertEquals("2004-07-01T00:00:00.000+01:00", copy.toString());
340         
341         test = new DateMidnight(2004, 6, 15);
342         copy = test.monthOfYear().roundHalfCeilingCopy();
343         assertEquals("2004-06-01T00:00:00.000+01:00", copy.toString());
344     }
345 
346     public void testPropertyRoundHalfEvenMonthOfYear() {
347         DateMidnight test = new DateMidnight(2004, 6, 16);
348         DateMidnight copy = test.monthOfYear().roundHalfEvenCopy();
349         assertEquals("2004-06-01T00:00:00.000+01:00", copy.toString());
350         
351         test = new DateMidnight(2004, 9, 16);
352         copy = test.monthOfYear().roundHalfEvenCopy();
353         assertEquals("2004-10-01T00:00:00.000+01:00", copy.toString());
354         
355         test = new DateMidnight(2004, 6, 17);
356         copy = test.monthOfYear().roundHalfEvenCopy();
357         assertEquals("2004-07-01T00:00:00.000+01:00", copy.toString());
358         
359         test = new DateMidnight(2004, 6, 15);
360         copy = test.monthOfYear().roundHalfEvenCopy();
361         assertEquals("2004-06-01T00:00:00.000+01:00", copy.toString());
362     }
363 
364     public void testPropertyRemainderMonthOfYear() {
365         DateMidnight test = new DateMidnight(2004, 6, 9);
366         assertEquals((9L - 1L) * DateTimeConstants.MILLIS_PER_DAY, test.monthOfYear().remainder());
367     }
368 
369     //-----------------------------------------------------------------------
370     public void testPropertyGetDayOfMonth() {
371         DateMidnight test = new DateMidnight(2004, 6, 9);
372         assertSame(test.getChronology().dayOfMonth(), test.dayOfMonth().getField());
373         assertEquals("dayOfMonth", test.dayOfMonth().getName());
374         assertEquals("Property[dayOfMonth]", test.dayOfMonth().toString());
375         assertSame(test, test.dayOfMonth().getDateMidnight());
376         assertEquals(9, test.dayOfMonth().get());
377         assertEquals("9", test.dayOfMonth().getAsText());
378         assertEquals("9", test.dayOfMonth().getAsText(Locale.FRENCH));
379         assertEquals("9", test.dayOfMonth().getAsShortText());
380         assertEquals("9", test.dayOfMonth().getAsShortText(Locale.FRENCH));
381         assertEquals(test.getChronology().days(), test.dayOfMonth().getDurationField());
382         assertEquals(test.getChronology().months(), test.dayOfMonth().getRangeDurationField());
383         assertEquals(2, test.dayOfMonth().getMaximumTextLength(null));
384         assertEquals(2, test.dayOfMonth().getMaximumShortTextLength(null));
385         assertEquals(1, test.dayOfMonth().getMinimumValue());
386         assertEquals(1, test.dayOfMonth().getMinimumValueOverall());
387         assertEquals(30, test.dayOfMonth().getMaximumValue());
388         assertEquals(31, test.dayOfMonth().getMaximumValueOverall());
389         assertEquals(false, test.dayOfMonth().isLeap());
390         assertEquals(0, test.dayOfMonth().getLeapAmount());
391         assertEquals(null, test.dayOfMonth().getLeapDurationField());
392     }
393 
394     public void testPropertyWithMaximumValueDayOfMonth() {
395         DateMidnight test = new DateMidnight(2004, 6, 9);
396         DateMidnight copy = test.dayOfMonth().withMaximumValue();
397         assertEquals("2004-06-09T00:00:00.000+01:00", test.toString());
398         assertEquals("2004-06-30T00:00:00.000+01:00", copy.toString());
399     }
400 
401     public void testPropertyWithMinimumValueDayOfMonth() {
402         DateMidnight test = new DateMidnight(2004, 6, 9);
403         DateMidnight copy = test.dayOfMonth().withMinimumValue();
404         assertEquals("2004-06-09T00:00:00.000+01:00", test.toString());
405         assertEquals("2004-06-01T00:00:00.000+01:00", copy.toString());
406     }
407 
408     //-----------------------------------------------------------------------
409     public void testPropertyGetDayOfYear() {
410         // 31+29+31+30+31+9 = 161
411         DateMidnight test = new DateMidnight(2004, 6, 9);
412         assertSame(test.getChronology().dayOfYear(), test.dayOfYear().getField());
413         assertEquals("dayOfYear", test.dayOfYear().getName());
414         assertEquals("Property[dayOfYear]", test.dayOfYear().toString());
415         assertSame(test, test.dayOfYear().getDateMidnight());
416         assertEquals(161, test.dayOfYear().get());
417         assertEquals("161", test.dayOfYear().getAsText());
418         assertEquals("161", test.dayOfYear().getAsText(Locale.FRENCH));
419         assertEquals("161", test.dayOfYear().getAsShortText());
420         assertEquals("161", test.dayOfYear().getAsShortText(Locale.FRENCH));
421         assertEquals(test.getChronology().days(), test.dayOfYear().getDurationField());
422         assertEquals(test.getChronology().years(), test.dayOfYear().getRangeDurationField());
423         assertEquals(3, test.dayOfYear().getMaximumTextLength(null));
424         assertEquals(3, test.dayOfYear().getMaximumShortTextLength(null));
425         assertEquals(false, test.dayOfYear().isLeap());
426         assertEquals(0, test.dayOfYear().getLeapAmount());
427         assertEquals(null, test.dayOfYear().getLeapDurationField());
428     }
429 
430     //-----------------------------------------------------------------------
431     public void testPropertyGetWeekOfWeekyear() {
432         DateMidnight test = new DateMidnight(2004, 6, 9);
433         assertSame(test.getChronology().weekOfWeekyear(), test.weekOfWeekyear().getField());
434         assertEquals("weekOfWeekyear", test.weekOfWeekyear().getName());
435         assertEquals("Property[weekOfWeekyear]", test.weekOfWeekyear().toString());
436         assertSame(test, test.weekOfWeekyear().getDateMidnight());
437         assertEquals(24, test.weekOfWeekyear().get());
438         assertEquals("24", test.weekOfWeekyear().getAsText());
439         assertEquals("24", test.weekOfWeekyear().getAsText(Locale.FRENCH));
440         assertEquals("24", test.weekOfWeekyear().getAsShortText());
441         assertEquals("24", test.weekOfWeekyear().getAsShortText(Locale.FRENCH));
442         assertEquals(test.getChronology().weeks(), test.weekOfWeekyear().getDurationField());
443         assertEquals(test.getChronology().weekyears(), test.weekOfWeekyear().getRangeDurationField());
444         assertEquals(2, test.weekOfWeekyear().getMaximumTextLength(null));
445         assertEquals(2, test.weekOfWeekyear().getMaximumShortTextLength(null));
446         assertEquals(false, test.weekOfWeekyear().isLeap());
447         assertEquals(0, test.weekOfWeekyear().getLeapAmount());
448         assertEquals(null, test.weekOfWeekyear().getLeapDurationField());
449     }
450 
451     //-----------------------------------------------------------------------
452     public void testPropertyGetDayOfWeek() {
453         DateMidnight test = new DateMidnight(2004, 6, 9);
454         assertSame(test.getChronology().dayOfWeek(), test.dayOfWeek().getField());
455         assertEquals("dayOfWeek", test.dayOfWeek().getName());
456         assertEquals("Property[dayOfWeek]", test.dayOfWeek().toString());
457         assertSame(test, test.dayOfWeek().getDateMidnight());
458         assertEquals(3, test.dayOfWeek().get());
459         assertEquals("3", test.dayOfWeek().getAsString());
460         assertEquals("Wednesday", test.dayOfWeek().getAsText());
461         assertEquals("mercredi", test.dayOfWeek().getAsText(Locale.FRENCH));
462         assertEquals("Wed", test.dayOfWeek().getAsShortText());
463         assertEquals("mer.", test.dayOfWeek().getAsShortText(Locale.FRENCH));
464         assertEquals(test.getChronology().days(), test.dayOfWeek().getDurationField());
465         assertEquals(test.getChronology().weeks(), test.dayOfWeek().getRangeDurationField());
466         assertEquals(9, test.dayOfWeek().getMaximumTextLength(null));
467         assertEquals(8, test.dayOfWeek().getMaximumTextLength(Locale.FRENCH));
468         assertEquals(3, test.dayOfWeek().getMaximumShortTextLength(null));
469         assertEquals(4, test.dayOfWeek().getMaximumShortTextLength(Locale.FRENCH));
470         assertEquals(1, test.dayOfWeek().getMinimumValue());
471         assertEquals(1, test.dayOfWeek().getMinimumValueOverall());
472         assertEquals(7, test.dayOfWeek().getMaximumValue());
473         assertEquals(7, test.dayOfWeek().getMaximumValueOverall());
474         assertEquals(false, test.dayOfWeek().isLeap());
475         assertEquals(0, test.dayOfWeek().getLeapAmount());
476         assertEquals(null, test.dayOfWeek().getLeapDurationField());
477     }
478 
479     //-----------------------------------------------------------------------
480     public void testPropertyToIntervalYearOfEra() {
481       DateMidnight test = new DateMidnight(2004, 6, 9);
482       Interval testInterval = test.yearOfEra().toInterval();
483       assertEquals(new DateMidnight(2004, 1, 1), testInterval.getStart());
484       assertEquals(new DateMidnight(2005, 1, 1), testInterval.getEnd());
485     }
486 
487     public void testPropertyToIntervalYearOfCentury() {
488       DateMidnight test = new DateMidnight(2004, 6, 9);
489       Interval testInterval = test.yearOfCentury().toInterval();
490       assertEquals(new DateMidnight(2004, 1, 1), testInterval.getStart());
491       assertEquals(new DateMidnight(2005, 1, 1), testInterval.getEnd());
492     }
493 
494     public void testPropertyToIntervalYear() {
495       DateMidnight test = new DateMidnight(2004, 6, 9);
496       Interval testInterval = test.year().toInterval();
497       assertEquals(new DateMidnight(2004, 1, 1), testInterval.getStart());
498       assertEquals(new DateMidnight(2005, 1, 1), testInterval.getEnd());
499     }
500 
501     public void testPropertyToIntervalMonthOfYear() {
502       DateMidnight test = new DateMidnight(2004, 6, 9);
503       Interval testInterval = test.monthOfYear().toInterval();
504       assertEquals(new DateMidnight(2004, 6, 1), testInterval.getStart());
505       assertEquals(new DateMidnight(2004, 7, 1), testInterval.getEnd());
506     }
507 
508     public void testPropertyToIntervalDayOfMonth() {
509       DateMidnight test = new DateMidnight(2004, 6, 9);
510       Interval testInterval = test.dayOfMonth().toInterval();
511       assertEquals(new DateMidnight(2004, 6, 9), testInterval.getStart());
512       assertEquals(new DateMidnight(2004, 6, 10), testInterval.getEnd());
513 
514       DateMidnight febTest = new DateMidnight(2004, 2, 29);
515       Interval febTestInterval = febTest.dayOfMonth().toInterval();
516       assertEquals(new DateMidnight(2004, 2, 29), febTestInterval.getStart());
517       assertEquals(new DateMidnight(2004, 3, 1), febTestInterval.getEnd());
518     }
519 
520     public void testPropertyEqualsHashCodeLenient() {
521         DateMidnight test1 = new DateMidnight(1970, 6, 9, LenientChronology.getInstance(COPTIC_PARIS));
522         DateMidnight test2 = new DateMidnight(1970, 6, 9, LenientChronology.getInstance(COPTIC_PARIS));
523         assertEquals(true, test1.dayOfMonth().equals(test2.dayOfMonth()));
524         assertEquals(true, test2.dayOfMonth().equals(test1.dayOfMonth()));
525         assertEquals(true, test1.dayOfMonth().equals(test1.dayOfMonth()));
526         assertEquals(true, test2.dayOfMonth().equals(test2.dayOfMonth()));
527         assertEquals(true, test1.dayOfMonth().hashCode() == test2.dayOfMonth().hashCode());
528         assertEquals(true, test1.dayOfMonth().hashCode() == test1.dayOfMonth().hashCode());
529         assertEquals(true, test2.dayOfMonth().hashCode() == test2.dayOfMonth().hashCode());
530     }
531 
532     public void testPropertyEqualsHashCodeStrict() {
533         DateMidnight test1 = new DateMidnight(1970, 6, 9, StrictChronology.getInstance(COPTIC_PARIS));
534         DateMidnight test2 = new DateMidnight(1970, 6, 9, StrictChronology.getInstance(COPTIC_PARIS));
535         assertEquals(true, test1.dayOfMonth().equals(test2.dayOfMonth()));
536         assertEquals(true, test2.dayOfMonth().equals(test1.dayOfMonth()));
537         assertEquals(true, test1.dayOfMonth().equals(test1.dayOfMonth()));
538         assertEquals(true, test2.dayOfMonth().equals(test2.dayOfMonth()));
539         assertEquals(true, test1.dayOfMonth().hashCode() == test2.dayOfMonth().hashCode());
540         assertEquals(true, test1.dayOfMonth().hashCode() == test1.dayOfMonth().hashCode());
541         assertEquals(true, test2.dayOfMonth().hashCode() == test2.dayOfMonth().hashCode());
542     }
543 
544 }