test/tck/FairSemaphoreTest.java

/*
 * Written by members of JCP JSR-166 Expert Group and released to the
 * public domain. Use, modify, and redistribute this code in any way
 * without acknowledgement. Other contributors include Andrew Wright,
 * Jeffrey Hayes, Pat Fischer, Mike Judd.
 */

import junit.framework.*;
import java.util.*;
import java.util.concurrent.*;

public class FairSemaphoreTest extends TestCase{

    public static void main(String[] args) {
        junit.textui.TestRunner.run (suite());  
    }
    
    public static Test suite() {
        return new TestSuite(FairSemaphoreTest.class);
    }

    private static long SHORT_DELAY_MS = 100; 
    private static long MEDIUM_DELAY_MS = 1000;
    private static long LONG_DELAY_MS = 10000; 


    public void testConstructor1() {
        FairSemaphore s = new FairSemaphore(0);
        assertEquals(0, s.availablePermits());
    }

    public void testConstructor2() {
        FairSemaphore s = new FairSemaphore(-1);
        assertEquals(-1, s.availablePermits());
    }

    public void testTryAcquireInSameThread() {
        FairSemaphore s = new FairSemaphore(2);
        assertEquals(2, s.availablePermits());
        assertTrue(s.tryAcquire());
        assertTrue(s.tryAcquire());
        assertEquals(0, s.availablePermits());
        assertFalse(s.tryAcquire());
    }

    public void testTryAcquireNInSameThread() {
        FairSemaphore s = new FairSemaphore(2);
        assertEquals(2, s.availablePermits());
        assertTrue(s.tryAcquire(2));
        assertEquals(0, s.availablePermits());
        assertFalse(s.tryAcquire());
    }

    public void testAcquireReleaseInSameThread(){
        FairSemaphore s = new FairSemaphore(1);
        try {
            s.acquire();
            s.release();
            s.acquire();
            s.release();
            s.acquire();
            s.release();
            s.acquire();
            s.release();
            s.acquire();
            s.release();
            assertEquals(1, s.availablePermits());
        } catch( InterruptedException e){
            fail("unexpected exception");
        }
    }

    public void testAcquireReleaseNInSameThread(){
        FairSemaphore s = new FairSemaphore(1);
        try {
            s.release(1);
            s.acquire(1);
            s.release(2);
            s.acquire(2);
            s.release(3);
            s.acquire(3);
            s.release(4);
            s.acquire(4);
            s.release(5);
            s.acquire(5);
            assertEquals(1, s.availablePermits());
        } catch( InterruptedException e){
            fail("unexpected exception");
        }
    }

    public void testAcquireUninterruptiblyReleaseNInSameThread(){
        FairSemaphore s = new FairSemaphore(1);
        try {
            s.release(1);
            s.acquireUninterruptibly(1);
            s.release(2);
            s.acquireUninterruptibly(2);
            s.release(3);
            s.acquireUninterruptibly(3);
            s.release(4);
            s.acquireUninterruptibly(4);
            s.release(5);
            s.acquireUninterruptibly(5);
            assertEquals(1, s.availablePermits());
        } finally {
        }
    }

    public void testAcquireReleaseInDifferentThreads() {
        final FairSemaphore s = new FairSemaphore(1);
        Thread t = new Thread(new Runnable(){
                public void run(){
                    try{
                        s.acquire();
                        s.acquire();
                        s.acquire();
                        s.acquire();
                        s.acquire();
                    }catch(InterruptedException ie){
                        fail("unexpected exception");
                    }
                }
            });
        t.start();
        try {
            s.release();
            s.release();
            s.release();
            s.release();
            s.release();
            t.join();
            assertEquals(1, s.availablePermits());
        } catch( InterruptedException e){
            fail("unexpected exception");
        }
    }

    public void testAcquireReleaseNInDifferentThreads() {
        final FairSemaphore s = new FairSemaphore(2);
        Thread t = new Thread(new Runnable(){
                public void run(){
                    try{
                        s.release(2);
                        s.release(2);
                        s.acquire(2);
                        s.acquire(2);
                    }catch(InterruptedException ie){
                        fail("unexpected exception");
                    }
                }
            });
        t.start();
        try {
            s.acquire(2);
            s.acquire(2);
            s.release(2);
            s.release(2);
            t.join();
        } catch( InterruptedException e){
            fail("unexpected exception");
        }
    }

