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.29 by jsr166, Tue Nov 17 13:31:53 2009 UTC vs.
Revision 1.42 by jsr166, Sat May 7 03:12:48 2011 UTC

#	Line 1 | Line 1
1		/*
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
4	>	* http://creativecommons.org/publicdomain/zero/1.0/
5		* Other contributors include Andrew Wright, Jeffrey Hayes,
6		* Pat Fisher, Mike Judd.
7		*/
#	Line 9 | Line 9
9		import junit.framework.*;
10		import java.util.concurrent.locks.*;
11		import java.util.concurrent.*;
12	+	import static java.util.concurrent.TimeUnit.MILLISECONDS;
13		import java.util.*;
14		import java.io.*;
15
16		public class ReentrantLockTest extends JSR166TestCase {
17		public static void main(String[] args) {
18	<	junit.textui.TestRunner.run (suite());
18	>	junit.textui.TestRunner.run(suite());
19		}
20		public static Test suite() {
21	<	return new TestSuite(ReentrantLockTest.class);
21	>	return new TestSuite(ReentrantLockTest.class);
22		}
23
24		/**
#	Line 55 | Line 56 | public class ReentrantLockTest extends J
56		public Collection<Thread> getWaitingThreads(Condition c) {
57		return super.getWaitingThreads(c);
58		}
58	–
59	–
59		}
60
61		/**
#	Line 72 | Line 71 | public class ReentrantLockTest extends J
71		* locking an unlocked lock succeeds
72		*/
73		public void testLock() {
74	<	ReentrantLock rl = new ReentrantLock();
74	>	ReentrantLock rl = new ReentrantLock();
75		rl.lock();
76		assertTrue(rl.isLocked());
77		rl.unlock();
#	Line 83 | Line 82 | public class ReentrantLockTest extends J
82		* locking an unlocked fair lock succeeds
83		*/
84		public void testFairLock() {
85	<	ReentrantLock rl = new ReentrantLock(true);
85	>	ReentrantLock rl = new ReentrantLock(true);
86		rl.lock();
87		assertTrue(rl.isLocked());
88		rl.unlock();
#	Line 93 | Line 92 | public class ReentrantLockTest extends J
92		* Unlocking an unlocked lock throws IllegalMonitorStateException
93		*/
94		public void testUnlock_IllegalMonitorStateException() {
95	<	ReentrantLock rl = new ReentrantLock();
96	<	try {
97	<	rl.unlock();
98	<	shouldThrow();
99	<	} catch (IllegalMonitorStateException success) {}
95	>	ReentrantLock rl = new ReentrantLock();
96	>	try {
97	>	rl.unlock();
98	>	shouldThrow();
99	>	} catch (IllegalMonitorStateException success) {}
100		}
101
102		/**
103		* tryLock on an unlocked lock succeeds
104		*/
105		public void testTryLock() {
106	<	ReentrantLock rl = new ReentrantLock();
106	>	ReentrantLock rl = new ReentrantLock();
107		assertTrue(rl.tryLock());
108		assertTrue(rl.isLocked());
109		rl.unlock();
#	Line 115 | Line 114 | public class ReentrantLockTest extends J
114		* hasQueuedThreads reports whether there are waiting threads
115		*/
116		public void testhasQueuedThreads() throws InterruptedException {
117	<	final ReentrantLock lock = new ReentrantLock();
117	>	final ReentrantLock lock = new ReentrantLock();
118		Thread t1 = new Thread(new InterruptedLockRunnable(lock));
119		Thread t2 = new Thread(new InterruptibleLockRunnable(lock));
120		assertFalse(lock.hasQueuedThreads());
121		lock.lock();
122		t1.start();
123	<	Thread.sleep(SHORT_DELAY_MS);
123	>	delay(SHORT_DELAY_MS);
124		assertTrue(lock.hasQueuedThreads());
125		t2.start();
126	<	Thread.sleep(SHORT_DELAY_MS);
126	>	delay(SHORT_DELAY_MS);
127		assertTrue(lock.hasQueuedThreads());
128		t1.interrupt();
129	<	Thread.sleep(SHORT_DELAY_MS);
129	>	delay(SHORT_DELAY_MS);
130		assertTrue(lock.hasQueuedThreads());
131		lock.unlock();
132	<	Thread.sleep(SHORT_DELAY_MS);
132	>	delay(SHORT_DELAY_MS);
133		assertFalse(lock.hasQueuedThreads());
134	<	t1.join();
135	<	t2.join();
134	>	awaitTermination(t1);
135	>	awaitTermination(t2);
136		}
137
138		/**
139		* getQueueLength reports number of waiting threads
140		*/
141		public void testGetQueueLength() throws InterruptedException {
142	<	final ReentrantLock lock = new ReentrantLock();
142	>	final ReentrantLock lock = new ReentrantLock();
143		Thread t1 = new Thread(new InterruptedLockRunnable(lock));
144		Thread t2 = new Thread(new InterruptibleLockRunnable(lock));
145		assertEquals(0, lock.getQueueLength());
146		lock.lock();
147		t1.start();
148	<	Thread.sleep(SHORT_DELAY_MS);
148	>	delay(SHORT_DELAY_MS);
149		assertEquals(1, lock.getQueueLength());
150		t2.start();
151	<	Thread.sleep(SHORT_DELAY_MS);
151	>	delay(SHORT_DELAY_MS);
152		assertEquals(2, lock.getQueueLength());
153		t1.interrupt();
154	<	Thread.sleep(SHORT_DELAY_MS);
154	>	delay(SHORT_DELAY_MS);
155		assertEquals(1, lock.getQueueLength());
156		lock.unlock();
157	<	Thread.sleep(SHORT_DELAY_MS);
157	>	delay(SHORT_DELAY_MS);
158		assertEquals(0, lock.getQueueLength());
159	<	t1.join();
160	<	t2.join();
159	>	awaitTermination(t1);
160	>	awaitTermination(t2);
161		}
162
163		/**
164		* getQueueLength reports number of waiting threads
165		*/
166		public void testGetQueueLength_fair() throws InterruptedException {
167	<	final ReentrantLock lock = new ReentrantLock(true);
167	>	final ReentrantLock lock = new ReentrantLock(true);
168		Thread t1 = new Thread(new InterruptedLockRunnable(lock));
169		Thread t2 = new Thread(new InterruptibleLockRunnable(lock));
170		assertEquals(0, lock.getQueueLength());
171		lock.lock();
172		t1.start();
173	<	Thread.sleep(SHORT_DELAY_MS);
173	>	delay(SHORT_DELAY_MS);
174		assertEquals(1, lock.getQueueLength());
175		t2.start();
176	<	Thread.sleep(SHORT_DELAY_MS);
176	>	delay(SHORT_DELAY_MS);
177		assertEquals(2, lock.getQueueLength());
178		t1.interrupt();
179	<	Thread.sleep(SHORT_DELAY_MS);
179	>	delay(SHORT_DELAY_MS);
180		assertEquals(1, lock.getQueueLength());
181		lock.unlock();
182	<	Thread.sleep(SHORT_DELAY_MS);
182	>	delay(SHORT_DELAY_MS);
183		assertEquals(0, lock.getQueueLength());
184	<	t1.join();
185	<	t2.join();
184	>	awaitTermination(t1);
185	>	awaitTermination(t2);
186		}
187
188		/**
189		* hasQueuedThread(null) throws NPE
190		*/
191		public void testHasQueuedThreadNPE() {
192	<	final ReentrantLock sync = new ReentrantLock();
192	>	final ReentrantLock sync = new ReentrantLock();
193		try {
194		sync.hasQueuedThread(null);
195		shouldThrow();
#	Line 201 | Line 200 | public class ReentrantLockTest extends J
200		* hasQueuedThread reports whether a thread is queued.
201		*/
202		public void testHasQueuedThread() throws InterruptedException {
203	<	final ReentrantLock sync = new ReentrantLock();
203	>	final ReentrantLock sync = new ReentrantLock();
204		Thread t1 = new Thread(new InterruptedLockRunnable(sync));
205		Thread t2 = new Thread(new InterruptibleLockRunnable(sync));
206		assertFalse(sync.hasQueuedThread(t1));
207		assertFalse(sync.hasQueuedThread(t2));
208		sync.lock();
209		t1.start();
210	<	Thread.sleep(SHORT_DELAY_MS);
210	>	delay(SHORT_DELAY_MS);
211		assertTrue(sync.hasQueuedThread(t1));
212		t2.start();
213	<	Thread.sleep(SHORT_DELAY_MS);
213	>	delay(SHORT_DELAY_MS);
214		assertTrue(sync.hasQueuedThread(t1));
215		assertTrue(sync.hasQueuedThread(t2));
216		t1.interrupt();
217	<	Thread.sleep(SHORT_DELAY_MS);
217	>	delay(SHORT_DELAY_MS);
218		assertFalse(sync.hasQueuedThread(t1));
219		assertTrue(sync.hasQueuedThread(t2));
220		sync.unlock();
221	<	Thread.sleep(SHORT_DELAY_MS);
221	>	delay(SHORT_DELAY_MS);
222		assertFalse(sync.hasQueuedThread(t1));
223	<	Thread.sleep(SHORT_DELAY_MS);
223	>	delay(SHORT_DELAY_MS);
224		assertFalse(sync.hasQueuedThread(t2));
225	<	t1.join();
226	<	t2.join();
225	>	awaitTermination(t1);
226	>	awaitTermination(t2);
227		}
228
229
#	Line 232 | Line 231 | public class ReentrantLockTest extends J
231		* getQueuedThreads includes waiting threads
232		*/
233		public void testGetQueuedThreads() throws InterruptedException {
234	<	final PublicReentrantLock lock = new PublicReentrantLock();
234	>	final PublicReentrantLock lock = new PublicReentrantLock();
235		Thread t1 = new Thread(new InterruptedLockRunnable(lock));
236		Thread t2 = new Thread(new InterruptibleLockRunnable(lock));
237		assertTrue(lock.getQueuedThreads().isEmpty());
238		lock.lock();
239		assertTrue(lock.getQueuedThreads().isEmpty());
240		t1.start();
241	<	Thread.sleep(SHORT_DELAY_MS);
241	>	delay(SHORT_DELAY_MS);
242		assertTrue(lock.getQueuedThreads().contains(t1));
243		t2.start();
244	<	Thread.sleep(SHORT_DELAY_MS);
244	>	delay(SHORT_DELAY_MS);
245		assertTrue(lock.getQueuedThreads().contains(t1));
246		assertTrue(lock.getQueuedThreads().contains(t2));
247		t1.interrupt();
248	<	Thread.sleep(SHORT_DELAY_MS);
248	>	delay(SHORT_DELAY_MS);
249		assertFalse(lock.getQueuedThreads().contains(t1));
250		assertTrue(lock.getQueuedThreads().contains(t2));
251		lock.unlock();
252	<	Thread.sleep(SHORT_DELAY_MS);
252	>	delay(SHORT_DELAY_MS);
253		assertTrue(lock.getQueuedThreads().isEmpty());
254	<	t1.join();
255	<	t2.join();
254	>	awaitTermination(t1);
255	>	awaitTermination(t2);
256		}
257
258
#	Line 261 | Line 260 | public class ReentrantLockTest extends J
260		* timed tryLock is interruptible.
261		*/
262		public void testInterruptedException2() throws InterruptedException {
263	<	final ReentrantLock lock = new ReentrantLock();
264	<	lock.lock();
265	<	Thread t = new Thread(new CheckedInterruptedRunnable() {
263	>	final ReentrantLock lock = new ReentrantLock();
264	>	lock.lock();
265	>	Thread t = newStartedThread(new CheckedInterruptedRunnable() {
266		public void realRun() throws InterruptedException {
267	<	lock.tryLock(MEDIUM_DELAY_MS,TimeUnit.MILLISECONDS);
267	>	lock.tryLock(MEDIUM_DELAY_MS,MILLISECONDS);
268		}});
269
270	<	t.start();
270	>	delay(SHORT_DELAY_MS);
271		t.interrupt();
272	<	t.join();
272	>	awaitTermination(t);
273		}
274
275
#	Line 278 | Line 277 | public class ReentrantLockTest extends J
277		* TryLock on a locked lock fails
278		*/
279		public void testTryLockWhenLocked() throws InterruptedException {
280	<	final ReentrantLock lock = new ReentrantLock();
281	<	lock.lock();
282	<	Thread t = new Thread(new CheckedRunnable() {
280	>	final ReentrantLock lock = new ReentrantLock();
281	>	lock.lock();
282	>	Thread t = newStartedThread(new CheckedRunnable() {
283		public void realRun() {
284	<	threadAssertFalse(lock.tryLock());
284	>	assertFalse(lock.tryLock());
285		}});
286
287	<	t.start();
289	<	t.join();
287	>	awaitTermination(t);
288		lock.unlock();
289		}
290
#	Line 294 | Line 292 | public class ReentrantLockTest extends J
292		* Timed tryLock on a locked lock times out
293		*/
294		public void testTryLock_Timeout() throws InterruptedException {
295	<	final ReentrantLock lock = new ReentrantLock();
296	<	lock.lock();
297	<	Thread t = new Thread(new CheckedRunnable() {
295	>	final ReentrantLock lock = new ReentrantLock();
296	>	lock.lock();
297	>	Thread t = newStartedThread(new CheckedRunnable() {
298		public void realRun() throws InterruptedException {
299	<	threadAssertFalse(lock.tryLock(1, TimeUnit.MILLISECONDS));
299	>	assertFalse(lock.tryLock(1, MILLISECONDS));
300		}});
301
302	<	t.start();
305	<	t.join();
302	>	awaitTermination(t);
303		lock.unlock();
304		}
305
#	Line 310 | Line 307 | public class ReentrantLockTest extends J
307		* getHoldCount returns number of recursive holds
308		*/
309		public void testGetHoldCount() {
310	<	ReentrantLock lock = new ReentrantLock();
311	<	for (int i = 1; i <= SIZE; i++) {
312	<	lock.lock();
313	<	assertEquals(i, lock.getHoldCount());
314	<	}
315	<	for (int i = SIZE; i > 0; i--) {
316	<	lock.unlock();
317	<	assertEquals(i-1, lock.getHoldCount());
318	<	}
310	>	ReentrantLock lock = new ReentrantLock();
311	>	for (int i = 1; i <= SIZE; i++) {
312	>	lock.lock();
313	>	assertEquals(i, lock.getHoldCount());
314	>	}
315	>	for (int i = SIZE; i > 0; i--) {
316	>	lock.unlock();
317	>	assertEquals(i-1, lock.getHoldCount());
318	>	}
319		}
320
321
#	Line 326 | Line 323 | public class ReentrantLockTest extends J
323		* isLocked is true when locked and false when not
324		*/
325		public void testIsLocked() throws InterruptedException {
326	<	final ReentrantLock lock = new ReentrantLock();
327	<	lock.lock();
328	<	assertTrue(lock.isLocked());
329	<	lock.unlock();
330	<	assertFalse(lock.isLocked());
331	<	Thread t = new Thread(new CheckedRunnable() {
326	>	final ReentrantLock lock = new ReentrantLock();
327	>	lock.lock();
328	>	assertTrue(lock.isLocked());
329	>	lock.unlock();
330	>	assertFalse(lock.isLocked());
331	>	Thread t = newStartedThread(new CheckedRunnable() {
332		public void realRun() throws InterruptedException {
333		lock.lock();
334	<	Thread.sleep(SMALL_DELAY_MS);
334	>	delay(SMALL_DELAY_MS);
335		lock.unlock();
336		}});
337
338	<	t.start();
342	<	Thread.sleep(SHORT_DELAY_MS);
338	>	delay(SHORT_DELAY_MS);
339		assertTrue(lock.isLocked());
340	<	t.join();
340	>	awaitTermination(t);
341		assertFalse(lock.isLocked());
342		}
343
#	Line 350 | Line 346 | public class ReentrantLockTest extends J
346		* lockInterruptibly is interruptible.
347		*/
348		public void testLockInterruptibly1() throws InterruptedException {
349	<	final ReentrantLock lock = new ReentrantLock();
350	<	lock.lock();
351	<	Thread t = new Thread(new InterruptedLockRunnable(lock));
352	<	t.start();
357	<	Thread.sleep(SHORT_DELAY_MS);
349	>	final ReentrantLock lock = new ReentrantLock();
350	>	lock.lock();
351	>	Thread t = newStartedThread(new InterruptedLockRunnable(lock));
352	>	delay(SHORT_DELAY_MS);
353		t.interrupt();
354	<	Thread.sleep(SHORT_DELAY_MS);
354	>	delay(SHORT_DELAY_MS);
355		lock.unlock();
356	<	t.join();
356	>	awaitTermination(t);
357		}
358
359		/**
360		* lockInterruptibly succeeds when unlocked, else is interruptible
361		*/
362		public void testLockInterruptibly2() throws InterruptedException {
363	<	final ReentrantLock lock = new ReentrantLock();
363	>	final ReentrantLock lock = new ReentrantLock();
364		lock.lockInterruptibly();
365	<	Thread t = new Thread(new InterruptedLockRunnable(lock));
366	<	t.start();
365	>	Thread t = newStartedThread(new InterruptedLockRunnable(lock));
366	>	delay(SHORT_DELAY_MS);
367		t.interrupt();
368		assertTrue(lock.isLocked());
369		assertTrue(lock.isHeldByCurrentThread());
370	<	t.join();
370	>	awaitTermination(t);
371		}
372
373		/**
374		* Calling await without holding lock throws IllegalMonitorStateException
375		*/
376		public void testAwait_IllegalMonitor() throws InterruptedException {
377	<	final ReentrantLock lock = new ReentrantLock();
377	>	final ReentrantLock lock = new ReentrantLock();
378		final Condition c = lock.newCondition();
379		try {
380		c.await();
#	Line 391 | Line 386 | public class ReentrantLockTest extends J
386		* Calling signal without holding lock throws IllegalMonitorStateException
387		*/
388		public void testSignal_IllegalMonitor() {
389	<	final ReentrantLock lock = new ReentrantLock();
389	>	final ReentrantLock lock = new ReentrantLock();
390		final Condition c = lock.newCondition();
391		try {
392		c.signal();
#	Line 403 | Line 398 | public class ReentrantLockTest extends J
398		* awaitNanos without a signal times out
399		*/
400		public void testAwaitNanos_Timeout() throws InterruptedException {
401	<	final ReentrantLock lock = new ReentrantLock();
401	>	final ReentrantLock lock = new ReentrantLock();
402		final Condition c = lock.newCondition();
403		lock.lock();
404		long t = c.awaitNanos(100);
#	Line 412 | Line 407 | public class ReentrantLockTest extends J
407		}
408
409		/**
410	<	*  timed await without a signal times out
410	>	* timed await without a signal times out
411		*/
412		public void testAwait_Timeout() throws InterruptedException {
413	<	final ReentrantLock lock = new ReentrantLock();
413	>	final ReentrantLock lock = new ReentrantLock();
414		final Condition c = lock.newCondition();
415		lock.lock();
416	<	assertFalse(c.await(SHORT_DELAY_MS, TimeUnit.MILLISECONDS));
416	>	assertFalse(c.await(SHORT_DELAY_MS, MILLISECONDS));
417		lock.unlock();
418		}
419
#	Line 426 | Line 421 | public class ReentrantLockTest extends J
421		* awaitUntil without a signal times out
422		*/
423		public void testAwaitUntil_Timeout() throws InterruptedException {
424	<	final ReentrantLock lock = new ReentrantLock();
424	>	final ReentrantLock lock = new ReentrantLock();
425		final Condition c = lock.newCondition();
426		lock.lock();
427		java.util.Date d = new java.util.Date();
#	Line 438 | Line 433 | public class ReentrantLockTest extends J
433		* await returns when signalled
434		*/
435		public void testAwait() throws InterruptedException {
436	<	final ReentrantLock lock = new ReentrantLock();
436	>	final ReentrantLock lock = new ReentrantLock();
437		final Condition c = lock.newCondition();
438	<	Thread t = new Thread(new CheckedRunnable() {
438	>	Thread t = newStartedThread(new CheckedRunnable() {
439		public void realRun() throws InterruptedException {
440		lock.lock();
441		c.await();
442		lock.unlock();
443		}});
444
445	<	t.start();
451	<	Thread.sleep(SHORT_DELAY_MS);
445	>	delay(SHORT_DELAY_MS);
446		lock.lock();
447		c.signal();
448		lock.unlock();
449	<	t.join(SHORT_DELAY_MS);
456	<	assertFalse(t.isAlive());
449	>	awaitTermination(t);
450		}
451
452		/**
453		* hasWaiters throws NPE if null
454		*/
455		public void testHasWaitersNPE() {
456	<	final ReentrantLock lock = new ReentrantLock();
456	>	final ReentrantLock lock = new ReentrantLock();
457		try {
458		lock.hasWaiters(null);
459		shouldThrow();
#	Line 471 | Line 464 | public class ReentrantLockTest extends J
464		* getWaitQueueLength throws NPE if null
465		*/
466		public void testGetWaitQueueLengthNPE() {
467	<	final ReentrantLock lock = new ReentrantLock();
467	>	final ReentrantLock lock = new ReentrantLock();
468		try {
469		lock.getWaitQueueLength(null);
470		shouldThrow();
#	Line 483 | Line 476 | public class ReentrantLockTest extends J
476		* getWaitingThreads throws NPE if null
477		*/
478		public void testGetWaitingThreadsNPE() {
479	<	final PublicReentrantLock lock = new PublicReentrantLock();
479	>	final PublicReentrantLock lock = new PublicReentrantLock();
480		try {
481		lock.getWaitingThreads(null);
482		shouldThrow();
#	Line 495 | Line 488 | public class ReentrantLockTest extends J
488		* hasWaiters throws IAE if not owned
489		*/
490		public void testHasWaitersIAE() {
491	<	final ReentrantLock lock = new ReentrantLock();
491	>	final ReentrantLock lock = new ReentrantLock();
492		final Condition c = lock.newCondition();
493	<	final ReentrantLock lock2 = new ReentrantLock();
493	>	final ReentrantLock lock2 = new ReentrantLock();
494		try {
495		lock2.hasWaiters(c);
496		shouldThrow();
#	Line 508 | Line 501 | public class ReentrantLockTest extends J
501		* hasWaiters throws IMSE if not locked
502		*/
503		public void testHasWaitersIMSE() {
504	<	final ReentrantLock lock = new ReentrantLock();
504	>	final ReentrantLock lock = new ReentrantLock();
505		final Condition c = lock.newCondition();
506		try {
507		lock.hasWaiters(c);
#	Line 521 | Line 514 | public class ReentrantLockTest extends J
514		* getWaitQueueLength throws IAE if not owned
515		*/
516		public void testGetWaitQueueLengthIAE() {
517	<	final ReentrantLock lock = new ReentrantLock();
517	>	final ReentrantLock lock = new ReentrantLock();
518		final Condition c = lock.newCondition();
519	<	final ReentrantLock lock2 = new ReentrantLock();
519	>	final ReentrantLock lock2 = new ReentrantLock();
520		try {
521		lock2.getWaitQueueLength(c);
522		shouldThrow();
#	Line 534 | Line 527 | public class ReentrantLockTest extends J
527		* getWaitQueueLength throws IMSE if not locked
528		*/
529		public void testGetWaitQueueLengthIMSE() {
530	<	final ReentrantLock lock = new ReentrantLock();
530	>	final ReentrantLock lock = new ReentrantLock();
531		final Condition c = lock.newCondition();
532		try {
533		lock.getWaitQueueLength(c);
#	Line 547 | Line 540 | public class ReentrantLockTest extends J
540		* getWaitingThreads throws IAE if not owned
541		*/
542		public void testGetWaitingThreadsIAE() {
543	<	final PublicReentrantLock lock = new PublicReentrantLock();
543	>	final PublicReentrantLock lock = new PublicReentrantLock();
544		final Condition c = lock.newCondition();
545	<	final PublicReentrantLock lock2 = new PublicReentrantLock();
545	>	final PublicReentrantLock lock2 = new PublicReentrantLock();
546		try {
547		lock2.getWaitingThreads(c);
548		shouldThrow();
#	Line 560 | Line 553 | public class ReentrantLockTest extends J
553		* getWaitingThreads throws IMSE if not locked
554		*/
555		public void testGetWaitingThreadsIMSE() {
556	<	final PublicReentrantLock lock = new PublicReentrantLock();
556	>	final PublicReentrantLock lock = new PublicReentrantLock();
557		final Condition c = lock.newCondition();
558		try {
559		lock.getWaitingThreads(c);
#	Line 573 | Line 566 | public class ReentrantLockTest extends J
566		* hasWaiters returns true when a thread is waiting, else false
567		*/
568		public void testHasWaiters() throws InterruptedException {
569	<	final ReentrantLock lock = new ReentrantLock();
569	>	final ReentrantLock lock = new ReentrantLock();
570		final Condition c = lock.newCondition();
571	<	Thread t = new Thread(new CheckedRunnable() {
571	>	Thread t = newStartedThread(new CheckedRunnable() {
572		public void realRun() throws InterruptedException {
573		lock.lock();
574	<	threadAssertFalse(lock.hasWaiters(c));
575	<	threadAssertEquals(0, lock.getWaitQueueLength(c));
574	>	assertFalse(lock.hasWaiters(c));
575	>	assertEquals(0, lock.getWaitQueueLength(c));
576		c.await();
577		lock.unlock();
578		}});
579
580	<	t.start();
588	<	Thread.sleep(SHORT_DELAY_MS);
580	>	delay(SHORT_DELAY_MS);
581		lock.lock();
582		assertTrue(lock.hasWaiters(c));
583		assertEquals(1, lock.getWaitQueueLength(c));
584		c.signal();
585		lock.unlock();
586	<	Thread.sleep(SHORT_DELAY_MS);
586	>	delay(SHORT_DELAY_MS);
587		lock.lock();
588		assertFalse(lock.hasWaiters(c));
589		assertEquals(0, lock.getWaitQueueLength(c));
590		lock.unlock();
591	<	t.join(SHORT_DELAY_MS);
600	<	assertFalse(t.isAlive());
591	>	awaitTermination(t);
592		}
593
594		/**
595		* getWaitQueueLength returns number of waiting threads
596		*/
597		public void testGetWaitQueueLength() throws InterruptedException {
598	<	final ReentrantLock lock = new ReentrantLock();
598	>	final ReentrantLock lock = new ReentrantLock();
599		final Condition c = lock.newCondition();
600	<	Thread t1 = new Thread(new CheckedRunnable() {
600	>	Thread t1 = newStartedThread(new CheckedRunnable() {
601		public void realRun() throws InterruptedException {
602		lock.lock();
603	<	threadAssertFalse(lock.hasWaiters(c));
604	<	threadAssertEquals(0, lock.getWaitQueueLength(c));
603	>	assertFalse(lock.hasWaiters(c));
604	>	assertEquals(0, lock.getWaitQueueLength(c));
605		c.await();
606		lock.unlock();
607		}});
608
609	<	Thread t2 = new Thread(new CheckedRunnable() {
609	>	delay(SHORT_DELAY_MS);
610	>
611	>	Thread t2 = newStartedThread(new CheckedRunnable() {
612		public void realRun() throws InterruptedException {
613		lock.lock();
614	<	threadAssertTrue(lock.hasWaiters(c));
615	<	threadAssertEquals(1, lock.getWaitQueueLength(c));
614	>	assertTrue(lock.hasWaiters(c));
615	>	assertEquals(1, lock.getWaitQueueLength(c));
616		c.await();
617		lock.unlock();
618		}});
619
620	<	t1.start();
628	<	Thread.sleep(SHORT_DELAY_MS);
629	<	t2.start();
630	<	Thread.sleep(SHORT_DELAY_MS);
620	>	delay(SHORT_DELAY_MS);
621		lock.lock();
622		assertTrue(lock.hasWaiters(c));
623		assertEquals(2, lock.getWaitQueueLength(c));
624		c.signalAll();
625		lock.unlock();
626	<	Thread.sleep(SHORT_DELAY_MS);
626	>	delay(SHORT_DELAY_MS);
627		lock.lock();
628		assertFalse(lock.hasWaiters(c));
629		assertEquals(0, lock.getWaitQueueLength(c));
630		lock.unlock();
631	<	t1.join(SHORT_DELAY_MS);
632	<	t2.join(SHORT_DELAY_MS);
643	<	assertFalse(t1.isAlive());
644	<	assertFalse(t2.isAlive());
631	>	awaitTermination(t1);
632	>	awaitTermination(t2);
633		}
634
635		/**
636		* getWaitingThreads returns only and all waiting threads
637		*/
638		public void testGetWaitingThreads() throws InterruptedException {
639	<	final PublicReentrantLock lock = new PublicReentrantLock();
639	>	final PublicReentrantLock lock = new PublicReentrantLock();
640		final Condition c = lock.newCondition();
641	<	Thread t1 = new Thread(new CheckedRunnable() {
641	>	Thread t1 = new Thread(new CheckedRunnable() {
642		public void realRun() throws InterruptedException {
643		lock.lock();
644	<	threadAssertTrue(lock.getWaitingThreads(c).isEmpty());
644	>	assertTrue(lock.getWaitingThreads(c).isEmpty());
645		c.await();
646		lock.unlock();
647		}});
648
649	<	Thread t2 = new Thread(new CheckedRunnable() {
649	>	Thread t2 = new Thread(new CheckedRunnable() {
650		public void realRun() throws InterruptedException {
651		lock.lock();
652	<	threadAssertFalse(lock.getWaitingThreads(c).isEmpty());
652	>	assertFalse(lock.getWaitingThreads(c).isEmpty());
653		c.await();
654		lock.unlock();
655		}});
#	Line 670 | Line 658 | public class ReentrantLockTest extends J
658		assertTrue(lock.getWaitingThreads(c).isEmpty());
659		lock.unlock();
660		t1.start();
661	<	Thread.sleep(SHORT_DELAY_MS);
661	>	delay(SHORT_DELAY_MS);
662		t2.start();
663	<	Thread.sleep(SHORT_DELAY_MS);
663	>	delay(SHORT_DELAY_MS);
664		lock.lock();
665		assertTrue(lock.hasWaiters(c));
666		assertTrue(lock.getWaitingThreads(c).contains(t1));
667		assertTrue(lock.getWaitingThreads(c).contains(t2));
668		c.signalAll();
669		lock.unlock();
670	<	Thread.sleep(SHORT_DELAY_MS);
670	>	delay(SHORT_DELAY_MS);
671		lock.lock();
672		assertFalse(lock.hasWaiters(c));
673		assertTrue(lock.getWaitingThreads(c).isEmpty());
674		lock.unlock();
675	<	t1.join(SHORT_DELAY_MS);
676	<	t2.join(SHORT_DELAY_MS);
689	<	assertFalse(t1.isAlive());
690	<	assertFalse(t2.isAlive());
675	>	awaitTermination(t1);
676	>	awaitTermination(t2);
677		}
678
679		/** A helper class for uninterruptible wait tests */
#	Line 728 | Line 714 | public class ReentrantLockTest extends J
714		thread.start();
715
716		while (!thread.lockStarted) {
717	<	Thread.sleep(100);
717	>	delay(100);
718		}
719
720		lock.lock();
#	Line 749 | Line 735 | public class ReentrantLockTest extends J
735		* await is interruptible
736		*/
737		public void testAwait_Interrupt() throws InterruptedException {
738	<	final ReentrantLock lock = new ReentrantLock();
738	>	final ReentrantLock lock = new ReentrantLock();
739		final Condition c = lock.newCondition();
740	<	Thread t = new Thread(new CheckedInterruptedRunnable() {
741	<	public void realRun() throws InterruptedException {
740	>	Thread t = newStartedThread(new CheckedInterruptedRunnable() {
741	>	public void realRun() throws InterruptedException {
742		lock.lock();
743		c.await();
744		}});
745
746	<	t.start();
761	<	Thread.sleep(SHORT_DELAY_MS);
746	>	delay(SHORT_DELAY_MS);
747		t.interrupt();
748	<	t.join(SHORT_DELAY_MS);
764	<	assertFalse(t.isAlive());
748	>	awaitTermination(t);
749		}
750
751		/**
752		* awaitNanos is interruptible
753		*/
754		public void testAwaitNanos_Interrupt() throws InterruptedException {
755	<	final ReentrantLock lock = new ReentrantLock();
755	>	final ReentrantLock lock = new ReentrantLock();
756		final Condition c = lock.newCondition();
757	<	Thread t = new Thread(new CheckedInterruptedRunnable() {
758	<	public void realRun() throws InterruptedException {
757	>	Thread t = newStartedThread(new CheckedInterruptedRunnable() {
758	>	public void realRun() throws InterruptedException {
759		lock.lock();
760	<	c.awaitNanos(1000 * 1000 * 1000); // 1 sec
760	>	c.awaitNanos(MILLISECONDS.toNanos(LONG_DELAY_MS));
761		}});
762
763	<	t.start();
780	<	Thread.sleep(SHORT_DELAY_MS);
763	>	delay(SHORT_DELAY_MS);
764		t.interrupt();
765	<	t.join(SHORT_DELAY_MS);
783	<	assertFalse(t.isAlive());
765	>	awaitTermination(t);
766		}
767
768		/**
769		* awaitUntil is interruptible
770		*/
771		public void testAwaitUntil_Interrupt() throws InterruptedException {
772	<	final ReentrantLock lock = new ReentrantLock();
772	>	final ReentrantLock lock = new ReentrantLock();
773		final Condition c = lock.newCondition();
774	<	Thread t = new Thread(new CheckedInterruptedRunnable() {
775	<	public void realRun() throws InterruptedException {
774	>	Thread t = newStartedThread(new CheckedInterruptedRunnable() {
775	>	public void realRun() throws InterruptedException {
776		lock.lock();
777		java.util.Date d = new java.util.Date();
778		c.awaitUntil(new java.util.Date(d.getTime() + 10000));
779		}});
780
781	<	t.start();
800	<	Thread.sleep(SHORT_DELAY_MS);
781	>	delay(SHORT_DELAY_MS);
782		t.interrupt();
783	<	t.join(SHORT_DELAY_MS);
803	<	assertFalse(t.isAlive());
783	>	awaitTermination(t);
784		}
785
786		/**
787		* signalAll wakes up all threads
788		*/
789		public void testSignalAll() throws InterruptedException {
790	<	final ReentrantLock lock = new ReentrantLock();
790	>	final ReentrantLock lock = new ReentrantLock();
791		final Condition c = lock.newCondition();
792	<	Thread t1 = new Thread(new CheckedRunnable() {
792	>	Thread t1 = newStartedThread(new CheckedRunnable() {
793		public void realRun() throws InterruptedException {
794		lock.lock();
795		c.await();
796		lock.unlock();
797		}});
798
799	<	Thread t2 = new Thread(new CheckedRunnable() {
799	>	Thread t2 = newStartedThread(new CheckedRunnable() {
800		public void realRun() throws InterruptedException {
801		lock.lock();
802		c.await();
803		lock.unlock();
804		}});
805
806	<	t1.start();
827	<	t2.start();
828	<	Thread.sleep(SHORT_DELAY_MS);
806	>	delay(SHORT_DELAY_MS);
807		lock.lock();
808		c.signalAll();
809		lock.unlock();
810	<	t1.join(SHORT_DELAY_MS);
811	<	t2.join(SHORT_DELAY_MS);
834	<	assertFalse(t1.isAlive());
835	<	assertFalse(t2.isAlive());
810	>	awaitTermination(t1);
811	>	awaitTermination(t2);
812		}
813
814		/**
815		* await after multiple reentrant locking preserves lock count
816		*/
817		public void testAwaitLockCount() throws InterruptedException {
818	<	final ReentrantLock lock = new ReentrantLock();
818	>	final ReentrantLock lock = new ReentrantLock();
819		final Condition c = lock.newCondition();
820	<	Thread t1 = new Thread(new CheckedRunnable() {
820	>	Thread t1 = newStartedThread(new CheckedRunnable() {
821		public void realRun() throws InterruptedException {
822		lock.lock();
823	<	threadAssertEquals(1, lock.getHoldCount());
823	>	assertEquals(1, lock.getHoldCount());
824		c.await();
825	<	threadAssertEquals(1, lock.getHoldCount());
825	>	assertEquals(1, lock.getHoldCount());
826		lock.unlock();
827		}});
828
829	<	Thread t2 = new Thread(new CheckedRunnable() {
829	>	Thread t2 = newStartedThread(new CheckedRunnable() {
830		public void realRun() throws InterruptedException {
831		lock.lock();
832		lock.lock();
833	<	threadAssertEquals(2, lock.getHoldCount());
833	>	assertEquals(2, lock.getHoldCount());
834		c.await();
835	<	threadAssertEquals(2, lock.getHoldCount());
835	>	assertEquals(2, lock.getHoldCount());
836		lock.unlock();
837		lock.unlock();
838		}});
839
840	<	t1.start();
865	<	t2.start();
866	<	Thread.sleep(SHORT_DELAY_MS);
840	>	delay(SHORT_DELAY_MS);
841		lock.lock();
842		c.signalAll();
843		lock.unlock();
844	<	t1.join(SHORT_DELAY_MS);
845	<	t2.join(SHORT_DELAY_MS);
872	<	assertFalse(t1.isAlive());
873	<	assertFalse(t2.isAlive());
844	>	awaitTermination(t1);
845	>	awaitTermination(t2);
846		}
847
848		/**
#	Line 886 | Line 858 | public class ReentrantLockTest extends J
858		new ObjectOutputStream(new BufferedOutputStream(bout));
859		out.writeObject(l);
860		out.close();
861	<
861	>
862		ByteArrayInputStream bin =
863		new ByteArrayInputStream(bout.toByteArray());
864		ObjectInputStream in =

Diff Legend

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