59 */ 60 package tck.java.time; 61 62 import static java.time.temporal.ChronoField.AMPM_OF_DAY; 63 import static java.time.temporal.ChronoField.CLOCK_HOUR_OF_AMPM; 64 import static java.time.temporal.ChronoField.CLOCK_HOUR_OF_DAY; 65 import static java.time.temporal.ChronoField.HOUR_OF_AMPM; 66 import static java.time.temporal.ChronoField.HOUR_OF_DAY; 67 import static java.time.temporal.ChronoField.MICRO_OF_DAY; 68 import static java.time.temporal.ChronoField.MICRO_OF_SECOND; 69 import static java.time.temporal.ChronoField.MILLI_OF_DAY; 70 import static java.time.temporal.ChronoField.MILLI_OF_SECOND; 71 import static java.time.temporal.ChronoField.MINUTE_OF_DAY; 72 import static java.time.temporal.ChronoField.MINUTE_OF_HOUR; 73 import static java.time.temporal.ChronoField.NANO_OF_DAY; 74 import static java.time.temporal.ChronoField.NANO_OF_SECOND; 75 import static java.time.temporal.ChronoField.SECOND_OF_DAY; 76 import static java.time.temporal.ChronoField.SECOND_OF_MINUTE; 77 import static java.time.temporal.ChronoUnit.DAYS; 78 import static java.time.temporal.ChronoUnit.FOREVER; 79 import static java.time.temporal.ChronoUnit.HOURS; 80 import static java.time.temporal.ChronoUnit.MICROS; 81 import static java.time.temporal.ChronoUnit.MILLIS; 82 import static java.time.temporal.ChronoUnit.MINUTES; 83 import static java.time.temporal.ChronoUnit.MONTHS; 84 import static java.time.temporal.ChronoUnit.NANOS; 85 import static java.time.temporal.ChronoUnit.SECONDS; 86 import static java.time.temporal.ChronoUnit.WEEKS; 87 import static java.time.temporal.ChronoUnit.YEARS; 88 import static org.testng.Assert.assertEquals; 89 import static org.testng.Assert.assertNotNull; 90 import static org.testng.Assert.assertTrue; 91 import static org.testng.Assert.fail; 92 93 import java.io.ByteArrayOutputStream; 94 import java.io.DataOutputStream; 95 import java.time.Clock; 96 import java.time.DateTimeException; 97 import java.time.Duration; 98 import java.time.Instant; 99 import java.time.LocalDate; 100 import java.time.LocalDateTime; 101 import java.time.LocalTime; 102 import java.time.OffsetTime; 103 import java.time.Period; 104 import java.time.ZoneId; 105 import java.time.ZoneOffset; 106 import java.time.format.DateTimeFormatter; 107 import java.time.format.DateTimeParseException; 108 import java.time.temporal.ChronoField; 109 import java.time.temporal.ChronoUnit; 110 import java.time.temporal.JulianFields; 111 import java.time.temporal.Queries; 112 import java.time.temporal.Temporal; 113 import java.time.temporal.TemporalAccessor; 114 import java.time.temporal.TemporalAdjuster; 115 import java.time.temporal.TemporalAmount; 116 import java.time.temporal.TemporalField; 117 import java.time.temporal.TemporalQuery; 118 import java.time.temporal.TemporalUnit; 119 import java.util.ArrayList; 120 import java.util.Arrays; 121 import java.util.EnumSet; 122 import java.util.Iterator; 123 import java.util.List; 124 125 import org.testng.annotations.BeforeMethod; 126 import org.testng.annotations.DataProvider; 127 import org.testng.annotations.Test; 128 129 /** 130 * Test LocalTime. 131 */ 132 @Test 133 public class TCKLocalTime extends AbstractDateTimeTest { 134 135 private static final ZoneOffset OFFSET_PTWO = ZoneOffset.ofHours(2); 136 137 private LocalTime TEST_12_30_40_987654321; 138 139 private static final TemporalUnit[] INVALID_UNITS; 140 static { 141 EnumSet<ChronoUnit> set = EnumSet.range(WEEKS, FOREVER); 142 INVALID_UNITS = (TemporalUnit[]) set.toArray(new TemporalUnit[set.size()]); 143 } 144 145 @BeforeMethod(groups={"tck","implementation"}) 146 public void setUp() { 147 TEST_12_30_40_987654321 = LocalTime.of(12, 30, 40, 987654321); 148 } 149 150 //----------------------------------------------------------------------- 151 @Override 152 protected List<TemporalAccessor> samples() { 153 TemporalAccessor[] array = {TEST_12_30_40_987654321, LocalTime.MIN, LocalTime.MAX, LocalTime.MIDNIGHT, LocalTime.NOON}; 154 return Arrays.asList(array); 155 } 156 157 @Override 158 protected List<TemporalField> validFields() { 159 TemporalField[] array = { 160 NANO_OF_SECOND, 161 NANO_OF_DAY, 162 MICRO_OF_SECOND, 163 MICRO_OF_DAY, 164 MILLI_OF_SECOND, 165 MILLI_OF_DAY, 241 dos.writeInt(459_000_000); 242 } 243 byte[] bytes = baos.toByteArray(); 244 assertSerializedBySer(LocalTime.of(22, 17, 59, 459_000_000), bytes); 245 } 246 247 //----------------------------------------------------------------------- 248 private void check(LocalTime test, int h, int m, int s, int n) { 249 assertEquals(test.getHour(), h); 250 assertEquals(test.getMinute(), m); 251 assertEquals(test.getSecond(), s); 252 assertEquals(test.getNano(), n); 253 assertEquals(test, test); 254 assertEquals(test.hashCode(), test.hashCode()); 255 assertEquals(LocalTime.of(h, m, s, n), test); 256 } 257 258 //----------------------------------------------------------------------- 259 // constants 260 //----------------------------------------------------------------------- 261 @Test(groups={"tck","implementation"}) 262 public void constant_MIDNIGHT() { 263 check(LocalTime.MIDNIGHT, 0, 0, 0, 0); 264 } 265 266 @Test 267 public void constant_MIDDAY() { 268 check(LocalTime.NOON, 12, 0, 0, 0); 269 } 270 271 @Test 272 public void constant_MIN() { 273 check(LocalTime.MIN, 0, 0, 0, 0); 274 } 275 276 @Test 277 public void constant_MAX() { 278 check(LocalTime.MAX, 23, 59, 59, 999999999); 279 } 280 281 //----------------------------------------------------------------------- 282 // now() 283 //----------------------------------------------------------------------- 284 @Test(groups={"tck"}) 285 public void now() { 286 LocalTime expected = LocalTime.now(Clock.systemDefaultZone()); 287 LocalTime test = LocalTime.now(); 288 long diff = Math.abs(test.toNanoOfDay() - expected.toNanoOfDay()); 289 assertTrue(diff < 100000000); // less than 0.1 secs 290 } 291 292 //----------------------------------------------------------------------- 293 // now(ZoneId) 294 //----------------------------------------------------------------------- 295 @Test(expectedExceptions=NullPointerException.class, groups={"tck"}) 296 public void now_ZoneId_nullZoneId() { 297 LocalTime.now((ZoneId) null); 298 } 299 300 @Test(groups={"tck"}) 301 public void now_ZoneId() { 302 ZoneId zone = ZoneId.of("UTC+01:02:03"); 303 LocalTime expected = LocalTime.now(Clock.system(zone)); 304 LocalTime test = LocalTime.now(zone); 305 for (int i = 0; i < 100; i++) { 306 if (expected.equals(test)) { 307 return; 308 } 309 expected = LocalTime.now(Clock.system(zone)); 310 test = LocalTime.now(zone); 311 } 312 assertEquals(test, expected); 313 } 314 315 //----------------------------------------------------------------------- 316 // now(Clock) 317 //----------------------------------------------------------------------- 318 @Test(expectedExceptions=NullPointerException.class, groups={"tck"}) 319 public void now_Clock_nullClock() { 320 LocalTime.now((Clock) null); 321 } 322 323 @Test(groups={"tck"}) 324 public void now_Clock_allSecsInDay() { 325 for (int i = 0; i < (2 * 24 * 60 * 60); i++) { 326 Instant instant = Instant.ofEpochSecond(i, 8); 327 Clock clock = Clock.fixed(instant, ZoneOffset.UTC); 328 LocalTime test = LocalTime.now(clock); 329 assertEquals(test.getHour(), (i / (60 * 60)) % 24); 330 assertEquals(test.getMinute(), (i / 60) % 60); 331 assertEquals(test.getSecond(), i % 60); 332 assertEquals(test.getNano(), 8); 333 } 334 } 335 336 @Test(groups={"tck"}) 337 public void now_Clock_beforeEpoch() { 338 for (int i =-1; i >= -(24 * 60 * 60); i--) { 339 Instant instant = Instant.ofEpochSecond(i, 8); 340 Clock clock = Clock.fixed(instant, ZoneOffset.UTC); 341 LocalTime test = LocalTime.now(clock); 342 assertEquals(test.getHour(), ((i + 24 * 60 * 60) / (60 * 60)) % 24); 343 assertEquals(test.getMinute(), ((i + 24 * 60 * 60) / 60) % 60); 344 assertEquals(test.getSecond(), (i + 24 * 60 * 60) % 60); 345 assertEquals(test.getNano(), 8); 346 } 347 } 348 349 //----------------------------------------------------------------------- 350 @Test(groups={"tck"}) 351 public void now_Clock_max() { 352 Clock clock = Clock.fixed(Instant.MAX, ZoneOffset.UTC); 353 LocalTime test = LocalTime.now(clock); 354 assertEquals(test.getHour(), 23); 355 assertEquals(test.getMinute(), 59); 356 assertEquals(test.getSecond(), 59); 357 assertEquals(test.getNano(), 999_999_999); 358 } 359 360 @Test(groups={"tck"}) 361 public void now_Clock_min() { 362 Clock clock = Clock.fixed(Instant.MIN, ZoneOffset.UTC); 363 LocalTime test = LocalTime.now(clock); 364 assertEquals(test.getHour(), 0); 365 assertEquals(test.getMinute(), 0); 366 assertEquals(test.getSecond(), 0); 367 assertEquals(test.getNano(), 0); 368 } 369 370 //----------------------------------------------------------------------- 371 // of() factories 372 //----------------------------------------------------------------------- 373 @Test(groups={"tck"}) 374 public void factory_time_2ints() { 375 LocalTime test = LocalTime.of(12, 30); 376 check(test, 12, 30, 0, 0); 377 } 378 379 @Test(expectedExceptions=DateTimeException.class, groups={"tck"}) 380 public void factory_time_2ints_hourTooLow() { 381 LocalTime.of(-1, 0); 382 } 383 384 @Test(expectedExceptions=DateTimeException.class, groups={"tck"}) 385 public void factory_time_2ints_hourTooHigh() { 386 LocalTime.of(24, 0); 387 } 388 389 @Test(expectedExceptions=DateTimeException.class, groups={"tck"}) 390 public void factory_time_2ints_minuteTooLow() { 391 LocalTime.of(0, -1); 392 } 393 394 @Test(expectedExceptions=DateTimeException.class, groups={"tck"}) 395 public void factory_time_2ints_minuteTooHigh() { 396 LocalTime.of(0, 60); 397 } 398 399 //----------------------------------------------------------------------- 400 @Test(groups={"tck"}) 401 public void factory_time_3ints() { 402 LocalTime test = LocalTime.of(12, 30, 40); 403 check(test, 12, 30, 40, 0); 404 } 405 406 @Test(expectedExceptions=DateTimeException.class, groups={"tck"}) 407 public void factory_time_3ints_hourTooLow() { 408 LocalTime.of(-1, 0, 0); 409 } 410 411 @Test(expectedExceptions=DateTimeException.class, groups={"tck"}) 412 public void factory_time_3ints_hourTooHigh() { 413 LocalTime.of(24, 0, 0); 414 } 415 416 @Test(expectedExceptions=DateTimeException.class, groups={"tck"}) 417 public void factory_time_3ints_minuteTooLow() { 418 LocalTime.of(0, -1, 0); 419 } 420 421 @Test(expectedExceptions=DateTimeException.class, groups={"tck"}) 422 public void factory_time_3ints_minuteTooHigh() { 423 LocalTime.of(0, 60, 0); 424 } 425 426 @Test(expectedExceptions=DateTimeException.class, groups={"tck"}) 427 public void factory_time_3ints_secondTooLow() { 428 LocalTime.of(0, 0, -1); 429 } 430 431 @Test(expectedExceptions=DateTimeException.class, groups={"tck"}) 432 public void factory_time_3ints_secondTooHigh() { 433 LocalTime.of(0, 0, 60); 434 } 435 436 //----------------------------------------------------------------------- 437 @Test(groups={"tck"}) 438 public void factory_time_4ints() { 439 LocalTime test = LocalTime.of(12, 30, 40, 987654321); 440 check(test, 12, 30, 40, 987654321); 441 test = LocalTime.of(12, 0, 40, 987654321); 442 check(test, 12, 0, 40, 987654321); 443 } 444 445 @Test(expectedExceptions=DateTimeException.class, groups={"tck"}) 446 public void factory_time_4ints_hourTooLow() { 447 LocalTime.of(-1, 0, 0, 0); 448 } 449 450 @Test(expectedExceptions=DateTimeException.class, groups={"tck"}) 451 public void factory_time_4ints_hourTooHigh() { 452 LocalTime.of(24, 0, 0, 0); 453 } 454 455 @Test(expectedExceptions=DateTimeException.class, groups={"tck"}) 456 public void factory_time_4ints_minuteTooLow() { 457 LocalTime.of(0, -1, 0, 0); 458 } 459 460 @Test(expectedExceptions=DateTimeException.class, groups={"tck"}) 461 public void factory_time_4ints_minuteTooHigh() { 462 LocalTime.of(0, 60, 0, 0); 463 } 464 465 @Test(expectedExceptions=DateTimeException.class, groups={"tck"}) 466 public void factory_time_4ints_secondTooLow() { 467 LocalTime.of(0, 0, -1, 0); 468 } 469 470 @Test(expectedExceptions=DateTimeException.class, groups={"tck"}) 471 public void factory_time_4ints_secondTooHigh() { 472 LocalTime.of(0, 0, 60, 0); 473 } 474 475 @Test(expectedExceptions=DateTimeException.class, groups={"tck"}) 476 public void factory_time_4ints_nanoTooLow() { 477 LocalTime.of(0, 0, 0, -1); 478 } 479 480 @Test(expectedExceptions=DateTimeException.class, groups={"tck"}) 481 public void factory_time_4ints_nanoTooHigh() { 482 LocalTime.of(0, 0, 0, 1000000000); 483 } 484 485 //----------------------------------------------------------------------- 486 // ofSecondOfDay(long) 487 //----------------------------------------------------------------------- 488 @Test(groups={"tck"}) 489 public void factory_ofSecondOfDay() { 490 LocalTime localTime = LocalTime.ofSecondOfDay(2 * 60 * 60 + 17 * 60 + 23); 491 check(localTime, 2, 17, 23, 0); 492 } 493 494 @Test(expectedExceptions=DateTimeException.class, groups={"tck"}) 495 public void factory_ofSecondOfDay_tooLow() { 496 LocalTime.ofSecondOfDay(-1); 497 } 498 499 @Test(expectedExceptions=DateTimeException.class, groups={"tck"}) 500 public void factory_ofSecondOfDay_tooHigh() { 501 LocalTime.ofSecondOfDay(24 * 60 * 60); 502 } 503 504 //----------------------------------------------------------------------- 505 // ofNanoOfDay(long) 506 //----------------------------------------------------------------------- 507 @Test(groups={"tck"}) 508 public void factory_ofNanoOfDay() { 509 LocalTime localTime = LocalTime.ofNanoOfDay(60 * 60 * 1000000000L + 17); 510 check(localTime, 1, 0, 0, 17); 511 } 512 513 @Test(expectedExceptions=DateTimeException.class, groups={"tck"}) 514 public void factory_ofNanoOfDay_tooLow() { 515 LocalTime.ofNanoOfDay(-1); 516 } 517 518 @Test(expectedExceptions=DateTimeException.class, groups={"tck"}) 519 public void factory_ofNanoOfDay_tooHigh() { 520 LocalTime.ofNanoOfDay(24 * 60 * 60 * 1000000000L); 521 } 522 523 //----------------------------------------------------------------------- 524 // from() 525 //----------------------------------------------------------------------- 526 @Test(groups={"tck"}) 527 public void factory_from_TemporalAccessor() { 528 assertEquals(LocalTime.from(LocalTime.of(17, 30)), LocalTime.of(17, 30)); 529 assertEquals(LocalTime.from(LocalDateTime.of(2012, 5, 1, 17, 30)), LocalTime.of(17, 30)); 530 } 531 532 @Test(expectedExceptions=DateTimeException.class, groups={"tck"}) 533 public void factory_from_TemporalAccessor_invalid_noDerive() { 534 LocalTime.from(LocalDate.of(2007, 7, 15)); 535 } 536 537 @Test(expectedExceptions=NullPointerException.class, groups={"tck"}) 538 public void factory_from_TemporalAccessor_null() { 539 LocalTime.from((TemporalAccessor) null); 540 } 541 542 //----------------------------------------------------------------------- 543 // parse() 544 //----------------------------------------------------------------------- 545 @Test(dataProvider = "sampleToString", groups={"tck"}) 546 public void factory_parse_validText(int h, int m, int s, int n, String parsable) { 547 LocalTime t = LocalTime.parse(parsable); 548 assertNotNull(t, parsable); 549 assertEquals(t.getHour(), h); 550 assertEquals(t.getMinute(), m); 551 assertEquals(t.getSecond(), s); 552 assertEquals(t.getNano(), n); 553 } 554 555 @DataProvider(name="sampleBadParse") 556 Object[][] provider_sampleBadParse() { 557 return new Object[][]{ 558 {"00;00"}, 559 {"12-00"}, 560 {"-01:00"}, 561 {"00:00:00-09"}, 562 {"00:00:00,09"}, 563 {"00:00:abs"}, 564 {"11"}, 565 {"11:30+01:00"}, 566 {"11:30+01:00[Europe/Paris]"}, 567 }; 568 } 569 570 @Test(dataProvider = "sampleBadParse", expectedExceptions={DateTimeParseException.class}, groups={"tck"}) 571 public void factory_parse_invalidText(String unparsable) { 572 LocalTime.parse(unparsable); 573 } 574 575 //-----------------------------------------------------------------------s 576 @Test(expectedExceptions=DateTimeParseException.class, groups={"tck"}) 577 public void factory_parse_illegalHour() { 578 LocalTime.parse("25:00"); 579 } 580 581 @Test(expectedExceptions=DateTimeParseException.class, groups={"tck"}) 582 public void factory_parse_illegalMinute() { 583 LocalTime.parse("12:60"); 584 } 585 586 @Test(expectedExceptions=DateTimeParseException.class, groups={"tck"}) 587 public void factory_parse_illegalSecond() { 588 LocalTime.parse("12:12:60"); 589 } 590 591 //-----------------------------------------------------------------------s 592 @Test(expectedExceptions = {NullPointerException.class}, groups={"tck"}) 593 public void factory_parse_nullTest() { 594 LocalTime.parse((String) null); 595 } 596 597 //----------------------------------------------------------------------- 598 // parse(DateTimeFormatter) 599 //----------------------------------------------------------------------- 600 @Test(groups={"tck"}) 601 public void factory_parse_formatter() { 602 DateTimeFormatter f = DateTimeFormatter.ofPattern("H m s"); 603 LocalTime test = LocalTime.parse("14 30 40", f); 604 assertEquals(test, LocalTime.of(14, 30, 40)); 605 } 606 607 @Test(expectedExceptions=NullPointerException.class, groups={"tck"}) 608 public void factory_parse_formatter_nullText() { 609 DateTimeFormatter f = DateTimeFormatter.ofPattern("H m s"); 610 LocalTime.parse((String) null, f); 611 } 612 613 @Test(expectedExceptions=NullPointerException.class, groups={"tck"}) 614 public void factory_parse_formatter_nullFormatter() { 615 LocalTime.parse("ANY", null); 616 } 617 618 //----------------------------------------------------------------------- 619 // get(TemporalField) 620 //----------------------------------------------------------------------- 621 @Test 622 public void test_get_TemporalField() { 623 LocalTime test = TEST_12_30_40_987654321; 624 assertEquals(test.get(ChronoField.HOUR_OF_DAY), 12); 625 assertEquals(test.get(ChronoField.MINUTE_OF_HOUR), 30); 626 assertEquals(test.get(ChronoField.SECOND_OF_MINUTE), 40); 627 assertEquals(test.get(ChronoField.NANO_OF_SECOND), 987654321); 628 629 assertEquals(test.get(ChronoField.SECOND_OF_DAY), 12 * 3600 + 30 * 60 + 40); 630 assertEquals(test.get(ChronoField.MINUTE_OF_DAY), 12 * 60 + 30); 631 assertEquals(test.get(ChronoField.HOUR_OF_AMPM), 0); 632 assertEquals(test.get(ChronoField.CLOCK_HOUR_OF_AMPM), 12); 633 assertEquals(test.get(ChronoField.CLOCK_HOUR_OF_DAY), 12); 639 LocalTime test = TEST_12_30_40_987654321; 640 assertEquals(test.getLong(ChronoField.HOUR_OF_DAY), 12); 641 assertEquals(test.getLong(ChronoField.MINUTE_OF_HOUR), 30); 642 assertEquals(test.getLong(ChronoField.SECOND_OF_MINUTE), 40); 643 assertEquals(test.getLong(ChronoField.NANO_OF_SECOND), 987654321); 644 645 assertEquals(test.getLong(ChronoField.SECOND_OF_DAY), 12 * 3600 + 30 * 60 + 40); 646 assertEquals(test.getLong(ChronoField.MINUTE_OF_DAY), 12 * 60 + 30); 647 assertEquals(test.getLong(ChronoField.HOUR_OF_AMPM), 0); 648 assertEquals(test.getLong(ChronoField.CLOCK_HOUR_OF_AMPM), 12); 649 assertEquals(test.getLong(ChronoField.CLOCK_HOUR_OF_DAY), 12); 650 assertEquals(test.getLong(ChronoField.AMPM_OF_DAY), 1); 651 } 652 653 //----------------------------------------------------------------------- 654 // query(TemporalQuery) 655 //----------------------------------------------------------------------- 656 @DataProvider(name="query") 657 Object[][] data_query() { 658 return new Object[][] { 659 {TEST_12_30_40_987654321, Queries.chronology(), null}, 660 {TEST_12_30_40_987654321, Queries.zoneId(), null}, 661 {TEST_12_30_40_987654321, Queries.precision(), ChronoUnit.NANOS}, 662 {TEST_12_30_40_987654321, Queries.zone(), null}, 663 {TEST_12_30_40_987654321, Queries.offset(), null}, 664 {TEST_12_30_40_987654321, Queries.localDate(), null}, 665 {TEST_12_30_40_987654321, Queries.localTime(), TEST_12_30_40_987654321}, 666 }; 667 } 668 669 @Test(dataProvider="query") 670 public <T> void test_query(TemporalAccessor temporal, TemporalQuery<T> query, T expected) { 671 assertEquals(temporal.query(query), expected); 672 } 673 674 @Test(dataProvider="query") 675 public <T> void test_queryFrom(TemporalAccessor temporal, TemporalQuery<T> query, T expected) { 676 assertEquals(query.queryFrom(temporal), expected); 677 } 678 679 @Test(expectedExceptions=NullPointerException.class) 680 public void test_query_null() { 681 TEST_12_30_40_987654321.query(null); 682 } 683 684 //----------------------------------------------------------------------- 685 // get*() 690 {0, 0, 0, 0}, 691 {0, 0, 0, 1}, 692 {0, 0, 1, 0}, 693 {0, 0, 1, 1}, 694 {0, 1, 0, 0}, 695 {0, 1, 0, 1}, 696 {0, 1, 1, 0}, 697 {0, 1, 1, 1}, 698 {1, 0, 0, 0}, 699 {1, 0, 0, 1}, 700 {1, 0, 1, 0}, 701 {1, 0, 1, 1}, 702 {1, 1, 0, 0}, 703 {1, 1, 0, 1}, 704 {1, 1, 1, 0}, 705 {1, 1, 1, 1}, 706 }; 707 } 708 709 //----------------------------------------------------------------------- 710 @Test(dataProvider="sampleTimes", groups={"tck"}) 711 public void test_get(int h, int m, int s, int ns) { 712 LocalTime a = LocalTime.of(h, m, s, ns); 713 assertEquals(a.getHour(), h); 714 assertEquals(a.getMinute(), m); 715 assertEquals(a.getSecond(), s); 716 assertEquals(a.getNano(), ns); 717 } 718 719 //----------------------------------------------------------------------- 720 // with() 721 //----------------------------------------------------------------------- 722 @Test(groups={"tck"}) 723 public void test_with_adjustment() { 724 final LocalTime sample = LocalTime.of(23, 5); 725 TemporalAdjuster adjuster = new TemporalAdjuster() { 726 @Override 727 public Temporal adjustInto(Temporal dateTime) { 728 return sample; 729 } 730 }; 731 assertEquals(TEST_12_30_40_987654321.with(adjuster), sample); 732 } 733 734 @Test(expectedExceptions=NullPointerException.class, groups={"tck"}) 735 public void test_with_adjustment_null() { 736 TEST_12_30_40_987654321.with((TemporalAdjuster) null); 737 } 738 739 //----------------------------------------------------------------------- 740 // withHour() 741 //----------------------------------------------------------------------- 742 @Test(groups={"tck"}) 743 public void test_withHour_normal() { 744 LocalTime t = TEST_12_30_40_987654321; 745 for (int i = 0; i < 24; i++) { 746 t = t.withHour(i); 747 assertEquals(t.getHour(), i); 748 } 749 } 750 751 @Test(groups={"tck"}) 752 public void test_withHour_noChange_equal() { 753 LocalTime t = TEST_12_30_40_987654321.withHour(12); 754 assertEquals(t, TEST_12_30_40_987654321); 755 } 756 757 @Test(groups={"tck"}) 758 public void test_withHour_toMidnight_equal() { 759 LocalTime t = LocalTime.of(1, 0).withHour(0); 760 assertEquals(t, LocalTime.MIDNIGHT); 761 } 762 763 @Test(groups={"tck"}) 764 public void test_withHour_toMidday_equal() { 765 LocalTime t = LocalTime.of(1, 0).withHour(12); 766 assertEquals(t, LocalTime.NOON); 767 } 768 769 @Test(expectedExceptions=DateTimeException.class, groups={"tck"}) 770 public void test_withHour_hourTooLow() { 771 TEST_12_30_40_987654321.withHour(-1); 772 } 773 774 @Test(expectedExceptions=DateTimeException.class, groups={"tck"}) 775 public void test_withHour_hourTooHigh() { 776 TEST_12_30_40_987654321.withHour(24); 777 } 778 779 //----------------------------------------------------------------------- 780 // withMinute() 781 //----------------------------------------------------------------------- 782 @Test(groups={"tck"}) 783 public void test_withMinute_normal() { 784 LocalTime t = TEST_12_30_40_987654321; 785 for (int i = 0; i < 60; i++) { 786 t = t.withMinute(i); 787 assertEquals(t.getMinute(), i); 788 } 789 } 790 791 @Test(groups={"tck"}) 792 public void test_withMinute_noChange_equal() { 793 LocalTime t = TEST_12_30_40_987654321.withMinute(30); 794 assertEquals(t, TEST_12_30_40_987654321); 795 } 796 797 @Test(groups={"tck"}) 798 public void test_withMinute_toMidnight_equal() { 799 LocalTime t = LocalTime.of(0, 1).withMinute(0); 800 assertEquals(t, LocalTime.MIDNIGHT); 801 } 802 803 @Test(groups={"tck"}) 804 public void test_withMinute_toMidday_equals() { 805 LocalTime t = LocalTime.of(12, 1).withMinute(0); 806 assertEquals(t, LocalTime.NOON); 807 } 808 809 @Test(expectedExceptions=DateTimeException.class, groups={"tck"}) 810 public void test_withMinute_minuteTooLow() { 811 TEST_12_30_40_987654321.withMinute(-1); 812 } 813 814 @Test(expectedExceptions=DateTimeException.class, groups={"tck"}) 815 public void test_withMinute_minuteTooHigh() { 816 TEST_12_30_40_987654321.withMinute(60); 817 } 818 819 //----------------------------------------------------------------------- 820 // withSecond() 821 //----------------------------------------------------------------------- 822 @Test(groups={"tck"}) 823 public void test_withSecond_normal() { 824 LocalTime t = TEST_12_30_40_987654321; 825 for (int i = 0; i < 60; i++) { 826 t = t.withSecond(i); 827 assertEquals(t.getSecond(), i); 828 } 829 } 830 831 @Test(groups={"tck"}) 832 public void test_withSecond_noChange_equal() { 833 LocalTime t = TEST_12_30_40_987654321.withSecond(40); 834 assertEquals(t, TEST_12_30_40_987654321); 835 } 836 837 @Test(groups={"tck"}) 838 public void test_withSecond_toMidnight_equal() { 839 LocalTime t = LocalTime.of(0, 0, 1).withSecond(0); 840 assertEquals(t, LocalTime.MIDNIGHT); 841 } 842 843 @Test(groups={"tck"}) 844 public void test_withSecond_toMidday_equal() { 845 LocalTime t = LocalTime.of(12, 0, 1).withSecond(0); 846 assertEquals(t, LocalTime.NOON); 847 } 848 849 @Test(expectedExceptions=DateTimeException.class, groups={"tck"}) 850 public void test_withSecond_secondTooLow() { 851 TEST_12_30_40_987654321.withSecond(-1); 852 } 853 854 @Test(expectedExceptions=DateTimeException.class, groups={"tck"}) 855 public void test_withSecond_secondTooHigh() { 856 TEST_12_30_40_987654321.withSecond(60); 857 } 858 859 //----------------------------------------------------------------------- 860 // withNano() 861 //----------------------------------------------------------------------- 862 @Test(groups={"tck"}) 863 public void test_withNanoOfSecond_normal() { 864 LocalTime t = TEST_12_30_40_987654321; 865 t = t.withNano(1); 866 assertEquals(t.getNano(), 1); 867 t = t.withNano(10); 868 assertEquals(t.getNano(), 10); 869 t = t.withNano(100); 870 assertEquals(t.getNano(), 100); 871 t = t.withNano(999999999); 872 assertEquals(t.getNano(), 999999999); 873 } 874 875 @Test(groups={"tck"}) 876 public void test_withNanoOfSecond_noChange_equal() { 877 LocalTime t = TEST_12_30_40_987654321.withNano(987654321); 878 assertEquals(t, TEST_12_30_40_987654321); 879 } 880 881 @Test(groups={"tck"}) 882 public void test_withNanoOfSecond_toMidnight_equal() { 883 LocalTime t = LocalTime.of(0, 0, 0, 1).withNano(0); 884 assertEquals(t, LocalTime.MIDNIGHT); 885 } 886 887 @Test(groups={"tck"}) 888 public void test_withNanoOfSecond_toMidday_equal() { 889 LocalTime t = LocalTime.of(12, 0, 0, 1).withNano(0); 890 assertEquals(t, LocalTime.NOON); 891 } 892 893 @Test(expectedExceptions=DateTimeException.class, groups={"tck"}) 894 public void test_withNanoOfSecond_nanoTooLow() { 895 TEST_12_30_40_987654321.withNano(-1); 896 } 897 898 @Test(expectedExceptions=DateTimeException.class, groups={"tck"}) 899 public void test_withNanoOfSecond_nanoTooHigh() { 900 TEST_12_30_40_987654321.withNano(1000000000); 901 } 902 903 //----------------------------------------------------------------------- 904 // truncated(TemporalUnit) 905 //----------------------------------------------------------------------- 906 TemporalUnit NINETY_MINS = new TemporalUnit() { 907 @Override 908 public String getName() { 909 return "NinetyMins"; 910 } 911 @Override 912 public Duration getDuration() { 913 return Duration.ofMinutes(90); 914 } 915 @Override 916 public boolean isDurationEstimated() { 917 return false; 918 } 957 } 958 }; 959 960 @DataProvider(name="truncatedToValid") 961 Object[][] data_truncatedToValid() { 962 return new Object[][] { 963 {LocalTime.of(1, 2, 3, 123_456_789), NANOS, LocalTime.of(1, 2, 3, 123_456_789)}, 964 {LocalTime.of(1, 2, 3, 123_456_789), MICROS, LocalTime.of(1, 2, 3, 123_456_000)}, 965 {LocalTime.of(1, 2, 3, 123_456_789), MILLIS, LocalTime.of(1, 2, 3, 1230_00_000)}, 966 {LocalTime.of(1, 2, 3, 123_456_789), SECONDS, LocalTime.of(1, 2, 3)}, 967 {LocalTime.of(1, 2, 3, 123_456_789), MINUTES, LocalTime.of(1, 2)}, 968 {LocalTime.of(1, 2, 3, 123_456_789), HOURS, LocalTime.of(1, 0)}, 969 {LocalTime.of(1, 2, 3, 123_456_789), DAYS, LocalTime.MIDNIGHT}, 970 971 {LocalTime.of(1, 1, 1, 123_456_789), NINETY_MINS, LocalTime.of(0, 0)}, 972 {LocalTime.of(2, 1, 1, 123_456_789), NINETY_MINS, LocalTime.of(1, 30)}, 973 {LocalTime.of(3, 1, 1, 123_456_789), NINETY_MINS, LocalTime.of(3, 0)}, 974 }; 975 } 976 977 @Test(groups={"tck"}, dataProvider="truncatedToValid") 978 public void test_truncatedTo_valid(LocalTime input, TemporalUnit unit, LocalTime expected) { 979 assertEquals(input.truncatedTo(unit), expected); 980 } 981 982 @DataProvider(name="truncatedToInvalid") 983 Object[][] data_truncatedToInvalid() { 984 return new Object[][] { 985 {LocalTime.of(1, 2, 3, 123_456_789), NINETY_FIVE_MINS}, 986 {LocalTime.of(1, 2, 3, 123_456_789), WEEKS}, 987 {LocalTime.of(1, 2, 3, 123_456_789), MONTHS}, 988 {LocalTime.of(1, 2, 3, 123_456_789), YEARS}, 989 }; 990 } 991 992 @Test(groups={"tck"}, dataProvider="truncatedToInvalid", expectedExceptions=DateTimeException.class) 993 public void test_truncatedTo_invalid(LocalTime input, TemporalUnit unit) { 994 input.truncatedTo(unit); 995 } 996 997 @Test(expectedExceptions=NullPointerException.class, groups={"tck"}) 998 public void test_truncatedTo_null() { 999 TEST_12_30_40_987654321.truncatedTo(null); 1000 } 1001 1002 //----------------------------------------------------------------------- 1003 // plus(TemporalAmount) 1004 //----------------------------------------------------------------------- 1005 @Test 1006 public void test_plus_TemporalAmount_positiveHours() { 1007 TemporalAmount period = MockSimplePeriod.of(7, ChronoUnit.HOURS); 1008 LocalTime t = TEST_12_30_40_987654321.plus(period); 1009 assertEquals(t, LocalTime.of(19, 30, 40, 987654321)); 1010 } 1011 1012 @Test 1013 public void test_plus_TemporalAmount_negativeMinutes() { 1014 TemporalAmount period = MockSimplePeriod.of(-25, ChronoUnit.MINUTES); 1015 LocalTime t = TEST_12_30_40_987654321.plus(period); 1016 assertEquals(t, LocalTime.of(12, 5, 40, 987654321)); 1017 } 1027 public void test_plus_TemporalAmount_wrap() { 1028 TemporalAmount p = MockSimplePeriod.of(1, HOURS); 1029 LocalTime t = LocalTime.of(23, 30).plus(p); 1030 assertEquals(t, LocalTime.of(0, 30)); 1031 } 1032 1033 @Test(expectedExceptions=DateTimeException.class) 1034 public void test_plus_TemporalAmount_dateNotAllowed() { 1035 TemporalAmount period = MockSimplePeriod.of(7, ChronoUnit.MONTHS); 1036 TEST_12_30_40_987654321.plus(period); 1037 } 1038 1039 @Test(expectedExceptions=NullPointerException.class) 1040 public void test_plus_TemporalAmount_null() { 1041 TEST_12_30_40_987654321.plus((TemporalAmount) null); 1042 } 1043 1044 //----------------------------------------------------------------------- 1045 // plus(long,TemporalUnit) 1046 //----------------------------------------------------------------------- 1047 @Test(groups={"tck"}) 1048 public void test_plus_longTemporalUnit_positiveHours() { 1049 LocalTime t = TEST_12_30_40_987654321.plus(7, ChronoUnit.HOURS); 1050 assertEquals(t, LocalTime.of(19, 30, 40, 987654321)); 1051 } 1052 1053 @Test(groups={"tck"}) 1054 public void test_plus_longTemporalUnit_negativeMinutes() { 1055 LocalTime t = TEST_12_30_40_987654321.plus(-25, ChronoUnit.MINUTES); 1056 assertEquals(t, LocalTime.of(12, 5, 40, 987654321)); 1057 } 1058 1059 @Test(groups={"tck"}) 1060 public void test_plus_longTemporalUnit_zero() { 1061 LocalTime t = TEST_12_30_40_987654321.plus(0, ChronoUnit.MINUTES); 1062 assertEquals(t, TEST_12_30_40_987654321); 1063 } 1064 1065 @Test(groups={"tck"}) 1066 public void test_plus_longTemporalUnit_invalidUnit() { 1067 for (TemporalUnit unit : INVALID_UNITS) { 1068 try { 1069 TEST_12_30_40_987654321.plus(1, unit); 1070 fail("Unit should not be allowed " + unit); 1071 } catch (DateTimeException ex) { 1072 // expected 1073 } 1074 } 1075 } 1076 1077 @Test(groups={"tck"}) 1078 public void test_plus_longTemporalUnit_multiples() { 1079 assertEquals(TEST_12_30_40_987654321.plus(0, DAYS), TEST_12_30_40_987654321); 1080 assertEquals(TEST_12_30_40_987654321.plus(1, DAYS), TEST_12_30_40_987654321); 1081 assertEquals(TEST_12_30_40_987654321.plus(2, DAYS), TEST_12_30_40_987654321); 1082 assertEquals(TEST_12_30_40_987654321.plus(-3, DAYS), TEST_12_30_40_987654321); 1083 } 1084 1085 @Test(expectedExceptions=NullPointerException.class, groups={"tck"}) 1086 public void test_plus_longTemporalUnit_null() { 1087 TEST_12_30_40_987654321.plus(1, (TemporalUnit) null); 1088 } 1089 1090 //----------------------------------------------------------------------- 1091 // plusHours() 1092 //----------------------------------------------------------------------- 1093 @Test(groups={"tck"}) 1094 public void test_plusHours_one() { 1095 LocalTime t = LocalTime.MIDNIGHT; 1096 for (int i = 0; i < 50; i++) { 1097 t = t.plusHours(1); 1098 assertEquals(t.getHour(), (i + 1) % 24); 1099 } 1100 } 1101 1102 @Test(groups={"tck"}) 1103 public void test_plusHours_fromZero() { 1104 LocalTime base = LocalTime.MIDNIGHT; 1105 for (int i = -50; i < 50; i++) { 1106 LocalTime t = base.plusHours(i); 1107 assertEquals(t.getHour(), (i + 72) % 24); 1108 } 1109 } 1110 1111 @Test(groups={"tck"}) 1112 public void test_plusHours_fromOne() { 1113 LocalTime base = LocalTime.of(1, 0); 1114 for (int i = -50; i < 50; i++) { 1115 LocalTime t = base.plusHours(i); 1116 assertEquals(t.getHour(), (1 + i + 72) % 24); 1117 } 1118 } 1119 1120 @Test(groups={"tck"}) 1121 public void test_plusHours_noChange_equal() { 1122 LocalTime t = TEST_12_30_40_987654321.plusHours(0); 1123 assertEquals(t, TEST_12_30_40_987654321); 1124 } 1125 1126 @Test(groups={"tck"}) 1127 public void test_plusHours_toMidnight_equal() { 1128 LocalTime t = LocalTime.of(23, 0).plusHours(1); 1129 assertEquals(t, LocalTime.MIDNIGHT); 1130 } 1131 1132 @Test(groups={"tck"}) 1133 public void test_plusHours_toMidday_equal() { 1134 LocalTime t = LocalTime.of(11, 0).plusHours(1); 1135 assertEquals(t, LocalTime.NOON); 1136 } 1137 1138 @Test(groups={"tck"}) 1139 public void test_plusHours_big() { 1140 LocalTime t = LocalTime.of(2, 30).plusHours(Long.MAX_VALUE); 1141 int hours = (int) (Long.MAX_VALUE % 24L); 1142 assertEquals(t, LocalTime.of(2, 30).plusHours(hours)); 1143 } 1144 1145 //----------------------------------------------------------------------- 1146 // plusMinutes() 1147 //----------------------------------------------------------------------- 1148 @Test(groups={"tck"}) 1149 public void test_plusMinutes_one() { 1150 LocalTime t = LocalTime.MIDNIGHT; 1151 int hour = 0; 1152 int min = 0; 1153 for (int i = 0; i < 70; i++) { 1154 t = t.plusMinutes(1); 1155 min++; 1156 if (min == 60) { 1157 hour++; 1158 min = 0; 1159 } 1160 assertEquals(t.getHour(), hour); 1161 assertEquals(t.getMinute(), min); 1162 } 1163 } 1164 1165 @Test(groups={"tck"}) 1166 public void test_plusMinutes_fromZero() { 1167 LocalTime base = LocalTime.MIDNIGHT; 1168 int hour; 1169 int min; 1170 for (int i = -70; i < 70; i++) { 1171 LocalTime t = base.plusMinutes(i); 1172 if (i < -60) { 1173 hour = 22; 1174 min = i + 120; 1175 } else if (i < 0) { 1176 hour = 23; 1177 min = i + 60; 1178 } else if (i >= 60) { 1179 hour = 1; 1180 min = i - 60; 1181 } else { 1182 hour = 0; 1183 min = i; 1184 } 1185 assertEquals(t.getHour(), hour); 1186 assertEquals(t.getMinute(), min); 1187 } 1188 } 1189 1190 @Test(groups={"tck"}) 1191 public void test_plusMinutes_noChange_equal() { 1192 LocalTime t = TEST_12_30_40_987654321.plusMinutes(0); 1193 assertEquals(t, TEST_12_30_40_987654321); 1194 } 1195 1196 @Test(groups={"tck"}) 1197 public void test_plusMinutes_noChange_oneDay_equal() { 1198 LocalTime t = TEST_12_30_40_987654321.plusMinutes(24 * 60); 1199 assertEquals(t, TEST_12_30_40_987654321); 1200 } 1201 1202 @Test(groups={"tck"}) 1203 public void test_plusMinutes_toMidnight_equal() { 1204 LocalTime t = LocalTime.of(23, 59).plusMinutes(1); 1205 assertEquals(t, LocalTime.MIDNIGHT); 1206 } 1207 1208 @Test(groups={"tck"}) 1209 public void test_plusMinutes_toMidday_equal() { 1210 LocalTime t = LocalTime.of(11, 59).plusMinutes(1); 1211 assertEquals(t, LocalTime.NOON); 1212 } 1213 1214 @Test(groups={"tck"}) 1215 public void test_plusMinutes_big() { 1216 LocalTime t = LocalTime.of(2, 30).plusMinutes(Long.MAX_VALUE); 1217 int mins = (int) (Long.MAX_VALUE % (24L * 60L)); 1218 assertEquals(t, LocalTime.of(2, 30).plusMinutes(mins)); 1219 } 1220 1221 //----------------------------------------------------------------------- 1222 // plusSeconds() 1223 //----------------------------------------------------------------------- 1224 @Test(groups={"tck"}) 1225 public void test_plusSeconds_one() { 1226 LocalTime t = LocalTime.MIDNIGHT; 1227 int hour = 0; 1228 int min = 0; 1229 int sec = 0; 1230 for (int i = 0; i < 3700; i++) { 1231 t = t.plusSeconds(1); 1232 sec++; 1233 if (sec == 60) { 1234 min++; 1235 sec = 0; 1236 } 1237 if (min == 60) { 1238 hour++; 1239 min = 0; 1240 } 1241 assertEquals(t.getHour(), hour); 1242 assertEquals(t.getMinute(), min); 1243 assertEquals(t.getSecond(), sec); 1244 } 1268 1269 if (min == 60) { 1270 hour++; 1271 min = 0; 1272 1273 if (hour == 24) { 1274 hour = 0; 1275 } 1276 } 1277 } 1278 1279 return ret; 1280 } 1281 1282 public void remove() { 1283 throw new UnsupportedOperationException(); 1284 } 1285 }; 1286 } 1287 1288 @Test(dataProvider="plusSeconds_fromZero", groups={"tck"}) 1289 public void test_plusSeconds_fromZero(int seconds, int hour, int min, int sec) { 1290 LocalTime base = LocalTime.MIDNIGHT; 1291 LocalTime t = base.plusSeconds(seconds); 1292 1293 assertEquals(hour, t.getHour()); 1294 assertEquals(min, t.getMinute()); 1295 assertEquals(sec, t.getSecond()); 1296 } 1297 1298 @Test(groups={"tck"}) 1299 public void test_plusSeconds_noChange_equal() { 1300 LocalTime t = TEST_12_30_40_987654321.plusSeconds(0); 1301 assertEquals(t, TEST_12_30_40_987654321); 1302 } 1303 1304 @Test(groups={"tck"}) 1305 public void test_plusSeconds_noChange_oneDay_equal() { 1306 LocalTime t = TEST_12_30_40_987654321.plusSeconds(24 * 60 * 60); 1307 assertEquals(t, TEST_12_30_40_987654321); 1308 } 1309 1310 @Test(groups={"tck"}) 1311 public void test_plusSeconds_toMidnight_equal() { 1312 LocalTime t = LocalTime.of(23, 59, 59).plusSeconds(1); 1313 assertEquals(t, LocalTime.MIDNIGHT); 1314 } 1315 1316 @Test(groups={"tck"}) 1317 public void test_plusSeconds_toMidday_equal() { 1318 LocalTime t = LocalTime.of(11, 59, 59).plusSeconds(1); 1319 assertEquals(t, LocalTime.NOON); 1320 } 1321 1322 //----------------------------------------------------------------------- 1323 // plusNanos() 1324 //----------------------------------------------------------------------- 1325 @Test(groups={"tck"}) 1326 public void test_plusNanos_halfABillion() { 1327 LocalTime t = LocalTime.MIDNIGHT; 1328 int hour = 0; 1329 int min = 0; 1330 int sec = 0; 1331 int nanos = 0; 1332 for (long i = 0; i < 3700 * 1000000000L; i+= 500000000) { 1333 t = t.plusNanos(500000000); 1334 nanos += 500000000; 1335 if (nanos == 1000000000) { 1336 sec++; 1337 nanos = 0; 1338 } 1339 if (sec == 60) { 1340 min++; 1341 sec = 0; 1342 } 1343 if (min == 60) { 1344 hour++; 1345 min = 0; 1381 if (min == 60) { 1382 hour++; 1383 min = 0; 1384 1385 if (hour == 24) { 1386 hour = 0; 1387 } 1388 } 1389 } 1390 } 1391 1392 return ret; 1393 } 1394 1395 public void remove() { 1396 throw new UnsupportedOperationException(); 1397 } 1398 }; 1399 } 1400 1401 @Test(dataProvider="plusNanos_fromZero", groups={"tck"}) 1402 public void test_plusNanos_fromZero(long nanoseconds, int hour, int min, int sec, int nanos) { 1403 LocalTime base = LocalTime.MIDNIGHT; 1404 LocalTime t = base.plusNanos(nanoseconds); 1405 1406 assertEquals(hour, t.getHour()); 1407 assertEquals(min, t.getMinute()); 1408 assertEquals(sec, t.getSecond()); 1409 assertEquals(nanos, t.getNano()); 1410 } 1411 1412 @Test(groups={"tck"}) 1413 public void test_plusNanos_noChange_equal() { 1414 LocalTime t = TEST_12_30_40_987654321.plusNanos(0); 1415 assertEquals(t, TEST_12_30_40_987654321); 1416 } 1417 1418 @Test(groups={"tck"}) 1419 public void test_plusNanos_noChange_oneDay_equal() { 1420 LocalTime t = TEST_12_30_40_987654321.plusNanos(24 * 60 * 60 * 1000000000L); 1421 assertEquals(t, TEST_12_30_40_987654321); 1422 } 1423 1424 @Test(groups={"tck"}) 1425 public void test_plusNanos_toMidnight_equal() { 1426 LocalTime t = LocalTime.of(23, 59, 59, 999999999).plusNanos(1); 1427 assertEquals(t, LocalTime.MIDNIGHT); 1428 } 1429 1430 @Test(groups={"tck"}) 1431 public void test_plusNanos_toMidday_equal() { 1432 LocalTime t = LocalTime.of(11, 59, 59, 999999999).plusNanos(1); 1433 assertEquals(t, LocalTime.NOON); 1434 } 1435 1436 //----------------------------------------------------------------------- 1437 // minus(TemporalAmount) 1438 //----------------------------------------------------------------------- 1439 @Test 1440 public void test_minus_TemporalAmount_positiveHours() { 1441 TemporalAmount period = MockSimplePeriod.of(7, ChronoUnit.HOURS); 1442 LocalTime t = TEST_12_30_40_987654321.minus(period); 1443 assertEquals(t, LocalTime.of(5, 30, 40, 987654321)); 1444 } 1445 1446 @Test 1447 public void test_minus_TemporalAmount_negativeMinutes() { 1448 TemporalAmount period = MockSimplePeriod.of(-25, ChronoUnit.MINUTES); 1449 LocalTime t = TEST_12_30_40_987654321.minus(period); 1450 assertEquals(t, LocalTime.of(12, 55, 40, 987654321)); 1461 public void test_minus_TemporalAmount_wrap() { 1462 TemporalAmount p = MockSimplePeriod.of(1, HOURS); 1463 LocalTime t = LocalTime.of(0, 30).minus(p); 1464 assertEquals(t, LocalTime.of(23, 30)); 1465 } 1466 1467 @Test(expectedExceptions=DateTimeException.class) 1468 public void test_minus_TemporalAmount_dateNotAllowed() { 1469 TemporalAmount period = MockSimplePeriod.of(7, ChronoUnit.MONTHS); 1470 TEST_12_30_40_987654321.minus(period); 1471 } 1472 1473 @Test(expectedExceptions=NullPointerException.class) 1474 public void test_minus_TemporalAmount_null() { 1475 TEST_12_30_40_987654321.minus((TemporalAmount) null); 1476 } 1477 1478 //----------------------------------------------------------------------- 1479 // minus(long,TemporalUnit) 1480 //----------------------------------------------------------------------- 1481 @Test(groups={"tck"}) 1482 public void test_minus_longTemporalUnit_positiveHours() { 1483 LocalTime t = TEST_12_30_40_987654321.minus(7, ChronoUnit.HOURS); 1484 assertEquals(t, LocalTime.of(5, 30, 40, 987654321)); 1485 } 1486 1487 @Test(groups={"tck"}) 1488 public void test_minus_longTemporalUnit_negativeMinutes() { 1489 LocalTime t = TEST_12_30_40_987654321.minus(-25, ChronoUnit.MINUTES); 1490 assertEquals(t, LocalTime.of(12, 55, 40, 987654321)); 1491 } 1492 1493 @Test(groups={"tck"}) 1494 public void test_minus_longTemporalUnit_zero() { 1495 LocalTime t = TEST_12_30_40_987654321.minus(0, ChronoUnit.MINUTES); 1496 assertEquals(t, TEST_12_30_40_987654321); 1497 } 1498 1499 @Test(groups={"tck"}) 1500 public void test_minus_longTemporalUnit_invalidUnit() { 1501 for (TemporalUnit unit : INVALID_UNITS) { 1502 try { 1503 TEST_12_30_40_987654321.minus(1, unit); 1504 fail("Unit should not be allowed " + unit); 1505 } catch (DateTimeException ex) { 1506 // expected 1507 } 1508 } 1509 } 1510 1511 @Test(groups={"tck"}) 1512 public void test_minus_longTemporalUnit_long_multiples() { 1513 assertEquals(TEST_12_30_40_987654321.minus(0, DAYS), TEST_12_30_40_987654321); 1514 assertEquals(TEST_12_30_40_987654321.minus(1, DAYS), TEST_12_30_40_987654321); 1515 assertEquals(TEST_12_30_40_987654321.minus(2, DAYS), TEST_12_30_40_987654321); 1516 assertEquals(TEST_12_30_40_987654321.minus(-3, DAYS), TEST_12_30_40_987654321); 1517 } 1518 1519 @Test(expectedExceptions=NullPointerException.class, groups={"tck"}) 1520 public void test_minus_longTemporalUnit_null() { 1521 TEST_12_30_40_987654321.minus(1, (TemporalUnit) null); 1522 } 1523 1524 //----------------------------------------------------------------------- 1525 // minusHours() 1526 //----------------------------------------------------------------------- 1527 @Test(groups={"tck"}) 1528 public void test_minusHours_one() { 1529 LocalTime t = LocalTime.MIDNIGHT; 1530 for (int i = 0; i < 50; i++) { 1531 t = t.minusHours(1); 1532 assertEquals(t.getHour(), (((-i + 23) % 24) + 24) % 24, String.valueOf(i)); 1533 } 1534 } 1535 1536 @Test(groups={"tck"}) 1537 public void test_minusHours_fromZero() { 1538 LocalTime base = LocalTime.MIDNIGHT; 1539 for (int i = -50; i < 50; i++) { 1540 LocalTime t = base.minusHours(i); 1541 assertEquals(t.getHour(), ((-i % 24) + 24) % 24); 1542 } 1543 } 1544 1545 @Test(groups={"tck"}) 1546 public void test_minusHours_fromOne() { 1547 LocalTime base = LocalTime.of(1, 0); 1548 for (int i = -50; i < 50; i++) { 1549 LocalTime t = base.minusHours(i); 1550 assertEquals(t.getHour(), (1 + (-i % 24) + 24) % 24); 1551 } 1552 } 1553 1554 @Test(groups={"tck"}) 1555 public void test_minusHours_noChange_equal() { 1556 LocalTime t = TEST_12_30_40_987654321.minusHours(0); 1557 assertEquals(t, TEST_12_30_40_987654321); 1558 } 1559 1560 @Test(groups={"tck"}) 1561 public void test_minusHours_toMidnight_equal() { 1562 LocalTime t = LocalTime.of(1, 0).minusHours(1); 1563 assertEquals(t, LocalTime.MIDNIGHT); 1564 } 1565 1566 @Test(groups={"tck"}) 1567 public void test_minusHours_toMidday_equal() { 1568 LocalTime t = LocalTime.of(13, 0).minusHours(1); 1569 assertEquals(t, LocalTime.NOON); 1570 } 1571 1572 @Test(groups={"tck"}) 1573 public void test_minusHours_big() { 1574 LocalTime t = LocalTime.of(2, 30).minusHours(Long.MAX_VALUE); 1575 int hours = (int) (Long.MAX_VALUE % 24L); 1576 assertEquals(t, LocalTime.of(2, 30).minusHours(hours)); 1577 } 1578 1579 //----------------------------------------------------------------------- 1580 // minusMinutes() 1581 //----------------------------------------------------------------------- 1582 @Test(groups={"tck"}) 1583 public void test_minusMinutes_one() { 1584 LocalTime t = LocalTime.MIDNIGHT; 1585 int hour = 0; 1586 int min = 0; 1587 for (int i = 0; i < 70; i++) { 1588 t = t.minusMinutes(1); 1589 min--; 1590 if (min == -1) { 1591 hour--; 1592 min = 59; 1593 1594 if (hour == -1) { 1595 hour = 23; 1596 } 1597 } 1598 assertEquals(t.getHour(), hour); 1599 assertEquals(t.getMinute(), min); 1600 } 1601 } 1602 1603 @Test(groups={"tck"}) 1604 public void test_minusMinutes_fromZero() { 1605 LocalTime base = LocalTime.MIDNIGHT; 1606 int hour = 22; 1607 int min = 49; 1608 for (int i = 70; i > -70; i--) { 1609 LocalTime t = base.minusMinutes(i); 1610 min++; 1611 1612 if (min == 60) { 1613 hour++; 1614 min = 0; 1615 1616 if (hour == 24) { 1617 hour = 0; 1618 } 1619 } 1620 1621 assertEquals(t.getHour(), hour); 1622 assertEquals(t.getMinute(), min); 1623 } 1624 } 1625 1626 @Test(groups={"tck"}) 1627 public void test_minusMinutes_noChange_equal() { 1628 LocalTime t = TEST_12_30_40_987654321.minusMinutes(0); 1629 assertEquals(t, TEST_12_30_40_987654321); 1630 } 1631 1632 @Test(groups={"tck"}) 1633 public void test_minusMinutes_noChange_oneDay_equal() { 1634 LocalTime t = TEST_12_30_40_987654321.minusMinutes(24 * 60); 1635 assertEquals(t, TEST_12_30_40_987654321); 1636 } 1637 1638 @Test(groups={"tck"}) 1639 public void test_minusMinutes_toMidnight_equal() { 1640 LocalTime t = LocalTime.of(0, 1).minusMinutes(1); 1641 assertEquals(t, LocalTime.MIDNIGHT); 1642 } 1643 1644 @Test(groups={"tck"}) 1645 public void test_minusMinutes_toMidday_equals() { 1646 LocalTime t = LocalTime.of(12, 1).minusMinutes(1); 1647 assertEquals(t, LocalTime.NOON); 1648 } 1649 1650 @Test(groups={"tck"}) 1651 public void test_minusMinutes_big() { 1652 LocalTime t = LocalTime.of(2, 30).minusMinutes(Long.MAX_VALUE); 1653 int mins = (int) (Long.MAX_VALUE % (24L * 60L)); 1654 assertEquals(t, LocalTime.of(2, 30).minusMinutes(mins)); 1655 } 1656 1657 //----------------------------------------------------------------------- 1658 // minusSeconds() 1659 //----------------------------------------------------------------------- 1660 @Test(groups={"tck"}) 1661 public void test_minusSeconds_one() { 1662 LocalTime t = LocalTime.MIDNIGHT; 1663 int hour = 0; 1664 int min = 0; 1665 int sec = 0; 1666 for (int i = 0; i < 3700; i++) { 1667 t = t.minusSeconds(1); 1668 sec--; 1669 if (sec == -1) { 1670 min--; 1671 sec = 59; 1672 1673 if (min == -1) { 1674 hour--; 1675 min = 59; 1676 1677 if (hour == -1) { 1678 hour = 23; 1679 } 1680 } 1709 1710 if (min == 60) { 1711 hour++; 1712 min = 0; 1713 1714 if (hour == 24) { 1715 hour = 0; 1716 } 1717 } 1718 } 1719 1720 return ret; 1721 } 1722 1723 public void remove() { 1724 throw new UnsupportedOperationException(); 1725 } 1726 }; 1727 } 1728 1729 @Test(dataProvider="minusSeconds_fromZero", groups={"tck"}) 1730 public void test_minusSeconds_fromZero(int seconds, int hour, int min, int sec) { 1731 LocalTime base = LocalTime.MIDNIGHT; 1732 LocalTime t = base.minusSeconds(seconds); 1733 1734 assertEquals(t.getHour(), hour); 1735 assertEquals(t.getMinute(), min); 1736 assertEquals(t.getSecond(), sec); 1737 } 1738 1739 @Test(groups={"tck"}) 1740 public void test_minusSeconds_noChange_equal() { 1741 LocalTime t = TEST_12_30_40_987654321.minusSeconds(0); 1742 assertEquals(t, TEST_12_30_40_987654321); 1743 } 1744 1745 @Test(groups={"tck"}) 1746 public void test_minusSeconds_noChange_oneDay_equal() { 1747 LocalTime t = TEST_12_30_40_987654321.minusSeconds(24 * 60 * 60); 1748 assertEquals(t, TEST_12_30_40_987654321); 1749 } 1750 1751 @Test(groups={"tck"}) 1752 public void test_minusSeconds_toMidnight_equal() { 1753 LocalTime t = LocalTime.of(0, 0, 1).minusSeconds(1); 1754 assertEquals(t, LocalTime.MIDNIGHT); 1755 } 1756 1757 @Test(groups={"tck"}) 1758 public void test_minusSeconds_toMidday_equal() { 1759 LocalTime t = LocalTime.of(12, 0, 1).minusSeconds(1); 1760 assertEquals(t, LocalTime.NOON); 1761 } 1762 1763 @Test(groups={"tck"}) 1764 public void test_minusSeconds_big() { 1765 LocalTime t = LocalTime.of(2, 30).minusSeconds(Long.MAX_VALUE); 1766 int secs = (int) (Long.MAX_VALUE % (24L * 60L * 60L)); 1767 assertEquals(t, LocalTime.of(2, 30).minusSeconds(secs)); 1768 } 1769 1770 //----------------------------------------------------------------------- 1771 // minusNanos() 1772 //----------------------------------------------------------------------- 1773 @Test(groups={"tck"}) 1774 public void test_minusNanos_halfABillion() { 1775 LocalTime t = LocalTime.MIDNIGHT; 1776 int hour = 0; 1777 int min = 0; 1778 int sec = 0; 1779 int nanos = 0; 1780 for (long i = 0; i < 3700 * 1000000000L; i+= 500000000) { 1781 t = t.minusNanos(500000000); 1782 nanos -= 500000000; 1783 1784 if (nanos < 0) { 1785 sec--; 1786 nanos += 1000000000; 1787 1788 if (sec == -1) { 1789 min--; 1790 sec += 60; 1791 1792 if (min == -1) { 1793 hour--; 1837 if (min == 60) { 1838 hour++; 1839 min = 0; 1840 1841 if (hour == 24) { 1842 hour = 0; 1843 } 1844 } 1845 } 1846 } 1847 1848 return ret; 1849 } 1850 1851 public void remove() { 1852 throw new UnsupportedOperationException(); 1853 } 1854 }; 1855 } 1856 1857 @Test(dataProvider="minusNanos_fromZero", groups={"tck"}) 1858 public void test_minusNanos_fromZero(long nanoseconds, int hour, int min, int sec, int nanos) { 1859 LocalTime base = LocalTime.MIDNIGHT; 1860 LocalTime t = base.minusNanos(nanoseconds); 1861 1862 assertEquals(hour, t.getHour()); 1863 assertEquals(min, t.getMinute()); 1864 assertEquals(sec, t.getSecond()); 1865 assertEquals(nanos, t.getNano()); 1866 } 1867 1868 @Test(groups={"tck"}) 1869 public void test_minusNanos_noChange_equal() { 1870 LocalTime t = TEST_12_30_40_987654321.minusNanos(0); 1871 assertEquals(t, TEST_12_30_40_987654321); 1872 } 1873 1874 @Test(groups={"tck"}) 1875 public void test_minusNanos_noChange_oneDay_equal() { 1876 LocalTime t = TEST_12_30_40_987654321.minusNanos(24 * 60 * 60 * 1000000000L); 1877 assertEquals(t, TEST_12_30_40_987654321); 1878 } 1879 1880 @Test(groups={"tck"}) 1881 public void test_minusNanos_toMidnight_equal() { 1882 LocalTime t = LocalTime.of(0, 0, 0, 1).minusNanos(1); 1883 assertEquals(t, LocalTime.MIDNIGHT); 1884 } 1885 1886 @Test(groups={"tck"}) 1887 public void test_minusNanos_toMidday_equal() { 1888 LocalTime t = LocalTime.of(12, 0, 0, 1).minusNanos(1); 1889 assertEquals(t, LocalTime.NOON); 1890 } 1891 1892 //----------------------------------------------------------------------- 1893 // atDate() 1894 //----------------------------------------------------------------------- 1895 @Test(groups={"tck"}) 1896 public void test_atDate() { 1897 LocalTime t = LocalTime.of(11, 30); 1898 assertEquals(t.atDate(LocalDate.of(2012, 6, 30)), LocalDateTime.of(2012, 6, 30, 11, 30)); 1899 } 1900 1901 @Test(expectedExceptions=NullPointerException.class, groups={"tck"}) 1902 public void test_atDate_nullDate() { 1903 TEST_12_30_40_987654321.atDate((LocalDate) null); 1904 } 1905 1906 //----------------------------------------------------------------------- 1907 // atOffset() 1908 //----------------------------------------------------------------------- 1909 @Test(groups={"tck"}) 1910 public void test_atOffset() { 1911 LocalTime t = LocalTime.of(11, 30); 1912 assertEquals(t.atOffset(OFFSET_PTWO), OffsetTime.of(LocalTime.of(11, 30), OFFSET_PTWO)); 1913 } 1914 1915 @Test(expectedExceptions=NullPointerException.class, groups={"tck"}) 1916 public void test_atOffset_nullZoneOffset() { 1917 LocalTime t = LocalTime.of(11, 30); 1918 t.atOffset((ZoneOffset) null); 1919 } 1920 1921 //----------------------------------------------------------------------- 1922 // toSecondOfDay() 1923 //----------------------------------------------------------------------- 1924 @Test(groups={"tck"}) 1925 public void test_toSecondOfDay() { 1926 LocalTime t = LocalTime.of(0, 0); 1927 for (int i = 0; i < 24 * 60 * 60; i++) { 1928 assertEquals(t.toSecondOfDay(), i); 1929 t = t.plusSeconds(1); 1930 } 1931 } 1932 1933 @Test(groups={"tck"}) 1934 public void test_toSecondOfDay_fromNanoOfDay_symmetry() { 1935 LocalTime t = LocalTime.of(0, 0); 1936 for (int i = 0; i < 24 * 60 * 60; i++) { 1937 assertEquals(LocalTime.ofSecondOfDay(t.toSecondOfDay()), t); 1938 t = t.plusSeconds(1); 1939 } 1940 } 1941 1942 //----------------------------------------------------------------------- 1943 // toNanoOfDay() 1944 //----------------------------------------------------------------------- 1945 @Test(groups={"tck"}) 1946 public void test_toNanoOfDay() { 1947 LocalTime t = LocalTime.of(0, 0); 1948 for (int i = 0; i < 1000000; i++) { 1949 assertEquals(t.toNanoOfDay(), i); 1950 t = t.plusNanos(1); 1951 } 1952 t = LocalTime.of(0, 0); 1953 for (int i = 1; i <= 1000000; i++) { 1954 t = t.minusNanos(1); 1955 assertEquals(t.toNanoOfDay(), 24 * 60 * 60 * 1000000000L - i); 1956 } 1957 } 1958 1959 @Test(groups={"tck"}) 1960 public void test_toNanoOfDay_fromNanoOfDay_symmetry() { 1961 LocalTime t = LocalTime.of(0, 0); 1962 for (int i = 0; i < 1000000; i++) { 1963 assertEquals(LocalTime.ofNanoOfDay(t.toNanoOfDay()), t); 1964 t = t.plusNanos(1); 1965 } 1966 t = LocalTime.of(0, 0); 1967 for (int i = 1; i <= 1000000; i++) { 1968 t = t.minusNanos(1); 1969 assertEquals(LocalTime.ofNanoOfDay(t.toNanoOfDay()), t); 1970 } 1971 } 1972 1973 //----------------------------------------------------------------------- 1974 // compareTo() 1975 //----------------------------------------------------------------------- 1976 @Test(groups={"tck"}) 1977 public void test_comparisons() { 1978 doTest_comparisons_LocalTime( 1979 LocalTime.MIDNIGHT, 1980 LocalTime.of(0, 0, 0, 999999999), 1981 LocalTime.of(0, 0, 59, 0), 1982 LocalTime.of(0, 0, 59, 999999999), 1983 LocalTime.of(0, 59, 0, 0), 1984 LocalTime.of(0, 59, 0, 999999999), 1985 LocalTime.of(0, 59, 59, 0), 1986 LocalTime.of(0, 59, 59, 999999999), 1987 LocalTime.NOON, 1988 LocalTime.of(12, 0, 0, 999999999), 1989 LocalTime.of(12, 0, 59, 0), 1990 LocalTime.of(12, 0, 59, 999999999), 1991 LocalTime.of(12, 59, 0, 0), 1992 LocalTime.of(12, 59, 0, 999999999), 1993 LocalTime.of(12, 59, 59, 0), 1994 LocalTime.of(12, 59, 59, 999999999), 1995 LocalTime.of(23, 0, 0, 0), 1996 LocalTime.of(23, 0, 0, 999999999), 2011 if (i < j) { 2012 assertTrue(a.compareTo(b) < 0, a + " <=> " + b); 2013 assertEquals(a.isBefore(b), true, a + " <=> " + b); 2014 assertEquals(a.isAfter(b), false, a + " <=> " + b); 2015 assertEquals(a.equals(b), false, a + " <=> " + b); 2016 } else if (i > j) { 2017 assertTrue(a.compareTo(b) > 0, a + " <=> " + b); 2018 assertEquals(a.isBefore(b), false, a + " <=> " + b); 2019 assertEquals(a.isAfter(b), true, a + " <=> " + b); 2020 assertEquals(a.equals(b), false, a + " <=> " + b); 2021 } else { 2022 assertEquals(a.compareTo(b), 0, a + " <=> " + b); 2023 assertEquals(a.isBefore(b), false, a + " <=> " + b); 2024 assertEquals(a.isAfter(b), false, a + " <=> " + b); 2025 assertEquals(a.equals(b), true, a + " <=> " + b); 2026 } 2027 } 2028 } 2029 } 2030 2031 @Test(expectedExceptions=NullPointerException.class, groups={"tck"}) 2032 public void test_compareTo_ObjectNull() { 2033 TEST_12_30_40_987654321.compareTo(null); 2034 } 2035 2036 @Test(expectedExceptions=NullPointerException.class, groups={"tck"}) 2037 public void test_isBefore_ObjectNull() { 2038 TEST_12_30_40_987654321.isBefore(null); 2039 } 2040 2041 @Test(expectedExceptions=NullPointerException.class, groups={"tck"}) 2042 public void test_isAfter_ObjectNull() { 2043 TEST_12_30_40_987654321.isAfter(null); 2044 } 2045 2046 @Test(expectedExceptions=ClassCastException.class, groups={"tck"}) 2047 @SuppressWarnings({"unchecked", "rawtypes"}) 2048 public void compareToNonLocalTime() { 2049 Comparable c = TEST_12_30_40_987654321; 2050 c.compareTo(new Object()); 2051 } 2052 2053 //----------------------------------------------------------------------- 2054 // equals() 2055 //----------------------------------------------------------------------- 2056 @Test(dataProvider="sampleTimes", groups={"tck"}) 2057 public void test_equals_true(int h, int m, int s, int n) { 2058 LocalTime a = LocalTime.of(h, m, s, n); 2059 LocalTime b = LocalTime.of(h, m, s, n); 2060 assertEquals(a.equals(b), true); 2061 } 2062 @Test(dataProvider="sampleTimes", groups={"tck"}) 2063 public void test_equals_false_hour_differs(int h, int m, int s, int n) { 2064 LocalTime a = LocalTime.of(h, m, s, n); 2065 LocalTime b = LocalTime.of(h + 1, m, s, n); 2066 assertEquals(a.equals(b), false); 2067 } 2068 @Test(dataProvider="sampleTimes", groups={"tck"}) 2069 public void test_equals_false_minute_differs(int h, int m, int s, int n) { 2070 LocalTime a = LocalTime.of(h, m, s, n); 2071 LocalTime b = LocalTime.of(h, m + 1, s, n); 2072 assertEquals(a.equals(b), false); 2073 } 2074 @Test(dataProvider="sampleTimes", groups={"tck"}) 2075 public void test_equals_false_second_differs(int h, int m, int s, int n) { 2076 LocalTime a = LocalTime.of(h, m, s, n); 2077 LocalTime b = LocalTime.of(h, m, s + 1, n); 2078 assertEquals(a.equals(b), false); 2079 } 2080 @Test(dataProvider="sampleTimes", groups={"tck"}) 2081 public void test_equals_false_nano_differs(int h, int m, int s, int n) { 2082 LocalTime a = LocalTime.of(h, m, s, n); 2083 LocalTime b = LocalTime.of(h, m, s, n + 1); 2084 assertEquals(a.equals(b), false); 2085 } 2086 2087 @Test(groups={"tck"}) 2088 public void test_equals_itself_true() { 2089 assertEquals(TEST_12_30_40_987654321.equals(TEST_12_30_40_987654321), true); 2090 } 2091 2092 @Test(groups={"tck"}) 2093 public void test_equals_string_false() { 2094 assertEquals(TEST_12_30_40_987654321.equals("2007-07-15"), false); 2095 } 2096 2097 @Test(groups={"tck"}) 2098 public void test_equals_null_false() { 2099 assertEquals(TEST_12_30_40_987654321.equals(null), false); 2100 } 2101 2102 //----------------------------------------------------------------------- 2103 // hashCode() 2104 //----------------------------------------------------------------------- 2105 @Test(dataProvider="sampleTimes", groups={"tck"}) 2106 public void test_hashCode_same(int h, int m, int s, int n) { 2107 LocalTime a = LocalTime.of(h, m, s, n); 2108 LocalTime b = LocalTime.of(h, m, s, n); 2109 assertEquals(a.hashCode(), b.hashCode()); 2110 } 2111 2112 @Test(dataProvider="sampleTimes", groups={"tck"}) 2113 public void test_hashCode_hour_differs(int h, int m, int s, int n) { 2114 LocalTime a = LocalTime.of(h, m, s, n); 2115 LocalTime b = LocalTime.of(h + 1, m, s, n); 2116 assertEquals(a.hashCode() == b.hashCode(), false); 2117 } 2118 2119 @Test(dataProvider="sampleTimes", groups={"tck"}) 2120 public void test_hashCode_minute_differs(int h, int m, int s, int n) { 2121 LocalTime a = LocalTime.of(h, m, s, n); 2122 LocalTime b = LocalTime.of(h, m + 1, s, n); 2123 assertEquals(a.hashCode() == b.hashCode(), false); 2124 } 2125 2126 @Test(dataProvider="sampleTimes", groups={"tck"}) 2127 public void test_hashCode_second_differs(int h, int m, int s, int n) { 2128 LocalTime a = LocalTime.of(h, m, s, n); 2129 LocalTime b = LocalTime.of(h, m, s + 1, n); 2130 assertEquals(a.hashCode() == b.hashCode(), false); 2131 } 2132 2133 @Test(dataProvider="sampleTimes", groups={"tck"}) 2134 public void test_hashCode_nano_differs(int h, int m, int s, int n) { 2135 LocalTime a = LocalTime.of(h, m, s, n); 2136 LocalTime b = LocalTime.of(h, m, s, n + 1); 2137 assertEquals(a.hashCode() == b.hashCode(), false); 2138 } 2139 2140 //----------------------------------------------------------------------- 2141 // toString() 2142 //----------------------------------------------------------------------- 2143 @DataProvider(name="sampleToString") 2144 Object[][] provider_sampleToString() { 2145 return new Object[][] { 2146 {0, 0, 0, 0, "00:00"}, 2147 {1, 0, 0, 0, "01:00"}, 2148 {23, 0, 0, 0, "23:00"}, 2149 {0, 1, 0, 0, "00:01"}, 2150 {12, 30, 0, 0, "12:30"}, 2151 {23, 59, 0, 0, "23:59"}, 2152 {0, 0, 1, 0, "00:00:01"}, 2153 {0, 0, 59, 0, "00:00:59"}, 2155 {0, 0, 0, 10000000, "00:00:00.010"}, 2156 {0, 0, 0, 1000000, "00:00:00.001"}, 2157 {0, 0, 0, 100000, "00:00:00.000100"}, 2158 {0, 0, 0, 10000, "00:00:00.000010"}, 2159 {0, 0, 0, 1000, "00:00:00.000001"}, 2160 {0, 0, 0, 100, "00:00:00.000000100"}, 2161 {0, 0, 0, 10, "00:00:00.000000010"}, 2162 {0, 0, 0, 1, "00:00:00.000000001"}, 2163 {0, 0, 0, 999999999, "00:00:00.999999999"}, 2164 {0, 0, 0, 99999999, "00:00:00.099999999"}, 2165 {0, 0, 0, 9999999, "00:00:00.009999999"}, 2166 {0, 0, 0, 999999, "00:00:00.000999999"}, 2167 {0, 0, 0, 99999, "00:00:00.000099999"}, 2168 {0, 0, 0, 9999, "00:00:00.000009999"}, 2169 {0, 0, 0, 999, "00:00:00.000000999"}, 2170 {0, 0, 0, 99, "00:00:00.000000099"}, 2171 {0, 0, 0, 9, "00:00:00.000000009"}, 2172 }; 2173 } 2174 2175 @Test(dataProvider="sampleToString", groups={"tck"}) 2176 public void test_toString(int h, int m, int s, int n, String expected) { 2177 LocalTime t = LocalTime.of(h, m, s, n); 2178 String str = t.toString(); 2179 assertEquals(str, expected); 2180 } 2181 2182 //----------------------------------------------------------------------- 2183 // toString(DateTimeFormatter) 2184 //----------------------------------------------------------------------- 2185 @Test(groups={"tck"}) 2186 public void test_toString_formatter() { 2187 DateTimeFormatter f = DateTimeFormatter.ofPattern("H m s"); 2188 String t = LocalTime.of(11, 30, 45).toString(f); 2189 assertEquals(t, "11 30 45"); 2190 } 2191 2192 @Test(expectedExceptions=NullPointerException.class, groups={"tck"}) 2193 public void test_toString_formatter_null() { 2194 LocalTime.of(11, 30, 45).toString(null); 2195 } 2196 2197 } | 59 */ 60 package tck.java.time; 61 62 import static java.time.temporal.ChronoField.AMPM_OF_DAY; 63 import static java.time.temporal.ChronoField.CLOCK_HOUR_OF_AMPM; 64 import static java.time.temporal.ChronoField.CLOCK_HOUR_OF_DAY; 65 import static java.time.temporal.ChronoField.HOUR_OF_AMPM; 66 import static java.time.temporal.ChronoField.HOUR_OF_DAY; 67 import static java.time.temporal.ChronoField.MICRO_OF_DAY; 68 import static java.time.temporal.ChronoField.MICRO_OF_SECOND; 69 import static java.time.temporal.ChronoField.MILLI_OF_DAY; 70 import static java.time.temporal.ChronoField.MILLI_OF_SECOND; 71 import static java.time.temporal.ChronoField.MINUTE_OF_DAY; 72 import static java.time.temporal.ChronoField.MINUTE_OF_HOUR; 73 import static java.time.temporal.ChronoField.NANO_OF_DAY; 74 import static java.time.temporal.ChronoField.NANO_OF_SECOND; 75 import static java.time.temporal.ChronoField.SECOND_OF_DAY; 76 import static java.time.temporal.ChronoField.SECOND_OF_MINUTE; 77 import static java.time.temporal.ChronoUnit.DAYS; 78 import static java.time.temporal.ChronoUnit.FOREVER; 79 import static java.time.temporal.ChronoUnit.HALF_DAYS; 80 import static java.time.temporal.ChronoUnit.HOURS; 81 import static java.time.temporal.ChronoUnit.MICROS; 82 import static java.time.temporal.ChronoUnit.MILLIS; 83 import static java.time.temporal.ChronoUnit.MINUTES; 84 import static java.time.temporal.ChronoUnit.MONTHS; 85 import static java.time.temporal.ChronoUnit.NANOS; 86 import static java.time.temporal.ChronoUnit.SECONDS; 87 import static java.time.temporal.ChronoUnit.WEEKS; 88 import static java.time.temporal.ChronoUnit.YEARS; 89 import static org.testng.Assert.assertEquals; 90 import static org.testng.Assert.assertNotNull; 91 import static org.testng.Assert.assertTrue; 92 import static org.testng.Assert.fail; 93 94 import java.io.ByteArrayOutputStream; 95 import java.io.DataOutputStream; 96 import java.time.Clock; 97 import java.time.DateTimeException; 98 import java.time.Duration; 99 import java.time.Instant; 100 import java.time.LocalDate; 101 import java.time.LocalDateTime; 102 import java.time.LocalTime; 103 import java.time.OffsetDateTime; 104 import java.time.OffsetTime; 105 import java.time.Period; 106 import java.time.ZoneId; 107 import java.time.ZoneOffset; 108 import java.time.ZonedDateTime; 109 import java.time.format.DateTimeFormatter; 110 import java.time.format.DateTimeParseException; 111 import java.time.temporal.ChronoField; 112 import java.time.temporal.ChronoUnit; 113 import java.time.temporal.JulianFields; 114 import java.time.temporal.Temporal; 115 import java.time.temporal.TemporalAccessor; 116 import java.time.temporal.TemporalAdjuster; 117 import java.time.temporal.TemporalAmount; 118 import java.time.temporal.TemporalField; 119 import java.time.temporal.TemporalQuery; 120 import java.time.temporal.TemporalUnit; 121 import java.time.temporal.UnsupportedTemporalTypeException; 122 import java.util.ArrayList; 123 import java.util.Arrays; 124 import java.util.EnumSet; 125 import java.util.Iterator; 126 import java.util.List; 127 128 import org.testng.annotations.BeforeMethod; 129 import org.testng.annotations.DataProvider; 130 import org.testng.annotations.Test; 131 132 /** 133 * Test LocalTime. 134 */ 135 @Test 136 public class TCKLocalTime extends AbstractDateTimeTest { 137 138 private static final ZoneOffset OFFSET_PTWO = ZoneOffset.ofHours(2); 139 private static final ZoneId ZONE_PARIS = ZoneId.of("Europe/Paris"); 140 141 private LocalTime TEST_12_30_40_987654321; 142 143 private static final TemporalUnit[] INVALID_UNITS; 144 static { 145 EnumSet<ChronoUnit> set = EnumSet.range(WEEKS, FOREVER); 146 INVALID_UNITS = (TemporalUnit[]) set.toArray(new TemporalUnit[set.size()]); 147 } 148 149 @BeforeMethod 150 public void setUp() { 151 TEST_12_30_40_987654321 = LocalTime.of(12, 30, 40, 987654321); 152 } 153 154 //----------------------------------------------------------------------- 155 @Override 156 protected List<TemporalAccessor> samples() { 157 TemporalAccessor[] array = {TEST_12_30_40_987654321, LocalTime.MIN, LocalTime.MAX, LocalTime.MIDNIGHT, LocalTime.NOON}; 158 return Arrays.asList(array); 159 } 160 161 @Override 162 protected List<TemporalField> validFields() { 163 TemporalField[] array = { 164 NANO_OF_SECOND, 165 NANO_OF_DAY, 166 MICRO_OF_SECOND, 167 MICRO_OF_DAY, 168 MILLI_OF_SECOND, 169 MILLI_OF_DAY, 245 dos.writeInt(459_000_000); 246 } 247 byte[] bytes = baos.toByteArray(); 248 assertSerializedBySer(LocalTime.of(22, 17, 59, 459_000_000), bytes); 249 } 250 251 //----------------------------------------------------------------------- 252 private void check(LocalTime test, int h, int m, int s, int n) { 253 assertEquals(test.getHour(), h); 254 assertEquals(test.getMinute(), m); 255 assertEquals(test.getSecond(), s); 256 assertEquals(test.getNano(), n); 257 assertEquals(test, test); 258 assertEquals(test.hashCode(), test.hashCode()); 259 assertEquals(LocalTime.of(h, m, s, n), test); 260 } 261 262 //----------------------------------------------------------------------- 263 // constants 264 //----------------------------------------------------------------------- 265 @Test 266 public void constant_MIDNIGHT() { 267 check(LocalTime.MIDNIGHT, 0, 0, 0, 0); 268 } 269 270 @Test 271 public void constant_MIDDAY() { 272 check(LocalTime.NOON, 12, 0, 0, 0); 273 } 274 275 @Test 276 public void constant_MIN() { 277 check(LocalTime.MIN, 0, 0, 0, 0); 278 } 279 280 @Test 281 public void constant_MAX() { 282 check(LocalTime.MAX, 23, 59, 59, 999999999); 283 } 284 285 //----------------------------------------------------------------------- 286 // now() 287 //----------------------------------------------------------------------- 288 @Test 289 public void now() { 290 LocalTime expected = LocalTime.now(Clock.systemDefaultZone()); 291 LocalTime test = LocalTime.now(); 292 long diff = Math.abs(test.toNanoOfDay() - expected.toNanoOfDay()); 293 assertTrue(diff < 100000000); // less than 0.1 secs 294 } 295 296 //----------------------------------------------------------------------- 297 // now(ZoneId) 298 //----------------------------------------------------------------------- 299 @Test(expectedExceptions=NullPointerException.class) 300 public void now_ZoneId_nullZoneId() { 301 LocalTime.now((ZoneId) null); 302 } 303 304 @Test 305 public void now_ZoneId() { 306 ZoneId zone = ZoneId.of("UTC+01:02:03"); 307 LocalTime expected = LocalTime.now(Clock.system(zone)); 308 LocalTime test = LocalTime.now(zone); 309 for (int i = 0; i < 100; i++) { 310 if (expected.equals(test)) { 311 return; 312 } 313 expected = LocalTime.now(Clock.system(zone)); 314 test = LocalTime.now(zone); 315 } 316 assertEquals(test, expected); 317 } 318 319 //----------------------------------------------------------------------- 320 // now(Clock) 321 //----------------------------------------------------------------------- 322 @Test(expectedExceptions=NullPointerException.class) 323 public void now_Clock_nullClock() { 324 LocalTime.now((Clock) null); 325 } 326 327 @Test 328 public void now_Clock_allSecsInDay() { 329 for (int i = 0; i < (2 * 24 * 60 * 60); i++) { 330 Instant instant = Instant.ofEpochSecond(i, 8); 331 Clock clock = Clock.fixed(instant, ZoneOffset.UTC); 332 LocalTime test = LocalTime.now(clock); 333 assertEquals(test.getHour(), (i / (60 * 60)) % 24); 334 assertEquals(test.getMinute(), (i / 60) % 60); 335 assertEquals(test.getSecond(), i % 60); 336 assertEquals(test.getNano(), 8); 337 } 338 } 339 340 @Test 341 public void now_Clock_beforeEpoch() { 342 for (int i =-1; i >= -(24 * 60 * 60); i--) { 343 Instant instant = Instant.ofEpochSecond(i, 8); 344 Clock clock = Clock.fixed(instant, ZoneOffset.UTC); 345 LocalTime test = LocalTime.now(clock); 346 assertEquals(test.getHour(), ((i + 24 * 60 * 60) / (60 * 60)) % 24); 347 assertEquals(test.getMinute(), ((i + 24 * 60 * 60) / 60) % 60); 348 assertEquals(test.getSecond(), (i + 24 * 60 * 60) % 60); 349 assertEquals(test.getNano(), 8); 350 } 351 } 352 353 //----------------------------------------------------------------------- 354 @Test 355 public void now_Clock_max() { 356 Clock clock = Clock.fixed(Instant.MAX, ZoneOffset.UTC); 357 LocalTime test = LocalTime.now(clock); 358 assertEquals(test.getHour(), 23); 359 assertEquals(test.getMinute(), 59); 360 assertEquals(test.getSecond(), 59); 361 assertEquals(test.getNano(), 999_999_999); 362 } 363 364 @Test 365 public void now_Clock_min() { 366 Clock clock = Clock.fixed(Instant.MIN, ZoneOffset.UTC); 367 LocalTime test = LocalTime.now(clock); 368 assertEquals(test.getHour(), 0); 369 assertEquals(test.getMinute(), 0); 370 assertEquals(test.getSecond(), 0); 371 assertEquals(test.getNano(), 0); 372 } 373 374 //----------------------------------------------------------------------- 375 // of() factories 376 //----------------------------------------------------------------------- 377 @Test 378 public void factory_time_2ints() { 379 LocalTime test = LocalTime.of(12, 30); 380 check(test, 12, 30, 0, 0); 381 } 382 383 @Test(expectedExceptions=DateTimeException.class) 384 public void factory_time_2ints_hourTooLow() { 385 LocalTime.of(-1, 0); 386 } 387 388 @Test(expectedExceptions=DateTimeException.class) 389 public void factory_time_2ints_hourTooHigh() { 390 LocalTime.of(24, 0); 391 } 392 393 @Test(expectedExceptions=DateTimeException.class) 394 public void factory_time_2ints_minuteTooLow() { 395 LocalTime.of(0, -1); 396 } 397 398 @Test(expectedExceptions=DateTimeException.class) 399 public void factory_time_2ints_minuteTooHigh() { 400 LocalTime.of(0, 60); 401 } 402 403 //----------------------------------------------------------------------- 404 @Test 405 public void factory_time_3ints() { 406 LocalTime test = LocalTime.of(12, 30, 40); 407 check(test, 12, 30, 40, 0); 408 } 409 410 @Test(expectedExceptions=DateTimeException.class) 411 public void factory_time_3ints_hourTooLow() { 412 LocalTime.of(-1, 0, 0); 413 } 414 415 @Test(expectedExceptions=DateTimeException.class) 416 public void factory_time_3ints_hourTooHigh() { 417 LocalTime.of(24, 0, 0); 418 } 419 420 @Test(expectedExceptions=DateTimeException.class) 421 public void factory_time_3ints_minuteTooLow() { 422 LocalTime.of(0, -1, 0); 423 } 424 425 @Test(expectedExceptions=DateTimeException.class) 426 public void factory_time_3ints_minuteTooHigh() { 427 LocalTime.of(0, 60, 0); 428 } 429 430 @Test(expectedExceptions=DateTimeException.class) 431 public void factory_time_3ints_secondTooLow() { 432 LocalTime.of(0, 0, -1); 433 } 434 435 @Test(expectedExceptions=DateTimeException.class) 436 public void factory_time_3ints_secondTooHigh() { 437 LocalTime.of(0, 0, 60); 438 } 439 440 //----------------------------------------------------------------------- 441 @Test 442 public void factory_time_4ints() { 443 LocalTime test = LocalTime.of(12, 30, 40, 987654321); 444 check(test, 12, 30, 40, 987654321); 445 test = LocalTime.of(12, 0, 40, 987654321); 446 check(test, 12, 0, 40, 987654321); 447 } 448 449 @Test(expectedExceptions=DateTimeException.class) 450 public void factory_time_4ints_hourTooLow() { 451 LocalTime.of(-1, 0, 0, 0); 452 } 453 454 @Test(expectedExceptions=DateTimeException.class) 455 public void factory_time_4ints_hourTooHigh() { 456 LocalTime.of(24, 0, 0, 0); 457 } 458 459 @Test(expectedExceptions=DateTimeException.class) 460 public void factory_time_4ints_minuteTooLow() { 461 LocalTime.of(0, -1, 0, 0); 462 } 463 464 @Test(expectedExceptions=DateTimeException.class) 465 public void factory_time_4ints_minuteTooHigh() { 466 LocalTime.of(0, 60, 0, 0); 467 } 468 469 @Test(expectedExceptions=DateTimeException.class) 470 public void factory_time_4ints_secondTooLow() { 471 LocalTime.of(0, 0, -1, 0); 472 } 473 474 @Test(expectedExceptions=DateTimeException.class) 475 public void factory_time_4ints_secondTooHigh() { 476 LocalTime.of(0, 0, 60, 0); 477 } 478 479 @Test(expectedExceptions=DateTimeException.class) 480 public void factory_time_4ints_nanoTooLow() { 481 LocalTime.of(0, 0, 0, -1); 482 } 483 484 @Test(expectedExceptions=DateTimeException.class) 485 public void factory_time_4ints_nanoTooHigh() { 486 LocalTime.of(0, 0, 0, 1000000000); 487 } 488 489 //----------------------------------------------------------------------- 490 // ofSecondOfDay(long) 491 //----------------------------------------------------------------------- 492 @Test 493 public void factory_ofSecondOfDay() { 494 LocalTime localTime = LocalTime.ofSecondOfDay(2 * 60 * 60 + 17 * 60 + 23); 495 check(localTime, 2, 17, 23, 0); 496 } 497 498 @Test(expectedExceptions=DateTimeException.class) 499 public void factory_ofSecondOfDay_tooLow() { 500 LocalTime.ofSecondOfDay(-1); 501 } 502 503 @Test(expectedExceptions=DateTimeException.class) 504 public void factory_ofSecondOfDay_tooHigh() { 505 LocalTime.ofSecondOfDay(24 * 60 * 60); 506 } 507 508 //----------------------------------------------------------------------- 509 // ofNanoOfDay(long) 510 //----------------------------------------------------------------------- 511 @Test 512 public void factory_ofNanoOfDay() { 513 LocalTime localTime = LocalTime.ofNanoOfDay(60 * 60 * 1000000000L + 17); 514 check(localTime, 1, 0, 0, 17); 515 } 516 517 @Test(expectedExceptions=DateTimeException.class) 518 public void factory_ofNanoOfDay_tooLow() { 519 LocalTime.ofNanoOfDay(-1); 520 } 521 522 @Test(expectedExceptions=DateTimeException.class) 523 public void factory_ofNanoOfDay_tooHigh() { 524 LocalTime.ofNanoOfDay(24 * 60 * 60 * 1000000000L); 525 } 526 527 //----------------------------------------------------------------------- 528 // from() 529 //----------------------------------------------------------------------- 530 @Test 531 public void factory_from_TemporalAccessor() { 532 assertEquals(LocalTime.from(LocalTime.of(17, 30)), LocalTime.of(17, 30)); 533 assertEquals(LocalTime.from(LocalDateTime.of(2012, 5, 1, 17, 30)), LocalTime.of(17, 30)); 534 } 535 536 @Test(expectedExceptions=DateTimeException.class) 537 public void factory_from_TemporalAccessor_invalid_noDerive() { 538 LocalTime.from(LocalDate.of(2007, 7, 15)); 539 } 540 541 @Test(expectedExceptions=NullPointerException.class) 542 public void factory_from_TemporalAccessor_null() { 543 LocalTime.from((TemporalAccessor) null); 544 } 545 546 //----------------------------------------------------------------------- 547 // parse() 548 //----------------------------------------------------------------------- 549 @Test(dataProvider = "sampleToString") 550 public void factory_parse_validText(int h, int m, int s, int n, String parsable) { 551 LocalTime t = LocalTime.parse(parsable); 552 assertNotNull(t, parsable); 553 assertEquals(t.getHour(), h); 554 assertEquals(t.getMinute(), m); 555 assertEquals(t.getSecond(), s); 556 assertEquals(t.getNano(), n); 557 } 558 559 @DataProvider(name="sampleBadParse") 560 Object[][] provider_sampleBadParse() { 561 return new Object[][]{ 562 {"00;00"}, 563 {"12-00"}, 564 {"-01:00"}, 565 {"00:00:00-09"}, 566 {"00:00:00,09"}, 567 {"00:00:abs"}, 568 {"11"}, 569 {"11:30+01:00"}, 570 {"11:30+01:00[Europe/Paris]"}, 571 }; 572 } 573 574 @Test(dataProvider = "sampleBadParse", expectedExceptions={DateTimeParseException.class}) 575 public void factory_parse_invalidText(String unparsable) { 576 LocalTime.parse(unparsable); 577 } 578 579 //-----------------------------------------------------------------------s 580 @Test(expectedExceptions=DateTimeParseException.class) 581 public void factory_parse_illegalHour() { 582 LocalTime.parse("25:00"); 583 } 584 585 @Test(expectedExceptions=DateTimeParseException.class) 586 public void factory_parse_illegalMinute() { 587 LocalTime.parse("12:60"); 588 } 589 590 @Test(expectedExceptions=DateTimeParseException.class) 591 public void factory_parse_illegalSecond() { 592 LocalTime.parse("12:12:60"); 593 } 594 595 //-----------------------------------------------------------------------s 596 @Test(expectedExceptions = {NullPointerException.class}) 597 public void factory_parse_nullTest() { 598 LocalTime.parse((String) null); 599 } 600 601 //----------------------------------------------------------------------- 602 // parse(DateTimeFormatter) 603 //----------------------------------------------------------------------- 604 @Test 605 public void factory_parse_formatter() { 606 DateTimeFormatter f = DateTimeFormatter.ofPattern("H m s"); 607 LocalTime test = LocalTime.parse("14 30 40", f); 608 assertEquals(test, LocalTime.of(14, 30, 40)); 609 } 610 611 @Test(expectedExceptions=NullPointerException.class) 612 public void factory_parse_formatter_nullText() { 613 DateTimeFormatter f = DateTimeFormatter.ofPattern("H m s"); 614 LocalTime.parse((String) null, f); 615 } 616 617 @Test(expectedExceptions=NullPointerException.class) 618 public void factory_parse_formatter_nullFormatter() { 619 LocalTime.parse("ANY", null); 620 } 621 622 //----------------------------------------------------------------------- 623 // get(TemporalField) 624 //----------------------------------------------------------------------- 625 @Test 626 public void test_get_TemporalField() { 627 LocalTime test = TEST_12_30_40_987654321; 628 assertEquals(test.get(ChronoField.HOUR_OF_DAY), 12); 629 assertEquals(test.get(ChronoField.MINUTE_OF_HOUR), 30); 630 assertEquals(test.get(ChronoField.SECOND_OF_MINUTE), 40); 631 assertEquals(test.get(ChronoField.NANO_OF_SECOND), 987654321); 632 633 assertEquals(test.get(ChronoField.SECOND_OF_DAY), 12 * 3600 + 30 * 60 + 40); 634 assertEquals(test.get(ChronoField.MINUTE_OF_DAY), 12 * 60 + 30); 635 assertEquals(test.get(ChronoField.HOUR_OF_AMPM), 0); 636 assertEquals(test.get(ChronoField.CLOCK_HOUR_OF_AMPM), 12); 637 assertEquals(test.get(ChronoField.CLOCK_HOUR_OF_DAY), 12); 643 LocalTime test = TEST_12_30_40_987654321; 644 assertEquals(test.getLong(ChronoField.HOUR_OF_DAY), 12); 645 assertEquals(test.getLong(ChronoField.MINUTE_OF_HOUR), 30); 646 assertEquals(test.getLong(ChronoField.SECOND_OF_MINUTE), 40); 647 assertEquals(test.getLong(ChronoField.NANO_OF_SECOND), 987654321); 648 649 assertEquals(test.getLong(ChronoField.SECOND_OF_DAY), 12 * 3600 + 30 * 60 + 40); 650 assertEquals(test.getLong(ChronoField.MINUTE_OF_DAY), 12 * 60 + 30); 651 assertEquals(test.getLong(ChronoField.HOUR_OF_AMPM), 0); 652 assertEquals(test.getLong(ChronoField.CLOCK_HOUR_OF_AMPM), 12); 653 assertEquals(test.getLong(ChronoField.CLOCK_HOUR_OF_DAY), 12); 654 assertEquals(test.getLong(ChronoField.AMPM_OF_DAY), 1); 655 } 656 657 //----------------------------------------------------------------------- 658 // query(TemporalQuery) 659 //----------------------------------------------------------------------- 660 @DataProvider(name="query") 661 Object[][] data_query() { 662 return new Object[][] { 663 {TEST_12_30_40_987654321, TemporalQuery.chronology(), null}, 664 {TEST_12_30_40_987654321, TemporalQuery.zoneId(), null}, 665 {TEST_12_30_40_987654321, TemporalQuery.precision(), ChronoUnit.NANOS}, 666 {TEST_12_30_40_987654321, TemporalQuery.zone(), null}, 667 {TEST_12_30_40_987654321, TemporalQuery.offset(), null}, 668 {TEST_12_30_40_987654321, TemporalQuery.localDate(), null}, 669 {TEST_12_30_40_987654321, TemporalQuery.localTime(), TEST_12_30_40_987654321}, 670 }; 671 } 672 673 @Test(dataProvider="query") 674 public <T> void test_query(TemporalAccessor temporal, TemporalQuery<T> query, T expected) { 675 assertEquals(temporal.query(query), expected); 676 } 677 678 @Test(dataProvider="query") 679 public <T> void test_queryFrom(TemporalAccessor temporal, TemporalQuery<T> query, T expected) { 680 assertEquals(query.queryFrom(temporal), expected); 681 } 682 683 @Test(expectedExceptions=NullPointerException.class) 684 public void test_query_null() { 685 TEST_12_30_40_987654321.query(null); 686 } 687 688 //----------------------------------------------------------------------- 689 // get*() 694 {0, 0, 0, 0}, 695 {0, 0, 0, 1}, 696 {0, 0, 1, 0}, 697 {0, 0, 1, 1}, 698 {0, 1, 0, 0}, 699 {0, 1, 0, 1}, 700 {0, 1, 1, 0}, 701 {0, 1, 1, 1}, 702 {1, 0, 0, 0}, 703 {1, 0, 0, 1}, 704 {1, 0, 1, 0}, 705 {1, 0, 1, 1}, 706 {1, 1, 0, 0}, 707 {1, 1, 0, 1}, 708 {1, 1, 1, 0}, 709 {1, 1, 1, 1}, 710 }; 711 } 712 713 //----------------------------------------------------------------------- 714 @Test(dataProvider="sampleTimes") 715 public void test_get(int h, int m, int s, int ns) { 716 LocalTime a = LocalTime.of(h, m, s, ns); 717 assertEquals(a.getHour(), h); 718 assertEquals(a.getMinute(), m); 719 assertEquals(a.getSecond(), s); 720 assertEquals(a.getNano(), ns); 721 } 722 723 //----------------------------------------------------------------------- 724 // adjustInto(Temporal) 725 //----------------------------------------------------------------------- 726 @DataProvider(name="adjustInto") 727 Object[][] data_adjustInto() { 728 return new Object[][]{ 729 {LocalTime.of(23, 5), LocalTime.of(4, 1, 1, 100), LocalTime.of(23, 5, 0, 0), null}, 730 {LocalTime.of(23, 5, 20), LocalTime.of(4, 1, 1, 100), LocalTime.of(23, 5, 20, 0), null}, 731 {LocalTime.of(23, 5, 20, 1000), LocalTime.of(4, 1, 1, 100), LocalTime.of(23, 5, 20, 1000), null}, 732 {LocalTime.of(23, 5, 20, 1000), LocalTime.MAX, LocalTime.of(23, 5, 20, 1000), null}, 733 {LocalTime.of(23, 5, 20, 1000), LocalTime.MIN, LocalTime.of(23, 5, 20, 1000), null}, 734 {LocalTime.of(23, 5, 20, 1000), LocalTime.NOON, LocalTime.of(23, 5, 20, 1000), null}, 735 {LocalTime.of(23, 5, 20, 1000), LocalTime.MIDNIGHT, LocalTime.of(23, 5, 20, 1000), null}, 736 {LocalTime.MAX, LocalTime.of(23, 5, 20, 1000), LocalTime.of(23, 59, 59, 999999999), null}, 737 {LocalTime.MIN, LocalTime.of(23, 5, 20, 1000), LocalTime.of(0, 0, 0), null}, 738 {LocalTime.NOON, LocalTime.of(23, 5, 20, 1000), LocalTime.of(12, 0, 0), null}, 739 {LocalTime.MIDNIGHT, LocalTime.of(23, 5, 20, 1000), LocalTime.of(0, 0, 0), null}, 740 741 {LocalTime.of(23, 5), LocalDateTime.of(2210, 2, 2, 1, 1), LocalDateTime.of(2210, 2, 2, 23, 5), null}, 742 {LocalTime.of(23, 5), OffsetTime.of(1, 1, 0, 0, OFFSET_PTWO), OffsetTime.of(23, 5, 0, 0, OFFSET_PTWO), null}, 743 {LocalTime.of(23, 5), OffsetDateTime.of(2210, 2, 2, 1, 1, 0, 0, OFFSET_PTWO), OffsetDateTime.of(2210, 2, 2, 23, 5, 0, 0, OFFSET_PTWO), null}, 744 {LocalTime.of(23, 5), ZonedDateTime.of(2210, 2, 2, 1, 1, 0, 0, ZONE_PARIS), ZonedDateTime.of(2210, 2, 2, 23, 5, 0, 0, ZONE_PARIS), null}, 745 746 {LocalTime.of(23, 5), LocalDate.of(2210, 2, 2), null, DateTimeException.class}, 747 {LocalTime.of(23, 5), null, null, NullPointerException.class}, 748 749 }; 750 } 751 752 @Test(dataProvider="adjustInto") 753 public void test_adjustInto(LocalTime test, Temporal temporal, Temporal expected, Class<?> expectedEx) { 754 if (expectedEx == null) { 755 Temporal result = test.adjustInto(temporal); 756 assertEquals(result, expected); 757 } else { 758 try { 759 Temporal result = test.adjustInto(temporal); 760 fail(); 761 } catch (Exception ex) { 762 assertTrue(expectedEx.isInstance(ex)); 763 } 764 } 765 } 766 767 //----------------------------------------------------------------------- 768 // with() 769 //----------------------------------------------------------------------- 770 @Test 771 public void test_with_adjustment() { 772 final LocalTime sample = LocalTime.of(23, 5); 773 TemporalAdjuster adjuster = new TemporalAdjuster() { 774 @Override 775 public Temporal adjustInto(Temporal dateTime) { 776 return sample; 777 } 778 }; 779 assertEquals(TEST_12_30_40_987654321.with(adjuster), sample); 780 } 781 782 @Test(expectedExceptions=NullPointerException.class) 783 public void test_with_adjustment_null() { 784 TEST_12_30_40_987654321.with((TemporalAdjuster) null); 785 } 786 787 //----------------------------------------------------------------------- 788 // withHour() 789 //----------------------------------------------------------------------- 790 @Test 791 public void test_withHour_normal() { 792 LocalTime t = TEST_12_30_40_987654321; 793 for (int i = 0; i < 24; i++) { 794 t = t.withHour(i); 795 assertEquals(t.getHour(), i); 796 } 797 } 798 799 @Test 800 public void test_withHour_noChange_equal() { 801 LocalTime t = TEST_12_30_40_987654321.withHour(12); 802 assertEquals(t, TEST_12_30_40_987654321); 803 } 804 805 @Test 806 public void test_withHour_toMidnight_equal() { 807 LocalTime t = LocalTime.of(1, 0).withHour(0); 808 assertEquals(t, LocalTime.MIDNIGHT); 809 } 810 811 @Test 812 public void test_withHour_toMidday_equal() { 813 LocalTime t = LocalTime.of(1, 0).withHour(12); 814 assertEquals(t, LocalTime.NOON); 815 } 816 817 @Test(expectedExceptions=DateTimeException.class) 818 public void test_withHour_hourTooLow() { 819 TEST_12_30_40_987654321.withHour(-1); 820 } 821 822 @Test(expectedExceptions=DateTimeException.class) 823 public void test_withHour_hourTooHigh() { 824 TEST_12_30_40_987654321.withHour(24); 825 } 826 827 //----------------------------------------------------------------------- 828 // withMinute() 829 //----------------------------------------------------------------------- 830 @Test 831 public void test_withMinute_normal() { 832 LocalTime t = TEST_12_30_40_987654321; 833 for (int i = 0; i < 60; i++) { 834 t = t.withMinute(i); 835 assertEquals(t.getMinute(), i); 836 } 837 } 838 839 @Test 840 public void test_withMinute_noChange_equal() { 841 LocalTime t = TEST_12_30_40_987654321.withMinute(30); 842 assertEquals(t, TEST_12_30_40_987654321); 843 } 844 845 @Test 846 public void test_withMinute_toMidnight_equal() { 847 LocalTime t = LocalTime.of(0, 1).withMinute(0); 848 assertEquals(t, LocalTime.MIDNIGHT); 849 } 850 851 @Test 852 public void test_withMinute_toMidday_equals() { 853 LocalTime t = LocalTime.of(12, 1).withMinute(0); 854 assertEquals(t, LocalTime.NOON); 855 } 856 857 @Test(expectedExceptions=DateTimeException.class) 858 public void test_withMinute_minuteTooLow() { 859 TEST_12_30_40_987654321.withMinute(-1); 860 } 861 862 @Test(expectedExceptions=DateTimeException.class) 863 public void test_withMinute_minuteTooHigh() { 864 TEST_12_30_40_987654321.withMinute(60); 865 } 866 867 //----------------------------------------------------------------------- 868 // withSecond() 869 //----------------------------------------------------------------------- 870 @Test 871 public void test_withSecond_normal() { 872 LocalTime t = TEST_12_30_40_987654321; 873 for (int i = 0; i < 60; i++) { 874 t = t.withSecond(i); 875 assertEquals(t.getSecond(), i); 876 } 877 } 878 879 @Test 880 public void test_withSecond_noChange_equal() { 881 LocalTime t = TEST_12_30_40_987654321.withSecond(40); 882 assertEquals(t, TEST_12_30_40_987654321); 883 } 884 885 @Test 886 public void test_withSecond_toMidnight_equal() { 887 LocalTime t = LocalTime.of(0, 0, 1).withSecond(0); 888 assertEquals(t, LocalTime.MIDNIGHT); 889 } 890 891 @Test 892 public void test_withSecond_toMidday_equal() { 893 LocalTime t = LocalTime.of(12, 0, 1).withSecond(0); 894 assertEquals(t, LocalTime.NOON); 895 } 896 897 @Test(expectedExceptions=DateTimeException.class) 898 public void test_withSecond_secondTooLow() { 899 TEST_12_30_40_987654321.withSecond(-1); 900 } 901 902 @Test(expectedExceptions=DateTimeException.class) 903 public void test_withSecond_secondTooHigh() { 904 TEST_12_30_40_987654321.withSecond(60); 905 } 906 907 //----------------------------------------------------------------------- 908 // withNano() 909 //----------------------------------------------------------------------- 910 @Test 911 public void test_withNanoOfSecond_normal() { 912 LocalTime t = TEST_12_30_40_987654321; 913 t = t.withNano(1); 914 assertEquals(t.getNano(), 1); 915 t = t.withNano(10); 916 assertEquals(t.getNano(), 10); 917 t = t.withNano(100); 918 assertEquals(t.getNano(), 100); 919 t = t.withNano(999999999); 920 assertEquals(t.getNano(), 999999999); 921 } 922 923 @Test 924 public void test_withNanoOfSecond_noChange_equal() { 925 LocalTime t = TEST_12_30_40_987654321.withNano(987654321); 926 assertEquals(t, TEST_12_30_40_987654321); 927 } 928 929 @Test 930 public void test_withNanoOfSecond_toMidnight_equal() { 931 LocalTime t = LocalTime.of(0, 0, 0, 1).withNano(0); 932 assertEquals(t, LocalTime.MIDNIGHT); 933 } 934 935 @Test 936 public void test_withNanoOfSecond_toMidday_equal() { 937 LocalTime t = LocalTime.of(12, 0, 0, 1).withNano(0); 938 assertEquals(t, LocalTime.NOON); 939 } 940 941 @Test(expectedExceptions=DateTimeException.class) 942 public void test_withNanoOfSecond_nanoTooLow() { 943 TEST_12_30_40_987654321.withNano(-1); 944 } 945 946 @Test(expectedExceptions=DateTimeException.class) 947 public void test_withNanoOfSecond_nanoTooHigh() { 948 TEST_12_30_40_987654321.withNano(1000000000); 949 } 950 951 //----------------------------------------------------------------------- 952 // truncated(TemporalUnit) 953 //----------------------------------------------------------------------- 954 TemporalUnit NINETY_MINS = new TemporalUnit() { 955 @Override 956 public String getName() { 957 return "NinetyMins"; 958 } 959 @Override 960 public Duration getDuration() { 961 return Duration.ofMinutes(90); 962 } 963 @Override 964 public boolean isDurationEstimated() { 965 return false; 966 } 1005 } 1006 }; 1007 1008 @DataProvider(name="truncatedToValid") 1009 Object[][] data_truncatedToValid() { 1010 return new Object[][] { 1011 {LocalTime.of(1, 2, 3, 123_456_789), NANOS, LocalTime.of(1, 2, 3, 123_456_789)}, 1012 {LocalTime.of(1, 2, 3, 123_456_789), MICROS, LocalTime.of(1, 2, 3, 123_456_000)}, 1013 {LocalTime.of(1, 2, 3, 123_456_789), MILLIS, LocalTime.of(1, 2, 3, 1230_00_000)}, 1014 {LocalTime.of(1, 2, 3, 123_456_789), SECONDS, LocalTime.of(1, 2, 3)}, 1015 {LocalTime.of(1, 2, 3, 123_456_789), MINUTES, LocalTime.of(1, 2)}, 1016 {LocalTime.of(1, 2, 3, 123_456_789), HOURS, LocalTime.of(1, 0)}, 1017 {LocalTime.of(1, 2, 3, 123_456_789), DAYS, LocalTime.MIDNIGHT}, 1018 1019 {LocalTime.of(1, 1, 1, 123_456_789), NINETY_MINS, LocalTime.of(0, 0)}, 1020 {LocalTime.of(2, 1, 1, 123_456_789), NINETY_MINS, LocalTime.of(1, 30)}, 1021 {LocalTime.of(3, 1, 1, 123_456_789), NINETY_MINS, LocalTime.of(3, 0)}, 1022 }; 1023 } 1024 1025 @Test(dataProvider="truncatedToValid") 1026 public void test_truncatedTo_valid(LocalTime input, TemporalUnit unit, LocalTime expected) { 1027 assertEquals(input.truncatedTo(unit), expected); 1028 } 1029 1030 @DataProvider(name="truncatedToInvalid") 1031 Object[][] data_truncatedToInvalid() { 1032 return new Object[][] { 1033 {LocalTime.of(1, 2, 3, 123_456_789), NINETY_FIVE_MINS}, 1034 {LocalTime.of(1, 2, 3, 123_456_789), WEEKS}, 1035 {LocalTime.of(1, 2, 3, 123_456_789), MONTHS}, 1036 {LocalTime.of(1, 2, 3, 123_456_789), YEARS}, 1037 }; 1038 } 1039 1040 @Test(dataProvider="truncatedToInvalid", expectedExceptions=DateTimeException.class) 1041 public void test_truncatedTo_invalid(LocalTime input, TemporalUnit unit) { 1042 input.truncatedTo(unit); 1043 } 1044 1045 @Test(expectedExceptions=NullPointerException.class) 1046 public void test_truncatedTo_null() { 1047 TEST_12_30_40_987654321.truncatedTo(null); 1048 } 1049 1050 //----------------------------------------------------------------------- 1051 // plus(TemporalAmount) 1052 //----------------------------------------------------------------------- 1053 @Test 1054 public void test_plus_TemporalAmount_positiveHours() { 1055 TemporalAmount period = MockSimplePeriod.of(7, ChronoUnit.HOURS); 1056 LocalTime t = TEST_12_30_40_987654321.plus(period); 1057 assertEquals(t, LocalTime.of(19, 30, 40, 987654321)); 1058 } 1059 1060 @Test 1061 public void test_plus_TemporalAmount_negativeMinutes() { 1062 TemporalAmount period = MockSimplePeriod.of(-25, ChronoUnit.MINUTES); 1063 LocalTime t = TEST_12_30_40_987654321.plus(period); 1064 assertEquals(t, LocalTime.of(12, 5, 40, 987654321)); 1065 } 1075 public void test_plus_TemporalAmount_wrap() { 1076 TemporalAmount p = MockSimplePeriod.of(1, HOURS); 1077 LocalTime t = LocalTime.of(23, 30).plus(p); 1078 assertEquals(t, LocalTime.of(0, 30)); 1079 } 1080 1081 @Test(expectedExceptions=DateTimeException.class) 1082 public void test_plus_TemporalAmount_dateNotAllowed() { 1083 TemporalAmount period = MockSimplePeriod.of(7, ChronoUnit.MONTHS); 1084 TEST_12_30_40_987654321.plus(period); 1085 } 1086 1087 @Test(expectedExceptions=NullPointerException.class) 1088 public void test_plus_TemporalAmount_null() { 1089 TEST_12_30_40_987654321.plus((TemporalAmount) null); 1090 } 1091 1092 //----------------------------------------------------------------------- 1093 // plus(long,TemporalUnit) 1094 //----------------------------------------------------------------------- 1095 @Test 1096 public void test_plus_longTemporalUnit_positiveHours() { 1097 LocalTime t = TEST_12_30_40_987654321.plus(7, ChronoUnit.HOURS); 1098 assertEquals(t, LocalTime.of(19, 30, 40, 987654321)); 1099 } 1100 1101 @Test 1102 public void test_plus_longTemporalUnit_negativeMinutes() { 1103 LocalTime t = TEST_12_30_40_987654321.plus(-25, ChronoUnit.MINUTES); 1104 assertEquals(t, LocalTime.of(12, 5, 40, 987654321)); 1105 } 1106 1107 @Test 1108 public void test_plus_longTemporalUnit_zero() { 1109 LocalTime t = TEST_12_30_40_987654321.plus(0, ChronoUnit.MINUTES); 1110 assertEquals(t, TEST_12_30_40_987654321); 1111 } 1112 1113 @Test 1114 public void test_plus_longTemporalUnit_invalidUnit() { 1115 for (TemporalUnit unit : INVALID_UNITS) { 1116 try { 1117 TEST_12_30_40_987654321.plus(1, unit); 1118 fail("Unit should not be allowed " + unit); 1119 } catch (DateTimeException ex) { 1120 // expected 1121 } 1122 } 1123 } 1124 1125 @Test 1126 public void test_plus_longTemporalUnit_multiples() { 1127 assertEquals(TEST_12_30_40_987654321.plus(0, DAYS), TEST_12_30_40_987654321); 1128 assertEquals(TEST_12_30_40_987654321.plus(1, DAYS), TEST_12_30_40_987654321); 1129 assertEquals(TEST_12_30_40_987654321.plus(2, DAYS), TEST_12_30_40_987654321); 1130 assertEquals(TEST_12_30_40_987654321.plus(-3, DAYS), TEST_12_30_40_987654321); 1131 } 1132 1133 @Test(expectedExceptions=NullPointerException.class) 1134 public void test_plus_longTemporalUnit_null() { 1135 TEST_12_30_40_987654321.plus(1, (TemporalUnit) null); 1136 } 1137 1138 //----------------------------------------------------------------------- 1139 // plusHours() 1140 //----------------------------------------------------------------------- 1141 @Test 1142 public void test_plusHours_one() { 1143 LocalTime t = LocalTime.MIDNIGHT; 1144 for (int i = 0; i < 50; i++) { 1145 t = t.plusHours(1); 1146 assertEquals(t.getHour(), (i + 1) % 24); 1147 } 1148 } 1149 1150 @Test 1151 public void test_plusHours_fromZero() { 1152 LocalTime base = LocalTime.MIDNIGHT; 1153 for (int i = -50; i < 50; i++) { 1154 LocalTime t = base.plusHours(i); 1155 assertEquals(t.getHour(), (i + 72) % 24); 1156 } 1157 } 1158 1159 @Test 1160 public void test_plusHours_fromOne() { 1161 LocalTime base = LocalTime.of(1, 0); 1162 for (int i = -50; i < 50; i++) { 1163 LocalTime t = base.plusHours(i); 1164 assertEquals(t.getHour(), (1 + i + 72) % 24); 1165 } 1166 } 1167 1168 @Test 1169 public void test_plusHours_noChange_equal() { 1170 LocalTime t = TEST_12_30_40_987654321.plusHours(0); 1171 assertEquals(t, TEST_12_30_40_987654321); 1172 } 1173 1174 @Test 1175 public void test_plusHours_toMidnight_equal() { 1176 LocalTime t = LocalTime.of(23, 0).plusHours(1); 1177 assertEquals(t, LocalTime.MIDNIGHT); 1178 } 1179 1180 @Test 1181 public void test_plusHours_toMidday_equal() { 1182 LocalTime t = LocalTime.of(11, 0).plusHours(1); 1183 assertEquals(t, LocalTime.NOON); 1184 } 1185 1186 @Test 1187 public void test_plusHours_big() { 1188 LocalTime t = LocalTime.of(2, 30).plusHours(Long.MAX_VALUE); 1189 int hours = (int) (Long.MAX_VALUE % 24L); 1190 assertEquals(t, LocalTime.of(2, 30).plusHours(hours)); 1191 } 1192 1193 //----------------------------------------------------------------------- 1194 // plusMinutes() 1195 //----------------------------------------------------------------------- 1196 @Test 1197 public void test_plusMinutes_one() { 1198 LocalTime t = LocalTime.MIDNIGHT; 1199 int hour = 0; 1200 int min = 0; 1201 for (int i = 0; i < 70; i++) { 1202 t = t.plusMinutes(1); 1203 min++; 1204 if (min == 60) { 1205 hour++; 1206 min = 0; 1207 } 1208 assertEquals(t.getHour(), hour); 1209 assertEquals(t.getMinute(), min); 1210 } 1211 } 1212 1213 @Test 1214 public void test_plusMinutes_fromZero() { 1215 LocalTime base = LocalTime.MIDNIGHT; 1216 int hour; 1217 int min; 1218 for (int i = -70; i < 70; i++) { 1219 LocalTime t = base.plusMinutes(i); 1220 if (i < -60) { 1221 hour = 22; 1222 min = i + 120; 1223 } else if (i < 0) { 1224 hour = 23; 1225 min = i + 60; 1226 } else if (i >= 60) { 1227 hour = 1; 1228 min = i - 60; 1229 } else { 1230 hour = 0; 1231 min = i; 1232 } 1233 assertEquals(t.getHour(), hour); 1234 assertEquals(t.getMinute(), min); 1235 } 1236 } 1237 1238 @Test 1239 public void test_plusMinutes_noChange_equal() { 1240 LocalTime t = TEST_12_30_40_987654321.plusMinutes(0); 1241 assertEquals(t, TEST_12_30_40_987654321); 1242 } 1243 1244 @Test 1245 public void test_plusMinutes_noChange_oneDay_equal() { 1246 LocalTime t = TEST_12_30_40_987654321.plusMinutes(24 * 60); 1247 assertEquals(t, TEST_12_30_40_987654321); 1248 } 1249 1250 @Test 1251 public void test_plusMinutes_toMidnight_equal() { 1252 LocalTime t = LocalTime.of(23, 59).plusMinutes(1); 1253 assertEquals(t, LocalTime.MIDNIGHT); 1254 } 1255 1256 @Test 1257 public void test_plusMinutes_toMidday_equal() { 1258 LocalTime t = LocalTime.of(11, 59).plusMinutes(1); 1259 assertEquals(t, LocalTime.NOON); 1260 } 1261 1262 @Test 1263 public void test_plusMinutes_big() { 1264 LocalTime t = LocalTime.of(2, 30).plusMinutes(Long.MAX_VALUE); 1265 int mins = (int) (Long.MAX_VALUE % (24L * 60L)); 1266 assertEquals(t, LocalTime.of(2, 30).plusMinutes(mins)); 1267 } 1268 1269 //----------------------------------------------------------------------- 1270 // plusSeconds() 1271 //----------------------------------------------------------------------- 1272 @Test 1273 public void test_plusSeconds_one() { 1274 LocalTime t = LocalTime.MIDNIGHT; 1275 int hour = 0; 1276 int min = 0; 1277 int sec = 0; 1278 for (int i = 0; i < 3700; i++) { 1279 t = t.plusSeconds(1); 1280 sec++; 1281 if (sec == 60) { 1282 min++; 1283 sec = 0; 1284 } 1285 if (min == 60) { 1286 hour++; 1287 min = 0; 1288 } 1289 assertEquals(t.getHour(), hour); 1290 assertEquals(t.getMinute(), min); 1291 assertEquals(t.getSecond(), sec); 1292 } 1316 1317 if (min == 60) { 1318 hour++; 1319 min = 0; 1320 1321 if (hour == 24) { 1322 hour = 0; 1323 } 1324 } 1325 } 1326 1327 return ret; 1328 } 1329 1330 public void remove() { 1331 throw new UnsupportedOperationException(); 1332 } 1333 }; 1334 } 1335 1336 @Test(dataProvider="plusSeconds_fromZero") 1337 public void test_plusSeconds_fromZero(int seconds, int hour, int min, int sec) { 1338 LocalTime base = LocalTime.MIDNIGHT; 1339 LocalTime t = base.plusSeconds(seconds); 1340 1341 assertEquals(hour, t.getHour()); 1342 assertEquals(min, t.getMinute()); 1343 assertEquals(sec, t.getSecond()); 1344 } 1345 1346 @Test 1347 public void test_plusSeconds_noChange_equal() { 1348 LocalTime t = TEST_12_30_40_987654321.plusSeconds(0); 1349 assertEquals(t, TEST_12_30_40_987654321); 1350 } 1351 1352 @Test 1353 public void test_plusSeconds_noChange_oneDay_equal() { 1354 LocalTime t = TEST_12_30_40_987654321.plusSeconds(24 * 60 * 60); 1355 assertEquals(t, TEST_12_30_40_987654321); 1356 } 1357 1358 @Test 1359 public void test_plusSeconds_toMidnight_equal() { 1360 LocalTime t = LocalTime.of(23, 59, 59).plusSeconds(1); 1361 assertEquals(t, LocalTime.MIDNIGHT); 1362 } 1363 1364 @Test 1365 public void test_plusSeconds_toMidday_equal() { 1366 LocalTime t = LocalTime.of(11, 59, 59).plusSeconds(1); 1367 assertEquals(t, LocalTime.NOON); 1368 } 1369 1370 //----------------------------------------------------------------------- 1371 // plusNanos() 1372 //----------------------------------------------------------------------- 1373 @Test 1374 public void test_plusNanos_halfABillion() { 1375 LocalTime t = LocalTime.MIDNIGHT; 1376 int hour = 0; 1377 int min = 0; 1378 int sec = 0; 1379 int nanos = 0; 1380 for (long i = 0; i < 3700 * 1000000000L; i+= 500000000) { 1381 t = t.plusNanos(500000000); 1382 nanos += 500000000; 1383 if (nanos == 1000000000) { 1384 sec++; 1385 nanos = 0; 1386 } 1387 if (sec == 60) { 1388 min++; 1389 sec = 0; 1390 } 1391 if (min == 60) { 1392 hour++; 1393 min = 0; 1429 if (min == 60) { 1430 hour++; 1431 min = 0; 1432 1433 if (hour == 24) { 1434 hour = 0; 1435 } 1436 } 1437 } 1438 } 1439 1440 return ret; 1441 } 1442 1443 public void remove() { 1444 throw new UnsupportedOperationException(); 1445 } 1446 }; 1447 } 1448 1449 @Test(dataProvider="plusNanos_fromZero") 1450 public void test_plusNanos_fromZero(long nanoseconds, int hour, int min, int sec, int nanos) { 1451 LocalTime base = LocalTime.MIDNIGHT; 1452 LocalTime t = base.plusNanos(nanoseconds); 1453 1454 assertEquals(hour, t.getHour()); 1455 assertEquals(min, t.getMinute()); 1456 assertEquals(sec, t.getSecond()); 1457 assertEquals(nanos, t.getNano()); 1458 } 1459 1460 @Test 1461 public void test_plusNanos_noChange_equal() { 1462 LocalTime t = TEST_12_30_40_987654321.plusNanos(0); 1463 assertEquals(t, TEST_12_30_40_987654321); 1464 } 1465 1466 @Test 1467 public void test_plusNanos_noChange_oneDay_equal() { 1468 LocalTime t = TEST_12_30_40_987654321.plusNanos(24 * 60 * 60 * 1000000000L); 1469 assertEquals(t, TEST_12_30_40_987654321); 1470 } 1471 1472 @Test 1473 public void test_plusNanos_toMidnight_equal() { 1474 LocalTime t = LocalTime.of(23, 59, 59, 999999999).plusNanos(1); 1475 assertEquals(t, LocalTime.MIDNIGHT); 1476 } 1477 1478 @Test 1479 public void test_plusNanos_toMidday_equal() { 1480 LocalTime t = LocalTime.of(11, 59, 59, 999999999).plusNanos(1); 1481 assertEquals(t, LocalTime.NOON); 1482 } 1483 1484 //----------------------------------------------------------------------- 1485 // minus(TemporalAmount) 1486 //----------------------------------------------------------------------- 1487 @Test 1488 public void test_minus_TemporalAmount_positiveHours() { 1489 TemporalAmount period = MockSimplePeriod.of(7, ChronoUnit.HOURS); 1490 LocalTime t = TEST_12_30_40_987654321.minus(period); 1491 assertEquals(t, LocalTime.of(5, 30, 40, 987654321)); 1492 } 1493 1494 @Test 1495 public void test_minus_TemporalAmount_negativeMinutes() { 1496 TemporalAmount period = MockSimplePeriod.of(-25, ChronoUnit.MINUTES); 1497 LocalTime t = TEST_12_30_40_987654321.minus(period); 1498 assertEquals(t, LocalTime.of(12, 55, 40, 987654321)); 1509 public void test_minus_TemporalAmount_wrap() { 1510 TemporalAmount p = MockSimplePeriod.of(1, HOURS); 1511 LocalTime t = LocalTime.of(0, 30).minus(p); 1512 assertEquals(t, LocalTime.of(23, 30)); 1513 } 1514 1515 @Test(expectedExceptions=DateTimeException.class) 1516 public void test_minus_TemporalAmount_dateNotAllowed() { 1517 TemporalAmount period = MockSimplePeriod.of(7, ChronoUnit.MONTHS); 1518 TEST_12_30_40_987654321.minus(period); 1519 } 1520 1521 @Test(expectedExceptions=NullPointerException.class) 1522 public void test_minus_TemporalAmount_null() { 1523 TEST_12_30_40_987654321.minus((TemporalAmount) null); 1524 } 1525 1526 //----------------------------------------------------------------------- 1527 // minus(long,TemporalUnit) 1528 //----------------------------------------------------------------------- 1529 @Test 1530 public void test_minus_longTemporalUnit_positiveHours() { 1531 LocalTime t = TEST_12_30_40_987654321.minus(7, ChronoUnit.HOURS); 1532 assertEquals(t, LocalTime.of(5, 30, 40, 987654321)); 1533 } 1534 1535 @Test 1536 public void test_minus_longTemporalUnit_negativeMinutes() { 1537 LocalTime t = TEST_12_30_40_987654321.minus(-25, ChronoUnit.MINUTES); 1538 assertEquals(t, LocalTime.of(12, 55, 40, 987654321)); 1539 } 1540 1541 @Test 1542 public void test_minus_longTemporalUnit_zero() { 1543 LocalTime t = TEST_12_30_40_987654321.minus(0, ChronoUnit.MINUTES); 1544 assertEquals(t, TEST_12_30_40_987654321); 1545 } 1546 1547 @Test 1548 public void test_minus_longTemporalUnit_invalidUnit() { 1549 for (TemporalUnit unit : INVALID_UNITS) { 1550 try { 1551 TEST_12_30_40_987654321.minus(1, unit); 1552 fail("Unit should not be allowed " + unit); 1553 } catch (DateTimeException ex) { 1554 // expected 1555 } 1556 } 1557 } 1558 1559 @Test 1560 public void test_minus_longTemporalUnit_long_multiples() { 1561 assertEquals(TEST_12_30_40_987654321.minus(0, DAYS), TEST_12_30_40_987654321); 1562 assertEquals(TEST_12_30_40_987654321.minus(1, DAYS), TEST_12_30_40_987654321); 1563 assertEquals(TEST_12_30_40_987654321.minus(2, DAYS), TEST_12_30_40_987654321); 1564 assertEquals(TEST_12_30_40_987654321.minus(-3, DAYS), TEST_12_30_40_987654321); 1565 } 1566 1567 @Test(expectedExceptions=NullPointerException.class) 1568 public void test_minus_longTemporalUnit_null() { 1569 TEST_12_30_40_987654321.minus(1, (TemporalUnit) null); 1570 } 1571 1572 //----------------------------------------------------------------------- 1573 // minusHours() 1574 //----------------------------------------------------------------------- 1575 @Test 1576 public void test_minusHours_one() { 1577 LocalTime t = LocalTime.MIDNIGHT; 1578 for (int i = 0; i < 50; i++) { 1579 t = t.minusHours(1); 1580 assertEquals(t.getHour(), (((-i + 23) % 24) + 24) % 24, String.valueOf(i)); 1581 } 1582 } 1583 1584 @Test 1585 public void test_minusHours_fromZero() { 1586 LocalTime base = LocalTime.MIDNIGHT; 1587 for (int i = -50; i < 50; i++) { 1588 LocalTime t = base.minusHours(i); 1589 assertEquals(t.getHour(), ((-i % 24) + 24) % 24); 1590 } 1591 } 1592 1593 @Test 1594 public void test_minusHours_fromOne() { 1595 LocalTime base = LocalTime.of(1, 0); 1596 for (int i = -50; i < 50; i++) { 1597 LocalTime t = base.minusHours(i); 1598 assertEquals(t.getHour(), (1 + (-i % 24) + 24) % 24); 1599 } 1600 } 1601 1602 @Test 1603 public void test_minusHours_noChange_equal() { 1604 LocalTime t = TEST_12_30_40_987654321.minusHours(0); 1605 assertEquals(t, TEST_12_30_40_987654321); 1606 } 1607 1608 @Test 1609 public void test_minusHours_toMidnight_equal() { 1610 LocalTime t = LocalTime.of(1, 0).minusHours(1); 1611 assertEquals(t, LocalTime.MIDNIGHT); 1612 } 1613 1614 @Test 1615 public void test_minusHours_toMidday_equal() { 1616 LocalTime t = LocalTime.of(13, 0).minusHours(1); 1617 assertEquals(t, LocalTime.NOON); 1618 } 1619 1620 @Test 1621 public void test_minusHours_big() { 1622 LocalTime t = LocalTime.of(2, 30).minusHours(Long.MAX_VALUE); 1623 int hours = (int) (Long.MAX_VALUE % 24L); 1624 assertEquals(t, LocalTime.of(2, 30).minusHours(hours)); 1625 } 1626 1627 //----------------------------------------------------------------------- 1628 // minusMinutes() 1629 //----------------------------------------------------------------------- 1630 @Test 1631 public void test_minusMinutes_one() { 1632 LocalTime t = LocalTime.MIDNIGHT; 1633 int hour = 0; 1634 int min = 0; 1635 for (int i = 0; i < 70; i++) { 1636 t = t.minusMinutes(1); 1637 min--; 1638 if (min == -1) { 1639 hour--; 1640 min = 59; 1641 1642 if (hour == -1) { 1643 hour = 23; 1644 } 1645 } 1646 assertEquals(t.getHour(), hour); 1647 assertEquals(t.getMinute(), min); 1648 } 1649 } 1650 1651 @Test 1652 public void test_minusMinutes_fromZero() { 1653 LocalTime base = LocalTime.MIDNIGHT; 1654 int hour = 22; 1655 int min = 49; 1656 for (int i = 70; i > -70; i--) { 1657 LocalTime t = base.minusMinutes(i); 1658 min++; 1659 1660 if (min == 60) { 1661 hour++; 1662 min = 0; 1663 1664 if (hour == 24) { 1665 hour = 0; 1666 } 1667 } 1668 1669 assertEquals(t.getHour(), hour); 1670 assertEquals(t.getMinute(), min); 1671 } 1672 } 1673 1674 @Test 1675 public void test_minusMinutes_noChange_equal() { 1676 LocalTime t = TEST_12_30_40_987654321.minusMinutes(0); 1677 assertEquals(t, TEST_12_30_40_987654321); 1678 } 1679 1680 @Test 1681 public void test_minusMinutes_noChange_oneDay_equal() { 1682 LocalTime t = TEST_12_30_40_987654321.minusMinutes(24 * 60); 1683 assertEquals(t, TEST_12_30_40_987654321); 1684 } 1685 1686 @Test 1687 public void test_minusMinutes_toMidnight_equal() { 1688 LocalTime t = LocalTime.of(0, 1).minusMinutes(1); 1689 assertEquals(t, LocalTime.MIDNIGHT); 1690 } 1691 1692 @Test 1693 public void test_minusMinutes_toMidday_equals() { 1694 LocalTime t = LocalTime.of(12, 1).minusMinutes(1); 1695 assertEquals(t, LocalTime.NOON); 1696 } 1697 1698 @Test 1699 public void test_minusMinutes_big() { 1700 LocalTime t = LocalTime.of(2, 30).minusMinutes(Long.MAX_VALUE); 1701 int mins = (int) (Long.MAX_VALUE % (24L * 60L)); 1702 assertEquals(t, LocalTime.of(2, 30).minusMinutes(mins)); 1703 } 1704 1705 //----------------------------------------------------------------------- 1706 // minusSeconds() 1707 //----------------------------------------------------------------------- 1708 @Test 1709 public void test_minusSeconds_one() { 1710 LocalTime t = LocalTime.MIDNIGHT; 1711 int hour = 0; 1712 int min = 0; 1713 int sec = 0; 1714 for (int i = 0; i < 3700; i++) { 1715 t = t.minusSeconds(1); 1716 sec--; 1717 if (sec == -1) { 1718 min--; 1719 sec = 59; 1720 1721 if (min == -1) { 1722 hour--; 1723 min = 59; 1724 1725 if (hour == -1) { 1726 hour = 23; 1727 } 1728 } 1757 1758 if (min == 60) { 1759 hour++; 1760 min = 0; 1761 1762 if (hour == 24) { 1763 hour = 0; 1764 } 1765 } 1766 } 1767 1768 return ret; 1769 } 1770 1771 public void remove() { 1772 throw new UnsupportedOperationException(); 1773 } 1774 }; 1775 } 1776 1777 @Test(dataProvider="minusSeconds_fromZero") 1778 public void test_minusSeconds_fromZero(int seconds, int hour, int min, int sec) { 1779 LocalTime base = LocalTime.MIDNIGHT; 1780 LocalTime t = base.minusSeconds(seconds); 1781 1782 assertEquals(t.getHour(), hour); 1783 assertEquals(t.getMinute(), min); 1784 assertEquals(t.getSecond(), sec); 1785 } 1786 1787 @Test 1788 public void test_minusSeconds_noChange_equal() { 1789 LocalTime t = TEST_12_30_40_987654321.minusSeconds(0); 1790 assertEquals(t, TEST_12_30_40_987654321); 1791 } 1792 1793 @Test 1794 public void test_minusSeconds_noChange_oneDay_equal() { 1795 LocalTime t = TEST_12_30_40_987654321.minusSeconds(24 * 60 * 60); 1796 assertEquals(t, TEST_12_30_40_987654321); 1797 } 1798 1799 @Test 1800 public void test_minusSeconds_toMidnight_equal() { 1801 LocalTime t = LocalTime.of(0, 0, 1).minusSeconds(1); 1802 assertEquals(t, LocalTime.MIDNIGHT); 1803 } 1804 1805 @Test 1806 public void test_minusSeconds_toMidday_equal() { 1807 LocalTime t = LocalTime.of(12, 0, 1).minusSeconds(1); 1808 assertEquals(t, LocalTime.NOON); 1809 } 1810 1811 @Test 1812 public void test_minusSeconds_big() { 1813 LocalTime t = LocalTime.of(2, 30).minusSeconds(Long.MAX_VALUE); 1814 int secs = (int) (Long.MAX_VALUE % (24L * 60L * 60L)); 1815 assertEquals(t, LocalTime.of(2, 30).minusSeconds(secs)); 1816 } 1817 1818 //----------------------------------------------------------------------- 1819 // minusNanos() 1820 //----------------------------------------------------------------------- 1821 @Test 1822 public void test_minusNanos_halfABillion() { 1823 LocalTime t = LocalTime.MIDNIGHT; 1824 int hour = 0; 1825 int min = 0; 1826 int sec = 0; 1827 int nanos = 0; 1828 for (long i = 0; i < 3700 * 1000000000L; i+= 500000000) { 1829 t = t.minusNanos(500000000); 1830 nanos -= 500000000; 1831 1832 if (nanos < 0) { 1833 sec--; 1834 nanos += 1000000000; 1835 1836 if (sec == -1) { 1837 min--; 1838 sec += 60; 1839 1840 if (min == -1) { 1841 hour--; 1885 if (min == 60) { 1886 hour++; 1887 min = 0; 1888 1889 if (hour == 24) { 1890 hour = 0; 1891 } 1892 } 1893 } 1894 } 1895 1896 return ret; 1897 } 1898 1899 public void remove() { 1900 throw new UnsupportedOperationException(); 1901 } 1902 }; 1903 } 1904 1905 @Test(dataProvider="minusNanos_fromZero") 1906 public void test_minusNanos_fromZero(long nanoseconds, int hour, int min, int sec, int nanos) { 1907 LocalTime base = LocalTime.MIDNIGHT; 1908 LocalTime t = base.minusNanos(nanoseconds); 1909 1910 assertEquals(hour, t.getHour()); 1911 assertEquals(min, t.getMinute()); 1912 assertEquals(sec, t.getSecond()); 1913 assertEquals(nanos, t.getNano()); 1914 } 1915 1916 @Test 1917 public void test_minusNanos_noChange_equal() { 1918 LocalTime t = TEST_12_30_40_987654321.minusNanos(0); 1919 assertEquals(t, TEST_12_30_40_987654321); 1920 } 1921 1922 @Test 1923 public void test_minusNanos_noChange_oneDay_equal() { 1924 LocalTime t = TEST_12_30_40_987654321.minusNanos(24 * 60 * 60 * 1000000000L); 1925 assertEquals(t, TEST_12_30_40_987654321); 1926 } 1927 1928 @Test 1929 public void test_minusNanos_toMidnight_equal() { 1930 LocalTime t = LocalTime.of(0, 0, 0, 1).minusNanos(1); 1931 assertEquals(t, LocalTime.MIDNIGHT); 1932 } 1933 1934 @Test 1935 public void test_minusNanos_toMidday_equal() { 1936 LocalTime t = LocalTime.of(12, 0, 0, 1).minusNanos(1); 1937 assertEquals(t, LocalTime.NOON); 1938 } 1939 1940 //----------------------------------------------------------------------- 1941 // periodUntil(Temporal, TemporalUnit) 1942 //----------------------------------------------------------------------- 1943 @DataProvider(name="periodUntilUnit") 1944 Object[][] data_periodUntilUnit() { 1945 return new Object[][] { 1946 {time(0, 0, 0, 0), time(0, 0, 0, 0), NANOS, 0}, 1947 {time(0, 0, 0, 0), time(0, 0, 0, 0), MICROS, 0}, 1948 {time(0, 0, 0, 0), time(0, 0, 0, 0), MILLIS, 0}, 1949 {time(0, 0, 0, 0), time(0, 0, 0, 0), SECONDS, 0}, 1950 {time(0, 0, 0, 0), time(0, 0, 0, 0), MINUTES, 0}, 1951 {time(0, 0, 0, 0), time(0, 0, 0, 0), HOURS, 0}, 1952 {time(0, 0, 0, 0), time(0, 0, 0, 0), HALF_DAYS, 0}, 1953 1954 {time(0, 0, 0, 0), time(2, 0, 0, 0), NANOS, 2 * 3600 * 1_000_000_000L}, 1955 {time(0, 0, 0, 0), time(2, 0, 0, 0), MICROS, 2 * 3600 * 1_000_000L}, 1956 {time(0, 0, 0, 0), time(2, 0, 0, 0), MILLIS, 2 * 3600 * 1_000L}, 1957 {time(0, 0, 0, 0), time(2, 0, 0, 0), SECONDS, 2 * 3600}, 1958 {time(0, 0, 0, 0), time(2, 0, 0, 0), MINUTES, 2 * 60}, 1959 {time(0, 0, 0, 0), time(2, 0, 0, 0), HOURS, 2}, 1960 {time(0, 0, 0, 0), time(2, 0, 0, 0), HALF_DAYS, 0}, 1961 1962 {time(0, 0, 0, 0), time(14, 0, 0, 0), NANOS, 14 * 3600 * 1_000_000_000L}, 1963 {time(0, 0, 0, 0), time(14, 0, 0, 0), MICROS, 14 * 3600 * 1_000_000L}, 1964 {time(0, 0, 0, 0), time(14, 0, 0, 0), MILLIS, 14 * 3600 * 1_000L}, 1965 {time(0, 0, 0, 0), time(14, 0, 0, 0), SECONDS, 14 * 3600}, 1966 {time(0, 0, 0, 0), time(14, 0, 0, 0), MINUTES, 14 * 60}, 1967 {time(0, 0, 0, 0), time(14, 0, 0, 0), HOURS, 14}, 1968 {time(0, 0, 0, 0), time(14, 0, 0, 0), HALF_DAYS, 1}, 1969 1970 {time(0, 0, 0, 0), time(2, 30, 40, 1500), NANOS, (2 * 3600 + 30 * 60 + 40) * 1_000_000_000L + 1500}, 1971 {time(0, 0, 0, 0), time(2, 30, 40, 1500), MICROS, (2 * 3600 + 30 * 60 + 40) * 1_000_000L + 1}, 1972 {time(0, 0, 0, 0), time(2, 30, 40, 1500), MILLIS, (2 * 3600 + 30 * 60 + 40) * 1_000L}, 1973 {time(0, 0, 0, 0), time(2, 30, 40, 1500), SECONDS, 2 * 3600 + 30 * 60 + 40}, 1974 {time(0, 0, 0, 0), time(2, 30, 40, 1500), MINUTES, 2 * 60 + 30}, 1975 {time(0, 0, 0, 0), time(2, 30, 40, 1500), HOURS, 2}, 1976 }; 1977 } 1978 1979 @Test(dataProvider="periodUntilUnit") 1980 public void test_periodUntil_TemporalUnit(LocalTime time1, LocalTime time2, TemporalUnit unit, long expected) { 1981 long amount = time1.periodUntil(time2, unit); 1982 assertEquals(amount, expected); 1983 } 1984 1985 @Test(dataProvider="periodUntilUnit") 1986 public void test_periodUntil_TemporalUnit_negated(LocalTime time1, LocalTime time2, TemporalUnit unit, long expected) { 1987 long amount = time2.periodUntil(time1, unit); 1988 assertEquals(amount, -expected); 1989 } 1990 1991 @Test(expectedExceptions = UnsupportedTemporalTypeException.class) 1992 public void test_periodUntil_TemporalUnit_unsupportedUnit() { 1993 TEST_12_30_40_987654321.periodUntil(TEST_12_30_40_987654321, DAYS); 1994 } 1995 1996 @Test(expectedExceptions = NullPointerException.class) 1997 public void test_periodUntil_TemporalUnit_nullEnd() { 1998 TEST_12_30_40_987654321.periodUntil(null, HOURS); 1999 } 2000 2001 @Test(expectedExceptions = NullPointerException.class) 2002 public void test_periodUntil_TemporalUnit_nullUnit() { 2003 TEST_12_30_40_987654321.periodUntil(TEST_12_30_40_987654321, null); 2004 } 2005 2006 //----------------------------------------------------------------------- 2007 // format(DateTimeFormatter) 2008 //----------------------------------------------------------------------- 2009 @Test 2010 public void test_format_formatter() { 2011 DateTimeFormatter f = DateTimeFormatter.ofPattern("H m s"); 2012 String t = LocalTime.of(11, 30, 45).format(f); 2013 assertEquals(t, "11 30 45"); 2014 } 2015 2016 @Test(expectedExceptions=NullPointerException.class) 2017 public void test_format_formatter_null() { 2018 LocalTime.of(11, 30, 45).format(null); 2019 } 2020 2021 //----------------------------------------------------------------------- 2022 // atDate() 2023 //----------------------------------------------------------------------- 2024 @Test 2025 public void test_atDate() { 2026 LocalTime t = LocalTime.of(11, 30); 2027 assertEquals(t.atDate(LocalDate.of(2012, 6, 30)), LocalDateTime.of(2012, 6, 30, 11, 30)); 2028 } 2029 2030 @Test(expectedExceptions=NullPointerException.class) 2031 public void test_atDate_nullDate() { 2032 TEST_12_30_40_987654321.atDate((LocalDate) null); 2033 } 2034 2035 //----------------------------------------------------------------------- 2036 // atOffset() 2037 //----------------------------------------------------------------------- 2038 @Test 2039 public void test_atOffset() { 2040 LocalTime t = LocalTime.of(11, 30); 2041 assertEquals(t.atOffset(OFFSET_PTWO), OffsetTime.of(LocalTime.of(11, 30), OFFSET_PTWO)); 2042 } 2043 2044 @Test(expectedExceptions=NullPointerException.class) 2045 public void test_atOffset_nullZoneOffset() { 2046 LocalTime t = LocalTime.of(11, 30); 2047 t.atOffset((ZoneOffset) null); 2048 } 2049 2050 //----------------------------------------------------------------------- 2051 // toSecondOfDay() 2052 //----------------------------------------------------------------------- 2053 @Test 2054 public void test_toSecondOfDay() { 2055 LocalTime t = LocalTime.of(0, 0); 2056 for (int i = 0; i < 24 * 60 * 60; i++) { 2057 assertEquals(t.toSecondOfDay(), i); 2058 t = t.plusSeconds(1); 2059 } 2060 } 2061 2062 @Test 2063 public void test_toSecondOfDay_fromNanoOfDay_symmetry() { 2064 LocalTime t = LocalTime.of(0, 0); 2065 for (int i = 0; i < 24 * 60 * 60; i++) { 2066 assertEquals(LocalTime.ofSecondOfDay(t.toSecondOfDay()), t); 2067 t = t.plusSeconds(1); 2068 } 2069 } 2070 2071 //----------------------------------------------------------------------- 2072 // toNanoOfDay() 2073 //----------------------------------------------------------------------- 2074 @Test 2075 public void test_toNanoOfDay() { 2076 LocalTime t = LocalTime.of(0, 0); 2077 for (int i = 0; i < 1000000; i++) { 2078 assertEquals(t.toNanoOfDay(), i); 2079 t = t.plusNanos(1); 2080 } 2081 t = LocalTime.of(0, 0); 2082 for (int i = 1; i <= 1000000; i++) { 2083 t = t.minusNanos(1); 2084 assertEquals(t.toNanoOfDay(), 24 * 60 * 60 * 1000000000L - i); 2085 } 2086 } 2087 2088 @Test 2089 public void test_toNanoOfDay_fromNanoOfDay_symmetry() { 2090 LocalTime t = LocalTime.of(0, 0); 2091 for (int i = 0; i < 1000000; i++) { 2092 assertEquals(LocalTime.ofNanoOfDay(t.toNanoOfDay()), t); 2093 t = t.plusNanos(1); 2094 } 2095 t = LocalTime.of(0, 0); 2096 for (int i = 1; i <= 1000000; i++) { 2097 t = t.minusNanos(1); 2098 assertEquals(LocalTime.ofNanoOfDay(t.toNanoOfDay()), t); 2099 } 2100 } 2101 2102 //----------------------------------------------------------------------- 2103 // compareTo() 2104 //----------------------------------------------------------------------- 2105 @Test 2106 public void test_comparisons() { 2107 doTest_comparisons_LocalTime( 2108 LocalTime.MIDNIGHT, 2109 LocalTime.of(0, 0, 0, 999999999), 2110 LocalTime.of(0, 0, 59, 0), 2111 LocalTime.of(0, 0, 59, 999999999), 2112 LocalTime.of(0, 59, 0, 0), 2113 LocalTime.of(0, 59, 0, 999999999), 2114 LocalTime.of(0, 59, 59, 0), 2115 LocalTime.of(0, 59, 59, 999999999), 2116 LocalTime.NOON, 2117 LocalTime.of(12, 0, 0, 999999999), 2118 LocalTime.of(12, 0, 59, 0), 2119 LocalTime.of(12, 0, 59, 999999999), 2120 LocalTime.of(12, 59, 0, 0), 2121 LocalTime.of(12, 59, 0, 999999999), 2122 LocalTime.of(12, 59, 59, 0), 2123 LocalTime.of(12, 59, 59, 999999999), 2124 LocalTime.of(23, 0, 0, 0), 2125 LocalTime.of(23, 0, 0, 999999999), 2140 if (i < j) { 2141 assertTrue(a.compareTo(b) < 0, a + " <=> " + b); 2142 assertEquals(a.isBefore(b), true, a + " <=> " + b); 2143 assertEquals(a.isAfter(b), false, a + " <=> " + b); 2144 assertEquals(a.equals(b), false, a + " <=> " + b); 2145 } else if (i > j) { 2146 assertTrue(a.compareTo(b) > 0, a + " <=> " + b); 2147 assertEquals(a.isBefore(b), false, a + " <=> " + b); 2148 assertEquals(a.isAfter(b), true, a + " <=> " + b); 2149 assertEquals(a.equals(b), false, a + " <=> " + b); 2150 } else { 2151 assertEquals(a.compareTo(b), 0, a + " <=> " + b); 2152 assertEquals(a.isBefore(b), false, a + " <=> " + b); 2153 assertEquals(a.isAfter(b), false, a + " <=> " + b); 2154 assertEquals(a.equals(b), true, a + " <=> " + b); 2155 } 2156 } 2157 } 2158 } 2159 2160 @Test(expectedExceptions=NullPointerException.class) 2161 public void test_compareTo_ObjectNull() { 2162 TEST_12_30_40_987654321.compareTo(null); 2163 } 2164 2165 @Test(expectedExceptions=NullPointerException.class) 2166 public void test_isBefore_ObjectNull() { 2167 TEST_12_30_40_987654321.isBefore(null); 2168 } 2169 2170 @Test(expectedExceptions=NullPointerException.class) 2171 public void test_isAfter_ObjectNull() { 2172 TEST_12_30_40_987654321.isAfter(null); 2173 } 2174 2175 @Test(expectedExceptions=ClassCastException.class) 2176 @SuppressWarnings({"unchecked", "rawtypes"}) 2177 public void compareToNonLocalTime() { 2178 Comparable c = TEST_12_30_40_987654321; 2179 c.compareTo(new Object()); 2180 } 2181 2182 //----------------------------------------------------------------------- 2183 // equals() 2184 //----------------------------------------------------------------------- 2185 @Test(dataProvider="sampleTimes") 2186 public void test_equals_true(int h, int m, int s, int n) { 2187 LocalTime a = LocalTime.of(h, m, s, n); 2188 LocalTime b = LocalTime.of(h, m, s, n); 2189 assertEquals(a.equals(b), true); 2190 } 2191 @Test(dataProvider="sampleTimes") 2192 public void test_equals_false_hour_differs(int h, int m, int s, int n) { 2193 LocalTime a = LocalTime.of(h, m, s, n); 2194 LocalTime b = LocalTime.of(h + 1, m, s, n); 2195 assertEquals(a.equals(b), false); 2196 } 2197 @Test(dataProvider="sampleTimes") 2198 public void test_equals_false_minute_differs(int h, int m, int s, int n) { 2199 LocalTime a = LocalTime.of(h, m, s, n); 2200 LocalTime b = LocalTime.of(h, m + 1, s, n); 2201 assertEquals(a.equals(b), false); 2202 } 2203 @Test(dataProvider="sampleTimes") 2204 public void test_equals_false_second_differs(int h, int m, int s, int n) { 2205 LocalTime a = LocalTime.of(h, m, s, n); 2206 LocalTime b = LocalTime.of(h, m, s + 1, n); 2207 assertEquals(a.equals(b), false); 2208 } 2209 @Test(dataProvider="sampleTimes") 2210 public void test_equals_false_nano_differs(int h, int m, int s, int n) { 2211 LocalTime a = LocalTime.of(h, m, s, n); 2212 LocalTime b = LocalTime.of(h, m, s, n + 1); 2213 assertEquals(a.equals(b), false); 2214 } 2215 2216 @Test 2217 public void test_equals_itself_true() { 2218 assertEquals(TEST_12_30_40_987654321.equals(TEST_12_30_40_987654321), true); 2219 } 2220 2221 @Test 2222 public void test_equals_string_false() { 2223 assertEquals(TEST_12_30_40_987654321.equals("2007-07-15"), false); 2224 } 2225 2226 @Test 2227 public void test_equals_null_false() { 2228 assertEquals(TEST_12_30_40_987654321.equals(null), false); 2229 } 2230 2231 //----------------------------------------------------------------------- 2232 // hashCode() 2233 //----------------------------------------------------------------------- 2234 @Test(dataProvider="sampleTimes") 2235 public void test_hashCode_same(int h, int m, int s, int n) { 2236 LocalTime a = LocalTime.of(h, m, s, n); 2237 LocalTime b = LocalTime.of(h, m, s, n); 2238 assertEquals(a.hashCode(), b.hashCode()); 2239 } 2240 2241 @Test(dataProvider="sampleTimes") 2242 public void test_hashCode_hour_differs(int h, int m, int s, int n) { 2243 LocalTime a = LocalTime.of(h, m, s, n); 2244 LocalTime b = LocalTime.of(h + 1, m, s, n); 2245 assertEquals(a.hashCode() == b.hashCode(), false); 2246 } 2247 2248 @Test(dataProvider="sampleTimes") 2249 public void test_hashCode_minute_differs(int h, int m, int s, int n) { 2250 LocalTime a = LocalTime.of(h, m, s, n); 2251 LocalTime b = LocalTime.of(h, m + 1, s, n); 2252 assertEquals(a.hashCode() == b.hashCode(), false); 2253 } 2254 2255 @Test(dataProvider="sampleTimes") 2256 public void test_hashCode_second_differs(int h, int m, int s, int n) { 2257 LocalTime a = LocalTime.of(h, m, s, n); 2258 LocalTime b = LocalTime.of(h, m, s + 1, n); 2259 assertEquals(a.hashCode() == b.hashCode(), false); 2260 } 2261 2262 @Test(dataProvider="sampleTimes") 2263 public void test_hashCode_nano_differs(int h, int m, int s, int n) { 2264 LocalTime a = LocalTime.of(h, m, s, n); 2265 LocalTime b = LocalTime.of(h, m, s, n + 1); 2266 assertEquals(a.hashCode() == b.hashCode(), false); 2267 } 2268 2269 //----------------------------------------------------------------------- 2270 // toString() 2271 //----------------------------------------------------------------------- 2272 @DataProvider(name="sampleToString") 2273 Object[][] provider_sampleToString() { 2274 return new Object[][] { 2275 {0, 0, 0, 0, "00:00"}, 2276 {1, 0, 0, 0, "01:00"}, 2277 {23, 0, 0, 0, "23:00"}, 2278 {0, 1, 0, 0, "00:01"}, 2279 {12, 30, 0, 0, "12:30"}, 2280 {23, 59, 0, 0, "23:59"}, 2281 {0, 0, 1, 0, "00:00:01"}, 2282 {0, 0, 59, 0, "00:00:59"}, 2284 {0, 0, 0, 10000000, "00:00:00.010"}, 2285 {0, 0, 0, 1000000, "00:00:00.001"}, 2286 {0, 0, 0, 100000, "00:00:00.000100"}, 2287 {0, 0, 0, 10000, "00:00:00.000010"}, 2288 {0, 0, 0, 1000, "00:00:00.000001"}, 2289 {0, 0, 0, 100, "00:00:00.000000100"}, 2290 {0, 0, 0, 10, "00:00:00.000000010"}, 2291 {0, 0, 0, 1, "00:00:00.000000001"}, 2292 {0, 0, 0, 999999999, "00:00:00.999999999"}, 2293 {0, 0, 0, 99999999, "00:00:00.099999999"}, 2294 {0, 0, 0, 9999999, "00:00:00.009999999"}, 2295 {0, 0, 0, 999999, "00:00:00.000999999"}, 2296 {0, 0, 0, 99999, "00:00:00.000099999"}, 2297 {0, 0, 0, 9999, "00:00:00.000009999"}, 2298 {0, 0, 0, 999, "00:00:00.000000999"}, 2299 {0, 0, 0, 99, "00:00:00.000000099"}, 2300 {0, 0, 0, 9, "00:00:00.000000009"}, 2301 }; 2302 } 2303 2304 @Test(dataProvider="sampleToString") 2305 public void test_toString(int h, int m, int s, int n, String expected) { 2306 LocalTime t = LocalTime.of(h, m, s, n); 2307 String str = t.toString(); 2308 assertEquals(str, expected); 2309 } 2310 2311 private LocalTime time(int hour, int min, int sec, int nano) { 2312 return LocalTime.of(hour, min, sec, nano); 2313 } 2314 } |