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

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

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

revision 1.25, Tue Nov 17 13:40:14 2009 UTC revision 1.26, Wed Nov 18 08:22:57 2009 UTC
# Line 125  Line 125 
125      /**      /**
126       * hasQueuedThreads reports whether there are waiting threads       * hasQueuedThreads reports whether there are waiting threads
127       */       */
128      public void testhasQueuedThreads() {      public void testhasQueuedThreads() throws InterruptedException {
129          final Mutex sync = new Mutex();          final Mutex sync = new Mutex();
130          Thread t1 = new Thread(new InterruptedSyncRunnable(sync));          Thread t1 = new Thread(new InterruptedSyncRunnable(sync));
131          Thread t2 = new Thread(new InterruptibleSyncRunnable(sync));          Thread t2 = new Thread(new InterruptibleSyncRunnable(sync));
         try {  
132              assertFalse(sync.hasQueuedThreads());              assertFalse(sync.hasQueuedThreads());
133              sync.acquire(1);              sync.acquire(1);
134              t1.start();              t1.start();
# Line 146  Line 145 
145              assertFalse(sync.hasQueuedThreads());              assertFalse(sync.hasQueuedThreads());
146              t1.join();              t1.join();
147              t2.join();              t2.join();
         } catch (Exception e) {  
             unexpectedException();  
         }  
148      }      }
149    
150      /**      /**
# Line 159  Line 155 
155          try {          try {
156              sync.isQueued(null);              sync.isQueued(null);
157              shouldThrow();              shouldThrow();
158          } catch (NullPointerException success) {          } catch (NullPointerException success) {}
         }  
159      }      }
160    
161      /**      /**
162       * isQueued reports whether a thread is queued.       * isQueued reports whether a thread is queued.
163       */       */
164      public void testIsQueued() {      public void testIsQueued() throws InterruptedException {
165          final Mutex sync = new Mutex();          final Mutex sync = new Mutex();
166          Thread t1 = new Thread(new InterruptedSyncRunnable(sync));          Thread t1 = new Thread(new InterruptedSyncRunnable(sync));
167          Thread t2 = new Thread(new InterruptibleSyncRunnable(sync));          Thread t2 = new Thread(new InterruptibleSyncRunnable(sync));
         try {  
168              assertFalse(sync.isQueued(t1));              assertFalse(sync.isQueued(t1));
169              assertFalse(sync.isQueued(t2));              assertFalse(sync.isQueued(t2));
170              sync.acquire(1);              sync.acquire(1);
# Line 192  Line 186 
186              assertFalse(sync.isQueued(t2));              assertFalse(sync.isQueued(t2));
187              t1.join();              t1.join();
188              t2.join();              t2.join();
         } catch (Exception e) {  
             unexpectedException();  
         }  
189      }      }
190    
191      /**      /**
192       * getFirstQueuedThread returns first waiting thread or null if none       * getFirstQueuedThread returns first waiting thread or null if none
193       */       */
194      public void testGetFirstQueuedThread() {      public void testGetFirstQueuedThread() throws InterruptedException {
195          final Mutex sync = new Mutex();          final Mutex sync = new Mutex();
196          Thread t1 = new Thread(new InterruptedSyncRunnable(sync));          Thread t1 = new Thread(new InterruptedSyncRunnable(sync));
197          Thread t2 = new Thread(new InterruptibleSyncRunnable(sync));          Thread t2 = new Thread(new InterruptibleSyncRunnable(sync));
         try {  
198              assertNull(sync.getFirstQueuedThread());              assertNull(sync.getFirstQueuedThread());
199              sync.acquire(1);              sync.acquire(1);
200              t1.start();              t1.start();
# Line 222  Line 212 
212              assertNull(sync.getFirstQueuedThread());              assertNull(sync.getFirstQueuedThread());
213              t1.join();              t1.join();
214              t2.join();              t2.join();
         } catch (Exception e) {  
             unexpectedException();  
         }  
215      }      }
216    
217    
218      /**      /**
219       * hasContended reports false if no thread has ever blocked, else true       * hasContended reports false if no thread has ever blocked, else true
220       */       */
221      public void testHasContended() {      public void testHasContended() throws InterruptedException {
222          final Mutex sync = new Mutex();          final Mutex sync = new Mutex();
223          Thread t1 = new Thread(new InterruptedSyncRunnable(sync));          Thread t1 = new Thread(new InterruptedSyncRunnable(sync));
224          Thread t2 = new Thread(new InterruptibleSyncRunnable(sync));          Thread t2 = new Thread(new InterruptibleSyncRunnable(sync));
         try {  
225              assertFalse(sync.hasContended());              assertFalse(sync.hasContended());
226              sync.acquire(1);              sync.acquire(1);
227              t1.start();              t1.start();
# Line 252  Line 238 
238              assertTrue(sync.hasContended());              assertTrue(sync.hasContended());
239              t1.join();              t1.join();
240              t2.join();              t2.join();
         } catch (Exception e) {  
             unexpectedException();  
         }  
241      }      }
242    
243      /**      /**
244       * getQueuedThreads includes waiting threads       * getQueuedThreads includes waiting threads
245       */       */
246      public void testGetQueuedThreads() {      public void testGetQueuedThreads() throws InterruptedException {
247          final Mutex sync = new Mutex();          final Mutex sync = new Mutex();
248          Thread t1 = new Thread(new InterruptedSyncRunnable(sync));          Thread t1 = new Thread(new InterruptedSyncRunnable(sync));
249          Thread t2 = new Thread(new InterruptibleSyncRunnable(sync));          Thread t2 = new Thread(new InterruptibleSyncRunnable(sync));
         try {  
250              assertTrue(sync.getQueuedThreads().isEmpty());              assertTrue(sync.getQueuedThreads().isEmpty());
251              sync.acquire(1);              sync.acquire(1);
252              assertTrue(sync.getQueuedThreads().isEmpty());              assertTrue(sync.getQueuedThreads().isEmpty());
# Line 284  Line 266 
266              assertTrue(sync.getQueuedThreads().isEmpty());              assertTrue(sync.getQueuedThreads().isEmpty());
267              t1.join();              t1.join();
268              t2.join();              t2.join();
         } catch (Exception e) {  
             unexpectedException();  
         }  
269      }      }
270    
271      /**      /**
272       * getExclusiveQueuedThreads includes waiting threads       * getExclusiveQueuedThreads includes waiting threads
273       */       */
274      public void testGetExclusiveQueuedThreads() {      public void testGetExclusiveQueuedThreads() throws InterruptedException {
275          final Mutex sync = new Mutex();          final Mutex sync = new Mutex();
276          Thread t1 = new Thread(new InterruptedSyncRunnable(sync));          Thread t1 = new Thread(new InterruptedSyncRunnable(sync));
277          Thread t2 = new Thread(new InterruptibleSyncRunnable(sync));          Thread t2 = new Thread(new InterruptibleSyncRunnable(sync));
         try {  
278              assertTrue(sync.getExclusiveQueuedThreads().isEmpty());              assertTrue(sync.getExclusiveQueuedThreads().isEmpty());
279              sync.acquire(1);              sync.acquire(1);
280              assertTrue(sync.getExclusiveQueuedThreads().isEmpty());              assertTrue(sync.getExclusiveQueuedThreads().isEmpty());
# Line 316  Line 294 
294              assertTrue(sync.getExclusiveQueuedThreads().isEmpty());              assertTrue(sync.getExclusiveQueuedThreads().isEmpty());
295              t1.join();              t1.join();
296              t2.join();              t2.join();
         } catch (Exception e) {  
             unexpectedException();  
         }  
297      }      }
298    
299      /**      /**
300       * getSharedQueuedThreads does not include exclusively waiting threads       * getSharedQueuedThreads does not include exclusively waiting threads
301       */       */
302      public void testGetSharedQueuedThreads() {      public void testGetSharedQueuedThreads() throws InterruptedException {
303          final Mutex sync = new Mutex();          final Mutex sync = new Mutex();
304          Thread t1 = new Thread(new InterruptedSyncRunnable(sync));          Thread t1 = new Thread(new InterruptedSyncRunnable(sync));
305          Thread t2 = new Thread(new InterruptibleSyncRunnable(sync));          Thread t2 = new Thread(new InterruptibleSyncRunnable(sync));
         try {  
306              assertTrue(sync.getSharedQueuedThreads().isEmpty());              assertTrue(sync.getSharedQueuedThreads().isEmpty());
307              sync.acquire(1);              sync.acquire(1);
308              assertTrue(sync.getSharedQueuedThreads().isEmpty());              assertTrue(sync.getSharedQueuedThreads().isEmpty());
# Line 346  Line 320 
320              assertTrue(sync.getSharedQueuedThreads().isEmpty());              assertTrue(sync.getSharedQueuedThreads().isEmpty());
321              t1.join();              t1.join();
322              t2.join();              t2.join();
         } catch (Exception e) {  
             unexpectedException();  
         }  
323      }      }
324    
325      /**      /**
# Line 365  Line 336 
336                      } catch (InterruptedException success) {}                      } catch (InterruptedException success) {}
337                  }                  }
338              });              });
339          try {  
340              t.start();              t.start();
341              t.interrupt();              t.interrupt();
         } catch (Exception e) {  
             unexpectedException();  
         }  
342      }      }
343    
344    
345      /**      /**
346       * TryAcquire on exclusively held sync fails       * TryAcquire on exclusively held sync fails
347       */       */
348      public void testTryAcquireWhenSynced() {      public void testTryAcquireWhenSynced() throws InterruptedException {
349          final Mutex sync = new Mutex();          final Mutex sync = new Mutex();
350          sync.acquire(1);          sync.acquire(1);
351          Thread t = new Thread(new Runnable() {          Thread t = new Thread(new Runnable() {
# Line 385  Line 353 
353                      threadAssertFalse(sync.tryAcquire(1));                      threadAssertFalse(sync.tryAcquire(1));
354                  }                  }
355              });              });
356          try {  
357              t.start();              t.start();
358              t.join();              t.join();
359              sync.release(1);              sync.release(1);
         } catch (Exception e) {  
             unexpectedException();  
         }  
