ViewVC Help

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

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

Comparing jsr166/src/test/tck/ReentrantLockTest.java (file contents):
Revision 1.40 by dl, Fri May 6 11:22:07 2011 UTC vs.
Revision 1.44 by jsr166, Sat May 7 03:40:45 2011 UTC

#	Line 59 | Line 59 | public class ReentrantLockTest extends J
59		}
60
61		/**
62	+	* Checks that condition c has no waiters.
63	+	*/
64	+	void assertHasNoWaiters(PublicReentrantLock lock, Condition c) {
65	+	assertHasWaiters(lock, c, new Thread[] {});
66	+	}
67	+
68	+	/**
69	+	* Checks that condition c has exactly the given waiter threads.
70	+	*/
71	+	void assertHasWaiters(PublicReentrantLock lock, Condition c,
72	+	Thread... threads) {
73	+	lock.lock();
74	+	assertEquals(threads.length > 0, lock.hasWaiters(c));
75	+	assertEquals(threads.length, lock.getWaitQueueLength(c));
76	+	assertEquals(threads.length == 0, lock.getWaitingThreads(c).isEmpty());
77	+	assertEquals(threads.length, lock.getWaitingThreads(c).size());
78	+	assertEquals(new HashSet<Thread>(lock.getWaitingThreads(c)),
79	+	new HashSet<Thread>(Arrays.asList(threads)));
80	+	lock.unlock();
81	+	}
82	+
83	+	/**
84		* Constructor sets given fairness
85		*/
86		public void testConstructor() {
#	Line 131 | Line 153 | public class ReentrantLockTest extends J
153		lock.unlock();
154		delay(SHORT_DELAY_MS);
155		assertFalse(lock.hasQueuedThreads());
156	<	t1.join();
157	<	t2.join();
156	>	awaitTermination(t1);
157	>	awaitTermination(t2);
158		}
159
160		/**
#	Line 156 | Line 178 | public class ReentrantLockTest extends J
178		lock.unlock();
179		delay(SHORT_DELAY_MS);
180		assertEquals(0, lock.getQueueLength());
181	<	t1.join();
182	<	t2.join();
181	>	awaitTermination(t1);
182	>	awaitTermination(t2);
183		}
184
185		/**
#	Line 181 | Line 203 | public class ReentrantLockTest extends J
203		lock.unlock();
204		delay(SHORT_DELAY_MS);
205		assertEquals(0, lock.getQueueLength());
206	<	t1.join();
207	<	t2.join();
206	>	awaitTermination(t1);
207	>	awaitTermination(t2);
208		}
209
210		/**
#	Line 222 | Line 244 | public class ReentrantLockTest extends J
244		assertFalse(sync.hasQueuedThread(t1));
245		delay(SHORT_DELAY_MS);
246		assertFalse(sync.hasQueuedThread(t2));
247	<	t1.join();
248	<	t2.join();
247	>	awaitTermination(t1);
248	>	awaitTermination(t2);
249		}
250
251
#	Line 251 | Line 273 | public class ReentrantLockTest extends J
273		lock.unlock();
274		delay(SHORT_DELAY_MS);
275		assertTrue(lock.getQueuedThreads().isEmpty());
276	<	t1.join();
277	<	t2.join();
276	>	awaitTermination(t1);
277	>	awaitTermination(t2);
278		}
279
280
#	Line 262 | Line 284 | public class ReentrantLockTest extends J
284		public void testInterruptedException2() throws InterruptedException {
285		final ReentrantLock lock = new ReentrantLock();
286		lock.lock();
287	<	Thread t = new Thread(new CheckedInterruptedRunnable() {
287	>	Thread t = newStartedThread(new CheckedInterruptedRunnable() {
288		public void realRun() throws InterruptedException {
289		lock.tryLock(MEDIUM_DELAY_MS,MILLISECONDS);
290		}});
291
270	–	t.start();
292		delay(SHORT_DELAY_MS);
293		t.interrupt();
294	<	t.join();
294	>	awaitTermination(t);
295		}
296
297
#	Line 280 | Line 301 | public class ReentrantLockTest extends J
301		public void testTryLockWhenLocked() throws InterruptedException {
302		final ReentrantLock lock = new ReentrantLock();
303		lock.lock();
304	<	Thread t = new Thread(new CheckedRunnable() {
304	>	Thread t = newStartedThread(new CheckedRunnable() {
305		public void realRun() {
306		assertFalse(lock.tryLock());
307		}});
308
309	<	t.start();
289	<	t.join();
309	>	awaitTermination(t);
310		lock.unlock();
311		}
312
#	Line 296 | Line 316 | public class ReentrantLockTest extends J
316		public void testTryLock_Timeout() throws InterruptedException {
317		final ReentrantLock lock = new ReentrantLock();
318		lock.lock();
319	<	Thread t = new Thread(new CheckedRunnable() {
319	>	Thread t = newStartedThread(new CheckedRunnable() {
320		public void realRun() throws InterruptedException {
321		assertFalse(lock.tryLock(1, MILLISECONDS));
322		}});
323
324	<	t.start();
305	<	t.join();
324	>	awaitTermination(t);
325		lock.unlock();
326		}
327
#	Line 331 | Line 350 | public class ReentrantLockTest extends J
350		assertTrue(lock.isLocked());
351		lock.unlock();
352		assertFalse(lock.isLocked());
353	<	Thread t = new Thread(new CheckedRunnable() {
353	>	Thread t = newStartedThread(new CheckedRunnable() {
354		public void realRun() throws InterruptedException {
355		lock.lock();
356		delay(SMALL_DELAY_MS);
357		lock.unlock();
358		}});
359
341	–	t.start();
360		delay(SHORT_DELAY_MS);
361		assertTrue(lock.isLocked());
362	<	t.join();
362	>	awaitTermination(t);
363		assertFalse(lock.isLocked());
364		}
365
#	Line 352 | Line 370 | public class ReentrantLockTest extends J
370		public void testLockInterruptibly1() throws InterruptedException {
371		final ReentrantLock lock = new ReentrantLock();
372		lock.lock();
373	<	Thread t = new Thread(new InterruptedLockRunnable(lock));
356	<	t.start();
373	>	Thread t = newStartedThread(new InterruptedLockRunnable(lock));
374		delay(SHORT_DELAY_MS);
375		t.interrupt();
376		delay(SHORT_DELAY_MS);
377		lock.unlock();
378	<	t.join();
378	>	awaitTermination(t);
379		}
380
381		/**
#	Line 367 | Line 384 | public class ReentrantLockTest extends J
384		public void testLockInterruptibly2() throws InterruptedException {
385		final ReentrantLock lock = new ReentrantLock();
386		lock.lockInterruptibly();
387	<	Thread t = new Thread(new InterruptedLockRunnable(lock));
371	<	t.start();
387	>	Thread t = newStartedThread(new InterruptedLockRunnable(lock));
388		delay(SHORT_DELAY_MS);
389		t.interrupt();
390		assertTrue(lock.isLocked());
391		assertTrue(lock.isHeldByCurrentThread());
392	<	t.join();
392	>	awaitTermination(t);
393		}
394
395		/**
#	Line 441 | Line 457 | public class ReentrantLockTest extends J
457		public void testAwait() throws InterruptedException {
458		final ReentrantLock lock = new ReentrantLock();
459		final Condition c = lock.newCondition();
460	<	Thread t = new Thread(new CheckedRunnable() {
460	>	Thread t = newStartedThread(new CheckedRunnable() {
461		public void realRun() throws InterruptedException {
462		lock.lock();
463		c.await();
464		lock.unlock();
465		}});
466
451	–	t.start();
467		delay(SHORT_DELAY_MS);
468		lock.lock();
469		c.signal();
470		lock.unlock();
471	<	t.join(SHORT_DELAY_MS);
457	<	assertFalse(t.isAlive());
471	>	awaitTermination(t);
472		}
473
474		/**
#	Line 576 | Line 590 | public class ReentrantLockTest extends J
590		public void testHasWaiters() throws InterruptedException {
591		final ReentrantLock lock = new ReentrantLock();
592		final Condition c = lock.newCondition();
593	<	Thread t = new Thread(new CheckedRunnable() {
593	>	Thread t = newStartedThread(new CheckedRunnable() {
594		public void realRun() throws InterruptedException {
595		lock.lock();
596		assertFalse(lock.hasWaiters(c));
#	Line 585 | Line 599 | public class ReentrantLockTest extends J
599		lock.unlock();
600		}});
601
588	–	t.start();
602		delay(SHORT_DELAY_MS);
603		lock.lock();
604		assertTrue(lock.hasWaiters(c));
#	Line 597 | Line 610 | public class ReentrantLockTest extends J
610		assertFalse(lock.hasWaiters(c));
611		assertEquals(0, lock.getWaitQueueLength(c));
612		lock.unlock();
613	<	t.join(SHORT_DELAY_MS);
601	<	assertFalse(t.isAlive());
613	>	awaitTermination(t);
614		}
615
616		/**
#	Line 607 | Line 619 | public class ReentrantLockTest extends J
619		public void testGetWaitQueueLength() throws InterruptedException {
620		final ReentrantLock lock = new ReentrantLock();
621		final Condition c = lock.newCondition();
622	<	Thread t1 = new Thread(new CheckedRunnable() {
622	>	Thread t1 = newStartedThread(new CheckedRunnable() {
623		public void realRun() throws InterruptedException {
624		lock.lock();
625		assertFalse(lock.hasWaiters(c));
#	Line 616 | Line 628 | public class ReentrantLockTest extends J
628		lock.unlock();
629		}});
630
631	<	Thread t2 = new Thread(new CheckedRunnable() {
631	>	delay(SHORT_DELAY_MS);
632	>
633	>	Thread t2 = newStartedThread(new CheckedRunnable() {
634		public void realRun() throws InterruptedException {
635		lock.lock();
636		assertTrue(lock.hasWaiters(c));
#	Line 625 | Line 639 | public class ReentrantLockTest extends J
639		lock.unlock();
640		}});
641
628	–	t1.start();
629	–	delay(SHORT_DELAY_MS);
630	–	t2.start();
642		delay(SHORT_DELAY_MS);
643		lock.lock();
644		assertTrue(lock.hasWaiters(c));
#	Line 639 | Line 650 | public class ReentrantLockTest extends J
650		assertFalse(lock.hasWaiters(c));
651		assertEquals(0, lock.getWaitQueueLength(c));
652		lock.unlock();
653	<	t1.join(SHORT_DELAY_MS);
654	<	t2.join(SHORT_DELAY_MS);
644	<	assertFalse(t1.isAlive());
645	<	assertFalse(t2.isAlive());
653	>	awaitTermination(t1);
654	>	awaitTermination(t2);
655		}
656
657		/**
#	Line 685 | Line 694 | public class ReentrantLockTest extends J
694		assertFalse(lock.hasWaiters(c));
695		assertTrue(lock.getWaitingThreads(c).isEmpty());
696		lock.unlock();
697	<	t1.join(SHORT_DELAY_MS);
698	<	t2.join(SHORT_DELAY_MS);
690	<	assertFalse(t1.isAlive());
691	<	assertFalse(t2.isAlive());
697	>	awaitTermination(t1);
698	>	awaitTermination(t2);
699		}
700
701		/** A helper class for uninterruptible wait tests */
#	Line 750 | Line 757 | public class ReentrantLockTest extends J
757		* await is interruptible
758		*/
759		public void testAwait_Interrupt() throws InterruptedException {
760	<	final ReentrantLock lock = new ReentrantLock();
760	>	final PublicReentrantLock lock = new PublicReentrantLock();
761		final Condition c = lock.newCondition();
762	<	Thread t = new Thread(new CheckedInterruptedRunnable() {
762	>	final CountDownLatch locked = new CountDownLatch(1);
763	>	Thread t = newStartedThread(new CheckedInterruptedRunnable() {
764		public void realRun() throws InterruptedException {
765		lock.lock();
766	<	c.await();
766	>	assertTrue(lock.isLocked());
767	>	assertTrue(lock.isHeldByCurrentThread());
768	>	assertHasNoWaiters(lock, c);
769	>	locked.countDown();
770	>	try {
771	>	c.await();
772	>	} finally {
773	>	assertTrue(lock.isLocked());
774	>	assertTrue(lock.isHeldByCurrentThread());
775	>	assertHasNoWaiters(lock, c);
776	>	lock.unlock();
777	>	assertFalse(Thread.interrupted());
778	>	}
779		}});
780
781	<	t.start();
782	<	delay(SHORT_DELAY_MS);
781	>	locked.await();
782	>	assertHasWaiters(lock, c, t);
783		t.interrupt();
784	<	t.join(SHORT_DELAY_MS);
785	<	assertFalse(t.isAlive());
784	>	awaitTermination(t);
785	>	assertFalse(lock.isLocked());
786		}
787
788		/**
789		* awaitNanos is interruptible
790		*/
791		public void testAwaitNanos_Interrupt() throws InterruptedException {
792	<	final ReentrantLock lock = new ReentrantLock();
792	>	final PublicReentrantLock lock = new PublicReentrantLock();
793		final Condition c = lock.newCondition();
794	<	Thread t = new Thread(new CheckedInterruptedRunnable() {
794	>	final CountDownLatch locked = new CountDownLatch(1);
795	>	Thread t = newStartedThread(new CheckedInterruptedRunnable() {
796		public void realRun() throws InterruptedException {
797		lock.lock();
798	<	c.awaitNanos(MILLISECONDS.toNanos(LONG_DELAY_MS));
798	>	assertTrue(lock.isLocked());
799	>	assertTrue(lock.isHeldByCurrentThread());
800	>	assertHasNoWaiters(lock, c);
801	>	locked.countDown();
802	>	try {
803	>	c.awaitNanos(MILLISECONDS.toNanos(LONG_DELAY_MS));
804	>	} finally {
805	>	assertTrue(lock.isLocked());
806	>	assertTrue(lock.isHeldByCurrentThread());
807	>	assertHasNoWaiters(lock, c);
808	>	lock.unlock();
809	>	assertFalse(Thread.interrupted());
810	>	}
811		}});
812
813	<	t.start();
814	<	delay(SHORT_DELAY_MS);
813	>	locked.await();
814	>	assertHasWaiters(lock, c, t);
815		t.interrupt();
816	<	t.join(SHORT_DELAY_MS);
817	<	assertFalse(t.isAlive());
816	>	awaitTermination(t);
817	>	assertFalse(lock.isLocked());
818		}
819
820		/**
821		* awaitUntil is interruptible
822		*/
823		public void testAwaitUntil_Interrupt() throws InterruptedException {
824	<	final ReentrantLock lock = new ReentrantLock();
824	>	final PublicReentrantLock lock = new PublicReentrantLock();
825		final Condition c = lock.newCondition();
826	<	Thread t = new Thread(new CheckedInterruptedRunnable() {
826	>	final CountDownLatch locked = new CountDownLatch(1);
827	>	Thread t = newStartedThread(new CheckedInterruptedRunnable() {
828		public void realRun() throws InterruptedException {
829		lock.lock();
830	+	assertTrue(lock.isLocked());
831	+	assertTrue(lock.isHeldByCurrentThread());
832	+	assertHasNoWaiters(lock, c);
833	+	locked.countDown();
834		java.util.Date d = new java.util.Date();
835	<	c.awaitUntil(new java.util.Date(d.getTime() + 10000));
835	>	try {
836	>	c.awaitUntil(new java.util.Date(d.getTime() + 10000));
837	>	} finally {
838	>	assertTrue(lock.isLocked());
839	>	assertTrue(lock.isHeldByCurrentThread());
840	>	assertHasNoWaiters(lock, c);
841	>	lock.unlock();
842	>	assertFalse(Thread.interrupted());
843	>	}
844		}});
845
846	<	t.start();
847	<	delay(SHORT_DELAY_MS);
846	>	locked.await();
847	>	assertHasWaiters(lock, c, t);
848		t.interrupt();
849	<	t.join(SHORT_DELAY_MS);
850	<	assertFalse(t.isAlive());
849	>	awaitTermination(t);
850	>	assertFalse(lock.isLocked());
851		}
852
853		/**
#	Line 810 | Line 856 | public class ReentrantLockTest extends J
856		public void testSignalAll() throws InterruptedException {
857		final ReentrantLock lock = new ReentrantLock();
858		final Condition c = lock.newCondition();
859	<	Thread t1 = new Thread(new CheckedRunnable() {
859	>	Thread t1 = newStartedThread(new CheckedRunnable() {
860		public void realRun() throws InterruptedException {
861		lock.lock();
862		c.await();
863		lock.unlock();
864		}});
865
866	<	Thread t2 = new Thread(new CheckedRunnable() {
866	>	Thread t2 = newStartedThread(new CheckedRunnable() {
867		public void realRun() throws InterruptedException {
868		lock.lock();
869		c.await();
870		lock.unlock();
871		}});
872
827	–	t1.start();
828	–	t2.start();
873		delay(SHORT_DELAY_MS);
874		lock.lock();
875		c.signalAll();
876		lock.unlock();
877	<	t1.join(SHORT_DELAY_MS);
878	<	t2.join(SHORT_DELAY_MS);
835	<	assertFalse(t1.isAlive());
836	<	assertFalse(t2.isAlive());
877	>	awaitTermination(t1);
878	>	awaitTermination(t2);
879		}
880
881		/**
#	Line 842 | Line 884 | public class ReentrantLockTest extends J
884		public void testAwaitLockCount() throws InterruptedException {
885		final ReentrantLock lock = new ReentrantLock();
886		final Condition c = lock.newCondition();
887	<	Thread t1 = new Thread(new CheckedRunnable() {
887	>	Thread t1 = newStartedThread(new CheckedRunnable() {
888		public void realRun() throws InterruptedException {
889		lock.lock();
890		assertEquals(1, lock.getHoldCount());
#	Line 851 | Line 893 | public class ReentrantLockTest extends J
893		lock.unlock();
894		}});
895
896	<	Thread t2 = new Thread(new CheckedRunnable() {
896	>	Thread t2 = newStartedThread(new CheckedRunnable() {
897		public void realRun() throws InterruptedException {
898		lock.lock();
899		lock.lock();
#	Line 862 | Line 904 | public class ReentrantLockTest extends J
904		lock.unlock();
905		}});
906
865	–	t1.start();
866	–	t2.start();
907		delay(SHORT_DELAY_MS);
908		lock.lock();
909		c.signalAll();
910		lock.unlock();
911	<	t1.join(SHORT_DELAY_MS);
912	<	t2.join(SHORT_DELAY_MS);
873	<	assertFalse(t1.isAlive());
874	<	assertFalse(t2.isAlive());
911	>	awaitTermination(t1);
912	>	awaitTermination(t2);
913		}
914
915		/**

Diff Legend

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