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.9 by jsr166, Mon Nov 2 20:28:31 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);
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 46 | Line 44 | public class PriorityQueueTest extends J
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 {
#	Line 66 | Line 64 | public class PriorityQueueTest extends J
64		}
65
66		/**
67	<	*
67	>	* Initializing from null Collection throws NPE
68		*/
69		public void testConstructor3() {
72	–
70		try {
71		PriorityQueue q = new PriorityQueue((Collection)null);
72		shouldThrow();
#	Line 78 | Line 75 | public class PriorityQueueTest extends J
75		}
76
77		/**
78	<	*
78	>	* Initializing from Collection of null elements throws NPE
79		*/
80		public void testConstructor4() {
81		try {
#	Line 90 | Line 87 | public class PriorityQueueTest extends J
87		}
88
89		/**
90	<	*
90	>	* Initializing from Collection with some null elements throws NPE
91		*/
92		public void testConstructor5() {
93		try {
#	Line 104 | Line 101 | public class PriorityQueueTest extends J
101		}
102
103		/**
104	<	*
104	>	* Queue contains all elements of collection used to initialize
105		*/
106		public void testConstructor6() {
107		try {
#	Line 119 | Line 116 | public class PriorityQueueTest extends J
116		}
117
118		/**
119	<	*
119	>	* The comparator used in constructor is used
120		*/
121		public void testConstructor7() {
122		try {
#	Line 137 | Line 134 | public class PriorityQueueTest extends J
134		}
135
136		/**
137	<	*
137	>	* isEmpty is true before add, false after
138		*/
139		public void testEmpty() {
140		PriorityQueue q = new PriorityQueue(2);
#	Line 151 | Line 148 | public class PriorityQueueTest extends J
148		}
149
150		/**
151	<	*
151	>	* size changes when elements added and removed
152		*/
153		public void testSize() {
154		PriorityQueue q = populatedQueue(SIZE);
#	Line 166 | Line 163 | public class PriorityQueueTest extends J
163		}
164
165		/**
166	<	*
166	>	* offer(null) throws NPE
167		*/
168		public void testOfferNull() {
169		try {
170		PriorityQueue q = new PriorityQueue(1);
171		q.offer(null);
172		shouldThrow();
173	<	} catch (NullPointerException success) { }
173	>	} catch (NullPointerException success) { }
174		}
175
176		/**
177	<	*
177	>	* add(null) throws NPE
178	>	*/
179	>	public void testAddNull() {
180	>	try {
181	>	PriorityQueue q = new PriorityQueue(1);
182	>	q.add(null);
183	>	shouldThrow();
184	>	} catch (NullPointerException success) { }
185	>	}
186	>
187	>	/**
188	>	* Offer of comparable element succeeds
189		*/
190		public void testOffer() {
191		PriorityQueue q = new PriorityQueue(1);
192	<	assertTrue(q.offer(new Integer(0)));
193	<	assertTrue(q.offer(new Integer(1)));
192	>	assertTrue(q.offer(zero));
193	>	assertTrue(q.offer(one));
194		}
195
196		/**
197	<	*
197	>	* Offer of non-Comparable throws CCE
198		*/
199		public void testOfferNonComparable() {
200		try {
#	Line 200 | Line 208 | public class PriorityQueueTest extends J
208		}
209
210		/**
211	<	*
211	>	* add of comparable succeeds
212		*/
213		public void testAdd() {
214		PriorityQueue q = new PriorityQueue(SIZE);
#	Line 211 | Line 219 | public class PriorityQueueTest extends J
219		}
220
221		/**
222	<	*
222	>	* addAll(null) throws NPE
223		*/
224		public void testAddAll1() {
225		try {
#	Line 222 | Line 230 | public class PriorityQueueTest extends J
230		catch (NullPointerException success) {}
231		}
232		/**
233	<	*
233	>	* addAll of a collection with null elements throws NPE
234		*/
235		public void testAddAll2() {
236		try {
#	Line 234 | Line 242 | public class PriorityQueueTest extends J
242		catch (NullPointerException success) {}
243		}
244		/**
245	<	*
245	>	* addAll of a collection with any null elements throws NPE after
246	>	* possibly adding some elements
247		*/
248		public void testAddAll3() {
249		try {
#	Line 249 | Line 258 | public class PriorityQueueTest extends J
258		}
259
260		/**
261	<	*
261	>	* Queue contains all elements of successful addAll
262		*/
263		public void testAddAll5() {
264		try {
#	Line 267 | Line 276 | public class PriorityQueueTest extends J
276		}
277
278		/**
279	<	*
279	>	* poll succeeds unless empty
280		*/
281		public void testPoll() {
282		PriorityQueue q = populatedQueue(SIZE);
#	Line 278 | Line 287 | public class PriorityQueueTest extends J
287		}
288
289		/**
290	<	*
290	>	* peek returns next element, or null if empty
291		*/
292		public void testPeek() {
293		PriorityQueue q = populatedQueue(SIZE);
#	Line 292 | Line 301 | public class PriorityQueueTest extends J
301		}
302
303		/**
304	<	*
304	>	* element returns next element, or throws NSEE if empty
305		*/
306		public void testElement() {
307		PriorityQueue q = populatedQueue(SIZE);
#	Line 308 | Line 317 | public class PriorityQueueTest extends J
317		}
318
319		/**
320	<	*
320	>	* remove removes next element, or throws NSEE if empty
321		*/
322		public void testRemove() {
323		PriorityQueue q = populatedQueue(SIZE);
#	Line 319 | Line 328 | public class PriorityQueueTest extends J
328		q.remove();
329		shouldThrow();
330		} catch (NoSuchElementException success){
331	<	}
331	>	}
332		}
333
334		/**
335	<	*
335	>	* remove(x) removes x and returns true if present
336		*/
337		public void testRemoveElement() {
338		PriorityQueue q = populatedQueue(SIZE);
#	Line 336 | Line 345 | public class PriorityQueueTest extends J
345		}
346		assertTrue(q.isEmpty());
347		}
348	<
348	>
349		/**
350	<	*
350	>	* contains(x) reports true when elements added but not yet removed
351		*/
352		public void testContains() {
353		PriorityQueue q = populatedQueue(SIZE);
#	Line 350 | Line 359 | public class PriorityQueueTest extends J
359		}
360
361		/**
362	<	*
362	>	* clear removes all elements
363		*/
364		public void testClear() {
365		PriorityQueue q = populatedQueue(SIZE);
#	Line 364 | Line 373 | public class PriorityQueueTest extends J
373		}
374
375		/**
376	<	*
376	>	* containsAll(c) is true when c contains a subset of elements
377		*/
378		public void testContainsAll() {
379		PriorityQueue q = populatedQueue(SIZE);
#	Line 378 | Line 387 | public class PriorityQueueTest extends J
387		}
388
389		/**
390	<	*
390	>	* retainAll(c) retains only those elements of c and reports true if changed
391		*/
392		public void testRetainAll() {
393		PriorityQueue q = populatedQueue(SIZE);
#	Line 397 | Line 406 | public class PriorityQueueTest extends J
406		}
407
408		/**
409	<	*
409	>	* removeAll(c) removes only those elements of c and reports true if changed
410		*/
411		public void testRemoveAll() {
412		for (int i = 1; i < SIZE; ++i) {
#	Line 413 | Line 422 | public class PriorityQueueTest extends J
422		}
423
424		/**
425	<	*
425	>	* toArray contains all elements
426		*/
427		public void testToArray() {
428		PriorityQueue q = populatedQueue(SIZE);
#	Line 424 | Line 433 | public class PriorityQueueTest extends J
433		}
434
435		/**
436	<	*
436	>	* toArray(a) contains all elements
437		*/
438		public void testToArray2() {
439		PriorityQueue q = populatedQueue(SIZE);
#	Line 434 | Line 443 | public class PriorityQueueTest extends J
443		for(int i = 0; i < ints.length; i++)
444		assertEquals(ints[i], q.poll());
445		}
446	<
446	>
447		/**
448	<	*
448	>	* iterator iterates through all elements
449		*/
450		public void testIterator() {
451		PriorityQueue q = populatedQueue(SIZE);
#	Line 450 | Line 459 | public class PriorityQueueTest extends J
459		}
460
461		/**
462	<	*
462	>	* iterator.remove removes current element
463		*/
464		public void testIteratorRemove () {
465		final PriorityQueue q = new PriorityQueue(3);
#	Line 470 | Line 479 | public class PriorityQueueTest extends J
479
480
481		/**
482	<	*
482	>	* toString contains toStrings of elements
483		*/
484		public void testToString() {
485		PriorityQueue q = populatedQueue(SIZE);
#	Line 478 | Line 487 | public class PriorityQueueTest extends J
487		for (int i = 0; i < SIZE; ++i) {
488		assertTrue(s.indexOf(String.valueOf(i)) >= 0);
489		}
490	<	}
490	>	}
491
492		/**
493	<	*
493	>	* A deserialized serialized queue has same elements
494		*/
495		public void testSerialization() {
496		PriorityQueue q = populatedQueue(SIZE);
#	Line 495 | Line 504 | public class PriorityQueueTest extends J
504		ObjectInputStream in = new ObjectInputStream(new BufferedInputStream(bin));
505		PriorityQueue r = (PriorityQueue)in.readObject();
506		assertEquals(q.size(), r.size());
507	<	while (!q.isEmpty())
507	>	while (!q.isEmpty())
508		assertEquals(q.remove(), r.remove());
509		} catch(Exception e){
510		unexpectedException();

Diff Legend

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