ViewVC Help
View File | Revision Log | Show Annotations | Download File | Root Listing
root/jsr166/jsr166/src/test/tck/ExchangerTest.java
(Generate patch)

Comparing jsr166/src/test/tck/ExchangerTest.java (file contents):
Revision 1.11 by jsr166, Sat Nov 21 02:33:20 2009 UTC vs.
Revision 1.24 by jsr166, Sat Mar 25 21:41:10 2017 UTC

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

Diff Legend

– Removed lines
+ Added lines
< Changed lines
> Changed lines