test/tck/LockSupportTest.java

/*
 * Written by Doug Lea with assistance from members of JCP JSR-166
 * Expert Group and released to the public domain, as explained at
 * http://creativecommons.org/licenses/publicdomain
 * Other contributors include Andrew Wright, Jeffrey Hayes, 
 * Pat Fisher, 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 occurring 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 occurring 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.6
Committed:	Mon Dec 29 19:05:40 2003 UTC (20 years, 4 months ago) by dl
Branch:	MAIN
CVS Tags:	JSR166_PFD
Changes since 1.5:	+2 -2 lines
Log Message:	spellcheck
#	Content
1	/*
2	* Written by Doug Lea with assistance from members of JCP JSR-166
3	* Expert Group and released to the public domain, as explained at
4	* http://creativecommons.org/licenses/publicdomain
5	* Other contributors include Andrew Wright, Jeffrey Hayes,
6	* Pat Fisher, Mike Judd.
7	*/
8
9	import junit.framework.*;
10	import java.util.*;
11	import java.util.concurrent.*;
12	import java.util.concurrent.locks.*;
13
14	public class LockSupportTest extends JSR166TestCase{
15	public static void main(String[] args) {
16	junit.textui.TestRunner.run (suite());
17	}
18	public static Test suite() {
19	return new TestSuite(LockSupportTest.class);
20	}
21
22	/**
23	* park is released by unpark occurring after park
24	*/
25	public void testPark() {
26	Thread t = new Thread(new Runnable() {
27	public void run() {
28	try {
29	LockSupport.park();
30	} catch(Exception e){
31	threadUnexpectedException();
32	}
33	}
34	});
35	try {
36	t.start();
37	Thread.sleep(SHORT_DELAY_MS);
38	LockSupport.unpark(t);
39	t.join();
40	}
41	catch(Exception e) {
42	unexpectedException();
43	}
44	}
45
46	/**
47	* park is released by unpark occurring before park
48	*/
49	public void testPark2() {
50	Thread t = new Thread(new Runnable() {
51	public void run() {
52	try {
53	Thread.sleep(SHORT_DELAY_MS);
54	LockSupport.park();
55	} catch(Exception e){
56	threadUnexpectedException();
57	}
58	}
59	});
60	try {
61	t.start();
62	LockSupport.unpark(t);
63	t.join();
64	}
65	catch(Exception e) {
66	unexpectedException();
67	}
68	}
69
70	/**
71	* park is released by interrupt
72	*/
73	public void testPark3() {
74	Thread t = new Thread(new Runnable() {
75	public void run() {
76	try {
77	LockSupport.park();
78	threadAssertTrue(Thread.interrupted());
79	} catch(Exception e){
80	threadUnexpectedException();
81	}
82	}
83	});
84	try {
85	t.start();
86	Thread.sleep(SHORT_DELAY_MS);
87	t.interrupt();
88	t.join();
89	}
90	catch(Exception e) {
91	unexpectedException();
92	}
93	}
94
95	/**
96	* park returns if interrupted before park
97	*/
98	public void testPark4() {
99	final ReentrantLock lock = new ReentrantLock();
100	lock.lock();
101	Thread t = new Thread(new Runnable() {
102	public void run() {
103	try {
104	lock.lock();
105	LockSupport.park();
106	} catch(Exception e){
107	threadUnexpectedException();
108	}
109	}
110	});
111	try {
112	t.start();
113	t.interrupt();
114	lock.unlock();
115	t.join();
116	}
117	catch(Exception e) {
118	unexpectedException();
119	}
120	}
121
122	/**
123	* parkNanos times out if not unparked
124	*/
125	public void testParkNanos() {
126	Thread t = new Thread(new Runnable() {
127	public void run() {
128	try {
129	LockSupport.parkNanos(1000);
130	} catch(Exception e){
131	threadUnexpectedException();
132	}
133	}
134	});
135	try {
136	t.start();
137	t.join();
138	}
139	catch(Exception e) {
140	unexpectedException();
141	}
142	}
143
144
145	/**
146	* parkUntil times out if not unparked
147	*/
148	public void testParkUntil() {
149	Thread t = new Thread(new Runnable() {
150	public void run() {
151	try {
152	long d = new Date().getTime() + 100;
153	LockSupport.parkUntil(d);
154	} catch(Exception e){
155	threadUnexpectedException();
156	}
157	}
158	});
159	try {
160	t.start();
161	t.join();
162	}
163	catch(Exception e) {
164	unexpectedException();
165	}
166	}
167	}