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 TestCase {
      static public boolean DEBUG = false;


    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.SECONDS.NANOSECONDS.toNanos(t));
        }
    }


    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);
    }

    // Exception tests
    
    /**
     *  This test specifically to catch the unreported exception
     */
    public void testTimedWaitForUnreportedIllegalMonitorException() {
        //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,40000);
                        fail("should throw");
                    }
                    catch (InterruptedException ie) {
                        fail("should not throw IE here");
                    } 
                    catch(IllegalMonitorStateException success) {
                    }
                    
                }
            });
        t.start();
        try {
            Thread.sleep(100);
            t.interrupt();
            t.join();
        } catch(Exception e) {
            fail("Unexpected exception");
        }
    }
    
    /**
     *  Test to verify that 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,1000);
                        }
                        fail("should throw");
                    }
                    catch(InterruptedException success) {} 
                    catch(IllegalMonitorStateException failure) {
                        fail("should not throw");
                    }
                }
            });
        t.start();
        try {
            Thread.sleep(100);
            t.interrupt();
            t.join();
        } catch(Exception e) {
            fail("Unexpected exception");
        }
    }
    
    
    /**
     *  Test to verify that 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(1000);
                                    }catch(InterruptedException success){}
                                }
                            });
                        s.start();
                        tu.timedJoin(s,1000);
                        fail("should throw");
                    }
                    catch(Exception e) {}
                }
            });
        t.start();
        try {
            Thread.sleep(100);
            t.interrupt();
            t.join();
        } catch(Exception e) {
            fail("Unexpected exception");
        }
    }
    
    /**
     *  Test to verify that 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(1000);
                        fail("should throw");
                    }
                    catch(InterruptedException success) {} 
                }
            });
        t.start();
        try {
            Thread.sleep(100);
            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.2
Committed:	Sun Sep 7 20:39:11 2003 UTC (20 years, 8 months ago) by dl
Branch:	MAIN
Changes since 1.1:	+22 -0 lines
Log Message:	Added serialization and lock tests
#	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 TestCase {
14	static public boolean DEBUG = false;
15
16
17	public static void main(String[] args) {
18	junit.textui.TestRunner.run(suite());
19	}
20
21	public static Test suite() {
22	return new TestSuite(TimeUnitTest.class);
23	}
24
25	public void testConvert() {
26	for (long t = 0; t < 10; ++t) {
27	assertEquals(t,
28	TimeUnit.SECONDS.convert(t,
29	TimeUnit.SECONDS));
30	assertEquals(t,
31	TimeUnit.SECONDS.convert(1000 * t,
32	TimeUnit.MILLISECONDS));
33	assertEquals(t,
34	TimeUnit.SECONDS.convert(1000000 * t,
35	TimeUnit.MICROSECONDS));
36	assertEquals(t,
37	TimeUnit.SECONDS.convert(1000000000 * t,
38	TimeUnit.NANOSECONDS));
39	assertEquals(1000 * t,
40	TimeUnit.MILLISECONDS.convert(t,
41	TimeUnit.SECONDS));
42	assertEquals(t,
43	TimeUnit.MILLISECONDS.convert(t,
44	TimeUnit.MILLISECONDS));
45	assertEquals(t,
46	TimeUnit.MILLISECONDS.convert(1000 * t,
47	TimeUnit.MICROSECONDS));
48	assertEquals(t,
49	TimeUnit.MILLISECONDS.convert(1000000 * t,
50	TimeUnit.NANOSECONDS));
51	assertEquals(1000000 * t,
52	TimeUnit.MICROSECONDS.convert(t,
53	TimeUnit.SECONDS));
54	assertEquals(1000 * t,
55	TimeUnit.MICROSECONDS.convert(t,
56	TimeUnit.MILLISECONDS));
57	assertEquals(t,
58	TimeUnit.MICROSECONDS.convert(t,
59	TimeUnit.MICROSECONDS));
60	assertEquals(t,
61	TimeUnit.MICROSECONDS.convert(1000 * t,
62	TimeUnit.NANOSECONDS));
63	assertEquals(1000000000 * t,
64	TimeUnit.NANOSECONDS.convert(t,
65	TimeUnit.SECONDS));
66	assertEquals(1000000 * t,
67	TimeUnit.NANOSECONDS.convert(t,
68	TimeUnit.MILLISECONDS));
69	assertEquals(1000 * t,
70	TimeUnit.NANOSECONDS.convert(t,
71	TimeUnit.MICROSECONDS));
72	assertEquals(t,
73	TimeUnit.NANOSECONDS.convert(t,
74	TimeUnit.NANOSECONDS));
75	}
76	}
77
78	public void testToNanos() {
79	for (long t = 0; t < 10; ++t) {
80	assertEquals(1000000000 * t,
81	TimeUnit.SECONDS.toNanos(t));
82
83	assertEquals(1000000 * t,
84	TimeUnit.MILLISECONDS.toNanos(t));
85	assertEquals(1000 * t,
86	TimeUnit.MICROSECONDS.toNanos(t));
87	assertEquals(t,
88	TimeUnit.SECONDS.NANOSECONDS.toNanos(t));
89	}
90	}
91
92
93	public void testConvertSaturate() {
94	assertEquals(Long.MAX_VALUE,
95	TimeUnit.NANOSECONDS.convert(Long.MAX_VALUE / 2,
96	TimeUnit.SECONDS));
97	assertEquals(Long.MIN_VALUE,
98	TimeUnit.NANOSECONDS.convert(-Long.MAX_VALUE / 4,
99	TimeUnit.SECONDS));
100
101	}
102
103	public void testToNanosSaturate() {
104	assertEquals(Long.MAX_VALUE,
105	TimeUnit.MILLISECONDS.toNanos(Long.MAX_VALUE / 2));
106	assertEquals(Long.MIN_VALUE,
107	TimeUnit.MILLISECONDS.toNanos(-Long.MAX_VALUE / 3));
108
109	}
110
111
112	public void testToString() {
113	String s = TimeUnit.SECONDS.toString();
114	assertTrue(s.indexOf("econd") >= 0);
115	}
116
117	// Exception tests
118
119	/**
120	* This test specifically to catch the unreported exception
121	*/
122	public void testTimedWaitForUnreportedIllegalMonitorException() {
123	//created a new thread with anonymous runnable
124
125	Thread t = new Thread(new Runnable() {
126	public void run() {
127	Object o = new Object();
128	TimeUnit tu = TimeUnit.MILLISECONDS;
129	try {
130	tu.timedWait(o,40000);
131	fail("should throw");
132	}
133	catch (InterruptedException ie) {
134	fail("should not throw IE here");
135	}
136	catch(IllegalMonitorStateException success) {
137	}
138
139	}
140	});
141	t.start();
142	try {
143	Thread.sleep(100);
144	t.interrupt();
145	t.join();
146	} catch(Exception e) {
147	fail("Unexpected exception");
148	}
149	}
150
151	/**
152	* Test to verify that timedWait will throw InterruptedException.
153	* Thread t waits on timedWait while the main thread interrupts it.
154	* Note: This does not throw IllegalMonitorException since timeWait
155	* is synchronized on o
156	*/
157	public void testTimedWait() {
158	Thread t = new Thread(new Runnable() {
159	public void run() {
160	Object o = new Object();
161
162	TimeUnit tu = TimeUnit.MILLISECONDS;
163	try {
164	synchronized(o) {
165	tu.timedWait(o,1000);
166	}
167	fail("should throw");
168	}
169	catch(InterruptedException success) {}
170	catch(IllegalMonitorStateException failure) {
171	fail("should not throw");
172	}
173	}
174	});
175	t.start();
176	try {
177	Thread.sleep(100);
178	t.interrupt();
179	t.join();
180	} catch(Exception e) {
181	fail("Unexpected exception");
182	}
183	}
184
185
186	/**
187	* Test to verify that timedJoin will throw InterruptedException.
188	* Thread t waits on timedJoin while the main thread interrupts it.
189	*/
190	public void testTimedJoin() {
191	Thread t = new Thread(new Runnable() {
192	public void run() {
193	TimeUnit tu = TimeUnit.MILLISECONDS;
194	try {
195	Thread s = new Thread(new Runnable() {
196	public void run() {
197	try{
198	Thread.sleep(1000);
199	}catch(InterruptedException success){}
200	}
201	});
202	s.start();
203	tu.timedJoin(s,1000);
204	fail("should throw");
205	}
206	catch(Exception e) {}
207	}
208	});
209	t.start();
210	try {
211	Thread.sleep(100);
212	t.interrupt();
213	t.join();
214	} catch(Exception e) {
215	fail("Unexpected exception");
216	}
217	}
218
219	/**
220	* Test to verify that timedSleep will throw InterruptedException.
221	* Thread t waits on timedSleep while the main thread interrupts it.
222	*/
223	public void testTimedSleep() {
224	//created a new thread with anonymous runnable
225
226	Thread t = new Thread(new Runnable() {
227	public void run() {
228	TimeUnit tu = TimeUnit.MILLISECONDS;
229	try {
230	tu.sleep(1000);
231	fail("should throw");
232	}
233	catch(InterruptedException success) {}
234	}
235	});
236	t.start();
237	try {
238	Thread.sleep(100);
239	t.interrupt();
240	t.join();
241	} catch(Exception e) {
242	fail("Unexpected exception");
243	}
244	}
245
246	public void testSerialization() {
247	TimeUnit q = TimeUnit.MILLISECONDS;
248
249	try {
250	ByteArrayOutputStream bout = new ByteArrayOutputStream(10000);
251	ObjectOutputStream out = new ObjectOutputStream(new BufferedOutputStream(bout));
252	out.writeObject(q);
253	out.close();
254
255	ByteArrayInputStream bin = new ByteArrayInputStream(bout.toByteArray());
256	ObjectInputStream in = new ObjectInputStream(new BufferedInputStream(bin));
257	TimeUnit r = (TimeUnit)in.readObject();
258
259	assertEquals(q.toString(), r.toString());
260	} catch(Exception e){
261	e.printStackTrace();
262	fail("unexpected exception");
263	}
264	}
265
266	}