[cvs] / jsr166 / src / test / tck / TimeUnitTest.java Repository:
ViewVC logotype

Diff of /jsr166/src/test/tck/TimeUnitTest.java

Parent Directory Parent Directory | Revision Log Revision Log | View Patch Patch

revision 1.2, Sun Sep 7 20:39:11 2003 UTC revision 1.3, Sun Sep 14 20:42:41 2003 UTC
# Line 10  Line 10 
10  import java.util.concurrent.*;  import java.util.concurrent.*;
11  import java.io.*;  import java.io.*;
12    
13  public class TimeUnitTest extends TestCase {  public class TimeUnitTest extends JSR166TestCase {
       static public boolean DEBUG = false;  
   
   
14      public static void main(String[] args) {      public static void main(String[] args) {
15          junit.textui.TestRunner.run(suite());          junit.textui.TestRunner.run(suite());
16      }      }
# Line 85  Line 82 
82              assertEquals(1000 * t,              assertEquals(1000 * t,
83                           TimeUnit.MICROSECONDS.toNanos(t));                           TimeUnit.MICROSECONDS.toNanos(t));
84              assertEquals(t,              assertEquals(t,
85                           TimeUnit.SECONDS.NANOSECONDS.toNanos(t));                           TimeUnit.NANOSECONDS.toNanos(t));
86            }
87        }
88    
89        public void testToMicros() {
90            for (long t = 0; t < 10; ++t) {
91                assertEquals(1000000 * t,
92                             TimeUnit.SECONDS.toMicros(t));
93    
94                assertEquals(1000 * t,
95                             TimeUnit.MILLISECONDS.toMicros(t));
96                assertEquals(t,
97                             TimeUnit.MICROSECONDS.toMicros(t));
98                assertEquals(t,
99                             TimeUnit.NANOSECONDS.toMicros(t * 1000));
100            }
101        }
102    
103        public void testToMillis() {
104            for (long t = 0; t < 10; ++t) {
105                assertEquals(1000 * t,
106                             TimeUnit.SECONDS.toMillis(t));
107    
108                assertEquals(t,
109                             TimeUnit.MILLISECONDS.toMillis(t));
110                assertEquals(t,
111                             TimeUnit.MICROSECONDS.toMillis(t * 1000));
112                assertEquals(t,
113                             TimeUnit.NANOSECONDS.toMillis(t * 1000000));
114            }
115        }
116    
117        public void testToSeconds() {
118            for (long t = 0; t < 10; ++t) {
119                assertEquals(t,
120                             TimeUnit.SECONDS.toSeconds(t));
121    
122                assertEquals(t,
123                             TimeUnit.MILLISECONDS.toSeconds(t * 1000));
124                assertEquals(t,
125                             TimeUnit.MICROSECONDS.toSeconds(t * 1000000));
126                assertEquals(t,
127                             TimeUnit.NANOSECONDS.toSeconds(t * 1000000000));
128          }          }
129      }      }
130    
# Line 114  Line 153 
153          assertTrue(s.indexOf("econd") >= 0);          assertTrue(s.indexOf("econd") >= 0);
154      }      }
155    
     // Exception tests  
