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

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

Parent Directory Parent Directory | Revision Log Revision Log


Revision 1.3 - (view) (download)

1 : dl 1.1 /*
2 :     * Written by members of JCP JSR-166 Expert Group and released to the
3 :     * public domain. Use, modify, and redistribute this code in any way
4 :     * without acknowledgement. Other contributors include Andrew Wright,
5 :     * Jeffrey Hayes, Pat Fischer, Mike Judd.
6 :     */
7 :    
8 :     import junit.framework.*;
9 :     import java.util.*;
10 :     import java.util.concurrent.*;
11 :    
12 : dl 1.3 public class LinkedListTest extends JSR166TestCase {
13 : dl 1.1 public static void main(String[] args) {
14 :     junit.textui.TestRunner.run (suite());
15 :     }
16 :    
17 :     public static Test suite() {
18 :     return new TestSuite(LinkedListTest.class);
19 :     }
20 :    
21 :     /**
22 :     * Create a queue of given size containing consecutive
23 :     * Integers 0 ... n.
24 :     */
25 : dl 1.3 private LinkedList populatedQueue(int n) {
26 : dl 1.1 LinkedList q = new LinkedList();
27 :     assertTrue(q.isEmpty());
28 :     for(int i = 0; i < n; ++i)
29 :     assertTrue(q.offer(new Integer(i)));
30 :     assertFalse(q.isEmpty());
31 :     assertEquals(n, q.size());
32 :     return q;
33 :     }
34 :    
35 :     public void testConstructor1(){
36 :     assertEquals(0, new LinkedList().size());
37 :     }
38 :    
39 :     public void testConstructor3() {
40 :     try {
41 :     LinkedList q = new LinkedList((Collection)null);
42 :     fail("Cannot make from null collection");
43 :     }
44 :     catch (NullPointerException success) {}
45 :     }
46 :    
47 :     public void testConstructor6(){
48 :     try {
49 : dl 1.3 Integer[] ints = new Integer[SIZE];
50 :     for (int i = 0; i < SIZE; ++i)
51 : dl 1.1 ints[i] = new Integer(i);
52 :     LinkedList q = new LinkedList(Arrays.asList(ints));
53 : dl 1.3 for (int i = 0; i < SIZE; ++i)
54 : dl 1.1 assertEquals(ints[i], q.poll());
55 :     }
56 :     finally {}
57 :     }
58 :    
59 :     public void testEmpty() {
60 :     LinkedList q = new LinkedList();
61 :     assertTrue(q.isEmpty());
62 :     q.add(new Integer(1));
63 :     assertFalse(q.isEmpty());
64 :     q.add(new Integer(2));
65 :     q.remove();
66 :     q.remove();
67 :     assertTrue(q.isEmpty());
68 :     }
69 :    
70 :     public void testSize() {
71 : dl 1.3 LinkedList q = populatedQueue(SIZE);
72 :     for (int i = 0; i < SIZE; ++i) {
73 :     assertEquals(SIZE-i, q.size());
74 : dl 1.1 q.remove();
75 :     }
76 : dl 1.3 for (int i = 0; i < SIZE; ++i) {
77 : dl 1.1 assertEquals(i, q.size());
78 :     q.add(new Integer(i));
79 :     }
80 :     }
81 :    
82 :     public void testOfferNull(){
83 :     try {
84 :     LinkedList q = new LinkedList();
85 :     q.offer(null);
86 :     } catch (NullPointerException ie) {
87 :     fail("should not throw NPE");
88 :     }
89 :     }
90 :    
91 :     public void testOffer() {
92 :     LinkedList q = new LinkedList();
93 :     assertTrue(q.offer(new Integer(0)));
94 :     assertTrue(q.offer(new Integer(1)));
95 :     }
96 :    
97 :     public void testAdd(){
98 :     LinkedList q = new LinkedList();
99 : dl 1.3 for (int i = 0; i < SIZE; ++i) {
100 : dl 1.1 assertEquals(i, q.size());
101 :     assertTrue(q.add(new Integer(i)));
102 :     }
103 :     }
104 :    
105 :     public void testAddAll1(){
106 :     try {
107 :     LinkedList q = new LinkedList();
108 :     q.addAll(null);
109 :     fail("Cannot add null collection");
110 :     }
111 :     catch (NullPointerException success) {}
112 :     }
113 :    
114 :     public void testAddAll5(){
115 :     try {
116 :     Integer[] empty = new Integer[0];
117 : dl 1.3 Integer[] ints = new Integer[SIZE];
118 :     for (int i = 0; i < SIZE; ++i)
119 : dl 1.1 ints[i] = new Integer(i);
120 :     LinkedList q = new LinkedList();
121 :     assertFalse(q.addAll(Arrays.asList(empty)));
122 :     assertTrue(q.addAll(Arrays.asList(ints)));
123 : dl 1.3 for (int i = 0; i < SIZE; ++i)
124 : dl 1.1 assertEquals(ints[i], q.poll());
125 :     }
126 :     finally {}
127 :     }
128 :    
129 :     public void testPoll(){
130 : dl 1.3 LinkedList q = populatedQueue(SIZE);
131 :     for (int i = 0; i < SIZE; ++i) {
132 : dl 1.1 assertEquals(i, ((Integer)q.poll()).intValue());
133 :     }
134 :     assertNull(q.poll());
135 :     }
136 :    
137 :     public void testPeek(){
138 : dl 1.3 LinkedList q = populatedQueue(SIZE);
139 :     for (int i = 0; i < SIZE; ++i) {
140 : dl 1.1 assertEquals(i, ((Integer)q.peek()).intValue());
141 :     q.poll();
142 :     assertTrue(q.peek() == null ||
143 :     i != ((Integer)q.peek()).intValue());
144 :     }
145 :     assertNull(q.peek());
146 :     }
147 :    
148 :     public void testElement(){
149 : dl 1.3 LinkedList q = populatedQueue(SIZE);
150 :     for (int i = 0; i < SIZE; ++i) {
151 : dl 1.1 assertEquals(i, ((Integer)q.element()).intValue());
152 :     q.poll();
153 :     }
154 :     try {
155 :     q.element();
156 :     fail("no such element");
157 :     }
158 :     catch (NoSuchElementException success) {}
159 :     }
160 :    
161 :     public void testRemove(){
162 : dl 1.3 LinkedList q = populatedQueue(SIZE);
163 :     for (int i = 0; i < SIZE; ++i) {
164 : dl 1.1 assertEquals(i, ((Integer)q.remove()).intValue());
165 :     }
166 :     try {
167 :     q.remove();
168 :     fail("remove should throw");
169 :     } catch (NoSuchElementException success){
170 :     }
171 :     }
172 :    
173 :     public void testRemoveElement(){
174 : dl 1.3 LinkedList q = populatedQueue(SIZE);
175 :     for (int i = 1; i < SIZE; i+=2) {
176 : dl 1.1 assertTrue(q.remove(new Integer(i)));
177 :     }
178 : dl 1.3 for (int i = 0; i < SIZE; i+=2) {
179 : dl 1.1 assertTrue(q.remove(new Integer(i)));
180 :     assertFalse(q.remove(new Integer(i+1)));
181 :     }
182 : dl 1.2 assertTrue(q.isEmpty());
183 : dl 1.1 }
184 :    
185 :     public void testContains(){
186 : dl 1.3 LinkedList q = populatedQueue(SIZE);
187 :     for (int i = 0; i < SIZE; ++i) {
188 : dl 1.1 assertTrue(q.contains(new Integer(i)));
189 :     q.poll();
190 :     assertFalse(q.contains(new Integer(i)));
191 :     }
192 :     }
193 :    
194 :     public void testClear(){
195 : dl 1.3 LinkedList q = populatedQueue(SIZE);
196 : dl 1.1 q.clear();
197 :     assertTrue(q.isEmpty());
198 :     assertEquals(0, q.size());
199 :     q.add(new Integer(1));
200 :     assertFalse(q.isEmpty());
201 :     q.clear();
202 :     assertTrue(q.isEmpty());
203 :     }
204 :    
205 :     public void testContainsAll(){
206 : dl 1.3 LinkedList q = populatedQueue(SIZE);
207 : dl 1.1 LinkedList p = new LinkedList();
208 : dl 1.3 for (int i = 0; i < SIZE; ++i) {
209 : dl 1.1 assertTrue(q.containsAll(p));
210 :     assertFalse(p.containsAll(q));
211 :     p.add(new Integer(i));
212 :     }
213 :     assertTrue(p.containsAll(q));
214 :     }
215 :    
216 :     public void testRetainAll(){
217 : dl 1.3 LinkedList q = populatedQueue(SIZE);
218 :     LinkedList p = populatedQueue(SIZE);
219 :     for (int i = 0; i < SIZE; ++i) {
220 : dl 1.1 boolean changed = q.retainAll(p);
221 :     if (i == 0)
222 :     assertFalse(changed);
223 :     else
224 :     assertTrue(changed);
225 :    
226 :     assertTrue(q.containsAll(p));
227 : dl 1.3 assertEquals(SIZE-i, q.size());
228 : dl 1.1 p.remove();
229 :     }
230 :     }
231 :    
232 :     public void testRemoveAll(){
233 : dl 1.3 for (int i = 1; i < SIZE; ++i) {
234 :     LinkedList q = populatedQueue(SIZE);
235 :     LinkedList p = populatedQueue(i);
236 : dl 1.1 assertTrue(q.removeAll(p));
237 : dl 1.3 assertEquals(SIZE-i, q.size());
238 : dl 1.1 for (int j = 0; j < i; ++j) {
239 :     Integer I = (Integer)(p.remove());
240 :     assertFalse(q.contains(I));
241 :     }
242 :     }
243 :     }
244 :    
245 :     public void testToArray(){
246 : dl 1.3 LinkedList q = populatedQueue(SIZE);
247 : dl 1.1 Object[] o = q.toArray();
248 :     Arrays.sort(o);
249 :     for(int i = 0; i < o.length; i++)
250 :     assertEquals(o[i], q.poll());
251 :     }
252 :    
253 :     public void testToArray2(){
254 : dl 1.3 LinkedList q = populatedQueue(SIZE);
255 :     Integer[] ints = new Integer[SIZE];
256 : dl 1.1 ints = (Integer[])q.toArray(ints);
257 :     Arrays.sort(ints);
258 :     for(int i = 0; i < ints.length; i++)
259 :     assertEquals(ints[i], q.poll());
260 :     }
261 :    
262 :     public void testIterator(){
263 : dl 1.3 LinkedList q = populatedQueue(SIZE);
264 : dl 1.1 int i = 0;
265 :     Iterator it = q.iterator();
266 :     while(it.hasNext()) {
267 :     assertTrue(q.contains(it.next()));
268 :     ++i;
269 :     }
270 : dl 1.3 assertEquals(i, SIZE);
271 : dl 1.1 }
272 :    
273 :     public void testIteratorOrdering() {
274 :    
275 :     final LinkedList q = new LinkedList();
276 :    
277 :     q.add(new Integer(1));
278 :     q.add(new Integer(2));
279 :     q.add(new Integer(3));
280 :    
281 :     int k = 0;
282 :     for (Iterator it = q.iterator(); it.hasNext();) {
283 :     int i = ((Integer)(it.next())).intValue();
284 :     assertEquals("items should come out in order", ++k, i);
285 :     }
286 :    
287 :     assertEquals("should go through 3 elements", 3, k);
288 :     }
289 :    
290 :     public void testIteratorRemove () {
291 :     final LinkedList q = new LinkedList();
292 :    
293 :     q.add(new Integer(1));
294 :     q.add(new Integer(2));
295 :     q.add(new Integer(3));
296 :    
297 :     Iterator it = q.iterator();
298 :     it.next();
299 :     it.remove();
300 :    
301 :     it = q.iterator();
302 :     assertEquals(it.next(), new Integer(2));
303 :     assertEquals(it.next(), new Integer(3));
304 :     assertFalse(it.hasNext());
305 :     }
306 :    
307 :    
308 :     public void testToString(){
309 : dl 1.3 LinkedList q = populatedQueue(SIZE);
310 : dl 1.1 String s = q.toString();
311 : dl 1.3 for (int i = 0; i < SIZE; ++i) {
312 : dl 1.1 assertTrue(s.indexOf(String.valueOf(i)) >= 0);
313 :     }
314 :     }
315 :    
316 :     public void testAddFirst(){
317 : dl 1.3 LinkedList q = populatedQueue(3);
318 : dl 1.1 q.addFirst(new Integer(4));
319 :     assertEquals(new Integer(4),q.get(0));
320 :     }
321 :    
322 :     public void testAddLast(){
323 : dl 1.3 LinkedList q = populatedQueue(3);
324 : dl 1.1 q.addLast(new Integer(3));
325 :     assertEquals(new Integer(3),q.get(3));
326 :     }
327 :    
328 :     public void testGetFirst() {
329 : dl 1.3 LinkedList q = populatedQueue(3);
330 : dl 1.1 assertEquals(new Integer(0),q.getFirst());
331 :     }
332 :    
333 :     public void testGetLast() {
334 : dl 1.3 LinkedList q = populatedQueue(3);
335 : dl 1.1 assertEquals(new Integer(2),q.getLast());
336 :     }
337 :    
338 :     public void testIndexOf(){
339 : dl 1.3 LinkedList q = populatedQueue(3);
340 : dl 1.1 assertEquals(0,q.indexOf(new Integer(0)));
341 :     assertEquals(1,q.indexOf(new Integer(1)));
342 :     assertEquals(2,q.indexOf(new Integer(2)));
343 :     assertEquals(-1, q.indexOf("not there"));
344 :     }
345 :    
346 :     public void testLastIndexOf(){
347 : dl 1.3 LinkedList q = populatedQueue(3);
348 : dl 1.1 q.add(new Integer(2));
349 :     assertEquals(3,q.lastIndexOf(new Integer(2)));
350 :     assertEquals(-1, q.lastIndexOf("not there"));
351 :     }
352 :    
353 :     public void testSet(){
354 : dl 1.3 LinkedList q = populatedQueue(3);
355 : dl 1.1 q.set(0,(new Integer(1)));
356 :     assertFalse(q.contains(new Integer(0)));
357 :     assertEquals(new Integer(1), q.get(0));
358 :     }
359 :    
360 :    
361 :     public void testGetFirst_NoSuchElementException(){
362 :     try {
363 :     LinkedList l = new LinkedList();
364 :     l.getFirst();
365 :     fail("First Element");
366 :     }
367 :     catch(NoSuchElementException success) {}
368 :     }
369 :    
370 :     public void testRemoveFirst() {
371 :     try {
372 :     LinkedList l = new LinkedList();
373 :     l.removeFirst();
374 :     fail("R: First Element");
375 :     }
376 :     catch(NoSuchElementException success) {}
377 :     }
378 :    
379 :     public void testRemoveLast() {
380 :     try {
381 :     LinkedList l = new LinkedList();
382 :     l.removeLast();
383 :     fail("R: Last Element");
384 :     }
385 :     catch(NoSuchElementException success) {}
386 :     }
387 :    
388 :     public void testGetLast_NoSuchElementException(){
389 :     try {
390 :     LinkedList l = new LinkedList();
391 :     l.getLast();
392 :     fail("Last Element");
393 :     }
394 :     catch(NoSuchElementException success) {}
395 :     }
396 :    
397 :    
398 :     public void testAddAll_NullPointerException(){
399 :     try {
400 :     LinkedList l = new LinkedList();
401 :     l.addAll((Collection)null);
402 :     fail("Add All Failed");
403 :     }
404 :     catch(NullPointerException success){}
405 :     }
406 :    
407 :    
408 :     public void testAddAll1_OutOfBounds() {
409 :     try {
410 :     LinkedList l = new LinkedList();
411 :     l.addAll(4,new LinkedList());
412 :     fail("boolean addAll(int, Collection) should throw IndexOutOfBoundsException");
413 :     }
414 :     catch(IndexOutOfBoundsException success) {}
415 :     }
416 :    
417 :    
418 :     public void testAddAll2_IndexOutOfBoundsException() {
419 :     try {
420 :     LinkedList l = new LinkedList();
421 :     l.add(new Object());
422 :     LinkedList m = new LinkedList();
423 :     m.add(new Object());
424 :     l.addAll(4,m);
425 :     fail("Add All Failed " + l.size());
426 :     }catch(IndexOutOfBoundsException success) {}
427 :     }
428 :    
429 :     public void testAddAll4_BadIndex() {
430 :     try {
431 :     LinkedList l = new LinkedList();
432 :     l.add(new Object());
433 :     LinkedList m = new LinkedList();
434 :     m.add(new Object());
435 :     l.addAll(-1,m);
436 :     fail("Add All Failed " + l.size());
437 :     }catch(IndexOutOfBoundsException success){}
438 :     }
439 :    
440 :     public void testget1() {
441 :     try {
442 :     LinkedList l = new LinkedList();
443 :     l.add(new Object());
444 :     l.get(-1);
445 :     fail("get Failed - l.get(-1)");
446 :     }catch(IndexOutOfBoundsException success) {}
447 :     }
448 :    
449 :     public void testget2() {
450 :     try {
451 :     LinkedList l = new LinkedList();
452 :     l.add(new Object());
453 :     l.get(5);
454 :     fail("get Failed - l.get(5) l.size(): " + l.size());
455 :     }catch(IndexOutOfBoundsException success){}
456 :     }
457 :    
458 :     public void testset1() {
459 :     try {
460 :     LinkedList l = new LinkedList();
461 :     l.add(new Object());
462 :     l.set(-1,new Object());
463 :     fail("set failed - l.set(-1,...)" + l.size());
464 :     }catch(IndexOutOfBoundsException success){}
465 :     }
466 :    
467 :     public void testset2() {
468 :     try {
469 :     LinkedList l = new LinkedList();
470 :     l.add(new Object());
471 :     l.set(5,new Object());
472 :     fail("set failed = l.set(5,..) l.size():" + l.size());
473 :     }catch(IndexOutOfBoundsException success){}
474 :     }
475 :    
476 :     public void testadd1() {
477 :     try {
478 :     LinkedList l = new LinkedList();
479 :     l.add(new Object());
480 :     l.add(-1,new Object());
481 :     fail("Add Failed - l.add(-1) l.size(): " + l.size());
482 :     }catch(IndexOutOfBoundsException success){}
483 :     }
484 :    
485 :     public void add2(){
486 :     try {
487 :     LinkedList l = new LinkedList();
488 :     l.add(new Object());
489 :     l.add(5,new Object());
490 :     fail("Add Failed l.add(f,...)");
491 :     }catch(IndexOutOfBoundsException success) {}
492 :     }
493 :    
494 :     public void testremove(){
495 :     try {
496 :     LinkedList l = new LinkedList();
497 :     l.add(new Object());
498 :     l.remove(-1);
499 :     fail("Remove Failed l.remove(-1); l.size():" + l.size());
500 :     }catch(IndexOutOfBoundsException success){}
501 :     }
502 :    
503 :     public void testremove1(){
504 :     try {
505 :     LinkedList l = new LinkedList();
506 :     l.add(new Object());
507 :     l.remove(5);
508 :     fail("Remove Failed l.remove(5); l.size():" + l.size());
509 :     }catch(IndexOutOfBoundsException success){}
510 :     }
511 :    
512 :    
513 :     public void testremove2(){
514 :     try{
515 :     LinkedList l = new LinkedList();
516 :     l.remove();
517 :     fail("LinkedList - Object remove() should throw a NoSuchElementException");
518 :     }catch(NoSuchElementException e){}
519 :     }
520 :    
521 :     public void testlistIt1() {
522 :     try {
523 :     LinkedList l = new LinkedList();
524 :     l.add(new Object());
525 :     l.listIterator(5);
526 :     fail("l.listIterator(5) l.size():" + l.size());
527 :     }catch(IndexOutOfBoundsException success){}
528 :     }
529 :    
530 :     public void testlistIt2() {
531 :     try {
532 :     LinkedList l = new LinkedList();
533 :     l.add(new Object());
534 :     l.listIterator(-1);
535 :     fail("l.listIterator(-1) l.size():" + l.size());
536 :     }catch(IndexOutOfBoundsException success){}
537 :     }
538 :    
539 :     public void testlistIt3() {
540 :     try {
541 :     LinkedList l = new LinkedList();
542 :     l.add(new Object());
543 :     ListIterator a = l.listIterator(0);
544 :     l.removeFirst();
545 :     a.next();
546 :     fail("l.listIterator(-1) l.size():" + l.size());
547 :     }catch(ConcurrentModificationException success){}
548 :     }
549 :    
550 :     public void testToArray_BadArg() {
551 :     try {
552 :     LinkedList l = new LinkedList();
553 :     l.add(new Object());
554 :     Object o[] = l.toArray(null);
555 :     fail("l.toArray(null) did not throw an exception");
556 :     }catch(NullPointerException success){}
557 :     }
558 :    
559 :     public void testToArray1_BadArg() {
560 :     try {
561 :     LinkedList l = new LinkedList();
562 :     l.add(new Integer(5));
563 :     Object o[] = l.toArray(new String[10] );
564 :     fail("l.toArray(String[] f) did not throw an exception, an Integer was added");
565 :     }catch(ArrayStoreException success){}
566 :     }
567 :    
568 :     }

Doug Lea
ViewVC Help
Powered by ViewVC 1.0.8