java.util.concurrent.ConcurrentLinkedDeque

Here are the examples of the java api class java.util.concurrent.ConcurrentLinkedDeque taken from open source projects.

1. ConcurrentLinkedDequeTest#testWeaklyConsistentIteration()

Project: openjdk
File: ConcurrentLinkedDequeTest.java
/**
     * Modifications do not cause iterators to fail
     */
public void testWeaklyConsistentIteration() {
    final ConcurrentLinkedDeque q = new ConcurrentLinkedDeque();
    q.add(one);
    q.add(two);
    q.add(three);
    for (Iterator it = q.iterator(); it.hasNext(); ) {
        q.remove();
        it.next();
    }
    assertEquals("deque should be empty again", 0, q.size());
}

2. ConcurrentLinkedDequeTest#testIteratorOrdering()

Project: openjdk
File: ConcurrentLinkedDequeTest.java
/**
     * Iterator ordering is FIFO
     */
public void testIteratorOrdering() {
    final ConcurrentLinkedDeque q = new ConcurrentLinkedDeque();
    q.add(one);
    q.add(two);
    q.add(three);
    int k = 0;
    for (Iterator it = q.iterator(); it.hasNext(); ) {
        assertEquals(++k, it.next());
    }
    assertEquals(3, k);
}

3. ConcurrentLinkedDequeTest#testWeaklyConsistentIteration()

Project: mapdb
File: ConcurrentLinkedDequeTest.java
/**
     * Modifications do not cause iterators to fail
     */
public void testWeaklyConsistentIteration() {
    final ConcurrentLinkedDeque q = new ConcurrentLinkedDeque();
    q.add(one);
    q.add(two);
    q.add(three);
    for (Iterator it = q.iterator(); it.hasNext(); ) {
        q.remove();
        it.next();
    }
    assertEquals("deque should be empty again", 0, q.size());
}

4. ConcurrentLinkedDequeTest#testIteratorOrdering()

Project: mapdb
File: ConcurrentLinkedDequeTest.java
/**
     * Iterator ordering is FIFO
     */
public void testIteratorOrdering() {
    final ConcurrentLinkedDeque q = new ConcurrentLinkedDeque();
    q.add(one);
    q.add(two);
    q.add(three);
    int k = 0;
    for (Iterator it = q.iterator(); it.hasNext(); ) {
        assertEquals(++k, it.next());
    }
    assertEquals(3, k);
}

5. ConcurrentLinkedDequeTest#testRetainAll()

Project: openjdk
File: ConcurrentLinkedDequeTest.java
/**
     * retainAll(c) retains only those elements of c and reports true if change
     */
public void testRetainAll() {
    ConcurrentLinkedDeque q = populatedDeque(SIZE);
    ConcurrentLinkedDeque p = populatedDeque(SIZE);
    for (int i = 0; i < SIZE; ++i) {
        boolean changed = q.retainAll(p);
        if (i == 0)
            assertFalse(changed);
        else
            assertTrue(changed);
        assertTrue(q.containsAll(p));
        assertEquals(SIZE - i, q.size());
        p.remove();
    }
}

6. ConcurrentLinkedDequeTest#testRetainAll()

Project: mapdb
File: ConcurrentLinkedDequeTest.java
/**
     * retainAll(c) retains only those elements of c and reports true if change
     */
public void testRetainAll() {
    ConcurrentLinkedDeque q = populatedDeque(SIZE);
    ConcurrentLinkedDeque p = populatedDeque(SIZE);
    for (int i = 0; i < SIZE; ++i) {
        boolean changed = q.retainAll(p);
        if (i == 0)
            assertFalse(changed);
        else
            assertTrue(changed);
        assertTrue(q.containsAll(p));
        assertEquals(SIZE - i, q.size());
        p.remove();
    }
}

7. ConcurrentLinkedDequeTest#testDescendingIteratorRemove()

Project: openjdk
File: ConcurrentLinkedDequeTest.java
/**
     * descendingIterator.remove() removes current element
     */
public void testDescendingIteratorRemove() {
    final ConcurrentLinkedDeque q = new ConcurrentLinkedDeque();
    final Random rng = new Random();
    for (int iters = 0; iters < 100; ++iters) {
        int max = rng.nextInt(5) + 2;
        int split = rng.nextInt(max - 1) + 1;
        for (int j = max; j >= 1; --j) q.add(new Integer(j));
        Iterator it = q.descendingIterator();
        for (int j = 1; j <= split; ++j) assertEquals(it.next(), new Integer(j));
        it.remove();
        assertEquals(it.next(), new Integer(split + 1));
        for (int j = 1; j <= split; ++j) q.remove(new Integer(j));
        it = q.descendingIterator();
        for (int j = split + 1; j <= max; ++j) {
            assertEquals(it.next(), new Integer(j));
            it.remove();
        }
        assertFalse(it.hasNext());
        assertTrue(q.isEmpty());
    }
}

8. ConcurrentLinkedDequeTest#testDescendingIteratorOrdering()

Project: openjdk
File: ConcurrentLinkedDequeTest.java
/**
     * Descending iterator ordering is reverse FIFO
     */
public void testDescendingIteratorOrdering() {
    final ConcurrentLinkedDeque q = new ConcurrentLinkedDeque();
    for (int iters = 0; iters < 100; ++iters) {
        q.add(new Integer(3));
        q.add(new Integer(2));
        q.add(new Integer(1));
        int k = 0;
        for (Iterator it = q.descendingIterator(); it.hasNext(); ) {
            assertEquals(++k, it.next());
        }
        assertEquals(3, k);
        q.remove();
        q.remove();
        q.remove();
    }
}

9. ConcurrentLinkedDequeTest#testDescendingIterator()

Project: openjdk
File: ConcurrentLinkedDequeTest.java
/**
     * Descending iterator iterates through all elements
     */
public void testDescendingIterator() {
    ConcurrentLinkedDeque q = populatedDeque(SIZE);
    int i = 0;
    Iterator it = q.descendingIterator();
    while (it.hasNext()) {
        assertTrue(q.contains(it.next()));
        ++i;
    }
    assertEquals(i, SIZE);
    assertFalse(it.hasNext());
    try {
        it.next();
        shouldThrow();
    } catch (NoSuchElementException success) {
    }
}

10. ConcurrentLinkedDequeTest#testIteratorRemove()

Project: openjdk
File: ConcurrentLinkedDequeTest.java
/**
     * iterator.remove() removes current element
     */
