ViewVC Help
View File | Revision Log | Show Annotations | Download File | Root Listing
root/jsr166/jsr166/src/test/tck/TimeUnitTest.java
(Generate patch)

Comparing jsr166/src/test/tck/TimeUnitTest.java (file contents):
Revision 1.26 by jsr166, Fri Jan 29 20:02:39 2016 UTC vs.
Revision 1.34 by jsr166, Wed Sep 4 22:18:03 2019 UTC

# Line 14 | Line 14 | import static java.util.concurrent.TimeU
14   import static java.util.concurrent.TimeUnit.NANOSECONDS;
15   import static java.util.concurrent.TimeUnit.SECONDS;
16  
17 – import java.time.temporal.ChronoUnit;
17   import java.util.concurrent.CountDownLatch;
18   import java.util.concurrent.TimeUnit;
19  
# Line 97 | Line 96 | public class TimeUnitTest extends JSR166
96              assertEquals(t,
97                           NANOSECONDS.convert(t, NANOSECONDS));
98          }
99 +
100 +        for (TimeUnit x : TimeUnit.values()) {
101 +            long[] zs = {
102 +                0, 1, -1,
103 +                Integer.MAX_VALUE, Integer.MIN_VALUE,
104 +                Long.MAX_VALUE, Long.MIN_VALUE,
105 +            };
106 +            for (long z : zs) assertEquals(z, x.convert(z, x));
107 +        }
108      }
109  
110      /**
# Line 281 | Line 289 | public class TimeUnitTest extends JSR166
289                       NANOSECONDS.convert(Long.MAX_VALUE / 2, DAYS));
290          assertEquals(Long.MIN_VALUE,
291                       NANOSECONDS.convert(-Long.MAX_VALUE / 4, DAYS));
292 +
293 +        for (TimeUnit x : TimeUnit.values())
294 +            for (TimeUnit y : TimeUnit.values()) {
295 +                long ratio = x.toNanos(1) / y.toNanos(1);
296 +                if (ratio >= 1) {
297 +                    assertEquals(ratio, y.convert(1, x));
298 +                    assertEquals(1, x.convert(ratio, y));
299 +                    long max = Long.MAX_VALUE/ratio;
300 +                    assertEquals(max * ratio, y.convert(max, x));
301 +                    assertEquals(-max * ratio, y.convert(-max, x));
302 +                    assertEquals(max, x.convert(max * ratio, y));
303 +                    assertEquals(-max, x.convert(-max * ratio, y));
304 +                    if (max < Long.MAX_VALUE) {
305 +                        assertEquals(Long.MAX_VALUE, y.convert(max + 1, x));
306 +                        assertEquals(Long.MIN_VALUE, y.convert(-max - 1, x));
307 +                        assertEquals(Long.MIN_VALUE, y.convert(Long.MIN_VALUE + 1, x));
308 +                    }
309 +                    assertEquals(Long.MAX_VALUE, y.convert(Long.MAX_VALUE, x));
310 +                    assertEquals(Long.MIN_VALUE, y.convert(Long.MIN_VALUE, x));
311 +                }
312 +            }
313      }
314  
315      /**
# Line 292 | Line 321 | public class TimeUnitTest extends JSR166
321                       MILLISECONDS.toNanos(Long.MAX_VALUE / 2));
322          assertEquals(Long.MIN_VALUE,
323                       MILLISECONDS.toNanos(-Long.MAX_VALUE / 3));
324 +
325 +        for (TimeUnit x : TimeUnit.values()) {
326 +            long ratio = x.toNanos(1) / NANOSECONDS.toNanos(1);
327 +            if (ratio >= 1) {
328 +                long max = Long.MAX_VALUE/ratio;
329 +                for (long z : new long[] {0, 1, -1, max, -max})
330 +                    assertEquals(z * ratio, x.toNanos(z));
331 +                if (max < Long.MAX_VALUE) {
332 +                    assertEquals(Long.MAX_VALUE, x.toNanos(max + 1));
333 +                    assertEquals(Long.MIN_VALUE, x.toNanos(-max - 1));
334 +                    assertEquals(Long.MIN_VALUE, x.toNanos(Long.MIN_VALUE + 1));
335 +                }
336 +                assertEquals(Long.MAX_VALUE, x.toNanos(Long.MAX_VALUE));
337 +                assertEquals(Long.MIN_VALUE, x.toNanos(Long.MIN_VALUE));
338 +                if (max < Integer.MAX_VALUE) {
339 +                    assertEquals(Long.MAX_VALUE, x.toNanos(Integer.MAX_VALUE));
340 +                    assertEquals(Long.MIN_VALUE, x.toNanos(Integer.MIN_VALUE));
341 +                }
342 +            }
343 +        }
344 +    }
345 +
346 +    /**
347 +     * toMicros saturates positive too-large values to Long.MAX_VALUE
348 +     * and negative to LONG.MIN_VALUE
349 +     */
350 +    public void testToMicrosSaturate() {
351 +        for (TimeUnit x : TimeUnit.values()) {
352 +            long ratio = x.toNanos(1) / MICROSECONDS.toNanos(1);
353 +            if (ratio >= 1) {
354 +                long max = Long.MAX_VALUE/ratio;
355 +                for (long z : new long[] {0, 1, -1, max, -max})
356 +                    assertEquals(z * ratio, x.toMicros(z));
357 +                if (max < Long.MAX_VALUE) {
358 +                    assertEquals(Long.MAX_VALUE, x.toMicros(max + 1));
359 +                    assertEquals(Long.MIN_VALUE, x.toMicros(-max - 1));
360 +                    assertEquals(Long.MIN_VALUE, x.toMicros(Long.MIN_VALUE + 1));
361 +                }
362 +                assertEquals(Long.MAX_VALUE, x.toMicros(Long.MAX_VALUE));
363 +                assertEquals(Long.MIN_VALUE, x.toMicros(Long.MIN_VALUE));
364 +                if (max < Integer.MAX_VALUE) {
365 +                    assertEquals(Long.MAX_VALUE, x.toMicros(Integer.MAX_VALUE));
366 +                    assertEquals(Long.MIN_VALUE, x.toMicros(Integer.MIN_VALUE));
367 +                }
368 +            }
369 +        }
370 +    }
371 +
372 +    /**
373 +     * toMillis saturates positive too-large values to Long.MAX_VALUE
374 +     * and negative to LONG.MIN_VALUE
375 +     */
376 +    public void testToMillisSaturate() {
377 +        for (TimeUnit x : TimeUnit.values()) {
378 +            long ratio = x.toNanos(1) / MILLISECONDS.toNanos(1);
379 +            if (ratio >= 1) {
380 +                long max = Long.MAX_VALUE/ratio;
381 +                for (long z : new long[] {0, 1, -1, max, -max})
382 +                    assertEquals(z * ratio, x.toMillis(z));
383 +                if (max < Long.MAX_VALUE) {
384 +                    assertEquals(Long.MAX_VALUE, x.toMillis(max + 1));
385 +                    assertEquals(Long.MIN_VALUE, x.toMillis(-max - 1));
386 +                    assertEquals(Long.MIN_VALUE, x.toMillis(Long.MIN_VALUE + 1));
387 +                }
388 +                assertEquals(Long.MAX_VALUE, x.toMillis(Long.MAX_VALUE));
389 +                assertEquals(Long.MIN_VALUE, x.toMillis(Long.MIN_VALUE));
390 +                if (max < Integer.MAX_VALUE) {
391 +                    assertEquals(Long.MAX_VALUE, x.toMillis(Integer.MAX_VALUE));
392 +                    assertEquals(Long.MIN_VALUE, x.toMillis(Integer.MIN_VALUE));
393 +                }
394 +            }
395 +        }
396 +    }
397 +
398 +    /**
399 +     * toSeconds saturates positive too-large values to Long.MAX_VALUE
400 +     * and negative to LONG.MIN_VALUE
401 +     */
402 +    public void testToSecondsSaturate() {
403 +        for (TimeUnit x : TimeUnit.values()) {
404 +            long ratio = x.toNanos(1) / SECONDS.toNanos(1);
405 +            if (ratio >= 1) {
406 +                long max = Long.MAX_VALUE/ratio;
407 +                for (long z : new long[] {0, 1, -1, max, -max})
408 +                    assertEquals(z * ratio, x.toSeconds(z));
409 +                if (max < Long.MAX_VALUE) {
410 +                    assertEquals(Long.MAX_VALUE, x.toSeconds(max + 1));
411 +                    assertEquals(Long.MIN_VALUE, x.toSeconds(-max - 1));
412 +                    assertEquals(Long.MIN_VALUE, x.toSeconds(Long.MIN_VALUE + 1));
413 +                }
414 +                assertEquals(Long.MAX_VALUE, x.toSeconds(Long.MAX_VALUE));
415 +                assertEquals(Long.MIN_VALUE, x.toSeconds(Long.MIN_VALUE));
416 +                if (max < Integer.MAX_VALUE) {
417 +                    assertEquals(Long.MAX_VALUE, x.toSeconds(Integer.MAX_VALUE));
418 +                    assertEquals(Long.MIN_VALUE, x.toSeconds(Integer.MIN_VALUE));
419 +                }
420 +            }
421 +        }
422 +    }
423 +
424 +    /**
425 +     * toMinutes saturates positive too-large values to Long.MAX_VALUE
426 +     * and negative to LONG.MIN_VALUE
427 +     */
428 +    public void testToMinutesSaturate() {
429 +        for (TimeUnit x : TimeUnit.values()) {
430 +            long ratio = x.toNanos(1) / MINUTES.toNanos(1);
431 +            if (ratio > 1) {
432 +                long max = Long.MAX_VALUE/ratio;
433 +                for (long z : new long[] {0, 1, -1, max, -max})
434 +                    assertEquals(z * ratio, x.toMinutes(z));
435 +                assertEquals(Long.MAX_VALUE, x.toMinutes(max + 1));
436 +                assertEquals(Long.MIN_VALUE, x.toMinutes(-max - 1));
437 +                assertEquals(Long.MAX_VALUE, x.toMinutes(Long.MAX_VALUE));
438 +                assertEquals(Long.MIN_VALUE, x.toMinutes(Long.MIN_VALUE));
439 +                assertEquals(Long.MIN_VALUE, x.toMinutes(Long.MIN_VALUE + 1));
440 +            }
441 +        }
442 +    }
443 +
444 +    /**
445 +     * toHours saturates positive too-large values to Long.MAX_VALUE
446 +     * and negative to LONG.MIN_VALUE
447 +     */
448 +    public void testToHoursSaturate() {
449 +        for (TimeUnit x : TimeUnit.values()) {
450 +            long ratio = x.toNanos(1) / HOURS.toNanos(1);
451 +            if (ratio >= 1) {
452 +                long max = Long.MAX_VALUE/ratio;
453 +                for (long z : new long[] {0, 1, -1, max, -max})
454 +                    assertEquals(z * ratio, x.toHours(z));
455 +                if (max < Long.MAX_VALUE) {
456 +                    assertEquals(Long.MAX_VALUE, x.toHours(max + 1));
457 +                    assertEquals(Long.MIN_VALUE, x.toHours(-max - 1));
458 +                    assertEquals(Long.MIN_VALUE, x.toHours(Long.MIN_VALUE + 1));
459 +                }
460 +                assertEquals(Long.MAX_VALUE, x.toHours(Long.MAX_VALUE));
461 +                assertEquals(Long.MIN_VALUE, x.toHours(Long.MIN_VALUE));
462 +            }
463 +        }
464      }
465  
466      /**
467       * toString returns name of unit
468       */
469      public void testToString() {
470 +        assertEquals("NANOSECONDS", NANOSECONDS.toString());
471 +        assertEquals("MICROSECONDS", MICROSECONDS.toString());
472 +        assertEquals("MILLISECONDS", MILLISECONDS.toString());
473          assertEquals("SECONDS", SECONDS.toString());
474 +        assertEquals("MINUTES", MINUTES.toString());
475 +        assertEquals("HOURS", HOURS.toString());
476 +        assertEquals("DAYS", DAYS.toString());
477      }
478  
479      /**
480       * name returns name of unit
481       */
482      public void testName() {
483 <        assertEquals("SECONDS", SECONDS.name());
483 >        for (TimeUnit x : TimeUnit.values())
484 >            assertEquals(x.toString(), x.name());
485      }
486  
487      /**
# Line 315 | Line 491 | public class TimeUnitTest extends JSR166
491      public void testTimedWait_IllegalMonitorException() {
492          Thread t = newStartedThread(new CheckedRunnable() {
493              public void realRun() throws InterruptedException {
494 +                long startTime = System.nanoTime();
495                  Object o = new Object();
319 –                TimeUnit tu = MILLISECONDS;
496  
497                  try {
498 <                    tu.timedWait(o, LONG_DELAY_MS);
498 >                    MILLISECONDS.timedWait(o, LONG_DELAY_MS);
499                      threadShouldThrow();
500                  } catch (IllegalMonitorStateException success) {}
501 +
502 +                assertTrue(millisElapsedSince(startTime) < LONG_DELAY_MS);
503              }});
504  
505          awaitTermination(t);
# Line 334 | Line 512 | public class TimeUnitTest extends JSR166
512          final CountDownLatch pleaseInterrupt = new CountDownLatch(1);
513          Thread t = newStartedThread(new CheckedRunnable() {
514              public void realRun() throws InterruptedException {
515 +                long startTime = System.nanoTime();
516                  Object o = new Object();
338 –                TimeUnit tu = MILLISECONDS;
517  
518                  Thread.currentThread().interrupt();
519                  try {
520                      synchronized (o) {
521 <                        tu.timedWait(o, LONG_DELAY_MS);
521 >                        MILLISECONDS.timedWait(o, LONG_DELAY_MS);
522                      }
523                      shouldThrow();
524                  } catch (InterruptedException success) {}
# Line 349 | Line 527 | public class TimeUnitTest extends JSR166
527                  pleaseInterrupt.countDown();
528                  try {
529                      synchronized (o) {
530 <                        tu.timedWait(o, LONG_DELAY_MS);
530 >                        MILLISECONDS.timedWait(o, LONG_DELAY_MS);
531                      }
532                      shouldThrow();
533                  } catch (InterruptedException success) {}
534                  assertFalse(Thread.interrupted());
535 +
536 +                assertTrue(millisElapsedSince(startTime) < LONG_DELAY_MS);
537              }});
538  
539          await(pleaseInterrupt);
540 <        assertThreadStaysAlive(t);
540 >        if (randomBoolean()) assertThreadBlocks(t, Thread.State.TIMED_WAITING);
541          t.interrupt();
542          awaitTermination(t);
543      }
# Line 373 | Line 553 | public class TimeUnitTest extends JSR166
553              }});
554          final Thread t = newStartedThread(new CheckedRunnable() {
555              public void realRun() throws InterruptedException {
556 <                TimeUnit tu = MILLISECONDS;
556 >                long startTime = System.nanoTime();
557 >
558                  Thread.currentThread().interrupt();
559                  try {
560 <                    tu.timedJoin(s, LONG_DELAY_MS);
560 >                    MILLISECONDS.timedJoin(s, LONG_DELAY_MS);
561                      shouldThrow();
562                  } catch (InterruptedException success) {}
563                  assertFalse(Thread.interrupted());
564  
565                  pleaseInterrupt.countDown();
566                  try {
567 <                    tu.timedJoin(s, LONG_DELAY_MS);
567 >                    MILLISECONDS.timedJoin(s, LONG_DELAY_MS);
568                      shouldThrow();
569                  } catch (InterruptedException success) {}
570                  assertFalse(Thread.interrupted());
571 +
572 +                assertTrue(millisElapsedSince(startTime) < LONG_DELAY_MS);
573              }});
574  
575          await(pleaseInterrupt);
576 <        assertThreadStaysAlive(t);
576 >        if (randomBoolean()) assertThreadBlocks(t, Thread.State.TIMED_WAITING);
577          t.interrupt();
578          awaitTermination(t);
579          s.interrupt();
# Line 398 | Line 581 | public class TimeUnitTest extends JSR166
581      }
582  
583      /**
584 <     * timedSleep throws InterruptedException when interrupted
584 >     * timeUnit.sleep throws InterruptedException when interrupted
585       */
586      public void testTimedSleep_Interruptible() {
587          final CountDownLatch pleaseInterrupt = new CountDownLatch(1);
588          Thread t = newStartedThread(new CheckedRunnable() {
589              public void realRun() throws InterruptedException {
590 <                TimeUnit tu = MILLISECONDS;
590 >                long startTime = System.nanoTime();
591 >
592                  Thread.currentThread().interrupt();
593                  try {
594 <                    tu.sleep(LONG_DELAY_MS);
594 >                    MILLISECONDS.sleep(LONG_DELAY_MS);
595                      shouldThrow();
596                  } catch (InterruptedException success) {}
597                  assertFalse(Thread.interrupted());
598  
599                  pleaseInterrupt.countDown();
600                  try {
601 <                    tu.sleep(LONG_DELAY_MS);
601 >                    MILLISECONDS.sleep(LONG_DELAY_MS);
602                      shouldThrow();
603                  } catch (InterruptedException success) {}
604                  assertFalse(Thread.interrupted());
605 +
606 +                assertTrue(millisElapsedSince(startTime) < LONG_DELAY_MS);
607              }});
608  
609          await(pleaseInterrupt);
610 <        assertThreadStaysAlive(t);
610 >        if (randomBoolean()) assertThreadBlocks(t, Thread.State.TIMED_WAITING);
611          t.interrupt();
612          awaitTermination(t);
613      }
614  
615      /**
616 <     * a deserialized serialized unit is the same instance
616 >     * timeUnit.sleep(x) for x <= 0 does not sleep at all.
617       */
618 <    public void testSerialization() throws Exception {
619 <        TimeUnit x = MILLISECONDS;
620 <        assertSame(x, serialClone(x));
618 >    public void testTimedSleep_nonPositive() throws InterruptedException {
619 >        long startTime = System.nanoTime();
620 >        boolean interrupt = randomBoolean();
621 >        if (interrupt) Thread.currentThread().interrupt();
622 >        randomTimeUnit().sleep(0L);
623 >        randomTimeUnit().sleep(-1L);
624 >        randomTimeUnit().sleep(Long.MIN_VALUE);
625 >        if (interrupt) assertTrue(Thread.interrupted());
626      }
627  
628      /**
629 <     * tests for toChronoUnit.
629 >     * a deserialized/reserialized unit is the same instance
630       */
631 <    public void testToChronoUnit() throws Exception {
441 <        assertSame(ChronoUnit.NANOS,   NANOSECONDS.toChronoUnit());
442 <        assertSame(ChronoUnit.MICROS,  MICROSECONDS.toChronoUnit());
443 <        assertSame(ChronoUnit.MILLIS,  MILLISECONDS.toChronoUnit());
444 <        assertSame(ChronoUnit.SECONDS, SECONDS.toChronoUnit());
445 <        assertSame(ChronoUnit.MINUTES, MINUTES.toChronoUnit());
446 <        assertSame(ChronoUnit.HOURS,   HOURS.toChronoUnit());
447 <        assertSame(ChronoUnit.DAYS,    DAYS.toChronoUnit());
448 <
449 <        // Every TimeUnit has a defined ChronoUnit equivalent
631 >    public void testSerialization() throws Exception {
632          for (TimeUnit x : TimeUnit.values())
633 <            assertSame(x, TimeUnit.of(x.toChronoUnit()));
452 <    }
453 <
454 <    /**
455 <     * tests for TimeUnit.of(ChronoUnit).
456 <     */
457 <    public void testTimeUnitOf() throws Exception {
458 <        assertSame(NANOSECONDS,  TimeUnit.of(ChronoUnit.NANOS));
459 <        assertSame(MICROSECONDS, TimeUnit.of(ChronoUnit.MICROS));
460 <        assertSame(MILLISECONDS, TimeUnit.of(ChronoUnit.MILLIS));
461 <        assertSame(SECONDS,      TimeUnit.of(ChronoUnit.SECONDS));
462 <        assertSame(MINUTES,      TimeUnit.of(ChronoUnit.MINUTES));
463 <        assertSame(HOURS,        TimeUnit.of(ChronoUnit.HOURS));
464 <        assertSame(DAYS,         TimeUnit.of(ChronoUnit.DAYS));
465 <
466 <        assertThrows(NullPointerException.class,
467 <                     () -> TimeUnit.of((ChronoUnit)null));
468 <
469 <        // ChronoUnits either round trip to their TimeUnit
470 <        // equivalents, or throw IllegalArgumentException.
471 <        for (ChronoUnit cu : ChronoUnit.values()) {
472 <            final TimeUnit tu;
473 <            try {
474 <                tu = TimeUnit.of(cu);
475 <            } catch (IllegalArgumentException acceptable) {
476 <                continue;
477 <            }
478 <            assertSame(cu, tu.toChronoUnit());
479 <        }
633 >            assertSame(x, serialClone(x));
634      }
635  
636   }

Diff Legend

– Removed lines
+ Added lines
< Changed lines
> Changed lines