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

Comparing jsr166/src/test/tck/ReentrantReadWriteLockTest.java (file contents):
Revision 1.54 by jsr166, Mon May 2 01:07:15 2011 UTC vs.
Revision 1.64 by jsr166, Tue May 24 23:40:14 2011 UTC

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

Diff Legend

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

Comparing jsr166/src/test/tck/ReentrantReadWriteLockTest.java (file contents): Revision 1.54 by jsr166, Mon May 2 01:07:15 2011 UTC vs. Revision 1.64 by jsr166, Tue May 24 23:40:14 2011 UTC

Diff Legend

Comparing jsr166/src/test/tck/ReentrantReadWriteLockTest.java (file contents):
Revision 1.54 by jsr166, Mon May 2 01:07:15 2011 UTC vs.
Revision 1.64 by jsr166, Tue May 24 23:40:14 2011 UTC