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.1 by dl, Sun Aug 31 19:24:55 2003 UTC vs.
Revision 1.2 by dl, Sun Sep 14 20:42:41 2003 UTC

#	Line 7 | Line 7
7
8		import junit.framework.*;
9
10	<	public class SystemTest extends TestCase {
10	>	public class SystemTest extends JSR166TestCase {
11		public static void main(String[] args) {
12		junit.textui.TestRunner.run(suite());
13		}
#	Line 16 | Line 16 | public class SystemTest extends TestCase
16		return new TestSuite(SystemTest.class);
17		}
18
19	+	/**
20	+	* Nanos between readings of millis is no longer than millis.
21	+	* This shows only that nano timing not (much) worse than milli.
22	+	*/
23		public void testNanoTime1() {
24	<	// Nanos between readings of millis must be no longer than millis
25	<	long m1 = System.currentTimeMillis();
26	<	long n1 = System.nanoTime();
27	<
28	<	// Ensure some computation that is not optimized away.
29	<	long sum = 0;
30	<	for (long i = 1; i < 10000; ++i)
31	<	sum += i;
32	<	assertTrue(sum != 0);
33	<
34	<	long n2 = System.nanoTime();
35	<
36	<	for (long i = 1; i < 10000; ++i)
37	<	sum -= i;
38	<	assertTrue(sum == 0);
39	<
40	<	long m2 = System.currentTimeMillis();
37	<	long millis = m2 - m1;
38	<	long nanos = n2 - n1;
39	<
40	<	assertTrue(nanos >= 0);
41	<	assertTrue(nanos <= millis * 1000000);
24	>	try {
25	>	long m1 = System.currentTimeMillis();
26	>	Thread.sleep(1);
27	>	long n1 = System.nanoTime();
28	>	Thread.sleep(SHORT_DELAY_MS);
29	>	long n2 = System.nanoTime();
30	>	Thread.sleep(1);
31	>	long m2 = System.currentTimeMillis();
32	>	long millis = m2 - m1;
33	>	long nanos = n2 - n1;
34	>
35	>	assertTrue(nanos >= 0);
36	>	assertTrue(nanos <= millis * 1000000);
37	>	}
38	>	catch(InterruptedException ie) {
39	>	fail("unexpected exception");
40	>	}
41		}
42
43	+	/**
44	+	* Millis between readings of nanos is no longer than nanos
45	+	* This shows only that nano timing not (much) worse than milli.
46	+	*/
47		public void testNanoTime2() {
48	<	// Millis between readings of nanos must be no longer than nanos
49	<	long n1 = System.nanoTime();
50	<	long m1 = System.currentTimeMillis();
51	<
52	<	// Ensure some computation that is not optimized away.
53	<	long sum = 0;
54	<	for (long i = 1; i < 10000; ++i)
55	<	sum += i;
56	<	assertTrue(sum != 0);
57	<
58	<	long m2 = System.currentTimeMillis();
59	<
60	<	for (long i = 1; i < 10000; ++i)
61	<	sum -= i;
62	<	assertTrue(sum == 0);
63	<
64	<	long n2 = System.nanoTime();
62	<
63	<	long millis = m2 - m1;
64	<	long nanos = n2 - n1;
65	<
66	<	assertTrue(nanos >= 0);
67	<	assertTrue(millis * 1000000 <= nanos);
48	>	try {
49	>	long n1 = System.nanoTime();
50	>	Thread.sleep(1);
51	>	long m1 = System.currentTimeMillis();
52	>	Thread.sleep(SHORT_DELAY_MS);
53	>	long m2 = System.currentTimeMillis();
54	>	Thread.sleep(1);
55	>	long n2 = System.nanoTime();
56	>	long millis = m2 - m1;
57	>	long nanos = n2 - n1;
58	>
59	>	assertTrue(nanos >= 0);
60	>	assertTrue(millis * 1000000 <= nanos);
61	>	}
62	>	catch(InterruptedException ie) {
63	>	fail("unexpected exception");
64	>	}
65		}
66
67		}

Diff Legend

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