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.1 by dl, Sun Aug 31 19:24:54 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.*;
10   import java.util.*;
11   import java.util.concurrent.*;
12  
13 < public class ExchangerTest extends TestCase{
14 <  
13 > public class ExchangerTest extends JSR166TestCase {
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 <    private static long SHORT_DELAY_MS = 100;
23 <    private static long MEDIUM_DELAY_MS = 1000;
24 <    private static long LONG_DELAY_MS = 10000;
25 <    
25 <    private final static Integer one = new Integer(1);
26 <    private final static Integer two = new Integer(2);
27 <
28 <    public void testExchange(){
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(){
29 <                    try{
29 >                    try {
30                          Object v = e.exchange(one);
31 <                        assertEquals(v, two);
31 >                        threadAssertEquals(v, two);
32                          Object w = e.exchange(v);
33 <                        assertEquals(w, one);
34 <                    }catch(InterruptedException e){
35 <                        fail("unexpected exception");
33 >                        threadAssertEquals(w, one);
34 >                    } catch (InterruptedException e){
35 >                        threadUnexpectedException();
36                      }
37                  }
38              });
39          Thread t2 = new Thread(new Runnable(){
40                  public void run(){
41 <                    try{
41 >                    try {
42                          Object v = e.exchange(two);
43 <                        assertEquals(v, one);
43 >                        threadAssertEquals(v, one);
44                          Object w = e.exchange(v);
45 <                        assertEquals(w, two);
46 <                    }catch(InterruptedException e){
47 <                        fail("unexpected exception");
45 >                        threadAssertEquals(w, two);
46 >                    } catch (InterruptedException e){
47 >                        threadUnexpectedException();
48                      }
49                  }
50              });
# Line 56 | Line 53 | public class ExchangerTest extends TestC
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 <    public void testExchange1_InterruptedException(){
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(){
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 >                        threadUnexpectedException();
75 >                    } catch (TimeoutException toe) {
76 >                        threadUnexpectedException();
77 >                    }
78 >                }
79 >            });
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 >                        threadUnexpectedException();
89 >                    } catch (TimeoutException toe) {
90 >                        threadUnexpectedException();
91 >                    }
92 >                }
93 >            });
94 >        try {
95 >            t1.start();
96 >            t2.start();
97 >            t1.join();
98 >            t2.join();
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{
111 >                    try {
112                          e.exchange(one);
113 <                        fail("should throw");
114 <                    }catch(InterruptedException success){
113 >                        threadShouldThrow();
114 >                    } catch (InterruptedException success){
115                      }
116                  }
117              });
118 <        try{
118 >        try {
119              t.start();
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 testExchange2_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(){
135 <                    try{
135 >                    try {
136                          e.exchange(null, MEDIUM_DELAY_MS, TimeUnit.MILLISECONDS);
137 <                        fail("should throw");
138 <                    } catch(InterruptedException success){
139 <                    } catch(Exception e2){
140 <                        fail("should throw IE");
137 >                        threadShouldThrow();
138 >                    } catch (InterruptedException success){
139 >                    } catch (Exception e2){
140 >                        threadFail("should throw IE");
141                      }
142                  }
143              });
144 <        try{
144 >        try {
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 testExchange3_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(){
160 <                    try{
160 >                    try {
161                          e.exchange(null, SHORT_DELAY_MS, TimeUnit.MILLISECONDS);
162 <                        fail("should throw");
163 <                    }catch(TimeoutException success){}
164 <                    catch(InterruptedException e2){
165 <                        fail("should throw TOE");
162 >                        threadShouldThrow();
163 >                    } catch (TimeoutException success){
164 >                    } catch (InterruptedException e2){
165 >                        threadFail("should throw TOE");
166                      }
167                  }
168              });
169 <        try{
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