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

Comparing jsr166/src/test/tck/LinkedListTest.java (file contents):
Revision 1.14 by jsr166, Sat Nov 21 02:39:41 2009 UTC vs.
Revision 1.20 by jsr166, Sat Oct 9 19:30:35 2010 UTC

# Line 12 | Line 12 | import java.util.concurrent.*;
12  
13   public class LinkedListTest extends JSR166TestCase {
14      public static void main(String[] args) {
15 <        junit.textui.TestRunner.run (suite());
15 >        junit.textui.TestRunner.run(suite());
16      }
17  
18      public static Test suite() {
# Line 56 | Line 56 | public class LinkedListTest extends JSR1
56      public void testConstructor6() {
57          Integer[] ints = new Integer[SIZE];
58          for (int i = 0; i < SIZE; ++i)
59 <            ints[i] = new Integer(i);
59 >            ints[i] = i;
60          LinkedList q = new LinkedList(Arrays.asList(ints));
61          for (int i = 0; i < SIZE; ++i)
62              assertEquals(ints[i], q.poll());
# Line 137 | Line 137 | public class LinkedListTest extends JSR1
137          Integer[] empty = new Integer[0];
138          Integer[] ints = new Integer[SIZE];
139          for (int i = 0; i < SIZE; ++i)
140 <            ints[i] = new Integer(i);
140 >            ints[i] = i;
141          LinkedList q = new LinkedList();
142          assertFalse(q.addAll(Arrays.asList(empty)));
143          assertTrue(q.addAll(Arrays.asList(ints)));
# Line 156 | Line 156 | public class LinkedListTest extends JSR1
156          try {
157              l.addAll(4,m);
158              shouldThrow();
159 <        } catch (IndexOutOfBoundsException  success) {}
159 >        } catch (IndexOutOfBoundsException success) {}
160      }
161  
162      /**
# Line 170 | Line 170 | public class LinkedListTest extends JSR1
170          try {
171              l.addAll(-1,m);
172              shouldThrow();
173 <        } catch (IndexOutOfBoundsException  success) {}
173 >        } catch (IndexOutOfBoundsException success) {}
174      }
175  
176      /**
177 <     *  poll succeeds unless empty
177 >     * poll succeeds unless empty
178       */
179      public void testPoll() {
180          LinkedList q = populatedQueue(SIZE);
181          for (int i = 0; i < SIZE; ++i) {
182 <            assertEquals(i, ((Integer)q.poll()).intValue());
182 >            assertEquals(i, q.poll());
183          }
184          assertNull(q.poll());
185      }
186  
187      /**
188 <     *  peek returns next element, or null if empty
188 >     * peek returns next element, or null if empty
189       */
190      public void testPeek() {
191          LinkedList q = populatedQueue(SIZE);
192          for (int i = 0; i < SIZE; ++i) {
193 <            assertEquals(i, ((Integer)q.peek()).intValue());
194 <            q.poll();
193 >            assertEquals(i, q.peek());
194 >            assertEquals(i, q.poll());
195              assertTrue(q.peek() == null ||
196 <                       i != ((Integer)q.peek()).intValue());
196 >                       !q.peek().equals(i));
197          }
198          assertNull(q.peek());
199      }
# Line 204 | Line 204 | public class LinkedListTest extends JSR1
204      public void testElement() {
205          LinkedList q = populatedQueue(SIZE);
206          for (int i = 0; i < SIZE; ++i) {
207 <            assertEquals(i, ((Integer)q.element()).intValue());
208 <            q.poll();
207 >            assertEquals(i, q.element());
208 >            assertEquals(i, q.poll());
209          }
210          try {
211              q.element();
# Line 214 | Line 214 | public class LinkedListTest extends JSR1
214      }
215  
216      /**
217 <     *  remove removes next element, or throws NSEE if empty
217 >     * remove removes next element, or throws NSEE if empty
218       */
219      public void testRemove() {
220          LinkedList q = populatedQueue(SIZE);
221          for (int i = 0; i < SIZE; ++i) {
222 <            assertEquals(i, ((Integer)q.remove()).intValue());
222 >            assertEquals(i, q.remove());
223          }
224          try {
225              q.remove();
# Line 262 | Line 262 | public class LinkedListTest extends JSR1
262          q.clear();
263          assertTrue(q.isEmpty());
264          assertEquals(0, q.size());
265 <        q.add(new Integer(1));
265 >        assertTrue(q.add(new Integer(1)));
266          assertFalse(q.isEmpty());
267          q.clear();
268          assertTrue(q.isEmpty());
# Line 277 | Line 277 | public class LinkedListTest extends JSR1
277          for (int i = 0; i < SIZE; ++i) {
278              assertTrue(q.containsAll(p));
279              assertFalse(p.containsAll(q));
280 <            p.add(new Integer(i));
280 >            assertTrue(p.add(new Integer(i)));
281          }
282          assertTrue(p.containsAll(q));
283      }
# Line 318 | Line 318 | public class LinkedListTest extends JSR1
318      }
319  
320      /**
321 <     *  toArray contains all elements
321 >     * toArray contains all elements
322       */
323      public void testToArray() {
324          LinkedList q = populatedQueue(SIZE);
# Line 329 | Line 329 | public class LinkedListTest extends JSR1
329      }
330  
331      /**
332 <     *  toArray(a) contains all elements
332 >     * toArray(a) contains all elements
333       */
334      public void testToArray2() {
335          LinkedList q = populatedQueue(SIZE);
# Line 344 | Line 344 | public class LinkedListTest extends JSR1
344       * toArray(null) throws NPE
345       */
346      public void testToArray_BadArg() {
347 +        LinkedList l = new LinkedList();
348 +        l.add(new Object());
349          try {
348 –            LinkedList l = new LinkedList();
349 –            l.add(new Object());
350              Object o[] = l.toArray(null);
351              shouldThrow();
352          } catch (NullPointerException success) {}
353      }
354  
355      /**
356 <     * toArray with incompatable aray type throws CCE
356 >     * toArray with incompatible array type throws CCE
357       */
358      public void testToArray1_BadArg() {
359 +        LinkedList l = new LinkedList();
360 +        l.add(new Integer(5));
361          try {
362 <            LinkedList l = new LinkedList();
361 <            l.add(new Integer(5));
362 <            Object o[] = l.toArray(new String[10] );
362 >            Object o[] = l.toArray(new String[10]);
363              shouldThrow();
364          } catch (ArrayStoreException success) {}
365      }
366  
367      /**
368 <     *  iterator iterates through all elements
368 >     * iterator iterates through all elements
369       */
370      public void testIterator() {
371          LinkedList q = populatedQueue(SIZE);
# Line 379 | Line 379 | public class LinkedListTest extends JSR1
379      }
380  
381      /**
382 <     *  iterator ordering is FIFO
382 >     * iterator ordering is FIFO
383       */
384      public void testIteratorOrdering() {
385          final LinkedList q = new LinkedList();
# Line 388 | Line 388 | public class LinkedListTest extends JSR1
388          q.add(new Integer(3));
389          int k = 0;
390          for (Iterator it = q.iterator(); it.hasNext();) {
391 <            int i = ((Integer)(it.next())).intValue();
392 <            assertEquals(++k, i);
391 >            assertEquals(++k, it.next());
392          }
393  
394          assertEquals(3, k);
# Line 398 | Line 397 | public class LinkedListTest extends JSR1
397      /**
398       * iterator.remove removes current element
399       */
400 <    public void testIteratorRemove () {
400 >    public void testIteratorRemove() {
401          final LinkedList q = new LinkedList();
402          q.add(new Integer(1));
403          q.add(new Integer(2));
404          q.add(new Integer(3));
405          Iterator it = q.iterator();
406 <        it.next();
406 >        assertEquals(it.next(), 1);
407          it.remove();
408          it = q.iterator();
409 <        assertEquals(it.next(), new Integer(2));
410 <        assertEquals(it.next(), new Integer(3));
409 >        assertEquals(it.next(), 2);
410 >        assertEquals(it.next(), 3);
411          assertFalse(it.hasNext());
412      }
413  
414      /**
415 <     *  Descending iterator iterates through all elements
415 >     * Descending iterator iterates through all elements
416       */
417      public void testDescendingIterator() {
418          LinkedList q = populatedQueue(SIZE);
# Line 432 | Line 431 | public class LinkedListTest extends JSR1
431      }
432  
433      /**
434 <     *  Descending iterator ordering is reverse FIFO
434 >     * Descending iterator ordering is reverse FIFO
435       */
436      public void testDescendingIteratorOrdering() {
437          final LinkedList q = new LinkedList();
# Line 441 | Line 440 | public class LinkedListTest extends JSR1
440          q.add(new Integer(1));
441          int k = 0;
442          for (Iterator it = q.descendingIterator(); it.hasNext();) {
443 <            int i = ((Integer)(it.next())).intValue();
445 <            assertEquals(++k, i);
443 >            assertEquals(++k, it.next());
444          }
445  
446          assertEquals(3, k);
# Line 451 | Line 449 | public class LinkedListTest extends JSR1
449      /**
450       * descendingIterator.remove removes current element
451       */
452 <    public void testDescendingIteratorRemove () {
452 >    public void testDescendingIteratorRemove() {
453          final LinkedList q = new LinkedList();
454 <        q.add(new Integer(3));
455 <        q.add(new Integer(2));
456 <        q.add(new Integer(1));
454 >        q.add(three);
455 >        q.add(two);
456 >        q.add(one);
457          Iterator it = q.descendingIterator();
458          it.next();
459          it.remove();
460          it = q.descendingIterator();
461 <        assertEquals(it.next(), new Integer(2));
462 <        assertEquals(it.next(), new Integer(3));
461 >        assertSame(it.next(), two);
462 >        assertSame(it.next(), three);
463          assertFalse(it.hasNext());
464      }
465  
# Line 483 | Line 481 | public class LinkedListTest extends JSR1
481      public void testAddFirst() {
482          LinkedList q = populatedQueue(3);
483          q.addFirst(four);
484 <        assertEquals(four,q.peek());
484 >        assertSame(four, q.peek());
485      }
486  
487      /**
# Line 491 | Line 489 | public class LinkedListTest extends JSR1
489       */
490      public void testPush() {
491          LinkedList q = populatedQueue(3);
494 –        q.pollLast();
492          q.push(four);
493 <        assertEquals(four,q.peekFirst());
493 >        assertSame(four, q.peekFirst());
494      }
495  
496      /**
497 <     *  pop removes next element, or throws NSEE if empty
497 >     * pop removes next element, or throws NSEE if empty
498       */
499      public void testPop() {
500          LinkedList q = populatedQueue(SIZE);
501          for (int i = 0; i < SIZE; ++i) {
502 <            assertEquals(i, ((Integer)q.pop()).intValue());
502 >            assertEquals(i, q.pop());
503          }
504          try {
505              q.pop();
# Line 529 | Line 526 | public class LinkedListTest extends JSR1
526      }
527  
528      /**
529 <     *  pollLast succeeds unless empty
529 >     * pollLast succeeds unless empty
530       */
531      public void testPollLast() {
532          LinkedList q = populatedQueue(SIZE);
533          for (int i = SIZE-1; i >= 0; --i) {
534 <            assertEquals(i, ((Integer)q.pollLast()).intValue());
534 >            assertEquals(i, q.pollLast());
535          }
536          assertNull(q.pollLast());
537      }
538  
539      /**
540 <     *  peekFirst returns next element, or null if empty
540 >     * peekFirst returns next element, or null if empty
541       */
542      public void testPeekFirst() {
543          LinkedList q = populatedQueue(SIZE);
544          for (int i = 0; i < SIZE; ++i) {
545 <            assertEquals(i, ((Integer)q.peekFirst()).intValue());
546 <            q.pollFirst();
545 >            assertEquals(i, q.peekFirst());
546 >            assertEquals(i, q.pollFirst());
547              assertTrue(q.peekFirst() == null ||
548 <                       i != ((Integer)q.peekFirst()).intValue());
548 >                       !q.peekFirst().equals(i));
549          }
550          assertNull(q.peekFirst());
551      }
552  
553  
554      /**
555 <     *  peekLast returns next element, or null if empty
555 >     * peekLast returns next element, or null if empty
556       */
557      public void testPeekLast() {
558          LinkedList q = populatedQueue(SIZE);
559          for (int i = SIZE-1; i >= 0; --i) {
560 <            assertEquals(i, ((Integer)q.peekLast()).intValue());
561 <            q.pollLast();
560 >            assertEquals(i, q.peekLast());
561 >            assertEquals(i, q.pollLast());
562              assertTrue(q.peekLast() == null ||
563 <                       i != ((Integer)q.peekLast()).intValue());
563 >                       !q.peekLast().equals(i));
564          }
565          assertNull(q.peekLast());
566      }
# Line 571 | Line 568 | public class LinkedListTest extends JSR1
568      public void testFirstElement() {
569          LinkedList q = populatedQueue(SIZE);
570          for (int i = 0; i < SIZE; ++i) {
571 <            assertEquals(i, ((Integer)q.getFirst()).intValue());
572 <            q.pollFirst();
571 >            assertEquals(i, q.getFirst());
572 >            assertEquals(i, q.pollFirst());
573          }
574          try {
575              q.getFirst();
# Line 581 | Line 578 | public class LinkedListTest extends JSR1
578      }
579  
580      /**
581 <     *  getLast returns next element, or throws NSEE if empty
581 >     * getLast returns next element, or throws NSEE if empty
582       */
583      public void testLastElement() {
584          LinkedList q = populatedQueue(SIZE);
585          for (int i = SIZE-1; i >= 0; --i) {
586 <            assertEquals(i, ((Integer)q.getLast()).intValue());
587 <            q.pollLast();
586 >            assertEquals(i, q.getLast());
587 >            assertEquals(i, q.pollLast());
588          }
589          try {
590              q.getLast();

Diff Legend

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