360      }      }
361    
362      /**      /**
363       * tryAcquireNanos on an exclusively held sync times out       * tryAcquireNanos on an exclusively held sync times out
364       */       */
365      public void testAcquireNanos_Timeout() {      public void testAcquireNanos_Timeout() throws InterruptedException {
366          final Mutex sync = new Mutex();          final Mutex sync = new Mutex();
367          sync.acquire(1);          sync.acquire(1);
368          Thread t = new Thread(new Runnable() {          Thread t = new Thread(new Runnable() {
# Line 409  Line 374 
374                      }                      }
375                  }                  }
376              });              });
377          try {  
378              t.start();              t.start();
379              t.join();              t.join();
380              sync.release(1);              sync.release(1);
         } catch (Exception e) {  
             unexpectedException();  
         }  
381      }      }
382    
383    
384      /**      /**
385       * getState is true when acquired and false when not       * getState is true when acquired and false when not
386       */       */
387      public void testGetState() {      public void testGetState() throws InterruptedException {
388          final Mutex sync = new Mutex();          final Mutex sync = new Mutex();
389          sync.acquire(1);          sync.acquire(1);
390          assertTrue(sync.isHeldExclusively());          assertTrue(sync.isHeldExclusively());
# Line 440  Line 402 
402                      sync.release(1);                      sync.release(1);
403                  }                  }
404              });              });
405          try {  
406              t.start();              t.start();
407              Thread.sleep(SHORT_DELAY_MS);              Thread.sleep(SHORT_DELAY_MS);
408              assertTrue(sync.isHeldExclusively());              assertTrue(sync.isHeldExclusively());
409              t.join();              t.join();
410              assertFalse(sync.isHeldExclusively());              assertFalse(sync.isHeldExclusively());
         } catch (Exception e) {  
             unexpectedException();  
         }  
