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

Comparing jsr166/src/test/tck/AbstractQueuedSynchronizerTest.java (file contents):
Revision 1.39 by jsr166, Tue Mar 15 19:47:06 2011 UTC vs.
Revision 1.40 by dl, Fri May 6 16:43:45 2011 UTC

# Line 131 | Line 131 | public class AbstractQueuedSynchronizerT
131          assertFalse(sync.hasQueuedThreads());
132          sync.acquire(1);
133          t1.start();
134 <        Thread.sleep(SHORT_DELAY_MS);
134 >        delay(SHORT_DELAY_MS);
135          assertTrue(sync.hasQueuedThreads());
136          t2.start();
137 <        Thread.sleep(SHORT_DELAY_MS);
137 >        delay(SHORT_DELAY_MS);
138          assertTrue(sync.hasQueuedThreads());
139          t1.interrupt();
140 <        Thread.sleep(SHORT_DELAY_MS);
140 >        delay(SHORT_DELAY_MS);
141          assertTrue(sync.hasQueuedThreads());
142          sync.release(1);
143 <        Thread.sleep(SHORT_DELAY_MS);
143 >        delay(SHORT_DELAY_MS);
144          assertFalse(sync.hasQueuedThreads());
145          t1.join();
146          t2.join();
# Line 168 | Line 168 | public class AbstractQueuedSynchronizerT
168          assertFalse(sync.isQueued(t2));
169          sync.acquire(1);
170          t1.start();
171 <        Thread.sleep(SHORT_DELAY_MS);
171 >        delay(SHORT_DELAY_MS);
172          assertTrue(sync.isQueued(t1));
173          t2.start();
174 <        Thread.sleep(SHORT_DELAY_MS);
174 >        delay(SHORT_DELAY_MS);
175          assertTrue(sync.isQueued(t1));
176          assertTrue(sync.isQueued(t2));
177          t1.interrupt();
178 <        Thread.sleep(SHORT_DELAY_MS);
178 >        delay(SHORT_DELAY_MS);
179          assertFalse(sync.isQueued(t1));
180          assertTrue(sync.isQueued(t2));
181          sync.release(1);
182 <        Thread.sleep(SHORT_DELAY_MS);
182 >        delay(SHORT_DELAY_MS);
183          assertFalse(sync.isQueued(t1));
184 <        Thread.sleep(SHORT_DELAY_MS);
184 >        delay(SHORT_DELAY_MS);
185          assertFalse(sync.isQueued(t2));
186          t1.join();
187          t2.join();
# Line 197 | Line 197 | public class AbstractQueuedSynchronizerT
197          assertNull(sync.getFirstQueuedThread());
198          sync.acquire(1);
199          t1.start();
200 <        Thread.sleep(SHORT_DELAY_MS);
200 >        delay(SHORT_DELAY_MS);
201          assertEquals(t1, sync.getFirstQueuedThread());
202          t2.start();
203 <        Thread.sleep(SHORT_DELAY_MS);
203 >        delay(SHORT_DELAY_MS);
204          assertEquals(t1, sync.getFirstQueuedThread());
205          t1.interrupt();
206 <        Thread.sleep(SHORT_DELAY_MS);
207 <        Thread.sleep(SHORT_DELAY_MS);
206 >        delay(SHORT_DELAY_MS);
207 >        delay(SHORT_DELAY_MS);
208          assertEquals(t2, sync.getFirstQueuedThread());
209          sync.release(1);
210 <        Thread.sleep(SHORT_DELAY_MS);
210 >        delay(SHORT_DELAY_MS);
211          assertNull(sync.getFirstQueuedThread());
212          t1.join();
213          t2.join();
# Line 224 | Line 224 | public class AbstractQueuedSynchronizerT
224          assertFalse(sync.hasContended());
225          sync.acquire(1);
226          t1.start();
227 <        Thread.sleep(SHORT_DELAY_MS);
227 >        delay(SHORT_DELAY_MS);
228          assertTrue(sync.hasContended());
229          t2.start();
230 <        Thread.sleep(SHORT_DELAY_MS);
230 >        delay(SHORT_DELAY_MS);
231          assertTrue(sync.hasContended());
232          t1.interrupt();
233 <        Thread.sleep(SHORT_DELAY_MS);
233 >        delay(SHORT_DELAY_MS);
234          assertTrue(sync.hasContended());
235          sync.release(1);
236 <        Thread.sleep(SHORT_DELAY_MS);
236 >        delay(SHORT_DELAY_MS);
237          assertTrue(sync.hasContended());
238          t1.join();
239          t2.join();
# Line 250 | Line 250 | public class AbstractQueuedSynchronizerT
250          sync.acquire(1);
251          assertTrue(sync.getQueuedThreads().isEmpty());
252          t1.start();
253 <        Thread.sleep(SHORT_DELAY_MS);
253 >        delay(SHORT_DELAY_MS);
254          assertTrue(sync.getQueuedThreads().contains(t1));
255          t2.start();
256 <        Thread.sleep(SHORT_DELAY_MS);
256 >        delay(SHORT_DELAY_MS);
257          assertTrue(sync.getQueuedThreads().contains(t1));
258          assertTrue(sync.getQueuedThreads().contains(t2));
259          t1.interrupt();
260 <        Thread.sleep(SHORT_DELAY_MS);
260 >        delay(SHORT_DELAY_MS);
261          assertFalse(sync.getQueuedThreads().contains(t1));
262          assertTrue(sync.getQueuedThreads().contains(t2));
263          sync.release(1);
264 <        Thread.sleep(SHORT_DELAY_MS);
264 >        delay(SHORT_DELAY_MS);
265          assertTrue(sync.getQueuedThreads().isEmpty());
266          t1.join();
267          t2.join();
# Line 278 | Line 278 | public class AbstractQueuedSynchronizerT
278          sync.acquire(1);
279          assertTrue(sync.getExclusiveQueuedThreads().isEmpty());
280          t1.start();
281 <        Thread.sleep(SHORT_DELAY_MS);
281 >        delay(SHORT_DELAY_MS);
282          assertTrue(sync.getExclusiveQueuedThreads().contains(t1));
283          t2.start();
284 <        Thread.sleep(SHORT_DELAY_MS);
284 >        delay(SHORT_DELAY_MS);
285          assertTrue(sync.getExclusiveQueuedThreads().contains(t1));
286          assertTrue(sync.getExclusiveQueuedThreads().contains(t2));
287          t1.interrupt();
288 <        Thread.sleep(SHORT_DELAY_MS);
288 >        delay(SHORT_DELAY_MS);
289          assertFalse(sync.getExclusiveQueuedThreads().contains(t1));
290          assertTrue(sync.getExclusiveQueuedThreads().contains(t2));
291          sync.release(1);
292 <        Thread.sleep(SHORT_DELAY_MS);
292 >        delay(SHORT_DELAY_MS);
293          assertTrue(sync.getExclusiveQueuedThreads().isEmpty());
294          t1.join();
295          t2.join();
# Line 306 | Line 306 | public class AbstractQueuedSynchronizerT
306          sync.acquire(1);
307          assertTrue(sync.getSharedQueuedThreads().isEmpty());
308          t1.start();
309 <        Thread.sleep(SHORT_DELAY_MS);
309 >        delay(SHORT_DELAY_MS);
310          assertTrue(sync.getSharedQueuedThreads().isEmpty());
311          t2.start();
312 <        Thread.sleep(SHORT_DELAY_MS);
312 >        delay(SHORT_DELAY_MS);
313          assertTrue(sync.getSharedQueuedThreads().isEmpty());
314          t1.interrupt();
315 <        Thread.sleep(SHORT_DELAY_MS);
315 >        delay(SHORT_DELAY_MS);
316          assertTrue(sync.getSharedQueuedThreads().isEmpty());
317          sync.release(1);
318 <        Thread.sleep(SHORT_DELAY_MS);
318 >        delay(SHORT_DELAY_MS);
319          assertTrue(sync.getSharedQueuedThreads().isEmpty());
320          t1.join();
321          t2.join();
# Line 333 | Line 333 | public class AbstractQueuedSynchronizerT
333              }});
334  
335          t.start();
336 <        Thread.sleep(SHORT_DELAY_MS);
336 >        delay(SHORT_DELAY_MS);
337          t.interrupt();
338          t.join();
339      }
# Line 385 | Line 385 | public class AbstractQueuedSynchronizerT
385          Thread t = new Thread(new CheckedRunnable() {
386              public void realRun() throws InterruptedException {
387                  sync.acquire(1);
388 <                Thread.sleep(SMALL_DELAY_MS);
388 >                delay(SMALL_DELAY_MS);
389                  sync.release(1);
390              }});
391  
392          t.start();
393 <        Thread.sleep(SHORT_DELAY_MS);
393 >        delay(SHORT_DELAY_MS);
394          assertTrue(sync.isHeldExclusively());
395          t.join();
396          assertFalse(sync.isHeldExclusively());
# Line 406 | Line 406 | public class AbstractQueuedSynchronizerT
406          Thread t = new Thread(new InterruptedSyncRunnable(sync));
407  
408          t.start();
409 <        Thread.sleep(SHORT_DELAY_MS);
409 >        delay(SHORT_DELAY_MS);
410          t.interrupt();
411 <        Thread.sleep(SHORT_DELAY_MS);
411 >        delay(SHORT_DELAY_MS);
412          sync.release(1);
413          t.join();
414      }
# Line 421 | Line 421 | public class AbstractQueuedSynchronizerT
421          sync.acquireInterruptibly(1);
422          Thread t = new Thread(new InterruptedSyncRunnable(sync));
423          t.start();
424 <        Thread.sleep(SHORT_DELAY_MS);
424 >        delay(SHORT_DELAY_MS);
425          t.interrupt();
426          assertTrue(sync.isHeldExclusively());
427          t.join();
# Line 511 | Line 511 | public class AbstractQueuedSynchronizerT
511              }});
512  
513          t.start();
514 <        Thread.sleep(SHORT_DELAY_MS);
514 >        delay(SHORT_DELAY_MS);
515          sync.acquire(1);
516          c.signal();
517          sync.release(1);
# Line 651 | Line 651 | public class AbstractQueuedSynchronizerT
651              }});
652  
653          t.start();
654 <        Thread.sleep(SHORT_DELAY_MS);
654 >        delay(SHORT_DELAY_MS);
655          sync.acquire(1);
656          assertTrue(sync.hasWaiters(c));
657          assertEquals(1, sync.getWaitQueueLength(c));
658          c.signal();
659          sync.release(1);
660 <        Thread.sleep(SHORT_DELAY_MS);
660 >        delay(SHORT_DELAY_MS);
661          sync.acquire(1);
662          assertFalse(sync.hasWaiters(c));
663          assertEquals(0, sync.getWaitQueueLength(c));
# Line 691 | Line 691 | public class AbstractQueuedSynchronizerT
691              }});
692  
693          t1.start();
694 <        Thread.sleep(SHORT_DELAY_MS);
694 >        delay(SHORT_DELAY_MS);
695          t2.start();
696 <        Thread.sleep(SHORT_DELAY_MS);
696 >        delay(SHORT_DELAY_MS);
697          sync.acquire(1);
698          assertTrue(sync.hasWaiters(c));
699          assertEquals(2, sync.getWaitQueueLength(c));
700          c.signalAll();
701          sync.release(1);
702 <        Thread.sleep(SHORT_DELAY_MS);
702 >        delay(SHORT_DELAY_MS);
703          sync.acquire(1);
704          assertFalse(sync.hasWaiters(c));
705          assertEquals(0, sync.getWaitQueueLength(c));
# Line 736 | Line 736 | public class AbstractQueuedSynchronizerT
736          assertTrue(sync.getWaitingThreads(c).isEmpty());
737          sync.release(1);
738          t1.start();
739 <        Thread.sleep(SHORT_DELAY_MS);
739 >        delay(SHORT_DELAY_MS);
740          t2.start();
741 <        Thread.sleep(SHORT_DELAY_MS);
741 >        delay(SHORT_DELAY_MS);
742          sync.acquire(1);
743          assertTrue(sync.hasWaiters(c));
744          assertTrue(sync.getWaitingThreads(c).contains(t1));
745          assertTrue(sync.getWaitingThreads(c).contains(t2));
746          c.signalAll();
747          sync.release(1);
748 <        Thread.sleep(SHORT_DELAY_MS);
748 >        delay(SHORT_DELAY_MS);
749          sync.acquire(1);
750          assertFalse(sync.hasWaiters(c));
751          assertTrue(sync.getWaitingThreads(c).isEmpty());
# Line 772 | Line 772 | public class AbstractQueuedSynchronizerT
772              }});
773  
774          t.start();
775 <        Thread.sleep(SHORT_DELAY_MS);
775 >        delay(SHORT_DELAY_MS);
776          t.interrupt();
777          sync.acquire(1);
778          c.signal();
# Line 794 | Line 794 | public class AbstractQueuedSynchronizerT
794              }});
795  
796          t.start();
797 <        Thread.sleep(SHORT_DELAY_MS);
797 >        delay(SHORT_DELAY_MS);
798          t.interrupt();
799          t.join(SHORT_DELAY_MS);
800          assertFalse(t.isAlive());
# Line 813 | Line 813 | public class AbstractQueuedSynchronizerT
813              }});
814  
815          t.start();
816 <        Thread.sleep(SHORT_DELAY_MS);
816 >        delay(SHORT_DELAY_MS);
817          t.interrupt();
818          t.join(SHORT_DELAY_MS);
819          assertFalse(t.isAlive());
# Line 833 | Line 833 | public class AbstractQueuedSynchronizerT
833              }});
834  
835          t.start();
836 <        Thread.sleep(SHORT_DELAY_MS);
836 >        delay(SHORT_DELAY_MS);
837          t.interrupt();
838          t.join(SHORT_DELAY_MS);
839          assertFalse(t.isAlive());
# Line 861 | Line 861 | public class AbstractQueuedSynchronizerT
861  
862          t1.start();
863          t2.start();
864 <        Thread.sleep(SHORT_DELAY_MS);
864 >        delay(SHORT_DELAY_MS);
865          sync.acquire(1);
866          c.signalAll();
867          sync.release(1);
# Line 941 | Line 941 | public class AbstractQueuedSynchronizerT
941  
942          t.start();
943          assertFalse(l.isSignalled());
944 <        Thread.sleep(SHORT_DELAY_MS);
944 >        delay(SHORT_DELAY_MS);
945          l.releaseShared(0);
946          assertTrue(l.isSignalled());
947          t.join();
# Line 964 | Line 964 | public class AbstractQueuedSynchronizerT
964  
965          t.start();
966          assertFalse(l.isSignalled());
967 <        Thread.sleep(SHORT_DELAY_MS);
967 >        delay(SHORT_DELAY_MS);
968          l.releaseShared(0);
969          assertTrue(l.isSignalled());
970          t.join();
# Line 1000 | Line 1000 | public class AbstractQueuedSynchronizerT
1000              }});
1001  
1002          t.start();
1003 <        Thread.sleep(SHORT_DELAY_MS);
1003 >        delay(SHORT_DELAY_MS);
1004          assertFalse(l.isSignalled());
1005          t.interrupt();
1006          t.join();
# Line 1019 | Line 1019 | public class AbstractQueuedSynchronizerT
1019              }});
1020  
1021          t.start();
1022 <        Thread.sleep(SHORT_DELAY_MS);
1022 >        delay(SHORT_DELAY_MS);
1023          assertFalse(l.isSignalled());
1024          t.join();
1025      }

Diff Legend

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