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.5 by dl, Sat Sep 20 18:20:08 2003 UTC vs.
Revision 1.13 by jsr166, Sat Nov 21 10:25:05 2009 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/licenses/publicdomain
5	>	* Other contributors include Andrew Wright, Jeffrey Hayes,
6	>	* Pat Fisher, Mike Judd.
7		*/
8
9		import junit.framework.*;
#	Line 11 | Line 12 | import java.util.concurrent.*;
12		import java.io.*;
13
14		public class PriorityQueueTest extends JSR166TestCase {
14	–
15		public static void main(String[] args) {
16	<	junit.textui.TestRunner.run (suite());
16	>	junit.textui.TestRunner.run (suite());
17		}
18	–
18		public static Test suite() {
19	<	return new TestSuite(PriorityQueueTest.class);
19	>	return new TestSuite(PriorityQueueTest.class);
20		}
21
22	<	static class MyReverseComparator implements Comparator {
22	>	static class MyReverseComparator implements Comparator {
23		public int compare(Object x, Object y) {
24		int i = ((Integer)x).intValue();
25		int j = ((Integer)y).intValue();
#	Line 30 | Line 29 | public class PriorityQueueTest extends J
29		}
30		}
31
33	–
32		/**
33		* Create a queue of given size containing consecutive
34		* Integers 0 ... n.
#	Line 38 | Line 36 | public class PriorityQueueTest extends J
36		private PriorityQueue populatedQueue(int n) {
37		PriorityQueue q = new PriorityQueue(n);
38		assertTrue(q.isEmpty());
39	<	for(int i = n-1; i >= 0; i-=2)
40	<	assertTrue(q.offer(new Integer(i)));
41	<	for(int i = (n & 1); i < n; i+=2)
42	<	assertTrue(q.offer(new Integer(i)));
39	>	for (int i = n-1; i >= 0; i-=2)
40	>	assertTrue(q.offer(new Integer(i)));
41	>	for (int i = (n & 1); i < n; i+=2)
42	>	assertTrue(q.offer(new Integer(i)));
43		assertFalse(q.isEmpty());
44	<	assertEquals(n, q.size());
44	>	assertEquals(n, q.size());
45		return q;
46		}
47	<
47	>
48		/**
49	<	*
49	>	* A new queue has unbounded capacity
50		*/
51		public void testConstructor1() {
52		assertEquals(0, new PriorityQueue(SIZE).size());
53		}
54
55		/**
56	<	*
56	>	* Constructor throws IAE if capacity argument nonpositive
57		*/
58		public void testConstructor2() {
59		try {
60		PriorityQueue q = new PriorityQueue(0);
61		shouldThrow();
62	<	}
65	<	catch (IllegalArgumentException success) {}
62	>	} catch (IllegalArgumentException success) {}
63		}
64
65		/**
66	<	*
66	>	* Initializing from null Collection throws NPE
67		*/
68		public void testConstructor3() {
72	–
69		try {
70		PriorityQueue q = new PriorityQueue((Collection)null);
71		shouldThrow();
72	<	}
77	<	catch (NullPointerException success) {}
72	>	} catch (NullPointerException success) {}
73		}
74
75		/**
76	<	*
76	>	* Initializing from Collection of null elements throws NPE
77		*/
78		public void testConstructor4() {
79		try {
80		Integer[] ints = new Integer[SIZE];
81		PriorityQueue q = new PriorityQueue(Arrays.asList(ints));
82		shouldThrow();
83	<	}
89	<	catch (NullPointerException success) {}
83	>	} catch (NullPointerException success) {}
84		}
85
86		/**
87	<	*
87	>	* Initializing from Collection with some null elements throws NPE
88		*/
89		public void testConstructor5() {
90		try {
#	Line 99 | Line 93 | public class PriorityQueueTest extends J
93		ints[i] = new Integer(i);
94		PriorityQueue q = new PriorityQueue(Arrays.asList(ints));
95		shouldThrow();
96	<	}
103	<	catch (NullPointerException success) {}
96	>	} catch (NullPointerException success) {}
97		}
98
99		/**
100	<	*
100	>	* Queue contains all elements of collection used to initialize
101		*/
102		public void testConstructor6() {
103		try {
#	Line 119 | Line 112 | public class PriorityQueueTest extends J
112		}
113
114		/**
115	<	*
115	>	* The comparator used in constructor is used
116		*/
117		public void testConstructor7() {
118		try {
#	Line 137 | Line 130 | public class PriorityQueueTest extends J
130		}
131
132		/**
133	<	*
133	>	* isEmpty is true before add, false after
134		*/
135		public void testEmpty() {
136		PriorityQueue q = new PriorityQueue(2);
#	Line 151 | Line 144 | public class PriorityQueueTest extends J
144		}
145
146		/**
147	<	*
147	>	* size changes when elements added and removed
148		*/
149		public void testSize() {
150		PriorityQueue q = populatedQueue(SIZE);
#	Line 166 | Line 159 | public class PriorityQueueTest extends J
159		}
160
161		/**
162	<	*
162	>	* offer(null) throws NPE
163		*/
164		public void testOfferNull() {
165	<	try {
165	>	try {
166		PriorityQueue q = new PriorityQueue(1);
167		q.offer(null);
168		shouldThrow();
169	<	} catch (NullPointerException success) { }
169	>	} catch (NullPointerException success) {}
170		}
171
172		/**
173	<	*
173	>	* add(null) throws NPE
174	>	*/
175	>	public void testAddNull() {
176	>	try {
177	>	PriorityQueue q = new PriorityQueue(1);
178	>	q.add(null);
179	>	shouldThrow();
180	>	} catch (NullPointerException success) {}
181	>	}
182	>
183	>	/**
184	>	* Offer of comparable element succeeds
185		*/
186		public void testOffer() {
187		PriorityQueue q = new PriorityQueue(1);
188	<	assertTrue(q.offer(new Integer(0)));
189	<	assertTrue(q.offer(new Integer(1)));
188	>	assertTrue(q.offer(zero));
189	>	assertTrue(q.offer(one));
190		}
191
192		/**
193	<	*
193	>	* Offer of non-Comparable throws CCE
194		*/
195		public void testOfferNonComparable() {
196		try {
#	Line 195 | Line 199 | public class PriorityQueueTest extends J
199		q.offer(new Object());
200		q.offer(new Object());
201		shouldThrow();
202	<	}
199	<	catch(ClassCastException success) {}
202	>	} catch (ClassCastException success) {}
203		}
204
205		/**
206	<	*
206	>	* add of comparable succeeds
207		*/
208		public void testAdd() {
209		PriorityQueue q = new PriorityQueue(SIZE);
#	Line 211 | Line 214 | public class PriorityQueueTest extends J
214		}
215
216		/**
217	<	*
217	>	* addAll(null) throws NPE
218		*/
219		public void testAddAll1() {
220		try {
221		PriorityQueue q = new PriorityQueue(1);
222		q.addAll(null);
223		shouldThrow();
224	<	}
222	<	catch (NullPointerException success) {}
224	>	} catch (NullPointerException success) {}
225		}
226		/**
227	<	*
227	>	* addAll of a collection with null elements throws NPE
228		*/
229		public void testAddAll2() {
230		try {
#	Line 230 | Line 232 | public class PriorityQueueTest extends J
232		Integer[] ints = new Integer[SIZE];
233		q.addAll(Arrays.asList(ints));
234		shouldThrow();
235	<	}
234	<	catch (NullPointerException success) {}
235	>	} catch (NullPointerException success) {}
236		}
237		/**
238	<	*
238	>	* addAll of a collection with any null elements throws NPE after
239	>	* possibly adding some elements
240		*/
241		public void testAddAll3() {
242		try {
#	Line 244 | Line 246 | public class PriorityQueueTest extends J
246		ints[i] = new Integer(i);
247		q.addAll(Arrays.asList(ints));
248		shouldThrow();
249	<	}
248	<	catch (NullPointerException success) {}
249	>	} catch (NullPointerException success) {}
250		}
251
252		/**
253	<	*
253	>	* Queue contains all elements of successful addAll
254		*/
255		public void testAddAll5() {
256		try {
#	Line 267 | Line 268 | public class PriorityQueueTest extends J
268		}
269
270		/**
271	<	*
271	>	* poll succeeds unless empty
272		*/
273		public void testPoll() {
274		PriorityQueue q = populatedQueue(SIZE);
275		for (int i = 0; i < SIZE; ++i) {
276		assertEquals(i, ((Integer)q.poll()).intValue());
277		}
278	<	assertNull(q.poll());
278	>	assertNull(q.poll());
279		}
280
281		/**
282	<	*
282	>	* peek returns next element, or null if empty
283		*/
284		public void testPeek() {
285		PriorityQueue q = populatedQueue(SIZE);
#	Line 288 | Line 289 | public class PriorityQueueTest extends J
289		assertTrue(q.peek() == null ||
290		i != ((Integer)q.peek()).intValue());
291		}
292	<	assertNull(q.peek());
292	>	assertNull(q.peek());
293		}
294
295		/**
296	<	*
296	>	* element returns next element, or throws NSEE if empty
297		*/
298		public void testElement() {
299		PriorityQueue q = populatedQueue(SIZE);
#	Line 303 | Line 304 | public class PriorityQueueTest extends J
304		try {
305		q.element();
306		shouldThrow();
307	<	}
307	<	catch (NoSuchElementException success) {}
307	>	} catch (NoSuchElementException success) {}
308		}
309
310		/**
311	<	*
311	>	* remove removes next element, or throws NSEE if empty
312		*/
313		public void testRemove() {
314		PriorityQueue q = populatedQueue(SIZE);
#	Line 318 | Line 318 | public class PriorityQueueTest extends J
318		try {
319		q.remove();
320		shouldThrow();
321	<	} catch (NoSuchElementException success){
322	<	}
321	>	} catch (NoSuchElementException success) {}
322		}
323
324		/**
325	<	*
325	>	* remove(x) removes x and returns true if present
326		*/
327		public void testRemoveElement() {
328		PriorityQueue q = populatedQueue(SIZE);
#	Line 336 | Line 335 | public class PriorityQueueTest extends J
335		}
336		assertTrue(q.isEmpty());
337		}
338	<
338	>
339		/**
340	<	*
340	>	* contains(x) reports true when elements added but not yet removed
341		*/
342		public void testContains() {
343		PriorityQueue q = populatedQueue(SIZE);
#	Line 350 | Line 349 | public class PriorityQueueTest extends J
349		}
350
351		/**
352	<	*
352	>	* clear removes all elements
353		*/
354		public void testClear() {
355		PriorityQueue q = populatedQueue(SIZE);
#	Line 364 | Line 363 | public class PriorityQueueTest extends J
363		}
364
365		/**
366	<	*
366	>	* containsAll(c) is true when c contains a subset of elements
367		*/
368		public void testContainsAll() {
369		PriorityQueue q = populatedQueue(SIZE);
#	Line 378 | Line 377 | public class PriorityQueueTest extends J
377		}
378
379		/**
380	<	*
380	>	* retainAll(c) retains only those elements of c and reports true if changed
381		*/
382		public void testRetainAll() {
383		PriorityQueue q = populatedQueue(SIZE);
#	Line 397 | Line 396 | public class PriorityQueueTest extends J
396		}
397
398		/**
399	<	*
399	>	* removeAll(c) removes only those elements of c and reports true if changed
400		*/
401		public void testRemoveAll() {
402		for (int i = 1; i < SIZE; ++i) {
#	Line 413 | Line 412 | public class PriorityQueueTest extends J
412		}
413
414		/**
415	<	*
415	>	* toArray contains all elements
416		*/
417		public void testToArray() {
418		PriorityQueue q = populatedQueue(SIZE);
419	<	Object[] o = q.toArray();
419	>	Object[] o = q.toArray();
420		Arrays.sort(o);
421	<	for(int i = 0; i < o.length; i++)
422	<	assertEquals(o[i], q.poll());
421	>	for (int i = 0; i < o.length; i++)
422	>	assertEquals(o[i], q.poll());
423		}
424
425		/**
426	<	*
426	>	* toArray(a) contains all elements
427		*/
428		public void testToArray2() {
429		PriorityQueue q = populatedQueue(SIZE);
430	<	Integer[] ints = new Integer[SIZE];
431	<	ints = (Integer[])q.toArray(ints);
430	>	Integer[] ints = new Integer[SIZE];
431	>	ints = (Integer[])q.toArray(ints);
432		Arrays.sort(ints);
433	<	for(int i = 0; i < ints.length; i++)
433	>	for (int i = 0; i < ints.length; i++)
434		assertEquals(ints[i], q.poll());
435		}
436	<
436	>
437		/**
438	<	*
438	>	* iterator iterates through all elements
439		*/
440		public void testIterator() {
441		PriorityQueue q = populatedQueue(SIZE);
442		int i = 0;
443	<	Iterator it = q.iterator();
444	<	while(it.hasNext()) {
443	>	Iterator it = q.iterator();
444	>	while (it.hasNext()) {
445		assertTrue(q.contains(it.next()));
446		++i;
447		}
#	Line 450 | Line 449 | public class PriorityQueueTest extends J
449		}
450
451		/**
452	<	*
452	>	* iterator.remove removes current element
453		*/
454		public void testIteratorRemove () {
455		final PriorityQueue q = new PriorityQueue(3);
#	Line 470 | Line 469 | public class PriorityQueueTest extends J
469
470
471		/**
472	<	*
472	>	* toString contains toStrings of elements
473		*/
474		public void testToString() {
475		PriorityQueue q = populatedQueue(SIZE);
#	Line 478 | Line 477 | public class PriorityQueueTest extends J
477		for (int i = 0; i < SIZE; ++i) {
478		assertTrue(s.indexOf(String.valueOf(i)) >= 0);
479		}
480	<	}
480	>	}
481
482		/**
483	<	*
483	>	* A deserialized serialized queue has same elements
484		*/
485	<	public void testSerialization() {
485	>	public void testSerialization() throws Exception {
486		PriorityQueue q = populatedQueue(SIZE);
487	<	try {
488	<	ByteArrayOutputStream bout = new ByteArrayOutputStream(10000);
489	<	ObjectOutputStream out = new ObjectOutputStream(new BufferedOutputStream(bout));
490	<	out.writeObject(q);
491	<	out.close();
492	<
493	<	ByteArrayInputStream bin = new ByteArrayInputStream(bout.toByteArray());
494	<	ObjectInputStream in = new ObjectInputStream(new BufferedInputStream(bin));
495	<	PriorityQueue r = (PriorityQueue)in.readObject();
496	<	assertEquals(q.size(), r.size());
497	<	while (!q.isEmpty())
499	<	assertEquals(q.remove(), r.remove());
500	<	} catch(Exception e){
501	<	unexpectedException();
502	<	}
487	>	ByteArrayOutputStream bout = new ByteArrayOutputStream(10000);
488	>	ObjectOutputStream out = new ObjectOutputStream(new BufferedOutputStream(bout));
489	>	out.writeObject(q);
490	>	out.close();
491	>
492	>	ByteArrayInputStream bin = new ByteArrayInputStream(bout.toByteArray());
493	>	ObjectInputStream in = new ObjectInputStream(new BufferedInputStream(bin));
494	>	PriorityQueue r = (PriorityQueue)in.readObject();
495	>	assertEquals(q.size(), r.size());
496	>	while (!q.isEmpty())
497	>	assertEquals(q.remove(), r.remove());
498		}
499		}

Diff Legend

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