test/tck/PriorityQueueTest.java

/*
 * Written by Doug Lea with assistance from members of JCP JSR-166
 * Expert Group and released to the public domain, as explained at
 * http://creativecommons.org/publicdomain/zero/1.0/
 * Other contributors include Andrew Wright, Jeffrey Hayes,
 * Pat Fisher, Mike Judd.
 */

import java.util.Arrays;
import java.util.Collection;
import java.util.Comparator;
import java.util.Iterator;
import java.util.NoSuchElementException;
import java.util.PriorityQueue;
import java.util.Queue;

import junit.framework.Test;

public class PriorityQueueTest extends JSR166TestCase {
    public static void main(String[] args) {
        main(suite(), args);
    }
    public static Test suite() {
        class Implementation implements CollectionImplementation {
            public Class<?> klazz() { return PriorityQueue.class; }
            public Collection emptyCollection() { return new PriorityQueue(); }
            public Object makeElement(int i) { return JSR166TestCase.itemFor(i); }
            public boolean isConcurrent() { return false; }
            public boolean permitsNulls() { return false; }
        }
        class ComparatorImplementation implements CollectionImplementation {
            public Class<?> klazz() { return PriorityQueue.class; }
            @SuppressWarnings("unchecked")
            public Collection emptyCollection() {
                return new PriorityQueue(new MyReverseComparator());
            }
            public Object makeElement(int i) { return JSR166TestCase.itemFor(i); }
            public boolean isConcurrent() { return false; }
            public boolean permitsNulls() { return false; }
        }
        return newTestSuite(
            PriorityQueueTest.class,
            CollectionTest.testSuite(new Implementation()),
            CollectionTest.testSuite(new ComparatorImplementation()));
    }

    static class MyReverseComparator implements Comparator, java.io.Serializable {
        @SuppressWarnings("unchecked")
        public int compare(Object x, Object y) {
            return ((Comparable)y).compareTo(x);
        }
    }

    /**
     * Returns a new queue of given size containing consecutive
     * Items 0 ... n - 1.
     */
    private static PriorityQueue<Item> populatedQueue(int n) {
        PriorityQueue<Item> q = new PriorityQueue<>(n);
        assertTrue(q.isEmpty());
        for (int i = n - 1; i >= 0; i -= 2)
            mustOffer(q, i);
        for (int i = (n & 1); i < n; i += 2)
            mustOffer(q, i);
        assertFalse(q.isEmpty());
        mustEqual(n, q.size());
        mustEqual(0, q.peek());
        return q;
    }

    /**
     * A new queue has unbounded capacity
     */
    public void testConstructor1() {
        mustEqual(0, new PriorityQueue<Item>(SIZE).size());
    }

    /**
     * Constructor throws IllegalArgumentException if capacity argument nonpositive
     */
    public void testConstructor2() {
        try {
            new PriorityQueue<Item>(0);
            shouldThrow();
        } catch (IllegalArgumentException success) {}
    }

    /**
     * Initializing from null Collection throws NPE
     */
    public void testConstructor3() {
        try {
            new PriorityQueue<Item>((Collection<Item>)null);
            shouldThrow();
        } catch (NullPointerException success) {}
    }

    /**
     * Initializing from Collection of null elements throws NPE
     */
    public void testConstructor4() {
        try {
            new PriorityQueue<Item>(Arrays.asList(new Item[SIZE]));
            shouldThrow();
        } catch (NullPointerException success) {}
    }

    /**
     * Initializing from Collection with some null elements throws NPE
     */
    public void testConstructor5() {
        Item[] items = new Item[2];
        items[0] = zero;
        try {
            new PriorityQueue<Item>(Arrays.asList(items));
            shouldThrow();
        } catch (NullPointerException success) {}
    }

    /**
     * Queue contains all elements of collection used to initialize
     */
    public void testConstructor6() {
        Item[] items = defaultItems;
        PriorityQueue<Item> q = new PriorityQueue<>(Arrays.asList(items));
        for (int i = 0; i < SIZE; ++i)
            mustEqual(items[i], q.poll());
    }

