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.17 by jsr166, Sun May 15 16:58:16 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 24 | Line 28 | public class ExchangerTest extends JSR16
28       * exchange exchanges objects across two threads
29       */
30      public void testExchange() {
31 <        final Exchanger e = new Exchanger();
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));
# Line 44 | Line 48 | public class ExchangerTest extends JSR16
48       * timed exchange exchanges objects across two threads
49       */
50      public void testTimedExchange() {
51 <        final Exchanger e = new Exchanger();
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, LONG_DELAY_MS, MILLISECONDS));
# Line 61 | Line 65 | public class ExchangerTest extends JSR16
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() {
71 <        final Exchanger e = new Exchanger();
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 {
# Line 78 | Line 82 | public class ExchangerTest extends JSR16
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() {
88 <        final Exchanger e = new Exchanger();
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 {
# Line 98 | Line 102 | public class ExchangerTest extends JSR16
102       * timeout during wait for timed exchange throws TimeoutException
103       */
104      public void testExchange_TimeoutException() {
105 <        final Exchanger e = new Exchanger();
105 >        final Exchanger<Item> e = new Exchanger<Item>();
106          Thread t = newStartedThread(new CheckedRunnable() {
107              public void realRun() throws Exception {
104 –                long timeoutMillis = SHORT_DELAY_MS;
108                  long startTime = System.nanoTime();
109                  try {
110 <                    e.exchange(null, timeoutMillis, MILLISECONDS);
110 >                    e.exchange(null, timeoutMillis(), MILLISECONDS);
111                      shouldThrow();
112 <                } catch (TimeoutException success) {
113 <                    assertTrue(millisElapsedSince(startTime) >= timeoutMillis);
111 <                }
112 >                } catch (TimeoutException success) {}
113 >                assertTrue(millisElapsedSince(startTime) >= timeoutMillis());
114              }});
115  
116          awaitTermination(t);
# Line 117 | Line 119 | public class ExchangerTest extends JSR16
119      /**
120       * If one exchanging thread is interrupted, another succeeds.
121       */
122 <    public void testReplacementAfterExchange() throws InterruptedException {
123 <        final Exchanger e = new Exchanger();
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() {
# Line 131 | Line 133 | public class ExchangerTest extends JSR16
133              public void realRun() throws InterruptedException {
134                  assertSame(one, e.exchange(two));
135                  exchanged.countDown();
136 <                interrupted.await();
136 >                await(interrupted);
137                  assertSame(three, e.exchange(one));
138              }});
139          Thread t3 = newStartedThread(new CheckedRunnable() {
140              public void realRun() throws InterruptedException {
141 <                interrupted.await();
141 >                await(interrupted);
142                  assertSame(one, e.exchange(three));
143              }});
144  
145          await(exchanged);
146          t1.interrupt();
145 –        interrupted.countDown();
147          awaitTermination(t1);
148 +        interrupted.countDown();
149          awaitTermination(t2);
150          awaitTermination(t3);
151      }

Diff Legend

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