001 /*
002 * Copyright 2001-2013 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 TestDateTime_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(TestDateTime_Properties.class);
077 }
078
079 public TestDateTime_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 DateTime test = new DateTime(2004, 6, 9, 0, 0, 0, 0);
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().getDateTime());
112 assertEquals(1, test.era().get());
113 assertEquals("1", test.era().getAsString());
114 assertEquals("AD", test.era().getAsText());
115 assertEquals("AD", test.era().getField().getAsText(1, Locale.ENGLISH));
116 assertEquals("ap. J.-C.", test.era().getAsText(Locale.FRENCH));
117 assertEquals("ap. J.-C.", test.era().getField().getAsText(1, Locale.FRENCH));
118 assertEquals("AD", test.era().getAsShortText());
119 assertEquals("AD", test.era().getField().getAsShortText(1, Locale.ENGLISH));
120 assertEquals("ap. J.-C.", test.era().getAsShortText(Locale.FRENCH));
121 assertEquals("ap. J.-C.", test.era().getField().getAsShortText(1, Locale.FRENCH));
122 assertEquals(test.getChronology().eras(), test.era().getDurationField());
123 assertEquals(null, test.era().getRangeDurationField());
124 assertEquals(2, test.era().getMaximumTextLength(null));
125 assertEquals(9, test.era().getMaximumTextLength(Locale.FRENCH));
126 assertEquals(2, test.era().getMaximumShortTextLength(null));
127 assertEquals(9, test.era().getMaximumShortTextLength(Locale.FRENCH));
128 }
129
130 //-----------------------------------------------------------------------
131 public void testPropertyGetYearOfEra() {
132 DateTime test = new DateTime(2004, 6, 9, 0, 0, 0, 0);
133 assertSame(test.getChronology().yearOfEra(), test.yearOfEra().getField());
134 assertEquals("yearOfEra", test.yearOfEra().getName());
135 assertEquals("Property[yearOfEra]", test.yearOfEra().toString());
136 assertSame(test, test.yearOfEra().getDateTime());
137 assertEquals(2004, test.yearOfEra().get());
138 assertEquals("2004", test.yearOfEra().getAsString());
139 assertEquals("2004", test.yearOfEra().getAsText());
140 assertEquals("2004", test.yearOfEra().getAsText(Locale.FRENCH));
141 assertEquals("2004", test.yearOfEra().getAsShortText());
142 assertEquals("2004", test.yearOfEra().getAsShortText(Locale.FRENCH));
143 assertEquals(test.getChronology().years(), test.yearOfEra().getDurationField());
144 assertEquals(null, test.yearOfEra().getRangeDurationField());
145 assertEquals(9, test.yearOfEra().getMaximumTextLength(null));
146 assertEquals(9, test.yearOfEra().getMaximumShortTextLength(null));
147 }
148
149 //-----------------------------------------------------------------------
150 public void testPropertyGetCenturyOfEra() {
151 DateTime test = new DateTime(2004, 6, 9, 0, 0, 0, 0);
152 assertSame(test.getChronology().centuryOfEra(), test.centuryOfEra().getField());
153 assertEquals("centuryOfEra", test.centuryOfEra().getName());
154 assertEquals("Property[centuryOfEra]", test.centuryOfEra().toString());
155 assertSame(test, test.centuryOfEra().getDateTime());
156 assertEquals(20, test.centuryOfEra().get());
157 assertEquals("20", test.centuryOfEra().getAsString());
158 assertEquals("20", test.centuryOfEra().getAsText());
159 assertEquals("20", test.centuryOfEra().getAsText(Locale.FRENCH));
160 assertEquals("20", test.centuryOfEra().getAsShortText());
161 assertEquals("20", test.centuryOfEra().getAsShortText(Locale.FRENCH));
162 assertEquals(test.getChronology().centuries(), test.centuryOfEra().getDurationField());
163 assertEquals(null, test.centuryOfEra().getRangeDurationField());
164 assertEquals(7, test.centuryOfEra().getMaximumTextLength(null));
165 assertEquals(7, test.centuryOfEra().getMaximumShortTextLength(null));
166 }
167
168 //-----------------------------------------------------------------------
169 public void testPropertyGetYearOfCentury() {
170 DateTime test = new DateTime(2004, 6, 9, 0, 0, 0, 0);
171 assertSame(test.getChronology().yearOfCentury(), test.yearOfCentury().getField());
172 assertEquals("yearOfCentury", test.yearOfCentury().getName());
173 assertEquals("Property[yearOfCentury]", test.yearOfCentury().toString());
174 assertSame(test, test.yearOfCentury().getDateTime());
175 assertEquals(4, test.yearOfCentury().get());
176 assertEquals("4", test.yearOfCentury().getAsString());
177 assertEquals("4", test.yearOfCentury().getAsText());
178 assertEquals("4", test.yearOfCentury().getAsText(Locale.FRENCH));
179 assertEquals("4", test.yearOfCentury().getAsShortText());
180 assertEquals("4", test.yearOfCentury().getAsShortText(Locale.FRENCH));
181 assertEquals(test.getChronology().years(), test.yearOfCentury().getDurationField());
182 assertEquals(test.getChronology().centuries(), test.yearOfCentury().getRangeDurationField());
183 assertEquals(2, test.yearOfCentury().getMaximumTextLength(null));
184 assertEquals(2, test.yearOfCentury().getMaximumShortTextLength(null));
185 }
186
187 //-----------------------------------------------------------------------
188 public void testPropertyGetWeekyear() {
189 DateTime test = new DateTime(2004, 6, 9, 0, 0, 0, 0);
190 assertSame(test.getChronology().weekyear(), test.weekyear().getField());
191 assertEquals("weekyear", test.weekyear().getName());
192 assertEquals("Property[weekyear]", test.weekyear().toString());
193 assertSame(test, test.weekyear().getDateTime());
194 assertEquals(2004, test.weekyear().get());
195 assertEquals("2004", test.weekyear().getAsString());
196 assertEquals("2004", test.weekyear().getAsText());
197 assertEquals("2004", test.weekyear().getAsText(Locale.FRENCH));
198 assertEquals("2004", test.weekyear().getAsShortText());
199 assertEquals("2004", test.weekyear().getAsShortText(Locale.FRENCH));
200 assertEquals(test.getChronology().weekyears(), test.weekyear().getDurationField());
201 assertEquals(null, test.weekyear().getRangeDurationField());
202 assertEquals(9, test.weekyear().getMaximumTextLength(null));
203 assertEquals(9, test.weekyear().getMaximumShortTextLength(null));
204 }
205
206 //-----------------------------------------------------------------------
207 public void testPropertyGetYear() {
208 DateTime test = new DateTime(2004, 6, 9, 0, 0, 0, 0);
209 assertSame(test.getChronology().year(), test.year().getField());
210 assertEquals("year", test.year().getName());
211 assertEquals("Property[year]", test.year().toString());
212 assertSame(test, test.year().getDateTime());
213 assertEquals(2004, test.year().get());
214 assertEquals("2004", test.year().getAsString());
215 assertEquals("2004", test.year().getAsText());
216 assertEquals("2004", test.year().getAsText(Locale.FRENCH));
217 assertEquals("2004", test.year().getAsShortText());
218 assertEquals("2004", test.year().getAsShortText(Locale.FRENCH));
219 assertEquals(test.getChronology().years(), test.year().getDurationField());
220 assertEquals(null, test.year().getRangeDurationField());
221 assertEquals(9, test.year().getMaximumTextLength(null));
222 assertEquals(9, test.year().getMaximumShortTextLength(null));
223 assertEquals(-292275054, test.year().getMinimumValue());
224 assertEquals(-292275054, test.year().getMinimumValueOverall());
225 assertEquals(292278993, test.year().getMaximumValue());
226 assertEquals(292278993, test.year().getMaximumValueOverall());
227 }
228
229 public void testPropertyLeapYear() {
230 DateTime test = new DateTime(2004, 6, 9, 0, 0, 0, 0);
231 assertEquals(true, test.year().isLeap());
232 assertEquals(1, test.year().getLeapAmount());
233 assertEquals(test.getChronology().days(), test.year().getLeapDurationField());
234 test = new DateTime(2003, 6, 9, 0, 0, 0, 0);
235 assertEquals(false, test.year().isLeap());
236 assertEquals(0, test.year().getLeapAmount());
237 assertEquals(test.getChronology().days(), test.year().getLeapDurationField());
238 }
239
240 public void testPropertyAddYear() {
241 DateTime test = new DateTime(2004, 6, 9, 0, 0, 0, 0);
242 DateTime copy = test.year().addToCopy(9);
243 assertEquals("2004-06-09T00:00:00.000+01:00", test.toString());
244 assertEquals("2013-06-09T00:00:00.000+01:00", copy.toString());
245
246 copy = test.year().addToCopy(0);
247 assertEquals("2004-06-09T00:00:00.000+01:00", copy.toString());
248
249 copy = test.year().addToCopy(292277023 - 2004);
250 assertEquals(292277023, copy.getYear());
251
252 try {
253 test.year().addToCopy(292278993 - 2004 + 1);
254 fail();
255 } catch (IllegalArgumentException ex) {}
256
257 copy = test.year().addToCopy(-2004);
258 assertEquals(0, copy.getYear());
259
260 copy = test.year().addToCopy(-2005);
261 assertEquals(-1, copy.getYear());
262
263 try {
264 test.year().addToCopy(-292275054 - 2004 - 1);
265 fail();
266 } catch (IllegalArgumentException ex) {}
267 }
268
269 public void testPropertyAddWrapFieldYear() {
270 DateTime test = new DateTime(2004, 6, 9, 0, 0, 0, 0);
271 DateTime copy = test.year().addWrapFieldToCopy(9);
272 assertEquals("2004-06-09T00:00:00.000+01:00", test.toString());
273 assertEquals("2013-06-09T00:00:00.000+01:00", copy.toString());
274
275 copy = test.year().addWrapFieldToCopy(0);
276 assertEquals(2004, copy.getYear());
277
278 copy = test.year().addWrapFieldToCopy(292278993 - 2004 + 1);
279 assertEquals(-292275054, copy.getYear());
280
281 copy = test.year().addWrapFieldToCopy(-292275054 - 2004 - 1);
282 assertEquals(292278993, copy.getYear());
283 }
284
285 public void testPropertySetYear() {
286 DateTime test = new DateTime(2004, 6, 9, 0, 0, 0, 0);
287 DateTime copy = test.year().setCopy(1960);
288 assertEquals("2004-06-09T00:00:00.000+01:00", test.toString());
289 assertEquals("1960-06-09T00:00:00.000+01:00", copy.toString());
290 }
291
292 public void testPropertySetTextYear() {
293 DateTime test = new DateTime(2004, 6, 9, 0, 0, 0, 0);
294 DateTime copy = test.year().setCopy("1960");
295 assertEquals("2004-06-09T00:00:00.000+01:00", test.toString());
296 assertEquals("1960-06-09T00:00:00.000+01:00", copy.toString());
297 }
298
299 public void testPropertyCompareToYear() {
300 DateTime test1 = new DateTime(TEST_TIME1);
301 DateTime test2 = new DateTime(TEST_TIME2);
302 assertEquals(true, test1.year().compareTo(test2) < 0);
303 assertEquals(true, test2.year().compareTo(test1) > 0);
304 assertEquals(true, test1.year().compareTo(test1) == 0);
305 try {
306 test1.year().compareTo((ReadableInstant) null);
307 fail();
308 } catch (IllegalArgumentException ex) {}
309 }
310
311 public void testPropertyCompareToYear2() {
312 DateTime test1 = new DateTime(2004, 6, 9, 0, 0, 0, 0);
313 YearMonthDay ymd1 = new YearMonthDay(2003, 6, 9);
314 YearMonthDay ymd2 = new YearMonthDay(2004, 6, 9);
315 YearMonthDay ymd3 = new YearMonthDay(2005, 6, 9);
316 assertEquals(true, test1.year().compareTo(ymd1) > 0);
317 assertEquals(true, test1.year().compareTo(ymd2) == 0);
318 assertEquals(true, test1.year().compareTo(ymd3) < 0);
319 try {
320 test1.year().compareTo((ReadablePartial) null);
321 fail();
322 } catch (IllegalArgumentException ex) {}
323 }
324
325 public void testPropertyEqualsHashCodeYear() {
326 DateTime test1 = new DateTime(2004, 6, 9, 0, 0, 0, 0);
327 assertEquals(true, test1.year().equals(test1.year()));
328 assertEquals(true, test1.year().equals(new DateTime(2004, 6, 9, 0, 0, 0, 0).year()));
329 assertEquals(false, test1.year().equals(new DateTime(2004, 6, 9, 0, 0, 0, 0).monthOfYear()));
330 assertEquals(false, test1.year().equals(new DateTime(2004, 6, 9, 0, 0, 0, 0, CopticChronology.getInstance()).year()));
331
332 assertEquals(true, test1.year().hashCode() == test1.year().hashCode());
333 assertEquals(true, test1.year().hashCode() == new DateTime(2004, 6, 9, 0, 0, 0, 0).year().hashCode());
334 assertEquals(false, test1.year().hashCode() == new DateTime(2004, 6, 9, 0, 0, 0, 0).monthOfYear().hashCode());
335 assertEquals(false, test1.year().hashCode() == new DateTime(2004, 6, 9, 0, 0, 0, 0, CopticChronology.getInstance()).year().hashCode());
336 }
337
338 //-----------------------------------------------------------------------
339 public void testPropertyGetMonthOfYear() {
340 DateTime test = new DateTime(2004, 6, 9, 0, 0, 0, 0);
341 assertSame(test.getChronology().monthOfYear(), test.monthOfYear().getField());
342 assertEquals("monthOfYear", test.monthOfYear().getName());
343 assertEquals("Property[monthOfYear]", test.monthOfYear().toString());
344 assertSame(test, test.monthOfYear().getDateTime());
345 assertEquals(6, test.monthOfYear().get());
346 assertEquals("6", test.monthOfYear().getAsString());
347 assertEquals("June", test.monthOfYear().getAsText());
348 assertEquals("June", test.monthOfYear().getField().getAsText(6, Locale.ENGLISH));
349 assertEquals("juin", test.monthOfYear().getAsText(Locale.FRENCH));
350 assertEquals("juin", test.monthOfYear().getField().getAsText(6, Locale.FRENCH));
351 assertEquals("Jun", test.monthOfYear().getAsShortText());
352 assertEquals("Jun", test.monthOfYear().getField().getAsShortText(6, Locale.ENGLISH));
353 assertEquals("juin", test.monthOfYear().getAsShortText(Locale.FRENCH));
354 assertEquals("juin", test.monthOfYear().getField().getAsShortText(6, Locale.FRENCH));
355 assertEquals(test.getChronology().months(), test.monthOfYear().getDurationField());
356 assertEquals(test.getChronology().years(), test.monthOfYear().getRangeDurationField());
357 assertEquals(9, test.monthOfYear().getMaximumTextLength(null));
358 assertEquals(3, test.monthOfYear().getMaximumShortTextLength(null));
359 test = new DateTime(2004, 7, 9, 0, 0, 0, 0);
360 assertEquals("juillet", test.monthOfYear().getAsText(Locale.FRENCH));
361 assertEquals("juillet", test.monthOfYear().getField().getAsText(7, Locale.FRENCH));
362 assertEquals("juil.", test.monthOfYear().getAsShortText(Locale.FRENCH));
363 assertEquals("juil.", test.monthOfYear().getField().getAsShortText(7, Locale.FRENCH));
364 assertEquals(1, test.monthOfYear().getMinimumValue());
365 assertEquals(1, test.monthOfYear().getMinimumValueOverall());
366 assertEquals(12, test.monthOfYear().getMaximumValue());
367 assertEquals(12, test.monthOfYear().getMaximumValueOverall());
368 assertEquals(1, test.monthOfYear().getMinimumValue());
369 assertEquals(1, test.monthOfYear().getMinimumValueOverall());
370 assertEquals(12, test.monthOfYear().getMaximumValue());
371 assertEquals(12, test.monthOfYear().getMaximumValueOverall());
372 }
373
374 public void testPropertyLeapMonthOfYear() {
375 DateTime test = new DateTime(2004, 6, 9, 0, 0, 0, 0);
376 assertEquals(false, test.monthOfYear().isLeap());
377 assertEquals(0, test.monthOfYear().getLeapAmount());
378 assertEquals(test.getChronology().days(), test.monthOfYear().getLeapDurationField());
379
380 test = new DateTime(2004, 2, 9, 0, 0, 0, 0);
381 assertEquals(true, test.monthOfYear().isLeap());
382 assertEquals(1, test.monthOfYear().getLeapAmount());
383 assertEquals(test.getChronology().days(), test.monthOfYear().getLeapDurationField());
384
385 test = new DateTime(2003, 6, 9, 0, 0, 0, 0);
386 assertEquals(false, test.monthOfYear().isLeap());
387 assertEquals(0, test.monthOfYear().getLeapAmount());
388 assertEquals(test.getChronology().days(), test.monthOfYear().getLeapDurationField());
389
390 test = new DateTime(2003, 2, 9, 0, 0, 0, 0);
391 assertEquals(false, test.monthOfYear().isLeap());
392 assertEquals(0, test.monthOfYear().getLeapAmount());
393 assertEquals(test.getChronology().days(), test.monthOfYear().getLeapDurationField());
394 }
395
396 public void testPropertyAddMonthOfYear() {
397 DateTime test = new DateTime(2004, 6, 9, 0, 0, 0, 0);
398 DateTime copy = test.monthOfYear().addToCopy(6);
399 assertEquals("2004-06-09T00:00:00.000+01:00", test.toString());
400 assertEquals("2004-12-09T00:00:00.000Z", copy.toString());
401
402 copy = test.monthOfYear().addToCopy(7);
403 assertEquals("2005-01-09T00:00:00.000Z", copy.toString());
404
405 copy = test.monthOfYear().addToCopy(-5);
406 assertEquals("2004-01-09T00:00:00.000Z", copy.toString());
407
408 copy = test.monthOfYear().addToCopy(-6);
409 assertEquals("2003-12-09T00:00:00.000Z", copy.toString());
410
411 test = new DateTime(2004, 1, 31, 0, 0, 0, 0);
412 copy = test.monthOfYear().addToCopy(1);
413 assertEquals("2004-01-31T00:00:00.000Z", test.toString());
414 assertEquals("2004-02-29T00:00:00.000Z", copy.toString());
415
416 copy = test.monthOfYear().addToCopy(2);
417 assertEquals("2004-03-31T00:00:00.000+01:00", copy.toString());
418
419 copy = test.monthOfYear().addToCopy(3);
420 assertEquals("2004-04-30T00:00:00.000+01:00", copy.toString());
421
422 test = new DateTime(2003, 1, 31, 0, 0, 0, 0);
423 copy = test.monthOfYear().addToCopy(1);
424 assertEquals("2003-02-28T00:00:00.000Z", copy.toString());
425 }
426
427 public void testPropertyAddWrapFieldMonthOfYear() {
428 DateTime test = new DateTime(2004, 6, 9, 0, 0, 0, 0);
429 DateTime copy = test.monthOfYear().addWrapFieldToCopy(4);
430 assertEquals("2004-06-09T00:00:00.000+01:00", test.toString());
431 assertEquals("2004-10-09T00:00:00.000+01:00", copy.toString());
432
433 copy = test.monthOfYear().addWrapFieldToCopy(8);
434 assertEquals("2004-02-09T00:00:00.000Z", copy.toString());
435
436 copy = test.monthOfYear().addWrapFieldToCopy(-8);
437 assertEquals("2004-10-09T00:00:00.000+01:00", copy.toString());
438
439 test = new DateTime(2004, 1, 31, 0, 0, 0, 0);
440 copy = test.monthOfYear().addWrapFieldToCopy(1);
441 assertEquals("2004-01-31T00:00:00.000Z", test.toString());
442 assertEquals("2004-02-29T00:00:00.000Z", copy.toString());
443
444 copy = test.monthOfYear().addWrapFieldToCopy(2);
445 assertEquals("2004-03-31T00:00:00.000+01:00", copy.toString());
446
447 copy = test.monthOfYear().addWrapFieldToCopy(3);
448 assertEquals("2004-04-30T00:00:00.000+01:00", copy.toString());
449
450 test = new DateTime(2005, 1, 31, 0, 0, 0, 0);
451 copy = test.monthOfYear().addWrapFieldToCopy(1);
452 assertEquals("2005-01-31T00:00:00.000Z", test.toString());
453 assertEquals("2005-02-28T00:00:00.000Z", copy.toString());
454 }
455
456 public void testPropertySetMonthOfYear() {
457 DateTime test = new DateTime(2004, 6, 9, 0, 0, 0, 0);
458 DateTime copy = test.monthOfYear().setCopy(12);
459 assertEquals("2004-06-09T00:00:00.000+01:00", test.toString());
460 assertEquals("2004-12-09T00:00:00.000Z", copy.toString());
461
462 test = new DateTime(2004, 1, 31, 0, 0, 0, 0);
463 copy = test.monthOfYear().setCopy(2);
464 assertEquals("2004-02-29T00:00:00.000Z", copy.toString());
465
466 try {
467 test.monthOfYear().setCopy(13);
468 fail();
469 } catch (IllegalArgumentException ex) {}
470 try {
471 test.monthOfYear().setCopy(0);
472 fail();
473 } catch (IllegalArgumentException ex) {}
474 }
475
476 public void testPropertySetTextMonthOfYear() {
477 DateTime test = new DateTime(2004, 6, 9, 0, 0, 0, 0);
478 DateTime copy = test.monthOfYear().setCopy("12");
479 assertEquals("2004-06-09T00:00:00.000+01:00", test.toString());
480 assertEquals("2004-12-09T00:00:00.000Z", copy.toString());
481
482 copy = test.monthOfYear().setCopy("December");
483 assertEquals("2004-06-09T00:00:00.000+01:00", test.toString());
484 assertEquals("2004-12-09T00:00:00.000Z", copy.toString());
485
486 copy = test.monthOfYear().setCopy("Dec");
487 assertEquals("2004-06-09T00:00:00.000+01:00", test.toString());
488 assertEquals("2004-12-09T00:00:00.000Z", copy.toString());
489 }
490
491 public void testPropertyCompareToMonthOfYear() {
492 DateTime test1 = new DateTime(TEST_TIME1);
493 DateTime test2 = new DateTime(TEST_TIME2);
494 assertEquals(true, test1.monthOfYear().compareTo(test2) < 0);
495 assertEquals(true, test2.monthOfYear().compareTo(test1) > 0);
496 assertEquals(true, test1.monthOfYear().compareTo(test1) == 0);
497 try {
498 test1.monthOfYear().compareTo((ReadableInstant) null);
499 fail();
500 } catch (IllegalArgumentException ex) {}
501
502 DateTime dt1 = new DateTime(TEST_TIME1);
503 DateTime dt2 = new DateTime(TEST_TIME2);
504 assertEquals(true, test1.monthOfYear().compareTo(dt2) < 0);
505 assertEquals(true, test2.monthOfYear().compareTo(dt1) > 0);
506 assertEquals(true, test1.monthOfYear().compareTo(dt1) == 0);
507 try {
508 test1.monthOfYear().compareTo((ReadableInstant) null);
509 fail();
510 } catch (IllegalArgumentException ex) {}
511 }
512
513 //-----------------------------------------------------------------------
514 public void testPropertyGetDayOfMonth() {
515 DateTime test = new DateTime(2004, 6, 9, 0, 0, 0, 0);
516 assertSame(test.getChronology().dayOfMonth(), test.dayOfMonth().getField());
517 assertEquals("dayOfMonth", test.dayOfMonth().getName());
518 assertEquals("Property[dayOfMonth]", test.dayOfMonth().toString());
519 assertSame(test, test.dayOfMonth().getDateTime());
520 assertEquals(9, test.dayOfMonth().get());
521 assertEquals("9", test.dayOfMonth().getAsString());
522 assertEquals("9", test.dayOfMonth().getAsText());
523 assertEquals("9", test.dayOfMonth().getAsText(Locale.FRENCH));
524 assertEquals("9", test.dayOfMonth().getAsShortText());
525 assertEquals("9", test.dayOfMonth().getAsShortText(Locale.FRENCH));
526 assertEquals(test.getChronology().days(), test.dayOfMonth().getDurationField());
527 assertEquals(test.getChronology().months(), test.dayOfMonth().getRangeDurationField());
528 assertEquals(2, test.dayOfMonth().getMaximumTextLength(null));
529 assertEquals(2, test.dayOfMonth().getMaximumShortTextLength(null));
530 assertEquals(1, test.dayOfMonth().getMinimumValue());
531 assertEquals(1, test.dayOfMonth().getMinimumValueOverall());
532 assertEquals(30, test.dayOfMonth().getMaximumValue());
533 assertEquals(31, test.dayOfMonth().getMaximumValueOverall());
534 assertEquals(false, test.dayOfMonth().isLeap());
535 assertEquals(0, test.dayOfMonth().getLeapAmount());
536 assertEquals(null, test.dayOfMonth().getLeapDurationField());
537 }
538
539 public void testPropertyGetMaxMinValuesDayOfMonth() {
540 DateTime test = new DateTime(2004, 6, 9, 0, 0, 0, 0);
541 assertEquals(1, test.dayOfMonth().getMinimumValue());
542 assertEquals(1, test.dayOfMonth().getMinimumValueOverall());
543 assertEquals(30, test.dayOfMonth().getMaximumValue());
544 assertEquals(31, test.dayOfMonth().getMaximumValueOverall());
545 test = new DateTime(2004, 7, 9, 0, 0, 0, 0);
546 assertEquals(31, test.dayOfMonth().getMaximumValue());
547 test = new DateTime(2004, 2, 9, 0, 0, 0, 0);
548 assertEquals(29, test.dayOfMonth().getMaximumValue());
549 test = new DateTime(2003, 2, 9, 0, 0, 0, 0);
550 assertEquals(28, test.dayOfMonth().getMaximumValue());
551 }
552
553 public void testPropertyAddDayOfMonth() {
554 DateTime test = new DateTime(2004, 6, 9, 0, 0, 0, 0);
555 DateTime copy = test.dayOfMonth().addToCopy(9);
556 assertEquals("2004-06-09T00:00:00.000+01:00", test.toString());
557 assertEquals("2004-06-18T00:00:00.000+01:00", copy.toString());
558
559 copy = test.dayOfMonth().addToCopy(21);
560 assertEquals("2004-06-30T00:00:00.000+01:00", copy.toString());
561
562 copy = test.dayOfMonth().addToCopy(22);
563 assertEquals("2004-07-01T00:00:00.000+01:00", copy.toString());
564
565 copy = test.dayOfMonth().addToCopy(22 + 30);
566 assertEquals("2004-07-31T00:00:00.000+01:00", copy.toString());
567
568 copy = test.dayOfMonth().addToCopy(22 + 31);
569 assertEquals("2004-08-01T00:00:00.000+01:00", copy.toString());
570
571 copy = test.dayOfMonth().addToCopy(21 + 31 + 31 + 30 + 31 + 30 + 31);
572 assertEquals("2004-12-31T00:00:00.000Z", copy.toString());
573
574 copy = test.dayOfMonth().addToCopy(22 + 31 + 31 + 30 + 31 + 30 + 31);
575 assertEquals("2005-01-01T00:00:00.000Z", copy.toString());
576
577 copy = test.dayOfMonth().addToCopy(-8);
578 assertEquals("2004-06-01T00:00:00.000+01:00", copy.toString());
579
580 copy = test.dayOfMonth().addToCopy(-9);
581 assertEquals("2004-05-31T00:00:00.000+01:00", copy.toString());
582
583 copy = test.dayOfMonth().addToCopy(-8 - 31 - 30 - 31 - 29 - 31);
584 assertEquals("2004-01-01T00:00:00.000Z", copy.toString());
585
586 copy = test.dayOfMonth().addToCopy(-9 - 31 - 30 - 31 - 29 - 31);
587 assertEquals("2003-12-31T00:00:00.000Z", copy.toString());
588 }
589
590 public void testPropertyAddWrapFieldDayOfMonth() {
591 DateTime test = new DateTime(2004, 6, 9, 0, 0, 0, 0);
592 DateTime copy = test.dayOfMonth().addWrapFieldToCopy(21);
593 assertEquals("2004-06-09T00:00:00.000+01:00", test.toString());
594 assertEquals("2004-06-30T00:00:00.000+01:00", copy.toString());
595
596 copy = test.dayOfMonth().addWrapFieldToCopy(22);
597 assertEquals("2004-06-01T00:00:00.000+01:00", copy.toString());
598
599 copy = test.dayOfMonth().addWrapFieldToCopy(-12);
600 assertEquals("2004-06-27T00:00:00.000+01:00", copy.toString());
601
602 test = new DateTime(2004, 7, 9, 0, 0, 0, 0);
603 copy = test.dayOfMonth().addWrapFieldToCopy(21);
604 assertEquals("2004-07-30T00:00:00.000+01:00", copy.toString());
605
606 copy = test.dayOfMonth().addWrapFieldToCopy(22);
607 assertEquals("2004-07-31T00:00:00.000+01:00", copy.toString());
608
609 copy = test.dayOfMonth().addWrapFieldToCopy(23);
610 assertEquals("2004-07-01T00:00:00.000+01:00", copy.toString());
611
612 copy = test.dayOfMonth().addWrapFieldToCopy(-12);
613 assertEquals("2004-07-28T00:00:00.000+01:00", copy.toString());
614 }
615
616 public void testPropertySetDayOfMonth() {
617 DateTime test = new DateTime(2004, 6, 9, 0, 0, 0, 0);
618 DateTime copy = test.dayOfMonth().setCopy(12);
619 assertEquals("2004-06-09T00:00:00.000+01:00", test.toString());
620 assertEquals("2004-06-12T00:00:00.000+01:00", copy.toString());
621
622 try {
623 test.dayOfMonth().setCopy(31);
624 fail();
625 } catch (IllegalArgumentException ex) {}
626 try {
627 test.dayOfMonth().setCopy(0);
628 fail();
629 } catch (IllegalArgumentException ex) {}
630 }
631
632 public void testPropertySetTextDayOfMonth() {
633 DateTime test = new DateTime(2004, 6, 9, 0, 0, 0, 0);
634 DateTime copy = test.dayOfMonth().setCopy("12");
635 assertEquals("2004-06-09T00:00:00.000+01:00", test.toString());
636 assertEquals("2004-06-12T00:00:00.000+01:00", copy.toString());
637 }
638
639 public void testPropertyWithMaximumValueDayOfMonth() {
640 DateTime test = new DateTime(2004, 6, 9, 0, 0, 0, 0);
641 DateTime copy = test.dayOfMonth().withMaximumValue();
642 assertEquals("2004-06-09T00:00:00.000+01:00", test.toString());
643 assertEquals("2004-06-30T00:00:00.000+01:00", copy.toString());
644 }
645
646 public void testPropertyWithMaximumValueMillisOfDayDSTGap() {
647 DateTimeZone paris = DateTimeZone.forID("Europe/Paris");
648 DateTime dt = new DateTime(1926, 4, 17, 18, 0, 0, 0, paris); // DST gap 23:00 to 00:00
649 DateTime test = dt.millisOfDay().withMaximumValue();
650 assertEquals("1926-04-17T22:59:59.999Z", test.toString());
651 }
652
653 public void testPropertyWithMinimumValueDayOfMonth() {
654 DateTime test = new DateTime(2004, 6, 9, 0, 0, 0, 0);
655 DateTime copy = test.dayOfMonth().withMinimumValue();
656 assertEquals("2004-06-09T00:00:00.000+01:00", test.toString());
657 assertEquals("2004-06-01T00:00:00.000+01:00", copy.toString());
658 }
659
660 public void testPropertyWithMinimumValueMillisOfDayDSTGap() {
661 DateTimeZone gaza = DateTimeZone.forID("Asia/Gaza");
662 DateTime dt = new DateTime(2001, 4, 20, 18, 0, 0, 0, gaza); // DST gap 00:00 to 01:00
663 DateTime test = dt.millisOfDay().withMinimumValue();
664 assertEquals("2001-04-20T01:00:00.000+03:00", test.toString());
665 }
666
667 public void testPropertyCompareToDayOfMonth() {
668 DateTime test1 = new DateTime(TEST_TIME1);
669 DateTime test2 = new DateTime(TEST_TIME2);
670 assertEquals(true, test1.dayOfMonth().compareTo(test2) < 0);
671 assertEquals(true, test2.dayOfMonth().compareTo(test1) > 0);
672 assertEquals(true, test1.dayOfMonth().compareTo(test1) == 0);
673 try {
674 test1.dayOfMonth().compareTo((ReadableInstant) null);
675 fail();
676 } catch (IllegalArgumentException ex) {}
677
678 DateTime dt1 = new DateTime(TEST_TIME1);
679 DateTime dt2 = new DateTime(TEST_TIME2);
680 assertEquals(true, test1.dayOfMonth().compareTo(dt2) < 0);
681 assertEquals(true, test2.dayOfMonth().compareTo(dt1) > 0);
682 assertEquals(true, test1.dayOfMonth().compareTo(dt1) == 0);
683 try {
684 test1.dayOfMonth().compareTo((ReadableInstant) null);
685 fail();
686 } catch (IllegalArgumentException ex) {}
687 }
688
689 //-----------------------------------------------------------------------
690 public void testPropertyGetDayOfYear() {
691 // 31+29+31+30+31+9 = 161
692 DateTime test = new DateTime(2004, 6, 9, 0, 0, 0, 0);
693 assertSame(test.getChronology().dayOfYear(), test.dayOfYear().getField());
694 assertEquals("dayOfYear", test.dayOfYear().getName());
695 assertEquals("Property[dayOfYear]", test.dayOfYear().toString());
696 assertSame(test, test.dayOfYear().getDateTime());
697 assertEquals(161, test.dayOfYear().get());
698 assertEquals("161", test.dayOfYear().getAsString());
699 assertEquals("161", test.dayOfYear().getAsText());
700 assertEquals("161", test.dayOfYear().getAsText(Locale.FRENCH));
701 assertEquals("161", test.dayOfYear().getAsShortText());
702 assertEquals("161", test.dayOfYear().getAsShortText(Locale.FRENCH));
703 assertEquals(test.getChronology().days(), test.dayOfYear().getDurationField());
704 assertEquals(test.getChronology().years(), test.dayOfYear().getRangeDurationField());
705 assertEquals(3, test.dayOfYear().getMaximumTextLength(null));
706 assertEquals(3, test.dayOfYear().getMaximumShortTextLength(null));
707 assertEquals(false, test.dayOfYear().isLeap());
708 assertEquals(0, test.dayOfYear().getLeapAmount());
709 assertEquals(null, test.dayOfYear().getLeapDurationField());
710 }
711
712 public void testPropertyGetMaxMinValuesDayOfYear() {
713 DateTime test = new DateTime(2004, 6, 9, 0, 0, 0, 0);
714 assertEquals(1, test.dayOfYear().getMinimumValue());
715 assertEquals(1, test.dayOfYear().getMinimumValueOverall());
716 assertEquals(366, test.dayOfYear().getMaximumValue());
717 assertEquals(366, test.dayOfYear().getMaximumValueOverall());
718 test = new DateTime(2002, 6, 9, 0, 0, 0, 0);
719 assertEquals(365, test.dayOfYear().getMaximumValue());
720 assertEquals(366, test.dayOfYear().getMaximumValueOverall());
721 }
722
723 public void testPropertyAddDayOfYear() {
724 DateTime test = new DateTime(2004, 6, 9, 0, 0, 0, 0);
725 DateTime copy = test.dayOfYear().addToCopy(9);
726 assertEquals("2004-06-09T00:00:00.000+01:00", test.toString());
727 assertEquals("2004-06-18T00:00:00.000+01:00", copy.toString());
728
729 copy = test.dayOfYear().addToCopy(21);
730 assertEquals("2004-06-30T00:00:00.000+01:00", copy.toString());
731
732 copy = test.dayOfYear().addToCopy(22);
733 assertEquals("2004-07-01T00:00:00.000+01:00", copy.toString());
734
735 copy = test.dayOfYear().addToCopy(21 + 31 + 31 + 30 + 31 + 30 + 31);
736 assertEquals("2004-12-31T00:00:00.000Z", copy.toString());
737
738 copy = test.dayOfYear().addToCopy(22 + 31 + 31 + 30 + 31 + 30 + 31);
739 assertEquals("2005-01-01T00:00:00.000Z", copy.toString());
740
741 copy = test.dayOfYear().addToCopy(-8);
742 assertEquals("2004-06-01T00:00:00.000+01:00", copy.toString());
743
744 copy = test.dayOfYear().addToCopy(-9);
745 assertEquals("2004-05-31T00:00:00.000+01:00", copy.toString());
746
747 copy = test.dayOfYear().addToCopy(-8 - 31 - 30 - 31 - 29 - 31);
748 assertEquals("2004-01-01T00:00:00.000Z", copy.toString());
749
750 copy = test.dayOfYear().addToCopy(-9 - 31 - 30 - 31 - 29 - 31);
751 assertEquals("2003-12-31T00:00:00.000Z", copy.toString());
752 }
753
754 public void testPropertyAddWrapFieldDayOfYear() {
755 DateTime test = new DateTime(2004, 6, 9, 0, 0, 0, 0);
756 DateTime copy = test.dayOfYear().addWrapFieldToCopy(21);
757 assertEquals("2004-06-09T00:00:00.000+01:00", test.toString());
758 assertEquals("2004-06-30T00:00:00.000+01:00", copy.toString());
759
760 copy = test.dayOfYear().addWrapFieldToCopy(22);
761 assertEquals("2004-07-01T00:00:00.000+01:00", copy.toString());
762
763 copy = test.dayOfYear().addWrapFieldToCopy(-12);
764 assertEquals("2004-05-28T00:00:00.000+01:00", copy.toString());
765
766 copy = test.dayOfYear().addWrapFieldToCopy(205);
767 assertEquals("2004-12-31T00:00:00.000Z", copy.toString());
768
769 copy = test.dayOfYear().addWrapFieldToCopy(206);
770 assertEquals("2004-01-01T00:00:00.000Z", copy.toString());
771
772 copy = test.dayOfYear().addWrapFieldToCopy(-160);
773 assertEquals("2004-01-01T00:00:00.000Z", copy.toString());
774
775 copy = test.dayOfYear().addWrapFieldToCopy(-161);
776 assertEquals("2004-12-31T00:00:00.000Z", copy.toString());
777 }
778
779 public void testPropertySetDayOfYear() {
780 DateTime test = new DateTime(2004, 6, 9, 0, 0, 0, 0);
781 DateTime copy = test.dayOfYear().setCopy(12);
782 assertEquals("2004-06-09T00:00:00.000+01:00", test.toString());
783 assertEquals("2004-01-12T00:00:00.000Z", copy.toString());
784
785 try {
786 test.dayOfYear().setCopy(367);
787 fail();
788 } catch (IllegalArgumentException ex) {}
789 try {
790 test.dayOfYear().setCopy(0);
791 fail();
792 } catch (IllegalArgumentException ex) {}
793 }
794
795 public void testPropertySetTextDayOfYear() {
796 DateTime test = new DateTime(2004, 6, 9, 0, 0, 0, 0);
797 DateTime copy = test.dayOfYear().setCopy("12");
798 assertEquals("2004-06-09T00:00:00.000+01:00", test.toString());
799 assertEquals("2004-01-12T00:00:00.000Z", copy.toString());
800 }
801
802 public void testPropertyCompareToDayOfYear() {
803 DateTime test1 = new DateTime(TEST_TIME1);
804 DateTime test2 = new DateTime(TEST_TIME2);
805 assertEquals(true, test1.dayOfYear().compareTo(test2) < 0);
806 assertEquals(true, test2.dayOfYear().compareTo(test1) > 0);
807 assertEquals(true, test1.dayOfYear().compareTo(test1) == 0);
808 try {
809 test1.dayOfYear().compareTo((ReadableInstant) null);
810 fail();
811 } catch (IllegalArgumentException ex) {}
812
813 DateTime dt1 = new DateTime(TEST_TIME1);
814 DateTime dt2 = new DateTime(TEST_TIME2);
815 assertEquals(true, test1.dayOfYear().compareTo(dt2) < 0);
816 assertEquals(true, test2.dayOfYear().compareTo(dt1) > 0);
817 assertEquals(true, test1.dayOfYear().compareTo(dt1) == 0);
818 try {
819 test1.dayOfYear().compareTo((ReadableInstant) null);
820 fail();
821 } catch (IllegalArgumentException ex) {}
822 }
823
824 //-----------------------------------------------------------------------
825 public void testPropertyGetWeekOfWeekyear() {
826 // 2002-01-01 = Thu
827 // 2002-12-31 = Thu (+364 days)
828 // 2003-12-30 = Thu (+364 days)
829 // 2004-01-03 = Mon W1
830 // 2004-01-31 = Mon (+28 days) W5
831 // 2004-02-28 = Mon (+28 days) W9
832 // 2004-03-27 = Mon (+28 days) W13
833 // 2004-04-24 = Mon (+28 days) W17
834 // 2004-05-23 = Mon (+28 days) W21
835 // 2004-06-05 = Mon (+14 days) W23
836 // 2004-06-09 = Fri
837 // 2004-12-25 = Mon W52
838 // 2005-01-01 = Mon W1
839 DateTime test = new DateTime(2004, 6, 9, 0, 0, 0, 0);
840 assertSame(test.getChronology().weekOfWeekyear(), test.weekOfWeekyear().getField());
841 assertEquals("weekOfWeekyear", test.weekOfWeekyear().getName());
842 assertEquals("Property[weekOfWeekyear]", test.weekOfWeekyear().toString());
843 assertSame(test, test.weekOfWeekyear().getDateTime());
844 assertEquals(24, test.weekOfWeekyear().get());
845 assertEquals("24", test.weekOfWeekyear().getAsString());
846 assertEquals("24", test.weekOfWeekyear().getAsText());
847 assertEquals("24", test.weekOfWeekyear().getAsText(Locale.FRENCH));
848 assertEquals("24", test.weekOfWeekyear().getAsShortText());
849 assertEquals("24", test.weekOfWeekyear().getAsShortText(Locale.FRENCH));
850 assertEquals(test.getChronology().weeks(), test.weekOfWeekyear().getDurationField());
851 assertEquals(test.getChronology().weekyears(), test.weekOfWeekyear().getRangeDurationField());
852 assertEquals(2, test.weekOfWeekyear().getMaximumTextLength(null));
853 assertEquals(2, test.weekOfWeekyear().getMaximumShortTextLength(null));
854 assertEquals(false, test.weekOfWeekyear().isLeap());
855 assertEquals(0, test.weekOfWeekyear().getLeapAmount());
856 assertEquals(null, test.weekOfWeekyear().getLeapDurationField());
857 }
858
859 public void testPropertyGetMaxMinValuesWeekOfWeekyear() {
860 DateTime test = new DateTime(2004, 6, 9, 0, 0, 0, 0);
861 assertEquals(1, test.weekOfWeekyear().getMinimumValue());
862 assertEquals(1, test.weekOfWeekyear().getMinimumValueOverall());
863 assertEquals(53, test.weekOfWeekyear().getMaximumValue());
864 assertEquals(53, test.weekOfWeekyear().getMaximumValueOverall());
865 test = new DateTime(2005, 6, 9, 0, 0, 0, 0);
866 assertEquals(52, test.weekOfWeekyear().getMaximumValue());
867 assertEquals(53, test.weekOfWeekyear().getMaximumValueOverall());
868 }
869
870 public void testPropertyAddWeekOfWeekyear() {
871 DateTime test = new DateTime(2004, 6, 7, 0, 0, 0, 0);
872 DateTime copy = test.weekOfWeekyear().addToCopy(1);
873 assertEquals("2004-06-07T00:00:00.000+01:00", test.toString());
874 assertEquals("2004-06-14T00:00:00.000+01:00", copy.toString());
875
876 copy = test.weekOfWeekyear().addToCopy(29);
877 assertEquals("2004-12-27T00:00:00.000Z", copy.toString());
878
879 copy = test.weekOfWeekyear().addToCopy(30);
880 assertEquals("2005-01-03T00:00:00.000Z", copy.toString());
881
882 copy = test.weekOfWeekyear().addToCopy(-22);
883 assertEquals("2004-01-05T00:00:00.000Z", copy.toString());
884
885 copy = test.weekOfWeekyear().addToCopy(-23);
886 assertEquals("2003-12-29T00:00:00.000Z", copy.toString());
887 }
888
889 public void testPropertyAddWrapFieldWeekOfWeekyear() {
890 DateTime test = new DateTime(2004, 6, 7, 0, 0, 0, 0);
891 DateTime copy = test.weekOfWeekyear().addWrapFieldToCopy(1);
892 assertEquals("2004-06-07T00:00:00.000+01:00", test.toString());
893 assertEquals("2004-06-14T00:00:00.000+01:00", copy.toString());
894
895 copy = test.weekOfWeekyear().addWrapFieldToCopy(29);
896 assertEquals("2004-12-27T00:00:00.000Z", copy.toString());
897
898 copy = test.weekOfWeekyear().addWrapFieldToCopy(30);
899 assertEquals("2003-12-29T00:00:00.000Z", copy.toString());
900
901 copy = test.weekOfWeekyear().addWrapFieldToCopy(-23);
902 assertEquals("2003-12-29T00:00:00.000Z", copy.toString());
903 }
904
905 public void testPropertySetWeekOfWeekyear() {
906 DateTime test = new DateTime(2004, 6, 7, 0, 0, 0, 0);
907 DateTime copy = test.weekOfWeekyear().setCopy(4);
908 assertEquals("2004-06-07T00:00:00.000+01:00", test.toString());
909 assertEquals("2004-01-19T00:00:00.000Z", copy.toString());
910
911 try {
912 test.weekOfWeekyear().setCopy(54);
913 fail();
914 } catch (IllegalArgumentException ex) {}
915 try {
916 test.weekOfWeekyear().setCopy(0);
917 fail();
918 } catch (IllegalArgumentException ex) {}
919 }
920
921 public void testPropertySetTextWeekOfWeekyear() {
922 DateTime test = new DateTime(2004, 6, 7, 0, 0, 0, 0);
923 DateTime copy = test.weekOfWeekyear().setCopy("4");
924 assertEquals("2004-06-07T00:00:00.000+01:00", test.toString());
925 assertEquals("2004-01-19T00:00:00.000Z", copy.toString());
926 }
927
928 public void testPropertyCompareToWeekOfWeekyear() {
929 DateTime test1 = new DateTime(TEST_TIME1);
930 DateTime test2 = new DateTime(TEST_TIME2);
931 assertEquals(true, test1.weekOfWeekyear().compareTo(test2) < 0);
932 assertEquals(true, test2.weekOfWeekyear().compareTo(test1) > 0);
933 assertEquals(true, test1.weekOfWeekyear().compareTo(test1) == 0);
934 try {
935 test1.weekOfWeekyear().compareTo((ReadableInstant) null);
936 fail();
937 } catch (IllegalArgumentException ex) {}
938
939 DateTime dt1 = new DateTime(TEST_TIME1);
940 DateTime dt2 = new DateTime(TEST_TIME2);
941 assertEquals(true, test1.weekOfWeekyear().compareTo(dt2) < 0);
942 assertEquals(true, test2.weekOfWeekyear().compareTo(dt1) > 0);
943 assertEquals(true, test1.weekOfWeekyear().compareTo(dt1) == 0);
944 try {
945 test1.weekOfWeekyear().compareTo((ReadableInstant) null);
946 fail();
947 } catch (IllegalArgumentException ex) {}
948 }
949
950 //-----------------------------------------------------------------------
951 public void testPropertyGetDayOfWeek() {
952 DateTime test = new DateTime(2004, 6, 9, 0, 0, 0, 0);
953 assertSame(test.getChronology().dayOfWeek(), test.dayOfWeek().getField());
954 assertEquals("dayOfWeek", test.dayOfWeek().getName());
955 assertEquals("Property[dayOfWeek]", test.dayOfWeek().toString());
956 assertSame(test, test.dayOfWeek().getDateTime());
957 assertEquals(3, test.dayOfWeek().get());
958 assertEquals("3", test.dayOfWeek().getAsString());
959 assertEquals("Wednesday", test.dayOfWeek().getAsText());
960 assertEquals("Wednesday", test.dayOfWeek().getField().getAsText(3, Locale.ENGLISH));
961 assertEquals("mercredi", test.dayOfWeek().getAsText(Locale.FRENCH));
962 assertEquals("mercredi", test.dayOfWeek().getField().getAsText(3, Locale.FRENCH));
963 assertEquals("Wed", test.dayOfWeek().getAsShortText());
964 assertEquals("Wed", test.dayOfWeek().getField().getAsShortText(3, Locale.ENGLISH));
965 assertEquals("mer.", test.dayOfWeek().getAsShortText(Locale.FRENCH));
966 assertEquals("mer.", test.dayOfWeek().getField().getAsShortText(3, Locale.FRENCH));
967 assertEquals(test.getChronology().days(), test.dayOfWeek().getDurationField());
968 assertEquals(test.getChronology().weeks(), test.dayOfWeek().getRangeDurationField());
969 assertEquals(9, test.dayOfWeek().getMaximumTextLength(null));
970 assertEquals(8, test.dayOfWeek().getMaximumTextLength(Locale.FRENCH));
971 assertEquals(3, test.dayOfWeek().getMaximumShortTextLength(null));
972 assertEquals(4, test.dayOfWeek().getMaximumShortTextLength(Locale.FRENCH));
973 assertEquals(1, test.dayOfWeek().getMinimumValue());
974 assertEquals(1, test.dayOfWeek().getMinimumValueOverall());
975 assertEquals(7, test.dayOfWeek().getMaximumValue());
976 assertEquals(7, test.dayOfWeek().getMaximumValueOverall());
977 assertEquals(false, test.dayOfWeek().isLeap());
978 assertEquals(0, test.dayOfWeek().getLeapAmount());
979 assertEquals(null, test.dayOfWeek().getLeapDurationField());
980 }
981
982 public void testPropertyAddDayOfWeek() {
983 DateTime test = new DateTime(2004, 6, 9, 0, 0, 0, 0);
984 DateTime copy = test.dayOfWeek().addToCopy(1);
985 assertEquals("2004-06-09T00:00:00.000+01:00", test.toString());
986 assertEquals("2004-06-10T00:00:00.000+01:00", copy.toString());
987
988 copy = test.dayOfWeek().addToCopy(21);
989 assertEquals("2004-06-30T00:00:00.000+01:00", copy.toString());
990
991 copy = test.dayOfWeek().addToCopy(22);
992 assertEquals("2004-07-01T00:00:00.000+01:00", copy.toString());
993
994 copy = test.dayOfWeek().addToCopy(21 + 31 + 31 + 30 + 31 + 30 + 31);
995 assertEquals("2004-12-31T00:00:00.000Z", copy.toString());
996
997 copy = test.dayOfWeek().addToCopy(22 + 31 + 31 + 30 + 31 + 30 + 31);
998 assertEquals("2005-01-01T00:00:00.000Z", copy.toString());
999
1000 copy = test.dayOfWeek().addToCopy(-8);
1001 assertEquals("2004-06-01T00:00:00.000+01:00", copy.toString());
1002
1003 copy = test.dayOfWeek().addToCopy(-9);
1004 assertEquals("2004-05-31T00:00:00.000+01:00", copy.toString());
1005
1006 copy = test.dayOfWeek().addToCopy(-8 - 31 - 30 - 31 - 29 - 31);
1007 assertEquals("2004-01-01T00:00:00.000Z", copy.toString());
1008
1009 copy = test.dayOfWeek().addToCopy(-9 - 31 - 30 - 31 - 29 - 31);
1010 assertEquals("2003-12-31T00:00:00.000Z", copy.toString());
1011 }
1012
1013 public void testPropertyAddLongDayOfWeek() {
1014 DateTime test = new DateTime(2004, 6, 9, 0, 0, 0, 0);
1015 DateTime copy = test.dayOfWeek().addToCopy(1L);
1016 assertEquals("2004-06-09T00:00:00.000+01:00", test.toString());
1017 assertEquals("2004-06-10T00:00:00.000+01:00", copy.toString());
1018 }
1019
1020 public void testPropertyAddWrapFieldDayOfWeek() {
1021 DateTime test = new DateTime(2004, 6, 9, 0, 0, 0, 0); // Wed
1022 DateTime copy = test.dayOfWeek().addWrapFieldToCopy(1);
1023 assertEquals("2004-06-09T00:00:00.000+01:00", test.toString());
1024 assertEquals("2004-06-10T00:00:00.000+01:00", copy.toString());
1025
1026 copy = test.dayOfWeek().addWrapFieldToCopy(5);
1027 assertEquals("2004-06-07T00:00:00.000+01:00", copy.toString());
1028
1029 copy = test.dayOfWeek().addWrapFieldToCopy(-10);
1030 assertEquals("2004-06-13T00:00:00.000+01:00", copy.toString());
1031
1032 test = new DateTime(2004, 6, 2, 0, 0, 0, 0);
1033 copy = test.dayOfWeek().addWrapFieldToCopy(5);
1034 assertEquals("2004-06-02T00:00:00.000+01:00", test.toString());
1035 assertEquals("2004-05-31T00:00:00.000+01:00", copy.toString());
1036 }
1037
1038 public void testPropertySetDayOfWeek() {
1039 DateTime test = new DateTime(2004, 6, 9, 0, 0, 0, 0);
1040 DateTime copy = test.dayOfWeek().setCopy(4);
1041 assertEquals("2004-06-09T00:00:00.000+01:00", test.toString());
1042 assertEquals("2004-06-10T00:00:00.000+01:00", copy.toString());
1043
1044 try {
1045 test.dayOfWeek().setCopy(8);
1046 fail();
1047 } catch (IllegalArgumentException ex) {}
1048 try {
1049 test.dayOfWeek().setCopy(0);
1050 fail();
1051 } catch (IllegalArgumentException ex) {}
1052 }
1053
1054 public void testPropertySetTextDayOfWeek() {
1055 DateTime test = new DateTime(2004, 6, 9, 0, 0, 0, 0);
1056 DateTime copy = test.dayOfWeek().setCopy("4");
1057 assertEquals("2004-06-09T00:00:00.000+01:00", test.toString());
1058 assertEquals("2004-06-10T00:00:00.000+01:00", copy.toString());
1059 copy = test.dayOfWeek().setCopy("Mon");
1060 assertEquals("2004-06-07T00:00:00.000+01:00", copy.toString());
1061 copy = test.dayOfWeek().setCopy("Tuesday");
1062 assertEquals("2004-06-08T00:00:00.000+01:00", copy.toString());
1063 copy = test.dayOfWeek().setCopy("lundi", Locale.FRENCH);
1064 assertEquals("2004-06-07T00:00:00.000+01:00", copy.toString());
1065 }
1066
1067 public void testPropertyCompareToDayOfWeek() {
1068 DateTime test1 = new DateTime(TEST_TIME1);
1069 DateTime test2 = new DateTime(TEST_TIME2);
1070 assertEquals(true, test2.dayOfWeek().compareTo(test1) < 0);
1071 assertEquals(true, test1.dayOfWeek().compareTo(test2) > 0);
1072 assertEquals(true, test1.dayOfWeek().compareTo(test1) == 0);
1073 try {
1074 test1.dayOfWeek().compareTo((ReadableInstant) null);
1075 fail();
1076 } catch (IllegalArgumentException ex) {}
1077
1078 DateTime dt1 = new DateTime(TEST_TIME1);
1079 DateTime dt2 = new DateTime(TEST_TIME2);
1080 assertEquals(true, test2.dayOfWeek().compareTo(dt1) < 0);
1081 assertEquals(true, test1.dayOfWeek().compareTo(dt2) > 0);
1082 assertEquals(true, test1.dayOfWeek().compareTo(dt1) == 0);
1083 try {
1084 test1.dayOfWeek().compareTo((ReadableInstant) null);
1085 fail();
1086 } catch (IllegalArgumentException ex) {}
1087 }
1088
1089 //-----------------------------------------------------------------------
1090 public void testPropertyGetHourOfDay() {
1091 DateTime test = new DateTime(2004, 6, 9, 13, 23, 43, 53);
1092 assertSame(test.getChronology().hourOfDay(), test.hourOfDay().getField());
1093 assertEquals("hourOfDay", test.hourOfDay().getName());
1094 assertEquals("Property[hourOfDay]", test.hourOfDay().toString());
1095 assertSame(test, test.hourOfDay().getDateTime());
1096 assertEquals(13, test.hourOfDay().get());
1097 assertEquals("13", test.hourOfDay().getAsString());
1098 assertEquals("13", test.hourOfDay().getAsText());
1099 assertEquals("13", test.hourOfDay().getAsText(Locale.FRENCH));
1100 assertEquals("13", test.hourOfDay().getAsShortText());
1101 assertEquals("13", test.hourOfDay().getAsShortText(Locale.FRENCH));
1102 assertEquals(test.getChronology().hours(), test.hourOfDay().getDurationField());
1103 assertEquals(test.getChronology().days(), test.hourOfDay().getRangeDurationField());
1104 assertEquals(2, test.hourOfDay().getMaximumTextLength(null));
1105 assertEquals(2, test.hourOfDay().getMaximumShortTextLength(null));
1106 }
1107
1108 public void testPropertyGetDifferenceHourOfDay() {
1109 DateTime test1 = new DateTime(2004, 6, 9, 13, 30, 0, 0);
1110 DateTime test2 = new DateTime(2004, 6, 9, 15, 30, 0, 0);
1111 assertEquals(-2, test1.hourOfDay().getDifference(test2));
1112 assertEquals(2, test2.hourOfDay().getDifference(test1));
1113 assertEquals(-2L, test1.hourOfDay().getDifferenceAsLong(test2));
1114 assertEquals(2L, test2.hourOfDay().getDifferenceAsLong(test1));
1115
1116 DateTime test = new DateTime(TEST_TIME_NOW + (13L * DateTimeConstants.MILLIS_PER_HOUR));
1117 assertEquals(13, test.hourOfDay().getDifference(null));
1118 assertEquals(13L, test.hourOfDay().getDifferenceAsLong(null));
1119 }
1120
1121 public void testPropertyRoundFloorHourOfDay() {
1122 DateTime test = new DateTime(2004, 6, 9, 13, 30, 0, 0);
1123 DateTime copy = test.hourOfDay().roundFloorCopy();
1124 assertEquals("2004-06-09T13:00:00.000+01:00", copy.toString());
1125 }
1126
1127 public void testPropertyRoundCeilingHourOfDay() {
1128 DateTime test = new DateTime(2004, 6, 9, 13, 30, 0, 0);
1129 DateTime copy = test.hourOfDay().roundCeilingCopy();
1130 assertEquals("2004-06-09T14:00:00.000+01:00", copy.toString());
1131 }
1132
1133 public void testPropertyRoundHalfFloorHourOfDay() {
1134 DateTime test = new DateTime(2004, 6, 9, 13, 30, 0, 0);
1135 DateTime copy = test.hourOfDay().roundHalfFloorCopy();
1136 assertEquals("2004-06-09T13:00:00.000+01:00", copy.toString());
1137
1138 test = new DateTime(2004, 6, 9, 13, 30, 0, 1);
1139 copy = test.hourOfDay().roundHalfFloorCopy();
1140 assertEquals("2004-06-09T14:00:00.000+01:00", copy.toString());
1141
1142 test = new DateTime(2004, 6, 9, 13, 29, 59, 999);
1143 copy = test.hourOfDay().roundHalfFloorCopy();
1144 assertEquals("2004-06-09T13:00:00.000+01:00", copy.toString());
1145 }
1146
1147 public void testPropertyRoundHalfCeilingHourOfDay() {
1148 DateTime test = new DateTime(2004, 6, 9, 13, 30, 0, 0);
1149 DateTime copy = test.hourOfDay().roundHalfCeilingCopy();
1150 assertEquals("2004-06-09T14:00:00.000+01:00", copy.toString());
1151
1152 test = new DateTime(2004, 6, 9, 13, 30, 0, 1);
1153 copy = test.hourOfDay().roundHalfCeilingCopy();
1154 assertEquals("2004-06-09T14:00:00.000+01:00", copy.toString());
1155
1156 test = new DateTime(2004, 6, 9, 13, 29, 59, 999);
1157 copy = test.hourOfDay().roundHalfCeilingCopy();
1158 assertEquals("2004-06-09T13:00:00.000+01:00", copy.toString());
1159 }
1160
1161 public void testPropertyRoundHalfEvenHourOfDay() {
1162 DateTime test = new DateTime(2004, 6, 9, 13, 30, 0, 0);
1163 DateTime copy = test.hourOfDay().roundHalfEvenCopy();
1164 assertEquals("2004-06-09T14:00:00.000+01:00", copy.toString());
1165
1166 test = new DateTime(2004, 6, 9, 14, 30, 0, 0);
1167 copy = test.hourOfDay().roundHalfEvenCopy();
1168 assertEquals("2004-06-09T14:00:00.000+01:00", copy.toString());
1169
1170 test = new DateTime(2004, 6, 9, 13, 30, 0, 1);
1171 copy = test.hourOfDay().roundHalfEvenCopy();
1172 assertEquals("2004-06-09T14:00:00.000+01:00", copy.toString());
1173
1174 test = new DateTime(2004, 6, 9, 13, 29, 59, 999);
1175 copy = test.hourOfDay().roundHalfEvenCopy();
1176 assertEquals("2004-06-09T13:00:00.000+01:00", copy.toString());
1177 }
1178
1179 public void testPropertyRemainderHourOfDay() {
1180 DateTime test = new DateTime(2004, 6, 9, 13, 30, 0, 0);
1181 assertEquals(30L * DateTimeConstants.MILLIS_PER_MINUTE, test.hourOfDay().remainder());
1182 }
1183
1184 //-----------------------------------------------------------------------
1185 public void testPropertyGetMinuteOfHour() {
1186 DateTime test = new DateTime(2004, 6, 9, 13, 23, 43, 53);
1187 assertSame(test.getChronology().minuteOfHour(), test.minuteOfHour().getField());
1188 assertEquals("minuteOfHour", test.minuteOfHour().getName());
1189 assertEquals("Property[minuteOfHour]", test.minuteOfHour().toString());
1190 assertSame(test, test.minuteOfHour().getDateTime());
1191 assertEquals(23, test.minuteOfHour().get());
1192 assertEquals("23", test.minuteOfHour().getAsString());
1193 assertEquals("23", test.minuteOfHour().getAsText());
1194 assertEquals("23", test.minuteOfHour().getAsText(Locale.FRENCH));
1195 assertEquals("23", test.minuteOfHour().getAsShortText());
1196 assertEquals("23", test.minuteOfHour().getAsShortText(Locale.FRENCH));
1197 assertEquals(test.getChronology().minutes(), test.minuteOfHour().getDurationField());
1198 assertEquals(test.getChronology().hours(), test.minuteOfHour().getRangeDurationField());
1199 assertEquals(2, test.minuteOfHour().getMaximumTextLength(null));
1200 assertEquals(2, test.minuteOfHour().getMaximumShortTextLength(null));
1201 }
1202
1203 //-----------------------------------------------------------------------
1204 public void testPropertyGetMinuteOfDay() {
1205 DateTime test = new DateTime(2004, 6, 9, 13, 23, 43, 53);
1206 assertSame(test.getChronology().minuteOfDay(), test.minuteOfDay().getField());
1207 assertEquals("minuteOfDay", test.minuteOfDay().getName());
1208 assertEquals("Property[minuteOfDay]", test.minuteOfDay().toString());
1209 assertSame(test, test.minuteOfDay().getDateTime());
1210 assertEquals(803, test.minuteOfDay().get());
1211 assertEquals("803", test.minuteOfDay().getAsString());
1212 assertEquals("803", test.minuteOfDay().getAsText());
1213 assertEquals("803", test.minuteOfDay().getAsText(Locale.FRENCH));
1214 assertEquals("803", test.minuteOfDay().getAsShortText());
1215 assertEquals("803", test.minuteOfDay().getAsShortText(Locale.FRENCH));
1216 assertEquals(test.getChronology().minutes(), test.minuteOfDay().getDurationField());
1217 assertEquals(test.getChronology().days(), test.minuteOfDay().getRangeDurationField());
1218 assertEquals(4, test.minuteOfDay().getMaximumTextLength(null));
1219 assertEquals(4, test.minuteOfDay().getMaximumShortTextLength(null));
1220 }
1221
1222 //-----------------------------------------------------------------------
1223 public void testPropertyGetSecondOfMinute() {
1224 DateTime test = new DateTime(2004, 6, 9, 13, 23, 43, 53);
1225 assertSame(test.getChronology().secondOfMinute(), test.secondOfMinute().getField());
1226 assertEquals("secondOfMinute", test.secondOfMinute().getName());
1227 assertEquals("Property[secondOfMinute]", test.secondOfMinute().toString());
1228 assertSame(test, test.secondOfMinute().getDateTime());
1229 assertEquals(43, test.secondOfMinute().get());
1230 assertEquals("43", test.secondOfMinute().getAsString());
1231 assertEquals("43", test.secondOfMinute().getAsText());
1232 assertEquals("43", test.secondOfMinute().getAsText(Locale.FRENCH));
1233 assertEquals("43", test.secondOfMinute().getAsShortText());
1234 assertEquals("43", test.secondOfMinute().getAsShortText(Locale.FRENCH));
1235 assertEquals(test.getChronology().seconds(), test.secondOfMinute().getDurationField());
1236 assertEquals(test.getChronology().minutes(), test.secondOfMinute().getRangeDurationField());
1237 assertEquals(2, test.secondOfMinute().getMaximumTextLength(null));
1238 assertEquals(2, test.secondOfMinute().getMaximumShortTextLength(null));
1239 }
1240
1241 //-----------------------------------------------------------------------
1242 public void testPropertyGetSecondOfDay() {
1243 DateTime test = new DateTime(2004, 6, 9, 13, 23, 43, 53);
1244 assertSame(test.getChronology().secondOfDay(), test.secondOfDay().getField());
1245 assertEquals("secondOfDay", test.secondOfDay().getName());
1246 assertEquals("Property[secondOfDay]", test.secondOfDay().toString());
1247 assertSame(test, test.secondOfDay().getDateTime());
1248 assertEquals(48223, test.secondOfDay().get());
1249 assertEquals("48223", test.secondOfDay().getAsString());
1250 assertEquals("48223", test.secondOfDay().getAsText());
1251 assertEquals("48223", test.secondOfDay().getAsText(Locale.FRENCH));
1252 assertEquals("48223", test.secondOfDay().getAsShortText());
1253 assertEquals("48223", test.secondOfDay().getAsShortText(Locale.FRENCH));
1254 assertEquals(test.getChronology().seconds(), test.secondOfDay().getDurationField());
1255 assertEquals(test.getChronology().days(), test.secondOfDay().getRangeDurationField());
1256 assertEquals(5, test.secondOfDay().getMaximumTextLength(null));
1257 assertEquals(5, test.secondOfDay().getMaximumShortTextLength(null));
1258 }
1259
1260 //-----------------------------------------------------------------------
1261 public void testPropertyGetMillisOfSecond() {
1262 DateTime test = new DateTime(2004, 6, 9, 13, 23, 43, 53);
1263 assertSame(test.getChronology().millisOfSecond(), test.millisOfSecond().getField());
1264 assertEquals("millisOfSecond", test.millisOfSecond().getName());
1265 assertEquals("Property[millisOfSecond]", test.millisOfSecond().toString());
1266 assertSame(test, test.millisOfSecond().getDateTime());
1267 assertEquals(53, test.millisOfSecond().get());
1268 assertEquals("53", test.millisOfSecond().getAsString());
1269 assertEquals("53", test.millisOfSecond().getAsText());
1270 assertEquals("53", test.millisOfSecond().getAsText(Locale.FRENCH));
1271 assertEquals("53", test.millisOfSecond().getAsShortText());
1272 assertEquals("53", test.millisOfSecond().getAsShortText(Locale.FRENCH));
1273 assertEquals(test.getChronology().millis(), test.millisOfSecond().getDurationField());
1274 assertEquals(test.getChronology().seconds(), test.millisOfSecond().getRangeDurationField());
1275 assertEquals(3, test.millisOfSecond().getMaximumTextLength(null));
1276 assertEquals(3, test.millisOfSecond().getMaximumShortTextLength(null));
1277 }
1278
1279 //-----------------------------------------------------------------------
1280 public void testPropertyGetMillisOfDay() {
1281 DateTime test = new DateTime(2004, 6, 9, 13, 23, 43, 53);
1282 assertSame(test.getChronology().millisOfDay(), test.millisOfDay().getField());
1283 assertEquals("millisOfDay", test.millisOfDay().getName());
1284 assertEquals("Property[millisOfDay]", test.millisOfDay().toString());
1285 assertSame(test, test.millisOfDay().getDateTime());
1286 assertEquals(48223053, test.millisOfDay().get());
1287 assertEquals("48223053", test.millisOfDay().getAsString());
1288 assertEquals("48223053", test.millisOfDay().getAsText());
1289 assertEquals("48223053", test.millisOfDay().getAsText(Locale.FRENCH));
1290 assertEquals("48223053", test.millisOfDay().getAsShortText());
1291 assertEquals("48223053", test.millisOfDay().getAsShortText(Locale.FRENCH));
1292 assertEquals(test.getChronology().millis(), test.millisOfDay().getDurationField());
1293 assertEquals(test.getChronology().days(), test.millisOfDay().getRangeDurationField());
1294 assertEquals(8, test.millisOfDay().getMaximumTextLength(null));
1295 assertEquals(8, test.millisOfDay().getMaximumShortTextLength(null));
1296 }
1297
1298 //-----------------------------------------------------------------------
1299 public void testPropertyToIntervalYearOfEra() {
1300 DateTime test = new DateTime(2004, 6, 9, 13, 23, 43, 53);
1301 Interval testInterval = test.yearOfEra().toInterval();
1302 assertEquals(new DateTime(2004, 1, 1, 0, 0, 0, 0), testInterval.getStart());
1303 assertEquals(new DateTime(2005, 1, 1, 0, 0, 0, 0), testInterval.getEnd());
1304 }
1305
1306 public void testPropertyToIntervalYearOfCentury() {
1307 DateTime test = new DateTime(2004, 6, 9, 13, 23, 43, 53);
1308 Interval testInterval = test.yearOfCentury().toInterval();
1309 assertEquals(new DateTime(2004, 1, 1, 0, 0, 0, 0), testInterval.getStart());
1310 assertEquals(new DateTime(2005, 1, 1, 0, 0, 0, 0), testInterval.getEnd());
1311 }
1312
1313 public void testPropertyToIntervalYear() {
1314 DateTime test = new DateTime(2004, 6, 9, 13, 23, 43, 53);
1315 Interval testInterval = test.year().toInterval();
1316 assertEquals(new DateTime(2004, 1, 1, 0, 0, 0, 0), testInterval.getStart());
1317 assertEquals(new DateTime(2005, 1, 1, 0, 0, 0, 0), testInterval.getEnd());
1318 }
1319
1320 public void testPropertyToIntervalMonthOfYear() {
1321 DateTime test = new DateTime(2004, 6, 9, 13, 23, 43, 53);
1322 Interval testInterval = test.monthOfYear().toInterval();
1323 assertEquals(new DateTime(2004, 6, 1, 0, 0, 0, 0), testInterval.getStart());
1324 assertEquals(new DateTime(2004, 7, 1, 0, 0, 0, 0), testInterval.getEnd());
1325 }
1326
1327 public void testPropertyToIntervalDayOfMonth() {
1328 DateTime test = new DateTime(2004, 6, 9, 13, 23, 43, 53);
1329 Interval testInterval = test.dayOfMonth().toInterval();
1330 assertEquals(new DateTime(2004, 6, 9, 0, 0, 0, 0), testInterval.getStart());
1331 assertEquals(new DateTime(2004, 6, 10, 0, 0, 0, 0), testInterval.getEnd());
1332
1333 DateTime febTest = new DateTime(2004, 2, 29, 13, 23, 43, 53);
1334 Interval febTestInterval = febTest.dayOfMonth().toInterval();
1335 assertEquals(new DateTime(2004, 2, 29, 0, 0, 0, 0), febTestInterval.getStart());
1336 assertEquals(new DateTime(2004, 3, 1, 0, 0, 0, 0), febTestInterval.getEnd());
1337 }
1338
1339 public void testPropertyToIntervalHourOfDay() {
1340 DateTime test = new DateTime(2004, 6, 9, 13, 23, 43, 53);
1341 Interval testInterval = test.hourOfDay().toInterval();
1342 assertEquals(new DateTime(2004, 6, 9, 13, 0, 0, 0), testInterval.getStart());
1343 assertEquals(new DateTime(2004, 6, 9, 14, 0, 0, 0), testInterval.getEnd());
1344
1345 DateTime midnightTest = new DateTime(2004, 6, 9, 23, 23, 43, 53);
1346 Interval midnightTestInterval = midnightTest.hourOfDay().toInterval();
1347 assertEquals(new DateTime(2004, 6, 9, 23, 0, 0, 0), midnightTestInterval.getStart());
1348 assertEquals(new DateTime(2004, 6, 10, 0, 0, 0, 0), midnightTestInterval.getEnd());
1349 }
1350
1351 public void testPropertyToIntervalMinuteOfHour() {
1352 DateTime test = new DateTime(2004, 6, 9, 13, 23, 43, 53);
1353 Interval testInterval = test.minuteOfHour().toInterval();
1354 assertEquals(new DateTime(2004, 6, 9, 13, 23, 0, 0), testInterval.getStart());
1355 assertEquals(new DateTime(2004, 6, 9, 13, 24, 0, 0), testInterval.getEnd());
1356 }
1357
1358 public void testPropertyToIntervalSecondOfMinute() {
1359 DateTime test = new DateTime(2004, 6, 9, 13, 23, 43, 53);
1360 Interval testInterval = test.secondOfMinute().toInterval();
1361 assertEquals(new DateTime(2004, 6, 9, 13, 23, 43, 0), testInterval.getStart());
1362 assertEquals(new DateTime(2004, 6, 9, 13, 23, 44, 0), testInterval.getEnd());
1363 }
1364
1365 public void testPropertyToIntervalMillisOfSecond() {
1366 DateTime test = new DateTime(2004, 6, 9, 13, 23, 43, 53);
1367 Interval testInterval = test.millisOfSecond().toInterval();
1368 assertEquals(new DateTime(2004, 6, 9, 13, 23, 43, 53), testInterval.getStart());
1369 assertEquals(new DateTime(2004, 6, 9, 13, 23, 43, 54), testInterval.getEnd());
1370 }
1371
1372 public void testPropertyEqualsHashCodeLenient() {
1373 DateTime test1 = new DateTime(1970, 6, 9, 0, 0, 0, 0, LenientChronology.getInstance(COPTIC_PARIS));
1374 DateTime test2 = new DateTime(1970, 6, 9, 0, 0, 0, 0, LenientChronology.getInstance(COPTIC_PARIS));
1375 assertEquals(true, test1.dayOfMonth().equals(test2.dayOfMonth()));
1376 assertEquals(true, test2.dayOfMonth().equals(test1.dayOfMonth()));
1377 assertEquals(true, test1.dayOfMonth().equals(test1.dayOfMonth()));
1378 assertEquals(true, test2.dayOfMonth().equals(test2.dayOfMonth()));
1379 assertEquals(true, test1.dayOfMonth().hashCode() == test2.dayOfMonth().hashCode());
1380 assertEquals(true, test1.dayOfMonth().hashCode() == test1.dayOfMonth().hashCode());
1381 assertEquals(true, test2.dayOfMonth().hashCode() == test2.dayOfMonth().hashCode());
1382 }
1383
1384 public void testPropertyEqualsHashCodeStrict() {
1385 DateTime test1 = new DateTime(1970, 6, 9, 0, 0, 0, 0, StrictChronology.getInstance(COPTIC_PARIS));
1386 DateTime test2 = new DateTime(1970, 6, 9, 0, 0, 0, 0, StrictChronology.getInstance(COPTIC_PARIS));
1387 assertEquals(true, test1.dayOfMonth().equals(test2.dayOfMonth()));
1388 assertEquals(true, test2.dayOfMonth().equals(test1.dayOfMonth()));
1389 assertEquals(true, test1.dayOfMonth().equals(test1.dayOfMonth()));
1390 assertEquals(true, test2.dayOfMonth().equals(test2.dayOfMonth()));
1391 assertEquals(true, test1.dayOfMonth().hashCode() == test2.dayOfMonth().hashCode());
1392 assertEquals(true, test1.dayOfMonth().hashCode() == test1.dayOfMonth().hashCode());
1393 assertEquals(true, test2.dayOfMonth().hashCode() == test2.dayOfMonth().hashCode());
1394 }
1395
1396 }