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.*;
import java.io.*;

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");
        }
    }

    public void testSerialization() {
        Semaphore l = new Semaphore(3);

        try {
            l.acquire();
            l.release();
            ByteArrayOutputStream bout = new ByteArrayOutputStream(10000);
            ObjectOutputStream out = new ObjectOutputStream(new BufferedOutputStream(bout));
            out.writeObject(l);
            out.close();

            ByteArrayInputStream bin = new ByteArrayInputStream(bout.toByteArray());
            ObjectInputStream in = new ObjectInputStream(new BufferedInputStream(bin));
            Semaphore r = (Semaphore) in.readObject();
            assertEquals(3, r.availablePermits());
            r.acquire();
            r.release();
        } catch(Exception e){
            e.printStackTrace();
            fail("unexpected exception");
        }
    }

}
Revision:	1.2
Committed:	Sun Sep 7 20:39:11 2003 UTC (20 years, 8 months ago) by dl
Branch:	MAIN
Changes since 1.1:	+25 -0 lines
Log Message:	Added serialization and lock tests
#	Content
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	import java.io.*;
12
13	public class SemaphoreTest extends TestCase{
14
15	public static void main(String[] args) {
16	junit.textui.TestRunner.run (suite());
17	}
18
19	public static Test suite() {
20	return new TestSuite(SemaphoreTest.class);
21	}
22
23	private static long SHORT_DELAY_MS = 100;
24	private static long MEDIUM_DELAY_MS = 1000;
25	private static long LONG_DELAY_MS = 10000;
26
27
28	public void testConstructor1() {
29	Semaphore s = new Semaphore(0);
30	assertEquals(0, s.availablePermits());
31	}
32
33	public void testConstructor2() {
34	Semaphore s = new Semaphore(-1);
35	assertEquals(-1, s.availablePermits());
36	}
37
38	public void testTryAcquireInSameThread() {
39	Semaphore s = new Semaphore(2);
40	assertEquals(2, s.availablePermits());
41	assertTrue(s.tryAcquire());
42	assertTrue(s.tryAcquire());
43	assertEquals(0, s.availablePermits());
44	assertFalse(s.tryAcquire());
45	}
46
47	public void testAcquireReleaseInSameThread(){
48	Semaphore s = new Semaphore(1);
49	try {
50	s.acquire();
51	s.release();
52	s.acquire();
53	s.release();
54	s.acquire();
55	s.release();
56	s.acquire();
57	s.release();
58	s.acquire();
59	s.release();
60	assertEquals(1, s.availablePermits());
61	} catch( InterruptedException e){
62	fail("unexpected exception");
63	}
64	}
65
66	public void testAcquireUninterruptiblyReleaseInSameThread(){
67	Semaphore s = new Semaphore(1);
68	try {
69	s.acquireUninterruptibly();
70	s.release();
71	s.acquireUninterruptibly();
72	s.release();
73	s.acquireUninterruptibly();
74	s.release();
75	s.acquireUninterruptibly();
76	s.release();
77	s.acquireUninterruptibly();
78	s.release();
79	assertEquals(1, s.availablePermits());
80	} finally {
81	}
82	}
83
84
85	public void testAcquireReleaseInDifferentThreads() {
86	final Semaphore s = new Semaphore(1);
87	Thread t = new Thread(new Runnable(){
88	public void run(){
89	try{
90	s.acquire();
91	s.release();
92	s.release();
93	s.acquire();
94	}catch(InterruptedException ie){
95	fail("unexpected exception");
96	}
97	}
98	});
99	t.start();
100	try {
101	s.release();
102	s.release();
103	s.acquire();
104	s.acquire();
105	t.join();
106	} catch( InterruptedException e){
107	fail("unexpected exception");
108	}
109	}
110
111	public void testTimedAcquireReleaseInSameThread(){
112	Semaphore s = new Semaphore(1);
113	try {
114	assertTrue(s.tryAcquire(SHORT_DELAY_MS, TimeUnit.MILLISECONDS));
115	s.release();
116	assertTrue(s.tryAcquire(SHORT_DELAY_MS, TimeUnit.MILLISECONDS));
117	s.release();
118	assertTrue(s.tryAcquire(SHORT_DELAY_MS, TimeUnit.MILLISECONDS));
119	s.release();
120	assertTrue(s.tryAcquire(SHORT_DELAY_MS, TimeUnit.MILLISECONDS));
121	s.release();
122	assertTrue(s.tryAcquire(SHORT_DELAY_MS, TimeUnit.MILLISECONDS));
123	s.release();
124	assertEquals(1, s.availablePermits());
125	} catch( InterruptedException e){
126	fail("unexpected exception");
127	}
128	}
129
130	public void testTimedAcquireReleaseInDifferentThreads() {
131	final Semaphore s = new Semaphore(1);
132	Thread t = new Thread(new Runnable(){
133	public void run(){
134	try{
135	s.release();
136	assertTrue(s.tryAcquire(SHORT_DELAY_MS, TimeUnit.MILLISECONDS));
137	s.release();
138	assertTrue(s.tryAcquire(SHORT_DELAY_MS, TimeUnit.MILLISECONDS));
139
140	}catch(InterruptedException ie){
141	fail("unexpected exception");
142	}
143	}
144	});
145	t.start();
146	try {
147	assertTrue(s.tryAcquire(SHORT_DELAY_MS, TimeUnit.MILLISECONDS));
148	s.release();
149	assertTrue(s.tryAcquire(SHORT_DELAY_MS, TimeUnit.MILLISECONDS));
150	s.release();
151	t.join();
152	} catch( InterruptedException e){
153	fail("unexpected exception");
154	}
155	}
156
157	public void testAcquire_InterruptedException(){
158	final Semaphore s = new Semaphore(0);
159	Thread t = new Thread(new Runnable(){
160	public void run(){
161	try{
162	s.acquire();
163	fail("should throw");
164	}catch(InterruptedException success){}
165	}
166	});
167	t.start();
168	try{
169	Thread.sleep(SHORT_DELAY_MS);
170	t.interrupt();
171	t.join();
172	} catch(InterruptedException e){
173	fail("unexpected exception");
174	}
175	}
176
177	public void testTryAcquire_InterruptedException(){
178	final Semaphore s = new Semaphore(0);
179	Thread t = new Thread(new Runnable(){
180	public void run(){
181	try{
182	s.tryAcquire(MEDIUM_DELAY_MS, TimeUnit.MILLISECONDS);
183	fail("should throw");
184	}catch(InterruptedException success){
185	}
186	}
187	});
188	t.start();
189	try{
190	Thread.sleep(SHORT_DELAY_MS);
191	t.interrupt();
192	t.join();
193	} catch(InterruptedException e){
194	fail("unexpected exception");
195	}
196	}
197
198	public void testSerialization() {
199	Semaphore l = new Semaphore(3);
200
201	try {
202	l.acquire();
203	l.release();
204	ByteArrayOutputStream bout = new ByteArrayOutputStream(10000);
205	ObjectOutputStream out = new ObjectOutputStream(new BufferedOutputStream(bout));
206	out.writeObject(l);
207	out.close();
208
209	ByteArrayInputStream bin = new ByteArrayInputStream(bout.toByteArray());
210	ObjectInputStream in = new ObjectInputStream(new BufferedInputStream(bin));
211	Semaphore r = (Semaphore) in.readObject();
212	assertEquals(3, r.availablePermits());
213	r.acquire();
214	r.release();
215	} catch(Exception e){
216	e.printStackTrace();
217	fail("unexpected exception");
218	}
219	}
220
221	}