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.15 by jsr166, Tue Mar 15 19:47:06 2011 UTC vs.
Revision 1.26 by dl, Tue Jan 26 13:33:06 2021 UTC

# Line 6 | Line 6
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 {
31 <        final Exchanger e = new Exchanger();
32 <        Thread t1 = new Thread(new CheckedRunnable() {
30 >    public void testExchange() {
31 >        final Exchanger<Item> e = new Exchanger<Item>();
32 >        Thread t1 = newStartedThread(new CheckedRunnable() {
33              public void realRun() throws InterruptedException {
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                  assertSame(two, e.exchange(one));
40                  assertSame(one, e.exchange(two));
41              }});
42  
43 <        t1.start();
44 <        t2.start();
41 <        t1.join();
42 <        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 {
51 <        final Exchanger e = new Exchanger();
52 <        Thread t1 = new Thread(new CheckedRunnable() {
50 >    public void testTimedExchange() {
51 >        final Exchanger<Item> e = new Exchanger<Item>();
52 >        Thread t1 = newStartedThread(new CheckedRunnable() {
53              public void realRun() throws Exception {
54 <                assertSame(one, e.exchange(two, SHORT_DELAY_MS, MILLISECONDS));
55 <                assertSame(two, e.exchange(one, SHORT_DELAY_MS, MILLISECONDS));
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 <                assertSame(two, e.exchange(one, SHORT_DELAY_MS, MILLISECONDS));
60 <                assertSame(one, e.exchange(two, SHORT_DELAY_MS, MILLISECONDS));
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();
63 <        t1.join();
64 <        t2.join();
63 >        awaitTermination(t1);
64 >        awaitTermination(t2);
65      }
66  
67      /**
68 <     * interrupt during wait for exchange throws IE
68 >     * interrupt during wait for exchange throws InterruptedException
69       */
70 <    public void testExchange_InterruptedException() throws InterruptedException {
71 <        final Exchanger e = new Exchanger();
72 <        Thread t = new Thread(new CheckedInterruptedRunnable() {
70 >    public void testExchange_InterruptedException() {
71 >        final Exchanger<Item> e = new Exchanger<Item>();
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();
78 <        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
85 >     * interrupt during wait for timed exchange throws InterruptedException
86       */
87 <    public void testTimedExchange_InterruptedException() throws InterruptedException {
88 <        final Exchanger e = new Exchanger();
89 <        Thread t = new Thread(new CheckedInterruptedRunnable() {
87 >    public void testTimedExchange_InterruptedException() {
88 >        final Exchanger<Item> e = new Exchanger<Item>();
89 >        final CountDownLatch threadStarted = new CountDownLatch(1);
90 >        Thread t = newStartedThread(new CheckedInterruptedRunnable() {
91              public void realRun() throws Exception {
92 <                e.exchange(null, SMALL_DELAY_MS, MILLISECONDS);
92 >                threadStarted.countDown();
93 >                e.exchange(null, LONG_DELAY_MS, MILLISECONDS);
94              }});
95  
96 <        t.start();
94 <        Thread.sleep(SHORT_DELAY_MS);
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 {
105 <        final Exchanger e = new Exchanger();
106 <        Thread t = new ThreadShouldThrow(TimeoutException.class) {
104 >    public void testExchange_TimeoutException() {
105 >        final Exchanger<Item> e = new Exchanger<Item>();
106 >        Thread t = newStartedThread(new CheckedRunnable() {
107              public void realRun() throws Exception {
108 <                e.exchange(null, SHORT_DELAY_MS, MILLISECONDS);
109 <            }};
108 >                long startTime = System.nanoTime();
109 >                try {
110 >                    e.exchange(null, timeoutMillis(), MILLISECONDS);
111 >                    shouldThrow();
112 >                } catch (TimeoutException success) {}
113 >                assertTrue(millisElapsedSince(startTime) >= timeoutMillis());
114 >            }});
115  
116 <        t.start();
110 <        t.join();
116 >        awaitTermination(t);
117      }
118  
119      /**
120       * If one exchanging thread is interrupted, another succeeds.
121       */
122 <    public void testReplacementAfterExchange() throws InterruptedException {
123 <        final Exchanger e = new Exchanger();
124 <        Thread t1 = new Thread(new CheckedInterruptedRunnable() {
122 >    public void testReplacementAfterExchange() {
123 >        final Exchanger<Item> e = new Exchanger<Item>();
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                  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                  assertSame(one, e.exchange(two));
135 <                Thread.sleep(SMALL_DELAY_MS);
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);
141 >                await(interrupted);
142                  assertSame(one, e.exchange(three));
143              }});
144  
145 <        t1.start();
136 <        t2.start();
137 <        t3.start();
138 <        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