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.30 by jsr166, Sat Mar 26 06:58:47 2016 UTC vs.
Revision 1.37 by jsr166, Sun Sep 8 23:45:54 2019 UTC

# Line 29 | 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));
58 <            assertEquals(1000L*t*60,
59 <                         MILLISECONDS.convert(t, MINUTES));
60 <            assertEquals(1000L*t,
61 <                         MILLISECONDS.convert(t, SECONDS));
62 <            assertEquals(t,
63 <                         MILLISECONDS.convert(t, MILLISECONDS));
64 <            assertEquals(t,
65 <                         MILLISECONDS.convert(1000L*t, MICROSECONDS));
66 <            assertEquals(t,
67 <                         MILLISECONDS.convert(1000000L*t, NANOSECONDS));
68 <
69 <            assertEquals(1000000L*t*60*60*24,
70 <                         MICROSECONDS.convert(t, DAYS));
71 <            assertEquals(1000000L*t*60*60,
72 <                         MICROSECONDS.convert(t, HOURS));
73 <            assertEquals(1000000L*t*60,
74 <                         MICROSECONDS.convert(t, MINUTES));
75 <            assertEquals(1000000L*t,
76 <                         MICROSECONDS.convert(t, SECONDS));
77 <            assertEquals(1000L*t,
78 <                         MICROSECONDS.convert(t, MILLISECONDS));
79 <            assertEquals(t,
80 <                         MICROSECONDS.convert(t, MICROSECONDS));
81 <            assertEquals(t,
82 <                         MICROSECONDS.convert(1000L*t, NANOSECONDS));
83 <
84 <            assertEquals(1000000000L*t*60*60*24,
85 <                         NANOSECONDS.convert(t, DAYS));
86 <            assertEquals(1000000000L*t*60*60,
87 <                         NANOSECONDS.convert(t, HOURS));
88 <            assertEquals(1000000000L*t*60,
89 <                         NANOSECONDS.convert(t, MINUTES));
90 <            assertEquals(1000000000L*t,
91 <                         NANOSECONDS.convert(t, SECONDS));
92 <            assertEquals(1000000L*t,
93 <                         NANOSECONDS.convert(t, MILLISECONDS));
94 <            assertEquals(1000L*t,
95 <                         NANOSECONDS.convert(t, MICROSECONDS));
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 <    /**
111 <     * toNanos correctly converts sample values in different units to
112 <     * nanoseconds
113 <     */
114 <    public void testToNanos() {
115 <        for (long t = 0; t < 88888; ++t) {
116 <            assertEquals(t*1000000000L*60*60*24,
117 <                         DAYS.toNanos(t));
118 <            assertEquals(t*1000000000L*60*60,
119 <                         HOURS.toNanos(t));
120 <            assertEquals(t*1000000000L*60,
121 <                         MINUTES.toNanos(t));
122 <            assertEquals(1000000000L*t,
123 <                         SECONDS.toNanos(t));
124 <            assertEquals(1000000L*t,
125 <                         MILLISECONDS.toNanos(t));
126 <            assertEquals(1000L*t,
127 <                         MICROSECONDS.toNanos(t));
128 <            assertEquals(t,
129 <                         NANOSECONDS.toNanos(t));
130 <        }
131 <    }
132 <
133 <    /**
134 <     * toMicros correctly converts sample values in different units to
135 <     * microseconds
136 <     */
137 <    public void testToMicros() {
138 <        for (long t = 0; t < 88888; ++t) {
139 <            assertEquals(t*1000000L*60*60*24,
140 <                         DAYS.toMicros(t));
141 <            assertEquals(t*1000000L*60*60,
142 <                         HOURS.toMicros(t));
143 <            assertEquals(t*1000000L*60,
144 <                         MINUTES.toMicros(t));
145 <            assertEquals(1000000L*t,
146 <                         SECONDS.toMicros(t));
147 <            assertEquals(1000L*t,
148 <                         MILLISECONDS.toMicros(t));
149 <            assertEquals(t,
150 <                         MICROSECONDS.toMicros(t));
151 <            assertEquals(t,
152 <                         NANOSECONDS.toMicros(t*1000L));
153 <        }
154 <    }
155 <
156 <    /**
157 <     * toMillis correctly converts sample values in different units to
158 <     * milliseconds
159 <     */
160 <    public void testToMillis() {
161 <        for (long t = 0; t < 88888; ++t) {
162 <            assertEquals(t*1000L*60*60*24,
163 <                         DAYS.toMillis(t));
164 <            assertEquals(t*1000L*60*60,
165 <                         HOURS.toMillis(t));
166 <            assertEquals(t*1000L*60,
167 <                         MINUTES.toMillis(t));
168 <            assertEquals(1000L*t,
169 <                         SECONDS.toMillis(t));
170 <            assertEquals(t,
171 <                         MILLISECONDS.toMillis(t));
172 <            assertEquals(t,
173 <                         MICROSECONDS.toMillis(t*1000L));
174 <            assertEquals(t,
175 <                         NANOSECONDS.toMillis(t*1000000L));
176 <        }
177 <    }
178 <
179 <    /**
180 <     * toSeconds correctly converts sample values in different units to
181 <     * seconds
182 <     */
183 <    public void testToSeconds() {
184 <        for (long t = 0; t < 88888; ++t) {
185 <            assertEquals(t*60*60*24,
186 <                         DAYS.toSeconds(t));
187 <            assertEquals(t*60*60,
188 <                         HOURS.toSeconds(t));
189 <            assertEquals(t*60,
190 <                         MINUTES.toSeconds(t));
191 <            assertEquals(t,
192 <                         SECONDS.toSeconds(t));
193 <            assertEquals(t,
194 <                         MILLISECONDS.toSeconds(t*1000L));
195 <            assertEquals(t,
196 <                         MICROSECONDS.toSeconds(t*1000000L));
197 <            assertEquals(t,
198 <                         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
204 <     * 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,
215 <                         SECONDS.toMinutes(t*60));
216 <            assertEquals(t,
217 <                         MILLISECONDS.toMinutes(t*1000L*60));
218 <            assertEquals(t,
219 <                         MICROSECONDS.toMinutes(t*1000000L*60));
220 <            assertEquals(t,
221 <                         NANOSECONDS.toMinutes(t*1000000000L*60));
222 <        }
223 <    }
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
227 <     * hours
228 <     */
229 <    public void testToHours() {
230 <        for (long t = 0; t < 88888; ++t) {
231 <            assertEquals(t*24,
232 <                         DAYS.toHours(t));
233 <            assertEquals(t,
234 <                         HOURS.toHours(t));
235 <            assertEquals(t,
236 <                         MINUTES.toHours(t*60));
237 <            assertEquals(t,
238 <                         SECONDS.toHours(t*60*60));
239 <            assertEquals(t,
240 <                         MILLISECONDS.toHours(t*1000L*60*60));
241 <            assertEquals(t,
242 <                         MICROSECONDS.toHours(t*1000000L*60*60));
243 <            assertEquals(t,
244 <                         NANOSECONDS.toHours(t*1000000000L*60*60));
74 >        for (TimeUnit x : TimeUnit.values()) {
75 >            assertEquals(x.toNanos(1), NANOSECONDS.convert(1, x));
76          }
246 –    }
77  
78 <    /**
79 <     * toDays correctly converts sample values in different units to
80 <     * days
81 <     */
252 <    public void testToDays() {
253 <        for (long t = 0; t < 88888; ++t) {
254 <            assertEquals(t,
255 <                         DAYS.toDays(t));
256 <            assertEquals(t,
257 <                         HOURS.toDays(t*24));
258 <            assertEquals(t,
259 <                         MINUTES.toDays(t*60*24));
260 <            assertEquals(t,
261 <                         SECONDS.toDays(t*60*60*24));
262 <            assertEquals(t,
263 <                         MILLISECONDS.toDays(t*1000L*60*60*24));
264 <            assertEquals(t,
265 <                         MICROSECONDS.toDays(t*1000000L*60*60*24));
266 <            assertEquals(t,
267 <                         NANOSECONDS.toDays(t*1000000000L*60*60*24));
268 <        }
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 467 | 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 485 | Line 305 | public class TimeUnitTest extends JSR166
305          Thread t = newStartedThread(new CheckedRunnable() {
306              public void realRun() throws InterruptedException {
307                  Object o = new Object();
488 –                TimeUnit tu = MILLISECONDS;
489 –
308                  try {
309 <                    tu.timedWait(o, LONG_DELAY_MS);
309 >                    MILLISECONDS.timedWait(o, LONGER_DELAY_MS);
310                      threadShouldThrow();
311                  } catch (IllegalMonitorStateException success) {}
312              }});
# Line 504 | Line 322 | public class TimeUnitTest extends JSR166
322          Thread t = newStartedThread(new CheckedRunnable() {
323              public void realRun() throws InterruptedException {
324                  Object o = new Object();
507 –                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 518 | 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 526 | 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 538 | 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 {
545 –                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 567 | 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 {
576 –                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 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 >     * a deserialized/reserialized unit is the same instance
427       */
428      public void testSerialization() throws Exception {
429          for (TimeUnit x : TimeUnit.values())

Diff Legend

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