001 /*
002 * Copyright 2001-2005 Stephen Colebourne
003 *
004 * Licensed under the Apache License, Version 2.0 (the "License");
005 * you may not use this file except in compliance with the License.
006 * You may obtain a copy of the License at
007 *
008 * http://www.apache.org/licenses/LICENSE-2.0
009 *
010 * Unless required by applicable law or agreed to in writing, software
011 * distributed under the License is distributed on an "AS IS" BASIS,
012 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
013 * See the License for the specific language governing permissions and
014 * limitations under the License.
015 */
016 package org.joda.time;
017
018 import java.util.Locale;
019
020 import junit.framework.TestCase;
021 import junit.framework.TestSuite;
022
023 import org.joda.time.chrono.CopticChronology;
024 import org.joda.time.chrono.LenientChronology;
025 import org.joda.time.chrono.StrictChronology;
026
027 /**
028 * This class is a Junit unit test for DateTime.
029 *
030 * @author Stephen Colebourne
031 * @author Mike Schrag
032 */
033 public class TestDateMidnight_Properties extends TestCase {
034 // Test in 2002/03 as time zones are more well known
035 // (before the late 90's they were all over the place)
036
037 private static final DateTimeZone PARIS = DateTimeZone.forID("Europe/Paris");
038 private static final Chronology COPTIC_PARIS = CopticChronology.getInstance(PARIS);
039
040 //private static final DateTimeZone PARIS = DateTimeZone.forID("Europe/Paris");
041 private static final DateTimeZone LONDON = DateTimeZone.forID("Europe/London");
042
043 long y2002days = 365 + 365 + 366 + 365 + 365 + 365 + 366 + 365 + 365 + 365 +
044 366 + 365 + 365 + 365 + 366 + 365 + 365 + 365 + 366 + 365 +
045 365 + 365 + 366 + 365 + 365 + 365 + 366 + 365 + 365 + 365 +
046 366 + 365;
047 long y2003days = 365 + 365 + 366 + 365 + 365 + 365 + 366 + 365 + 365 + 365 +
048 366 + 365 + 365 + 365 + 366 + 365 + 365 + 365 + 366 + 365 +
049 365 + 365 + 366 + 365 + 365 + 365 + 366 + 365 + 365 + 365 +
050 366 + 365 + 365;
051
052 // 2002-06-09
053 private long TEST_TIME_NOW =
054 (y2002days + 31L + 28L + 31L + 30L + 31L + 9L -1L) * DateTimeConstants.MILLIS_PER_DAY;
055
056 // 2002-04-05 Fri
057 private long TEST_TIME1 =
058 (y2002days + 31L + 28L + 31L + 5L -1L) * DateTimeConstants.MILLIS_PER_DAY
059 + 12L * DateTimeConstants.MILLIS_PER_HOUR
060 + 24L * DateTimeConstants.MILLIS_PER_MINUTE;
061
062 // 2003-05-06 Tue
063 private long TEST_TIME2 =
064 (y2003days + 31L + 28L + 31L + 30L + 6L -1L) * DateTimeConstants.MILLIS_PER_DAY
065 + 14L * DateTimeConstants.MILLIS_PER_HOUR
066 + 28L * DateTimeConstants.MILLIS_PER_MINUTE;
067
068 private DateTimeZone zone = null;
069 private Locale locale = null;
070
071 public static void main(String[] args) {
072 junit.textui.TestRunner.run(suite());
073 }
074
075 public static TestSuite suite() {
076 return new TestSuite(TestDateMidnight_Properties.class);
077 }
078
079 public TestDateMidnight_Properties(String name) {
080 super(name);
081 }
082
083 protected void setUp() throws Exception {
084 DateTimeUtils.setCurrentMillisFixed(TEST_TIME_NOW);
085 zone = DateTimeZone.getDefault();
086 locale = Locale.getDefault();
087 DateTimeZone.setDefault(LONDON);
088 Locale.setDefault(Locale.UK);
089 }
090
091 protected void tearDown() throws Exception {
092 DateTimeUtils.setCurrentMillisSystem();
093 DateTimeZone.setDefault(zone);
094 Locale.setDefault(locale);
095 zone = null;
096 }
097
098 //-----------------------------------------------------------------------
099 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 }