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

Comparing jsr166/src/test/tck/ReentrantLockTest.java (file contents):
Revision 1.11 by dl, Sat Dec 27 18:27:02 2003 UTC vs.
Revision 1.29 by jsr166, Tue Nov 17 13:31:53 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.*;
# Line 13 | Line 14 | import java.io.*;
14  
15   public class ReentrantLockTest extends JSR166TestCase {
16      public static void main(String[] args) {
17 <        junit.textui.TestRunner.run (suite());  
17 >        junit.textui.TestRunner.run (suite());
18      }
19      public static Test suite() {
20          return new TestSuite(ReentrantLockTest.class);
# Line 22 | Line 23 | public class ReentrantLockTest extends J
23      /**
24       * A runnable calling lockInterruptibly
25       */
26 <    class InterruptibleLockRunnable implements Runnable {
26 >    class InterruptibleLockRunnable extends CheckedRunnable {
27          final ReentrantLock lock;
28          InterruptibleLockRunnable(ReentrantLock l) { lock = l; }
29 <        public void run() {
30 <            try {
30 <                lock.lockInterruptibly();
31 <            } catch(InterruptedException success){}
29 >        public void realRun() throws InterruptedException {
30 >            lock.lockInterruptibly();
31          }
32      }
33  
# Line 37 | Line 36 | public class ReentrantLockTest extends J
36       * A runnable calling lockInterruptibly that expects to be
37       * interrupted
38       */
39 <    class InterruptedLockRunnable implements Runnable {
39 >    class InterruptedLockRunnable extends CheckedInterruptedRunnable {
40          final ReentrantLock lock;
41          InterruptedLockRunnable(ReentrantLock l) { lock = l; }
42 <        public void run() {
43 <            try {
45 <                lock.lockInterruptibly();
46 <                threadShouldThrow();
47 <            } catch(InterruptedException success){}
42 >        public void realRun() throws InterruptedException {
43 >            lock.lockInterruptibly();
44          }
45      }
46  
# Line 53 | Line 49 | public class ReentrantLockTest extends J
49       */
50      static class PublicReentrantLock extends ReentrantLock {
51          PublicReentrantLock() { super(); }
52 <        public Collection<Thread> getQueuedThreads() {
53 <            return super.getQueuedThreads();
52 >        public Collection<Thread> getQueuedThreads() {
53 >            return super.getQueuedThreads();
54          }
55 +        public Collection<Thread> getWaitingThreads(Condition c) {
56 +            return super.getWaitingThreads(c);
57 +        }
58 +
59  
60      }
61  
62      /**
63       * Constructor sets given fairness
64       */
65 <    public void testConstructor() {
66 <        ReentrantLock rl = new ReentrantLock();
67 <        assertFalse(rl.isFair());
68 <        ReentrantLock r2 = new ReentrantLock(true);
69 <        assertTrue(r2.isFair());
65 >    public void testConstructor() {
66 >        assertFalse(new ReentrantLock().isFair());
67 >        assertFalse(new ReentrantLock(false).isFair());
68 >        assertTrue(new ReentrantLock(true).isFair());
69      }
70  
71      /**
72       * locking an unlocked lock succeeds
73       */
74 <    public void testLock() {
74 >    public void testLock() {
75          ReentrantLock rl = new ReentrantLock();
76          rl.lock();
77          assertTrue(rl.isLocked());
78          rl.unlock();
79 +        assertFalse(rl.isLocked());
80      }
81  
82      /**
83       * locking an unlocked fair lock succeeds
84       */
85 <    public void testFairLock() {
85 >    public void testFairLock() {
86          ReentrantLock rl = new ReentrantLock(true);
87          rl.lock();
88          assertTrue(rl.isLocked());
# Line 92 | Line 92 | public class ReentrantLockTest extends J
92      /**
93       * Unlocking an unlocked lock throws IllegalMonitorStateException
94       */
95 <    public void testUnlock_IllegalMonitorStateException() {
95 >    public void testUnlock_IllegalMonitorStateException() {
96          ReentrantLock rl = new ReentrantLock();
97          try {
98              rl.unlock();
99              shouldThrow();
100 <
101 <        } catch(IllegalMonitorStateException success){}
100 >        } catch (IllegalMonitorStateException success) {}
101      }
102  
103      /**
104 <     * trylock on an unlocked lock succeeds
104 >     * tryLock on an unlocked lock succeeds
105       */
106 <    public void testTryLock() {
106 >    public void testTryLock() {
107          ReentrantLock rl = new ReentrantLock();
108          assertTrue(rl.tryLock());
109          assertTrue(rl.isLocked());
# Line 113 | Line 112 | public class ReentrantLockTest extends J
112  
113  
114      /**
115 +     * hasQueuedThreads reports whether there are waiting threads
116 +     */
117 +    public void testhasQueuedThreads() throws InterruptedException {
118 +        final ReentrantLock lock = new ReentrantLock();
119 +        Thread t1 = new Thread(new InterruptedLockRunnable(lock));
120 +        Thread t2 = new Thread(new InterruptibleLockRunnable(lock));
121 +        assertFalse(lock.hasQueuedThreads());
122 +        lock.lock();
123 +        t1.start();
124 +        Thread.sleep(SHORT_DELAY_MS);
125 +        assertTrue(lock.hasQueuedThreads());
126 +        t2.start();
127 +        Thread.sleep(SHORT_DELAY_MS);
128 +        assertTrue(lock.hasQueuedThreads());
129 +        t1.interrupt();
130 +        Thread.sleep(SHORT_DELAY_MS);
131 +        assertTrue(lock.hasQueuedThreads());
132 +        lock.unlock();
133 +        Thread.sleep(SHORT_DELAY_MS);
134 +        assertFalse(lock.hasQueuedThreads());
135 +        t1.join();
136 +        t2.join();
137 +    }
138 +
139 +    /**
140       * getQueueLength reports number of waiting threads
141       */
142 <    public void testGetQueueLength() {
142 >    public void testGetQueueLength() throws InterruptedException {
143          final ReentrantLock lock = new ReentrantLock();
144          Thread t1 = new Thread(new InterruptedLockRunnable(lock));
145          Thread t2 = new Thread(new InterruptibleLockRunnable(lock));
146 +        assertEquals(0, lock.getQueueLength());
147 +        lock.lock();
148 +        t1.start();
149 +        Thread.sleep(SHORT_DELAY_MS);
150 +        assertEquals(1, lock.getQueueLength());
151 +        t2.start();
152 +        Thread.sleep(SHORT_DELAY_MS);
153 +        assertEquals(2, lock.getQueueLength());
154 +        t1.interrupt();
155 +        Thread.sleep(SHORT_DELAY_MS);
156 +        assertEquals(1, lock.getQueueLength());
157 +        lock.unlock();
158 +        Thread.sleep(SHORT_DELAY_MS);
159 +        assertEquals(0, lock.getQueueLength());
160 +        t1.join();
161 +        t2.join();
162 +    }
163 +
164 +    /**
165 +     * getQueueLength reports number of waiting threads
166 +     */
167 +    public void testGetQueueLength_fair() throws InterruptedException {
168 +        final ReentrantLock lock = new ReentrantLock(true);
169 +        Thread t1 = new Thread(new InterruptedLockRunnable(lock));
170 +        Thread t2 = new Thread(new InterruptibleLockRunnable(lock));
171 +        assertEquals(0, lock.getQueueLength());
172 +        lock.lock();
173 +        t1.start();
174 +        Thread.sleep(SHORT_DELAY_MS);
175 +        assertEquals(1, lock.getQueueLength());
176 +        t2.start();
177 +        Thread.sleep(SHORT_DELAY_MS);
178 +        assertEquals(2, lock.getQueueLength());
179 +        t1.interrupt();
180 +        Thread.sleep(SHORT_DELAY_MS);
181 +        assertEquals(1, lock.getQueueLength());
182 +        lock.unlock();
183 +        Thread.sleep(SHORT_DELAY_MS);
184 +        assertEquals(0, lock.getQueueLength());
185 +        t1.join();
186 +        t2.join();
187 +    }
188 +
189 +    /**
190 +     * hasQueuedThread(null) throws NPE
191 +     */
192 +    public void testHasQueuedThreadNPE() {
193 +        final ReentrantLock sync = new ReentrantLock();
194          try {
195 <            assertEquals(0, lock.getQueueLength());
196 <            lock.lock();
197 <            t1.start();
198 <            Thread.sleep(SHORT_DELAY_MS);
199 <            assertEquals(1, lock.getQueueLength());
200 <            t2.start();
201 <            Thread.sleep(SHORT_DELAY_MS);
202 <            assertEquals(2, lock.getQueueLength());
203 <            t1.interrupt();
204 <            Thread.sleep(SHORT_DELAY_MS);
205 <            assertEquals(1, lock.getQueueLength());
206 <            lock.unlock();
207 <            Thread.sleep(SHORT_DELAY_MS);
208 <            assertEquals(0, lock.getQueueLength());
209 <            t1.join();
210 <            t2.join();
211 <        } catch(Exception e){
212 <            unexpectedException();
213 <        }
214 <    }
195 >            sync.hasQueuedThread(null);
196 >            shouldThrow();
197 >        } catch (NullPointerException success) {}
198 >    }
199 >
200 >    /**
201 >     * hasQueuedThread reports whether a thread is queued.
202 >     */
203 >    public void testHasQueuedThread() throws InterruptedException {
204 >        final ReentrantLock sync = new ReentrantLock();
205 >        Thread t1 = new Thread(new InterruptedLockRunnable(sync));
206 >        Thread t2 = new Thread(new InterruptibleLockRunnable(sync));
207 >        assertFalse(sync.hasQueuedThread(t1));
208 >        assertFalse(sync.hasQueuedThread(t2));
209 >        sync.lock();
210 >        t1.start();
211 >        Thread.sleep(SHORT_DELAY_MS);
212 >        assertTrue(sync.hasQueuedThread(t1));
213 >        t2.start();
214 >        Thread.sleep(SHORT_DELAY_MS);
215 >        assertTrue(sync.hasQueuedThread(t1));
216 >        assertTrue(sync.hasQueuedThread(t2));
217 >        t1.interrupt();
218 >        Thread.sleep(SHORT_DELAY_MS);
219 >        assertFalse(sync.hasQueuedThread(t1));
220 >        assertTrue(sync.hasQueuedThread(t2));
221 >        sync.unlock();
222 >        Thread.sleep(SHORT_DELAY_MS);
223 >        assertFalse(sync.hasQueuedThread(t1));
224 >        Thread.sleep(SHORT_DELAY_MS);
225 >        assertFalse(sync.hasQueuedThread(t2));
226 >        t1.join();
227 >        t2.join();
228 >    }
229 >
230  
231      /**
232       * getQueuedThreads includes waiting threads
233       */
234 <    public void testGetQueuedThreads() {
234 >    public void testGetQueuedThreads() throws InterruptedException {
235          final PublicReentrantLock lock = new PublicReentrantLock();
236          Thread t1 = new Thread(new InterruptedLockRunnable(lock));
237          Thread t2 = new Thread(new InterruptibleLockRunnable(lock));
238 <        try {
239 <            assertTrue(lock.getQueuedThreads().isEmpty());
240 <            lock.lock();
241 <            assertTrue(lock.getQueuedThreads().isEmpty());
242 <            t1.start();
243 <            Thread.sleep(SHORT_DELAY_MS);
244 <            assertTrue(lock.getQueuedThreads().contains(t1));
245 <            t2.start();
246 <            Thread.sleep(SHORT_DELAY_MS);
247 <            assertTrue(lock.getQueuedThreads().contains(t1));
248 <            assertTrue(lock.getQueuedThreads().contains(t2));
249 <            t1.interrupt();
250 <            Thread.sleep(SHORT_DELAY_MS);
251 <            assertFalse(lock.getQueuedThreads().contains(t1));
252 <            assertTrue(lock.getQueuedThreads().contains(t2));
253 <            lock.unlock();
254 <            Thread.sleep(SHORT_DELAY_MS);
255 <            assertTrue(lock.getQueuedThreads().isEmpty());
256 <            t1.join();
257 <            t2.join();
171 <        } catch(Exception e){
172 <            unexpectedException();
173 <        }
174 <    }
238 >        assertTrue(lock.getQueuedThreads().isEmpty());
239 >        lock.lock();
240 >        assertTrue(lock.getQueuedThreads().isEmpty());
241 >        t1.start();
242 >        Thread.sleep(SHORT_DELAY_MS);
243 >        assertTrue(lock.getQueuedThreads().contains(t1));
244 >        t2.start();
245 >        Thread.sleep(SHORT_DELAY_MS);
246 >        assertTrue(lock.getQueuedThreads().contains(t1));
247 >        assertTrue(lock.getQueuedThreads().contains(t2));
248 >        t1.interrupt();
249 >        Thread.sleep(SHORT_DELAY_MS);
250 >        assertFalse(lock.getQueuedThreads().contains(t1));
251 >        assertTrue(lock.getQueuedThreads().contains(t2));
252 >        lock.unlock();
253 >        Thread.sleep(SHORT_DELAY_MS);
254 >        assertTrue(lock.getQueuedThreads().isEmpty());
255 >        t1.join();
256 >        t2.join();
257 >    }
258  
259  
260      /**
261 <     * timed trylock is interruptible.
261 >     * timed tryLock is interruptible.
262       */
263 <    public void testInterruptedException2() {
263 >    public void testInterruptedException2() throws InterruptedException {
264          final ReentrantLock lock = new ReentrantLock();
265          lock.lock();
266 <        Thread t = new Thread(new Runnable() {
267 <                public void run() {
268 <                    try {
269 <                        lock.tryLock(MEDIUM_DELAY_MS,TimeUnit.MILLISECONDS);
270 <                        threadShouldThrow();
271 <                    } catch(InterruptedException success){}
272 <                }
273 <            });
191 <        try {
192 <            t.start();
193 <            t.interrupt();
194 <        } catch(Exception e){
195 <            unexpectedException();
196 <        }
266 >        Thread t = new Thread(new CheckedInterruptedRunnable() {
267 >            public void realRun() throws InterruptedException {
268 >                lock.tryLock(MEDIUM_DELAY_MS,TimeUnit.MILLISECONDS);
269 >            }});
270 >
271 >        t.start();
272 >        t.interrupt();
273 >        t.join();
274      }
275  
276  
277      /**
278 <     * Trylock on a locked lock fails
278 >     * TryLock on a locked lock fails
279       */
280 <    public void testTryLockWhenLocked() {
280 >    public void testTryLockWhenLocked() throws InterruptedException {
281          final ReentrantLock lock = new ReentrantLock();
282          lock.lock();
283 <        Thread t = new Thread(new Runnable() {
284 <                public void run() {
285 <                    threadAssertFalse(lock.tryLock());
286 <                }
287 <            });
288 <        try {
289 <            t.start();
290 <            t.join();
291 <            lock.unlock();
215 <        } catch(Exception e){
216 <            unexpectedException();
217 <        }
218 <    }
283 >        Thread t = new Thread(new CheckedRunnable() {
284 >            public void realRun() {
285 >                threadAssertFalse(lock.tryLock());
286 >            }});
287 >
288 >        t.start();
289 >        t.join();
290 >        lock.unlock();
291 >    }
292  
293      /**
294 <     * Timed trylock on a locked lock times out
294 >     * Timed tryLock on a locked lock times out
295       */
296 <    public void testTryLock_Timeout() {
296 >    public void testTryLock_Timeout() throws InterruptedException {
297          final ReentrantLock lock = new ReentrantLock();
298          lock.lock();
299 <        Thread t = new Thread(new Runnable() {
300 <                public void run() {
301 <                    try {
302 <                        threadAssertFalse(lock.tryLock(1, TimeUnit.MILLISECONDS));
303 <                    } catch (Exception ex) {
304 <                        threadUnexpectedException();
305 <                    }
306 <                }
307 <            });
308 <        try {
236 <            t.start();
237 <            t.join();
238 <            lock.unlock();
239 <        } catch(Exception e){
240 <            unexpectedException();
241 <        }
242 <    }
243 <    
299 >        Thread t = new Thread(new CheckedRunnable() {
300 >            public void realRun() throws InterruptedException {
301 >                threadAssertFalse(lock.tryLock(1, TimeUnit.MILLISECONDS));
302 >            }});
303 >
304 >        t.start();
305 >        t.join();
306 >        lock.unlock();
307 >    }
308 >
309      /**
310       * getHoldCount returns number of recursive holds
311       */
312      public void testGetHoldCount() {
313          ReentrantLock lock = new ReentrantLock();
314 <        for(int i = 1; i <= SIZE; i++) {
314 >        for (int i = 1; i <= SIZE; i++) {
315              lock.lock();
316 <            assertEquals(i,lock.getHoldCount());
316 >            assertEquals(i, lock.getHoldCount());
317          }
318 <        for(int i = SIZE; i > 0; i--) {
318 >        for (int i = SIZE; i > 0; i--) {
319              lock.unlock();
320 <            assertEquals(i-1,lock.getHoldCount());
320 >            assertEquals(i-1, lock.getHoldCount());
321          }
322      }
323 <    
324 <  
323 >
324 >
325      /**
326       * isLocked is true when locked and false when not
327       */
328 <    public void testIsLocked() {
328 >    public void testIsLocked() throws InterruptedException {
329          final ReentrantLock lock = new ReentrantLock();
330          lock.lock();
331          assertTrue(lock.isLocked());
332          lock.unlock();
333          assertFalse(lock.isLocked());
334 <        Thread t = new Thread(new Runnable() {
335 <                public void run() {
336 <                    lock.lock();
337 <                    try {
338 <                        Thread.sleep(SMALL_DELAY_MS);
339 <                    }
340 <                    catch(Exception e) {
341 <                        threadUnexpectedException();
342 <                    }
343 <                    lock.unlock();
344 <                }
345 <            });
281 <        try {
282 <            t.start();
283 <            Thread.sleep(SHORT_DELAY_MS);
284 <            assertTrue(lock.isLocked());
285 <            t.join();
286 <            assertFalse(lock.isLocked());
287 <        } catch(Exception e){
288 <            unexpectedException();
289 <        }
334 >        Thread t = new Thread(new CheckedRunnable() {
335 >            public void realRun() throws InterruptedException {
336 >                lock.lock();
337 >                Thread.sleep(SMALL_DELAY_MS);
338 >                lock.unlock();
339 >            }});
340 >
341 >        t.start();
342 >        Thread.sleep(SHORT_DELAY_MS);
343 >        assertTrue(lock.isLocked());
344 >        t.join();
345 >        assertFalse(lock.isLocked());
346      }
347  
348  
349      /**
350       * lockInterruptibly is interruptible.
351       */
352 <    public void testLockInterruptibly1() {
352 >    public void testLockInterruptibly1() throws InterruptedException {
353          final ReentrantLock lock = new ReentrantLock();
354          lock.lock();
355          Thread t = new Thread(new InterruptedLockRunnable(lock));
356 <        try {
357 <            t.start();
358 <            t.interrupt();
359 <            lock.unlock();
360 <            t.join();
361 <        } catch(Exception e){
362 <            unexpectedException();
307 <        }
308 <    }
356 >        t.start();
357 >        Thread.sleep(SHORT_DELAY_MS);
358 >        t.interrupt();
359 >        Thread.sleep(SHORT_DELAY_MS);
360 >        lock.unlock();
361 >        t.join();
362 >    }
363  
364      /**
365       * lockInterruptibly succeeds when unlocked, else is interruptible
366       */
367 <    public void testLockInterruptibly2() {
368 <        final ReentrantLock lock = new ReentrantLock();
369 <        try {
316 <            lock.lockInterruptibly();
317 <        } catch(Exception e) {
318 <            unexpectedException();
319 <        }
367 >    public void testLockInterruptibly2() throws InterruptedException {
368 >        final ReentrantLock lock = new ReentrantLock();
369 >        lock.lockInterruptibly();
370          Thread t = new Thread(new InterruptedLockRunnable(lock));
371 <        try {
372 <            t.start();
373 <            t.interrupt();
374 <            assertTrue(lock.isLocked());
375 <            assertTrue(lock.isHeldByCurrentThread());
326 <            t.join();
327 <        } catch(Exception e){
328 <            unexpectedException();
329 <        }
371 >        t.start();
372 >        t.interrupt();
373 >        assertTrue(lock.isLocked());
374 >        assertTrue(lock.isHeldByCurrentThread());
375 >        t.join();
376      }
377  
378      /**
379       * Calling await without holding lock throws IllegalMonitorStateException
380       */
381 <    public void testAwait_IllegalMonitor() {
382 <        final ReentrantLock lock = new ReentrantLock();
381 >    public void testAwait_IllegalMonitor() throws InterruptedException {
382 >        final ReentrantLock lock = new ReentrantLock();
383          final Condition c = lock.newCondition();
384          try {
385              c.await();
386              shouldThrow();
387 <        }
342 <        catch (IllegalMonitorStateException success) {
343 <        }
344 <        catch (Exception ex) {
345 <            unexpectedException();
346 <        }
387 >        } catch (IllegalMonitorStateException success) {}
388      }
389  
390      /**
391       * Calling signal without holding lock throws IllegalMonitorStateException
392       */
393      public void testSignal_IllegalMonitor() {
394 <        final ReentrantLock lock = new ReentrantLock();
394 >        final ReentrantLock lock = new ReentrantLock();
395          final Condition c = lock.newCondition();
396          try {
397              c.signal();
398              shouldThrow();
399 <        }
359 <        catch (IllegalMonitorStateException success) {
360 <        }
361 <        catch (Exception ex) {
362 <            unexpectedException();
363 <        }
399 >        } catch (IllegalMonitorStateException success) {}
400      }
401  
402      /**
403       * awaitNanos without a signal times out
404       */
405 <    public void testAwaitNanos_Timeout() {
406 <        final ReentrantLock lock = new ReentrantLock();
405 >    public void testAwaitNanos_Timeout() throws InterruptedException {
406 >        final ReentrantLock lock = new ReentrantLock();
407          final Condition c = lock.newCondition();
408 <        try {
409 <            lock.lock();
410 <            long t = c.awaitNanos(100);
411 <            assertTrue(t <= 0);
376 <            lock.unlock();
377 <        }
378 <        catch (Exception ex) {
379 <            unexpectedException();
380 <        }
408 >        lock.lock();
409 >        long t = c.awaitNanos(100);
410 >        assertTrue(t <= 0);
411 >        lock.unlock();
412      }
413  
414      /**
415       *  timed await without a signal times out
416       */
417 <    public void testAwait_Timeout() {
418 <        final ReentrantLock lock = new ReentrantLock();
417 >    public void testAwait_Timeout() throws InterruptedException {
418 >        final ReentrantLock lock = new ReentrantLock();
419          final Condition c = lock.newCondition();
420 <        try {
421 <            lock.lock();
422 <            assertFalse(c.await(SHORT_DELAY_MS, TimeUnit.MILLISECONDS));
392 <            lock.unlock();
393 <        }
394 <        catch (Exception ex) {
395 <            unexpectedException();
396 <        }
420 >        lock.lock();
421 >        assertFalse(c.await(SHORT_DELAY_MS, TimeUnit.MILLISECONDS));
422 >        lock.unlock();
423      }
424  
425      /**
426       * awaitUntil without a signal times out
427       */
428 <    public void testAwaitUntil_Timeout() {
429 <        final ReentrantLock lock = new ReentrantLock();
428 >    public void testAwaitUntil_Timeout() throws InterruptedException {
429 >        final ReentrantLock lock = new ReentrantLock();
430          final Condition c = lock.newCondition();
431 <        try {
432 <            lock.lock();
433 <            java.util.Date d = new java.util.Date();
434 <            assertFalse(c.awaitUntil(new java.util.Date(d.getTime() + 10)));
409 <            lock.unlock();
410 <        }
411 <        catch (Exception ex) {
412 <            unexpectedException();
413 <        }
431 >        lock.lock();
432 >        java.util.Date d = new java.util.Date();
433 >        assertFalse(c.awaitUntil(new java.util.Date(d.getTime() + 10)));
434 >        lock.unlock();
435      }
436  
437      /**
438       * await returns when signalled
439       */
440 <    public void testAwait() {
441 <        final ReentrantLock lock = new ReentrantLock();
442 <        final AbstractQueuedSynchronizer.ConditionObject c = lock.newCondition();
443 <        Thread t = new Thread(new Runnable() {
444 <                public void run() {
445 <                    try {
446 <                        lock.lock();
447 <                        c.await();
448 <                        lock.unlock();
449 <                    }
450 <                    catch(InterruptedException e) {
451 <                        threadUnexpectedException();
452 <                    }
453 <                }
454 <            });
440 >    public void testAwait() throws InterruptedException {
441 >        final ReentrantLock lock = new ReentrantLock();
442 >        final Condition c = lock.newCondition();
443 >        Thread t = new Thread(new CheckedRunnable() {
444 >            public void realRun() throws InterruptedException {
445 >                lock.lock();
446 >                c.await();
447 >                lock.unlock();
448 >            }});
449 >
450 >        t.start();
451 >        Thread.sleep(SHORT_DELAY_MS);
452 >        lock.lock();
453 >        c.signal();
454 >        lock.unlock();
455 >        t.join(SHORT_DELAY_MS);
456 >        assertFalse(t.isAlive());
457 >    }
458  
459 +    /**
460 +     * hasWaiters throws NPE if null
461 +     */
462 +    public void testHasWaitersNPE() {
463 +        final ReentrantLock lock = new ReentrantLock();
464          try {
465 <            t.start();
466 <            Thread.sleep(SHORT_DELAY_MS);
467 <            lock.lock();
439 <            c.signal();
440 <            lock.unlock();
441 <            t.join(SHORT_DELAY_MS);
442 <            assertFalse(t.isAlive());
443 <        }
444 <        catch (Exception ex) {
445 <            unexpectedException();
446 <        }
465 >            lock.hasWaiters(null);
466 >            shouldThrow();
467 >        } catch (NullPointerException success) {}
468      }
469  
470      /**
471 <     * hasWaiters returns true when a thread is waiting, else false
471 >     * getWaitQueueLength throws NPE if null
472       */
473 <    public void testHasWaiters() {
474 <        final ReentrantLock lock = new ReentrantLock();
475 <        final AbstractQueuedSynchronizer.ConditionObject c = lock.newCondition();
476 <        Thread t = new Thread(new Runnable() {
477 <                public void run() {
478 <                    try {
479 <                        lock.lock();
480 <                        threadAssertFalse(c.hasWaiters());
460 <                        threadAssertEquals(0, c.getWaitQueueLength());
461 <                        c.await();
462 <                        lock.unlock();
463 <                    }
464 <                    catch(InterruptedException e) {
465 <                        threadUnexpectedException();
466 <                    }
467 <                }
468 <            });
473 >    public void testGetWaitQueueLengthNPE() {
474 >        final ReentrantLock lock = new ReentrantLock();
475 >        try {
476 >            lock.getWaitQueueLength(null);
477 >            shouldThrow();
478 >        } catch (NullPointerException success) {}
479 >    }
480 >
481  
482 +    /**
483 +     * getWaitingThreads throws NPE if null
484 +     */
485 +    public void testGetWaitingThreadsNPE() {
486 +        final PublicReentrantLock lock = new PublicReentrantLock();
487          try {
488 <            t.start();
489 <            Thread.sleep(SHORT_DELAY_MS);
490 <            lock.lock();
491 <            assertTrue(c.hasWaiters());
492 <            assertEquals(1, c.getWaitQueueLength());
493 <            c.signal();
494 <            lock.unlock();
495 <            Thread.sleep(SHORT_DELAY_MS);
496 <            lock.lock();
497 <            assertFalse(c.hasWaiters());
498 <            assertEquals(0, c.getWaitQueueLength());
499 <            lock.unlock();
500 <            t.join(SHORT_DELAY_MS);
501 <            assertFalse(t.isAlive());
502 <        }
503 <        catch (Exception ex) {
504 <            unexpectedException();
505 <        }
488 >            lock.getWaitingThreads(null);
489 >            shouldThrow();
490 >        } catch (NullPointerException success) {}
491 >    }
492 >
493 >
494 >    /**
495 >     * hasWaiters throws IAE if not owned
496 >     */
497 >    public void testHasWaitersIAE() {
498 >        final ReentrantLock lock = new ReentrantLock();
499 >        final Condition c = lock.newCondition();
500 >        final ReentrantLock lock2 = new ReentrantLock();
501 >        try {
502 >            lock2.hasWaiters(c);
503 >            shouldThrow();
504 >        } catch (IllegalArgumentException success) {}
505 >    }
506 >
507 >    /**
508 >     * hasWaiters throws IMSE if not locked
509 >     */
510 >    public void testHasWaitersIMSE() {
511 >        final ReentrantLock lock = new ReentrantLock();
512 >        final Condition c = lock.newCondition();
513 >        try {
514 >            lock.hasWaiters(c);
515 >            shouldThrow();
516 >        } catch (IllegalMonitorStateException success) {}
517 >    }
518 >
519 >
520 >    /**
521 >     * getWaitQueueLength throws IAE if not owned
522 >     */
523 >    public void testGetWaitQueueLengthIAE() {
524 >        final ReentrantLock lock = new ReentrantLock();
525 >        final Condition c = lock.newCondition();
526 >        final ReentrantLock lock2 = new ReentrantLock();
527 >        try {
528 >            lock2.getWaitQueueLength(c);
529 >            shouldThrow();
530 >        } catch (IllegalArgumentException success) {}
531 >    }
532 >
533 >    /**
534 >     * getWaitQueueLength throws IMSE if not locked
535 >     */
536 >    public void testGetWaitQueueLengthIMSE() {
537 >        final ReentrantLock lock = new ReentrantLock();
538 >        final Condition c = lock.newCondition();
539 >        try {
540 >            lock.getWaitQueueLength(c);
541 >            shouldThrow();
542 >        } catch (IllegalMonitorStateException success) {}
543 >    }
544 >
545 >
546 >    /**
547 >     * getWaitingThreads throws IAE if not owned
548 >     */
549 >    public void testGetWaitingThreadsIAE() {
550 >        final PublicReentrantLock lock = new PublicReentrantLock();
551 >        final Condition c = lock.newCondition();
552 >        final PublicReentrantLock lock2 = new PublicReentrantLock();
553 >        try {
554 >            lock2.getWaitingThreads(c);
555 >            shouldThrow();
556 >        } catch (IllegalArgumentException success) {}
557 >    }
558 >
559 >    /**
560 >     * getWaitingThreads throws IMSE if not locked
561 >     */
562 >    public void testGetWaitingThreadsIMSE() {
563 >        final PublicReentrantLock lock = new PublicReentrantLock();
564 >        final Condition c = lock.newCondition();
565 >        try {
566 >            lock.getWaitingThreads(c);
567 >            shouldThrow();
568 >        } catch (IllegalMonitorStateException success) {}
569 >    }
570 >
571 >
572 >    /**
573 >     * hasWaiters returns true when a thread is waiting, else false
574 >     */
575 >    public void testHasWaiters() throws InterruptedException {
576 >        final ReentrantLock lock = new ReentrantLock();
577 >        final Condition c = lock.newCondition();
578 >        Thread t = new Thread(new CheckedRunnable() {
579 >            public void realRun() throws InterruptedException {
580 >                lock.lock();
581 >                threadAssertFalse(lock.hasWaiters(c));
582 >                threadAssertEquals(0, lock.getWaitQueueLength(c));
583 >                c.await();
584 >                lock.unlock();
585 >            }});
586 >
587 >        t.start();
588 >        Thread.sleep(SHORT_DELAY_MS);
589 >        lock.lock();
590 >        assertTrue(lock.hasWaiters(c));
591 >        assertEquals(1, lock.getWaitQueueLength(c));
592 >        c.signal();
593 >        lock.unlock();
594 >        Thread.sleep(SHORT_DELAY_MS);
595 >        lock.lock();
596 >        assertFalse(lock.hasWaiters(c));
597 >        assertEquals(0, lock.getWaitQueueLength(c));
598 >        lock.unlock();
599 >        t.join(SHORT_DELAY_MS);
600 >        assertFalse(t.isAlive());
601      }
602  
603      /**
604       * getWaitQueueLength returns number of waiting threads
605       */
606 <    public void testGetWaitQueueLength() {
607 <        final ReentrantLock lock = new ReentrantLock();
608 <        final AbstractQueuedSynchronizer.ConditionObject c = lock.newCondition();
609 <        Thread t1 = new Thread(new Runnable() {
610 <                public void run() {
611 <                    try {
612 <                        lock.lock();
613 <                        threadAssertFalse(c.hasWaiters());
614 <                        threadAssertEquals(0, c.getWaitQueueLength());
615 <                        c.await();
616 <                        lock.unlock();
617 <                    }
618 <                    catch(InterruptedException e) {
619 <                        threadUnexpectedException();
620 <                    }
621 <                }
622 <            });
623 <
624 <        Thread t2 = new Thread(new Runnable() {
625 <                public void run() {
626 <                    try {
627 <                        lock.lock();
628 <                        threadAssertTrue(c.hasWaiters());
629 <                        threadAssertEquals(1, c.getWaitQueueLength());
630 <                        c.await();
631 <                        lock.unlock();
632 <                    }
633 <                    catch(InterruptedException e) {
634 <                        threadUnexpectedException();
635 <                    }
636 <                }
637 <            });
638 <
639 <        try {
640 <            t1.start();
641 <            Thread.sleep(SHORT_DELAY_MS);
642 <            t2.start();
643 <            Thread.sleep(SHORT_DELAY_MS);
644 <            lock.lock();
645 <            assertTrue(c.hasWaiters());
646 <            assertEquals(2, c.getWaitQueueLength());
647 <            c.signalAll();
648 <            lock.unlock();
649 <            Thread.sleep(SHORT_DELAY_MS);
650 <            lock.lock();
651 <            assertFalse(c.hasWaiters());
652 <            assertEquals(0, c.getWaitQueueLength());
606 >    public void testGetWaitQueueLength() throws InterruptedException {
607 >        final ReentrantLock lock = new ReentrantLock();
608 >        final Condition c = lock.newCondition();
609 >        Thread t1 = new Thread(new CheckedRunnable() {
610 >            public void realRun() throws InterruptedException {
611 >                lock.lock();
612 >                threadAssertFalse(lock.hasWaiters(c));
613 >                threadAssertEquals(0, lock.getWaitQueueLength(c));
614 >                c.await();
615 >                lock.unlock();
616 >            }});
617 >
618 >        Thread t2 = new Thread(new CheckedRunnable() {
619 >            public void realRun() throws InterruptedException {
620 >                lock.lock();
621 >                threadAssertTrue(lock.hasWaiters(c));
622 >                threadAssertEquals(1, lock.getWaitQueueLength(c));
623 >                c.await();
624 >                lock.unlock();
625 >            }});
626 >
627 >        t1.start();
628 >        Thread.sleep(SHORT_DELAY_MS);
629 >        t2.start();
630 >        Thread.sleep(SHORT_DELAY_MS);
631 >        lock.lock();
632 >        assertTrue(lock.hasWaiters(c));
633 >        assertEquals(2, lock.getWaitQueueLength(c));
634 >        c.signalAll();
635 >        lock.unlock();
636 >        Thread.sleep(SHORT_DELAY_MS);
637 >        lock.lock();
638 >        assertFalse(lock.hasWaiters(c));
639 >        assertEquals(0, lock.getWaitQueueLength(c));
640 >        lock.unlock();
641 >        t1.join(SHORT_DELAY_MS);
642 >        t2.join(SHORT_DELAY_MS);
643 >        assertFalse(t1.isAlive());
644 >        assertFalse(t2.isAlive());
645 >    }
646 >
647 >    /**
648 >     * getWaitingThreads returns only and all waiting threads
649 >     */
650 >    public void testGetWaitingThreads() throws InterruptedException {
651 >        final PublicReentrantLock lock = new PublicReentrantLock();
652 >        final Condition c = lock.newCondition();
653 >        Thread t1 = new Thread(new CheckedRunnable() {
654 >            public void realRun() throws InterruptedException {
655 >                lock.lock();
656 >                threadAssertTrue(lock.getWaitingThreads(c).isEmpty());
657 >                c.await();
658 >                lock.unlock();
659 >            }});
660 >
661 >        Thread t2 = new Thread(new CheckedRunnable() {
662 >            public void realRun() throws InterruptedException {
663 >                lock.lock();
664 >                threadAssertFalse(lock.getWaitingThreads(c).isEmpty());
665 >                c.await();
666 >                lock.unlock();
667 >            }});
668 >
669 >        lock.lock();
670 >        assertTrue(lock.getWaitingThreads(c).isEmpty());
671 >        lock.unlock();
672 >        t1.start();
673 >        Thread.sleep(SHORT_DELAY_MS);
674 >        t2.start();
675 >        Thread.sleep(SHORT_DELAY_MS);
676 >        lock.lock();
677 >        assertTrue(lock.hasWaiters(c));
678 >        assertTrue(lock.getWaitingThreads(c).contains(t1));
679 >        assertTrue(lock.getWaitingThreads(c).contains(t2));
680 >        c.signalAll();
681 >        lock.unlock();
682 >        Thread.sleep(SHORT_DELAY_MS);
683 >        lock.lock();
684 >        assertFalse(lock.hasWaiters(c));
685 >        assertTrue(lock.getWaitingThreads(c).isEmpty());
686 >        lock.unlock();
687 >        t1.join(SHORT_DELAY_MS);
688 >        t2.join(SHORT_DELAY_MS);
689 >        assertFalse(t1.isAlive());
690 >        assertFalse(t2.isAlive());
691 >    }
692 >
693 >    /** A helper class for uninterruptible wait tests */
694 >    class UninterruptibleThread extends Thread {
695 >        private ReentrantLock lock;
696 >        private Condition c;
697 >
698 >        public volatile boolean canAwake = false;
699 >        public volatile boolean interrupted = false;
700 >        public volatile boolean lockStarted = false;
701 >
702 >        public UninterruptibleThread(ReentrantLock lock, Condition c) {
703 >            this.lock = lock;
704 >            this.c = c;
705 >        }
706 >
707 >        public synchronized void run() {
708 >            lock.lock();
709 >            lockStarted = true;
710 >
711 >            while (!canAwake) {
712 >                c.awaitUninterruptibly();
713 >            }
714 >
715 >            interrupted = isInterrupted();
716              lock.unlock();
542            t1.join(SHORT_DELAY_MS);
543            t2.join(SHORT_DELAY_MS);
544            assertFalse(t1.isAlive());
545            assertFalse(t2.isAlive());
546        }
547        catch (Exception ex) {
548            unexpectedException();
717          }
718      }
719  
720      /**
721       * awaitUninterruptibly doesn't abort on interrupt
722       */
723 <    public void testAwaitUninterruptibly() {
724 <        final ReentrantLock lock = new ReentrantLock();
723 >    public void testAwaitUninterruptibly() throws InterruptedException {
724 >        final ReentrantLock lock = new ReentrantLock();
725          final Condition c = lock.newCondition();
726 <        Thread t = new Thread(new Runnable() {
727 <                public void run() {
728 <                    lock.lock();
561 <                    c.awaitUninterruptibly();
562 <                    lock.unlock();
563 <                }
564 <            });
726 >        UninterruptibleThread thread = new UninterruptibleThread(lock, c);
727 >
728 >        thread.start();
729  
730 +        while (!thread.lockStarted) {
731 +            Thread.sleep(100);
732 +        }
733 +
734 +        lock.lock();
735          try {
736 <            t.start();
737 <            Thread.sleep(SHORT_DELAY_MS);
569 <            t.interrupt();
570 <            lock.lock();
736 >            thread.interrupt();
737 >            thread.canAwake = true;
738              c.signal();
739 +        } finally {
740              lock.unlock();
573            assert(t.isInterrupted());
574            t.join(SHORT_DELAY_MS);
575            assertFalse(t.isAlive());
576        }
577        catch (Exception ex) {
578            unexpectedException();
741          }
742 +
743 +        thread.join();
744 +        assertTrue(thread.interrupted);
745 +        assertFalse(thread.isAlive());
746      }
747  
748      /**
749       * await is interruptible
750       */
751 <    public void testAwait_Interrupt() {
752 <        final ReentrantLock lock = new ReentrantLock();
751 >    public void testAwait_Interrupt() throws InterruptedException {
752 >        final ReentrantLock lock = new ReentrantLock();
753          final Condition c = lock.newCondition();
754 <        Thread t = new Thread(new Runnable() {
755 <                public void run() {
756 <                    try {
757 <                        lock.lock();
758 <                        c.await();
759 <                        lock.unlock();
760 <                        threadShouldThrow();
761 <                    }
762 <                    catch(InterruptedException success) {
763 <                    }
764 <                }
599 <            });
600 <
601 <        try {
602 <            t.start();
603 <            Thread.sleep(SHORT_DELAY_MS);
604 <            t.interrupt();
605 <            t.join(SHORT_DELAY_MS);
606 <            assertFalse(t.isAlive());
607 <        }
608 <        catch (Exception ex) {
609 <            unexpectedException();
610 <        }
754 >        Thread t = new Thread(new CheckedInterruptedRunnable() {
755 >            public void realRun() throws InterruptedException {
756 >                lock.lock();
757 >                c.await();
758 >            }});
759 >
760 >        t.start();
761 >        Thread.sleep(SHORT_DELAY_MS);
762 >        t.interrupt();
763 >        t.join(SHORT_DELAY_MS);
764 >        assertFalse(t.isAlive());
765      }
766  
767      /**
768       * awaitNanos is interruptible
769       */
770 <    public void testAwaitNanos_Interrupt() {
771 <        final ReentrantLock lock = new ReentrantLock();
770 >    public void testAwaitNanos_Interrupt() throws InterruptedException {
771 >        final ReentrantLock lock = new ReentrantLock();
772          final Condition c = lock.newCondition();
773 <        Thread t = new Thread(new Runnable() {
774 <                public void run() {
775 <                    try {
776 <                        lock.lock();
777 <                        c.awaitNanos(SHORT_DELAY_MS * 2 * 1000000);
778 <                        lock.unlock();
779 <                        threadShouldThrow();
780 <                    }
781 <                    catch(InterruptedException success) {
782 <                    }
783 <                }
630 <            });
631 <
632 <        try {
633 <            t.start();
634 <            Thread.sleep(SHORT_DELAY_MS);
635 <            t.interrupt();
636 <            t.join(SHORT_DELAY_MS);
637 <            assertFalse(t.isAlive());
638 <        }
639 <        catch (Exception ex) {
640 <            unexpectedException();
641 <        }
773 >        Thread t = new Thread(new CheckedInterruptedRunnable() {
774 >            public void realRun() throws InterruptedException {
775 >                lock.lock();
776 >                c.awaitNanos(1000 * 1000 * 1000); // 1 sec
777 >            }});
778 >
779 >        t.start();
780 >        Thread.sleep(SHORT_DELAY_MS);
781 >        t.interrupt();
782 >        t.join(SHORT_DELAY_MS);
783 >        assertFalse(t.isAlive());
784      }
785  
786      /**
787       * awaitUntil is interruptible
788       */
789 <    public void testAwaitUntil_Interrupt() {
790 <        final ReentrantLock lock = new ReentrantLock();
789 >    public void testAwaitUntil_Interrupt() throws InterruptedException {
790 >        final ReentrantLock lock = new ReentrantLock();
791          final Condition c = lock.newCondition();
792 <        Thread t = new Thread(new Runnable() {
793 <                public void run() {
794 <                    try {
795 <                        lock.lock();
796 <                        java.util.Date d = new java.util.Date();
797 <                        c.awaitUntil(new java.util.Date(d.getTime() + 10000));
798 <                        lock.unlock();
799 <                        threadShouldThrow();
800 <                    }
801 <                    catch(InterruptedException success) {
802 <                    }
803 <                }
662 <            });
663 <
664 <        try {
665 <            t.start();
666 <            Thread.sleep(SHORT_DELAY_MS);
667 <            t.interrupt();
668 <            t.join(SHORT_DELAY_MS);
669 <            assertFalse(t.isAlive());
670 <        }
671 <        catch (Exception ex) {
672 <            unexpectedException();
673 <        }
792 >        Thread t = new Thread(new CheckedInterruptedRunnable() {
793 >            public void realRun() throws InterruptedException {
794 >                lock.lock();
795 >                java.util.Date d = new java.util.Date();
796 >                c.awaitUntil(new java.util.Date(d.getTime() + 10000));
797 >            }});
798 >
799 >        t.start();
800 >        Thread.sleep(SHORT_DELAY_MS);
801 >        t.interrupt();
802 >        t.join(SHORT_DELAY_MS);
803 >        assertFalse(t.isAlive());
804      }
805  
806      /**
807       * signalAll wakes up all threads
808       */
809 <    public void testSignalAll() {
810 <        final ReentrantLock lock = new ReentrantLock();
809 >    public void testSignalAll() throws InterruptedException {
810 >        final ReentrantLock lock = new ReentrantLock();
811          final Condition c = lock.newCondition();
812 <        Thread t1 = new Thread(new Runnable() {
813 <                public void run() {
814 <                    try {
815 <                        lock.lock();
816 <                        c.await();
817 <                        lock.unlock();
818 <                    }
819 <                    catch(InterruptedException e) {
820 <                        threadUnexpectedException();
821 <                    }
822 <                }
823 <            });
824 <
825 <        Thread t2 = new Thread(new Runnable() {
826 <                public void run() {
827 <                    try {
828 <                        lock.lock();
829 <                        c.await();
830 <                        lock.unlock();
831 <                    }
832 <                    catch(InterruptedException e) {
833 <                        threadUnexpectedException();
834 <                    }
835 <                }
836 <            });
837 <
838 <        try {
839 <            t1.start();
840 <            t2.start();
841 <            Thread.sleep(SHORT_DELAY_MS);
842 <            lock.lock();
843 <            c.signalAll();
844 <            lock.unlock();
845 <            t1.join(SHORT_DELAY_MS);
846 <            t2.join(SHORT_DELAY_MS);
847 <            assertFalse(t1.isAlive());
848 <            assertFalse(t2.isAlive());
849 <        }
850 <        catch (Exception ex) {
851 <            unexpectedException();
852 <        }
812 >        Thread t1 = new Thread(new CheckedRunnable() {
813 >            public void realRun() throws InterruptedException {
814 >                lock.lock();
815 >                c.await();
816 >                lock.unlock();
817 >            }});
818 >
819 >        Thread t2 = new Thread(new CheckedRunnable() {
820 >            public void realRun() throws InterruptedException {
821 >                lock.lock();
822 >                c.await();
823 >                lock.unlock();
824 >            }});
825 >
826 >        t1.start();
827 >        t2.start();
828 >        Thread.sleep(SHORT_DELAY_MS);
829 >        lock.lock();
830 >        c.signalAll();
831 >        lock.unlock();
832 >        t1.join(SHORT_DELAY_MS);
833 >        t2.join(SHORT_DELAY_MS);
834 >        assertFalse(t1.isAlive());
835 >        assertFalse(t2.isAlive());
836 >    }
837 >
838 >    /**
839 >     * await after multiple reentrant locking preserves lock count
840 >     */
841 >    public void testAwaitLockCount() throws InterruptedException {
842 >        final ReentrantLock lock = new ReentrantLock();
843 >        final Condition c = lock.newCondition();
844 >        Thread t1 = new Thread(new CheckedRunnable() {
845 >            public void realRun() throws InterruptedException {
846 >                lock.lock();
847 >                threadAssertEquals(1, lock.getHoldCount());
848 >                c.await();
849 >                threadAssertEquals(1, lock.getHoldCount());
850 >                lock.unlock();
851 >            }});
852 >
853 >        Thread t2 = new Thread(new CheckedRunnable() {
854 >            public void realRun() throws InterruptedException {
855 >                lock.lock();
856 >                lock.lock();
857 >                threadAssertEquals(2, lock.getHoldCount());
858 >                c.await();
859 >                threadAssertEquals(2, lock.getHoldCount());
860 >                lock.unlock();
861 >                lock.unlock();
862 >            }});
863 >
864 >        t1.start();
865 >        t2.start();
866 >        Thread.sleep(SHORT_DELAY_MS);
867 >        lock.lock();
868 >        c.signalAll();
869 >        lock.unlock();
870 >        t1.join(SHORT_DELAY_MS);
871 >        t2.join(SHORT_DELAY_MS);
872 >        assertFalse(t1.isAlive());
873 >        assertFalse(t2.isAlive());
874      }
875  
876      /**
877       * A serialized lock deserializes as unlocked
878       */
879 <    public void testSerialization() {
879 >    public void testSerialization() throws Exception {
880          ReentrantLock l = new ReentrantLock();
881          l.lock();
882          l.unlock();
883  
884 <        try {
885 <            ByteArrayOutputStream bout = new ByteArrayOutputStream(10000);
886 <            ObjectOutputStream out = new ObjectOutputStream(new BufferedOutputStream(bout));
887 <            out.writeObject(l);
888 <            out.close();
889 <
890 <            ByteArrayInputStream bin = new ByteArrayInputStream(bout.toByteArray());
891 <            ObjectInputStream in = new ObjectInputStream(new BufferedInputStream(bin));
892 <            ReentrantLock r = (ReentrantLock) in.readObject();
893 <            r.lock();
894 <            r.unlock();
895 <        } catch(Exception e){
896 <            e.printStackTrace();
897 <            unexpectedException();
898 <        }
884 >        ByteArrayOutputStream bout = new ByteArrayOutputStream(10000);
885 >        ObjectOutputStream out =
886 >            new ObjectOutputStream(new BufferedOutputStream(bout));
887 >        out.writeObject(l);
888 >        out.close();
889 >        
890 >        ByteArrayInputStream bin =
891 >            new ByteArrayInputStream(bout.toByteArray());
892 >        ObjectInputStream in =
893 >            new ObjectInputStream(new BufferedInputStream(bin));
894 >        ReentrantLock r = (ReentrantLock) in.readObject();
895 >        r.lock();
896 >        r.unlock();
897 >    }
898 >
899 >    /**
900 >     * toString indicates current lock state
901 >     */
902 >    public void testToString() {
903 >        ReentrantLock lock = new ReentrantLock();
904 >        String us = lock.toString();
905 >        assertTrue(us.indexOf("Unlocked") >= 0);
906 >        lock.lock();
907 >        String ls = lock.toString();
908 >        assertTrue(ls.indexOf("Locked") >= 0);
909      }
910  
911   }

Diff Legend

Removed lines
+ Added lines
< Changed lines
> Changed lines