test/tck/TimeUnitTest.java

/*
 * Written by members of JCP JSR-166 Expert Group and released to the
 * public domain. Use, modify, and redistribute this code in any way
 * without acknowledgement. Other contributors include Andrew Wright,
 * Jeffrey Hayes, Pat Fischer, Mike Judd.
 */


import junit.framework.*;
import java.util.concurrent.*;
import java.io.*;

public class TimeUnitTest extends JSR166TestCase {
    public static void main(String[] args) {
        junit.textui.TestRunner.run(suite());   
    }
    
    public static Test suite() {
        return new TestSuite(TimeUnitTest.class);
    }

    public void testConvert() {
        for (long t = 0; t < 10; ++t) {
            assertEquals(t, 
                         TimeUnit.SECONDS.convert(t, 
                                                  TimeUnit.SECONDS));
            assertEquals(t, 
                         TimeUnit.SECONDS.convert(1000 * t, 
                                                  TimeUnit.MILLISECONDS));
            assertEquals(t, 
                         TimeUnit.SECONDS.convert(1000000 * t, 
                                                  TimeUnit.MICROSECONDS));
            assertEquals(t, 
                         TimeUnit.SECONDS.convert(1000000000 * t, 
                                                  TimeUnit.NANOSECONDS));
            assertEquals(1000 * t, 
                         TimeUnit.MILLISECONDS.convert(t, 
                                                  TimeUnit.SECONDS));
            assertEquals(t, 
                         TimeUnit.MILLISECONDS.convert(t, 
                                                  TimeUnit.MILLISECONDS));
            assertEquals(t, 
                         TimeUnit.MILLISECONDS.convert(1000 * t, 
                                                  TimeUnit.MICROSECONDS));
            assertEquals(t, 
                         TimeUnit.MILLISECONDS.convert(1000000 * t, 
                                                  TimeUnit.NANOSECONDS));
            assertEquals(1000000 * t, 
                         TimeUnit.MICROSECONDS.convert(t, 
                                                  TimeUnit.SECONDS));
            assertEquals(1000 * t, 
                         TimeUnit.MICROSECONDS.convert(t, 
                                                  TimeUnit.MILLISECONDS));
            assertEquals(t, 
                         TimeUnit.MICROSECONDS.convert(t, 
                                                  TimeUnit.MICROSECONDS));
            assertEquals(t, 
                         TimeUnit.MICROSECONDS.convert(1000 * t, 
                                                  TimeUnit.NANOSECONDS));
            assertEquals(1000000000 * t, 
                         TimeUnit.NANOSECONDS.convert(t, 
                                                  TimeUnit.SECONDS));
            assertEquals(1000000 * t, 
                         TimeUnit.NANOSECONDS.convert(t, 
                                                  TimeUnit.MILLISECONDS));
            assertEquals(1000 * t, 
                         TimeUnit.NANOSECONDS.convert(t, 
                                                  TimeUnit.MICROSECONDS));
            assertEquals(t, 
                         TimeUnit.NANOSECONDS.convert(t, 
                                                  TimeUnit.NANOSECONDS));
        }
    }

    public void testToNanos() {
        for (long t = 0; t < 10; ++t) {
            assertEquals(1000000000 * t, 
                         TimeUnit.SECONDS.toNanos(t));

            assertEquals(1000000 * t, 
                         TimeUnit.MILLISECONDS.toNanos(t));
            assertEquals(1000 * t, 
                         TimeUnit.MICROSECONDS.toNanos(t));
            assertEquals(t, 
                         TimeUnit.NANOSECONDS.toNanos(t));
        }
    }

    public void testToMicros() {
        for (long t = 0; t < 10; ++t) {
            assertEquals(1000000 * t, 
                         TimeUnit.SECONDS.toMicros(t));

            assertEquals(1000 * t, 
                         TimeUnit.MILLISECONDS.toMicros(t));
            assertEquals(t, 
                         TimeUnit.MICROSECONDS.toMicros(t));
            assertEquals(t, 
                         TimeUnit.NANOSECONDS.toMicros(t * 1000));
        }
    }

