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.25 by jsr166, Sat Apr 25 04:55:31 2015 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));
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          }
99 –    }
44  
45 <    /**
102 <     * toNanos correctly converts sample values in different units to
103 <     * nanoseconds
104 <     */
105 <    public void testToNanos() {
106 <        for (long t = 0; t < 88888; ++t) {
107 <            assertEquals(t*1000000000L*60*60*24,
108 <                         DAYS.toNanos(t));
109 <            assertEquals(t*1000000000L*60*60,
110 <                         HOURS.toNanos(t));
111 <            assertEquals(t*1000000000L*60,
112 <                         MINUTES.toNanos(t));
113 <            assertEquals(1000000000L*t,
114 <                         SECONDS.toNanos(t));
115 <            assertEquals(1000000L*t,
116 <                         MILLISECONDS.toNanos(t));
117 <            assertEquals(1000L*t,
118 <                         MICROSECONDS.toNanos(t));
119 <            assertEquals(t,
120 <                         NANOSECONDS.toNanos(t));
121 <        }
45 >        if (n > 0) testConversion(x, y, -n, -expected);
46      }
47  
48 <    /**
49 <     * toMicros correctly converts sample values in different units to
50 <     * microseconds
51 <     */
52 <    public void testToMicros() {
53 <        for (long t = 0; t < 88888; ++t) {
54 <            assertEquals(t*1000000L*60*60*24,
55 <                         DAYS.toMicros(t));
56 <            assertEquals(t*1000000L*60*60,
57 <                         HOURS.toMicros(t));
134 <            assertEquals(t*1000000L*60,
135 <                         MINUTES.toMicros(t));
136 <            assertEquals(1000000L*t,
137 <                         SECONDS.toMicros(t));
138 <            assertEquals(1000L*t,
139 <                         MILLISECONDS.toMicros(t));
140 <            assertEquals(t,
141 <                         MICROSECONDS.toMicros(t));
142 <            assertEquals(t,
143 <                         NANOSECONDS.toMicros(t*1000L));
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 <     * toMillis correctly converts sample values in different units to
149 <     * milliseconds
62 >     * Conversion methods correctly convert sample values
63       */
64 <    public void testToMillis() {
65 <        for (long t = 0; t < 88888; ++t) {
66 <            assertEquals(t*1000L*60*60*24,
67 <                         DAYS.toMillis(t));
68 <            assertEquals(t*1000L*60*60,
69 <                         HOURS.toMillis(t));
70 <            assertEquals(t*1000L*60,
71 <                         MINUTES.toMillis(t));
72 <            assertEquals(1000L*t,
160 <                         SECONDS.toMillis(t));
161 <            assertEquals(t,
162 <                         MILLISECONDS.toMillis(t));
163 <            assertEquals(t,
164 <                         MICROSECONDS.toMillis(t*1000L));
165 <            assertEquals(t,
166 <                         NANOSECONDS.toMillis(t*1000000L));
167 <        }
168 <    }
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 <     * toSeconds correctly converts sample values in different units to
172 <     * seconds
173 <     */
174 <    public void testToSeconds() {
175 <        for (long t = 0; t < 88888; ++t) {
176 <            assertEquals(t*60*60*24,
177 <                         DAYS.toSeconds(t));
178 <            assertEquals(t*60*60,
179 <                         HOURS.toSeconds(t));
180 <            assertEquals(t*60,
181 <                         MINUTES.toSeconds(t));
182 <            assertEquals(t,
183 <                         SECONDS.toSeconds(t));
184 <            assertEquals(t,
185 <                         MILLISECONDS.toSeconds(t*1000L));
186 <            assertEquals(t,
187 <                         MICROSECONDS.toSeconds(t*1000000L));
188 <            assertEquals(t,
189 <                         NANOSECONDS.toSeconds(t*1000000000L));
74 >        for (TimeUnit x : TimeUnit.values()) {
75 >            assertEquals(x.toNanos(1), NANOSECONDS.convert(1, x));
76          }
191 –    }
77  
78 <    /**
79 <     * toMinutes correctly converts sample values in different units to
80 <     * minutes
81 <     */
197 <    public void testToMinutes() {
198 <        for (long t = 0; t < 88888; ++t) {
199 <            assertEquals(t*60*24,
200 <                         DAYS.toMinutes(t));
201 <            assertEquals(t*60,
202 <                         HOURS.toMinutes(t));
203 <            assertEquals(t,
204 <                         MINUTES.toMinutes(t));
205 <            assertEquals(t,
206 <                         SECONDS.toMinutes(t*60));
207 <            assertEquals(t,
208 <                         MILLISECONDS.toMinutes(t*1000L*60));
209 <            assertEquals(t,
210 <                         MICROSECONDS.toMinutes(t*1000000L*60));
211 <            assertEquals(t,
212 <                         NANOSECONDS.toMinutes(t*1000000000L*60));
213 <        }
214 <    }
215 <
216 <    /**
217 <     * toHours correctly converts sample values in different units to
218 <     * hours
219 <     */
220 <    public void testToHours() {
221 <        for (long t = 0; t < 88888; ++t) {
222 <            assertEquals(t*24,
223 <                         DAYS.toHours(t));
224 <            assertEquals(t,
225 <                         HOURS.toHours(t));
226 <            assertEquals(t,
227 <                         MINUTES.toHours(t*60));
228 <            assertEquals(t,
229 <                         SECONDS.toHours(t*60*60));
230 <            assertEquals(t,
231 <                         MILLISECONDS.toHours(t*1000L*60*60));
232 <            assertEquals(t,
233 <                         MICROSECONDS.toHours(t*1000000L*60*60));
234 <            assertEquals(t,
235 <                         NANOSECONDS.toHours(t*1000000000L*60*60));
236 <        }
237 <    }
238 <
239 <    /**
240 <     * toDays correctly converts sample values in different units to
241 <     * days
242 <     */
243 <    public void testToDays() {
244 <        for (long t = 0; t < 88888; ++t) {
245 <            assertEquals(t,
246 <                         DAYS.toDays(t));
247 <            assertEquals(t,
248 <                         HOURS.toDays(t*24));
249 <            assertEquals(t,
250 <                         MINUTES.toDays(t*60*24));
251 <            assertEquals(t,
252 <                         SECONDS.toDays(t*60*60*24));
253 <            assertEquals(t,
254 <                         MILLISECONDS.toDays(t*1000L*60*60*24));
255 <            assertEquals(t,
256 <                         MICROSECONDS.toDays(t*1000000L*60*60*24));
257 <            assertEquals(t,
258 <                         NANOSECONDS.toDays(t*1000000000L*60*60*24));
259 <        }
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 280 | Line 102 | public class TimeUnitTest extends JSR166
102                       NANOSECONDS.convert(Long.MAX_VALUE / 2, DAYS));
103          assertEquals(Long.MIN_VALUE,
104                       NANOSECONDS.convert(-Long.MAX_VALUE / 4, DAYS));
105 +
106 +        for (TimeUnit x : TimeUnit.values())
107 +            for (TimeUnit y : TimeUnit.values()) {
108 +                long ratio = x.toNanos(1) / y.toNanos(1);
109 +                if (ratio >= 1) {
110 +                    assertEquals(ratio, y.convert(1, x));
111 +                    assertEquals(1, x.convert(ratio, y));
112 +                    long max = Long.MAX_VALUE/ratio;
113 +                    assertEquals(max * ratio, y.convert(max, x));
114 +                    assertEquals(-max * ratio, y.convert(-max, x));
115 +                    assertEquals(max, x.convert(max * ratio, y));
116 +                    assertEquals(-max, x.convert(-max * ratio, y));
117 +                    if (max < Long.MAX_VALUE) {
118 +                        assertEquals(Long.MAX_VALUE, y.convert(max + 1, x));
119 +                        assertEquals(Long.MIN_VALUE, y.convert(-max - 1, x));
120 +                        assertEquals(Long.MIN_VALUE, y.convert(Long.MIN_VALUE + 1, x));
121 +                    }
122 +                    assertEquals(Long.MAX_VALUE, y.convert(Long.MAX_VALUE, x));
123 +                    assertEquals(Long.MIN_VALUE, y.convert(Long.MIN_VALUE, x));
124 +                }
125 +            }
126      }
127  
128      /**
# Line 291 | Line 134 | public class TimeUnitTest extends JSR166
134                       MILLISECONDS.toNanos(Long.MAX_VALUE / 2));
135          assertEquals(Long.MIN_VALUE,
136                       MILLISECONDS.toNanos(-Long.MAX_VALUE / 3));
137 +
138 +        for (TimeUnit x : TimeUnit.values()) {
139 +            long ratio = x.toNanos(1) / NANOSECONDS.toNanos(1);
140 +            if (ratio >= 1) {
141 +                long max = Long.MAX_VALUE/ratio;
142 +                for (long z : new long[] {0, 1, -1, max, -max})
143 +                    assertEquals(z * ratio, x.toNanos(z));
144 +                if (max < Long.MAX_VALUE) {
145 +                    assertEquals(Long.MAX_VALUE, x.toNanos(max + 1));
146 +                    assertEquals(Long.MIN_VALUE, x.toNanos(-max - 1));
147 +                    assertEquals(Long.MIN_VALUE, x.toNanos(Long.MIN_VALUE + 1));
148 +                }
149 +                assertEquals(Long.MAX_VALUE, x.toNanos(Long.MAX_VALUE));
150 +                assertEquals(Long.MIN_VALUE, x.toNanos(Long.MIN_VALUE));
151 +                if (max < Integer.MAX_VALUE) {
152 +                    assertEquals(Long.MAX_VALUE, x.toNanos(Integer.MAX_VALUE));
153 +                    assertEquals(Long.MIN_VALUE, x.toNanos(Integer.MIN_VALUE));
154 +                }
155 +            }
156 +        }
157 +    }
158 +
159 +    /**
160 +     * toMicros saturates positive too-large values to Long.MAX_VALUE
161 +     * and negative to LONG.MIN_VALUE
162 +     */
163 +    public void testToMicrosSaturate() {
164 +        for (TimeUnit x : TimeUnit.values()) {
165 +            long ratio = x.toNanos(1) / MICROSECONDS.toNanos(1);
166 +            if (ratio >= 1) {
167 +                long max = Long.MAX_VALUE/ratio;
168 +                for (long z : new long[] {0, 1, -1, max, -max})
169 +                    assertEquals(z * ratio, x.toMicros(z));
170 +                if (max < Long.MAX_VALUE) {
171 +                    assertEquals(Long.MAX_VALUE, x.toMicros(max + 1));
172 +                    assertEquals(Long.MIN_VALUE, x.toMicros(-max - 1));
173 +                    assertEquals(Long.MIN_VALUE, x.toMicros(Long.MIN_VALUE + 1));
174 +                }
175 +                assertEquals(Long.MAX_VALUE, x.toMicros(Long.MAX_VALUE));
176 +                assertEquals(Long.MIN_VALUE, x.toMicros(Long.MIN_VALUE));
177 +                if (max < Integer.MAX_VALUE) {
178 +                    assertEquals(Long.MAX_VALUE, x.toMicros(Integer.MAX_VALUE));
179 +                    assertEquals(Long.MIN_VALUE, x.toMicros(Integer.MIN_VALUE));
180 +                }
181 +            }
182 +        }
183 +    }
184 +
185 +    /**
186 +     * toMillis saturates positive too-large values to Long.MAX_VALUE
187 +     * and negative to LONG.MIN_VALUE
188 +     */
189 +    public void testToMillisSaturate() {
190 +        for (TimeUnit x : TimeUnit.values()) {
191 +            long ratio = x.toNanos(1) / MILLISECONDS.toNanos(1);
192 +            if (ratio >= 1) {
193 +                long max = Long.MAX_VALUE/ratio;
194 +                for (long z : new long[] {0, 1, -1, max, -max})
195 +                    assertEquals(z * ratio, x.toMillis(z));
196 +                if (max < Long.MAX_VALUE) {
197 +                    assertEquals(Long.MAX_VALUE, x.toMillis(max + 1));
198 +                    assertEquals(Long.MIN_VALUE, x.toMillis(-max - 1));
199 +                    assertEquals(Long.MIN_VALUE, x.toMillis(Long.MIN_VALUE + 1));
200 +                }
201 +                assertEquals(Long.MAX_VALUE, x.toMillis(Long.MAX_VALUE));
202 +                assertEquals(Long.MIN_VALUE, x.toMillis(Long.MIN_VALUE));
203 +                if (max < Integer.MAX_VALUE) {
204 +                    assertEquals(Long.MAX_VALUE, x.toMillis(Integer.MAX_VALUE));
205 +                    assertEquals(Long.MIN_VALUE, x.toMillis(Integer.MIN_VALUE));
206 +                }
207 +            }
208 +        }
209 +    }
210 +
211 +    /**
212 +     * toSeconds saturates positive too-large values to Long.MAX_VALUE
213 +     * and negative to LONG.MIN_VALUE
214 +     */
215 +    public void testToSecondsSaturate() {
216 +        for (TimeUnit x : TimeUnit.values()) {
217 +            long ratio = x.toNanos(1) / SECONDS.toNanos(1);
218 +            if (ratio >= 1) {
219 +                long max = Long.MAX_VALUE/ratio;
220 +                for (long z : new long[] {0, 1, -1, max, -max})
221 +                    assertEquals(z * ratio, x.toSeconds(z));
222 +                if (max < Long.MAX_VALUE) {
223 +                    assertEquals(Long.MAX_VALUE, x.toSeconds(max + 1));
224 +                    assertEquals(Long.MIN_VALUE, x.toSeconds(-max - 1));
225 +                    assertEquals(Long.MIN_VALUE, x.toSeconds(Long.MIN_VALUE + 1));
226 +                }
227 +                assertEquals(Long.MAX_VALUE, x.toSeconds(Long.MAX_VALUE));
228 +                assertEquals(Long.MIN_VALUE, x.toSeconds(Long.MIN_VALUE));
229 +                if (max < Integer.MAX_VALUE) {
230 +                    assertEquals(Long.MAX_VALUE, x.toSeconds(Integer.MAX_VALUE));
231 +                    assertEquals(Long.MIN_VALUE, x.toSeconds(Integer.MIN_VALUE));
232 +                }
233 +            }
234 +        }
235 +    }
236 +
237 +    /**
238 +     * toMinutes saturates positive too-large values to Long.MAX_VALUE
239 +     * and negative to LONG.MIN_VALUE
240 +     */
241 +    public void testToMinutesSaturate() {
242 +        for (TimeUnit x : TimeUnit.values()) {
243 +            long ratio = x.toNanos(1) / MINUTES.toNanos(1);
244 +            if (ratio > 1) {
245 +                long max = Long.MAX_VALUE/ratio;
246 +                for (long z : new long[] {0, 1, -1, max, -max})
247 +                    assertEquals(z * ratio, x.toMinutes(z));
248 +                assertEquals(Long.MAX_VALUE, x.toMinutes(max + 1));
249 +                assertEquals(Long.MIN_VALUE, x.toMinutes(-max - 1));
250 +                assertEquals(Long.MAX_VALUE, x.toMinutes(Long.MAX_VALUE));
251 +                assertEquals(Long.MIN_VALUE, x.toMinutes(Long.MIN_VALUE));
252 +                assertEquals(Long.MIN_VALUE, x.toMinutes(Long.MIN_VALUE + 1));
253 +            }
254 +        }
255 +    }
256 +
257 +    /**
258 +     * toHours saturates positive too-large values to Long.MAX_VALUE
259 +     * and negative to LONG.MIN_VALUE
260 +     */
261 +    public void testToHoursSaturate() {
262 +        for (TimeUnit x : TimeUnit.values()) {
263 +            long ratio = x.toNanos(1) / HOURS.toNanos(1);
264 +            if (ratio >= 1) {
265 +                long max = Long.MAX_VALUE/ratio;
266 +                for (long z : new long[] {0, 1, -1, max, -max})
267 +                    assertEquals(z * ratio, x.toHours(z));
268 +                if (max < Long.MAX_VALUE) {
269 +                    assertEquals(Long.MAX_VALUE, x.toHours(max + 1));
270 +                    assertEquals(Long.MIN_VALUE, x.toHours(-max - 1));
271 +                    assertEquals(Long.MIN_VALUE, x.toHours(Long.MIN_VALUE + 1));
272 +                }
273 +                assertEquals(Long.MAX_VALUE, x.toHours(Long.MAX_VALUE));
274 +                assertEquals(Long.MIN_VALUE, x.toHours(Long.MIN_VALUE));
275 +            }
276 +        }
277      }
278  
279      /**
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 315 | Line 305 | public class TimeUnitTest extends JSR166
305          Thread t = newStartedThread(new CheckedRunnable() {
306              public void realRun() throws InterruptedException {
307                  Object o = new Object();
318 –                TimeUnit tu = MILLISECONDS;
319 –
308                  try {
309 <                    tu.timedWait(o, LONG_DELAY_MS);
309 >                    MILLISECONDS.timedWait(o, LONGER_DELAY_MS);
310                      threadShouldThrow();
311                  } catch (IllegalMonitorStateException success) {}
312              }});
# Line 334 | Line 322 | public class TimeUnitTest extends JSR166
322          Thread t = newStartedThread(new CheckedRunnable() {
323              public void realRun() throws InterruptedException {
324                  Object o = new Object();
337 –                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 348 | 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 356 | 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 368 | 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 {
375 –                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 397 | 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 {
406 –                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 <        TimeUnit x = MILLISECONDS;
430 <        assertSame(x, serialClone(x));
429 >        for (TimeUnit x : TimeUnit.values())
430 >            assertSame(x, serialClone(x));
431      }
432  
433   }

Diff Legend

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