411      }      }
412    
413    
414      /**      /**
415       * acquireInterruptibly is interruptible.       * acquireInterruptibly is interruptible.
416       */       */
417      public void testAcquireInterruptibly1() {      public void testAcquireInterruptibly1() throws InterruptedException {
418          final Mutex sync = new Mutex();          final Mutex sync = new Mutex();
419          sync.acquire(1);          sync.acquire(1);
420          Thread t = new Thread(new InterruptedSyncRunnable(sync));          Thread t = new Thread(new InterruptedSyncRunnable(sync));
421          try {  
422              t.start();              t.start();
423              Thread.sleep(SHORT_DELAY_MS);              Thread.sleep(SHORT_DELAY_MS);
424              t.interrupt();              t.interrupt();
425              Thread.sleep(SHORT_DELAY_MS);              Thread.sleep(SHORT_DELAY_MS);
426              sync.release(1);              sync.release(1);
427              t.join();              t.join();
         } catch (Exception e) {  
             unexpectedException();  
         }  
428      }      }
429    
430      /**      /**
431       * acquireInterruptibly succeeds when released, else is interruptible       * acquireInterruptibly succeeds when released, else is interruptible
432       */       */
433      public void testAcquireInterruptibly2() {      public void testAcquireInterruptibly2() throws InterruptedException {
434          final Mutex sync = new Mutex();          final Mutex sync = new Mutex();
         try {  
435              sync.acquireInterruptibly(1);              sync.acquireInterruptibly(1);
         } catch (Exception e) {  
             unexpectedException();  
         }  
436          Thread t = new Thread(new InterruptedSyncRunnable(sync));          Thread t = new Thread(new InterruptedSyncRunnable(sync));
         try {  
437              t.start();              t.start();
438              t.interrupt();              t.interrupt();
439              assertTrue(sync.isHeldExclusively());              assertTrue(sync.isHeldExclusively());
440              t.join();              t.join();
         } catch (Exception e) {  
             unexpectedException();  
         }  
441      }      }
442    
443      /**      /**
# Line 506  Line 454 
454      /**      /**
455       * Calling await without holding sync throws IllegalMonitorStateException       * Calling await without holding sync throws IllegalMonitorStateException
456       */       */
457      public void testAwait_IllegalMonitor() {      public void testAwait_IllegalMonitor() throws InterruptedException {
458          final Mutex sync = new Mutex();          final Mutex sync = new Mutex();
459          final AbstractQueuedSynchronizer.ConditionObject c = sync.newCondition();          final AbstractQueuedSynchronizer.ConditionObject c = sync.newCondition();
460          try {          try {
461              c.await();              c.await();
462              shouldThrow();              shouldThrow();
463          }          }
464          catch (IllegalMonitorStateException success) {          catch (IllegalMonitorStateException success) {}
         }  
         catch (Exception ex) {  
             unexpectedException();  
         }  
465      }      }
466    
467      /**      /**
# Line 530  Line 474 
474              c.signal();              c.signal();
475              shouldThrow();              shouldThrow();
476          }          }
477          catch (IllegalMonitorStateException success) {          catch (IllegalMonitorStateException success) {}
         }  
         catch (Exception ex) {  
             unexpectedException();  
         }  
478      }      }
479    
480      /**      /**
481       * awaitNanos without a signal times out       * awaitNanos without a signal times out
482       */       */
483      public void testAwaitNanos_Timeout() {      public void testAwaitNanos_Timeout() throws InterruptedException {
484          final Mutex sync = new Mutex();          final Mutex sync = new Mutex();
485          final AbstractQueuedSynchronizer.ConditionObject c = sync.newCondition();          final AbstractQueuedSynchronizer.ConditionObject c = sync.newCondition();
         try {  
486              sync.acquire(1);              sync.acquire(1);
487              long t = c.awaitNanos(100);              long t = c.awaitNanos(100);
488              assertTrue(t <= 0);              assertTrue(t <= 0);
489              sync.release(1);              sync.release(1);
490          }          }
         catch (Exception ex) {  
             unexpectedException();  
         }  
     }  
