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();
        Thread.sleep(SHORT_DELAY_MS);
        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.12
Committed:	Mon Nov 30 08:31:09 2009 UTC (14 years, 5 months ago) by jsr166
Branch:	MAIN
Changes since 1.11:	+1 -0 lines
Log Message:	replace absolute waits with _DELAY_MS; 1000 => 1000L; short delay after starting a thread before interrupting it
#	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	Thread.sleep(SHORT_DELAY_MS);
103	t.interrupt();
104	t.join();
105	}
106
107	/**
108	* timeout during wait for timed exchange throws TOE
109	*/
110	public void testExchange_TimeOutException() throws InterruptedException {
111	final Exchanger e = new Exchanger();
112	Thread t = new Thread(new CheckedRunnable() {
113	public void realRun() throws Exception {
114	try {
115	e.exchange(null, SHORT_DELAY_MS, MILLISECONDS);
116	threadShouldThrow();
117	} catch (TimeoutException success) {}
118	}});
119
120	t.start();
121	t.join();
122	}
123
124	/**
125	* If one exchanging thread is interrupted, another succeeds.
126	*/
127	public void testReplacementAfterExchange() throws InterruptedException {
128	final Exchanger e = new Exchanger();
129	Thread t1 = new Thread(new CheckedInterruptedRunnable() {
130	public void realRun() throws InterruptedException {
131	Object v = e.exchange(one);
132	threadAssertEquals(v, two);
133	Object w = e.exchange(v);
134	}});
135	Thread t2 = new Thread(new CheckedRunnable() {
136	public void realRun() throws InterruptedException {
137	Object v = e.exchange(two);
138	threadAssertEquals(v, one);
139	Thread.sleep(SMALL_DELAY_MS);
140	Object w = e.exchange(v);
141	threadAssertEquals(w, three);
142	}});
143	Thread t3 = new Thread(new CheckedRunnable() {
144	public void realRun() throws InterruptedException {
145	Thread.sleep(SMALL_DELAY_MS);
146	Object w = e.exchange(three);
147	threadAssertEquals(w, one);
148	}});
149
150	t1.start();
151	t2.start();
152	t3.start();
153	Thread.sleep(SHORT_DELAY_MS);
154	t1.interrupt();
155	t1.join();
156	t2.join();
157	t3.join();
158	}
159
160	}