test/tck/LockSupportTest.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.util.concurrent.locks.*;

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

    /**
     * park is released by unpark occuring after park
     */
    public void testPark() { 
        Thread t = new Thread(new Runnable() {
                public void run() {
                    try {
                        LockSupport.park();
                    } catch(Exception e){
                        threadUnexpectedException();
                    }
                }
            });
        try {
            t.start();
            Thread.sleep(SHORT_DELAY_MS);
            LockSupport.unpark(t);
            t.join();
        }
        catch(Exception e) {
            unexpectedException();
        }
    }

    /**
     * park is released by unpark occuring before park
     */
    public void testPark2() { 
        Thread t = new Thread(new Runnable() {
                public void run() {
                    try {
                        Thread.sleep(SHORT_DELAY_MS);
                        LockSupport.park();
                    } catch(Exception e){
                        threadUnexpectedException();
                    }
                }
            });
        try {
            t.start();
            LockSupport.unpark(t);
            t.join();
        }
        catch(Exception e) {
            unexpectedException();
        }
    }

    /**
     * park is released by interrupt 
     */
    public void testPark3() { 
        Thread t = new Thread(new Runnable() {
                public void run() {
                    try {
                        LockSupport.park();
                        threadAssertTrue(Thread.interrupted());
                    } catch(Exception e){
                        threadUnexpectedException();
                    }
                }
            });
        try {
            t.start();
            Thread.sleep(SHORT_DELAY_MS);
            t.interrupt();
            t.join();
        }
        catch(Exception e) {
            unexpectedException();
        }
    }

    /**
     * park returns if interrupted before park
     */
    public void testPark4() { 
        final ReentrantLock lock = new ReentrantLock();
        lock.lock();
        Thread t = new Thread(new Runnable() {
                public void run() {
                    try {
                        lock.lock();
                        LockSupport.park();
                    } catch(Exception e){
                        threadUnexpectedException();
                    }
                }
            });
        try {
            t.start();
            t.interrupt();
            lock.unlock();
            t.join();
        }
        catch(Exception e) {
            unexpectedException();
        }
    }

    /**
     * parkNanos times out if not unparked
     */
    public void testParkNanos() { 
        Thread t = new Thread(new Runnable() {
                public void run() {
                    try {
                        LockSupport.parkNanos(1000);
                    } catch(Exception e){
                        threadUnexpectedException();
                    }
                }
            });
        try {
            t.start();
            t.join();
        }
        catch(Exception e) {
            unexpectedException();
        }
    }


    /**
     * parkUntil times out if not unparked
     */
    public void testParkUntil() { 
        Thread t = new Thread(new Runnable() {
                public void run() {
                    try {
                        long d = new Date().getTime() + 100;
                        LockSupport.parkUntil(d);
                    } catch(Exception e){
                        threadUnexpectedException();
                    }
                }
            });
        try {
            t.start();
            t.join();
        }
        catch(Exception e) {
            unexpectedException();
        }
    }
}
Revision:	1.4
Committed:	Thu Sep 25 11:02:41 2003 UTC (20 years, 7 months ago) by dl
Branch:	MAIN
CVS Tags:	JSR166_NOV3_FREEZE, JSR166_DEC9_PRE_ES_SUBMIT, JSR166_DEC9_POST_ES_SUBMIT
Changes since 1.3:	+82 -5 lines
Log Message:	improve tck javadocs; rename and add a few 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.util.concurrent.locks.*;
12
13	public class LockSupportTest extends JSR166TestCase{
14	public static void main(String[] args) {
15	junit.textui.TestRunner.run (suite());
16	}
17	public static Test suite() {
18	return new TestSuite(LockSupportTest.class);
19	}
20
21	/**
22	* park is released by unpark occuring after park
23	*/
24	public void testPark() {
25	Thread t = new Thread(new Runnable() {
26	public void run() {
27	try {
28	LockSupport.park();
29	} catch(Exception e){
30	threadUnexpectedException();
31	}
32	}
33	});
34	try {
35	t.start();
36	Thread.sleep(SHORT_DELAY_MS);
37	LockSupport.unpark(t);
38	t.join();
39	}
40	catch(Exception e) {
41	unexpectedException();
42	}
43	}
44
45	/**
46	* park is released by unpark occuring before park
47	*/
48	public void testPark2() {
49	Thread t = new Thread(new Runnable() {
50	public void run() {
51	try {
52	Thread.sleep(SHORT_DELAY_MS);
53	LockSupport.park();
54	} catch(Exception e){
55	threadUnexpectedException();
56	}
57	}
58	});
59	try {
60	t.start();
61	LockSupport.unpark(t);
62	t.join();
63	}
64	catch(Exception e) {
65	unexpectedException();
66	}
67	}
68
69	/**
70	* park is released by interrupt
71	*/
72	public void testPark3() {
73	Thread t = new Thread(new Runnable() {
74	public void run() {
75	try {
76	LockSupport.park();
77	threadAssertTrue(Thread.interrupted());
78	} catch(Exception e){
79	threadUnexpectedException();
80	}
81	}
82	});
83	try {
84	t.start();
85	Thread.sleep(SHORT_DELAY_MS);
86	t.interrupt();
87	t.join();
88	}
89	catch(Exception e) {
90	unexpectedException();
91	}
92	}
93
94	/**
95	* park returns if interrupted before park
96	*/
97	public void testPark4() {
98	final ReentrantLock lock = new ReentrantLock();
99	lock.lock();
100	Thread t = new Thread(new Runnable() {
101	public void run() {
102	try {
103	lock.lock();
104	LockSupport.park();
105	} catch(Exception e){
106	threadUnexpectedException();
107	}
108	}
109	});
110	try {
111	t.start();
112	t.interrupt();
113	lock.unlock();
114	t.join();
115	}
116	catch(Exception e) {
117	unexpectedException();
118	}
119	}
120
121	/**
122	* parkNanos times out if not unparked
123	*/
124	public void testParkNanos() {
125	Thread t = new Thread(new Runnable() {
126	public void run() {
127	try {
128	LockSupport.parkNanos(1000);
129	} catch(Exception e){
130	threadUnexpectedException();
131	}
132	}
133	});
134	try {
135	t.start();
136	t.join();
137	}
138	catch(Exception e) {
139	unexpectedException();
140	}
141	}
142
143
144	/**
145	* parkUntil times out if not unparked
146	*/
147	public void testParkUntil() {
148	Thread t = new Thread(new Runnable() {
149	public void run() {
150	try {
151	long d = new Date().getTime() + 100;
152	LockSupport.parkUntil(d);
153	} catch(Exception e){
154	threadUnexpectedException();
155	}
156	}
157	});
158	try {
159	t.start();
160	t.join();
161	}
162	catch(Exception e) {
163	unexpectedException();
164	}
165	}
166	}