491    
492      /**      /**
493       *  Timed await without a signal times out       *  Timed await without a signal times out
494       */       */
495      public void testAwait_Timeout() {      public void testAwait_Timeout() throws InterruptedException {
496          final Mutex sync = new Mutex();          final Mutex sync = new Mutex();
497          final AbstractQueuedSynchronizer.ConditionObject c = sync.newCondition();          final AbstractQueuedSynchronizer.ConditionObject c = sync.newCondition();
         try {  
498              sync.acquire(1);              sync.acquire(1);
499              assertFalse(c.await(SHORT_DELAY_MS, TimeUnit.MILLISECONDS));              assertFalse(c.await(SHORT_DELAY_MS, TimeUnit.MILLISECONDS));
500              sync.release(1);              sync.release(1);
501          }          }
         catch (Exception ex) {  
             unexpectedException();  
         }  
     }  
502    
503      /**      /**
504       * awaitUntil without a signal times out       * awaitUntil without a signal times out
505       */       */
506      public void testAwaitUntil_Timeout() {      public void testAwaitUntil_Timeout() throws InterruptedException {
507          final Mutex sync = new Mutex();          final Mutex sync = new Mutex();
508          final AbstractQueuedSynchronizer.ConditionObject c = sync.newCondition();          final AbstractQueuedSynchronizer.ConditionObject c = sync.newCondition();
         try {  
509              sync.acquire(1);              sync.acquire(1);
510              java.util.Date d = new java.util.Date();              java.util.Date d = new java.util.Date();
511              assertFalse(c.awaitUntil(new java.util.Date(d.getTime() + 10)));              assertFalse(c.awaitUntil(new java.util.Date(d.getTime() + 10)));
512              sync.release(1);              sync.release(1);
513          }          }
         catch (Exception ex) {  
             unexpectedException();  
         }  
     }  
514    
515      /**      /**
516       * await returns when signalled       * await returns when signalled
517       */       */
518      public void testAwait() {      public void testAwait() throws InterruptedException {
519          final Mutex sync = new Mutex();          final Mutex sync = new Mutex();
520          final AbstractQueuedSynchronizer.ConditionObject c = sync.newCondition();          final AbstractQueuedSynchronizer.ConditionObject c = sync.newCondition();
521          Thread t = new Thread(new Runnable() {          Thread t = new Thread(new Runnable() {
# Line 606  Line 531 
531                  }                  }
532              });              });
533    
         try {  
534              t.start();              t.start();
535              Thread.sleep(SHORT_DELAY_MS);              Thread.sleep(SHORT_DELAY_MS);
536              sync.acquire(1);              sync.acquire(1);
# Line 615  Line 539 
539              t.join(SHORT_DELAY_MS);              t.join(SHORT_DELAY_MS);
540              assertFalse(t.isAlive());              assertFalse(t.isAlive());
541          }          }
         catch (Exception ex) {  
             unexpectedException();  
         }  
     }  
542    
543    
544    
# Line 630  Line 550 
550          try {          try {
551              sync.hasWaiters(null);              sync.hasWaiters(null);
552              shouldThrow();              shouldThrow();
553          } catch (NullPointerException success) {          } catch (NullPointerException success) {}
         } catch (Exception ex) {  
             unexpectedException();  
         }  
