ViewVC Help

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

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

Comparing jsr166/src/test/tck/AbstractQueuedLongSynchronizerTest.java (file contents):
Revision 1.12 by jsr166, Sat Nov 21 02:33:20 2009 UTC vs.
Revision 1.23 by dl, Fri May 6 11:22:07 2011 UTC

#	Line 1 | Line 1
1		/*
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
4	>	* http://creativecommons.org/publicdomain/zero/1.0/
5		* Other contributors include Andrew Wright, Jeffrey Hayes,
6		* Pat Fisher, Mike Judd.
7		*/
#	Line 16 | Line 16 | import java.io.*;
16
17		public class AbstractQueuedLongSynchronizerTest extends JSR166TestCase {
18		public static void main(String[] args) {
19	<	junit.textui.TestRunner.run (suite());
19	>	junit.textui.TestRunner.run(suite());
20		}
21		public static Test suite() {
22		return new TestSuite(AbstractQueuedLongSynchronizerTest.class);
#	Line 47 | Line 47 | public class AbstractQueuedLongSynchroni
47		return true;
48		}
49
50	<	public AbstractQueuedLongSynchronizer.ConditionObject newCondition() { return new AbstractQueuedLongSynchronizer.ConditionObject(); }
50	>	public AbstractQueuedLongSynchronizer.ConditionObject newCondition() {
51	>	return new AbstractQueuedLongSynchronizer.ConditionObject();
52	>	}
53
54		}
55
#	Line 59 | Line 61 | public class AbstractQueuedLongSynchroni
61		public boolean isSignalled() { return getState() != 0; }
62
63		public long tryAcquireShared(long ignore) {
64	<	return isSignalled()? 1 : -1;
64	>	return isSignalled() ? 1 : -1;
65		}
66
67		public boolean tryReleaseShared(long ignore) {
#	Line 132 | Line 134 | public class AbstractQueuedLongSynchroni
134		assertFalse(sync.hasQueuedThreads());
135		sync.acquire(1);
136		t1.start();
137	<	Thread.sleep(SHORT_DELAY_MS);
137	>	delay(SHORT_DELAY_MS);
138		assertTrue(sync.hasQueuedThreads());
139		t2.start();
140	<	Thread.sleep(SHORT_DELAY_MS);
140	>	delay(SHORT_DELAY_MS);
141		assertTrue(sync.hasQueuedThreads());
142		t1.interrupt();
143	<	Thread.sleep(SHORT_DELAY_MS);
143	>	delay(SHORT_DELAY_MS);
144		assertTrue(sync.hasQueuedThreads());
145		sync.release(1);
146	<	Thread.sleep(SHORT_DELAY_MS);
146	>	delay(SHORT_DELAY_MS);
147		assertFalse(sync.hasQueuedThreads());
148		t1.join();
149		t2.join();
#	Line 169 | Line 171 | public class AbstractQueuedLongSynchroni
171		assertFalse(sync.isQueued(t2));
172		sync.acquire(1);
173		t1.start();
174	<	Thread.sleep(SHORT_DELAY_MS);
174	>	delay(SHORT_DELAY_MS);
175		assertTrue(sync.isQueued(t1));
176		t2.start();
177	<	Thread.sleep(SHORT_DELAY_MS);
177	>	delay(SHORT_DELAY_MS);
178		assertTrue(sync.isQueued(t1));
179		assertTrue(sync.isQueued(t2));
180		t1.interrupt();
181	<	Thread.sleep(SHORT_DELAY_MS);
181	>	delay(SHORT_DELAY_MS);
182		assertFalse(sync.isQueued(t1));
183		assertTrue(sync.isQueued(t2));
184		sync.release(1);
185	<	Thread.sleep(SHORT_DELAY_MS);
185	>	delay(SHORT_DELAY_MS);
186		assertFalse(sync.isQueued(t1));
187	<	Thread.sleep(SHORT_DELAY_MS);
187	>	delay(SHORT_DELAY_MS);
188		assertFalse(sync.isQueued(t2));
189		t1.join();
190		t2.join();
#	Line 198 | Line 200 | public class AbstractQueuedLongSynchroni
200		assertNull(sync.getFirstQueuedThread());
201		sync.acquire(1);
202		t1.start();
203	<	Thread.sleep(SHORT_DELAY_MS);
203	>	delay(SHORT_DELAY_MS);
204		assertEquals(t1, sync.getFirstQueuedThread());
205		t2.start();
206	<	Thread.sleep(SHORT_DELAY_MS);
206	>	delay(SHORT_DELAY_MS);
207		assertEquals(t1, sync.getFirstQueuedThread());
208		t1.interrupt();
209	<	Thread.sleep(SHORT_DELAY_MS);
210	<	Thread.sleep(SHORT_DELAY_MS);
209	>	delay(SHORT_DELAY_MS);
210	>	delay(SHORT_DELAY_MS);
211		assertEquals(t2, sync.getFirstQueuedThread());
212		sync.release(1);
213	<	Thread.sleep(SHORT_DELAY_MS);
213	>	delay(SHORT_DELAY_MS);
214		assertNull(sync.getFirstQueuedThread());
215		t1.join();
216		t2.join();
#	Line 225 | Line 227 | public class AbstractQueuedLongSynchroni
227		assertFalse(sync.hasContended());
228		sync.acquire(1);
229		t1.start();
230	<	Thread.sleep(SHORT_DELAY_MS);
230	>	delay(SHORT_DELAY_MS);
231		assertTrue(sync.hasContended());
232		t2.start();
233	<	Thread.sleep(SHORT_DELAY_MS);
233	>	delay(SHORT_DELAY_MS);
234		assertTrue(sync.hasContended());
235		t1.interrupt();
236	<	Thread.sleep(SHORT_DELAY_MS);
236	>	delay(SHORT_DELAY_MS);
237		assertTrue(sync.hasContended());
238		sync.release(1);
239	<	Thread.sleep(SHORT_DELAY_MS);
239	>	delay(SHORT_DELAY_MS);
240		assertTrue(sync.hasContended());
241		t1.join();
242		t2.join();
#	Line 251 | Line 253 | public class AbstractQueuedLongSynchroni
253		sync.acquire(1);
254		assertTrue(sync.getQueuedThreads().isEmpty());
255		t1.start();
256	<	Thread.sleep(SHORT_DELAY_MS);
256	>	delay(SHORT_DELAY_MS);
257		assertTrue(sync.getQueuedThreads().contains(t1));
258		t2.start();
259	<	Thread.sleep(SHORT_DELAY_MS);
259	>	delay(SHORT_DELAY_MS);
260		assertTrue(sync.getQueuedThreads().contains(t1));
261		assertTrue(sync.getQueuedThreads().contains(t2));
262		t1.interrupt();
263	<	Thread.sleep(SHORT_DELAY_MS);
263	>	delay(SHORT_DELAY_MS);
264		assertFalse(sync.getQueuedThreads().contains(t1));
265		assertTrue(sync.getQueuedThreads().contains(t2));
266		sync.release(1);
267	<	Thread.sleep(SHORT_DELAY_MS);
267	>	delay(SHORT_DELAY_MS);
268		assertTrue(sync.getQueuedThreads().isEmpty());
269		t1.join();
270		t2.join();
#	Line 279 | Line 281 | public class AbstractQueuedLongSynchroni
281		sync.acquire(1);
282		assertTrue(sync.getExclusiveQueuedThreads().isEmpty());
283		t1.start();
284	<	Thread.sleep(SHORT_DELAY_MS);
284	>	delay(SHORT_DELAY_MS);
285		assertTrue(sync.getExclusiveQueuedThreads().contains(t1));
286		t2.start();
287	<	Thread.sleep(SHORT_DELAY_MS);
287	>	delay(SHORT_DELAY_MS);
288		assertTrue(sync.getExclusiveQueuedThreads().contains(t1));
289		assertTrue(sync.getExclusiveQueuedThreads().contains(t2));
290		t1.interrupt();
291	<	Thread.sleep(SHORT_DELAY_MS);
291	>	delay(SHORT_DELAY_MS);
292		assertFalse(sync.getExclusiveQueuedThreads().contains(t1));
293		assertTrue(sync.getExclusiveQueuedThreads().contains(t2));
294		sync.release(1);
295	<	Thread.sleep(SHORT_DELAY_MS);
295	>	delay(SHORT_DELAY_MS);
296		assertTrue(sync.getExclusiveQueuedThreads().isEmpty());
297		t1.join();
298		t2.join();
#	Line 307 | Line 309 | public class AbstractQueuedLongSynchroni
309		sync.acquire(1);
310		assertTrue(sync.getSharedQueuedThreads().isEmpty());
311		t1.start();
312	<	Thread.sleep(SHORT_DELAY_MS);
312	>	delay(SHORT_DELAY_MS);
313		assertTrue(sync.getSharedQueuedThreads().isEmpty());
314		t2.start();
315	<	Thread.sleep(SHORT_DELAY_MS);
315	>	delay(SHORT_DELAY_MS);
316		assertTrue(sync.getSharedQueuedThreads().isEmpty());
317		t1.interrupt();
318	<	Thread.sleep(SHORT_DELAY_MS);
318	>	delay(SHORT_DELAY_MS);
319		assertTrue(sync.getSharedQueuedThreads().isEmpty());
320		sync.release(1);
321	<	Thread.sleep(SHORT_DELAY_MS);
321	>	delay(SHORT_DELAY_MS);
322		assertTrue(sync.getSharedQueuedThreads().isEmpty());
323		t1.join();
324		t2.join();
#	Line 330 | Line 332 | public class AbstractQueuedLongSynchroni
332		sync.acquire(1);
333		Thread t = new Thread(new CheckedInterruptedRunnable() {
334		public void realRun() throws InterruptedException {
335	<	sync.tryAcquireNanos(1, MEDIUM_DELAY_MS * 1000 * 1000);
335	>	sync.tryAcquireNanos(1, MILLISECONDS.toNanos(MEDIUM_DELAY_MS));
336		}});
337
338		t.start();
339	+	delay(SHORT_DELAY_MS);
340		t.interrupt();
341		t.join();
342		}
#	Line 347 | Line 350 | public class AbstractQueuedLongSynchroni
350		sync.acquire(1);
351		Thread t = new Thread(new CheckedRunnable() {
352		public void realRun() {
353	<	threadAssertFalse(sync.tryAcquire(1));
353	>	assertFalse(sync.tryAcquire(1));
354		}});
355
356		t.start();
#	Line 363 | Line 366 | public class AbstractQueuedLongSynchroni
366		sync.acquire(1);
367		Thread t = new Thread(new CheckedRunnable() {
368		public void realRun() throws InterruptedException {
369	<	threadAssertFalse(sync.tryAcquireNanos(1, 1000 * 1000));
369	>	long nanos = MILLISECONDS.toNanos(SHORT_DELAY_MS);
370	>	assertFalse(sync.tryAcquireNanos(1, nanos));
371		}});
372
373		t.start();
#	Line 384 | Line 388 | public class AbstractQueuedLongSynchroni
388		Thread t = new Thread(new CheckedRunnable() {
389		public void realRun() throws InterruptedException {
390		sync.acquire(1);
391	<	Thread.sleep(SMALL_DELAY_MS);
391	>	delay(SMALL_DELAY_MS);
392		sync.release(1);
393		}});
394
395		t.start();
396	<	Thread.sleep(SHORT_DELAY_MS);
396	>	delay(SHORT_DELAY_MS);
397		assertTrue(sync.isHeldExclusively());
398		t.join();
399		assertFalse(sync.isHeldExclusively());
#	Line 404 | Line 408 | public class AbstractQueuedLongSynchroni
408		sync.acquire(1);
409		Thread t = new Thread(new InterruptedSyncRunnable(sync));
410		t.start();
411	<	Thread.sleep(SHORT_DELAY_MS);
411	>	delay(SHORT_DELAY_MS);
412		t.interrupt();
413	<	Thread.sleep(SHORT_DELAY_MS);
413	>	delay(SHORT_DELAY_MS);
414		sync.release(1);
415		t.join();
416		}
#	Line 419 | Line 423 | public class AbstractQueuedLongSynchroni
423		sync.acquireInterruptibly(1);
424		Thread t = new Thread(new InterruptedSyncRunnable(sync));
425		t.start();
426	+	delay(SHORT_DELAY_MS);
427		t.interrupt();
428		assertTrue(sync.isHeldExclusively());
429		t.join();
#	Line 472 | Line 477 | public class AbstractQueuedLongSynchroni
477		}
478
479		/**
480	<	*  Timed await without a signal times out
480	>	* Timed await without a signal times out
481		*/
482		public void testAwait_Timeout() throws InterruptedException {
483		final Mutex sync = new Mutex();
#	Line 508 | Line 513 | public class AbstractQueuedLongSynchroni
513		}});
514
515		t.start();
516	<	Thread.sleep(SHORT_DELAY_MS);
516	>	delay(SHORT_DELAY_MS);
517		sync.acquire(1);
518		c.signal();
519		sync.release(1);
#	Line 641 | Line 646 | public class AbstractQueuedLongSynchroni
646		Thread t = new Thread(new CheckedRunnable() {
647		public void realRun() throws InterruptedException {
648		sync.acquire(1);
649	<	threadAssertFalse(sync.hasWaiters(c));
650	<	threadAssertEquals(0, sync.getWaitQueueLength(c));
649	>	assertFalse(sync.hasWaiters(c));
650	>	assertEquals(0, sync.getWaitQueueLength(c));
651		c.await();
652		sync.release(1);
653		}});
654
655		t.start();
656	<	Thread.sleep(SHORT_DELAY_MS);
656	>	delay(SHORT_DELAY_MS);
657		sync.acquire(1);
658		assertTrue(sync.hasWaiters(c));
659		assertEquals(1, sync.getWaitQueueLength(c));
660		c.signal();
661		sync.release(1);
662	<	Thread.sleep(SHORT_DELAY_MS);
662	>	delay(SHORT_DELAY_MS);
663		sync.acquire(1);
664		assertFalse(sync.hasWaiters(c));
665		assertEquals(0, sync.getWaitQueueLength(c));
#	Line 672 | Line 677 | public class AbstractQueuedLongSynchroni
677		Thread t1 = new Thread(new CheckedRunnable() {
678		public void realRun() throws InterruptedException {
679		sync.acquire(1);
680	<	threadAssertFalse(sync.hasWaiters(c));
681	<	threadAssertEquals(0, sync.getWaitQueueLength(c));
680	>	assertFalse(sync.hasWaiters(c));
681	>	assertEquals(0, sync.getWaitQueueLength(c));
682		c.await();
683		sync.release(1);
684		}});
#	Line 681 | Line 686 | public class AbstractQueuedLongSynchroni
686		Thread t2 = new Thread(new CheckedRunnable() {
687		public void realRun() throws InterruptedException {
688		sync.acquire(1);
689	<	threadAssertTrue(sync.hasWaiters(c));
690	<	threadAssertEquals(1, sync.getWaitQueueLength(c));
689	>	assertTrue(sync.hasWaiters(c));
690	>	assertEquals(1, sync.getWaitQueueLength(c));
691		c.await();
692		sync.release(1);
693		}});
694
695		t1.start();
696	<	Thread.sleep(SHORT_DELAY_MS);
696	>	delay(SHORT_DELAY_MS);
697		t2.start();
698	<	Thread.sleep(SHORT_DELAY_MS);
698	>	delay(SHORT_DELAY_MS);
699		sync.acquire(1);
700		assertTrue(sync.hasWaiters(c));
701		assertEquals(2, sync.getWaitQueueLength(c));
702		c.signalAll();
703		sync.release(1);
704	<	Thread.sleep(SHORT_DELAY_MS);
704	>	delay(SHORT_DELAY_MS);
705		sync.acquire(1);
706		assertFalse(sync.hasWaiters(c));
707		assertEquals(0, sync.getWaitQueueLength(c));
#	Line 716 | Line 721 | public class AbstractQueuedLongSynchroni
721		Thread t1 = new Thread(new CheckedRunnable() {
722		public void realRun() throws InterruptedException {
723		sync.acquire(1);
724	<	threadAssertTrue(sync.getWaitingThreads(c).isEmpty());
724	>	assertTrue(sync.getWaitingThreads(c).isEmpty());
725		c.await();
726		sync.release(1);
727		}});
#	Line 724 | Line 729 | public class AbstractQueuedLongSynchroni
729		Thread t2 = new Thread(new CheckedRunnable() {
730		public void realRun() throws InterruptedException {
731		sync.acquire(1);
732	<	threadAssertFalse(sync.getWaitingThreads(c).isEmpty());
732	>	assertFalse(sync.getWaitingThreads(c).isEmpty());
733		c.await();
734		sync.release(1);
735		}});
#	Line 733 | Line 738 | public class AbstractQueuedLongSynchroni
738		assertTrue(sync.getWaitingThreads(c).isEmpty());
739		sync.release(1);
740		t1.start();
741	<	Thread.sleep(SHORT_DELAY_MS);
741	>	delay(SHORT_DELAY_MS);
742		t2.start();
743	<	Thread.sleep(SHORT_DELAY_MS);
743	>	delay(SHORT_DELAY_MS);
744		sync.acquire(1);
745		assertTrue(sync.hasWaiters(c));
746		assertTrue(sync.getWaitingThreads(c).contains(t1));
747		assertTrue(sync.getWaitingThreads(c).contains(t2));
748		c.signalAll();
749		sync.release(1);
750	<	Thread.sleep(SHORT_DELAY_MS);
750	>	delay(SHORT_DELAY_MS);
751		sync.acquire(1);
752		assertFalse(sync.hasWaiters(c));
753		assertTrue(sync.getWaitingThreads(c).isEmpty());
#	Line 769 | Line 774 | public class AbstractQueuedLongSynchroni
774		}});
775
776		t.start();
777	<	Thread.sleep(SHORT_DELAY_MS);
777	>	delay(SHORT_DELAY_MS);
778		t.interrupt();
779		sync.acquire(1);
780		c.signal();
#	Line 788 | Line 793 | public class AbstractQueuedLongSynchroni
793		public void realRun() throws InterruptedException {
794		sync.acquire(1);
795		c.await();
791	–	sync.release(1);
796		}});
797
798		t.start();
799	<	Thread.sleep(SHORT_DELAY_MS);
799	>	delay(SHORT_DELAY_MS);
800		t.interrupt();
801		t.join(SHORT_DELAY_MS);
802		assertFalse(t.isAlive());
#	Line 807 | Line 811 | public class AbstractQueuedLongSynchroni
811		Thread t = new Thread(new CheckedInterruptedRunnable() {
812		public void realRun() throws InterruptedException {
813		sync.acquire(1);
814	<	c.awaitNanos(1000 * 1000 * 1000); // 1 sec
811	<	sync.release(1);
814	>	c.awaitNanos(MILLISECONDS.toNanos(LONG_DELAY_MS));
815		}});
816
817		t.start();
818	<	Thread.sleep(SHORT_DELAY_MS);
818	>	delay(SHORT_DELAY_MS);
819		t.interrupt();
820		t.join(SHORT_DELAY_MS);
821		assertFalse(t.isAlive());
#	Line 829 | Line 832 | public class AbstractQueuedLongSynchroni
832		sync.acquire(1);
833		java.util.Date d = new java.util.Date();
834		c.awaitUntil(new java.util.Date(d.getTime() + 10000));
832	–	sync.release(1);
835		}});
836
837		t.start();
838	<	Thread.sleep(SHORT_DELAY_MS);
838	>	delay(SHORT_DELAY_MS);
839		t.interrupt();
840		t.join(SHORT_DELAY_MS);
841		assertFalse(t.isAlive());
#	Line 861 | Line 863 | public class AbstractQueuedLongSynchroni
863
864		t1.start();
865		t2.start();
866	<	Thread.sleep(SHORT_DELAY_MS);
866	>	delay(SHORT_DELAY_MS);
867		sync.acquire(1);
868		c.signalAll();
869		sync.release(1);
#	Line 934 | Line 936 | public class AbstractQueuedLongSynchroni
936
937		Thread t = new Thread(new CheckedRunnable() {
938		public void realRun() throws InterruptedException {
939	<	threadAssertFalse(l.isSignalled());
939	>	assertFalse(l.isSignalled());
940		l.acquireSharedInterruptibly(0);
941	<	threadAssertTrue(l.isSignalled());
941	>	assertTrue(l.isSignalled());
942		}});
943
944		t.start();
945		assertFalse(l.isSignalled());
946	<	Thread.sleep(SHORT_DELAY_MS);
946	>	delay(SHORT_DELAY_MS);
947		l.releaseShared(0);
948		assertTrue(l.isSignalled());
949		t.join();
#	Line 951 | Line 953 | public class AbstractQueuedLongSynchroni
953		/**
954		* acquireSharedTimed returns after release
955		*/
956	<	public void testAsquireSharedTimed() throws InterruptedException {
956	>	public void testAcquireSharedTimed() throws InterruptedException {
957		final BooleanLatch l = new BooleanLatch();
958
959		Thread t = new Thread(new CheckedRunnable() {
960		public void realRun() throws InterruptedException {
961	<	threadAssertFalse(l.isSignalled());
962	<	threadAssertTrue(l.tryAcquireSharedNanos(0, MEDIUM_DELAY_MS* 1000 * 1000));
963	<	threadAssertTrue(l.isSignalled());
961	>	assertFalse(l.isSignalled());
962	>	long nanos = MILLISECONDS.toNanos(MEDIUM_DELAY_MS);
963	>	assertTrue(l.tryAcquireSharedNanos(0, nanos));
964	>	assertTrue(l.isSignalled());
965		}});
966
967		t.start();
968		assertFalse(l.isSignalled());
969	<	Thread.sleep(SHORT_DELAY_MS);
969	>	delay(SHORT_DELAY_MS);
970		l.releaseShared(0);
971		assertTrue(l.isSignalled());
972		t.join();
#	Line 972 | Line 975 | public class AbstractQueuedLongSynchroni
975		/**
976		* acquireSharedInterruptibly throws IE if interrupted before released
977		*/
978	<	public void testAcquireSharedInterruptibly_InterruptedException() throws InterruptedException {
978	>	public void testAcquireSharedInterruptibly_InterruptedException()
979	>	throws InterruptedException {
980		final BooleanLatch l = new BooleanLatch();
981		Thread t = new Thread(new CheckedInterruptedRunnable() {
982		public void realRun() throws InterruptedException {
983	<	threadAssertFalse(l.isSignalled());
983	>	assertFalse(l.isSignalled());
984		l.acquireSharedInterruptibly(0);
985		}});
986
#	Line 993 | Line 997 | public class AbstractQueuedLongSynchroni
997		final BooleanLatch l = new BooleanLatch();
998		Thread t = new Thread(new CheckedInterruptedRunnable() {
999		public void realRun() throws InterruptedException {
1000	<	threadAssertFalse(l.isSignalled());
1001	<	l.tryAcquireSharedNanos(0, SMALL_DELAY_MS* 1000 * 1000);
1000	>	assertFalse(l.isSignalled());
1001	>	long nanos = MILLISECONDS.toNanos(SMALL_DELAY_MS);
1002	>	l.tryAcquireSharedNanos(0, nanos);
1003		}});
1004
1005		t.start();
1006	<	Thread.sleep(SHORT_DELAY_MS);
1006	>	delay(SHORT_DELAY_MS);
1007		assertFalse(l.isSignalled());
1008		t.interrupt();
1009		t.join();
#	Line 1011 | Line 1016 | public class AbstractQueuedLongSynchroni
1016		final BooleanLatch l = new BooleanLatch();
1017		Thread t = new Thread(new CheckedRunnable() {
1018		public void realRun() throws InterruptedException {
1019	<	threadAssertFalse(l.isSignalled());
1020	<	threadAssertFalse(l.tryAcquireSharedNanos(0, SMALL_DELAY_MS* 1000 * 1000));
1019	>	assertFalse(l.isSignalled());
1020	>	long nanos = MILLISECONDS.toNanos(SMALL_DELAY_MS);
1021	>	assertFalse(l.tryAcquireSharedNanos(0, nanos));
1022		}});
1023
1024		t.start();
1025	<	Thread.sleep(SHORT_DELAY_MS);
1025	>	delay(SHORT_DELAY_MS);
1026		assertFalse(l.isSignalled());
1027		t.join();
1028		}

Diff Legend

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