ViewVC Help

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

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

Comparing jsr166/src/test/tck/SemaphoreTest.java (file contents):
Revision 1.4 by dl, Sat Sep 20 18:20:08 2003 UTC vs.
Revision 1.5 by dl, Thu Sep 25 11:02:41 2003 UTC

#	Line 19 | Line 19 | public class SemaphoreTest extends JSR16
19		}
20
21		/**
22	<	*
22	>	* Zero, negative, and positive initial values are allowed in constructor
23		*/
24	<	public void testConstructor1() {
25	<	Semaphore s = new Semaphore(0);
26	<	assertEquals(0, s.availablePermits());
27	<	}
28	<
29	<	/**
30	<	*
31	<	*/
32	<	public void testConstructor2() {
33	<	Semaphore s = new Semaphore(-1);
34	<	assertEquals(-1, s.availablePermits());
24	>	public void testConstructor() {
25	>	Semaphore s0 = new Semaphore(0);
26	>	assertEquals(0, s0.availablePermits());
27	>	Semaphore s1 = new Semaphore(-1);
28	>	assertEquals(-1, s1.availablePermits());
29	>	Semaphore s2 = new Semaphore(-1);
30	>	assertEquals(-1, s2.availablePermits());
31		}
32
33		/**
34	<	*
34	>	* tryAcquire succeeds when sufficent permits, else fails
35		*/
36		public void testTryAcquireInSameThread() {
37		Semaphore s = new Semaphore(2);
#	Line 47 | Line 43 | public class SemaphoreTest extends JSR16
43		}
44
45		/**
46	<	*
46	>	* Acquire and release of semaphore succeed if initially available
47		*/
48		public void testAcquireReleaseInSameThread() {
49		Semaphore s = new Semaphore(1);
#	Line 69 | Line 65 | public class SemaphoreTest extends JSR16
65		}
66
67		/**
68	<	*
68	>	* Uninterruptible acquire and release of semaphore succeed if
69	>	* initially available
70		*/
71		public void testAcquireUninterruptiblyReleaseInSameThread() {
72		Semaphore s = new Semaphore(1);
#	Line 89 | Line 86 | public class SemaphoreTest extends JSR16
86		}
87		}
88
89	+	/**
90	+	* Timed Acquire and release of semaphore succeed if
91	+	* initially available
92	+	*/
93	+	public void testTimedAcquireReleaseInSameThread() {
94	+	Semaphore s = new Semaphore(1);
95	+	try {
96	+	assertTrue(s.tryAcquire(SHORT_DELAY_MS, TimeUnit.MILLISECONDS));
97	+	s.release();
98	+	assertTrue(s.tryAcquire(SHORT_DELAY_MS, TimeUnit.MILLISECONDS));
99	+	s.release();
100	+	assertTrue(s.tryAcquire(SHORT_DELAY_MS, TimeUnit.MILLISECONDS));
101	+	s.release();
102	+	assertTrue(s.tryAcquire(SHORT_DELAY_MS, TimeUnit.MILLISECONDS));
103	+	s.release();
104	+	assertTrue(s.tryAcquire(SHORT_DELAY_MS, TimeUnit.MILLISECONDS));
105	+	s.release();
106	+	assertEquals(1, s.availablePermits());
107	+	} catch( InterruptedException e){
108	+	unexpectedException();
109	+	}
110	+	}
111
112		/**
113	<	*
113	>	* A release in one thread enables an acquire in another thread
114		*/
115		public void testAcquireReleaseInDifferentThreads() {
116	<	final Semaphore s = new Semaphore(1);
116	>	final Semaphore s = new Semaphore(0);
117		Thread t = new Thread(new Runnable() {
118		public void run() {
119		try {
#	Line 107 | Line 126 | public class SemaphoreTest extends JSR16
126		}
127		}
128		});
110	–	t.start();
129		try {
130	+	t.start();
131	+	Thread.sleep(SHORT_DELAY_MS);
132		s.release();
133		s.release();
134		s.acquire();
135		s.acquire();
136	+	s.release();
137		t.join();
138		} catch( InterruptedException e){
139		unexpectedException();
#	Line 120 | Line 141 | public class SemaphoreTest extends JSR16
141		}
142
143		/**
144	<	*
144	>	* A release in one thread enables an uninterruptible acquire in another thread
145		*/
146	<	public void testTimedAcquireReleaseInSameThread() {
147	<	Semaphore s = new Semaphore(1);
146	>	public void testUninterruptibleAcquireReleaseInDifferentThreads() {
147	>	final Semaphore s = new Semaphore(0);
148	>	Thread t = new Thread(new Runnable() {
149	>	public void run() {
150	>	s.acquireUninterruptibly();
151	>	s.release();
152	>	s.release();
153	>	s.acquireUninterruptibly();
154	>	}
155	>	});
156		try {
157	<	assertTrue(s.tryAcquire(SHORT_DELAY_MS, TimeUnit.MILLISECONDS));
158	<	s.release();
130	<	assertTrue(s.tryAcquire(SHORT_DELAY_MS, TimeUnit.MILLISECONDS));
131	<	s.release();
132	<	assertTrue(s.tryAcquire(SHORT_DELAY_MS, TimeUnit.MILLISECONDS));
157	>	t.start();
158	>	Thread.sleep(SHORT_DELAY_MS);
159		s.release();
134	–	assertTrue(s.tryAcquire(SHORT_DELAY_MS, TimeUnit.MILLISECONDS));
160		s.release();
161	<	assertTrue(s.tryAcquire(SHORT_DELAY_MS, TimeUnit.MILLISECONDS));
161	>	s.acquireUninterruptibly();
162	>	s.acquireUninterruptibly();
163		s.release();
164	<	assertEquals(1, s.availablePermits());
164	>	t.join();
165		} catch( InterruptedException e){
166		unexpectedException();
167		}
168		}
169
170	+
171		/**
172	<	*
172	>	*  A release in one thread enables a timed acquire in another thread
173		*/
174		public void testTimedAcquireReleaseInDifferentThreads() {
175		final Semaphore s = new Semaphore(1);
#	Line 159 | Line 186 | public class SemaphoreTest extends JSR16
186		}
187		}
188		});
162	–	t.start();
189		try {
190	+	t.start();
191		assertTrue(s.tryAcquire(SHORT_DELAY_MS, TimeUnit.MILLISECONDS));
192		s.release();
193		assertTrue(s.tryAcquire(SHORT_DELAY_MS, TimeUnit.MILLISECONDS));
194		s.release();
195	+	s.release();
196		t.join();
197		} catch( InterruptedException e){
198		unexpectedException();
#	Line 172 | Line 200 | public class SemaphoreTest extends JSR16
200		}
201
202		/**
203	<	*
203	>	* A waiting acquire blocks interruptibly
204		*/
205		public void testAcquire_InterruptedException() {
206		final Semaphore s = new Semaphore(0);
#	Line 195 | Line 223 | public class SemaphoreTest extends JSR16
223		}
224
225		/**
226	<	*
226	>	*  A waiting timed acquire blocks interruptibly
227		*/
228		public void testTryAcquire_InterruptedException() {
229		final Semaphore s = new Semaphore(0);
#	Line 219 | Line 247 | public class SemaphoreTest extends JSR16
247		}
248
249		/**
250	<	*
250	>	* a deserialized serialized semaphore has same number of permits
251		*/
252		public void testSerialization() {
253		Semaphore l = new Semaphore(3);

Diff Legend

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