test/tck/TimeUnitTest.java

/*
 * Written by Doug Lea with assistance from members of JCP JSR-166
 * Expert Group and released to the public domain, as explained at
 * http://creativecommons.org/licenses/publicdomain
 * Other contributors include Andrew Wright, Jeffrey Hayes, 
 * Pat Fisher, 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);
    }

    // (loops to 88888 check increments at all time divisions.)

    /**
     * convert correctly converts sample values across the units
     */
    public void testConvert() {
        for (long t = 0; t < 88888; ++t) {
            assertEquals(t*60*60*24, 
                         TimeUnit.SECONDS.convert(t, 
                                                  TimeUnit.DAYS));
            assertEquals(t*60*60, 
                         TimeUnit.SECONDS.convert(t, 
                                                  TimeUnit.HOURS));
            assertEquals(t*60, 
                         TimeUnit.SECONDS.convert(t, 
                                                  TimeUnit.MINUTES));
            assertEquals(t, 
                         TimeUnit.SECONDS.convert(t, 
                                                  TimeUnit.SECONDS));
            assertEquals(t, 
                         TimeUnit.SECONDS.convert(1000L*t, 
                                                  TimeUnit.MILLISECONDS));
            assertEquals(t, 
                         TimeUnit.SECONDS.convert(1000000L*t, 
                                                  TimeUnit.MICROSECONDS));
            assertEquals(t, 
                         TimeUnit.SECONDS.convert(1000000000L*t, 
                                                  TimeUnit.NANOSECONDS));


            assertEquals(1000L*t*60*60*24, 
                         TimeUnit.MILLISECONDS.convert(t, 
                                                  TimeUnit.DAYS));
            assertEquals(1000L*t*60*60, 
                         TimeUnit.MILLISECONDS.convert(t, 
                                                  TimeUnit.HOURS));
            assertEquals(1000L*t*60, 
                         TimeUnit.MILLISECONDS.convert(t, 
                                                  TimeUnit.MINUTES));
            assertEquals(1000L*t, 
                         TimeUnit.MILLISECONDS.convert(t, 
                                                  TimeUnit.SECONDS));
            assertEquals(t, 
                         TimeUnit.MILLISECONDS.convert(t, 
                                                  TimeUnit.MILLISECONDS));
            assertEquals(t, 
                         TimeUnit.MILLISECONDS.convert(1000L*t, 
                                                  TimeUnit.MICROSECONDS));
            assertEquals(t, 
                         TimeUnit.MILLISECONDS.convert(1000000L*t, 
                                                  TimeUnit.NANOSECONDS));

            assertEquals(1000000L*t*60*60*24, 
                         TimeUnit.MICROSECONDS.convert(t, 
                                                  TimeUnit.DAYS));
            assertEquals(1000000L*t*60*60, 
                         TimeUnit.MICROSECONDS.convert(t, 
                                                  TimeUnit.HOURS));
            assertEquals(1000000L*t*60, 
                         TimeUnit.MICROSECONDS.convert(t, 
                                                  TimeUnit.MINUTES));
            assertEquals(1000000L*t, 
                         TimeUnit.MICROSECONDS.convert(t, 
                                                  TimeUnit.SECONDS));
            assertEquals(1000L*t, 
                         TimeUnit.MICROSECONDS.convert(t, 
                                                  TimeUnit.MILLISECONDS));
            assertEquals(t, 
                         TimeUnit.MICROSECONDS.convert(t, 
                                                  TimeUnit.MICROSECONDS));
            assertEquals(t, 
                         TimeUnit.MICROSECONDS.convert(1000L*t, 
                                                  TimeUnit.NANOSECONDS));

            assertEquals(1000000000L*t*60*60*24, 
                         TimeUnit.NANOSECONDS.convert(t, 
                                                  TimeUnit.DAYS));
            assertEquals(1000000000L*t*60*60, 
                         TimeUnit.NANOSECONDS.convert(t, 
                                                  TimeUnit.HOURS));
            assertEquals(1000000000L*t*60, 
                         TimeUnit.NANOSECONDS.convert(t, 
                                                  TimeUnit.MINUTES));
            assertEquals(1000000000L*t, 
                         TimeUnit.NANOSECONDS.convert(t, 
                                                  TimeUnit.SECONDS));
            assertEquals(1000000L*t, 
                         TimeUnit.NANOSECONDS.convert(t, 
                                                  TimeUnit.MILLISECONDS));
            assertEquals(1000L*t, 
                         TimeUnit.NANOSECONDS.convert(t, 
                                                  TimeUnit.MICROSECONDS));
            assertEquals(t, 
                         TimeUnit.NANOSECONDS.convert(t, 
                                                  TimeUnit.NANOSECONDS));
        }
    }

    /**
     * toNanos correctly converts sample values in different units to
     * nanoseconds
     */
    public void testToNanos() {
        for (long t = 0; t < 88888; ++t) {
            assertEquals(t*1000000000L*60*60*24, 
                         TimeUnit.DAYS.toNanos(t));
            assertEquals(t*1000000000L*60*60, 
                         TimeUnit.HOURS.toNanos(t));
            assertEquals(t*1000000000L*60, 
                         TimeUnit.MINUTES.toNanos(t));
            assertEquals(1000000000L*t, 
                         TimeUnit.SECONDS.toNanos(t));
            assertEquals(1000000L*t, 
                         TimeUnit.MILLISECONDS.toNanos(t));
            assertEquals(1000L*t, 
                         TimeUnit.MICROSECONDS.toNanos(t));
            assertEquals(t, 
                         TimeUnit.NANOSECONDS.toNanos(t));
        }
    }

    /**
     * toMicros correctly converts sample values in different units to
     * microseconds
     */
    public void testToMicros() {
        for (long t = 0; t < 88888; ++t) {
            assertEquals(t*1000000L*60*60*24, 
                         TimeUnit.DAYS.toMicros(t));
            assertEquals(t*1000000L*60*60, 
                         TimeUnit.HOURS.toMicros(t));
            assertEquals(t*1000000L*60, 
                         TimeUnit.MINUTES.toMicros(t));
            assertEquals(1000000L*t, 
                         TimeUnit.SECONDS.toMicros(t));
            assertEquals(1000L*t, 
                         TimeUnit.MILLISECONDS.toMicros(t));
            assertEquals(t, 
                         TimeUnit.MICROSECONDS.toMicros(t));
            assertEquals(t, 
                         TimeUnit.NANOSECONDS.toMicros(t*1000L));
        }
    }

    /**
     * toMillis correctly converts sample values in different units to
     * milliseconds
     */
    public void testToMillis() {
        for (long t = 0; t < 88888; ++t) {
            assertEquals(t*1000L*60*60*24, 
                         TimeUnit.DAYS.toMillis(t));
            assertEquals(t*1000L*60*60, 
                         TimeUnit.HOURS.toMillis(t));
            assertEquals(t*1000L*60, 
                         TimeUnit.MINUTES.toMillis(t));
            assertEquals(1000L*t, 
                         TimeUnit.SECONDS.toMillis(t));
            assertEquals(t, 
                         TimeUnit.MILLISECONDS.toMillis(t));
            assertEquals(t, 
                         TimeUnit.MICROSECONDS.toMillis(t*1000L));
            assertEquals(t, 
                         TimeUnit.NANOSECONDS.toMillis(t*1000000L));
        }
    }

    /**
     * toSeconds correctly converts sample values in different units to
     * seconds
     */
    public void testToSeconds() {
        for (long t = 0; t < 88888; ++t) {
            assertEquals(t*60*60*24, 
                         TimeUnit.DAYS.toSeconds(t));
            assertEquals(t*60*60, 
                         TimeUnit.HOURS.toSeconds(t));
            assertEquals(t*60, 
                         TimeUnit.MINUTES.toSeconds(t));
            assertEquals(t, 
                         TimeUnit.SECONDS.toSeconds(t));
            assertEquals(t, 
                         TimeUnit.MILLISECONDS.toSeconds(t*1000L));
            assertEquals(t, 
                         TimeUnit.MICROSECONDS.toSeconds(t*1000000L));
            assertEquals(t, 
                         TimeUnit.NANOSECONDS.toSeconds(t*1000000000L));
        }
    }

    /**
     * toMinutes correctly converts sample values in different units to
     * minutes
     */
    public void testToMinutes() {
        for (long t = 0; t < 88888; ++t) {
            assertEquals(t*60*24, 
                         TimeUnit.DAYS.toMinutes(t));
            assertEquals(t*60, 
                         TimeUnit.HOURS.toMinutes(t));
            assertEquals(t, 
                         TimeUnit.MINUTES.toMinutes(t));
            assertEquals(t, 
                         TimeUnit.SECONDS.toMinutes(t*60));
            assertEquals(t, 
                         TimeUnit.MILLISECONDS.toMinutes(t*1000L*60));
            assertEquals(t, 
                         TimeUnit.MICROSECONDS.toMinutes(t*1000000L*60));
            assertEquals(t, 
                         TimeUnit.NANOSECONDS.toMinutes(t*1000000000L*60));
        }
    }

    /**
     * toHours correctly converts sample values in different units to
     * hours
     */
    public void testToHours() {
        for (long t = 0; t < 88888; ++t) {
            assertEquals(t*24, 
                         TimeUnit.DAYS.toHours(t));
            assertEquals(t, 
                         TimeUnit.HOURS.toHours(t));
            assertEquals(t, 
                         TimeUnit.MINUTES.toHours(t*60));
            assertEquals(t, 
                         TimeUnit.SECONDS.toHours(t*60*60));
            assertEquals(t, 
                         TimeUnit.MILLISECONDS.toHours(t*1000L*60*60));
            assertEquals(t, 
                         TimeUnit.MICROSECONDS.toHours(t*1000000L*60*60));
            assertEquals(t, 
                         TimeUnit.NANOSECONDS.toHours(t*1000000000L*60*60));
        }
    }

    /**
     * toDays correctly converts sample values in different units to
     * days
     */
    public void testToDays() {
        for (long t = 0; t < 88888; ++t) {
            assertEquals(t, 
                         TimeUnit.DAYS.toDays(t));
            assertEquals(t, 
                         TimeUnit.HOURS.toDays(t*24));
            assertEquals(t, 
                         TimeUnit.MINUTES.toDays(t*60*24));
            assertEquals(t, 
                         TimeUnit.SECONDS.toDays(t*60*60*24));
            assertEquals(t, 
                         TimeUnit.MILLISECONDS.toDays(t*1000L*60*60*24));
            assertEquals(t, 
                         TimeUnit.MICROSECONDS.toDays(t*1000000L*60*60*24));
            assertEquals(t, 
                         TimeUnit.NANOSECONDS.toDays(t*1000000000L*60*60*24));
        }
    }


    /**
     * convert saturates positive too-large values to Long.MAX_VALUE 
     * and negative to LONG.MIN_VALUE
     */
    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));
        assertEquals(Long.MAX_VALUE,
                     TimeUnit.NANOSECONDS.convert(Long.MAX_VALUE / 2,
                                                  TimeUnit.MINUTES));
        assertEquals(Long.MIN_VALUE,
                     TimeUnit.NANOSECONDS.convert(-Long.MAX_VALUE / 4,
                                                  TimeUnit.MINUTES));
        assertEquals(Long.MAX_VALUE,
                     TimeUnit.NANOSECONDS.convert(Long.MAX_VALUE / 2,
                                                  TimeUnit.HOURS));
        assertEquals(Long.MIN_VALUE,
                     TimeUnit.NANOSECONDS.convert(-Long.MAX_VALUE / 4,
                                                  TimeUnit.HOURS));
        assertEquals(Long.MAX_VALUE,
                     TimeUnit.NANOSECONDS.convert(Long.MAX_VALUE / 2,
                                                  TimeUnit.DAYS));
        assertEquals(Long.MIN_VALUE,
                     TimeUnit.NANOSECONDS.convert(-Long.MAX_VALUE / 4,
                                                  TimeUnit.DAYS));

    }

    /**
     * toNanos saturates positive too-large values to Long.MAX_VALUE 
     * and negative to LONG.MIN_VALUE
     */
    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));
    }


    /**
     * toString returns string containing common name of unit
     */
    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);
                        threadShouldThrow();
                    }
                    catch (InterruptedException ie) {
                        threadUnexpectedException();
                    } 
                    catch(IllegalMonitorStateException success) {
                    }
                    
                }
            });
        t.start();
        try {
            Thread.sleep(SHORT_DELAY_MS);
            t.interrupt();
            t.join();
        } catch(Exception e) {
            unexpectedException();
        }
    }
    
    /**
     * timedWait throws InterruptedException when interrupted
     */
    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);
                        }
                        threadShouldThrow();
                    }
                    catch(InterruptedException success) {} 
                    catch(IllegalMonitorStateException failure) {
                        threadUnexpectedException();
                    }
                }
            });
        t.start();
        try {
            Thread.sleep(SHORT_DELAY_MS);
            t.interrupt();
            t.join();
        } catch(Exception e) {
            unexpectedException();
        }
    }
    
    
    /**
     * timedJoin throws InterruptedException when interrupted
     */
    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);
                        threadShouldThrow();
                    }
                    catch(Exception e) {}
                }
            });
        t.start();
        try {
            Thread.sleep(SHORT_DELAY_MS);
            t.interrupt();
            t.join();
        } catch(Exception e) {
            unexpectedException();
        }
    }
    
    /**
     *  timedSleep throws InterruptedException when interrupted
     */
    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);
                        threadShouldThrow();
                    }
                    catch(InterruptedException success) {} 
                }
            });
        t.start();
        try {
            Thread.sleep(SHORT_DELAY_MS);
            t.interrupt();
            t.join();
        } catch(Exception e) {
            unexpectedException();
        }
    }

    /**
     * a deserialized serialized unit is equal 
     */
    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();
            unexpectedException();
        }
    }

}
Revision:	1.9
Committed:	Thu Dec 30 13:04:50 2004 UTC (19 years, 4 months ago) by dl
Branch:	MAIN
Changes since 1.8:	+183 -33 lines
Log Message:	Added minutes, hours, days support
#	User	Rev	Content
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(t6060*24,
31			TimeUnit.SECONDS.convert(t,
32			TimeUnit.DAYS));
33			assertEquals(t6060,
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(1000Lt606024,
54			TimeUnit.MILLISECONDS.convert(t,
55			TimeUnit.DAYS));
56			assertEquals(1000Lt60*60,
57			TimeUnit.MILLISECONDS.convert(t,
58			TimeUnit.HOURS));
59			assertEquals(1000Lt60,
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(1000000Lt606024,
76			TimeUnit.MICROSECONDS.convert(t,
77			TimeUnit.DAYS));
78			assertEquals(1000000Lt60*60,
79			TimeUnit.MICROSECONDS.convert(t,
80			TimeUnit.HOURS));
81			assertEquals(1000000Lt60,
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(1000000000Lt606024,
98			TimeUnit.NANOSECONDS.convert(t,
99			TimeUnit.DAYS));
100			assertEquals(1000000000Lt60*60,
101			TimeUnit.NANOSECONDS.convert(t,
102			TimeUnit.HOURS));
103			assertEquals(1000000000Lt60,
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(t1000000000L606024,
128			TimeUnit.DAYS.toNanos(t));
129			assertEquals(t1000000000L60*60,
130			TimeUnit.HOURS.toNanos(t));
131			assertEquals(t1000000000L60,
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(t1000000L606024,
151			TimeUnit.DAYS.toMicros(t));
152			assertEquals(t1000000L60*60,
153			TimeUnit.HOURS.toMicros(t));
154			assertEquals(t1000000L60,
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(t1000L606024,
174			TimeUnit.DAYS.toMillis(t));
175			assertEquals(t1000L60*60,
176			TimeUnit.HOURS.toMillis(t));
177			assertEquals(t1000L60,
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(t6060*24,
197			TimeUnit.DAYS.toSeconds(t));
198			assertEquals(t6060,
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(t6024,
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(t1000L60));
229	dl	1.3	assertEquals(t,
230	dl	1.9	TimeUnit.MICROSECONDS.toMinutes(t1000000L60));
231	dl	1.3	assertEquals(t,
232	dl	1.9	TimeUnit.NANOSECONDS.toMinutes(t1000000000L60));
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(t6060));
250			assertEquals(t,
251			TimeUnit.MILLISECONDS.toHours(t1000L60*60));
252			assertEquals(t,
253			TimeUnit.MICROSECONDS.toHours(t1000000L60*60));
254			assertEquals(t,
255			TimeUnit.NANOSECONDS.toHours(t1000000000L60*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(t6024));
271			assertEquals(t,
272			TimeUnit.SECONDS.toDays(t6060*24));
273			assertEquals(t,
274			TimeUnit.MILLISECONDS.toDays(t1000L606024));
275			assertEquals(t,
276			TimeUnit.MICROSECONDS.toDays(t1000000L606024));
277			assertEquals(t,
278			TimeUnit.NANOSECONDS.toDays(t1000000000L606024));
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	}