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.43 by jsr166, Sat May 7 03:36:23 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		/**
#	Line 771 | Line 791 | public class ReentrantLockTest extends J
791		public void testAwaitNanos_Interrupt() throws InterruptedException {
792		final ReentrantLock lock = new ReentrantLock();
793		final Condition c = lock.newCondition();
794	<	Thread t = new Thread(new CheckedInterruptedRunnable() {
794	>	Thread t = newStartedThread(new CheckedInterruptedRunnable() {
795		public void realRun() throws InterruptedException {
796		lock.lock();
797		c.awaitNanos(MILLISECONDS.toNanos(LONG_DELAY_MS));
798		}});
799
780	–	t.start();
800		delay(SHORT_DELAY_MS);
801		t.interrupt();
802	<	t.join(SHORT_DELAY_MS);
784	<	assertFalse(t.isAlive());
802	>	awaitTermination(t);
803		}
804
805		/**
#	Line 790 | Line 808 | public class ReentrantLockTest extends J
808		public void testAwaitUntil_Interrupt() throws InterruptedException {
809		final ReentrantLock lock = new ReentrantLock();
810		final Condition c = lock.newCondition();
811	<	Thread t = new Thread(new CheckedInterruptedRunnable() {
811	>	Thread t = newStartedThread(new CheckedInterruptedRunnable() {
812		public void realRun() throws InterruptedException {
813		lock.lock();
814		java.util.Date d = new java.util.Date();
815		c.awaitUntil(new java.util.Date(d.getTime() + 10000));
816		}});
817
800	–	t.start();
818		delay(SHORT_DELAY_MS);
819		t.interrupt();
820	<	t.join(SHORT_DELAY_MS);
804	<	assertFalse(t.isAlive());
820	>	awaitTermination(t);
821		}
822
823		/**
#	Line 810 | Line 826 | public class ReentrantLockTest extends J
826		public void testSignalAll() throws InterruptedException {
827		final ReentrantLock lock = new ReentrantLock();
828		final Condition c = lock.newCondition();
829	<	Thread t1 = new Thread(new CheckedRunnable() {
829	>	Thread t1 = newStartedThread(new CheckedRunnable() {
830		public void realRun() throws InterruptedException {
831		lock.lock();
832		c.await();
833		lock.unlock();
834		}});
835
836	<	Thread t2 = new Thread(new CheckedRunnable() {
836	>	Thread t2 = newStartedThread(new CheckedRunnable() {
837		public void realRun() throws InterruptedException {
838		lock.lock();
839		c.await();
840		lock.unlock();
841		}});
842
827	–	t1.start();
828	–	t2.start();
843		delay(SHORT_DELAY_MS);
844		lock.lock();
845		c.signalAll();
846		lock.unlock();
847	<	t1.join(SHORT_DELAY_MS);
848	<	t2.join(SHORT_DELAY_MS);
835	<	assertFalse(t1.isAlive());
836	<	assertFalse(t2.isAlive());
847	>	awaitTermination(t1);
848	>	awaitTermination(t2);
849		}
850
851		/**
#	Line 842 | Line 854 | public class ReentrantLockTest extends J
854		public void testAwaitLockCount() throws InterruptedException {
855		final ReentrantLock lock = new ReentrantLock();
856		final Condition c = lock.newCondition();
857	<	Thread t1 = new Thread(new CheckedRunnable() {
857	>	Thread t1 = newStartedThread(new CheckedRunnable() {
858		public void realRun() throws InterruptedException {
859		lock.lock();
860		assertEquals(1, lock.getHoldCount());
#	Line 851 | Line 863 | public class ReentrantLockTest extends J
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		lock.lock();
#	Line 862 | Line 874 | public class ReentrantLockTest extends J
874		lock.unlock();
875		}});
876
865	–	t1.start();
866	–	t2.start();
877		delay(SHORT_DELAY_MS);
878		lock.lock();
879		c.signalAll();
880		lock.unlock();
881	<	t1.join(SHORT_DELAY_MS);
882	<	t2.join(SHORT_DELAY_MS);
873	<	assertFalse(t1.isAlive());
874	<	assertFalse(t2.isAlive());
881	>	awaitTermination(t1);
882	>	awaitTermination(t2);
883		}
884
885		/**

Diff Legend

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