    /**
     * The comparator used in constructor is used
     */
    public void testConstructor7() {
        MyReverseComparator cmp = new MyReverseComparator();
        @SuppressWarnings("unchecked")
        PriorityQueue<Item> q = new PriorityQueue<>(SIZE, cmp);
        assertEquals(cmp, q.comparator());
        Item[] items = seqItems(SIZE);
        q.addAll(Arrays.asList(items));
        for (int i = SIZE - 1; i >= 0; --i)
            mustEqual(items[i], q.poll());
    }

    /**
     * isEmpty is true before add, false after
     */
    public void testEmpty() {
        PriorityQueue<Item> q = new PriorityQueue<>(2);
        assertTrue(q.isEmpty());
        q.add(one);
        assertFalse(q.isEmpty());
        q.add(two);
        q.remove();
        q.remove();
        assertTrue(q.isEmpty());
    }

    /**
     * size changes when elements added and removed
     */
    public void testSize() {
        PriorityQueue<Item> q = populatedQueue(SIZE);
        for (int i = 0; i < SIZE; ++i) {
            mustEqual(SIZE - i, q.size());
            q.remove();
        }
        for (int i = 0; i < SIZE; ++i) {
            mustEqual(i, q.size());
            mustAdd(q, i);
        }
    }

    /**
     * offer(null) throws NPE
     */
    public void testOfferNull() {
        PriorityQueue<Item> q = new PriorityQueue<>(1);
        try {
            q.offer(null);
            shouldThrow();
        } catch (NullPointerException success) {}
    }

    /**
     * add(null) throws NPE
     */
    public void testAddNull() {
        PriorityQueue<Item> q = new PriorityQueue<>(1);
        try {
            q.add(null);
            shouldThrow();
        } catch (NullPointerException success) {}
    }

    /**
     * Offer of comparable element succeeds
     */
    public void testOffer() {
        PriorityQueue<Item> q = new PriorityQueue<>(1);
        assertTrue(q.offer(zero));
        assertTrue(q.offer(one));
    }

    /**
     * Offer of non-Comparable throws CCE
     */
    public void testOfferNonComparable() {
        PriorityQueue<Object> q = new PriorityQueue<>(1);
        try {
            q.offer(new Object());
            shouldThrow();
        } catch (ClassCastException success) {
            assertTrue(q.isEmpty());
            mustEqual(0, q.size());
            assertNull(q.poll());
        }
    }

    /**
     * add of comparable succeeds
     */
    public void testAdd() {
        PriorityQueue<Item> q = new PriorityQueue<>(SIZE);
        for (int i = 0; i < SIZE; ++i) {
            mustEqual(i, q.size());
            mustAdd(q, i);
        }
    }

    /**
     * addAll(null) throws NPE
     */
    public void testAddAll1() {
        PriorityQueue<Item> q = new PriorityQueue<>(1);
        try {
            q.addAll(null);
            shouldThrow();
        } catch (NullPointerException success) {}
    }

    /**
     * addAll of a collection with null elements throws NPE
     */
    public void testAddAll2() {
        PriorityQueue<Item> q = new PriorityQueue<>(SIZE);
        try {
            q.addAll(Arrays.asList(new Item[SIZE]));
            shouldThrow();
        } catch (NullPointerException success) {}
    }

    /**
     * addAll of a collection with any null elements throws NPE after
     * possibly adding some elements
     */
    public void testAddAll3() {
        PriorityQueue<Item> q = new PriorityQueue<>(SIZE);
        Item[] items = new Item[2];
        items[0] = zero;
        try {
            q.addAll(Arrays.asList(items));
            shouldThrow();
        } catch (NullPointerException success) {}
    }

