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

Comparing jsr166/src/test/tck/SynchronousQueueTest.java (file contents):
Revision 1.53 by jsr166, Sat May 13 21:52:59 2017 UTC vs.
Revision 1.63 by jsr166, Sun Aug 11 22:29:27 2019 UTC

# Line 18 | Line 18 | import java.util.concurrent.CountDownLat
18   import java.util.concurrent.Executors;
19   import java.util.concurrent.ExecutorService;
20   import java.util.concurrent.SynchronousQueue;
21 + import java.util.concurrent.ThreadLocalRandom;
22  
23   import junit.framework.Test;
24  
# Line 96 | Line 97 | public class SynchronousQueueTest extend
97      }
98  
99      /**
100 <     * addAll throws ISE if no active taker
100 >     * addAll throws IllegalStateException if no active taker
101       */
102      public void testAddAll_ISE()      { testAddAll_ISE(false); }
103      public void testAddAll_ISE_fair() { testAddAll_ISE(true); }
# Line 138 | Line 139 | public class SynchronousQueueTest extend
139              }});
140  
141          await(pleaseInterrupt);
142 <        assertThreadStaysAlive(t);
142 >        if (randomBoolean()) assertThreadBlocks(t, Thread.State.WAITING);
143          t.interrupt();
144          awaitTermination(t);
145          assertEquals(0, q.remainingCapacity());
# Line 158 | Line 159 | public class SynchronousQueueTest extend
159                  pleaseTake.countDown();
160                  q.put(one);
161  
162 +                Thread.currentThread().interrupt();
163 +                try {
164 +                    q.put(99);
165 +                    shouldThrow();
166 +                } catch (InterruptedException success) {}
167 +                assertFalse(Thread.interrupted());
168 +
169                  pleaseInterrupt.countDown();
170                  try {
171                      q.put(99);
# Line 172 | Line 180 | public class SynchronousQueueTest extend
180          catch (InterruptedException e) { threadUnexpectedException(e); }
181  
182          await(pleaseInterrupt);
183 <        assertThreadBlocks(t, Thread.State.WAITING);
183 >        if (randomBoolean()) assertThreadBlocks(t, Thread.State.WAITING);
184          t.interrupt();
185          awaitTermination(t);
186          assertEquals(0, q.remainingCapacity());
# Line 181 | Line 189 | public class SynchronousQueueTest extend
189      /**
190       * timed offer times out if elements not taken
191       */
192 <    public void testTimedOffer()      { testTimedOffer(false); }
193 <    public void testTimedOffer_fair() { testTimedOffer(true); }
186 <    public void testTimedOffer(boolean fair) {
192 >    public void testTimedOffer() {
193 >        final boolean fair = ThreadLocalRandom.current().nextBoolean();
194          final SynchronousQueue q = new SynchronousQueue(fair);
195          final CountDownLatch pleaseInterrupt = new CountDownLatch(1);
196          Thread t = newStartedThread(new CheckedRunnable() {
197              public void realRun() throws InterruptedException {
198                  long startTime = System.nanoTime();
199 +
200                  assertFalse(q.offer(new Object(), timeoutMillis(), MILLISECONDS));
201                  assertTrue(millisElapsedSince(startTime) >= timeoutMillis());
202 +
203 +                Thread.currentThread().interrupt();
204 +                try {
205 +                    q.offer(new Object(), randomTimeout(), randomTimeUnit());
206 +                    shouldThrow();
207 +                } catch (InterruptedException success) {}
208 +                assertFalse(Thread.interrupted());
209 +
210                  pleaseInterrupt.countDown();
211                  try {
212 <                    q.offer(new Object(), 2 * LONG_DELAY_MS, MILLISECONDS);
212 >                    q.offer(new Object(), LONG_DELAY_MS, MILLISECONDS);
213                      shouldThrow();
214                  } catch (InterruptedException success) {}
215 +                assertFalse(Thread.interrupted());
216 +
217 +                assertTrue(millisElapsedSince(startTime) < LONG_DELAY_MS);
218              }});
219  
220          await(pleaseInterrupt);
221 <        assertThreadStaysAlive(t);
221 >        if (randomBoolean()) assertThreadBlocks(t, Thread.State.TIMED_WAITING);
222          t.interrupt();
223          awaitTermination(t);
224      }
# Line 228 | Line 247 | public class SynchronousQueueTest extend
247      /**
248       * timed poll with nonzero timeout times out if no active putter
249       */
250 <    public void testTimedPoll()      { testTimedPoll(false); }
251 <    public void testTimedPoll_fair() { testTimedPoll(true); }
233 <    public void testTimedPoll(boolean fair) {
250 >    public void testTimedPoll() {
251 >        final boolean fair = ThreadLocalRandom.current().nextBoolean();
252          final SynchronousQueue q = new SynchronousQueue(fair);
253 <        long startTime = System.nanoTime();
253 >        final long startTime = System.nanoTime();
254          try { assertNull(q.poll(timeoutMillis(), MILLISECONDS)); }
255          catch (InterruptedException e) { threadUnexpectedException(e); }
256          assertTrue(millisElapsedSince(startTime) >= timeoutMillis());
# Line 242 | Line 260 | public class SynchronousQueueTest extend
260       * timed poll before a delayed offer times out, returning null;
261       * after offer succeeds; on interruption throws
262       */
263 <    public void testTimedPollWithOffer()      { testTimedPollWithOffer(false); }
264 <    public void testTimedPollWithOffer_fair() { testTimedPollWithOffer(true); }
247 <    public void testTimedPollWithOffer(boolean fair) {
263 >    public void testTimedPollWithOffer() {
264 >        final boolean fair = ThreadLocalRandom.current().nextBoolean();
265          final SynchronousQueue q = new SynchronousQueue(fair);
266          final CountDownLatch pleaseOffer = new CountDownLatch(1);
267          final CountDownLatch pleaseInterrupt = new CountDownLatch(1);
# Line 260 | Line 277 | public class SynchronousQueueTest extend
277  
278                  Thread.currentThread().interrupt();
279                  try {
280 <                    q.poll(LONG_DELAY_MS, MILLISECONDS);
280 >                    q.poll(randomTimeout(), randomTimeUnit());
281                      shouldThrow();
282                  } catch (InterruptedException success) {}
283                  assertFalse(Thread.interrupted());
# Line 282 | Line 299 | public class SynchronousQueueTest extend
299          assertTrue(millisElapsedSince(startTime) < LONG_DELAY_MS);
300  
301          await(pleaseInterrupt);
302 <        assertThreadStaysAlive(t);
302 >        if (randomBoolean()) assertThreadBlocks(t, Thread.State.TIMED_WAITING);
303          t.interrupt();
304          awaitTermination(t);
305      }
# Line 423 | Line 440 | public class SynchronousQueueTest extend
440      public void testToArray_null(boolean fair) {
441          final SynchronousQueue q = new SynchronousQueue(fair);
442          try {
443 <            Object[] o = q.toArray(null);
443 >            Object[] o = q.toArray((Object[])null);
444              shouldThrow();
445          } catch (NullPointerException success) {}
446      }
# Line 438 | Line 455 | public class SynchronousQueueTest extend
455      }
456  
457      /**
458 <     * iterator remove throws ISE
458 >     * iterator remove throws IllegalStateException
459       */
460      public void testIteratorRemove()      { testIteratorRemove(false); }
461      public void testIteratorRemove_fair() { testIteratorRemove(true); }
# Line 516 | Line 533 | public class SynchronousQueueTest extend
533      }
534  
535      /**
536 <     * a deserialized serialized queue is usable
536 >     * a deserialized/reserialized queue is usable
537       */
538      public void testSerialization() {
539          final SynchronousQueue x = new SynchronousQueue();

Diff Legend

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