554      }      }
555    
556      /**      /**
# Line 644  Line 561 
561          try {          try {
562              sync.getWaitQueueLength(null);              sync.getWaitQueueLength(null);
563              shouldThrow();              shouldThrow();
564          } catch (NullPointerException success) {          } catch (NullPointerException success) {}
         } catch (Exception ex) {  
             unexpectedException();  
         }  
565      }      }
566    
567    
# Line 659  Line 573 
573          try {          try {
574              sync.getWaitingThreads(null);              sync.getWaitingThreads(null);
575              shouldThrow();              shouldThrow();
576          } catch (NullPointerException success) {          } catch (NullPointerException success) {}
         } catch (Exception ex) {  
             unexpectedException();  
         }  
577      }      }
578    
579    
# Line 676  Line 587 
587          try {          try {
588              sync2.hasWaiters(c);              sync2.hasWaiters(c);
589              shouldThrow();              shouldThrow();
590          } catch (IllegalArgumentException success) {          } catch (IllegalArgumentException success) {}
         } catch (Exception ex) {  
             unexpectedException();  
         }  
591      }      }
592    
593      /**      /**
# Line 691  Line 599 
599          try {          try {
600              sync.hasWaiters(c);              sync.hasWaiters(c);
601              shouldThrow();              shouldThrow();
602          } catch (IllegalMonitorStateException success) {          } catch (IllegalMonitorStateException success) {}
         } catch (Exception ex) {  
             unexpectedException();  
         }  
603      }      }
604    
605    
# Line 708  Line 613 
613          try {          try {
614              sync2.getWaitQueueLength(c);              sync2.getWaitQueueLength(c);
615              shouldThrow();              shouldThrow();
616          } catch (IllegalArgumentException success) {          } catch (IllegalArgumentException success) {}
         } catch (Exception ex) {  
             unexpectedException();  
         }  
617      }      }
618    
619      /**      /**
# Line 723  Line 625 
625          try {          try {
626              sync.getWaitQueueLength(c);              sync.getWaitQueueLength(c);
627              shouldThrow();              shouldThrow();
628          } catch (IllegalMonitorStateException success) {          } catch (IllegalMonitorStateException success) {}
         } catch (Exception ex) {  
             unexpectedException();  
         }  
629      }      }
630    
631    
# Line 740  Line 639 
639          try {          try {
640              sync2.getWaitingThreads(c);              sync2.getWaitingThreads(c);
641              shouldThrow();              shouldThrow();
642          } catch (IllegalArgumentException success) {          } catch (IllegalArgumentException success) {}
         } catch (Exception ex) {  
             unexpectedException();  
         }  
643      }      }
644    
645      /**      /**
# Line 755  Line 651 
651          try {          try {
652              sync.getWaitingThreads(c);              sync.getWaitingThreads(c);
653              shouldThrow();              shouldThrow();
654          } catch (IllegalMonitorStateException success) {          } catch (IllegalMonitorStateException success) {}
         } catch (Exception ex) {  
             unexpectedException();  
         }  
655      }      }
656    
657    
# Line 766  Line 659 
659      /**      /**
660       * hasWaiters returns true when a thread is waiting, else false       * hasWaiters returns true when a thread is waiting, else false
661       */       */
662      public void testHasWaiters() {      public void testHasWaiters() throws InterruptedException {
663          final Mutex sync = new Mutex();          final Mutex sync = new Mutex();
664          final AbstractQueuedSynchronizer.ConditionObject c = sync.newCondition();          final AbstractQueuedSynchronizer.ConditionObject c = sync.newCondition();
665          Thread t = new Thread(new Runnable() {          Thread t = new Thread(new Runnable() {
# Line 784  Line 677 
677                  }                  }
678              });              });
679    
         try {  
680              t.start();              t.start();
681              Thread.sleep(SHORT_DELAY_MS);              Thread.sleep(SHORT_DELAY_MS);
682              sync.acquire(1);              sync.acquire(1);
# Line 800  Line 692 
692              t.join(SHORT_DELAY_MS);              t.join(SHORT_DELAY_MS);
693              assertFalse(t.isAlive());              assertFalse(t.isAlive());
694          }          }
         catch (Exception ex) {  
             unexpectedException();  
         }  
     }  
