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.41 by jsr166, Sat May 7 02:51:33 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();
#	Line 140 | Line 139 | public class ReentrantLockTest extends J
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();
#	Line 165 | Line 164 | public class ReentrantLockTest extends J
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();
#	Line 190 | Line 189 | public class ReentrantLockTest extends J
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();
#	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();
#	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();
273		}
#	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
288	–	t.start();
287		t.join();
288		lock.unlock();
289		}
#	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
304	–	t.start();
302		t.join();
303		lock.unlock();
304		}
#	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();
341		assertFalse(lock.isLocked());
#	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();
357		}
#	Line 365 | Line 360 | public class ReentrantLockTest extends J
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());
#	Line 379 | Line 374 | public class ReentrantLockTest extends J
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();
#	Line 460 | Line 454 | public class ReentrantLockTest extends J
454		* hasWaiters throws NPE if null
455		*/
456		public void testHasWaitersNPE() {
457	<	final ReentrantLock lock = new ReentrantLock();
457	>	final ReentrantLock lock = new ReentrantLock();
458		try {
459		lock.hasWaiters(null);
460		shouldThrow();
#	Line 471 | Line 465 | public class ReentrantLockTest extends J
465		* getWaitQueueLength throws NPE if null
466		*/
467		public void testGetWaitQueueLengthNPE() {
468	<	final ReentrantLock lock = new ReentrantLock();
468	>	final ReentrantLock lock = new ReentrantLock();
469		try {
470		lock.getWaitQueueLength(null);
471		shouldThrow();
#	Line 483 | Line 477 | public class ReentrantLockTest extends J
477		* getWaitingThreads throws NPE if null
478		*/
479		public void testGetWaitingThreadsNPE() {
480	<	final PublicReentrantLock lock = new PublicReentrantLock();
480	>	final PublicReentrantLock lock = new PublicReentrantLock();
481		try {
482		lock.getWaitingThreads(null);
483		shouldThrow();
#	Line 495 | Line 489 | public class ReentrantLockTest extends J
489		* hasWaiters throws IAE if not owned
490		*/
491		public void testHasWaitersIAE() {
492	<	final ReentrantLock lock = new ReentrantLock();
492	>	final ReentrantLock lock = new ReentrantLock();
493		final Condition c = lock.newCondition();
494	<	final ReentrantLock lock2 = new ReentrantLock();
494	>	final ReentrantLock lock2 = new ReentrantLock();
495		try {
496		lock2.hasWaiters(c);
497		shouldThrow();
#	Line 508 | Line 502 | public class ReentrantLockTest extends J
502		* hasWaiters throws IMSE if not locked
503		*/
504		public void testHasWaitersIMSE() {
505	<	final ReentrantLock lock = new ReentrantLock();
505	>	final ReentrantLock lock = new ReentrantLock();
506		final Condition c = lock.newCondition();
507		try {
508		lock.hasWaiters(c);
#	Line 521 | Line 515 | public class ReentrantLockTest extends J
515		* getWaitQueueLength throws IAE if not owned
516		*/
517		public void testGetWaitQueueLengthIAE() {
518	<	final ReentrantLock lock = new ReentrantLock();
518	>	final ReentrantLock lock = new ReentrantLock();
519		final Condition c = lock.newCondition();
520	<	final ReentrantLock lock2 = new ReentrantLock();
520	>	final ReentrantLock lock2 = new ReentrantLock();
521		try {
522		lock2.getWaitQueueLength(c);
523		shouldThrow();
#	Line 534 | Line 528 | public class ReentrantLockTest extends J
528		* getWaitQueueLength throws IMSE if not locked
529		*/
530		public void testGetWaitQueueLengthIMSE() {
531	<	final ReentrantLock lock = new ReentrantLock();
531	>	final ReentrantLock lock = new ReentrantLock();
532		final Condition c = lock.newCondition();
533		try {
534		lock.getWaitQueueLength(c);
#	Line 547 | Line 541 | public class ReentrantLockTest extends J
541		* getWaitingThreads throws IAE if not owned
542		*/
543		public void testGetWaitingThreadsIAE() {
544	<	final PublicReentrantLock lock = new PublicReentrantLock();
544	>	final PublicReentrantLock lock = new PublicReentrantLock();
545		final Condition c = lock.newCondition();
546	<	final PublicReentrantLock lock2 = new PublicReentrantLock();
546	>	final PublicReentrantLock lock2 = new PublicReentrantLock();
547		try {
548		lock2.getWaitingThreads(c);
549		shouldThrow();
#	Line 560 | Line 554 | public class ReentrantLockTest extends J
554		* getWaitingThreads throws IMSE if not locked
555		*/
556		public void testGetWaitingThreadsIMSE() {
557	<	final PublicReentrantLock lock = new PublicReentrantLock();
557	>	final PublicReentrantLock lock = new PublicReentrantLock();
558		final Condition c = lock.newCondition();
559		try {
560		lock.getWaitingThreads(c);
#	Line 573 | Line 567 | public class ReentrantLockTest extends J
567		* hasWaiters returns true when a thread is waiting, else false
568		*/
569		public void testHasWaiters() throws InterruptedException {
570	<	final ReentrantLock lock = new ReentrantLock();
570	>	final ReentrantLock lock = new ReentrantLock();
571		final Condition c = lock.newCondition();
572	<	Thread t = new Thread(new CheckedRunnable() {
572	>	Thread t = newStartedThread(new CheckedRunnable() {
573		public void realRun() throws InterruptedException {
574		lock.lock();
575	<	threadAssertFalse(lock.hasWaiters(c));
576	<	threadAssertEquals(0, lock.getWaitQueueLength(c));
575	>	assertFalse(lock.hasWaiters(c));
576	>	assertEquals(0, lock.getWaitQueueLength(c));
577		c.await();
578		lock.unlock();
579		}});
580
581	<	t.start();
588	<	Thread.sleep(SHORT_DELAY_MS);
581	>	delay(SHORT_DELAY_MS);
582		lock.lock();
583		assertTrue(lock.hasWaiters(c));
584		assertEquals(1, lock.getWaitQueueLength(c));
585		c.signal();
586		lock.unlock();
587	<	Thread.sleep(SHORT_DELAY_MS);
587	>	delay(SHORT_DELAY_MS);
588		lock.lock();
589		assertFalse(lock.hasWaiters(c));
590		assertEquals(0, lock.getWaitQueueLength(c));
#	Line 604 | Line 597 | public class ReentrantLockTest extends J
597		* getWaitQueueLength returns number of waiting threads
598		*/
599		public void testGetWaitQueueLength() throws InterruptedException {
600	<	final ReentrantLock lock = new ReentrantLock();
600	>	final ReentrantLock lock = new ReentrantLock();
601		final Condition c = lock.newCondition();
602	<	Thread t1 = new Thread(new CheckedRunnable() {
602	>	Thread t1 = newStartedThread(new CheckedRunnable() {
603		public void realRun() throws InterruptedException {
604		lock.lock();
605	<	threadAssertFalse(lock.hasWaiters(c));
606	<	threadAssertEquals(0, lock.getWaitQueueLength(c));
605	>	assertFalse(lock.hasWaiters(c));
606	>	assertEquals(0, lock.getWaitQueueLength(c));
607		c.await();
608		lock.unlock();
609		}});
610
611	<	Thread t2 = new Thread(new CheckedRunnable() {
611	>	delay(SHORT_DELAY_MS);
612	>
613	>	Thread t2 = newStartedThread(new CheckedRunnable() {
614		public void realRun() throws InterruptedException {
615		lock.lock();
616	<	threadAssertTrue(lock.hasWaiters(c));
617	<	threadAssertEquals(1, lock.getWaitQueueLength(c));
616	>	assertTrue(lock.hasWaiters(c));
617	>	assertEquals(1, lock.getWaitQueueLength(c));
618		c.await();
619		lock.unlock();
620		}});
621
622	<	t1.start();
628	<	Thread.sleep(SHORT_DELAY_MS);
629	<	t2.start();
630	<	Thread.sleep(SHORT_DELAY_MS);
622	>	delay(SHORT_DELAY_MS);
623		lock.lock();
624		assertTrue(lock.hasWaiters(c));
625		assertEquals(2, lock.getWaitQueueLength(c));
626		c.signalAll();
627		lock.unlock();
628	<	Thread.sleep(SHORT_DELAY_MS);
628	>	delay(SHORT_DELAY_MS);
629		lock.lock();
630		assertFalse(lock.hasWaiters(c));
631		assertEquals(0, lock.getWaitQueueLength(c));
#	Line 648 | Line 640 | public class ReentrantLockTest extends J
640		* getWaitingThreads returns only and all waiting threads
641		*/
642		public void testGetWaitingThreads() throws InterruptedException {
643	<	final PublicReentrantLock lock = new PublicReentrantLock();
643	>	final PublicReentrantLock lock = new PublicReentrantLock();
644		final Condition c = lock.newCondition();
645	<	Thread t1 = new Thread(new CheckedRunnable() {
645	>	Thread t1 = new Thread(new CheckedRunnable() {
646		public void realRun() throws InterruptedException {
647		lock.lock();
648	<	threadAssertTrue(lock.getWaitingThreads(c).isEmpty());
648	>	assertTrue(lock.getWaitingThreads(c).isEmpty());
649		c.await();
650		lock.unlock();
651		}});
652
653	<	Thread t2 = new Thread(new CheckedRunnable() {
653	>	Thread t2 = new Thread(new CheckedRunnable() {
654		public void realRun() throws InterruptedException {
655		lock.lock();
656	<	threadAssertFalse(lock.getWaitingThreads(c).isEmpty());
656	>	assertFalse(lock.getWaitingThreads(c).isEmpty());
657		c.await();
658		lock.unlock();
659		}});
#	Line 670 | Line 662 | public class ReentrantLockTest extends J
662		assertTrue(lock.getWaitingThreads(c).isEmpty());
663		lock.unlock();
664		t1.start();
665	<	Thread.sleep(SHORT_DELAY_MS);
665	>	delay(SHORT_DELAY_MS);
666		t2.start();
667	<	Thread.sleep(SHORT_DELAY_MS);
667	>	delay(SHORT_DELAY_MS);
668		lock.lock();
669		assertTrue(lock.hasWaiters(c));
670		assertTrue(lock.getWaitingThreads(c).contains(t1));
671		assertTrue(lock.getWaitingThreads(c).contains(t2));
672		c.signalAll();
673		lock.unlock();
674	<	Thread.sleep(SHORT_DELAY_MS);
674	>	delay(SHORT_DELAY_MS);
675		lock.lock();
676		assertFalse(lock.hasWaiters(c));
677		assertTrue(lock.getWaitingThreads(c).isEmpty());
#	Line 728 | Line 720 | public class ReentrantLockTest extends J
720		thread.start();
721
722		while (!thread.lockStarted) {
723	<	Thread.sleep(100);
723	>	delay(100);
724		}
725
726		lock.lock();
#	Line 749 | Line 741 | public class ReentrantLockTest extends J
741		* await is interruptible
742		*/
743		public void testAwait_Interrupt() throws InterruptedException {
744	<	final ReentrantLock lock = new ReentrantLock();
744	>	final ReentrantLock lock = new ReentrantLock();
745		final Condition c = lock.newCondition();
746	<	Thread t = new Thread(new CheckedInterruptedRunnable() {
747	<	public void realRun() throws InterruptedException {
746	>	Thread t = newStartedThread(new CheckedInterruptedRunnable() {
747	>	public void realRun() throws InterruptedException {
748		lock.lock();
749		c.await();
750		}});
751
752	<	t.start();
761	<	Thread.sleep(SHORT_DELAY_MS);
752	>	delay(SHORT_DELAY_MS);
753		t.interrupt();
754		t.join(SHORT_DELAY_MS);
755		assertFalse(t.isAlive());
#	Line 768 | Line 759 | public class ReentrantLockTest extends J
759		* awaitNanos is interruptible
760		*/
761		public void testAwaitNanos_Interrupt() throws InterruptedException {
762	<	final ReentrantLock lock = new ReentrantLock();
762	>	final ReentrantLock lock = new ReentrantLock();
763		final Condition c = lock.newCondition();
764	<	Thread t = new Thread(new CheckedInterruptedRunnable() {
765	<	public void realRun() throws InterruptedException {
764	>	Thread t = newStartedThread(new CheckedInterruptedRunnable() {
765	>	public void realRun() throws InterruptedException {
766		lock.lock();
767	<	c.awaitNanos(1000 * 1000 * 1000); // 1 sec
767	>	c.awaitNanos(MILLISECONDS.toNanos(LONG_DELAY_MS));
768		}});
769
770	<	t.start();
780	<	Thread.sleep(SHORT_DELAY_MS);
770	>	delay(SHORT_DELAY_MS);
771		t.interrupt();
772		t.join(SHORT_DELAY_MS);
773		assertFalse(t.isAlive());
#	Line 787 | Line 777 | public class ReentrantLockTest extends J
777		* awaitUntil is interruptible
778		*/
779		public void testAwaitUntil_Interrupt() throws InterruptedException {
780	<	final ReentrantLock lock = new ReentrantLock();
780	>	final ReentrantLock lock = new ReentrantLock();
781		final Condition c = lock.newCondition();
782	<	Thread t = new Thread(new CheckedInterruptedRunnable() {
783	<	public void realRun() throws InterruptedException {
782	>	Thread t = newStartedThread(new CheckedInterruptedRunnable() {
783	>	public void realRun() throws InterruptedException {
784		lock.lock();
785		java.util.Date d = new java.util.Date();
786		c.awaitUntil(new java.util.Date(d.getTime() + 10000));
787		}});
788
789	<	t.start();
800	<	Thread.sleep(SHORT_DELAY_MS);
789	>	delay(SHORT_DELAY_MS);
790		t.interrupt();
791		t.join(SHORT_DELAY_MS);
792		assertFalse(t.isAlive());
#	Line 807 | Line 796 | public class ReentrantLockTest extends J
796		* signalAll wakes up all threads
797		*/
798		public void testSignalAll() throws InterruptedException {
799	<	final ReentrantLock lock = new ReentrantLock();
799	>	final ReentrantLock lock = new ReentrantLock();
800		final Condition c = lock.newCondition();
801	<	Thread t1 = new Thread(new CheckedRunnable() {
801	>	Thread t1 = newStartedThread(new CheckedRunnable() {
802		public void realRun() throws InterruptedException {
803		lock.lock();
804		c.await();
805		lock.unlock();
806		}});
807
808	<	Thread t2 = new Thread(new CheckedRunnable() {
808	>	Thread t2 = newStartedThread(new CheckedRunnable() {
809		public void realRun() throws InterruptedException {
810		lock.lock();
811		c.await();
812		lock.unlock();
813		}});
814
815	<	t1.start();
827	<	t2.start();
828	<	Thread.sleep(SHORT_DELAY_MS);
815	>	delay(SHORT_DELAY_MS);
816		lock.lock();
817		c.signalAll();
818		lock.unlock();
#	Line 839 | Line 826 | public class ReentrantLockTest extends J
826		* await after multiple reentrant locking preserves lock count
827		*/
828		public void testAwaitLockCount() throws InterruptedException {
829	<	final ReentrantLock lock = new ReentrantLock();
829	>	final ReentrantLock lock = new ReentrantLock();
830		final Condition c = lock.newCondition();
831	<	Thread t1 = new Thread(new CheckedRunnable() {
831	>	Thread t1 = newStartedThread(new CheckedRunnable() {
832		public void realRun() throws InterruptedException {
833		lock.lock();
834	<	threadAssertEquals(1, lock.getHoldCount());
834	>	assertEquals(1, lock.getHoldCount());
835		c.await();
836	<	threadAssertEquals(1, lock.getHoldCount());
836	>	assertEquals(1, lock.getHoldCount());
837		lock.unlock();
838		}});
839
840	<	Thread t2 = new Thread(new CheckedRunnable() {
840	>	Thread t2 = newStartedThread(new CheckedRunnable() {
841		public void realRun() throws InterruptedException {
842		lock.lock();
843		lock.lock();
844	<	threadAssertEquals(2, lock.getHoldCount());
844	>	assertEquals(2, lock.getHoldCount());
845		c.await();
846	<	threadAssertEquals(2, lock.getHoldCount());
846	>	assertEquals(2, lock.getHoldCount());
847		lock.unlock();
848		lock.unlock();
849		}});
850
851	<	t1.start();
865	<	t2.start();
866	<	Thread.sleep(SHORT_DELAY_MS);
851	>	delay(SHORT_DELAY_MS);
852		lock.lock();
853		c.signalAll();
854		lock.unlock();
#	Line 886 | Line 871 | public class ReentrantLockTest extends J
871		new ObjectOutputStream(new BufferedOutputStream(bout));
872		out.writeObject(l);
873		out.close();
874	<
874	>
875		ByteArrayInputStream bin =
876		new ByteArrayInputStream(bout.toByteArray());
877		ObjectInputStream in =

Diff Legend

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