    public void testTimedAcquireReleaseInSameThread(){
        FairSemaphore s = new FairSemaphore(1);
        try {
            assertTrue(s.tryAcquire(SHORT_DELAY_MS, TimeUnit.MILLISECONDS));
            s.release();
            assertTrue(s.tryAcquire(SHORT_DELAY_MS, TimeUnit.MILLISECONDS));
            s.release();
            assertTrue(s.tryAcquire(SHORT_DELAY_MS, TimeUnit.MILLISECONDS));
            s.release();
            assertTrue(s.tryAcquire(SHORT_DELAY_MS, TimeUnit.MILLISECONDS));
            s.release();
            assertTrue(s.tryAcquire(SHORT_DELAY_MS, TimeUnit.MILLISECONDS));
            s.release();
            assertEquals(1, s.availablePermits());
        } catch( InterruptedException e){
            fail("unexpected exception");
        }
    }

    public void testTimedAcquireReleaseNInSameThread(){
        FairSemaphore s = new FairSemaphore(1);
        try {
            s.release(1);
            assertTrue(s.tryAcquire(1, SHORT_DELAY_MS, TimeUnit.MILLISECONDS));
            s.release(2);
            assertTrue(s.tryAcquire(2, SHORT_DELAY_MS, TimeUnit.MILLISECONDS));
            s.release(3);
            assertTrue(s.tryAcquire(3, SHORT_DELAY_MS, TimeUnit.MILLISECONDS));
            s.release(4);
            assertTrue(s.tryAcquire(4, SHORT_DELAY_MS, TimeUnit.MILLISECONDS));
            s.release(5);
            assertTrue(s.tryAcquire(5, SHORT_DELAY_MS, TimeUnit.MILLISECONDS));
            assertEquals(1, s.availablePermits());
        } catch( InterruptedException e){
            fail("unexpected exception");
        }
    }

    public void testTimedAcquireReleaseInDifferentThreads() {
        final FairSemaphore s = new FairSemaphore(1);
        Thread t = new Thread(new Runnable(){
                public void run(){
                    try{
                        assertTrue(s.tryAcquire(SHORT_DELAY_MS, TimeUnit.MILLISECONDS));
                        assertTrue(s.tryAcquire(SHORT_DELAY_MS, TimeUnit.MILLISECONDS));
                        assertTrue(s.tryAcquire(SHORT_DELAY_MS, TimeUnit.MILLISECONDS));
                        assertTrue(s.tryAcquire(SHORT_DELAY_MS, TimeUnit.MILLISECONDS));
                        assertTrue(s.tryAcquire(SHORT_DELAY_MS, TimeUnit.MILLISECONDS));

                    }catch(InterruptedException ie){
                        fail("unexpected exception");
                    }
                }
            });
        t.start();
        try {
            s.release();
            s.release();
            s.release();
            s.release();
            s.release();
            t.join();
        } catch( InterruptedException e){
            fail("unexpected exception");
        }
    }

    public void testTimedAcquireReleaseNInDifferentThreads() {
        final FairSemaphore s = new FairSemaphore(2);
        Thread t = new Thread(new Runnable(){
                public void run(){
                    try{
                        assertTrue(s.tryAcquire(2, SHORT_DELAY_MS, TimeUnit.MILLISECONDS));
                        s.release(2);
                        assertTrue(s.tryAcquire(2, SHORT_DELAY_MS, TimeUnit.MILLISECONDS));
                        s.release(2);
                    }catch(InterruptedException ie){
                        fail("unexpected exception");
                    }
                }
            });
        t.start();
        try {
            s.release(2);
            assertTrue(s.tryAcquire(2, SHORT_DELAY_MS, TimeUnit.MILLISECONDS));
            s.release(2);
            assertTrue(s.tryAcquire(2, SHORT_DELAY_MS, TimeUnit.MILLISECONDS));
            t.join();
        } catch( InterruptedException e){
            fail("unexpected exception");
        }
    }

    public void testAcquire_InterruptedException(){
        final FairSemaphore s = new FairSemaphore(0);
        Thread t = new Thread(new Runnable(){
                public void run(){
                    try{
                        s.acquire();
                        fail("should throw");
                    }catch(InterruptedException success){}
                }
            });
        t.start();
        try{
            Thread.sleep(SHORT_DELAY_MS);
            t.interrupt();
            t.join();
        } catch(InterruptedException e){
            fail("unexpected exception");
        }
    }

