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.43 by jsr166, Tue Oct 25 20:29:12 2011 UTC vs.
Revision 1.50 by jsr166, Sun Nov 23 22:27:06 2014 UTC

# Line 8 | Line 8 | import junit.framework.*;
8   import java.util.Arrays;
9   import java.util.ArrayList;
10   import java.util.Collection;
11 + import java.util.Deque;
12   import java.util.Iterator;
13   import java.util.NoSuchElementException;
14   import java.util.Queue;
# Line 44 | Line 45 | public class LinkedBlockingDequeTest ext
45      }
46  
47      /**
48 <     * Create a deque of given size containing consecutive
48 >     * Returns a new deque of given size containing consecutive
49       * Integers 0 ... n.
50       */
51      private LinkedBlockingDeque<Integer> populatedDeque(int n) {
# Line 622 | Line 623 | public class LinkedBlockingDequeTest ext
623              }});
624  
625          await(pleaseTake);
626 <        assertEquals(q.remainingCapacity(), 0);
626 >        assertEquals(0, q.remainingCapacity());
627          assertEquals(0, q.take());
628  
629          await(pleaseInterrupt);
630          assertThreadStaysAlive(t);
631          t.interrupt();
632          awaitTermination(t);
633 <        assertEquals(q.remainingCapacity(), 0);
633 >        assertEquals(0, q.remainingCapacity());
634      }
635  
636      /**
# Line 854 | Line 855 | public class LinkedBlockingDequeTest ext
855              }});
856  
857          await(pleaseTake);
858 <        assertEquals(q.remainingCapacity(), 0);
858 >        assertEquals(0, q.remainingCapacity());
859          assertEquals(capacity - 1, q.take());
860  
861          await(pleaseInterrupt);
862          assertThreadStaysAlive(t);
863          t.interrupt();
864          awaitTermination(t);
865 <        assertEquals(q.remainingCapacity(), 0);
865 >        assertEquals(0, q.remainingCapacity());
866      }
867  
868      /**
# Line 1064 | Line 1065 | public class LinkedBlockingDequeTest ext
1065  
1066                  pleaseInterrupt.countDown();
1067                  try {
1068 <                    q.pollFirst(SMALL_DELAY_MS, MILLISECONDS);
1068 >                    q.pollFirst(LONG_DELAY_MS, MILLISECONDS);
1069                      shouldThrow();
1070                  } catch (InterruptedException success) {}
1071                  assertFalse(Thread.interrupted());
# Line 1201 | Line 1202 | public class LinkedBlockingDequeTest ext
1202              }});
1203  
1204          await(pleaseTake);
1205 <        assertEquals(q.remainingCapacity(), 0);
1205 >        assertEquals(0, q.remainingCapacity());
1206          assertEquals(0, q.take());
1207  
1208          await(pleaseInterrupt);
1209          assertThreadStaysAlive(t);
1210          t.interrupt();
1211          awaitTermination(t);
1212 <        assertEquals(q.remainingCapacity(), 0);
1212 >        assertEquals(0, q.remainingCapacity());
1213      }
1214  
1215      /**
# Line 1700 | Line 1701 | public class LinkedBlockingDequeTest ext
1701          Queue x = populatedDeque(SIZE);
1702          Queue y = serialClone(x);
1703  
1704 <        assertTrue(x != y);
1704 >        assertNotSame(y, x);
1705          assertEquals(x.size(), y.size());
1706          assertEquals(x.toString(), y.toString());
1707          assertTrue(Arrays.equals(x.toArray(), y.toArray()));
# Line 1718 | Line 1719 | public class LinkedBlockingDequeTest ext
1719          LinkedBlockingDeque q = populatedDeque(SIZE);
1720          ArrayList l = new ArrayList();
1721          q.drainTo(l);
1722 <        assertEquals(q.size(), 0);
1723 <        assertEquals(l.size(), SIZE);
1722 >        assertEquals(0, q.size());
1723 >        assertEquals(SIZE, l.size());
1724          for (int i = 0; i < SIZE; ++i)
1725              assertEquals(l.get(i), new Integer(i));
1726          q.add(zero);
# Line 1729 | Line 1730 | public class LinkedBlockingDequeTest ext
1730          assertTrue(q.contains(one));
1731          l.clear();
1732          q.drainTo(l);
1733 <        assertEquals(q.size(), 0);
1734 <        assertEquals(l.size(), 2);
1733 >        assertEquals(0, q.size());
1734 >        assertEquals(2, l.size());
1735          for (int i = 0; i < 2; ++i)
1736              assertEquals(l.get(i), new Integer(i));
1737      }
# Line 1766 | Line 1767 | public class LinkedBlockingDequeTest ext
1767              ArrayList l = new ArrayList();
1768              q.drainTo(l, i);
1769              int k = (i < SIZE) ? i : SIZE;
1770 <            assertEquals(l.size(), k);
1771 <            assertEquals(q.size(), SIZE-k);
1770 >            assertEquals(k, l.size());
1771 >            assertEquals(SIZE-k, q.size());
1772              for (int j = 0; j < k; ++j)
1773                  assertEquals(l.get(j), new Integer(j));
1774              while (q.poll() != null) ;
1775          }
1776      }
1777  
1778 +    /**
1779 +     * remove(null), contains(null) always return false
1780 +     */
1781 +    public void testNeverContainsNull() {
1782 +        Deque<?>[] qs = {
1783 +            new LinkedBlockingDeque<Object>(),
1784 +            populatedDeque(2),
1785 +        };
1786 +
1787 +        for (Deque<?> q : qs) {
1788 +            assertFalse(q.contains(null));
1789 +            assertFalse(q.remove(null));
1790 +            assertFalse(q.removeFirstOccurrence(null));
1791 +            assertFalse(q.removeLastOccurrence(null));
1792 +        }
1793 +    }
1794 +
1795   }

Diff Legend

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