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.12 by jsr166, Mon Nov 30 08:31:09 2009 UTC vs.
Revision 1.26 by dl, Tue Jan 26 13:33:06 2021 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 {
31 <        final Exchanger e = new Exchanger();
32 <        Thread t1 = new Thread(new CheckedRunnable() {
33 <            public void realRun() throws InterruptedException {
34 <                Object v = e.exchange(one);
35 <                threadAssertEquals(v, two);
36 <                Object w = e.exchange(v);
37 <                threadAssertEquals(w, one);
38 <            }});
39 <        Thread t2 = new Thread(new CheckedRunnable() {
40 <            public void realRun() throws InterruptedException {
41 <                Object v = e.exchange(two);
42 <                threadAssertEquals(v, one);
43 <                Object w = e.exchange(v);
44 <                threadAssertEquals(w, two);
41 <            }});
42 <
43 <        t1.start();
44 <        t2.start();
45 <        t1.join();
46 <        t2.join();
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 = newStartedThread(new CheckedRunnable() {
38 >            public void realRun() throws InterruptedException {
39 >                assertSame(two, e.exchange(one));
40 >                assertSame(one, e.exchange(two));
41 >            }});
42 >
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 <                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
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();
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
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, MEDIUM_DELAY_MS, MILLISECONDS);
92 >                threadStarted.countDown();
93 >                e.exchange(null, LONG_DELAY_MS, MILLISECONDS);
94              }});
95  
96 <        t.start();
102 <        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 Thread(new CheckedRunnable() {
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 +                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();
121 <        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 <                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);
141 <                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);
147 <                threadAssertEquals(w, one);
141 >                await(interrupted);
142 >                assertSame(one, e.exchange(three));
143              }});
144  
145 <        t1.start();
151 <        t2.start();
152 <        t3.start();
153 <        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