ViewVC Help

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

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

Comparing jsr166/src/test/tck/ReentrantReadWriteLockTest.java (file contents):
Revision 1.2 by dl, Sun Sep 7 20:39:11 2003 UTC vs.
Revision 1.56 by jsr166, Tue May 3 06:08:49 2011 UTC

#	Line 1 | Line 1
1		/*
2	<	* Written by members of JCP JSR-166 Expert Group and released to the
3	<	* public domain. Use, modify, and redistribute this code in any way
4	<	* without acknowledgement. Other contributors include Andrew Wright,
5	<	* Jeffrey Hayes, Pat Fischer, Mike Judd.
2	>	* Written by Doug Lea with assistance from members of JCP JSR-166
3	>	* Expert Group and released to the public domain, as explained at
4	>	* http://creativecommons.org/publicdomain/zero/1.0/
5	>	* Other contributors include Andrew Wright, Jeffrey Hayes,
6	>	* Pat Fisher, Mike Judd.
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;
14		import java.io.*;
15	+	import java.util.*;
16
17	<	public class ReentrantReadWriteLockTest extends TestCase {
14	<	static int HOLD_COUNT_TEST_LIMIT = 20;
15	<
17	>	public class ReentrantReadWriteLockTest extends JSR166TestCase {
18		public static void main(String[] args) {
19	<	junit.textui.TestRunner.run (suite());
19	>	junit.textui.TestRunner.run(suite());
20		}
19	–
21		public static Test suite() {
22	<	return new TestSuite(ReentrantReadWriteLockTest.class);
22	>	return new TestSuite(ReentrantReadWriteLockTest.class);
23		}
24
25	+	/**
26	+	* A runnable calling lockInterruptibly
27	+	*/
28	+	class InterruptibleLockRunnable extends CheckedRunnable {
29	+	final ReentrantReadWriteLock lock;
30	+	InterruptibleLockRunnable(ReentrantReadWriteLock l) { lock = l; }
31	+	public void realRun() throws InterruptedException {
32	+	lock.writeLock().lockInterruptibly();
33	+	}
34	+	}
35
36	<	private static long SHORT_DELAY_MS = 100;
37	<	private static long MEDIUM_DELAY_MS = 1000;
38	<	private static long LONG_DELAY_MS = 10000;
36	>	/**
37	>	* A runnable calling lockInterruptibly that expects to be
38	>	* interrupted
39	>	*/
40	>	class InterruptedLockRunnable extends CheckedInterruptedRunnable {
41	>	final ReentrantReadWriteLock lock;
42	>	InterruptedLockRunnable(ReentrantReadWriteLock l) { lock = l; }
43	>	public void realRun() throws InterruptedException {
44	>	lock.writeLock().lockInterruptibly();
45	>	}
46	>	}
47
48	<	/*
49	<	* Unlocks an unlocked lock, throws Illegal Monitor State
31	<	*
48	>	/**
49	>	* Subclass to expose protected methods
50		*/
51	<
52	<	public void testIllegalMonitorStateException(){
53	<	ReentrantReadWriteLock rl = new ReentrantReadWriteLock();
54	<	try{
55	<	rl.writeLock().unlock();
56	<	fail("Should of thown Illegal Monitor State Exception");
51	>	static class PublicReentrantReadWriteLock extends ReentrantReadWriteLock {
52	>	PublicReentrantReadWriteLock() { super(); }
53	>	public Collection<Thread> getQueuedThreads() {
54	>	return super.getQueuedThreads();
55	>	}
56	>	public Collection<Thread> getWaitingThreads(Condition c) {
57	>	return super.getWaitingThreads(c);
58	>	}
59	>	}
60
61	<	}catch(IllegalMonitorStateException success){}
61	>	/**
62	>	* Releases write lock, checking that it had a hold count of 1.
63	>	*/
64	>	void releaseWriteLock(ReentrantReadWriteLock lock) {
65	>	ReentrantReadWriteLock.WriteLock writeLock = lock.writeLock();
66	>	assertTrue(writeLock.isHeldByCurrentThread());
67	>	writeLock.unlock();
68	>	assertFalse(writeLock.isHeldByCurrentThread());
69		}
70
71	+	/**
72	+	* Spin-waits until lock.hasQueuedThread(t) becomes true.
73	+	*/
74	+	void waitForQueuedThread(ReentrantReadWriteLock lock, Thread t) {
75	+	long startTime = System.nanoTime();
76	+	while (!lock.hasQueuedThread(t)) {
77	+	if (millisElapsedSince(startTime) > LONG_DELAY_MS)
78	+	throw new AssertionError("timed out");
79	+	Thread.yield();
80	+	}
81	+	}
82
83	+	/**
84	+	* Checks that lock is not write-locked.
85	+	*/
86	+	void assertNotWriteLocked(ReentrantReadWriteLock lock) {
87	+	assertFalse(lock.isWriteLocked());
88	+	assertFalse(lock.isWriteLockedByCurrentThread());
89	+	assertEquals(0, lock.getWriteHoldCount());
90	+	}
91
92	<	public void testInterruptedException(){
93	<	final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
94	<	lock.writeLock().lock();
95	<	Thread t = new Thread(new Runnable() {
96	<	public void run(){
50	<	try{
51	<	lock.writeLock().lockInterruptibly();
52	<	fail("should throw");
53	<	}catch(InterruptedException success){}
54	<	}
55	<	});
56	<	try {
57	<	t.start();
58	<	t.interrupt();
59	<	lock.writeLock().unlock();
60	<	t.join();
61	<	} catch(Exception e){
62	<	fail("unexpected exception");
63	<	}
64	<	}
65	<
66	<	public void testInterruptedException2(){
67	<	final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
68	<	lock.writeLock().lock();
69	<	Thread t = new Thread(new Runnable() {
70	<	public void run(){
71	<	try{
72	<	lock.writeLock().tryLock(1000,TimeUnit.MILLISECONDS);
73	<	fail("should throw");
74	<	}catch(InterruptedException success){}
75	<	}
76	<	});
77	<	try {
78	<	t.start();
79	<	t.interrupt();
80	<	lock.writeLock().unlock();
81	<	t.join();
82	<	} catch(Exception e){
83	<	fail("unexpected exception");
84	<	}
92	>	/**
93	>	* Checks that condition c has no waiters.
94	>	*/
95	>	void assertHasNoWaiters(PublicReentrantReadWriteLock lock, Condition c) {
96	>	assertHasWaiters(lock, c, new Thread[] {});
97		}
98
99	<	public void testInterruptedException3(){
100	<	final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
101	<	lock.writeLock().lock();
102	<	Thread t = new Thread(new Runnable() {
103	<	public void run(){
104	<	try{
105	<	lock.readLock().lockInterruptibly();
106	<	fail("should throw");
107	<	}catch(InterruptedException success){}
108	<	}
109	<	});
110	<	try {
111	<	t.start();
100	<	t.interrupt();
101	<	lock.writeLock().unlock();
102	<	t.join();
103	<	} catch(Exception e){
104	<	fail("unexpected exception");
105	<	}
106	<	}
107	<
108	<	public void testInterruptedException4(){
109	<	final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
110	<	lock.writeLock().lock();
111	<	Thread t = new Thread(new Runnable() {
112	<	public void run(){
113	<	try{
114	<	lock.readLock().tryLock(1000,TimeUnit.MILLISECONDS);
115	<	fail("should throw");
116	<	}catch(InterruptedException success){}
117	<	}
118	<	});
119	<	try {
120	<	t.start();
121	<	t.interrupt();
122	<	t.join();
123	<	} catch(Exception e){
124	<	fail("unexpected exception");
125	<	}
99	>	/**
100	>	* Checks that condition c has exactly the given waiter threads.
101	>	*/
102	>	void assertHasWaiters(PublicReentrantReadWriteLock lock, Condition c,
103	>	Thread... threads) {
104	>	lock.writeLock().lock();
105	>	assertEquals(threads.length > 0, lock.hasWaiters(c));
106	>	assertEquals(threads.length, lock.getWaitQueueLength(c));
107	>	assertEquals(threads.length == 0, lock.getWaitingThreads(c).isEmpty());
108	>	assertEquals(threads.length, lock.getWaitingThreads(c).size());
109	>	assertEquals(new HashSet<Thread>(lock.getWaitingThreads(c)),
110	>	new HashSet<Thread>(Arrays.asList(threads)));
111	>	lock.writeLock().unlock();
112		}
113
114	<
115	<	public void testTryLockWhenLocked() {
116	<	final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
117	<	lock.writeLock().lock();
118	<	Thread t = new Thread(new Runnable() {
119	<	public void run(){
120	<	assertFalse(lock.writeLock().tryLock());
121	<	}
122	<	});
123	<	try {
124	<	t.start();
125	<	t.join();
114	>	/**
115	>	* Constructor sets given fairness, and is in unlocked state
116	>	*/
117	>	public void testConstructor() {
118	>	ReentrantReadWriteLock rl = new ReentrantReadWriteLock();
119	>	assertFalse(rl.isFair());
120	>	assertFalse(rl.isWriteLocked());
121	>	assertEquals(0, rl.getReadLockCount());
122	>	ReentrantReadWriteLock r2 = new ReentrantReadWriteLock(true);
123	>	assertTrue(r2.isFair());
124	>	assertFalse(r2.isWriteLocked());
125	>	assertEquals(0, r2.getReadLockCount());
126	>	ReentrantReadWriteLock r3 = new ReentrantReadWriteLock(false);
127	>	assertFalse(r3.isFair());
128	>	assertFalse(r3.isWriteLocked());
129	>	assertEquals(0, r3.getReadLockCount());
130	>	}
131	>
132	>	/**
133	>	* write-locking and read-locking an unlocked lock succeed
134	>	*/
135	>	public void testLock() {
136	>	ReentrantReadWriteLock rl = new ReentrantReadWriteLock();
137	>	rl.writeLock().lock();
138	>	assertTrue(rl.isWriteLocked());
139	>	assertTrue(rl.isWriteLockedByCurrentThread());
140	>	assertTrue(rl.writeLock().isHeldByCurrentThread());
141	>	assertEquals(0, rl.getReadLockCount());
142	>	rl.writeLock().unlock();
143	>	assertFalse(rl.isWriteLocked());
144	>	assertFalse(rl.isWriteLockedByCurrentThread());
145	>	assertFalse(rl.writeLock().isHeldByCurrentThread());
146	>	assertEquals(0, rl.getReadLockCount());
147	>	rl.readLock().lock();
148	>	assertFalse(rl.isWriteLocked());
149	>	assertFalse(rl.isWriteLockedByCurrentThread());
150	>	assertEquals(1, rl.getReadLockCount());
151	>	rl.readLock().unlock();
152	>	assertFalse(rl.isWriteLocked());
153	>	assertFalse(rl.isWriteLockedByCurrentThread());
154	>	assertEquals(0, rl.getReadLockCount());
155	>	}
156	>
157	>	/**
158	>	* locking an unlocked fair lock succeeds
159	>	*/
160	>	public void testFairLock() {
161	>	ReentrantReadWriteLock rl = new ReentrantReadWriteLock(true);
162	>	rl.writeLock().lock();
163	>	assertTrue(rl.isWriteLocked());
164	>	assertTrue(rl.isWriteLockedByCurrentThread());
165	>	assertTrue(rl.writeLock().isHeldByCurrentThread());
166	>	assertEquals(0, rl.getReadLockCount());
167	>	rl.writeLock().unlock();
168	>	assertFalse(rl.isWriteLocked());
169	>	assertFalse(rl.isWriteLockedByCurrentThread());
170	>	assertFalse(rl.writeLock().isHeldByCurrentThread());
171	>	assertEquals(0, rl.getReadLockCount());
172	>	rl.readLock().lock();
173	>	assertFalse(rl.isWriteLocked());
174	>	assertFalse(rl.isWriteLockedByCurrentThread());
175	>	assertEquals(1, rl.getReadLockCount());
176	>	rl.readLock().unlock();
177	>	assertFalse(rl.isWriteLocked());
178	>	assertFalse(rl.isWriteLockedByCurrentThread());
179	>	assertEquals(0, rl.getReadLockCount());
180	>	}
181	>
182	>	/**
183	>	* getWriteHoldCount returns number of recursive holds
184	>	*/
185	>	public void testGetWriteHoldCount() {
186	>	ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
187	>	for (int i = 1; i <= SIZE; i++) {
188	>	lock.writeLock().lock();
189	>	assertEquals(i,lock.getWriteHoldCount());
190	>	}
191	>	for (int i = SIZE; i > 0; i--) {
192		lock.writeLock().unlock();
193	<	} catch(Exception e){
142	<	fail("unexpected exception");
193	>	assertEquals(i-1,lock.getWriteHoldCount());
194		}
195	<	}
195	>	}
196
197	<	public void testTryLockWhenLocked2() {
198	<	final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
199	<	lock.writeLock().lock();
200	<	Thread t = new Thread(new Runnable() {
201	<	public void run(){
202	<	assertFalse(lock.readLock().tryLock());
203	<	}
204	<	});
205	<	try {
206	<	t.start();
156	<	t.join();
197	>	/**
198	>	* WriteLock.getHoldCount returns number of recursive holds
199	>	*/
200	>	public void testGetHoldCount() {
201	>	ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
202	>	for (int i = 1; i <= SIZE; i++) {
203	>	lock.writeLock().lock();
204	>	assertEquals(i,lock.writeLock().getHoldCount());
205	>	}
206	>	for (int i = SIZE; i > 0; i--) {
207		lock.writeLock().unlock();
208	<	} catch(Exception e){
159	<	fail("unexpected exception");
208	>	assertEquals(i-1,lock.writeLock().getHoldCount());
209		}
210	<	}
210	>	}
211
212	<	public void testMultipleReadLocks() {
213	<	final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
214	<	lock.readLock().lock();
215	<	Thread t = new Thread(new Runnable() {
216	<	public void run(){
217	<	assertTrue(lock.readLock().tryLock());
218	<	lock.readLock().unlock();
219	<	}
220	<	});
221	<	try {
173	<	t.start();
174	<	t.join();
212	>	/**
213	>	* getReadHoldCount returns number of recursive holds
214	>	*/
215	>	public void testGetReadHoldCount() {
216	>	ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
217	>	for (int i = 1; i <= SIZE; i++) {
218	>	lock.readLock().lock();
219	>	assertEquals(i,lock.getReadHoldCount());
220	>	}
221	>	for (int i = SIZE; i > 0; i--) {
222		lock.readLock().unlock();
223	<	} catch(Exception e){
177	<	fail("unexpected exception");
223	>	assertEquals(i-1,lock.getReadHoldCount());
224		}
225	<	}
180	<
181	<	public void testWriteAfterMultipleReadLocks() {
182	<	final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
183	<	lock.readLock().lock();
184	<	Thread t1 = new Thread(new Runnable() {
185	<	public void run(){
186	<	lock.readLock().lock();
187	<	lock.readLock().unlock();
188	<	}
189	<	});
190	<	Thread t2 = new Thread(new Runnable() {
191	<	public void run(){
192	<	lock.writeLock().lock();
193	<	lock.writeLock().unlock();
194	<	}
195	<	});
225	>	}
226
227	+	/**
228	+	* write-unlocking an unlocked lock throws IllegalMonitorStateException
229	+	*/
230	+	public void testWriteUnlock_IllegalMonitorStateException() {
231	+	ReentrantReadWriteLock rl = new ReentrantReadWriteLock();
232		try {
233	<	t1.start();
234	<	t2.start();
235	<	Thread.sleep(SHORT_DELAY_MS);
236	<	lock.readLock().unlock();
237	<	t1.join(MEDIUM_DELAY_MS);
238	<	t2.join(MEDIUM_DELAY_MS);
239	<	assertTrue(!t1.isAlive());
240	<	assertTrue(!t2.isAlive());
241	<
242	<	} catch(Exception e){
208	<	fail("unexpected exception");
209	<	}
210	<	}
211	<
212	<	public void testReadAfterWriteLock() {
213	<	final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
214	<	lock.writeLock().lock();
215	<	Thread t1 = new Thread(new Runnable() {
216	<	public void run(){
217	<	lock.readLock().lock();
218	<	lock.readLock().unlock();
219	<	}
220	<	});
221	<	Thread t2 = new Thread(new Runnable() {
222	<	public void run(){
223	<	lock.readLock().lock();
224	<	lock.readLock().unlock();
225	<	}
226	<	});
227	<
228	<	try {
229	<	t1.start();
230	<	t2.start();
231	<	Thread.sleep(SHORT_DELAY_MS);
232	<	lock.writeLock().unlock();
233	<	t1.join(MEDIUM_DELAY_MS);
234	<	t2.join(MEDIUM_DELAY_MS);
235	<	assertTrue(!t1.isAlive());
236	<	assertTrue(!t2.isAlive());
237	<
238	<	} catch(Exception e){
239	<	fail("unexpected exception");
240	<	}
241	<	}
242	<
243	<
244	<	public void testTryLockWhenReadLocked() {
245	<	final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
246	<	lock.readLock().lock();
247	<	Thread t = new Thread(new Runnable() {
248	<	public void run(){
249	<	assertTrue(lock.readLock().tryLock());
250	<	lock.readLock().unlock();
251	<	}
252	<	});
233	>	rl.writeLock().unlock();
234	>	shouldThrow();
235	>	} catch (IllegalMonitorStateException success) {}
236	>	}
237	>
238	>	/**
239	>	* read-unlocking an unlocked lock throws IllegalMonitorStateException
240	>	*/
241	>	public void testReadUnlock_IllegalMonitorStateException() {
242	>	ReentrantReadWriteLock rl = new ReentrantReadWriteLock();
243		try {
244	<	t.start();
245	<	t.join();
246	<	lock.readLock().unlock();
247	<	} catch(Exception e){
258	<	fail("unexpected exception");
259	<	}
260	<	}
244	>	rl.readLock().unlock();
245	>	shouldThrow();
246	>	} catch (IllegalMonitorStateException success) {}
247	>	}
248
249	<
249	>	/**
250	>	* write-lockInterruptibly is interruptible
251	>	*/
252	>	public void testWriteLockInterruptibly_Interrupted() throws Exception {
253	>	final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
254	>	lock.writeLock().lock();
255	>	Thread t = newStartedThread(new CheckedInterruptedRunnable() {
256	>	public void realRun() throws InterruptedException {
257	>	lock.writeLock().lockInterruptibly();
258	>	}});
259	>
260	>	waitForQueuedThread(lock, t);
261	>	t.interrupt();
262	>	awaitTermination(t);
263	>	releaseWriteLock(lock);
264	>	}
265
266	<	public void testWriteTryLockWhenReadLocked() {
267	<	final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
268	<	lock.readLock().lock();
269	<	Thread t = new Thread(new Runnable() {
270	<	public void run(){
271	<	assertFalse(lock.writeLock().tryLock());
272	<	}
273	<	});
274	<	try {
275	<	t.start();
276	<	t.join();
277	<	lock.readLock().unlock();
278	<	} catch(Exception e){
279	<	fail("unexpected exception");
280	<	}
281	<	}
266	>	/**
267	>	* timed write-tryLock is interruptible
268	>	*/
269	>	public void testWriteTryLock_Interrupted() throws InterruptedException {
270	>	final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
271	>	lock.writeLock().lock();
272	>	Thread t = newStartedThread(new CheckedInterruptedRunnable() {
273	>	public void realRun() throws InterruptedException {
274	>	lock.writeLock().tryLock(LONG_DELAY_MS, MILLISECONDS);
275	>	}});
276	>
277	>	waitForQueuedThread(lock, t);
278	>	t.interrupt();
279	>	awaitTermination(t);
280	>	releaseWriteLock(lock);
281	>	}
282
283	<
283	>	/**
284	>	* read-lockInterruptibly is interruptible
285	>	*/
286	>	public void testReadLockInterruptibly_Interrupted() throws InterruptedException {
287	>	final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
288	>	lock.writeLock().lock();
289	>	Thread t = newStartedThread(new CheckedInterruptedRunnable() {
290	>	public void realRun() throws InterruptedException {
291	>	lock.readLock().lockInterruptibly();
292	>	}});
293	>
294	>	waitForQueuedThread(lock, t);
295	>	t.interrupt();
296	>	awaitTermination(t);
297	>	releaseWriteLock(lock);
298	>	}
299
300	<	public void testTryLock_Timeout(){
301	<	final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
302	<	lock.writeLock().lock();
303	<	Thread t = new Thread(new Runnable() {
304	<	public void run(){
305	<	try {
306	<	assertFalse(lock.writeLock().tryLock(1, TimeUnit.MILLISECONDS));
307	<	} catch (Exception ex) {
308	<	fail("unexpected exception");
309	<	}
310	<	}
311	<	});
312	<	try {
313	<	t.start();
314	<	t.join();
315	<	lock.writeLock().unlock();
299	<	} catch(Exception e){
300	<	fail("unexpected exception");
301	<	}
302	<	}
300	>	/**
301	>	* timed read-tryLock is interruptible
302	>	*/
303	>	public void testReadTryLock_Interrupted() throws InterruptedException {
304	>	final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
305	>	lock.writeLock().lock();
306	>	Thread t = newStartedThread(new CheckedInterruptedRunnable() {
307	>	public void realRun() throws InterruptedException {
308	>	lock.readLock().tryLock(LONG_DELAY_MS, MILLISECONDS);
309	>	}});
310	>
311	>	waitForQueuedThread(lock, t);
312	>	t.interrupt();
313	>	awaitTermination(t);
314	>	releaseWriteLock(lock);
315	>	}
316
317	<	public void testTryLock_Timeout2(){
318	<	final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
319	<	lock.writeLock().lock();
320	<	Thread t = new Thread(new Runnable() {
321	<	public void run(){
322	<	try {
323	<	assertFalse(lock.readLock().tryLock(1, TimeUnit.MILLISECONDS));
324	<	} catch (Exception ex) {
325	<	fail("unexpected exception");
326	<	}
314	<	}
315	<	});
316	<	try {
317	<	t.start();
318	<	t.join();
319	<	lock.writeLock().unlock();
320	<	} catch(Exception e){
321	<	fail("unexpected exception");
322	<	}
323	<	}
317	>	/**
318	>	* write-tryLock fails if locked
319	>	*/
320	>	public void testWriteTryLockWhenLocked() throws InterruptedException {
321	>	final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
322	>	lock.writeLock().lock();
323	>	Thread t = newStartedThread(new CheckedRunnable() {
324	>	public void realRun() {
325	>	assertFalse(lock.writeLock().tryLock());
326	>	}});
327
328	+	awaitTermination(t);
329	+	releaseWriteLock(lock);
330	+	}
331
332	<	public void testLockInterruptibly() {
333	<	final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
334	<	try {
335	<	lock.writeLock().lockInterruptibly();
336	<	} catch(Exception e) {
337	<	fail("unexpected exception");
338	<	}
339	<	Thread t = new Thread(new Runnable() {
340	<	public void run() {
341	<	try {
342	<	lock.writeLock().lockInterruptibly();
343	<	fail("should throw");
344	<	}
339	<	catch(InterruptedException success) {
340	<	}
341	<	}
342	<	});
343	<	try {
344	<	t.start();
345	<	t.interrupt();
346	<	t.join();
347	<	lock.writeLock().unlock();
348	<	} catch(Exception e){
349	<	fail("unexpected exception");
350	<	}
332	>	/**
333	>	* read-tryLock fails if locked
334	>	*/
335	>	public void testReadTryLockWhenLocked() throws InterruptedException {
336	>	final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
337	>	lock.writeLock().lock();
338	>	Thread t = newStartedThread(new CheckedRunnable() {
339	>	public void realRun() {
340	>	assertFalse(lock.readLock().tryLock());
341	>	}});
342	>
343	>	awaitTermination(t);
344	>	releaseWriteLock(lock);
345		}
346
347	<	public void testLockInterruptibly2() {
348	<	final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
349	<	try {
350	<	lock.writeLock().lockInterruptibly();
351	<	} catch(Exception e) {
352	<	fail("unexpected exception");
353	<	}
354	<	Thread t = new Thread(new Runnable() {
355	<	public void run() {
356	<	try {
357	<	lock.readLock().lockInterruptibly();
358	<	fail("should throw");
359	<	}
360	<	catch(InterruptedException success) {
361	<	}
362	<	}
363	<	});
364	<	try {
365	<	t.start();
366	<	t.interrupt();
367	<	t.join();
368	<	lock.writeLock().unlock();
369	<	} catch(Exception e){
370	<	fail("unexpected exception");
371	<	}
347	>	/**
348	>	* Multiple threads can hold a read lock when not write-locked
349	>	*/
350	>	public void testMultipleReadLocks() throws InterruptedException {
351	>	final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
352	>	lock.readLock().lock();
353	>	Thread t = newStartedThread(new CheckedRunnable() {
354	>	public void realRun() {
355	>	assertTrue(lock.readLock().tryLock());
356	>	lock.readLock().unlock();
357	>	}});
358	>
359	>	awaitTermination(t);
360	>	lock.readLock().unlock();
361	>	}
362	>
363	>	/**
364	>	* A writelock succeeds only after reading threads unlock
365	>	*/
366	>	public void testWriteAfterMultipleReadLocks() throws InterruptedException {
367	>	final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
368	>	lock.readLock().lock();
369	>	Thread t1 = newStartedThread(new CheckedRunnable() {
370	>	public void realRun() {
371	>	lock.readLock().lock();
372	>	lock.readLock().unlock();
373	>	}});
374	>	Thread t2 = newStartedThread(new CheckedRunnable() {
375	>	public void realRun() {
376	>	lock.writeLock().lock();
377	>	lock.writeLock().unlock();
378	>	}});
379	>
380	>	awaitTermination(t1);
381	>	waitForQueuedThread(lock, t2);
382	>	assertNotWriteLocked(lock);
383	>	lock.readLock().unlock();
384	>	awaitTermination(t2);
385	>	}
386	>
387	>	/**
388	>	* Readlocks succeed only after a writing thread unlocks
389	>	*/
390	>	public void testReadAfterWriteLock() throws InterruptedException {
391	>	final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
392	>	lock.writeLock().lock();
393	>	Thread t1 = newStartedThread(new CheckedRunnable() {
394	>	public void realRun() {
395	>	lock.readLock().lock();
396	>	lock.readLock().unlock();
397	>	}});
398	>	Thread t2 = newStartedThread(new CheckedRunnable() {
399	>	public void realRun() {
400	>	lock.readLock().lock();
401	>	lock.readLock().unlock();
402	>	}});
403	>
404	>	waitForQueuedThread(lock, t1);
405	>	waitForQueuedThread(lock, t2);
406	>	releaseWriteLock(lock);
407	>	awaitTermination(t1);
408	>	awaitTermination(t2);
409	>	}
410	>
411	>	/**
412	>	* Read trylock succeeds if write locked by current thread
413	>	*/
414	>	public void testReadHoldingWriteLock() {
415	>	final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
416	>	lock.writeLock().lock();
417	>	assertTrue(lock.readLock().tryLock());
418	>	lock.readLock().unlock();
419	>	lock.writeLock().unlock();
420	>	}
421	>
422	>	/**
423	>	* Read lock succeeds if write locked by current thread even if
424	>	* other threads are waiting for readlock
425	>	*/
426	>	public void testReadHoldingWriteLock2() throws InterruptedException {
427	>	final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
428	>	lock.writeLock().lock();
429	>	lock.readLock().lock();
430	>	lock.readLock().unlock();
431	>
432	>	Thread t1 = newStartedThread(new CheckedRunnable() {
433	>	public void realRun() {
434	>	lock.readLock().lock();
435	>	lock.readLock().unlock();
436	>	}});
437	>	Thread t2 = newStartedThread(new CheckedRunnable() {
438	>	public void realRun() {
439	>	lock.readLock().lock();
440	>	lock.readLock().unlock();
441	>	}});
442	>
443	>	waitForQueuedThread(lock, t1);
444	>	waitForQueuedThread(lock, t2);
445	>	assertTrue(lock.isWriteLockedByCurrentThread());
446	>	lock.readLock().lock();
447	>	lock.readLock().unlock();
448	>	releaseWriteLock(lock);
449	>	awaitTermination(t1);
450	>	awaitTermination(t2);
451	>	}
452	>
453	>	/**
454	>	* Read lock succeeds if write locked by current thread even if
455	>	* other threads are waiting for writelock
456	>	*/
457	>	public void testReadHoldingWriteLock3() throws InterruptedException {
458	>	final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
459	>	lock.writeLock().lock();
460	>	lock.readLock().lock();
461	>	lock.readLock().unlock();
462	>
463	>	Thread t1 = newStartedThread(new CheckedRunnable() {
464	>	public void realRun() {
465	>	lock.writeLock().lock();
466	>	lock.writeLock().unlock();
467	>	}});
468	>	Thread t2 = newStartedThread(new CheckedRunnable() {
469	>	public void realRun() {
470	>	lock.writeLock().lock();
471	>	lock.writeLock().unlock();
472	>	}});
473	>
474	>	waitForQueuedThread(lock, t1);
475	>	waitForQueuedThread(lock, t2);
476	>	assertTrue(lock.isWriteLockedByCurrentThread());
477	>	lock.readLock().lock();
478	>	lock.readLock().unlock();
479	>	releaseWriteLock(lock);
480	>	awaitTermination(t1);
481	>	awaitTermination(t2);
482	>	}
483	>
484	>	/**
485	>	* Write lock succeeds if write locked by current thread even if
486	>	* other threads are waiting for writelock
487	>	*/
488	>	public void testWriteHoldingWriteLock4() throws InterruptedException {
489	>	final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
490	>	lock.writeLock().lock();
491	>	lock.writeLock().lock();
492	>	lock.writeLock().unlock();
493	>
494	>	Thread t1 = newStartedThread(new CheckedRunnable() {
495	>	public void realRun() {
496	>	lock.writeLock().lock();
497	>	lock.writeLock().unlock();
498	>	}});
499	>	Thread t2 = newStartedThread(new CheckedRunnable() {
500	>	public void realRun() {
501	>	lock.writeLock().lock();
502	>	lock.writeLock().unlock();
503	>	}});
504	>
505	>	waitForQueuedThread(lock, t1);
506	>	waitForQueuedThread(lock, t2);
507	>	assertTrue(lock.isWriteLockedByCurrentThread());
508	>	assertEquals(1, lock.getWriteHoldCount());
509	>	lock.writeLock().lock();
510	>	assertTrue(lock.isWriteLockedByCurrentThread());
511	>	assertEquals(2, lock.getWriteHoldCount());
512	>	lock.writeLock().unlock();
513	>	releaseWriteLock(lock);
514	>	awaitTermination(t1);
515	>	awaitTermination(t2);
516	>	}
517	>
518	>	/**
519	>	* Fair Read trylock succeeds if write locked by current thread
520	>	*/
521	>	public void testReadHoldingWriteLockFair() {
522	>	final ReentrantReadWriteLock lock = new ReentrantReadWriteLock(true);
523	>	lock.writeLock().lock();
524	>	assertTrue(lock.readLock().tryLock());
525	>	lock.readLock().unlock();
526	>	lock.writeLock().unlock();
527	>	}
528	>
529	>	/**
530	>	* Fair Read lock succeeds if write locked by current thread even if
531	>	* other threads are waiting for readlock
532	>	*/
533	>	public void testReadHoldingWriteLockFair2() throws InterruptedException {
534	>	final ReentrantReadWriteLock lock = new ReentrantReadWriteLock(true);
535	>	lock.writeLock().lock();
536	>	lock.readLock().lock();
537	>	lock.readLock().unlock();
538	>
539	>	Thread t1 = newStartedThread(new CheckedRunnable() {
540	>	public void realRun() {
541	>	lock.readLock().lock();
542	>	lock.readLock().unlock();
543	>	}});
544	>	Thread t2 = newStartedThread(new CheckedRunnable() {
545	>	public void realRun() {
546	>	lock.readLock().lock();
547	>	lock.readLock().unlock();
548	>	}});
549	>
550	>	waitForQueuedThread(lock, t1);
551	>	waitForQueuedThread(lock, t2);
552	>	assertTrue(lock.isWriteLockedByCurrentThread());
553	>	lock.readLock().lock();
554	>	lock.readLock().unlock();
555	>	releaseWriteLock(lock);
556	>	awaitTermination(t1);
557	>	awaitTermination(t2);
558	>	}
559	>
560	>	/**
561	>	* Fair Read lock succeeds if write locked by current thread even if
562	>	* other threads are waiting for writelock
563	>	*/
564	>	public void testReadHoldingWriteLockFair3() throws InterruptedException {
565	>	final ReentrantReadWriteLock lock = new ReentrantReadWriteLock(true);
566	>	lock.writeLock().lock();
567	>	lock.readLock().lock();
568	>	lock.readLock().unlock();
569	>
570	>	Thread t1 = newStartedThread(new CheckedRunnable() {
571	>	public void realRun() {
572	>	lock.writeLock().lock();
573	>	lock.writeLock().unlock();
574	>	}});
575	>	Thread t2 = newStartedThread(new CheckedRunnable() {
576	>	public void realRun() {
577	>	lock.writeLock().lock();
578	>	lock.writeLock().unlock();
579	>	}});
580	>
581	>	waitForQueuedThread(lock, t1);
582	>	waitForQueuedThread(lock, t2);
583	>	assertTrue(lock.isWriteLockedByCurrentThread());
584	>	lock.readLock().lock();
585	>	lock.readLock().unlock();
586	>	releaseWriteLock(lock);
587	>	awaitTermination(t1);
588	>	awaitTermination(t2);
589	>	}
590	>
591	>	/**
592	>	* Fair Write lock succeeds if write locked by current thread even if
593	>	* other threads are waiting for writelock
594	>	*/
595	>	public void testWriteHoldingWriteLockFair4() throws InterruptedException {
596	>	final ReentrantReadWriteLock lock = new ReentrantReadWriteLock(true);
597	>	lock.writeLock().lock();
598	>	Thread t1 = newStartedThread(new CheckedRunnable() {
599	>	public void realRun() {
600	>	lock.writeLock().lock();
601	>	lock.writeLock().unlock();
602	>	}});
603	>	Thread t2 = newStartedThread(new CheckedRunnable() {
604	>	public void realRun() {
605	>	lock.writeLock().lock();
606	>	lock.writeLock().unlock();
607	>	}});
608	>
609	>	waitForQueuedThread(lock, t1);
610	>	waitForQueuedThread(lock, t2);
611	>	assertTrue(lock.isWriteLockedByCurrentThread());
612	>	assertEquals(1, lock.getWriteHoldCount());
613	>	lock.writeLock().lock();
614	>	assertEquals(2, lock.getWriteHoldCount());
615	>	lock.writeLock().unlock();
616	>	lock.writeLock().lock();
617	>	lock.writeLock().unlock();
618	>	releaseWriteLock(lock);
619	>	awaitTermination(t1);
620	>	awaitTermination(t2);
621	>	}
622	>
623	>	/**
624	>	* Read tryLock succeeds if readlocked but not writelocked
625	>	*/
626	>	public void testTryLockWhenReadLocked() throws InterruptedException {
627	>	final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
628	>	lock.readLock().lock();
629	>	Thread t = newStartedThread(new CheckedRunnable() {
630	>	public void realRun() {
631	>	assertTrue(lock.readLock().tryLock());
632	>	lock.readLock().unlock();
633	>	}});
634	>
635	>	awaitTermination(t);
636	>	lock.readLock().unlock();
637	>	}
638	>
639	>	/**
640	>	* write tryLock fails when readlocked
641	>	*/
642	>	public void testWriteTryLockWhenReadLocked() throws InterruptedException {
643	>	final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
644	>	lock.readLock().lock();
645	>	Thread t = newStartedThread(new CheckedRunnable() {
646	>	public void realRun() {
647	>	assertFalse(lock.writeLock().tryLock());
648	>	}});
649	>
650	>	awaitTermination(t);
651	>	lock.readLock().unlock();
652	>	}
653	>
654	>	/**
655	>	* Fair Read tryLock succeeds if readlocked but not writelocked
656	>	*/
657	>	public void testTryLockWhenReadLockedFair() throws InterruptedException {
658	>	final ReentrantReadWriteLock lock = new ReentrantReadWriteLock(true);
659	>	lock.readLock().lock();
660	>	Thread t = newStartedThread(new CheckedRunnable() {
661	>	public void realRun() {
662	>	assertTrue(lock.readLock().tryLock());
663	>	lock.readLock().unlock();
664	>	}});
665	>
666	>	awaitTermination(t);
667	>	lock.readLock().unlock();
668	>	}
669	>
670	>	/**
671	>	* Fair write tryLock fails when readlocked
672	>	*/
673	>	public void testWriteTryLockWhenReadLockedFair() throws InterruptedException {
674	>	final ReentrantReadWriteLock lock = new ReentrantReadWriteLock(true);
675	>	lock.readLock().lock();
676	>	Thread t = newStartedThread(new CheckedRunnable() {
677	>	public void realRun() {
678	>	assertFalse(lock.writeLock().tryLock());
679	>	}});
680	>
681	>	awaitTermination(t);
682	>	lock.readLock().unlock();
683	>	}
684	>
685	>	/**
686	>	* write timed tryLock times out if locked
687	>	*/
688	>	public void testWriteTryLock_Timeout() throws InterruptedException {
689	>	final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
690	>	lock.writeLock().lock();
691	>	Thread t = newStartedThread(new CheckedRunnable() {
692	>	public void realRun() throws InterruptedException {
693	>	assertFalse(lock.writeLock().tryLock(1, MILLISECONDS));
694	>	}});
695	>
696	>	awaitTermination(t);
697	>	assertTrue(lock.writeLock().isHeldByCurrentThread());
698	>	lock.writeLock().unlock();
699	>	}
700	>
701	>	/**
702	>	* read timed tryLock times out if write-locked
703	>	*/
704	>	public void testReadTryLock_Timeout() throws InterruptedException {
705	>	final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
706	>	lock.writeLock().lock();
707	>	Thread t = newStartedThread(new CheckedRunnable() {
708	>	public void realRun() throws InterruptedException {
709	>	assertFalse(lock.readLock().tryLock(1, MILLISECONDS));
710	>	}});
711	>
712	>	awaitTermination(t);
713	>	assertTrue(lock.writeLock().isHeldByCurrentThread());
714	>	lock.writeLock().unlock();
715	>	}
716	>
717	>	/**
718	>	* write lockInterruptibly succeeds if lock free else is interruptible
719	>	*/
720	>	public void testWriteLockInterruptibly() throws InterruptedException {
721	>	final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
722	>	lock.writeLock().lockInterruptibly();
723	>	Thread t = newStartedThread(new CheckedInterruptedRunnable() {
724	>	public void realRun() throws InterruptedException {
725	>	lock.writeLock().lockInterruptibly();
726	>	}});
727	>
728	>	waitForQueuedThread(lock, t);
729	>	t.interrupt();
730	>	awaitTermination(t);
731	>	releaseWriteLock(lock);
732	>	}
733	>
734	>	/**
735	>	* read lockInterruptibly succeeds if lock free else is interruptible
736	>	*/
737	>	public void testReadLockInterruptibly() throws InterruptedException {
738	>	final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
739	>	lock.writeLock().lockInterruptibly();
740	>	Thread t = newStartedThread(new CheckedInterruptedRunnable() {
741	>	public void realRun() throws InterruptedException {
742	>	lock.readLock().lockInterruptibly();
743	>	}});
744	>
745	>	waitForQueuedThread(lock, t);
746	>	t.interrupt();
747	>	awaitTermination(t);
748	>	releaseWriteLock(lock);
749		}
750
751	<	public void testAwait_IllegalMonitor() {
752	<	final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
751	>	/**
752	>	* Calling await without holding lock throws IllegalMonitorStateException
753	>	*/
754	>	public void testAwait_IllegalMonitor() throws InterruptedException {
755	>	final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
756		final Condition c = lock.writeLock().newCondition();
757		try {
758		c.await();
759	<	fail("should throw");
760	<	}
761	<	catch (IllegalMonitorStateException success) {
762	<	}
763	<	catch (Exception ex) {
764	<	fail("should throw IMSE");
765	<	}
759	>	shouldThrow();
760	>	} catch (IllegalMonitorStateException success) {}
761	>	try {
762	>	c.await(LONG_DELAY_MS, MILLISECONDS);
763	>	shouldThrow();
764	>	} catch (IllegalMonitorStateException success) {}
765	>	try {
766	>	c.awaitNanos(100);
767	>	shouldThrow();
768	>	} catch (IllegalMonitorStateException success) {}
769	>	try {
770	>	c.awaitUninterruptibly();
771	>	shouldThrow();
772	>	} catch (IllegalMonitorStateException success) {}
773		}
774
775	+	/**
776	+	* Calling signal without holding lock throws IllegalMonitorStateException
777	+	*/
778		public void testSignal_IllegalMonitor() {
779	<	final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
779	>	final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
780		final Condition c = lock.writeLock().newCondition();
781		try {
782		c.signal();
783	<	fail("should throw");
784	<	}
401	<	catch (IllegalMonitorStateException success) {
402	<	}
403	<	catch (Exception ex) {
404	<	fail("should throw IMSE");
405	<	}
783	>	shouldThrow();
784	>	} catch (IllegalMonitorStateException success) {}
785		}
786
787	<	public void testAwaitNanos_Timeout() {
788	<	final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
787	>	/**
788	>	* Calling signalAll without holding lock throws IllegalMonitorStateException
789	>	*/
790	>	public void testSignalAll_IllegalMonitor() {
791	>	final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
792		final Condition c = lock.writeLock().newCondition();
793		try {
794	<	lock.writeLock().lock();
795	<	long t = c.awaitNanos(100);
796	<	assertTrue(t <= 0);
415	<	lock.writeLock().unlock();
416	<	}
417	<	catch (Exception ex) {
418	<	fail("unexpected exception");
419	<	}
794	>	c.signalAll();
795	>	shouldThrow();
796	>	} catch (IllegalMonitorStateException success) {}
797		}
798
799	<	public void testAwait_Timeout() {
800	<	final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
799	>	/**
800	>	* awaitNanos without a signal times out
801	>	*/
802	>	public void testAwaitNanos_Timeout() throws InterruptedException {
803	>	final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
804		final Condition c = lock.writeLock().newCondition();
805	<	try {
806	<	lock.writeLock().lock();
807	<	assertFalse(c.await(10, TimeUnit.MILLISECONDS));
808	<	lock.writeLock().unlock();
809	<	}
810	<	catch (Exception ex) {
811	<	fail("unexpected exception");
812	<	}
805	>	lock.writeLock().lock();
806	>	long startTime = System.nanoTime();
807	>	long timeoutMillis = 10;
808	>	long timeoutNanos = MILLISECONDS.toNanos(timeoutMillis);
809	>	long nanosRemaining = c.awaitNanos(timeoutNanos);
810	>	assertTrue(nanosRemaining <= 0);
811	>	assertTrue(millisElapsedSince(startTime) >= timeoutMillis);
812	>	lock.writeLock().unlock();
813		}
814
815	<	public void testAwaitUntil_Timeout() {
816	<	final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
815	>	/**
816	>	* timed await without a signal times out
817	>	*/
818	>	public void testAwait_Timeout() throws InterruptedException {
819	>	final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
820		final Condition c = lock.writeLock().newCondition();
821	<	try {
822	<	lock.writeLock().lock();
823	<	java.util.Date d = new java.util.Date();
824	<	assertFalse(c.awaitUntil(new java.util.Date(d.getTime() + 10)));
825	<	lock.writeLock().unlock();
826	<	}
444	<	catch (Exception ex) {
445	<	fail("unexpected exception");
446	<	}
821	>	lock.writeLock().lock();
822	>	long startTime = System.nanoTime();
823	>	long timeoutMillis = 10;
824	>	assertFalse(c.await(timeoutMillis, MILLISECONDS));
825	>	assertTrue(millisElapsedSince(startTime) >= timeoutMillis);
826	>	lock.writeLock().unlock();
827		}
828
829	<	public void testAwait() {
830	<	final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
829	>	/**
830	>	* awaitUntil without a signal times out
831	>	*/
832	>	public void testAwaitUntil_Timeout() throws InterruptedException {
833	>	final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
834		final Condition c = lock.writeLock().newCondition();
835	<	Thread t = new Thread(new Runnable() {
836	<	public void run() {
837	<	try {
838	<	lock.writeLock().lock();
839	<	c.await();
457	<	lock.writeLock().unlock();
458	<	}
459	<	catch(InterruptedException e) {
460	<	fail("unexpected exception");
461	<	}
462	<	}
463	<	});
835	>	lock.writeLock().lock();
836	>	java.util.Date d = new java.util.Date();
837	>	assertFalse(c.awaitUntil(new java.util.Date(d.getTime() + 10)));
838	>	lock.writeLock().unlock();
839	>	}
840
841	<	try {
842	<	t.start();
843	<	Thread.sleep(SHORT_DELAY_MS);
844	<	lock.writeLock().lock();
845	<	c.signal();
846	<	lock.writeLock().unlock();
847	<	t.join(SHORT_DELAY_MS);
848	<	assertFalse(t.isAlive());
849	<	}
850	<	catch (Exception ex) {
851	<	fail("unexpected exception");
852	<	}
841	>	/**
842	>	* await returns when signalled
843	>	*/
844	>	public void testAwait() throws InterruptedException {
845	>	final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
846	>	final Condition c = lock.writeLock().newCondition();
847	>	final CountDownLatch locked = new CountDownLatch(1);
848	>	Thread t = newStartedThread(new CheckedRunnable() {
849	>	public void realRun() throws InterruptedException {
850	>	lock.writeLock().lock();
851	>	locked.countDown();
852	>	c.await();
853	>	lock.writeLock().unlock();
854	>	}});
855	>
856	>	locked.await();
857	>	lock.writeLock().lock();
858	>	c.signal();
859	>	assertTrue(t.isAlive());
860	>	lock.writeLock().unlock();
861	>	awaitTermination(t);
862		}
863
864	<	public void testAwaitUninterruptibly() {
865	<	final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
864	>	/**
865	>	* awaitUninterruptibly doesn't abort on interrupt
866	>	*/
867	>	public void testAwaitUninterruptibly() throws InterruptedException {
868	>	final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
869		final Condition c = lock.writeLock().newCondition();
870	<	Thread t = new Thread(new Runnable() {
871	<	public void run() {
872	<	lock.writeLock().lock();
873	<	c.awaitUninterruptibly();
870	>	final CountDownLatch locked = new CountDownLatch(1);
871	>	final AtomicBoolean canAwake = new AtomicBoolean(false);
872	>	Thread t = newStartedThread(new CheckedRunnable() {
873	>	public void realRun() {
874	>	lock.writeLock().lock();
875	>	locked.countDown();
876	>	c.awaitUninterruptibly();
877	>	assertTrue(Thread.interrupted());
878	>	lock.writeLock().unlock();
879	>	}});
880	>
881	>	locked.await();
882	>	lock.writeLock().lock();
883	>	lock.writeLock().unlock();
884	>	t.interrupt();
885	>	t.join(10);
886	>	assertTrue(t.isAlive());
887	>	lock.writeLock().lock();
888	>	c.signal();
889	>	lock.writeLock().unlock();
890	>	awaitTermination(t);
891	>	}
892	>
893	>	/**
894	>	* await is interruptible
895	>	*/
896	>	public void testAwait_Interrupt() throws InterruptedException {
897	>	final PublicReentrantReadWriteLock lock = new PublicReentrantReadWriteLock();
898	>	final Condition c = lock.writeLock().newCondition();
899	>	final CountDownLatch locked = new CountDownLatch(1);
900	>	Thread t = newStartedThread(new CheckedInterruptedRunnable() {
901	>	public void realRun() throws InterruptedException {
902	>	lock.writeLock().lock();
903	>	assertTrue(lock.isWriteLocked());
904	>	assertTrue(lock.isWriteLockedByCurrentThread());
905	>	assertHasNoWaiters(lock, c);
906	>	locked.countDown();
907	>	try {
908	>	c.await();
909	>	} finally {
910	>	assertTrue(lock.isWriteLocked());
911	>	assertTrue(lock.isWriteLockedByCurrentThread());
912	>	assertHasNoWaiters(lock, c);
913		lock.writeLock().unlock();
914	<	}
915	<	});
914	>	assertFalse(Thread.interrupted());
915	>	}
916	>	}});
917	>
918	>	locked.await();
919	>	assertHasWaiters(lock, c, t);
920	>	t.interrupt();
921	>	awaitTermination(t);
922	>	assertFalse(lock.isWriteLocked());
923	>	}
924
925	<	try {
926	<	t.start();
927	<	Thread.sleep(SHORT_DELAY_MS);
928	<	t.interrupt();
929	<	lock.writeLock().lock();
930	<	c.signal();
931	<	lock.writeLock().unlock();
932	<	t.join(SHORT_DELAY_MS);
933	<	assertFalse(t.isAlive());
934	<	}
935	<	catch (Exception ex) {
936	<	fail("unexpected exception");
937	<	}
925	>	/**
926	>	* awaitNanos is interruptible
927	>	*/
928	>	public void testAwaitNanos_Interrupt() throws InterruptedException {
929	>	final PublicReentrantReadWriteLock lock = new PublicReentrantReadWriteLock();
930	>	final Condition c = lock.writeLock().newCondition();
931	>	final CountDownLatch locked = new CountDownLatch(1);
932	>	Thread t = newStartedThread(new CheckedInterruptedRunnable() {
933	>	public void realRun() throws InterruptedException {
934	>	lock.writeLock().lock();
935	>	assertTrue(lock.isWriteLocked());
936	>	assertTrue(lock.isWriteLockedByCurrentThread());
937	>	assertHasNoWaiters(lock, c);
938	>	locked.countDown();
939	>	try {
940	>	c.awaitNanos(MILLISECONDS.toNanos(LONG_DELAY_MS));
941	>	} finally {
942	>	assertTrue(lock.isWriteLocked());
943	>	assertTrue(lock.isWriteLockedByCurrentThread());
944	>	assertHasNoWaiters(lock, c);
945	>	lock.writeLock().unlock();
946	>	assertFalse(Thread.interrupted());
947	>	}
948	>	}});
949	>
950	>	locked.await();
951	>	assertHasWaiters(lock, c, t);
952	>	t.interrupt();
953	>	awaitTermination(t);
954	>	assertFalse(lock.isWriteLocked());
955		}
956
957	<	public void testAwait_Interrupt() {
958	<	final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
959	<	final Condition c = lock.writeLock().newCondition();
960	<	Thread t = new Thread(new Runnable() {
961	<	public void run() {
962	<	try {
963	<	lock.writeLock().lock();
964	<	c.await();
965	<	lock.writeLock().unlock();
966	<	fail("should throw");
967	<	}
968	<	catch(InterruptedException success) {
969	<	}
970	<	}
971	<	});
972	<
973	<	try {
974	<	t.start();
975	<	Thread.sleep(SHORT_DELAY_MS);
976	<	t.interrupt();
977	<	t.join(SHORT_DELAY_MS);
978	<	assertFalse(t.isAlive());
979	<	}
980	<	catch (Exception ex) {
981	<	fail("unexpected exception");
982	<	}
983	<	}
984	<
985	<	public void testAwaitNanos_Interrupt() {
986	<	final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
987	<	final Condition c = lock.writeLock().newCondition();
988	<	Thread t = new Thread(new Runnable() {
989	<	public void run() {
990	<	try {
991	<	lock.writeLock().lock();
992	<	c.awaitNanos(SHORT_DELAY_MS * 2 * 1000000);
993	<	lock.writeLock().unlock();
994	<	fail("should throw");
995	<	}
996	<	catch(InterruptedException success) {
997	<	}
998	<	}
999	<	});
1000	<
1001	<	try {
1002	<	t.start();
1003	<	Thread.sleep(SHORT_DELAY_MS);
1004	<	t.interrupt();
1005	<	t.join(SHORT_DELAY_MS);
1006	<	assertFalse(t.isAlive());
1007	<	}
1008	<	catch (Exception ex) {
1009	<	fail("unexpected exception");
1010	<	}
1011	<	}
1012	<
1013	<	public void testAwaitUntil_Interrupt() {
1014	<	final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
1015	<	final Condition c = lock.writeLock().newCondition();
1016	<	Thread t = new Thread(new Runnable() {
1017	<	public void run() {
1018	<	try {
1019	<	lock.writeLock().lock();
1020	<	java.util.Date d = new java.util.Date();
1021	<	c.awaitUntil(new java.util.Date(d.getTime() + 10000));
1022	<	lock.writeLock().unlock();
1023	<	fail("should throw");
1024	<	}
1025	<	catch(InterruptedException success) {
1026	<	}
1027	<	}
1028	<	});
1029	<
1030	<	try {
1031	<	t.start();
1032	<	Thread.sleep(SHORT_DELAY_MS);
1033	<	t.interrupt();
1034	<	t.join(SHORT_DELAY_MS);
1035	<	assertFalse(t.isAlive());
1036	<	}
1037	<	catch (Exception ex) {
1038	<	fail("unexpected exception");
1039	<	}
1040	<	}
1041	<
1042	<	public void testSignalAll() {
1043	<	final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
1044	<	final Condition c = lock.writeLock().newCondition();
1045	<	Thread t1 = new Thread(new Runnable() {
1046	<	public void run() {
1047	<	try {
1048	<	lock.writeLock().lock();
1049	<	c.await();
1050	<	lock.writeLock().unlock();
1051	<	}
1052	<	catch(InterruptedException e) {
1053	<	fail("unexpected exception");
1054	<	}
1055	<	}
1056	<	});
1057	<
1058	<	Thread t2 = new Thread(new Runnable() {
1059	<	public void run() {
1060	<	try {
1061	<	lock.writeLock().lock();
1062	<	c.await();
1063	<	lock.writeLock().unlock();
1064	<	}
1065	<	catch(InterruptedException e) {
1066	<	fail("unexpected exception");
615	<	}
616	<	}
617	<	});
618	<
619	<	try {
620	<	t1.start();
621	<	t2.start();
622	<	Thread.sleep(SHORT_DELAY_MS);
623	<	lock.writeLock().lock();
624	<	c.signalAll();
625	<	lock.writeLock().unlock();
626	<	t1.join(SHORT_DELAY_MS);
627	<	t2.join(SHORT_DELAY_MS);
628	<	assertFalse(t1.isAlive());
629	<	assertFalse(t2.isAlive());
630	<	}
631	<	catch (Exception ex) {
632	<	fail("unexpected exception");
633	<	}
957	>	/**
958	>	* awaitUntil is interruptible
959	>	*/
960	>	public void testAwaitUntil_Interrupt() throws InterruptedException {
961	>	final PublicReentrantReadWriteLock lock = new PublicReentrantReadWriteLock();
962	>	final Condition c = lock.writeLock().newCondition();
963	>	final CountDownLatch locked = new CountDownLatch(1);
964	>	Thread t = newStartedThread(new CheckedInterruptedRunnable() {
965	>	public void realRun() throws InterruptedException {
966	>	lock.writeLock().lock();
967	>	assertTrue(lock.isWriteLocked());
968	>	assertTrue(lock.isWriteLockedByCurrentThread());
969	>	assertHasNoWaiters(lock, c);
970	>	locked.countDown();
971	>	java.util.Date d = new java.util.Date();
972	>	try {
973	>	c.awaitUntil(new java.util.Date(d.getTime() + 10000));
974	>	} finally {
975	>	assertTrue(lock.isWriteLocked());
976	>	assertTrue(lock.isWriteLockedByCurrentThread());
977	>	assertHasNoWaiters(lock, c);
978	>	lock.writeLock().unlock();
979	>	assertFalse(Thread.interrupted());
980	>	}
981	>	}});
982	>
983	>	locked.await();
984	>	assertHasWaiters(lock, c, t);
985	>	t.interrupt();
986	>	awaitTermination(t);
987	>	assertFalse(lock.isWriteLocked());
988	>	}
989	>
990	>	/**
991	>	* signalAll wakes up all threads
992	>	*/
993	>	public void testSignalAll() throws InterruptedException {
994	>	final PublicReentrantReadWriteLock lock = new PublicReentrantReadWriteLock();
995	>	final Condition c = lock.writeLock().newCondition();
996	>	final CountDownLatch locked = new CountDownLatch(2);
997	>	final Lock writeLock = lock.writeLock();
998	>	Thread t1 = newStartedThread(new CheckedRunnable() {
999	>	public void realRun() throws InterruptedException {
1000	>	writeLock.lock();
1001	>	locked.countDown();
1002	>	c.await();
1003	>	writeLock.unlock();
1004	>	}});
1005	>
1006	>	Thread t2 = newStartedThread(new CheckedRunnable() {
1007	>	public void realRun() throws InterruptedException {
1008	>	writeLock.lock();
1009	>	locked.countDown();
1010	>	c.await();
1011	>	writeLock.unlock();
1012	>	}});
1013	>
1014	>	locked.await();
1015	>	writeLock.lock();
1016	>	assertHasWaiters(lock, c, t1, t2);
1017	>	c.signalAll();
1018	>	assertHasNoWaiters(lock, c);
1019	>	writeLock.unlock();
1020	>	awaitTermination(t1);
1021	>	awaitTermination(t2);
1022	>	}
1023	>
1024	>	/**
1025	>	* signal wakes up waiting threads in FIFO order.
1026	>	*/
1027	>	public void testSignalWakesFifo() throws InterruptedException {
1028	>	final PublicReentrantReadWriteLock lock = new PublicReentrantReadWriteLock();
1029	>	final Condition c = lock.writeLock().newCondition();
1030	>	final CountDownLatch locked1 = new CountDownLatch(1);
1031	>	final CountDownLatch locked2 = new CountDownLatch(1);
1032	>	final Lock writeLock = lock.writeLock();
1033	>	Thread t1 = newStartedThread(new CheckedRunnable() {
1034	>	public void realRun() throws InterruptedException {
1035	>	writeLock.lock();
1036	>	locked1.countDown();
1037	>	c.await();
1038	>	writeLock.unlock();
1039	>	}});
1040	>
1041	>	locked1.await();
1042	>
1043	>	Thread t2 = newStartedThread(new CheckedRunnable() {
1044	>	public void realRun() throws InterruptedException {
1045	>	writeLock.lock();
1046	>	locked2.countDown();
1047	>	c.await();
1048	>	writeLock.unlock();
1049	>	}});
1050	>
1051	>	locked2.await();
1052	>
1053	>	writeLock.lock();
1054	>	assertHasWaiters(lock, c, t1, t2);
1055	>	assertFalse(lock.hasQueuedThreads());
1056	>	c.signal();
1057	>	assertHasWaiters(lock, c, t2);
1058	>	assertTrue(lock.hasQueuedThread(t1));
1059	>	assertFalse(lock.hasQueuedThread(t2));
1060	>	c.signal();
1061	>	assertHasNoWaiters(lock, c);
1062	>	assertTrue(lock.hasQueuedThread(t1));
1063	>	assertTrue(lock.hasQueuedThread(t2));
1064	>	writeLock.unlock();
1065	>	awaitTermination(t1);
1066	>	awaitTermination(t2);
1067		}
1068
1069	<	public void testSerialization() {
1069	>	/**
1070	>	* A serialized lock deserializes as unlocked
1071	>	*/
1072	>	public void testSerialization() throws Exception {
1073		ReentrantReadWriteLock l = new ReentrantReadWriteLock();
1074		l.readLock().lock();
1075		l.readLock().unlock();
1076
1077	+	ByteArrayOutputStream bout = new ByteArrayOutputStream(10000);
1078	+	ObjectOutputStream out = new ObjectOutputStream(new BufferedOutputStream(bout));
1079	+	out.writeObject(l);
1080	+	out.close();
1081	+
1082	+	ByteArrayInputStream bin = new ByteArrayInputStream(bout.toByteArray());
1083	+	ObjectInputStream in = new ObjectInputStream(new BufferedInputStream(bin));
1084	+	ReentrantReadWriteLock r = (ReentrantReadWriteLock) in.readObject();
1085	+	r.readLock().lock();
1086	+	r.readLock().unlock();
1087	+	}
1088	+
1089	+	/**
1090	+	* hasQueuedThreads reports whether there are waiting threads
1091	+	*/
1092	+	public void testhasQueuedThreads() throws InterruptedException {
1093	+	final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
1094	+	Thread t1 = new Thread(new InterruptedLockRunnable(lock));
1095	+	Thread t2 = new Thread(new InterruptibleLockRunnable(lock));
1096	+	assertFalse(lock.hasQueuedThreads());
1097	+	lock.writeLock().lock();
1098	+	assertFalse(lock.hasQueuedThreads());
1099	+	long startTime = System.nanoTime();
1100	+	t1.start();
1101	+	waitForQueuedThread(lock, t1);
1102	+	t2.start();
1103	+	waitForQueuedThread(lock, t2);
1104	+	assertTrue(lock.hasQueuedThreads());
1105	+	t1.interrupt();
1106	+	awaitTermination(t1);
1107	+	assertTrue(lock.hasQueuedThreads());
1108	+	lock.writeLock().unlock();
1109	+	awaitTermination(t2);
1110	+	assertFalse(lock.hasQueuedThreads());
1111	+	}
1112	+
1113	+	/**
1114	+	* hasQueuedThread(null) throws NPE
1115	+	*/
1116	+	public void testHasQueuedThreadNPE() {
1117	+	final ReentrantReadWriteLock sync = new ReentrantReadWriteLock();
1118		try {
1119	<	ByteArrayOutputStream bout = new ByteArrayOutputStream(10000);
1120	<	ObjectOutputStream out = new ObjectOutputStream(new BufferedOutputStream(bout));
1121	<	out.writeObject(l);
1122	<	out.close();
1123	<
1124	<	ByteArrayInputStream bin = new ByteArrayInputStream(bout.toByteArray());
1125	<	ObjectInputStream in = new ObjectInputStream(new BufferedInputStream(bin));
1126	<	ReentrantReadWriteLock r = (ReentrantReadWriteLock) in.readObject();
1127	<	r.readLock().lock();
1128	<	r.readLock().unlock();
1129	<	} catch(Exception e){
1130	<	e.printStackTrace();
1131	<	fail("unexpected exception");
1132	<	}
1119	>	sync.hasQueuedThread(null);
1120	>	shouldThrow();
1121	>	} catch (NullPointerException success) {}
1122	>	}
1123	>
1124	>	/**
1125	>	* hasQueuedThread reports whether a thread is queued.
1126	>	*/
1127	>	public void testHasQueuedThread() throws InterruptedException {
1128	>	final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
1129	>	Thread t1 = new Thread(new InterruptedLockRunnable(lock));
1130	>	Thread t2 = new Thread(new InterruptibleLockRunnable(lock));
1131	>	assertFalse(lock.hasQueuedThread(t1));
1132	>	assertFalse(lock.hasQueuedThread(t2));
1133	>	lock.writeLock().lock();
1134	>	long startTime = System.nanoTime();
1135	>	t1.start();
1136	>	waitForQueuedThread(lock, t1);
1137	>	assertTrue(lock.hasQueuedThread(t1));
1138	>	assertFalse(lock.hasQueuedThread(t2));
1139	>	t2.start();
1140	>	waitForQueuedThread(lock, t2);
1141	>	assertTrue(lock.hasQueuedThread(t1));
1142	>	assertTrue(lock.hasQueuedThread(t2));
1143	>	t1.interrupt();
1144	>	awaitTermination(t1);
1145	>	assertFalse(lock.hasQueuedThread(t1));
1146	>	assertTrue(lock.hasQueuedThread(t2));
1147	>	lock.writeLock().unlock();
1148	>	awaitTermination(t2);
1149	>	assertFalse(lock.hasQueuedThread(t1));
1150	>	assertFalse(lock.hasQueuedThread(t2));
1151	>	}
1152	>
1153	>	/**
1154	>	* getQueueLength reports number of waiting threads
1155	>	*/
1156	>	public void testGetQueueLength() throws InterruptedException {
1157	>	final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
1158	>	Thread t1 = new Thread(new InterruptedLockRunnable(lock));
1159	>	Thread t2 = new Thread(new InterruptibleLockRunnable(lock));
1160	>	assertEquals(0, lock.getQueueLength());
1161	>	lock.writeLock().lock();
1162	>	long startTime = System.nanoTime();
1163	>	t1.start();
1164	>	waitForQueuedThread(lock, t1);
1165	>	assertEquals(1, lock.getQueueLength());
1166	>	t2.start();
1167	>	waitForQueuedThread(lock, t2);
1168	>	assertEquals(2, lock.getQueueLength());
1169	>	t1.interrupt();
1170	>	awaitTermination(t1);
1171	>	assertEquals(1, lock.getQueueLength());
1172	>	lock.writeLock().unlock();
1173	>	awaitTermination(t2);
1174	>	assertEquals(0, lock.getQueueLength());
1175	>	}
1176	>
1177	>	/**
1178	>	* getQueuedThreads includes waiting threads
1179	>	*/
1180	>	public void testGetQueuedThreads() throws InterruptedException {
1181	>	final PublicReentrantReadWriteLock lock = new PublicReentrantReadWriteLock();
1182	>	Thread t1 = new Thread(new InterruptedLockRunnable(lock));
1183	>	Thread t2 = new Thread(new InterruptibleLockRunnable(lock));
1184	>	assertTrue(lock.getQueuedThreads().isEmpty());
1185	>	lock.writeLock().lock();
1186	>	long startTime = System.nanoTime();
1187	>	assertTrue(lock.getQueuedThreads().isEmpty());
1188	>	t1.start();
1189	>	waitForQueuedThread(lock, t1);
1190	>	assertEquals(1, lock.getQueuedThreads().size());
1191	>	assertTrue(lock.getQueuedThreads().contains(t1));
1192	>	t2.start();
1193	>	waitForQueuedThread(lock, t2);
1194	>	assertEquals(2, lock.getQueuedThreads().size());
1195	>	assertTrue(lock.getQueuedThreads().contains(t1));
1196	>	assertTrue(lock.getQueuedThreads().contains(t2));
1197	>	t1.interrupt();
1198	>	awaitTermination(t1);
1199	>	assertFalse(lock.getQueuedThreads().contains(t1));
1200	>	assertTrue(lock.getQueuedThreads().contains(t2));
1201	>	assertEquals(1, lock.getQueuedThreads().size());
1202	>	lock.writeLock().unlock();
1203	>	awaitTermination(t2);
1204	>	assertTrue(lock.getQueuedThreads().isEmpty());
1205	>	}
1206	>
1207	>	/**
1208	>	* hasWaiters throws NPE if null
1209	>	*/
1210	>	public void testHasWaitersNPE() {
1211	>	final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
1212	>	try {
1213	>	lock.hasWaiters(null);
1214	>	shouldThrow();
1215	>	} catch (NullPointerException success) {}
1216	>	}
1217	>
1218	>	/**
1219	>	* getWaitQueueLength throws NPE if null
1220	>	*/
1221	>	public void testGetWaitQueueLengthNPE() {
1222	>	final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
1223	>	try {
1224	>	lock.getWaitQueueLength(null);
1225	>	shouldThrow();
1226	>	} catch (NullPointerException success) {}
1227	>	}
1228	>
1229	>	/**
1230	>	* getWaitingThreads throws NPE if null
1231	>	*/
1232	>	public void testGetWaitingThreadsNPE() {
1233	>	final PublicReentrantReadWriteLock lock = new PublicReentrantReadWriteLock();
1234	>	try {
1235	>	lock.getWaitingThreads(null);
1236	>	shouldThrow();
1237	>	} catch (NullPointerException success) {}
1238	>	}
1239	>
1240	>	/**
1241	>	* hasWaiters throws IAE if not owned
1242	>	*/
1243	>	public void testHasWaitersIAE() {
1244	>	final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
1245	>	final Condition c = lock.writeLock().newCondition();
1246	>	final ReentrantReadWriteLock lock2 = new ReentrantReadWriteLock();
1247	>	try {
1248	>	lock2.hasWaiters(c);
1249	>	shouldThrow();
1250	>	} catch (IllegalArgumentException success) {}
1251	>	}
1252	>
1253	>	/**
1254	>	* hasWaiters throws IMSE if not locked
1255	>	*/
1256	>	public void testHasWaitersIMSE() {
1257	>	final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
1258	>	final Condition c = lock.writeLock().newCondition();
1259	>	try {
1260	>	lock.hasWaiters(c);
1261	>	shouldThrow();
1262	>	} catch (IllegalMonitorStateException success) {}
1263	>	}
1264	>
1265	>	/**
1266	>	* getWaitQueueLength throws IAE if not owned
1267	>	*/
1268	>	public void testGetWaitQueueLengthIAE() {
1269	>	final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
1270	>	final Condition c = lock.writeLock().newCondition();
1271	>	final ReentrantReadWriteLock lock2 = new ReentrantReadWriteLock();
1272	>	try {
1273	>	lock2.getWaitQueueLength(c);
1274	>	shouldThrow();
1275	>	} catch (IllegalArgumentException success) {}
1276		}
1277
1278	+	/**
1279	+	* getWaitQueueLength throws IMSE if not locked
1280	+	*/
1281	+	public void testGetWaitQueueLengthIMSE() {
1282	+	final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
1283	+	final Condition c = lock.writeLock().newCondition();
1284	+	try {
1285	+	lock.getWaitQueueLength(c);
1286	+	shouldThrow();
1287	+	} catch (IllegalMonitorStateException success) {}
1288	+	}
1289	+
1290	+	/**
1291	+	* getWaitingThreads throws IAE if not owned
1292	+	*/
1293	+	public void testGetWaitingThreadsIAE() {
1294	+	final PublicReentrantReadWriteLock lock = new PublicReentrantReadWriteLock();
1295	+	final Condition c = lock.writeLock().newCondition();
1296	+	final PublicReentrantReadWriteLock lock2 = new PublicReentrantReadWriteLock();
1297	+	try {
1298	+	lock2.getWaitingThreads(c);
1299	+	shouldThrow();
1300	+	} catch (IllegalArgumentException success) {}
1301	+	}
1302	+
1303	+	/**
1304	+	* getWaitingThreads throws IMSE if not locked
1305	+	*/
1306	+	public void testGetWaitingThreadsIMSE() {
1307	+	final PublicReentrantReadWriteLock lock = new PublicReentrantReadWriteLock();
1308	+	final Condition c = lock.writeLock().newCondition();
1309	+	try {
1310	+	lock.getWaitingThreads(c);
1311	+	shouldThrow();
1312	+	} catch (IllegalMonitorStateException success) {}
1313	+	}
1314	+
1315	+	/**
1316	+	* hasWaiters returns true when a thread is waiting, else false
1317	+	*/
1318	+	public void testHasWaiters() throws InterruptedException {
1319	+	final PublicReentrantReadWriteLock lock = new PublicReentrantReadWriteLock();
1320	+	final Condition c = lock.writeLock().newCondition();
1321	+	final CountDownLatch locked = new CountDownLatch(1);
1322	+	Thread t = newStartedThread(new CheckedRunnable() {
1323	+	public void realRun() throws InterruptedException {
1324	+	lock.writeLock().lock();
1325	+	assertFalse(lock.hasWaiters(c));
1326	+	locked.countDown();
1327	+	assertEquals(0, lock.getWaitQueueLength(c));
1328	+	c.await();
1329	+	lock.writeLock().unlock();
1330	+	}});
1331	+
1332	+	locked.await();
1333	+	lock.writeLock().lock();
1334	+	assertTrue(lock.hasWaiters(c));
1335	+	assertEquals(1, lock.getWaitQueueLength(c));
1336	+	c.signal();
1337	+	assertHasNoWaiters(lock, c);
1338	+	lock.writeLock().unlock();
1339	+	awaitTermination(t);
1340	+	assertHasNoWaiters(lock, c);
1341	+	}
1342	+
1343	+	/**
1344	+	* getWaitQueueLength returns number of waiting threads
1345	+	*/
1346	+	public void testGetWaitQueueLength() throws InterruptedException {
1347	+	final PublicReentrantReadWriteLock lock = new PublicReentrantReadWriteLock();
1348	+	final Condition c = lock.writeLock().newCondition();
1349	+	final CountDownLatch locked = new CountDownLatch(1);
1350	+	Thread t = newStartedThread(new CheckedRunnable() {
1351	+	public void realRun() throws InterruptedException {
1352	+	lock.writeLock().lock();
1353	+	assertEquals(0, lock.getWaitQueueLength(c));
1354	+	locked.countDown();
1355	+	c.await();
1356	+	lock.writeLock().unlock();
1357	+	}});
1358	+
1359	+	locked.await();
1360	+	lock.writeLock().lock();
1361	+	assertHasWaiters(lock, c, t);
1362	+	assertEquals(1, lock.getWaitQueueLength(c));
1363	+	c.signal();
1364	+	assertHasNoWaiters(lock, c);
1365	+	assertEquals(0, lock.getWaitQueueLength(c));
1366	+	lock.writeLock().unlock();
1367	+	awaitTermination(t);
1368	+	}
1369	+
1370	+	/**
1371	+	* getWaitingThreads returns only and all waiting threads
1372	+	*/
1373	+	public void testGetWaitingThreads() throws InterruptedException {
1374	+	final PublicReentrantReadWriteLock lock = new PublicReentrantReadWriteLock();
1375	+	final Condition c = lock.writeLock().newCondition();
1376	+	final CountDownLatch locked1 = new CountDownLatch(1);
1377	+	final CountDownLatch locked2 = new CountDownLatch(1);
1378	+	Thread t1 = new Thread(new CheckedRunnable() {
1379	+	public void realRun() throws InterruptedException {
1380	+	lock.writeLock().lock();
1381	+	assertTrue(lock.getWaitingThreads(c).isEmpty());
1382	+	locked1.countDown();
1383	+	c.await();
1384	+	lock.writeLock().unlock();
1385	+	}});
1386	+
1387	+	Thread t2 = new Thread(new CheckedRunnable() {
1388	+	public void realRun() throws InterruptedException {
1389	+	lock.writeLock().lock();
1390	+	assertFalse(lock.getWaitingThreads(c).isEmpty());
1391	+	locked2.countDown();
1392	+	c.await();
1393	+	lock.writeLock().unlock();
1394	+	}});
1395	+
1396	+	lock.writeLock().lock();
1397	+	assertTrue(lock.getWaitingThreads(c).isEmpty());
1398	+	lock.writeLock().unlock();
1399	+
1400	+	t1.start();
1401	+	locked1.await();
1402	+	t2.start();
1403	+	locked2.await();
1404	+
1405	+	lock.writeLock().lock();
1406	+	assertTrue(lock.hasWaiters(c));
1407	+	assertTrue(lock.getWaitingThreads(c).contains(t1));
1408	+	assertTrue(lock.getWaitingThreads(c).contains(t2));
1409	+	assertEquals(2, lock.getWaitingThreads(c).size());
1410	+	c.signalAll();
1411	+	assertHasNoWaiters(lock, c);
1412	+	lock.writeLock().unlock();
1413	+
1414	+	awaitTermination(t1);
1415	+	awaitTermination(t2);
1416	+
1417	+	assertHasNoWaiters(lock, c);
1418	+	}
1419	+
1420	+	/**
1421	+	* toString indicates current lock state
1422	+	*/
1423	+	public void testToString() {
1424	+	ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
1425	+	String us = lock.toString();
1426	+	assertTrue(us.indexOf("Write locks = 0") >= 0);
1427	+	assertTrue(us.indexOf("Read locks = 0") >= 0);
1428	+	lock.writeLock().lock();
1429	+	String ws = lock.toString();
1430	+	assertTrue(ws.indexOf("Write locks = 1") >= 0);
1431	+	assertTrue(ws.indexOf("Read locks = 0") >= 0);
1432	+	lock.writeLock().unlock();
1433	+	lock.readLock().lock();
1434	+	lock.readLock().lock();
1435	+	String rs = lock.toString();
1436	+	assertTrue(rs.indexOf("Write locks = 0") >= 0);
1437	+	assertTrue(rs.indexOf("Read locks = 2") >= 0);
1438	+	}
1439	+
1440	+	/**
1441	+	* readLock.toString indicates current lock state
1442	+	*/
1443	+	public void testReadLockToString() {
1444	+	ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
1445	+	String us = lock.readLock().toString();
1446	+	assertTrue(us.indexOf("Read locks = 0") >= 0);
1447	+	lock.readLock().lock();
1448	+	lock.readLock().lock();
1449	+	String rs = lock.readLock().toString();
1450	+	assertTrue(rs.indexOf("Read locks = 2") >= 0);
1451	+	}
1452	+
1453	+	/**
1454	+	* writeLock.toString indicates current lock state
1455	+	*/
1456	+	public void testWriteLockToString() {
1457	+	ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
1458	+	String us = lock.writeLock().toString();
1459	+	assertTrue(us.indexOf("Unlocked") >= 0);
1460	+	lock.writeLock().lock();
1461	+	String ls = lock.writeLock().toString();
1462	+	assertTrue(ls.indexOf("Locked") >= 0);
1463	+	}
1464
1465		}

Diff Legend

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