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.33 by jsr166, Tue Nov 17 14:33:55 2009 UTC vs.
Revision 1.37 by jsr166, Sat Nov 21 10:25:05 2009 UTC

#	Line 9 | Line 9
9		import junit.framework.*;
10		import java.util.concurrent.locks.*;
11		import java.util.concurrent.*;
12	+	import static java.util.concurrent.TimeUnit.MILLISECONDS;
13		import java.io.*;
14		import java.util.*;
15
16		public class ReentrantReadWriteLockTest extends JSR166TestCase {
17		public static void main(String[] args) {
18	<	junit.textui.TestRunner.run (suite());
18	>	junit.textui.TestRunner.run (suite());
19		}
20		public static Test suite() {
21	<	return new TestSuite(ReentrantReadWriteLockTest.class);
21	>	return new TestSuite(ReentrantReadWriteLockTest.class);
22		}
23
24		/**
#	Line 61 | Line 62 | public class ReentrantReadWriteLockTest
62		* Constructor sets given fairness, and is in unlocked state
63		*/
64		public void testConstructor() {
65	<	ReentrantReadWriteLock rl = new ReentrantReadWriteLock();
65	>	ReentrantReadWriteLock rl = new ReentrantReadWriteLock();
66		assertFalse(rl.isFair());
67		assertFalse(rl.isWriteLocked());
68		assertEquals(0, rl.getReadLockCount());
69	<	ReentrantReadWriteLock r2 = new ReentrantReadWriteLock(true);
69	>	ReentrantReadWriteLock r2 = new ReentrantReadWriteLock(true);
70		assertTrue(r2.isFair());
71		assertFalse(r2.isWriteLocked());
72		assertEquals(0, r2.getReadLockCount());
73	<	ReentrantReadWriteLock r3 = new ReentrantReadWriteLock(false);
73	>	ReentrantReadWriteLock r3 = new ReentrantReadWriteLock(false);
74		assertFalse(r3.isFair());
75		assertFalse(r3.isWriteLocked());
76		assertEquals(0, r3.getReadLockCount());
#	Line 79 | Line 80 | public class ReentrantReadWriteLockTest
80		* write-locking and read-locking an unlocked lock succeed
81		*/
82		public void testLock() {
83	<	ReentrantReadWriteLock rl = new ReentrantReadWriteLock();
83	>	ReentrantReadWriteLock rl = new ReentrantReadWriteLock();
84		rl.writeLock().lock();
85		assertTrue(rl.isWriteLocked());
86		assertTrue(rl.isWriteLockedByCurrentThread());
#	Line 105 | Line 106 | public class ReentrantReadWriteLockTest
106		* locking an unlocked fair lock succeeds
107		*/
108		public void testFairLock() {
109	<	ReentrantReadWriteLock rl = new ReentrantReadWriteLock(true);
109	>	ReentrantReadWriteLock rl = new ReentrantReadWriteLock(true);
110		rl.writeLock().lock();
111		assertTrue(rl.isWriteLocked());
112		assertTrue(rl.isWriteLockedByCurrentThread());
#	Line 130 | Line 131 | public class ReentrantReadWriteLockTest
131		* getWriteHoldCount returns number of recursive holds
132		*/
133		public void testGetWriteHoldCount() {
134	<	ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
135	<	for (int i = 1; i <= SIZE; i++) {
136	<	lock.writeLock().lock();
137	<	assertEquals(i,lock.getWriteHoldCount());
138	<	}
139	<	for (int i = SIZE; i > 0; i--) {
140	<	lock.writeLock().unlock();
141	<	assertEquals(i-1,lock.getWriteHoldCount());
142	<	}
134	>	ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
135	>	for (int i = 1; i <= SIZE; i++) {
136	>	lock.writeLock().lock();
137	>	assertEquals(i,lock.getWriteHoldCount());
138	>	}
139	>	for (int i = SIZE; i > 0; i--) {
140	>	lock.writeLock().unlock();
141	>	assertEquals(i-1,lock.getWriteHoldCount());
142	>	}
143		}
144
145		/**
146		* WriteLock.getHoldCount returns number of recursive holds
147		*/
148		public void testGetHoldCount() {
149	<	ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
150	<	for (int i = 1; i <= SIZE; i++) {
151	<	lock.writeLock().lock();
152	<	assertEquals(i,lock.writeLock().getHoldCount());
153	<	}
154	<	for (int i = SIZE; i > 0; i--) {
155	<	lock.writeLock().unlock();
156	<	assertEquals(i-1,lock.writeLock().getHoldCount());
157	<	}
149	>	ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
150	>	for (int i = 1; i <= SIZE; i++) {
151	>	lock.writeLock().lock();
152	>	assertEquals(i,lock.writeLock().getHoldCount());
153	>	}
154	>	for (int i = SIZE; i > 0; i--) {
155	>	lock.writeLock().unlock();
156	>	assertEquals(i-1,lock.writeLock().getHoldCount());
157	>	}
158		}
159
160		/**
161		* getReadHoldCount returns number of recursive holds
162		*/
163		public void testGetReadHoldCount() {
164	<	ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
165	<	for (int i = 1; i <= SIZE; i++) {
166	<	lock.readLock().lock();
167	<	assertEquals(i,lock.getReadHoldCount());
168	<	}
169	<	for (int i = SIZE; i > 0; i--) {
170	<	lock.readLock().unlock();
171	<	assertEquals(i-1,lock.getReadHoldCount());
172	<	}
164	>	ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
165	>	for (int i = 1; i <= SIZE; i++) {
166	>	lock.readLock().lock();
167	>	assertEquals(i,lock.getReadHoldCount());
168	>	}
169	>	for (int i = SIZE; i > 0; i--) {
170	>	lock.readLock().unlock();
171	>	assertEquals(i-1,lock.getReadHoldCount());
172	>	}
173		}
174
175
#	Line 176 | Line 177 | public class ReentrantReadWriteLockTest
177		* write-unlocking an unlocked lock throws IllegalMonitorStateException
178		*/
179		public void testUnlock_IllegalMonitorStateException() {
180	<	ReentrantReadWriteLock rl = new ReentrantReadWriteLock();
181	<	try {
182	<	rl.writeLock().unlock();
183	<	shouldThrow();
184	<	} catch (IllegalMonitorStateException success) {}
180	>	ReentrantReadWriteLock rl = new ReentrantReadWriteLock();
181	>	try {
182	>	rl.writeLock().unlock();
183	>	shouldThrow();
184	>	} catch (IllegalMonitorStateException success) {}
185		}
186
187
#	Line 188 | Line 189 | public class ReentrantReadWriteLockTest
189		* write-lockInterruptibly is interruptible
190		*/
191		public void testWriteLockInterruptibly_Interrupted() throws Exception {
192	<	final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
193	<	Thread t = new Thread(new CheckedInterruptedRunnable() {
192	>	final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
193	>	Thread t = new Thread(new CheckedInterruptedRunnable() {
194		public void realRun() throws InterruptedException {
195		lock.writeLock().lockInterruptibly();
196		lock.writeLock().unlock();
#	Line 210 | Line 211 | public class ReentrantReadWriteLockTest
211		* timed write-tryLock is interruptible
212		*/
213		public void testWriteTryLock_Interrupted() throws InterruptedException {
214	<	final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
215	<	lock.writeLock().lock();
216	<	Thread t = new Thread(new CheckedInterruptedRunnable() {
214	>	final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
215	>	lock.writeLock().lock();
216	>	Thread t = new Thread(new CheckedInterruptedRunnable() {
217		public void realRun() throws InterruptedException {
218	<	lock.writeLock().tryLock(1000,TimeUnit.MILLISECONDS);
218	>	lock.writeLock().tryLock(1000,MILLISECONDS);
219		}});
220
221		t.start();
#	Line 227 | Line 228 | public class ReentrantReadWriteLockTest
228		* read-lockInterruptibly is interruptible
229		*/
230		public void testReadLockInterruptibly_Interrupted() throws InterruptedException {
231	<	final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
232	<	lock.writeLock().lock();
233	<	Thread t = new Thread(new CheckedInterruptedRunnable() {
231	>	final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
232	>	lock.writeLock().lock();
233	>	Thread t = new Thread(new CheckedInterruptedRunnable() {
234		public void realRun() throws InterruptedException {
235		lock.readLock().lockInterruptibly();
236		}});
#	Line 246 | Line 247 | public class ReentrantReadWriteLockTest
247		* timed read-tryLock is interruptible
248		*/
249		public void testReadTryLock_Interrupted() throws InterruptedException {
250	<	final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
251	<	lock.writeLock().lock();
252	<	Thread t = new Thread(new CheckedInterruptedRunnable() {
250	>	final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
251	>	lock.writeLock().lock();
252	>	Thread t = new Thread(new CheckedInterruptedRunnable() {
253		public void realRun() throws InterruptedException {
254	<	lock.readLock().tryLock(1000,TimeUnit.MILLISECONDS);
254	>	lock.readLock().tryLock(1000,MILLISECONDS);
255		}});
256
257		t.start();
#	Line 263 | Line 264 | public class ReentrantReadWriteLockTest
264		* write-tryLock fails if locked
265		*/
266		public void testWriteTryLockWhenLocked() throws InterruptedException {
267	<	final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
268	<	lock.writeLock().lock();
269	<	Thread t = new Thread(new Runnable() {
270	<	public void run() {
271	<	threadAssertFalse(lock.writeLock().tryLock());
272	<	}
272	<	});
267	>	final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
268	>	lock.writeLock().lock();
269	>	Thread t = new Thread(new CheckedRunnable() {
270	>	public void realRun() {
271	>	threadAssertFalse(lock.writeLock().tryLock());
272	>	}});
273
274		t.start();
275		t.join();
#	Line 280 | Line 280 | public class ReentrantReadWriteLockTest
280		* read-tryLock fails if locked
281		*/
282		public void testReadTryLockWhenLocked() throws InterruptedException {
283	<	final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
284	<	lock.writeLock().lock();
285	<	Thread t = new Thread(new Runnable() {
286	<	public void run() {
287	<	threadAssertFalse(lock.readLock().tryLock());
288	<	}
289	<	});
283	>	final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
284	>	lock.writeLock().lock();
285	>	Thread t = new Thread(new CheckedRunnable() {
286	>	public void realRun() {
287	>	threadAssertFalse(lock.readLock().tryLock());
288	>	}});
289
290		t.start();
291		t.join();
#	Line 297 | Line 296 | public class ReentrantReadWriteLockTest
296		* Multiple threads can hold a read lock when not write-locked
297		*/
298		public void testMultipleReadLocks() throws InterruptedException {
299	<	final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
300	<	lock.readLock().lock();
301	<	Thread t = new Thread(new Runnable() {
302	<	public void run() {
303	<	threadAssertTrue(lock.readLock().tryLock());
304	<	lock.readLock().unlock();
305	<	}
307	<	});
299	>	final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
300	>	lock.readLock().lock();
301	>	Thread t = new Thread(new CheckedRunnable() {
302	>	public void realRun() {
303	>	threadAssertTrue(lock.readLock().tryLock());
304	>	lock.readLock().unlock();
305	>	}});
306
307		t.start();
308		t.join();
#	Line 315 | Line 313 | public class ReentrantReadWriteLockTest
313		* A writelock succeeds after reading threads unlock
314		*/
315		public void testWriteAfterMultipleReadLocks() throws InterruptedException {
316	<	final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
317	<	lock.readLock().lock();
318	<	Thread t1 = new Thread(new Runnable() {
319	<	public void run() {
320	<	lock.readLock().lock();
321	<	lock.readLock().unlock();
322	<	}
323	<	});
324	<	Thread t2 = new Thread(new Runnable() {
325	<	public void run() {
326	<	lock.writeLock().lock();
327	<	lock.writeLock().unlock();
330	<	}
331	<	});
316	>	final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
317	>	lock.readLock().lock();
318	>	Thread t1 = new Thread(new CheckedRunnable() {
319	>	public void realRun() {
320	>	lock.readLock().lock();
321	>	lock.readLock().unlock();
322	>	}});
323	>	Thread t2 = new Thread(new CheckedRunnable() {
324	>	public void realRun() {
325	>	lock.writeLock().lock();
326	>	lock.writeLock().unlock();
327	>	}});
328
329		t1.start();
330		t2.start();
#	Line 344 | Line 340 | public class ReentrantReadWriteLockTest
340		* Readlocks succeed after a writing thread unlocks
341		*/
342		public void testReadAfterWriteLock() throws InterruptedException {
343	<	final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
344	<	lock.writeLock().lock();
345	<	Thread t1 = new Thread(new Runnable() {
346	<	public void run() {
347	<	lock.readLock().lock();
348	<	lock.readLock().unlock();
349	<	}
350	<	});
351	<	Thread t2 = new Thread(new Runnable() {
352	<	public void run() {
353	<	lock.readLock().lock();
354	<	lock.readLock().unlock();
359	<	}
360	<	});
343	>	final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
344	>	lock.writeLock().lock();
345	>	Thread t1 = new Thread(new CheckedRunnable() {
346	>	public void realRun() {
347	>	lock.readLock().lock();
348	>	lock.readLock().unlock();
349	>	}});
350	>	Thread t2 = new Thread(new CheckedRunnable() {
351	>	public void realRun() {
352	>	lock.readLock().lock();
353	>	lock.readLock().unlock();
354	>	}});
355
356		t1.start();
357		t2.start();
#	Line 373 | Line 367 | public class ReentrantReadWriteLockTest
367		* Read trylock succeeds if write locked by current thread
368		*/
369		public void testReadHoldingWriteLock() {
370	<	final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
371	<	lock.writeLock().lock();
370	>	final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
371	>	lock.writeLock().lock();
372		assertTrue(lock.readLock().tryLock());
373		lock.readLock().unlock();
374		lock.writeLock().unlock();
#	Line 385 | Line 379 | public class ReentrantReadWriteLockTest
379		* other threads are waiting for readlock
380		*/
381		public void testReadHoldingWriteLock2() throws InterruptedException {
382	<	final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
383	<	lock.writeLock().lock();
384	<	Thread t1 = new Thread(new Runnable() {
385	<	public void run() {
386	<	lock.readLock().lock();
387	<	lock.readLock().unlock();
388	<	}
389	<	});
390	<	Thread t2 = new Thread(new Runnable() {
391	<	public void run() {
392	<	lock.readLock().lock();
393	<	lock.readLock().unlock();
400	<	}
401	<	});
382	>	final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
383	>	lock.writeLock().lock();
384	>	Thread t1 = new Thread(new CheckedRunnable() {
385	>	public void realRun() {
386	>	lock.readLock().lock();
387	>	lock.readLock().unlock();
388	>	}});
389	>	Thread t2 = new Thread(new CheckedRunnable() {
390	>	public void realRun() {
391	>	lock.readLock().lock();
392	>	lock.readLock().unlock();
393	>	}});
394
395		t1.start();
396		t2.start();
#	Line 419 | Line 411 | public class ReentrantReadWriteLockTest
411		* other threads are waiting for writelock
412		*/
413		public void testReadHoldingWriteLock3() throws InterruptedException {
414	<	final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
415	<	lock.writeLock().lock();
416	<	Thread t1 = new Thread(new Runnable() {
417	<	public void run() {
418	<	lock.writeLock().lock();
419	<	lock.writeLock().unlock();
420	<	}
421	<	});
422	<	Thread t2 = new Thread(new Runnable() {
423	<	public void run() {
424	<	lock.writeLock().lock();
425	<	lock.writeLock().unlock();
434	<	}
435	<	});
414	>	final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
415	>	lock.writeLock().lock();
416	>	Thread t1 = new Thread(new CheckedRunnable() {
417	>	public void realRun() {
418	>	lock.writeLock().lock();
419	>	lock.writeLock().unlock();
420	>	}});
421	>	Thread t2 = new Thread(new CheckedRunnable() {
422	>	public void realRun() {
423	>	lock.writeLock().lock();
424	>	lock.writeLock().unlock();
425	>	}});
426
427		t1.start();
428		t2.start();
#	Line 454 | Line 444 | public class ReentrantReadWriteLockTest
444		* other threads are waiting for writelock
445		*/
446		public void testWriteHoldingWriteLock4() throws InterruptedException {
447	<	final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
448	<	lock.writeLock().lock();
449	<	Thread t1 = new Thread(new Runnable() {
450	<	public void run() {
451	<	lock.writeLock().lock();
452	<	lock.writeLock().unlock();
453	<	}
454	<	});
455	<	Thread t2 = new Thread(new Runnable() {
456	<	public void run() {
457	<	lock.writeLock().lock();
458	<	lock.writeLock().unlock();
469	<	}
470	<	});
447	>	final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
448	>	lock.writeLock().lock();
449	>	Thread t1 = new Thread(new CheckedRunnable() {
450	>	public void realRun() {
451	>	lock.writeLock().lock();
452	>	lock.writeLock().unlock();
453	>	}});
454	>	Thread t2 = new Thread(new CheckedRunnable() {
455	>	public void realRun() {
456	>	lock.writeLock().lock();
457	>	lock.writeLock().unlock();
458	>	}});
459
460		t1.start();
461		t2.start();
#	Line 488 | Line 476 | public class ReentrantReadWriteLockTest
476		* Fair Read trylock succeeds if write locked by current thread
477		*/
478		public void testReadHoldingWriteLockFair() {
479	<	final ReentrantReadWriteLock lock = new ReentrantReadWriteLock(true);
480	<	lock.writeLock().lock();
479	>	final ReentrantReadWriteLock lock = new ReentrantReadWriteLock(true);
480	>	lock.writeLock().lock();
481		assertTrue(lock.readLock().tryLock());
482		lock.readLock().unlock();
483		lock.writeLock().unlock();
#	Line 500 | Line 488 | public class ReentrantReadWriteLockTest
488		* other threads are waiting for readlock
489		*/
490		public void testReadHoldingWriteLockFair2() throws InterruptedException {
491	<	final ReentrantReadWriteLock lock = new ReentrantReadWriteLock(true);
492	<	lock.writeLock().lock();
493	<	Thread t1 = new Thread(new Runnable() {
494	<	public void run() {
495	<	lock.readLock().lock();
496	<	lock.readLock().unlock();
497	<	}
498	<	});
499	<	Thread t2 = new Thread(new Runnable() {
500	<	public void run() {
501	<	lock.readLock().lock();
502	<	lock.readLock().unlock();
515	<	}
516	<	});
491	>	final ReentrantReadWriteLock lock = new ReentrantReadWriteLock(true);
492	>	lock.writeLock().lock();
493	>	Thread t1 = new Thread(new CheckedRunnable() {
494	>	public void realRun() {
495	>	lock.readLock().lock();
496	>	lock.readLock().unlock();
497	>	}});
498	>	Thread t2 = new Thread(new CheckedRunnable() {
499	>	public void realRun() {
500	>	lock.readLock().lock();
501	>	lock.readLock().unlock();
502	>	}});
503
504		t1.start();
505		t2.start();
#	Line 535 | Line 521 | public class ReentrantReadWriteLockTest
521		* other threads are waiting for writelock
522		*/
523		public void testReadHoldingWriteLockFair3() throws InterruptedException {
524	<	final ReentrantReadWriteLock lock = new ReentrantReadWriteLock(true);
525	<	lock.writeLock().lock();
526	<	Thread t1 = new Thread(new Runnable() {
527	<	public void run() {
528	<	lock.writeLock().lock();
529	<	lock.writeLock().unlock();
530	<	}
531	<	});
532	<	Thread t2 = new Thread(new Runnable() {
533	<	public void run() {
534	<	lock.writeLock().lock();
535	<	lock.writeLock().unlock();
550	<	}
551	<	});
524	>	final ReentrantReadWriteLock lock = new ReentrantReadWriteLock(true);
525	>	lock.writeLock().lock();
526	>	Thread t1 = new Thread(new CheckedRunnable() {
527	>	public void realRun() {
528	>	lock.writeLock().lock();
529	>	lock.writeLock().unlock();
530	>	}});
531	>	Thread t2 = new Thread(new CheckedRunnable() {
532	>	public void realRun() {
533	>	lock.writeLock().lock();
534	>	lock.writeLock().unlock();
535	>	}});
536
537		t1.start();
538		t2.start();
#	Line 570 | Line 554 | public class ReentrantReadWriteLockTest
554		* other threads are waiting for writelock
555		*/
556		public void testWriteHoldingWriteLockFair4() throws InterruptedException {
557	<	final ReentrantReadWriteLock lock = new ReentrantReadWriteLock(true);
558	<	lock.writeLock().lock();
559	<	Thread t1 = new Thread(new Runnable() {
560	<	public void run() {
561	<	lock.writeLock().lock();
562	<	lock.writeLock().unlock();
563	<	}
564	<	});
565	<	Thread t2 = new Thread(new Runnable() {
566	<	public void run() {
567	<	lock.writeLock().lock();
568	<	lock.writeLock().unlock();
585	<	}
586	<	});
557	>	final ReentrantReadWriteLock lock = new ReentrantReadWriteLock(true);
558	>	lock.writeLock().lock();
559	>	Thread t1 = new Thread(new CheckedRunnable() {
560	>	public void realRun() {
561	>	lock.writeLock().lock();
562	>	lock.writeLock().unlock();
563	>	}});
564	>	Thread t2 = new Thread(new CheckedRunnable() {
565	>	public void realRun() {
566	>	lock.writeLock().lock();
567	>	lock.writeLock().unlock();
568	>	}});
569
570		t1.start();
571		t2.start();
#	Line 607 | Line 589 | public class ReentrantReadWriteLockTest
589		* Read tryLock succeeds if readlocked but not writelocked
590		*/
591		public void testTryLockWhenReadLocked() throws InterruptedException {
592	<	final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
593	<	lock.readLock().lock();
594	<	Thread t = new Thread(new Runnable() {
595	<	public void run() {
596	<	threadAssertTrue(lock.readLock().tryLock());
597	<	lock.readLock().unlock();
598	<	}
617	<	});
592	>	final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
593	>	lock.readLock().lock();
594	>	Thread t = new Thread(new CheckedRunnable() {
595	>	public void realRun() {
596	>	threadAssertTrue(lock.readLock().tryLock());
597	>	lock.readLock().unlock();
598	>	}});
599
600		t.start();
601		t.join();
#	Line 627 | Line 608 | public class ReentrantReadWriteLockTest
608		* write tryLock fails when readlocked
609		*/
610		public void testWriteTryLockWhenReadLocked() throws InterruptedException {
611	<	final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
612	<	lock.readLock().lock();
613	<	Thread t = new Thread(new Runnable() {
614	<	public void run() {
615	<	threadAssertFalse(lock.writeLock().tryLock());
616	<	}
636	<	});
611	>	final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
612	>	lock.readLock().lock();
613	>	Thread t = new Thread(new CheckedRunnable() {
614	>	public void realRun() {
615	>	threadAssertFalse(lock.writeLock().tryLock());
616	>	}});
617
618		t.start();
619		t.join();
#	Line 645 | Line 625 | public class ReentrantReadWriteLockTest
625		* Fair Read tryLock succeeds if readlocked but not writelocked
626		*/
627		public void testTryLockWhenReadLockedFair() throws InterruptedException {
628	<	final ReentrantReadWriteLock lock = new ReentrantReadWriteLock(true);
629	<	lock.readLock().lock();
630	<	Thread t = new Thread(new Runnable() {
631	<	public void run() {
632	<	threadAssertTrue(lock.readLock().tryLock());
633	<	lock.readLock().unlock();
634	<	}
655	<	});
628	>	final ReentrantReadWriteLock lock = new ReentrantReadWriteLock(true);
629	>	lock.readLock().lock();
630	>	Thread t = new Thread(new CheckedRunnable() {
631	>	public void realRun() {
632	>	threadAssertTrue(lock.readLock().tryLock());
633	>	lock.readLock().unlock();
634	>	}});
635
636		t.start();
637		t.join();
#	Line 665 | Line 644 | public class ReentrantReadWriteLockTest
644		* Fair write tryLock fails when readlocked
645		*/
646		public void testWriteTryLockWhenReadLockedFair() throws InterruptedException {
647	<	final ReentrantReadWriteLock lock = new ReentrantReadWriteLock(true);
648	<	lock.readLock().lock();
649	<	Thread t = new Thread(new Runnable() {
650	<	public void run() {
651	<	threadAssertFalse(lock.writeLock().tryLock());
652	<	}
674	<	});
647	>	final ReentrantReadWriteLock lock = new ReentrantReadWriteLock(true);
648	>	lock.readLock().lock();
649	>	Thread t = new Thread(new CheckedRunnable() {
650	>	public void realRun() {
651	>	threadAssertFalse(lock.writeLock().tryLock());
652	>	}});
653
654		t.start();
655		t.join();
#	Line 684 | Line 662 | public class ReentrantReadWriteLockTest
662		* write timed tryLock times out if locked
663		*/
664		public void testWriteTryLock_Timeout() throws InterruptedException {
665	<	final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
666	<	lock.writeLock().lock();
667	<	Thread t = new Thread(new CheckedRunnable() {
665	>	final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
666	>	lock.writeLock().lock();
667	>	Thread t = new Thread(new CheckedRunnable() {
668		public void realRun() throws InterruptedException {
669	<	threadAssertFalse(lock.writeLock().tryLock(1, TimeUnit.MILLISECONDS));
669	>	threadAssertFalse(lock.writeLock().tryLock(1, MILLISECONDS));
670		}});
671
672		t.start();
673		t.join();
674	+	assertTrue(lock.writeLock().isHeldByCurrentThread());
675		lock.writeLock().unlock();
676		}
677
#	Line 700 | Line 679 | public class ReentrantReadWriteLockTest
679		* read timed tryLock times out if write-locked
680		*/
681		public void testReadTryLock_Timeout() throws InterruptedException {
682	<	final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
683	<	lock.writeLock().lock();
684	<	Thread t = new Thread(new CheckedRunnable() {
682	>	final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
683	>	lock.writeLock().lock();
684	>	Thread t = new Thread(new CheckedRunnable() {
685		public void realRun() throws InterruptedException {
686	<	threadAssertFalse(lock.readLock().tryLock(1, TimeUnit.MILLISECONDS));
686	>	threadAssertFalse(lock.readLock().tryLock(1, MILLISECONDS));
687		}});
688
689		t.start();
690		t.join();
691	+	assertTrue(lock.writeLock().isHeldByCurrentThread());
692		lock.writeLock().unlock();
693		}
694
#	Line 717 | Line 697 | public class ReentrantReadWriteLockTest
697		* write lockInterruptibly succeeds if lock free else is interruptible
698		*/
699		public void testWriteLockInterruptibly() throws InterruptedException {
700	<	final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
700	>	final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
701		lock.writeLock().lockInterruptibly();
702	<	Thread t = new Thread(new CheckedInterruptedRunnable() {
702	>	Thread t = new Thread(new CheckedInterruptedRunnable() {
703		public void realRun() throws InterruptedException {
704		lock.writeLock().lockInterruptibly();
705		}});
#	Line 736 | Line 716 | public class ReentrantReadWriteLockTest
716		*  read lockInterruptibly succeeds if lock free else is interruptible
717		*/
718		public void testReadLockInterruptibly() throws InterruptedException {
719	<	final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
719	>	final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
720		lock.writeLock().lockInterruptibly();
721	<	Thread t = new Thread(new CheckedInterruptedRunnable() {
721	>	Thread t = new Thread(new CheckedInterruptedRunnable() {
722		public void realRun() throws InterruptedException {
723		lock.readLock().lockInterruptibly();
724		}});
#	Line 754 | Line 734 | public class ReentrantReadWriteLockTest
734		* Calling await without holding lock throws IllegalMonitorStateException
735		*/
736		public void testAwait_IllegalMonitor() throws InterruptedException {
737	<	final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
737	>	final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
738		final Condition c = lock.writeLock().newCondition();
739		try {
740		c.await();
#	Line 766 | Line 746 | public class ReentrantReadWriteLockTest
746		* Calling signal without holding lock throws IllegalMonitorStateException
747		*/
748		public void testSignal_IllegalMonitor() {
749	<	final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
749	>	final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
750		final Condition c = lock.writeLock().newCondition();
751		try {
752		c.signal();
#	Line 778 | Line 758 | public class ReentrantReadWriteLockTest
758		* awaitNanos without a signal times out
759		*/
760		public void testAwaitNanos_Timeout() throws InterruptedException {
761	<	final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
761	>	final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
762		final Condition c = lock.writeLock().newCondition();
763
764		lock.writeLock().lock();
#	Line 791 | Line 771 | public class ReentrantReadWriteLockTest
771		/**
772		*  timed await without a signal times out
773		*/
774	<	public void testAwait_Timeout() {
775	<	final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
774	>	public void testAwait_Timeout() throws InterruptedException {
775	>	final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
776		final Condition c = lock.writeLock().newCondition();
777		lock.writeLock().lock();
778	+	assertFalse(c.await(SHORT_DELAY_MS, MILLISECONDS));
779		lock.writeLock().unlock();
780		}
781
782		/**
783		* awaitUntil without a signal times out
784		*/
785	<	public void testAwaitUntil_Timeout() {
786	<	final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
785	>	public void testAwaitUntil_Timeout() throws InterruptedException {
786	>	final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
787		final Condition c = lock.writeLock().newCondition();
788		lock.writeLock().lock();
789		java.util.Date d = new java.util.Date();
790	+	assertFalse(c.awaitUntil(new java.util.Date(d.getTime() + 10)));
791		lock.writeLock().unlock();
792		}
793
#	Line 813 | Line 795 | public class ReentrantReadWriteLockTest
795		* await returns when signalled
796		*/
797		public void testAwait() throws InterruptedException {
798	<	final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
798	>	final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
799		final Condition c = lock.writeLock().newCondition();
800	<	Thread t = new Thread(new CheckedRunnable() {
800	>	Thread t = new Thread(new CheckedRunnable() {
801		public void realRun() throws InterruptedException {
802		lock.writeLock().lock();
803		c.await();
#	Line 890 | Line 872 | public class ReentrantReadWriteLockTest
872		* await is interruptible
873		*/
874		public void testAwait_Interrupt() throws InterruptedException {
875	<	final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
875	>	final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
876		final Condition c = lock.writeLock().newCondition();
877	<	Thread t = new Thread(new CheckedInterruptedRunnable() {
877	>	Thread t = new Thread(new CheckedInterruptedRunnable() {
878		public void realRun() throws InterruptedException {
879		lock.writeLock().lock();
880		c.await();
#	Line 910 | Line 892 | public class ReentrantReadWriteLockTest
892		* awaitNanos is interruptible
893		*/
894		public void testAwaitNanos_Interrupt() throws InterruptedException {
895	<	final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
895	>	final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
896		final Condition c = lock.writeLock().newCondition();
897	<	Thread t = new Thread(new CheckedInterruptedRunnable() {
897	>	Thread t = new Thread(new CheckedInterruptedRunnable() {
898		public void realRun() throws InterruptedException {
899		lock.writeLock().lock();
900		c.awaitNanos(SHORT_DELAY_MS * 2 * 1000000);
#	Line 930 | Line 912 | public class ReentrantReadWriteLockTest
912		* awaitUntil is interruptible
913		*/
914		public void testAwaitUntil_Interrupt() throws InterruptedException {
915	<	final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
915	>	final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
916		final Condition c = lock.writeLock().newCondition();
917	<	Thread t = new Thread(new CheckedInterruptedRunnable() {
917	>	Thread t = new Thread(new CheckedInterruptedRunnable() {
918		public void realRun() throws InterruptedException {
919		lock.writeLock().lock();
920		java.util.Date d = new java.util.Date();
#	Line 951 | Line 933 | public class ReentrantReadWriteLockTest
933		* signalAll wakes up all threads
934		*/
935		public void testSignalAll() throws InterruptedException {
936	<	final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
936	>	final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
937		final Condition c = lock.writeLock().newCondition();
938	<	Thread t1 = new Thread(new CheckedRunnable() {
938	>	Thread t1 = new Thread(new CheckedRunnable() {
939		public void realRun() throws InterruptedException {
940		lock.writeLock().lock();
941		c.await();
942		lock.writeLock().unlock();
943		}});
944
945	<	Thread t2 = new Thread(new CheckedRunnable() {
945	>	Thread t2 = new Thread(new CheckedRunnable() {
946		public void realRun() throws InterruptedException {
947		lock.writeLock().lock();
948		c.await();
#	Line 1003 | Line 985 | public class ReentrantReadWriteLockTest
985		* hasQueuedThreads reports whether there are waiting threads
986		*/
987		public void testhasQueuedThreads() throws InterruptedException {
988	<	final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
988	>	final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
989		Thread t1 = new Thread(new InterruptedLockRunnable(lock));
990		Thread t2 = new Thread(new InterruptibleLockRunnable(lock));
991		assertFalse(lock.hasQueuedThreads());
#	Line 1028 | Line 1010 | public class ReentrantReadWriteLockTest
1010		* hasQueuedThread(null) throws NPE
1011		*/
1012		public void testHasQueuedThreadNPE() {
1013	<	final ReentrantReadWriteLock sync = new ReentrantReadWriteLock();
1013	>	final ReentrantReadWriteLock sync = new ReentrantReadWriteLock();
1014		try {
1015		sync.hasQueuedThread(null);
1016		shouldThrow();
#	Line 1039 | Line 1021 | public class ReentrantReadWriteLockTest
1021		* hasQueuedThread reports whether a thread is queued.
1022		*/
1023		public void testHasQueuedThread() throws InterruptedException {
1024	<	final ReentrantReadWriteLock sync = new ReentrantReadWriteLock();
1024	>	final ReentrantReadWriteLock sync = new ReentrantReadWriteLock();
1025		Thread t1 = new Thread(new InterruptedLockRunnable(sync));
1026		Thread t2 = new Thread(new InterruptibleLockRunnable(sync));
1027		assertFalse(sync.hasQueuedThread(t1));
#	Line 1070 | Line 1052 | public class ReentrantReadWriteLockTest
1052		* getQueueLength reports number of waiting threads
1053		*/
1054		public void testGetQueueLength() throws InterruptedException {
1055	<	final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
1055	>	final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
1056		Thread t1 = new Thread(new InterruptedLockRunnable(lock));
1057		Thread t2 = new Thread(new InterruptibleLockRunnable(lock));
1058		assertEquals(0, lock.getQueueLength());
#	Line 1095 | Line 1077 | public class ReentrantReadWriteLockTest
1077		* getQueuedThreads includes waiting threads
1078		*/
1079		public void testGetQueuedThreads() throws InterruptedException {
1080	<	final PublicReentrantReadWriteLock lock = new PublicReentrantReadWriteLock();
1080	>	final PublicReentrantReadWriteLock lock = new PublicReentrantReadWriteLock();
1081		Thread t1 = new Thread(new InterruptedLockRunnable(lock));
1082		Thread t2 = new Thread(new InterruptibleLockRunnable(lock));
1083		assertTrue(lock.getQueuedThreads().isEmpty());
#	Line 1123 | Line 1105 | public class ReentrantReadWriteLockTest
1105		* hasWaiters throws NPE if null
1106		*/
1107		public void testHasWaitersNPE() {
1108	<	final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
1108	>	final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
1109		try {
1110		lock.hasWaiters(null);
1111		shouldThrow();
#	Line 1134 | Line 1116 | public class ReentrantReadWriteLockTest
1116		* getWaitQueueLength throws NPE if null
1117		*/
1118		public void testGetWaitQueueLengthNPE() {
1119	<	final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
1119	>	final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
1120		try {
1121		lock.getWaitQueueLength(null);
1122		shouldThrow();
#	Line 1146 | Line 1128 | public class ReentrantReadWriteLockTest
1128		* getWaitingThreads throws NPE if null
1129		*/
1130		public void testGetWaitingThreadsNPE() {
1131	<	final PublicReentrantReadWriteLock lock = new PublicReentrantReadWriteLock();
1131	>	final PublicReentrantReadWriteLock lock = new PublicReentrantReadWriteLock();
1132		try {
1133		lock.getWaitingThreads(null);
1134		shouldThrow();
#	Line 1157 | Line 1139 | public class ReentrantReadWriteLockTest
1139		* hasWaiters throws IAE if not owned
1140		*/
1141		public void testHasWaitersIAE() {
1142	<	final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
1142	>	final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
1143		final Condition c = lock.writeLock().newCondition();
1144	<	final ReentrantReadWriteLock lock2 = new ReentrantReadWriteLock();
1144	>	final ReentrantReadWriteLock lock2 = new ReentrantReadWriteLock();
1145		try {
1146		lock2.hasWaiters(c);
1147		shouldThrow();
#	Line 1170 | Line 1152 | public class ReentrantReadWriteLockTest
1152		* hasWaiters throws IMSE if not locked
1153		*/
1154		public void testHasWaitersIMSE() {
1155	<	final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
1155	>	final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
1156		final Condition c = lock.writeLock().newCondition();
1157		try {
1158		lock.hasWaiters(c);
#	Line 1183 | Line 1165 | public class ReentrantReadWriteLockTest
1165		* getWaitQueueLength throws IAE if not owned
1166		*/
1167		public void testGetWaitQueueLengthIAE() {
1168	<	final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
1168	>	final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
1169		final Condition c = lock.writeLock().newCondition();
1170	<	final ReentrantReadWriteLock lock2 = new ReentrantReadWriteLock();
1170	>	final ReentrantReadWriteLock lock2 = new ReentrantReadWriteLock();
1171		try {
1172		lock2.getWaitQueueLength(c);
1173		shouldThrow();
#	Line 1196 | Line 1178 | public class ReentrantReadWriteLockTest
1178		* getWaitQueueLength throws IMSE if not locked
1179		*/
1180		public void testGetWaitQueueLengthIMSE() {
1181	<	final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
1181	>	final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
1182		final Condition c = lock.writeLock().newCondition();
1183		try {
1184		lock.getWaitQueueLength(c);
#	Line 1209 | Line 1191 | public class ReentrantReadWriteLockTest
1191		* getWaitingThreads throws IAE if not owned
1192		*/
1193		public void testGetWaitingThreadsIAE() {
1194	<	final PublicReentrantReadWriteLock lock = new PublicReentrantReadWriteLock();
1194	>	final PublicReentrantReadWriteLock lock = new PublicReentrantReadWriteLock();
1195		final Condition c = lock.writeLock().newCondition();
1196	<	final PublicReentrantReadWriteLock lock2 = new PublicReentrantReadWriteLock();
1196	>	final PublicReentrantReadWriteLock lock2 = new PublicReentrantReadWriteLock();
1197		try {
1198		lock2.getWaitingThreads(c);
1199		shouldThrow();
#	Line 1222 | Line 1204 | public class ReentrantReadWriteLockTest
1204		* getWaitingThreads throws IMSE if not locked
1205		*/
1206		public void testGetWaitingThreadsIMSE() {
1207	<	final PublicReentrantReadWriteLock lock = new PublicReentrantReadWriteLock();
1207	>	final PublicReentrantReadWriteLock lock = new PublicReentrantReadWriteLock();
1208		final Condition c = lock.writeLock().newCondition();
1209		try {
1210		lock.getWaitingThreads(c);
#	Line 1235 | Line 1217 | public class ReentrantReadWriteLockTest
1217		* hasWaiters returns true when a thread is waiting, else false
1218		*/
1219		public void testHasWaiters() throws InterruptedException {
1220	<	final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
1220	>	final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
1221		final Condition c = lock.writeLock().newCondition();
1222	<	Thread t = new Thread(new CheckedRunnable() {
1222	>	Thread t = new Thread(new CheckedRunnable() {
1223		public void realRun() throws InterruptedException {
1224		lock.writeLock().lock();
1225		threadAssertFalse(lock.hasWaiters(c));
#	Line 1266 | Line 1248 | public class ReentrantReadWriteLockTest
1248		* getWaitQueueLength returns number of waiting threads
1249		*/
1250		public void testGetWaitQueueLength() throws InterruptedException {
1251	<	final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
1251	>	final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
1252		final Condition c = lock.writeLock().newCondition();
1253	<	Thread t = new Thread(new CheckedRunnable() {
1253	>	Thread t = new Thread(new CheckedRunnable() {
1254		public void realRun() throws InterruptedException {
1255		lock.writeLock().lock();
1256		threadAssertFalse(lock.hasWaiters(c));
#	Line 1298 | Line 1280 | public class ReentrantReadWriteLockTest
1280		* getWaitingThreads returns only and all waiting threads
1281		*/
1282		public void testGetWaitingThreads() throws InterruptedException {
1283	<	final PublicReentrantReadWriteLock lock = new PublicReentrantReadWriteLock();
1283	>	final PublicReentrantReadWriteLock lock = new PublicReentrantReadWriteLock();
1284		final Condition c = lock.writeLock().newCondition();
1285	<	Thread t1 = new Thread(new CheckedRunnable() {
1285	>	Thread t1 = new Thread(new CheckedRunnable() {
1286		public void realRun() throws InterruptedException {
1287		lock.writeLock().lock();
1288		threadAssertTrue(lock.getWaitingThreads(c).isEmpty());
#	Line 1308 | Line 1290 | public class ReentrantReadWriteLockTest
1290		lock.writeLock().unlock();
1291		}});
1292
1293	<	Thread t2 = new Thread(new CheckedRunnable() {
1293	>	Thread t2 = new Thread(new CheckedRunnable() {
1294		public void realRun() throws InterruptedException {
1295		lock.writeLock().lock();
1296		threadAssertFalse(lock.getWaitingThreads(c).isEmpty());

Diff Legend

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