public void testIteratorRemove() {
    final ConcurrentLinkedDeque q = new ConcurrentLinkedDeque();
    final Random rng = new Random();
    for (int iters = 0; iters < 100; ++iters) {
        int max = rng.nextInt(5) + 2;
        int split = rng.nextInt(max - 1) + 1;
        for (int j = 1; j <= max; ++j) q.add(new Integer(j));
        Iterator it = q.iterator();
        for (int j = 1; j <= split; ++j) assertEquals(it.next(), new Integer(j));
        it.remove();
        assertEquals(it.next(), new Integer(split + 1));
        for (int j = 1; j <= split; ++j) q.remove(new Integer(j));
        it = q.iterator();
        for (int j = split + 1; j <= max; ++j) {
            assertEquals(it.next(), new Integer(j));
            it.remove();
        }
        assertFalse(it.hasNext());
        assertTrue(q.isEmpty());
    }
}

11. ConcurrentLinkedDequeTest#testLastElement()

Project: openjdk
File: ConcurrentLinkedDequeTest.java
/**
     * getLast() returns last element, or throws NSEE if empty
     */
public void testLastElement() {
    ConcurrentLinkedDeque q = populatedDeque(SIZE);
    for (int i = SIZE - 1; i >= 0; --i) {
        assertEquals(i, q.getLast());
        assertEquals(i, q.pollLast());
    }
    try {
        q.getLast();
        shouldThrow();
    } catch (NoSuchElementException success) {
    }
    assertNull(q.peekLast());
}

12. ConcurrentLinkedDequeTest#testRemoveElement()

Project: openjdk
File: ConcurrentLinkedDequeTest.java
/**
     * remove(x) removes x and returns true if present
     */
public void testRemoveElement() {
    ConcurrentLinkedDeque q = populatedDeque(SIZE);
    for (int i = 1; i < SIZE; i += 2) {
        assertTrue(q.contains(i));
        assertTrue(q.remove(i));
        assertFalse(q.contains(i));
        assertTrue(q.contains(i - 1));
    }
    for (int i = 0; i < SIZE; i += 2) {
        assertTrue(q.contains(i));
        assertTrue(q.remove(i));
        assertFalse(q.contains(i));
        assertFalse(q.remove(i + 1));
        assertFalse(q.contains(i + 1));
    }
    assertTrue(q.isEmpty());
}

13. ConcurrentLinkedDequeTest#testDescendingIteratorRemove()

Project: mapdb
File: ConcurrentLinkedDequeTest.java
/**
     * descendingIterator.remove() removes current element
     */
public void testDescendingIteratorRemove() {
    final ConcurrentLinkedDeque q = new ConcurrentLinkedDeque();
    final Random rng = new Random();
    for (int iters = 0; iters < 100; ++iters) {
        int max = rng.nextInt(5) + 2;
        int split = rng.nextInt(max - 1) + 1;
        for (int j = max; j >= 1; --j) q.add(new Integer(j));
        Iterator it = q.descendingIterator();
        for (int j = 1; j <= split; ++j) assertEquals(it.next(), new Integer(j));
        it.remove();
        assertEquals(it.next(), new Integer(split + 1));
        for (int j = 1; j <= split; ++j) q.remove(new Integer(j));
        it = q.descendingIterator();
        for (int j = split + 1; j <= max; ++j) {
            assertEquals(it.next(), new Integer(j));
            it.remove();
        }
        assertFalse(it.hasNext());
        assertTrue(q.isEmpty());
    }
}

14. ConcurrentLinkedDequeTest#testDescendingIteratorOrdering()

Project: mapdb
File: ConcurrentLinkedDequeTest.java
/**
     * Descending iterator ordering is reverse FIFO
     */
public void testDescendingIteratorOrdering() {
    final ConcurrentLinkedDeque q = new ConcurrentLinkedDeque();
    for (int iters = 0; iters < 100; ++iters) {
        q.add(new Integer(3));
        q.add(new Integer(2));
        q.add(new Integer(1));
        int k = 0;
        for (Iterator it = q.descendingIterator(); it.hasNext(); ) {
            assertEquals(++k, it.next());
        }
        assertEquals(3, k);
        q.remove();
        q.remove();
        q.remove();
    }
}

15. ConcurrentLinkedDequeTest#testDescendingIterator()

Project: mapdb
File: ConcurrentLinkedDequeTest.java
/**
     * Descending iterator iterates through all elements
     */
public void testDescendingIterator() {
    ConcurrentLinkedDeque q = populatedDeque(SIZE);
    int i = 0;
    Iterator it = q.descendingIterator();
    while (it.hasNext()) {
        assertTrue(q.contains(it.next()));
        ++i;
    }
    assertEquals(i, SIZE);
    assertFalse(it.hasNext());
    try {
        it.next();
        shouldThrow();
    } catch (NoSuchElementException success) {
    }
}

16. ConcurrentLinkedDequeTest#testIteratorRemove()

Project: mapdb
File: ConcurrentLinkedDequeTest.java
/**
     * iterator.remove() removes current element
     */
public void testIteratorRemove() {
    final ConcurrentLinkedDeque q = new ConcurrentLinkedDeque();
    final Random rng = new Random();
    for (int iters = 0; iters < 100; ++iters) {
        int max = rng.nextInt(5) + 2;
        int split = rng.nextInt(max - 1) + 1;
        for (int j = 1; j <= max; ++j) q.add(new Integer(j));
        Iterator it = q.iterator();
        for (int j = 1; j <= split; ++j) assertEquals(it.next(), new Integer(j));
        it.remove();
        assertEquals(it.next(), new Integer(split + 1));
        for (int j = 1; j <= split; ++j) q.remove(new Integer(j));
        it = q.iterator();
        for (int j = split + 1; j <= max; ++j) {
            assertEquals(it.next(), new Integer(j));
            it.remove();
        }
        assertFalse(it.hasNext());
        assertTrue(q.isEmpty());
    }
}

17. ConcurrentLinkedDequeTest#testLastElement()

Project: mapdb
File: ConcurrentLinkedDequeTest.java
/**
     * getLast() returns last element, or throws NSEE if empty
     */
public void testLastElement() {
    ConcurrentLinkedDeque q = populatedDeque(SIZE);
    for (int i = SIZE - 1; i >= 0; --i) {
        assertEquals(i, q.getLast());
        assertEquals(i, q.pollLast());
    }
    try {
        q.getLast();
        shouldThrow();
    } catch (NoSuchElementException success) {
    }
    assertNull(q.peekLast());
}

18. ConcurrentLinkedDequeTest#testRemoveElement()

Project: mapdb
File: ConcurrentLinkedDequeTest.java
/**
     * remove(x) removes x and returns true if present
     */
