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.21 by jsr166, Wed Aug 25 00:07:03 2010 UTC vs.
Revision 1.27 by jsr166, Thu Oct 28 17:57:26 2010 UTC

# Line 14 | Line 14 | import java.io.*;
14  
15   public class SynchronousQueueTest extends JSR166TestCase {
16  
17 +    public static class Fair extends BlockingQueueTest {
18 +        protected BlockingQueue emptyCollection() {
19 +            return new SynchronousQueue(true);
20 +        }
21 +    }
22 +
23 +    public static class NonFair extends BlockingQueueTest {
24 +        protected BlockingQueue emptyCollection() {
25 +            return new SynchronousQueue(false);
26 +        }
27 +    }
28 +
29      public static void main(String[] args) {
30          junit.textui.TestRunner.run(suite());
31      }
32  
33      public static Test suite() {
34 <        return new TestSuite(SynchronousQueueTest.class);
34 >        return newTestSuite(SynchronousQueueTest.class,
35 >                            new Fair().testSuite(),
36 >                            new NonFair().testSuite());
37      }
38  
39      /**
# Line 119 | Line 133 | public class SynchronousQueueTest extend
133              shouldThrow();
134          } catch (NullPointerException success) {}
135      }
136 +
137      /**
138       * addAll throws ISE if no active taker
139       */
# Line 174 | Line 189 | public class SynchronousQueueTest extend
189                          ++added;
190                      }
191                  } catch (InterruptedException success) {
192 <                    assertTrue(added == 1);
192 >                    assertEquals(1, added);
193                  }
194              }});
195  
# Line 203 | Line 218 | public class SynchronousQueueTest extend
218          t.join();
219      }
220  
206 –
207 –    /**
208 –     * take blocks interruptibly when empty
209 –     */
210 –    public void testTakeFromEmpty() throws InterruptedException {
211 –        final SynchronousQueue q = new SynchronousQueue();
212 –        Thread t = new Thread(new CheckedInterruptedRunnable() {
213 –            public void realRun() throws InterruptedException {
214 –                q.take();
215 –            }});
216 –
217 –        t.start();
218 –        Thread.sleep(SHORT_DELAY_MS);
219 –        t.interrupt();
220 –        t.join();
221 –    }
222 –
223 –
221      /**
222       * put blocks interruptibly if no active taker
223       */
# Line 251 | Line 248 | public class SynchronousQueueTest extend
248                          ++added;
249                      }
250                  } catch (InterruptedException success) {
251 <                    assertTrue(added == 1);
251 >                    assertEquals(1, added);
252                  }
253              }});
254  
# Line 339 | Line 336 | public class SynchronousQueueTest extend
336      }
337  
338      /**
342 –     *  timed poll before a delayed offer fails; after offer succeeds;
343 –     *  on interruption throws
344 –     */
345 –    public void testTimedPollWithOffer() throws InterruptedException {
346 –        final SynchronousQueue q = new SynchronousQueue();
347 –        Thread t = new Thread(new CheckedRunnable() {
348 –            public void realRun() throws InterruptedException {
349 –                assertNull(q.poll(SHORT_DELAY_MS, MILLISECONDS));
350 –                assertSame(zero, q.poll(LONG_DELAY_MS, MILLISECONDS));
351 –                try {
352 –                    q.poll(LONG_DELAY_MS, MILLISECONDS);
353 –                    shouldThrow();
354 –                } catch (InterruptedException success) {}
355 –            }});
356 –
357 –        t.start();
358 –        Thread.sleep(SMALL_DELAY_MS);
359 –        assertTrue(q.offer(zero, SHORT_DELAY_MS, MILLISECONDS));
360 –        t.interrupt();
361 –        t.join();
362 –    }
363 –
364 –    /**
339       * Interrupted timed poll throws InterruptedException instead of
340       * returning timeout status
341       */
# Line 379 | Line 353 | public class SynchronousQueueTest extend
353      }
354  
355      /**
356 <     *  timed poll before a delayed offer fails; after offer succeeds;
357 <     *  on interruption throws
356 >     * timed poll before a delayed offer fails; after offer succeeds;
357 >     * on interruption throws
358       */
359      public void testFairTimedPollWithOffer() throws InterruptedException {
360          final SynchronousQueue q = new SynchronousQueue(true);
361          Thread t = new Thread(new CheckedRunnable() {
362              public void realRun() throws InterruptedException {
389 –                assertNull(q.poll(SHORT_DELAY_MS, MILLISECONDS));
390 –                assertSame(zero, q.poll(LONG_DELAY_MS, MILLISECONDS));
363                  try {
364 +                    assertNull(q.poll(SHORT_DELAY_MS, MILLISECONDS));
365 +                    assertSame(zero, q.poll(LONG_DELAY_MS, MILLISECONDS));
366                      q.poll(LONG_DELAY_MS, MILLISECONDS);
367                      threadShouldThrow();
368                  } catch (InterruptedException success) {}
# Line 716 | Line 690 | public class SynchronousQueueTest extend
690          ArrayList l = new ArrayList();
691          Thread.sleep(SHORT_DELAY_MS);
692          q.drainTo(l, 1);
693 <        assertTrue(l.size() == 1);
693 >        assertEquals(1, l.size());
694          q.drainTo(l, 1);
695 <        assertTrue(l.size() == 2);
695 >        assertEquals(2, l.size());
696          assertTrue(l.contains(one));
697          assertTrue(l.contains(two));
698          t1.join();

Diff Legend

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