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.2 by dl, Sun Sep 14 20:42:40 2003 UTC vs.
Revision 1.8 by jsr166, Mon Nov 16 05:30:07 2009 UTC

# Line 1 | Line 1
1   /*
2 < * Written by members of JCP JSR-166 Expert Group and released to the
3 < * public domain. Use, modify, and redistribute this code in any way
4 < * without acknowledgement. Other contributors include Andrew Wright,
5 < * Jeffrey Hayes, Pat Fischer, Mike Judd.
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
5 > * Other contributors include Andrew Wright, Jeffrey Hayes,
6 > * Pat Fisher, Mike Judd.
7   */
8  
9   import junit.framework.*;
# Line 10 | Line 11 | import java.util.*;
11   import java.util.concurrent.*;
12  
13   public class ExchangerTest extends JSR166TestCase {
14 <  
14 >
15      public static void main(String[] args) {
16 <        junit.textui.TestRunner.run (suite());  
16 >        junit.textui.TestRunner.run (suite());
17      }
18      public static Test suite() {
19          return new TestSuite(ExchangerTest.class);
20      }
21  
22 +    /**
23 +     * exchange exchanges objects across two threads
24 +     */
25      public void testExchange() {
26          final Exchanger e = new Exchanger();
27 <        Thread t1 = new Thread(new Runnable(){
28 <                public void run(){
27 >        Thread t1 = new Thread(new Runnable() {
28 >                public void run() {
29                      try {
30                          Object v = e.exchange(one);
31                          threadAssertEquals(v, two);
32                          Object w = e.exchange(v);
33                          threadAssertEquals(w, one);
34 <                    } catch(InterruptedException e){
35 <                        threadFail("unexpected exception");
34 >                    } catch (InterruptedException e) {
35 >                        threadUnexpectedException();
36                      }
37                  }
38              });
39 <        Thread t2 = new Thread(new Runnable(){
40 <                public void run(){
39 >        Thread t2 = new Thread(new Runnable() {
40 >                public void run() {
41                      try {
42                          Object v = e.exchange(two);
43                          threadAssertEquals(v, one);
44                          Object w = e.exchange(v);
45                          threadAssertEquals(w, two);
46 <                    } catch(InterruptedException e){
47 <                        threadFail("unexpected exception");
46 >                    } catch (InterruptedException e) {
47 >                        threadUnexpectedException();
48                      }
49                  }
50              });
# Line 49 | Line 53 | public class ExchangerTest extends JSR16
53              t2.start();
54              t1.join();
55              t2.join();
56 <        } catch(InterruptedException ex) {
57 <            fail("unexpected exception");
56 >        } catch (InterruptedException ex) {
57 >            unexpectedException();
58          }
59      }
60  
61 +    /**
62 +     * timed exchange exchanges objects across two threads
63 +     */
64      public void testTimedExchange() {
65          final Exchanger e = new Exchanger();
66 <        Thread t1 = new Thread(new Runnable(){
67 <                public void run(){
66 >        Thread t1 = new Thread(new Runnable() {
67 >                public void run() {
68                      try {
69                          Object v = e.exchange(one, SHORT_DELAY_MS, TimeUnit.MILLISECONDS);
70                          threadAssertEquals(v, two);
71                          Object w = e.exchange(v, SHORT_DELAY_MS, TimeUnit.MILLISECONDS);
72                          threadAssertEquals(w, one);
73 <                    } catch(InterruptedException e){
74 <                        threadFail("unexpected exception");
75 <                    } catch(TimeoutException toe) {
76 <                        threadFail("unexpected exception");
73 >                    } catch (InterruptedException e) {
74 >                        threadUnexpectedException();
75 >                    } catch (TimeoutException toe) {
76 >                        threadUnexpectedException();
77                      }
78                  }
79              });
80 <        Thread t2 = new Thread(new Runnable(){
81 <                public void run(){
80 >        Thread t2 = new Thread(new Runnable() {
81 >                public void run() {
82                      try {
83                          Object v = e.exchange(two, SHORT_DELAY_MS, TimeUnit.MILLISECONDS);
84                          threadAssertEquals(v, one);
85                          Object w = e.exchange(v, SHORT_DELAY_MS, TimeUnit.MILLISECONDS);
86                          threadAssertEquals(w, two);
87 <                    } catch(InterruptedException e){
88 <                        threadFail("unexpected exception");
89 <                    } catch(TimeoutException toe) {
90 <                        threadFail("unexpected exception");
87 >                    } catch (InterruptedException e) {
88 >                        threadUnexpectedException();
89 >                    } catch (TimeoutException toe) {
90 >                        threadUnexpectedException();
91                      }
92                  }
93              });
# Line 89 | Line 96 | public class ExchangerTest extends JSR16
96              t2.start();
97              t1.join();
98              t2.join();
99 <        } catch(InterruptedException ex) {
100 <            fail("unexpected exception");
99 >        } catch (InterruptedException ex) {
100 >            unexpectedException();
101          }
102      }
103  
104 <    public void testExchange_InterruptedException(){
104 >    /**
105 >     * interrupt during wait for exchange throws IE
106 >     */
107 >    public void testExchange_InterruptedException() {
108          final Exchanger e = new Exchanger();
109          Thread t = new Thread(new Runnable() {
110 <                public void run(){
110 >                public void run() {
111                      try {
112                          e.exchange(one);
113 <                        threadFail("should throw");
114 <                    } catch(InterruptedException success){
113 >                        threadShouldThrow();
114 >                    } catch (InterruptedException success) {
115                      }
116                  }
117              });
# Line 110 | Line 120 | public class ExchangerTest extends JSR16
120              Thread.sleep(SHORT_DELAY_MS);
121              t.interrupt();
122              t.join();
123 <        } catch(InterruptedException ex) {
124 <            fail("unexpected exception");
123 >        } catch (InterruptedException ex) {
124 >            unexpectedException();
125          }
126      }
127  
128 <    public void testTimedExchange_InterruptedException(){
128 >    /**
129 >     * interrupt during wait for timed exchange throws IE
130 >     */
131 >    public void testTimedExchange_InterruptedException() {
132          final Exchanger e = new Exchanger();
133          Thread t = new Thread(new Runnable() {
134 <                public void run(){
134 >                public void run() {
135                      try {
136                          e.exchange(null, MEDIUM_DELAY_MS, TimeUnit.MILLISECONDS);
137 <                        threadFail("should throw");
138 <                    } catch(InterruptedException success){
139 <                    } catch(Exception e2){
137 >                        threadShouldThrow();
138 >                    } catch (InterruptedException success) {
139 >                    } catch (Exception e2) {
140                          threadFail("should throw IE");
141                      }
142                  }
# Line 132 | Line 145 | public class ExchangerTest extends JSR16
145              t.start();
146              t.interrupt();
147              t.join();
148 <        } catch(InterruptedException ex){
149 <            fail("unexpected exception");
148 >        } catch (InterruptedException ex) {
149 >            unexpectedException();
150          }
151      }
152  
153 <    public void testExchange_TimeOutException(){
153 >    /**
154 >     * timeout during wait for timed exchange throws TOE
155 >     */
156 >    public void testExchange_TimeOutException() {
157          final Exchanger e = new Exchanger();
158          Thread t = new Thread(new Runnable() {
159 <                public void run(){
159 >                public void run() {
160                      try {
161                          e.exchange(null, SHORT_DELAY_MS, TimeUnit.MILLISECONDS);
162 <                        threadFail("should throw");
163 <                    } catch(TimeoutException success){
164 <                    } catch(InterruptedException e2){
162 >                        threadShouldThrow();
163 >                    } catch (TimeoutException success) {
164 >                    } catch (InterruptedException e2) {
165                          threadFail("should throw TOE");
166                      }
167                  }
# Line 153 | Line 169 | public class ExchangerTest extends JSR16
169          try {
170              t.start();
171              t.join();
172 <        } catch(InterruptedException ex){
173 <            fail("unexpected exception");
172 >        } catch (InterruptedException ex) {
173 >            unexpectedException();
174 >        }
175 >    }
176 >
177 >    /**
178 >     * If one exchanging thread is interrupted, another succeeds.
179 >     */
180 >    public void testReplacementAfterExchange() {
181 >        final Exchanger e = new Exchanger();
182 >        Thread t1 = new Thread(new Runnable() {
183 >                public void run() {
184 >                    try {
185 >                        Object v = e.exchange(one);
186 >                        threadAssertEquals(v, two);
187 >                        Object w = e.exchange(v);
188 >                        threadShouldThrow();
189 >                    } catch (InterruptedException success) {
190 >                    }
191 >                }
192 >            });
193 >        Thread t2 = new Thread(new Runnable() {
194 >                public void run() {
195 >                    try {
196 >                        Object v = e.exchange(two);
197 >                        threadAssertEquals(v, one);
198 >                        Thread.sleep(SMALL_DELAY_MS);
199 >                        Object w = e.exchange(v);
200 >                        threadAssertEquals(w, three);
201 >                    } catch (InterruptedException e) {
202 >                        threadUnexpectedException();
203 >                    }
204 >                }
205 >            });
206 >        Thread t3 = new Thread(new Runnable() {
207 >                public void run() {
208 >                    try {
209 >                        Thread.sleep(SMALL_DELAY_MS);
210 >                        Object w = e.exchange(three);
211 >                        threadAssertEquals(w, one);
212 >                    } catch (InterruptedException e) {
213 >                        threadUnexpectedException();
214 >                    }
215 >                }
216 >            });
217 >
218 >        try {
219 >            t1.start();
220 >            t2.start();
221 >            t3.start();
222 >            Thread.sleep(SHORT_DELAY_MS);
223 >            t1.interrupt();
224 >            t1.join();
225 >            t2.join();
226 >            t3.join();
227 >        } catch (InterruptedException ex) {
228 >            unexpectedException();
229          }
230      }
231 +
232   }

Diff Legend

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