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() {
        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 timeoutMillis = SHORT_DELAY_MS;
                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.19
Committed:	Sun May 22 20:05:57 2011 UTC (12 years, 11 months ago) by jsr166
Branch:	MAIN
Changes since 1.18:	+1 -1 lines
Log Message:	Fix flaky test testReplacementAfterExchange
#	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() {
27	final Exchanger e = new Exchanger();
28	Thread t1 = newStartedThread(new CheckedRunnable() {
29	public void realRun() throws InterruptedException {
30	assertSame(one, e.exchange(two));
31	assertSame(two, e.exchange(one));
32	}});
33	Thread t2 = newStartedThread(new CheckedRunnable() {
34	public void realRun() throws InterruptedException {
35	assertSame(two, e.exchange(one));
36	assertSame(one, e.exchange(two));
37	}});
38
39	awaitTermination(t1);
40	awaitTermination(t2);
41	}
42
43	/**
44	* timed exchange exchanges objects across two threads
45	*/
46	public void testTimedExchange() {
47	final Exchanger e = new Exchanger();
48	Thread t1 = newStartedThread(new CheckedRunnable() {
49	public void realRun() throws Exception {
50	assertSame(one, e.exchange(two, LONG_DELAY_MS, MILLISECONDS));
51	assertSame(two, e.exchange(one, LONG_DELAY_MS, MILLISECONDS));
52	}});
53	Thread t2 = newStartedThread(new CheckedRunnable() {
54	public void realRun() throws Exception {
55	assertSame(two, e.exchange(one, LONG_DELAY_MS, MILLISECONDS));
56	assertSame(one, e.exchange(two, LONG_DELAY_MS, MILLISECONDS));
57	}});
58
59	awaitTermination(t1);
60	awaitTermination(t2);
61	}
62
63	/**
64	* interrupt during wait for exchange throws IE
65	*/
66	public void testExchange_InterruptedException() {
67	final Exchanger e = new Exchanger();
68	final CountDownLatch threadStarted = new CountDownLatch(1);
69	Thread t = newStartedThread(new CheckedInterruptedRunnable() {
70	public void realRun() throws InterruptedException {
71	threadStarted.countDown();
72	e.exchange(one);
73	}});
74
75	await(threadStarted);
76	t.interrupt();
77	awaitTermination(t);
78	}
79
80	/**
81	* interrupt during wait for timed exchange throws IE
82	*/
83	public void testTimedExchange_InterruptedException() {
84	final Exchanger e = new Exchanger();
85	final CountDownLatch threadStarted = new CountDownLatch(1);
86	Thread t = newStartedThread(new CheckedInterruptedRunnable() {
87	public void realRun() throws Exception {
88	threadStarted.countDown();
89	e.exchange(null, LONG_DELAY_MS, MILLISECONDS);
90	}});
91
92	await(threadStarted);
93	t.interrupt();
94	awaitTermination(t);
95	}
96
97	/**
98	* timeout during wait for timed exchange throws TimeoutException
99	*/
100	public void testExchange_TimeoutException() {
101	final Exchanger e = new Exchanger();
102	Thread t = newStartedThread(new CheckedRunnable() {
103	public void realRun() throws Exception {
104	long timeoutMillis = SHORT_DELAY_MS;
105	long startTime = System.nanoTime();
106	try {
107	e.exchange(null, timeoutMillis, MILLISECONDS);
108	shouldThrow();
109	} catch (TimeoutException success) {
110	assertTrue(millisElapsedSince(startTime) >= timeoutMillis);
111	}
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	}