156    
157      /**      /**
158       *  This test specifically to catch the unreported exception       *  Timed wait without holding lock throws
159         *  IllegalMonitorStateException
160       */       */
161      public void testTimedWaitForUnreportedIllegalMonitorException() {      public void testTimedWait_IllegalMonitorException() {
162          //created a new thread with anonymous runnable          //created a new thread with anonymous runnable
163    
164          Thread t = new Thread(new Runnable() {          Thread t = new Thread(new Runnable() {
# Line 127  Line 166 
166                      Object o = new Object();                      Object o = new Object();
167                      TimeUnit tu = TimeUnit.MILLISECONDS;                      TimeUnit tu = TimeUnit.MILLISECONDS;
168                      try {                      try {
169                          tu.timedWait(o,40000);                          tu.timedWait(o,LONG_DELAY_MS);
170                          fail("should throw");                          fail("should throw");
171                      }                      }
172                      catch (InterruptedException ie) {                      catch (InterruptedException ie) {
# Line 140  Line 179 
179              });              });
180          t.start();          t.start();
181          try {          try {
182              Thread.sleep(100);              Thread.sleep(SHORT_DELAY_MS);
183              t.interrupt();              t.interrupt();
184              t.join();              t.join();
185          } catch(Exception e) {          } catch(Exception e) {
# Line 149  Line 188 
188      }      }
189    
190      /**      /**
191       *  Test to verify that timedWait will throw InterruptedException.       *   timedWait will throw InterruptedException.
192       *  Thread t waits on timedWait while the main thread interrupts it.       *  Thread t waits on timedWait while the main thread interrupts it.
193       *  Note:  This does not throw IllegalMonitorException since timeWait       *  Note:  This does not throw IllegalMonitorException since timeWait
194       *         is synchronized on o       *         is synchronized on o
# Line 162  Line 201 
201                      TimeUnit tu = TimeUnit.MILLISECONDS;                      TimeUnit tu = TimeUnit.MILLISECONDS;
202                      try {                      try {
203                          synchronized(o) {                          synchronized(o) {
204                              tu.timedWait(o,1000);                              tu.timedWait(o,MEDIUM_DELAY_MS);
205                          }                          }
206                          fail("should throw");                          fail("should throw");
207                      }                      }
# Line 174  Line 213 
213              });              });
214          t.start();          t.start();
215          try {          try {
216              Thread.sleep(100);              Thread.sleep(SHORT_DELAY_MS);
217              t.interrupt();              t.interrupt();
218              t.join();              t.join();
219          } catch(Exception e) {          } catch(Exception e) {
# Line 184  Line 223 
223    
224    
225      /**      /**
226       *  Test to verify that timedJoin will throw InterruptedException.       *   timedJoin will throw InterruptedException.
227       *  Thread t waits on timedJoin while the main thread interrupts it.       *  Thread t waits on timedJoin while the main thread interrupts it.
228       */       */
229      public void testTimedJoin() {      public void testTimedJoin() {
# Line 195  Line 234 
234                          Thread s = new Thread(new Runnable() {                          Thread s = new Thread(new Runnable() {
235                                  public void run() {                                  public void run() {
236                                      try{                                      try{
237                                          Thread.sleep(1000);                                          Thread.sleep(MEDIUM_DELAY_MS);
238                                      }catch(InterruptedException success){}                                      }catch(InterruptedException success){}
239                                  }                                  }
240                              });                              });
241                          s.start();                          s.start();
242                          tu.timedJoin(s,1000);                          tu.timedJoin(s,MEDIUM_DELAY_MS);
243                          fail("should throw");                          fail("should throw");
244                      }                      }
245                      catch(Exception e) {}                      catch(Exception e) {}
# Line 208  Line 247 
247              });              });
248          t.start();          t.start();
249          try {          try {
250              Thread.sleep(100);              Thread.sleep(SHORT_DELAY_MS);
251              t.interrupt();              t.interrupt();
252              t.join();              t.join();
253          } catch(Exception e) {          } catch(Exception e) {
# Line 217  Line 256 
256      }      }
257    
258      /**      /**
259       *  Test to verify that timedSleep will throw InterruptedException.       *   timedSleep will throw InterruptedException.
260       *  Thread t waits on timedSleep while the main thread interrupts it.       *  Thread t waits on timedSleep while the main thread interrupts it.
261       */       */
262      public void testTimedSleep() {      public void testTimedSleep() {
# Line 227  Line 266 
266                  public void run() {                  public void run() {
267                      TimeUnit tu = TimeUnit.MILLISECONDS;                      TimeUnit tu = TimeUnit.MILLISECONDS;
268                      try {                      try {
269                          tu.sleep(1000);                          tu.sleep(MEDIUM_DELAY_MS);
270                          fail("should throw");                          fail("should throw");
271                      }                      }
272                      catch(InterruptedException success) {}                      catch(InterruptedException success) {}
# Line 235  Line 274 
274              });              });
275          t.start();          t.start();
276          try {          try {
277              Thread.sleep(100);              Thread.sleep(SHORT_DELAY_MS);
278              t.interrupt();              t.interrupt();
279              t.join();              t.join();
280          } catch(Exception e) {          } catch(Exception e) {

Legend:
Removed from v.1.2  
changed lines
  Added in v.1.3

Doug Lea
ViewVC Help
Powered by ViewVC 1.0.8