[ViewVC] Diff of: jsr166/jsr166/src/test/tck/ReentrantReadWriteLockTest.java

Comparing jsr166/src/test/tck/ReentrantReadWriteLockTest.java (file contents):
Revision 1.45 by jsr166, Sun May 1 23:49:41 2011 UTC vs.
Revision 1.65 by jsr166, Tue May 31 16:16:24 2011 UTC

#	Line 7 \| Line 7
7		*/
8
9		import junit.framework.*;
10	<	import java.util.concurrent.locks.*;
11	<	import java.util.concurrent.*;
10	>	import java.util.concurrent.atomic.AtomicBoolean;
11	>	import java.util.concurrent.locks.Condition;
12	>	import java.util.concurrent.locks.Lock;
13	>	import java.util.concurrent.locks.ReentrantReadWriteLock;
14	>	import java.util.concurrent.CountDownLatch;
15		import static java.util.concurrent.TimeUnit.MILLISECONDS;
13	–	import java.io.*;
16		import java.util.*;
17
18		public class ReentrantReadWriteLockTest extends JSR166TestCase {
#	Line 32 \| Line 34 \| public class ReentrantReadWriteLockTest
34		}
35		}
36
35	–
37		/**
38		* A runnable calling lockInterruptibly that expects to be
39		* interrupted
#	Line 50 \| Line 51 \| public class ReentrantReadWriteLockTest
51		*/
52		static class PublicReentrantReadWriteLock extends ReentrantReadWriteLock {
53		PublicReentrantReadWriteLock() { super(); }
54	+	PublicReentrantReadWriteLock(boolean fair) { super(fair); }
55	+	public Thread getOwner() {
56	+	return super.getOwner();
57	+	}
58		public Collection<Thread> getQueuedThreads() {
59		return super.getQueuedThreads();
60		}
#	Line 59 \| Line 64 \| public class ReentrantReadWriteLockTest
64		}
65
66		/**
67	<	* Constructor sets given fairness, and is in unlocked state
67	>	* Releases write lock, checking that it had a hold count of 1.
68		*/
69	<	public void testConstructor() {
70	<	ReentrantReadWriteLock rl = new ReentrantReadWriteLock();
71	<	assertFalse(rl.isFair());
72	<	assertFalse(rl.isWriteLocked());
73	<	assertEquals(0, rl.getReadLockCount());
74	<	ReentrantReadWriteLock r2 = new ReentrantReadWriteLock(true);
70	<	assertTrue(r2.isFair());
71	<	assertFalse(r2.isWriteLocked());
72	<	assertEquals(0, r2.getReadLockCount());
73	<	ReentrantReadWriteLock r3 = new ReentrantReadWriteLock(false);
74	<	assertFalse(r3.isFair());
75	<	assertFalse(r3.isWriteLocked());
76	<	assertEquals(0, r3.getReadLockCount());
69	>	void releaseWriteLock(PublicReentrantReadWriteLock lock) {
70	>	ReentrantReadWriteLock.WriteLock writeLock = lock.writeLock();
71	>	assertWriteLockedByMoi(lock);
72	>	assertEquals(1, lock.getWriteHoldCount());
73	>	writeLock.unlock();
74	>	assertNotWriteLocked(lock);
75		}
76
77		/**
78	<	* write-locking and read-locking an unlocked lock succeed
78	>	* Spin-waits until lock.hasQueuedThread(t) becomes true.
79	>	*/
80	>	void waitForQueuedThread(PublicReentrantReadWriteLock lock, Thread t) {
81	>	long startTime = System.nanoTime();
82	>	while (!lock.hasQueuedThread(t)) {
83	>	if (millisElapsedSince(startTime) > LONG_DELAY_MS)
84	>	throw new AssertionFailedError("timed out");
85	>	Thread.yield();
86	>	}
87	>	assertTrue(t.isAlive());
88	>	assertTrue(lock.getOwner() != t);
89	>	}
90	>
91	>	/**
92	>	* Checks that lock is not write-locked.
93	>	*/
94	>	void assertNotWriteLocked(PublicReentrantReadWriteLock lock) {
95	>	assertFalse(lock.isWriteLocked());
96	>	assertFalse(lock.isWriteLockedByCurrentThread());
97	>	assertFalse(lock.writeLock().isHeldByCurrentThread());
98	>	assertEquals(0, lock.getWriteHoldCount());
99	>	assertEquals(0, lock.writeLock().getHoldCount());
100	>	assertNull(lock.getOwner());
101	>	}
102	>
103	>	/**
104	>	* Checks that lock is write-locked by the given thread.
105	>	*/
106	>	void assertWriteLockedBy(PublicReentrantReadWriteLock lock, Thread t) {
107	>	assertTrue(lock.isWriteLocked());
108	>	assertSame(t, lock.getOwner());
109	>	assertEquals(t == Thread.currentThread(),
110	>	lock.isWriteLockedByCurrentThread());
111	>	assertEquals(t == Thread.currentThread(),
112	>	lock.writeLock().isHeldByCurrentThread());
113	>	assertEquals(t == Thread.currentThread(),
114	>	lock.getWriteHoldCount() > 0);
115	>	assertEquals(t == Thread.currentThread(),
116	>	lock.writeLock().getHoldCount() > 0);
117	>	assertEquals(0, lock.getReadLockCount());
118	>	}
119	>
120	>	/**
121	>	* Checks that lock is write-locked by the current thread.
122	>	*/
123	>	void assertWriteLockedByMoi(PublicReentrantReadWriteLock lock) {
124	>	assertWriteLockedBy(lock, Thread.currentThread());
125	>	}
126	>
127	>	/**
128	>	* Checks that condition c has no waiters.
129	>	*/
130	>	void assertHasNoWaiters(PublicReentrantReadWriteLock lock, Condition c) {
131	>	assertHasWaiters(lock, c, new Thread[] {});
132	>	}
133	>
134	>	/**
135	>	* Checks that condition c has exactly the given waiter threads.
136	>	*/
137	>	void assertHasWaiters(PublicReentrantReadWriteLock lock, Condition c,
138	>	Thread... threads) {
139	>	lock.writeLock().lock();
140	>	assertEquals(threads.length > 0, lock.hasWaiters(c));
141	>	assertEquals(threads.length, lock.getWaitQueueLength(c));
142	>	assertEquals(threads.length == 0, lock.getWaitingThreads(c).isEmpty());
143	>	assertEquals(threads.length, lock.getWaitingThreads(c).size());
144	>	assertEquals(new HashSet<Thread>(lock.getWaitingThreads(c)),
145	>	new HashSet<Thread>(Arrays.asList(threads)));
146	>	lock.writeLock().unlock();
147	>	}
148	>
149	>	enum AwaitMethod { await, awaitTimed, awaitNanos, awaitUntil };
150	>
151	>	/**
152	>	* Awaits condition using the specified AwaitMethod.
153		*/
154	<	public void testLock() {
155	<	ReentrantReadWriteLock rl = new ReentrantReadWriteLock();
156	<	rl.writeLock().lock();
157	<	assertTrue(rl.isWriteLocked());
158	<	assertTrue(rl.isWriteLockedByCurrentThread());
159	<	assertTrue(rl.writeLock().isHeldByCurrentThread());
160	<	assertEquals(0, rl.getReadLockCount());
161	<	rl.writeLock().unlock();
162	<	assertFalse(rl.isWriteLocked());
163	<	assertFalse(rl.isWriteLockedByCurrentThread());
164	<	assertFalse(rl.writeLock().isHeldByCurrentThread());
165	<	assertEquals(0, rl.getReadLockCount());
166	<	rl.readLock().lock();
167	<	assertFalse(rl.isWriteLocked());
168	<	assertFalse(rl.isWriteLockedByCurrentThread());
169	<	assertEquals(1, rl.getReadLockCount());
170	<	rl.readLock().unlock();
171	<	assertFalse(rl.isWriteLocked());
100	<	assertFalse(rl.isWriteLockedByCurrentThread());
101	<	assertEquals(0, rl.getReadLockCount());
154	>	void await(Condition c, AwaitMethod awaitMethod)
155	>	throws InterruptedException {
156	>	switch (awaitMethod) {
157	>	case await:
158	>	c.await();
159	>	break;
160	>	case awaitTimed:
161	>	assertTrue(c.await(2 * LONG_DELAY_MS, MILLISECONDS));
162	>	break;
163	>	case awaitNanos:
164	>	long nanosRemaining = c.awaitNanos(MILLISECONDS.toNanos(2 * LONG_DELAY_MS));
165	>	assertTrue(nanosRemaining > 0);
166	>	break;
167	>	case awaitUntil:
168	>	java.util.Date d = new java.util.Date();
169	>	assertTrue(c.awaitUntil(new java.util.Date(d.getTime() + 2 * LONG_DELAY_MS)));
170	>	break;
171	>	}
172		}
173
174	+	/**
175	+	* Constructor sets given fairness, and is in unlocked state
176	+	*/
177	+	public void testConstructor() {
178	+	PublicReentrantReadWriteLock lock;
179	+
180	+	lock = new PublicReentrantReadWriteLock();
181	+	assertFalse(lock.isFair());
182	+	assertNotWriteLocked(lock);
183	+	assertEquals(0, lock.getReadLockCount());
184	+
185	+	lock = new PublicReentrantReadWriteLock(true);
186	+	assertTrue(lock.isFair());
187	+	assertNotWriteLocked(lock);
188	+	assertEquals(0, lock.getReadLockCount());
189	+
190	+	lock = new PublicReentrantReadWriteLock(false);
191	+	assertFalse(lock.isFair());
192	+	assertNotWriteLocked(lock);
193	+	assertEquals(0, lock.getReadLockCount());
194	+	}
195
196		/**
197	<	* locking an unlocked fair lock succeeds
198	<	*/
199	<	public void testFairLock() {
200	<	ReentrantReadWriteLock rl = new ReentrantReadWriteLock(true);
201	<	rl.writeLock().lock();
202	<	assertTrue(rl.isWriteLocked());
203	<	assertTrue(rl.isWriteLockedByCurrentThread());
204	<	assertTrue(rl.writeLock().isHeldByCurrentThread());
205	<	assertEquals(0, rl.getReadLockCount());
206	<	rl.writeLock().unlock();
207	<	assertFalse(rl.isWriteLocked());
208	<	assertFalse(rl.isWriteLockedByCurrentThread());
209	<	assertFalse(rl.writeLock().isHeldByCurrentThread());
210	<	assertEquals(0, rl.getReadLockCount());
211	<	rl.readLock().lock();
212	<	assertFalse(rl.isWriteLocked());
213	<	assertFalse(rl.isWriteLockedByCurrentThread());
214	<	assertEquals(1, rl.getReadLockCount());
215	<	rl.readLock().unlock();
125	<	assertFalse(rl.isWriteLocked());
126	<	assertFalse(rl.isWriteLockedByCurrentThread());
127	<	assertEquals(0, rl.getReadLockCount());
197	>	* write-locking and read-locking an unlocked lock succeed
198	>	*/
199	>	public void testLock() { testLock(false); }
200	>	public void testLock_fair() { testLock(true); }
201	>	public void testLock(boolean fair) {
202	>	PublicReentrantReadWriteLock lock =
203	>	new PublicReentrantReadWriteLock(fair);
204	>	assertNotWriteLocked(lock);
205	>	lock.writeLock().lock();
206	>	assertWriteLockedByMoi(lock);
207	>	lock.writeLock().unlock();
208	>	assertNotWriteLocked(lock);
209	>	assertEquals(0, lock.getReadLockCount());
210	>	lock.readLock().lock();
211	>	assertNotWriteLocked(lock);
212	>	assertEquals(1, lock.getReadLockCount());
213	>	lock.readLock().unlock();
214	>	assertNotWriteLocked(lock);
215	>	assertEquals(0, lock.getReadLockCount());
216		}
217
218		/**
219		* getWriteHoldCount returns number of recursive holds
220		*/
221	<	public void testGetWriteHoldCount() {
222	<	ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
221	>	public void testGetWriteHoldCount() { testGetWriteHoldCount(false); }
222	>	public void testGetWriteHoldCount_fair() { testGetWriteHoldCount(true); }
223	>	public void testGetWriteHoldCount(boolean fair) {
224	>	ReentrantReadWriteLock lock = new ReentrantReadWriteLock(fair);
225		for (int i = 1; i <= SIZE; i++) {
226		lock.writeLock().lock();
227		assertEquals(i,lock.getWriteHoldCount());
#	Line 143 \| Line 233 \| public class ReentrantReadWriteLockTest
233		}
234
235		/**
236	<	* WriteLock.getHoldCount returns number of recursive holds
236	>	* writelock.getHoldCount returns number of recursive holds
237		*/
238	<	public void testGetHoldCount() {
239	<	ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
238	>	public void testGetHoldCount() { testGetHoldCount(false); }
239	>	public void testGetHoldCount_fair() { testGetHoldCount(true); }
240	>	public void testGetHoldCount(boolean fair) {
241	>	ReentrantReadWriteLock lock = new ReentrantReadWriteLock(fair);
242		for (int i = 1; i <= SIZE; i++) {
243		lock.writeLock().lock();
244		assertEquals(i,lock.writeLock().getHoldCount());
#	Line 160 \| Line 252 \| public class ReentrantReadWriteLockTest
252		/**
253		* getReadHoldCount returns number of recursive holds
254		*/
255	<	public void testGetReadHoldCount() {
256	<	ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
255	>	public void testGetReadHoldCount() { testGetReadHoldCount(false); }
256	>	public void testGetReadHoldCount_fair() { testGetReadHoldCount(true); }
257	>	public void testGetReadHoldCount(boolean fair) {
258	>	ReentrantReadWriteLock lock = new ReentrantReadWriteLock(fair);
259		for (int i = 1; i <= SIZE; i++) {
260		lock.readLock().lock();
261		assertEquals(i,lock.getReadHoldCount());
#	Line 172 \| Line 266 \| public class ReentrantReadWriteLockTest
266		}
267		}
268
175	–
269		/**
270		* write-unlocking an unlocked lock throws IllegalMonitorStateException
271		*/
272	<	public void testUnlock_IllegalMonitorStateException() {
273	<	ReentrantReadWriteLock rl = new ReentrantReadWriteLock();
272	>	public void testWriteUnlock_IMSE() { testWriteUnlock_IMSE(false); }
273	>	public void testWriteUnlock_IMSE_fair() { testWriteUnlock_IMSE(true); }
274	>	public void testWriteUnlock_IMSE(boolean fair) {
275	>	ReentrantReadWriteLock lock = new ReentrantReadWriteLock(fair);
276		try {
277	<	rl.writeLock().unlock();
277	>	lock.writeLock().unlock();
278		shouldThrow();
279		} catch (IllegalMonitorStateException success) {}
280		}
281
282	+	/**
283	+	* read-unlocking an unlocked lock throws IllegalMonitorStateException
284	+	*/
285	+	public void testReadUnlock_IMSE() { testReadUnlock_IMSE(false); }
286	+	public void testReadUnlock_IMSE_fair() { testReadUnlock_IMSE(true); }
287	+	public void testReadUnlock_IMSE(boolean fair) {
288	+	ReentrantReadWriteLock lock = new ReentrantReadWriteLock(fair);
289	+	try {
290	+	lock.readLock().unlock();
291	+	shouldThrow();
292	+	} catch (IllegalMonitorStateException success) {}
293	+	}
294
295		/**
296		* write-lockInterruptibly is interruptible
297		*/
298	<	public void testWriteLockInterruptibly_Interrupted() throws Exception {
299	<	final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
298	>	public void testWriteLockInterruptibly_Interruptible() { testWriteLockInterruptibly_Interruptible(false); }
299	>	public void testWriteLockInterruptibly_Interruptible_fair() { testWriteLockInterruptibly_Interruptible(true); }
300	>	public void testWriteLockInterruptibly_Interruptible(boolean fair) {
301	>	final PublicReentrantReadWriteLock lock =
302	>	new PublicReentrantReadWriteLock(fair);
303		lock.writeLock().lock();
304		Thread t = newStartedThread(new CheckedInterruptedRunnable() {
305		public void realRun() throws InterruptedException {
306		lock.writeLock().lockInterruptibly();
197	–	lock.writeLock().unlock();
198	–	lock.writeLock().lockInterruptibly();
199	–	lock.writeLock().unlock();
307		}});
308
309	<	Thread.sleep(SHORT_DELAY_MS);
309	>	waitForQueuedThread(lock, t);
310		t.interrupt();
311	<	Thread.sleep(SHORT_DELAY_MS);
312	<	lock.writeLock().unlock();
206	<	t.join();
311	>	awaitTermination(t);
312	>	releaseWriteLock(lock);
313		}
314
315		/**
316		* timed write-tryLock is interruptible
317		*/
318	<	public void testWriteTryLock_Interrupted() throws InterruptedException {
319	<	final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
318	>	public void testWriteTryLock_Interruptible() { testWriteTryLock_Interruptible(false); }
319	>	public void testWriteTryLock_Interruptible_fair() { testWriteTryLock_Interruptible(true); }
320	>	public void testWriteTryLock_Interruptible(boolean fair) {
321	>	final PublicReentrantReadWriteLock lock =
322	>	new PublicReentrantReadWriteLock(fair);
323		lock.writeLock().lock();
324		Thread t = newStartedThread(new CheckedInterruptedRunnable() {
325		public void realRun() throws InterruptedException {
326	<	lock.writeLock().tryLock(SMALL_DELAY_MS, MILLISECONDS);
326	>	lock.writeLock().tryLock(2 * LONG_DELAY_MS, MILLISECONDS);
327		}});
328
329	<	Thread.sleep(SHORT_DELAY_MS);
329	>	waitForQueuedThread(lock, t);
330		t.interrupt();
331	<	lock.writeLock().unlock();
332	<	t.join();
331	>	awaitTermination(t);
332	>	releaseWriteLock(lock);
333		}
334
335		/**
336		* read-lockInterruptibly is interruptible
337		*/
338	<	public void testReadLockInterruptibly_Interrupted() throws InterruptedException {
339	<	final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
338	>	public void testReadLockInterruptibly_Interruptible() { testReadLockInterruptibly_Interruptible(false); }
339	>	public void testReadLockInterruptibly_Interruptible_fair() { testReadLockInterruptibly_Interruptible(true); }
340	>	public void testReadLockInterruptibly_Interruptible(boolean fair) {
341	>	final PublicReentrantReadWriteLock lock =
342	>	new PublicReentrantReadWriteLock(fair);
343		lock.writeLock().lock();
344		Thread t = newStartedThread(new CheckedInterruptedRunnable() {
345		public void realRun() throws InterruptedException {
346		lock.readLock().lockInterruptibly();
347		}});
348
349	<	Thread.sleep(SHORT_DELAY_MS);
349	>	waitForQueuedThread(lock, t);
350		t.interrupt();
351	<	Thread.sleep(SHORT_DELAY_MS);
352	<	lock.writeLock().unlock();
241	<	t.join();
351	>	awaitTermination(t);
352	>	releaseWriteLock(lock);
353		}
354
355		/**
356		* timed read-tryLock is interruptible
357		*/
358	<	public void testReadTryLock_Interrupted() throws InterruptedException {
359	<	final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
358	>	public void testReadTryLock_Interruptible() { testReadTryLock_Interruptible(false); }
359	>	public void testReadTryLock_Interruptible_fair() { testReadTryLock_Interruptible(true); }
360	>	public void testReadTryLock_Interruptible(boolean fair) {
361	>	final PublicReentrantReadWriteLock lock =
362	>	new PublicReentrantReadWriteLock(fair);
363		lock.writeLock().lock();
364		Thread t = newStartedThread(new CheckedInterruptedRunnable() {
365		public void realRun() throws InterruptedException {
366	<	lock.readLock().tryLock(LONG_DELAY_MS, MILLISECONDS);
366	>	lock.readLock().tryLock(2 * LONG_DELAY_MS, MILLISECONDS);
367		}});
368
369	<	Thread.sleep(SHORT_DELAY_MS);
369	>	waitForQueuedThread(lock, t);
370		t.interrupt();
371	<	t.join();
371	>	awaitTermination(t);
372	>	releaseWriteLock(lock);
373		}
374
375	+	/**
376	+	* write-tryLock on an unlocked lock succeeds
377	+	*/
378	+	public void testWriteTryLock() { testWriteTryLock(false); }
379	+	public void testWriteTryLock_fair() { testWriteTryLock(true); }
380	+	public void testWriteTryLock(boolean fair) {
381	+	final PublicReentrantReadWriteLock lock =
382	+	new PublicReentrantReadWriteLock(fair);
383	+	assertTrue(lock.writeLock().tryLock());
384	+	assertWriteLockedByMoi(lock);
385	+	assertTrue(lock.writeLock().tryLock());
386	+	assertWriteLockedByMoi(lock);
387	+	lock.writeLock().unlock();
388	+	releaseWriteLock(lock);
389	+	}
390
391		/**
392		* write-tryLock fails if locked
393		*/
394	<	public void testWriteTryLockWhenLocked() throws InterruptedException {
395	<	final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
394	>	public void testWriteTryLockWhenLocked() { testWriteTryLockWhenLocked(false); }
395	>	public void testWriteTryLockWhenLocked_fair() { testWriteTryLockWhenLocked(true); }
396	>	public void testWriteTryLockWhenLocked(boolean fair) {
397	>	final PublicReentrantReadWriteLock lock =
398	>	new PublicReentrantReadWriteLock(fair);
399		lock.writeLock().lock();
400		Thread t = newStartedThread(new CheckedRunnable() {
401		public void realRun() {
402		assertFalse(lock.writeLock().tryLock());
403		}});
404
405	<	t.join();
406	<	lock.writeLock().unlock();
405	>	awaitTermination(t);
406	>	releaseWriteLock(lock);
407		}
408
409		/**
410		* read-tryLock fails if locked
411		*/
412	<	public void testReadTryLockWhenLocked() throws InterruptedException {
413	<	final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
412	>	public void testReadTryLockWhenLocked() { testReadTryLockWhenLocked(false); }
413	>	public void testReadTryLockWhenLocked_fair() { testReadTryLockWhenLocked(true); }
414	>	public void testReadTryLockWhenLocked(boolean fair) {
415	>	final PublicReentrantReadWriteLock lock =
416	>	new PublicReentrantReadWriteLock(fair);
417		lock.writeLock().lock();
418		Thread t = newStartedThread(new CheckedRunnable() {
419		public void realRun() {
420		assertFalse(lock.readLock().tryLock());
421		}});
422
423	<	t.join();
424	<	lock.writeLock().unlock();
423	>	awaitTermination(t);
424	>	releaseWriteLock(lock);
425		}
426
427		/**
428		* Multiple threads can hold a read lock when not write-locked
429		*/
430	<	public void testMultipleReadLocks() throws InterruptedException {
431	<	final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
430	>	public void testMultipleReadLocks() { testMultipleReadLocks(false); }
431	>	public void testMultipleReadLocks_fair() { testMultipleReadLocks(true); }
432	>	public void testMultipleReadLocks(boolean fair) {
433	>	final ReentrantReadWriteLock lock = new ReentrantReadWriteLock(fair);
434		lock.readLock().lock();
435		Thread t = newStartedThread(new CheckedRunnable() {
436	<	public void realRun() {
436	>	public void realRun() throws InterruptedException {
437		assertTrue(lock.readLock().tryLock());
438		lock.readLock().unlock();
439	+	assertTrue(lock.readLock().tryLock(LONG_DELAY_MS, MILLISECONDS));
440	+	lock.readLock().unlock();
441	+	lock.readLock().lock();
442	+	lock.readLock().unlock();
443		}});
444
445	<	t.join();
445	>	awaitTermination(t);
446	>	lock.readLock().unlock();
447	>	}
448	>
449	>	/**
450	>	* A writelock succeeds only after a reading thread unlocks
451	>	*/
452	>	public void testWriteAfterReadLock() { testWriteAfterReadLock(false); }
453	>	public void testWriteAfterReadLock_fair() { testWriteAfterReadLock(true); }
454	>	public void testWriteAfterReadLock(boolean fair) {
455	>	final PublicReentrantReadWriteLock lock =
456	>	new PublicReentrantReadWriteLock(fair);
457	>	lock.readLock().lock();
458	>	Thread t = newStartedThread(new CheckedRunnable() {
459	>	public void realRun() {
460	>	assertEquals(1, lock.getReadLockCount());
461	>	lock.writeLock().lock();
462	>	assertEquals(0, lock.getReadLockCount());
463	>	lock.writeLock().unlock();
464	>	}});
465	>	waitForQueuedThread(lock, t);
466	>	assertNotWriteLocked(lock);
467	>	assertEquals(1, lock.getReadLockCount());
468		lock.readLock().unlock();
469	+	assertEquals(0, lock.getReadLockCount());
470	+	awaitTermination(t);
471	+	assertNotWriteLocked(lock);
472		}
473
474		/**
475	<	* A writelock succeeds after reading threads unlock
475	>	* A writelock succeeds only after reading threads unlock
476		*/
477	<	public void testWriteAfterMultipleReadLocks() throws InterruptedException {
478	<	final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
477	>	public void testWriteAfterMultipleReadLocks() { testWriteAfterMultipleReadLocks(false); }
478	>	public void testWriteAfterMultipleReadLocks_fair() { testWriteAfterMultipleReadLocks(true); }
479	>	public void testWriteAfterMultipleReadLocks(boolean fair) {
480	>	final PublicReentrantReadWriteLock lock =
481	>	new PublicReentrantReadWriteLock(fair);
482	>	lock.readLock().lock();
483		lock.readLock().lock();
484		Thread t1 = newStartedThread(new CheckedRunnable() {
485		public void realRun() {
486		lock.readLock().lock();
487	+	assertEquals(3, lock.getReadLockCount());
488		lock.readLock().unlock();
489		}});
490	+	awaitTermination(t1);
491	+
492		Thread t2 = newStartedThread(new CheckedRunnable() {
493		public void realRun() {
494	+	assertEquals(2, lock.getReadLockCount());
495		lock.writeLock().lock();
496	+	assertEquals(0, lock.getReadLockCount());
497		lock.writeLock().unlock();
498		}});
499	<
500	<	Thread.sleep(SHORT_DELAY_MS);
499	>	waitForQueuedThread(lock, t2);
500	>	assertNotWriteLocked(lock);
501	>	assertEquals(2, lock.getReadLockCount());
502		lock.readLock().unlock();
503	<	t1.join(MEDIUM_DELAY_MS);
504	<	t2.join(MEDIUM_DELAY_MS);
505	<	assertTrue(!t1.isAlive());
506	<	assertTrue(!t2.isAlive());
503	>	lock.readLock().unlock();
504	>	assertEquals(0, lock.getReadLockCount());
505	>	awaitTermination(t2);
506	>	assertNotWriteLocked(lock);
507		}
508
509		/**
510	<	* Readlocks succeed after a writing thread unlocks
510	>	* A thread that tries to acquire a fair read lock (non-reentrantly)
511	>	* will block if there is a waiting writer thread
512		*/
513	<	public void testReadAfterWriteLock() throws InterruptedException {
514	<	final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
515	<	lock.writeLock().lock();
513	>	public void testReaderWriterReaderFairFifo() {
514	>	final PublicReentrantReadWriteLock lock =
515	>	new PublicReentrantReadWriteLock(true);
516	>	final AtomicBoolean t1GotLock = new AtomicBoolean(false);
517	>
518	>	lock.readLock().lock();
519		Thread t1 = newStartedThread(new CheckedRunnable() {
520		public void realRun() {
521	<	lock.readLock().lock();
522	<	lock.readLock().unlock();
521	>	assertEquals(1, lock.getReadLockCount());
522	>	lock.writeLock().lock();
523	>	assertEquals(0, lock.getReadLockCount());
524	>	t1GotLock.set(true);
525	>	lock.writeLock().unlock();
526		}});
527	+	waitForQueuedThread(lock, t1);
528	+
529		Thread t2 = newStartedThread(new CheckedRunnable() {
530		public void realRun() {
531	+	assertEquals(1, lock.getReadLockCount());
532		lock.readLock().lock();
533	+	assertEquals(1, lock.getReadLockCount());
534	+	assertTrue(t1GotLock.get());
535		lock.readLock().unlock();
536		}});
537	<
538	<	Thread.sleep(SHORT_DELAY_MS);
539	<	lock.writeLock().unlock();
540	<	t1.join(MEDIUM_DELAY_MS);
352	<	t2.join(MEDIUM_DELAY_MS);
353	<	assertTrue(!t1.isAlive());
354	<	assertTrue(!t2.isAlive());
355	<	}
356	<
357	<	/**
358	<	* Read trylock succeeds if write locked by current thread
359	<	*/
360	<	public void testReadHoldingWriteLock() {
361	<	final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
362	<	lock.writeLock().lock();
363	<	assertTrue(lock.readLock().tryLock());
537	>	waitForQueuedThread(lock, t2);
538	>	assertTrue(t1.isAlive());
539	>	assertNotWriteLocked(lock);
540	>	assertEquals(1, lock.getReadLockCount());
541		lock.readLock().unlock();
542	<	lock.writeLock().unlock();
542	>	awaitTermination(t1);
543	>	awaitTermination(t2);
544	>	assertNotWriteLocked(lock);
545		}
546
547		/**
548	<	* Read lock succeeds if write locked by current thread even if
370	<	* other threads are waiting for readlock
548	>	* Readlocks succeed only after a writing thread unlocks
549		*/
550	<	public void testReadHoldingWriteLock2() throws InterruptedException {
551	<	final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
550	>	public void testReadAfterWriteLock() { testReadAfterWriteLock(false); }
551	>	public void testReadAfterWriteLock_fair() { testReadAfterWriteLock(true); }
552	>	public void testReadAfterWriteLock(boolean fair) {
553	>	final PublicReentrantReadWriteLock lock =
554	>	new PublicReentrantReadWriteLock(fair);
555		lock.writeLock().lock();
556		Thread t1 = newStartedThread(new CheckedRunnable() {
557		public void realRun() {
#	Line 383 \| Line 564 \| public class ReentrantReadWriteLockTest
564		lock.readLock().unlock();
565		}});
566
567	<	lock.readLock().lock();
568	<	lock.readLock().unlock();
569	<	Thread.sleep(SHORT_DELAY_MS);
570	<	lock.readLock().lock();
571	<	lock.readLock().unlock();
391	<	lock.writeLock().unlock();
392	<	t1.join(MEDIUM_DELAY_MS);
393	<	t2.join(MEDIUM_DELAY_MS);
394	<	assertTrue(!t1.isAlive());
395	<	assertTrue(!t2.isAlive());
567	>	waitForQueuedThread(lock, t1);
568	>	waitForQueuedThread(lock, t2);
569	>	releaseWriteLock(lock);
570	>	awaitTermination(t1);
571	>	awaitTermination(t2);
572		}
573
574		/**
575	<	* Read lock succeeds if write locked by current thread even if
400	<	* other threads are waiting for writelock
575	>	* Read trylock succeeds if write locked by current thread
576		*/
577	<	public void testReadHoldingWriteLock3() throws InterruptedException {
578	<	final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
577	>	public void testReadHoldingWriteLock() { testReadHoldingWriteLock(false); }
578	>	public void testReadHoldingWriteLock_fair() { testReadHoldingWriteLock(true); }
579	>	public void testReadHoldingWriteLock(boolean fair) {
580	>	final ReentrantReadWriteLock lock = new ReentrantReadWriteLock(fair);
581		lock.writeLock().lock();
582	<	Thread t1 = newStartedThread(new CheckedRunnable() {
406	<	public void realRun() {
407	<	lock.writeLock().lock();
408	<	lock.writeLock().unlock();
409	<	}});
410	<	Thread t2 = newStartedThread(new CheckedRunnable() {
411	<	public void realRun() {
412	<	lock.writeLock().lock();
413	<	lock.writeLock().unlock();
414	<	}});
415	<
416	<	lock.readLock().lock();
417	<	lock.readLock().unlock();
418	<	Thread.sleep(SHORT_DELAY_MS);
419	<	lock.readLock().lock();
582	>	assertTrue(lock.readLock().tryLock());
583		lock.readLock().unlock();
584		lock.writeLock().unlock();
422	–	t1.join(MEDIUM_DELAY_MS);
423	–	t2.join(MEDIUM_DELAY_MS);
424	–	assertTrue(!t1.isAlive());
425	–	assertTrue(!t2.isAlive());
585		}
586
428	–
587		/**
588	<	* Write lock succeeds if write locked by current thread even if
589	<	* other threads are waiting for writelock
588	>	* Read trylock succeeds (barging) even in the presence of waiting
589	>	* readers and/or writers
590		*/
591	<	public void testWriteHoldingWriteLock4() throws InterruptedException {
592	<	final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
593	<	lock.writeLock().lock();
591	>	public void testReadTryLockBarging() { testReadTryLockBarging(false); }
592	>	public void testReadTryLockBarging_fair() { testReadTryLockBarging(true); }
593	>	public void testReadTryLockBarging(boolean fair) {
594	>	final PublicReentrantReadWriteLock lock =
595	>	new PublicReentrantReadWriteLock(fair);
596	>	lock.readLock().lock();
597	>
598		Thread t1 = newStartedThread(new CheckedRunnable() {
599		public void realRun() {
600		lock.writeLock().lock();
601		lock.writeLock().unlock();
602		}});
603	+
604	+	waitForQueuedThread(lock, t1);
605	+
606		Thread t2 = newStartedThread(new CheckedRunnable() {
607		public void realRun() {
608	<	lock.writeLock().lock();
609	<	lock.writeLock().unlock();
608	>	lock.readLock().lock();
609	>	lock.readLock().unlock();
610		}});
611
612	<	lock.writeLock().lock();
613	<	lock.writeLock().unlock();
449	<	Thread.sleep(SHORT_DELAY_MS);
450	<	lock.writeLock().lock();
451	<	lock.writeLock().unlock();
452	<	lock.writeLock().unlock();
453	<	t1.join(MEDIUM_DELAY_MS);
454	<	t2.join(MEDIUM_DELAY_MS);
455	<	assertTrue(!t1.isAlive());
456	<	assertTrue(!t2.isAlive());
457	<	}
612	>	if (fair)
613	>	waitForQueuedThread(lock, t2);
614
615	+	Thread t3 = newStartedThread(new CheckedRunnable() {
616	+	public void realRun() {
617	+	lock.readLock().tryLock();
618	+	lock.readLock().unlock();
619	+	}});
620
621	<	/**
622	<	* Fair Read trylock succeeds if write locked by current thread
623	<	*/
624	<	public void testReadHoldingWriteLockFair() {
464	<	final ReentrantReadWriteLock lock = new ReentrantReadWriteLock(true);
465	<	lock.writeLock().lock();
466	<	assertTrue(lock.readLock().tryLock());
621	>	assertTrue(lock.getReadLockCount() > 0);
622	>	awaitTermination(t3);
623	>	assertTrue(t1.isAlive());
624	>	if (fair) assertTrue(t2.isAlive());
625		lock.readLock().unlock();
626	<	lock.writeLock().unlock();
626	>	awaitTermination(t1);
627	>	awaitTermination(t2);
628		}
629
630		/**
631	<	* Fair Read lock succeeds if write locked by current thread even if
631	>	* Read lock succeeds if write locked by current thread even if
632		* other threads are waiting for readlock
633		*/
634	<	public void testReadHoldingWriteLockFair2() throws InterruptedException {
635	<	final ReentrantReadWriteLock lock = new ReentrantReadWriteLock(true);
634	>	public void testReadHoldingWriteLock2() { testReadHoldingWriteLock2(false); }
635	>	public void testReadHoldingWriteLock2_fair() { testReadHoldingWriteLock2(true); }
636	>	public void testReadHoldingWriteLock2(boolean fair) {
637	>	final PublicReentrantReadWriteLock lock =
638	>	new PublicReentrantReadWriteLock(fair);
639		lock.writeLock().lock();
640	+	lock.readLock().lock();
641	+	lock.readLock().unlock();
642	+
643		Thread t1 = newStartedThread(new CheckedRunnable() {
644		public void realRun() {
645		lock.readLock().lock();
#	Line 486 \| Line 651 \| public class ReentrantReadWriteLockTest
651		lock.readLock().unlock();
652		}});
653
654	+	waitForQueuedThread(lock, t1);
655	+	waitForQueuedThread(lock, t2);
656	+	assertWriteLockedByMoi(lock);
657		lock.readLock().lock();
658		lock.readLock().unlock();
659	<	Thread.sleep(SHORT_DELAY_MS);
660	<	lock.readLock().lock();
661	<	lock.readLock().unlock();
494	<	lock.writeLock().unlock();
495	<	t1.join(MEDIUM_DELAY_MS);
496	<	t2.join(MEDIUM_DELAY_MS);
497	<	assertTrue(!t1.isAlive());
498	<	assertTrue(!t2.isAlive());
659	>	releaseWriteLock(lock);
660	>	awaitTermination(t1);
661	>	awaitTermination(t2);
662		}
663
501	–
664		/**
665	<	* Fair Read lock succeeds if write locked by current thread even if
665	>	* Read lock succeeds if write locked by current thread even if
666		* other threads are waiting for writelock
667		*/
668	<	public void testReadHoldingWriteLockFair3() throws InterruptedException {
669	<	final ReentrantReadWriteLock lock = new ReentrantReadWriteLock(true);
668	>	public void testReadHoldingWriteLock3() { testReadHoldingWriteLock3(false); }
669	>	public void testReadHoldingWriteLock3_fair() { testReadHoldingWriteLock3(true); }
670	>	public void testReadHoldingWriteLock3(boolean fair) {
671	>	final PublicReentrantReadWriteLock lock =
672	>	new PublicReentrantReadWriteLock(fair);
673		lock.writeLock().lock();
674	+	lock.readLock().lock();
675	+	lock.readLock().unlock();
676	+
677		Thread t1 = newStartedThread(new CheckedRunnable() {
678		public void realRun() {
679		lock.writeLock().lock();
#	Line 517 \| Line 685 \| public class ReentrantReadWriteLockTest
685		lock.writeLock().unlock();
686		}});
687
688	+	waitForQueuedThread(lock, t1);
689	+	waitForQueuedThread(lock, t2);
690	+	assertWriteLockedByMoi(lock);
691		lock.readLock().lock();
692		lock.readLock().unlock();
693	<	Thread.sleep(SHORT_DELAY_MS);
523	<	lock.readLock().lock();
524	<	lock.readLock().unlock();
693	>	assertWriteLockedByMoi(lock);
694		lock.writeLock().unlock();
695	<	t1.join(MEDIUM_DELAY_MS);
696	<	t2.join(MEDIUM_DELAY_MS);
528	<	assertTrue(!t1.isAlive());
529	<	assertTrue(!t2.isAlive());
695	>	awaitTermination(t1);
696	>	awaitTermination(t2);
697		}
698
532	–
699		/**
700	<	* Fair Write lock succeeds if write locked by current thread even if
700	>	* Write lock succeeds if write locked by current thread even if
701		* other threads are waiting for writelock
702		*/
703	<	public void testWriteHoldingWriteLockFair4() throws InterruptedException {
704	<	final ReentrantReadWriteLock lock = new ReentrantReadWriteLock(true);
703	>	public void testWriteHoldingWriteLock4() { testWriteHoldingWriteLock4(false); }
704	>	public void testWriteHoldingWriteLock4_fair() { testWriteHoldingWriteLock4(true); }
705	>	public void testWriteHoldingWriteLock4(boolean fair) {
706	>	final PublicReentrantReadWriteLock lock =
707	>	new PublicReentrantReadWriteLock(fair);
708	>	lock.writeLock().lock();
709		lock.writeLock().lock();
710	+	lock.writeLock().unlock();
711	+
712		Thread t1 = newStartedThread(new CheckedRunnable() {
713		public void realRun() {
714		lock.writeLock().lock();
#	Line 548 \| Line 720 \| public class ReentrantReadWriteLockTest
720		lock.writeLock().unlock();
721		}});
722
723	<	Thread.sleep(SHORT_DELAY_MS);
724	<	assertTrue(lock.isWriteLockedByCurrentThread());
723	>	waitForQueuedThread(lock, t1);
724	>	waitForQueuedThread(lock, t2);
725	>	assertWriteLockedByMoi(lock);
726		assertEquals(1, lock.getWriteHoldCount());
727		lock.writeLock().lock();
728	+	assertWriteLockedByMoi(lock);
729		assertEquals(2, lock.getWriteHoldCount());
730		lock.writeLock().unlock();
731	<	lock.writeLock().lock();
732	<	lock.writeLock().unlock();
731	>	assertWriteLockedByMoi(lock);
732	>	assertEquals(1, lock.getWriteHoldCount());
733		lock.writeLock().unlock();
734	<	t1.join(MEDIUM_DELAY_MS);
735	<	t2.join(MEDIUM_DELAY_MS);
562	<	assertTrue(!t1.isAlive());
563	<	assertTrue(!t2.isAlive());
734	>	awaitTermination(t1);
735	>	awaitTermination(t2);
736		}
737
566	–
738		/**
739		* Read tryLock succeeds if readlocked but not writelocked
740		*/
741	<	public void testTryLockWhenReadLocked() throws InterruptedException {
742	<	final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
741	>	public void testTryLockWhenReadLocked() { testTryLockWhenReadLocked(false); }
742	>	public void testTryLockWhenReadLocked_fair() { testTryLockWhenReadLocked(true); }
743	>	public void testTryLockWhenReadLocked(boolean fair) {
744	>	final ReentrantReadWriteLock lock = new ReentrantReadWriteLock(fair);
745		lock.readLock().lock();
746		Thread t = newStartedThread(new CheckedRunnable() {
747		public void realRun() {
#	Line 576 \| Line 749 \| public class ReentrantReadWriteLockTest
749		lock.readLock().unlock();
750		}});
751
752	<	t.join();
752	>	awaitTermination(t);
753		lock.readLock().unlock();
754		}
755
756		/**
757		* write tryLock fails when readlocked
758		*/
759	<	public void testWriteTryLockWhenReadLocked() throws InterruptedException {
760	<	final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
761	<	lock.readLock().lock();
762	<	Thread t = newStartedThread(new CheckedRunnable() {
590	<	public void realRun() {
591	<	assertFalse(lock.writeLock().tryLock());
592	<	}});
593	<
594	<	t.join();
595	<	lock.readLock().unlock();
596	<	}
597	<
598	<
599	<	/**
600	<	* Fair Read tryLock succeeds if readlocked but not writelocked
601	<	*/
602	<	public void testTryLockWhenReadLockedFair() throws InterruptedException {
603	<	final ReentrantReadWriteLock lock = new ReentrantReadWriteLock(true);
604	<	lock.readLock().lock();
605	<	Thread t = newStartedThread(new CheckedRunnable() {
606	<	public void realRun() {
607	<	assertTrue(lock.readLock().tryLock());
608	<	lock.readLock().unlock();
609	<	}});
610	<
611	<	t.join();
612	<	lock.readLock().unlock();
613	<	}
614	<
615	<
616	<
617	<	/**
618	<	* Fair write tryLock fails when readlocked
619	<	*/
620	<	public void testWriteTryLockWhenReadLockedFair() throws InterruptedException {
621	<	final ReentrantReadWriteLock lock = new ReentrantReadWriteLock(true);
759	>	public void testWriteTryLockWhenReadLocked() { testWriteTryLockWhenReadLocked(false); }
760	>	public void testWriteTryLockWhenReadLocked_fair() { testWriteTryLockWhenReadLocked(true); }
761	>	public void testWriteTryLockWhenReadLocked(boolean fair) {
762	>	final ReentrantReadWriteLock lock = new ReentrantReadWriteLock(fair);
763		lock.readLock().lock();
764		Thread t = newStartedThread(new CheckedRunnable() {
765		public void realRun() {
766		assertFalse(lock.writeLock().tryLock());
767		}});
768
769	<	t.join();
769	>	awaitTermination(t);
770		lock.readLock().unlock();
771		}
772
632	–
633	–
773		/**
774		* write timed tryLock times out if locked
775		*/
776	<	public void testWriteTryLock_Timeout() throws InterruptedException {
777	<	final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
776	>	public void testWriteTryLock_Timeout() { testWriteTryLock_Timeout(false); }
777	>	public void testWriteTryLock_Timeout_fair() { testWriteTryLock_Timeout(true); }
778	>	public void testWriteTryLock_Timeout(boolean fair) {
779	>	final PublicReentrantReadWriteLock lock =
780	>	new PublicReentrantReadWriteLock(fair);
781		lock.writeLock().lock();
782		Thread t = newStartedThread(new CheckedRunnable() {
783		public void realRun() throws InterruptedException {
784	<	assertFalse(lock.writeLock().tryLock(1, MILLISECONDS));
784	>	long startTime = System.nanoTime();
785	>	long timeoutMillis = 10;
786	>	assertFalse(lock.writeLock().tryLock(timeoutMillis, MILLISECONDS));
787	>	assertTrue(millisElapsedSince(startTime) >= timeoutMillis);
788		}});
789
790	<	t.join();
791	<	assertTrue(lock.writeLock().isHeldByCurrentThread());
647	<	lock.writeLock().unlock();
790	>	awaitTermination(t);
791	>	releaseWriteLock(lock);
792		}
793
794		/**
795		* read timed tryLock times out if write-locked
796		*/
797	<	public void testReadTryLock_Timeout() throws InterruptedException {
798	<	final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
797	>	public void testReadTryLock_Timeout() { testReadTryLock_Timeout(false); }
798	>	public void testReadTryLock_Timeout_fair() { testReadTryLock_Timeout(true); }
799	>	public void testReadTryLock_Timeout(boolean fair) {
800	>	final ReentrantReadWriteLock lock = new ReentrantReadWriteLock(fair);
801		lock.writeLock().lock();
802		Thread t = newStartedThread(new CheckedRunnable() {
803		public void realRun() throws InterruptedException {
804	<	assertFalse(lock.readLock().tryLock(1, MILLISECONDS));
804	>	long startTime = System.nanoTime();
805	>	long timeoutMillis = 10;
806	>	assertFalse(lock.readLock().tryLock(timeoutMillis, MILLISECONDS));
807	>	assertTrue(millisElapsedSince(startTime) >= timeoutMillis);
808		}});
809
810	<	t.join();
810	>	awaitTermination(t);
811		assertTrue(lock.writeLock().isHeldByCurrentThread());
812		lock.writeLock().unlock();
813		}
814
666	–
815		/**
816	<	* write lockInterruptibly succeeds if lock free else is interruptible
816	>	* write lockInterruptibly succeeds if unlocked, else is interruptible
817		*/
818	<	public void testWriteLockInterruptibly() throws InterruptedException {
819	<	final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
820	<	lock.writeLock().lockInterruptibly();
818	>	public void testWriteLockInterruptibly() { testWriteLockInterruptibly(false); }
819	>	public void testWriteLockInterruptibly_fair() { testWriteLockInterruptibly(true); }
820	>	public void testWriteLockInterruptibly(boolean fair) {
821	>	final PublicReentrantReadWriteLock lock =
822	>	new PublicReentrantReadWriteLock(fair);
823	>	try {
824	>	lock.writeLock().lockInterruptibly();
825	>	} catch (InterruptedException ie) {
826	>	threadUnexpectedException(ie);
827	>	}
828		Thread t = newStartedThread(new CheckedInterruptedRunnable() {
829		public void realRun() throws InterruptedException {
830		lock.writeLock().lockInterruptibly();
831		}});
832
833	<	Thread.sleep(SHORT_DELAY_MS);
833	>	waitForQueuedThread(lock, t);
834		t.interrupt();
835	<	Thread.sleep(SHORT_DELAY_MS);
836	<	t.join();
837	<	lock.writeLock().unlock();
835	>	assertTrue(lock.writeLock().isHeldByCurrentThread());
836	>	awaitTermination(t);
837	>	releaseWriteLock(lock);
838		}
839
840		/**
841		* read lockInterruptibly succeeds if lock free else is interruptible
842		*/
843	<	public void testReadLockInterruptibly() throws InterruptedException {
844	<	final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
845	<	lock.writeLock().lockInterruptibly();
843	>	public void testReadLockInterruptibly() { testReadLockInterruptibly(false); }
844	>	public void testReadLockInterruptibly_fair() { testReadLockInterruptibly(true); }
845	>	public void testReadLockInterruptibly(boolean fair) {
846	>	final PublicReentrantReadWriteLock lock =
847	>	new PublicReentrantReadWriteLock(fair);
848	>	try {
849	>	lock.readLock().lockInterruptibly();
850	>	lock.readLock().unlock();
851	>	lock.writeLock().lockInterruptibly();
852	>	} catch (InterruptedException ie) {
853	>	threadUnexpectedException(ie);
854	>	}
855		Thread t = newStartedThread(new CheckedInterruptedRunnable() {
856		public void realRun() throws InterruptedException {
857		lock.readLock().lockInterruptibly();
858		}});
859
860	<	Thread.sleep(SHORT_DELAY_MS);
860	>	waitForQueuedThread(lock, t);
861		t.interrupt();
862	<	t.join();
863	<	lock.writeLock().unlock();
862	>	awaitTermination(t);
863	>	releaseWriteLock(lock);
864		}
865
866		/**
867		* Calling await without holding lock throws IllegalMonitorStateException
868		*/
869	<	public void testAwait_IllegalMonitor() throws InterruptedException {
870	<	final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
869	>	public void testAwait_IMSE() { testAwait_IMSE(false); }
870	>	public void testAwait_IMSE_fair() { testAwait_IMSE(true); }
871	>	public void testAwait_IMSE(boolean fair) {
872	>	final ReentrantReadWriteLock lock = new ReentrantReadWriteLock(fair);
873		final Condition c = lock.writeLock().newCondition();
874	<	try {
875	<	c.await();
876	<	shouldThrow();
877	<	} catch (IllegalMonitorStateException success) {}
874	>	for (AwaitMethod awaitMethod : AwaitMethod.values()) {
875	>	long startTime = System.nanoTime();
876	>	try {
877	>	await(c, awaitMethod);
878	>	shouldThrow();
879	>	} catch (IllegalMonitorStateException success) {
880	>	} catch (InterruptedException e) { threadUnexpectedException(e); }
881	>	assertTrue(millisElapsedSince(startTime) < LONG_DELAY_MS);
882	>	}
883		}
884
885		/**
886		* Calling signal without holding lock throws IllegalMonitorStateException
887		*/
888	<	public void testSignal_IllegalMonitor() {
889	<	final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
888	>	public void testSignal_IMSE() { testSignal_IMSE(false); }
889	>	public void testSignal_IMSE_fair() { testSignal_IMSE(true); }
890	>	public void testSignal_IMSE(boolean fair) {
891	>	final ReentrantReadWriteLock lock = new ReentrantReadWriteLock(fair);
892		final Condition c = lock.writeLock().newCondition();
893		try {
894		c.signal();
#	Line 724 \| Line 897 \| public class ReentrantReadWriteLockTest
897		}
898
899		/**
900	<	* awaitNanos without a signal times out
900	>	* Calling signalAll without holding lock throws IllegalMonitorStateException
901		*/
902	<	public void testAwaitNanos_Timeout() throws InterruptedException {
903	<	final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
902	>	public void testSignalAll_IMSE() { testSignalAll_IMSE(false); }
903	>	public void testSignalAll_IMSE_fair() { testSignalAll_IMSE(true); }
904	>	public void testSignalAll_IMSE(boolean fair) {
905	>	final ReentrantReadWriteLock lock = new ReentrantReadWriteLock(fair);
906		final Condition c = lock.writeLock().newCondition();
907	<
908	<	lock.writeLock().lock();
909	<	long t = c.awaitNanos(100);
910	<	assertTrue(t <= 0);
736	<	lock.writeLock().unlock();
907	>	try {
908	>	c.signalAll();
909	>	shouldThrow();
910	>	} catch (IllegalMonitorStateException success) {}
911		}
912
913	+	/**
914	+	* awaitNanos without a signal times out
915	+	*/
916	+	public void testAwaitNanos_Timeout() { testAwaitNanos_Timeout(false); }
917	+	public void testAwaitNanos_Timeout_fair() { testAwaitNanos_Timeout(true); }
918	+	public void testAwaitNanos_Timeout(boolean fair) {
919	+	try {
920	+	final ReentrantReadWriteLock lock =
921	+	new ReentrantReadWriteLock(fair);
922	+	final Condition c = lock.writeLock().newCondition();
923	+	lock.writeLock().lock();
924	+	long startTime = System.nanoTime();
925	+	long timeoutMillis = 10;
926	+	long timeoutNanos = MILLISECONDS.toNanos(timeoutMillis);
927	+	long nanosRemaining = c.awaitNanos(timeoutNanos);
928	+	assertTrue(nanosRemaining <= 0);
929	+	assertTrue(millisElapsedSince(startTime) >= timeoutMillis);
930	+	lock.writeLock().unlock();
931	+	} catch (InterruptedException e) {
932	+	threadUnexpectedException(e);
933	+	}
934	+	}
935
936		/**
937		* timed await without a signal times out
938		*/
939	<	public void testAwait_Timeout() throws InterruptedException {
940	<	final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
941	<	final Condition c = lock.writeLock().newCondition();
942	<	lock.writeLock().lock();
943	<	assertFalse(c.await(SHORT_DELAY_MS, MILLISECONDS));
944	<	lock.writeLock().unlock();
939	>	public void testAwait_Timeout() { testAwait_Timeout(false); }
940	>	public void testAwait_Timeout_fair() { testAwait_Timeout(true); }
941	>	public void testAwait_Timeout(boolean fair) {
942	>	try {
943	>	final ReentrantReadWriteLock lock =
944	>	new ReentrantReadWriteLock(fair);
945	>	final Condition c = lock.writeLock().newCondition();
946	>	lock.writeLock().lock();
947	>	long startTime = System.nanoTime();
948	>	long timeoutMillis = 10;
949	>	assertFalse(c.await(timeoutMillis, MILLISECONDS));
950	>	assertTrue(millisElapsedSince(startTime) >= timeoutMillis);
951	>	lock.writeLock().unlock();
952	>	} catch (InterruptedException e) {
953	>	threadUnexpectedException(e);
954	>	}
955		}
956
957		/**
958		* awaitUntil without a signal times out
959		*/
960	<	public void testAwaitUntil_Timeout() throws InterruptedException {
961	<	final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
962	<	final Condition c = lock.writeLock().newCondition();
963	<	lock.writeLock().lock();
964	<	java.util.Date d = new java.util.Date();
965	<	assertFalse(c.awaitUntil(new java.util.Date(d.getTime() + 10)));
966	<	lock.writeLock().unlock();
960	>	public void testAwaitUntil_Timeout() { testAwaitUntil_Timeout(false); }
961	>	public void testAwaitUntil_Timeout_fair() { testAwaitUntil_Timeout(true); }
962	>	public void testAwaitUntil_Timeout(boolean fair) {
963	>	try {
964	>	final ReentrantReadWriteLock lock =
965	>	new ReentrantReadWriteLock(fair);
966	>	final Condition c = lock.writeLock().newCondition();
967	>	lock.writeLock().lock();
968	>	long startTime = System.nanoTime();
969	>	long timeoutMillis = 10;
970	>	java.util.Date d = new java.util.Date();
971	>	assertFalse(c.awaitUntil(new java.util.Date(d.getTime() + timeoutMillis)));
972	>	assertTrue(millisElapsedSince(startTime) >= timeoutMillis);
973	>	lock.writeLock().unlock();
974	>	} catch (InterruptedException e) {
975	>	threadUnexpectedException(e);
976	>	}
977		}
978
979		/**
980		* await returns when signalled
981		*/
982	<	public void testAwait() throws InterruptedException {
983	<	final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
982	>	public void testAwait() { testAwait(false); }
983	>	public void testAwait_fair() { testAwait(true); }
984	>	public void testAwait(boolean fair) {
985	>	final PublicReentrantReadWriteLock lock =
986	>	new PublicReentrantReadWriteLock(fair);
987		final Condition c = lock.writeLock().newCondition();
988	+	final CountDownLatch locked = new CountDownLatch(1);
989		Thread t = newStartedThread(new CheckedRunnable() {
990		public void realRun() throws InterruptedException {
991		lock.writeLock().lock();
992	+	locked.countDown();
993		c.await();
994		lock.writeLock().unlock();
995		}});
996
997	<	Thread.sleep(SHORT_DELAY_MS);
997	>	await(locked);
998		lock.writeLock().lock();
999	+	assertHasWaiters(lock, c, t);
1000		c.signal();
1001	+	assertHasNoWaiters(lock, c);
1002	+	assertTrue(t.isAlive());
1003		lock.writeLock().unlock();
1004	<	t.join(SHORT_DELAY_MS);
781	<	assertFalse(t.isAlive());
782	<	}
783	<
784	<	/** A helper class for uninterruptible wait tests */
785	<	class UninterruptableThread extends Thread {
786	<	private Lock lock;
787	<	private Condition c;
788	<
789	<	public volatile boolean canAwake = false;
790	<	public volatile boolean interrupted = false;
791	<	public volatile boolean lockStarted = false;
792	<
793	<	public UninterruptableThread(Lock lock, Condition c) {
794	<	this.lock = lock;
795	<	this.c = c;
796	<	}
797	<
798	<	public synchronized void run() {
799	<	lock.lock();
800	<	lockStarted = true;
801	<
802	<	while (!canAwake) {
803	<	c.awaitUninterruptibly();
804	<	}
805	<
806	<	interrupted = isInterrupted();
807	<	lock.unlock();
808	<	}
1004	>	awaitTermination(t);
1005		}
1006
1007		/**
1008		* awaitUninterruptibly doesn't abort on interrupt
1009		*/
1010	<	public void testAwaitUninterruptibly() throws InterruptedException {
1011	<	final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
1010	>	public void testAwaitUninterruptibly() { testAwaitUninterruptibly(false); }
1011	>	public void testAwaitUninterruptibly_fair() { testAwaitUninterruptibly(true); }
1012	>	public void testAwaitUninterruptibly(boolean fair) {
1013	>	final ReentrantReadWriteLock lock = new ReentrantReadWriteLock(fair);
1014		final Condition c = lock.writeLock().newCondition();
1015	<	UninterruptableThread thread = new UninterruptableThread(lock.writeLock(), c);
1016	<
1017	<	thread.start();
1018	<
1019	<	while (!thread.lockStarted) {
1020	<	Thread.sleep(100);
1021	<	}
1015	>	final CountDownLatch locked = new CountDownLatch(1);
1016	>	Thread t = newStartedThread(new CheckedRunnable() {
1017	>	public void realRun() {
1018	>	lock.writeLock().lock();
1019	>	locked.countDown();
1020	>	c.awaitUninterruptibly();
1021	>	assertTrue(Thread.interrupted());
1022	>	lock.writeLock().unlock();
1023	>	}});
1024
1025	+	await(locked);
1026		lock.writeLock().lock();
1027	<	try {
1028	<	thread.interrupt();
1029	<	thread.canAwake = true;
1030	<	c.signal();
1031	<	} finally {
1032	<	lock.writeLock().unlock();
1033	<	}
1034	<
834	<	thread.join();
835	<	assertTrue(thread.interrupted);
836	<	assertFalse(thread.isAlive());
1027	>	lock.writeLock().unlock();
1028	>	t.interrupt();
1029	>	long timeoutMillis = 10;
1030	>	assertThreadStaysAlive(t, timeoutMillis);
1031	>	lock.writeLock().lock();
1032	>	c.signal();
1033	>	lock.writeLock().unlock();
1034	>	awaitTermination(t);
1035		}
1036
1037		/**
1038	<	* await is interruptible
1038	>	* await/awaitNanos/awaitUntil is interruptible
1039		*/
1040	<	public void testAwait_Interrupt() throws InterruptedException {
1041	<	final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
1040	>	public void testInterruptible_await() { testInterruptible(false, AwaitMethod.await); }
1041	>	public void testInterruptible_await_fair() { testInterruptible(true, AwaitMethod.await); }
1042	>	public void testInterruptible_awaitTimed() { testInterruptible(false, AwaitMethod.awaitTimed); }
1043	>	public void testInterruptible_awaitTimed_fair() { testInterruptible(true, AwaitMethod.awaitTimed); }
1044	>	public void testInterruptible_awaitNanos() { testInterruptible(false, AwaitMethod.awaitNanos); }
1045	>	public void testInterruptible_awaitNanos_fair() { testInterruptible(true, AwaitMethod.awaitNanos); }
1046	>	public void testInterruptible_awaitUntil() { testInterruptible(false, AwaitMethod.awaitUntil); }
1047	>	public void testInterruptible_awaitUntil_fair() { testInterruptible(true, AwaitMethod.awaitUntil); }
1048	>	public void testInterruptible(boolean fair, final AwaitMethod awaitMethod) {
1049	>	final PublicReentrantReadWriteLock lock =
1050	>	new PublicReentrantReadWriteLock(fair);
1051		final Condition c = lock.writeLock().newCondition();
1052	+	final CountDownLatch locked = new CountDownLatch(1);
1053		Thread t = newStartedThread(new CheckedInterruptedRunnable() {
1054		public void realRun() throws InterruptedException {
1055		lock.writeLock().lock();
1056	<	c.await();
1057	<	lock.writeLock().unlock();
1056	>	assertWriteLockedByMoi(lock);
1057	>	assertHasNoWaiters(lock, c);
1058	>	locked.countDown();
1059	>	try {
1060	>	await(c, awaitMethod);
1061	>	} finally {
1062	>	assertWriteLockedByMoi(lock);
1063	>	assertHasNoWaiters(lock, c);
1064	>	lock.writeLock().unlock();
1065	>	assertFalse(Thread.interrupted());
1066	>	}
1067		}});
1068
1069	<	Thread.sleep(SHORT_DELAY_MS);
1069	>	await(locked);
1070	>	assertHasWaiters(lock, c, t);
1071		t.interrupt();
1072	<	t.join(SHORT_DELAY_MS);
1073	<	assertFalse(t.isAlive());
1072	>	awaitTermination(t);
1073	>	assertNotWriteLocked(lock);
1074		}
1075
1076		/**
1077	<	* awaitNanos is interruptible
1077	>	* signalAll wakes up all threads
1078		*/
1079	<	public void testAwaitNanos_Interrupt() throws InterruptedException {
1080	<	final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
1079	>	public void testSignalAll_await() { testSignalAll(false, AwaitMethod.await); }
1080	>	public void testSignalAll_await_fair() { testSignalAll(true, AwaitMethod.await); }
1081	>	public void testSignalAll_awaitTimed() { testSignalAll(false, AwaitMethod.awaitTimed); }
1082	>	public void testSignalAll_awaitTimed_fair() { testSignalAll(true, AwaitMethod.awaitTimed); }
1083	>	public void testSignalAll_awaitNanos() { testSignalAll(false, AwaitMethod.awaitNanos); }
1084	>	public void testSignalAll_awaitNanos_fair() { testSignalAll(true, AwaitMethod.awaitNanos); }
1085	>	public void testSignalAll_awaitUntil() { testSignalAll(false, AwaitMethod.awaitUntil); }
1086	>	public void testSignalAll_awaitUntil_fair() { testSignalAll(true, AwaitMethod.awaitUntil); }
1087	>	public void testSignalAll(boolean fair, final AwaitMethod awaitMethod) {
1088	>	final PublicReentrantReadWriteLock lock =
1089	>	new PublicReentrantReadWriteLock(fair);
1090		final Condition c = lock.writeLock().newCondition();
1091	<	Thread t = newStartedThread(new CheckedInterruptedRunnable() {
1091	>	final CountDownLatch locked = new CountDownLatch(2);
1092	>	final Lock writeLock = lock.writeLock();
1093	>	class Awaiter extends CheckedRunnable {
1094		public void realRun() throws InterruptedException {
1095	<	lock.writeLock().lock();
1096	<	c.awaitNanos(MILLISECONDS.toNanos(LONG_DELAY_MS));
1097	<	lock.writeLock().unlock();
1098	<	}});
1095	>	writeLock.lock();
1096	>	locked.countDown();
1097	>	await(c, awaitMethod);
1098	>	writeLock.unlock();
1099	>	}
1100	>	}
1101
1102	<	Thread.sleep(SHORT_DELAY_MS);
1103	<	t.interrupt();
1104	<	t.join(SHORT_DELAY_MS);
1105	<	assertFalse(t.isAlive());
1102	>	Thread t1 = newStartedThread(new Awaiter());
1103	>	Thread t2 = newStartedThread(new Awaiter());
1104	>
1105	>	await(locked);
1106	>	writeLock.lock();
1107	>	assertHasWaiters(lock, c, t1, t2);
1108	>	c.signalAll();
1109	>	assertHasNoWaiters(lock, c);
1110	>	writeLock.unlock();
1111	>	awaitTermination(t1);
1112	>	awaitTermination(t2);
1113		}
1114
1115		/**
1116	<	* awaitUntil is interruptible
1116	>	* signal wakes up waiting threads in FIFO order
1117		*/
1118	<	public void testAwaitUntil_Interrupt() throws InterruptedException {
1119	<	final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
1118	>	public void testSignalWakesFifo() { testSignalWakesFifo(false); }
1119	>	public void testSignalWakesFifo_fair() { testSignalWakesFifo(true); }
1120	>	public void testSignalWakesFifo(boolean fair) {
1121	>	final PublicReentrantReadWriteLock lock =
1122	>	new PublicReentrantReadWriteLock(fair);
1123		final Condition c = lock.writeLock().newCondition();
1124	<	Thread t = newStartedThread(new CheckedInterruptedRunnable() {
1124	>	final CountDownLatch locked1 = new CountDownLatch(1);
1125	>	final CountDownLatch locked2 = new CountDownLatch(1);
1126	>	final Lock writeLock = lock.writeLock();
1127	>	Thread t1 = newStartedThread(new CheckedRunnable() {
1128		public void realRun() throws InterruptedException {
1129	<	lock.writeLock().lock();
1130	<	java.util.Date d = new java.util.Date();
1131	<	c.awaitUntil(new java.util.Date(d.getTime() + 10000));
1132	<	lock.writeLock().unlock();
1129	>	writeLock.lock();
1130	>	locked1.countDown();
1131	>	c.await();
1132	>	writeLock.unlock();
1133		}});
1134
1135	<	Thread.sleep(SHORT_DELAY_MS);
1136	<	t.interrupt();
1137	<	t.join(SHORT_DELAY_MS);
1138	<	assertFalse(t.isAlive());
1135	>	await(locked1);
1136	>
1137	>	Thread t2 = newStartedThread(new CheckedRunnable() {
1138	>	public void realRun() throws InterruptedException {
1139	>	writeLock.lock();
1140	>	locked2.countDown();
1141	>	c.await();
1142	>	writeLock.unlock();
1143	>	}});
1144	>
1145	>	await(locked2);
1146	>
1147	>	writeLock.lock();
1148	>	assertHasWaiters(lock, c, t1, t2);
1149	>	assertFalse(lock.hasQueuedThreads());
1150	>	c.signal();
1151	>	assertHasWaiters(lock, c, t2);
1152	>	assertTrue(lock.hasQueuedThread(t1));
1153	>	assertFalse(lock.hasQueuedThread(t2));
1154	>	c.signal();
1155	>	assertHasNoWaiters(lock, c);
1156	>	assertTrue(lock.hasQueuedThread(t1));
1157	>	assertTrue(lock.hasQueuedThread(t2));
1158	>	writeLock.unlock();
1159	>	awaitTermination(t1);
1160	>	awaitTermination(t2);
1161		}
1162
1163		/**
1164	<	* signalAll wakes up all threads
1165	<	*/
1166	<	public void testSignalAll() throws InterruptedException {
1167	<	final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
1164	>	* await after multiple reentrant locking preserves lock count
1165	>	*/
1166	>	public void testAwaitLockCount() { testAwaitLockCount(false); }
1167	>	public void testAwaitLockCount_fair() { testAwaitLockCount(true); }
1168	>	public void testAwaitLockCount(boolean fair) {
1169	>	final PublicReentrantReadWriteLock lock =
1170	>	new PublicReentrantReadWriteLock(fair);
1171		final Condition c = lock.writeLock().newCondition();
1172	+	final CountDownLatch locked = new CountDownLatch(2);
1173		Thread t1 = newStartedThread(new CheckedRunnable() {
1174		public void realRun() throws InterruptedException {
1175		lock.writeLock().lock();
1176	+	assertWriteLockedByMoi(lock);
1177	+	assertEquals(1, lock.writeLock().getHoldCount());
1178	+	locked.countDown();
1179		c.await();
1180	+	assertWriteLockedByMoi(lock);
1181	+	assertEquals(1, lock.writeLock().getHoldCount());
1182		lock.writeLock().unlock();
1183		}});
1184
1185		Thread t2 = newStartedThread(new CheckedRunnable() {
1186		public void realRun() throws InterruptedException {
1187		lock.writeLock().lock();
1188	+	lock.writeLock().lock();
1189	+	assertWriteLockedByMoi(lock);
1190	+	assertEquals(2, lock.writeLock().getHoldCount());
1191	+	locked.countDown();
1192		c.await();
1193	+	assertWriteLockedByMoi(lock);
1194	+	assertEquals(2, lock.writeLock().getHoldCount());
1195	+	lock.writeLock().unlock();
1196		lock.writeLock().unlock();
1197		}});
1198
1199	<	Thread.sleep(SHORT_DELAY_MS);
1199	>	await(locked);
1200		lock.writeLock().lock();
1201	+	assertHasWaiters(lock, c, t1, t2);
1202		c.signalAll();
1203	+	assertHasNoWaiters(lock, c);
1204		lock.writeLock().unlock();
1205	<	t1.join(SHORT_DELAY_MS);
1206	<	t2.join(SHORT_DELAY_MS);
923	<	assertFalse(t1.isAlive());
924	<	assertFalse(t2.isAlive());
1205	>	awaitTermination(t1);
1206	>	awaitTermination(t2);
1207		}
1208
1209		/**
1210		* A serialized lock deserializes as unlocked
1211		*/
1212	<	public void testSerialization() throws Exception {
1213	<	ReentrantReadWriteLock l = new ReentrantReadWriteLock();
1214	<	l.readLock().lock();
1215	<	l.readLock().unlock();
1216	<
1217	<	ByteArrayOutputStream bout = new ByteArrayOutputStream(10000);
1218	<	ObjectOutputStream out = new ObjectOutputStream(new BufferedOutputStream(bout));
1219	<	out.writeObject(l);
1220	<	out.close();
1221	<
1222	<	ByteArrayInputStream bin = new ByteArrayInputStream(bout.toByteArray());
1223	<	ObjectInputStream in = new ObjectInputStream(new BufferedInputStream(bin));
1224	<	ReentrantReadWriteLock r = (ReentrantReadWriteLock) in.readObject();
1225	<	r.readLock().lock();
1226	<	r.readLock().unlock();
1212	>	public void testSerialization() { testSerialization(false); }
1213	>	public void testSerialization_fair() { testSerialization(true); }
1214	>	public void testSerialization(boolean fair) {
1215	>	ReentrantReadWriteLock lock = new ReentrantReadWriteLock(fair);
1216	>	lock.writeLock().lock();
1217	>	lock.readLock().lock();
1218	>
1219	>	ReentrantReadWriteLock clone = serialClone(lock);
1220	>	assertEquals(lock.isFair(), clone.isFair());
1221	>	assertTrue(lock.isWriteLocked());
1222	>	assertFalse(clone.isWriteLocked());
1223	>	assertEquals(1, lock.getReadLockCount());
1224	>	assertEquals(0, clone.getReadLockCount());
1225	>	clone.writeLock().lock();
1226	>	clone.readLock().lock();
1227	>	assertTrue(clone.isWriteLocked());
1228	>	assertEquals(1, clone.getReadLockCount());
1229	>	clone.readLock().unlock();
1230	>	clone.writeLock().unlock();
1231	>	assertFalse(clone.isWriteLocked());
1232	>	assertEquals(1, lock.getReadLockCount());
1233	>	assertEquals(0, clone.getReadLockCount());
1234		}
1235
1236		/**
1237		* hasQueuedThreads reports whether there are waiting threads
1238		*/
1239	<	public void testhasQueuedThreads() throws InterruptedException {
1240	<	final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
1239	>	public void testHasQueuedThreads() { testHasQueuedThreads(false); }
1240	>	public void testHasQueuedThreads_fair() { testHasQueuedThreads(true); }
1241	>	public void testHasQueuedThreads(boolean fair) {
1242	>	final PublicReentrantReadWriteLock lock =
1243	>	new PublicReentrantReadWriteLock(fair);
1244		Thread t1 = new Thread(new InterruptedLockRunnable(lock));
1245		Thread t2 = new Thread(new InterruptibleLockRunnable(lock));
1246		assertFalse(lock.hasQueuedThreads());
1247		lock.writeLock().lock();
1248	+	assertFalse(lock.hasQueuedThreads());
1249		t1.start();
1250	<	Thread.sleep(SHORT_DELAY_MS);
1250	>	waitForQueuedThread(lock, t1);
1251		assertTrue(lock.hasQueuedThreads());
1252		t2.start();
1253	<	Thread.sleep(SHORT_DELAY_MS);
1253	>	waitForQueuedThread(lock, t2);
1254		assertTrue(lock.hasQueuedThreads());
1255		t1.interrupt();
1256	<	Thread.sleep(SHORT_DELAY_MS);
1256	>	awaitTermination(t1);
1257		assertTrue(lock.hasQueuedThreads());
1258		lock.writeLock().unlock();
1259	<	Thread.sleep(SHORT_DELAY_MS);
1259	>	awaitTermination(t2);
1260		assertFalse(lock.hasQueuedThreads());
968	–	t1.join();
969	–	t2.join();
1261		}
1262
1263		/**
1264		* hasQueuedThread(null) throws NPE
1265		*/
1266	<	public void testHasQueuedThreadNPE() {
1267	<	final ReentrantReadWriteLock sync = new ReentrantReadWriteLock();
1266	>	public void testHasQueuedThreadNPE() { testHasQueuedThreadNPE(false); }
1267	>	public void testHasQueuedThreadNPE_fair() { testHasQueuedThreadNPE(true); }
1268	>	public void testHasQueuedThreadNPE(boolean fair) {
1269	>	final ReentrantReadWriteLock lock = new ReentrantReadWriteLock(fair);
1270		try {
1271	<	sync.hasQueuedThread(null);
1271	>	lock.hasQueuedThread(null);
1272		shouldThrow();
1273		} catch (NullPointerException success) {}
1274		}
1275
1276		/**
1277	<	* hasQueuedThread reports whether a thread is queued.
1277	>	* hasQueuedThread reports whether a thread is queued
1278		*/
1279	<	public void testHasQueuedThread() throws InterruptedException {
1280	<	final ReentrantReadWriteLock sync = new ReentrantReadWriteLock();
1281	<	Thread t1 = new Thread(new InterruptedLockRunnable(sync));
1282	<	Thread t2 = new Thread(new InterruptibleLockRunnable(sync));
1283	<	assertFalse(sync.hasQueuedThread(t1));
1284	<	assertFalse(sync.hasQueuedThread(t2));
1285	<	sync.writeLock().lock();
1279	>	public void testHasQueuedThread() { testHasQueuedThread(false); }
1280	>	public void testHasQueuedThread_fair() { testHasQueuedThread(true); }
1281	>	public void testHasQueuedThread(boolean fair) {
1282	>	final PublicReentrantReadWriteLock lock =
1283	>	new PublicReentrantReadWriteLock(fair);
1284	>	Thread t1 = new Thread(new InterruptedLockRunnable(lock));
1285	>	Thread t2 = new Thread(new InterruptibleLockRunnable(lock));
1286	>	assertFalse(lock.hasQueuedThread(t1));
1287	>	assertFalse(lock.hasQueuedThread(t2));
1288	>	lock.writeLock().lock();
1289		t1.start();
1290	<	Thread.sleep(SHORT_DELAY_MS);
1291	<	assertTrue(sync.hasQueuedThread(t1));
1290	>	waitForQueuedThread(lock, t1);
1291	>	assertTrue(lock.hasQueuedThread(t1));
1292	>	assertFalse(lock.hasQueuedThread(t2));
1293		t2.start();
1294	<	Thread.sleep(SHORT_DELAY_MS);
1295	<	assertTrue(sync.hasQueuedThread(t1));
1296	<	assertTrue(sync.hasQueuedThread(t2));
1294	>	waitForQueuedThread(lock, t2);
1295	>	assertTrue(lock.hasQueuedThread(t1));
1296	>	assertTrue(lock.hasQueuedThread(t2));
1297		t1.interrupt();
1298	<	Thread.sleep(SHORT_DELAY_MS);
1299	<	assertFalse(sync.hasQueuedThread(t1));
1300	<	assertTrue(sync.hasQueuedThread(t2));
1301	<	sync.writeLock().unlock();
1302	<	Thread.sleep(SHORT_DELAY_MS);
1303	<	assertFalse(sync.hasQueuedThread(t1));
1304	<	Thread.sleep(SHORT_DELAY_MS);
1008	<	assertFalse(sync.hasQueuedThread(t2));
1009	<	t1.join();
1010	<	t2.join();
1298	>	awaitTermination(t1);
1299	>	assertFalse(lock.hasQueuedThread(t1));
1300	>	assertTrue(lock.hasQueuedThread(t2));
1301	>	lock.writeLock().unlock();
1302	>	awaitTermination(t2);
1303	>	assertFalse(lock.hasQueuedThread(t1));
1304	>	assertFalse(lock.hasQueuedThread(t2));
1305		}
1306
1013	–
1307		/**
1308		* getQueueLength reports number of waiting threads
1309		*/
1310	<	public void testGetQueueLength() throws InterruptedException {
1311	<	final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
1310	>	public void testGetQueueLength() { testGetQueueLength(false); }
1311	>	public void testGetQueueLength_fair() { testGetQueueLength(true); }
1312	>	public void testGetQueueLength(boolean fair) {
1313	>	final PublicReentrantReadWriteLock lock =
1314	>	new PublicReentrantReadWriteLock(fair);
1315		Thread t1 = new Thread(new InterruptedLockRunnable(lock));
1316		Thread t2 = new Thread(new InterruptibleLockRunnable(lock));
1317		assertEquals(0, lock.getQueueLength());
1318		lock.writeLock().lock();
1319		t1.start();
1320	<	Thread.sleep(SHORT_DELAY_MS);
1320	>	waitForQueuedThread(lock, t1);
1321		assertEquals(1, lock.getQueueLength());
1322		t2.start();
1323	<	Thread.sleep(SHORT_DELAY_MS);
1323	>	waitForQueuedThread(lock, t2);
1324		assertEquals(2, lock.getQueueLength());
1325		t1.interrupt();
1326	<	Thread.sleep(SHORT_DELAY_MS);
1326	>	awaitTermination(t1);
1327		assertEquals(1, lock.getQueueLength());
1328		lock.writeLock().unlock();
1329	<	Thread.sleep(SHORT_DELAY_MS);
1329	>	awaitTermination(t2);
1330		assertEquals(0, lock.getQueueLength());
1035	–	t1.join();
1036	–	t2.join();
1331		}
1332
1333		/**
1334		* getQueuedThreads includes waiting threads
1335		*/
1336	<	public void testGetQueuedThreads() throws InterruptedException {
1337	<	final PublicReentrantReadWriteLock lock = new PublicReentrantReadWriteLock();
1336	>	public void testGetQueuedThreads() { testGetQueuedThreads(false); }
1337	>	public void testGetQueuedThreads_fair() { testGetQueuedThreads(true); }
1338	>	public void testGetQueuedThreads(boolean fair) {
1339	>	final PublicReentrantReadWriteLock lock =
1340	>	new PublicReentrantReadWriteLock(fair);
1341		Thread t1 = new Thread(new InterruptedLockRunnable(lock));
1342		Thread t2 = new Thread(new InterruptibleLockRunnable(lock));
1343		assertTrue(lock.getQueuedThreads().isEmpty());
1344		lock.writeLock().lock();
1345		assertTrue(lock.getQueuedThreads().isEmpty());
1346		t1.start();
1347	<	Thread.sleep(SHORT_DELAY_MS);
1347	>	waitForQueuedThread(lock, t1);
1348	>	assertEquals(1, lock.getQueuedThreads().size());
1349		assertTrue(lock.getQueuedThreads().contains(t1));
1350		t2.start();
1351	<	Thread.sleep(SHORT_DELAY_MS);
1351	>	waitForQueuedThread(lock, t2);
1352	>	assertEquals(2, lock.getQueuedThreads().size());
1353		assertTrue(lock.getQueuedThreads().contains(t1));
1354		assertTrue(lock.getQueuedThreads().contains(t2));
1355		t1.interrupt();
1356	<	Thread.sleep(SHORT_DELAY_MS);
1356	>	awaitTermination(t1);
1357		assertFalse(lock.getQueuedThreads().contains(t1));
1358		assertTrue(lock.getQueuedThreads().contains(t2));
1359	+	assertEquals(1, lock.getQueuedThreads().size());
1360		lock.writeLock().unlock();
1361	<	Thread.sleep(SHORT_DELAY_MS);
1361	>	awaitTermination(t2);
1362		assertTrue(lock.getQueuedThreads().isEmpty());
1063	–	t1.join();
1064	–	t2.join();
1363		}
1364
1365		/**
1366		* hasWaiters throws NPE if null
1367		*/
1368	<	public void testHasWaitersNPE() {
1369	<	final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
1368	>	public void testHasWaitersNPE() { testHasWaitersNPE(false); }
1369	>	public void testHasWaitersNPE_fair() { testHasWaitersNPE(true); }
1370	>	public void testHasWaitersNPE(boolean fair) {
1371	>	final ReentrantReadWriteLock lock = new ReentrantReadWriteLock(fair);
1372		try {
1373		lock.hasWaiters(null);
1374		shouldThrow();
#	Line 1078 \| Line 1378 \| public class ReentrantReadWriteLockTest
1378		/**
1379		* getWaitQueueLength throws NPE if null
1380		*/
1381	<	public void testGetWaitQueueLengthNPE() {
1382	<	final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
1381	>	public void testGetWaitQueueLengthNPE() { testGetWaitQueueLengthNPE(false); }
1382	>	public void testGetWaitQueueLengthNPE_fair() { testGetWaitQueueLengthNPE(true); }
1383	>	public void testGetWaitQueueLengthNPE(boolean fair) {
1384	>	final ReentrantReadWriteLock lock = new ReentrantReadWriteLock(fair);
1385		try {
1386		lock.getWaitQueueLength(null);
1387		shouldThrow();
1388		} catch (NullPointerException success) {}
1389		}
1390
1089	–
1391		/**
1392		* getWaitingThreads throws NPE if null
1393		*/
1394	<	public void testGetWaitingThreadsNPE() {
1395	<	final PublicReentrantReadWriteLock lock = new PublicReentrantReadWriteLock();
1394	>	public void testGetWaitingThreadsNPE() { testGetWaitingThreadsNPE(false); }
1395	>	public void testGetWaitingThreadsNPE_fair() { testGetWaitingThreadsNPE(true); }
1396	>	public void testGetWaitingThreadsNPE(boolean fair) {
1397	>	final PublicReentrantReadWriteLock lock = new PublicReentrantReadWriteLock(fair);
1398		try {
1399		lock.getWaitingThreads(null);
1400		shouldThrow();
#	Line 1099 \| Line 1402 \| public class ReentrantReadWriteLockTest
1402		}
1403
1404		/**
1405	<	* hasWaiters throws IAE if not owned
1405	>	* hasWaiters throws IllegalArgumentException if not owned
1406		*/
1407	<	public void testHasWaitersIAE() {
1408	<	final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
1407	>	public void testHasWaitersIAE() { testHasWaitersIAE(false); }
1408	>	public void testHasWaitersIAE_fair() { testHasWaitersIAE(true); }
1409	>	public void testHasWaitersIAE(boolean fair) {
1410	>	final ReentrantReadWriteLock lock = new ReentrantReadWriteLock(fair);
1411		final Condition c = lock.writeLock().newCondition();
1412	<	final ReentrantReadWriteLock lock2 = new ReentrantReadWriteLock();
1412	>	final ReentrantReadWriteLock lock2 = new ReentrantReadWriteLock(fair);
1413		try {
1414		lock2.hasWaiters(c);
1415		shouldThrow();
#	Line 1112 \| Line 1417 \| public class ReentrantReadWriteLockTest
1417		}
1418
1419		/**
1420	<	* hasWaiters throws IMSE if not locked
1420	>	* hasWaiters throws IllegalMonitorStateException if not locked
1421		*/
1422	<	public void testHasWaitersIMSE() {
1423	<	final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
1422	>	public void testHasWaitersIMSE() { testHasWaitersIMSE(false); }
1423	>	public void testHasWaitersIMSE_fair() { testHasWaitersIMSE(true); }
1424	>	public void testHasWaitersIMSE(boolean fair) {
1425	>	final ReentrantReadWriteLock lock = new ReentrantReadWriteLock(fair);
1426		final Condition c = lock.writeLock().newCondition();
1427		try {
1428		lock.hasWaiters(c);
#	Line 1123 \| Line 1430 \| public class ReentrantReadWriteLockTest
1430		} catch (IllegalMonitorStateException success) {}
1431		}
1432
1126	–
1433		/**
1434	<	* getWaitQueueLength throws IAE if not owned
1434	>	* getWaitQueueLength throws IllegalArgumentException if not owned
1435		*/
1436	<	public void testGetWaitQueueLengthIAE() {
1437	<	final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
1436	>	public void testGetWaitQueueLengthIAE() { testGetWaitQueueLengthIAE(false); }
1437	>	public void testGetWaitQueueLengthIAE_fair() { testGetWaitQueueLengthIAE(true); }
1438	>	public void testGetWaitQueueLengthIAE(boolean fair) {
1439	>	final ReentrantReadWriteLock lock = new ReentrantReadWriteLock(fair);
1440		final Condition c = lock.writeLock().newCondition();
1441	<	final ReentrantReadWriteLock lock2 = new ReentrantReadWriteLock();
1441	>	final ReentrantReadWriteLock lock2 = new ReentrantReadWriteLock(fair);
1442		try {
1443		lock2.getWaitQueueLength(c);
1444		shouldThrow();
#	Line 1138 \| Line 1446 \| public class ReentrantReadWriteLockTest
1446		}
1447
1448		/**
1449	<	* getWaitQueueLength throws IMSE if not locked
1449	>	* getWaitQueueLength throws IllegalMonitorStateException if not locked
1450		*/
1451	<	public void testGetWaitQueueLengthIMSE() {
1452	<	final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
1451	>	public void testGetWaitQueueLengthIMSE() { testGetWaitQueueLengthIMSE(false); }
1452	>	public void testGetWaitQueueLengthIMSE_fair() { testGetWaitQueueLengthIMSE(true); }
1453	>	public void testGetWaitQueueLengthIMSE(boolean fair) {
1454	>	final ReentrantReadWriteLock lock = new ReentrantReadWriteLock(fair);
1455		final Condition c = lock.writeLock().newCondition();
1456		try {
1457		lock.getWaitQueueLength(c);
#	Line 1149 \| Line 1459 \| public class ReentrantReadWriteLockTest
1459		} catch (IllegalMonitorStateException success) {}
1460		}
1461
1152	–
1462		/**
1463	<	* getWaitingThreads throws IAE if not owned
1463	>	* getWaitingThreads throws IllegalArgumentException if not owned
1464		*/
1465	<	public void testGetWaitingThreadsIAE() {
1466	<	final PublicReentrantReadWriteLock lock = new PublicReentrantReadWriteLock();
1465	>	public void testGetWaitingThreadsIAE() { testGetWaitingThreadsIAE(false); }
1466	>	public void testGetWaitingThreadsIAE_fair() { testGetWaitingThreadsIAE(true); }
1467	>	public void testGetWaitingThreadsIAE(boolean fair) {
1468	>	final PublicReentrantReadWriteLock lock =
1469	>	new PublicReentrantReadWriteLock(fair);
1470		final Condition c = lock.writeLock().newCondition();
1471	<	final PublicReentrantReadWriteLock lock2 = new PublicReentrantReadWriteLock();
1471	>	final PublicReentrantReadWriteLock lock2 =
1472	>	new PublicReentrantReadWriteLock(fair);
1473		try {
1474		lock2.getWaitingThreads(c);
1475		shouldThrow();
#	Line 1164 \| Line 1477 \| public class ReentrantReadWriteLockTest
1477		}
1478
1479		/**
1480	<	* getWaitingThreads throws IMSE if not locked
1480	>	* getWaitingThreads throws IllegalMonitorStateException if not locked
1481		*/
1482	<	public void testGetWaitingThreadsIMSE() {
1483	<	final PublicReentrantReadWriteLock lock = new PublicReentrantReadWriteLock();
1482	>	public void testGetWaitingThreadsIMSE() { testGetWaitingThreadsIMSE(false); }
1483	>	public void testGetWaitingThreadsIMSE_fair() { testGetWaitingThreadsIMSE(true); }
1484	>	public void testGetWaitingThreadsIMSE(boolean fair) {
1485	>	final PublicReentrantReadWriteLock lock =
1486	>	new PublicReentrantReadWriteLock(fair);
1487		final Condition c = lock.writeLock().newCondition();
1488		try {
1489		lock.getWaitingThreads(c);
#	Line 1175 \| Line 1491 \| public class ReentrantReadWriteLockTest
1491		} catch (IllegalMonitorStateException success) {}
1492		}
1493
1178	–
1494		/**
1495		* hasWaiters returns true when a thread is waiting, else false
1496		*/
1497	<	public void testHasWaiters() throws InterruptedException {
1498	<	final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
1497	>	public void testHasWaiters() { testHasWaiters(false); }
1498	>	public void testHasWaiters_fair() { testHasWaiters(true); }
1499	>	public void testHasWaiters(boolean fair) {
1500	>	final PublicReentrantReadWriteLock lock =
1501	>	new PublicReentrantReadWriteLock(fair);
1502		final Condition c = lock.writeLock().newCondition();
1503	+	final CountDownLatch locked = new CountDownLatch(1);
1504		Thread t = newStartedThread(new CheckedRunnable() {
1505		public void realRun() throws InterruptedException {
1506		lock.writeLock().lock();
1507	+	assertHasNoWaiters(lock, c);
1508		assertFalse(lock.hasWaiters(c));
1509	<	assertEquals(0, lock.getWaitQueueLength(c));
1509	>	locked.countDown();
1510		c.await();
1511	+	assertHasNoWaiters(lock, c);
1512	+	assertFalse(lock.hasWaiters(c));
1513		lock.writeLock().unlock();
1514		}});
1515
1516	<	Thread.sleep(SHORT_DELAY_MS);
1516	>	await(locked);
1517		lock.writeLock().lock();
1518	+	assertHasWaiters(lock, c, t);
1519		assertTrue(lock.hasWaiters(c));
1197	–	assertEquals(1, lock.getWaitQueueLength(c));
1520		c.signal();
1521	<	lock.writeLock().unlock();
1200	<	Thread.sleep(SHORT_DELAY_MS);
1201	<	lock.writeLock().lock();
1521	>	assertHasNoWaiters(lock, c);
1522		assertFalse(lock.hasWaiters(c));
1203	–	assertEquals(0, lock.getWaitQueueLength(c));
1523		lock.writeLock().unlock();
1524	<	t.join(SHORT_DELAY_MS);
1525	<	assertFalse(t.isAlive());
1524	>	awaitTermination(t);
1525	>	assertHasNoWaiters(lock, c);
1526		}
1527
1528		/**
1529		* getWaitQueueLength returns number of waiting threads
1530		*/
1531	<	public void testGetWaitQueueLength() throws InterruptedException {
1532	<	final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
1531	>	public void testGetWaitQueueLength() { testGetWaitQueueLength(false); }
1532	>	public void testGetWaitQueueLength_fair() { testGetWaitQueueLength(true); }
1533	>	public void testGetWaitQueueLength(boolean fair) {
1534	>	final PublicReentrantReadWriteLock lock =
1535	>	new PublicReentrantReadWriteLock(fair);
1536		final Condition c = lock.writeLock().newCondition();
1537	+	final CountDownLatch locked = new CountDownLatch(1);
1538		Thread t = newStartedThread(new CheckedRunnable() {
1539		public void realRun() throws InterruptedException {
1540		lock.writeLock().lock();
1218	–	assertFalse(lock.hasWaiters(c));
1541		assertEquals(0, lock.getWaitQueueLength(c));
1542	+	locked.countDown();
1543		c.await();
1544		lock.writeLock().unlock();
1545		}});
1546
1547	<	Thread.sleep(SHORT_DELAY_MS);
1547	>	await(locked);
1548		lock.writeLock().lock();
1549	<	assertTrue(lock.hasWaiters(c));
1549	>	assertHasWaiters(lock, c, t);
1550		assertEquals(1, lock.getWaitQueueLength(c));
1551		c.signal();
1552	<	lock.writeLock().unlock();
1230	<	Thread.sleep(SHORT_DELAY_MS);
1231	<	lock.writeLock().lock();
1232	<	assertFalse(lock.hasWaiters(c));
1552	>	assertHasNoWaiters(lock, c);
1553		assertEquals(0, lock.getWaitQueueLength(c));
1554		lock.writeLock().unlock();
1555	<	t.join(SHORT_DELAY_MS);
1236	<	assertFalse(t.isAlive());
1555	>	awaitTermination(t);
1556		}
1557
1239	–
1558		/**
1559		* getWaitingThreads returns only and all waiting threads
1560		*/
1561	<	public void testGetWaitingThreads() throws InterruptedException {
1562	<	final PublicReentrantReadWriteLock lock = new PublicReentrantReadWriteLock();
1561	>	public void testGetWaitingThreads() { testGetWaitingThreads(false); }
1562	>	public void testGetWaitingThreads_fair() { testGetWaitingThreads(true); }
1563	>	public void testGetWaitingThreads(boolean fair) {
1564	>	final PublicReentrantReadWriteLock lock =
1565	>	new PublicReentrantReadWriteLock(fair);
1566		final Condition c = lock.writeLock().newCondition();
1567	+	final CountDownLatch locked1 = new CountDownLatch(1);
1568	+	final CountDownLatch locked2 = new CountDownLatch(1);
1569		Thread t1 = new Thread(new CheckedRunnable() {
1570		public void realRun() throws InterruptedException {
1571		lock.writeLock().lock();
1572		assertTrue(lock.getWaitingThreads(c).isEmpty());
1573	+	locked1.countDown();
1574		c.await();
1575		lock.writeLock().unlock();
1576		}});
#	Line 1255 \| Line 1579 \| public class ReentrantReadWriteLockTest
1579		public void realRun() throws InterruptedException {
1580		lock.writeLock().lock();
1581		assertFalse(lock.getWaitingThreads(c).isEmpty());
1582	+	locked2.countDown();
1583		c.await();
1584		lock.writeLock().unlock();
1585		}});
#	Line 1262 \| Line 1587 \| public class ReentrantReadWriteLockTest
1587		lock.writeLock().lock();
1588		assertTrue(lock.getWaitingThreads(c).isEmpty());
1589		lock.writeLock().unlock();
1590	+
1591		t1.start();
1592	<	Thread.sleep(SHORT_DELAY_MS);
1592	>	await(locked1);
1593		t2.start();
1594	<	Thread.sleep(SHORT_DELAY_MS);
1594	>	await(locked2);
1595	>
1596		lock.writeLock().lock();
1597		assertTrue(lock.hasWaiters(c));
1598		assertTrue(lock.getWaitingThreads(c).contains(t1));
1599		assertTrue(lock.getWaitingThreads(c).contains(t2));
1600	+	assertEquals(2, lock.getWaitingThreads(c).size());
1601		c.signalAll();
1602	+	assertHasNoWaiters(lock, c);
1603		lock.writeLock().unlock();
1604	<	Thread.sleep(SHORT_DELAY_MS);
1605	<	lock.writeLock().lock();
1606	<	assertFalse(lock.hasWaiters(c));
1607	<	assertTrue(lock.getWaitingThreads(c).isEmpty());
1608	<	lock.writeLock().unlock();
1280	<	t1.join(SHORT_DELAY_MS);
1281	<	t2.join(SHORT_DELAY_MS);
1282	<	assertFalse(t1.isAlive());
1283	<	assertFalse(t2.isAlive());
1604	>
1605	>	awaitTermination(t1);
1606	>	awaitTermination(t2);
1607	>
1608	>	assertHasNoWaiters(lock, c);
1609		}
1610
1611		/**
1612		* toString indicates current lock state
1613		*/
1614	<	public void testToString() {
1615	<	ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
1616	<	String us = lock.toString();
1617	<	assertTrue(us.indexOf("Write locks = 0") >= 0);
1618	<	assertTrue(us.indexOf("Read locks = 0") >= 0);
1619	<	lock.writeLock().lock();
1620	<	String ws = lock.toString();
1621	<	assertTrue(ws.indexOf("Write locks = 1") >= 0);
1622	<	assertTrue(ws.indexOf("Read locks = 0") >= 0);
1614	>	public void testToString() { testToString(false); }
1615	>	public void testToString_fair() { testToString(true); }
1616	>	public void testToString(boolean fair) {
1617	>	ReentrantReadWriteLock lock = new ReentrantReadWriteLock(fair);
1618	>	assertTrue(lock.toString().contains("Write locks = 0"));
1619	>	assertTrue(lock.toString().contains("Read locks = 0"));
1620	>	lock.writeLock().lock();
1621	>	assertTrue(lock.toString().contains("Write locks = 1"));
1622	>	assertTrue(lock.toString().contains("Read locks = 0"));
1623		lock.writeLock().unlock();
1624		lock.readLock().lock();
1625		lock.readLock().lock();
1626	<	String rs = lock.toString();
1627	<	assertTrue(rs.indexOf("Write locks = 0") >= 0);
1303	<	assertTrue(rs.indexOf("Read locks = 2") >= 0);
1626	>	assertTrue(lock.toString().contains("Write locks = 0"));
1627	>	assertTrue(lock.toString().contains("Read locks = 2"));
1628		}
1629
1630		/**
1631		* readLock.toString indicates current lock state
1632		*/
1633	<	public void testReadLockToString() {
1634	<	ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
1635	<	String us = lock.readLock().toString();
1636	<	assertTrue(us.indexOf("Read locks = 0") >= 0);
1633	>	public void testReadLockToString() { testReadLockToString(false); }
1634	>	public void testReadLockToString_fair() { testReadLockToString(true); }
1635	>	public void testReadLockToString(boolean fair) {
1636	>	ReentrantReadWriteLock lock = new ReentrantReadWriteLock(fair);
1637	>	assertTrue(lock.readLock().toString().contains("Read locks = 0"));
1638		lock.readLock().lock();
1639		lock.readLock().lock();
1640	<	String rs = lock.readLock().toString();
1316	<	assertTrue(rs.indexOf("Read locks = 2") >= 0);
1640	>	assertTrue(lock.readLock().toString().contains("Read locks = 2"));
1641		}
1642
1643		/**
1644		* writeLock.toString indicates current lock state
1645		*/
1646	<	public void testWriteLockToString() {
1647	<	ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
1648	<	String us = lock.writeLock().toString();
1649	<	assertTrue(us.indexOf("Unlocked") >= 0);
1646	>	public void testWriteLockToString() { testWriteLockToString(false); }
1647	>	public void testWriteLockToString_fair() { testWriteLockToString(true); }
1648	>	public void testWriteLockToString(boolean fair) {
1649	>	ReentrantReadWriteLock lock = new ReentrantReadWriteLock(fair);
1650	>	assertTrue(lock.writeLock().toString().contains("Unlocked"));
1651		lock.writeLock().lock();
1652	<	String ls = lock.writeLock().toString();
1653	<	assertTrue(ls.indexOf("Locked") >= 0);
1652	>	assertTrue(lock.writeLock().toString().contains("Locked"));
1653	>	lock.writeLock().unlock();
1654	>	assertTrue(lock.writeLock().toString().contains("Unlocked"));
1655		}
1656
1657		}

Diff Legend

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

Comparing jsr166/src/test/tck/ReentrantReadWriteLockTest.java (file contents): Revision 1.45 by jsr166, Sun May 1 23:49:41 2011 UTC vs. Revision 1.65 by jsr166, Tue May 31 16:16:24 2011 UTC

Diff Legend

Comparing jsr166/src/test/tck/ReentrantReadWriteLockTest.java (file contents):
Revision 1.45 by jsr166, Sun May 1 23:49:41 2011 UTC vs.
Revision 1.65 by jsr166, Tue May 31 16:16:24 2011 UTC