public void testRemoveElement() {
    ConcurrentLinkedDeque q = populatedDeque(SIZE);
    for (int i = 1; i < SIZE; i += 2) {
        assertTrue(q.contains(i));
        assertTrue(q.remove(i));
        assertFalse(q.contains(i));
        assertTrue(q.contains(i - 1));
    }
    for (int i = 0; i < SIZE; i += 2) {
        assertTrue(q.contains(i));
        assertTrue(q.remove(i));
        assertFalse(q.contains(i));
        assertFalse(q.remove(i + 1));
        assertFalse(q.contains(i + 1));
    }
    assertTrue(q.isEmpty());
}

19. ConcurrentLinkedDequeTest#testEmpty()

Project: openjdk
File: ConcurrentLinkedDequeTest.java
/**
     * isEmpty is true before add, false after
     */
public void testEmpty() {
    ConcurrentLinkedDeque q = new ConcurrentLinkedDeque();
    assertTrue(q.isEmpty());
    q.add(one);
    assertFalse(q.isEmpty());
    q.add(two);
    q.remove();
    q.remove();
    assertTrue(q.isEmpty());
}

20. ConcurrentLinkedDequeTest#testEmpty()

Project: mapdb
File: ConcurrentLinkedDequeTest.java
/**
     * isEmpty is true before add, false after
     */
public void testEmpty() {
    ConcurrentLinkedDeque q = new ConcurrentLinkedDeque();
    assertTrue(q.isEmpty());
    q.add(one);
    assertFalse(q.isEmpty());
    q.add(two);
    q.remove();
    q.remove();
    assertTrue(q.isEmpty());
}

21. ConcurrentLinkedDequeTest#testClear()

Project: openjdk
File: ConcurrentLinkedDequeTest.java
/**
     * clear() removes all elements
     */
public void testClear() {
    ConcurrentLinkedDeque q = populatedDeque(SIZE);
    q.clear();
    assertTrue(q.isEmpty());
    assertEquals(0, q.size());
    q.add(one);
    assertFalse(q.isEmpty());
    q.clear();
    assertTrue(q.isEmpty());
}

22. ConcurrentLinkedDequeTest#testClear()

Project: mapdb
File: ConcurrentLinkedDequeTest.java
/**
     * clear() removes all elements
     */
public void testClear() {
    ConcurrentLinkedDeque q = populatedDeque(SIZE);
    q.clear();
    assertTrue(q.isEmpty());
    assertEquals(0, q.size());
    q.add(one);
    assertFalse(q.isEmpty());
    q.clear();
    assertTrue(q.isEmpty());
}

23. ConcurrentLinkedDequeTest#testAddLast()

Project: openjdk
File: ConcurrentLinkedDequeTest.java
/**
     * addLast(x) succeeds
     */
public void testAddLast() {
    ConcurrentLinkedDeque q = new ConcurrentLinkedDeque();
    q.addLast(zero);
    q.addLast(one);
    assertSame(zero, q.peekFirst());
    assertSame(one, q.peekLast());
}

24. ConcurrentLinkedDequeTest#testAddFirst()

Project: openjdk
File: ConcurrentLinkedDequeTest.java
/**
     * addFirst(x) succeeds
     */
public void testAddFirst() {
    ConcurrentLinkedDeque q = new ConcurrentLinkedDeque();
    q.addFirst(zero);
    q.addFirst(one);
    assertSame(one, q.peekFirst());
    assertSame(zero, q.peekLast());
}

25. ConcurrentLinkedDequeTest#testPush()

Project: openjdk
File: ConcurrentLinkedDequeTest.java
/**
     * peekFirst() returns element inserted with push
     */
public void testPush() {
    ConcurrentLinkedDeque q = populatedDeque(3);
    q.pollLast();
    q.push(four);
    assertSame(four, q.peekFirst());
}

26. ConcurrentLinkedDequeTest#testAddLast()

Project: mapdb
File: ConcurrentLinkedDequeTest.java
/**
     * addLast(x) succeeds
     */
public void testAddLast() {
    ConcurrentLinkedDeque q = new ConcurrentLinkedDeque();
    q.addLast(zero);
    q.addLast(one);
    assertSame(zero, q.peekFirst());
    assertSame(one, q.peekLast());
}

27. ConcurrentLinkedDequeTest#testAddFirst()

Project: mapdb
File: ConcurrentLinkedDequeTest.java
/**
     * addFirst(x) succeeds
     */
public void testAddFirst() {
    ConcurrentLinkedDeque q = new ConcurrentLinkedDeque();
    q.addFirst(zero);
    q.addFirst(one);
    assertSame(one, q.peekFirst());
    assertSame(zero, q.peekLast());
}

28. ConcurrentLinkedDequeTest#testPush()

Project: mapdb
File: ConcurrentLinkedDequeTest.java
/**
     * peekFirst() returns element inserted with push
     */
public void testPush() {
    ConcurrentLinkedDeque q = populatedDeque(3);
    q.pollLast();
    q.push(four);
    assertSame(four, q.peekFirst());
}

29. ConcurrentLinkedDequeTest#testContainsAll()

Project: openjdk
File: ConcurrentLinkedDequeTest.java
/**
     * containsAll(c) is true when c contains a subset of elements
     */
public void testContainsAll() {
    ConcurrentLinkedDeque q = populatedDeque(SIZE);
    ConcurrentLinkedDeque p = new ConcurrentLinkedDeque();
    for (int i = 0; i < SIZE; ++i) {
        assertTrue(q.containsAll(p));
        assertFalse(p.containsAll(q));
        p.add(new Integer(i));
    }
    assertTrue(p.containsAll(q));
}

30. ConcurrentLinkedDequeTest#testContainsAll()

Project: mapdb
File: ConcurrentLinkedDequeTest.java
/**
     * containsAll(c) is true when c contains a subset of elements
     */
public void testContainsAll() {
    ConcurrentLinkedDeque q = populatedDeque(SIZE);
    ConcurrentLinkedDeque p = new ConcurrentLinkedDeque();
    for (int i = 0; i < SIZE; ++i) {
        assertTrue(q.containsAll(p));
        assertFalse(p.containsAll(q));
        p.add(new Integer(i));
    }
    assertTrue(p.containsAll(q));
}

31. ConcurrentLinkedDequeTest#testToString()

Project: openjdk
File: ConcurrentLinkedDequeTest.java
/**
     * toString() contains toStrings of elements
     */
public void testToString() {
    ConcurrentLinkedDeque q = populatedDeque(SIZE);
    String s = q.toString();
    for (int i = 0; i < SIZE; ++i) {
        assertTrue(s.contains(String.valueOf(i)));
    }
}

32. ConcurrentLinkedDequeTest#testIterator()

Project: openjdk
File: ConcurrentLinkedDequeTest.java
/**
     * Iterator iterates through all elements
     */
public void testIterator() {
    ConcurrentLinkedDeque q = populatedDeque(SIZE);
    Iterator it = q.iterator();
    int i;
    for (i = 0; it.hasNext(); i++) assertTrue(q.contains(it.next()));
    assertEquals(i, SIZE);
    assertIteratorExhausted(it);
}

