ViewVC Help

View File | Revision Log | Show Annotations | Download File | Root Listing

root/jsr166/jsr166/src/test/tck/PriorityQueueTest.java

Comparing jsr166/src/test/tck/PriorityQueueTest.java (file contents):
Revision 1.4 by dl, Sat Sep 20 00:31:57 2003 UTC vs.
Revision 1.49 by jsr166, Wed Jan 27 01:57:24 2021 UTC

#	Line 1 | Line 1
1		/*
2	<	* Written by members of JCP JSR-166 Expert Group and released to the
3	<	* public domain. Use, modify, and redistribute this code in any way
4	<	* without acknowledgement. Other contributors include Andrew Wright,
5	<	* Jeffrey Hayes, Pat Fischer, Mike Judd.
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 junit.framework.*;
10	<	import java.util.*;
11	<	import java.util.concurrent.*;
12	<	import java.io.*;
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	<	public class PriorityQueueTest extends JSR166TestCase {
17	>	import junit.framework.Test;
18
19	+	public class PriorityQueueTest extends JSR166TestCase {
20		public static void main(String[] args) {
21	<	junit.textui.TestRunner.run (suite());
21	>	main(suite(), args);
22		}
18	–
23		public static Test suite() {
24	<	return new TestSuite(PriorityQueueTest.class);
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 {
47	>	static class MyReverseComparator implements Comparator, java.io.Serializable {
48	>	@SuppressWarnings("unchecked")
49		public int compare(Object x, Object y) {
50	<	int i = ((Integer)x).intValue();
26	<	int j = ((Integer)y).intValue();
27	<	if (i < j) return 1;
28	<	if (i > j) return -1;
29	<	return 0;
50	>	return ((Comparable)y).compareTo(x);
51		}
52		}
53
33	–
54		/**
55	<	* Create a queue of given size containing consecutive
56	<	* Integers 0 ... n.
55	>	* Returns a new queue of given size containing consecutive
56	>	* Items 0 ... n - 1.
57		*/
58	<	private PriorityQueue populatedQueue(int n) {
59	<	PriorityQueue q = new PriorityQueue(n);
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	<	assertTrue(q.offer(new Integer(i)));
63	<	for(int i = (n & 1); i < n; i+=2)
64	<	assertTrue(q.offer(new Integer(i)));
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	<	assertEquals(n, q.size());
66	>	mustEqual(n, q.size());
67	>	mustEqual(0, q.peek());
68		return q;
69		}
70	<
71	<	public void testConstructor1(){
72	<	assertEquals(0, new PriorityQueue(SIZE).size());
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	<	public void testConstructor2(){
78	>	/**
79	>	* Constructor throws IllegalArgumentException if capacity argument nonpositive
80	>	*/
81	>	public void testConstructor2() {
82		try {
83	<	PriorityQueue q = new PriorityQueue(0);
84	<	fail("Cannot make zero-sized");
85	<	}
59	<	catch (IllegalArgumentException success) {}
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() {
63	–
92		try {
93	<	PriorityQueue q = new PriorityQueue((Collection)null);
94	<	fail("Cannot make from null collection");
95	<	}
68	<	catch (NullPointerException success) {}
93	>	new PriorityQueue<Item>((Collection<Item>)null);
94	>	shouldThrow();
95	>	} catch (NullPointerException success) {}
96		}
97
98	<	public void testConstructor4(){
98	>	/**
99	>	* Initializing from Collection of null elements throws NPE
100	>	*/
101	>	public void testConstructor4() {
102		try {
103	<	Integer[] ints = new Integer[SIZE];
104	<	PriorityQueue q = new PriorityQueue(Arrays.asList(ints));
105	<	fail("Cannot make with null elements");
76	<	}
77	<	catch (NullPointerException success) {}
103	>	new PriorityQueue<Item>(Arrays.asList(new Item[SIZE]));
104	>	shouldThrow();
105	>	} catch (NullPointerException success) {}
106		}
107
108	<	public void testConstructor5(){
109	<	try {
110	<	Integer[] ints = new Integer[SIZE];
111	<	for (int i = 0; i < SIZE-1; ++i)
112	<	ints[i] = new Integer(i);
113	<	PriorityQueue q = new PriorityQueue(Arrays.asList(ints));
114	<	fail("Cannot make with null elements");
115	<	}
116	<	catch (NullPointerException success) {}
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	<	public void testConstructor6(){
121	<	try {
122	<	Integer[] ints = new Integer[SIZE];
123	<	for (int i = 0; i < SIZE; ++i)
124	<	ints[i] = new Integer(i);
125	<	PriorityQueue q = new PriorityQueue(Arrays.asList(ints));
126	<	for (int i = 0; i < SIZE; ++i)
127	<	assertEquals(ints[i], q.poll());
99	<	}
100	<	finally {}
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	<	public void testConstructor7(){
131	<	try {
132	<	MyReverseComparator cmp = new MyReverseComparator();
133	<	PriorityQueue q = new PriorityQueue(SIZE, cmp);
134	<	assertEquals(cmp, q.comparator());
135	<	Integer[] ints = new Integer[SIZE];
136	<	for (int i = 0; i < SIZE; ++i)
137	<	ints[i] = new Integer(i);
138	<	q.addAll(Arrays.asList(ints));
139	<	for (int i = SIZE-1; i >= 0; --i)
140	<	assertEquals(ints[i], q.poll());
141	<	}
115	<	finally {}
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 q = new PriorityQueue(2);
148	>	PriorityQueue<Item> q = new PriorityQueue<>(2);
149		assertTrue(q.isEmpty());
150	<	q.add(new Integer(1));
150	>	q.add(one);
151		assertFalse(q.isEmpty());
152	<	q.add(new Integer(2));
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 q = populatedQueue(SIZE);
162	>	PriorityQueue<Item> q = populatedQueue(SIZE);
163		for (int i = 0; i < SIZE; ++i) {
164	<	assertEquals(SIZE-i, q.size());
164	>	mustEqual(SIZE - i, q.size());
165		q.remove();
166		}
167		for (int i = 0; i < SIZE; ++i) {
168	<	assertEquals(i, q.size());
169	<	q.add(new Integer(i));
168	>	mustEqual(i, q.size());
169	>	mustAdd(q, i);
170		}
171		}
172
173	<	public void testOfferNull(){
174	<	try {
175	<	PriorityQueue q = new PriorityQueue(1);
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	<	fail("should throw NPE");
181	<	} catch (NullPointerException success) { }
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 q = new PriorityQueue(1);
200	<	assertTrue(q.offer(new Integer(0)));
201	<	assertTrue(q.offer(new Integer(1)));
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 {
157	–	PriorityQueue q = new PriorityQueue(1);
158	–	q.offer(new Object());
210		q.offer(new Object());
211	<	q.offer(new Object());
212	<	fail("should throw CCE");
211	>	shouldThrow();
212	>	} catch (ClassCastException success) {
213	>	assertTrue(q.isEmpty());
214	>	mustEqual(0, q.size());
215	>	assertNull(q.poll());
216		}
163	–	catch(ClassCastException success) {}
217		}
218
219	<	public void testAdd(){
220	<	PriorityQueue q = new PriorityQueue(SIZE);
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	<	assertEquals(i, q.size());
226	<	assertTrue(q.add(new Integer(i)));
225	>	mustEqual(i, q.size());
226	>	mustAdd(q, i);
227		}
228		}
229
230	<	public void testAddAll1(){
230	>	/**
231	>	* addAll(null) throws NPE
232	>	*/
233	>	public void testAddAll1() {
234	>	PriorityQueue<Item> q = new PriorityQueue<>(1);
235		try {
176	–	PriorityQueue q = new PriorityQueue(1);
236		q.addAll(null);
237	<	fail("Cannot add null collection");
238	<	}
180	<	catch (NullPointerException success) {}
237	>	shouldThrow();
238	>	} catch (NullPointerException success) {}
239		}
240	<	public void testAddAll2(){
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	<	PriorityQueue q = new PriorityQueue(SIZE);
248	<	Integer[] ints = new Integer[SIZE];
249	<	q.addAll(Arrays.asList(ints));
187	<	fail("Cannot add null elements");
188	<	}
189	<	catch (NullPointerException success) {}
247	>	q.addAll(Arrays.asList(new Item[SIZE]));
248	>	shouldThrow();
249	>	} catch (NullPointerException success) {}
250		}
251	<	public void testAddAll3(){
252	<	try {
253	<	PriorityQueue q = new PriorityQueue(SIZE);
254	<	Integer[] ints = new Integer[SIZE];
255	<	for (int i = 0; i < SIZE-1; ++i)
256	<	ints[i] = new Integer(i);
257	<	q.addAll(Arrays.asList(ints));
258	<	fail("Cannot add null elements");
259	<	}
260	<	catch (NullPointerException success) {}
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	<	public void testAddAll5(){
267	<	try {
268	<	Integer[] empty = new Integer[0];
269	<	Integer[] ints = new Integer[SIZE];
270	<	for (int i = 0; i < SIZE; ++i)
271	<	ints[i] = new Integer(SIZE-1-i);
272	<	PriorityQueue q = new PriorityQueue(SIZE);
273	<	assertFalse(q.addAll(Arrays.asList(empty)));
274	<	assertTrue(q.addAll(Arrays.asList(ints)));
275	<	for (int i = 0; i < SIZE; ++i)
276	<	assertEquals(new Integer(i), q.poll());
277	<	}
278	<	finally {}
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	<	public void testPoll(){
282	<	PriorityQueue q = populatedQueue(SIZE);
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	<	assertEquals(i, ((Integer)q.poll()).intValue());
287	>	mustEqual(i, q.poll());
288		}
289	<	assertNull(q.poll());
289	>	assertNull(q.poll());
290		}
291
292	<	public void testPeek(){
293	<	PriorityQueue q = populatedQueue(SIZE);
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	<	assertEquals(i, ((Integer)q.peek()).intValue());
299	<	q.poll();
298	>	mustEqual(i, q.peek());
299	>	mustEqual(i, q.poll());
300		assertTrue(q.peek() == null ||
301	<	i != ((Integer)q.peek()).intValue());
301	>	!q.peek().equals(i));
302		}
303	<	assertNull(q.peek());
303	>	assertNull(q.peek());
304		}
305
306	<	public void testElement(){
307	<	PriorityQueue q = populatedQueue(SIZE);
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	<	assertEquals(i, ((Integer)q.element()).intValue());
313	<	q.poll();
312	>	mustEqual(i, q.element());
313	>	mustEqual(i, q.poll());
314		}
315		try {
316		q.element();
317	<	fail("no such element");
318	<	}
247	<	catch (NoSuchElementException success) {}
317	>	shouldThrow();
318	>	} catch (NoSuchElementException success) {}
319		}
320
321	<	public void testRemove(){
322	<	PriorityQueue q = populatedQueue(SIZE);
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	<	assertEquals(i, ((Integer)q.remove()).intValue());
327	>	mustEqual(i, q.remove());
328		}
329		try {
330		q.remove();
331	<	fail("remove should throw");
332	<	} catch (NoSuchElementException success){
259	<	}
331	>	shouldThrow();
332	>	} catch (NoSuchElementException success) {}
333		}
334
335	<	public void testRemoveElement(){
336	<	PriorityQueue q = populatedQueue(SIZE);
337	<	for (int i = 1; i < SIZE; i+=2) {
338	<	assertTrue(q.remove(new Integer(i)));
339	<	}
340	<	for (int i = 0; i < SIZE; i+=2) {
341	<	assertTrue(q.remove(new Integer(i)));
342	<	assertFalse(q.remove(new Integer(i+1)));
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	<	public void testContains(){
357	<	PriorityQueue q = populatedQueue(SIZE);
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	<	assertTrue(q.contains(new Integer(i)));
362	>	mustContain(q, i);
363		q.poll();
364	<	assertFalse(q.contains(new Integer(i)));
364	>	mustNotContain(q, i);
365		}
366		}
367
368	<	public void testClear(){
369	<	PriorityQueue q = populatedQueue(SIZE);
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	<	assertEquals(0, q.size());
376	<	q.add(new Integer(1));
375	>	mustEqual(0, q.size());
376	>	q.add(one);
377		assertFalse(q.isEmpty());
378		q.clear();
379		assertTrue(q.isEmpty());
380		}
381
382	<	public void testContainsAll(){
383	<	PriorityQueue q = populatedQueue(SIZE);
384	<	PriorityQueue p = new PriorityQueue(SIZE);
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	<	p.add(new Integer(i));
391	>	mustAdd(p, i);
392		}
393		assertTrue(p.containsAll(q));
394		}
395
396	<	public void testRetainAll(){
397	<	PriorityQueue q = populatedQueue(SIZE);
398	<	PriorityQueue p = populatedQueue(SIZE);
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)
#	Line 313 | Line 407 | public class PriorityQueueTest extends J
407		assertTrue(changed);
408
409		assertTrue(q.containsAll(p));
410	<	assertEquals(SIZE-i, q.size());
410	>	mustEqual(SIZE - i, q.size());
411		p.remove();
412		}
413		}
414
415	<	public void testRemoveAll(){
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 q = populatedQueue(SIZE);
421	<	PriorityQueue p = populatedQueue(i);
420	>	PriorityQueue<Item> q = populatedQueue(SIZE);
421	>	PriorityQueue<Item> p = populatedQueue(i);
422		assertTrue(q.removeAll(p));
423	<	assertEquals(SIZE-i, q.size());
423	>	mustEqual(SIZE - i, q.size());
424		for (int j = 0; j < i; ++j) {
425	<	Integer I = (Integer)(p.remove());
329	<	assertFalse(q.contains(I));
425	>	mustNotContain(q, p.remove());
426		}
427		}
428		}
429
430	<	public void testToArray(){
431	<	PriorityQueue q = populatedQueue(SIZE);
432	<	Object[] o = q.toArray();
433	<	Arrays.sort(o);
434	<	for(int i = 0; i < o.length; i++)
435	<	assertEquals(o[i], q.poll());
436	<	}
437	<
438	<	public void testToArray2(){
439	<	PriorityQueue q = populatedQueue(SIZE);
440	<	Integer[] ints = new Integer[SIZE];
441	<	ints = (Integer[])q.toArray(ints);
442	<	Arrays.sort(ints);
443	<	for(int i = 0; i < ints.length; i++)
444	<	assertEquals(ints[i], q.poll());
445	<	}
446	<
447	<	public void testIterator(){
448	<	PriorityQueue q = populatedQueue(SIZE);
449	<	int i = 0;
450	<	Iterator it = q.iterator();
451	<	while(it.hasNext()) {
452	<	assertTrue(q.contains(it.next()));
453	<	++i;
454	<	}
455	<	assertEquals(i, SIZE);
456	<	}
457	<
458	<	public void testIteratorRemove () {
459	<
460	<	final PriorityQueue q = new PriorityQueue(3);
461	<
462	<	q.add(new Integer(2));
463	<	q.add(new Integer(1));
464	<	q.add(new Integer(3));
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	<	Iterator it = q.iterator();
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	<	assertEquals(it.next(), new Integer(2));
492	<	assertEquals(it.next(), new Integer(3));
491	>	mustEqual(it.next(), two);
492	>	mustEqual(it.next(), three);
493		assertFalse(it.hasNext());
494		}
495
496	<
497	<	public void testToString(){
498	<	PriorityQueue q = populatedQueue(SIZE);
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.indexOf(String.valueOf(i)) >= 0);
503	>	assertTrue(s.contains(String.valueOf(i)));
504		}
505	<	}
505	>	}
506
507	<	public void testSerialization() {
508	<	PriorityQueue q = populatedQueue(SIZE);
509	<	try {
510	<	ByteArrayOutputStream bout = new ByteArrayOutputStream(10000);
511	<	ObjectOutputStream out = new ObjectOutputStream(new BufferedOutputStream(bout));
512	<	out.writeObject(q);
513	<	out.close();
514	<
515	<	ByteArrayInputStream bin = new ByteArrayInputStream(bout.toByteArray());
516	<	ObjectInputStream in = new ObjectInputStream(new BufferedInputStream(bin));
517	<	PriorityQueue r = (PriorityQueue)in.readObject();
518	<	assertEquals(q.size(), r.size());
401	<	while (!q.isEmpty())
402	<	assertEquals(q.remove(), r.remove());
403	<	} catch(Exception e){
404	<	fail("unexpected exception");
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		}

Diff Legend

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