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.7 by jsr166, Mon Nov 16 04:57:10 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(){
# Line 27 | Line 31 | public class ExchangerTest extends JSR16
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              });
# Line 39 | Line 43 | public class ExchangerTest extends JSR16
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(){
# Line 63 | Line 70 | public class ExchangerTest extends JSR16
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              });
# Line 77 | Line 84 | public class ExchangerTest extends JSR16
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 +    /**
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(){
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 +    /**
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(){
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 +    /**
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(){
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