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

Comparing jsr166/src/test/tck/LinkedBlockingDequeTest.java (file contents):
Revision 1.39 by jsr166, Fri May 27 20:07:24 2011 UTC vs.
Revision 1.41 by jsr166, Tue May 31 16:16:24 2011 UTC

# Line 5 | Line 5
5   */
6  
7   import junit.framework.*;
8 < import java.util.*;
9 < import java.util.concurrent.*;
8 > import java.util.Arrays;
9 > import java.util.ArrayList;
10 > import java.util.Collection;
11 > import java.util.Iterator;
12 > import java.util.NoSuchElementException;
13 > import java.util.Queue;
14 > import java.util.concurrent.BlockingDeque;
15 > import java.util.concurrent.BlockingQueue;
16 > import java.util.concurrent.CountDownLatch;
17 > import java.util.concurrent.Executors;
18 > import java.util.concurrent.ExecutorService;
19 > import java.util.concurrent.LinkedBlockingDeque;
20   import static java.util.concurrent.TimeUnit.MILLISECONDS;
11 – import java.io.*;
21  
22   public class LinkedBlockingDequeTest extends JSR166TestCase {
23  
# Line 80 | Line 89 | public class LinkedBlockingDequeTest ext
89      }
90  
91      /**
92 <     * offer(null) throws NPE
92 >     * offerFirst(null) throws NullPointerException
93       */
94      public void testOfferFirstNull() {
95 +        LinkedBlockingDeque q = new LinkedBlockingDeque();
96          try {
87 –            LinkedBlockingDeque q = new LinkedBlockingDeque();
97              q.offerFirst(null);
98              shouldThrow();
99          } catch (NullPointerException success) {}
100      }
101  
102      /**
103 +     * offerLast(null) throws NullPointerException
104 +     */
105 +    public void testOfferLastNull() {
106 +        LinkedBlockingDeque q = new LinkedBlockingDeque();
107 +        try {
108 +            q.offerLast(null);
109 +            shouldThrow();
110 +        } catch (NullPointerException success) {}
111 +    }
112 +
113 +    /**
114       * OfferFirst succeeds
115       */
116      public void testOfferFirst() {
# Line 308 | Line 328 | public class LinkedBlockingDequeTest ext
328      }
329  
330      /**
331 <     * Constructor throws IAE if capacity argument nonpositive
331 >     * Constructor throws IllegalArgumentException if capacity argument nonpositive
332       */
333      public void testConstructor2() {
334          try {
335 <            LinkedBlockingDeque q = new LinkedBlockingDeque(0);
335 >            new LinkedBlockingDeque(0);
336              shouldThrow();
337          } catch (IllegalArgumentException success) {}
338      }
339  
340      /**
341 <     * Initializing from null Collection throws NPE
341 >     * Initializing from null Collection throws NullPointerException
342       */
343      public void testConstructor3() {
344          try {
345 <            LinkedBlockingDeque q = new LinkedBlockingDeque(null);
345 >            new LinkedBlockingDeque(null);
346              shouldThrow();
347          } catch (NullPointerException success) {}
348      }
349  
350      /**
351 <     * Initializing from Collection of null elements throws NPE
351 >     * Initializing from Collection of null elements throws NullPointerException
352       */
353      public void testConstructor4() {
354 +        Collection<Integer> elements = Arrays.asList(new Integer[SIZE]);
355          try {
356 <            Integer[] ints = new Integer[SIZE];
336 <            LinkedBlockingDeque q = new LinkedBlockingDeque(Arrays.asList(ints));
356 >            new LinkedBlockingDeque(elements);
357              shouldThrow();
358          } catch (NullPointerException success) {}
359      }
360  
361      /**
362 <     * Initializing from Collection with some null elements throws NPE
362 >     * Initializing from Collection with some null elements throws
363 >     * NullPointerException
364       */
365      public void testConstructor5() {
366 +        Integer[] ints = new Integer[SIZE];
367 +        for (int i = 0; i < SIZE-1; ++i)
368 +            ints[i] = i;
369 +        Collection<Integer> elements = Arrays.asList(ints);
370          try {
371 <            Integer[] ints = new Integer[SIZE];
347 <            for (int i = 0; i < SIZE-1; ++i)
348 <                ints[i] = new Integer(i);
349 <            LinkedBlockingDeque q = new LinkedBlockingDeque(Arrays.asList(ints));
371 >            new LinkedBlockingDeque(elements);
372              shouldThrow();
373          } catch (NullPointerException success) {}
374      }
# Line 357 | Line 379 | public class LinkedBlockingDequeTest ext
379      public void testConstructor6() {
380          Integer[] ints = new Integer[SIZE];
381          for (int i = 0; i < SIZE; ++i)
382 <            ints[i] = new Integer(i);
382 >            ints[i] = i;
383          LinkedBlockingDeque q = new LinkedBlockingDeque(Arrays.asList(ints));
384          for (int i = 0; i < SIZE; ++i)
385              assertEquals(ints[i], q.poll());
# Line 396 | Line 418 | public class LinkedBlockingDequeTest ext
418      }
419  
420      /**
399 –     * offer(null) throws NPE
400 –     */
401 –    public void testOfferNull() {
402 –        try {
403 –            LinkedBlockingDeque q = new LinkedBlockingDeque(1);
404 –            q.offer(null);
405 –            shouldThrow();
406 –        } catch (NullPointerException success) {}
407 –    }
408 –
409 –    /**
410 –     * add(null) throws NPE
411 –     */
412 –    public void testAddNull() {
413 –        try {
414 –            LinkedBlockingDeque q = new LinkedBlockingDeque(1);
415 –            q.add(null);
416 –            shouldThrow();
417 –        } catch (NullPointerException success) {}
418 –    }
419 –
420 –    /**
421       * push(null) throws NPE
422       */
423      public void testPushNull() {
# Line 482 | Line 482 | public class LinkedBlockingDequeTest ext
482       * add succeeds if not full; throws ISE if full
483       */
484      public void testAdd() {
485 +        LinkedBlockingDeque q = new LinkedBlockingDeque(SIZE);
486 +        for (int i = 0; i < SIZE; ++i)
487 +            assertTrue(q.add(new Integer(i)));
488 +        assertEquals(0, q.remainingCapacity());
489          try {
486 –            LinkedBlockingDeque q = new LinkedBlockingDeque(SIZE);
487 –            for (int i = 0; i < SIZE; ++i) {
488 –                assertTrue(q.add(new Integer(i)));
489 –            }
490 –            assertEquals(0, q.remainingCapacity());
490              q.add(new Integer(SIZE));
491              shouldThrow();
492          } catch (IllegalStateException success) {}
493      }
494  
495      /**
497 –     * addAll(null) throws NPE
498 –     */
499 –    public void testAddAll1() {
500 –        try {
501 –            LinkedBlockingDeque q = new LinkedBlockingDeque(1);
502 –            q.addAll(null);
503 –            shouldThrow();
504 –        } catch (NullPointerException success) {}
505 –    }
506 –
507 –    /**
496       * addAll(this) throws IAE
497       */
498      public void testAddAllSelf() {
499 +        LinkedBlockingDeque q = populatedDeque(SIZE);
500          try {
512 –            LinkedBlockingDeque q = populatedDeque(SIZE);
501              q.addAll(q);
502              shouldThrow();
503          } catch (IllegalArgumentException success) {}
504      }
505  
506      /**
519 –     * addAll of a collection with null elements throws NPE
520 –     */
521 –    public void testAddAll2() {
522 –        try {
523 –            LinkedBlockingDeque q = new LinkedBlockingDeque(SIZE);
524 –            Integer[] ints = new Integer[SIZE];
525 –            q.addAll(Arrays.asList(ints));
526 –            shouldThrow();
527 –        } catch (NullPointerException success) {}
528 –    }
529 –
530 –    /**
507       * addAll of a collection with any null elements throws NPE after
508       * possibly adding some elements
509       */
510      public void testAddAll3() {
511 +        LinkedBlockingDeque q = new LinkedBlockingDeque(SIZE);
512 +        Integer[] ints = new Integer[SIZE];
513 +        for (int i = 0; i < SIZE-1; ++i)
514 +            ints[i] = new Integer(i);
515 +        Collection<Integer> elements = Arrays.asList(ints);
516          try {
517 <            LinkedBlockingDeque q = new LinkedBlockingDeque(SIZE);
537 <            Integer[] ints = new Integer[SIZE];
538 <            for (int i = 0; i < SIZE-1; ++i)
539 <                ints[i] = new Integer(i);
540 <            q.addAll(Arrays.asList(ints));
517 >            q.addAll(elements);
518              shouldThrow();
519          } catch (NullPointerException success) {}
520      }
521  
522      /**
523 <     * addAll throws ISE if not enough room
523 >     * addAll throws IllegalStateException if not enough room
524       */
525      public void testAddAll4() {
526 +        LinkedBlockingDeque q = new LinkedBlockingDeque(SIZE - 1);
527 +        Integer[] ints = new Integer[SIZE];
528 +        for (int i = 0; i < SIZE; ++i)
529 +            ints[i] = new Integer(i);
530 +        Collection<Integer> elements = Arrays.asList(ints);
531          try {
532 <            LinkedBlockingDeque q = new LinkedBlockingDeque(1);
551 <            Integer[] ints = new Integer[SIZE];
552 <            for (int i = 0; i < SIZE; ++i)
553 <                ints[i] = new Integer(i);
554 <            q.addAll(Arrays.asList(ints));
532 >            q.addAll(elements);
533              shouldThrow();
534          } catch (IllegalStateException success) {}
535      }
# Line 572 | Line 550 | public class LinkedBlockingDequeTest ext
550      }
551  
552      /**
575 –     * put(null) throws NPE
576 –     */
577 –    public void testPutNull() throws InterruptedException {
578 –        try {
579 –            LinkedBlockingDeque q = new LinkedBlockingDeque(SIZE);
580 –            q.put(null);
581 –            shouldThrow();
582 –        } catch (NullPointerException success) {}
583 –    }
584 –
585 –    /**
553       * all elements successfully put are contained
554       */
555      public void testPut() throws InterruptedException {
# Line 807 | Line 774 | public class LinkedBlockingDequeTest ext
774       * putFirst(null) throws NPE
775       */
776      public void testPutFirstNull() throws InterruptedException {
777 +        LinkedBlockingDeque q = new LinkedBlockingDeque(SIZE);
778          try {
811 –            LinkedBlockingDeque q = new LinkedBlockingDeque(SIZE);
779              q.putFirst(null);
780              shouldThrow();
781          } catch (NullPointerException success) {}
# Line 1154 | Line 1121 | public class LinkedBlockingDequeTest ext
1121       * putLast(null) throws NPE
1122       */
1123      public void testPutLastNull() throws InterruptedException {
1124 +        LinkedBlockingDeque q = new LinkedBlockingDeque(SIZE);
1125          try {
1158 –            LinkedBlockingDeque q = new LinkedBlockingDeque(SIZE);
1126              q.putLast(null);
1127              shouldThrow();
1128          } catch (NullPointerException success) {}
# Line 1553 | Line 1520 | public class LinkedBlockingDequeTest ext
1520      }
1521  
1522      /**
1556 –     * toArray(null) throws NullPointerException
1557 –     */
1558 –    public void testToArray_NullArg() {
1559 –        LinkedBlockingDeque q = populatedDeque(SIZE);
1560 –        try {
1561 –            q.toArray(null);
1562 –            shouldThrow();
1563 –        } catch (NullPointerException success) {}
1564 –    }
1565 –
1566 –    /**
1523       * toArray(incompatible array type) throws ArrayStoreException
1524       */
1525      public void testToArray1_BadArg() {
# Line 1762 | Line 1718 | public class LinkedBlockingDequeTest ext
1718       * A deserialized serialized deque has same elements in same order
1719       */
1720      public void testSerialization() throws Exception {
1721 <        LinkedBlockingDeque q = populatedDeque(SIZE);
1722 <
1767 <        ByteArrayOutputStream bout = new ByteArrayOutputStream(10000);
1768 <        ObjectOutputStream out = new ObjectOutputStream(new BufferedOutputStream(bout));
1769 <        out.writeObject(q);
1770 <        out.close();
1771 <
1772 <        ByteArrayInputStream bin = new ByteArrayInputStream(bout.toByteArray());
1773 <        ObjectInputStream in = new ObjectInputStream(new BufferedInputStream(bin));
1774 <        LinkedBlockingDeque r = (LinkedBlockingDeque)in.readObject();
1775 <        assertEquals(q.size(), r.size());
1776 <        while (!q.isEmpty())
1777 <            assertEquals(q.remove(), r.remove());
1778 <    }
1721 >        Queue x = populatedDeque(SIZE);
1722 >        Queue y = serialClone(x);
1723  
1724 <    /**
1725 <     * drainTo(null) throws NPE
1726 <     */
1727 <    public void testDrainToNull() {
1728 <        LinkedBlockingDeque q = populatedDeque(SIZE);
1729 <        try {
1730 <            q.drainTo(null);
1731 <            shouldThrow();
1732 <        } catch (NullPointerException success) {}
1789 <    }
1790 <
1791 <    /**
1792 <     * drainTo(this) throws IAE
1793 <     */
1794 <    public void testDrainToSelf() {
1795 <        LinkedBlockingDeque q = populatedDeque(SIZE);
1796 <        try {
1797 <            q.drainTo(q);
1798 <            shouldThrow();
1799 <        } catch (IllegalArgumentException success) {}
1724 >        assertTrue(x != y);
1725 >        assertEquals(x.size(), y.size());
1726 >        assertEquals(x.toString(), y.toString());
1727 >        assertTrue(Arrays.equals(x.toArray(), y.toArray()));
1728 >        while (!x.isEmpty()) {
1729 >            assertFalse(y.isEmpty());
1730 >            assertEquals(x.remove(), y.remove());
1731 >        }
1732 >        assertTrue(y.isEmpty());
1733      }
1734  
1735      /**
# Line 1844 | Line 1777 | public class LinkedBlockingDequeTest ext
1777      }
1778  
1779      /**
1847 –     * drainTo(null, n) throws NPE
1848 –     */
1849 –    public void testDrainToNullN() {
1850 –        LinkedBlockingDeque q = populatedDeque(SIZE);
1851 –        try {
1852 –            q.drainTo(null, 0);
1853 –            shouldThrow();
1854 –        } catch (NullPointerException success) {}
1855 –    }
1856 –
1857 –    /**
1858 –     * drainTo(this, n) throws IAE
1859 –     */
1860 –    public void testDrainToSelfN() {
1861 –        LinkedBlockingDeque q = populatedDeque(SIZE);
1862 –        try {
1863 –            q.drainTo(q, 0);
1864 –            shouldThrow();
1865 –        } catch (IllegalArgumentException success) {}
1866 –    }
1867 –
1868 –    /**
1780       * drainTo(c, n) empties first min(n, size) elements of queue into c
1781       */
1782      public void testDrainToN() {

Diff Legend

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