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.3 by dl, Sat Sep 20 18:20:07 2003 UTC vs.
Revision 1.11 by jsr166, Sat Nov 21 02:07:26 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 11 | Line 12 | import java.util.concurrent.*;
12  
13   public class CountDownLatchTest extends JSR166TestCase {
14      public static void main(String[] args) {
15 <        junit.textui.TestRunner.run (suite());  
15 >        junit.textui.TestRunner.run (suite());
16      }
17      public static Test suite() {
18 <        return new TestSuite(CountDownLatchTest.class);
18 >        return new TestSuite(CountDownLatchTest.class);
19      }
20  
21      /**
22 <     *
22 >     * negative constructor argument throws IAE
23       */
24      public void testConstructor() {
25          try {
26              new CountDownLatch(-1);
27              shouldThrow();
28 <        } catch(IllegalArgumentException success){}
28 >        } catch (IllegalArgumentException success) {}
29      }
30  
31      /**
32 <     *
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());
35 >        final CountDownLatch l = new CountDownLatch(2);
36 >        assertEquals(2, l.getCount());
37 >        l.countDown();
38 >        assertEquals(1, l.getCount());
39      }
40  
41      /**
42 <     *
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);
57 >        final CountDownLatch l = new CountDownLatch(2);
58  
59 <        Thread t = new Thread(new Runnable() {
60 <                public void run() {
61 <                    try {
62 <                        l.await();
63 <                    } catch(InterruptedException e){
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                          threadUnexpectedException();
67                      }
68 <                }
69 <            });
70 <        t.start();
71 <        try {
68 >                }
69 >            });
70 >        t.start();
71 >        try {
72              assertEquals(l.getCount(), 2);
73              Thread.sleep(SHORT_DELAY_MS);
74              l.countDown();
# Line 61 | Line 76 | public class CountDownLatchTest extends
76              l.countDown();
77              assertEquals(l.getCount(), 0);
78              t.join();
79 <        } catch (InterruptedException e){
79 >        } catch (InterruptedException e) {
80              unexpectedException();
81          }
82      }
83 <    
83 >
84  
85      /**
86 <     *
86 >     * timed await returns after countDown to zero
87       */
88      public void testTimedAwait() {
89 <        final CountDownLatch l = new CountDownLatch(2);
89 >        final CountDownLatch l = new CountDownLatch(2);
90  
91 <        Thread t = new Thread(new Runnable() {
92 <                public void run() {
93 <                    try {
94 <                        threadAssertTrue(l.await(SMALL_DELAY_MS, TimeUnit.MILLISECONDS));
95 <                    } catch(InterruptedException e){
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                          threadUnexpectedException();
98                      }
99 <                }
100 <            });
101 <        t.start();
102 <        try {
99 >                }
100 >            });
101 >        t.start();
102 >        try {
103              assertEquals(l.getCount(), 2);
104              Thread.sleep(SHORT_DELAY_MS);
105              l.countDown();
# Line 91 | Line 107 | public class CountDownLatchTest extends
107              l.countDown();
108              assertEquals(l.getCount(), 0);
109              t.join();
110 <        } catch (InterruptedException e){
110 >        } catch (InterruptedException e) {
111              unexpectedException();
112          }
113      }
98 –    
99 –
100 –
114  
115      /**
116 <     *
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() {
122                      try {
123 +                        threadAssertTrue(l.getCount() > 0);
124                          l.await();
125                          threadShouldThrow();
126 <                    } catch(InterruptedException success){}
126 >                    } catch (InterruptedException success) {}
127                  }
128              });
129 <        t.start();
130 <        try {
129 >        t.start();
130 >        try {
131              assertEquals(l.getCount(), 1);
132              t.interrupt();
133              t.join();
134 <        } catch (InterruptedException e){
134 >        } catch (InterruptedException e) {
135              unexpectedException();
136          }
137      }
138  
139      /**
140 <     *
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() {
146                      try {
147 +                        threadAssertTrue(l.getCount() > 0);
148                          l.await(MEDIUM_DELAY_MS, TimeUnit.MILLISECONDS);
149 <                        threadShouldThrow();                        
150 <                    } catch(InterruptedException success){}
149 >                        threadShouldThrow();
150 >                    } catch (InterruptedException success) {}
151                  }
152              });
153          t.start();
# Line 141 | Line 156 | public class CountDownLatchTest extends
156              assertEquals(l.getCount(), 1);
157              t.interrupt();
158              t.join();
159 <        } catch (InterruptedException e){
159 >        } catch (InterruptedException e) {
160              unexpectedException();
161          }
162      }
163  
164      /**
165 <     *
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() {
171                      try {
172 +                        threadAssertTrue(l.getCount() > 0);
173                          threadAssertFalse(l.await(SHORT_DELAY_MS, TimeUnit.MILLISECONDS));
174 <                    } catch(InterruptedException ie){
174 >                        threadAssertTrue(l.getCount() > 0);
175 >                    } catch (InterruptedException ie) {
176                          threadUnexpectedException();
177                      }
178                  }
# Line 164 | Line 181 | public class CountDownLatchTest extends
181          try {
182              assertEquals(l.getCount(), 1);
183              t.join();
184 <        } catch (InterruptedException e){
184 >        } catch (InterruptedException e) {
185              unexpectedException();
186          }
187      }
188  
189 +    /**
190 +     * toString indicates current count
191 +     */
192 +    public void testToString() {
193 +        CountDownLatch s = new CountDownLatch(2);
194 +        String us = s.toString();
195 +        assertTrue(us.indexOf("Count = 2") >= 0);
196 +        s.countDown();
197 +        String s1 = s.toString();
198 +        assertTrue(s1.indexOf("Count = 1") >= 0);
199 +        s.countDown();
200 +        String s2 = s.toString();
201 +        assertTrue(s2.indexOf("Count = 0") >= 0);
202 +    }
203 +
204   }

Diff Legend

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