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.45 by jsr166, Sun May 1 23:49:41 2011 UTC vs.
Revision 1.53 by jsr166, Mon May 2 00:49:26 2011 UTC

#	Line 59 | Line 59 | public class ReentrantReadWriteLockTest
59		}
60
61		/**
62	+	* Releases 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());
68	+	}
69	+
70	+	/**
71		* Constructor sets given fairness, and is in unlocked state
72		*/
73		public void testConstructor() {
#	Line 194 | Line 203 | public class ReentrantReadWriteLockTest
203		Thread t = newStartedThread(new CheckedInterruptedRunnable() {
204		public void realRun() throws InterruptedException {
205		lock.writeLock().lockInterruptibly();
197	–	lock.writeLock().unlock();
198	–	lock.writeLock().lockInterruptibly();
199	–	lock.writeLock().unlock();
206		}});
207
208		Thread.sleep(SHORT_DELAY_MS);
209		t.interrupt();
210	<	Thread.sleep(SHORT_DELAY_MS);
211	<	lock.writeLock().unlock();
206	<	t.join();
210	>	awaitTermination(t, LONG_DELAY_MS);
211	>	releaseLock(lock.writeLock());
212		}
213
214		/**
#	Line 219 | Line 224 | public class ReentrantReadWriteLockTest
224
225		Thread.sleep(SHORT_DELAY_MS);
226		t.interrupt();
227	<	lock.writeLock().unlock();
228	<	t.join();
227	>	awaitTermination(t, LONG_DELAY_MS);
228	>	releaseLock(lock.writeLock());
229		}
230
231		/**
#	Line 236 | Line 241 | public class ReentrantReadWriteLockTest
241
242		Thread.sleep(SHORT_DELAY_MS);
243		t.interrupt();
244	<	Thread.sleep(SHORT_DELAY_MS);
245	<	lock.writeLock().unlock();
241	<	t.join();
244	>	awaitTermination(t, LONG_DELAY_MS);
245	>	releaseLock(lock.writeLock());
246		}
247
248		/**
#	Line 254 | Line 258 | public class ReentrantReadWriteLockTest
258
259		Thread.sleep(SHORT_DELAY_MS);
260		t.interrupt();
261	<	t.join();
261	>	awaitTermination(t, LONG_DELAY_MS);
262	>	releaseLock(lock.writeLock());
263		}
264
265
#	Line 269 | Line 274 | public class ReentrantReadWriteLockTest
274		assertFalse(lock.writeLock().tryLock());
275		}});
276
277	<	t.join();
277	>	awaitTermination(t, LONG_DELAY_MS);
278		lock.writeLock().unlock();
279		}
280
#	Line 284 | Line 289 | public class ReentrantReadWriteLockTest
289		assertFalse(lock.readLock().tryLock());
290		}});
291
292	<	t.join();
292	>	awaitTermination(t, LONG_DELAY_MS);
293		lock.writeLock().unlock();
294		}
295
#	Line 300 | Line 305 | public class ReentrantReadWriteLockTest
305		lock.readLock().unlock();
306		}});
307
308	<	t.join();
308	>	awaitTermination(t, LONG_DELAY_MS);
309		lock.readLock().unlock();
310		}
311
#	Line 323 | Line 328 | public class ReentrantReadWriteLockTest
328
329		Thread.sleep(SHORT_DELAY_MS);
330		lock.readLock().unlock();
331	<	t1.join(MEDIUM_DELAY_MS);
332	<	t2.join(MEDIUM_DELAY_MS);
328	<	assertTrue(!t1.isAlive());
329	<	assertTrue(!t2.isAlive());
331	>	awaitTermination(t1, LONG_DELAY_MS);
332	>	awaitTermination(t2, LONG_DELAY_MS);
333		}
334
335		/**
#	Line 348 | Line 351 | public class ReentrantReadWriteLockTest
351
352		Thread.sleep(SHORT_DELAY_MS);
353		lock.writeLock().unlock();
354	<	t1.join(MEDIUM_DELAY_MS);
355	<	t2.join(MEDIUM_DELAY_MS);
353	<	assertTrue(!t1.isAlive());
354	<	assertTrue(!t2.isAlive());
354	>	awaitTermination(t1, LONG_DELAY_MS);
355	>	awaitTermination(t2, LONG_DELAY_MS);
356		}
357
358		/**
#	Line 389 | Line 390 | public class ReentrantReadWriteLockTest
390		lock.readLock().lock();
391		lock.readLock().unlock();
392		lock.writeLock().unlock();
393	<	t1.join(MEDIUM_DELAY_MS);
394	<	t2.join(MEDIUM_DELAY_MS);
394	<	assertTrue(!t1.isAlive());
395	<	assertTrue(!t2.isAlive());
393	>	awaitTermination(t1, LONG_DELAY_MS);
394	>	awaitTermination(t2, LONG_DELAY_MS);
395		}
396
397		/**
#	Line 419 | Line 418 | public class ReentrantReadWriteLockTest
418		lock.readLock().lock();
419		lock.readLock().unlock();
420		lock.writeLock().unlock();
421	<	t1.join(MEDIUM_DELAY_MS);
422	<	t2.join(MEDIUM_DELAY_MS);
424	<	assertTrue(!t1.isAlive());
425	<	assertTrue(!t2.isAlive());
421	>	awaitTermination(t1, LONG_DELAY_MS);
422	>	awaitTermination(t2, LONG_DELAY_MS);
423		}
424
425
#	Line 450 | Line 447 | public class ReentrantReadWriteLockTest
447		lock.writeLock().lock();
448		lock.writeLock().unlock();
449		lock.writeLock().unlock();
450	<	t1.join(MEDIUM_DELAY_MS);
451	<	t2.join(MEDIUM_DELAY_MS);
455	<	assertTrue(!t1.isAlive());
456	<	assertTrue(!t2.isAlive());
450	>	awaitTermination(t1, LONG_DELAY_MS);
451	>	awaitTermination(t2, LONG_DELAY_MS);
452		}
453
454
#	Line 492 | Line 487 | public class ReentrantReadWriteLockTest
487		lock.readLock().lock();
488		lock.readLock().unlock();
489		lock.writeLock().unlock();
490	<	t1.join(MEDIUM_DELAY_MS);
491	<	t2.join(MEDIUM_DELAY_MS);
497	<	assertTrue(!t1.isAlive());
498	<	assertTrue(!t2.isAlive());
490	>	awaitTermination(t1, LONG_DELAY_MS);
491	>	awaitTermination(t2, LONG_DELAY_MS);
492		}
493
494
#	Line 523 | Line 516 | public class ReentrantReadWriteLockTest
516		lock.readLock().lock();
517		lock.readLock().unlock();
518		lock.writeLock().unlock();
519	<	t1.join(MEDIUM_DELAY_MS);
520	<	t2.join(MEDIUM_DELAY_MS);
528	<	assertTrue(!t1.isAlive());
529	<	assertTrue(!t2.isAlive());
519	>	awaitTermination(t1, LONG_DELAY_MS);
520	>	awaitTermination(t2, LONG_DELAY_MS);
521		}
522
523
#	Line 557 | Line 548 | public class ReentrantReadWriteLockTest
548		lock.writeLock().lock();
549		lock.writeLock().unlock();
550		lock.writeLock().unlock();
551	<	t1.join(MEDIUM_DELAY_MS);
552	<	t2.join(MEDIUM_DELAY_MS);
562	<	assertTrue(!t1.isAlive());
563	<	assertTrue(!t2.isAlive());
551	>	awaitTermination(t1, LONG_DELAY_MS);
552	>	awaitTermination(t2, LONG_DELAY_MS);
553		}
554
555
#	Line 576 | Line 565 | public class ReentrantReadWriteLockTest
565		lock.readLock().unlock();
566		}});
567
568	<	t.join();
568	>	awaitTermination(t, LONG_DELAY_MS);
569		lock.readLock().unlock();
570		}
571
#	Line 591 | Line 580 | public class ReentrantReadWriteLockTest
580		assertFalse(lock.writeLock().tryLock());
581		}});
582
583	<	t.join();
583	>	awaitTermination(t, LONG_DELAY_MS);
584		lock.readLock().unlock();
585		}
586
#	Line 608 | Line 597 | public class ReentrantReadWriteLockTest
597		lock.readLock().unlock();
598		}});
599
600	<	t.join();
600	>	awaitTermination(t, LONG_DELAY_MS);
601		lock.readLock().unlock();
602		}
603
#	Line 625 | Line 614 | public class ReentrantReadWriteLockTest
614		assertFalse(lock.writeLock().tryLock());
615		}});
616
617	<	t.join();
617	>	awaitTermination(t, LONG_DELAY_MS);
618		lock.readLock().unlock();
619		}
620
#	Line 642 | Line 631 | public class ReentrantReadWriteLockTest
631		assertFalse(lock.writeLock().tryLock(1, MILLISECONDS));
632		}});
633
634	<	t.join();
634	>	awaitTermination(t, LONG_DELAY_MS);
635		assertTrue(lock.writeLock().isHeldByCurrentThread());
636		lock.writeLock().unlock();
637		}
#	Line 658 | Line 647 | public class ReentrantReadWriteLockTest
647		assertFalse(lock.readLock().tryLock(1, MILLISECONDS));
648		}});
649
650	<	t.join();
650	>	awaitTermination(t, LONG_DELAY_MS);
651		assertTrue(lock.writeLock().isHeldByCurrentThread());
652		lock.writeLock().unlock();
653		}
#	Line 677 | Line 666 | public class ReentrantReadWriteLockTest
666
667		Thread.sleep(SHORT_DELAY_MS);
668		t.interrupt();
669	<	Thread.sleep(SHORT_DELAY_MS);
670	<	t.join();
682	<	lock.writeLock().unlock();
669	>	awaitTermination(t, LONG_DELAY_MS);
670	>	releaseLock(lock.writeLock());
671		}
672
673		/**
#	Line 695 | Line 683 | public class ReentrantReadWriteLockTest
683
684		Thread.sleep(SHORT_DELAY_MS);
685		t.interrupt();
686	<	t.join();
687	<	lock.writeLock().unlock();
686	>	awaitTermination(t, LONG_DELAY_MS);
687	>	releaseLock(lock.writeLock());
688		}
689
690		/**
#	Line 777 | Line 765 | public class ReentrantReadWriteLockTest
765		lock.writeLock().lock();
766		c.signal();
767		lock.writeLock().unlock();
768	<	t.join(SHORT_DELAY_MS);
781	<	assertFalse(t.isAlive());
768	>	awaitTermination(t, LONG_DELAY_MS);
769		}
770
771		/** A helper class for uninterruptible wait tests */
#	Line 831 | Line 818 | public class ReentrantReadWriteLockTest
818		lock.writeLock().unlock();
819		}
820
821	<	thread.join();
821	>	awaitTermination(thread, LONG_DELAY_MS);
822		assertTrue(thread.interrupted);
836	–	assertFalse(thread.isAlive());
823		}
824
825		/**
#	Line 842 | Line 828 | public class ReentrantReadWriteLockTest
828		public void testAwait_Interrupt() throws InterruptedException {
829		final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
830		final Condition c = lock.writeLock().newCondition();
831	+	final CountDownLatch locked = new CountDownLatch(1);
832		Thread t = newStartedThread(new CheckedInterruptedRunnable() {
833		public void realRun() throws InterruptedException {
834		lock.writeLock().lock();
835	<	c.await();
836	<	lock.writeLock().unlock();
835	>	assertTrue(lock.isWriteLocked());
836	>	locked.countDown();
837	>	try { c.await(); }
838	>	finally { lock.writeLock().unlock(); }
839		}});
840
841	<	Thread.sleep(SHORT_DELAY_MS);
841	>	locked.await();
842	>	while (lock.isWriteLocked())
843	>	Thread.yield();
844		t.interrupt();
845	<	t.join(SHORT_DELAY_MS);
846	<	assertFalse(t.isAlive());
845	>	awaitTermination(t, LONG_DELAY_MS);
846	>	assertFalse(lock.isWriteLocked());
847		}
848
849		/**
#	Line 861 | Line 852 | public class ReentrantReadWriteLockTest
852		public void testAwaitNanos_Interrupt() throws InterruptedException {
853		final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
854		final Condition c = lock.writeLock().newCondition();
855	+	final CountDownLatch locked = new CountDownLatch(1);
856		Thread t = newStartedThread(new CheckedInterruptedRunnable() {
857		public void realRun() throws InterruptedException {
858		lock.writeLock().lock();
859	<	c.awaitNanos(MILLISECONDS.toNanos(LONG_DELAY_MS));
860	<	lock.writeLock().unlock();
859	>	assertTrue(lock.isWriteLocked());
860	>	locked.countDown();
861	>	try { c.awaitNanos(MILLISECONDS.toNanos(LONG_DELAY_MS)); }
862	>	finally { lock.writeLock().unlock(); }
863		}});
864
865	<	Thread.sleep(SHORT_DELAY_MS);
865	>	locked.await();
866	>	while (lock.isWriteLocked())
867	>	Thread.yield();
868		t.interrupt();
869	<	t.join(SHORT_DELAY_MS);
870	<	assertFalse(t.isAlive());
869	>	awaitTermination(t, LONG_DELAY_MS);
870	>	assertFalse(lock.isWriteLocked());
871		}
872
873		/**
#	Line 880 | Line 876 | public class ReentrantReadWriteLockTest
876		public void testAwaitUntil_Interrupt() throws InterruptedException {
877		final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
878		final Condition c = lock.writeLock().newCondition();
879	+	final CountDownLatch locked = new CountDownLatch(1);
880		Thread t = newStartedThread(new CheckedInterruptedRunnable() {
881		public void realRun() throws InterruptedException {
882		lock.writeLock().lock();
883	+	assertTrue(lock.isWriteLocked());
884	+	locked.countDown();
885		java.util.Date d = new java.util.Date();
886	<	c.awaitUntil(new java.util.Date(d.getTime() + 10000));
887	<	lock.writeLock().unlock();
886	>	try { c.awaitUntil(new java.util.Date(d.getTime() + 10000)); }
887	>	finally { lock.writeLock().unlock(); }
888		}});
889
890	<	Thread.sleep(SHORT_DELAY_MS);
890	>	locked.await();
891	>	while (lock.isWriteLocked())
892	>	Thread.yield();
893		t.interrupt();
894	<	t.join(SHORT_DELAY_MS);
895	<	assertFalse(t.isAlive());
894	>	awaitTermination(t, LONG_DELAY_MS);
895	>	assertFalse(lock.isWriteLocked());
896		}
897
898		/**
#	Line 918 | Line 919 | public class ReentrantReadWriteLockTest
919		lock.writeLock().lock();
920		c.signalAll();
921		lock.writeLock().unlock();
922	<	t1.join(SHORT_DELAY_MS);
923	<	t2.join(SHORT_DELAY_MS);
923	<	assertFalse(t1.isAlive());
924	<	assertFalse(t2.isAlive());
922	>	awaitTermination(t1, LONG_DELAY_MS);
923	>	awaitTermination(t2, LONG_DELAY_MS);
924		}
925
926		/**
#	Line 965 | Line 964 | public class ReentrantReadWriteLockTest
964		lock.writeLock().unlock();
965		Thread.sleep(SHORT_DELAY_MS);
966		assertFalse(lock.hasQueuedThreads());
967	<	t1.join();
968	<	t2.join();
967	>	awaitTermination(t1, LONG_DELAY_MS);
968	>	awaitTermination(t2, LONG_DELAY_MS);
969		}
970
971		/**
#	Line 1006 | Line 1005 | public class ReentrantReadWriteLockTest
1005		assertFalse(sync.hasQueuedThread(t1));
1006		Thread.sleep(SHORT_DELAY_MS);
1007		assertFalse(sync.hasQueuedThread(t2));
1008	<	t1.join();
1009	<	t2.join();
1008	>	awaitTermination(t1, LONG_DELAY_MS);
1009	>	awaitTermination(t2, LONG_DELAY_MS);
1010		}
1011
1012
#	Line 1032 | Line 1031 | public class ReentrantReadWriteLockTest
1031		lock.writeLock().unlock();
1032		Thread.sleep(SHORT_DELAY_MS);
1033		assertEquals(0, lock.getQueueLength());
1034	<	t1.join();
1035	<	t2.join();
1034	>	awaitTermination(t1, LONG_DELAY_MS);
1035	>	awaitTermination(t2, LONG_DELAY_MS);
1036		}
1037
1038		/**
#	Line 1060 | Line 1059 | public class ReentrantReadWriteLockTest
1059		lock.writeLock().unlock();
1060		Thread.sleep(SHORT_DELAY_MS);
1061		assertTrue(lock.getQueuedThreads().isEmpty());
1062	<	t1.join();
1063	<	t2.join();
1062	>	awaitTermination(t1, LONG_DELAY_MS);
1063	>	awaitTermination(t2, LONG_DELAY_MS);
1064		}
1065
1066		/**
#	Line 1202 | Line 1201 | public class ReentrantReadWriteLockTest
1201		assertFalse(lock.hasWaiters(c));
1202		assertEquals(0, lock.getWaitQueueLength(c));
1203		lock.writeLock().unlock();
1204	<	t.join(SHORT_DELAY_MS);
1206	<	assertFalse(t.isAlive());
1204	>	awaitTermination(t, LONG_DELAY_MS);
1205		}
1206
1207		/**
#	Line 1232 | Line 1230 | public class ReentrantReadWriteLockTest
1230		assertFalse(lock.hasWaiters(c));
1231		assertEquals(0, lock.getWaitQueueLength(c));
1232		lock.writeLock().unlock();
1233	<	t.join(SHORT_DELAY_MS);
1236	<	assertFalse(t.isAlive());
1233	>	awaitTermination(t, LONG_DELAY_MS);
1234		}
1235
1236
#	Line 1277 | Line 1274 | public class ReentrantReadWriteLockTest
1274		assertFalse(lock.hasWaiters(c));
1275		assertTrue(lock.getWaitingThreads(c).isEmpty());
1276		lock.writeLock().unlock();
1277	<	t1.join(SHORT_DELAY_MS);
1278	<	t2.join(SHORT_DELAY_MS);
1282	<	assertFalse(t1.isAlive());
1283	<	assertFalse(t2.isAlive());
1277	>	awaitTermination(t1, LONG_DELAY_MS);
1278	>	awaitTermination(t2, LONG_DELAY_MS);
1279		}
1280
1281		/**

Diff Legend

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