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.23 by jsr166, Tue Sep 24 16:48:52 2013 UTC vs.
Revision 1.37 by jsr166, Sun Sep 8 23:45:54 2019 UTC

# Line 6 | Line 6
6   * Pat Fisher, Mike Judd.
7   */
8  
9 < import junit.framework.*;
9 > import static java.util.concurrent.TimeUnit.DAYS;
10 > import static java.util.concurrent.TimeUnit.HOURS;
11 > import static java.util.concurrent.TimeUnit.MICROSECONDS;
12 > import static java.util.concurrent.TimeUnit.MILLISECONDS;
13 > import static java.util.concurrent.TimeUnit.MINUTES;
14 > import static java.util.concurrent.TimeUnit.NANOSECONDS;
15 > import static java.util.concurrent.TimeUnit.SECONDS;
16 >
17   import java.util.concurrent.CountDownLatch;
18   import java.util.concurrent.TimeUnit;
19 < import static java.util.concurrent.TimeUnit.*;
19 >
20 > import junit.framework.Test;
21 > import junit.framework.TestSuite;
22  
23   public class TimeUnitTest extends JSR166TestCase {
24      public static void main(String[] args) {
25 <        junit.textui.TestRunner.run(suite());
25 >        main(suite(), args);
26      }
27  
28      public static Test suite() {
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));
34 <            assertEquals(t*60,
35 <                         SECONDS.convert(t, MINUTES));
36 <            assertEquals(t,
37 <                         SECONDS.convert(t, SECONDS));
38 <            assertEquals(t,
39 <                         SECONDS.convert(1000L*t, MILLISECONDS));
40 <            assertEquals(t,
41 <                         SECONDS.convert(1000000L*t, MICROSECONDS));
42 <            assertEquals(t,
43 <                         SECONDS.convert(1000000000L*t, NANOSECONDS));
44 <
45 <            assertEquals(1000L*t*60*60*24,
46 <                         MILLISECONDS.convert(t, DAYS));
47 <            assertEquals(1000L*t*60*60,
48 <                         MILLISECONDS.convert(t, HOURS));
49 <            assertEquals(1000L*t*60,
50 <                         MILLISECONDS.convert(t, MINUTES));
51 <            assertEquals(1000L*t,
52 <                         MILLISECONDS.convert(t, SECONDS));
53 <            assertEquals(t,
54 <                         MILLISECONDS.convert(t, MILLISECONDS));
55 <            assertEquals(t,
56 <                         MILLISECONDS.convert(1000L*t, MICROSECONDS));
57 <            assertEquals(t,
58 <                         MILLISECONDS.convert(1000000L*t, NANOSECONDS));
59 <
60 <            assertEquals(1000000L*t*60*60*24,
61 <                         MICROSECONDS.convert(t, DAYS));
62 <            assertEquals(1000000L*t*60*60,
63 <                         MICROSECONDS.convert(t, HOURS));
64 <            assertEquals(1000000L*t*60,
65 <                         MICROSECONDS.convert(t, MINUTES));
66 <            assertEquals(1000000L*t,
67 <                         MICROSECONDS.convert(t, SECONDS));
68 <            assertEquals(1000L*t,
69 <                         MICROSECONDS.convert(t, MILLISECONDS));
70 <            assertEquals(t,
71 <                         MICROSECONDS.convert(t, MICROSECONDS));
72 <            assertEquals(t,
73 <                         MICROSECONDS.convert(1000L*t, NANOSECONDS));
74 <
75 <            assertEquals(1000000000L*t*60*60*24,
76 <                         NANOSECONDS.convert(t, DAYS));
77 <            assertEquals(1000000000L*t*60*60,
78 <                         NANOSECONDS.convert(t, HOURS));
79 <            assertEquals(1000000000L*t*60,
80 <                         NANOSECONDS.convert(t, MINUTES));
81 <            assertEquals(1000000000L*t,
82 <                         NANOSECONDS.convert(t, SECONDS));
83 <            assertEquals(1000000L*t,
84 <                         NANOSECONDS.convert(t, MILLISECONDS));
85 <            assertEquals(1000L*t,
86 <                         NANOSECONDS.convert(t, MICROSECONDS));
87 <            assertEquals(t,
88 <                         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          }
90 –    }
44  
45 <    /**
93 <     * toNanos correctly converts sample values in different units to
94 <     * nanoseconds
95 <     */
96 <    public void testToNanos() {
97 <        for (long t = 0; t < 88888; ++t) {
98 <            assertEquals(t*1000000000L*60*60*24,
99 <                         DAYS.toNanos(t));
100 <            assertEquals(t*1000000000L*60*60,
101 <                         HOURS.toNanos(t));
102 <            assertEquals(t*1000000000L*60,
103 <                         MINUTES.toNanos(t));
104 <            assertEquals(1000000000L*t,
105 <                         SECONDS.toNanos(t));
106 <            assertEquals(1000000L*t,
107 <                         MILLISECONDS.toNanos(t));
108 <            assertEquals(1000L*t,
109 <                         MICROSECONDS.toNanos(t));
110 <            assertEquals(t,
111 <                         NANOSECONDS.toNanos(t));
112 <        }
113 <    }
114 <
115 <    /**
116 <     * toMicros correctly converts sample values in different units to
117 <     * microseconds
118 <     */
119 <    public void testToMicros() {
120 <        for (long t = 0; t < 88888; ++t) {
121 <            assertEquals(t*1000000L*60*60*24,
122 <                         DAYS.toMicros(t));
123 <            assertEquals(t*1000000L*60*60,
124 <                         HOURS.toMicros(t));
125 <            assertEquals(t*1000000L*60,
126 <                         MINUTES.toMicros(t));
127 <            assertEquals(1000000L*t,
128 <                         SECONDS.toMicros(t));
129 <            assertEquals(1000L*t,
130 <                         MILLISECONDS.toMicros(t));
131 <            assertEquals(t,
132 <                         MICROSECONDS.toMicros(t));
133 <            assertEquals(t,
134 <                         NANOSECONDS.toMicros(t*1000L));
135 <        }
136 <    }
137 <
138 <    /**
139 <     * toMillis correctly converts sample values in different units to
140 <     * milliseconds
141 <     */
142 <    public void testToMillis() {
143 <        for (long t = 0; t < 88888; ++t) {
144 <            assertEquals(t*1000L*60*60*24,
145 <                         DAYS.toMillis(t));
146 <            assertEquals(t*1000L*60*60,
147 <                         HOURS.toMillis(t));
148 <            assertEquals(t*1000L*60,
149 <                         MINUTES.toMillis(t));
150 <            assertEquals(1000L*t,
151 <                         SECONDS.toMillis(t));
152 <            assertEquals(t,
153 <                         MILLISECONDS.toMillis(t));
154 <            assertEquals(t,
155 <                         MICROSECONDS.toMillis(t*1000L));
156 <            assertEquals(t,
157 <                         NANOSECONDS.toMillis(t*1000000L));
158 <        }
45 >        if (n > 0) testConversion(x, y, -n, -expected);
46      }
47  
48 <    /**
49 <     * toSeconds correctly converts sample values in different units to
50 <     * seconds
51 <     */
52 <    public void testToSeconds() {
53 <        for (long t = 0; t < 88888; ++t) {
54 <            assertEquals(t*60*60*24,
55 <                         DAYS.toSeconds(t));
56 <            assertEquals(t*60*60,
57 <                         HOURS.toSeconds(t));
171 <            assertEquals(t*60,
172 <                         MINUTES.toSeconds(t));
173 <            assertEquals(t,
174 <                         SECONDS.toSeconds(t));
175 <            assertEquals(t,
176 <                         MILLISECONDS.toSeconds(t*1000L));
177 <            assertEquals(t,
178 <                         MICROSECONDS.toSeconds(t*1000000L));
179 <            assertEquals(t,
180 <                         NANOSECONDS.toSeconds(t*1000000000L));
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
186 <     * 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,
197 <                         SECONDS.toMinutes(t*60));
198 <            assertEquals(t,
199 <                         MILLISECONDS.toMinutes(t*1000L*60));
200 <            assertEquals(t,
201 <                         MICROSECONDS.toMinutes(t*1000000L*60));
202 <            assertEquals(t,
203 <                         NANOSECONDS.toMinutes(t*1000000000L*60));
204 <        }
205 <    }
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
209 <     * hours
210 <     */
211 <    public void testToHours() {
212 <        for (long t = 0; t < 88888; ++t) {
213 <            assertEquals(t*24,
214 <                         DAYS.toHours(t));
215 <            assertEquals(t,
216 <                         HOURS.toHours(t));
217 <            assertEquals(t,
218 <                         MINUTES.toHours(t*60));
219 <            assertEquals(t,
220 <                         SECONDS.toHours(t*60*60));
221 <            assertEquals(t,
222 <                         MILLISECONDS.toHours(t*1000L*60*60));
223 <            assertEquals(t,
224 <                         MICROSECONDS.toHours(t*1000000L*60*60));
225 <            assertEquals(t,
226 <                         NANOSECONDS.toHours(t*1000000000L*60*60));
74 >        for (TimeUnit x : TimeUnit.values()) {
75 >            assertEquals(x.toNanos(1), NANOSECONDS.convert(1, x));
76          }
228 –    }
77  
78 <    /**
79 <     * toDays correctly converts sample values in different units to
80 <     * days
81 <     */
234 <    public void testToDays() {
235 <        for (long t = 0; t < 88888; ++t) {
236 <            assertEquals(t,
237 <                         DAYS.toDays(t));
238 <            assertEquals(t,
239 <                         HOURS.toDays(t*24));
240 <            assertEquals(t,
241 <                         MINUTES.toDays(t*60*24));
242 <            assertEquals(t,
243 <                         SECONDS.toDays(t*60*60*24));
244 <            assertEquals(t,
245 <                         MILLISECONDS.toDays(t*1000L*60*60*24));
246 <            assertEquals(t,
247 <                         MICROSECONDS.toDays(t*1000000L*60*60*24));
248 <            assertEquals(t,
249 <                         NANOSECONDS.toDays(t*1000000000L*60*60*24));
250 <        }
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 271 | 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 282 | 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 306 | Line 305 | public class TimeUnitTest extends JSR166
305          Thread t = newStartedThread(new CheckedRunnable() {
306              public void realRun() throws InterruptedException {
307                  Object o = new Object();
309 –                TimeUnit tu = MILLISECONDS;
310 –
308                  try {
309 <                    tu.timedWait(o, LONG_DELAY_MS);
309 >                    MILLISECONDS.timedWait(o, LONGER_DELAY_MS);
310                      threadShouldThrow();
311                  } catch (IllegalMonitorStateException success) {}
312              }});
# Line 325 | Line 322 | public class TimeUnitTest extends JSR166
322          Thread t = newStartedThread(new CheckedRunnable() {
323              public void realRun() throws InterruptedException {
324                  Object o = new Object();
328 –                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 339 | 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 347 | 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 359 | 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 {
366 –                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 388 | 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 {
397 –                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