695    
696      /**      /**
697       * getWaitQueueLength returns number of waiting threads       * getWaitQueueLength returns number of waiting threads
698       */       */
699      public void testGetWaitQueueLength() {      public void testGetWaitQueueLength() throws InterruptedException {
700          final Mutex sync = new Mutex();          final Mutex sync = new Mutex();
701          final AbstractQueuedSynchronizer.ConditionObject c = sync.newCondition();          final AbstractQueuedSynchronizer.ConditionObject c = sync.newCondition();
702          Thread t1 = new Thread(new Runnable() {          Thread t1 = new Thread(new Runnable() {
# Line 841  Line 729 
729                  }                  }
730              });              });
731    
         try {  
732              t1.start();              t1.start();
733              Thread.sleep(SHORT_DELAY_MS);              Thread.sleep(SHORT_DELAY_MS);
734              t2.start();              t2.start();
# Line 861  Line 748 
748              assertFalse(t1.isAlive());              assertFalse(t1.isAlive());
749              assertFalse(t2.isAlive());              assertFalse(t2.isAlive());
750          }          }
         catch (Exception ex) {  
             unexpectedException();  
         }  
     }  
751    
752      /**      /**
753       * getWaitingThreads returns only and all waiting threads       * getWaitingThreads returns only and all waiting threads
754       */       */
755      public void testGetWaitingThreads() {      public void testGetWaitingThreads() throws InterruptedException {
756          final Mutex sync = new Mutex();          final Mutex sync = new Mutex();
757          final AbstractQueuedSynchronizer.ConditionObject c = sync.newCondition();          final AbstractQueuedSynchronizer.ConditionObject c = sync.newCondition();
758          Thread t1 = new Thread(new Runnable() {          Thread t1 = new Thread(new Runnable() {
# Line 900  Line 783 
783                  }                  }
784              });              });
785    
         try {  
786              sync.acquire(1);              sync.acquire(1);
787              assertTrue(sync.getWaitingThreads(c).isEmpty());              assertTrue(sync.getWaitingThreads(c).isEmpty());
788              sync.release(1);              sync.release(1);
# Line 924  Line 806 
806              assertFalse(t1.isAlive());              assertFalse(t1.isAlive());
807              assertFalse(t2.isAlive());              assertFalse(t2.isAlive());
808          }          }
         catch (Exception ex) {  
             unexpectedException();  
         }  
     }  
809    
810    
811    
812      /**      /**
813       * awaitUninterruptibly doesn't abort on interrupt       * awaitUninterruptibly doesn't abort on interrupt
814       */       */
815      public void testAwaitUninterruptibly() {      public void testAwaitUninterruptibly() throws InterruptedException {
816          final Mutex sync = new Mutex();          final Mutex sync = new Mutex();
817          final AbstractQueuedSynchronizer.ConditionObject c = sync.newCondition();          final AbstractQueuedSynchronizer.ConditionObject c = sync.newCondition();
818          Thread t = new Thread(new Runnable() {          Thread t = new Thread(new Runnable() {
# Line 945  Line 823 
823                  }                  }
824              });              });
825    
         try {  
826              t.start();              t.start();
827              Thread.sleep(SHORT_DELAY_MS);              Thread.sleep(SHORT_DELAY_MS);
828              t.interrupt();              t.interrupt();
# Line 955  Line 832 
832              t.join(SHORT_DELAY_MS);              t.join(SHORT_DELAY_MS);
833              assertFalse(t.isAlive());              assertFalse(t.isAlive());
834          }          }
         catch (Exception ex) {  
             unexpectedException();  
         }  
     }  
835    
836      /**      /**
837       * await is interruptible       * await is interruptible
838       */       */
839      public void testAwait_Interrupt() {      public void testAwait_Interrupt() throws InterruptedException {
840          final Mutex sync = new Mutex();          final Mutex sync = new Mutex();
841          final AbstractQueuedSynchronizer.ConditionObject c = sync.newCondition();          final AbstractQueuedSynchronizer.ConditionObject c = sync.newCondition();
842          Thread t = new Thread(new Runnable() {          Thread t = new Thread(new Runnable() {
# Line 979  Line 852 
852                  }                  }
853              });              });
854    
         try {  
855              t.start();              t.start();
856              Thread.sleep(SHORT_DELAY_MS);              Thread.sleep(SHORT_DELAY_MS);
857              t.interrupt();              t.interrupt();
858              t.join(SHORT_DELAY_MS);              t.join(SHORT_DELAY_MS);
859              assertFalse(t.isAlive());              assertFalse(t.isAlive());
860          }          }
         catch (Exception ex) {  
             unexpectedException();  
         }  
     }  
861    
862      /**      /**
863       * awaitNanos is interruptible       * awaitNanos is interruptible
864       */       */
865      public void testAwaitNanos_Interrupt() {      public void testAwaitNanos_Interrupt() throws InterruptedException {
866          final Mutex sync = new Mutex();          final Mutex sync = new Mutex();
867          final AbstractQueuedSynchronizer.ConditionObject c = sync.newCondition();          final AbstractQueuedSynchronizer.ConditionObject c = sync.newCondition();
868          Thread t = new Thread(new Runnable() {          Thread t = new Thread(new Runnable() {
# Line 1010  Line 878 
878                  }                  }
879              });              });
880    
         try {  
881              t.start();              t.start();
882              Thread.sleep(SHORT_DELAY_MS);              Thread.sleep(SHORT_DELAY_MS);
883              t.interrupt();              t.interrupt();
884              t.join(SHORT_DELAY_MS);              t.join(SHORT_DELAY_MS);
885              assertFalse(t.isAlive());              assertFalse(t.isAlive());
886          }          }
         catch (Exception ex) {  
             unexpectedException();  
         }  
     }  
