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.11 by jsr166, Mon Nov 16 05:30:08 2009 UTC vs.
Revision 1.49 by jsr166, Wed Jan 27 01:57:24 2021 UTC

#	Line 1 | Line 1
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/licenses/publicdomain
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	>	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		}
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();
25	<	int j = ((Integer)y).intValue();
26	<	if (i < j) return 1;
27	<	if (i > j) return -1;
28	<	return 0;
50	>	return ((Comparable)y).compareTo(x);
51		}
52		}
53
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
#	Line 49 | Line 72 | public class PriorityQueueTest extends J
72		* A new queue has unbounded capacity
73		*/
74		public void testConstructor1() {
75	<	assertEquals(0, new PriorityQueue(SIZE).size());
75	>	mustEqual(0, new PriorityQueue<Item>(SIZE).size());
76		}
77
78		/**
79	<	* Constructor throws IAE if  capacity argument nonpositive
79	>	* Constructor throws IllegalArgumentException if capacity argument nonpositive
80		*/
81		public void testConstructor2() {
82		try {
83	<	PriorityQueue q = new PriorityQueue(0);
83	>	new PriorityQueue<Item>(0);
84		shouldThrow();
85	<	}
63	<	catch (IllegalArgumentException success) {}
85	>	} catch (IllegalArgumentException success) {}
86		}
87
88		/**
#	Line 68 | Line 90 | public class PriorityQueueTest extends J
90		*/
91		public void testConstructor3() {
92		try {
93	<	PriorityQueue q = new PriorityQueue((Collection)null);
93	>	new PriorityQueue<Item>((Collection<Item>)null);
94		shouldThrow();
95	<	}
74	<	catch (NullPointerException success) {}
95	>	} catch (NullPointerException success) {}
96		}
97
98		/**
#	Line 79 | Line 100 | public class PriorityQueueTest extends J
100		*/
101		public void testConstructor4() {
102		try {
103	<	Integer[] ints = new Integer[SIZE];
83	<	PriorityQueue q = new PriorityQueue(Arrays.asList(ints));
103	>	new PriorityQueue<Item>(Arrays.asList(new Item[SIZE]));
104		shouldThrow();
105	<	}
86	<	catch (NullPointerException success) {}
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	<	Integer[] ints = new Integer[SIZE];
95	<	for (int i = 0; i < SIZE-1; ++i)
96	<	ints[i] = new Integer(i);
97	<	PriorityQueue q = new PriorityQueue(Arrays.asList(ints));
115	>	new PriorityQueue<Item>(Arrays.asList(items));
116		shouldThrow();
117	<	}
100	<	catch (NullPointerException success) {}
117	>	} catch (NullPointerException success) {}
118		}
119
120		/**
121		* Queue contains all elements of collection used to initialize
122		*/
123		public void testConstructor6() {
124	<	try {
125	<	Integer[] ints = new Integer[SIZE];
126	<	for (int i = 0; i < SIZE; ++i)
127	<	ints[i] = new Integer(i);
111	<	PriorityQueue q = new PriorityQueue(Arrays.asList(ints));
112	<	for (int i = 0; i < SIZE; ++i)
113	<	assertEquals(ints[i], q.poll());
114	<	}
115	<	finally {}
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	<	try {
135	<	MyReverseComparator cmp = new MyReverseComparator();
136	<	PriorityQueue q = new PriorityQueue(SIZE, cmp);
137	<	assertEquals(cmp, q.comparator());
138	<	Integer[] ints = new Integer[SIZE];
139	<	for (int i = 0; i < SIZE; ++i)
140	<	ints[i] = new Integer(i);
141	<	q.addAll(Arrays.asList(ints));
130	<	for (int i = SIZE-1; i >= 0; --i)
131	<	assertEquals(ints[i], q.poll());
132	<	}
133	<	finally {}
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());
#	Line 151 | Line 159 | public class PriorityQueueTest extends J
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
#	Line 166 | Line 174 | public class PriorityQueueTest extends J
174		* offer(null) throws NPE
175		*/
176		public void testOfferNull() {
177	<	try {
178	<	PriorityQueue q = new PriorityQueue(1);
177	>	PriorityQueue<Item> q = new PriorityQueue<>(1);
178	>	try {
179		q.offer(null);
180		shouldThrow();
181	<	} catch (NullPointerException success) { }
181	>	} catch (NullPointerException success) {}
182		}
183
184		/**
185		* add(null) throws NPE
186		*/
187		public void testAddNull() {
188	<	try {
189	<	PriorityQueue q = new PriorityQueue(1);
188	>	PriorityQueue<Item> q = new PriorityQueue<>(1);
189	>	try {
190		q.add(null);
191		shouldThrow();
192	<	} catch (NullPointerException success) { }
192	>	} catch (NullPointerException success) {}
193		}
194
195		/**
196		* Offer of comparable element succeeds
197		*/
198		public void testOffer() {
199	<	PriorityQueue q = new PriorityQueue(1);
199	>	PriorityQueue<Item> q = new PriorityQueue<>(1);
200		assertTrue(q.offer(zero));
201		assertTrue(q.offer(one));
202		}
#	Line 197 | Line 205 | public class PriorityQueueTest extends J
205		* Offer of non-Comparable throws CCE
206		*/
207		public void testOfferNonComparable() {
208	+	PriorityQueue<Object> q = new PriorityQueue<>(1);
209		try {
201	–	PriorityQueue q = new PriorityQueue(1);
202	–	q.offer(new Object());
203	–	q.offer(new Object());
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		}
207	–	catch (ClassCastException success) {}
217		}
218
219		/**
220		* add of comparable succeeds
221		*/
222		public void testAdd() {
223	<	PriorityQueue q = new PriorityQueue(SIZE);
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
#	Line 222 | Line 231 | public class PriorityQueueTest extends J
231		* addAll(null) throws NPE
232		*/
233		public void testAddAll1() {
234	+	PriorityQueue<Item> q = new PriorityQueue<>(1);
235		try {
226	–	PriorityQueue q = new PriorityQueue(1);
236		q.addAll(null);
237		shouldThrow();
238	<	}
230	<	catch (NullPointerException success) {}
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	<	PriorityQueue q = new PriorityQueue(SIZE);
238	<	Integer[] ints = new Integer[SIZE];
239	<	q.addAll(Arrays.asList(ints));
247	>	q.addAll(Arrays.asList(new Item[SIZE]));
248		shouldThrow();
249	<	}
242	<	catch (NullPointerException success) {}
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	<	PriorityQueue q = new PriorityQueue(SIZE);
251	<	Integer[] ints = new Integer[SIZE];
252	<	for (int i = 0; i < SIZE-1; ++i)
253	<	ints[i] = new Integer(i);
254	<	q.addAll(Arrays.asList(ints));
261	>	q.addAll(Arrays.asList(items));
262		shouldThrow();
263	<	}
257	<	catch (NullPointerException success) {}
263	>	} catch (NullPointerException success) {}
264		}
265
266		/**
267		* Queue contains all elements of successful addAll
268		*/
269		public void testAddAll5() {
270	<	try {
271	<	Integer[] empty = new Integer[0];
272	<	Integer[] ints = new Integer[SIZE];
273	<	for (int i = 0; i < SIZE; ++i)
274	<	ints[i] = new Integer(SIZE-1-i);
275	<	PriorityQueue q = new PriorityQueue(SIZE);
276	<	assertFalse(q.addAll(Arrays.asList(empty)));
277	<	assertTrue(q.addAll(Arrays.asList(ints)));
278	<	for (int i = 0; i < SIZE; ++i)
273	<	assertEquals(new Integer(i), q.poll());
274	<	}
275	<	finally {}
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 q = populatedQueue(SIZE);
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		/**
293		* peek returns next element, or null if empty
294		*/
295		public void testPeek() {
296	<	PriorityQueue q = populatedQueue(SIZE);
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		/**
307		* element returns next element, or throws NSEE if empty
308		*/
309		public void testElement() {
310	<	PriorityQueue q = populatedQueue(SIZE);
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		shouldThrow();
318	<	}
316	<	catch (NoSuchElementException success) {}
318	>	} catch (NoSuchElementException success) {}
319		}
320
321		/**
322		* remove removes next element, or throws NSEE if empty
323		*/
324		public void testRemove() {
325	<	PriorityQueue q = populatedQueue(SIZE);
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		shouldThrow();
332	<	} catch (NoSuchElementException success) {
331	<	}
332	>	} catch (NoSuchElementException success) {}
333		}
334
335		/**
336		* remove(x) removes x and returns true if present
337		*/
338		public void testRemoveElement() {
339	<	PriorityQueue q = populatedQueue(SIZE);
340	<	for (int i = 1; i < SIZE; i+=2) {
341	<	assertTrue(q.remove(new Integer(i)));
342	<	}
343	<	for (int i = 0; i < SIZE; i+=2) {
344	<	assertTrue(q.remove(new Integer(i)));
345	<	assertFalse(q.remove(new Integer(i+1)));
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		}
#	Line 350 | Line 357 | public class PriorityQueueTest extends J
357		* contains(x) reports true when elements added but not yet removed
358		*/
359		public void testContains() {
360	<	PriorityQueue q = populatedQueue(SIZE);
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
#	Line 362 | Line 369 | public class PriorityQueueTest extends J
369		* clear removes all elements
370		*/
371		public void testClear() {
372	<	PriorityQueue q = populatedQueue(SIZE);
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());
#	Line 376 | Line 383 | public class PriorityQueueTest extends J
383		* containsAll(c) is true when c contains a subset of elements
384		*/
385		public void testContainsAll() {
386	<	PriorityQueue q = populatedQueue(SIZE);
387	<	PriorityQueue p = new PriorityQueue(SIZE);
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		}
#	Line 390 | Line 397 | public class PriorityQueueTest extends J
397		* retainAll(c) retains only those elements of c and reports true if changed
398		*/
399		public void testRetainAll() {
400	<	PriorityQueue q = populatedQueue(SIZE);
401	<	PriorityQueue p = populatedQueue(SIZE);
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 400 | 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		}
#	Line 410 | Line 417 | public class PriorityQueueTest extends J
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());
419	<	assertFalse(q.contains(I));
425	>	mustNotContain(q, p.remove());
426		}
427		}
428		}
#	Line 425 | Line 431 | public class PriorityQueueTest extends J
431		* toArray contains all elements
432		*/
433		public void testToArray() {
434	<	PriorityQueue q = populatedQueue(SIZE);
435	<	Object[] o = q.toArray();
436	<	Arrays.sort(o);
437	<	for (int i = 0; i < o.length; i++)
438	<	assertEquals(o[i], q.poll());
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 q = populatedQueue(SIZE);
448	<	Integer[] ints = new Integer[SIZE];
449	<	ints = (Integer[])q.toArray(ints);
450	<	Arrays.sort(ints);
451	<	for (int i = 0; i < ints.length; i++)
452	<	assertEquals(ints[i], q.poll());
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 q = populatedQueue(SIZE);
462	<	int i = 0;
463	<	Iterator it = q.iterator();
464	<	while (it.hasNext()) {
465	<	assertTrue(q.contains(it.next()));
466	<	++i;
467	<	}
468	<	assertEquals(i, SIZE);
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 q = new PriorityQueue(3);
482	<	q.add(new Integer(2));
483	<	q.add(new Integer(1));
484	<	q.add(new Integer(3));
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 it = q.iterator();
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
480	–
496		/**
497		* toString contains toStrings of elements
498		*/
499		public void testToString() {
500	<	PriorityQueue q = populatedQueue(SIZE);
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		}
506
507		/**
508	<	* A deserialized serialized queue has same elements
508	>	* A deserialized/reserialized queue has same elements
509		*/
510	<	public void testSerialization() {
511	<	PriorityQueue q = populatedQueue(SIZE);
512	<	try {
498	<	ByteArrayOutputStream bout = new ByteArrayOutputStream(10000);
499	<	ObjectOutputStream out = new ObjectOutputStream(new BufferedOutputStream(bout));
500	<	out.writeObject(q);
501	<	out.close();
510	>	public void testSerialization() throws Exception {
511	>	Queue<Item> x = populatedQueue(SIZE);
512	>	Queue<Item> y = serialClone(x);
513
514	<	ByteArrayInputStream bin = new ByteArrayInputStream(bout.toByteArray());
515	<	ObjectInputStream in = new ObjectInputStream(new BufferedInputStream(bin));
516	<	PriorityQueue r = (PriorityQueue)in.readObject();
517	<	assertEquals(q.size(), r.size());
518	<	while (!q.isEmpty())
508	<	assertEquals(q.remove(), r.remove());
509	<	} catch (Exception e) {
510	<	unexpectedException();
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