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 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.20
Committed:	Sun May 29 06:48:42 2011 UTC (12 years, 11 months ago) by jsr166
Branch:	MAIN
Changes since 1.19:	+3 -5 lines
Log Message:	improve testExchange_TimeoutException
#	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 startTime = System.nanoTime();
105	try {
106	e.exchange(null, timeoutMillis(), MILLISECONDS);
107	shouldThrow();
108	} catch (TimeoutException success) {}
109	assertTrue(millisElapsedSince(startTime) >= timeoutMillis());
110	}});
111
112	awaitTermination(t);
113	}
114
115	/**
116	* If one exchanging thread is interrupted, another succeeds.
117	*/
118	public void testReplacementAfterExchange() {
119	final Exchanger e = new Exchanger();
120	final CountDownLatch exchanged = new CountDownLatch(2);
121	final CountDownLatch interrupted = new CountDownLatch(1);
122	Thread t1 = newStartedThread(new CheckedInterruptedRunnable() {
123	public void realRun() throws InterruptedException {
124	assertSame(two, e.exchange(one));
125	exchanged.countDown();
126	e.exchange(two);
127	}});
128	Thread t2 = newStartedThread(new CheckedRunnable() {
129	public void realRun() throws InterruptedException {
130	assertSame(one, e.exchange(two));
131	exchanged.countDown();
132	interrupted.await();
133	assertSame(three, e.exchange(one));
134	}});
135	Thread t3 = newStartedThread(new CheckedRunnable() {
136	public void realRun() throws InterruptedException {
137	interrupted.await();
138	assertSame(one, e.exchange(three));
139	}});
140
141	await(exchanged);
142	t1.interrupt();
143	awaitTermination(t1);
144	interrupted.countDown();
145	awaitTermination(t2);
146	awaitTermination(t3);
147	}
148
149	}