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.49 by jsr166, Mon May 2 00:07:54 2011 UTC vs.
Revision 1.54 by jsr166, Mon May 2 01:07:15 2011 UTC

#	Line 59 | Line 59 | public class ReentrantReadWriteLockTest
59		}
60
61		/**
62	<	* Releases lock, checking that it had a hold count of 1.
62	>	* Releases write lock, checking that it had a hold count of 1.
63		*/
64	<	void releaseLock(ReentrantReadWriteLock.WriteLock lock) {
65	<	assertTrue(lock.isHeldByCurrentThread());
66	<	lock.unlock();
67	<	assertFalse(lock.isHeldByCurrentThread());
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		/**
#	Line 207 | Line 208 | public class ReentrantReadWriteLockTest
208
209		Thread.sleep(SHORT_DELAY_MS);
210		t.interrupt();
211	<	t.join();
212	<	releaseLock(lock.writeLock());
211	>	awaitTermination(t, LONG_DELAY_MS);
212	>	releaseWriteLock(lock);
213		}
214
215		/**
#	Line 224 | Line 225 | public class ReentrantReadWriteLockTest
225
226		Thread.sleep(SHORT_DELAY_MS);
227		t.interrupt();
228	<	t.join();
229	<	releaseLock(lock.writeLock());
228	>	awaitTermination(t, LONG_DELAY_MS);
229	>	releaseWriteLock(lock);
230		}
231
232		/**
#	Line 241 | Line 242 | public class ReentrantReadWriteLockTest
242
243		Thread.sleep(SHORT_DELAY_MS);
244		t.interrupt();
245	<	t.join();
246	<	releaseLock(lock.writeLock());
245	>	awaitTermination(t, LONG_DELAY_MS);
246	>	releaseWriteLock(lock);
247		}
248
249		/**
#	Line 258 | Line 259 | public class ReentrantReadWriteLockTest
259
260		Thread.sleep(SHORT_DELAY_MS);
261		t.interrupt();
262	<	t.join();
263	<	releaseLock(lock.writeLock());
262	>	awaitTermination(t, LONG_DELAY_MS);
263	>	releaseWriteLock(lock);
264		}
265
266
#	Line 274 | Line 275 | public class ReentrantReadWriteLockTest
275		assertFalse(lock.writeLock().tryLock());
276		}});
277
278	<	t.join();
279	<	lock.writeLock().unlock();
278	>	awaitTermination(t, LONG_DELAY_MS);
279	>	releaseWriteLock(lock);
280		}
281
282		/**
#	Line 289 | Line 290 | public class ReentrantReadWriteLockTest
290		assertFalse(lock.readLock().tryLock());
291		}});
292
293	<	t.join();
294	<	lock.writeLock().unlock();
293	>	awaitTermination(t, LONG_DELAY_MS);
294	>	releaseWriteLock(lock);
295		}
296
297		/**
#	Line 305 | Line 306 | public class ReentrantReadWriteLockTest
306		lock.readLock().unlock();
307		}});
308
309	<	t.join();
309	>	awaitTermination(t, LONG_DELAY_MS);
310		lock.readLock().unlock();
311		}
312
#	Line 328 | Line 329 | public class ReentrantReadWriteLockTest
329
330		Thread.sleep(SHORT_DELAY_MS);
331		lock.readLock().unlock();
332	<	t1.join(MEDIUM_DELAY_MS);
333	<	t2.join(MEDIUM_DELAY_MS);
333	<	assertTrue(!t1.isAlive());
334	<	assertTrue(!t2.isAlive());
332	>	awaitTermination(t1, LONG_DELAY_MS);
333	>	awaitTermination(t2, LONG_DELAY_MS);
334		}
335
336		/**
#	Line 352 | Line 351 | public class ReentrantReadWriteLockTest
351		}});
352
353		Thread.sleep(SHORT_DELAY_MS);
354	<	lock.writeLock().unlock();
355	<	t1.join(MEDIUM_DELAY_MS);
356	<	t2.join(MEDIUM_DELAY_MS);
358	<	assertTrue(!t1.isAlive());
359	<	assertTrue(!t2.isAlive());
354	>	releaseWriteLock(lock);
355	>	awaitTermination(t1, LONG_DELAY_MS);
356	>	awaitTermination(t2, LONG_DELAY_MS);
357		}
358
359		/**
#	Line 394 | Line 391 | public class ReentrantReadWriteLockTest
391		lock.readLock().lock();
392		lock.readLock().unlock();
393		lock.writeLock().unlock();
394	<	t1.join(MEDIUM_DELAY_MS);
395	<	t2.join(MEDIUM_DELAY_MS);
399	<	assertTrue(!t1.isAlive());
400	<	assertTrue(!t2.isAlive());
394	>	awaitTermination(t1, LONG_DELAY_MS);
395	>	awaitTermination(t2, LONG_DELAY_MS);
396		}
397
398		/**
#	Line 424 | Line 419 | public class ReentrantReadWriteLockTest
419		lock.readLock().lock();
420		lock.readLock().unlock();
421		lock.writeLock().unlock();
422	<	t1.join(MEDIUM_DELAY_MS);
423	<	t2.join(MEDIUM_DELAY_MS);
429	<	assertTrue(!t1.isAlive());
430	<	assertTrue(!t2.isAlive());
422	>	awaitTermination(t1, LONG_DELAY_MS);
423	>	awaitTermination(t2, LONG_DELAY_MS);
424		}
425
426
#	Line 455 | Line 448 | public class ReentrantReadWriteLockTest
448		lock.writeLock().lock();
449		lock.writeLock().unlock();
450		lock.writeLock().unlock();
451	<	t1.join(MEDIUM_DELAY_MS);
452	<	t2.join(MEDIUM_DELAY_MS);
460	<	assertTrue(!t1.isAlive());
461	<	assertTrue(!t2.isAlive());
451	>	awaitTermination(t1, LONG_DELAY_MS);
452	>	awaitTermination(t2, LONG_DELAY_MS);
453		}
454
455
#	Line 497 | Line 488 | public class ReentrantReadWriteLockTest
488		lock.readLock().lock();
489		lock.readLock().unlock();
490		lock.writeLock().unlock();
491	<	t1.join(MEDIUM_DELAY_MS);
492	<	t2.join(MEDIUM_DELAY_MS);
502	<	assertTrue(!t1.isAlive());
503	<	assertTrue(!t2.isAlive());
491	>	awaitTermination(t1, LONG_DELAY_MS);
492	>	awaitTermination(t2, LONG_DELAY_MS);
493		}
494
495
#	Line 528 | Line 517 | public class ReentrantReadWriteLockTest
517		lock.readLock().lock();
518		lock.readLock().unlock();
519		lock.writeLock().unlock();
520	<	t1.join(MEDIUM_DELAY_MS);
521	<	t2.join(MEDIUM_DELAY_MS);
533	<	assertTrue(!t1.isAlive());
534	<	assertTrue(!t2.isAlive());
520	>	awaitTermination(t1, LONG_DELAY_MS);
521	>	awaitTermination(t2, LONG_DELAY_MS);
522		}
523
524
#	Line 562 | Line 549 | public class ReentrantReadWriteLockTest
549		lock.writeLock().lock();
550		lock.writeLock().unlock();
551		lock.writeLock().unlock();
552	<	t1.join(MEDIUM_DELAY_MS);
553	<	t2.join(MEDIUM_DELAY_MS);
567	<	assertTrue(!t1.isAlive());
568	<	assertTrue(!t2.isAlive());
552	>	awaitTermination(t1, LONG_DELAY_MS);
553	>	awaitTermination(t2, LONG_DELAY_MS);
554		}
555
556
#	Line 581 | Line 566 | public class ReentrantReadWriteLockTest
566		lock.readLock().unlock();
567		}});
568
569	<	t.join();
569	>	awaitTermination(t, LONG_DELAY_MS);
570		lock.readLock().unlock();
571		}
572
#	Line 596 | Line 581 | public class ReentrantReadWriteLockTest
581		assertFalse(lock.writeLock().tryLock());
582		}});
583
584	<	t.join();
584	>	awaitTermination(t, LONG_DELAY_MS);
585		lock.readLock().unlock();
586		}
587
#	Line 613 | Line 598 | public class ReentrantReadWriteLockTest
598		lock.readLock().unlock();
599		}});
600
601	<	t.join();
601	>	awaitTermination(t, LONG_DELAY_MS);
602		lock.readLock().unlock();
603		}
604
#	Line 630 | Line 615 | public class ReentrantReadWriteLockTest
615		assertFalse(lock.writeLock().tryLock());
616		}});
617
618	<	t.join();
618	>	awaitTermination(t, LONG_DELAY_MS);
619		lock.readLock().unlock();
620		}
621
#	Line 647 | Line 632 | public class ReentrantReadWriteLockTest
632		assertFalse(lock.writeLock().tryLock(1, MILLISECONDS));
633		}});
634
635	<	t.join();
635	>	awaitTermination(t, LONG_DELAY_MS);
636		assertTrue(lock.writeLock().isHeldByCurrentThread());
637		lock.writeLock().unlock();
638		}
#	Line 663 | Line 648 | public class ReentrantReadWriteLockTest
648		assertFalse(lock.readLock().tryLock(1, MILLISECONDS));
649		}});
650
651	<	t.join();
651	>	awaitTermination(t, LONG_DELAY_MS);
652		assertTrue(lock.writeLock().isHeldByCurrentThread());
653		lock.writeLock().unlock();
654		}
#	Line 682 | Line 667 | public class ReentrantReadWriteLockTest
667
668		Thread.sleep(SHORT_DELAY_MS);
669		t.interrupt();
670	<	Thread.sleep(SHORT_DELAY_MS);
671	<	t.join();
687	<	lock.writeLock().unlock();
670	>	awaitTermination(t, LONG_DELAY_MS);
671	>	releaseWriteLock(lock);
672		}
673
674		/**
#	Line 700 | Line 684 | public class ReentrantReadWriteLockTest
684
685		Thread.sleep(SHORT_DELAY_MS);
686		t.interrupt();
687	<	t.join();
688	<	lock.writeLock().unlock();
687	>	awaitTermination(t, LONG_DELAY_MS);
688	>	releaseWriteLock(lock);
689		}
690
691		/**
#	Line 782 | Line 766 | public class ReentrantReadWriteLockTest
766		lock.writeLock().lock();
767		c.signal();
768		lock.writeLock().unlock();
769	<	t.join(SHORT_DELAY_MS);
786	<	assertFalse(t.isAlive());
769	>	awaitTermination(t, LONG_DELAY_MS);
770		}
771
772		/** A helper class for uninterruptible wait tests */
#	Line 836 | Line 819 | public class ReentrantReadWriteLockTest
819		lock.writeLock().unlock();
820		}
821
822	<	thread.join();
822	>	awaitTermination(thread, LONG_DELAY_MS);
823		assertTrue(thread.interrupted);
841	–	assertFalse(thread.isAlive());
824		}
825
826		/**
#	Line 847 | Line 829 | public class ReentrantReadWriteLockTest
829		public void testAwait_Interrupt() throws InterruptedException {
830		final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
831		final Condition c = lock.writeLock().newCondition();
832	+	final CountDownLatch locked = new CountDownLatch(1);
833		Thread t = newStartedThread(new CheckedInterruptedRunnable() {
834		public void realRun() throws InterruptedException {
835		lock.writeLock().lock();
836	<	c.await();
837	<	lock.writeLock().unlock();
836	>	assertTrue(lock.isWriteLocked());
837	>	locked.countDown();
838	>	try { c.await(); }
839	>	finally { lock.writeLock().unlock(); }
840		}});
841
842	<	Thread.sleep(SHORT_DELAY_MS);
842	>	locked.await();
843	>	while (lock.isWriteLocked())
844	>	Thread.yield();
845		t.interrupt();
846	<	t.join(SHORT_DELAY_MS);
847	<	assertFalse(t.isAlive());
846	>	awaitTermination(t, LONG_DELAY_MS);
847	>	assertFalse(lock.isWriteLocked());
848		}
849
850		/**
#	Line 866 | Line 853 | public class ReentrantReadWriteLockTest
853		public void testAwaitNanos_Interrupt() throws InterruptedException {
854		final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
855		final Condition c = lock.writeLock().newCondition();
856	+	final CountDownLatch locked = new CountDownLatch(1);
857		Thread t = newStartedThread(new CheckedInterruptedRunnable() {
858		public void realRun() throws InterruptedException {
859		lock.writeLock().lock();
860	<	c.awaitNanos(MILLISECONDS.toNanos(LONG_DELAY_MS));
861	<	lock.writeLock().unlock();
860	>	assertTrue(lock.isWriteLocked());
861	>	locked.countDown();
862	>	try { c.awaitNanos(MILLISECONDS.toNanos(LONG_DELAY_MS)); }
863	>	finally { lock.writeLock().unlock(); }
864		}});
865
866	<	Thread.sleep(SHORT_DELAY_MS);
866	>	locked.await();
867	>	while (lock.isWriteLocked())
868	>	Thread.yield();
869		t.interrupt();
870	<	t.join(SHORT_DELAY_MS);
871	<	assertFalse(t.isAlive());
870	>	awaitTermination(t, LONG_DELAY_MS);
871	>	assertFalse(lock.isWriteLocked());
872		}
873
874		/**
#	Line 885 | Line 877 | public class ReentrantReadWriteLockTest
877		public void testAwaitUntil_Interrupt() throws InterruptedException {
878		final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
879		final Condition c = lock.writeLock().newCondition();
880	+	final CountDownLatch locked = new CountDownLatch(1);
881		Thread t = newStartedThread(new CheckedInterruptedRunnable() {
882		public void realRun() throws InterruptedException {
883		lock.writeLock().lock();
884	+	assertTrue(lock.isWriteLocked());
885	+	locked.countDown();
886		java.util.Date d = new java.util.Date();
887	<	c.awaitUntil(new java.util.Date(d.getTime() + 10000));
888	<	lock.writeLock().unlock();
887	>	try { c.awaitUntil(new java.util.Date(d.getTime() + 10000)); }
888	>	finally { lock.writeLock().unlock(); }
889		}});
890
891	<	Thread.sleep(SHORT_DELAY_MS);
891	>	locked.await();
892	>	while (lock.isWriteLocked())
893	>	Thread.yield();
894		t.interrupt();
895	<	t.join(SHORT_DELAY_MS);
896	<	assertFalse(t.isAlive());
895	>	awaitTermination(t, LONG_DELAY_MS);
896	>	assertFalse(lock.isWriteLocked());
897		}
898
899		/**
#	Line 923 | Line 920 | public class ReentrantReadWriteLockTest
920		lock.writeLock().lock();
921		c.signalAll();
922		lock.writeLock().unlock();
923	<	t1.join(SHORT_DELAY_MS);
924	<	t2.join(SHORT_DELAY_MS);
928	<	assertFalse(t1.isAlive());
929	<	assertFalse(t2.isAlive());
923	>	awaitTermination(t1, LONG_DELAY_MS);
924	>	awaitTermination(t2, LONG_DELAY_MS);
925		}
926
927		/**
#	Line 970 | Line 965 | public class ReentrantReadWriteLockTest
965		lock.writeLock().unlock();
966		Thread.sleep(SHORT_DELAY_MS);
967		assertFalse(lock.hasQueuedThreads());
968	<	t1.join();
969	<	t2.join();
968	>	awaitTermination(t1, LONG_DELAY_MS);
969	>	awaitTermination(t2, LONG_DELAY_MS);
970		}
971
972		/**
#	Line 1011 | Line 1006 | public class ReentrantReadWriteLockTest
1006		assertFalse(sync.hasQueuedThread(t1));
1007		Thread.sleep(SHORT_DELAY_MS);
1008		assertFalse(sync.hasQueuedThread(t2));
1009	<	t1.join();
1010	<	t2.join();
1009	>	awaitTermination(t1, LONG_DELAY_MS);
1010	>	awaitTermination(t2, LONG_DELAY_MS);
1011		}
1012
1013
#	Line 1037 | Line 1032 | public class ReentrantReadWriteLockTest
1032		lock.writeLock().unlock();
1033		Thread.sleep(SHORT_DELAY_MS);
1034		assertEquals(0, lock.getQueueLength());
1035	<	t1.join();
1036	<	t2.join();
1035	>	awaitTermination(t1, LONG_DELAY_MS);
1036	>	awaitTermination(t2, LONG_DELAY_MS);
1037		}
1038
1039		/**
#	Line 1065 | Line 1060 | public class ReentrantReadWriteLockTest
1060		lock.writeLock().unlock();
1061		Thread.sleep(SHORT_DELAY_MS);
1062		assertTrue(lock.getQueuedThreads().isEmpty());
1063	<	t1.join();
1064	<	t2.join();
1063	>	awaitTermination(t1, LONG_DELAY_MS);
1064	>	awaitTermination(t2, LONG_DELAY_MS);
1065		}
1066
1067		/**
#	Line 1207 | Line 1202 | public class ReentrantReadWriteLockTest
1202		assertFalse(lock.hasWaiters(c));
1203		assertEquals(0, lock.getWaitQueueLength(c));
1204		lock.writeLock().unlock();
1205	<	t.join(SHORT_DELAY_MS);
1211	<	assertFalse(t.isAlive());
1205	>	awaitTermination(t, LONG_DELAY_MS);
1206		}
1207
1208		/**
#	Line 1237 | Line 1231 | public class ReentrantReadWriteLockTest
1231		assertFalse(lock.hasWaiters(c));
1232		assertEquals(0, lock.getWaitQueueLength(c));
1233		lock.writeLock().unlock();
1234	<	t.join(SHORT_DELAY_MS);
1241	<	assertFalse(t.isAlive());
1234	>	awaitTermination(t, LONG_DELAY_MS);
1235		}
1236
1237
#	Line 1282 | Line 1275 | public class ReentrantReadWriteLockTest
1275		assertFalse(lock.hasWaiters(c));
1276		assertTrue(lock.getWaitingThreads(c).isEmpty());
1277		lock.writeLock().unlock();
1278	<	t1.join(SHORT_DELAY_MS);
1279	<	t2.join(SHORT_DELAY_MS);
1287	<	assertFalse(t1.isAlive());
1288	<	assertFalse(t2.isAlive());
1278	>	awaitTermination(t1, LONG_DELAY_MS);
1279	>	awaitTermination(t2, LONG_DELAY_MS);
1280		}
1281
1282		/**

Diff Legend

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