ViewVC Help
View File | Revision Log | Show Annotations | Download File | Root Listing
root/jsr166/jsr166/src/test/tck/SystemTest.java
(Generate patch)

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.7 by jsr166, Mon Nov 2 20:28:32 2009 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);
18      }
19  
20      /**
21 +     * Worst case rounding for millisecs; set for 60 cycle millis clock.
22 +     * This value might need to be changed os 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 <     * one milli to allow for rounding).
29 >     * possible rounding).
30       * This shows only that nano timing not (much) worse than milli.
31       */
32      public void testNanoTime1() {
# Line 32 | Line 40 | public class SystemTest extends JSR166Te
40              long m2 = System.currentTimeMillis();
41              long millis = m2 - m1;
42              long nanos = n2 - n1;
35 –            
43              assertTrue(nanos >= 0);
44 <            assertTrue(nanos < (millis+1) * 1000000);
44 >            long nanosAsMillis = nanos / 1000000;
45 >            assertTrue(nanosAsMillis <= millis + MILLIS_ROUND);
46          }
47          catch(InterruptedException ie) {
48              unexpectedException();
# Line 42 | Line 50 | public class SystemTest extends JSR166Te
50      }
51  
52      /**
53 <     * Millis between readings of nanos is no longer than nanos
53 >     * Millis between readings of nanos is less than nanos, adjusting
54 >     * for rounding.
55       * This shows only that nano timing not (much) worse than milli.
56       */
57      public void testNanoTime2() {
# Line 56 | Line 65 | public class SystemTest extends JSR166Te
65              long n2 = System.nanoTime();
66              long millis = m2 - m1;
67              long nanos = n2 - n1;
68 <            
68 >
69              assertTrue(nanos >= 0);
70 <            assertTrue(millis * 1000000 <= nanos);
70 >            long nanosAsMillis = nanos / 1000000;
71 >            assertTrue(millis <= nanosAsMillis + MILLIS_ROUND);
72          }
73          catch(InterruptedException ie) {
74              unexpectedException();
# Line 66 | Line 76 | public class SystemTest extends JSR166Te
76      }
77  
78   }
69 –

Diff Legend

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