33. ConcurrentLinkedDequeTest#testToArray1_BadArg()

Project: openjdk
File: ConcurrentLinkedDequeTest.java
/**
     * toArray(incompatible array type) throws ArrayStoreException
     */
public void testToArray1_BadArg() {
    ConcurrentLinkedDeque q = populatedDeque(SIZE);
    try {
        q.toArray(new String[10]);
        shouldThrow();
    } catch (ArrayStoreException success) {
    }
}

34. ConcurrentLinkedDequeTest#testToArray_NullArg()

Project: openjdk
File: ConcurrentLinkedDequeTest.java
/**
     * toArray(null) throws NullPointerException
     */
public void testToArray_NullArg() {
    ConcurrentLinkedDeque q = populatedDeque(SIZE);
    try {
        q.toArray(null);
        shouldThrow();
    } catch (NullPointerException success) {
    }
}

35. ConcurrentLinkedDequeTest#testToArray()

Project: openjdk
File: ConcurrentLinkedDequeTest.java
/**
     * toArray() contains all elements in FIFO order
     */
public void testToArray() {
    ConcurrentLinkedDeque q = populatedDeque(SIZE);
    Object[] o = q.toArray();
    for (int i = 0; i < o.length; i++) assertSame(o[i], q.poll());
}

36. ConcurrentLinkedDequeTest#testContains()

Project: openjdk
File: ConcurrentLinkedDequeTest.java
/**
     * contains(x) reports true when elements added but not yet removed
     */
public void testContains() {
    ConcurrentLinkedDeque q = populatedDeque(SIZE);
    for (int i = 0; i < SIZE; ++i) {
        assertTrue(q.contains(new Integer(i)));
        q.poll();
        assertFalse(q.contains(new Integer(i)));
    }
}

37. ConcurrentLinkedDequeTest#testRemoveLastOccurrence()

Project: openjdk
File: ConcurrentLinkedDequeTest.java
/**
     * removeLastOccurrence(x) removes x and returns true if present
     */
public void testRemoveLastOccurrence() {
    ConcurrentLinkedDeque q = populatedDeque(SIZE);
    for (int i = 1; i < SIZE; i += 2) {
        assertTrue(q.removeLastOccurrence(new Integer(i)));
    }
    for (int i = 0; i < SIZE; i += 2) {
        assertTrue(q.removeLastOccurrence(new Integer(i)));
        assertFalse(q.removeLastOccurrence(new Integer(i + 1)));
    }
    assertTrue(q.isEmpty());
}

38. ConcurrentLinkedDequeTest#testRemoveFirstOccurrence()

Project: openjdk
File: ConcurrentLinkedDequeTest.java
/**
     * removeFirstOccurrence(x) removes x and returns true if present
     */
public void testRemoveFirstOccurrence() {
    ConcurrentLinkedDeque q = populatedDeque(SIZE);
    for (int i = 1; i < SIZE; i += 2) {
        assertTrue(q.removeFirstOccurrence(new Integer(i)));
    }
    for (int i = 0; i < SIZE; i += 2) {
        assertTrue(q.removeFirstOccurrence(new Integer(i)));
        assertFalse(q.removeFirstOccurrence(new Integer(i + 1)));
    }
    assertTrue(q.isEmpty());
}

39. ConcurrentLinkedDequeTest#testRemoveLast()

Project: openjdk
File: ConcurrentLinkedDequeTest.java
/**
     * removeLast() removes last element, or throws NSEE if empty
     */
public void testRemoveLast() {
    ConcurrentLinkedDeque q = populatedDeque(SIZE);
    for (int i = SIZE - 1; i >= 0; --i) {
        assertEquals(i, q.removeLast());
    }
    try {
        q.removeLast();
        shouldThrow();
    } catch (NoSuchElementException success) {
    }
    assertNull(q.peekLast());
}

40. ConcurrentLinkedDequeTest#testRemoveFirst()

Project: openjdk
File: ConcurrentLinkedDequeTest.java
/**
     * removeFirst() removes first element, or throws NSEE if empty
     */
public void testRemoveFirst() {
    ConcurrentLinkedDeque q = populatedDeque(SIZE);
    for (int i = 0; i < SIZE; ++i) {
        assertEquals(i, q.removeFirst());
    }
    try {
        q.removeFirst();
        shouldThrow();
    } catch (NoSuchElementException success) {
    }
    assertNull(q.peekFirst());
}

41. ConcurrentLinkedDequeTest#testFirstElement()

Project: openjdk
File: ConcurrentLinkedDequeTest.java
/**
     * getFirst() returns first element, or throws NSEE if empty
     */
public void testFirstElement() {
    ConcurrentLinkedDeque q = populatedDeque(SIZE);
    for (int i = 0; i < SIZE; ++i) {
        assertEquals(i, q.getFirst());
        assertEquals(i, q.pollFirst());
    }
    try {
        q.getFirst();
        shouldThrow();
    } catch (NoSuchElementException success) {
    }
}

42. ConcurrentLinkedDequeTest#testPeekLast()

Project: openjdk
File: ConcurrentLinkedDequeTest.java
/**
     * peekLast() returns next element, or null if empty
     */
public void testPeekLast() {
    ConcurrentLinkedDeque q = populatedDeque(SIZE);
    for (int i = SIZE - 1; i >= 0; --i) {
        assertEquals(i, q.peekLast());
        assertEquals(i, q.pollLast());
        assertTrue(q.peekLast() == null || !q.peekLast().equals(i));
    }
    assertNull(q.peekLast());
}

43. ConcurrentLinkedDequeTest#testPeekFirst()

Project: openjdk
File: ConcurrentLinkedDequeTest.java
/**
     * peekFirst() returns next element, or null if empty
     */
public void testPeekFirst() {
    ConcurrentLinkedDeque q = populatedDeque(SIZE);
    for (int i = 0; i < SIZE; ++i) {
        assertEquals(i, q.peekFirst());
        assertEquals(i, q.pollFirst());
        assertTrue(q.peekFirst() == null || !q.peekFirst().equals(i));
    }
    assertNull(q.peekFirst());
}

44. ConcurrentLinkedDequeTest#testRemove()

Project: openjdk
File: ConcurrentLinkedDequeTest.java
/**
     * remove() removes next element, or throws NSEE if empty
     */
public void testRemove() {
    ConcurrentLinkedDeque q = populatedDeque(SIZE);
    for (int i = 0; i < SIZE; ++i) {
        assertEquals(i, q.remove());
    }
    try {
        q.remove();
        shouldThrow();
    } catch (NoSuchElementException success) {
    }
}

45. ConcurrentLinkedDequeTest#testElement()