    public void testToMillis() {
        for (long t = 0; t < 10; ++t) {
            assertEquals(1000 * t, 
                         TimeUnit.SECONDS.toMillis(t));

            assertEquals(t, 
                         TimeUnit.MILLISECONDS.toMillis(t));
            assertEquals(t, 
                         TimeUnit.MICROSECONDS.toMillis(t * 1000));
            assertEquals(t, 
                         TimeUnit.NANOSECONDS.toMillis(t * 1000000));
        }
    }

    public void testToSeconds() {
        for (long t = 0; t < 10; ++t) {
            assertEquals(t, 
                         TimeUnit.SECONDS.toSeconds(t));

            assertEquals(t, 
                         TimeUnit.MILLISECONDS.toSeconds(t * 1000));
            assertEquals(t, 
                         TimeUnit.MICROSECONDS.toSeconds(t * 1000000));
            assertEquals(t, 
                         TimeUnit.NANOSECONDS.toSeconds(t * 1000000000));
        }
    }


    public void testConvertSaturate() {
        assertEquals(Long.MAX_VALUE,
                     TimeUnit.NANOSECONDS.convert(Long.MAX_VALUE / 2,
                                                  TimeUnit.SECONDS));
        assertEquals(Long.MIN_VALUE,
                     TimeUnit.NANOSECONDS.convert(-Long.MAX_VALUE / 4,
                                                  TimeUnit.SECONDS));

    }

    public void testToNanosSaturate() {
            assertEquals(Long.MAX_VALUE,
                         TimeUnit.MILLISECONDS.toNanos(Long.MAX_VALUE / 2));
            assertEquals(Long.MIN_VALUE,
                         TimeUnit.MILLISECONDS.toNanos(-Long.MAX_VALUE / 3));
            
    }


    public void testToString() {
        String s = TimeUnit.SECONDS.toString();
        assertTrue(s.indexOf("econd") >= 0);
    }

    
    /**
     *  Timed wait without holding lock throws
     *  IllegalMonitorStateException
     */
    public void testTimedWait_IllegalMonitorException() {
        //created a new thread with anonymous runnable

        Thread t = new Thread(new Runnable() {
                public void run() {
                    Object o = new Object();
                    TimeUnit tu = TimeUnit.MILLISECONDS;
                    try {
                        tu.timedWait(o,LONG_DELAY_MS);
                        fail("should throw");
                    }
                    catch (InterruptedException ie) {
                        fail("should not throw IE here");
                    } 
                    catch(IllegalMonitorStateException success) {
                    }
                    
                }
            });
        t.start();
        try {
            Thread.sleep(SHORT_DELAY_MS);
            t.interrupt();
            t.join();
        } catch(Exception e) {
            fail("Unexpected exception");
        }
    }
    
    /**
     *   timedWait will throw InterruptedException.
     *  Thread t waits on timedWait while the main thread interrupts it.
     *  Note:  This does not throw IllegalMonitorException since timeWait
     *         is synchronized on o
     */
    public void testTimedWait() {
        Thread t = new Thread(new Runnable() {
                public void run() {
                    Object o = new Object();
                    
                    TimeUnit tu = TimeUnit.MILLISECONDS;
                    try {
                        synchronized(o) {
                            tu.timedWait(o,MEDIUM_DELAY_MS);
                        }
                        fail("should throw");
                    }
                    catch(InterruptedException success) {} 
                    catch(IllegalMonitorStateException failure) {
                        fail("should not throw");
                    }
                }
            });
        t.start();
        try {
            Thread.sleep(SHORT_DELAY_MS);
            t.interrupt();
            t.join();
        } catch(Exception e) {
            fail("Unexpected exception");
        }
    }
    
    
    /**
     *   timedJoin will throw InterruptedException.
     *  Thread t waits on timedJoin while the main thread interrupts it.
     */
    public void testTimedJoin() {
        Thread t = new Thread(new Runnable() {
                public void run() {
                    TimeUnit tu = TimeUnit.MILLISECONDS;        
                    try {
                        Thread s = new Thread(new Runnable() {
                                public void run() {
                                    try{
                                        Thread.sleep(MEDIUM_DELAY_MS);
                                    }catch(InterruptedException success){}
                                }
                            });
                        s.start();
                        tu.timedJoin(s,MEDIUM_DELAY_MS);
                        fail("should throw");
                    }
                    catch(Exception e) {}
                }
            });
        t.start();
        try {
            Thread.sleep(SHORT_DELAY_MS);
            t.interrupt();
            t.join();
        } catch(Exception e) {
            fail("Unexpected exception");
        }
    }
    
