[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.20, Fri May 27 19:12:09 2011 UTC revision 1.21, Sat May 28 12:13:08 2011 UTC
# Line 337  Line 337 
337       * Timed wait without holding lock throws       * Timed wait without holding lock throws
338       * IllegalMonitorStateException       * IllegalMonitorStateException
339       */       */
340      public void testTimedWait_IllegalMonitorException() throws Exception {      public void testTimedWait_IllegalMonitorException() {
341          Thread t = new Thread(new CheckedRunnable() {          Thread t = newStartedThread(new CheckedRunnable() {
342              public void realRun() throws InterruptedException {              public void realRun() throws InterruptedException {
343                  Object o = new Object();                  Object o = new Object();
344                  TimeUnit tu = TimeUnit.MILLISECONDS;                  TimeUnit tu = TimeUnit.MILLISECONDS;
345    
346                  try {                  try {
347                      tu.timedWait(o,LONG_DELAY_MS);                      tu.timedWait(o,LONG_DELAY_MS);
348                      threadShouldThrow();                      threadShouldThrow();
349                  } catch (IllegalMonitorStateException success) {}}});                  } catch (IllegalMonitorStateException success) {}
350                }});
351    
352          t.start();          awaitTermination(t);
         Thread.sleep(SHORT_DELAY_MS);  
         t.interrupt();  
         t.join();  
353      }      }
354    
355      /**      /**
356       * timedWait throws InterruptedException when interrupted       * timedWait throws InterruptedException when interrupted
357       */       */
358      public void testTimedWait() throws InterruptedException {      public void testTimedWait_Interruptible() {
359          Thread t = new Thread(new CheckedInterruptedRunnable() {          final CountDownLatch pleaseInterrupt = new CountDownLatch(1);
360            Thread t = newStartedThread(new CheckedRunnable() {
361              public void realRun() throws InterruptedException {              public void realRun() throws InterruptedException {
362                  Object o = new Object();                  Object o = new Object();
   
363                  TimeUnit tu = TimeUnit.MILLISECONDS;                  TimeUnit tu = TimeUnit.MILLISECONDS;
364    
365                    Thread.currentThread().interrupt();
366                    try {
367                  synchronized (o) {                  synchronized (o) {
368                      tu.timedWait(o,MEDIUM_DELAY_MS);                          tu.timedWait(o, LONG_DELAY_MS);
369                  }                  }
370                        shouldThrow();
371                    } catch (InterruptedException success) {}
372                    assertFalse(Thread.interrupted());
373    
374                    pleaseInterrupt.countDown();
375                    try {
376                        synchronized (o) {
377                            tu.timedWait(o, LONG_DELAY_MS);
378                        }
379                        shouldThrow();
380                    } catch (InterruptedException success) {}
381                    assertFalse(Thread.interrupted());
382              }});              }});
383          t.start();  
384          Thread.sleep(SHORT_DELAY_MS);          await(pleaseInterrupt);
385            assertThreadStaysAlive(t);
386          t.interrupt();          t.interrupt();
387          t.join();          awaitTermination(t);
388      }      }
389    
390      /**      /**
391       * timedJoin throws InterruptedException when interrupted       * timedJoin throws InterruptedException when interrupted
392       */       */
393      public void testTimedJoin() throws InterruptedException {      public void testTimedJoin_Interruptible() {
394          final Thread s = new Thread(new CheckedInterruptedRunnable() {          final CountDownLatch pleaseInterrupt = new CountDownLatch(1);
395            final Thread s = newStartedThread(new CheckedInterruptedRunnable() {
396              public void realRun() throws InterruptedException {              public void realRun() throws InterruptedException {
397                  Thread.sleep(MEDIUM_DELAY_MS);                  Thread.sleep(LONG_DELAY_MS);
398              }});              }});
399          final Thread t = new Thread(new CheckedInterruptedRunnable() {          final Thread t = newStartedThread(new CheckedRunnable() {
400              public void realRun() throws InterruptedException {              public void realRun() throws InterruptedException {
401                  TimeUnit tu = TimeUnit.MILLISECONDS;                  TimeUnit tu = TimeUnit.MILLISECONDS;
402                  tu.timedJoin(s, MEDIUM_DELAY_MS);                  Thread.currentThread().interrupt();
403                    try {
404                        tu.timedJoin(s, LONG_DELAY_MS);
405                        shouldThrow();
406                    } catch (InterruptedException success) {}
407                    assertFalse(Thread.interrupted());
408    
409                    pleaseInterrupt.countDown();
410                    try {
411                        tu.timedJoin(s, LONG_DELAY_MS);
412                        shouldThrow();
413                    } catch (InterruptedException success) {}
414                    assertFalse(Thread.interrupted());
415              }});              }});
416          s.start();  
417          t.start();          await(pleaseInterrupt);
418          Thread.sleep(SHORT_DELAY_MS);          assertThreadStaysAlive(t);
419          t.interrupt();          t.interrupt();
420          t.join();          awaitTermination(t);
421          s.interrupt();          s.interrupt();
422          s.join();          awaitTermination(s);
423      }      }
424    
425      /**      /**
426       * timedSleep throws InterruptedException when interrupted       * timedSleep throws InterruptedException when interrupted
427       */       */
428      public void testTimedSleep() throws InterruptedException {      public void testTimedSleep_Interruptible() {
429          Thread t = new Thread(new CheckedInterruptedRunnable() {          final CountDownLatch pleaseInterrupt = new CountDownLatch(1);
430            Thread t = newStartedThread(new CheckedRunnable() {
431              public void realRun() throws InterruptedException {              public void realRun() throws InterruptedException {
432                  TimeUnit tu = TimeUnit.MILLISECONDS;                  TimeUnit tu = TimeUnit.MILLISECONDS;
433                  tu.sleep(MEDIUM_DELAY_MS);                  Thread.currentThread().interrupt();
434                    try {
435                        tu.sleep(LONG_DELAY_MS);
436                        shouldThrow();
437                    } catch (InterruptedException success) {}
438                    assertFalse(Thread.interrupted());
439    
440                    pleaseInterrupt.countDown();
441                    try {
442                        tu.sleep(LONG_DELAY_MS);
443                        shouldThrow();
444                    } catch (InterruptedException success) {}
445                    assertFalse(Thread.interrupted());
446              }});              }});
447    
448          t.start();          await(pleaseInterrupt);
449          Thread.sleep(SHORT_DELAY_MS);          assertThreadStaysAlive(t);
450          t.interrupt();          t.interrupt();
451          t.join();          awaitTermination(t);
452      }      }
453    
454      /**      /**
# Line 415  Line 456 
456       */       */
457      public void testSerialization() throws Exception {      public void testSerialization() throws Exception {
458          TimeUnit q = TimeUnit.MILLISECONDS;          TimeUnit q = TimeUnit.MILLISECONDS;
459            assertSame(q, serialClone(q));
         ByteArrayOutputStream bout = new ByteArrayOutputStream(10000);  
         ObjectOutputStream out = new ObjectOutputStream(new BufferedOutputStream(bout));  
         out.writeObject(q);  
         out.close();  
   
         ByteArrayInputStream bin = new ByteArrayInputStream(bout.toByteArray());  
         ObjectInputStream in = new ObjectInputStream(new BufferedInputStream(bin));  
         TimeUnit r = (TimeUnit)in.readObject();  
         assertSame(q, r);  
460      }      }
461    
462  }  }

Legend:
Removed from v.1.20  
changed lines
  Added in v.1.21

Doug Lea
ViewVC Help
Powered by ViewVC 1.0.8