Project: openjdk
File: ConcurrentLinkedDequeTest.java
/**
     * element() returns first element, or throws NSEE if empty
     */
public void testElement() {
    ConcurrentLinkedDeque q = populatedDeque(SIZE);
    for (int i = 0; i < SIZE; ++i) {
        assertEquals(i, q.element());
        assertEquals(i, q.poll());
    }
    try {
        q.element();
        shouldThrow();
    } catch (NoSuchElementException success) {
    }
}

46. ConcurrentLinkedDequeTest#testPeek()

Project: openjdk
File: ConcurrentLinkedDequeTest.java
/**
     * peek() returns next element, or null if empty
     */
public void testPeek() {
    ConcurrentLinkedDeque q = populatedDeque(SIZE);
    for (int i = 0; i < SIZE; ++i) {
        assertEquals(i, q.peek());
        assertEquals(i, q.poll());
        assertTrue(q.peek() == null || !q.peek().equals(i));
    }
    assertNull(q.peek());
}

47. ConcurrentLinkedDequeTest#testPoll()

Project: openjdk
File: ConcurrentLinkedDequeTest.java
/**
     * poll() succeeds unless empty
     */
public void testPoll() {
    ConcurrentLinkedDeque q = populatedDeque(SIZE);
    for (int i = 0; i < SIZE; ++i) {
        assertEquals(i, q.poll());
    }
    assertNull(q.poll());
}

48. ConcurrentLinkedDequeTest#testPollLast()

Project: openjdk
File: ConcurrentLinkedDequeTest.java
/**
     * pollLast() succeeds unless empty
     */
public void testPollLast() {
    ConcurrentLinkedDeque q = populatedDeque(SIZE);
    for (int i = SIZE - 1; i >= 0; --i) {
        assertEquals(i, q.pollLast());
    }
    assertNull(q.pollLast());
}

49. ConcurrentLinkedDequeTest#testPollFirst()

Project: openjdk
File: ConcurrentLinkedDequeTest.java
/**
     * pollFirst() succeeds unless empty
     */
public void testPollFirst() {
    ConcurrentLinkedDeque q = populatedDeque(SIZE);
    for (int i = 0; i < SIZE; ++i) {
        assertEquals(i, q.pollFirst());
    }
    assertNull(q.pollFirst());
}

50. ConcurrentLinkedDequeTest#testAddAll5()

Project: openjdk
File: ConcurrentLinkedDequeTest.java
/**
     * Deque contains all elements, in traversal order, of successful addAll
     */
public void testAddAll5() {
    Integer[] empty = new Integer[0];
    Integer[] ints = new Integer[SIZE];
    for (int i = 0; i < SIZE; ++i) ints[i] = new Integer(i);
    ConcurrentLinkedDeque q = new ConcurrentLinkedDeque();
    assertFalse(q.addAll(Arrays.asList(empty)));
    assertTrue(q.addAll(Arrays.asList(ints)));
    for (int i = 0; i < SIZE; ++i) assertEquals(ints[i], q.poll());
}

51. ConcurrentLinkedDequeTest#testAddAll3()

Project: openjdk
File: ConcurrentLinkedDequeTest.java
/**
     * addAll of a collection with any null elements throws NPE after
     * possibly adding some elements
     */
public void testAddAll3() {
    ConcurrentLinkedDeque q = new ConcurrentLinkedDeque();
    Integer[] ints = new Integer[SIZE];
    for (int i = 0; i < SIZE - 1; ++i) ints[i] = new Integer(i);
    try {
        q.addAll(Arrays.asList(ints));
        shouldThrow();
    } catch (NullPointerException success) {
    }
}

52. ConcurrentLinkedDequeTest#testAddAll2()

Project: openjdk
File: ConcurrentLinkedDequeTest.java
/**
     * addAll of a collection with null elements throws NPE
     */
public void testAddAll2() {
    ConcurrentLinkedDeque q = new ConcurrentLinkedDeque();
    try {
        q.addAll(Arrays.asList(new Integer[SIZE]));
        shouldThrow();
    } catch (NullPointerException success) {
    }
}

53. ConcurrentLinkedDequeTest#testAddAllSelf()

Project: openjdk
File: ConcurrentLinkedDequeTest.java
/**
     * addAll(this) throws IAE
     */
public void testAddAllSelf() {
    ConcurrentLinkedDeque q = populatedDeque(SIZE);
    try {
        q.addAll(q);
        shouldThrow();
    } catch (IllegalArgumentException success) {
    }
}

54. ConcurrentLinkedDequeTest#testAddAll1()

Project: openjdk
File: ConcurrentLinkedDequeTest.java
/**
     * addAll(null) throws NPE
     */
public void testAddAll1() {
    ConcurrentLinkedDeque q = new ConcurrentLinkedDeque();
    try {
        q.addAll(null);
        shouldThrow();
    } catch (NullPointerException success) {
    }
}

55. ConcurrentLinkedDequeTest#testAdd()

Project: openjdk
File: ConcurrentLinkedDequeTest.java
/**
     * add(x) succeeds
     */
public void testAdd() {
    ConcurrentLinkedDeque q = new ConcurrentLinkedDeque();
    assertTrue(q.add(zero));
    assertTrue(q.add(one));
    assertSame(zero, q.peekFirst());
    assertSame(one, q.peekLast());
}

56. ConcurrentLinkedDequeTest#testAddLastNull()

Project: openjdk
File: ConcurrentLinkedDequeTest.java
/**
     * addLast(null) throws NPE
     */
public void testAddLastNull() {
    ConcurrentLinkedDeque q = new ConcurrentLinkedDeque();
    try {
        q.addLast(null);
        shouldThrow();
    } catch (NullPointerException success) {
    }
}

57. ConcurrentLinkedDequeTest#testAddFirstNull()

Project: openjdk
File: ConcurrentLinkedDequeTest.java
/**
     * addFirst(null) throws NPE
     */
public void testAddFirstNull() {
    ConcurrentLinkedDeque q = new ConcurrentLinkedDeque();
    try {
        q.addFirst(null);
        shouldThrow();
    } catch (NullPointerException success) {
    }
}

58. ConcurrentLinkedDequeTest#testAddNull()

Project: openjdk
File: ConcurrentLinkedDequeTest.java
/**
     * add(null) throws NPE
     */
public void testAddNull() {
    ConcurrentLinkedDeque q = new ConcurrentLinkedDeque();
    try {
        q.add(null);
        shouldThrow();
    } catch (NullPointerException success) {
    }
}

59. ConcurrentLinkedDequeTest#testOfferLast()

Project: openjdk
File: ConcurrentLinkedDequeTest.java
/**
     * offerLast(x) succeeds
     */