    /**
     * Queue contains all elements of successful addAll
     */
    public void testAddAll5() {
        Item[] empty = new Item[0];
        Item[] items = new Item[SIZE];
        for (int i = 0; i < SIZE; ++i)
            items[i] = itemFor(SIZE - 1 - i);
        PriorityQueue<Item> q = new PriorityQueue<>(SIZE);
        assertFalse(q.addAll(Arrays.asList(empty)));
        assertTrue(q.addAll(Arrays.asList(items)));
        for (int i = 0; i < SIZE; ++i)
            mustEqual(i, q.poll());
    }

    /**
     * poll succeeds unless empty
     */
    public void testPoll() {
        PriorityQueue<Item> q = populatedQueue(SIZE);
        for (int i = 0; i < SIZE; ++i) {
            mustEqual(i, q.poll());
        }
        assertNull(q.poll());
    }

    /**
     * peek returns next element, or null if empty
     */
    public void testPeek() {
        PriorityQueue<Item> q = populatedQueue(SIZE);
        for (int i = 0; i < SIZE; ++i) {
            mustEqual(i, q.peek());
            mustEqual(i, q.poll());
            assertTrue(q.peek() == null ||
                       !q.peek().equals(i));
        }
        assertNull(q.peek());
    }

    /**
     * element returns next element, or throws NSEE if empty
     */
    public void testElement() {
        PriorityQueue<Item> q = populatedQueue(SIZE);
        for (int i = 0; i < SIZE; ++i) {
            mustEqual(i, q.element());
            mustEqual(i, q.poll());
        }
        try {
            q.element();
            shouldThrow();
        } catch (NoSuchElementException success) {}
    }

    /**
     * remove removes next element, or throws NSEE if empty
     */
    public void testRemove() {
        PriorityQueue<Item> q = populatedQueue(SIZE);
        for (int i = 0; i < SIZE; ++i) {
            mustEqual(i, q.remove());
        }
        try {
            q.remove();
            shouldThrow();
        } catch (NoSuchElementException success) {}
    }

    /**
     * remove(x) removes x and returns true if present
     */
    public void testRemoveElement() {
        PriorityQueue<Item> q = populatedQueue(SIZE);
        for (int i = 1; i < SIZE; i += 2) {
            mustContain(q, i);
            mustRemove(q, i);
            mustNotContain(q, i);
            mustContain(q, i - 1);
        }
        for (int i = 0; i < SIZE; i += 2) {
            mustContain(q, i);
            mustRemove(q, i);
            mustNotContain(q, i);
            mustNotRemove(q, i + 1);
            mustNotContain(q, i + 1);
        }
        assertTrue(q.isEmpty());
    }

    /**
     * contains(x) reports true when elements added but not yet removed
     */
    public void testContains() {
        PriorityQueue<Item> q = populatedQueue(SIZE);
        for (int i = 0; i < SIZE; ++i) {
            mustContain(q, i);
            q.poll();
            mustNotContain(q, i);
        }
    }

    /**
     * clear removes all elements
     */
    public void testClear() {
        PriorityQueue<Item> q = populatedQueue(SIZE);
        q.clear();
        assertTrue(q.isEmpty());
        mustEqual(0, q.size());
        q.add(one);
        assertFalse(q.isEmpty());
        q.clear();
        assertTrue(q.isEmpty());
    }

    /**
     * containsAll(c) is true when c contains a subset of elements
     */
    public void testContainsAll() {
        PriorityQueue<Item> q = populatedQueue(SIZE);
        PriorityQueue<Item> p = new PriorityQueue<>(SIZE);
        for (int i = 0; i < SIZE; ++i) {
            assertTrue(q.containsAll(p));
            assertFalse(p.containsAll(q));
            mustAdd(p, i);
        }
        assertTrue(p.containsAll(q));
    }

