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.*;
import static java.util.concurrent.TimeUnit.MILLISECONDS;

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() throws InterruptedException {
        final Exchanger e = new Exchanger();
        Thread t1 = new Thread(new CheckedRunnable() {
            public void realRun() throws InterruptedException {
                Object v = e.exchange(one);
                threadAssertEquals(v, two);
                Object w = e.exchange(v);
                threadAssertEquals(w, one);
            }});
        Thread t2 = new Thread(new CheckedRunnable() {
            public void realRun() throws InterruptedException {
                Object v = e.exchange(two);
                threadAssertEquals(v, one);
                Object w = e.exchange(v);
                threadAssertEquals(w, two);
            }});

        t1.start();
        t2.start();
        t1.join();
        t2.join();
    }

    /**
     * timed exchange exchanges objects across two threads
     */
    public void testTimedExchange() throws InterruptedException {
        final Exchanger e = new Exchanger();
        Thread t1 = new Thread(new CheckedRunnable() {
            public void realRun() throws Exception {
                Object v = e.exchange(one, SHORT_DELAY_MS, MILLISECONDS);
                threadAssertEquals(v, two);
                Object w = e.exchange(v, SHORT_DELAY_MS, MILLISECONDS);
                threadAssertEquals(w, one);
            }});
        Thread t2 = new Thread(new CheckedRunnable() {
            public void realRun() throws Exception {
                Object v = e.exchange(two, SHORT_DELAY_MS, MILLISECONDS);
                threadAssertEquals(v, one);
                Object w = e.exchange(v, SHORT_DELAY_MS, MILLISECONDS);
                threadAssertEquals(w, two);
            }});

        t1.start();
        t2.start();
        t1.join();
        t2.join();
    }

    /**
     * interrupt during wait for exchange throws IE
     */
    public void testExchange_InterruptedException() throws InterruptedException {
        final Exchanger e = new Exchanger();
        Thread t = new Thread(new CheckedInterruptedRunnable() {
            public void realRun() throws InterruptedException {
                e.exchange(one);
            }});

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

    /**
     * interrupt during wait for timed exchange throws IE
     */
    public void testTimedExchange_InterruptedException() throws InterruptedException {
        final Exchanger e = new Exchanger();
        Thread t = new Thread(new CheckedInterruptedRunnable() {
            public void realRun() throws Exception {
                e.exchange(null, MEDIUM_DELAY_MS, MILLISECONDS);
            }});

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

    /**
     * timeout during wait for timed exchange throws TOE
     */
    public void testExchange_TimeOutException() throws InterruptedException {
        final Exchanger e = new Exchanger();
        Thread t = new Thread(new CheckedRunnable() {
            public void realRun() throws Exception {
                try {
                    e.exchange(null, SHORT_DELAY_MS, MILLISECONDS);
                    threadShouldThrow();
                } catch (TimeoutException success) {}
            }});

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

    /**
     * If one exchanging thread is interrupted, another succeeds.
     */
    public void testReplacementAfterExchange() throws InterruptedException {
        final Exchanger e = new Exchanger();
        Thread t1 = new Thread(new CheckedInterruptedRunnable() {
            public void realRun() throws InterruptedException {
                Object v = e.exchange(one);
                threadAssertEquals(v, two);
                Object w = e.exchange(v);
            }});
        Thread t2 = new Thread(new CheckedRunnable() {
            public void realRun() throws InterruptedException {
                Object v = e.exchange(two);
                threadAssertEquals(v, one);
                Thread.sleep(SMALL_DELAY_MS);
                Object w = e.exchange(v);
                threadAssertEquals(w, three);
            }});
        Thread t3 = new Thread(new CheckedRunnable() {
            public void realRun() throws InterruptedException {
                Thread.sleep(SMALL_DELAY_MS);
                Object w = e.exchange(three);
                threadAssertEquals(w, one);
            }});

        t1.start();
        t2.start();
        t3.start();
        Thread.sleep(SHORT_DELAY_MS);
        t1.interrupt();
        t1.join();
        t2.join();
        t3.join();
    }

}
Revision:	1.11
Committed:	Sat Nov 21 02:33:20 2009 UTC (14 years, 6 months ago) by jsr166
Branch:	MAIN
Changes since 1.10:	+7 -6 lines
Log Message:	import static TimeUnit.MILLISECONDS
#	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 static java.util.concurrent.TimeUnit.MILLISECONDS;
13
14	public class ExchangerTest extends JSR166TestCase {
15
16	public static void main(String[] args) {
17	junit.textui.TestRunner.run (suite());
18	}
19	public static Test suite() {
20	return new TestSuite(ExchangerTest.class);
21	}
22
23	/**
24	* exchange exchanges objects across two threads
25	*/
26	public void testExchange() throws InterruptedException {
27	final Exchanger e = new Exchanger();
28	Thread t1 = new Thread(new CheckedRunnable() {
29	public void realRun() throws InterruptedException {
30	Object v = e.exchange(one);
31	threadAssertEquals(v, two);
32	Object w = e.exchange(v);
33	threadAssertEquals(w, one);
34	}});
35	Thread t2 = new Thread(new CheckedRunnable() {
36	public void realRun() throws InterruptedException {
37	Object v = e.exchange(two);
38	threadAssertEquals(v, one);
39	Object w = e.exchange(v);
40	threadAssertEquals(w, two);
41	}});
42
43	t1.start();
44	t2.start();
45	t1.join();
46	t2.join();
47	}
48
49	/**
50	* timed exchange exchanges objects across two threads
51	*/
52	public void testTimedExchange() throws InterruptedException {
53	final Exchanger e = new Exchanger();
54	Thread t1 = new Thread(new CheckedRunnable() {
55	public void realRun() throws Exception {
56	Object v = e.exchange(one, SHORT_DELAY_MS, MILLISECONDS);
57	threadAssertEquals(v, two);
58	Object w = e.exchange(v, SHORT_DELAY_MS, MILLISECONDS);
59	threadAssertEquals(w, one);
60	}});
61	Thread t2 = new Thread(new CheckedRunnable() {
62	public void realRun() throws Exception {
63	Object v = e.exchange(two, SHORT_DELAY_MS, MILLISECONDS);
64	threadAssertEquals(v, one);
65	Object w = e.exchange(v, SHORT_DELAY_MS, MILLISECONDS);
66	threadAssertEquals(w, two);
67	}});
68
69	t1.start();
70	t2.start();
71	t1.join();
72	t2.join();
73	}
74
75	/**
76	* interrupt during wait for exchange throws IE
77	*/
78	public void testExchange_InterruptedException() throws InterruptedException {
79	final Exchanger e = new Exchanger();
80	Thread t = new Thread(new CheckedInterruptedRunnable() {
81	public void realRun() throws InterruptedException {
82	e.exchange(one);
83	}});
84
85	t.start();
86	Thread.sleep(SHORT_DELAY_MS);
87	t.interrupt();
88	t.join();
89	}
90
91	/**
92	* interrupt during wait for timed exchange throws IE
93	*/
94	public void testTimedExchange_InterruptedException() throws InterruptedException {
95	final Exchanger e = new Exchanger();
96	Thread t = new Thread(new CheckedInterruptedRunnable() {
97	public void realRun() throws Exception {
98	e.exchange(null, MEDIUM_DELAY_MS, MILLISECONDS);
99	}});
100
101	t.start();
102	t.interrupt();
103	t.join();
104	}
105
106	/**
107	* timeout during wait for timed exchange throws TOE
108	*/
109	public void testExchange_TimeOutException() throws InterruptedException {
110	final Exchanger e = new Exchanger();
111	Thread t = new Thread(new CheckedRunnable() {
112	public void realRun() throws Exception {
113	try {
114	e.exchange(null, SHORT_DELAY_MS, MILLISECONDS);
115	threadShouldThrow();
116	} catch (TimeoutException success) {}
117	}});
118
119	t.start();
120	t.join();
121	}
122
123	/**
124	* If one exchanging thread is interrupted, another succeeds.
125	*/
126	public void testReplacementAfterExchange() throws InterruptedException {
127	final Exchanger e = new Exchanger();
128	Thread t1 = new Thread(new CheckedInterruptedRunnable() {
129	public void realRun() throws InterruptedException {
130	Object v = e.exchange(one);
131	threadAssertEquals(v, two);
132	Object w = e.exchange(v);
133	}});
134	Thread t2 = new Thread(new CheckedRunnable() {
135	public void realRun() throws InterruptedException {
136	Object v = e.exchange(two);
137	threadAssertEquals(v, one);
138	Thread.sleep(SMALL_DELAY_MS);
139	Object w = e.exchange(v);
140	threadAssertEquals(w, three);
141	}});
142	Thread t3 = new Thread(new CheckedRunnable() {
143	public void realRun() throws InterruptedException {
144	Thread.sleep(SMALL_DELAY_MS);
145	Object w = e.exchange(three);
146	threadAssertEquals(w, one);
147	}});
148
149	t1.start();
150	t2.start();
151	t3.start();
152	Thread.sleep(SHORT_DELAY_MS);
153	t1.interrupt();
154	t1.join();
155	t2.join();
156	t3.join();
157	}
158
159	}