[cvs] / jsr166 / src / test / tck / TimeUnitTest.java Repository:
ViewVC logotype

Annotation of /jsr166/src/test/tck/TimeUnitTest.java

Parent Directory Parent Directory | Revision Log Revision Log


Revision 1.9 - (view) (download)

1 : dl 1.1 /*
2 : dl 1.6 * Written by Doug Lea with assistance from members of JCP JSR-166
3 :     * Expert Group and released to the public domain, as explained at
4 :     * http://creativecommons.org/licenses/publicdomain
5 :     * Other contributors include Andrew Wright, Jeffrey Hayes,
6 :     * Pat Fisher, Mike Judd.
7 : dl 1.1 */
8 :    
9 :    
10 :     import junit.framework.*;
11 :     import java.util.concurrent.*;
12 : dl 1.2 import java.io.*;
13 : dl 1.1
14 : dl 1.3 public class TimeUnitTest extends JSR166TestCase {
15 : dl 1.1 public static void main(String[] args) {
16 :     junit.textui.TestRunner.run(suite());
17 :     }
18 :    
19 :     public static Test suite() {
20 :     return new TestSuite(TimeUnitTest.class);
21 :     }
22 :    
23 : dl 1.9 // (loops to 88888 check increments at all time divisions.)
24 :    
25 : dl 1.4 /**
26 : dl 1.9 * convert correctly converts sample values across the units
27 : dl 1.4 */
28 : dl 1.1 public void testConvert() {
29 : dl 1.9 for (long t = 0; t < 88888; ++t) {
30 :     assertEquals(t*60*60*24,
31 :     TimeUnit.SECONDS.convert(t,
32 :     TimeUnit.DAYS));
33 :     assertEquals(t*60*60,
34 :     TimeUnit.SECONDS.convert(t,
35 :     TimeUnit.HOURS));
36 :     assertEquals(t*60,
37 :     TimeUnit.SECONDS.convert(t,
38 :     TimeUnit.MINUTES));
39 : dl 1.1 assertEquals(t,
40 :     TimeUnit.SECONDS.convert(t,
41 :     TimeUnit.SECONDS));
42 :     assertEquals(t,
43 : dl 1.9 TimeUnit.SECONDS.convert(1000L*t,
44 : dl 1.1 TimeUnit.MILLISECONDS));
45 :     assertEquals(t,
46 : dl 1.9 TimeUnit.SECONDS.convert(1000000L*t,
47 : dl 1.1 TimeUnit.MICROSECONDS));
48 :     assertEquals(t,
49 : dl 1.9 TimeUnit.SECONDS.convert(1000000000L*t,
50 : dl 1.1 TimeUnit.NANOSECONDS));
51 : dl 1.9
52 :    
53 :     assertEquals(1000L*t*60*60*24,
54 :     TimeUnit.MILLISECONDS.convert(t,
55 :     TimeUnit.DAYS));
56 :     assertEquals(1000L*t*60*60,
57 :     TimeUnit.MILLISECONDS.convert(t,
58 :     TimeUnit.HOURS));
59 :     assertEquals(1000L*t*60,
60 :     TimeUnit.MILLISECONDS.convert(t,
61 :     TimeUnit.MINUTES));
62 :     assertEquals(1000L*t,
63 : dl 1.1 TimeUnit.MILLISECONDS.convert(t,
64 :     TimeUnit.SECONDS));
65 :     assertEquals(t,
66 :     TimeUnit.MILLISECONDS.convert(t,
67 :     TimeUnit.MILLISECONDS));
68 :     assertEquals(t,
69 : dl 1.9 TimeUnit.MILLISECONDS.convert(1000L*t,
70 : dl 1.1 TimeUnit.MICROSECONDS));
71 :     assertEquals(t,
72 : dl 1.9 TimeUnit.MILLISECONDS.convert(1000000L*t,
73 : dl 1.1 TimeUnit.NANOSECONDS));
74 : dl 1.9
75 :     assertEquals(1000000L*t*60*60*24,
76 :     TimeUnit.MICROSECONDS.convert(t,
77 :     TimeUnit.DAYS));
78 :     assertEquals(1000000L*t*60*60,
79 :     TimeUnit.MICROSECONDS.convert(t,
80 :     TimeUnit.HOURS));
81 :     assertEquals(1000000L*t*60,
82 :     TimeUnit.MICROSECONDS.convert(t,
83 :     TimeUnit.MINUTES));
84 :     assertEquals(1000000L*t,
85 : dl 1.1 TimeUnit.MICROSECONDS.convert(t,
86 :     TimeUnit.SECONDS));
87 : dl 1.9 assertEquals(1000L*t,
88 : dl 1.1 TimeUnit.MICROSECONDS.convert(t,
89 :     TimeUnit.MILLISECONDS));
90 :     assertEquals(t,
91 :     TimeUnit.MICROSECONDS.convert(t,
92 :     TimeUnit.MICROSECONDS));
93 :     assertEquals(t,
94 : dl 1.9 TimeUnit.MICROSECONDS.convert(1000L*t,
95 : dl 1.1 TimeUnit.NANOSECONDS));
96 : dl 1.9
97 :     assertEquals(1000000000L*t*60*60*24,
98 :     TimeUnit.NANOSECONDS.convert(t,
99 :     TimeUnit.DAYS));
100 :     assertEquals(1000000000L*t*60*60,
101 :     TimeUnit.NANOSECONDS.convert(t,
102 :     TimeUnit.HOURS));
103 :     assertEquals(1000000000L*t*60,
104 :     TimeUnit.NANOSECONDS.convert(t,
105 :     TimeUnit.MINUTES));
106 :     assertEquals(1000000000L*t,
107 : dl 1.1 TimeUnit.NANOSECONDS.convert(t,
108 :     TimeUnit.SECONDS));
109 : dl 1.9 assertEquals(1000000L*t,
110 : dl 1.1 TimeUnit.NANOSECONDS.convert(t,
111 :     TimeUnit.MILLISECONDS));
112 : dl 1.9 assertEquals(1000L*t,
113 : dl 1.1 TimeUnit.NANOSECONDS.convert(t,
114 :     TimeUnit.MICROSECONDS));
115 :     assertEquals(t,
116 :     TimeUnit.NANOSECONDS.convert(t,
117 :     TimeUnit.NANOSECONDS));
118 :     }
119 :     }
120 :    
121 : dl 1.4 /**
122 : dl 1.5 * toNanos correctly converts sample values in different units to
123 :     * nanoseconds
124 : dl 1.4 */
125 : dl 1.1 public void testToNanos() {
126 : dl 1.9 for (long t = 0; t < 88888; ++t) {
127 :     assertEquals(t*1000000000L*60*60*24,
128 :     TimeUnit.DAYS.toNanos(t));
129 :     assertEquals(t*1000000000L*60*60,
130 :     TimeUnit.HOURS.toNanos(t));
131 :     assertEquals(t*1000000000L*60,
132 :     TimeUnit.MINUTES.toNanos(t));
133 :     assertEquals(1000000000L*t,
134 : dl 1.1 TimeUnit.SECONDS.toNanos(t));
135 : dl 1.9 assertEquals(1000000L*t,
136 : dl 1.1 TimeUnit.MILLISECONDS.toNanos(t));
137 : dl 1.9 assertEquals(1000L*t,
138 : dl 1.1 TimeUnit.MICROSECONDS.toNanos(t));
139 :     assertEquals(t,
140 : dl 1.3 TimeUnit.NANOSECONDS.toNanos(t));
141 :     }
142 :     }
143 :    
144 : dl 1.4 /**
145 : dl 1.5 * toMicros correctly converts sample values in different units to
146 :     * microseconds
147 : dl 1.4 */
148 : dl 1.3 public void testToMicros() {
149 : dl 1.9 for (long t = 0; t < 88888; ++t) {
150 :     assertEquals(t*1000000L*60*60*24,
151 :     TimeUnit.DAYS.toMicros(t));
152 :     assertEquals(t*1000000L*60*60,
153 :     TimeUnit.HOURS.toMicros(t));
154 :     assertEquals(t*1000000L*60,
155 :     TimeUnit.MINUTES.toMicros(t));
156 :     assertEquals(1000000L*t,
157 : dl 1.3 TimeUnit.SECONDS.toMicros(t));
158 : dl 1.9 assertEquals(1000L*t,
159 : dl 1.3 TimeUnit.MILLISECONDS.toMicros(t));
160 :     assertEquals(t,
161 :     TimeUnit.MICROSECONDS.toMicros(t));
162 :     assertEquals(t,
163 : dl 1.9 TimeUnit.NANOSECONDS.toMicros(t*1000L));
164 : dl 1.3 }
165 :     }
166 :    
167 : dl 1.4 /**
168 : dl 1.5 * toMillis correctly converts sample values in different units to
169 :     * milliseconds
170 : dl 1.4 */
171 : dl 1.3 public void testToMillis() {
172 : dl 1.9 for (long t = 0; t < 88888; ++t) {
173 :     assertEquals(t*1000L*60*60*24,
174 :     TimeUnit.DAYS.toMillis(t));
175 :     assertEquals(t*1000L*60*60,
176 :     TimeUnit.HOURS.toMillis(t));
177 :     assertEquals(t*1000L*60,
178 :     TimeUnit.MINUTES.toMillis(t));
179 :     assertEquals(1000L*t,
180 : dl 1.3 TimeUnit.SECONDS.toMillis(t));
181 :     assertEquals(t,
182 :     TimeUnit.MILLISECONDS.toMillis(t));
183 :     assertEquals(t,
184 : dl 1.9 TimeUnit.MICROSECONDS.toMillis(t*1000L));
185 : dl 1.3 assertEquals(t,
186 : dl 1.9 TimeUnit.NANOSECONDS.toMillis(t*1000000L));
187 : dl 1.3 }
188 :     }
189 :    
190 : dl 1.4 /**
191 : dl 1.5 * toSeconds correctly converts sample values in different units to
192 :     * seconds
193 : dl 1.4 */
194 : dl 1.3 public void testToSeconds() {
195 : dl 1.9 for (long t = 0; t < 88888; ++t) {
196 :     assertEquals(t*60*60*24,
197 :     TimeUnit.DAYS.toSeconds(t));
198 :     assertEquals(t*60*60,
199 :     TimeUnit.HOURS.toSeconds(t));
200 :     assertEquals(t*60,
201 :     TimeUnit.MINUTES.toSeconds(t));
202 : dl 1.3 assertEquals(t,
203 :     TimeUnit.SECONDS.toSeconds(t));
204 : dl 1.9 assertEquals(t,
205 :     TimeUnit.MILLISECONDS.toSeconds(t*1000L));
206 :     assertEquals(t,
207 :     TimeUnit.MICROSECONDS.toSeconds(t*1000000L));
208 :     assertEquals(t,
209 :     TimeUnit.NANOSECONDS.toSeconds(t*1000000000L));
210 :     }
211 :     }
212 : dl 1.3
213 : dl 1.9 /**
214 :     * toMinutes correctly converts sample values in different units to
215 :     * minutes
216 :     */
217 :     public void testToMinutes() {
218 :     for (long t = 0; t < 88888; ++t) {
219 :     assertEquals(t*60*24,
220 :     TimeUnit.DAYS.toMinutes(t));
221 :     assertEquals(t*60,
222 :     TimeUnit.HOURS.toMinutes(t));
223 :     assertEquals(t,
224 :     TimeUnit.MINUTES.toMinutes(t));
225 :     assertEquals(t,
226 :     TimeUnit.SECONDS.toMinutes(t*60));
227 : dl 1.3 assertEquals(t,
228 : dl 1.9 TimeUnit.MILLISECONDS.toMinutes(t*1000L*60));
229 : dl 1.3 assertEquals(t,
230 : dl 1.9 TimeUnit.MICROSECONDS.toMinutes(t*1000000L*60));
231 : dl 1.3 assertEquals(t,
232 : dl 1.9 TimeUnit.NANOSECONDS.toMinutes(t*1000000000L*60));
233 :     }
234 :     }
235 :    
236 :     /**
237 :     * toHours correctly converts sample values in different units to
238 :     * hours
239 :     */
240 :     public void testToHours() {
241 :     for (long t = 0; t < 88888; ++t) {
242 :     assertEquals(t*24,
243 :     TimeUnit.DAYS.toHours(t));
244 :     assertEquals(t,
245 :     TimeUnit.HOURS.toHours(t));
246 :     assertEquals(t,
247 :     TimeUnit.MINUTES.toHours(t*60));
248 :     assertEquals(t,
249 :     TimeUnit.SECONDS.toHours(t*60*60));
250 :     assertEquals(t,
251 :     TimeUnit.MILLISECONDS.toHours(t*1000L*60*60));
252 :     assertEquals(t,
253 :     TimeUnit.MICROSECONDS.toHours(t*1000000L*60*60));
254 :     assertEquals(t,
255 :     TimeUnit.NANOSECONDS.toHours(t*1000000000L*60*60));
256 :     }
257 :     }
258 :    
259 :     /**
260 :     * toDays correctly converts sample values in different units to
261 :     * days
262 :     */
263 :     public void testToDays() {
264 :     for (long t = 0; t < 88888; ++t) {
265 :     assertEquals(t,
266 :     TimeUnit.DAYS.toDays(t));
267 :     assertEquals(t,
268 :     TimeUnit.HOURS.toDays(t*24));
269 :     assertEquals(t,
270 :     TimeUnit.MINUTES.toDays(t*60*24));
271 :     assertEquals(t,
272 :     TimeUnit.SECONDS.toDays(t*60*60*24));
273 :     assertEquals(t,
274 :     TimeUnit.MILLISECONDS.toDays(t*1000L*60*60*24));
275 :     assertEquals(t,
276 :     TimeUnit.MICROSECONDS.toDays(t*1000000L*60*60*24));
277 :     assertEquals(t,
278 :     TimeUnit.NANOSECONDS.toDays(t*1000000000L*60*60*24));
279 : dl 1.1 }
280 :     }
281 :    
282 :    
283 : dl 1.4 /**
284 : dl 1.5 * convert saturates positive too-large values to Long.MAX_VALUE
285 :     * and negative to LONG.MIN_VALUE
286 : dl 1.4 */
287 : dl 1.1 public void testConvertSaturate() {
288 :     assertEquals(Long.MAX_VALUE,
289 :     TimeUnit.NANOSECONDS.convert(Long.MAX_VALUE / 2,
290 :     TimeUnit.SECONDS));
291 :     assertEquals(Long.MIN_VALUE,
292 :     TimeUnit.NANOSECONDS.convert(-Long.MAX_VALUE / 4,
293 :     TimeUnit.SECONDS));
294 : dl 1.9 assertEquals(Long.MAX_VALUE,
295 :     TimeUnit.NANOSECONDS.convert(Long.MAX_VALUE / 2,
296 :     TimeUnit.MINUTES));
297 :     assertEquals(Long.MIN_VALUE,
298 :     TimeUnit.NANOSECONDS.convert(-Long.MAX_VALUE / 4,
299 :     TimeUnit.MINUTES));
300 :     assertEquals(Long.MAX_VALUE,
301 :     TimeUnit.NANOSECONDS.convert(Long.MAX_VALUE / 2,
302 :     TimeUnit.HOURS));
303 :     assertEquals(Long.MIN_VALUE,
304 :     TimeUnit.NANOSECONDS.convert(-Long.MAX_VALUE / 4,
305 :     TimeUnit.HOURS));
306 :     assertEquals(Long.MAX_VALUE,
307 :     TimeUnit.NANOSECONDS.convert(Long.MAX_VALUE / 2,
308 :     TimeUnit.DAYS));
309 :     assertEquals(Long.MIN_VALUE,
310 :     TimeUnit.NANOSECONDS.convert(-Long.MAX_VALUE / 4,
311 :     TimeUnit.DAYS));
312 :    
313 : dl 1.1 }
314 :    
315 : dl 1.4 /**
316 : dl 1.5 * toNanos saturates positive too-large values to Long.MAX_VALUE
317 :     * and negative to LONG.MIN_VALUE
318 : dl 1.4 */
319 : dl 1.1 public void testToNanosSaturate() {
320 :     assertEquals(Long.MAX_VALUE,
321 :     TimeUnit.MILLISECONDS.toNanos(Long.MAX_VALUE / 2));
322 :     assertEquals(Long.MIN_VALUE,
323 :     TimeUnit.MILLISECONDS.toNanos(-Long.MAX_VALUE / 3));
324 :     }
325 :    
326 :    
327 : dl 1.4 /**
328 : dl 1.7 * toString returns string containing common name of unit
329 : dl 1.4 */
330 : dl 1.1 public void testToString() {
331 :     String s = TimeUnit.SECONDS.toString();
332 : dl 1.8 assertTrue(s.indexOf("ECOND") >= 0);
333 : dl 1.1 }
334 :    
335 :    
336 :     /**
337 : dl 1.3 * Timed wait without holding lock throws
338 :     * IllegalMonitorStateException
339 : dl 1.1 */
340 : dl 1.3 public void testTimedWait_IllegalMonitorException() {
341 : dl 1.1 //created a new thread with anonymous runnable
342 :    
343 :     Thread t = new Thread(new Runnable() {
344 :     public void run() {
345 :     Object o = new Object();
346 :     TimeUnit tu = TimeUnit.MILLISECONDS;
347 :     try {
348 : dl 1.3 tu.timedWait(o,LONG_DELAY_MS);
349 : dl 1.4 threadShouldThrow();
350 : dl 1.1 }
351 :     catch (InterruptedException ie) {
352 : dl 1.4 threadUnexpectedException();
353 : dl 1.1 }
354 :     catch(IllegalMonitorStateException success) {
355 :     }
356 :    
357 :     }
358 :     });
359 :     t.start();
360 :     try {
361 : dl 1.3 Thread.sleep(SHORT_DELAY_MS);
362 : dl 1.1 t.interrupt();
363 :     t.join();
364 :     } catch(Exception e) {
365 : dl 1.4 unexpectedException();
366 : dl 1.1 }
367 :     }
368 :    
369 :     /**
370 : dl 1.5 * timedWait throws InterruptedException when interrupted
371 : dl 1.4 */
372 : dl 1.1 public void testTimedWait() {
373 :     Thread t = new Thread(new Runnable() {
374 :     public void run() {
375 :     Object o = new Object();
376 :    
377 :     TimeUnit tu = TimeUnit.MILLISECONDS;
378 :     try {
379 :     synchronized(o) {
380 : dl 1.3 tu.timedWait(o,MEDIUM_DELAY_MS);
381 : dl 1.1 }
382 : dl 1.4 threadShouldThrow();
383 : dl 1.1 }
384 :     catch(InterruptedException success) {}
385 :     catch(IllegalMonitorStateException failure) {
386 : dl 1.4 threadUnexpectedException();
387 : dl 1.1 }
388 :     }
389 :     });
390 :     t.start();
391 :     try {
392 : dl 1.3 Thread.sleep(SHORT_DELAY_MS);
393 : dl 1.1 t.interrupt();
394 :     t.join();
395 :     } catch(Exception e) {
396 : dl 1.4 unexpectedException();
397 : dl 1.1 }
398 :     }
399 :    
400 :    
401 :     /**
402 : dl 1.5 * timedJoin throws InterruptedException when interrupted
403 : dl 1.4 */
404 : dl 1.1 public void testTimedJoin() {
405 :     Thread t = new Thread(new Runnable() {
406 :     public void run() {
407 :     TimeUnit tu = TimeUnit.MILLISECONDS;
408 :     try {
409 :     Thread s = new Thread(new Runnable() {
410 :     public void run() {
411 : dl 1.4 try {
412 : dl 1.3 Thread.sleep(MEDIUM_DELAY_MS);
413 : dl 1.4 } catch(InterruptedException success){}
414 : dl 1.1 }
415 :     });
416 :     s.start();
417 : dl 1.3 tu.timedJoin(s,MEDIUM_DELAY_MS);
418 : dl 1.4 threadShouldThrow();
419 : dl 1.1 }
420 :     catch(Exception e) {}
421 :     }
422 :     });
423 :     t.start();
424 :     try {
425 : dl 1.3 Thread.sleep(SHORT_DELAY_MS);
426 : dl 1.1 t.interrupt();
427 :     t.join();
428 :     } catch(Exception e) {
429 : dl 1.4 unexpectedException();
430 : dl 1.1 }
431 :     }
432 :    
433 :     /**
434 : dl 1.5 * timedSleep throws InterruptedException when interrupted
435 : dl 1.4 */
436 : dl 1.1 public void testTimedSleep() {
437 :     //created a new thread with anonymous runnable
438 :    
439 :     Thread t = new Thread(new Runnable() {
440 :     public void run() {
441 :     TimeUnit tu = TimeUnit.MILLISECONDS;
442 :     try {
443 : dl 1.3 tu.sleep(MEDIUM_DELAY_MS);
444 : dl 1.4 threadShouldThrow();
445 : dl 1.1 }
446 :     catch(InterruptedException success) {}
447 :     }
448 :     });
449 :     t.start();
450 :     try {
451 : dl 1.3 Thread.sleep(SHORT_DELAY_MS);
452 : dl 1.1 t.interrupt();
453 :     t.join();
454 :     } catch(Exception e) {
455 : dl 1.4 unexpectedException();
456 : dl 1.1 }
457 :     }
458 : dl 1.2
459 : dl 1.4 /**
460 : dl 1.5 * a deserialized serialized unit is equal
461 : dl 1.4 */
462 : dl 1.2 public void testSerialization() {
463 :     TimeUnit q = TimeUnit.MILLISECONDS;
464 :    
465 :     try {
466 :     ByteArrayOutputStream bout = new ByteArrayOutputStream(10000);
467 :     ObjectOutputStream out = new ObjectOutputStream(new BufferedOutputStream(bout));
468 :     out.writeObject(q);
469 :     out.close();
470 :    
471 :     ByteArrayInputStream bin = new ByteArrayInputStream(bout.toByteArray());
472 :     ObjectInputStream in = new ObjectInputStream(new BufferedInputStream(bin));
473 :     TimeUnit r = (TimeUnit)in.readObject();
474 :    
475 :     assertEquals(q.toString(), r.toString());
476 :     } catch(Exception e){
477 :     e.printStackTrace();
478 : dl 1.4 unexpectedException();
479 : dl 1.2 }
480 :     }
481 :    
482 : dl 1.1 }

Doug Lea
ViewVC Help
Powered by ViewVC 1.0.8