test/tck/ExchangerTest.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.*;

public class ExchangerTest extends JSR166TestCase {

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

    /**
     * exchange exchanges objects across two threads
     */
    public void testExchange() {
        final Exchanger e = new Exchanger();
        Thread t1 = new Thread(new Runnable() {
                public void run() {
                    try {
                        Object v = e.exchange(one);
                        threadAssertEquals(v, two);
                        Object w = e.exchange(v);
                        threadAssertEquals(w, one);
                    } catch (InterruptedException e) {
                        threadUnexpectedException();
                    }
                }
            });
        Thread t2 = new Thread(new Runnable() {
                public void run() {
                    try {
                        Object v = e.exchange(two);
                        threadAssertEquals(v, one);
                        Object w = e.exchange(v);
                        threadAssertEquals(w, two);
                    } catch (InterruptedException e) {
                        threadUnexpectedException();
                    }
                }
            });
        try {
            t1.start();
            t2.start();
            t1.join();
            t2.join();
        } catch (InterruptedException ex) {
            unexpectedException();
        }
    }

    /**
     * timed exchange exchanges objects across two threads
     */
    public void testTimedExchange() {
        final Exchanger e = new Exchanger();
        Thread t1 = new Thread(new Runnable() {
                public void run() {
                    try {
                        Object v = e.exchange(one, SHORT_DELAY_MS, TimeUnit.MILLISECONDS);
                        threadAssertEquals(v, two);
                        Object w = e.exchange(v, SHORT_DELAY_MS, TimeUnit.MILLISECONDS);
                        threadAssertEquals(w, one);
                    } catch (InterruptedException e) {
                        threadUnexpectedException();
                    } catch (TimeoutException toe) {
                        threadUnexpectedException();
                    }
                }
            });
        Thread t2 = new Thread(new Runnable() {
                public void run() {
                    try {
                        Object v = e.exchange(two, SHORT_DELAY_MS, TimeUnit.MILLISECONDS);
                        threadAssertEquals(v, one);
                        Object w = e.exchange(v, SHORT_DELAY_MS, TimeUnit.MILLISECONDS);
                        threadAssertEquals(w, two);
                    } catch (InterruptedException e) {
                        threadUnexpectedException();
                    } catch (TimeoutException toe) {
                        threadUnexpectedException();
                    }
                }
            });
        try {
            t1.start();
            t2.start();
            t1.join();
            t2.join();
        } catch (InterruptedException ex) {
            unexpectedException();
        }
    }

    /**
     * interrupt during wait for exchange throws IE
     */
    public void testExchange_InterruptedException() {
        final Exchanger e = new Exchanger();
        Thread t = new Thread(new Runnable() {
                public void run() {
                    try {
                        e.exchange(one);
                        threadShouldThrow();
                    } catch (InterruptedException success) {
                    }
                }
            });
        try {
            t.start();
            Thread.sleep(SHORT_DELAY_MS);
            t.interrupt();
            t.join();
        } catch (InterruptedException ex) {
            unexpectedException();
        }
    }

    /**
     * interrupt during wait for timed exchange throws IE
     */
    public void testTimedExchange_InterruptedException() {
        final Exchanger e = new Exchanger();
        Thread t = new Thread(new Runnable() {
                public void run() {
                    try {
                        e.exchange(null, MEDIUM_DELAY_MS, TimeUnit.MILLISECONDS);
                        threadShouldThrow();
                    } catch (InterruptedException success) {
                    } catch (Exception e2) {
                        threadFail("should throw IE");
                    }
                }
            });
        try {
            t.start();
            t.interrupt();
            t.join();
        } catch (InterruptedException ex) {
            unexpectedException();
        }
    }

    /**
     * timeout during wait for timed exchange throws TOE
     */
    public void testExchange_TimeOutException() {
        final Exchanger e = new Exchanger();
        Thread t = new Thread(new Runnable() {
                public void run() {
                    try {
                        e.exchange(null, SHORT_DELAY_MS, TimeUnit.MILLISECONDS);
                        threadShouldThrow();
                    } catch (TimeoutException success) {
                    } catch (InterruptedException e2) {
                        threadFail("should throw TOE");
                    }
                }
            });
        try {
            t.start();
            t.join();
        } catch (InterruptedException ex) {
            unexpectedException();
        }
    }

