ViewVC Help

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

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

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

#	Line 21 | Line 21 | public class FairSemaphoreTest extends J
21		}
22
23		/**
24	<	*
24	>	* Zero, negative, and positive initial values are allowed in constructor
25		*/
26	<	public void testConstructor1() {
27	<	FairSemaphore s = new FairSemaphore(0);
28	<	assertEquals(0, s.availablePermits());
26	>	public void testConstructor() {
27	>	FairSemaphore s0 = new FairSemaphore(0);
28	>	assertEquals(0, s0.availablePermits());
29	>	FairSemaphore s1 = new FairSemaphore(-1);
30	>	assertEquals(-1, s1.availablePermits());
31	>	FairSemaphore s2 = new FairSemaphore(-1);
32	>	assertEquals(-1, s2.availablePermits());
33		}
34
35		/**
36	<	*
33	<	*/
34	<	public void testConstructor2() {
35	<	FairSemaphore s = new FairSemaphore(-1);
36	<	assertEquals(-1, s.availablePermits());
37	<	}
38	<
39	<	/**
40	<	*
36	>	* tryAcquire succeeds when sufficent permits, else fails
37		*/
38		public void testTryAcquireInSameThread() {
39		FairSemaphore s = new FairSemaphore(2);
#	Line 49 | Line 45 | public class FairSemaphoreTest extends J
45		}
46
47		/**
48	<	*
48	>	* tryAcquire(n) succeeds when sufficent permits, else fails
49		*/
50		public void testTryAcquireNInSameThread() {
51		FairSemaphore s = new FairSemaphore(2);
#	Line 60 | Line 56 | public class FairSemaphoreTest extends J
56		}
57
58		/**
59	<	*
59	>	* Acquire and release of semaphore succeed if initially available
60		*/
61		public void testAcquireReleaseInSameThread() {
62		FairSemaphore s = new FairSemaphore(1);
#	Line 82 | Line 78 | public class FairSemaphoreTest extends J
78		}
79
80		/**
81	<	*
81	>	* Acquire(n) and release(n) of semaphore succeed if initially available
82		*/
83		public void testAcquireReleaseNInSameThread() {
84		FairSemaphore s = new FairSemaphore(1);
#	Line 104 | Line 100 | public class FairSemaphoreTest extends J
100		}
101
102		/**
103	<	*
103	>	* Acquire(n) and release(n) of semaphore succeed if initially available
104		*/
105		public void testAcquireUninterruptiblyReleaseNInSameThread() {
106		FairSemaphore s = new FairSemaphore(1);
#	Line 125 | Line 121 | public class FairSemaphoreTest extends J
121		}
122
123		/**
124	<	*
124	>	* release(n) in one thread enables timed acquire(n) in another thread
125	>	*/
126	>	public void testTimedAcquireReleaseNInSameThread() {
127	>	FairSemaphore s = new FairSemaphore(1);
128	>	try {
129	>	s.release(1);
130	>	assertTrue(s.tryAcquire(1, SHORT_DELAY_MS, TimeUnit.MILLISECONDS));
131	>	s.release(2);
132	>	assertTrue(s.tryAcquire(2, SHORT_DELAY_MS, TimeUnit.MILLISECONDS));
133	>	s.release(3);
134	>	assertTrue(s.tryAcquire(3, SHORT_DELAY_MS, TimeUnit.MILLISECONDS));
135	>	s.release(4);
136	>	assertTrue(s.tryAcquire(4, SHORT_DELAY_MS, TimeUnit.MILLISECONDS));
137	>	s.release(5);
138	>	assertTrue(s.tryAcquire(5, SHORT_DELAY_MS, TimeUnit.MILLISECONDS));
139	>	assertEquals(1, s.availablePermits());
140	>	} catch( InterruptedException e){
141	>	unexpectedException();
142	>	}
143	>	}
144	>
145	>	/**
146	>	* release in one thread enables timed acquire in another thread
147	>	*/
148	>	public void testTimedAcquireReleaseInSameThread() {
149	>	FairSemaphore s = new FairSemaphore(1);
150	>	try {
151	>	assertTrue(s.tryAcquire(SHORT_DELAY_MS, TimeUnit.MILLISECONDS));
152	>	s.release();
153	>	assertTrue(s.tryAcquire(SHORT_DELAY_MS, TimeUnit.MILLISECONDS));
154	>	s.release();
155	>	assertTrue(s.tryAcquire(SHORT_DELAY_MS, TimeUnit.MILLISECONDS));
156	>	s.release();
157	>	assertTrue(s.tryAcquire(SHORT_DELAY_MS, TimeUnit.MILLISECONDS));
158	>	s.release();
159	>	assertTrue(s.tryAcquire(SHORT_DELAY_MS, TimeUnit.MILLISECONDS));
160	>	s.release();
161	>	assertEquals(1, s.availablePermits());
162	>	} catch( InterruptedException e){
163	>	unexpectedException();
164	>	}
165	>	}
166	>
167	>	/**
168	>	* A release in one thread enables an acquire in another thread
169		*/
170		public void testAcquireReleaseInDifferentThreads() {
171	<	final FairSemaphore s = new FairSemaphore(1);
171	>	final FairSemaphore s = new FairSemaphore(0);
172		Thread t = new Thread(new Runnable() {
173		public void run() {
174		try {
#	Line 136 | Line 176 | public class FairSemaphoreTest extends J
176		s.acquire();
177		s.acquire();
178		s.acquire();
139	–	s.acquire();
179		} catch(InterruptedException ie){
180		threadUnexpectedException();
181		}
182		}
183		});
145	–	t.start();
184		try {
185	+	t.start();
186	+	Thread.sleep(SHORT_DELAY_MS);
187	+	s.release();
188		s.release();
189		s.release();
190		s.release();
191		s.release();
192		s.release();
193		t.join();
194	<	assertEquals(1, s.availablePermits());
194	>	assertEquals(2, s.availablePermits());
195		} catch( InterruptedException e){
196		unexpectedException();
197		}
198		}
199
200		/**
201	<	*
201	>	* release(n) in one thread enables acquire(n) in another thread
202		*/
203		public void testAcquireReleaseNInDifferentThreads() {
204	<	final FairSemaphore s = new FairSemaphore(2);
204	>	final FairSemaphore s = new FairSemaphore(0);
205		Thread t = new Thread(new Runnable() {
206		public void run() {
207		try {
167	–	s.release(2);
168	–	s.release(2);
208		s.acquire(2);
209		s.acquire(2);
210	+	s.release(4);
211		} catch(InterruptedException ie){
212		threadUnexpectedException();
213		}
214		}
215		});
176	–	t.start();
216		try {
217	+	t.start();
218	+	Thread.sleep(SHORT_DELAY_MS);
219	+	s.release(6);
220		s.acquire(2);
221		s.acquire(2);
222		s.release(2);
181	–	s.release(2);
223		t.join();
224		} catch( InterruptedException e){
225		unexpectedException();
226		}
227		}
228
188	–	/**
189	–	*
190	–	*/
191	–	public void testTimedAcquireReleaseInSameThread() {
192	–	FairSemaphore s = new FairSemaphore(1);
193	–	try {
194	–	assertTrue(s.tryAcquire(SHORT_DELAY_MS, TimeUnit.MILLISECONDS));
195	–	s.release();
196	–	assertTrue(s.tryAcquire(SHORT_DELAY_MS, TimeUnit.MILLISECONDS));
197	–	s.release();
198	–	assertTrue(s.tryAcquire(SHORT_DELAY_MS, TimeUnit.MILLISECONDS));
199	–	s.release();
200	–	assertTrue(s.tryAcquire(SHORT_DELAY_MS, TimeUnit.MILLISECONDS));
201	–	s.release();
202	–	assertTrue(s.tryAcquire(SHORT_DELAY_MS, TimeUnit.MILLISECONDS));
203	–	s.release();
204	–	assertEquals(1, s.availablePermits());
205	–	} catch( InterruptedException e){
206	–	unexpectedException();
207	–	}
208	–	}
229
210	–	/**
211	–	*
212	–	*/
213	–	public void testTimedAcquireReleaseNInSameThread() {
214	–	FairSemaphore s = new FairSemaphore(1);
215	–	try {
216	–	s.release(1);
217	–	assertTrue(s.tryAcquire(1, SHORT_DELAY_MS, TimeUnit.MILLISECONDS));
218	–	s.release(2);
219	–	assertTrue(s.tryAcquire(2, SHORT_DELAY_MS, TimeUnit.MILLISECONDS));
220	–	s.release(3);
221	–	assertTrue(s.tryAcquire(3, SHORT_DELAY_MS, TimeUnit.MILLISECONDS));
222	–	s.release(4);
223	–	assertTrue(s.tryAcquire(4, SHORT_DELAY_MS, TimeUnit.MILLISECONDS));
224	–	s.release(5);
225	–	assertTrue(s.tryAcquire(5, SHORT_DELAY_MS, TimeUnit.MILLISECONDS));
226	–	assertEquals(1, s.availablePermits());
227	–	} catch( InterruptedException e){
228	–	unexpectedException();
229	–	}
230	–	}
230
231		/**
232	<	*
232	>	* release in one thread enables timed acquire in another thread
233		*/
234		public void testTimedAcquireReleaseInDifferentThreads() {
235		final FairSemaphore s = new FairSemaphore(1);
#	Line 262 | Line 261 | public class FairSemaphoreTest extends J
261		}
262
263		/**
264	<	*
264	>	* release(n) in one thread enables timed acquire(n) in another thread
265		*/
266		public void testTimedAcquireReleaseNInDifferentThreads() {
267		final FairSemaphore s = new FairSemaphore(2);
#	Line 280 | Line 279 | public class FairSemaphoreTest extends J
279		});
280		t.start();
281		try {
283	–	s.release(2);
282		assertTrue(s.tryAcquire(2, SHORT_DELAY_MS, TimeUnit.MILLISECONDS));
283		s.release(2);
284		assertTrue(s.tryAcquire(2, SHORT_DELAY_MS, TimeUnit.MILLISECONDS));
285	+	s.release(2);
286		t.join();
287		} catch( InterruptedException e){
288		unexpectedException();
#	Line 291 | Line 290 | public class FairSemaphoreTest extends J
290		}
291
292		/**
293	<	*
293	>	* A waiting acquire blocks interruptibly
294		*/
295		public void testAcquire_InterruptedException() {
296		final FairSemaphore s = new FairSemaphore(0);
#	Line 314 | Line 313 | public class FairSemaphoreTest extends J
313		}
314
315		/**
316	<	*
316	>	* A waiting acquire(n) blocks interruptibly
317		*/
318		public void testAcquireN_InterruptedException() {
319		final FairSemaphore s = new FairSemaphore(2);
#	Line 337 | Line 336 | public class FairSemaphoreTest extends J
336		}
337
338		/**
339	<	*
339	>	*  A waiting tryAcquire blocks interruptibly
340		*/
341		public void testTryAcquire_InterruptedException() {
342		final FairSemaphore s = new FairSemaphore(0);
#	Line 361 | Line 360 | public class FairSemaphoreTest extends J
360		}
361
362		/**
363	<	*
363	>	*  A waiting tryAcquire(n) blocks interruptibly
364		*/
365		public void testTryAcquireN_InterruptedException() {
366		final FairSemaphore s = new FairSemaphore(1);
#	Line 385 | Line 384 | public class FairSemaphoreTest extends J
384		}
385
386		/**
387	<	*
387	>	* a deserialized serialized semaphore has same number of permits
388		*/
389		public void testSerialization() {
390		FairSemaphore l = new FairSemaphore(3);

Diff Legend

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