ViewVC Help

View File | Revision Log | Show Annotations | Download File | Root Listing

root/jsr166/jsr166/src/test/tck/ReentrantLockTest.java

Comparing jsr166/src/test/tck/ReentrantLockTest.java (file contents):
Revision 1.13 by dl, Sun Dec 28 21:56:18 2003 UTC vs.
Revision 1.27 by jsr166, Mon Nov 16 04:57:10 2009 UTC

#	Line 2 | Line 2
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.
5	>	* Other contributors include Andrew Wright, Jeffrey Hayes,
6	>	* Pat Fisher, Mike Judd.
7		*/
8
9		import junit.framework.*;
#	Line 14 | 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 29 | Line 29 | public class ReentrantLockTest extends J
29		public void run() {
30		try {
31		lock.lockInterruptibly();
32	<	} catch(InterruptedException success){}
32	>	} catch (InterruptedException success){}
33		}
34		}
35
#	Line 45 | Line 45 | public class ReentrantLockTest extends J
45		try {
46		lock.lockInterruptibly();
47		threadShouldThrow();
48	<	} catch(InterruptedException success){}
48	>	} catch (InterruptedException success){}
49		}
50		}
51
#	Line 54 | Line 54 | public class ReentrantLockTest extends J
54		*/
55		static class PublicReentrantLock extends ReentrantLock {
56		PublicReentrantLock() { super(); }
57	<	public Collection<Thread> getQueuedThreads() {
58	<	return super.getQueuedThreads();
57	>	public Collection<Thread> getQueuedThreads() {
58	>	return super.getQueuedThreads();
59		}
60	<	public Collection<Thread> getWaitingThreads(Condition c) {
61	<	return super.getWaitingThreads(c);
60	>	public Collection<Thread> getWaitingThreads(Condition c) {
61	>	return super.getWaitingThreads(c);
62		}
63
64
#	Line 67 | Line 67 | public class ReentrantLockTest extends J
67		/**
68		* Constructor sets given fairness
69		*/
70	<	public void testConstructor() {
70	>	public void testConstructor() {
71		ReentrantLock rl = new ReentrantLock();
72		assertFalse(rl.isFair());
73		ReentrantLock r2 = new ReentrantLock(true);
#	Line 77 | Line 77 | public class ReentrantLockTest extends J
77		/**
78		* locking an unlocked lock succeeds
79		*/
80	<	public void testLock() {
80	>	public void testLock() {
81		ReentrantLock rl = new ReentrantLock();
82		rl.lock();
83		assertTrue(rl.isLocked());
#	Line 87 | Line 87 | public class ReentrantLockTest extends J
87		/**
88		* locking an unlocked fair lock succeeds
89		*/
90	<	public void testFairLock() {
90	>	public void testFairLock() {
91		ReentrantLock rl = new ReentrantLock(true);
92		rl.lock();
93		assertTrue(rl.isLocked());
#	Line 97 | Line 97 | public class ReentrantLockTest extends J
97		/**
98		* Unlocking an unlocked lock throws IllegalMonitorStateException
99		*/
100	<	public void testUnlock_IllegalMonitorStateException() {
100	>	public void testUnlock_IllegalMonitorStateException() {
101		ReentrantLock rl = new ReentrantLock();
102		try {
103		rl.unlock();
104		shouldThrow();
105
106	<	} catch(IllegalMonitorStateException success){}
106	>	} catch (IllegalMonitorStateException success){}
107		}
108
109		/**
110	<	* trylock on an unlocked lock succeeds
110	>	* tryLock on an unlocked lock succeeds
111		*/
112	<	public void testTryLock() {
112	>	public void testTryLock() {
113		ReentrantLock rl = new ReentrantLock();
114		assertTrue(rl.tryLock());
115		assertTrue(rl.isLocked());
#	Line 120 | Line 120 | public class ReentrantLockTest extends J
120		/**
121		* hasQueuedThreads reports whether there are waiting threads
122		*/
123	<	public void testhasQueuedThreads() {
123	>	public void testhasQueuedThreads() {
124		final ReentrantLock lock = new ReentrantLock();
125		Thread t1 = new Thread(new InterruptedLockRunnable(lock));
126		Thread t2 = new Thread(new InterruptibleLockRunnable(lock));
#	Line 141 | Line 141 | public class ReentrantLockTest extends J
141		assertFalse(lock.hasQueuedThreads());
142		t1.join();
143		t2.join();
144	<	} catch(Exception e){
144	>	} catch (Exception e){
145		unexpectedException();
146		}
147	<	}
147	>	}
148
149		/**
150		* getQueueLength reports number of waiting threads
151		*/
152	<	public void testGetQueueLength() {
152	>	public void testGetQueueLength() {
153		final ReentrantLock lock = new ReentrantLock();
154		Thread t1 = new Thread(new InterruptedLockRunnable(lock));
155		Thread t2 = new Thread(new InterruptibleLockRunnable(lock));
#	Line 170 | Line 170 | public class ReentrantLockTest extends J
170		assertEquals(0, lock.getQueueLength());
171		t1.join();
172		t2.join();
173	<	} catch(Exception e){
173	>	} catch (Exception e){
174	>	unexpectedException();
175	>	}
176	>	}
177	>
178	>	/**
179	>	* getQueueLength reports number of waiting threads
180	>	*/
181	>	public void testGetQueueLength_fair() {
182	>	final ReentrantLock lock = new ReentrantLock(true);
183	>	Thread t1 = new Thread(new InterruptedLockRunnable(lock));
184	>	Thread t2 = new Thread(new InterruptibleLockRunnable(lock));
185	>	try {
186	>	assertEquals(0, lock.getQueueLength());
187	>	lock.lock();
188	>	t1.start();
189	>	Thread.sleep(SHORT_DELAY_MS);
190	>	assertEquals(1, lock.getQueueLength());
191	>	t2.start();
192	>	Thread.sleep(SHORT_DELAY_MS);
193	>	assertEquals(2, lock.getQueueLength());
194	>	t1.interrupt();
195	>	Thread.sleep(SHORT_DELAY_MS);
196	>	assertEquals(1, lock.getQueueLength());
197	>	lock.unlock();
198	>	Thread.sleep(SHORT_DELAY_MS);
199	>	assertEquals(0, lock.getQueueLength());
200	>	t1.join();
201	>	t2.join();
202	>	} catch (Exception e){
203		unexpectedException();
204		}
205	<	}
205	>	}
206	>
207	>	/**
208	>	* hasQueuedThread(null) throws NPE
209	>	*/
210	>	public void testHasQueuedThreadNPE() {
211	>	final ReentrantLock sync = new ReentrantLock();
212	>	try {
213	>	sync.hasQueuedThread(null);
214	>	shouldThrow();
215	>	} catch (NullPointerException success) {
216	>	}
217	>	}
218	>
219	>	/**
220	>	* hasQueuedThread reports whether a thread is queued.
221	>	*/
222	>	public void testHasQueuedThread() {
223	>	final ReentrantLock sync = new ReentrantLock();
224	>	Thread t1 = new Thread(new InterruptedLockRunnable(sync));
225	>	Thread t2 = new Thread(new InterruptibleLockRunnable(sync));
226	>	try {
227	>	assertFalse(sync.hasQueuedThread(t1));
228	>	assertFalse(sync.hasQueuedThread(t2));
229	>	sync.lock();
230	>	t1.start();
231	>	Thread.sleep(SHORT_DELAY_MS);
232	>	assertTrue(sync.hasQueuedThread(t1));
233	>	t2.start();
234	>	Thread.sleep(SHORT_DELAY_MS);
235	>	assertTrue(sync.hasQueuedThread(t1));
236	>	assertTrue(sync.hasQueuedThread(t2));
237	>	t1.interrupt();
238	>	Thread.sleep(SHORT_DELAY_MS);
239	>	assertFalse(sync.hasQueuedThread(t1));
240	>	assertTrue(sync.hasQueuedThread(t2));
241	>	sync.unlock();
242	>	Thread.sleep(SHORT_DELAY_MS);
243	>	assertFalse(sync.hasQueuedThread(t1));
244	>	Thread.sleep(SHORT_DELAY_MS);
245	>	assertFalse(sync.hasQueuedThread(t2));
246	>	t1.join();
247	>	t2.join();
248	>	} catch (Exception e){
249	>	unexpectedException();
250	>	}
251	>	}
252	>
253
254		/**
255		* getQueuedThreads includes waiting threads
256		*/
257	<	public void testGetQueuedThreads() {
257	>	public void testGetQueuedThreads() {
258		final PublicReentrantLock lock = new PublicReentrantLock();
259		Thread t1 = new Thread(new InterruptedLockRunnable(lock));
260		Thread t2 = new Thread(new InterruptibleLockRunnable(lock));
#	Line 202 | Line 278 | public class ReentrantLockTest extends J
278		assertTrue(lock.getQueuedThreads().isEmpty());
279		t1.join();
280		t2.join();
281	<	} catch(Exception e){
281	>	} catch (Exception e){
282		unexpectedException();
283		}
284	<	}
284	>	}
285
286
287		/**
288	<	* timed trylock is interruptible.
288	>	* timed tryLock is interruptible.
289		*/
290	<	public void testInterruptedException2() {
290	>	public void testInterruptedException2() {
291		final ReentrantLock lock = new ReentrantLock();
292		lock.lock();
293		Thread t = new Thread(new Runnable() {
#	Line 219 | Line 295 | public class ReentrantLockTest extends J
295		try {
296		lock.tryLock(MEDIUM_DELAY_MS,TimeUnit.MILLISECONDS);
297		threadShouldThrow();
298	<	} catch(InterruptedException success){}
298	>	} catch (InterruptedException success){}
299		}
300		});
301		try {
302		t.start();
303		t.interrupt();
304	<	} catch(Exception e){
304	>	} catch (Exception e){
305		unexpectedException();
306		}
307		}
308
309
310		/**
311	<	* Trylock on a locked lock fails
311	>	* TryLock on a locked lock fails
312		*/
313	<	public void testTryLockWhenLocked() {
313	>	public void testTryLockWhenLocked() {
314		final ReentrantLock lock = new ReentrantLock();
315		lock.lock();
316		Thread t = new Thread(new Runnable() {
#	Line 246 | Line 322 | public class ReentrantLockTest extends J
322		t.start();
323		t.join();
324		lock.unlock();
325	<	} catch(Exception e){
325	>	} catch (Exception e){
326		unexpectedException();
327		}
328	<	}
328	>	}
329
330		/**
331	<	* Timed trylock on a locked lock times out
331	>	* Timed tryLock on a locked lock times out
332		*/
333	<	public void testTryLock_Timeout() {
333	>	public void testTryLock_Timeout() {
334		final ReentrantLock lock = new ReentrantLock();
335		lock.lock();
336		Thread t = new Thread(new Runnable() {
#	Line 270 | Line 346 | public class ReentrantLockTest extends J
346		t.start();
347		t.join();
348		lock.unlock();
349	<	} catch(Exception e){
349	>	} catch (Exception e){
350		unexpectedException();
351		}
352	<	}
353	<
352	>	}
353	>
354		/**
355		* getHoldCount returns number of recursive holds
356		*/
357		public void testGetHoldCount() {
358		ReentrantLock lock = new ReentrantLock();
359	<	for(int i = 1; i <= SIZE; i++) {
359	>	for (int i = 1; i <= SIZE; i++) {
360		lock.lock();
361		assertEquals(i,lock.getHoldCount());
362		}
363	<	for(int i = SIZE; i > 0; i--) {
363	>	for (int i = SIZE; i > 0; i--) {
364		lock.unlock();
365		assertEquals(i-1,lock.getHoldCount());
366		}
367		}
368	<
369	<
368	>
369	>
370		/**
371		* isLocked is true when locked and false when not
372		*/
#	Line 300 | Line 376 | public class ReentrantLockTest extends J
376		assertTrue(lock.isLocked());
377		lock.unlock();
378		assertFalse(lock.isLocked());
379	<	Thread t = new Thread(new Runnable() {
379	>	Thread t = new Thread(new Runnable() {
380		public void run() {
381		lock.lock();
382		try {
383		Thread.sleep(SMALL_DELAY_MS);
384		}
385	<	catch(Exception e) {
385	>	catch (Exception e) {
386		threadUnexpectedException();
387		}
388		lock.unlock();
#	Line 318 | Line 394 | public class ReentrantLockTest extends J
394		assertTrue(lock.isLocked());
395		t.join();
396		assertFalse(lock.isLocked());
397	<	} catch(Exception e){
397	>	} catch (Exception e){
398		unexpectedException();
399		}
400		}
#	Line 327 | Line 403 | public class ReentrantLockTest extends J
403		/**
404		* lockInterruptibly is interruptible.
405		*/
406	<	public void testLockInterruptibly1() {
406	>	public void testLockInterruptibly1() {
407		final ReentrantLock lock = new ReentrantLock();
408		lock.lock();
409		Thread t = new Thread(new InterruptedLockRunnable(lock));
410		try {
411		t.start();
412	+	Thread.sleep(SHORT_DELAY_MS);
413		t.interrupt();
414	+	Thread.sleep(SHORT_DELAY_MS);
415		lock.unlock();
416		t.join();
417	<	} catch(Exception e){
417	>	} catch (Exception e){
418		unexpectedException();
419		}
420	<	}
420	>	}
421
422		/**
423		* lockInterruptibly succeeds when unlocked, else is interruptible
424		*/
425		public void testLockInterruptibly2() {
426	<	final ReentrantLock lock = new ReentrantLock();
426	>	final ReentrantLock lock = new ReentrantLock();
427		try {
428		lock.lockInterruptibly();
429	<	} catch(Exception e) {
429	>	} catch (Exception e) {
430		unexpectedException();
431		}
432		Thread t = new Thread(new InterruptedLockRunnable(lock));
#	Line 358 | Line 436 | public class ReentrantLockTest extends J
436		assertTrue(lock.isLocked());
437		assertTrue(lock.isHeldByCurrentThread());
438		t.join();
439	<	} catch(Exception e){
439	>	} catch (Exception e){
440		unexpectedException();
441		}
442		}
#	Line 367 | Line 445 | public class ReentrantLockTest extends J
445		* Calling await without holding lock throws IllegalMonitorStateException
446		*/
447		public void testAwait_IllegalMonitor() {
448	<	final ReentrantLock lock = new ReentrantLock();
448	>	final ReentrantLock lock = new ReentrantLock();
449		final Condition c = lock.newCondition();
450		try {
451		c.await();
#	Line 384 | Line 462 | public class ReentrantLockTest extends J
462		* Calling signal without holding lock throws IllegalMonitorStateException
463		*/
464		public void testSignal_IllegalMonitor() {
465	<	final ReentrantLock lock = new ReentrantLock();
465	>	final ReentrantLock lock = new ReentrantLock();
466		final Condition c = lock.newCondition();
467		try {
468		c.signal();
#	Line 401 | Line 479 | public class ReentrantLockTest extends J
479		* awaitNanos without a signal times out
480		*/
481		public void testAwaitNanos_Timeout() {
482	<	final ReentrantLock lock = new ReentrantLock();
482	>	final ReentrantLock lock = new ReentrantLock();
483		final Condition c = lock.newCondition();
484		try {
485		lock.lock();
#	Line 418 | Line 496 | public class ReentrantLockTest extends J
496		*  timed await without a signal times out
497		*/
498		public void testAwait_Timeout() {
499	<	final ReentrantLock lock = new ReentrantLock();
499	>	final ReentrantLock lock = new ReentrantLock();
500		final Condition c = lock.newCondition();
501		try {
502		lock.lock();
503	<	assertFalse(c.await(SHORT_DELAY_MS, TimeUnit.MILLISECONDS));
503	>	c.await(SHORT_DELAY_MS, TimeUnit.MILLISECONDS);
504		lock.unlock();
505		}
506		catch (Exception ex) {
#	Line 434 | Line 512 | public class ReentrantLockTest extends J
512		* awaitUntil without a signal times out
513		*/
514		public void testAwaitUntil_Timeout() {
515	<	final ReentrantLock lock = new ReentrantLock();
515	>	final ReentrantLock lock = new ReentrantLock();
516		final Condition c = lock.newCondition();
517		try {
518		lock.lock();
519		java.util.Date d = new java.util.Date();
520	<	assertFalse(c.awaitUntil(new java.util.Date(d.getTime() + 10)));
520	>	c.awaitUntil(new java.util.Date(d.getTime() + 10));
521		lock.unlock();
522		}
523		catch (Exception ex) {
#	Line 451 | Line 529 | public class ReentrantLockTest extends J
529		* await returns when signalled
530		*/
531		public void testAwait() {
532	<	final ReentrantLock lock = new ReentrantLock();
532	>	final ReentrantLock lock = new ReentrantLock();
533		final Condition c = lock.newCondition();
534	<	Thread t = new Thread(new Runnable() {
534	>	Thread t = new Thread(new Runnable() {
535		public void run() {
536		try {
537		lock.lock();
538		c.await();
539		lock.unlock();
540		}
541	<	catch(InterruptedException e) {
541	>	catch (InterruptedException e) {
542		threadUnexpectedException();
543		}
544		}
#	Line 481 | Line 559 | public class ReentrantLockTest extends J
559		}
560
561		/**
562	+	* hasWaiters throws NPE if null
563	+	*/
564	+	public void testHasWaitersNPE() {
565	+	final ReentrantLock lock = new ReentrantLock();
566	+	try {
567	+	lock.hasWaiters(null);
568	+	shouldThrow();
569	+	} catch (NullPointerException success) {
570	+	} catch (Exception ex) {
571	+	unexpectedException();
572	+	}
573	+	}
574	+
575	+	/**
576	+	* getWaitQueueLength throws NPE if null
577	+	*/
578	+	public void testGetWaitQueueLengthNPE() {
579	+	final ReentrantLock lock = new ReentrantLock();
580	+	try {
581	+	lock.getWaitQueueLength(null);
582	+	shouldThrow();
583	+	} catch (NullPointerException success) {
584	+	} catch (Exception ex) {
585	+	unexpectedException();
586	+	}
587	+	}
588	+
589	+
590	+	/**
591	+	* getWaitingThreads throws NPE if null
592	+	*/
593	+	public void testGetWaitingThreadsNPE() {
594	+	final PublicReentrantLock lock = new PublicReentrantLock();
595	+	try {
596	+	lock.getWaitingThreads(null);
597	+	shouldThrow();
598	+	} catch (NullPointerException success) {
599	+	} catch (Exception ex) {
600	+	unexpectedException();
601	+	}
602	+	}
603	+
604	+
605	+	/**
606		* hasWaiters throws IAE if not owned
607		*/
608		public void testHasWaitersIAE() {
#	Line 548 | Line 670 | public class ReentrantLockTest extends J
670		* getWaitingThreads throws IAE if not owned
671		*/
672		public void testGetWaitingThreadsIAE() {
673	<	final PublicReentrantLock lock = new PublicReentrantLock();
673	>	final PublicReentrantLock lock = new PublicReentrantLock();
674		final Condition c = (lock.newCondition());
675	<	final PublicReentrantLock lock2 = new PublicReentrantLock();
675	>	final PublicReentrantLock lock2 = new PublicReentrantLock();
676		try {
677		lock2.getWaitingThreads(c);
678		shouldThrow();
#	Line 564 | Line 686 | public class ReentrantLockTest extends J
686		* getWaitingThreads throws IMSE if not locked
687		*/
688		public void testGetWaitingThreadsIMSE() {
689	<	final PublicReentrantLock lock = new PublicReentrantLock();
689	>	final PublicReentrantLock lock = new PublicReentrantLock();
690		final Condition c = (lock.newCondition());
691		try {
692		lock.getWaitingThreads(c);
#	Line 581 | Line 703 | public class ReentrantLockTest extends J
703		* hasWaiters returns true when a thread is waiting, else false
704		*/
705		public void testHasWaiters() {
706	<	final ReentrantLock lock = new ReentrantLock();
706	>	final ReentrantLock lock = new ReentrantLock();
707		final Condition c = lock.newCondition();
708	<	Thread t = new Thread(new Runnable() {
708	>	Thread t = new Thread(new Runnable() {
709		public void run() {
710		try {
711		lock.lock();
#	Line 592 | Line 714 | public class ReentrantLockTest extends J
714		c.await();
715		lock.unlock();
716		}
717	<	catch(InterruptedException e) {
717	>	catch (InterruptedException e) {
718		threadUnexpectedException();
719		}
720		}
#	Line 623 | Line 745 | public class ReentrantLockTest extends J
745		* getWaitQueueLength returns number of waiting threads
746		*/
747		public void testGetWaitQueueLength() {
748	<	final ReentrantLock lock = new ReentrantLock();
748	>	final ReentrantLock lock = new ReentrantLock();
749		final Condition c = lock.newCondition();
750	<	Thread t1 = new Thread(new Runnable() {
750	>	Thread t1 = new Thread(new Runnable() {
751		public void run() {
752		try {
753		lock.lock();
#	Line 634 | Line 756 | public class ReentrantLockTest extends J
756		c.await();
757		lock.unlock();
758		}
759	<	catch(InterruptedException e) {
759	>	catch (InterruptedException e) {
760		threadUnexpectedException();
761		}
762		}
763		});
764
765	<	Thread t2 = new Thread(new Runnable() {
765	>	Thread t2 = new Thread(new Runnable() {
766		public void run() {
767		try {
768		lock.lock();
#	Line 649 | Line 771 | public class ReentrantLockTest extends J
771		c.await();
772		lock.unlock();
773		}
774	<	catch(InterruptedException e) {
774	>	catch (InterruptedException e) {
775		threadUnexpectedException();
776		}
777		}
#	Line 684 | Line 806 | public class ReentrantLockTest extends J
806		* getWaitingThreads returns only and all waiting threads
807		*/
808		public void testGetWaitingThreads() {
809	<	final PublicReentrantLock lock = new PublicReentrantLock();
809	>	final PublicReentrantLock lock = new PublicReentrantLock();
810		final Condition c = lock.newCondition();
811	<	Thread t1 = new Thread(new Runnable() {
811	>	Thread t1 = new Thread(new Runnable() {
812		public void run() {
813		try {
814		lock.lock();
#	Line 694 | Line 816 | public class ReentrantLockTest extends J
816		c.await();
817		lock.unlock();
818		}
819	<	catch(InterruptedException e) {
819	>	catch (InterruptedException e) {
820		threadUnexpectedException();
821		}
822		}
823		});
824
825	<	Thread t2 = new Thread(new Runnable() {
825	>	Thread t2 = new Thread(new Runnable() {
826		public void run() {
827		try {
828		lock.lock();
#	Line 708 | Line 830 | public class ReentrantLockTest extends J
830		c.await();
831		lock.unlock();
832		}
833	<	catch(InterruptedException e) {
833	>	catch (InterruptedException e) {
834		threadUnexpectedException();
835		}
836		}
#	Line 743 | Line 865 | public class ReentrantLockTest extends J
865		}
866		}
867
868	+	/** A helper class for uninterruptible wait tests */
869	+	class UninterruptableThread extends Thread {
870	+	private ReentrantLock lock;
871	+	private Condition c;
872	+
873	+	public volatile boolean canAwake = false;
874	+	public volatile boolean interrupted = false;
875	+	public volatile boolean lockStarted = false;
876	+
877	+	public UninterruptableThread(ReentrantLock lock, Condition c) {
878	+	this.lock = lock;
879	+	this.c = c;
880	+	}
881	+
882	+	public synchronized void run() {
883	+	lock.lock();
884	+	lockStarted = true;
885	+
886	+	while (!canAwake) {
887	+	c.awaitUninterruptibly();
888	+	}
889
890	+	interrupted = isInterrupted();
891	+	lock.unlock();
892	+	}
893	+	}
894
895		/**
896		* awaitUninterruptibly doesn't abort on interrupt
897		*/
898		public void testAwaitUninterruptibly() {
899	<	final ReentrantLock lock = new ReentrantLock();
899	>	final ReentrantLock lock = new ReentrantLock();
900		final Condition c = lock.newCondition();
901	<	Thread t = new Thread(new Runnable() {
755	<	public void run() {
756	<	lock.lock();
757	<	c.awaitUninterruptibly();
758	<	lock.unlock();
759	<	}
760	<	});
901	>	UninterruptableThread thread = new UninterruptableThread(lock, c);
902
903		try {
904	<	t.start();
905	<	Thread.sleep(SHORT_DELAY_MS);
906	<	t.interrupt();
904	>	thread.start();
905	>
906	>	while (!thread.lockStarted) {
907	>	Thread.sleep(100);
908	>	}
909	>
910		lock.lock();
911	<	c.signal();
912	<	lock.unlock();
913	<	assert(t.isInterrupted());
914	<	t.join(SHORT_DELAY_MS);
915	<	assertFalse(t.isAlive());
916	<	}
917	<	catch (Exception ex) {
911	>	try {
912	>	thread.interrupt();
913	>	thread.canAwake = true;
914	>	c.signal();
915	>	} finally {
916	>	lock.unlock();
917	>	}
918	>
919	>	thread.join();
920	>	assertTrue(thread.interrupted);
921	>	assertFalse(thread.isAlive());
922	>	} catch (Exception ex) {
923		unexpectedException();
924		}
925		}
#	Line 779 | Line 928 | public class ReentrantLockTest extends J
928		* await is interruptible
929		*/
930		public void testAwait_Interrupt() {
931	<	final ReentrantLock lock = new ReentrantLock();
931	>	final ReentrantLock lock = new ReentrantLock();
932		final Condition c = lock.newCondition();
933	<	Thread t = new Thread(new Runnable() {
933	>	Thread t = new Thread(new Runnable() {
934		public void run() {
935		try {
936		lock.lock();
#	Line 789 | Line 938 | public class ReentrantLockTest extends J
938		lock.unlock();
939		threadShouldThrow();
940		}
941	<	catch(InterruptedException success) {
941	>	catch (InterruptedException success) {
942		}
943		}
944		});
#	Line 810 | Line 959 | public class ReentrantLockTest extends J
959		* awaitNanos is interruptible
960		*/
961		public void testAwaitNanos_Interrupt() {
962	<	final ReentrantLock lock = new ReentrantLock();
962	>	final ReentrantLock lock = new ReentrantLock();
963		final Condition c = lock.newCondition();
964	<	Thread t = new Thread(new Runnable() {
964	>	Thread t = new Thread(new Runnable() {
965		public void run() {
966		try {
967		lock.lock();
968	<	c.awaitNanos(SHORT_DELAY_MS * 2 * 1000000);
968	>	c.awaitNanos(1000 * 1000 * 1000); // 1 sec
969		lock.unlock();
970		threadShouldThrow();
971		}
972	<	catch(InterruptedException success) {
972	>	catch (InterruptedException success) {
973		}
974		}
975		});
#	Line 841 | Line 990 | public class ReentrantLockTest extends J
990		* awaitUntil is interruptible
991		*/
992		public void testAwaitUntil_Interrupt() {
993	<	final ReentrantLock lock = new ReentrantLock();
993	>	final ReentrantLock lock = new ReentrantLock();
994		final Condition c = lock.newCondition();
995	<	Thread t = new Thread(new Runnable() {
995	>	Thread t = new Thread(new Runnable() {
996		public void run() {
997		try {
998		lock.lock();
#	Line 852 | Line 1001 | public class ReentrantLockTest extends J
1001		lock.unlock();
1002		threadShouldThrow();
1003		}
1004	<	catch(InterruptedException success) {
1004	>	catch (InterruptedException success) {
1005		}
1006		}
1007		});
#	Line 873 | Line 1022 | public class ReentrantLockTest extends J
1022		* signalAll wakes up all threads
1023		*/
1024		public void testSignalAll() {
1025	<	final ReentrantLock lock = new ReentrantLock();
1025	>	final ReentrantLock lock = new ReentrantLock();
1026		final Condition c = lock.newCondition();
1027	<	Thread t1 = new Thread(new Runnable() {
1027	>	Thread t1 = new Thread(new Runnable() {
1028		public void run() {
1029		try {
1030		lock.lock();
1031		c.await();
1032		lock.unlock();
1033		}
1034	<	catch(InterruptedException e) {
1034	>	catch (InterruptedException e) {
1035		threadUnexpectedException();
1036		}
1037		}
1038		});
1039
1040	<	Thread t2 = new Thread(new Runnable() {
1040	>	Thread t2 = new Thread(new Runnable() {
1041		public void run() {
1042		try {
1043		lock.lock();
1044		c.await();
1045		lock.unlock();
1046		}
1047	<	catch(InterruptedException e) {
1047	>	catch (InterruptedException e) {
1048	>	threadUnexpectedException();
1049	>	}
1050	>	}
1051	>	});
1052	>
1053	>	try {
1054	>	t1.start();
1055	>	t2.start();
1056	>	Thread.sleep(SHORT_DELAY_MS);
1057	>	lock.lock();
1058	>	c.signalAll();
1059	>	lock.unlock();
1060	>	t1.join(SHORT_DELAY_MS);
1061	>	t2.join(SHORT_DELAY_MS);
1062	>	assertFalse(t1.isAlive());
1063	>	assertFalse(t2.isAlive());
1064	>	}
1065	>	catch (Exception ex) {
1066	>	unexpectedException();
1067	>	}
1068	>	}
1069	>
1070	>	/**
1071	>	* await after multiple reentrant locking preserves lock count
1072	>	*/
1073	>	public void testAwaitLockCount() {
1074	>	final ReentrantLock lock = new ReentrantLock();
1075	>	final Condition c = lock.newCondition();
1076	>	Thread t1 = new Thread(new Runnable() {
1077	>	public void run() {
1078	>	try {
1079	>	lock.lock();
1080	>	threadAssertEquals(1, lock.getHoldCount());
1081	>	c.await();
1082	>	threadAssertEquals(1, lock.getHoldCount());
1083	>	lock.unlock();
1084	>	}
1085	>	catch (InterruptedException e) {
1086	>	threadUnexpectedException();
1087	>	}
1088	>	}
1089	>	});
1090	>
1091	>	Thread t2 = new Thread(new Runnable() {
1092	>	public void run() {
1093	>	try {
1094	>	lock.lock();
1095	>	lock.lock();
1096	>	threadAssertEquals(2, lock.getHoldCount());
1097	>	c.await();
1098	>	threadAssertEquals(2, lock.getHoldCount());
1099	>	lock.unlock();
1100	>	lock.unlock();
1101	>	}
1102	>	catch (InterruptedException e) {
1103		threadUnexpectedException();
1104		}
1105		}
#	Line 937 | Line 1141 | public class ReentrantLockTest extends J
1141		ReentrantLock r = (ReentrantLock) in.readObject();
1142		r.lock();
1143		r.unlock();
1144	<	} catch(Exception e){
1144	>	} catch (Exception e){
1145		e.printStackTrace();
1146		unexpectedException();
1147		}
1148		}
1149
1150	+	/**
1151	+	* toString indicates current lock state
1152	+	*/
1153	+	public void testToString() {
1154	+	ReentrantLock lock = new ReentrantLock();
1155	+	String us = lock.toString();
1156	+	assertTrue(us.indexOf("Unlocked") >= 0);
1157	+	lock.lock();
1158	+	String ls = lock.toString();
1159	+	assertTrue(ls.indexOf("Locked") >= 0);
1160	+	}
1161	+
1162		}

Diff Legend

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