    /**
     * If one exchanging thread is interrupted, another succeeds.
     */
    public void testReplacementAfterExchange() {
        final Exchanger e = new Exchanger();
        Thread t1 = new Thread(new Runnable() {
                public void run() {
                    try {
                        Object v = e.exchange(one);
                        threadAssertEquals(v, two);
                        Object w = e.exchange(v);
                        threadShouldThrow();
                    } catch (InterruptedException success) {
                    }
                }
            });
        Thread t2 = new Thread(new Runnable() {
                public void run() {
                    try {
                        Object v = e.exchange(two);
                        threadAssertEquals(v, one);
                        Thread.sleep(SMALL_DELAY_MS);
                        Object w = e.exchange(v);
                        threadAssertEquals(w, three);
                    } catch (InterruptedException e) {
                        threadUnexpectedException();
                    }
                }
            });
        Thread t3 = new Thread(new Runnable() {
                public void run() {
                    try {
                        Thread.sleep(SMALL_DELAY_MS);
                        Object w = e.exchange(three);
                        threadAssertEquals(w, one);
                    } catch (InterruptedException e) {
                        threadUnexpectedException();
                    }
                }
            });

        try {
            t1.start();
            t2.start();
            t3.start();
            Thread.sleep(SHORT_DELAY_MS);
            t1.interrupt();
            t1.join();
            t2.join();
            t3.join();
        } catch (InterruptedException ex) {
            unexpectedException();
        }
    }

}
Revision:	1.8
Committed:	Mon Nov 16 05:30:07 2009 UTC (14 years, 6 months ago) by jsr166
Branch:	MAIN
Changes since 1.7:	+34 -34 lines
Log Message:	whitespace
#	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
13	public class ExchangerTest extends JSR166TestCase {
14
15	public static void main(String[] args) {
16	junit.textui.TestRunner.run (suite());
17	}
18	public static Test suite() {
19	return new TestSuite(ExchangerTest.class);
20	}
21
22	/**
23	* exchange exchanges objects across two threads
24	*/
25	public void testExchange() {
26	final Exchanger e = new Exchanger();
27	Thread t1 = new Thread(new Runnable() {
28	public void run() {
29	try {
30	Object v = e.exchange(one);
31	threadAssertEquals(v, two);
32	Object w = e.exchange(v);
33	threadAssertEquals(w, one);
34	} catch (InterruptedException e) {
35	threadUnexpectedException();
36	}
37	}
38	});
39	Thread t2 = new Thread(new Runnable() {
40	public void run() {
41	try {
42	Object v = e.exchange(two);
43	threadAssertEquals(v, one);
44	Object w = e.exchange(v);
45	threadAssertEquals(w, two);
46	} catch (InterruptedException e) {
47	threadUnexpectedException();
48	}
49	}
50	});
51	try {
52	t1.start();
53	t2.start();
54	t1.join();
55	t2.join();
56	} catch (InterruptedException ex) {
57	unexpectedException();
58	}
59	}
60
61	/**
62	* timed exchange exchanges objects across two threads
63	*/
64	public void testTimedExchange() {
65	final Exchanger e = new Exchanger();
66	Thread t1 = new Thread(new Runnable() {
67	public void run() {
68	try {
69	Object v = e.exchange(one, SHORT_DELAY_MS, TimeUnit.MILLISECONDS);
70	threadAssertEquals(v, two);
71	Object w = e.exchange(v, SHORT_DELAY_MS, TimeUnit.MILLISECONDS);
72	threadAssertEquals(w, one);
73	} catch (InterruptedException e) {
74	threadUnexpectedException();
75	} catch (TimeoutException toe) {
76	threadUnexpectedException();
77	}
78	}
79	});
80	Thread t2 = new Thread(new Runnable() {
81	public void run() {
82	try {
83	Object v = e.exchange(two, SHORT_DELAY_MS, TimeUnit.MILLISECONDS);
84	threadAssertEquals(v, one);
85	Object w = e.exchange(v, SHORT_DELAY_MS, TimeUnit.MILLISECONDS);
86	threadAssertEquals(w, two);
87	} catch (InterruptedException e) {
88	threadUnexpectedException();
89	} catch (TimeoutException toe) {
90	threadUnexpectedException();
91	}
92	}
93	});
94	try {
95	t1.start();
96	t2.start();
97	t1.join();
98	t2.join();
99	} catch (InterruptedException ex) {
100	unexpectedException();
101	}
102	}
103
104	/**
105	* interrupt during wait for exchange throws IE
106	*/
107	public void testExchange_InterruptedException() {
108	final Exchanger e = new Exchanger();
109	Thread t = new Thread(new Runnable() {
110	public void run() {
111	try {
112	e.exchange(one);
113	threadShouldThrow();
114	} catch (InterruptedException success) {
115	}
116	}
117	});
118	try {
119	t.start();
120	Thread.sleep(SHORT_DELAY_MS);
121	t.interrupt();
122	t.join();
123	} catch (InterruptedException ex) {
124	unexpectedException();
125	}
126	}
127
128	/**
129	* interrupt during wait for timed exchange throws IE
130	*/
131	public void testTimedExchange_InterruptedException() {
132	final Exchanger e = new Exchanger();
133	Thread t = new Thread(new Runnable() {
134	public void run() {
135	try {
136	e.exchange(null, MEDIUM_DELAY_MS, TimeUnit.MILLISECONDS);
137	threadShouldThrow();
138	} catch (InterruptedException success) {
139	} catch (Exception e2) {
140	threadFail("should throw IE");
141	}
142	}
143	});
144	try {
145	t.start();
146	t.interrupt();
147	t.join();
148	} catch (InterruptedException ex) {
149	unexpectedException();
150	}
151	}
152
153	/**
154	* timeout during wait for timed exchange throws TOE
155	*/
156	public void testExchange_TimeOutException() {
157	final Exchanger e = new Exchanger();
158	Thread t = new Thread(new Runnable() {
159	public void run() {
160	try {
161	e.exchange(null, SHORT_DELAY_MS, TimeUnit.MILLISECONDS);
162	threadShouldThrow();
163	} catch (TimeoutException success) {
164	} catch (InterruptedException e2) {
165	threadFail("should throw TOE");
166	}
167	}
168	});
169	try {
170	t.start();
171	t.join();
172	} catch (InterruptedException ex) {
173	unexpectedException();
174	}
175	}
176
177	/**
178	* If one exchanging thread is interrupted, another succeeds.
179	*/
180	public void testReplacementAfterExchange() {
181	final Exchanger e = new Exchanger();
182	Thread t1 = new Thread(new Runnable() {
183	public void run() {
184	try {
185	Object v = e.exchange(one);
186	threadAssertEquals(v, two);
187	Object w = e.exchange(v);
188	threadShouldThrow();
189	} catch (InterruptedException success) {
190	}
191	}
192	});
193	Thread t2 = new Thread(new Runnable() {
194	public void run() {
195	try {
196	Object v = e.exchange(two);
197	threadAssertEquals(v, one);
198	Thread.sleep(SMALL_DELAY_MS);
199	Object w = e.exchange(v);
200	threadAssertEquals(w, three);
201	} catch (InterruptedException e) {
202	threadUnexpectedException();
203	}
204	}
205	});
206	Thread t3 = new Thread(new Runnable() {
207	public void run() {
208	try {
209	Thread.sleep(SMALL_DELAY_MS);
210	Object w = e.exchange(three);
211	threadAssertEquals(w, one);
212	} catch (InterruptedException e) {
213	threadUnexpectedException();
214	}
215	}
216	});
217
218	try {
219	t1.start();
220	t2.start();
221	t3.start();
222	Thread.sleep(SHORT_DELAY_MS);
223	t1.interrupt();
224	t1.join();
225	t2.join();
226	t3.join();
227	} catch (InterruptedException ex) {
228	unexpectedException();
229	}
230	}
231
232	}