[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.3, Sun Sep 14 20:42:40 2003 UTC revision 1.4, Sat Sep 20 18:20:08 2003 UTC
# Line 32  Line 32 
32          return q;          return q;
33      }      }
34    
35        /**
36         *
37         */
38      public void testConstructor1(){      public void testConstructor1(){
39          assertEquals(0, new LinkedList().size());          assertEquals(0, new LinkedList().size());
40      }      }
41    
42        /**
43         *
44         */
45      public void testConstructor3() {      public void testConstructor3() {
46          try {          try {
47              LinkedList q = new LinkedList((Collection)null);              LinkedList q = new LinkedList((Collection)null);
48              fail("Cannot make from null collection");              shouldThrow();
49          }          }
50          catch (NullPointerException success) {}          catch (NullPointerException success) {}
51      }      }
52    
53        /**
54         *
55         */
56      public void testConstructor6(){      public void testConstructor6(){
57          try {          try {
58              Integer[] ints = new Integer[SIZE];              Integer[] ints = new Integer[SIZE];
# Line 56  Line 65 
65          finally {}          finally {}
66      }      }
67    
68        /**
69         *
70         */
71      public void testEmpty() {      public void testEmpty() {
72          LinkedList q = new LinkedList();          LinkedList q = new LinkedList();
73          assertTrue(q.isEmpty());          assertTrue(q.isEmpty());
# Line 67  Line 79 
79          assertTrue(q.isEmpty());          assertTrue(q.isEmpty());
80      }      }
81    
82        /**
83         *
84         */
85      public void testSize() {      public void testSize() {
86          LinkedList q = populatedQueue(SIZE);          LinkedList q = populatedQueue(SIZE);
87          for (int i = 0; i < SIZE; ++i) {          for (int i = 0; i < SIZE; ++i) {
# Line 79  Line 94 
94          }          }
95      }      }
96    
97        /**
98         *
99         */
100      public void testOfferNull(){      public void testOfferNull(){
101          try {          try {
102              LinkedList q = new LinkedList();              LinkedList q = new LinkedList();
103              q.offer(null);              q.offer(null);
104          } catch (NullPointerException ie) {          } catch (NullPointerException ie) {
105              fail("should not throw NPE");              unexpectedException();
106          }          }
107      }      }
108    
109        /**
110         *
111         */
112      public void testOffer() {      public void testOffer() {
113          LinkedList q = new LinkedList();          LinkedList q = new LinkedList();
114          assertTrue(q.offer(new Integer(0)));          assertTrue(q.offer(new Integer(0)));
115          assertTrue(q.offer(new Integer(1)));          assertTrue(q.offer(new Integer(1)));
116      }      }
117    
118        /**
119         *
120         */
121      public void testAdd(){      public void testAdd(){
122          LinkedList q = new LinkedList();          LinkedList q = new LinkedList();
123          for (int i = 0; i < SIZE; ++i) {          for (int i = 0; i < SIZE; ++i) {
# Line 102  Line 126 
126          }          }
127      }      }
128    
129        /**
130         *
131         */
132      public void testAddAll1(){      public void testAddAll1(){
133          try {          try {
134              LinkedList q = new LinkedList();              LinkedList q = new LinkedList();
135              q.addAll(null);              q.addAll(null);
136              fail("Cannot add null collection");              shouldThrow();
137          }          }
138          catch (NullPointerException success) {}          catch (NullPointerException success) {}
139      }      }
140    
141        /**
142         *
143         */
144      public void testAddAll5(){      public void testAddAll5(){
145          try {          try {
146              Integer[] empty = new Integer[0];              Integer[] empty = new Integer[0];
# Line 126  Line 156 
156          finally {}          finally {}
157      }      }
158    
159        /**
160         *
161         */
162      public void testPoll(){      public void testPoll(){
163          LinkedList q = populatedQueue(SIZE);          LinkedList q = populatedQueue(SIZE);
164          for (int i = 0; i < SIZE; ++i) {          for (int i = 0; i < SIZE; ++i) {
# Line 134  Line 167 
167          assertNull(q.poll());          assertNull(q.poll());
168      }      }
169    
170        /**
171         *
172         */
173      public void testPeek(){      public void testPeek(){
174          LinkedList q = populatedQueue(SIZE);          LinkedList q = populatedQueue(SIZE);
175          for (int i = 0; i < SIZE; ++i) {          for (int i = 0; i < SIZE; ++i) {
# Line 145  Line 181 
181          assertNull(q.peek());          assertNull(q.peek());
182      }      }
183    
184        /**
185         *
186         */
187      public void testElement(){      public void testElement(){
188          LinkedList q = populatedQueue(SIZE);          LinkedList q = populatedQueue(SIZE);
189          for (int i = 0; i < SIZE; ++i) {          for (int i = 0; i < SIZE; ++i) {
# Line 153  Line 192 
192          }          }
193          try {          try {
194              q.element();              q.element();
195              fail("no such element");              shouldThrow();
196          }          }
197          catch (NoSuchElementException success) {}          catch (NoSuchElementException success) {}
198      }      }
199    
200        /**
201         *
202         */
203      public void testRemove(){      public void testRemove(){
204          LinkedList q = populatedQueue(SIZE);          LinkedList q = populatedQueue(SIZE);
205          for (int i = 0; i < SIZE; ++i) {          for (int i = 0; i < SIZE; ++i) {
# Line 165  Line 207 
207          }          }
208          try {          try {
209              q.remove();              q.remove();
210              fail("remove should throw");              shouldThrow();
211          } catch (NoSuchElementException success){          } catch (NoSuchElementException success){
212          }          }
213      }      }
214    
215        /**
216         *
217         */
218      public void testRemoveElement(){      public void testRemoveElement(){
219          LinkedList q = populatedQueue(SIZE);          LinkedList q = populatedQueue(SIZE);
220          for (int i = 1; i < SIZE; i+=2) {          for (int i = 1; i < SIZE; i+=2) {
# Line 182  Line 227 
227          assertTrue(q.isEmpty());          assertTrue(q.isEmpty());
228      }      }
229    
230        /**
231         *
232         */
233      public void testContains(){      public void testContains(){
234          LinkedList q = populatedQueue(SIZE);          LinkedList q = populatedQueue(SIZE);
235          for (int i = 0; i < SIZE; ++i) {          for (int i = 0; i < SIZE; ++i) {
# Line 191  Line 239 
239          }          }
240      }      }
241    
242        /**
243         *
244         */
245      public void testClear(){      public void testClear(){
246          LinkedList q = populatedQueue(SIZE);          LinkedList q = populatedQueue(SIZE);
247          q.clear();          q.clear();
# Line 202  Line 253 
253          assertTrue(q.isEmpty());          assertTrue(q.isEmpty());
254      }      }
255    
256        /**
257         *
258         */
259      public void testContainsAll(){      public void testContainsAll(){
260          LinkedList q = populatedQueue(SIZE);          LinkedList q = populatedQueue(SIZE);
261          LinkedList p = new LinkedList();          LinkedList p = new LinkedList();
# Line 213  Line 267 
267          assertTrue(p.containsAll(q));          assertTrue(p.containsAll(q));
268      }      }
269    
270        /**
271         *
272         */
273      public void testRetainAll(){      public void testRetainAll(){
274          LinkedList q = populatedQueue(SIZE);          LinkedList q = populatedQueue(SIZE);
275          LinkedList p = populatedQueue(SIZE);          LinkedList p = populatedQueue(SIZE);
# Line 229  Line 286 
286          }          }
287      }      }
288    
289        /**
290         *
291         */
292      public void testRemoveAll(){      public void testRemoveAll(){
293          for (int i = 1; i < SIZE; ++i) {          for (int i = 1; i < SIZE; ++i) {
294              LinkedList q = populatedQueue(SIZE);              LinkedList q = populatedQueue(SIZE);
# Line 242  Line 302 
302          }          }
303      }      }
304    
305        /**
306         *
307         */
308      public void testToArray(){      public void testToArray(){
309          LinkedList q = populatedQueue(SIZE);          LinkedList q = populatedQueue(SIZE);
310          Object[] o = q.toArray();          Object[] o = q.toArray();
# Line 250  Line 313 
313              assertEquals(o[i], q.poll());              assertEquals(o[i], q.poll());
314      }      }
315    
316        /**
317         *
318         */
319      public void testToArray2(){      public void testToArray2(){
320          LinkedList q = populatedQueue(SIZE);          LinkedList q = populatedQueue(SIZE);
321          Integer[] ints = new Integer[SIZE];          Integer[] ints = new Integer[SIZE];
# Line 259  Line 325 
325              assertEquals(ints[i], q.poll());              assertEquals(ints[i], q.poll());
326      }      }
327    
328        /**
329         *
330         */
331      public void testIterator(){      public void testIterator(){
332          LinkedList q = populatedQueue(SIZE);          LinkedList q = populatedQueue(SIZE);
333          int i = 0;          int i = 0;
# Line 270  Line 339 
339          assertEquals(i, SIZE);          assertEquals(i, SIZE);
340      }      }
341    
342        /**
343         *
344         */
345      public void testIteratorOrdering() {      public void testIteratorOrdering() {
346    
347          final LinkedList q = new LinkedList();          final LinkedList q = new LinkedList();
# Line 281  Line 353 
353          int k = 0;          int k = 0;
354          for (Iterator it = q.iterator(); it.hasNext();) {          for (Iterator it = q.iterator(); it.hasNext();) {
355              int i = ((Integer)(it.next())).intValue();              int i = ((Integer)(it.next())).intValue();
356              assertEquals("items should come out in order", ++k, i);              assertEquals(++k, i);
357          }          }
358    
359          assertEquals("should go through 3 elements", 3, k);          assertEquals(3, k);
360      }      }
361    
362        /**
363         *
364         */
365      public void testIteratorRemove () {      public void testIteratorRemove () {
366          final LinkedList q = new LinkedList();          final LinkedList q = new LinkedList();
367    
# Line 305  Line 380 
380      }      }
381    
382    
383        /**
384         *
385         */
386      public void testToString(){      public void testToString(){
387          LinkedList q = populatedQueue(SIZE);          LinkedList q = populatedQueue(SIZE);
388          String s = q.toString();          String s = q.toString();
# Line 313  Line 391 
391          }          }
392      }      }
393    
394        /**
395         *
396         */
397      public void testAddFirst(){      public void testAddFirst(){
398          LinkedList q = populatedQueue(3);          LinkedList q = populatedQueue(3);
399          q.addFirst(new Integer(4));          q.addFirst(new Integer(4));
400          assertEquals(new Integer(4),q.get(0));          assertEquals(new Integer(4),q.get(0));
401      }      }
402    
403        /**
404         *
405         */
406      public void testAddLast(){      public void testAddLast(){
407          LinkedList q = populatedQueue(3);          LinkedList q = populatedQueue(3);
408          q.addLast(new Integer(3));          q.addLast(new Integer(3));
409          assertEquals(new Integer(3),q.get(3));          assertEquals(new Integer(3),q.get(3));
410      }      }
411    
412        /**
413         *
414         */
415      public void testGetFirst() {      public void testGetFirst() {
416          LinkedList q = populatedQueue(3);          LinkedList q = populatedQueue(3);
417          assertEquals(new Integer(0),q.getFirst());          assertEquals(new Integer(0),q.getFirst());
418      }      }
419    
420        /**
421         *
422         */
423      public void testGetLast() {      public void testGetLast() {
424          LinkedList q = populatedQueue(3);          LinkedList q = populatedQueue(3);
425          assertEquals(new Integer(2),q.getLast());          assertEquals(new Integer(2),q.getLast());
426      }      }
427    
428        /**
429         *
430         */
431      public void testIndexOf(){      public void testIndexOf(){
432          LinkedList q = populatedQueue(3);          LinkedList q = populatedQueue(3);
433          assertEquals(0,q.indexOf(new Integer(0)));          assertEquals(0,q.indexOf(new Integer(0)));
# Line 343  Line 436 
436          assertEquals(-1, q.indexOf("not there"));          assertEquals(-1, q.indexOf("not there"));
437      }      }
438    
439        /**
440         *
441         */
442      public void testLastIndexOf(){      public void testLastIndexOf(){
443          LinkedList q = populatedQueue(3);          LinkedList q = populatedQueue(3);
444          q.add(new Integer(2));          q.add(new Integer(2));
# Line 350  Line 446 
446          assertEquals(-1, q.lastIndexOf("not there"));          assertEquals(-1, q.lastIndexOf("not there"));
447      }      }
448    
449        /**
450         *
451         */
452      public void testSet(){      public void testSet(){
453          LinkedList q = populatedQueue(3);          LinkedList q = populatedQueue(3);
454          q.set(0,(new Integer(1)));          q.set(0,(new Integer(1)));
# Line 358  Line 457 
457      }      }
458    
459    
460        /**
461         *
462         */
463      public void testGetFirst_NoSuchElementException(){      public void testGetFirst_NoSuchElementException(){
464          try {          try {
465              LinkedList l = new LinkedList();              LinkedList l = new LinkedList();
466              l.getFirst();              l.getFirst();
467              fail("First Element");              shouldThrow();
468          }          }
469          catch(NoSuchElementException success) {}          catch(NoSuchElementException success) {}
470      }      }
471    
472        /**
473         *
474         */
475      public void testRemoveFirst() {      public void testRemoveFirst() {
476          try {          try {
477              LinkedList l = new LinkedList();              LinkedList l = new LinkedList();
478              l.removeFirst();              l.removeFirst();
479              fail("R: First Element");              shouldThrow();
480          }          }
481          catch(NoSuchElementException success) {}          catch(NoSuchElementException success) {}
482      }      }
483    
484        /**
485         *
486         */
487      public void testRemoveLast() {      public void testRemoveLast() {
488          try {          try {
489              LinkedList l = new LinkedList();              LinkedList l = new LinkedList();
490              l.removeLast();              l.removeLast();
491              fail("R: Last Element");              shouldThrow();
492          }          }
493          catch(NoSuchElementException success) {}          catch(NoSuchElementException success) {}
494      }      }
495    
496        /**
497         *
498         */
499      public void testGetLast_NoSuchElementException(){      public void testGetLast_NoSuchElementException(){
500          try {          try {
501              LinkedList l = new LinkedList();              LinkedList l = new LinkedList();
502              l.getLast();              l.getLast();
503              fail("Last Element");              shouldThrow();
504          }          }
505          catch(NoSuchElementException success) {}          catch(NoSuchElementException success) {}
506      }      }
507    
508    
509        /**
510         *
511         */
512      public void testAddAll_NullPointerException(){      public void testAddAll_NullPointerException(){
513          try {          try {
514              LinkedList l = new LinkedList();              LinkedList l = new LinkedList();
515              l.addAll((Collection)null);              l.addAll((Collection)null);
516              fail("Add All Failed");              shouldThrow();
517          }          }
518          catch(NullPointerException success){}          catch(NullPointerException success){}
519      }      }
520    
521    
522        /**
523         *
524         */
525      public void testAddAll1_OutOfBounds() {      public void testAddAll1_OutOfBounds() {
526          try {          try {
527              LinkedList l = new LinkedList();              LinkedList l = new LinkedList();
528              l.addAll(4,new LinkedList());              l.addAll(4,new LinkedList());
529              fail("boolean addAll(int, Collection) should throw IndexOutOfBoundsException");              shouldThrow();
530          }          }
531          catch(IndexOutOfBoundsException  success) {}          catch(IndexOutOfBoundsException  success) {}
532      }      }
533    
534    
535        /**
536         *
537         */
538      public void testAddAll2_IndexOutOfBoundsException() {      public void testAddAll2_IndexOutOfBoundsException() {
539          try {          try {
540              LinkedList l = new LinkedList();              LinkedList l = new LinkedList();
# Line 422  Line 542 
542              LinkedList m = new LinkedList();              LinkedList m = new LinkedList();
543              m.add(new Object());              m.add(new Object());
544              l.addAll(4,m);              l.addAll(4,m);
545              fail("Add All Failed " + l.size());              shouldThrow();
546          }catch(IndexOutOfBoundsException  success) {}          }catch(IndexOutOfBoundsException  success) {}
547      }      }
548    
549        /**
550         *
551         */
552      public void testAddAll4_BadIndex() {      public void testAddAll4_BadIndex() {
553          try {          try {
554              LinkedList l = new LinkedList();              LinkedList l = new LinkedList();
# Line 433  Line 556 
556              LinkedList m = new LinkedList();              LinkedList m = new LinkedList();
557              m.add(new Object());              m.add(new Object());
558              l.addAll(-1,m);              l.addAll(-1,m);
559              fail("Add All Failed " + l.size());              shouldThrow();
560          }catch(IndexOutOfBoundsException  success){}          }catch(IndexOutOfBoundsException  success){}
561      }      }
562    
563        /**
564         *
565         */
566      public void testget1() {      public void testget1() {
567          try {          try {
568              LinkedList l = new LinkedList();              LinkedList l = new LinkedList();
569              l.add(new Object());              l.add(new Object());
570              l.get(-1);              l.get(-1);
571              fail("get Failed - l.get(-1)");              shouldThrow();
572          }catch(IndexOutOfBoundsException  success) {}          }catch(IndexOutOfBoundsException  success) {}
573      }      }
574    
575        /**
576         *
577         */
578      public void testget2() {      public void testget2() {
579          try {          try {
580              LinkedList l = new LinkedList();              LinkedList l = new LinkedList();
581              l.add(new Object());              l.add(new Object());
582              l.get(5);              l.get(5);
583              fail("get Failed - l.get(5) l.size(): " + l.size());              shouldThrow();
584          }catch(IndexOutOfBoundsException  success){}          }catch(IndexOutOfBoundsException  success){}
585      }      }
586    
587        /**
588         *
589         */
590      public void testset1() {      public void testset1() {
591          try {          try {
592              LinkedList l = new LinkedList();              LinkedList l = new LinkedList();
593              l.add(new Object());              l.add(new Object());
594              l.set(-1,new Object());              l.set(-1,new Object());
595              fail("set failed - l.set(-1,...)" + l.size());              shouldThrow();
596          }catch(IndexOutOfBoundsException  success){}          }catch(IndexOutOfBoundsException  success){}
597      }      }
598    
599        /**
600         *
601         */
602      public void testset2() {      public void testset2() {
603          try {          try {
604              LinkedList l = new LinkedList();              LinkedList l = new LinkedList();
605              l.add(new Object());              l.add(new Object());
606              l.set(5,new Object());              l.set(5,new Object());
607              fail("set failed = l.set(5,..) l.size():" + l.size());              shouldThrow();
608          }catch(IndexOutOfBoundsException  success){}          }catch(IndexOutOfBoundsException  success){}
609      }      }
610    
611        /**
612         *
613         */
614      public void testadd1() {      public void testadd1() {
615          try {          try {
616              LinkedList l = new LinkedList();              LinkedList l = new LinkedList();
617              l.add(new Object());              l.add(new Object());
618              l.add(-1,new Object());              l.add(-1,new Object());
619              fail("Add Failed - l.add(-1) l.size(): " + l.size());              shouldThrow();
620          }catch(IndexOutOfBoundsException  success){}          }catch(IndexOutOfBoundsException  success){}
621      }      }
622    
# Line 487  Line 625 
625              LinkedList l = new LinkedList();              LinkedList l = new LinkedList();
626              l.add(new Object());              l.add(new Object());
627              l.add(5,new Object());              l.add(5,new Object());
628              fail("Add Failed  l.add(f,...)");              shouldThrow();
629          }catch(IndexOutOfBoundsException  success) {}          }catch(IndexOutOfBoundsException  success) {}
630      }      }
631    
632        /**
633         *
634         */
635      public void testremove(){      public void testremove(){
636          try {          try {
637              LinkedList l = new LinkedList();              LinkedList l = new LinkedList();
638              l.add(new Object());              l.add(new Object());
639              l.remove(-1);              l.remove(-1);
640              fail("Remove Failed l.remove(-1); l.size():" + l.size());              shouldThrow();
641          }catch(IndexOutOfBoundsException  success){}          }catch(IndexOutOfBoundsException  success){}
642      }      }
643    
644        /**
645         *
646         */
647      public void testremove1(){      public void testremove1(){
648          try {          try {
649              LinkedList l = new LinkedList();              LinkedList l = new LinkedList();
650              l.add(new Object());              l.add(new Object());
651              l.remove(5);              l.remove(5);
652              fail("Remove Failed l.remove(5); l.size():" + l.size());              shouldThrow();
653          }catch(IndexOutOfBoundsException  success){}          }catch(IndexOutOfBoundsException  success){}
654      }      }
655    
656    
657        /**
658         *
659         */
660      public void testremove2(){      public void testremove2(){
661          try{          try{
662              LinkedList l = new LinkedList();              LinkedList l = new LinkedList();
663              l.remove();              l.remove();
664              fail("LinkedList - Object remove() should throw a NoSuchElementException");              shouldThrow();
665          }catch(NoSuchElementException e){}          }catch(NoSuchElementException e){}
666      }      }
667    
668        /**
669         *
670         */
671      public void testlistIt1() {      public void testlistIt1() {
672          try {          try {
673              LinkedList l = new LinkedList();              LinkedList l = new LinkedList();
674              l.add(new Object());              l.add(new Object());
675              l.listIterator(5);              l.listIterator(5);
676              fail("l.listIterator(5) l.size():" + l.size());              shouldThrow();
677          }catch(IndexOutOfBoundsException  success){}          }catch(IndexOutOfBoundsException  success){}
678      }      }
679    
680        /**
681         *
682         */
683      public void testlistIt2() {      public void testlistIt2() {
684          try {          try {
685              LinkedList l = new LinkedList();              LinkedList l = new LinkedList();
686              l.add(new Object());              l.add(new Object());
687              l.listIterator(-1);              l.listIterator(-1);
688              fail("l.listIterator(-1) l.size():" + l.size());              shouldThrow();
689          }catch(IndexOutOfBoundsException  success){}          }catch(IndexOutOfBoundsException  success){}
690      }      }
691    
692        /**
693         *
694         */
695      public void testlistIt3() {      public void testlistIt3() {
696          try {          try {
697              LinkedList l = new LinkedList();              LinkedList l = new LinkedList();
# Line 543  Line 699 
699              ListIterator a = l.listIterator(0);              ListIterator a = l.listIterator(0);
700              l.removeFirst();              l.removeFirst();
701              a.next();              a.next();
702              fail("l.listIterator(-1) l.size():" + l.size());              shouldThrow();
703          }catch(ConcurrentModificationException success){}          }catch(ConcurrentModificationException success){}
704      }      }
705    
706        /**
707         *
708         */
709      public void testToArray_BadArg() {      public void testToArray_BadArg() {
710          try {          try {
711              LinkedList l = new LinkedList();              LinkedList l = new LinkedList();
712              l.add(new Object());              l.add(new Object());
713              Object o[] = l.toArray(null);              Object o[] = l.toArray(null);
714              fail("l.toArray(null) did not throw an exception");              shouldThrow();
715          }catch(NullPointerException success){}          }catch(NullPointerException success){}
716      }      }
717    
718        /**
719         *
720         */
721      public void testToArray1_BadArg() {      public void testToArray1_BadArg() {
722          try {          try {
723              LinkedList l = new LinkedList();              LinkedList l = new LinkedList();
724              l.add(new Integer(5));              l.add(new Integer(5));
725              Object o[] = l.toArray(new String[10] );              Object o[] = l.toArray(new String[10] );
726              fail("l.toArray(String[] f) did not throw an exception, an Integer was added");              shouldThrow();
727          }catch(ArrayStoreException  success){}          }catch(ArrayStoreException  success){}
728      }      }
729    

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

Doug Lea
ViewVC Help
Powered by ViewVC 1.0.8