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.15 by jsr166, Sun Nov 22 18:57:17 2009 UTC vs.
Revision 1.32 by jsr166, Sat Feb 28 20:13:46 2015 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 > import junit.framework.TestSuite;
19  
20   public class PriorityQueueTest extends JSR166TestCase {
21      public static void main(String[] args) {
22 <        junit.textui.TestRunner.run (suite());
22 >        junit.textui.TestRunner.run(suite());
23      }
24      public static Test suite() {
25          return new TestSuite(PriorityQueueTest.class);
# Line 26 | Line 32 | public class PriorityQueueTest extends J
32      }
33  
34      /**
35 <     * Create a queue of given size containing consecutive
35 >     * Returns a new queue of given size containing consecutive
36       * Integers 0 ... n.
37       */
38 <    private PriorityQueue populatedQueue(int n) {
39 <        PriorityQueue q = new PriorityQueue(n);
38 >    private PriorityQueue<Integer> populatedQueue(int n) {
39 >        PriorityQueue<Integer> q = new PriorityQueue<Integer>(n);
40          assertTrue(q.isEmpty());
41 <        for (int i = n-1; i >= 0; i-=2)
41 >        for (int i = n-1; i >= 0; i -= 2)
42              assertTrue(q.offer(new Integer(i)));
43 <        for (int i = (n & 1); i < n; i+=2)
43 >        for (int i = (n & 1); i < n; i += 2)
44              assertTrue(q.offer(new Integer(i)));
45          assertFalse(q.isEmpty());
46          assertEquals(n, q.size());
# Line 53 | Line 59 | public class PriorityQueueTest extends J
59       */
60      public void testConstructor2() {
61          try {
62 <            PriorityQueue q = new PriorityQueue(0);
62 >            new PriorityQueue(0);
63              shouldThrow();
64          } catch (IllegalArgumentException success) {}
65      }
# Line 63 | Line 69 | public class PriorityQueueTest extends J
69       */
70      public void testConstructor3() {
71          try {
72 <            PriorityQueue q = new PriorityQueue((Collection)null);
72 >            new PriorityQueue((Collection)null);
73              shouldThrow();
74          } catch (NullPointerException success) {}
75      }
# Line 74 | Line 80 | public class PriorityQueueTest extends J
80      public void testConstructor4() {
81          try {
82              Integer[] ints = new Integer[SIZE];
83 <            PriorityQueue q = new PriorityQueue(Arrays.asList(ints));
83 >            new PriorityQueue(Arrays.asList(ints));
84              shouldThrow();
85          } catch (NullPointerException success) {}
86      }
# Line 87 | Line 93 | public class PriorityQueueTest extends J
93              Integer[] ints = new Integer[SIZE];
94              for (int i = 0; i < SIZE-1; ++i)
95                  ints[i] = new Integer(i);
96 <            PriorityQueue q = new PriorityQueue(Arrays.asList(ints));
96 >            new PriorityQueue(Arrays.asList(ints));
97              shouldThrow();
98          } catch (NullPointerException success) {}
99      }
# Line 183 | Line 189 | public class PriorityQueueTest extends J
189       * Offer of non-Comparable throws CCE
190       */
191      public void testOfferNonComparable() {
192 +        PriorityQueue q = new PriorityQueue(1);
193          try {
187 –            PriorityQueue q = new PriorityQueue(1);
188 –            q.offer(new Object());
194              q.offer(new Object());
195              q.offer(new Object());
196              shouldThrow();
# Line 213 | Line 218 | public class PriorityQueueTest extends J
218              shouldThrow();
219          } catch (NullPointerException success) {}
220      }
221 +
222      /**
223       * addAll of a collection with null elements throws NPE
224       */
# Line 224 | Line 230 | public class PriorityQueueTest extends J
230              shouldThrow();
231          } catch (NullPointerException success) {}
232      }
233 +
234      /**
235       * addAll of a collection with any null elements throws NPE after
236       * possibly adding some elements
# Line 313 | Line 320 | public class PriorityQueueTest extends J
320       */
321      public void testRemoveElement() {
322          PriorityQueue q = populatedQueue(SIZE);
323 <        for (int i = 1; i < SIZE; i+=2) {
324 <            assertTrue(q.remove(new Integer(i)));
325 <        }
326 <        for (int i = 0; i < SIZE; i+=2) {
327 <            assertTrue(q.remove(new Integer(i)));
328 <            assertFalse(q.remove(new Integer(i+1)));
323 >        for (int i = 1; i < SIZE; i += 2) {
324 >            assertTrue(q.contains(i));
325 >            assertTrue(q.remove(i));
326 >            assertFalse(q.contains(i));
327 >            assertTrue(q.contains(i-1));
328 >        }
329 >        for (int i = 0; i < SIZE; i += 2) {
330 >            assertTrue(q.contains(i));
331 >            assertTrue(q.remove(i));
332 >            assertFalse(q.contains(i));
333 >            assertFalse(q.remove(i+1));
334 >            assertFalse(q.contains(i+1));
335          }
336          assertTrue(q.isEmpty());
337      }
# Line 392 | Line 405 | public class PriorityQueueTest extends J
405              assertTrue(q.removeAll(p));
406              assertEquals(SIZE-i, q.size());
407              for (int j = 0; j < i; ++j) {
408 <                Integer I = (Integer)(p.remove());
409 <                assertFalse(q.contains(I));
408 >                Integer x = (Integer)(p.remove());
409 >                assertFalse(q.contains(x));
410              }
411          }
412      }
# Line 406 | Line 419 | public class PriorityQueueTest extends J
419          Object[] o = q.toArray();
420          Arrays.sort(o);
421          for (int i = 0; i < o.length; i++)
422 <            assertEquals(o[i], q.poll());
422 >            assertSame(o[i], q.poll());
423      }
424  
425      /**
426       * toArray(a) contains all elements
427       */
428      public void testToArray2() {
429 <        PriorityQueue q = populatedQueue(SIZE);
429 >        PriorityQueue<Integer> q = populatedQueue(SIZE);
430          Integer[] ints = new Integer[SIZE];
431 <        ints = (Integer[])q.toArray(ints);
431 >        Integer[] array = q.toArray(ints);
432 >        assertSame(ints, array);
433          Arrays.sort(ints);
434          for (int i = 0; i < ints.length; i++)
435 <            assertEquals(ints[i], q.poll());
435 >            assertSame(ints[i], q.poll());
436      }
437  
438      /**
# Line 426 | Line 440 | public class PriorityQueueTest extends J
440       */
441      public void testIterator() {
442          PriorityQueue q = populatedQueue(SIZE);
429 –        int i = 0;
443          Iterator it = q.iterator();
444 <        while (it.hasNext()) {
444 >        int i;
445 >        for (i = 0; it.hasNext(); i++)
446              assertTrue(q.contains(it.next()));
433 –            ++i;
434 –        }
447          assertEquals(i, SIZE);
448 +        assertIteratorExhausted(it);
449 +    }
450 +
451 +    /**
452 +     * iterator of empty collection has no elements
453 +     */
454 +    public void testEmptyIterator() {
455 +        assertIteratorExhausted(new PriorityQueue().iterator());
456      }
457  
458      /**
459       * iterator.remove removes current element
460       */
461 <    public void testIteratorRemove () {
461 >    public void testIteratorRemove() {
462          final PriorityQueue q = new PriorityQueue(3);
463          q.add(new Integer(2));
464          q.add(new Integer(1));
# Line 454 | Line 474 | public class PriorityQueueTest extends J
474          assertFalse(it.hasNext());
475      }
476  
457 –
477      /**
478       * toString contains toStrings of elements
479       */
# Line 462 | Line 481 | public class PriorityQueueTest extends J
481          PriorityQueue q = populatedQueue(SIZE);
482          String s = q.toString();
483          for (int i = 0; i < SIZE; ++i) {
484 <            assertTrue(s.indexOf(String.valueOf(i)) >= 0);
484 >            assertTrue(s.contains(String.valueOf(i)));
485          }
486      }
487  
# Line 470 | Line 489 | public class PriorityQueueTest extends J
489       * A deserialized serialized queue has same elements
490       */
491      public void testSerialization() throws Exception {
492 <        PriorityQueue q = populatedQueue(SIZE);
493 <        ByteArrayOutputStream bout = new ByteArrayOutputStream(10000);
494 <        ObjectOutputStream out = new ObjectOutputStream(new BufferedOutputStream(bout));
495 <        out.writeObject(q);
496 <        out.close();
497 <
498 <        ByteArrayInputStream bin = new ByteArrayInputStream(bout.toByteArray());
499 <        ObjectInputStream in = new ObjectInputStream(new BufferedInputStream(bin));
500 <        PriorityQueue r = (PriorityQueue)in.readObject();
501 <        assertEquals(q.size(), r.size());
483 <        while (!q.isEmpty())
484 <            assertEquals(q.remove(), r.remove());
492 >        Queue x = populatedQueue(SIZE);
493 >        Queue y = serialClone(x);
494 >
495 >        assertNotSame(x, y);
496 >        assertEquals(x.size(), y.size());
497 >        while (!x.isEmpty()) {
498 >            assertFalse(y.isEmpty());
499 >            assertEquals(x.remove(), y.remove());
500 >        }
501 >        assertTrue(y.isEmpty());
502      }
503   }

Diff Legend

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