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/publicdomain/zero/1.0/
 * 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 {
                assertSame(one, e.exchange(two));
                assertSame(two, e.exchange(one));
            }});
        Thread t2 = new Thread(new CheckedRunnable() {
            public void realRun() throws InterruptedException {
                assertSame(two, e.exchange(one));
                assertSame(one, e.exchange(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 {
                assertSame(one, e.exchange(two, SHORT_DELAY_MS, MILLISECONDS));
                assertSame(two, e.exchange(one, SHORT_DELAY_MS, MILLISECONDS));
            }});
        Thread t2 = new Thread(new CheckedRunnable() {
            public void realRun() throws Exception {
                assertSame(two, e.exchange(one, SHORT_DELAY_MS, MILLISECONDS));
                assertSame(one, e.exchange(two, SHORT_DELAY_MS, MILLISECONDS));
            }});

        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();
        delay(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, SMALL_DELAY_MS, MILLISECONDS);
            }});

        t.start();
        delay(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 ThreadShouldThrow(TimeoutException.class) {
            public void realRun() throws Exception {
                e.exchange(null, SHORT_DELAY_MS, MILLISECONDS);
            }};

        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 {
                assertSame(two, e.exchange(one));
                e.exchange(two);
            }});
        Thread t2 = new Thread(new CheckedRunnable() {
            public void realRun() throws InterruptedException {
                assertSame(one, e.exchange(two));
                delay(SMALL_DELAY_MS);
                assertSame(three, e.exchange(one));
            }});
        Thread t3 = new Thread(new CheckedRunnable() {
            public void realRun() throws InterruptedException {
                delay(SMALL_DELAY_MS);
                assertSame(one, e.exchange(three));
            }});

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

}
Revision:	1.16
Committed:	Fri May 6 11:22:07 2011 UTC (13 years ago) by dl
Branch:	MAIN
CVS Tags:	release-1_7_0
Changes since 1.15:	+5 -5 lines
Log Message:	Add/use delay() instead of Thread.sleep to ensure sleeps are long enough
#	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/publicdomain/zero/1.0/
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	assertSame(one, e.exchange(two));
31	assertSame(two, e.exchange(one));
32	}});
33	Thread t2 = new Thread(new CheckedRunnable() {
34	public void realRun() throws InterruptedException {
35	assertSame(two, e.exchange(one));
36	assertSame(one, e.exchange(two));
37	}});
38
39	t1.start();
40	t2.start();
41	t1.join();
42	t2.join();
43	}
44
45	/**
46	* timed exchange exchanges objects across two threads
47	*/
48	public void testTimedExchange() throws InterruptedException {
49	final Exchanger e = new Exchanger();
50	Thread t1 = new Thread(new CheckedRunnable() {
51	public void realRun() throws Exception {
52	assertSame(one, e.exchange(two, SHORT_DELAY_MS, MILLISECONDS));
53	assertSame(two, e.exchange(one, SHORT_DELAY_MS, MILLISECONDS));
54	}});
55	Thread t2 = new Thread(new CheckedRunnable() {
56	public void realRun() throws Exception {
57	assertSame(two, e.exchange(one, SHORT_DELAY_MS, MILLISECONDS));
58	assertSame(one, e.exchange(two, SHORT_DELAY_MS, MILLISECONDS));
59	}});
60
61	t1.start();
62	t2.start();
63	t1.join();
64	t2.join();
65	}
66
67	/**
68	* interrupt during wait for exchange throws IE
69	*/
70	public void testExchange_InterruptedException() throws InterruptedException {
71	final Exchanger e = new Exchanger();
72	Thread t = new Thread(new CheckedInterruptedRunnable() {
73	public void realRun() throws InterruptedException {
74	e.exchange(one);
75	}});
76
77	t.start();
78	delay(SHORT_DELAY_MS);
79	t.interrupt();
80	t.join();
81	}
82
83	/**
84	* interrupt during wait for timed exchange throws IE
85	*/
86	public void testTimedExchange_InterruptedException() throws InterruptedException {
87	final Exchanger e = new Exchanger();
88	Thread t = new Thread(new CheckedInterruptedRunnable() {
89	public void realRun() throws Exception {
90	e.exchange(null, SMALL_DELAY_MS, MILLISECONDS);
91	}});
92
93	t.start();
94	delay(SHORT_DELAY_MS);
95	t.interrupt();
96	t.join();
97	}
98
99	/**
100	* timeout during wait for timed exchange throws TOE
101	*/
102	public void testExchange_TimeOutException() throws InterruptedException {
103	final Exchanger e = new Exchanger();
104	Thread t = new ThreadShouldThrow(TimeoutException.class) {
105	public void realRun() throws Exception {
106	e.exchange(null, SHORT_DELAY_MS, MILLISECONDS);
107	}};
108
109	t.start();
110	t.join();
111	}
112
113	/**
114	* If one exchanging thread is interrupted, another succeeds.
115	*/
116	public void testReplacementAfterExchange() throws InterruptedException {
117	final Exchanger e = new Exchanger();
118	Thread t1 = new Thread(new CheckedInterruptedRunnable() {
119	public void realRun() throws InterruptedException {
120	assertSame(two, e.exchange(one));
121	e.exchange(two);
122	}});
123	Thread t2 = new Thread(new CheckedRunnable() {
124	public void realRun() throws InterruptedException {
125	assertSame(one, e.exchange(two));
126	delay(SMALL_DELAY_MS);
127	assertSame(three, e.exchange(one));
128	}});
129	Thread t3 = new Thread(new CheckedRunnable() {
130	public void realRun() throws InterruptedException {
131	delay(SMALL_DELAY_MS);
132	assertSame(one, e.exchange(three));
133	}});
134
135	t1.start();
136	t2.start();
137	t3.start();
138	delay(SHORT_DELAY_MS);
139	t1.interrupt();
140	t1.join();
141	t2.join();
142	t3.join();
143	}
144
145	}