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.10 by jsr166, Mon Nov 16 04:57:10 2009 UTC vs.
Revision 1.13 by jsr166, Sat Nov 21 10:25:05 2009 UTC

# Line 13 | Line 13 | import java.io.*;
13  
14   public class PriorityQueueTest extends JSR166TestCase {
15      public static void main(String[] args) {
16 <        junit.textui.TestRunner.run (suite());
16 >        junit.textui.TestRunner.run (suite());
17      }
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 {
# Line 36 | 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  
# Line 53 | Line 53 | public class PriorityQueueTest extends J
53      }
54  
55      /**
56 <     * Constructor throws IAE if  capacity argument nonpositive
56 >     * Constructor throws IAE if capacity argument nonpositive
57       */
58      public void testConstructor2() {
59          try {
60              PriorityQueue q = new PriorityQueue(0);
61              shouldThrow();
62 <        }
63 <        catch (IllegalArgumentException success) {}
62 >        } catch (IllegalArgumentException success) {}
63      }
64  
65      /**
# Line 70 | Line 69 | public class PriorityQueueTest extends J
69          try {
70              PriorityQueue q = new PriorityQueue((Collection)null);
71              shouldThrow();
72 <        }
74 <        catch (NullPointerException success) {}
72 >        } catch (NullPointerException success) {}
73      }
74  
75      /**
# Line 82 | Line 80 | public class PriorityQueueTest extends J
80              Integer[] ints = new Integer[SIZE];
81              PriorityQueue q = new PriorityQueue(Arrays.asList(ints));
82              shouldThrow();
83 <        }
86 <        catch (NullPointerException success) {}
83 >        } catch (NullPointerException success) {}
84      }
85  
86      /**
# Line 96 | Line 93 | public class PriorityQueueTest extends J
93                  ints[i] = new Integer(i);
94              PriorityQueue q = new PriorityQueue(Arrays.asList(ints));
95              shouldThrow();
96 <        }
100 <        catch (NullPointerException success) {}
96 >        } catch (NullPointerException success) {}
97      }
98  
99      /**
# Line 166 | Line 162 | public class PriorityQueueTest extends J
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       * add(null) throws NPE
174       */
175      public void testAddNull() {
176 <        try {
176 >        try {
177              PriorityQueue q = new PriorityQueue(1);
178              q.add(null);
179              shouldThrow();
180 <        } catch (NullPointerException success) { }
180 >        } catch (NullPointerException success) {}
181      }
182  
183      /**
# Line 203 | Line 199 | public class PriorityQueueTest extends J
199              q.offer(new Object());
200              q.offer(new Object());
201              shouldThrow();
202 <        }
207 <        catch (ClassCastException success) {}
202 >        } catch (ClassCastException success) {}
203      }
204  
205      /**
# Line 226 | Line 221 | public class PriorityQueueTest extends J
221              PriorityQueue q = new PriorityQueue(1);
222              q.addAll(null);
223              shouldThrow();
224 <        }
230 <        catch (NullPointerException success) {}
224 >        } catch (NullPointerException success) {}
225      }
226      /**
227       * addAll of a collection with null elements throws NPE
# Line 238 | Line 232 | public class PriorityQueueTest extends J
232              Integer[] ints = new Integer[SIZE];
233              q.addAll(Arrays.asList(ints));
234              shouldThrow();
235 <        }
242 <        catch (NullPointerException success) {}
235 >        } catch (NullPointerException success) {}
236      }
237      /**
238       * addAll of a collection with any null elements throws NPE after
# Line 253 | Line 246 | public class PriorityQueueTest extends J
246                  ints[i] = new Integer(i);
247              q.addAll(Arrays.asList(ints));
248              shouldThrow();
249 <        }
257 <        catch (NullPointerException success) {}
249 >        } catch (NullPointerException success) {}
250      }
251  
252      /**
# Line 283 | Line 275 | public class PriorityQueueTest extends J
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      /**
# Line 297 | 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      /**
# Line 312 | Line 304 | public class PriorityQueueTest extends J
304          try {
305              q.element();
306              shouldThrow();
307 <        }
316 <        catch (NoSuchElementException success) {}
307 >        } catch (NoSuchElementException success) {}
308      }
309  
310      /**
# Line 327 | Line 318 | public class PriorityQueueTest extends J
318          try {
319              q.remove();
320              shouldThrow();
321 <        } catch (NoSuchElementException success){
331 <        }
321 >        } catch (NoSuchElementException success) {}
322      }
323  
324      /**
# Line 426 | Line 416 | public class PriorityQueueTest extends J
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      /**
# Line 437 | Line 427 | public class PriorityQueueTest extends J
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++)
434              assertEquals(ints[i], q.poll());
# Line 450 | Line 440 | public class PriorityQueueTest extends J
440      public void testIterator() {
441          PriorityQueue q = populatedQueue(SIZE);
442          int i = 0;
443 <        Iterator it = q.iterator();
443 >        Iterator it = q.iterator();
444          while (it.hasNext()) {
445              assertTrue(q.contains(it.next()));
446              ++i;
# Line 492 | Line 482 | public class PriorityQueueTest extends J
482      /**
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())
508 <                assertEquals(q.remove(), r.remove());
509 <        } catch (Exception e){
510 <            unexpectedException();
511 <        }
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