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.4 by tim, Mon Dec 8 20:01:50 2003 UTC vs.
Revision 1.14 by jsr166, Sun May 14 03:09:25 2017 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/publicdomain/zero/1.0/
5	>	* Other contributors include Andrew Wright, Jeffrey Hayes,
6	>	* Pat Fisher, Mike Judd.
7		*/
8
9	<	import junit.framework.*;
9	>	import junit.framework.Test;
10	>	import junit.framework.TestSuite;
11
12		public class SystemTest extends JSR166TestCase {
13		public static void main(String[] args) {
14	<	junit.textui.TestRunner.run(suite());
14	>	main(suite(), args);
15		}
16	<
16	>
17		public static Test suite() {
18		return new TestSuite(SystemTest.class);
19		}
20
21		/**
22	<	* Nanos between readings of millis is no longer than millis (plus
23	<	* one milli to allow for rounding).
24	<	* This shows only that nano timing not (much) worse than milli.
22	>	* Worst case rounding for millisecs; set for 60 cycle millis clock.
23	>	* This value might need to be changed on JVMs with coarser
24	>	* System.currentTimeMillis clocks.
25		*/
26	<	public void testNanoTime1() {
25	<	try {
26	<	long m1 = System.currentTimeMillis();
27	<	Thread.sleep(1);
28	<	long n1 = System.nanoTime();
29	<	Thread.sleep(SHORT_DELAY_MS);
30	<	long n2 = System.nanoTime();
31	<	Thread.sleep(1);
32	<	long m2 = System.currentTimeMillis();
33	<	long millis = m2 - m1;
34	<	long nanos = n2 - n1;
35	<
36	<	assertTrue(nanos >= 0);
37	<	assertTrue(nanos < (millis+1) * 1000000);
38	<	}
39	<	catch(InterruptedException ie) {
40	<	unexpectedException();
41	<	}
42	<	}
26	>	static final long MILLIS_ROUND = 17;
27
28		/**
29	<	* Millis between readings of nanos is no longer than nanos
29	>	* Nanos between readings of millis is no longer than millis (plus
30	>	* possible rounding), and vice versa.
31		* This shows only that nano timing not (much) worse than milli.
32		*/
33	<	public void testNanoTime2() {
34	<	try {
35	<	long n1 = System.nanoTime();
36	<	Thread.sleep(1);
37	<	long m1 = System.currentTimeMillis();
38	<	Thread.sleep(SHORT_DELAY_MS);
39	<	long m2 = System.currentTimeMillis();
40	<	Thread.sleep(1);
41	<	long n2 = System.nanoTime();
42	<	long millis = m2 - m1;
43	<	long nanos = n2 - n1;
44	<
45	<	assertTrue(nanos >= 0);
46	<	assertTrue(millis * 1000000 <= nanos);
62	<	}
63	<	catch(InterruptedException ie) {
64	<	unexpectedException();
65	<	}
33	>	public void testNanoTime() throws InterruptedException {
34	>	long m0 = System.currentTimeMillis();
35	>	long n0 = System.nanoTime();
36	>	Thread.sleep(1);
37	>	long m1 = System.currentTimeMillis();
38	>	long n1 = System.nanoTime();
39	>	Thread.sleep(50);       // avoid possibly scaled SHORT_DELAY_MS
40	>	long m2 = System.currentTimeMillis();
41	>	long n2 = System.nanoTime();
42	>	Thread.sleep(1);
43	>	long m3 = System.currentTimeMillis();
44	>	long n3 = System.nanoTime();
45	>	assertTrue((n2 - n1) / 1_000_000 <= m3 - m0 + MILLIS_ROUND);
46	>	assertTrue(m2 - m1 <= (n3 - n0) / 1_000_000 + MILLIS_ROUND);
47		}
67	–
48		}
69	–

Diff Legend

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