ViewVC Help

View File | Revision Log | Show Annotations | Download File | Root Listing

root/jsr166/jsr166/src/test/tck/LockSupportTest.java

Comparing jsr166/src/test/tck/LockSupportTest.java (file contents):
Revision 1.1 by dl, Sun Aug 31 19:24:55 2003 UTC vs.
Revision 1.5 by dl, Sat Dec 27 19:26:43 2003 UTC

#	Line 1 | Line 1
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.
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.*;
#	Line 10 | Line 11 | import java.util.*;
11		import java.util.concurrent.*;
12		import java.util.concurrent.locks.*;
13
14	<	public class LockSupportTest extends TestCase{
14	<
14	>	public class LockSupportTest extends JSR166TestCase{
15		public static void main(String[] args) {
16		junit.textui.TestRunner.run (suite());
17		}
18	–
19	–
18		public static Test suite() {
19		return new TestSuite(LockSupportTest.class);
20		}
21
22	<	public void testUnpark() {
23	<	Thread t = new Thread(new Runnable(){
24	<	public void run(){
25	<	try{
22	>	/**
23	>	* park is released by unpark occuring 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 occuring 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	<	fail("unexpected exception");
55	>	} catch(Exception e){
56	>	threadUnexpectedException();
57		}
58		}
59		});
60	<	t.start();
61	<	try{
60	>	try {
61	>	t.start();
62		LockSupport.unpark(t);
63		t.join();
64		}
65		catch(Exception e) {
66	<	fail("unexpected exception");
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{
126	>	Thread t = new Thread(new Runnable() {
127	>	public void run() {
128	>	try {
129		LockSupport.parkNanos(1000);
130	<	}catch(Exception e){
131	<	fail("unexpected exception");
130	>	} catch(Exception e){
131	>	threadUnexpectedException();
132		}
133		}
134		});
135	<	try{
135	>	try {
136		t.start();
137		t.join();
138		}
139		catch(Exception e) {
140	<	fail("unexpected exception");
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{
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	<	fail("unexpected exception");
154	>	} catch(Exception e){
155	>	threadUnexpectedException();
156		}
157		}
158		});
159	<	try{
159	>	try {
160		t.start();
161		t.join();
162		}
163		catch(Exception e) {
164	<	fail("unexpected exception");
164	>	unexpectedException();
165		}
166		}
83	–
84	–
167		}

Diff Legend

–	Removed lines
+	Added lines
<	Changed lines
>	Changed lines