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.28 by jsr166, Thu Oct 28 22:20:47 2010 UTC vs.
Revision 1.29 by jsr166, Thu Nov 18 20:18:43 2010 UTC

# Line 37 | Line 37 | public class SynchronousQueueTest extend
37      }
38  
39      /**
40 <     * A SynchronousQueue is both empty and full
40 >     * Any SynchronousQueue is both empty and full
41       */
42 <    public void testEmptyFull() {
43 <        SynchronousQueue q = new SynchronousQueue();
42 >    public void testEmptyFull(SynchronousQueue q) {
43          assertTrue(q.isEmpty());
44          assertEquals(0, q.size());
45          assertEquals(0, q.remainingCapacity());
# Line 48 | Line 47 | public class SynchronousQueueTest extend
47      }
48  
49      /**
50 +     * A non-fair SynchronousQueue is both empty and full
51 +     */
52 +    public void testEmptyFull() {
53 +        testEmptyFull(new SynchronousQueue());
54 +    }
55 +
56 +    /**
57       * A fair SynchronousQueue is both empty and full
58       */
59      public void testFairEmptyFull() {
60 <        SynchronousQueue q = new SynchronousQueue(true);
55 <        assertTrue(q.isEmpty());
56 <        assertEquals(0, q.size());
57 <        assertEquals(0, q.remainingCapacity());
58 <        assertFalse(q.offer(zero));
60 >        testEmptyFull(new SynchronousQueue(true));
61      }
62  
63      /**
# Line 204 | Line 206 | public class SynchronousQueueTest extend
206      /**
207       * timed offer times out if elements not taken
208       */
209 <    public void testTimedOffer() throws InterruptedException {
210 <        final SynchronousQueue q = new SynchronousQueue();
211 <        Thread t = new Thread(new CheckedInterruptedRunnable() {
209 >    public void testTimedOffer(final SynchronousQueue q)
210 >            throws InterruptedException {
211 >        final CountDownLatch pleaseInterrupt = new CountDownLatch(1);
212 >        Thread t = newStartedThread(new CheckedRunnable() {
213              public void realRun() throws InterruptedException {
214 +                long t0 = System.nanoTime();
215                  assertFalse(q.offer(new Object(), SHORT_DELAY_MS, MILLISECONDS));
216 <                q.offer(new Object(), LONG_DELAY_MS, MILLISECONDS);
216 >                assertTrue(millisElapsedSince(t0) >= SHORT_DELAY_MS);
217 >                pleaseInterrupt.countDown();
218 >                t0 = System.nanoTime();
219 >                try {
220 >                    q.offer(new Object(), LONG_DELAY_MS, MILLISECONDS);
221 >                    shouldThrow();
222 >                } catch (InterruptedException success) {}
223 >                assertTrue(millisElapsedSince(t0) < MEDIUM_DELAY_MS);
224              }});
225  
226 <        t.start();
216 <        Thread.sleep(SMALL_DELAY_MS);
226 >        assertTrue(pleaseInterrupt.await(MEDIUM_DELAY_MS, MILLISECONDS));
227          t.interrupt();
228 <        t.join();
228 >        awaitTermination(t, MEDIUM_DELAY_MS);
229 >    }
230 >
231 >    /**
232 >     * timed offer times out if elements not taken
233 >     */
234 >    public void testTimedOffer() throws InterruptedException {
235 >        testTimedOffer(new SynchronousQueue());
236 >    }
237 >
238 >    /**
239 >     * timed offer times out if elements not taken
240 >     */
241 >    public void testFairTimedOffer() throws InterruptedException {
242 >        testTimedOffer(new SynchronousQueue(true));
243      }
244  
245      /**
# Line 261 | Line 285 | public class SynchronousQueueTest extend
285      }
286  
287      /**
264 –     * timed offer times out if elements not taken
265 –     */
266 –    public void testFairTimedOffer() throws InterruptedException {
267 –        final SynchronousQueue q = new SynchronousQueue(true);
268 –        Thread t = new Thread(new CheckedInterruptedRunnable() {
269 –            public void realRun() throws InterruptedException {
270 –                assertFalse(q.offer(new Object(), SHORT_DELAY_MS, MILLISECONDS));
271 –                q.offer(new Object(), LONG_DELAY_MS, MILLISECONDS);
272 –            }});
273 –
274 –        t.start();
275 –        Thread.sleep(SMALL_DELAY_MS);
276 –        t.interrupt();
277 –        t.join();
278 –    }
279 –
280 –
281 –    /**
288       * take blocks interruptibly when empty
289       */
290      public void testFairTakeFromEmpty() throws InterruptedException {
# Line 295 | Line 301 | public class SynchronousQueueTest extend
301      }
302  
303      /**
304 <     * poll fails unless active taker
304 >     * poll return null if no active putter
305       */
306      public void testPoll() {
307          SynchronousQueue q = new SynchronousQueue();
# Line 303 | Line 309 | public class SynchronousQueueTest extend
309      }
310  
311      /**
312 <     * timed poll with zero timeout times out if no active taker
312 >     * timed poll with zero timeout times out if no active putter
313       */
314      public void testTimedPoll0() throws InterruptedException {
315          SynchronousQueue q = new SynchronousQueue();
# Line 311 | Line 317 | public class SynchronousQueueTest extend
317      }
318  
319      /**
320 <     * timed poll with nonzero timeout times out if no active taker
320 >     * timed poll with nonzero timeout times out if no active putter
321       */
322      public void testTimedPoll() throws InterruptedException {
323          SynchronousQueue q = new SynchronousQueue();
324 +        long t0 = System.nanoTime();
325          assertNull(q.poll(SHORT_DELAY_MS, MILLISECONDS));
326 +        assertTrue(millisElapsedSince(t0) >= SHORT_DELAY_MS);
327      }
328  
329      /**
330       * Interrupted timed poll throws InterruptedException instead of
331       * returning timeout status
332       */
333 <    public void testInterruptedTimedPoll() throws InterruptedException {
334 <        final SynchronousQueue q = new SynchronousQueue();
335 <        Thread t = new Thread(new CheckedInterruptedRunnable() {
333 >    public void testInterruptedTimedPoll(final SynchronousQueue q)
334 >            throws InterruptedException {
335 >        final CountDownLatch threadStarted = new CountDownLatch(1);
336 >        Thread t = newStartedThread(new CheckedRunnable() {
337              public void realRun() throws InterruptedException {
338 <                q.poll(SMALL_DELAY_MS, MILLISECONDS);
338 >                long t0 = System.nanoTime();
339 >                threadStarted.countDown();
340 >                try {
341 >                    q.poll(LONG_DELAY_MS, MILLISECONDS);
342 >                    shouldThrow();
343 >                } catch (InterruptedException success) {}
344 >                assertTrue(millisElapsedSince(t0) >= SHORT_DELAY_MS);
345 >                assertTrue(millisElapsedSince(t0) < MEDIUM_DELAY_MS);
346              }});
347  
348 <        t.start();
348 >        threadStarted.await();
349          Thread.sleep(SHORT_DELAY_MS);
350          t.interrupt();
351 <        t.join();
351 >        awaitTermination(t, MEDIUM_DELAY_MS);
352      }
353  
354      /**
355       * Interrupted timed poll throws InterruptedException instead of
356       * returning timeout status
357       */
358 <    public void testFairInterruptedTimedPoll() throws InterruptedException {
359 <        Thread t = new Thread(new CheckedInterruptedRunnable() {
360 <            public void realRun() throws InterruptedException {
345 <                SynchronousQueue q = new SynchronousQueue(true);
346 <                q.poll(SMALL_DELAY_MS, MILLISECONDS);
347 <            }});
358 >    public void testInterruptedTimedPoll() throws InterruptedException {
359 >        testInterruptedTimedPoll(new SynchronousQueue());
360 >    }
361  
362 <        t.start();
363 <        Thread.sleep(SHORT_DELAY_MS);
364 <        t.interrupt();
365 <        t.join();
362 >    /**
363 >     * Interrupted timed poll throws InterruptedException instead of
364 >     * returning timeout status
365 >     */
366 >    public void testFairInterruptedTimedPoll() throws InterruptedException {
367 >        testInterruptedTimedPoll(new SynchronousQueue(true));
368      }
369  
370      /**
371 <     * timed poll before a delayed offer fails; after offer succeeds;
372 <     * on interruption throws
371 >     * timed poll before a delayed offer times out, returning null;
372 >     * after offer succeeds; on interruption throws
373       */
374      public void testFairTimedPollWithOffer() throws InterruptedException {
375          final SynchronousQueue q = new SynchronousQueue(true);
376 <        Thread t = new Thread(new CheckedRunnable() {
376 >        final CountDownLatch pleaseOffer = new CountDownLatch(1);
377 >        Thread t = newStartedThread(new CheckedRunnable() {
378              public void realRun() throws InterruptedException {
379 +                long t0 = System.nanoTime();
380 +                assertNull(q.poll(SHORT_DELAY_MS, MILLISECONDS));
381 +                assertTrue(millisElapsedSince(t0) >= SHORT_DELAY_MS);
382 +
383 +                pleaseOffer.countDown();
384 +                t0 = System.nanoTime();
385 +                assertSame(zero, q.poll(LONG_DELAY_MS, MILLISECONDS));
386 +                assertTrue(millisElapsedSince(t0) < MEDIUM_DELAY_MS);
387 +
388 +                t0 = System.nanoTime();
389                  try {
364 –                    assertNull(q.poll(SHORT_DELAY_MS, MILLISECONDS));
365 –                    assertSame(zero, q.poll(LONG_DELAY_MS, MILLISECONDS));
390                      q.poll(LONG_DELAY_MS, MILLISECONDS);
391 <                    threadShouldThrow();
391 >                    shouldThrow();
392                  } catch (InterruptedException success) {}
393 +                assertTrue(millisElapsedSince(t0) < MEDIUM_DELAY_MS);
394              }});
395  
396 <        t.start();
397 <        Thread.sleep(SMALL_DELAY_MS);
398 <        assertTrue(q.offer(zero, SHORT_DELAY_MS, MILLISECONDS));
396 >        assertTrue(pleaseOffer.await(MEDIUM_DELAY_MS, MILLISECONDS));
397 >        long t0 = System.nanoTime();
398 >        assertTrue(q.offer(zero, LONG_DELAY_MS, MILLISECONDS));
399 >        assertTrue(millisElapsedSince(t0) < MEDIUM_DELAY_MS);
400 >        
401          t.interrupt();
402 <        t.join();
402 >        awaitTermination(t, MEDIUM_DELAY_MS);
403      }
404  
378 –
405      /**
406 <     * peek returns null
406 >     * peek() returns null if no active putter
407       */
408      public void testPeek() {
409          SynchronousQueue q = new SynchronousQueue();
# Line 385 | Line 411 | public class SynchronousQueueTest extend
411      }
412  
413      /**
414 <     * element throws NSEE
414 >     * element() throws NSEE if no active putter
415       */
416      public void testElement() {
417          SynchronousQueue q = new SynchronousQueue();
# Line 396 | Line 422 | public class SynchronousQueueTest extend
422      }
423  
424      /**
425 <     * remove throws NSEE if no active taker
425 >     * remove() throws NSEE if no active putter
426       */
427      public void testRemove() {
428          SynchronousQueue q = new SynchronousQueue();

Diff Legend

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