887    
888      /**      /**
889       * awaitUntil is interruptible       * awaitUntil is interruptible
890       */       */
891      public void testAwaitUntil_Interrupt() {      public void testAwaitUntil_Interrupt() throws InterruptedException {
892          final Mutex sync = new Mutex();          final Mutex sync = new Mutex();
893          final AbstractQueuedSynchronizer.ConditionObject c = sync.newCondition();          final AbstractQueuedSynchronizer.ConditionObject c = sync.newCondition();
894          Thread t = new Thread(new Runnable() {          Thread t = new Thread(new Runnable() {
# Line 1042  Line 905 
905                  }                  }
906              });              });
907    
         try {  
908              t.start();              t.start();
909              Thread.sleep(SHORT_DELAY_MS);              Thread.sleep(SHORT_DELAY_MS);
910              t.interrupt();              t.interrupt();
911              t.join(SHORT_DELAY_MS);              t.join(SHORT_DELAY_MS);
912              assertFalse(t.isAlive());              assertFalse(t.isAlive());
913          }          }
         catch (Exception ex) {  
             unexpectedException();  
         }  
     }  
914    
915      /**      /**
916       * signalAll wakes up all threads       * signalAll wakes up all threads
917       */       */
918      public void testSignalAll() {      public void testSignalAll() throws InterruptedException {
919          final Mutex sync = new Mutex();          final Mutex sync = new Mutex();
920          final AbstractQueuedSynchronizer.ConditionObject c = sync.newCondition();          final AbstractQueuedSynchronizer.ConditionObject c = sync.newCondition();
921          Thread t1 = new Thread(new Runnable() {          Thread t1 = new Thread(new Runnable() {
# Line 1086  Line 944 
944                  }                  }
945              });              });
946    
         try {  
947              t1.start();              t1.start();
948              t2.start();              t2.start();
949              Thread.sleep(SHORT_DELAY_MS);              Thread.sleep(SHORT_DELAY_MS);
# Line 1098  Line 955 
955              assertFalse(t1.isAlive());              assertFalse(t1.isAlive());
956              assertFalse(t2.isAlive());              assertFalse(t2.isAlive());
957          }          }
         catch (Exception ex) {  
             unexpectedException();  
         }  
     }  
958    
959    
960      /**      /**
# Line 1119  Line 972 
972      /**      /**
973       * A serialized AQS deserializes with current state       * A serialized AQS deserializes with current state
974       */       */
975      public void testSerialization() {      public void testSerialization() throws Exception {
976          Mutex l = new Mutex();          Mutex l = new Mutex();
977          l.acquire(1);          l.acquire(1);
978          assertTrue(l.isHeldExclusively());          assertTrue(l.isHeldExclusively());
979    
         try {  
980              ByteArrayOutputStream bout = new ByteArrayOutputStream(10000);              ByteArrayOutputStream bout = new ByteArrayOutputStream(10000);
981              ObjectOutputStream out = new ObjectOutputStream(new BufferedOutputStream(bout));              ObjectOutputStream out = new ObjectOutputStream(new BufferedOutputStream(bout));
982              out.writeObject(l);              out.writeObject(l);
# Line 1134  Line 986 
986              ObjectInputStream in = new ObjectInputStream(new BufferedInputStream(bin));              ObjectInputStream in = new ObjectInputStream(new BufferedInputStream(bin));
987              Mutex r = (Mutex) in.readObject();              Mutex r = (Mutex) in.readObject();
988              assertTrue(r.isHeldExclusively());              assertTrue(r.isHeldExclusively());
         } catch (Exception e) {  
             e.printStackTrace();  
             unexpectedException();  
         }  
989      }      }
990    
991    
# Line 1166  Line 1014 
1014      /**      /**
1015       * acquireSharedInterruptibly returns after release, but not before       * acquireSharedInterruptibly returns after release, but not before
1016       */       */
1017      public void testAcquireSharedInterruptibly() {      public void testAcquireSharedInterruptibly() throws InterruptedException {
1018          final BooleanLatch l = new BooleanLatch();          final BooleanLatch l = new BooleanLatch();
1019    
1020          Thread t = new Thread(new Runnable() {          Thread t = new Thread(new Runnable() {
# Line 1180  Line 1028 
1028                      }                      }
1029                  }                  }
1030              });              });
1031          try {  
1032              t.start();              t.start();
1033              assertFalse(l.isSignalled());              assertFalse(l.isSignalled());
1034              Thread.sleep(SHORT_DELAY_MS);              Thread.sleep(SHORT_DELAY_MS);
1035              l.releaseShared(0);              l.releaseShared(0);
1036              assertTrue(l.isSignalled());              assertTrue(l.isSignalled());
1037              t.join();              t.join();
         } catch (InterruptedException e) {  
             unexpectedException();  
         }  
