[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.2, Sun Sep 7 20:39:11 2003 UTC revision 1.10, Mon Nov 2 20:28:31 2009 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.*;
10  import java.util.*;  import java.util.*;
11  import java.util.concurrent.*;  import java.util.concurrent.*;
12    
13  public class LinkedListTest extends TestCase {  public class LinkedListTest extends JSR166TestCase {
   
     private static final int N = 10;  
     private static final long SHORT_DELAY_MS = 100;  
     private static final long MEDIUM_DELAY_MS = 1000;  
     private static final long LONG_DELAY_MS = 10000;  
   
14      public static void main(String[] args) {      public static void main(String[] args) {
15          junit.textui.TestRunner.run (suite());          junit.textui.TestRunner.run (suite());
16      }      }
# Line 28  Line 23 
23       * Create a queue of given size containing consecutive       * Create a queue of given size containing consecutive
24       * Integers 0 ... n.       * Integers 0 ... n.
25       */       */
26      private LinkedList fullQueue(int n) {      private LinkedList populatedQueue(int n) {
27          LinkedList q = new LinkedList();          LinkedList q = new LinkedList();
28          assertTrue(q.isEmpty());          assertTrue(q.isEmpty());
29          for(int i = 0; i < n; ++i)          for(int i = 0; i < n; ++i)
# Line 38  Line 33 
33          return q;          return q;
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 {
48              LinkedList q = new LinkedList((Collection)null);              LinkedList q = new LinkedList((Collection)null);
49              fail("Cannot make from null collection");              shouldThrow();
50          }          }
51          catch (NullPointerException success) {}          catch (NullPointerException success) {}
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 {
60              Integer[] ints = new Integer[N];              Integer[] ints = new Integer[SIZE];
61              for (int i = 0; i < N; ++i)              for (int i = 0; i < SIZE; ++i)
62                  ints[i] = new Integer(i);                  ints[i] = new Integer(i);
63              LinkedList q = new LinkedList(Arrays.asList(ints));              LinkedList q = new LinkedList(Arrays.asList(ints));
64              for (int i = 0; i < N; ++i)              for (int i = 0; i < SIZE; ++i)
65                  assertEquals(ints[i], q.poll());                  assertEquals(ints[i], q.poll());
66          }          }
67          finally {}          finally {}
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();
75          assertTrue(q.isEmpty());          assertTrue(q.isEmpty());
# Line 73  Line 81 
81          assertTrue(q.isEmpty());          assertTrue(q.isEmpty());
82      }      }
83    
84        /**
85         * size changes when elements added and removed
86         */
87      public void testSize() {      public void testSize() {
88          LinkedList q = fullQueue(N);          LinkedList q = populatedQueue(SIZE);
89          for (int i = 0; i < N; ++i) {          for (int i = 0; i < SIZE; ++i) {
90              assertEquals(N-i, q.size());              assertEquals(SIZE-i, q.size());
91              q.remove();              q.remove();
92          }          }
93          for (int i = 0; i < N; ++i) {          for (int i = 0; i < SIZE; ++i) {
94              assertEquals(i, q.size());              assertEquals(i, q.size());
95              q.add(new Integer(i));              q.add(new Integer(i));
96          }          }
97      }      }
98    
99        /**
100         * offer(null) succeeds
101         */
102      public void testOfferNull(){      public void testOfferNull(){
103          try {          try {
104              LinkedList q = new LinkedList();              LinkedList q = new LinkedList();
105              q.offer(null);              q.offer(null);
106          } catch (NullPointerException ie) {          } catch (NullPointerException ie) {
107              fail("should not throw NPE");              unexpectedException();
108          }          }
109      }      }
110    
111        /**
112         * Offer succeeds
113         */
114      public void testOffer() {      public void testOffer() {
115          LinkedList q = new LinkedList();          LinkedList q = new LinkedList();
116          assertTrue(q.offer(new Integer(0)));          assertTrue(q.offer(new Integer(0)));
117          assertTrue(q.offer(new Integer(1)));          assertTrue(q.offer(new Integer(1)));
118      }      }
119    
120        /**
121         * add succeeds
122         */
123      public void testAdd(){      public void testAdd(){
124          LinkedList q = new LinkedList();          LinkedList q = new LinkedList();
125          for (int i = 0; i < N; ++i) {          for (int i = 0; i < SIZE; ++i) {
126              assertEquals(i, q.size());              assertEquals(i, q.size());
127              assertTrue(q.add(new Integer(i)));              assertTrue(q.add(new Integer(i)));
128          }          }
129      }      }
130    
131        /**
132         * addAll(null) throws NPE
133         */
134      public void testAddAll1(){      public void testAddAll1(){
135          try {          try {
136              LinkedList q = new LinkedList();              LinkedList q = new LinkedList();
137              q.addAll(null);              q.addAll(null);
138              fail("Cannot add null collection");              shouldThrow();
139          }          }
140          catch (NullPointerException success) {}          catch (NullPointerException success) {}
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 {
148              Integer[] empty = new Integer[0];              Integer[] empty = new Integer[0];
149              Integer[] ints = new Integer[N];              Integer[] ints = new Integer[SIZE];
150              for (int i = 0; i < N; ++i)              for (int i = 0; i < SIZE; ++i)
151                  ints[i] = new Integer(i);                  ints[i] = new Integer(i);
152              LinkedList q = new LinkedList();              LinkedList q = new LinkedList();
153              assertFalse(q.addAll(Arrays.asList(empty)));              assertFalse(q.addAll(Arrays.asList(empty)));
154              assertTrue(q.addAll(Arrays.asList(ints)));              assertTrue(q.addAll(Arrays.asList(ints)));
155              for (int i = 0; i < N; ++i)              for (int i = 0; i < SIZE; ++i)
156                  assertEquals(ints[i], q.poll());                  assertEquals(ints[i], q.poll());
157          }          }
158          finally {}          finally {}
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 = fullQueue(N);          LinkedList q = populatedQueue(SIZE);
194          for (int i = 0; i < N; ++i) {          for (int i = 0; i < SIZE; ++i) {
195              assertEquals(i, ((Integer)q.poll()).intValue());              assertEquals(i, ((Integer)q.poll()).intValue());
196          }          }
197          assertNull(q.poll());          assertNull(q.poll());
198      }      }
199    
200        /**
201         *  peek returns next element, or null if empty
202         */
203      public void testPeek(){      public void testPeek(){
204          LinkedList q = fullQueue(N);          LinkedList q = populatedQueue(SIZE);
205          for (int i = 0; i < N; ++i) {          for (int i = 0; i < SIZE; ++i) {
206              assertEquals(i, ((Integer)q.peek()).intValue());              assertEquals(i, ((Integer)q.peek()).intValue());
207              q.poll();              q.poll();
208              assertTrue(q.peek() == null ||              assertTrue(q.peek() == null ||
# Line 151  Line 211 
211          assertNull(q.peek());          assertNull(q.peek());
212      }      }
213    
214        /**
215         * element returns next element, or throws NSEE if empty
216         */
217      public void testElement(){      public void testElement(){
218          LinkedList q = fullQueue(N);          LinkedList q = populatedQueue(SIZE);
219          for (int i = 0; i < N; ++i) {          for (int i = 0; i < SIZE; ++i) {
220              assertEquals(i, ((Integer)q.element()).intValue());              assertEquals(i, ((Integer)q.element()).intValue());
221              q.poll();              q.poll();
222          }          }
223          try {          try {
224              q.element();              q.element();
225              fail("no such element");              shouldThrow();
226          }          }
227          catch (NoSuchElementException success) {}          catch (NoSuchElementException success) {}
228      }      }
229    
230        /**
231         *  remove removes next element, or throws NSEE if empty
232         */
233      public void testRemove(){      public void testRemove(){
234          LinkedList q = fullQueue(N);          LinkedList q = populatedQueue(SIZE);
235          for (int i = 0; i < N; ++i) {          for (int i = 0; i < SIZE; ++i) {
236              assertEquals(i, ((Integer)q.remove()).intValue());              assertEquals(i, ((Integer)q.remove()).intValue());
237          }          }
238          try {          try {
239              q.remove();              q.remove();
240              fail("remove should throw");              shouldThrow();
241          } catch (NoSuchElementException success){          } catch (NoSuchElementException success){
242          }          }
243      }      }
244    
245        /**
246         * remove(x) removes x and returns true if present
247         */
248      public void testRemoveElement(){      public void testRemoveElement(){
249          LinkedList q = fullQueue(N);          LinkedList q = populatedQueue(SIZE);
250          for (int i = 1; i < N; i+=2) {          for (int i = 1; i < SIZE; i+=2) {
251              assertTrue(q.remove(new Integer(i)));              assertTrue(q.remove(new Integer(i)));
252          }          }
253          for (int i = 0; i < N; i+=2) {          for (int i = 0; i < SIZE; i+=2) {
254              assertTrue(q.remove(new Integer(i)));              assertTrue(q.remove(new Integer(i)));
255              assertFalse(q.remove(new Integer(i+1)));              assertFalse(q.remove(new Integer(i+1)));
256          }          }
257          assertTrue(q.isEmpty());          assertTrue(q.isEmpty());
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 = fullQueue(N);          LinkedList q = populatedQueue(SIZE);
265          for (int i = 0; i < N; ++i) {          for (int i = 0; i < SIZE; ++i) {
266              assertTrue(q.contains(new Integer(i)));              assertTrue(q.contains(new Integer(i)));
267              q.poll();              q.poll();
268              assertFalse(q.contains(new Integer(i)));              assertFalse(q.contains(new Integer(i)));
269          }          }
270      }      }
271    
272        /**
273         * clear removes all elements
274         */
275      public void testClear(){      public void testClear(){
276          LinkedList q = fullQueue(N);          LinkedList q = populatedQueue(SIZE);
277          q.clear();          q.clear();
278          assertTrue(q.isEmpty());          assertTrue(q.isEmpty());
279          assertEquals(0, q.size());          assertEquals(0, q.size());
# Line 208  Line 283 
283          assertTrue(q.isEmpty());          assertTrue(q.isEmpty());
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 = fullQueue(N);          LinkedList q = populatedQueue(SIZE);
291          LinkedList p = new LinkedList();          LinkedList p = new LinkedList();
292          for (int i = 0; i < N; ++i) {          for (int i = 0; i < SIZE; ++i) {
293              assertTrue(q.containsAll(p));              assertTrue(q.containsAll(p));
294              assertFalse(p.containsAll(q));              assertFalse(p.containsAll(q));
295              p.add(new Integer(i));              p.add(new Integer(i));
# Line 219  Line 297 
297          assertTrue(p.containsAll(q));          assertTrue(p.containsAll(q));
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 = fullQueue(N);          LinkedList q = populatedQueue(SIZE);
305          LinkedList p = fullQueue(N);          LinkedList p = populatedQueue(SIZE);
306          for (int i = 0; i < N; ++i) {          for (int i = 0; i < SIZE; ++i) {
307              boolean changed = q.retainAll(p);              boolean changed = q.retainAll(p);
308              if (i == 0)              if (i == 0)
309                  assertFalse(changed);                  assertFalse(changed);
# Line 230  Line 311 
311                  assertTrue(changed);                  assertTrue(changed);
312    
313              assertTrue(q.containsAll(p));              assertTrue(q.containsAll(p));
314              assertEquals(N-i, q.size());              assertEquals(SIZE-i, q.size());
315              p.remove();              p.remove();
316          }          }
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 < N; ++i) {          for (int i = 1; i < SIZE; ++i) {
324              LinkedList q = fullQueue(N);              LinkedList q = populatedQueue(SIZE);
325              LinkedList p = fullQueue(i);              LinkedList p = populatedQueue(i);
326              assertTrue(q.removeAll(p));              assertTrue(q.removeAll(p));
327              assertEquals(N-i, q.size());              assertEquals(SIZE-i, q.size());
328              for (int j = 0; j < i; ++j) {              for (int j = 0; j < i; ++j) {
329                  Integer I = (Integer)(p.remove());                  Integer I = (Integer)(p.remove());
330                  assertFalse(q.contains(I));                  assertFalse(q.contains(I));
# Line 248  Line 332 
332          }          }
333      }      }
334    
335        /**
336         *  toArray contains all elements
337         */
338      public void testToArray(){      public void testToArray(){
339          LinkedList q = fullQueue(N);          LinkedList q = populatedQueue(SIZE);
340          Object[] o = q.toArray();          Object[] o = q.toArray();
341          Arrays.sort(o);          Arrays.sort(o);
342          for(int i = 0; i < o.length; i++)          for(int i = 0; i < o.length; i++)
343              assertEquals(o[i], q.poll());              assertEquals(o[i], q.poll());
344      }      }
345    
346        /**
347         *  toArray(a) contains all elements
348         */
349      public void testToArray2(){      public void testToArray2(){
350          LinkedList q = fullQueue(N);          LinkedList q = populatedQueue(SIZE);
351          Integer[] ints = new Integer[N];          Integer[] ints = new Integer[SIZE];
352          ints = (Integer[])q.toArray(ints);          ints = (Integer[])q.toArray(ints);
353          Arrays.sort(ints);          Arrays.sort(ints);
354          for(int i = 0; i < ints.length; i++)          for(int i = 0; i < ints.length; i++)
355              assertEquals(ints[i], q.poll());              assertEquals(ints[i], q.poll());
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 = fullQueue(N);          LinkedList q = populatedQueue(SIZE);
387          int i = 0;          int i = 0;
388          Iterator it = q.iterator();          Iterator it = q.iterator();
389          while(it.hasNext()) {          while(it.hasNext()) {
390              assertTrue(q.contains(it.next()));              assertTrue(q.contains(it.next()));
391              ++i;              ++i;
392          }          }
393          assertEquals(i, N);          assertEquals(i, SIZE);
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();
407              assertEquals("items should come out in order", ++k, i);              assertEquals(++k, i);
408          }          }
409    
410          assertEquals("should go through 3 elements", 3, k);          assertEquals(3, k);
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      public void testToString(){       *  Descending iterator iterates through all elements
432          LinkedList q = fullQueue(N);       */
433          String s = q.toString();      public void testDescendingIterator() {
434          for (int i = 0; i < N; ++i) {          LinkedList q = populatedQueue(SIZE);
435              assertTrue(s.indexOf(String.valueOf(i)) >= 0);          int i = 0;
436          }          Iterator it = q.descendingIterator();
437      }          while(it.hasNext()) {
438                assertTrue(q.contains(it.next()));
439      public void testAddFirst(){              ++i;
         LinkedList q = fullQueue(3);  
         q.addFirst(new Integer(4));  
         assertEquals(new Integer(4),q.get(0));  
440      }      }
441            assertEquals(i, SIZE);
442      public void testAddLast(){          assertFalse(it.hasNext());
443          LinkedList q = fullQueue(3);          try {
444          q.addLast(new Integer(3));              it.next();
445          assertEquals(new Integer(3),q.get(3));          } catch(NoSuchElementException success) {
446      }      }
   
     public void testGetFirst() {  
         LinkedList q = fullQueue(3);  
         assertEquals(new Integer(0),q.getFirst());  
447      }      }
448    
449      public void testGetLast() {      /**
450          LinkedList q = fullQueue(3);       *  Descending iterator ordering is reverse FIFO
451          assertEquals(new Integer(2),q.getLast());       */
452        public void testDescendingIteratorOrdering() {
453            final LinkedList q = new LinkedList();
454            q.add(new Integer(3));
455            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      public void testIndexOf(){          assertEquals(3, k);
         LinkedList q = fullQueue(3);  
         assertEquals(0,q.indexOf(new Integer(0)));  
         assertEquals(1,q.indexOf(new Integer(1)));  
         assertEquals(2,q.indexOf(new Integer(2)));  
         assertEquals(-1, q.indexOf("not there"));  
464      }      }
465    
466      public void testLastIndexOf(){      /**
467          LinkedList q = fullQueue(3);       * descendingIterator.remove removes current element
468         */
469        public void testDescendingIteratorRemove () {
470            final LinkedList q = new LinkedList();
471            q.add(new Integer(3));
472          q.add(new Integer(2));          q.add(new Integer(2));
473          assertEquals(3,q.lastIndexOf(new Integer(2)));          q.add(new Integer(1));
474          assertEquals(-1, q.lastIndexOf("not there"));          Iterator it = q.descendingIterator();
475      }          it.next();
476            it.remove();
477      public void testSet(){          it = q.descendingIterator();
478          LinkedList q = fullQueue(3);          assertEquals(it.next(), new Integer(2));
479          q.set(0,(new Integer(1)));          assertEquals(it.next(), new Integer(3));
480          assertFalse(q.contains(new Integer(0)));          assertFalse(it.hasNext());
         assertEquals(new Integer(1), q.get(0));  
481      }      }
482    
483    
484      public void testGetFirst_NoSuchElementException(){      /**
485          try {       * toString contains toStrings of elements
486              LinkedList l = new LinkedList();       */
487              l.getFirst();      public void testToString() {
488              fail("First Element");          LinkedList q = populatedQueue(SIZE);
489            String s = q.toString();
490            for (int i = 0; i < SIZE; ++i) {
491                assertTrue(s.indexOf(String.valueOf(i)) >= 0);
492          }          }
         catch(NoSuchElementException success) {}  
493      }      }
494    
495      public void testRemoveFirst() {      /**
496          try {       * peek returns element inserted with addFirst
497              LinkedList l = new LinkedList();       */
498              l.removeFirst();      public void testAddFirst() {
499              fail("R: First Element");          LinkedList q = populatedQueue(3);
500          }          q.addFirst(four);
501          catch(NoSuchElementException success) {}          assertEquals(four,q.peek());
502      }      }
503    
504      public void testRemoveLast() {      /**
505          try {       * peekFirst returns element inserted with push
506              LinkedList l = new LinkedList();       */
507              l.removeLast();      public void testPush() {
508              fail("R: Last Element");          LinkedList q = populatedQueue(3);
509          }          q.pollLast();
510          catch(NoSuchElementException success) {}          q.push(four);
511            assertEquals(four,q.peekFirst());
512      }      }
513    
514      public void testGetLast_NoSuchElementException(){      /**
515          try {       *  pop removes next element, or throws NSEE if empty
516              LinkedList l = new LinkedList();       */
517              l.getLast();      public void testPop() {
518              fail("Last Element");          LinkedList q = populatedQueue(SIZE);
519          }          for (int i = 0; i < SIZE; ++i) {
520          catch(NoSuchElementException success) {}              assertEquals(i, ((Integer)q.pop()).intValue());
521      }      }
   
   
     public void testAddAll_NullPointerException(){  
522          try {          try {
523              LinkedList l = new LinkedList();              q.pop();
524              l.addAll((Collection)null);              shouldThrow();
525              fail("Add All Failed");          } catch (NoSuchElementException success){
526          }          }
         catch(NullPointerException success){}  
527      }      }
528    
529        /**
530      public void testAddAll1_OutOfBounds() {       * OfferFirst succeeds
531          try {       */
532              LinkedList l = new LinkedList();      public void testOfferFirst() {
533              l.addAll(4,new LinkedList());          LinkedList q = new LinkedList();
534              fail("boolean addAll(int, Collection) should throw IndexOutOfBoundsException");          assertTrue(q.offerFirst(new Integer(0)));
535          }          assertTrue(q.offerFirst(new Integer(1)));
         catch(IndexOutOfBoundsException  success) {}  
536      }      }
537    
538        /**
539      public void testAddAll2_IndexOutOfBoundsException() {       * OfferLast succeeds
540          try {       */
541              LinkedList l = new LinkedList();      public void testOfferLast() {
542              l.add(new Object());          LinkedList q = new LinkedList();
543              LinkedList m = new LinkedList();          assertTrue(q.offerLast(new Integer(0)));
544              m.add(new Object());          assertTrue(q.offerLast(new Integer(1)));
             l.addAll(4,m);  
             fail("Add All Failed " + l.size());  
         }catch(IndexOutOfBoundsException  success) {}  
545      }      }
546    
547      public void testAddAll4_BadIndex() {      /**
548          try {       *  pollLast succeeds unless empty
549              LinkedList l = new LinkedList();       */
550              l.add(new Object());      public void testPollLast() {
551              LinkedList m = new LinkedList();          LinkedList q = populatedQueue(SIZE);
552              m.add(new Object());          for (int i = SIZE-1; i >= 0; --i) {
553              l.addAll(-1,m);              assertEquals(i, ((Integer)q.pollLast()).intValue());
             fail("Add All Failed " + l.size());  
         }catch(IndexOutOfBoundsException  success){}  
554      }      }
555            assertNull(q.pollLast());
     public void testget1() {  
         try {  
             LinkedList l = new LinkedList();  
             l.add(new Object());  
             l.get(-1);  
             fail("get Failed - l.get(-1)");  
         }catch(IndexOutOfBoundsException  success) {}  
556      }      }
557    
558      public void testget2() {      /**
559          try {       *  peekFirst returns next element, or null if empty
560              LinkedList l = new LinkedList();       */
561              l.add(new Object());      public void testPeekFirst() {
562              l.get(5);          LinkedList q = populatedQueue(SIZE);
563              fail("get Failed - l.get(5) l.size(): " + l.size());          for (int i = 0; i < SIZE; ++i) {
564          }catch(IndexOutOfBoundsException  success){}              assertEquals(i, ((Integer)q.peekFirst()).intValue());
565                q.pollFirst();
566                assertTrue(q.peekFirst() == null ||
567                           i != ((Integer)q.peekFirst()).intValue());
568      }      }
569            assertNull(q.peekFirst());
     public void testset1() {  
         try {  
             LinkedList l = new LinkedList();  
             l.add(new Object());  
             l.set(-1,new Object());  
             fail("set failed - l.set(-1,...)" + l.size());  
         }catch(IndexOutOfBoundsException  success){}  
570      }      }
571    
     public void testset2() {  
         try {  
             LinkedList l = new LinkedList();  
             l.add(new Object());  
             l.set(5,new Object());  
             fail("set failed = l.set(5,..) l.size():" + l.size());  
         }catch(IndexOutOfBoundsException  success){}  
     }  
