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.8 by dl, Fri Sep 26 15:33:13 2003 UTC vs.
Revision 1.19 by dl, Sun Jan 25 13:25:28 2004 UTC

#	Line 1 | Line 1
1		/*
2	<	* Written by members of JCP JSR-166 Expert Group and released to the
3	<	* public domain. Use, modify, and redistribute this code in any way
4	<	* without acknowledgement. Other contributors include Andrew Wright,
5	<	* Jeffrey Hayes, Pat Fischer, Mike Judd.
2	>	* Written by Doug Lea with assistance from members of JCP JSR-166
3	>	* Expert Group and released to the public domain, as explained at
4	>	* http://creativecommons.org/licenses/publicdomain
5	>	* Other contributors include Andrew Wright, Jeffrey Hayes,
6	>	* Pat Fisher, Mike Judd.
7		*/
8
9		import junit.framework.*;
#	Line 56 | Line 57 | public class ReentrantLockTest extends J
57		public Collection<Thread> getQueuedThreads() {
58		return super.getQueuedThreads();
59		}
60	<	public ConditionObject newCondition() {
61	<	return new PublicCondition(this);
60	>	public Collection<Thread> getWaitingThreads(Condition c) {
61	>	return super.getWaitingThreads(c);
62		}
63
63	–	static class PublicCondition extends ReentrantLock.ConditionObject {
64	–	PublicCondition(PublicReentrantLock l) { super(l); }
65	–	public Collection<Thread> getWaitingThreads() {
66	–	return super.getWaitingThreads();
67	–	}
68	–	}
64
65		}
66
67		/**
68	+	* Constructor sets given fairness
69	+	*/
70	+	public void testConstructor() {
71	+	ReentrantLock rl = new ReentrantLock();
72	+	assertFalse(rl.isFair());
73	+	ReentrantLock r2 = new ReentrantLock(true);
74	+	assertTrue(r2.isFair());
75	+	}
76	+
77	+	/**
78		* locking an unlocked lock succeeds
79		*/
80		public void testLock() {
#	Line 102 | Line 107 | public class ReentrantLockTest extends J
107		}
108
109		/**
110	<	* trylock on an unlocked lock succeeds
110	>	* tryLock on an unlocked lock succeeds
111		*/
112		public void testTryLock() {
113		ReentrantLock rl = new ReentrantLock();
#	Line 113 | Line 118 | public class ReentrantLockTest extends J
118
119
120		/**
121	+	* hasQueuedThreads reports whether there are waiting threads
122	+	*/
123	+	public void testhasQueuedThreads() {
124	+	final ReentrantLock lock = new ReentrantLock();
125	+	Thread t1 = new Thread(new InterruptedLockRunnable(lock));
126	+	Thread t2 = new Thread(new InterruptibleLockRunnable(lock));
127	+	try {
128	+	assertFalse(lock.hasQueuedThreads());
129	+	lock.lock();
130	+	t1.start();
131	+	Thread.sleep(SHORT_DELAY_MS);
132	+	assertTrue(lock.hasQueuedThreads());
133	+	t2.start();
134	+	Thread.sleep(SHORT_DELAY_MS);
135	+	assertTrue(lock.hasQueuedThreads());
136	+	t1.interrupt();
137	+	Thread.sleep(SHORT_DELAY_MS);
138	+	assertTrue(lock.hasQueuedThreads());
139	+	lock.unlock();
140	+	Thread.sleep(SHORT_DELAY_MS);
141	+	assertFalse(lock.hasQueuedThreads());
142	+	t1.join();
143	+	t2.join();
144	+	} catch(Exception e){
145	+	unexpectedException();
146	+	}
147	+	}
148	+
149	+	/**
150		* getQueueLength reports number of waiting threads
151		*/
152		public void testGetQueueLength() {
#	Line 142 | Line 176 | public class ReentrantLockTest extends J
176		}
177
178		/**
179	+	* getQueueLength reports number of waiting threads
180	+	*/
181	+	public void testGetQueueLength_fair() {
182	+	final ReentrantLock lock = new ReentrantLock(true);
183	+	Thread t1 = new Thread(new InterruptedLockRunnable(lock));
184	+	Thread t2 = new Thread(new InterruptibleLockRunnable(lock));
185	+	try {
186	+	assertEquals(0, lock.getQueueLength());
187	+	lock.lock();
188	+	t1.start();
189	+	Thread.sleep(SHORT_DELAY_MS);
190	+	assertEquals(1, lock.getQueueLength());
191	+	t2.start();
192	+	Thread.sleep(SHORT_DELAY_MS);
193	+	assertEquals(2, lock.getQueueLength());
194	+	t1.interrupt();
195	+	Thread.sleep(SHORT_DELAY_MS);
196	+	assertEquals(1, lock.getQueueLength());
197	+	lock.unlock();
198	+	Thread.sleep(SHORT_DELAY_MS);
199	+	assertEquals(0, lock.getQueueLength());
200	+	t1.join();
201	+	t2.join();
202	+	} catch(Exception e){
203	+	unexpectedException();
204	+	}
205	+	}
206	+
207	+	/**
208	+	* hasQueuedThread(null) throws NPE
209	+	*/
210	+	public void testHasQueuedThreadNPE() {
211	+	final ReentrantLock sync = new ReentrantLock();
212	+	try {
213	+	sync.hasQueuedThread(null);
214	+	shouldThrow();
215	+	} catch (NullPointerException success) {
216	+	}
217	+	}
218	+
219	+	/**
220	+	* hasQueuedThread reports whether a thread is queued.
221	+	*/
222	+	public void testHasQueuedThread() {
223	+	final ReentrantLock sync = new ReentrantLock();
224	+	Thread t1 = new Thread(new InterruptedLockRunnable(sync));
225	+	Thread t2 = new Thread(new InterruptibleLockRunnable(sync));
226	+	try {
227	+	assertFalse(sync.hasQueuedThread(t1));
228	+	assertFalse(sync.hasQueuedThread(t2));
229	+	sync.lock();
230	+	t1.start();
231	+	Thread.sleep(SHORT_DELAY_MS);
232	+	assertTrue(sync.hasQueuedThread(t1));
233	+	t2.start();
234	+	Thread.sleep(SHORT_DELAY_MS);
235	+	assertTrue(sync.hasQueuedThread(t1));
236	+	assertTrue(sync.hasQueuedThread(t2));
237	+	t1.interrupt();
238	+	Thread.sleep(SHORT_DELAY_MS);
239	+	assertFalse(sync.hasQueuedThread(t1));
240	+	assertTrue(sync.hasQueuedThread(t2));
241	+	sync.unlock();
242	+	Thread.sleep(SHORT_DELAY_MS);
243	+	assertFalse(sync.hasQueuedThread(t1));
244	+	Thread.sleep(SHORT_DELAY_MS);
245	+	assertFalse(sync.hasQueuedThread(t2));
246	+	t1.join();
247	+	t2.join();
248	+	} catch(Exception e){
249	+	unexpectedException();
250	+	}
251	+	}
252	+
253	+
254	+	/**
255		* getQueuedThreads includes waiting threads
256		*/
257		public void testGetQueuedThreads() {
#	Line 175 | Line 285 | public class ReentrantLockTest extends J
285
286
287		/**
288	<	* timed trylock is interruptible.
288	>	* timed tryLock is interruptible.
289		*/
290		public void testInterruptedException2() {
291		final ReentrantLock lock = new ReentrantLock();
#	Line 198 | Line 308 | public class ReentrantLockTest extends J
308
309
310		/**
311	<	* Trylock on a locked lock fails
311	>	* TryLock on a locked lock fails
312		*/
313		public void testTryLockWhenLocked() {
314		final ReentrantLock lock = new ReentrantLock();
#	Line 218 | Line 328 | public class ReentrantLockTest extends J
328		}
329
330		/**
331	<	* Timed trylock on a locked lock times out
331	>	* Timed tryLock on a locked lock times out
332		*/
333		public void testTryLock_Timeout() {
334		final ReentrantLock lock = new ReentrantLock();
#	Line 418 | Line 528 | public class ReentrantLockTest extends J
528		*/
529		public void testAwait() {
530		final ReentrantLock lock = new ReentrantLock();
531	<	final ReentrantLock.ConditionObject c = lock.newCondition();
531	>	final Condition c = lock.newCondition();
532		Thread t = new Thread(new Runnable() {
533		public void run() {
534		try {
#	Line 447 | Line 557 | public class ReentrantLockTest extends J
557		}
558
559		/**
560	+	* hasWaiters throws NPE if null
561	+	*/
562	+	public void testHasWaitersNPE() {
563	+	final ReentrantLock lock = new ReentrantLock();
564	+	try {
565	+	lock.hasWaiters(null);
566	+	shouldThrow();
567	+	} catch (NullPointerException success) {
568	+	} catch (Exception ex) {
569	+	unexpectedException();
570	+	}
571	+	}
572	+
573	+	/**
574	+	* getWaitQueueLength throws NPE if null
575	+	*/
576	+	public void testGetWaitQueueLengthNPE() {
577	+	final ReentrantLock lock = new ReentrantLock();
578	+	try {
579	+	lock.getWaitQueueLength(null);
580	+	shouldThrow();
581	+	} catch (NullPointerException success) {
582	+	} catch (Exception ex) {
583	+	unexpectedException();
584	+	}
585	+	}
586	+
587	+
588	+	/**
589	+	* getWaitingThreads throws NPE if null
590	+	*/
591	+	public void testGetWaitingThreadsNPE() {
592	+	final PublicReentrantLock lock = new PublicReentrantLock();
593	+	try {
594	+	lock.getWaitingThreads(null);
595	+	shouldThrow();
596	+	} catch (NullPointerException success) {
597	+	} catch (Exception ex) {
598	+	unexpectedException();
599	+	}
600	+	}
601	+
602	+
603	+	/**
604	+	* hasWaiters throws IAE if not owned
605	+	*/
606	+	public void testHasWaitersIAE() {
607	+	final ReentrantLock lock = new ReentrantLock();
608	+	final Condition c = (lock.newCondition());
609	+	final ReentrantLock lock2 = new ReentrantLock();
610	+	try {
611	+	lock2.hasWaiters(c);
612	+	shouldThrow();
613	+	} catch (IllegalArgumentException success) {
614	+	} catch (Exception ex) {
615	+	unexpectedException();
616	+	}
617	+	}
618	+
619	+	/**
620	+	* hasWaiters throws IMSE if not locked
621	+	*/
622	+	public void testHasWaitersIMSE() {
623	+	final ReentrantLock lock = new ReentrantLock();
624	+	final Condition c = (lock.newCondition());
625	+	try {
626	+	lock.hasWaiters(c);
627	+	shouldThrow();
628	+	} catch (IllegalMonitorStateException success) {
629	+	} catch (Exception ex) {
630	+	unexpectedException();
631	+	}
632	+	}
633	+
634	+
635	+	/**
636	+	* getWaitQueueLength throws IAE if not owned
637	+	*/
638	+	public void testGetWaitQueueLengthIAE() {
639	+	final ReentrantLock lock = new ReentrantLock();
640	+	final Condition c = (lock.newCondition());
641	+	final ReentrantLock lock2 = new ReentrantLock();
642	+	try {
643	+	lock2.getWaitQueueLength(c);
644	+	shouldThrow();
645	+	} catch (IllegalArgumentException success) {
646	+	} catch (Exception ex) {
647	+	unexpectedException();
648	+	}
649	+	}
650	+
651	+	/**
652	+	* getWaitQueueLength throws IMSE if not locked
653	+	*/
654	+	public void testGetWaitQueueLengthIMSE() {
655	+	final ReentrantLock lock = new ReentrantLock();
656	+	final Condition c = (lock.newCondition());
657	+	try {
658	+	lock.getWaitQueueLength(c);
659	+	shouldThrow();
660	+	} catch (IllegalMonitorStateException success) {
661	+	} catch (Exception ex) {
662	+	unexpectedException();
663	+	}
664	+	}
665	+
666	+
667	+	/**
668	+	* getWaitingThreads throws IAE if not owned
669	+	*/
670	+	public void testGetWaitingThreadsIAE() {
671	+	final PublicReentrantLock lock = new PublicReentrantLock();
672	+	final Condition c = (lock.newCondition());
673	+	final PublicReentrantLock lock2 = new PublicReentrantLock();
674	+	try {
675	+	lock2.getWaitingThreads(c);
676	+	shouldThrow();
677	+	} catch (IllegalArgumentException success) {
678	+	} catch (Exception ex) {
679	+	unexpectedException();
680	+	}
681	+	}
682	+
683	+	/**
684	+	* getWaitingThreads throws IMSE if not locked
685	+	*/
686	+	public void testGetWaitingThreadsIMSE() {
687	+	final PublicReentrantLock lock = new PublicReentrantLock();
688	+	final Condition c = (lock.newCondition());
689	+	try {
690	+	lock.getWaitingThreads(c);
691	+	shouldThrow();
692	+	} catch (IllegalMonitorStateException success) {
693	+	} catch (Exception ex) {
694	+	unexpectedException();
695	+	}
696	+	}
697	+
698	+
699	+
700	+	/**
701		* hasWaiters returns true when a thread is waiting, else false
702		*/
703		public void testHasWaiters() {
704		final ReentrantLock lock = new ReentrantLock();
705	<	final ReentrantLock.ConditionObject c = lock.newCondition();
705	>	final Condition c = lock.newCondition();
706		Thread t = new Thread(new Runnable() {
707		public void run() {
708		try {
709		lock.lock();
710	<	threadAssertFalse(c.hasWaiters());
711	<	threadAssertEquals(0, c.getWaitQueueLength());
710	>	threadAssertFalse(lock.hasWaiters(c));
711	>	threadAssertEquals(0, lock.getWaitQueueLength(c));
712		c.await();
713		lock.unlock();
714		}
#	Line 471 | Line 722 | public class ReentrantLockTest extends J
722		t.start();
723		Thread.sleep(SHORT_DELAY_MS);
724		lock.lock();
725	<	assertTrue(c.hasWaiters());
726	<	assertEquals(1, c.getWaitQueueLength());
725	>	assertTrue(lock.hasWaiters(c));
726	>	assertEquals(1, lock.getWaitQueueLength(c));
727		c.signal();
728		lock.unlock();
729		Thread.sleep(SHORT_DELAY_MS);
730		lock.lock();
731	<	assertFalse(c.hasWaiters());
732	<	assertEquals(0, c.getWaitQueueLength());
731	>	assertFalse(lock.hasWaiters(c));
732	>	assertEquals(0, lock.getWaitQueueLength(c));
733		lock.unlock();
734		t.join(SHORT_DELAY_MS);
735		assertFalse(t.isAlive());
#	Line 493 | Line 744 | public class ReentrantLockTest extends J
744		*/
745		public void testGetWaitQueueLength() {
746		final ReentrantLock lock = new ReentrantLock();
747	<	final ReentrantLock.ConditionObject c = lock.newCondition();
747	>	final Condition c = lock.newCondition();
748		Thread t1 = new Thread(new Runnable() {
749		public void run() {
750		try {
751		lock.lock();
752	<	threadAssertFalse(c.hasWaiters());
753	<	threadAssertEquals(0, c.getWaitQueueLength());
752	>	threadAssertFalse(lock.hasWaiters(c));
753	>	threadAssertEquals(0, lock.getWaitQueueLength(c));
754		c.await();
755		lock.unlock();
756		}
#	Line 513 | Line 764 | public class ReentrantLockTest extends J
764		public void run() {
765		try {
766		lock.lock();
767	<	threadAssertTrue(c.hasWaiters());
768	<	threadAssertEquals(1, c.getWaitQueueLength());
767	>	threadAssertTrue(lock.hasWaiters(c));
768	>	threadAssertEquals(1, lock.getWaitQueueLength(c));
769		c.await();
770		lock.unlock();
771		}
#	Line 530 | Line 781 | public class ReentrantLockTest extends J
781		t2.start();
782		Thread.sleep(SHORT_DELAY_MS);
783		lock.lock();
784	<	assertTrue(c.hasWaiters());
785	<	assertEquals(2, c.getWaitQueueLength());
784	>	assertTrue(lock.hasWaiters(c));
785	>	assertEquals(2, lock.getWaitQueueLength(c));
786		c.signalAll();
787		lock.unlock();
788		Thread.sleep(SHORT_DELAY_MS);
789		lock.lock();
790	<	assertFalse(c.hasWaiters());
791	<	assertEquals(0, c.getWaitQueueLength());
790	>	assertFalse(lock.hasWaiters(c));
791	>	assertEquals(0, lock.getWaitQueueLength(c));
792		lock.unlock();
793		t1.join(SHORT_DELAY_MS);
794		t2.join(SHORT_DELAY_MS);
#	Line 554 | Line 805 | public class ReentrantLockTest extends J
805		*/
806		public void testGetWaitingThreads() {
807		final PublicReentrantLock lock = new PublicReentrantLock();
808	<	final PublicReentrantLock.PublicCondition c = (PublicReentrantLock.PublicCondition)lock.newCondition();
808	>	final Condition c = lock.newCondition();
809		Thread t1 = new Thread(new Runnable() {
810		public void run() {
811		try {
812		lock.lock();
813	<	threadAssertTrue(c.getWaitingThreads().isEmpty());
813	>	threadAssertTrue(lock.getWaitingThreads(c).isEmpty());
814		c.await();
815		lock.unlock();
816		}
#	Line 573 | Line 824 | public class ReentrantLockTest extends J
824		public void run() {
825		try {
826		lock.lock();
827	<	threadAssertFalse(c.getWaitingThreads().isEmpty());
827	>	threadAssertFalse(lock.getWaitingThreads(c).isEmpty());
828		c.await();
829		lock.unlock();
830		}
#	Line 585 | Line 836 | public class ReentrantLockTest extends J
836
837		try {
838		lock.lock();
839	<	assertTrue(c.getWaitingThreads().isEmpty());
839	>	assertTrue(lock.getWaitingThreads(c).isEmpty());
840		lock.unlock();
841		t1.start();
842		Thread.sleep(SHORT_DELAY_MS);
843		t2.start();
844		Thread.sleep(SHORT_DELAY_MS);
845		lock.lock();
846	<	assertTrue(c.hasWaiters());
847	<	assertTrue(c.getWaitingThreads().contains(t1));
848	<	assertTrue(c.getWaitingThreads().contains(t2));
846	>	assertTrue(lock.hasWaiters(c));
847	>	assertTrue(lock.getWaitingThreads(c).contains(t1));
848	>	assertTrue(lock.getWaitingThreads(c).contains(t2));
849		c.signalAll();
850		lock.unlock();
851		Thread.sleep(SHORT_DELAY_MS);
852		lock.lock();
853	<	assertFalse(c.hasWaiters());
854	<	assertTrue(c.getWaitingThreads().isEmpty());
853	>	assertFalse(lock.hasWaiters(c));
854	>	assertTrue(lock.getWaitingThreads(c).isEmpty());
855		lock.unlock();
856		t1.join(SHORT_DELAY_MS);
857		t2.join(SHORT_DELAY_MS);
#	Line 612 | Line 863 | public class ReentrantLockTest extends J
863		}
864		}
865
866	+
867	+
868		/**
869		* awaitUninterruptibly doesn't abort on interrupt
870		*/
#	Line 683 | Line 936 | public class ReentrantLockTest extends J
936		public void run() {
937		try {
938		lock.lock();
939	<	c.awaitNanos(SHORT_DELAY_MS * 2 * 1000000);
939	>	c.awaitNanos(1000 * 1000 * 1000); // 1 sec
940		lock.unlock();
941		threadShouldThrow();
942		}
#	Line 810 | Line 1063 | public class ReentrantLockTest extends J
1063		}
1064		}
1065
1066	+	/**
1067	+	* toString indicates current lock state
1068	+	*/
1069	+	public void testToString() {
1070	+	ReentrantLock lock = new ReentrantLock();
1071	+	String us = lock.toString();
1072	+	assertTrue(us.indexOf("Unlocked") >= 0);
1073	+	lock.lock();
1074	+	String ls = lock.toString();
1075	+	assertTrue(ls.indexOf("Locked") >= 0);
1076	+	}
1077	+
1078		}

Diff Legend

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