test/tck/SemaphoreTest.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 SemaphoreTest extends TestCase{

    public static void main(String[] args) {
        junit.textui.TestRunner.run (suite());  
    }
    
    public static Test suite() {
        return new TestSuite(SemaphoreTest.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() {
        Semaphore s = new Semaphore(0);
        assertEquals(0, s.availablePermits());
    }

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

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

    public void testAcquireReleaseInSameThread(){
        Semaphore s = new Semaphore(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 testAcquireUninterruptiblyReleaseInSameThread(){
        Semaphore s = new Semaphore(1);
        try {
            s.acquireUninterruptibly();
            s.release();
            s.acquireUninterruptibly();
            s.release();
            s.acquireUninterruptibly();
            s.release();
            s.acquireUninterruptibly();
            s.release();
            s.acquireUninterruptibly();
            s.release();
            assertEquals(1, s.availablePermits());
        } finally {
        }
    }


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

    public void testTimedAcquireReleaseInSameThread(){
        Semaphore s = new Semaphore(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 testTimedAcquireReleaseInDifferentThreads() {
        final Semaphore s = new Semaphore(1);
        Thread t = new Thread(new Runnable(){
                public void run(){
                    try{
                        s.release();
                        assertTrue(s.tryAcquire(SHORT_DELAY_MS, TimeUnit.MILLISECONDS));
                        s.release();
                        assertTrue(s.tryAcquire(SHORT_DELAY_MS, TimeUnit.MILLISECONDS));

                    }catch(InterruptedException ie){
                        fail("unexpected exception");
                    }
                }
            });
        t.start();
        try {
            assertTrue(s.tryAcquire(SHORT_DELAY_MS, TimeUnit.MILLISECONDS));
            s.release();
            assertTrue(s.tryAcquire(SHORT_DELAY_MS, TimeUnit.MILLISECONDS));
            s.release();
            t.join();
        } catch( InterruptedException e){
            fail("unexpected exception");
        }
    }

    public void testAcquire_InterruptedException(){
        final Semaphore s = new Semaphore(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 testTryAcquire_InterruptedException(){
        final Semaphore s = new Semaphore(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");
        }
    }
}
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 SemaphoreTest 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(SemaphoreTest.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			Semaphore s = new Semaphore(0);
29			assertEquals(0, s.availablePermits());
30			}
31
32			public void testConstructor2() {
33			Semaphore s = new Semaphore(-1);
34			assertEquals(-1, s.availablePermits());
35			}
36
37			public void testTryAcquireInSameThread() {
38			Semaphore s = new Semaphore(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 testAcquireReleaseInSameThread(){
47			Semaphore s = new Semaphore(1);
48			try {
49			s.acquire();
50			s.release();
51			s.acquire();
52			s.release();
53			s.acquire();
54			s.release();
55			s.acquire();
56			s.release();
57			s.acquire();
58			s.release();
59			assertEquals(1, s.availablePermits());
60			} catch( InterruptedException e){
61			fail("unexpected exception");
62			}
63			}
64
65			public void testAcquireUninterruptiblyReleaseInSameThread(){
66			Semaphore s = new Semaphore(1);
67			try {
68			s.acquireUninterruptibly();
69			s.release();
70			s.acquireUninterruptibly();
71			s.release();
72			s.acquireUninterruptibly();
73			s.release();
74			s.acquireUninterruptibly();
75			s.release();
76			s.acquireUninterruptibly();
77			s.release();
78			assertEquals(1, s.availablePermits());
79			} finally {
80			}
81			}
82
83
84			public void testAcquireReleaseInDifferentThreads() {
85			final Semaphore s = new Semaphore(1);
86			Thread t = new Thread(new Runnable(){
87			public void run(){
88			try{
89			s.acquire();
90			s.release();
91			s.release();
92			s.acquire();
93			}catch(InterruptedException ie){
94			fail("unexpected exception");
95			}
96			}
97			});
98			t.start();
99			try {
100			s.release();
101			s.release();
102			s.acquire();
103			s.acquire();
104			t.join();
105			} catch( InterruptedException e){
106			fail("unexpected exception");
107			}
108			}
109
110			public void testTimedAcquireReleaseInSameThread(){
111			Semaphore s = new Semaphore(1);
112			try {
113			assertTrue(s.tryAcquire(SHORT_DELAY_MS, TimeUnit.MILLISECONDS));
114			s.release();
115			assertTrue(s.tryAcquire(SHORT_DELAY_MS, TimeUnit.MILLISECONDS));
116			s.release();
117			assertTrue(s.tryAcquire(SHORT_DELAY_MS, TimeUnit.MILLISECONDS));
118			s.release();
119			assertTrue(s.tryAcquire(SHORT_DELAY_MS, TimeUnit.MILLISECONDS));
120			s.release();
121			assertTrue(s.tryAcquire(SHORT_DELAY_MS, TimeUnit.MILLISECONDS));
122			s.release();
123			assertEquals(1, s.availablePermits());
124			} catch( InterruptedException e){
125			fail("unexpected exception");
126			}
127			}
128
129			public void testTimedAcquireReleaseInDifferentThreads() {
130			final Semaphore s = new Semaphore(1);
131			Thread t = new Thread(new Runnable(){
132			public void run(){
133			try{
134			s.release();
135			assertTrue(s.tryAcquire(SHORT_DELAY_MS, TimeUnit.MILLISECONDS));
136			s.release();
137			assertTrue(s.tryAcquire(SHORT_DELAY_MS, TimeUnit.MILLISECONDS));
138
139			}catch(InterruptedException ie){
140			fail("unexpected exception");
141			}
142			}
143			});
144			t.start();
145			try {
146			assertTrue(s.tryAcquire(SHORT_DELAY_MS, TimeUnit.MILLISECONDS));
147			s.release();
148			assertTrue(s.tryAcquire(SHORT_DELAY_MS, TimeUnit.MILLISECONDS));
149			s.release();
150			t.join();
151			} catch( InterruptedException e){
152			fail("unexpected exception");
153			}
154			}
155
156			public void testAcquire_InterruptedException(){
157			final Semaphore s = new Semaphore(0);
158			Thread t = new Thread(new Runnable(){
159			public void run(){
160			try{
161			s.acquire();
162			fail("should throw");
163			}catch(InterruptedException success){}
164			}
165			});
166			t.start();
167			try{
168			Thread.sleep(SHORT_DELAY_MS);
169			t.interrupt();
170			t.join();
171			} catch(InterruptedException e){
172			fail("unexpected exception");
173			}
174			}
175
176			public void testTryAcquire_InterruptedException(){
177			final Semaphore s = new Semaphore(0);
178			Thread t = new Thread(new Runnable(){
179			public void run(){
180			try{
181			s.tryAcquire(MEDIUM_DELAY_MS, TimeUnit.MILLISECONDS);
182			fail("should throw");
183			}catch(InterruptedException success){
184			}
185			}
186			});
187			t.start();
188			try{
189			Thread.sleep(SHORT_DELAY_MS);
190			t.interrupt();
191			t.join();
192			} catch(InterruptedException e){
193			fail("unexpected exception");
194			}
195			}
196			}