public void testOfferLast() {
    ConcurrentLinkedDeque q = new ConcurrentLinkedDeque();
    assertTrue(q.offerLast(zero));
    assertTrue(q.offerLast(one));
    assertSame(zero, q.peekFirst());
    assertSame(one, q.peekLast());
}

60. ConcurrentLinkedDequeTest#testOfferFirst()

Project: openjdk
File: ConcurrentLinkedDequeTest.java
/**
     * offerFirst(x) succeeds
     */
public void testOfferFirst() {
    ConcurrentLinkedDeque q = new ConcurrentLinkedDeque();
    assertTrue(q.offerFirst(zero));
    assertTrue(q.offerFirst(one));
    assertSame(one, q.peekFirst());
    assertSame(zero, q.peekLast());
}

61. ConcurrentLinkedDequeTest#testOffer()

Project: openjdk
File: ConcurrentLinkedDequeTest.java
/**
     * offer(x) succeeds
     */
public void testOffer() {
    ConcurrentLinkedDeque q = new ConcurrentLinkedDeque();
    assertTrue(q.offer(zero));
    assertTrue(q.offer(one));
    assertSame(zero, q.peekFirst());
    assertSame(one, q.peekLast());
}

62. ConcurrentLinkedDequeTest#testOfferLastNull()

Project: openjdk
File: ConcurrentLinkedDequeTest.java
/**
     * offerLast(null) throws NPE
     */
public void testOfferLastNull() {
    ConcurrentLinkedDeque q = new ConcurrentLinkedDeque();
    try {
        q.offerLast(null);
        shouldThrow();
    } catch (NullPointerException success) {
    }
}

63. ConcurrentLinkedDequeTest#testOfferFirstNull()

Project: openjdk
File: ConcurrentLinkedDequeTest.java
/**
     * offerFirst(null) throws NPE
     */
public void testOfferFirstNull() {
    ConcurrentLinkedDeque q = new ConcurrentLinkedDeque();
    try {
        q.offerFirst(null);
        shouldThrow();
    } catch (NullPointerException success) {
    }
}

64. ConcurrentLinkedDequeTest#testOfferNull()

Project: openjdk
File: ConcurrentLinkedDequeTest.java
/**
     * offer(null) throws NPE
     */
public void testOfferNull() {
    ConcurrentLinkedDeque q = new ConcurrentLinkedDeque();
    try {
        q.offer(null);
        shouldThrow();
    } catch (NullPointerException success) {
    }
}

65. ConcurrentLinkedDequeTest#testPop()

Project: openjdk
File: ConcurrentLinkedDequeTest.java
/**
     * pop() removes first element, or throws NSEE if empty
     */
public void testPop() {
    ConcurrentLinkedDeque q = populatedDeque(SIZE);
    for (int i = 0; i < SIZE; ++i) {
        assertEquals(i, q.pop());
    }
    try {
        q.pop();
        shouldThrow();
    } catch (NoSuchElementException success) {
    }
}

66. ConcurrentLinkedDequeTest#testPushNull()

Project: openjdk
File: ConcurrentLinkedDequeTest.java
/**
     * push(null) throws NPE
     */
public void testPushNull() {
    ConcurrentLinkedDeque q = new ConcurrentLinkedDeque();
    try {
        q.push(null);
        shouldThrow();
    } catch (NullPointerException success) {
    }
}

67. ConcurrentLinkedDequeTest#testSize()

Project: openjdk
File: ConcurrentLinkedDequeTest.java
/**
     * size() changes when elements added and removed
     */
public void testSize() {
    ConcurrentLinkedDeque q = populatedDeque(SIZE);
    for (int i = 0; i < SIZE; ++i) {
        assertEquals(SIZE - i, q.size());
        q.remove();
    }
    for (int i = 0; i < SIZE; ++i) {
        assertEquals(i, q.size());
        q.add(new Integer(i));
    }
}

68. ConcurrentLinkedDequeTest#testConstructor6()

Project: openjdk
File: ConcurrentLinkedDequeTest.java
/**
     * Deque contains all elements of collection used to initialize
     */
public void testConstructor6() {
    Integer[] ints = new Integer[SIZE];
    for (int i = 0; i < SIZE; ++i) ints[i] = new Integer(i);
    ConcurrentLinkedDeque q = new ConcurrentLinkedDeque(Arrays.asList(ints));
    for (int i = 0; i < SIZE; ++i) assertEquals(ints[i], q.poll());
}

69. ConcurrentLinkedDequeTest#testToString()

Project: mapdb
File: ConcurrentLinkedDequeTest.java
/**
     * toString() contains toStrings of elements
     */
public void testToString() {
    ConcurrentLinkedDeque q = populatedDeque(SIZE);
    String s = q.toString();
    for (int i = 0; i < SIZE; ++i) {
        assertTrue(s.contains(String.valueOf(i)));
    }
}

70. ConcurrentLinkedDequeTest#testIterator()

Project: mapdb
File: ConcurrentLinkedDequeTest.java
/**
     * Iterator iterates through all elements
     */
public void testIterator() {
    ConcurrentLinkedDeque q = populatedDeque(SIZE);
    Iterator it = q.iterator();
    int i;
    for (i = 0; it.hasNext(); i++) assertTrue(q.contains(it.next()));
    assertEquals(i, SIZE);
    assertIteratorExhausted(it);
}

71. ConcurrentLinkedDequeTest#testToArray1_BadArg()

Project: mapdb
File: ConcurrentLinkedDequeTest.java
/**
     * toArray(incompatible array type) throws ArrayStoreException
     */
public void testToArray1_BadArg() {
    ConcurrentLinkedDeque q = populatedDeque(SIZE);
    try {
        q.toArray(new String[10]);
        shouldThrow();
    } catch (ArrayStoreException success) {
    }
}

72. ConcurrentLinkedDequeTest#testToArray_NullArg()

Project: mapdb
File: ConcurrentLinkedDequeTest.java
/**
     * toArray(null) throws NullPointerException
     */
public void testToArray_NullArg() {
    ConcurrentLinkedDeque q = populatedDeque(SIZE);
    try {
        q.toArray(null);
        shouldThrow();
    } catch (NullPointerException success) {
    }
}

73. ConcurrentLinkedDequeTest#testToArray()

Project: mapdb
File: ConcurrentLinkedDequeTest.java
/**
     * toArray() contains all elements in FIFO order
     */
public void testToArray() {
    ConcurrentLinkedDeque q = populatedDeque(SIZE);
    Object[] o = q.toArray();
    for (int i = 0; i < o.length; i++) assertSame(o[i], q.poll());
}

74. ConcurrentLinkedDequeTest#testContains()

Project: mapdb
File: ConcurrentLinkedDequeTest.java
/**
     * contains(x) reports true when elements added but not yet removed
     */
