ViewVC Help
View File | Revision Log | Show Annotations | Download File | Root Listing
root/jsr166/jsr166/src/test/tck/PriorityQueueTest.java
(Generate patch)

Comparing jsr166/src/test/tck/PriorityQueueTest.java (file contents):
Revision 1.13 by jsr166, Sat Nov 21 10:25:05 2009 UTC vs.
Revision 1.25 by jsr166, Tue Feb 21 02:04:17 2012 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.*;
10 > import java.util.Arrays;
11 > import java.util.Collection;
12 > import java.util.Comparator;
13 > import java.util.Iterator;
14 > import java.util.NoSuchElementException;
15 > import java.util.PriorityQueue;
16 > import java.util.Queue;
17  
18   public class PriorityQueueTest extends JSR166TestCase {
19      public static void main(String[] args) {
20 <        junit.textui.TestRunner.run (suite());
20 >        junit.textui.TestRunner.run(suite());
21      }
22      public static Test suite() {
23          return new TestSuite(PriorityQueueTest.class);
# Line 21 | Line 25 | public class PriorityQueueTest extends J
25  
26      static class MyReverseComparator implements Comparator {
27          public int compare(Object x, Object y) {
28 <            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;
28 >            return ((Comparable)y).compareTo(x);
29          }
30      }
31  
32      /**
33 <     * Create a queue of given size containing consecutive
33 >     * Returns a new queue of given size containing consecutive
34       * Integers 0 ... n.
35       */
36 <    private PriorityQueue populatedQueue(int n) {
37 <        PriorityQueue q = new PriorityQueue(n);
36 >    private PriorityQueue<Integer> populatedQueue(int n) {
37 >        PriorityQueue<Integer> q = new PriorityQueue<Integer>(n);
38          assertTrue(q.isEmpty());
39          for (int i = n-1; i >= 0; i-=2)
40              assertTrue(q.offer(new Integer(i)));
# Line 100 | Line 100 | public class PriorityQueueTest extends J
100       * Queue contains all elements of collection used to initialize
101       */
102      public void testConstructor6() {
103 <        try {
104 <            Integer[] ints = new Integer[SIZE];
105 <            for (int i = 0; i < SIZE; ++i)
106 <                ints[i] = new Integer(i);
107 <            PriorityQueue q = new PriorityQueue(Arrays.asList(ints));
108 <            for (int i = 0; i < SIZE; ++i)
109 <                assertEquals(ints[i], q.poll());
110 <        }
111 <        finally {}
103 >        Integer[] ints = new Integer[SIZE];
104 >        for (int i = 0; i < SIZE; ++i)
105 >            ints[i] = new Integer(i);
106 >        PriorityQueue q = new PriorityQueue(Arrays.asList(ints));
107 >        for (int i = 0; i < SIZE; ++i)
108 >            assertEquals(ints[i], q.poll());
109      }
110  
111      /**
112       * The comparator used in constructor is used
113       */
114      public void testConstructor7() {
115 <        try {
116 <            MyReverseComparator cmp = new MyReverseComparator();
117 <            PriorityQueue q = new PriorityQueue(SIZE, cmp);
118 <            assertEquals(cmp, q.comparator());
119 <            Integer[] ints = new Integer[SIZE];
120 <            for (int i = 0; i < SIZE; ++i)
121 <                ints[i] = new Integer(i);
122 <            q.addAll(Arrays.asList(ints));
123 <            for (int i = SIZE-1; i >= 0; --i)
127 <                assertEquals(ints[i], q.poll());
128 <        }
129 <        finally {}
115 >        MyReverseComparator cmp = new MyReverseComparator();
116 >        PriorityQueue q = new PriorityQueue(SIZE, cmp);
117 >        assertEquals(cmp, q.comparator());
118 >        Integer[] ints = new Integer[SIZE];
119 >        for (int i = 0; i < SIZE; ++i)
120 >            ints[i] = new Integer(i);
121 >        q.addAll(Arrays.asList(ints));
122 >        for (int i = SIZE-1; i >= 0; --i)
123 >            assertEquals(ints[i], q.poll());
124      }
125  
126      /**
# Line 223 | Line 217 | public class PriorityQueueTest extends J
217              shouldThrow();
218          } catch (NullPointerException success) {}
219      }
220 +
221      /**
222       * addAll of a collection with null elements throws NPE
223       */
# Line 234 | Line 229 | public class PriorityQueueTest extends J
229              shouldThrow();
230          } catch (NullPointerException success) {}
231      }
232 +
233      /**
234       * addAll of a collection with any null elements throws NPE after
235       * possibly adding some elements
# Line 253 | Line 249 | public class PriorityQueueTest extends J
249       * Queue contains all elements of successful addAll
250       */
251      public void testAddAll5() {
252 <        try {
253 <            Integer[] empty = new Integer[0];
254 <            Integer[] ints = new Integer[SIZE];
255 <            for (int i = 0; i < SIZE; ++i)
256 <                ints[i] = new Integer(SIZE-1-i);
257 <            PriorityQueue q = new PriorityQueue(SIZE);
258 <            assertFalse(q.addAll(Arrays.asList(empty)));
259 <            assertTrue(q.addAll(Arrays.asList(ints)));
260 <            for (int i = 0; i < SIZE; ++i)
265 <                assertEquals(new Integer(i), q.poll());
266 <        }
267 <        finally {}
252 >        Integer[] empty = new Integer[0];
253 >        Integer[] ints = new Integer[SIZE];
254 >        for (int i = 0; i < SIZE; ++i)
255 >            ints[i] = new Integer(SIZE-1-i);
256 >        PriorityQueue q = new PriorityQueue(SIZE);
257 >        assertFalse(q.addAll(Arrays.asList(empty)));
258 >        assertTrue(q.addAll(Arrays.asList(ints)));
259 >        for (int i = 0; i < SIZE; ++i)
260 >            assertEquals(new Integer(i), q.poll());
261      }
262  
263      /**
# Line 273 | Line 266 | public class PriorityQueueTest extends J
266      public void testPoll() {
267          PriorityQueue q = populatedQueue(SIZE);
268          for (int i = 0; i < SIZE; ++i) {
269 <            assertEquals(i, ((Integer)q.poll()).intValue());
269 >            assertEquals(i, q.poll());
270          }
271          assertNull(q.poll());
272      }
# Line 284 | Line 277 | public class PriorityQueueTest extends J
277      public void testPeek() {
278          PriorityQueue q = populatedQueue(SIZE);
279          for (int i = 0; i < SIZE; ++i) {
280 <            assertEquals(i, ((Integer)q.peek()).intValue());
281 <            q.poll();
280 >            assertEquals(i, q.peek());
281 >            assertEquals(i, q.poll());
282              assertTrue(q.peek() == null ||
283 <                       i != ((Integer)q.peek()).intValue());
283 >                       !q.peek().equals(i));
284          }
285          assertNull(q.peek());
286      }
# Line 298 | Line 291 | public class PriorityQueueTest extends J
291      public void testElement() {
292          PriorityQueue q = populatedQueue(SIZE);
293          for (int i = 0; i < SIZE; ++i) {
294 <            assertEquals(i, ((Integer)q.element()).intValue());
295 <            q.poll();
294 >            assertEquals(i, q.element());
295 >            assertEquals(i, q.poll());
296          }
297          try {
298              q.element();
# Line 313 | Line 306 | public class PriorityQueueTest extends J
306      public void testRemove() {
307          PriorityQueue q = populatedQueue(SIZE);
308          for (int i = 0; i < SIZE; ++i) {
309 <            assertEquals(i, ((Integer)q.remove()).intValue());
309 >            assertEquals(i, q.remove());
310          }
311          try {
312              q.remove();
# Line 327 | Line 320 | public class PriorityQueueTest extends J
320      public void testRemoveElement() {
321          PriorityQueue q = populatedQueue(SIZE);
322          for (int i = 1; i < SIZE; i+=2) {
323 <            assertTrue(q.remove(new Integer(i)));
323 >            assertTrue(q.contains(i));
324 >            assertTrue(q.remove(i));
325 >            assertFalse(q.contains(i));
326 >            assertTrue(q.contains(i-1));
327          }
328          for (int i = 0; i < SIZE; i+=2) {
329 <            assertTrue(q.remove(new Integer(i)));
330 <            assertFalse(q.remove(new Integer(i+1)));
329 >            assertTrue(q.contains(i));
330 >            assertTrue(q.remove(i));
331 >            assertFalse(q.contains(i));
332 >            assertFalse(q.remove(i+1));
333 >            assertFalse(q.contains(i+1));
334          }
335          assertTrue(q.isEmpty());
336      }
# Line 419 | Line 418 | public class PriorityQueueTest extends J
418          Object[] o = q.toArray();
419          Arrays.sort(o);
420          for (int i = 0; i < o.length; i++)
421 <            assertEquals(o[i], q.poll());
421 >            assertSame(o[i], q.poll());
422      }
423  
424      /**
425       * toArray(a) contains all elements
426       */
427      public void testToArray2() {
428 <        PriorityQueue q = populatedQueue(SIZE);
428 >        PriorityQueue<Integer> q = populatedQueue(SIZE);
429          Integer[] ints = new Integer[SIZE];
430 <        ints = (Integer[])q.toArray(ints);
430 >        Integer[] array = q.toArray(ints);
431 >        assertSame(ints, array);
432          Arrays.sort(ints);
433          for (int i = 0; i < ints.length; i++)
434 <            assertEquals(ints[i], q.poll());
434 >            assertSame(ints[i], q.poll());
435      }
436  
437      /**
# Line 451 | Line 451 | public class PriorityQueueTest extends J
451      /**
452       * iterator.remove removes current element
453       */
454 <    public void testIteratorRemove () {
454 >    public void testIteratorRemove() {
455          final PriorityQueue q = new PriorityQueue(3);
456          q.add(new Integer(2));
457          q.add(new Integer(1));
# Line 467 | Line 467 | public class PriorityQueueTest extends J
467          assertFalse(it.hasNext());
468      }
469  
470 –
470      /**
471       * toString contains toStrings of elements
472       */
# Line 475 | Line 474 | public class PriorityQueueTest extends J
474          PriorityQueue q = populatedQueue(SIZE);
475          String s = q.toString();
476          for (int i = 0; i < SIZE; ++i) {
477 <            assertTrue(s.indexOf(String.valueOf(i)) >= 0);
477 >            assertTrue(s.contains(String.valueOf(i)));
478          }
479      }
480  
# Line 483 | Line 482 | public class PriorityQueueTest extends J
482       * A deserialized serialized queue has same elements
483       */
484      public void testSerialization() throws Exception {
485 <        PriorityQueue q = populatedQueue(SIZE);
486 <        ByteArrayOutputStream bout = new ByteArrayOutputStream(10000);
487 <        ObjectOutputStream out = new ObjectOutputStream(new BufferedOutputStream(bout));
488 <        out.writeObject(q);
489 <        out.close();
490 <
491 <        ByteArrayInputStream bin = new ByteArrayInputStream(bout.toByteArray());
492 <        ObjectInputStream in = new ObjectInputStream(new BufferedInputStream(bin));
493 <        PriorityQueue r = (PriorityQueue)in.readObject();
494 <        assertEquals(q.size(), r.size());
496 <        while (!q.isEmpty())
497 <            assertEquals(q.remove(), r.remove());
485 >        Queue x = populatedQueue(SIZE);
486 >        Queue y = serialClone(x);
487 >
488 >        assertTrue(x != y);
489 >        assertEquals(x.size(), y.size());
490 >        while (!x.isEmpty()) {
491 >            assertFalse(y.isEmpty());
492 >            assertEquals(x.remove(), y.remove());
493 >        }
494 >        assertTrue(y.isEmpty());
495      }
496   }

Diff Legend

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