1038      }      }
1039    
1040    
1041      /**      /**
1042       * acquireSharedTimed returns after release       * acquireSharedTimed returns after release
1043       */       */
1044      public void testAsquireSharedTimed() {      public void testAsquireSharedTimed() throws InterruptedException {
1045          final BooleanLatch l = new BooleanLatch();          final BooleanLatch l = new BooleanLatch();
1046    
1047          Thread t = new Thread(new Runnable() {          Thread t = new Thread(new Runnable() {
# Line 1211  Line 1056 
1056                      }                      }
1057                  }                  }
1058              });              });
1059          try {  
1060              t.start();              t.start();
1061              assertFalse(l.isSignalled());              assertFalse(l.isSignalled());
1062              Thread.sleep(SHORT_DELAY_MS);              Thread.sleep(SHORT_DELAY_MS);
1063              l.releaseShared(0);              l.releaseShared(0);
1064              assertTrue(l.isSignalled());              assertTrue(l.isSignalled());
1065              t.join();              t.join();
         } catch (InterruptedException e) {  
             unexpectedException();  
         }  
1066      }      }
1067    
1068      /**      /**
1069       * acquireSharedInterruptibly throws IE if interrupted before released       * acquireSharedInterruptibly throws IE if interrupted before released
1070       */       */
1071      public void testAcquireSharedInterruptibly_InterruptedException() {      public void testAcquireSharedInterruptibly_InterruptedException() throws InterruptedException {
1072          final BooleanLatch l = new BooleanLatch();          final BooleanLatch l = new BooleanLatch();
1073          Thread t = new Thread(new Runnable() {          Thread t = new Thread(new Runnable() {
1074                  public void run() {                  public void run() {
# Line 1238  Line 1080 
1080                  }                  }
1081              });              });
1082          t.start();          t.start();
         try {  
1083              assertFalse(l.isSignalled());              assertFalse(l.isSignalled());
1084              t.interrupt();              t.interrupt();
1085              t.join();              t.join();
         } catch (InterruptedException e) {  
             unexpectedException();  
         }  
1086      }      }
1087    
1088      /**      /**
1089       * acquireSharedTimed throws IE if interrupted before released       * acquireSharedTimed throws IE if interrupted before released
1090       */       */
1091      public void testAcquireSharedNanos_InterruptedException() {      public void testAcquireSharedNanos_InterruptedException() throws InterruptedException {
1092          final BooleanLatch l = new BooleanLatch();          final BooleanLatch l = new BooleanLatch();
1093          Thread t = new Thread(new Runnable() {          Thread t = new Thread(new Runnable() {
1094                  public void run() {                  public void run() {
# Line 1262  Line 1100 
1100                  }                  }
1101              });              });
1102          t.start();          t.start();
         try {  
1103              Thread.sleep(SHORT_DELAY_MS);              Thread.sleep(SHORT_DELAY_MS);
1104              assertFalse(l.isSignalled());              assertFalse(l.isSignalled());
1105              t.interrupt();              t.interrupt();
1106              t.join();              t.join();
         } catch (InterruptedException e) {  
             unexpectedException();  
         }  
1107      }      }
1108    
1109      /**      /**
1110       * acquireSharedTimed times out if not released before timeout       * acquireSharedTimed times out if not released before timeout
1111       */       */
1112      public void testAcquireSharedNanos_Timeout() {      public void testAcquireSharedNanos_Timeout() throws InterruptedException {
1113          final BooleanLatch l = new BooleanLatch();          final BooleanLatch l = new BooleanLatch();
1114          Thread t = new Thread(new Runnable() {          Thread t = new Thread(new Runnable() {
1115                  public void run() {                  public void run() {
# Line 1288  Line 1122 
1122                  }                  }
1123              });              });
1124          t.start();          t.start();
         try {  
1125              Thread.sleep(SHORT_DELAY_MS);              Thread.sleep(SHORT_DELAY_MS);
1126              assertFalse(l.isSignalled());              assertFalse(l.isSignalled());
1127              t.join();              t.join();
         } catch (InterruptedException e) {  
             unexpectedException();  
         }  
1128      }      }
1129    
1130    

Legend:
Removed from v.1.25  
changed lines
  Added in v.1.26

Doug Lea
ViewVC Help
Powered by ViewVC 1.0.8