public void testContains() {
    ConcurrentLinkedDeque q = populatedDeque(SIZE);
    for (int i = 0; i < SIZE; ++i) {
        assertTrue(q.contains(new Integer(i)));
        q.poll();
        assertFalse(q.contains(new Integer(i)));
    }
}

75. ConcurrentLinkedDequeTest#testRemoveLastOccurrence()

Project: mapdb
File: ConcurrentLinkedDequeTest.java
/**
     * removeLastOccurrence(x) removes x and returns true if present
     */
public void testRemoveLastOccurrence() {
    ConcurrentLinkedDeque q = populatedDeque(SIZE);
    for (int i = 1; i < SIZE; i += 2) {
        assertTrue(q.removeLastOccurrence(new Integer(i)));
    }
    for (int i = 0; i < SIZE; i += 2) {
        assertTrue(q.removeLastOccurrence(new Integer(i)));
        assertFalse(q.removeLastOccurrence(new Integer(i + 1)));
    }
    assertTrue(q.isEmpty());
}

76. ConcurrentLinkedDequeTest#testRemoveFirstOccurrence()

Project: mapdb
File: ConcurrentLinkedDequeTest.java
/**
     * removeFirstOccurrence(x) removes x and returns true if present
     */
public void testRemoveFirstOccurrence() {
    ConcurrentLinkedDeque q = populatedDeque(SIZE);
    for (int i = 1; i < SIZE; i += 2) {
        assertTrue(q.removeFirstOccurrence(new Integer(i)));
    }
    for (int i = 0; i < SIZE; i += 2) {
        assertTrue(q.removeFirstOccurrence(new Integer(i)));
        assertFalse(q.removeFirstOccurrence(new Integer(i + 1)));
    }
    assertTrue(q.isEmpty());
}

77. ConcurrentLinkedDequeTest#testRemoveLast()

Project: mapdb
File: ConcurrentLinkedDequeTest.java
/**
     * removeLast() removes last element, or throws NSEE if empty
     */
public void testRemoveLast() {
    ConcurrentLinkedDeque q = populatedDeque(SIZE);
    for (int i = SIZE - 1; i >= 0; --i) {
        assertEquals(i, q.removeLast());
    }
    try {
        q.removeLast();
        shouldThrow();
    } catch (NoSuchElementException success) {
    }
    assertNull(q.peekLast());
}

78. ConcurrentLinkedDequeTest#testRemoveFirst()

Project: mapdb
File: ConcurrentLinkedDequeTest.java
/**
     * removeFirst() removes first element, or throws NSEE if empty
     */
public void testRemoveFirst() {
    ConcurrentLinkedDeque q = populatedDeque(SIZE);
    for (int i = 0; i < SIZE; ++i) {
        assertEquals(i, q.removeFirst());
    }
    try {
        q.removeFirst();
        shouldThrow();
    } catch (NoSuchElementException success) {
    }
    assertNull(q.peekFirst());
}

79. ConcurrentLinkedDequeTest#testFirstElement()

Project: mapdb
File: ConcurrentLinkedDequeTest.java
/**
     * getFirst() returns first element, or throws NSEE if empty
     */
public void testFirstElement() {
    ConcurrentLinkedDeque q = populatedDeque(SIZE);
    for (int i = 0; i < SIZE; ++i) {
        assertEquals(i, q.getFirst());
        assertEquals(i, q.pollFirst());
    }
    try {
        q.getFirst();
        shouldThrow();
    } catch (NoSuchElementException success) {
    }
}

80. ConcurrentLinkedDequeTest#testPeekLast()

Project: mapdb
File: ConcurrentLinkedDequeTest.java
/**
     * peekLast() returns next element, or null if empty
     */
public void testPeekLast() {
    ConcurrentLinkedDeque q = populatedDeque(SIZE);
    for (int i = SIZE - 1; i >= 0; --i) {
        assertEquals(i, q.peekLast());
        assertEquals(i, q.pollLast());
        assertTrue(q.peekLast() == null || !q.peekLast().equals(i));
    }
    assertNull(q.peekLast());
}

81. ConcurrentLinkedDequeTest#testPeekFirst()

Project: mapdb
File: ConcurrentLinkedDequeTest.java
/**
     * peekFirst() returns next element, or null if empty
     */
public void testPeekFirst() {
    ConcurrentLinkedDeque q = populatedDeque(SIZE);
    for (int i = 0; i < SIZE; ++i) {
        assertEquals(i, q.peekFirst());
        assertEquals(i, q.pollFirst());
        assertTrue(q.peekFirst() == null || !q.peekFirst().equals(i));
    }
    assertNull(q.peekFirst());
}

82. ConcurrentLinkedDequeTest#testRemove()

Project: mapdb
File: ConcurrentLinkedDequeTest.java
/**
     * remove() removes next element, or throws NSEE if empty
     */
public void testRemove() {
    ConcurrentLinkedDeque q = populatedDeque(SIZE);
    for (int i = 0; i < SIZE; ++i) {
        assertEquals(i, q.remove());
    }
    try {
        q.remove();
        shouldThrow();
    } catch (NoSuchElementException success) {
    }
}

83. ConcurrentLinkedDequeTest#testElement()

Project: mapdb
File: ConcurrentLinkedDequeTest.java
/**
     * element() returns first element, or throws NSEE if empty
     */
public void testElement() {
    ConcurrentLinkedDeque q = populatedDeque(SIZE);
    for (int i = 0; i < SIZE; ++i) {
        assertEquals(i, q.element());
        assertEquals(i, q.poll());
    }
    try {
        q.element();
        shouldThrow();
    } catch (NoSuchElementException success) {
    }
}

84. ConcurrentLinkedDequeTest#testPeek()

Project: mapdb
File: ConcurrentLinkedDequeTest.java
/**
     * peek() returns next element, or null if empty
     */
public void testPeek() {
    ConcurrentLinkedDeque q = populatedDeque(SIZE);
    for (int i = 0; i < SIZE; ++i) {
        assertEquals(i, q.peek());
        assertEquals(i, q.poll());
        assertTrue(q.peek() == null || !q.peek().equals(i));
    }
    assertNull(q.peek());
}

85. ConcurrentLinkedDequeTest#testPoll()

Project: mapdb
File: ConcurrentLinkedDequeTest.java
/**
     * poll() succeeds unless empty
     */
public void testPoll() {
    ConcurrentLinkedDeque q = populatedDeque(SIZE);
    for (int i = 0; i < SIZE; ++i) {
        assertEquals(i, q.poll());
    }
    assertNull(q.poll());
}

86. ConcurrentLinkedDequeTest#testPollLast()

Project: mapdb
File: ConcurrentLinkedDequeTest.java
/**
     * pollLast() succeeds unless empty
     */
