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 }