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() throws InterruptedException {
        Thread t = new Thread(new CheckedRunnable() {
            public void realRun() {
                LockSupport.park();
            }});

        t.start();
        Thread.sleep(SHORT_DELAY_MS);
        LockSupport.unpark(t);
        t.join();
    }

    /**
     * park is released by unpark occurring before park
     */
    public void testPark2() throws InterruptedException {
        Thread t = new Thread(new CheckedRunnable() {
            public void realRun() throws InterruptedException {
                Thread.sleep(SHORT_DELAY_MS);
                LockSupport.park();
            }});

        t.start();
        LockSupport.unpark(t);
        t.join();
    }

    /**
     * park is released by interrupt
     */
    public void testPark3() throws InterruptedException {
        Thread t = new Thread(new CheckedRunnable() {
            public void realRun() {
                LockSupport.park();
            }});

        t.start();
        Thread.sleep(SHORT_DELAY_MS);
        t.interrupt();
        t.join();
    }

    /**
     * park returns if interrupted before park
     */
    public void testPark4() throws InterruptedException {
        final ReentrantLock lock = new ReentrantLock();
        lock.lock();
        Thread t = new Thread(new CheckedRunnable() {
            public void realRun() {
                lock.lock();
                LockSupport.park();
            }});

        t.start();
        t.interrupt();
        lock.unlock();
        t.join();
    }

    /**
     * parkNanos times out if not unparked
     */
    public void testParkNanos() throws InterruptedException {
        Thread t = new Thread(new CheckedRunnable() {
            public void realRun() {
                LockSupport.parkNanos(1000);
            }});

        t.start();
        t.join();
    }


    /**
     * parkUntil times out if not unparked
     */
    public void testParkUntil() throws InterruptedException {
        Thread t = new Thread(new CheckedRunnable() {
            public void realRun() {
                long d = new Date().getTime() + 100;
                LockSupport.parkUntil(d);
            }});

        t.start();
        t.join();
    }
}
Revision:	1.11
Committed:	Tue Nov 17 12:46:10 2009 UTC (14 years, 6 months ago) by jsr166
Branch:	MAIN
Changes since 1.10:	+58 -112 lines
Log Message:	cleanup exception handling; use CheckedRunnable
#	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() throws InterruptedException {
26	Thread t = new Thread(new CheckedRunnable() {
27	public void realRun() {
28	LockSupport.park();
29	}});
30
31	t.start();
32	Thread.sleep(SHORT_DELAY_MS);
33	LockSupport.unpark(t);
34	t.join();
35	}
36
37	/**
38	* park is released by unpark occurring before park
39	*/
40	public void testPark2() throws InterruptedException {
41	Thread t = new Thread(new CheckedRunnable() {
42	public void realRun() throws InterruptedException {
43	Thread.sleep(SHORT_DELAY_MS);
44	LockSupport.park();
45	}});
46
47	t.start();
48	LockSupport.unpark(t);
49	t.join();
50	}
51
52	/**
53	* park is released by interrupt
54	*/
55	public void testPark3() throws InterruptedException {
56	Thread t = new Thread(new CheckedRunnable() {
57	public void realRun() {
58	LockSupport.park();
59	}});
60
61	t.start();
62	Thread.sleep(SHORT_DELAY_MS);
63	t.interrupt();
64	t.join();
65	}
66
67	/**
68	* park returns if interrupted before park
69	*/
70	public void testPark4() throws InterruptedException {
71	final ReentrantLock lock = new ReentrantLock();
72	lock.lock();
73	Thread t = new Thread(new CheckedRunnable() {
74	public void realRun() {
75	lock.lock();
76	LockSupport.park();
77	}});
78
79	t.start();
80	t.interrupt();
81	lock.unlock();
82	t.join();
83	}
84
85	/**
86	* parkNanos times out if not unparked
87	*/
88	public void testParkNanos() throws InterruptedException {
89	Thread t = new Thread(new CheckedRunnable() {
90	public void realRun() {
91	LockSupport.parkNanos(1000);
92	}});
93
94	t.start();
95	t.join();
96	}
97
98
99	/**
100	* parkUntil times out if not unparked
101	*/
102	public void testParkUntil() throws InterruptedException {
103	Thread t = new Thread(new CheckedRunnable() {
104	public void realRun() {
105	long d = new Date().getTime() + 100;
106	LockSupport.parkUntil(d);
107	}});
108
109	t.start();
110	t.join();
111	}
112	}