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.CountDownLatch;
import java.util.concurrent.Exchanger;
import java.util.concurrent.TimeoutException;
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() {
        final Exchanger e = new Exchanger();
        Thread t1 = newStartedThread(new CheckedRunnable() {
            public void realRun() throws InterruptedException {
                assertSame(one, e.exchange(two));
                assertSame(two, e.exchange(one));
            }});
        Thread t2 = newStartedThread(new CheckedRunnable() {
            public void realRun() throws InterruptedException {
                assertSame(two, e.exchange(one));
                assertSame(one, e.exchange(two));
            }});

        awaitTermination(t1);
        awaitTermination(t2);
    }

    /**
     * timed exchange exchanges objects across two threads
     */
    public void testTimedExchange() {
        final Exchanger e = new Exchanger();
        Thread t1 = newStartedThread(new CheckedRunnable() {
            public void realRun() throws Exception {
                assertSame(one, e.exchange(two, LONG_DELAY_MS, MILLISECONDS));
                assertSame(two, e.exchange(one, LONG_DELAY_MS, MILLISECONDS));
            }});
        Thread t2 = newStartedThread(new CheckedRunnable() {
            public void realRun() throws Exception {
                assertSame(two, e.exchange(one, LONG_DELAY_MS, MILLISECONDS));
                assertSame(one, e.exchange(two, LONG_DELAY_MS, MILLISECONDS));
            }});

        awaitTermination(t1);
        awaitTermination(t2);
    }

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

        await(threadStarted);
        t.interrupt();
        awaitTermination(t);
    }

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

        await(threadStarted);
        t.interrupt();
        awaitTermination(t);
    }

    /**
     * timeout during wait for timed exchange throws TimeoutException
     */
    public void testExchange_TimeoutException() {
        final Exchanger e = new Exchanger();
        Thread t = newStartedThread(new CheckedRunnable() {
            public void realRun() throws Exception {
                long startTime = System.nanoTime();
                try {
                    e.exchange(null, timeoutMillis(), MILLISECONDS);
                    shouldThrow();
                } catch (TimeoutException success) {}
                assertTrue(millisElapsedSince(startTime) >= timeoutMillis());
            }});

        awaitTermination(t);
    }

    /**
     * If one exchanging thread is interrupted, another succeeds.
     */
    public void testReplacementAfterExchange() {
        final Exchanger e = new Exchanger();
        final CountDownLatch exchanged = new CountDownLatch(2);
        final CountDownLatch interrupted = new CountDownLatch(1);
        Thread t1 = newStartedThread(new CheckedInterruptedRunnable() {
            public void realRun() throws InterruptedException {
                assertSame(two, e.exchange(one));
                exchanged.countDown();
                e.exchange(two);
            }});
        Thread t2 = newStartedThread(new CheckedRunnable() {
            public void realRun() throws InterruptedException {
                assertSame(one, e.exchange(two));
                exchanged.countDown();
                interrupted.await();
                assertSame(three, e.exchange(one));
            }});
        Thread t3 = newStartedThread(new CheckedRunnable() {
            public void realRun() throws InterruptedException {
                interrupted.await();
                assertSame(one, e.exchange(three));
            }});

        await(exchanged);
        t1.interrupt();
        awaitTermination(t1);
        interrupted.countDown();
        awaitTermination(t2);
        awaitTermination(t3);
    }

}
Revision:	1.21
Committed:	Tue May 31 16:16:23 2011 UTC (12 years, 11 months ago) by jsr166
Branch:	MAIN
Changes since 1.20:	+3 -1 lines
Log Message:	use serialClone in serialization tests; update imports
#	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.CountDownLatch;
12	import java.util.concurrent.Exchanger;
13	import java.util.concurrent.TimeoutException;
14	import static java.util.concurrent.TimeUnit.MILLISECONDS;
15
16	public class ExchangerTest extends JSR166TestCase {
17
18	public static void main(String[] args) {
19	junit.textui.TestRunner.run(suite());
20	}
21	public static Test suite() {
22	return new TestSuite(ExchangerTest.class);
23	}
24
25	/**
26	* exchange exchanges objects across two threads
27	*/
28	public void testExchange() {
29	final Exchanger e = new Exchanger();
30	Thread t1 = newStartedThread(new CheckedRunnable() {
31	public void realRun() throws InterruptedException {
32	assertSame(one, e.exchange(two));
33	assertSame(two, e.exchange(one));
34	}});
35	Thread t2 = newStartedThread(new CheckedRunnable() {
36	public void realRun() throws InterruptedException {
37	assertSame(two, e.exchange(one));
38	assertSame(one, e.exchange(two));
39	}});
40
41	awaitTermination(t1);
42	awaitTermination(t2);
43	}
44
45	/**
46	* timed exchange exchanges objects across two threads
47	*/
48	public void testTimedExchange() {
49	final Exchanger e = new Exchanger();
50	Thread t1 = newStartedThread(new CheckedRunnable() {
51	public void realRun() throws Exception {
52	assertSame(one, e.exchange(two, LONG_DELAY_MS, MILLISECONDS));
53	assertSame(two, e.exchange(one, LONG_DELAY_MS, MILLISECONDS));
54	}});
55	Thread t2 = newStartedThread(new CheckedRunnable() {
56	public void realRun() throws Exception {
57	assertSame(two, e.exchange(one, LONG_DELAY_MS, MILLISECONDS));
58	assertSame(one, e.exchange(two, LONG_DELAY_MS, MILLISECONDS));
59	}});
60
61	awaitTermination(t1);
62	awaitTermination(t2);
63	}
64
65	/**
66	* interrupt during wait for exchange throws IE
67	*/
68	public void testExchange_InterruptedException() {
69	final Exchanger e = new Exchanger();
70	final CountDownLatch threadStarted = new CountDownLatch(1);
71	Thread t = newStartedThread(new CheckedInterruptedRunnable() {
72	public void realRun() throws InterruptedException {
73	threadStarted.countDown();
74	e.exchange(one);
75	}});
76
77	await(threadStarted);
78	t.interrupt();
79	awaitTermination(t);
80	}
81
82	/**
83	* interrupt during wait for timed exchange throws IE
84	*/
85	public void testTimedExchange_InterruptedException() {
86	final Exchanger e = new Exchanger();
87	final CountDownLatch threadStarted = new CountDownLatch(1);
88	Thread t = newStartedThread(new CheckedInterruptedRunnable() {
89	public void realRun() throws Exception {
90	threadStarted.countDown();
91	e.exchange(null, LONG_DELAY_MS, MILLISECONDS);
92	}});
93
94	await(threadStarted);
95	t.interrupt();
96	awaitTermination(t);
97	}
98
99	/**
100	* timeout during wait for timed exchange throws TimeoutException
101	*/
102	public void testExchange_TimeoutException() {
103	final Exchanger e = new Exchanger();
104	Thread t = newStartedThread(new CheckedRunnable() {
105	public void realRun() throws Exception {
106	long startTime = System.nanoTime();
107	try {
108	e.exchange(null, timeoutMillis(), MILLISECONDS);
109	shouldThrow();
110	} catch (TimeoutException success) {}
111	assertTrue(millisElapsedSince(startTime) >= timeoutMillis());
112	}});
113
114	awaitTermination(t);
115	}
116
117	/**
118	* If one exchanging thread is interrupted, another succeeds.
119	*/
120	public void testReplacementAfterExchange() {
121	final Exchanger e = new Exchanger();
122	final CountDownLatch exchanged = new CountDownLatch(2);
123	final CountDownLatch interrupted = new CountDownLatch(1);
124	Thread t1 = newStartedThread(new CheckedInterruptedRunnable() {
125	public void realRun() throws InterruptedException {
126	assertSame(two, e.exchange(one));
127	exchanged.countDown();
128	e.exchange(two);
129	}});
130	Thread t2 = newStartedThread(new CheckedRunnable() {
131	public void realRun() throws InterruptedException {
132	assertSame(one, e.exchange(two));
133	exchanged.countDown();
134	interrupted.await();
135	assertSame(three, e.exchange(one));
136	}});
137	Thread t3 = newStartedThread(new CheckedRunnable() {
138	public void realRun() throws InterruptedException {
139	interrupted.await();
140	assertSame(one, e.exchange(three));
141	}});
142
143	await(exchanged);
144	t1.interrupt();
145	awaitTermination(t1);
146	interrupted.countDown();
147	awaitTermination(t2);
148	awaitTermination(t3);
149	}
150
151	}