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.3 by dl, Sat Sep 20 18:20:07 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 <     *
23 >     * exchange exchanges objects across two threads
24       */
25      public void testExchange() {
26          final Exchanger e = new Exchanger();
# Line 30 | 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){
34 >                    } catch (InterruptedException e){
35                          threadUnexpectedException();
36                      }
37                  }
# Line 42 | 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){
46 >                    } catch (InterruptedException e){
47                          threadUnexpectedException();
48                      }
49                  }
# Line 52 | Line 53 | public class ExchangerTest extends JSR16
53              t2.start();
54              t1.join();
55              t2.join();
56 <        } catch(InterruptedException ex) {
56 >        } catch (InterruptedException ex) {
57              unexpectedException();
58          }
59      }
60  
61      /**
62 <     *
62 >     * timed exchange exchanges objects across two threads
63       */
64      public void testTimedExchange() {
65          final Exchanger e = new Exchanger();
# Line 69 | 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){
73 >                    } catch (InterruptedException e){
74                          threadUnexpectedException();
75 <                    } catch(TimeoutException toe) {
75 >                    } catch (TimeoutException toe) {
76                          threadUnexpectedException();
77                      }
78                  }
# Line 83 | 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){
87 >                    } catch (InterruptedException e){
88                          threadUnexpectedException();
89 <                    } catch(TimeoutException toe) {
89 >                    } catch (TimeoutException toe) {
90                          threadUnexpectedException();
91                      }
92                  }
# Line 95 | Line 96 | public class ExchangerTest extends JSR16
96              t2.start();
97              t1.join();
98              t2.join();
99 <        } catch(InterruptedException ex) {
99 >        } catch (InterruptedException ex) {
100              unexpectedException();
101          }
102      }
103  
104      /**
105 <     *
105 >     * interrupt during wait for exchange throws IE
106       */
107      public void testExchange_InterruptedException(){
108          final Exchanger e = new Exchanger();
# Line 110 | Line 111 | public class ExchangerTest extends JSR16
111                      try {
112                          e.exchange(one);
113                          threadShouldThrow();
114 <                    } catch(InterruptedException success){
114 >                    } catch (InterruptedException success){
115                      }
116                  }
117              });
# Line 119 | Line 120 | public class ExchangerTest extends JSR16
120              Thread.sleep(SHORT_DELAY_MS);
121              t.interrupt();
122              t.join();
123 <        } catch(InterruptedException ex) {
123 >        } catch (InterruptedException ex) {
124              unexpectedException();
125          }
126      }
127  
128      /**
129 <     *
129 >     * interrupt during wait for timed exchange throws IE
130       */
131      public void testTimedExchange_InterruptedException(){
132          final Exchanger e = new Exchanger();
# Line 134 | Line 135 | public class ExchangerTest extends JSR16
135                      try {
136                          e.exchange(null, MEDIUM_DELAY_MS, TimeUnit.MILLISECONDS);
137                          threadShouldThrow();
138 <                    } catch(InterruptedException success){
139 <                    } catch(Exception e2){
138 >                    } catch (InterruptedException success){
139 >                    } catch (Exception e2){
140                          threadFail("should throw IE");
141                      }
142                  }
# Line 144 | Line 145 | public class ExchangerTest extends JSR16
145              t.start();
146              t.interrupt();
147              t.join();
148 <        } catch(InterruptedException ex){
148 >        } catch (InterruptedException ex){
149              unexpectedException();
150          }
151      }
152  
153      /**
154 <     *
154 >     * timeout during wait for timed exchange throws TOE
155       */
156      public void testExchange_TimeOutException(){
157          final Exchanger e = new Exchanger();
# Line 159 | Line 160 | public class ExchangerTest extends JSR16
160                      try {
161                          e.exchange(null, SHORT_DELAY_MS, TimeUnit.MILLISECONDS);
162                          threadShouldThrow();
163 <                    } catch(TimeoutException success){
164 <                    } catch(InterruptedException e2){
163 >                    } catch (TimeoutException success){
164 >                    } catch (InterruptedException e2){
165                          threadFail("should throw TOE");
166                      }
167                  }
# Line 168 | Line 169 | public class ExchangerTest extends JSR16
169          try {
170              t.start();
171              t.join();
172 <        } catch(InterruptedException ex){
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