572    
573      public void testadd1() {      /**
574          try {       *  peekLast returns next element, or null if empty
575              LinkedList l = new LinkedList();       */
576              l.add(new Object());      public void testPeekLast() {
577              l.add(-1,new Object());          LinkedList q = populatedQueue(SIZE);
578              fail("Add Failed - l.add(-1) l.size(): " + l.size());          for (int i = SIZE-1; i >= 0; --i) {
579          }catch(IndexOutOfBoundsException  success){}              assertEquals(i, ((Integer)q.peekLast()).intValue());
580                q.pollLast();
581                assertTrue(q.peekLast() == null ||
582                           i != ((Integer)q.peekLast()).intValue());
583            }
584            assertNull(q.peekLast());
585        }
586    
587        public void testFirstElement() {
588            LinkedList q = populatedQueue(SIZE);
589            for (int i = 0; i < SIZE; ++i) {
590                assertEquals(i, ((Integer)q.getFirst()).intValue());
591                q.pollFirst();
592      }      }
   
     public void add2(){  
593          try {          try {
594              LinkedList l = new LinkedList();              q.getFirst();
595              l.add(new Object());              shouldThrow();
             l.add(5,new Object());  
             fail("Add Failed  l.add(f,...)");  
         }catch(IndexOutOfBoundsException  success) {}  
596      }      }
597            catch (NoSuchElementException success) {}
     public void testremove(){  
         try {  
             LinkedList l = new LinkedList();  
             l.add(new Object());  
             l.remove(-1);  
             fail("Remove Failed l.remove(-1); l.size():" + l.size());  
         }catch(IndexOutOfBoundsException  success){}  
598      }      }
599    
600      public void testremove1(){      /**
601          try {       *  getLast returns next element, or throws NSEE if empty
602              LinkedList l = new LinkedList();       */
603              l.add(new Object());      public void testLastElement() {
604              l.remove(5);          LinkedList q = populatedQueue(SIZE);
605              fail("Remove Failed l.remove(5); l.size():" + l.size());          for (int i = SIZE-1; i >= 0; --i) {
606          }catch(IndexOutOfBoundsException  success){}              assertEquals(i, ((Integer)q.getLast()).intValue());
607                q.pollLast();
608      }      }
   
   
     public void testremove2(){  
609          try{          try{
610              LinkedList l = new LinkedList();              q.getLast();
611              l.remove();              shouldThrow();
             fail("LinkedList - Object remove() should throw a NoSuchElementException");  
         }catch(NoSuchElementException e){}  
612      }      }
613            catch (NoSuchElementException success) {}
614      public void testlistIt1() {          assertNull(q.peekLast());
         try {  
             LinkedList l = new LinkedList();  
             l.add(new Object());  
             l.listIterator(5);  
             fail("l.listIterator(5) l.size():" + l.size());  
         }catch(IndexOutOfBoundsException  success){}  
615      }      }
616    
617      public void testlistIt2() {      /**
618          try {       * removeFirstOccurrence(x) removes x and returns true if present
619              LinkedList l = new LinkedList();       */
620              l.add(new Object());      public void testRemoveFirstOccurrence() {
621              l.listIterator(-1);          LinkedList q = populatedQueue(SIZE);
622              fail("l.listIterator(-1) l.size():" + l.size());          for (int i = 1; i < SIZE; i+=2) {
623          }catch(IndexOutOfBoundsException  success){}              assertTrue(q.removeFirstOccurrence(new Integer(i)));
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)));
628      }      }
629            assertTrue(q.isEmpty());
     public void testlistIt3() {  
         try {  
             LinkedList l = new LinkedList();  
             l.add(new Object());  
             ListIterator a = l.listIterator(0);  
             l.removeFirst();  
             a.next();  
             fail("l.listIterator(-1) l.size():" + l.size());  
         }catch(ConcurrentModificationException success){}  
630      }      }
631    
632      public void testToArray_BadArg() {      /**
633          try {       * removeLastOccurrence(x) removes x and returns true if present
634              LinkedList l = new LinkedList();       */
635              l.add(new Object());      public void testRemoveLastOccurrence() {
636              Object o[] = l.toArray(null);          LinkedList q = populatedQueue(SIZE);
637              fail("l.toArray(null) did not throw an exception");          for (int i = 1; i < SIZE; i+=2) {
638          }catch(NullPointerException success){}              assertTrue(q.removeLastOccurrence(new Integer(i)));
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)));
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] );  
             fail("l.toArray(String[] f) did not throw an exception, an Integer was added");  
         }catch(ArrayStoreException  success){}  
645      }      }
646    
647  }  }

Legend:
Removed from v.1.2  
changed lines
  Added in v.1.10

Doug Lea
ViewVC Help
Powered by ViewVC 1.0.8