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

Comparing jsr166/src/test/tck/ArrayDequeTest.java (file contents):
Revision 1.8 by jsr166, Sat Nov 21 02:07:26 2009 UTC vs.
Revision 1.15 by jsr166, Wed Dec 23 00:49:44 2009 UTC

# Line 45 | Line 45 | public class ArrayDequeTest extends JSR1
45          try {
46              ArrayDeque q = new ArrayDeque((Collection)null);
47              shouldThrow();
48 <        }
49 <        catch (NullPointerException success) {}
48 >        } catch (NullPointerException success) {}
49      }
50  
51      /**
# Line 54 | Line 53 | public class ArrayDequeTest extends JSR1
53  
54       */
55      public void testConstructor6() {
56 <        try {
57 <            Integer[] ints = new Integer[SIZE];
58 <            for (int i = 0; i < SIZE; ++i)
59 <                ints[i] = new Integer(i);
60 <            ArrayDeque q = new ArrayDeque(Arrays.asList(ints));
61 <            for (int i = 0; i < SIZE; ++i)
63 <                assertEquals(ints[i], q.pollFirst());
64 <        }
65 <        finally {}
56 >        Integer[] ints = new Integer[SIZE];
57 >        for (int i = 0; i < SIZE; ++i)
58 >            ints[i] = new Integer(i);
59 >        ArrayDeque q = new ArrayDeque(Arrays.asList(ints));
60 >        for (int i = 0; i < SIZE; ++i)
61 >            assertEquals(ints[i], q.pollFirst());
62      }
63  
64      /**
# Line 102 | Line 98 | public class ArrayDequeTest extends JSR1
98              ArrayDeque q = new ArrayDeque(1);
99              q.push(null);
100              shouldThrow();
101 <        } catch (NullPointerException success) { }
101 >        } catch (NullPointerException success) {}
102      }
103  
104      /**
# Line 112 | Line 108 | public class ArrayDequeTest extends JSR1
108          ArrayDeque q = populatedDeque(3);
109          q.pollLast();
110          q.push(four);
111 <        assertEquals(four,q.peekFirst());
111 >        assertSame(four, q.peekFirst());
112      }
113  
114      /**
# Line 121 | Line 117 | public class ArrayDequeTest extends JSR1
117      public void testPop() {
118          ArrayDeque q = populatedDeque(SIZE);
119          for (int i = 0; i < SIZE; ++i) {
120 <            assertEquals(i, ((Integer)q.pop()).intValue());
120 >            assertEquals(i, q.pop());
121          }
122          try {
123              q.pop();
124              shouldThrow();
125 <        } catch (NoSuchElementException success) {
130 <        }
125 >        } catch (NoSuchElementException success) {}
126      }
127  
128      /**
# Line 138 | Line 133 | public class ArrayDequeTest extends JSR1
133              ArrayDeque q = new ArrayDeque();
134              q.offerFirst(null);
135              shouldThrow();
136 <        } catch (NullPointerException success) {
142 <        }
136 >        } catch (NullPointerException success) {}
137      }
138  
139      /**
# Line 179 | Line 173 | public class ArrayDequeTest extends JSR1
173              ArrayDeque q = new ArrayDeque();
174              q.addAll(null);
175              shouldThrow();
176 <        }
183 <        catch (NullPointerException success) {}
176 >        } catch (NullPointerException success) {}
177      }
178  
179      /**
180       * Queue contains all elements, in traversal order, of successful addAll
181       */
182      public void testAddAll5() {
183 <        try {
184 <            Integer[] empty = new Integer[0];
185 <            Integer[] ints = new Integer[SIZE];
186 <            for (int i = 0; i < SIZE; ++i)
187 <                ints[i] = new Integer(i);
188 <            ArrayDeque q = new ArrayDeque();
189 <            assertFalse(q.addAll(Arrays.asList(empty)));
190 <            assertTrue(q.addAll(Arrays.asList(ints)));
191 <            for (int i = 0; i < SIZE; ++i)
199 <                assertEquals(ints[i], q.pollFirst());
200 <        }
201 <        finally {}
183 >        Integer[] empty = new Integer[0];
184 >        Integer[] ints = new Integer[SIZE];
185 >        for (int i = 0; i < SIZE; ++i)
186 >            ints[i] = new Integer(i);
187 >        ArrayDeque q = new ArrayDeque();
188 >        assertFalse(q.addAll(Arrays.asList(empty)));
189 >        assertTrue(q.addAll(Arrays.asList(ints)));
190 >        for (int i = 0; i < SIZE; ++i)
191 >            assertEquals(ints[i], q.pollFirst());
192      }
193  
194      /**
# Line 207 | Line 197 | public class ArrayDequeTest extends JSR1
197      public void testPollFirst() {
198          ArrayDeque q = populatedDeque(SIZE);
199          for (int i = 0; i < SIZE; ++i) {
200 <            assertEquals(i, ((Integer)q.pollFirst()).intValue());
200 >            assertEquals(i, q.pollFirst());
201          }
202          assertNull(q.pollFirst());
203      }
# Line 218 | Line 208 | public class ArrayDequeTest extends JSR1
208      public void testPollLast() {
209          ArrayDeque q = populatedDeque(SIZE);
210          for (int i = SIZE-1; i >= 0; --i) {
211 <            assertEquals(i, ((Integer)q.pollLast()).intValue());
211 >            assertEquals(i, q.pollLast());
212          }
213          assertNull(q.pollLast());
214      }
# Line 229 | Line 219 | public class ArrayDequeTest extends JSR1
219      public void testPoll() {
220          ArrayDeque q = populatedDeque(SIZE);
221          for (int i = 0; i < SIZE; ++i) {
222 <            assertEquals(i, ((Integer)q.poll()).intValue());
222 >            assertEquals(i, q.poll());
223          }
224          assertNull(q.poll());
225      }
# Line 240 | Line 230 | public class ArrayDequeTest extends JSR1
230      public void testRemove() {
231          ArrayDeque q = populatedDeque(SIZE);
232          for (int i = 0; i < SIZE; ++i) {
233 <            assertEquals(i, ((Integer)q.remove()).intValue());
233 >            assertEquals(i, q.remove());
234          }
235          try {
236              q.remove();
237              shouldThrow();
238 <        } catch (NoSuchElementException success) {
249 <        }
238 >        } catch (NoSuchElementException success) {}
239      }
240  
241      /**
# Line 255 | Line 244 | public class ArrayDequeTest extends JSR1
244      public void testPeekFirst() {
245          ArrayDeque q = populatedDeque(SIZE);
246          for (int i = 0; i < SIZE; ++i) {
247 <            assertEquals(i, ((Integer)q.peekFirst()).intValue());
248 <            q.pollFirst();
247 >            assertEquals(i, q.peekFirst());
248 >            assertEquals(i, q.pollFirst());
249              assertTrue(q.peekFirst() == null ||
250 <                       i != ((Integer)q.peekFirst()).intValue());
250 >                       !q.peekFirst().equals(i));
251          }
252          assertNull(q.peekFirst());
253      }
# Line 269 | Line 258 | public class ArrayDequeTest extends JSR1
258      public void testPeek() {
259          ArrayDeque q = populatedDeque(SIZE);
260          for (int i = 0; i < SIZE; ++i) {
261 <            assertEquals(i, ((Integer)q.peek()).intValue());
262 <            q.poll();
261 >            assertEquals(i, q.peek());
262 >            assertEquals(i, q.poll());
263              assertTrue(q.peek() == null ||
264 <                       i != ((Integer)q.peek()).intValue());
264 >                       !q.peek().equals(i));
265          }
266          assertNull(q.peek());
267      }
# Line 283 | Line 272 | public class ArrayDequeTest extends JSR1
272      public void testPeekLast() {
273          ArrayDeque q = populatedDeque(SIZE);
274          for (int i = SIZE-1; i >= 0; --i) {
275 <            assertEquals(i, ((Integer)q.peekLast()).intValue());
276 <            q.pollLast();
275 >            assertEquals(i, q.peekLast());
276 >            assertEquals(i, q.pollLast());
277              assertTrue(q.peekLast() == null ||
278 <                       i != ((Integer)q.peekLast()).intValue());
278 >                       !q.peekLast().equals(i));
279          }
280          assertNull(q.peekLast());
281      }
# Line 297 | Line 286 | public class ArrayDequeTest extends JSR1
286      public void testFirstElement() {
287          ArrayDeque q = populatedDeque(SIZE);
288          for (int i = 0; i < SIZE; ++i) {
289 <            assertEquals(i, ((Integer)q.getFirst()).intValue());
290 <            q.pollFirst();
289 >            assertEquals(i, q.getFirst());
290 >            assertEquals(i, q.pollFirst());
291          }
292          try {
293              q.getFirst();
294              shouldThrow();
295 <        }
307 <        catch (NoSuchElementException success) {}
295 >        } catch (NoSuchElementException success) {}
296      }
297  
298      /**
# Line 313 | Line 301 | public class ArrayDequeTest extends JSR1
301      public void testLastElement() {
302          ArrayDeque q = populatedDeque(SIZE);
303          for (int i = SIZE-1; i >= 0; --i) {
304 <            assertEquals(i, ((Integer)q.getLast()).intValue());
305 <            q.pollLast();
304 >            assertEquals(i, q.getLast());
305 >            assertEquals(i, q.pollLast());
306          }
307          try {
308              q.getLast();
309              shouldThrow();
310 <        }
323 <        catch (NoSuchElementException success) {}
310 >        } catch (NoSuchElementException success) {}
311          assertNull(q.peekLast());
312      }
313  
# Line 331 | Line 318 | public class ArrayDequeTest extends JSR1
318      public void testRemoveFirst() {
319          ArrayDeque q = populatedDeque(SIZE);
320          for (int i = 0; i < SIZE; ++i) {
321 <            assertEquals(i, ((Integer)q.removeFirst()).intValue());
321 >            assertEquals(i, q.removeFirst());
322          }
323          try {
324              q.removeFirst();
325              shouldThrow();
326 <        } catch (NoSuchElementException success) {
340 <        }
326 >        } catch (NoSuchElementException success) {}
327      }
328  
329      /**
# Line 377 | Line 363 | public class ArrayDequeTest extends JSR1
363          ArrayDeque q = populatedDeque(SIZE);
364          for (int i = 0; i < SIZE; ++i) {
365              assertTrue(q.contains(new Integer(i)));
366 <            q.pollFirst();
366 >            assertEquals(i, q.pollFirst());
367              assertFalse(q.contains(new Integer(i)));
368          }
369      }
# Line 390 | Line 376 | public class ArrayDequeTest extends JSR1
376          q.clear();
377          assertTrue(q.isEmpty());
378          assertEquals(0, q.size());
379 <        q.add(new Integer(1));
379 >        assertTrue(q.add(new Integer(1)));
380          assertFalse(q.isEmpty());
381          q.clear();
382          assertTrue(q.isEmpty());
# Line 405 | Line 391 | public class ArrayDequeTest extends JSR1
391          for (int i = 0; i < SIZE; ++i) {
392              assertTrue(q.containsAll(p));
393              assertFalse(p.containsAll(q));
394 <            p.add(new Integer(i));
394 >            assertTrue(p.add(new Integer(i)));
395          }
396          assertTrue(p.containsAll(q));
397      }
# Line 418 | Line 404 | public class ArrayDequeTest extends JSR1
404          ArrayDeque p = populatedDeque(SIZE);
405          for (int i = 0; i < SIZE; ++i) {
406              boolean changed = q.retainAll(p);
407 <            if (i == 0)
422 <                assertFalse(changed);
423 <            else
424 <                assertTrue(changed);
425 <
407 >            assertEquals(changed, (i > 0));
408              assertTrue(q.containsAll(p));
409              assertEquals(SIZE-i, q.size());
410              p.removeFirst();
# Line 439 | Line 421 | public class ArrayDequeTest extends JSR1
421              assertTrue(q.removeAll(p));
422              assertEquals(SIZE-i, q.size());
423              for (int j = 0; j < i; ++j) {
424 <                Integer I = (Integer)(p.removeFirst());
443 <                assertFalse(q.contains(I));
424 >                assertFalse(q.contains(p.removeFirst()));
425              }
426          }
427      }
# Line 472 | Line 453 | public class ArrayDequeTest extends JSR1
453       * toArray(null) throws NPE
454       */
455      public void testToArray_BadArg() {
456 +        ArrayDeque l = new ArrayDeque();
457 +        l.add(new Object());
458          try {
476 –            ArrayDeque l = new ArrayDeque();
477 –            l.add(new Object());
459              Object o[] = l.toArray(null);
460              shouldThrow();
461          } catch (NullPointerException success) {}
462      }
463  
464      /**
465 <     * toArray with incompatable aray type throws CCE
465 >     * toArray with incompatible array type throws CCE
466       */
467      public void testToArray1_BadArg() {
468 +        ArrayDeque l = new ArrayDeque();
469 +        l.add(new Integer(5));
470          try {
471 <            ArrayDeque l = new ArrayDeque();
489 <            l.add(new Integer(5));
490 <            Object o[] = l.toArray(new String[10] );
471 >            Object o[] = l.toArray(new String[10]);
472              shouldThrow();
473 <        } catch (ArrayStoreException  success) {}
473 >        } catch (ArrayStoreException success) {}
474      }
475  
476      /**
# Line 516 | Line 497 | public class ArrayDequeTest extends JSR1
497          q.add(new Integer(3));
498          int k = 0;
499          for (Iterator it = q.iterator(); it.hasNext();) {
500 <            int i = ((Integer)(it.next())).intValue();
520 <            assertEquals(++k, i);
500 >            assertEquals(++k, it.next());
501          }
502  
503          assertEquals(3, k);
# Line 566 | Line 546 | public class ArrayDequeTest extends JSR1
546          assertFalse(it.hasNext());
547          try {
548              it.next();
549 <        } catch (NoSuchElementException success) {
550 <        }
549 >            shouldThrow();
550 >        } catch (NoSuchElementException success) {}
551      }
552  
553      /**
# Line 581 | Line 561 | public class ArrayDequeTest extends JSR1
561              q.add(new Integer(1));
562              int k = 0;
563              for (Iterator it = q.descendingIterator(); it.hasNext();) {
564 <                int i = ((Integer)(it.next())).intValue();
585 <                assertEquals(++k, i);
564 >                assertEquals(++k, it.next());
565              }
566  
567              assertEquals(3, k);
# Line 638 | Line 617 | public class ArrayDequeTest extends JSR1
617      public void testAddFirst() {
618          ArrayDeque q = populatedDeque(3);
619          q.addFirst(four);
620 <        assertEquals(four,q.peekFirst());
620 >        assertSame(four, q.peekFirst());
621      }
622  
623      /**
# Line 647 | Line 626 | public class ArrayDequeTest extends JSR1
626      public void testAddLast() {
627          ArrayDeque q = populatedDeque(3);
628          q.addLast(four);
629 <        assertEquals(four,q.peekLast());
629 >        assertSame(four, q.peekLast());
630      }
631  
632   }

Diff Legend

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