test/tck/LockSupportTest.java

/*
 * Written by Doug Lea and Martin Buchholz 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.atomic.AtomicBoolean;
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 subsequent unpark
     */
    public void testParkBeforeUnpark() throws InterruptedException {
        final CountDownLatch threadStarted = new CountDownLatch(1);
        Thread t = newStartedThread(new CheckedRunnable() {
            public void realRun() {
                threadStarted.countDown();
                LockSupport.park();
            }});

        threadStarted.await();
        Thread.sleep(SHORT_DELAY_MS);
        LockSupport.unpark(t);
        awaitTermination(t, MEDIUM_DELAY_MS);
    }

    /**
     * parkUntil is released by subsequent unpark
     */
    public void testParkUntilBeforeUnpark() throws InterruptedException {
        final CountDownLatch threadStarted = new CountDownLatch(1);
        Thread t = newStartedThread(new CheckedRunnable() {
            public void realRun() {
                long d = new Date().getTime() + LONG_DELAY_MS;
                long nanos = LONG_DELAY_MS * 1000L * 1000L;
                long t0 = System.nanoTime();
                threadStarted.countDown();
                LockSupport.parkUntil(d);
                assertTrue(System.nanoTime() - t0 < nanos);
            }});

        threadStarted.await();
        Thread.sleep(SHORT_DELAY_MS);
        LockSupport.unpark(t);
        awaitTermination(t, MEDIUM_DELAY_MS);
    }

    /**
     * parkNanos is released by subsequent unpark
     */
    public void testParkNanosBeforeUnpark() throws InterruptedException {
        final CountDownLatch threadStarted = new CountDownLatch(1);
        Thread t = newStartedThread(new CheckedRunnable() {
            public void realRun() {
                long nanos = LONG_DELAY_MS * 1000L * 1000L;
                long t0 = System.nanoTime();
                threadStarted.countDown();
                LockSupport.parkNanos(nanos);
                assertTrue(System.nanoTime() - t0 < nanos);
            }});

        threadStarted.await();
        Thread.sleep(SHORT_DELAY_MS);
        LockSupport.unpark(t);
        awaitTermination(t, MEDIUM_DELAY_MS);
    }

    /**
     * park is released by preceding unpark
     */
    public void testParkAfterUnpark() throws Exception {
        final CountDownLatch threadStarted = new CountDownLatch(1);
        final AtomicBoolean unparked = new AtomicBoolean(false);
        Thread t = newStartedThread(new CheckedRunnable() {
            public void realRun() throws Exception {
                threadStarted.countDown();
                while (!unparked.get())
                    Thread.yield();
                LockSupport.park();
            }});

        threadStarted.await();
        LockSupport.unpark(t);
        unparked.set(true);
        awaitTermination(t, MEDIUM_DELAY_MS);
    }

    /**
     * parkUntil is released by preceding unpark
     */
    public void testParkUntilAfterUnpark() throws Exception {
        final CountDownLatch threadStarted = new CountDownLatch(1);
        final AtomicBoolean unparked = new AtomicBoolean(false);
        Thread t = newStartedThread(new CheckedRunnable() {
            public void realRun() throws Exception {
                threadStarted.countDown();
                while (!unparked.get())
                    Thread.yield();
                long d = new Date().getTime() + LONG_DELAY_MS;
                long nanos = LONG_DELAY_MS * 1000L * 1000L;
                long t0 = System.nanoTime();
                LockSupport.parkUntil(d);
                assertTrue(System.nanoTime() - t0 < nanos);
            }});

        threadStarted.await();
        LockSupport.unpark(t);
        unparked.set(true);
        awaitTermination(t, MEDIUM_DELAY_MS);
    }

    /**
     * parkNanos is released by preceding unpark
     */
    public void testParkNanosAfterUnpark() throws Exception {
        final CountDownLatch threadStarted = new CountDownLatch(1);
        final AtomicBoolean unparked = new AtomicBoolean(false);
        Thread t = newStartedThread(new CheckedRunnable() {
            public void realRun() throws Exception {
                threadStarted.countDown();
                while (!unparked.get())
                    Thread.yield();
                long nanos = LONG_DELAY_MS * 1000L * 1000L;
                long t0 = System.nanoTime();
                LockSupport.parkNanos(nanos);
                assertTrue(System.nanoTime() - t0 < nanos);
            }});

        threadStarted.await();
        LockSupport.unpark(t);
        unparked.set(true);
        awaitTermination(t, MEDIUM_DELAY_MS);
    }

    /**
     * park is released by subsequent interrupt
     */
    public void testParkBeforeInterrupt() throws InterruptedException {
        final CountDownLatch threadStarted = new CountDownLatch(1);
        Thread t = newStartedThread(new CheckedRunnable() {
            public void realRun() {
                assertFalse(Thread.currentThread().isInterrupted());
                threadStarted.countDown();
                do {
                    LockSupport.park();
                    // park may return spuriously
                } while (! Thread.currentThread().isInterrupted());
            }});

        threadStarted.await();
        Thread.sleep(SHORT_DELAY_MS);
        t.interrupt();
        awaitTermination(t, MEDIUM_DELAY_MS);
    }

    /**
     * parkUntil is released by subsequent interrupt
     */
    public void testParkUntilBeforeInterrupt() throws InterruptedException {
        final CountDownLatch threadStarted = new CountDownLatch(1);
        Thread t = newStartedThread(new CheckedRunnable() {
            public void realRun() {
                long d = new Date().getTime() + LONG_DELAY_MS;
                long nanos = LONG_DELAY_MS * 1000L * 1000L;
                long t0 = System.nanoTime();
                assertFalse(Thread.currentThread().isInterrupted());
                threadStarted.countDown();
                do {
                    LockSupport.parkUntil(d);
                    // parkUntil may return spuriously
                } while (! Thread.currentThread().isInterrupted());
                assertTrue(System.nanoTime() - t0 < nanos);
            }});

        threadStarted.await();
        Thread.sleep(SHORT_DELAY_MS);
        t.interrupt();
        awaitTermination(t, MEDIUM_DELAY_MS);
    }

    /**
     * parkNanos is released by subsequent interrupt
     */
    public void testParkNanosBeforeInterrupt() throws InterruptedException {
        final CountDownLatch threadStarted = new CountDownLatch(1);
        Thread t = newStartedThread(new CheckedRunnable() {
            public void realRun() {
                long nanos = LONG_DELAY_MS * 1000L * 1000L;
                long t0 = System.nanoTime();
                assertFalse(Thread.currentThread().isInterrupted());
                threadStarted.countDown();
                do {
                    LockSupport.parkNanos(nanos);
                    // parkNanos may return spuriously
                } while (! Thread.currentThread().isInterrupted());
                assertTrue(System.nanoTime() - t0 < nanos);
            }});

        threadStarted.await();
        Thread.sleep(SHORT_DELAY_MS);
        t.interrupt();
        awaitTermination(t, MEDIUM_DELAY_MS);
    }

    /**
     * park is released by preceding interrupt
     */
    public void testParkAfterInterrupt() throws Exception {
        final CountDownLatch threadStarted = new CountDownLatch(1);
        final AtomicBoolean unparked = new AtomicBoolean(false);
        Thread t = newStartedThread(new CheckedRunnable() {
            public void realRun() throws Exception {
                threadStarted.countDown();
                while (!unparked.get())
                    Thread.yield();
                assertTrue(Thread.currentThread().isInterrupted());
                LockSupport.park();
                assertTrue(Thread.currentThread().isInterrupted());
            }});

        threadStarted.await();
        t.interrupt();
        unparked.set(true);
        awaitTermination(t, MEDIUM_DELAY_MS);
    }

    /**
     * parkUntil is released by preceding interrupt
     */
    public void testParkUntilAfterInterrupt() throws Exception {
        final CountDownLatch threadStarted = new CountDownLatch(1);
        final AtomicBoolean unparked = new AtomicBoolean(false);
        Thread t = newStartedThread(new CheckedRunnable() {
            public void realRun() throws Exception {
                threadStarted.countDown();
                while (!unparked.get())
                    Thread.yield();
                long d = new Date().getTime() + LONG_DELAY_MS;
                long nanos = LONG_DELAY_MS * 1000L * 1000L;
                long t0 = System.nanoTime();
                assertTrue(Thread.currentThread().isInterrupted());
                LockSupport.parkUntil(d);
                assertTrue(System.nanoTime() - t0 < nanos);
                assertTrue(Thread.currentThread().isInterrupted());
            }});

        threadStarted.await();
        t.interrupt();
        unparked.set(true);
        awaitTermination(t, MEDIUM_DELAY_MS);
    }

    /**
     * parkNanos is released by preceding interrupt
     */
    public void testParkNanosAfterInterrupt() throws Exception {
        final CountDownLatch threadStarted = new CountDownLatch(1);
        final AtomicBoolean unparked = new AtomicBoolean(false);
        Thread t = newStartedThread(new CheckedRunnable() {
            public void realRun() throws Exception {
                threadStarted.countDown();
                while (!unparked.get())
                    Thread.yield();
                long nanos = LONG_DELAY_MS * 1000L * 1000L;
                long t0 = System.nanoTime();
                assertTrue(Thread.currentThread().isInterrupted());
                LockSupport.parkNanos(nanos);
                assertTrue(System.nanoTime() - t0 < nanos);
                assertTrue(Thread.currentThread().isInterrupted());
            }});

        threadStarted.await();
        t.interrupt();
        unparked.set(true);
        awaitTermination(t, MEDIUM_DELAY_MS);
    }

    /**
     * parkNanos times out if not unparked
     */
    public void testParkNanosTimesOut() throws InterruptedException {
        Thread t = newStartedThread(new CheckedRunnable() {
            public void realRun() {
                for (;;) {
                    long timeoutNanos = SHORT_DELAY_MS * 1000L * 1000L;
                    long t0 = System.nanoTime();
                    LockSupport.parkNanos(timeoutNanos);
                    // parkNanos may return spuriously
                    if (System.nanoTime() - t0 >= timeoutNanos)
                        return;
                }
            }});

        awaitTermination(t, MEDIUM_DELAY_MS);
    }


    /**
     * parkUntil times out if not unparked
     */
    public void testParkUntilTimesOut() throws InterruptedException {
        Thread t = newStartedThread(new CheckedRunnable() {
            public void realRun() {
                for (;;) {
                    long d = new Date().getTime() + SHORT_DELAY_MS;
                    // beware of rounding
                    long timeoutNanos = (SHORT_DELAY_MS - 1) * 1000L * 1000L;
                    long t0 = System.nanoTime();
                    LockSupport.parkUntil(d);
                    // parkUntil may return spuriously
                    if (System.nanoTime() - t0 >= timeoutNanos)
                        return;
                }
            }});

        awaitTermination(t, MEDIUM_DELAY_MS);
    }

    /**
     * parkUntil(0) returns immediately
     * Requires hotspot fix for:
     * 6763959 java.util.concurrent.locks.LockSupport.parkUntil(0) blocks forever
     */
    public void XXXXtestParkUntil0Returns() throws InterruptedException {
        Thread t = newStartedThread(new CheckedRunnable() {
            public void realRun() {
                LockSupport.parkUntil(0L);
            }});

        awaitTermination(t, MEDIUM_DELAY_MS);
    }
}
Revision:	1.17
Committed:	Sun Oct 10 18:15:10 2010 UTC (13 years, 7 months ago) by jsr166
Branch:	MAIN
Changes since 1.16:	+36 -14 lines
Log Message:	take spurious wakeups into account
#	User	Rev	Content
1	dl	1.1	/*
2	jsr166	1.15	* Written by Doug Lea and Martin Buchholz with assistance from
3			* members of JCP JSR-166 Expert Group and released to the public
4			* domain, as explained at
5	dl	1.5	* http://creativecommons.org/licenses/publicdomain
6	jsr166	1.8	* Other contributors include Andrew Wright, Jeffrey Hayes,
7			* Pat Fisher, Mike Judd.
8	dl	1.1	*/
9
10			import junit.framework.*;
11			import java.util.*;
12			import java.util.concurrent.*;
13	jsr166	1.15	import java.util.concurrent.atomic.AtomicBoolean;
14	dl	1.1	import java.util.concurrent.locks.*;
15
16	jsr166	1.10	public class LockSupportTest extends JSR166TestCase {
17	dl	1.1	public static void main(String[] args) {
18	jsr166	1.14	junit.textui.TestRunner.run(suite());
19	dl	1.1	}
20	jsr166	1.15
21	dl	1.1	public static Test suite() {
22	jsr166	1.12	return new TestSuite(LockSupportTest.class);
23	dl	1.1	}
24
25	dl	1.3	/**
26	jsr166	1.15	* park is released by subsequent unpark
27	dl	1.3	*/
28	jsr166	1.15	public void testParkBeforeUnpark() throws InterruptedException {
29			final CountDownLatch threadStarted = new CountDownLatch(1);
30	jsr166	1.16	Thread t = newStartedThread(new CheckedRunnable() {
31	jsr166	1.12	public void realRun() {
32	jsr166	1.15	threadStarted.countDown();
33	jsr166	1.11	LockSupport.park();
34			}});
35
36	jsr166	1.15	threadStarted.await();
37			Thread.sleep(SHORT_DELAY_MS);
38			LockSupport.unpark(t);
39	jsr166	1.16	awaitTermination(t, MEDIUM_DELAY_MS);
40	jsr166	1.15	}
41
42			/**
43			* parkUntil is released by subsequent unpark
44			*/
45			public void testParkUntilBeforeUnpark() throws InterruptedException {
46			final CountDownLatch threadStarted = new CountDownLatch(1);
47	jsr166	1.16	Thread t = newStartedThread(new CheckedRunnable() {
48	jsr166	1.15	public void realRun() {
49			long d = new Date().getTime() + LONG_DELAY_MS;
50			long nanos = LONG_DELAY_MS * 1000L * 1000L;
51			long t0 = System.nanoTime();
52			threadStarted.countDown();
53			LockSupport.parkUntil(d);
54			assertTrue(System.nanoTime() - t0 < nanos);
55			}});
56
57			threadStarted.await();
58			Thread.sleep(SHORT_DELAY_MS);
59			LockSupport.unpark(t);
60	jsr166	1.16	awaitTermination(t, MEDIUM_DELAY_MS);
61	jsr166	1.15	}
62
63			/**
64			* parkNanos is released by subsequent unpark
65			*/
66			public void testParkNanosBeforeUnpark() throws InterruptedException {
67			final CountDownLatch threadStarted = new CountDownLatch(1);
68	jsr166	1.16	Thread t = newStartedThread(new CheckedRunnable() {
69	jsr166	1.15	public void realRun() {
70			long nanos = LONG_DELAY_MS * 1000L * 1000L;
71			long t0 = System.nanoTime();
72			threadStarted.countDown();
73			LockSupport.parkNanos(nanos);
74			assertTrue(System.nanoTime() - t0 < nanos);
75			}});
76
77			threadStarted.await();
78	jsr166	1.11	Thread.sleep(SHORT_DELAY_MS);
79			LockSupport.unpark(t);
80	jsr166	1.16	awaitTermination(t, MEDIUM_DELAY_MS);
81	dl	1.1	}
82
83	dl	1.3	/**
84	jsr166	1.15	* park is released by preceding unpark
85	dl	1.4	*/
86	jsr166	1.15	public void testParkAfterUnpark() throws Exception {
87			final CountDownLatch threadStarted = new CountDownLatch(1);
88			final AtomicBoolean unparked = new AtomicBoolean(false);
89	jsr166	1.16	Thread t = newStartedThread(new CheckedRunnable() {
90	jsr166	1.15	public void realRun() throws Exception {
91			threadStarted.countDown();
92			while (!unparked.get())
93			Thread.yield();
94	jsr166	1.11	LockSupport.park();
95			}});
96
97	jsr166	1.15	threadStarted.await();
98	jsr166	1.11	LockSupport.unpark(t);
99	jsr166	1.15	unparked.set(true);
100	jsr166	1.16	awaitTermination(t, MEDIUM_DELAY_MS);
101	dl	1.4	}
102
103			/**
104	jsr166	1.15	* parkUntil is released by preceding unpark
105	dl	1.4	*/
106	jsr166	1.15	public void testParkUntilAfterUnpark() throws Exception {
107			final CountDownLatch threadStarted = new CountDownLatch(1);
108			final AtomicBoolean unparked = new AtomicBoolean(false);
109	jsr166	1.16	Thread t = newStartedThread(new CheckedRunnable() {
110	jsr166	1.15	public void realRun() throws Exception {
111			threadStarted.countDown();
112			while (!unparked.get())
113			Thread.yield();
114			long d = new Date().getTime() + LONG_DELAY_MS;
115			long nanos = LONG_DELAY_MS * 1000L * 1000L;
116			long t0 = System.nanoTime();
117			LockSupport.parkUntil(d);
118			assertTrue(System.nanoTime() - t0 < nanos);
119			}});
120
121			threadStarted.await();
122			LockSupport.unpark(t);
123			unparked.set(true);
124	jsr166	1.16	awaitTermination(t, MEDIUM_DELAY_MS);
125	jsr166	1.15	}
126
127			/**
128			* parkNanos is released by preceding unpark
129			*/
130			public void testParkNanosAfterUnpark() throws Exception {
131			final CountDownLatch threadStarted = new CountDownLatch(1);
132			final AtomicBoolean unparked = new AtomicBoolean(false);
133	jsr166	1.16	Thread t = newStartedThread(new CheckedRunnable() {
134	jsr166	1.15	public void realRun() throws Exception {
135			threadStarted.countDown();
136			while (!unparked.get())
137			Thread.yield();
138			long nanos = LONG_DELAY_MS * 1000L * 1000L;
139			long t0 = System.nanoTime();
140			LockSupport.parkNanos(nanos);
141			assertTrue(System.nanoTime() - t0 < nanos);
142			}});
143
144			threadStarted.await();
145			LockSupport.unpark(t);
146			unparked.set(true);
147	jsr166	1.16	awaitTermination(t, MEDIUM_DELAY_MS);
148	jsr166	1.15	}
149
150			/**
151			* park is released by subsequent interrupt
152			*/
153			public void testParkBeforeInterrupt() throws InterruptedException {
154			final CountDownLatch threadStarted = new CountDownLatch(1);
155	jsr166	1.16	Thread t = newStartedThread(new CheckedRunnable() {
156	jsr166	1.12	public void realRun() {
157	jsr166	1.15	assertFalse(Thread.currentThread().isInterrupted());
158			threadStarted.countDown();
159	jsr166	1.17	do {
160			LockSupport.park();
161			// park may return spuriously
162			} while (! Thread.currentThread().isInterrupted());
163	jsr166	1.15	}});
164
165			threadStarted.await();
166			Thread.sleep(SHORT_DELAY_MS);
167			t.interrupt();
168	jsr166	1.16	awaitTermination(t, MEDIUM_DELAY_MS);
169	jsr166	1.15	}
170
171			/**
172			* parkUntil is released by subsequent interrupt
173			*/
174			public void testParkUntilBeforeInterrupt() throws InterruptedException {
175			final CountDownLatch threadStarted = new CountDownLatch(1);
176	jsr166	1.16	Thread t = newStartedThread(new CheckedRunnable() {
177	jsr166	1.15	public void realRun() {
178			long d = new Date().getTime() + LONG_DELAY_MS;
179			long nanos = LONG_DELAY_MS * 1000L * 1000L;
180			long t0 = System.nanoTime();
181	jsr166	1.17	assertFalse(Thread.currentThread().isInterrupted());
182	jsr166	1.15	threadStarted.countDown();
183	jsr166	1.17	do {
184			LockSupport.parkUntil(d);
185			// parkUntil may return spuriously
186			} while (! Thread.currentThread().isInterrupted());
187	jsr166	1.15	assertTrue(System.nanoTime() - t0 < nanos);
188	jsr166	1.11	}});
189
190	jsr166	1.15	threadStarted.await();
191	jsr166	1.11	Thread.sleep(SHORT_DELAY_MS);
192			t.interrupt();
193	jsr166	1.16	awaitTermination(t, MEDIUM_DELAY_MS);
194	dl	1.4	}
195
196			/**
197	jsr166	1.15	* parkNanos is released by subsequent interrupt
198	dl	1.4	*/
199	jsr166	1.15	public void testParkNanosBeforeInterrupt() throws InterruptedException {
200			final CountDownLatch threadStarted = new CountDownLatch(1);
201	jsr166	1.16	Thread t = newStartedThread(new CheckedRunnable() {
202	jsr166	1.12	public void realRun() {
203	jsr166	1.15	long nanos = LONG_DELAY_MS * 1000L * 1000L;
204			long t0 = System.nanoTime();
205	jsr166	1.17	assertFalse(Thread.currentThread().isInterrupted());
206	jsr166	1.15	threadStarted.countDown();
207	jsr166	1.17	do {
208			LockSupport.parkNanos(nanos);
209			// parkNanos may return spuriously
210			} while (! Thread.currentThread().isInterrupted());
211	jsr166	1.15	assertTrue(System.nanoTime() - t0 < nanos);
212			}});
213
214			threadStarted.await();
215			Thread.sleep(SHORT_DELAY_MS);
216			t.interrupt();
217	jsr166	1.16	awaitTermination(t, MEDIUM_DELAY_MS);
218	jsr166	1.15	}
219
220			/**
221			* park is released by preceding interrupt
222			*/
223			public void testParkAfterInterrupt() throws Exception {
224			final CountDownLatch threadStarted = new CountDownLatch(1);
225			final AtomicBoolean unparked = new AtomicBoolean(false);
226	jsr166	1.16	Thread t = newStartedThread(new CheckedRunnable() {
227	jsr166	1.15	public void realRun() throws Exception {
228			threadStarted.countDown();
229			while (!unparked.get())
230			Thread.yield();
231			assertTrue(Thread.currentThread().isInterrupted());
232	jsr166	1.11	LockSupport.park();
233	jsr166	1.15	assertTrue(Thread.currentThread().isInterrupted());
234			}});
235
236			threadStarted.await();
237			t.interrupt();
238			unparked.set(true);
239	jsr166	1.16	awaitTermination(t, MEDIUM_DELAY_MS);
240	jsr166	1.15	}
241
242			/**
243			* parkUntil is released by preceding interrupt
244			*/
245			public void testParkUntilAfterInterrupt() throws Exception {
246			final CountDownLatch threadStarted = new CountDownLatch(1);
247			final AtomicBoolean unparked = new AtomicBoolean(false);
248	jsr166	1.16	Thread t = newStartedThread(new CheckedRunnable() {
249	jsr166	1.15	public void realRun() throws Exception {
250			threadStarted.countDown();
251			while (!unparked.get())
252			Thread.yield();
253			long d = new Date().getTime() + LONG_DELAY_MS;
254			long nanos = LONG_DELAY_MS * 1000L * 1000L;
255			long t0 = System.nanoTime();
256	jsr166	1.17	assertTrue(Thread.currentThread().isInterrupted());
257	jsr166	1.15	LockSupport.parkUntil(d);
258			assertTrue(System.nanoTime() - t0 < nanos);
259	jsr166	1.17	assertTrue(Thread.currentThread().isInterrupted());
260	jsr166	1.15	}});
261
262			threadStarted.await();
263			t.interrupt();
264			unparked.set(true);
265	jsr166	1.16	awaitTermination(t, MEDIUM_DELAY_MS);
266	jsr166	1.15	}
267
268			/**
269			* parkNanos is released by preceding interrupt
270			*/
271			public void testParkNanosAfterInterrupt() throws Exception {
272			final CountDownLatch threadStarted = new CountDownLatch(1);
273			final AtomicBoolean unparked = new AtomicBoolean(false);
274	jsr166	1.16	Thread t = newStartedThread(new CheckedRunnable() {
275	jsr166	1.15	public void realRun() throws Exception {
276			threadStarted.countDown();
277			while (!unparked.get())
278			Thread.yield();
279			long nanos = LONG_DELAY_MS * 1000L * 1000L;
280			long t0 = System.nanoTime();
281	jsr166	1.17	assertTrue(Thread.currentThread().isInterrupted());
282	jsr166	1.15	LockSupport.parkNanos(nanos);
283			assertTrue(System.nanoTime() - t0 < nanos);
284	jsr166	1.17	assertTrue(Thread.currentThread().isInterrupted());
285	jsr166	1.11	}});
286
287	jsr166	1.15	threadStarted.await();
288	jsr166	1.11	t.interrupt();
289	jsr166	1.15	unparked.set(true);
290	jsr166	1.16	awaitTermination(t, MEDIUM_DELAY_MS);
291	dl	1.4	}
292
293			/**
294			* parkNanos times out if not unparked
295	dl	1.3	*/
296	jsr166	1.15	public void testParkNanosTimesOut() throws InterruptedException {
297	jsr166	1.16	Thread t = newStartedThread(new CheckedRunnable() {
298	jsr166	1.12	public void realRun() {
299	jsr166	1.17	for (;;) {
300			long timeoutNanos = SHORT_DELAY_MS * 1000L * 1000L;
301			long t0 = System.nanoTime();
302			LockSupport.parkNanos(timeoutNanos);
303			// parkNanos may return spuriously
304			if (System.nanoTime() - t0 >= timeoutNanos)
305			return;
306			}
307	jsr166	1.11	}});
308
309	jsr166	1.16	awaitTermination(t, MEDIUM_DELAY_MS);
310	dl	1.1	}
311
312
313	dl	1.3	/**
314	dl	1.4	* parkUntil times out if not unparked
315	dl	1.3	*/
316	jsr166	1.15	public void testParkUntilTimesOut() throws InterruptedException {
317	jsr166	1.16	Thread t = newStartedThread(new CheckedRunnable() {
318	jsr166	1.12	public void realRun() {
319	jsr166	1.17	for (;;) {
320			long d = new Date().getTime() + SHORT_DELAY_MS;
321			// beware of rounding
322			long timeoutNanos = (SHORT_DELAY_MS - 1) * 1000L * 1000L;
323			long t0 = System.nanoTime();
324			LockSupport.parkUntil(d);
325			// parkUntil may return spuriously
326			if (System.nanoTime() - t0 >= timeoutNanos)
327			return;
328			}
329	jsr166	1.15	}});
330
331	jsr166	1.16	awaitTermination(t, MEDIUM_DELAY_MS);
332	jsr166	1.15	}
333
334			/**
335			* parkUntil(0) returns immediately
336			* Requires hotspot fix for:
337			* 6763959 java.util.concurrent.locks.LockSupport.parkUntil(0) blocks forever
338			*/
339	jsr166	1.16	public void XXXXtestParkUntil0Returns() throws InterruptedException {
340			Thread t = newStartedThread(new CheckedRunnable() {
341	jsr166	1.15	public void realRun() {
342			LockSupport.parkUntil(0L);
343	jsr166	1.11	}});
344
345	jsr166	1.16	awaitTermination(t, MEDIUM_DELAY_MS);
346	dl	1.1	}
347			}