    public void testAcquireN_InterruptedException(){
        final FairSemaphore s = new FairSemaphore(2);
        Thread t = new Thread(new Runnable(){
                public void run(){
                    try{
                        s.acquire(3);
                        fail("should throw");
                    }catch(InterruptedException success){}
                }
            });
        t.start();
        try{
            Thread.sleep(SHORT_DELAY_MS);
            t.interrupt();
            t.join();
        } catch(InterruptedException e){
            fail("unexpected exception");
        }
    }
    
    public void testTryAcquire_InterruptedException(){
        final FairSemaphore s = new FairSemaphore(0);
        Thread t = new Thread(new Runnable(){
                public void run(){
                    try{
                        s.tryAcquire(MEDIUM_DELAY_MS, TimeUnit.MILLISECONDS);
                        fail("should throw");
                    }catch(InterruptedException success){
                    }
                }
            });
        t.start();
        try{
            Thread.sleep(SHORT_DELAY_MS);
            t.interrupt();
            t.join();
        } catch(InterruptedException e){
            fail("unexpected exception");
        }
    }

    public void testTryAcquireN_InterruptedException(){
        final FairSemaphore s = new FairSemaphore(1);
        Thread t = new Thread(new Runnable(){
                public void run(){
                    try{
                        s.tryAcquire(4, MEDIUM_DELAY_MS, TimeUnit.MILLISECONDS);
                        fail("should throw");
                    }catch(InterruptedException success){
                    }
                }
            });
        t.start();
        try{
            Thread.sleep(SHORT_DELAY_MS);
            t.interrupt();
            t.join();
        } catch(InterruptedException e){
            fail("unexpected exception");
        }
    }

}
Revision:	1.1
Committed:	Sun Aug 31 19:24:55 2003 UTC (20 years, 8 months ago) by dl
Branch:	MAIN
Log Message:	First check-in of tests to be in tck
#	User	Rev	Content
1	dl	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.
6			*/
7
8			import junit.framework.*;
9			import java.util.*;
10			import java.util.concurrent.*;
11
12			public class FairSemaphoreTest extends TestCase{
13
14			public static void main(String[] args) {
15			junit.textui.TestRunner.run (suite());
16			}
17
18			public static Test suite() {
19			return new TestSuite(FairSemaphoreTest.class);
20			}
21
22			private static long SHORT_DELAY_MS = 100;
23			private static long MEDIUM_DELAY_MS = 1000;
24			private static long LONG_DELAY_MS = 10000;
25
26
27			public void testConstructor1() {
28			FairSemaphore s = new FairSemaphore(0);
29			assertEquals(0, s.availablePermits());
30			}
31
32			public void testConstructor2() {
33			FairSemaphore s = new FairSemaphore(-1);
34			assertEquals(-1, s.availablePermits());
35			}
36
37			public void testTryAcquireInSameThread() {
38			FairSemaphore s = new FairSemaphore(2);
39			assertEquals(2, s.availablePermits());
40			assertTrue(s.tryAcquire());
41			assertTrue(s.tryAcquire());
42			assertEquals(0, s.availablePermits());
43			assertFalse(s.tryAcquire());
44			}
45
46			public void testTryAcquireNInSameThread() {
47			FairSemaphore s = new FairSemaphore(2);
48			assertEquals(2, s.availablePermits());
49			assertTrue(s.tryAcquire(2));
50			assertEquals(0, s.availablePermits());
51			assertFalse(s.tryAcquire());
52			}
53
54			public void testAcquireReleaseInSameThread(){
55			FairSemaphore s = new FairSemaphore(1);
56			try {
57			s.acquire();
58			s.release();
59			s.acquire();
60			s.release();
61			s.acquire();
62			s.release();
63			s.acquire();
64			s.release();
65			s.acquire();
66			s.release();
67			assertEquals(1, s.availablePermits());
68			} catch( InterruptedException e){
69			fail("unexpected exception");
70			}
71			}
72
73			public void testAcquireReleaseNInSameThread(){
74			FairSemaphore s = new FairSemaphore(1);
75			try {
76			s.release(1);
77			s.acquire(1);
78			s.release(2);
79			s.acquire(2);
80			s.release(3);
81			s.acquire(3);
82			s.release(4);
83			s.acquire(4);
84			s.release(5);
85			s.acquire(5);
86			assertEquals(1, s.availablePermits());
87			} catch( InterruptedException e){
88			fail("unexpected exception");
89			}
90			}
91
92			public void testAcquireUninterruptiblyReleaseNInSameThread(){
93			FairSemaphore s = new FairSemaphore(1);
94			try {
95			s.release(1);
96			s.acquireUninterruptibly(1);
97			s.release(2);
98			s.acquireUninterruptibly(2);
99			s.release(3);
100			s.acquireUninterruptibly(3);
101			s.release(4);
102			s.acquireUninterruptibly(4);
103			s.release(5);
104			s.acquireUninterruptibly(5);
105			assertEquals(1, s.availablePermits());
106			} finally {
107			}
108			}
109
110			public void testAcquireReleaseInDifferentThreads() {
111			final FairSemaphore s = new FairSemaphore(1);
112			Thread t = new Thread(new Runnable(){
113			public void run(){
114			try{
115			s.acquire();
116			s.acquire();
117			s.acquire();
118			s.acquire();
119			s.acquire();
120			}catch(InterruptedException ie){
121			fail("unexpected exception");
122			}
123			}
124			});
125			t.start();
126			try {
127			s.release();
128			s.release();
129			s.release();
130			s.release();
131			s.release();
132			t.join();
133			assertEquals(1, s.availablePermits());
134			} catch( InterruptedException e){
135			fail("unexpected exception");
136			}
137			}
138
139			public void testAcquireReleaseNInDifferentThreads() {
140			final FairSemaphore s = new FairSemaphore(2);
141			Thread t = new Thread(new Runnable(){
142			public void run(){
143			try{
144			s.release(2);
145			s.release(2);
146			s.acquire(2);
147			s.acquire(2);
148			}catch(InterruptedException ie){
149			fail("unexpected exception");
150			}
151			}
152			});
153			t.start();
154			try {
155			s.acquire(2);
156			s.acquire(2);
157			s.release(2);
158			s.release(2);
159			t.join();
160			} catch( InterruptedException e){
161			fail("unexpected exception");
162			}
163			}
164
165			public void testTimedAcquireReleaseInSameThread(){
166			FairSemaphore s = new FairSemaphore(1);
167			try {
168			assertTrue(s.tryAcquire(SHORT_DELAY_MS, TimeUnit.MILLISECONDS));
169			s.release();
170			assertTrue(s.tryAcquire(SHORT_DELAY_MS, TimeUnit.MILLISECONDS));
171			s.release();
172			assertTrue(s.tryAcquire(SHORT_DELAY_MS, TimeUnit.MILLISECONDS));
173			s.release();
174			assertTrue(s.tryAcquire(SHORT_DELAY_MS, TimeUnit.MILLISECONDS));
175			s.release();
176			assertTrue(s.tryAcquire(SHORT_DELAY_MS, TimeUnit.MILLISECONDS));
177			s.release();
178			assertEquals(1, s.availablePermits());
179			} catch( InterruptedException e){
180			fail("unexpected exception");
181			}
182			}
183
184			public void testTimedAcquireReleaseNInSameThread(){
185			FairSemaphore s = new FairSemaphore(1);
186			try {
187			s.release(1);
188			assertTrue(s.tryAcquire(1, SHORT_DELAY_MS, TimeUnit.MILLISECONDS));
189			s.release(2);
190			assertTrue(s.tryAcquire(2, SHORT_DELAY_MS, TimeUnit.MILLISECONDS));
191			s.release(3);
192			assertTrue(s.tryAcquire(3, SHORT_DELAY_MS, TimeUnit.MILLISECONDS));
193			s.release(4);
194			assertTrue(s.tryAcquire(4, SHORT_DELAY_MS, TimeUnit.MILLISECONDS));
195			s.release(5);
196			assertTrue(s.tryAcquire(5, SHORT_DELAY_MS, TimeUnit.MILLISECONDS));
197			assertEquals(1, s.availablePermits());
198			} catch( InterruptedException e){
199			fail("unexpected exception");
200			}
201			}
202
203			public void testTimedAcquireReleaseInDifferentThreads() {
204			final FairSemaphore s = new FairSemaphore(1);
205			Thread t = new Thread(new Runnable(){
206			public void run(){
207			try{
208			assertTrue(s.tryAcquire(SHORT_DELAY_MS, TimeUnit.MILLISECONDS));
209			assertTrue(s.tryAcquire(SHORT_DELAY_MS, TimeUnit.MILLISECONDS));
210			assertTrue(s.tryAcquire(SHORT_DELAY_MS, TimeUnit.MILLISECONDS));
211			assertTrue(s.tryAcquire(SHORT_DELAY_MS, TimeUnit.MILLISECONDS));
212			assertTrue(s.tryAcquire(SHORT_DELAY_MS, TimeUnit.MILLISECONDS));
213
214			}catch(InterruptedException ie){
215			fail("unexpected exception");
216			}
217			}
218			});
219			t.start();
220			try {
221			s.release();
222			s.release();
223			s.release();
224			s.release();
225			s.release();
226			t.join();
227			} catch( InterruptedException e){
228			fail("unexpected exception");
229			}
230			}
231
232			public void testTimedAcquireReleaseNInDifferentThreads() {
233			final FairSemaphore s = new FairSemaphore(2);
234			Thread t = new Thread(new Runnable(){
235			public void run(){
236			try{
237			assertTrue(s.tryAcquire(2, SHORT_DELAY_MS, TimeUnit.MILLISECONDS));
238			s.release(2);
239			assertTrue(s.tryAcquire(2, SHORT_DELAY_MS, TimeUnit.MILLISECONDS));
240			s.release(2);
241			}catch(InterruptedException ie){
242			fail("unexpected exception");
243			}
244			}
245			});
246			t.start();
247			try {
248			s.release(2);
249			assertTrue(s.tryAcquire(2, SHORT_DELAY_MS, TimeUnit.MILLISECONDS));
250			s.release(2);
251			assertTrue(s.tryAcquire(2, SHORT_DELAY_MS, TimeUnit.MILLISECONDS));
252			t.join();
253			} catch( InterruptedException e){
254			fail("unexpected exception");
255			}
256			}
257
258			public void testAcquire_InterruptedException(){
259			final FairSemaphore s = new FairSemaphore(0);
260			Thread t = new Thread(new Runnable(){
261			public void run(){
262			try{
263			s.acquire();
264			fail("should throw");
265			}catch(InterruptedException success){}
266			}
267			});
268			t.start();
269			try{
270			Thread.sleep(SHORT_DELAY_MS);
271			t.interrupt();
272			t.join();
273			} catch(InterruptedException e){
274			fail("unexpected exception");
275			}
276			}
277
278			public void testAcquireN_InterruptedException(){
279			final FairSemaphore s = new FairSemaphore(2);
280			Thread t = new Thread(new Runnable(){
281			public void run(){
282			try{
283			s.acquire(3);
284			fail("should throw");
285			}catch(InterruptedException success){}
286			}
287			});
288			t.start();
289			try{
290			Thread.sleep(SHORT_DELAY_MS);
291			t.interrupt();
292			t.join();
293			} catch(InterruptedException e){
294			fail("unexpected exception");
295			}
296			}
297
298			public void testTryAcquire_InterruptedException(){
299			final FairSemaphore s = new FairSemaphore(0);
300			Thread t = new Thread(new Runnable(){
301			public void run(){
302			try{
303			s.tryAcquire(MEDIUM_DELAY_MS, TimeUnit.MILLISECONDS);
304			fail("should throw");
305			}catch(InterruptedException success){
306			}
307			}
308			});
309			t.start();
310			try{
311			Thread.sleep(SHORT_DELAY_MS);
312			t.interrupt();
313			t.join();
314			} catch(InterruptedException e){
315			fail("unexpected exception");
316			}
317			}
318
319			public void testTryAcquireN_InterruptedException(){
320			final FairSemaphore s = new FairSemaphore(1);
321			Thread t = new Thread(new Runnable(){
322			public void run(){
323			try{
324			s.tryAcquire(4, MEDIUM_DELAY_MS, TimeUnit.MILLISECONDS);
325			fail("should throw");
326			}catch(InterruptedException success){
327			}
328			}
329			});
330			t.start();
331			try{
332			Thread.sleep(SHORT_DELAY_MS);
333			t.interrupt();
334			t.join();
335			} catch(InterruptedException e){
336			fail("unexpected exception");
337			}
338			}
339
340			}