    /**
     *   timedSleep will throw InterruptedException.
     *  Thread t waits on timedSleep while the main thread interrupts it.
     */
    public void testTimedSleep() {
        //created a new thread with anonymous runnable

        Thread t = new Thread(new Runnable() {
                public void run() {
                    TimeUnit tu = TimeUnit.MILLISECONDS;
                    try {
                        tu.sleep(MEDIUM_DELAY_MS);
                        fail("should throw");
                    }
                    catch(InterruptedException success) {} 
                }
            });
        t.start();
        try {
            Thread.sleep(SHORT_DELAY_MS);
            t.interrupt();
            t.join();
        } catch(Exception e) {
            fail("Unexpected exception");
        }
    }

    public void testSerialization() {
        TimeUnit q = TimeUnit.MILLISECONDS;

        try {
            ByteArrayOutputStream bout = new ByteArrayOutputStream(10000);
            ObjectOutputStream out = new ObjectOutputStream(new BufferedOutputStream(bout));
            out.writeObject(q);
            out.close();

            ByteArrayInputStream bin = new ByteArrayInputStream(bout.toByteArray());
            ObjectInputStream in = new ObjectInputStream(new BufferedInputStream(bin));
            TimeUnit r = (TimeUnit)in.readObject();
            
            assertEquals(q.toString(), r.toString());
        } catch(Exception e){
            e.printStackTrace();
            fail("unexpected exception");
        }
    }

}
Revision:	1.3
Committed:	Sun Sep 14 20:42:41 2003 UTC (20 years, 8 months ago) by dl
Branch:	MAIN
Changes since 1.2:	+59 -20 lines
Log Message:	New base class JSR166TestCase
#	Content
1	/*
2	* Written by members of JCP JSR-166 Expert Group and released to the
3	* public domain. Use, modify, and redistribute this code in any way
4	* without acknowledgement. Other contributors include Andrew Wright,
5	* Jeffrey Hayes, Pat Fischer, Mike Judd.
6	*/
7
8
9	import junit.framework.*;
10	import java.util.concurrent.*;
11	import java.io.*;
12
13	public class TimeUnitTest extends JSR166TestCase {
14	public static void main(String[] args) {
15	junit.textui.TestRunner.run(suite());
16	}
17
18	public static Test suite() {
19	return new TestSuite(TimeUnitTest.class);
20	}
21
22	public void testConvert() {
23	for (long t = 0; t < 10; ++t) {
24	assertEquals(t,
25	TimeUnit.SECONDS.convert(t,
26	TimeUnit.SECONDS));
27	assertEquals(t,
28	TimeUnit.SECONDS.convert(1000 * t,
29	TimeUnit.MILLISECONDS));
30	assertEquals(t,
31	TimeUnit.SECONDS.convert(1000000 * t,
32	TimeUnit.MICROSECONDS));
33	assertEquals(t,
34	TimeUnit.SECONDS.convert(1000000000 * t,
35	TimeUnit.NANOSECONDS));
36	assertEquals(1000 * t,
37	TimeUnit.MILLISECONDS.convert(t,
38	TimeUnit.SECONDS));
39	assertEquals(t,
40	TimeUnit.MILLISECONDS.convert(t,
41	TimeUnit.MILLISECONDS));
42	assertEquals(t,
43	TimeUnit.MILLISECONDS.convert(1000 * t,
44	TimeUnit.MICROSECONDS));
45	assertEquals(t,
46	TimeUnit.MILLISECONDS.convert(1000000 * t,
47	TimeUnit.NANOSECONDS));
48	assertEquals(1000000 * t,
49	TimeUnit.MICROSECONDS.convert(t,
50	TimeUnit.SECONDS));
51	assertEquals(1000 * t,
52	TimeUnit.MICROSECONDS.convert(t,
53	TimeUnit.MILLISECONDS));
54	assertEquals(t,
55	TimeUnit.MICROSECONDS.convert(t,
56	TimeUnit.MICROSECONDS));
57	assertEquals(t,
58	TimeUnit.MICROSECONDS.convert(1000 * t,
59	TimeUnit.NANOSECONDS));
60	assertEquals(1000000000 * t,
61	TimeUnit.NANOSECONDS.convert(t,
62	TimeUnit.SECONDS));
63	assertEquals(1000000 * t,
64	TimeUnit.NANOSECONDS.convert(t,
65	TimeUnit.MILLISECONDS));
66	assertEquals(1000 * t,
67	TimeUnit.NANOSECONDS.convert(t,
68	TimeUnit.MICROSECONDS));
69	assertEquals(t,
70	TimeUnit.NANOSECONDS.convert(t,
71	TimeUnit.NANOSECONDS));
72	}
73	}
74
75	public void testToNanos() {
76	for (long t = 0; t < 10; ++t) {
77	assertEquals(1000000000 * t,
78	TimeUnit.SECONDS.toNanos(t));
79
80	assertEquals(1000000 * t,
81	TimeUnit.MILLISECONDS.toNanos(t));
82	assertEquals(1000 * t,
83	TimeUnit.MICROSECONDS.toNanos(t));
84	assertEquals(t,
85	TimeUnit.NANOSECONDS.toNanos(t));
86	}
87	}
88
89	public void testToMicros() {
90	for (long t = 0; t < 10; ++t) {
91	assertEquals(1000000 * t,
92	TimeUnit.SECONDS.toMicros(t));
93
94	assertEquals(1000 * t,
95	TimeUnit.MILLISECONDS.toMicros(t));
96	assertEquals(t,
97	TimeUnit.MICROSECONDS.toMicros(t));
98	assertEquals(t,
99	TimeUnit.NANOSECONDS.toMicros(t * 1000));
100	}
101	}
102
103	public void testToMillis() {
104	for (long t = 0; t < 10; ++t) {
105	assertEquals(1000 * t,
106	TimeUnit.SECONDS.toMillis(t));
107
108	assertEquals(t,
109	TimeUnit.MILLISECONDS.toMillis(t));
110	assertEquals(t,
111	TimeUnit.MICROSECONDS.toMillis(t * 1000));
112	assertEquals(t,
113	TimeUnit.NANOSECONDS.toMillis(t * 1000000));
114	}
115	}
116
117	public void testToSeconds() {
118	for (long t = 0; t < 10; ++t) {
119	assertEquals(t,
120	TimeUnit.SECONDS.toSeconds(t));
121
122	assertEquals(t,
123	TimeUnit.MILLISECONDS.toSeconds(t * 1000));
124	assertEquals(t,
125	TimeUnit.MICROSECONDS.toSeconds(t * 1000000));
126	assertEquals(t,
127	TimeUnit.NANOSECONDS.toSeconds(t * 1000000000));
128	}
129	}
130
131
132	public void testConvertSaturate() {
133	assertEquals(Long.MAX_VALUE,
134	TimeUnit.NANOSECONDS.convert(Long.MAX_VALUE / 2,
135	TimeUnit.SECONDS));
136	assertEquals(Long.MIN_VALUE,
137	TimeUnit.NANOSECONDS.convert(-Long.MAX_VALUE / 4,
138	TimeUnit.SECONDS));
139
140	}
141
142	public void testToNanosSaturate() {
143	assertEquals(Long.MAX_VALUE,
144	TimeUnit.MILLISECONDS.toNanos(Long.MAX_VALUE / 2));
145	assertEquals(Long.MIN_VALUE,
146	TimeUnit.MILLISECONDS.toNanos(-Long.MAX_VALUE / 3));
147
148	}
149
150
151	public void testToString() {
152	String s = TimeUnit.SECONDS.toString();
153	assertTrue(s.indexOf("econd") >= 0);
154	}
155
156
157	/**
158	* Timed wait without holding lock throws
159	* IllegalMonitorStateException
160	*/
161	public void testTimedWait_IllegalMonitorException() {
162	//created a new thread with anonymous runnable
163
164	Thread t = new Thread(new Runnable() {
165	public void run() {
166	Object o = new Object();
167	TimeUnit tu = TimeUnit.MILLISECONDS;
168	try {
169	tu.timedWait(o,LONG_DELAY_MS);
170	fail("should throw");
171	}
172	catch (InterruptedException ie) {
173	fail("should not throw IE here");
174	}
175	catch(IllegalMonitorStateException success) {
176	}
177
178	}
179	});
180	t.start();
181	try {
182	Thread.sleep(SHORT_DELAY_MS);
183	t.interrupt();
184	t.join();
185	} catch(Exception e) {
186	fail("Unexpected exception");
187	}
188	}
189
190	/**
191	* timedWait will throw InterruptedException.
192	* Thread t waits on timedWait while the main thread interrupts it.
193	* Note: This does not throw IllegalMonitorException since timeWait
194	* is synchronized on o
195	*/
196	public void testTimedWait() {
197	Thread t = new Thread(new Runnable() {
198	public void run() {
199	Object o = new Object();
200
201	TimeUnit tu = TimeUnit.MILLISECONDS;
202	try {
203	synchronized(o) {
204	tu.timedWait(o,MEDIUM_DELAY_MS);
205	}
206	fail("should throw");
207	}
208	catch(InterruptedException success) {}
209	catch(IllegalMonitorStateException failure) {
210	fail("should not throw");
211	}
212	}
213	});
214	t.start();
215	try {
216	Thread.sleep(SHORT_DELAY_MS);
217	t.interrupt();
218	t.join();
219	} catch(Exception e) {
220	fail("Unexpected exception");
221	}
222	}
223
224
225	/**
226	* timedJoin will throw InterruptedException.
227	* Thread t waits on timedJoin while the main thread interrupts it.
228	*/
229	public void testTimedJoin() {
230	Thread t = new Thread(new Runnable() {
231	public void run() {
232	TimeUnit tu = TimeUnit.MILLISECONDS;
233	try {
234	Thread s = new Thread(new Runnable() {
235	public void run() {
236	try{
237	Thread.sleep(MEDIUM_DELAY_MS);
238	}catch(InterruptedException success){}
239	}
240	});
241	s.start();
242	tu.timedJoin(s,MEDIUM_DELAY_MS);
243	fail("should throw");
244	}
245	catch(Exception e) {}
246	}
247	});
248	t.start();
249	try {
250	Thread.sleep(SHORT_DELAY_MS);
251	t.interrupt();
252	t.join();
253	} catch(Exception e) {
254	fail("Unexpected exception");
255	}
256	}
257
258	/**
259	* timedSleep will throw InterruptedException.
260	* Thread t waits on timedSleep while the main thread interrupts it.
261	*/
262	public void testTimedSleep() {
263	//created a new thread with anonymous runnable
264
265	Thread t = new Thread(new Runnable() {
266	public void run() {
267	TimeUnit tu = TimeUnit.MILLISECONDS;
268	try {
269	tu.sleep(MEDIUM_DELAY_MS);
270	fail("should throw");
271	}
272	catch(InterruptedException success) {}
273	}
274	});
275	t.start();
276	try {
277	Thread.sleep(SHORT_DELAY_MS);
278	t.interrupt();
279	t.join();
280	} catch(Exception e) {
281	fail("Unexpected exception");
282	}
283	}
284
285	public void testSerialization() {
286	TimeUnit q = TimeUnit.MILLISECONDS;
287
288	try {
289	ByteArrayOutputStream bout = new ByteArrayOutputStream(10000);
290	ObjectOutputStream out = new ObjectOutputStream(new BufferedOutputStream(bout));
291	out.writeObject(q);
292	out.close();
293
294	ByteArrayInputStream bin = new ByteArrayInputStream(bout.toByteArray());
295	ObjectInputStream in = new ObjectInputStream(new BufferedInputStream(bin));
296	TimeUnit r = (TimeUnit)in.readObject();
297
298	assertEquals(q.toString(), r.toString());
299	} catch(Exception e){
300	e.printStackTrace();
301	fail("unexpected exception");
302	}
303	}
304
305	}