test/java/time/tck/java/time/TCKLocalTime.java

Print this page




  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 }