ViewVC Help
View File | Revision Log | Show Annotations | Download File | Root Listing
root/jsr166/jsr166/src/test/tck/CountDownLatchTest.java
(Generate patch)

Comparing jsr166/src/test/tck/CountDownLatchTest.java (file contents):
Revision 1.2 by dl, Sun Sep 14 20:42:40 2003 UTC vs.
Revision 1.6 by dl, Sat Dec 27 19:26:43 2003 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 17 | Line 18 | public class CountDownLatchTest extends
18          return new TestSuite(CountDownLatchTest.class);
19      }
20  
21 <    public void testConstructor(){
21 >    /**
22 >     * negative constructor argument throws IAE
23 >     */
24 >    public void testConstructor() {
25          try {
26              new CountDownLatch(-1);
27 <            fail("should throw IllegalArgumentException");
27 >            shouldThrow();
28          } catch(IllegalArgumentException success){}
29      }
30  
31 <    public void testGetCount(){
31 >    /**
32 >     * getCount returns initial count and decreases after countDown
33 >     */
34 >    public void testGetCount() {
35          final CountDownLatch l = new CountDownLatch(2);
36          assertEquals(2, l.getCount());
37          l.countDown();
38          assertEquals(1, l.getCount());
39      }
40  
41 <    public void testAwait(){
41 >    /**
42 >     * countDown decrements count when positive and has no effect when zero
43 >     */
44 >    public void testCountDown() {
45 >        final CountDownLatch l = new CountDownLatch(1);
46 >        assertEquals(1, l.getCount());
47 >        l.countDown();
48 >        assertEquals(0, l.getCount());
49 >        l.countDown();
50 >        assertEquals(0, l.getCount());
51 >    }
52 >
53 >    /**
54 >     * await returns after countDown to zero, but not before
55 >     */
56 >    public void testAwait() {
57          final CountDownLatch l = new CountDownLatch(2);
58  
59 <        Thread t = new Thread(new Runnable(){
60 <                public void run(){
59 >        Thread t = new Thread(new Runnable() {
60 >                public void run() {
61                      try {
62 +                        threadAssertTrue(l.getCount() > 0);
63                          l.await();
64 +                        threadAssertTrue(l.getCount() == 0);
65                      } catch(InterruptedException e){
66 <                        threadFail("unexpected exception");
66 >                        threadUnexpectedException();
67                      }
68                  }
69              });
# Line 53 | Line 77 | public class CountDownLatchTest extends
77              assertEquals(l.getCount(), 0);
78              t.join();
79          } catch (InterruptedException e){
80 <            fail("unexpected exception");
80 >            unexpectedException();
81          }
82      }
83      
84  
85 <    public void testTimedAwait(){
85 >    /**
86 >     * timed await returns after countDown to zero
87 >     */
88 >    public void testTimedAwait() {
89          final CountDownLatch l = new CountDownLatch(2);
90  
91 <        Thread t = new Thread(new Runnable(){
92 <                public void run(){
91 >        Thread t = new Thread(new Runnable() {
92 >                public void run() {
93                      try {
94 +                        threadAssertTrue(l.getCount() > 0);
95                          threadAssertTrue(l.await(SMALL_DELAY_MS, TimeUnit.MILLISECONDS));
96                      } catch(InterruptedException e){
97 <                        threadFail("unexpected exception");
97 >                        threadUnexpectedException();
98                      }
99                  }
100              });
# Line 80 | Line 108 | public class CountDownLatchTest extends
108              assertEquals(l.getCount(), 0);
109              t.join();
110          } catch (InterruptedException e){
111 <            fail("unexpected exception");
111 >            unexpectedException();
112          }
113      }
114      
115 <
116 <
117 <
118 <    public void testAwait_InterruptedException(){
115 >    /**
116 >     * await throws IE if interrupted before counted down
117 >     */
118 >    public void testAwait_InterruptedException() {
119          final CountDownLatch l = new CountDownLatch(1);
120 <        Thread t = new Thread(new Runnable(){
121 <                public void run(){
120 >        Thread t = new Thread(new Runnable() {
121 >                public void run() {
122                      try {
123 +                        threadAssertTrue(l.getCount() > 0);
124                          l.await();
125 <                        threadFail("should throw");
125 >                        threadShouldThrow();
126                      } catch(InterruptedException success){}
127                  }
128              });
# Line 103 | Line 132 | public class CountDownLatchTest extends
132              t.interrupt();
133              t.join();
134          } catch (InterruptedException e){
135 <            fail("unexpected exception");
135 >            unexpectedException();
136          }
137      }
138  
139 <    public void testTimedAwait_InterruptedException(){
139 >    /**
140 >     * timed await throws IE if interrupted before counted down
141 >     */
142 >    public void testTimedAwait_InterruptedException() {
143          final CountDownLatch l = new CountDownLatch(1);
144 <        Thread t = new Thread(new Runnable(){
145 <                public void run(){
144 >        Thread t = new Thread(new Runnable() {
145 >                public void run() {
146                      try {
147 +                        threadAssertTrue(l.getCount() > 0);
148                          l.await(MEDIUM_DELAY_MS, TimeUnit.MILLISECONDS);
149 <                        threadFail("should throw");                        
149 >                        threadShouldThrow();                        
150                      } catch(InterruptedException success){}
151                  }
152              });
# Line 124 | Line 157 | public class CountDownLatchTest extends
157              t.interrupt();
158              t.join();
159          } catch (InterruptedException e){
160 <            fail("unexpected exception");
160 >            unexpectedException();
161          }
162      }
163  
164 <    public void testAwaitTimeout(){
164 >    /**
165 >     * timed await times out if not counted down before timeout
166 >     */
167 >    public void testAwaitTimeout() {
168          final CountDownLatch l = new CountDownLatch(1);
169 <        Thread t = new Thread(new Runnable(){
170 <                public void run(){
169 >        Thread t = new Thread(new Runnable() {
170 >                public void run() {
171                      try {
172 +                        threadAssertTrue(l.getCount() > 0);
173                          threadAssertFalse(l.await(SHORT_DELAY_MS, TimeUnit.MILLISECONDS));
174 +                        threadAssertTrue(l.getCount() > 0);
175                      } catch(InterruptedException ie){
176 <                        threadFail("unexpected exception");
176 >                        threadUnexpectedException();
177                      }
178                  }
179              });
# Line 144 | Line 182 | public class CountDownLatchTest extends
182              assertEquals(l.getCount(), 1);
183              t.join();
184          } catch (InterruptedException e){
185 <            fail("unexpected exception");
185 >            unexpectedException();
186          }
187      }
188  

Diff Legend

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