ViewVC Help

View File | Revision Log | Show Annotations | Download File | Root Listing

root/jsr166/jsr166/src/test/tck/SystemTest.java

Comparing jsr166/src/test/tck/SystemTest.java (file contents):
Revision 1.2 by dl, Sun Sep 14 20:42:41 2003 UTC vs.
Revision 1.10 by jsr166, Sat Oct 9 19:30:35 2010 UTC

#	Line 1 | Line 1
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.
2	>	* 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		*/
8
9		import junit.framework.*;
10
11		public class SystemTest extends JSR166TestCase {
12		public static void main(String[] args) {
13	<	junit.textui.TestRunner.run(suite());
13	>	junit.textui.TestRunner.run(suite());
14		}
15	<
15	>
16		public static Test suite() {
17	<	return new TestSuite(SystemTest.class);
17	>	return new TestSuite(SystemTest.class);
18		}
19
20		/**
21	<	* Nanos between readings of millis is no longer than millis.
21	>	* Worst case rounding for millisecs; set for 60 cycle millis clock.
22	>	* This value might need to be changed on JVMs with coarser
23	>	* System.currentTimeMillis clocks.
24	>	*/
25	>	static final long MILLIS_ROUND = 17;
26	>
27	>	/**
28	>	* Nanos between readings of millis is no longer than millis (plus
29	>	* possible rounding).
30		* This shows only that nano timing not (much) worse than milli.
31		*/
32	<	public void testNanoTime1() {
33	<	try {
34	<	long m1 = System.currentTimeMillis();
35	<	Thread.sleep(1);
36	<	long n1 = System.nanoTime();
37	<	Thread.sleep(SHORT_DELAY_MS);
38	<	long n2 = System.nanoTime();
39	<	Thread.sleep(1);
40	<	long m2 = System.currentTimeMillis();
41	<	long millis = m2 - m1;
42	<	long nanos = n2 - n1;
43	<
44	<	assertTrue(nanos >= 0);
36	<	assertTrue(nanos <= millis * 1000000);
37	<	}
38	<	catch(InterruptedException ie) {
39	<	fail("unexpected exception");
40	<	}
32	>	public void testNanoTime1() throws InterruptedException {
33	>	long m1 = System.currentTimeMillis();
34	>	Thread.sleep(1);
35	>	long n1 = System.nanoTime();
36	>	Thread.sleep(SHORT_DELAY_MS);
37	>	long n2 = System.nanoTime();
38	>	Thread.sleep(1);
39	>	long m2 = System.currentTimeMillis();
40	>	long millis = m2 - m1;
41	>	long nanos = n2 - n1;
42	>	assertTrue(nanos >= 0);
43	>	long nanosAsMillis = nanos / 1000000;
44	>	assertTrue(nanosAsMillis <= millis + MILLIS_ROUND);
45		}
46
47		/**
48	<	* Millis between readings of nanos is no longer than nanos
48	>	* Millis between readings of nanos is less than nanos, adjusting
49	>	* for rounding.
50		* This shows only that nano timing not (much) worse than milli.
51		*/
52	<	public void testNanoTime2() {
53	<	try {
54	<	long n1 = System.nanoTime();
55	<	Thread.sleep(1);
56	<	long m1 = System.currentTimeMillis();
57	<	Thread.sleep(SHORT_DELAY_MS);
58	<	long m2 = System.currentTimeMillis();
59	<	Thread.sleep(1);
60	<	long n2 = System.nanoTime();
61	<	long millis = m2 - m1;
62	<	long nanos = n2 - n1;
63	<
64	<	assertTrue(nanos >= 0);
65	<	assertTrue(millis * 1000000 <= nanos);
61	<	}
62	<	catch(InterruptedException ie) {
63	<	fail("unexpected exception");
64	<	}
52	>	public void testNanoTime2() throws InterruptedException {
53	>	long n1 = System.nanoTime();
54	>	Thread.sleep(1);
55	>	long m1 = System.currentTimeMillis();
56	>	Thread.sleep(SHORT_DELAY_MS);
57	>	long m2 = System.currentTimeMillis();
58	>	Thread.sleep(1);
59	>	long n2 = System.nanoTime();
60	>	long millis = m2 - m1;
61	>	long nanos = n2 - n1;
62	>
63	>	assertTrue(nanos >= 0);
64	>	long nanosAsMillis = nanos / 1000000;
65	>	assertTrue(millis <= nanosAsMillis + MILLIS_ROUND);
66		}
67
68		}
68	–

Diff Legend

–	Removed lines
+	Added lines
<	Changed lines
>	Changed lines