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.29 by jsr166, Fri Mar 25 04:53:28 2016 UTC vs.
Revision 1.37 by jsr166, Sun Sep 8 23:45:54 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 30 | Line 29 | public class TimeUnitTest extends JSR166
29          return new TestSuite(TimeUnitTest.class);
30      }
31  
32 <    // (loops to 88888 check increments at all time divisions.)
33 <
34 <    /**
35 <     * convert correctly converts sample values across the units
36 <     */
37 <    public void testConvert() {
38 <        for (long t = 0; t < 88888; ++t) {
39 <            assertEquals(t*60*60*24,
40 <                         SECONDS.convert(t, DAYS));
41 <            assertEquals(t*60*60,
42 <                         SECONDS.convert(t, HOURS));
43 <            assertEquals(t*60,
44 <                         SECONDS.convert(t, MINUTES));
45 <            assertEquals(t,
46 <                         SECONDS.convert(t, SECONDS));
47 <            assertEquals(t,
48 <                         SECONDS.convert(1000L*t, MILLISECONDS));
49 <            assertEquals(t,
50 <                         SECONDS.convert(1000000L*t, MICROSECONDS));
51 <            assertEquals(t,
52 <                         SECONDS.convert(1000000000L*t, NANOSECONDS));
53 <
54 <            assertEquals(1000L*t*60*60*24,
55 <                         MILLISECONDS.convert(t, DAYS));
56 <            assertEquals(1000L*t*60*60,
57 <                         MILLISECONDS.convert(t, HOURS));
59 <            assertEquals(1000L*t*60,
60 <                         MILLISECONDS.convert(t, MINUTES));
61 <            assertEquals(1000L*t,
62 <                         MILLISECONDS.convert(t, SECONDS));
63 <            assertEquals(t,
64 <                         MILLISECONDS.convert(t, MILLISECONDS));
65 <            assertEquals(t,
66 <                         MILLISECONDS.convert(1000L*t, MICROSECONDS));
67 <            assertEquals(t,
68 <                         MILLISECONDS.convert(1000000L*t, NANOSECONDS));
69 <
70 <            assertEquals(1000000L*t*60*60*24,
71 <                         MICROSECONDS.convert(t, DAYS));
72 <            assertEquals(1000000L*t*60*60,
73 <                         MICROSECONDS.convert(t, HOURS));
74 <            assertEquals(1000000L*t*60,
75 <                         MICROSECONDS.convert(t, MINUTES));
76 <            assertEquals(1000000L*t,
77 <                         MICROSECONDS.convert(t, SECONDS));
78 <            assertEquals(1000L*t,
79 <                         MICROSECONDS.convert(t, MILLISECONDS));
80 <            assertEquals(t,
81 <                         MICROSECONDS.convert(t, MICROSECONDS));
82 <            assertEquals(t,
83 <                         MICROSECONDS.convert(1000L*t, NANOSECONDS));
84 <
85 <            assertEquals(1000000000L*t*60*60*24,
86 <                         NANOSECONDS.convert(t, DAYS));
87 <            assertEquals(1000000000L*t*60*60,
88 <                         NANOSECONDS.convert(t, HOURS));
89 <            assertEquals(1000000000L*t*60,
90 <                         NANOSECONDS.convert(t, MINUTES));
91 <            assertEquals(1000000000L*t,
92 <                         NANOSECONDS.convert(t, SECONDS));
93 <            assertEquals(1000000L*t,
94 <                         NANOSECONDS.convert(t, MILLISECONDS));
95 <            assertEquals(1000L*t,
96 <                         NANOSECONDS.convert(t, MICROSECONDS));
97 <            assertEquals(t,
98 <                         NANOSECONDS.convert(t, NANOSECONDS));
99 <        }
100 <
101 <        for (TimeUnit x : TimeUnit.values()) {
102 <            long[] zs = {
103 <                0, 1, -1,
104 <                Integer.MAX_VALUE, Integer.MIN_VALUE,
105 <                Long.MAX_VALUE, Long.MIN_VALUE,
106 <            };
107 <            for (long z : zs) assertEquals(z, x.convert(z, x));
108 <        }
109 <    }
110 <
111 <    /**
112 <     * toNanos correctly converts sample values in different units to
113 <     * nanoseconds
114 <     */
115 <    public void testToNanos() {
116 <        for (long t = 0; t < 88888; ++t) {
117 <            assertEquals(t*1000000000L*60*60*24,
118 <                         DAYS.toNanos(t));
119 <            assertEquals(t*1000000000L*60*60,
120 <                         HOURS.toNanos(t));
121 <            assertEquals(t*1000000000L*60,
122 <                         MINUTES.toNanos(t));
123 <            assertEquals(1000000000L*t,
124 <                         SECONDS.toNanos(t));
125 <            assertEquals(1000000L*t,
126 <                         MILLISECONDS.toNanos(t));
127 <            assertEquals(1000L*t,
128 <                         MICROSECONDS.toNanos(t));
129 <            assertEquals(t,
130 <                         NANOSECONDS.toNanos(t));
131 <        }
132 <    }
133 <
134 <    /**
135 <     * toMicros correctly converts sample values in different units to
136 <     * microseconds
137 <     */
138 <    public void testToMicros() {
139 <        for (long t = 0; t < 88888; ++t) {
140 <            assertEquals(t*1000000L*60*60*24,
141 <                         DAYS.toMicros(t));
142 <            assertEquals(t*1000000L*60*60,
143 <                         HOURS.toMicros(t));
144 <            assertEquals(t*1000000L*60,
145 <                         MINUTES.toMicros(t));
146 <            assertEquals(1000000L*t,
147 <                         SECONDS.toMicros(t));
148 <            assertEquals(1000L*t,
149 <                         MILLISECONDS.toMicros(t));
150 <            assertEquals(t,
151 <                         MICROSECONDS.toMicros(t));
152 <            assertEquals(t,
153 <                         NANOSECONDS.toMicros(t*1000L));
154 <        }
155 <    }
156 <
157 <    /**
158 <     * toMillis correctly converts sample values in different units to
159 <     * milliseconds
160 <     */
161 <    public void testToMillis() {
162 <        for (long t = 0; t < 88888; ++t) {
163 <            assertEquals(t*1000L*60*60*24,
164 <                         DAYS.toMillis(t));
165 <            assertEquals(t*1000L*60*60,
166 <                         HOURS.toMillis(t));
167 <            assertEquals(t*1000L*60,
168 <                         MINUTES.toMillis(t));
169 <            assertEquals(1000L*t,
170 <                         SECONDS.toMillis(t));
171 <            assertEquals(t,
172 <                         MILLISECONDS.toMillis(t));
173 <            assertEquals(t,
174 <                         MICROSECONDS.toMillis(t*1000L));
175 <            assertEquals(t,
176 <                         NANOSECONDS.toMillis(t*1000000L));
177 <        }
178 <    }
179 <
180 <    /**
181 <     * toSeconds correctly converts sample values in different units to
182 <     * seconds
183 <     */
184 <    public void testToSeconds() {
185 <        for (long t = 0; t < 88888; ++t) {
186 <            assertEquals(t*60*60*24,
187 <                         DAYS.toSeconds(t));
188 <            assertEquals(t*60*60,
189 <                         HOURS.toSeconds(t));
190 <            assertEquals(t*60,
191 <                         MINUTES.toSeconds(t));
192 <            assertEquals(t,
193 <                         SECONDS.toSeconds(t));
194 <            assertEquals(t,
195 <                         MILLISECONDS.toSeconds(t*1000L));
196 <            assertEquals(t,
197 <                         MICROSECONDS.toSeconds(t*1000000L));
198 <            assertEquals(t,
199 <                         NANOSECONDS.toSeconds(t*1000000000L));
32 >    void testConversion(TimeUnit x, TimeUnit y, long n, long expected) {
33 >        assertEquals(expected, x.convert(n, y));
34 >        switch (x) {
35 >        case NANOSECONDS:  assertEquals(expected, y.toNanos(n));   break;
36 >        case MICROSECONDS: assertEquals(expected, y.toMicros(n));  break;
37 >        case MILLISECONDS: assertEquals(expected, y.toMillis(n));  break;
38 >        case SECONDS:      assertEquals(expected, y.toSeconds(n)); break;
39 >        case MINUTES:      assertEquals(expected, y.toMinutes(n)); break;
40 >        case HOURS:        assertEquals(expected, y.toHours(n));   break;
41 >        case DAYS:         assertEquals(expected, y.toDays(n));    break;
42 >        default: throw new AssertionError();
43 >        }
44 >
45 >        if (n > 0) testConversion(x, y, -n, -expected);
46 >    }
47 >
48 >    void testConversion(TimeUnit x, TimeUnit y) {
49 >        long ratio = x.toNanos(1)/y.toNanos(1);
50 >        assertTrue(ratio > 0);
51 >        long[] ns = { 0, 1, 2, Long.MAX_VALUE/ratio, Long.MIN_VALUE/ratio };
52 >        for (long n : ns) {
53 >            testConversion(y, x, n, n * ratio);
54 >            long[] ks = { n * ratio, n * ratio + 1, n * ratio - 1 };
55 >            for (long k : ks) {
56 >                testConversion(x, y, k, k / ratio);
57 >            }
58          }
59      }
60  
61      /**
62 <     * toMinutes correctly converts sample values in different units to
205 <     * minutes
62 >     * Conversion methods correctly convert sample values
63       */
64 <    public void testToMinutes() {
65 <        for (long t = 0; t < 88888; ++t) {
66 <            assertEquals(t*60*24,
67 <                         DAYS.toMinutes(t));
68 <            assertEquals(t*60,
69 <                         HOURS.toMinutes(t));
70 <            assertEquals(t,
71 <                         MINUTES.toMinutes(t));
72 <            assertEquals(t,
216 <                         SECONDS.toMinutes(t*60));
217 <            assertEquals(t,
218 <                         MILLISECONDS.toMinutes(t*1000L*60));
219 <            assertEquals(t,
220 <                         MICROSECONDS.toMinutes(t*1000000L*60));
221 <            assertEquals(t,
222 <                         NANOSECONDS.toMinutes(t*1000000000L*60));
223 <        }
224 <    }
64 >    public void testConversions() {
65 >        // Sanity check
66 >        assertEquals(1, NANOSECONDS.toNanos(1));
67 >        assertEquals(1000L * NANOSECONDS.toNanos(1), MICROSECONDS.toNanos(1));
68 >        assertEquals(1000L * MICROSECONDS.toNanos(1), MILLISECONDS.toNanos(1));
69 >        assertEquals(1000L * MILLISECONDS.toNanos(1), SECONDS.toNanos(1));
70 >        assertEquals(60L * SECONDS.toNanos(1), MINUTES.toNanos(1));
71 >        assertEquals(60L * MINUTES.toNanos(1), HOURS.toNanos(1));
72 >        assertEquals(24L * HOURS.toNanos(1), DAYS.toNanos(1));
73  
74 <    /**
75 <     * toHours correctly converts sample values in different units to
228 <     * hours
229 <     */
230 <    public void testToHours() {
231 <        for (long t = 0; t < 88888; ++t) {
232 <            assertEquals(t*24,
233 <                         DAYS.toHours(t));
234 <            assertEquals(t,
235 <                         HOURS.toHours(t));
236 <            assertEquals(t,
237 <                         MINUTES.toHours(t*60));
238 <            assertEquals(t,
239 <                         SECONDS.toHours(t*60*60));
240 <            assertEquals(t,
241 <                         MILLISECONDS.toHours(t*1000L*60*60));
242 <            assertEquals(t,
243 <                         MICROSECONDS.toHours(t*1000000L*60*60));
244 <            assertEquals(t,
245 <                         NANOSECONDS.toHours(t*1000000000L*60*60));
74 >        for (TimeUnit x : TimeUnit.values()) {
75 >            assertEquals(x.toNanos(1), NANOSECONDS.convert(1, x));
76          }
247 –    }
77  
78 <    /**
79 <     * toDays correctly converts sample values in different units to
80 <     * days
81 <     */
253 <    public void testToDays() {
254 <        for (long t = 0; t < 88888; ++t) {
255 <            assertEquals(t,
256 <                         DAYS.toDays(t));
257 <            assertEquals(t,
258 <                         HOURS.toDays(t*24));
259 <            assertEquals(t,
260 <                         MINUTES.toDays(t*60*24));
261 <            assertEquals(t,
262 <                         SECONDS.toDays(t*60*60*24));
263 <            assertEquals(t,
264 <                         MILLISECONDS.toDays(t*1000L*60*60*24));
265 <            assertEquals(t,
266 <                         MICROSECONDS.toDays(t*1000000L*60*60*24));
267 <            assertEquals(t,
268 <                         NANOSECONDS.toDays(t*1000000000L*60*60*24));
269 <        }
78 >        for (TimeUnit x : TimeUnit.values())
79 >            for (TimeUnit y : TimeUnit.values())
80 >                if (x.toNanos(1) >= y.toNanos(1))
81 >                    testConversion(x, y);
82      }
83  
84      /**
# Line 468 | Line 280 | public class TimeUnitTest extends JSR166
280       * toString returns name of unit
281       */
282      public void testToString() {
283 +        assertEquals("NANOSECONDS", NANOSECONDS.toString());
284 +        assertEquals("MICROSECONDS", MICROSECONDS.toString());
285 +        assertEquals("MILLISECONDS", MILLISECONDS.toString());
286          assertEquals("SECONDS", SECONDS.toString());
287 +        assertEquals("MINUTES", MINUTES.toString());
288 +        assertEquals("HOURS", HOURS.toString());
289 +        assertEquals("DAYS", DAYS.toString());
290      }
291  
292      /**
293       * name returns name of unit
294       */
295      public void testName() {
296 <        assertEquals("SECONDS", SECONDS.name());
296 >        for (TimeUnit x : TimeUnit.values())
297 >            assertEquals(x.toString(), x.name());
298      }
299  
300      /**
# Line 486 | Line 305 | public class TimeUnitTest extends JSR166
305          Thread t = newStartedThread(new CheckedRunnable() {
306              public void realRun() throws InterruptedException {
307                  Object o = new Object();
489 –                TimeUnit tu = MILLISECONDS;
490 –
308                  try {
309 <                    tu.timedWait(o, LONG_DELAY_MS);
309 >                    MILLISECONDS.timedWait(o, LONGER_DELAY_MS);
310                      threadShouldThrow();
311                  } catch (IllegalMonitorStateException success) {}
312              }});
# Line 505 | Line 322 | public class TimeUnitTest extends JSR166
322          Thread t = newStartedThread(new CheckedRunnable() {
323              public void realRun() throws InterruptedException {
324                  Object o = new Object();
508 –                TimeUnit tu = MILLISECONDS;
325  
326                  Thread.currentThread().interrupt();
327                  try {
328                      synchronized (o) {
329 <                        tu.timedWait(o, LONG_DELAY_MS);
329 >                        MILLISECONDS.timedWait(o, LONGER_DELAY_MS);
330                      }
331                      shouldThrow();
332                  } catch (InterruptedException success) {}
# Line 519 | Line 335 | public class TimeUnitTest extends JSR166
335                  pleaseInterrupt.countDown();
336                  try {
337                      synchronized (o) {
338 <                        tu.timedWait(o, LONG_DELAY_MS);
338 >                        MILLISECONDS.timedWait(o, LONGER_DELAY_MS);
339                      }
340                      shouldThrow();
341                  } catch (InterruptedException success) {}
# Line 527 | Line 343 | public class TimeUnitTest extends JSR166
343              }});
344  
345          await(pleaseInterrupt);
346 <        assertThreadStaysAlive(t);
346 >        if (randomBoolean()) assertThreadBlocks(t, Thread.State.TIMED_WAITING);
347          t.interrupt();
348          awaitTermination(t);
349      }
# Line 539 | Line 355 | public class TimeUnitTest extends JSR166
355          final CountDownLatch pleaseInterrupt = new CountDownLatch(1);
356          final Thread s = newStartedThread(new CheckedInterruptedRunnable() {
357              public void realRun() throws InterruptedException {
358 <                Thread.sleep(LONG_DELAY_MS);
358 >                Thread.sleep(LONGER_DELAY_MS);
359              }});
360          final Thread t = newStartedThread(new CheckedRunnable() {
361              public void realRun() throws InterruptedException {
546 –                TimeUnit tu = MILLISECONDS;
362                  Thread.currentThread().interrupt();
363                  try {
364 <                    tu.timedJoin(s, LONG_DELAY_MS);
364 >                    MILLISECONDS.timedJoin(s, LONGER_DELAY_MS);
365                      shouldThrow();
366                  } catch (InterruptedException success) {}
367                  assertFalse(Thread.interrupted());
368  
369                  pleaseInterrupt.countDown();
370                  try {
371 <                    tu.timedJoin(s, LONG_DELAY_MS);
371 >                    MILLISECONDS.timedJoin(s, LONGER_DELAY_MS);
372                      shouldThrow();
373                  } catch (InterruptedException success) {}
374                  assertFalse(Thread.interrupted());
375              }});
376  
377          await(pleaseInterrupt);
378 <        assertThreadStaysAlive(t);
378 >        if (randomBoolean()) assertThreadBlocks(t, Thread.State.TIMED_WAITING);
379          t.interrupt();
380          awaitTermination(t);
381          s.interrupt();
# Line 568 | Line 383 | public class TimeUnitTest extends JSR166
383      }
384  
385      /**
386 <     * timedSleep throws InterruptedException when interrupted
386 >     * timeUnit.sleep throws InterruptedException when interrupted
387       */
388      public void testTimedSleep_Interruptible() {
389          final CountDownLatch pleaseInterrupt = new CountDownLatch(1);
390          Thread t = newStartedThread(new CheckedRunnable() {
391              public void realRun() throws InterruptedException {
577 –                TimeUnit tu = MILLISECONDS;
392                  Thread.currentThread().interrupt();
393                  try {
394 <                    tu.sleep(LONG_DELAY_MS);
394 >                    MILLISECONDS.sleep(LONGER_DELAY_MS);
395                      shouldThrow();
396                  } catch (InterruptedException success) {}
397                  assertFalse(Thread.interrupted());
398  
399                  pleaseInterrupt.countDown();
400                  try {
401 <                    tu.sleep(LONG_DELAY_MS);
401 >                    MILLISECONDS.sleep(LONGER_DELAY_MS);
402                      shouldThrow();
403                  } catch (InterruptedException success) {}
404                  assertFalse(Thread.interrupted());
405              }});
406  
407          await(pleaseInterrupt);
408 <        assertThreadStaysAlive(t);
408 >        if (randomBoolean()) assertThreadBlocks(t, Thread.State.TIMED_WAITING);
409          t.interrupt();
410          awaitTermination(t);
411      }
412  
413      /**
414 <     * a deserialized serialized unit is the same instance
414 >     * timeUnit.sleep(x) for x <= 0 does not sleep at all.
415       */
416 <    public void testSerialization() throws Exception {
417 <        for (TimeUnit x : TimeUnit.values())
418 <            assertSame(x, serialClone(x));
416 >    public void testTimedSleep_nonPositive() throws InterruptedException {
417 >        boolean interrupt = randomBoolean();
418 >        if (interrupt) Thread.currentThread().interrupt();
419 >        randomTimeUnit().sleep(0L);
420 >        randomTimeUnit().sleep(-1L);
421 >        randomTimeUnit().sleep(Long.MIN_VALUE);
422 >        if (interrupt) assertTrue(Thread.interrupted());
423      }
424  
425      /**
426 <     * tests for toChronoUnit.
426 >     * a deserialized/reserialized unit is the same instance
427       */
428 <    public void testToChronoUnit() throws Exception {
611 <        assertSame(ChronoUnit.NANOS,   NANOSECONDS.toChronoUnit());
612 <        assertSame(ChronoUnit.MICROS,  MICROSECONDS.toChronoUnit());
613 <        assertSame(ChronoUnit.MILLIS,  MILLISECONDS.toChronoUnit());
614 <        assertSame(ChronoUnit.SECONDS, SECONDS.toChronoUnit());
615 <        assertSame(ChronoUnit.MINUTES, MINUTES.toChronoUnit());
616 <        assertSame(ChronoUnit.HOURS,   HOURS.toChronoUnit());
617 <        assertSame(ChronoUnit.DAYS,    DAYS.toChronoUnit());
618 <
619 <        // Every TimeUnit has a defined ChronoUnit equivalent
428 >    public void testSerialization() throws Exception {
429          for (TimeUnit x : TimeUnit.values())
430 <            assertSame(x, TimeUnit.of(x.toChronoUnit()));
622 <    }
623 <
624 <    /**
625 <     * tests for TimeUnit.of(ChronoUnit).
626 <     */
627 <    public void testTimeUnitOf() throws Exception {
628 <        assertSame(NANOSECONDS,  TimeUnit.of(ChronoUnit.NANOS));
629 <        assertSame(MICROSECONDS, TimeUnit.of(ChronoUnit.MICROS));
630 <        assertSame(MILLISECONDS, TimeUnit.of(ChronoUnit.MILLIS));
631 <        assertSame(SECONDS,      TimeUnit.of(ChronoUnit.SECONDS));
632 <        assertSame(MINUTES,      TimeUnit.of(ChronoUnit.MINUTES));
633 <        assertSame(HOURS,        TimeUnit.of(ChronoUnit.HOURS));
634 <        assertSame(DAYS,         TimeUnit.of(ChronoUnit.DAYS));
635 <
636 <        assertThrows(NullPointerException.class,
637 <                     () -> TimeUnit.of((ChronoUnit)null));
638 <
639 <        // ChronoUnits either round trip to their TimeUnit
640 <        // equivalents, or throw IllegalArgumentException.
641 <        for (ChronoUnit cu : ChronoUnit.values()) {
642 <            final TimeUnit tu;
643 <            try {
644 <                tu = TimeUnit.of(cu);
645 <            } catch (IllegalArgumentException acceptable) {
646 <                continue;
647 <            }
648 <            assertSame(cu, tu.toChronoUnit());
649 <        }
430 >            assertSame(x, serialClone(x));
431      }
432  
433   }

Diff Legend

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