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.17 by dl, Fri May 6 11:22:07 2011 UTC vs.
Revision 1.28 by jsr166, Sun Aug 11 22:29:26 2019 UTC

# Line 6 | Line 6
6   * Pat Fisher, Mike Judd.
7   */
8  
9 – import junit.framework.*;
10 – import java.util.*;
11 – import java.util.concurrent.*;
9   import static java.util.concurrent.TimeUnit.MILLISECONDS;
10  
11 + import java.util.concurrent.CountDownLatch;
12 + import java.util.concurrent.ThreadLocalRandom;
13 +
14 + import junit.framework.Test;
15 + import junit.framework.TestSuite;
16 +
17   public class CountDownLatchTest extends JSR166TestCase {
18      public static void main(String[] args) {
19 <        junit.textui.TestRunner.run(suite());
19 >        main(suite(), args);
20      }
21      public static Test suite() {
22          return new TestSuite(CountDownLatchTest.class);
23      }
24  
25      /**
26 <     * negative constructor argument throws IAE
26 >     * negative constructor argument throws IllegalArgumentException
27       */
28      public void testConstructor() {
29          try {
# Line 54 | Line 57 | public class CountDownLatchTest extends
57      /**
58       * await returns after countDown to zero, but not before
59       */
60 <    public void testAwait() throws InterruptedException {
60 >    public void testAwait() {
61          final CountDownLatch l = new CountDownLatch(2);
62 +        final CountDownLatch pleaseCountDown = new CountDownLatch(1);
63  
64 <        Thread t = new Thread(new CheckedRunnable() {
64 >        Thread t = newStartedThread(new CheckedRunnable() {
65              public void realRun() throws InterruptedException {
66 <                assertTrue(l.getCount() > 0);
66 >                assertEquals(2, l.getCount());
67 >                pleaseCountDown.countDown();
68                  l.await();
69                  assertEquals(0, l.getCount());
70              }});
71  
72 <        t.start();
73 <        assertEquals(l.getCount(), 2);
69 <        delay(SHORT_DELAY_MS);
72 >        await(pleaseCountDown);
73 >        assertEquals(2, l.getCount());
74          l.countDown();
75 <        assertEquals(l.getCount(), 1);
75 >        assertEquals(1, l.getCount());
76 >        if (randomBoolean()) assertThreadBlocks(t, Thread.State.WAITING);
77          l.countDown();
78 <        assertEquals(l.getCount(), 0);
79 <        t.join();
78 >        assertEquals(0, l.getCount());
79 >        awaitTermination(t);
80      }
81  
77 –
82      /**
83       * timed await returns after countDown to zero
84       */
85 <    public void testTimedAwait() throws InterruptedException {
85 >    public void testTimedAwait() {
86          final CountDownLatch l = new CountDownLatch(2);
87 +        final CountDownLatch pleaseCountDown = new CountDownLatch(1);
88  
89 <        Thread t = new Thread(new CheckedRunnable() {
89 >        Thread t = newStartedThread(new CheckedRunnable() {
90              public void realRun() throws InterruptedException {
91 <                assertTrue(l.getCount() > 0);
92 <                assertTrue(l.await(SMALL_DELAY_MS, MILLISECONDS));
91 >                assertEquals(2, l.getCount());
92 >                pleaseCountDown.countDown();
93 >                assertTrue(l.await(LONG_DELAY_MS, MILLISECONDS));
94 >                assertEquals(0, l.getCount());
95              }});
96  
97 <        t.start();
98 <        assertEquals(l.getCount(), 2);
92 <        delay(SHORT_DELAY_MS);
97 >        await(pleaseCountDown);
98 >        assertEquals(2, l.getCount());
99          l.countDown();
100 <        assertEquals(l.getCount(), 1);
100 >        assertEquals(1, l.getCount());
101 >        if (randomBoolean()) assertThreadBlocks(t, Thread.State.TIMED_WAITING);
102          l.countDown();
103 <        assertEquals(l.getCount(), 0);
104 <        t.join();
103 >        assertEquals(0, l.getCount());
104 >        awaitTermination(t);
105      }
106  
107      /**
108 <     * await throws IE if interrupted before counted down
108 >     * await throws InterruptedException if interrupted before counted down
109       */
110 <    public void testAwait_InterruptedException() throws InterruptedException {
110 >    public void testAwait_Interruptible() {
111          final CountDownLatch l = new CountDownLatch(1);
112 <        Thread t = new Thread(new CheckedInterruptedRunnable() {
112 >        final CountDownLatch pleaseInterrupt = new CountDownLatch(1);
113 >        Thread t = newStartedThread(new CheckedRunnable() {
114              public void realRun() throws InterruptedException {
115 <                assertTrue(l.getCount() > 0);
116 <                l.await();
115 >                Thread.currentThread().interrupt();
116 >                try {
117 >                    l.await();
118 >                    shouldThrow();
119 >                } catch (InterruptedException success) {}
120 >                assertFalse(Thread.interrupted());
121 >
122 >                pleaseInterrupt.countDown();
123 >                try {
124 >                    l.await();
125 >                    shouldThrow();
126 >                } catch (InterruptedException success) {}
127 >                assertFalse(Thread.interrupted());
128 >
129 >                assertEquals(1, l.getCount());
130              }});
131  
132 <        t.start();
133 <        assertEquals(l.getCount(), 1);
132 >        await(pleaseInterrupt);
133 >        if (randomBoolean()) assertThreadBlocks(t, Thread.State.WAITING);
134          t.interrupt();
135 <        t.join();
135 >        awaitTermination(t);
136      }
137  
138      /**
139 <     * timed await throws IE if interrupted before counted down
139 >     * timed await throws InterruptedException if interrupted before counted down
140       */
141 <    public void testTimedAwait_InterruptedException() throws InterruptedException {
142 <        final CountDownLatch l = new CountDownLatch(1);
143 <        Thread t = new Thread(new CheckedInterruptedRunnable() {
141 >    public void testTimedAwait_Interruptible() {
142 >        final int initialCount = ThreadLocalRandom.current().nextInt(1, 3);
143 >        final CountDownLatch l = new CountDownLatch(initialCount);
144 >        final CountDownLatch pleaseInterrupt = new CountDownLatch(1);
145 >        Thread t = newStartedThread(new CheckedRunnable() {
146              public void realRun() throws InterruptedException {
147 <                assertTrue(l.getCount() > 0);
148 <                l.await(MEDIUM_DELAY_MS, MILLISECONDS);
147 >                long startTime = System.nanoTime();
148 >
149 >                Thread.currentThread().interrupt();
150 >                try {
151 >                    l.await(randomTimeout(), randomTimeUnit());
152 >                    shouldThrow();
153 >                } catch (InterruptedException success) {}
154 >                assertFalse(Thread.interrupted());
155 >
156 >                pleaseInterrupt.countDown();
157 >                try {
158 >                    l.await(LONG_DELAY_MS, MILLISECONDS);
159 >                    shouldThrow();
160 >                } catch (InterruptedException success) {}
161 >                assertFalse(Thread.interrupted());
162 >
163 >                assertEquals(initialCount, l.getCount());
164 >                assertTrue(millisElapsedSince(startTime) < LONG_DELAY_MS);
165              }});
166  
167 <        t.start();
168 <        delay(SHORT_DELAY_MS);
130 <        assertEquals(l.getCount(), 1);
167 >        await(pleaseInterrupt);
168 >        if (randomBoolean()) assertThreadBlocks(t, Thread.State.TIMED_WAITING);
169          t.interrupt();
170 <        t.join();
170 >        awaitTermination(t);
171      }
172  
173      /**
# Line 137 | Line 175 | public class CountDownLatchTest extends
175       */
176      public void testAwaitTimeout() throws InterruptedException {
177          final CountDownLatch l = new CountDownLatch(1);
178 <        Thread t = new Thread(new CheckedRunnable() {
178 >        Thread t = newStartedThread(new CheckedRunnable() {
179              public void realRun() throws InterruptedException {
180 <                assertTrue(l.getCount() > 0);
181 <                assertFalse(l.await(SHORT_DELAY_MS, MILLISECONDS));
182 <                assertTrue(l.getCount() > 0);
180 >                assertEquals(1, l.getCount());
181 >
182 >                long startTime = System.nanoTime();
183 >                assertFalse(l.await(timeoutMillis(), MILLISECONDS));
184 >                assertTrue(millisElapsedSince(startTime) >= timeoutMillis());
185 >
186 >                assertEquals(1, l.getCount());
187              }});
188  
189 <        t.start();
190 <        assertEquals(l.getCount(), 1);
149 <        t.join();
189 >        awaitTermination(t);
190 >        assertEquals(1, l.getCount());
191      }
192  
193      /**
# Line 154 | Line 195 | public class CountDownLatchTest extends
195       */
196      public void testToString() {
197          CountDownLatch s = new CountDownLatch(2);
198 <        String us = s.toString();
158 <        assertTrue(us.indexOf("Count = 2") >= 0);
198 >        assertTrue(s.toString().contains("Count = 2"));
199          s.countDown();
200 <        String s1 = s.toString();
161 <        assertTrue(s1.indexOf("Count = 1") >= 0);
200 >        assertTrue(s.toString().contains("Count = 1"));
201          s.countDown();
202 <        String s2 = s.toString();
164 <        assertTrue(s2.indexOf("Count = 0") >= 0);
202 >        assertTrue(s.toString().contains("Count = 0"));
203      }
204  
205   }

Diff Legend

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