[cvs] / jsr166 / src / test / tck / LinkedListTest.java Repository:
ViewVC logotype

Diff of /jsr166/src/test/tck/LinkedListTest.java

Parent Directory Parent Directory | Revision Log Revision Log | View Patch Patch

revision 1.4, Sat Sep 20 18:20:08 2003 UTC revision 1.9, Wed Sep 14 23:50:31 2005 UTC
# Line 1  Line 1 
1  /*  /*
2   * Written by members of JCP JSR-166 Expert Group and released to the   * Written by Doug Lea with assistance from members of JCP JSR-166
3   * public domain. Use, modify, and redistribute this code in any way   * Expert Group and released to the public domain, as explained at
4   * without acknowledgement. Other contributors include Andrew Wright,   * http://creativecommons.org/licenses/publicdomain
5   * Jeffrey Hayes, Pat Fischer, Mike Judd.   * Other contributors include Andrew Wright, Jeffrey Hayes,
6     * Pat Fisher, Mike Judd.
7   */   */
8    
9  import junit.framework.*;  import junit.framework.*;
# Line 33  Line 34 
34      }      }
35    
36      /**      /**
37       *       * new queue is empty
38       */       */
39      public void testConstructor1() {      public void testConstructor1() {
40          assertEquals(0, new LinkedList().size());          assertEquals(0, new LinkedList().size());
41      }      }
42    
43      /**      /**
44       *       * Initializing from null Collection throws NPE
45       */       */
46      public void testConstructor3() {      public void testConstructor3() {
47          try {          try {
# Line 51  Line 52 
52      }      }
53    
54      /**      /**
55       *       * Queue contains all elements of collection used to initialize
56    
57       */       */
58      public void testConstructor6() {      public void testConstructor6() {
59          try {          try {
# Line 66  Line 68 
68      }      }
69    
70      /**      /**
71       *       * isEmpty is true before add, false after
72       */       */
73      public void testEmpty() {      public void testEmpty() {
74          LinkedList q = new LinkedList();          LinkedList q = new LinkedList();
# Line 80  Line 82 
82      }      }
83    
84      /**      /**
85       *       * size changes when elements added and removed
86       */       */
87      public void testSize() {      public void testSize() {
88          LinkedList q = populatedQueue(SIZE);          LinkedList q = populatedQueue(SIZE);
# Line 95  Line 97 
97      }      }
98    
99      /**      /**
100       *       * offer(null) succeeds
101       */       */
102      public void testOfferNull() {      public void testOfferNull() {
103          try {          try {
# Line 107  Line 109 
109      }      }
110    
111      /**      /**
112       *       * Offer succeeds
113       */       */
114      public void testOffer() {      public void testOffer() {
115          LinkedList q = new LinkedList();          LinkedList q = new LinkedList();
# Line 116  Line 118 
118      }      }
119    
120      /**      /**
121       *       * add succeeds
122       */       */
123      public void testAdd() {      public void testAdd() {
124          LinkedList q = new LinkedList();          LinkedList q = new LinkedList();
# Line 127  Line 129 
129      }      }
130    
131      /**      /**
132       *       * addAll(null) throws NPE
133       */       */
134      public void testAddAll1() {      public void testAddAll1() {
135          try {          try {
# Line 139  Line 141 
141      }      }
142    
143      /**      /**
144       *       * Queue contains all elements, in traversal order, of successful addAll
145       */       */
146      public void testAddAll5() {      public void testAddAll5() {
147          try {          try {
# Line 157  Line 159 
159      }      }
160    
161      /**      /**
162       *       * addAll with too large an index throws IOOBE
163         */
164        public void testAddAll2_IndexOutOfBoundsException() {
165            try {
166                LinkedList l = new LinkedList();
167                l.add(new Object());
168                LinkedList m = new LinkedList();
169                m.add(new Object());
170                l.addAll(4,m);
171                shouldThrow();
172            } catch(IndexOutOfBoundsException  success) {}
173        }
174    
175        /**
176         * addAll with negative index throws IOOBE
177         */
178        public void testAddAll4_BadIndex() {
179            try {
180                LinkedList l = new LinkedList();
181                l.add(new Object());
182                LinkedList m = new LinkedList();
183                m.add(new Object());
184                l.addAll(-1,m);
185                shouldThrow();
186            } catch(IndexOutOfBoundsException  success){}
187        }
188    
189        /**
190         *  poll succeeds unless empty
191       */       */
192      public void testPoll() {      public void testPoll() {
193          LinkedList q = populatedQueue(SIZE);          LinkedList q = populatedQueue(SIZE);
# Line 168  Line 198 
198      }      }
199    
200      /**      /**
201       *       *  peek returns next element, or null if empty
202       */       */
203      public void testPeek() {      public void testPeek() {
204          LinkedList q = populatedQueue(SIZE);          LinkedList q = populatedQueue(SIZE);
# Line 182  Line 212 
212      }      }
213    
214      /**      /**
215       *       * element returns next element, or throws NSEE if empty
216       */       */
217      public void testElement() {      public void testElement() {
218          LinkedList q = populatedQueue(SIZE);          LinkedList q = populatedQueue(SIZE);
# Line 198  Line 228 
228      }      }
229    
230      /**      /**
231       *       *  remove removes next element, or throws NSEE if empty
232       */       */
233      public void testRemove() {      public void testRemove() {
234          LinkedList q = populatedQueue(SIZE);          LinkedList q = populatedQueue(SIZE);
# Line 213  Line 243 
243      }      }
244    
245      /**      /**
246       *       * remove(x) removes x and returns true if present
247       */       */
248      public void testRemoveElement() {      public void testRemoveElement() {
249          LinkedList q = populatedQueue(SIZE);          LinkedList q = populatedQueue(SIZE);
# Line 228  Line 258 
258      }      }
259    
260      /**      /**
261       *       * contains(x) reports true when elements added but not yet removed
262       */       */
263      public void testContains() {      public void testContains() {
264          LinkedList q = populatedQueue(SIZE);          LinkedList q = populatedQueue(SIZE);
# Line 240  Line 270 
270      }      }
271    
272      /**      /**
273       *       * clear removes all elements
274       */       */
275      public void testClear() {      public void testClear() {
276          LinkedList q = populatedQueue(SIZE);          LinkedList q = populatedQueue(SIZE);
# Line 254  Line 284 
284      }      }
285    
286      /**      /**
287       *       * containsAll(c) is true when c contains a subset of elements
288       */       */
289      public void testContainsAll() {      public void testContainsAll() {
290          LinkedList q = populatedQueue(SIZE);          LinkedList q = populatedQueue(SIZE);
# Line 268  Line 298 
298      }      }
299    
300      /**      /**
301       *       * retainAll(c) retains only those elements of c and reports true if changed
302       */       */
303      public void testRetainAll() {      public void testRetainAll() {
304          LinkedList q = populatedQueue(SIZE);          LinkedList q = populatedQueue(SIZE);
# Line 287  Line 317 
317      }      }
318    
319      /**      /**
320       *       * removeAll(c) removes only those elements of c and reports true if changed
321       */       */
322      public void testRemoveAll() {      public void testRemoveAll() {
323          for (int i = 1; i < SIZE; ++i) {          for (int i = 1; i < SIZE; ++i) {
# Line 303  Line 333 
333      }      }
334    
335      /**      /**
336       *       *  toArray contains all elements
337       */       */
338      public void testToArray() {      public void testToArray() {
339          LinkedList q = populatedQueue(SIZE);          LinkedList q = populatedQueue(SIZE);
# Line 314  Line 344 
344      }      }
345    
346      /**      /**
347       *       *  toArray(a) contains all elements
348       */       */
349      public void testToArray2() {      public void testToArray2() {
350          LinkedList q = populatedQueue(SIZE);          LinkedList q = populatedQueue(SIZE);
# Line 326  Line 356 
356      }      }
357    
358      /**      /**
359       *       * toArray(null) throws NPE
360         */
361        public void testToArray_BadArg() {
362            try {
363                LinkedList l = new LinkedList();
364                l.add(new Object());
365                Object o[] = l.toArray(null);
366                shouldThrow();
367            } catch(NullPointerException success){}
368        }
369    
370        /**
371         * toArray with incompatable aray type throws CCE
372         */
373        public void testToArray1_BadArg() {
374            try {
375                LinkedList l = new LinkedList();
376                l.add(new Integer(5));
377                Object o[] = l.toArray(new String[10] );
378                shouldThrow();
379            } catch(ArrayStoreException  success){}
380        }
381    
382        /**
383         *  iterator iterates through all elements
384       */       */
385      public void testIterator() {      public void testIterator() {
386          LinkedList q = populatedQueue(SIZE);          LinkedList q = populatedQueue(SIZE);
# Line 340  Line 394 
394      }      }
395    
396      /**      /**
397       *       *  iterator ordering is FIFO
398       */       */
399      public void testIteratorOrdering() {      public void testIteratorOrdering() {
   
400          final LinkedList q = new LinkedList();          final LinkedList q = new LinkedList();
   
401          q.add(new Integer(1));          q.add(new Integer(1));
402          q.add(new Integer(2));          q.add(new Integer(2));
403          q.add(new Integer(3));          q.add(new Integer(3));
   
404          int k = 0;          int k = 0;
405          for (Iterator it = q.iterator(); it.hasNext();) {          for (Iterator it = q.iterator(); it.hasNext();) {
406              int i = ((Integer)(it.next())).intValue();              int i = ((Integer)(it.next())).intValue();
# Line 360  Line 411 
411      }      }
412    
413      /**      /**
414       *       * iterator.remove removes current element
415       */       */
416      public void testIteratorRemove () {      public void testIteratorRemove () {
417          final LinkedList q = new LinkedList();          final LinkedList q = new LinkedList();
   
418          q.add(new Integer(1));          q.add(new Integer(1));
419          q.add(new Integer(2));          q.add(new Integer(2));
420          q.add(new Integer(3));          q.add(new Integer(3));
   
421          Iterator it = q.iterator();          Iterator it = q.iterator();
422          it.next();          it.next();
423          it.remove();          it.remove();
   
424          it = q.iterator();          it = q.iterator();
425          assertEquals(it.next(), new Integer(2));          assertEquals(it.next(), new Integer(2));
426          assertEquals(it.next(), new Integer(3));          assertEquals(it.next(), new Integer(3));
427          assertFalse(it.hasNext());          assertFalse(it.hasNext());
428      }      }
429    
   
430      /**      /**
431       *       *  Descending iterator iterates through all elements
432       */       */
433      public void testToString() {      public void testDescendingIterator() {
434          LinkedList q = populatedQueue(SIZE);          LinkedList q = populatedQueue(SIZE);
435          String s = q.toString();          int i = 0;
436          for (int i = 0; i < SIZE; ++i) {          Iterator it = q.descendingIterator();
437              assertTrue(s.indexOf(String.valueOf(i)) >= 0);          while(it.hasNext()) {
438                assertTrue(q.contains(it.next()));
439                ++i;
440          }          }
441            assertEquals(i, SIZE);
442            assertFalse(it.hasNext());
443            try {
444                it.next();
445            } catch(NoSuchElementException success) {
446      }      }
   
     /**  
      *  
      */  
     public void testAddFirst() {  
         LinkedList q = populatedQueue(3);  
         q.addFirst(new Integer(4));  
         assertEquals(new Integer(4),q.get(0));  
447      }      }
448    
449      /**      /**
450       *       *  Descending iterator ordering is reverse FIFO
451       */       */
452      public void testAddLast() {      public void testDescendingIteratorOrdering() {
453          LinkedList q = populatedQueue(3);          final LinkedList q = new LinkedList();
454          q.addLast(new Integer(3));          q.add(new Integer(3));
455          assertEquals(new Integer(3),q.get(3));          q.add(new Integer(2));
456            q.add(new Integer(1));
457            int k = 0;
458            for (Iterator it = q.descendingIterator(); it.hasNext();) {
459                int i = ((Integer)(it.next())).intValue();
460                assertEquals(++k, i);
461      }      }
462    
463      /**          assertEquals(3, k);
      *  
      */  
     public void testGetFirst() {  
         LinkedList q = populatedQueue(3);  
         assertEquals(new Integer(0),q.getFirst());  
464      }      }
465    
466      /**      /**
467       *       * descendingIterator.remove removes current element
468       */       */
469      public void testGetLast() {      public void testDescendingIteratorRemove () {
470          LinkedList q = populatedQueue(3);          final LinkedList q = new LinkedList();
471          assertEquals(new Integer(2),q.getLast());          q.add(new Integer(3));
472            q.add(new Integer(2));
473            q.add(new Integer(1));
474            Iterator it = q.descendingIterator();
475            it.next();
476            it.remove();
477            it = q.descendingIterator();
478            assertEquals(it.next(), new Integer(2));
479            assertEquals(it.next(), new Integer(3));
480            assertFalse(it.hasNext());
481      }      }
482    
483    
484      /**      /**
485       *       * toString contains toStrings of elements
486       */       */
487      public void testIndexOf() {      public void testToString() {
488          LinkedList q = populatedQueue(3);          LinkedList q = populatedQueue(SIZE);
489          assertEquals(0,q.indexOf(new Integer(0)));          String s = q.toString();
490          assertEquals(1,q.indexOf(new Integer(1)));          for (int i = 0; i < SIZE; ++i) {
491          assertEquals(2,q.indexOf(new Integer(2)));              assertTrue(s.indexOf(String.valueOf(i)) >= 0);
492          assertEquals(-1, q.indexOf("not there"));          }
493      }      }
494    
495      /**      /**
496       *       * peek returns element inserted with addFirst
497       */       */
498      public void testLastIndexOf() {      public void testAddFirst() {
499          LinkedList q = populatedQueue(3);          LinkedList q = populatedQueue(3);
500          q.add(new Integer(2));          q.addFirst(four);
501          assertEquals(3,q.lastIndexOf(new Integer(2)));          assertEquals(four,q.peek());
         assertEquals(-1, q.lastIndexOf("not there"));  
502      }      }
503    
504      /**      /**
505       *       * peekFirst returns element inserted with push
506       */       */
507      public void testSet() {      public void testPush() {
508          LinkedList q = populatedQueue(3);          LinkedList q = populatedQueue(3);
509          q.set(0,(new Integer(1)));          q.pollLast();
510          assertFalse(q.contains(new Integer(0)));          q.push(four);
511          assertEquals(new Integer(1), q.get(0));          assertEquals(four,q.peekFirst());
512      }      }
513    
   
514      /**      /**
515       *       *  pop removes next element, or throws NSEE if empty
516       */       */
517      public void testGetFirst_NoSuchElementException() {      public void testPop() {
518          try {          LinkedList q = populatedQueue(SIZE);
519              LinkedList l = new LinkedList();          for (int i = 0; i < SIZE; ++i) {
520              l.getFirst();              assertEquals(i, ((Integer)q.pop()).intValue());
             shouldThrow();  
         }  
         catch(NoSuchElementException success) {}  
521      }      }
   
     /**  
      *  
      */  
     public void testRemoveFirst() {  
522          try {          try {
523              LinkedList l = new LinkedList();              q.pop();
             l.removeFirst();  
524              shouldThrow();              shouldThrow();
525            } catch (NoSuchElementException success){
526          }          }
         catch(NoSuchElementException success) {}  
527      }      }
528    
529      /**      /**
530       *       * OfferFirst succeeds
531       */       */
532      public void testRemoveLast() {      public void testOfferFirst() {
533          try {          LinkedList q = new LinkedList();
534              LinkedList l = new LinkedList();          assertTrue(q.offerFirst(new Integer(0)));
535              l.removeLast();          assertTrue(q.offerFirst(new Integer(1)));
             shouldThrow();  
         }  
         catch(NoSuchElementException success) {}  
536      }      }
537    
538      /**      /**
539       *       * OfferLast succeeds
540       */       */
541      public void testGetLast_NoSuchElementException() {      public void testOfferLast() {
542          try {          LinkedList q = new LinkedList();
543              LinkedList l = new LinkedList();          assertTrue(q.offerLast(new Integer(0)));
544              l.getLast();          assertTrue(q.offerLast(new Integer(1)));
             shouldThrow();  
         }  
         catch(NoSuchElementException success) {}  
545      }      }
546    
   
547      /**      /**
548       *       *  pollLast succeeds unless empty
549       */       */
550      public void testAddAll_NullPointerException() {      public void testPollLast() {
551          try {          LinkedList q = populatedQueue(SIZE);
552              LinkedList l = new LinkedList();          for (int i = SIZE-1; i >= 0; --i) {
553              l.addAll((Collection)null);              assertEquals(i, ((Integer)q.pollLast()).intValue());
             shouldThrow();  
554          }          }
555          catch(NullPointerException success){}          assertNull(q.pollLast());
556      }      }
557    
   
558      /**      /**
559       *       *  peekFirst returns next element, or null if empty
560       */       */
561      public void testAddAll1_OutOfBounds() {      public void testPeekFirst() {
562          try {          LinkedList q = populatedQueue(SIZE);
563              LinkedList l = new LinkedList();          for (int i = 0; i < SIZE; ++i) {
564              l.addAll(4,new LinkedList());              assertEquals(i, ((Integer)q.peekFirst()).intValue());
565              shouldThrow();              q.pollFirst();
566                assertTrue(q.peekFirst() == null ||
567                           i != ((Integer)q.peekFirst()).intValue());
568          }          }
569          catch(IndexOutOfBoundsException  success) {}          assertNull(q.peekFirst());
570      }      }
571    
572    
573      /**      /**
574       *       *  peekLast returns next element, or null if empty
      */  
     public void testAddAll2_IndexOutOfBoundsException() {  
         try {  
             LinkedList l = new LinkedList();  
             l.add(new Object());  
             LinkedList m = new LinkedList();  
             m.add(new Object());  
             l.addAll(4,m);  
             shouldThrow();  
         } catch(IndexOutOfBoundsException  success) {}  
     }  
   
     /**  
      *  
575       */       */
576      public void testAddAll4_BadIndex() {      public void testPeekLast() {
577          try {          LinkedList q = populatedQueue(SIZE);
578              LinkedList l = new LinkedList();          for (int i = SIZE-1; i >= 0; --i) {
579              l.add(new Object());              assertEquals(i, ((Integer)q.peekLast()).intValue());
580              LinkedList m = new LinkedList();              q.pollLast();
581              m.add(new Object());              assertTrue(q.peekLast() == null ||
582              l.addAll(-1,m);                         i != ((Integer)q.peekLast()).intValue());
             shouldThrow();  
         } catch(IndexOutOfBoundsException  success){}  
583      }      }
584            assertNull(q.peekLast());
     /**  
      *  
      */  
     public void testget1() {  
         try {  
             LinkedList l = new LinkedList();  
             l.add(new Object());  
             l.get(-1);  
             shouldThrow();  
         } catch(IndexOutOfBoundsException  success) {}  
585      }      }
586    
587      /**      public void testFirstElement() {
588       *          LinkedList q = populatedQueue(SIZE);
589       */          for (int i = 0; i < SIZE; ++i) {
590      public void testget2() {              assertEquals(i, ((Integer)q.getFirst()).intValue());
591          try {              q.pollFirst();
             LinkedList l = new LinkedList();  
             l.add(new Object());  
             l.get(5);  
             shouldThrow();  
         } catch(IndexOutOfBoundsException  success){}  
592      }      }
   
     /**  
      *  
      */  
     public void testset1() {  
593          try {          try {
594              LinkedList l = new LinkedList();              q.getFirst();
             l.add(new Object());  
             l.set(-1,new Object());  
595              shouldThrow();              shouldThrow();
         } catch(IndexOutOfBoundsException  success){}  
596      }      }
597            catch (NoSuchElementException success) {}
     /**  
      *  
      */  
     public void testset2() {  
         try {  
             LinkedList l = new LinkedList();  
             l.add(new Object());  
             l.set(5,new Object());  
             shouldThrow();  
         } catch(IndexOutOfBoundsException  success){}  
598      }      }
599    
600      /**      /**
601       *       *  getLast returns next element, or throws NSEE if empty
602       */       */
603      public void testadd1() {      public void testLastElement() {
604          try {          LinkedList q = populatedQueue(SIZE);
605              LinkedList l = new LinkedList();          for (int i = SIZE-1; i >= 0; --i) {
606              l.add(new Object());              assertEquals(i, ((Integer)q.getLast()).intValue());
607              l.add(-1,new Object());              q.pollLast();
             shouldThrow();  
         } catch(IndexOutOfBoundsException  success){}  
     }  
   
     public void add2() {  
         try {  
             LinkedList l = new LinkedList();  
             l.add(new Object());  
             l.add(5,new Object());  
             shouldThrow();  
         } catch(IndexOutOfBoundsException  success) {}  
608      }      }
   
     /**  
      *  
      */  
     public void testremove() {  
609          try {          try {
610              LinkedList l = new LinkedList();              q.getLast();
             l.add(new Object());  
             l.remove(-1);  
611              shouldThrow();              shouldThrow();
         } catch(IndexOutOfBoundsException  success){}  
612      }      }
613            catch (NoSuchElementException success) {}
614      /**          assertNull(q.peekLast());
      *  
      */  
     public void testremove1() {  
         try {  
             LinkedList l = new LinkedList();  
             l.add(new Object());  
             l.remove(5);  
             shouldThrow();  
         } catch(IndexOutOfBoundsException  success){}  
615      }      }
616    
   
617      /**      /**
618       *       * removeFirstOccurrence(x) removes x and returns true if present
619       */       */
620      public void testremove2() {      public void testRemoveFirstOccurrence() {
621          try {          LinkedList q = populatedQueue(SIZE);
622              LinkedList l = new LinkedList();          for (int i = 1; i < SIZE; i+=2) {
623              l.remove();              assertTrue(q.removeFirstOccurrence(new Integer(i)));
             shouldThrow();  
         } catch(NoSuchElementException e){}  
624      }      }
625            for (int i = 0; i < SIZE; i+=2) {
626      /**              assertTrue(q.removeFirstOccurrence(new Integer(i)));
627       *              assertFalse(q.removeFirstOccurrence(new Integer(i+1)));
      */  
     public void testlistIt1() {  
         try {  
             LinkedList l = new LinkedList();  
             l.add(new Object());  
             l.listIterator(5);  
             shouldThrow();  
         } catch(IndexOutOfBoundsException  success){}  
628      }      }
629            assertTrue(q.isEmpty());
     /**  
      *  
      */  
     public void testlistIt2() {  
         try {  
             LinkedList l = new LinkedList();  
             l.add(new Object());  
             l.listIterator(-1);  
             shouldThrow();  
         } catch(IndexOutOfBoundsException  success){}  
630      }      }
631    
632      /**      /**
633       *       * removeLastOccurrence(x) removes x and returns true if present
634       */       */
635      public void testlistIt3() {      public void testRemoveLastOccurrence() {
636          try {          LinkedList q = populatedQueue(SIZE);
637              LinkedList l = new LinkedList();          for (int i = 1; i < SIZE; i+=2) {
638              l.add(new Object());              assertTrue(q.removeLastOccurrence(new Integer(i)));
             ListIterator a = l.listIterator(0);  
             l.removeFirst();  
             a.next();  
             shouldThrow();  
         } catch(ConcurrentModificationException success){}  
639      }      }
640            for (int i = 0; i < SIZE; i+=2) {
641      /**              assertTrue(q.removeLastOccurrence(new Integer(i)));
642       *              assertFalse(q.removeLastOccurrence(new Integer(i+1)));
      */  
     public void testToArray_BadArg() {  
         try {  
             LinkedList l = new LinkedList();  
             l.add(new Object());  
             Object o[] = l.toArray(null);  
             shouldThrow();  
         } catch(NullPointerException success){}  
643      }      }
644            assertTrue(q.isEmpty());
     /**  
      *  
      */  
     public void testToArray1_BadArg() {  
         try {  
             LinkedList l = new LinkedList();  
             l.add(new Integer(5));  
             Object o[] = l.toArray(new String[10] );  
             shouldThrow();  
         } catch(ArrayStoreException  success){}  
645      }      }
646    
647  }  }

Legend:
Removed from v.1.4  
changed lines
  Added in v.1.9

Doug Lea
ViewVC Help
Powered by ViewVC 1.0.8