public void testPollLast() {
    ConcurrentLinkedDeque q = populatedDeque(SIZE);
    for (int i = SIZE - 1; i >= 0; --i) {
        assertEquals(i, q.pollLast());
    }
    assertNull(q.pollLast());
}

87. ConcurrentLinkedDequeTest#testPollFirst()

Project: mapdb
File: ConcurrentLinkedDequeTest.java
/**
     * pollFirst() succeeds unless empty
     */
public void testPollFirst() {
    ConcurrentLinkedDeque q = populatedDeque(SIZE);
    for (int i = 0; i < SIZE; ++i) {
        assertEquals(i, q.pollFirst());
    }
    assertNull(q.pollFirst());
}

88. ConcurrentLinkedDequeTest#testAddAll5()

Project: mapdb
File: ConcurrentLinkedDequeTest.java
/**
     * Deque contains all elements, in traversal order, of successful addAll
     */
public void testAddAll5() {
    Integer[] empty = new Integer[0];
    Integer[] ints = new Integer[SIZE];
    for (int i = 0; i < SIZE; ++i) ints[i] = new Integer(i);
    ConcurrentLinkedDeque q = new ConcurrentLinkedDeque();
    assertFalse(q.addAll(Arrays.asList(empty)));
    assertTrue(q.addAll(Arrays.asList(ints)));
    for (int i = 0; i < SIZE; ++i) assertEquals(ints[i], q.poll());
}

89. ConcurrentLinkedDequeTest#testAddAll3()

Project: mapdb
File: ConcurrentLinkedDequeTest.java
/**
     * addAll of a collection with any null elements throws NPE after
     * possibly adding some elements
     */
public void testAddAll3() {
    ConcurrentLinkedDeque q = new ConcurrentLinkedDeque();
    Integer[] ints = new Integer[SIZE];
    for (int i = 0; i < SIZE - 1; ++i) ints[i] = new Integer(i);
    try {
        q.addAll(Arrays.asList(ints));
        shouldThrow();
    } catch (NullPointerException success) {
    }
}

90. ConcurrentLinkedDequeTest#testAddAll2()

Project: mapdb
File: ConcurrentLinkedDequeTest.java
/**
     * addAll of a collection with null elements throws NPE
     */
public void testAddAll2() {
    ConcurrentLinkedDeque q = new ConcurrentLinkedDeque();
    try {
        q.addAll(Arrays.asList(new Integer[SIZE]));
        shouldThrow();
    } catch (NullPointerException success) {
    }
}

91. ConcurrentLinkedDequeTest#testAddAllSelf()

Project: mapdb
File: ConcurrentLinkedDequeTest.java
/**
     * addAll(this) throws IAE
     */
public void testAddAllSelf() {
    ConcurrentLinkedDeque q = populatedDeque(SIZE);
    try {
        q.addAll(q);
        shouldThrow();
    } catch (IllegalArgumentException success) {
    }
}

92. ConcurrentLinkedDequeTest#testAddAll1()

Project: mapdb
File: ConcurrentLinkedDequeTest.java
/**
     * addAll(null) throws NPE
     */
public void testAddAll1() {
    ConcurrentLinkedDeque q = new ConcurrentLinkedDeque();
    try {
        q.addAll(null);
        shouldThrow();
    } catch (NullPointerException success) {
    }
}

93. ConcurrentLinkedDequeTest#testAdd()

Project: mapdb
File: ConcurrentLinkedDequeTest.java
/**
     * add(x) succeeds
     */
public void testAdd() {
    ConcurrentLinkedDeque q = new ConcurrentLinkedDeque();
    assertTrue(q.add(zero));
    assertTrue(q.add(one));
    assertSame(zero, q.peekFirst());
    assertSame(one, q.peekLast());
}

94. ConcurrentLinkedDequeTest#testAddLastNull()

Project: mapdb
File: ConcurrentLinkedDequeTest.java
/**
     * addLast(null) throws NPE
     */
public void testAddLastNull() {
    ConcurrentLinkedDeque q = new ConcurrentLinkedDeque();
    try {
        q.addLast(null);
        shouldThrow();
    } catch (NullPointerException success) {
    }
}

95. ConcurrentLinkedDequeTest#testAddFirstNull()

Project: mapdb
File: ConcurrentLinkedDequeTest.java
/**
     * addFirst(null) throws NPE
     */
public void testAddFirstNull() {
    ConcurrentLinkedDeque q = new ConcurrentLinkedDeque();
    try {
        q.addFirst(null);
        shouldThrow();
    } catch (NullPointerException success) {
    }
}

96. ConcurrentLinkedDequeTest#testAddNull()

Project: mapdb
File: ConcurrentLinkedDequeTest.java
/**
     * add(null) throws NPE
     */
public void testAddNull() {
    ConcurrentLinkedDeque q = new ConcurrentLinkedDeque();
    try {
        q.add(null);
        shouldThrow();
    } catch (NullPointerException success) {
    }
}

97. ConcurrentLinkedDequeTest#testOfferLast()

Project: mapdb
File: ConcurrentLinkedDequeTest.java
/**
     * offerLast(x) succeeds
     */
public void testOfferLast() {
    ConcurrentLinkedDeque q = new ConcurrentLinkedDeque();
    assertTrue(q.offerLast(zero));
    assertTrue(q.offerLast(one));
    assertSame(zero, q.peekFirst());
    assertSame(one, q.peekLast());
}

98. ConcurrentLinkedDequeTest#testOfferFirst()

Project: mapdb
File: ConcurrentLinkedDequeTest.java
/**
     * offerFirst(x) succeeds
     */
public void testOfferFirst() {
    ConcurrentLinkedDeque q = new ConcurrentLinkedDeque();
    assertTrue(q.offerFirst(zero));
    assertTrue(q.offerFirst(one));
    assertSame(one, q.peekFirst());
    assertSame(zero, q.peekLast());
}

99. ConcurrentLinkedDequeTest#testOffer()

Project: mapdb
File: ConcurrentLinkedDequeTest.java
/**
     * offer(x) succeeds
     */
public void testOffer() {
    ConcurrentLinkedDeque q = new ConcurrentLinkedDeque();
    assertTrue(q.offer(zero));
    assertTrue(q.offer(one));
    assertSame(zero, q.peekFirst());
    assertSame(one, q.peekLast());
}

100. ConcurrentLinkedDequeTest#testOfferLastNull()

Project: mapdb
File: ConcurrentLinkedDequeTest.java
/**
     * offerLast(null) throws NPE
     */
public void testOfferLastNull() {
    ConcurrentLinkedDeque q = new ConcurrentLinkedDeque();
    try {
        q.offerLast(null);
        shouldThrow();
    } catch (NullPointerException success) {
    }
}