    /**
     * retainAll(c) retains only those elements of c and reports true if changed
     */
    public void testRetainAll() {
        PriorityQueue<Item> q = populatedQueue(SIZE);
        PriorityQueue<Item> p = populatedQueue(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));
            mustEqual(SIZE - i, q.size());
            p.remove();
        }
    }

    /**
     * removeAll(c) removes only those elements of c and reports true if changed
     */
    public void testRemoveAll() {
        for (int i = 1; i < SIZE; ++i) {
            PriorityQueue<Item> q = populatedQueue(SIZE);
            PriorityQueue<Item> p = populatedQueue(i);
            assertTrue(q.removeAll(p));
            mustEqual(SIZE - i, q.size());
            for (int j = 0; j < i; ++j) {
                mustNotContain(q, p.remove());
            }
        }
    }

    /**
     * toArray contains all elements
     */
    public void testToArray() {
        PriorityQueue<Item> q = populatedQueue(SIZE);
        Object[] a = q.toArray();
        assertSame(Object[].class, a.getClass());
        Arrays.sort(a);
        for (Object o : a)
            assertSame(o, q.poll());
        assertTrue(q.isEmpty());
    }

    /**
     * toArray(a) contains all elements
     */
    public void testToArray2() {
        PriorityQueue<Item> q = populatedQueue(SIZE);
        Item[] items = new Item[SIZE];
        Item[] array = q.toArray(items);
        assertSame(items, array);
        Arrays.sort(items);
        for (Item o : items)
            assertSame(o, q.poll());
        assertTrue(q.isEmpty());
    }

    /**
     * iterator iterates through all elements
     */
    public void testIterator() {
        PriorityQueue<Item> q = populatedQueue(SIZE);
        Iterator<? extends Item> it = q.iterator();
        int i;
        for (i = 0; it.hasNext(); i++)
            mustContain(q, it.next());
        mustEqual(i, SIZE);
        assertIteratorExhausted(it);
    }

    /**
     * iterator of empty collection has no elements
     */
    public void testEmptyIterator() {
        assertIteratorExhausted(new PriorityQueue<Item>().iterator());
    }

    /**
     * iterator.remove removes current element
     */
    public void testIteratorRemove() {
        final PriorityQueue<Item> q = new PriorityQueue<>(3);
        q.add(two);
        q.add(one);
        q.add(three);

        Iterator<? extends Item> it = q.iterator();
        it.next();
        it.remove();

        it = q.iterator();
        mustEqual(it.next(), two);
        mustEqual(it.next(), three);
        assertFalse(it.hasNext());
    }

    /**
     * toString contains toStrings of elements
     */
    public void testToString() {
        PriorityQueue<Item> q = populatedQueue(SIZE);
        String s = q.toString();
        for (int i = 0; i < SIZE; ++i) {
            assertTrue(s.contains(String.valueOf(i)));
        }
    }

    /**
     * A deserialized/reserialized queue has same elements
     */
    public void testSerialization() throws Exception {
        Queue<Item> x = populatedQueue(SIZE);
        Queue<Item> y = serialClone(x);

        assertNotSame(x, y);
        mustEqual(x.size(), y.size());
        while (!x.isEmpty()) {
            assertFalse(y.isEmpty());
            mustEqual(x.remove(), y.remove());
        }
        assertTrue(y.isEmpty());
    }
}
Revision:	1.49
Committed:	Wed Jan 27 01:57:24 2021 UTC (3 years, 3 months ago) by jsr166
Branch:	MAIN
CVS Tags:	HEAD
Changes since 1.48:	+14 -14 lines
Log Message:	use diamond <> pervasively
#	Content
1	/*
2	* Written by Doug Lea with assistance from members of JCP JSR-166
3	* Expert Group and released to the public domain, as explained at
4	* http://creativecommons.org/publicdomain/zero/1.0/
5	* Other contributors include Andrew Wright, Jeffrey Hayes,
6	* Pat Fisher, Mike Judd.
7	*/
8
9	import java.util.Arrays;
10	import java.util.Collection;
11	import java.util.Comparator;
12	import java.util.Iterator;
13	import java.util.NoSuchElementException;
14	import java.util.PriorityQueue;
15	import java.util.Queue;
16
17	import junit.framework.Test;
18
19	public class PriorityQueueTest extends JSR166TestCase {
20	public static void main(String[] args) {
21	main(suite(), args);
22	}
23	public static Test suite() {
24	class Implementation implements CollectionImplementation {
25	public Class<?> klazz() { return PriorityQueue.class; }
26	public Collection emptyCollection() { return new PriorityQueue(); }
27	public Object makeElement(int i) { return JSR166TestCase.itemFor(i); }
28	public boolean isConcurrent() { return false; }
29	public boolean permitsNulls() { return false; }
30	}
31	class ComparatorImplementation implements CollectionImplementation {
32	public Class<?> klazz() { return PriorityQueue.class; }
33	@SuppressWarnings("unchecked")
34	public Collection emptyCollection() {
35	return new PriorityQueue(new MyReverseComparator());
36	}
37	public Object makeElement(int i) { return JSR166TestCase.itemFor(i); }
38	public boolean isConcurrent() { return false; }
39	public boolean permitsNulls() { return false; }
40	}
41	return newTestSuite(
42	PriorityQueueTest.class,
43	CollectionTest.testSuite(new Implementation()),
44	CollectionTest.testSuite(new ComparatorImplementation()));
45	}
46
47	static class MyReverseComparator implements Comparator, java.io.Serializable {
48	@SuppressWarnings("unchecked")
49	public int compare(Object x, Object y) {
50	return ((Comparable)y).compareTo(x);
51	}
52	}
53
54	/**
55	* Returns a new queue of given size containing consecutive
56	* Items 0 ... n - 1.
57	*/
58	private static PriorityQueue<Item> populatedQueue(int n) {
59	PriorityQueue<Item> q = new PriorityQueue<>(n);
60	assertTrue(q.isEmpty());
61	for (int i = n - 1; i >= 0; i -= 2)
62	mustOffer(q, i);
63	for (int i = (n & 1); i < n; i += 2)
64	mustOffer(q, i);
65	assertFalse(q.isEmpty());
66	mustEqual(n, q.size());
67	mustEqual(0, q.peek());
68	return q;
69	}
70
71	/**
72	* A new queue has unbounded capacity
73	*/
74	public void testConstructor1() {
75	mustEqual(0, new PriorityQueue<Item>(SIZE).size());
76	}
77
78	/**
79	* Constructor throws IllegalArgumentException if capacity argument nonpositive
80	*/
81	public void testConstructor2() {
82	try {
83	new PriorityQueue<Item>(0);
84	shouldThrow();
85	} catch (IllegalArgumentException success) {}
86	}
87
88	/**
89	* Initializing from null Collection throws NPE
90	*/
91	public void testConstructor3() {
92	try {
93	new PriorityQueue<Item>((Collection<Item>)null);
94	shouldThrow();
95	} catch (NullPointerException success) {}
96	}
97
98	/**
99	* Initializing from Collection of null elements throws NPE
100	*/
101	public void testConstructor4() {
102	try {
103	new PriorityQueue<Item>(Arrays.asList(new Item[SIZE]));
104	shouldThrow();
105	} catch (NullPointerException success) {}
106	}
107
108	/**
109	* Initializing from Collection with some null elements throws NPE
110	*/
111	public void testConstructor5() {
112	Item[] items = new Item[2];
113	items[0] = zero;
114	try {
115	new PriorityQueue<Item>(Arrays.asList(items));
116	shouldThrow();
117	} catch (NullPointerException success) {}
118	}
119
120	/**
121	* Queue contains all elements of collection used to initialize
122	*/
123	public void testConstructor6() {
124	Item[] items = defaultItems;
125	PriorityQueue<Item> q = new PriorityQueue<>(Arrays.asList(items));
126	for (int i = 0; i < SIZE; ++i)
127	mustEqual(items[i], q.poll());
128	}
129
130	/**
131	* The comparator used in constructor is used
132	*/
133	public void testConstructor7() {
134	MyReverseComparator cmp = new MyReverseComparator();
135	@SuppressWarnings("unchecked")
136	PriorityQueue<Item> q = new PriorityQueue<>(SIZE, cmp);
137	assertEquals(cmp, q.comparator());
138	Item[] items = seqItems(SIZE);
139	q.addAll(Arrays.asList(items));
140	for (int i = SIZE - 1; i >= 0; --i)
141	mustEqual(items[i], q.poll());
142	}
143
144	/**
145	* isEmpty is true before add, false after
146	*/
147	public void testEmpty() {
148	PriorityQueue<Item> q = new PriorityQueue<>(2);
149	assertTrue(q.isEmpty());
150	q.add(one);
151	assertFalse(q.isEmpty());
152	q.add(two);
153	q.remove();
154	q.remove();
155	assertTrue(q.isEmpty());
156	}
157
158	/**
159	* size changes when elements added and removed
160	*/
161	public void testSize() {
162	PriorityQueue<Item> q = populatedQueue(SIZE);
163	for (int i = 0; i < SIZE; ++i) {
164	mustEqual(SIZE - i, q.size());
165	q.remove();
166	}
167	for (int i = 0; i < SIZE; ++i) {
168	mustEqual(i, q.size());
169	mustAdd(q, i);
170	}
171	}
172
173	/**
174	* offer(null) throws NPE
175	*/
176	public void testOfferNull() {
177	PriorityQueue<Item> q = new PriorityQueue<>(1);
178	try {
179	q.offer(null);
180	shouldThrow();
181	} catch (NullPointerException success) {}
182	}
183
184	/**
185	* add(null) throws NPE
186	*/
187	public void testAddNull() {
188	PriorityQueue<Item> q = new PriorityQueue<>(1);
189	try {
190	q.add(null);
191	shouldThrow();
192	} catch (NullPointerException success) {}
193	}
194
195	/**
196	* Offer of comparable element succeeds
197	*/
198	public void testOffer() {
199	PriorityQueue<Item> q = new PriorityQueue<>(1);
200	assertTrue(q.offer(zero));
201	assertTrue(q.offer(one));
202	}
203
204	/**
205	* Offer of non-Comparable throws CCE
206	*/
207	public void testOfferNonComparable() {
208	PriorityQueue<Object> q = new PriorityQueue<>(1);
209	try {
210	q.offer(new Object());
211	shouldThrow();
212	} catch (ClassCastException success) {
213	assertTrue(q.isEmpty());
214	mustEqual(0, q.size());
215	assertNull(q.poll());
216	}
217	}
218
219	/**
220	* add of comparable succeeds
221	*/
222	public void testAdd() {
223	PriorityQueue<Item> q = new PriorityQueue<>(SIZE);
224	for (int i = 0; i < SIZE; ++i) {
225	mustEqual(i, q.size());
226	mustAdd(q, i);
227	}
228	}
229
230	/**
231	* addAll(null) throws NPE
232	*/
233	public void testAddAll1() {
234	PriorityQueue<Item> q = new PriorityQueue<>(1);
235	try {
236	q.addAll(null);
237	shouldThrow();
238	} catch (NullPointerException success) {}
239	}
240
241	/**
242	* addAll of a collection with null elements throws NPE
243	*/
244	public void testAddAll2() {
245	PriorityQueue<Item> q = new PriorityQueue<>(SIZE);
246	try {
247	q.addAll(Arrays.asList(new Item[SIZE]));
248	shouldThrow();
249	} catch (NullPointerException success) {}
250	}
251
252	/**
253	* addAll of a collection with any null elements throws NPE after
254	* possibly adding some elements
255	*/
256	public void testAddAll3() {
257	PriorityQueue<Item> q = new PriorityQueue<>(SIZE);
258	Item[] items = new Item[2];
259	items[0] = zero;
260	try {
261	q.addAll(Arrays.asList(items));
262	shouldThrow();
263	} catch (NullPointerException success) {}
264	}
265
266	/**
267	* Queue contains all elements of successful addAll
268	*/
269	public void testAddAll5() {
270	Item[] empty = new Item[0];
271	Item[] items = new Item[SIZE];
272	for (int i = 0; i < SIZE; ++i)
273	items[i] = itemFor(SIZE - 1 - i);
274	PriorityQueue<Item> q = new PriorityQueue<>(SIZE);
275	assertFalse(q.addAll(Arrays.asList(empty)));
276	assertTrue(q.addAll(Arrays.asList(items)));
277	for (int i = 0; i < SIZE; ++i)
278	mustEqual(i, q.poll());
279	}
280
281	/**
282	* poll succeeds unless empty
283	*/
284	public void testPoll() {
285	PriorityQueue<Item> q = populatedQueue(SIZE);
286	for (int i = 0; i < SIZE; ++i) {
287	mustEqual(i, q.poll());
288	}
289	assertNull(q.poll());
290	}
291
292	/**
293	* peek returns next element, or null if empty
294	*/
295	public void testPeek() {
296	PriorityQueue<Item> q = populatedQueue(SIZE);
297	for (int i = 0; i < SIZE; ++i) {
298	mustEqual(i, q.peek());
299	mustEqual(i, q.poll());
300	assertTrue(q.peek() == null \|\|
301	!q.peek().equals(i));
302	}
303	assertNull(q.peek());
304	}
305
306	/**
307	* element returns next element, or throws NSEE if empty
308	*/
309	public void testElement() {
310	PriorityQueue<Item> q = populatedQueue(SIZE);
311	for (int i = 0; i < SIZE; ++i) {
312	mustEqual(i, q.element());
313	mustEqual(i, q.poll());
314	}
315	try {
316	q.element();
317	shouldThrow();
318	} catch (NoSuchElementException success) {}
319	}
320
321	/**
322	* remove removes next element, or throws NSEE if empty
323	*/
324	public void testRemove() {
325	PriorityQueue<Item> q = populatedQueue(SIZE);
326	for (int i = 0; i < SIZE; ++i) {
327	mustEqual(i, q.remove());
328	}
329	try {
330	q.remove();
331	shouldThrow();
332	} catch (NoSuchElementException success) {}
333	}
334
335	/**
336	* remove(x) removes x and returns true if present
337	*/
338	public void testRemoveElement() {
339	PriorityQueue<Item> q = populatedQueue(SIZE);
340	for (int i = 1; i < SIZE; i += 2) {
341	mustContain(q, i);
342	mustRemove(q, i);
343	mustNotContain(q, i);
344	mustContain(q, i - 1);
345	}
346	for (int i = 0; i < SIZE; i += 2) {
347	mustContain(q, i);
348	mustRemove(q, i);
349	mustNotContain(q, i);
350	mustNotRemove(q, i + 1);
351	mustNotContain(q, i + 1);
352	}
353	assertTrue(q.isEmpty());
354	}
355
356	/**
357	* contains(x) reports true when elements added but not yet removed
358	*/
359	public void testContains() {
360	PriorityQueue<Item> q = populatedQueue(SIZE);
361	for (int i = 0; i < SIZE; ++i) {
362	mustContain(q, i);
363	q.poll();
364	mustNotContain(q, i);
365	}
366	}
367
368	/**
369	* clear removes all elements
370	*/
371	public void testClear() {
372	PriorityQueue<Item> q = populatedQueue(SIZE);
373	q.clear();
374	assertTrue(q.isEmpty());
375	mustEqual(0, q.size());
376	q.add(one);
377	assertFalse(q.isEmpty());
378	q.clear();
379	assertTrue(q.isEmpty());
380	}
381
382	/**
383	* containsAll(c) is true when c contains a subset of elements
384	*/
385	public void testContainsAll() {
386	PriorityQueue<Item> q = populatedQueue(SIZE);
387	PriorityQueue<Item> p = new PriorityQueue<>(SIZE);
388	for (int i = 0; i < SIZE; ++i) {
389	assertTrue(q.containsAll(p));
390	assertFalse(p.containsAll(q));
391	mustAdd(p, i);
392	}
393	assertTrue(p.containsAll(q));
394	}
395
396	/**
397	* retainAll(c) retains only those elements of c and reports true if changed
398	*/
399	public void testRetainAll() {
400	PriorityQueue<Item> q = populatedQueue(SIZE);
401	PriorityQueue<Item> p = populatedQueue(SIZE);
402	for (int i = 0; i < SIZE; ++i) {
403	boolean changed = q.retainAll(p);
404	if (i == 0)
405	assertFalse(changed);
406	else
407	assertTrue(changed);
408
409	assertTrue(q.containsAll(p));
410	mustEqual(SIZE - i, q.size());
411	p.remove();
412	}
413	}
414
415	/**
416	* removeAll(c) removes only those elements of c and reports true if changed
417	*/
418	public void testRemoveAll() {
419	for (int i = 1; i < SIZE; ++i) {
420	PriorityQueue<Item> q = populatedQueue(SIZE);
421	PriorityQueue<Item> p = populatedQueue(i);
422	assertTrue(q.removeAll(p));
423	mustEqual(SIZE - i, q.size());
424	for (int j = 0; j < i; ++j) {
425	mustNotContain(q, p.remove());
426	}
427	}
428	}
429
430	/**
431	* toArray contains all elements
432	*/
433	public void testToArray() {
434	PriorityQueue<Item> q = populatedQueue(SIZE);
435	Object[] a = q.toArray();
436	assertSame(Object[].class, a.getClass());
437	Arrays.sort(a);
438	for (Object o : a)
439	assertSame(o, q.poll());
440	assertTrue(q.isEmpty());
441	}
442
443	/**
444	* toArray(a) contains all elements
445	*/
446	public void testToArray2() {
447	PriorityQueue<Item> q = populatedQueue(SIZE);
448	Item[] items = new Item[SIZE];
449	Item[] array = q.toArray(items);
450	assertSame(items, array);
451	Arrays.sort(items);
452	for (Item o : items)
453	assertSame(o, q.poll());
454	assertTrue(q.isEmpty());
455	}
456
457	/**
458	* iterator iterates through all elements
459	*/
460	public void testIterator() {
461	PriorityQueue<Item> q = populatedQueue(SIZE);
462	Iterator<? extends Item> it = q.iterator();
463	int i;
464	for (i = 0; it.hasNext(); i++)
465	mustContain(q, it.next());
466	mustEqual(i, SIZE);
467	assertIteratorExhausted(it);
468	}
469
470	/**
471	* iterator of empty collection has no elements
472	*/
473	public void testEmptyIterator() {
474	assertIteratorExhausted(new PriorityQueue<Item>().iterator());
475	}
476
477	/**
478	* iterator.remove removes current element
479	*/
480	public void testIteratorRemove() {
481	final PriorityQueue<Item> q = new PriorityQueue<>(3);
482	q.add(two);
483	q.add(one);
484	q.add(three);
485
486	Iterator<? extends Item> it = q.iterator();
487	it.next();
488	it.remove();
489
490	it = q.iterator();
491	mustEqual(it.next(), two);
492	mustEqual(it.next(), three);
493	assertFalse(it.hasNext());
494	}
495
496	/**
497	* toString contains toStrings of elements
498	*/
499	public void testToString() {
500	PriorityQueue<Item> q = populatedQueue(SIZE);
501	String s = q.toString();
502	for (int i = 0; i < SIZE; ++i) {
503	assertTrue(s.contains(String.valueOf(i)));
504	}
505	}
506
507	/**
508	* A deserialized/reserialized queue has same elements
509	*/
510	public void testSerialization() throws Exception {
511	Queue<Item> x = populatedQueue(SIZE);
512	Queue<Item> y = serialClone(x);
513
514	assertNotSame(x, y);
515	mustEqual(x.size(), y.size());
516	while (!x.isEmpty()) {
517	assertFalse(y.isEmpty());
518	mustEqual(x.remove(), y.remove());
519	}
520	assertTrue(y.isEmpty());
521	}
522	}