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.*;

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