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

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