1   /*
2    *  Licensed to the Apache Software Foundation (ASF) under one or more
3    *  contributor license agreements.  See the NOTICE file distributed with
4    *  this work for additional information regarding copyright ownership.
5    *  The ASF licenses this file to You under the Apache License, Version 2.0
6    *  (the "License"); you may not use this file except in compliance with
7    *  the License.  You may obtain a copy of the License at
8    *
9    *      http://www.apache.org/licenses/LICENSE-2.0
10   *
11   *  Unless required by applicable law or agreed to in writing, software
12   *  distributed under the License is distributed on an "AS IS" BASIS,
13   *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14   *  See the License for the specific language governing permissions and
15   *  limitations under the License.
16   */
17  package org.apache.commons.collections.list;
18  
19  import java.util.ArrayList;
20  import java.util.ConcurrentModificationException;
21  import java.util.HashSet;
22  import java.util.Iterator;
23  import java.util.List;
24  import java.util.ListIterator;
25  import java.util.NoSuchElementException;
26  
27  import junit.framework.Test;
28  
29  import org.apache.commons.collections.BulkTest;
30  
31  /**
32   * Test class.
33   * 
34   * @version $Revision: 646780 $ $Date: 2008-04-10 13:48:07 +0100 (Thu, 10 Apr 2008) $
35   * 
36   * @author Rodney Waldhoff
37   * @author Simon Kitching
38   */
39  public class TestCursorableLinkedList extends TestAbstractLinkedList {
40      public TestCursorableLinkedList(String testName) {
41          super(testName);
42      }
43  
44      public static Test suite() {
45          return BulkTest.makeSuite(TestCursorableLinkedList.class);
46      }
47  
48      public static void main(String args[]) {
49          String[] testCaseName = { TestCursorableLinkedList.class.getName() };
50          junit.textui.TestRunner.main(testCaseName);
51      }
52  
53      private CursorableLinkedList list = null;
54  
55      public void setUp() {
56          list = new CursorableLinkedList();
57      }
58  
59      public List makeEmptyList() {
60          return new CursorableLinkedList();
61      }
62  
63      public void testAdd() {
64          assertEquals("[]",list.toString());
65          assertTrue(list.add(new Integer(1)));
66          assertEquals("[1]",list.toString());
67          assertTrue(list.add(new Integer(2)));
68          assertEquals("[1, 2]",list.toString());
69          assertTrue(list.add(new Integer(3)));
70          assertEquals("[1, 2, 3]",list.toString());
71          assertTrue(list.addFirst(new Integer(0)));
72          assertEquals("[0, 1, 2, 3]",list.toString());
73          assertTrue(list.addLast(new Integer(4)));
74          assertEquals("[0, 1, 2, 3, 4]",list.toString());
75          list.add(0,new Integer(-2));
76          assertEquals("[-2, 0, 1, 2, 3, 4]",list.toString());
77          list.add(1,new Integer(-1));
78          assertEquals("[-2, -1, 0, 1, 2, 3, 4]",list.toString());
79          list.add(7,new Integer(5));
80          assertEquals("[-2, -1, 0, 1, 2, 3, 4, 5]",list.toString());
81  
82          java.util.List list2 = new java.util.LinkedList();
83          list2.add("A");
84          list2.add("B");
85          list2.add("C");
86  
87          assertTrue(list.addAll(list2));
88          assertEquals("[-2, -1, 0, 1, 2, 3, 4, 5, A, B, C]",list.toString());
89          assertTrue(list.addAll(3,list2));
90          assertEquals("[-2, -1, 0, A, B, C, 1, 2, 3, 4, 5, A, B, C]",list.toString());
91      }
92  
93      public void testClear() {
94          assertEquals(0,list.size());
95          assertTrue(list.isEmpty());
96          list.clear();
97          assertEquals(0,list.size());
98          assertTrue(list.isEmpty());
99  
100         list.add("element");
101         assertEquals(1,list.size());
102         assertTrue(!list.isEmpty());
103 
104         list.clear();
105         assertEquals(0,list.size());
106         assertTrue(list.isEmpty());
107 
108         list.add("element1");
109         list.add("element2");
110         assertEquals(2,list.size());
111         assertTrue(!list.isEmpty());
112 
113         list.clear();
114         assertEquals(0,list.size());
115         assertTrue(list.isEmpty());
116 
117         for(int i=0;i<1000;i++) {
118             list.add(new Integer(i));
119         }
120         assertEquals(1000,list.size());
121         assertTrue(!list.isEmpty());
122 
123         list.clear();
124         assertEquals(0,list.size());
125         assertTrue(list.isEmpty());
126     }
127 
128     public void testContains() {
129         assertTrue(!list.contains("A"));
130         assertTrue(list.add("A"));
131         assertTrue(list.contains("A"));
132         assertTrue(list.add("B"));
133         assertTrue(list.contains("A"));
134         assertTrue(list.addFirst("a"));
135         assertTrue(list.contains("A"));
136         assertTrue(list.remove("a"));
137         assertTrue(list.contains("A"));
138         assertTrue(list.remove("A"));
139         assertTrue(!list.contains("A"));
140     }
141 
142     public void testContainsAll() {
143         assertTrue(list.containsAll(list));
144         java.util.List list2 = new java.util.LinkedList();
145         assertTrue(list.containsAll(list2));
146         list2.add("A");
147         assertTrue(!list.containsAll(list2));
148         list.add("B");
149         list.add("A");
150         assertTrue(list.containsAll(list2));
151         list2.add("B");
152         assertTrue(list.containsAll(list2));
153         list2.add("C");
154         assertTrue(!list.containsAll(list2));
155         list.add("C");
156         assertTrue(list.containsAll(list2));
157         list2.add("C");
158         assertTrue(list.containsAll(list2));
159         assertTrue(list.containsAll(list));
160     }
161 
162     public void testCursorNavigation() {
163         list.add("1");
164         list.add("2");
165         list.add("3");
166         list.add("4");
167         list.add("5");
168         CursorableLinkedList.Cursor it = list.cursor();
169         assertTrue(it.hasNext());
170         assertTrue(!it.hasPrevious());
171         assertEquals("1",it.next());
172         assertTrue(it.hasNext());
173         assertTrue(it.hasPrevious());
174         assertEquals("1",it.previous());
175         assertTrue(it.hasNext());
176         assertTrue(!it.hasPrevious());
177         assertEquals("1",it.next());
178         assertTrue(it.hasNext());
179         assertTrue(it.hasPrevious());
180         assertEquals("2",it.next());
181         assertTrue(it.hasNext());
182         assertTrue(it.hasPrevious());
183         assertEquals("2",it.previous());
184         assertTrue(it.hasNext());
185         assertTrue(it.hasPrevious());
186         assertEquals("2",it.next());
187         assertTrue(it.hasNext());
188         assertTrue(it.hasPrevious());
189         assertEquals("3",it.next());
190         assertTrue(it.hasNext());
191         assertTrue(it.hasPrevious());
192         assertEquals("4",it.next());
193         assertTrue(it.hasNext());
194         assertTrue(it.hasPrevious());
195         assertEquals("5",it.next());
196         assertTrue(!it.hasNext());
197         assertTrue(it.hasPrevious());
198         assertEquals("5",it.previous());
199         assertTrue(it.hasNext());
200         assertTrue(it.hasPrevious());
201         assertEquals("4",it.previous());
202         assertTrue(it.hasNext());
203         assertTrue(it.hasPrevious());
204         assertEquals("3",it.previous());
205         assertTrue(it.hasNext());
206         assertTrue(it.hasPrevious());
207         assertEquals("2",it.previous());
208         assertTrue(it.hasNext());
209         assertTrue(it.hasPrevious());
210         assertEquals("1",it.previous());
211         assertTrue(it.hasNext());
212         assertTrue(!it.hasPrevious());
213         it.close();
214     }
215 
216     public void testCursorSet() {
217         list.add("1");
218         list.add("2");
219         list.add("3");
220         list.add("4");
221         list.add("5");
222 
223         CursorableLinkedList.Cursor it = list.cursor();
224         assertEquals("1",it.next());
225         it.set("a");
226         assertEquals("a",it.previous());
227         it.set("A");
228         assertEquals("A",it.next());
229         assertEquals("2",it.next());
230         it.set("B");
231         assertEquals("3",it.next());
232         assertEquals("4",it.next());
233         it.set("D");
234         assertEquals("5",it.next());
235         it.set("E");
236         assertEquals("[A, B, 3, D, E]",list.toString());
237         it.close();
238     }
239 
240     public void testCursorRemove() {
241         list.add("1");
242         list.add("2");
243         list.add("3");
244         list.add("4");
245         list.add("5");
246 
247         CursorableLinkedList.Cursor it = list.cursor();
248         try {
249             it.remove();
250             fail();
251         } catch(IllegalStateException e) {
252             // expected
253         }
254         assertEquals("1",it.next());
255         assertEquals("2",it.next());
256         assertEquals("[1, 2, 3, 4, 5]",list.toString());
257         it.remove();
258         assertEquals("[1, 3, 4, 5]",list.toString());
259         assertEquals("3",it.next());
260         assertEquals("3",it.previous());
261         assertEquals("1",it.previous());
262         it.remove();
263         assertEquals("[3, 4, 5]",list.toString());
264         assertTrue(!it.hasPrevious());
265         assertEquals("3",it.next());
266         it.remove();
267         assertEquals("[4, 5]",list.toString());
268         try {
269             it.remove();
270         } catch(IllegalStateException e) {
271             // expected
272         }
273         assertEquals("4",it.next());
274         assertEquals("5",it.next());
275         it.remove();
276         assertEquals("[4]",list.toString());
277         assertEquals("4",it.previous());
278         it.remove();
279         assertEquals("[]",list.toString());
280         it.close();
281     }
282 
283     public void testCursorAdd() {
284         CursorableLinkedList.Cursor it = list.cursor();
285         it.add("1");
286         assertEquals("[1]",list.toString());
287         it.add("3");
288         assertEquals("[1, 3]",list.toString());
289         it.add("5");
290         assertEquals("[1, 3, 5]",list.toString());
291         assertEquals("5",it.previous());
292         it.add("4");
293         assertEquals("[1, 3, 4, 5]",list.toString());
294         assertEquals("4",it.previous());
295         assertEquals("3",it.previous());
296         it.add("2");
297         assertEquals("[1, 2, 3, 4, 5]",list.toString());
298         it.close();
299     }
300 
301     public void testCursorConcurrentModification() {
302         // this test verifies that cursors remain valid when the list
303         // is modified via other means.
304         list.add("1");
305         list.add("2");
306         list.add("3");
307         list.add("5");
308         list.add("7");
309         list.add("9");
310 
311         CursorableLinkedList.Cursor c1 = list.cursor();
312         CursorableLinkedList.Cursor c2 = list.cursor();
313         Iterator li = list.iterator();
314         
315         // test cursors remain valid when list modified by std Iterator
316         // test cursors skip elements removed via ListIterator
317         assertEquals("1",li.next());
318         assertEquals("2",li.next());
319         li.remove();
320         assertEquals("3",li.next());
321         assertEquals("1",c1.next());
322         assertEquals("3",c1.next());
323         assertEquals("1",c2.next());
324         
325         // test cursor c1 can remove elements from previously modified list
326         // test cursor c2 skips elements removed via different cursor
327         c1.remove();
328         assertEquals("5",c2.next());
329         c2.add("6");
330         assertEquals("5",c1.next());
331         assertEquals("6",c1.next());
332         assertEquals("7",c1.next());
333         
334         // test cursors remain valid when list mod via CursorableLinkedList
335         // test cursor remains valid when elements inserted into list before
336         // the current position of the cursor.
337         list.add(0, "0");
338 
339         // test cursor remains valid when element inserted immediately after
340         // current element of a cursor, and the element is seen on the
341         // next call to the next method of that cursor.
342         list.add(5, "8");
343 
344         assertEquals("8",c1.next());
345         assertEquals("9",c1.next());
346         c1.add("10");
347         assertEquals("7",c2.next());
348         assertEquals("8",c2.next());
349         assertEquals("9",c2.next());
350         assertEquals("10",c2.next());
351         
352         try {
353             c2.next();
354             fail();
355         } catch (NoSuchElementException nse) {}
356         
357         try {
358             li.next();
359             fail();
360         } catch (ConcurrentModificationException cme) {}
361         
362         c1.close();  // not necessary
363         c2.close();  // not necessary
364     }
365     
366     public void testCursorNextIndexMid() {
367         list.add("1");
368         list.add("2");
369         list.add("3");
370         list.add("5");
371 
372         CursorableLinkedList.Cursor c1 = list.cursor();
373         Iterator li = list.iterator();
374         
375         // test cursors remain valid when list modified by std Iterator
376         // test cursors skip elements removed via ListIterator
377         assertEquals("1", li.next());
378         assertEquals("2", li.next());
379         li.remove();
380         assertEquals(0, c1.nextIndex());
381         assertEquals("1", c1.next());
382         assertEquals(1, c1.nextIndex());
383         assertEquals("3", c1.next());
384     }
385     
386     public void testCursorNextIndexFirst() {
387         list.add("1");
388         list.add("2");
389         list.add("3");
390         list.add("5");
391 
392         CursorableLinkedList.Cursor c1 = list.cursor();
393         
394         assertEquals(0, c1.nextIndex());
395         list.remove(0);
396         assertEquals(0, c1.nextIndex());
397         assertEquals("2", c1.next());
398         assertEquals(1, c1.nextIndex());
399         assertEquals("3", c1.next());
400     }
401     
402     public void testCursorNextIndexAddBefore() {
403         list.add("1");
404         list.add("2");
405         list.add("3");
406         list.add("5");
407 
408         CursorableLinkedList.Cursor c1 = list.cursor();
409         
410         assertEquals(0, c1.nextIndex());
411         assertEquals("1", c1.next());
412         list.add(0, "0");
413         assertEquals(2, c1.nextIndex());
414         assertEquals("2", c1.next());
415     }
416     
417     public void testCursorNextIndexAddNext() {
418         list.add("1");
419         list.add("2");
420         list.add("3");
421         list.add("5");
422 
423         CursorableLinkedList.Cursor c1 = list.cursor();
424         
425         assertEquals(0, c1.nextIndex());
426         list.add(0, "0");
427         assertEquals(0, c1.nextIndex());
428         assertEquals("0", c1.next());
429         assertEquals(1, c1.nextIndex());
430         assertEquals("1", c1.next());
431     }
432     
433     public void testCursorNextIndexAddAfter() {
434         list.add("1");
435         list.add("2");
436         list.add("3");
437         list.add("5");
438 
439         CursorableLinkedList.Cursor c1 = list.cursor();
440         
441         assertEquals(0, c1.nextIndex());
442         list.add(1, "0");
443         assertEquals(0, c1.nextIndex());
444         assertEquals("1", c1.next());
445         assertEquals(1, c1.nextIndex());
446         assertEquals("0", c1.next());
447     }
448 
449     //-----------------------------------------------------------------------
450     public void testInternalState_CursorNextNextPreviousRemoveIndex1ByList() {
451         list.add("A");
452         list.add("B");
453         list.add("C");
454 
455         CursorableLinkedList.Cursor c1 = list.cursor();
456         assertEquals("A", c1.next());
457         assertEquals("B", c1.next());
458         assertEquals("B", c1.previous());
459         
460         assertEquals("B", list.remove(1));
461         
462         assertEquals(true, c1.nextIndexValid);
463         assertEquals(1, c1.nextIndex);
464         assertEquals(true, c1.currentRemovedByAnother);
465         assertEquals(null, c1.current);
466         assertEquals("C", c1.next.value);
467         
468         assertEquals("[A, C]", list.toString());
469         c1.remove();  // works ok
470         assertEquals("[A, C]", list.toString());
471         try {
472             c1.remove();
473             fail();
474         } catch (IllegalStateException ex) {}
475     }
476 
477     public void testInternalState_CursorNextRemoveIndex1ByList() {
478         list.add("A");
479         list.add("B");
480         list.add("C");
481 
482         CursorableLinkedList.Cursor c1 = list.cursor();
483         assertEquals("A", c1.next());
484         
485         assertEquals("B", list.remove(1));
486         
487         assertEquals(true, c1.nextIndexValid);
488         assertEquals(1, c1.nextIndex);
489         assertEquals(false, c1.currentRemovedByAnother);
490         assertEquals("A", c1.current.value);
491         assertEquals("C", c1.next.value);
492         
493         assertEquals("[A, C]", list.toString());
494         c1.remove();  // works ok
495         assertEquals("[C]", list.toString());
496         try {
497             c1.remove();
498             fail();
499         } catch (IllegalStateException ex) {}
500     }
501 
502     public void testInternalState_CursorNextNextRemoveIndex1ByList() {
503         list.add("A");
504         list.add("B");
505         list.add("C");
506 
507         CursorableLinkedList.Cursor c1 = list.cursor();
508         assertEquals("A", c1.next());
509         assertEquals("B", c1.next());
510         
511         assertEquals("B", list.remove(1));
512         
513         assertEquals(true, c1.nextIndexValid);
514         assertEquals(1, c1.nextIndex);
515         assertEquals(true, c1.currentRemovedByAnother);
516         assertEquals(null, c1.current);
517         assertEquals("C", c1.next.value);
518         
519         assertEquals("[A, C]", list.toString());
520         c1.remove();  // works ok
521         assertEquals("[A, C]", list.toString());
522         try {
523             c1.remove();
524             fail();
525         } catch (IllegalStateException ex) {}
526     }
527 
528     public void testInternalState_CursorNextNextNextRemoveIndex1ByList() {
529         list.add("A");
530         list.add("B");
531         list.add("C");
532         list.add("D");
533 
534         CursorableLinkedList.Cursor c1 = list.cursor();
535         assertEquals("A", c1.next());
536         assertEquals("B", c1.next());
537         assertEquals("C", c1.next());
538         
539         assertEquals("B", list.remove(1));
540         
541         assertEquals(false, c1.nextIndexValid);
542         assertEquals(false, c1.currentRemovedByAnother);
543         assertEquals("C", c1.current.value);
544         assertEquals("D", c1.next.value);
545         
546         assertEquals("[A, C, D]", list.toString());
547         c1.remove();  // works ok
548         assertEquals("[A, D]", list.toString());
549         try {
550             c1.remove();
551             fail();
552         } catch (IllegalStateException ex) {}
553     }
554 
555     //-----------------------------------------------------------------------
556     public void testInternalState_CursorNextNextPreviousRemoveByIterator() {
557         list.add("A");
558         list.add("B");
559         list.add("C");
560 
561         CursorableLinkedList.Cursor c1 = list.cursor();
562         assertEquals("A", c1.next());
563         assertEquals("B", c1.next());
564         assertEquals("B", c1.previous());
565         
566         c1.remove();
567         
568         assertEquals(true, c1.nextIndexValid);
569         assertEquals(1, c1.nextIndex);
570         assertEquals(false, c1.currentRemovedByAnother);
571         assertEquals(null, c1.current);
572         assertEquals("C", c1.next.value);
573         
574         assertEquals("[A, C]", list.toString());
575         try {
576             c1.remove();
577             fail();
578         } catch (IllegalStateException ex) {}
579     }
580 
581     public void testInternalState_CursorNextNextRemoveByIterator() {
582         list.add("A");
583         list.add("B");
584         list.add("C");
585 
586         CursorableLinkedList.Cursor c1 = list.cursor();
587         assertEquals("A", c1.next());
588         assertEquals("B", c1.next());
589         
590         c1.remove();
591         
592         assertEquals(true, c1.nextIndexValid);
593         assertEquals(1, c1.nextIndex);
594         assertEquals(false, c1.currentRemovedByAnother);
595         assertEquals(null, c1.current);
596         assertEquals("C", c1.next.value);
597         
598         assertEquals("[A, C]", list.toString());
599         try {
600             c1.remove();
601             fail();
602         } catch (IllegalStateException ex) {}
603     }
604 
605     //-----------------------------------------------------------------------
606     public void testInternalState_CursorNextNextPreviousAddIndex1ByList() {
607         list.add("A");
608         list.add("B");
609         list.add("C");
610 
611         CursorableLinkedList.Cursor c1 = list.cursor();
612         assertEquals("A", c1.next());
613         assertEquals("B", c1.next());
614         assertEquals("B", c1.previous());
615         
616         list.add(1, "Z");
617         
618         assertEquals(true, c1.nextIndexValid);
619         assertEquals(1, c1.nextIndex);
620         assertEquals("B", c1.current.value);
621         assertEquals("Z", c1.next.value);
622         
623         assertEquals("[A, Z, B, C]", list.toString());
624         c1.remove();  // works ok
625         assertEquals("[A, Z, C]", list.toString());
626         try {
627             c1.remove();
628             fail();
629         } catch (IllegalStateException ex) {}
630     }
631 
632     public void testInternalState_CursorNextAddIndex1ByList() {
633         list.add("A");
634         list.add("B");
635         list.add("C");
636 
637         CursorableLinkedList.Cursor c1 = list.cursor();
638         assertEquals("A", c1.next());
639         
640         list.add(1, "Z");
641         
642         assertEquals(true, c1.nextIndexValid);
643         assertEquals(1, c1.nextIndex);
644         assertEquals("A", c1.current.value);
645         assertEquals("Z", c1.next.value);
646         
647         assertEquals("[A, Z, B, C]", list.toString());
648         c1.remove();  // works ok
649         assertEquals("[Z, B, C]", list.toString());
650         try {
651             c1.remove();
652             fail();
653         } catch (IllegalStateException ex) {}
654     }
655 
656     public void testInternalState_CursorNextNextAddIndex1ByList() {
657         list.add("A");
658         list.add("B");
659         list.add("C");
660 
661         CursorableLinkedList.Cursor c1 = list.cursor();
662         assertEquals("A", c1.next());
663         assertEquals("B", c1.next());
664         
665         list.add(1, "Z");
666         
667         assertEquals(false, c1.nextIndexValid);
668         assertEquals("B", c1.current.value);
669         assertEquals("C", c1.next.value);
670         
671         assertEquals("[A, Z, B, C]", list.toString());
672         c1.remove();  // works ok
673         assertEquals("[A, Z, C]", list.toString());
674         try {
675             c1.remove();
676             fail();
677         } catch (IllegalStateException ex) {}
678     }
679 
680     //-----------------------------------------------------------------------
681     public void testInternalState_CursorNextNextPreviousAddByIterator() {
682         list.add("A");
683         list.add("B");
684         list.add("C");
685 
686         CursorableLinkedList.Cursor c1 = list.cursor();
687         assertEquals("A", c1.next());
688         assertEquals("B", c1.next());
689         assertEquals("B", c1.previous());
690         
691         c1.add("Z");
692         
693         assertEquals(true, c1.nextIndexValid);
694         assertEquals(2, c1.nextIndex);
695         assertEquals(null, c1.current);
696         assertEquals("B", c1.next.value);
697         
698         assertEquals("[A, Z, B, C]", list.toString());
699         try {
700             c1.remove();
701             fail();
702         } catch (IllegalStateException ex) {}
703     }
704 
705     public void testInternalState_CursorNextNextAddByIterator() {
706         list.add("A");
707         list.add("B");
708         list.add("C");
709 
710         CursorableLinkedList.Cursor c1 = list.cursor();
711         assertEquals("A", c1.next());
712         assertEquals("B", c1.next());
713         
714         c1.add("Z");
715         
716         assertEquals(true, c1.nextIndexValid);
717         assertEquals(3, c1.nextIndex);
718         assertEquals(false, c1.currentRemovedByAnother);
719         assertEquals(null, c1.current);
720         assertEquals("C", c1.next.value);
721         
722         assertEquals("[A, B, Z, C]", list.toString());
723         try {
724             c1.remove();
725             fail();
726         } catch (IllegalStateException ex) {}
727     }
728 
729     //-----------------------------------------------------------------------
730     public void testInternalState_CursorNextNextRemoveByListSetByIterator() {
731         list.add("A");
732         list.add("B");
733         list.add("C");
734 
735         CursorableLinkedList.Cursor c1 = list.cursor();
736         assertEquals("A", c1.next());
737         assertEquals("B", c1.next());
738         
739         list.remove(1);
740         
741         assertEquals(true, c1.nextIndexValid);
742         assertEquals(1, c1.nextIndex);
743         assertEquals(null, c1.current);
744         assertEquals("C", c1.next.value);
745         assertEquals("[A, C]", list.toString());
746         
747         try {
748             c1.set("Z");
749             fail();
750         } catch (IllegalStateException ex) {}
751     }
752 
753     //-----------------------------------------------------------------------
754     public void testInternalState_CursorNextNextPreviousSetByIterator() {
755         list.add("A");
756         list.add("B");
757         list.add("C");
758 
759         CursorableLinkedList.Cursor c1 = list.cursor();
760         assertEquals("A", c1.next());
761         assertEquals("B", c1.next());
762         assertEquals("B", c1.previous());
763         
764         c1.set("Z");
765         
766         assertEquals(true, c1.nextIndexValid);
767         assertEquals(1, c1.nextIndex);
768         assertEquals("Z", c1.current.value);
769         assertEquals("Z", c1.next.value);
770         
771         assertEquals("[A, Z, C]", list.toString());
772         c1.remove();  // works ok
773         assertEquals("[A, C]", list.toString());
774         try {
775             c1.remove();
776             fail();
777         } catch (IllegalStateException ex) {}
778     }
779 
780     public void testInternalState_CursorNextNextSetByIterator() {
781         list.add("A");
782         list.add("B");
783         list.add("C");
784 
785         CursorableLinkedList.Cursor c1 = list.cursor();
786         assertEquals("A", c1.next());
787         assertEquals("B", c1.next());
788         
789         c1.set("Z");
790         
791         assertEquals(true, c1.nextIndexValid);
792         assertEquals(2, c1.nextIndex);
793         assertEquals("Z", c1.current.value);
794         assertEquals("C", c1.next.value);
795         
796         assertEquals("[A, Z, C]", list.toString());
797         c1.remove();  // works ok
798         assertEquals("[A, C]", list.toString());
799         try {
800             c1.remove();
801             fail();
802         } catch (IllegalStateException ex) {}
803     }
804 
805     //-----------------------------------------------------------------------
806     public void testEqualsAndHashCode() {
807         assertTrue(list.equals(list));
808         assertEquals(list.hashCode(),list.hashCode());
809         list.add("A");
810         assertTrue(list.equals(list));
811         assertEquals(list.hashCode(),list.hashCode());
812 
813         CursorableLinkedList list2 = new CursorableLinkedList();
814         assertTrue(!list.equals(list2));
815         assertTrue(!list2.equals(list));
816 
817         java.util.List list3 = new java.util.LinkedList();
818         assertTrue(!list.equals(list3));
819         assertTrue(!list3.equals(list));
820         assertTrue(list2.equals(list3));
821         assertTrue(list3.equals(list2));
822         assertEquals(list2.hashCode(),list3.hashCode());
823 
824         list2.add("A");
825         assertTrue(list.equals(list2));
826         assertTrue(list2.equals(list));
827         assertTrue(!list2.equals(list3));
828         assertTrue(!list3.equals(list2));
829 
830         list3.add("A");
831         assertTrue(list2.equals(list3));
832         assertTrue(list3.equals(list2));
833         assertEquals(list2.hashCode(),list3.hashCode());
834 
835         list.add("B");
836         assertTrue(list.equals(list));
837         assertTrue(!list.equals(list2));
838         assertTrue(!list2.equals(list));
839         assertTrue(!list.equals(list3));
840         assertTrue(!list3.equals(list));
841 
842         list2.add("B");
843         list3.add("B");
844         assertTrue(list.equals(list));
845         assertTrue(list.equals(list2));
846         assertTrue(list2.equals(list));
847         assertTrue(list2.equals(list3));
848         assertTrue(list3.equals(list2));
849         assertEquals(list2.hashCode(),list3.hashCode());
850 
851         list.add("C");
852         list2.add("C");
853         list3.add("C");
854         assertTrue(list.equals(list));
855         assertTrue(list.equals(list2));
856         assertTrue(list2.equals(list));
857         assertTrue(list2.equals(list3));
858         assertTrue(list3.equals(list2));
859         assertEquals(list.hashCode(),list2.hashCode());
860         assertEquals(list2.hashCode(),list3.hashCode());
861 
862         list.add("D");
863         list2.addFirst("D");
864         assertTrue(list.equals(list));
865         assertTrue(!list.equals(list2));
866         assertTrue(!list2.equals(list));
867     }
868 
869     public void testGet() {
870         try {
871             list.get(0);
872             fail("shouldn't get here");
873         } catch(IndexOutOfBoundsException e) {
874             // expected
875         }
876 
877         assertTrue(list.add("A"));
878         assertEquals("A",list.get(0));
879         assertTrue(list.add("B"));
880         assertEquals("A",list.get(0));
881         assertEquals("B",list.get(1));
882 
883         try {
884             list.get(-1);
885             fail("shouldn't get here");
886         } catch(IndexOutOfBoundsException e) {
887             // expected
888         }
889 
890         try {
891             list.get(2);
892             fail("shouldn't get here");
893         } catch(IndexOutOfBoundsException e) {
894             // expected
895         }
896     }
897 
898     public void testIndexOf() {
899         assertEquals(-1,list.indexOf("A"));
900         assertEquals(-1,list.lastIndexOf("A"));
901         list.add("A");
902         assertEquals(0,list.indexOf("A"));
903         assertEquals(0,list.lastIndexOf("A"));
904         assertEquals(-1,list.indexOf("B"));
905         assertEquals(-1,list.lastIndexOf("B"));
906         list.add("B");
907         assertEquals(0,list.indexOf("A"));
908         assertEquals(0,list.lastIndexOf("A"));
909         assertEquals(1,list.indexOf("B"));
910         assertEquals(1,list.lastIndexOf("B"));
911         list.addFirst("B");
912         assertEquals(1,list.indexOf("A"));
913         assertEquals(1,list.lastIndexOf("A"));
914         assertEquals(0,list.indexOf("B"));
915         assertEquals(2,list.lastIndexOf("B"));
916     }
917 
918     public void testIsEmpty() {
919         assertTrue(list.isEmpty());
920         list.add("element");
921         assertTrue(!list.isEmpty());
922         list.remove("element");
923         assertTrue(list.isEmpty());
924         list.add("element");
925         assertTrue(!list.isEmpty());
926         list.clear();
927         assertTrue(list.isEmpty());
928     }
929 
930     public void testIterator() {
931         list.add("1");
932         list.add("2");
933         list.add("3");
934         list.add("4");
935         list.add("5");
936         Iterator it = list.iterator();
937         assertTrue(it.hasNext());
938         assertEquals("1",it.next());
939         assertTrue(it.hasNext());
940         assertEquals("2",it.next());
941         assertTrue(it.hasNext());
942         assertEquals("3",it.next());
943         assertTrue(it.hasNext());
944         assertEquals("4",it.next());
945         assertTrue(it.hasNext());
946         assertEquals("5",it.next());
947         assertTrue(!it.hasNext());
948 
949         it = list.iterator();
950         assertTrue(it.hasNext());
951         assertEquals("1",it.next());
952         it.remove();
953         assertEquals("[2, 3, 4, 5]",list.toString());
954         assertTrue(it.hasNext());
955         assertEquals("2",it.next());
956         it.remove();
957         assertEquals("[3, 4, 5]",list.toString());
958         assertTrue(it.hasNext());
959         assertEquals("3",it.next());
960         it.remove();
961         assertEquals("[4, 5]",list.toString());
962         assertTrue(it.hasNext());
963         assertEquals("4",it.next());
964         it.remove();
965         assertEquals("[5]",list.toString());
966         assertTrue(it.hasNext());
967         assertEquals("5",it.next());
968         it.remove();
969         assertEquals("[]",list.toString());
970         assertTrue(!it.hasNext());
971     }
972 
973     public void testListIteratorNavigation() {
974         list.add("1");
975         list.add("2");
976         list.add("3");
977         list.add("4");
978         list.add("5");
979         ListIterator it = list.listIterator();
980         assertTrue(it.hasNext());
981         assertTrue(!it.hasPrevious());
982         assertEquals(-1,it.previousIndex());
983         assertEquals(0,it.nextIndex());
984         assertEquals("1",it.next());
985         assertTrue(it.hasNext());
986         assertTrue(it.hasPrevious());
987         assertEquals(0,it.previousIndex());
988         assertEquals(1,it.nextIndex());
989         assertEquals("1",it.previous());
990         assertTrue(it.hasNext());
991         assertTrue(!it.hasPrevious());
992         assertEquals(-1,it.previousIndex());
993         assertEquals(0,it.nextIndex());
994         assertEquals("1",it.next());
995         assertTrue(it.hasNext());
996         assertTrue(it.hasPrevious());
997         assertEquals(0,it.previousIndex());
998         assertEquals(1,it.nextIndex());
999         assertEquals("2",it.next());
1000         assertTrue(it.hasNext());
1001         assertTrue(it.hasPrevious());
1002         assertEquals(1,it.previousIndex());
1003         assertEquals(2,it.nextIndex());
1004         assertEquals("2",it.previous());
1005         assertTrue(it.hasNext());
1006         assertTrue(it.hasPrevious());
1007         assertEquals(0,it.previousIndex());
1008         assertEquals(1,it.nextIndex());
1009         assertEquals("2",it.next());
1010         assertTrue(it.hasNext());
1011         assertTrue(it.hasPrevious());
1012         assertEquals(1,it.previousIndex());
1013         assertEquals(2,it.nextIndex());
1014         assertEquals("3",it.next());
1015         assertTrue(it.hasNext());
1016         assertTrue(it.hasPrevious());
1017         assertEquals(2,it.previousIndex());
1018         assertEquals(3,it.nextIndex());
1019         assertEquals("4",it.next());
1020         assertTrue(it.hasNext());
1021         assertTrue(it.hasPrevious());
1022         assertEquals(3,it.previousIndex());
1023         assertEquals(4,it.nextIndex());
1024         assertEquals("5",it.next());
1025         assertTrue(!it.hasNext());
1026         assertTrue(it.hasPrevious());
1027         assertEquals(4,it.previousIndex());
1028         assertEquals(5,it.nextIndex());
1029         assertEquals("5",it.previous());
1030         assertTrue(it.hasNext());
1031         assertTrue(it.hasPrevious());
1032         assertEquals(3,it.previousIndex());
1033         assertEquals(4,it.nextIndex());
1034         assertEquals("4",it.previous());
1035         assertTrue(it.hasNext());
1036         assertTrue(it.hasPrevious());
1037         assertEquals(2,it.previousIndex());
1038         assertEquals(3,it.nextIndex());
1039         assertEquals("3",it.previous());
1040         assertTrue(it.hasNext());
1041         assertTrue(it.hasPrevious());
1042         assertEquals(1,it.previousIndex());
1043         assertEquals(2,it.nextIndex());
1044         assertEquals("2",it.previous());
1045         assertTrue(it.hasNext());
1046         assertTrue(it.hasPrevious());
1047         assertEquals(0,it.previousIndex());
1048         assertEquals(1,it.nextIndex());
1049         assertEquals("1",it.previous());
1050         assertTrue(it.hasNext());
1051         assertTrue(!it.hasPrevious());
1052         assertEquals(-1,it.previousIndex());
1053         assertEquals(0,it.nextIndex());
1054     }
1055 
1056     public void testListIteratorSet() {
1057         list.add("1");
1058         list.add("2");
1059         list.add("3");
1060         list.add("4");
1061         list.add("5");
1062 
1063         ListIterator it = list.listIterator();
1064         assertEquals("1",it.next());
1065         it.set("a");
1066         assertEquals("a",it.previous());
1067         it.set("A");
1068         assertEquals("A",it.next());
1069         assertEquals("2",it.next());
1070         it.set("B");
1071         assertEquals("3",it.next());
1072         assertEquals("4",it.next());
1073         it.set("D");
1074         assertEquals("5",it.next());
1075         it.set("E");
1076         assertEquals("[A, B, 3, D, E]",list.toString());
1077     }
1078 
1079     public void testListIteratorRemove() {
1080         list.add("1");
1081         list.add("2");
1082         list.add("3");
1083         list.add("4");
1084         list.add("5");
1085 
1086         ListIterator it = list.listIterator();
1087         try {
1088             it.remove();
1089         } catch(IllegalStateException e) {
1090             // expected
1091         }
1092         assertEquals("1",it.next());
1093         assertEquals("2",it.next());
1094         assertEquals("[1, 2, 3, 4, 5]",list.toString());
1095         it.remove();
1096         assertEquals("[1, 3, 4, 5]",list.toString());
1097         assertEquals("3",it.next());
1098         assertEquals("3",it.previous());
1099         assertEquals("1",it.previous());
1100         it.remove();
1101         assertEquals("[3, 4, 5]",list.toString());
1102         assertTrue(!it.hasPrevious());
1103         assertEquals("3",it.next());
1104         it.remove();
1105         assertEquals("[4, 5]",list.toString());
1106         try {
1107             it.remove();
1108         } catch(IllegalStateException e) {
1109             // expected
1110         }
1111         assertEquals("4",it.next());
1112         assertEquals("5",it.next());
1113         it.remove();
1114         assertEquals("[4]",list.toString());
1115         assertEquals("4",it.previous());
1116         it.remove();
1117         assertEquals("[]",list.toString());
1118     }
1119 
1120     public void testListIteratorAdd() {
1121         ListIterator it = list.listIterator();
1122         it.add("1");
1123         assertEquals("[1]",list.toString());
1124         it.add("3");
1125         assertEquals("[1, 3]",list.toString());
1126         it.add("5");
1127         assertEquals("[1, 3, 5]",list.toString());
1128         assertEquals("5",it.previous());
1129         it.add("4");
1130         assertEquals("[1, 3, 4, 5]",list.toString());
1131         assertEquals("4",it.previous());
1132         assertEquals("3",it.previous());
1133         it.add("2");
1134         assertEquals("[1, 2, 3, 4, 5]",list.toString());
1135     }
1136 
1137     public void testRemoveAll() {
1138         list.add("1");
1139         list.add("2");
1140         list.add("3");
1141         list.add("4");
1142         list.add("5");
1143 
1144         HashSet set = new HashSet();
1145         set.add("A");
1146         set.add("2");
1147         set.add("C");
1148         set.add("4");
1149         set.add("D");
1150 
1151         assertTrue(list.removeAll(set));
1152         assertEquals("[1, 3, 5]",list.toString());
1153         assertTrue(!list.removeAll(set));
1154     }
1155 
1156     public void testRemoveByIndex() {
1157         list.add("1");
1158         list.add("2");
1159         list.add("3");
1160         list.add("4");
1161         list.add("5");
1162         assertEquals("[1, 2, 3, 4, 5]",list.toString());
1163         assertEquals("1",list.remove(0));
1164         assertEquals("[2, 3, 4, 5]",list.toString());
1165         assertEquals("3",list.remove(1));
1166         assertEquals("[2, 4, 5]",list.toString());
1167         assertEquals("4",list.remove(1));
1168         assertEquals("[2, 5]",list.toString());
1169         assertEquals("5",list.remove(1));
1170         assertEquals("[2]",list.toString());
1171         assertEquals("2",list.remove(0));
1172         assertEquals("[]",list.toString());
1173     }
1174 
1175     public void testRemove() {
1176         list.add("1");
1177         list.add("1");
1178         list.add("2");
1179         list.add("3");
1180         list.add("4");
1181         list.add("5");
1182         list.add("2");
1183         list.add("3");
1184         list.add("4");
1185         list.add("5");
1186         assertEquals("[1, 1, 2, 3, 4, 5, 2, 3, 4, 5]",list.toString());
1187         assertTrue(!list.remove("6"));
1188         assertTrue(list.remove("5"));
1189         assertEquals("[1, 1, 2, 3, 4, 2, 3, 4, 5]",list.toString());
1190         assertTrue(list.remove("5"));
1191         assertEquals("[1, 1, 2, 3, 4, 2, 3, 4]",list.toString());
1192         assertTrue(!list.remove("5"));
1193         assertTrue(list.remove("1"));
1194         assertEquals("[1, 2, 3, 4, 2, 3, 4]",list.toString());
1195         assertTrue(list.remove("1"));
1196         assertEquals("[2, 3, 4, 2, 3, 4]",list.toString());
1197         assertTrue(list.remove("2"));
1198         assertEquals("[3, 4, 2, 3, 4]",list.toString());
1199         assertTrue(list.remove("2"));
1200         assertEquals("[3, 4, 3, 4]",list.toString());
1201         assertTrue(list.remove("3"));
1202         assertEquals("[4, 3, 4]",list.toString());
1203         assertTrue(list.remove("3"));
1204         assertEquals("[4, 4]",list.toString());
1205         assertTrue(list.remove("4"));
1206         assertEquals("[4]",list.toString());
1207         assertTrue(list.remove("4"));
1208         assertEquals("[]",list.toString());
1209     }
1210 
1211     public void testRetainAll() {
1212         list.add("1");
1213         list.add("1");
1214         list.add("2");
1215         list.add("2");
1216         list.add("3");
1217         list.add("3");
1218         list.add("4");
1219         list.add("4");
1220         list.add("5");
1221         list.add("5");
1222 
1223         HashSet set = new HashSet();
1224         set.add("A");
1225         set.add("2");
1226         set.add("C");
1227         set.add("4");
1228         set.add("D");
1229 
1230         assertTrue(list.retainAll(set));
1231         assertEquals("[2, 2, 4, 4]",list.toString());
1232         assertTrue(!list.retainAll(set));
1233     }
1234 
1235     public void testSet() {
1236         list.add("1");
1237         list.add("2");
1238         list.add("3");
1239         list.add("4");
1240         list.add("5");
1241         assertEquals("[1, 2, 3, 4, 5]",list.toString());
1242         list.set(0,"A");
1243         assertEquals("[A, 2, 3, 4, 5]",list.toString());
1244         list.set(1,"B");
1245         assertEquals("[A, B, 3, 4, 5]",list.toString());
1246         list.set(2,"C");
1247         assertEquals("[A, B, C, 4, 5]",list.toString());
1248         list.set(3,"D");
1249         assertEquals("[A, B, C, D, 5]",list.toString());
1250         list.set(4,"E");
1251         assertEquals("[A, B, C, D, E]",list.toString());
1252     }
1253 
1254     public void testSubList() {
1255         list.add("A");
1256         list.add("B");
1257         list.add("C");
1258         list.add("D");
1259         list.add("E");
1260 
1261         assertEquals("[A, B, C, D, E]",list.toString());
1262         assertEquals("[A, B, C, D, E]",list.subList(0,5).toString());
1263         assertEquals("[B, C, D, E]",list.subList(1,5).toString());
1264         assertEquals("[C, D, E]",list.subList(2,5).toString());
1265         assertEquals("[D, E]",list.subList(3,5).toString());
1266         assertEquals("[E]",list.subList(4,5).toString());
1267         assertEquals("[]",list.subList(5,5).toString());
1268     }
1269 
1270     public void testSubListAddEnd() {
1271         list.add("A");
1272         list.add("B");
1273         list.add("C");
1274         list.add("D");
1275         list.add("E");
1276 
1277         List sublist = list.subList(5,5);
1278         sublist.add("F");
1279         assertEquals("[A, B, C, D, E, F]",list.toString());
1280         assertEquals("[F]",sublist.toString());
1281         sublist.add("G");
1282         assertEquals("[A, B, C, D, E, F, G]",list.toString());
1283         assertEquals("[F, G]",sublist.toString());
1284     }
1285 
1286     public void testSubListAddBegin() {
1287         list.add("A");
1288         list.add("B");
1289         list.add("C");
1290         list.add("D");
1291         list.add("E");
1292 
1293         List sublist = list.subList(0,0);
1294         sublist.add("a");
1295         assertEquals("[a, A, B, C, D, E]",list.toString());
1296         assertEquals("[a]",sublist.toString());
1297         sublist.add("b");
1298         assertEquals("[a, b, A, B, C, D, E]",list.toString());
1299         assertEquals("[a, b]",sublist.toString());
1300     }
1301 
1302     public void testSubListAddMiddle() {
1303         list.add("A");
1304         list.add("B");
1305         list.add("C");
1306         list.add("D");
1307         list.add("E");
1308 
1309         List sublist = list.subList(1,3);
1310         sublist.add("a");
1311         assertEquals("[A, B, C, a, D, E]",list.toString());
1312         assertEquals("[B, C, a]",sublist.toString());
1313         sublist.add("b");
1314         assertEquals("[A, B, C, a, b, D, E]",list.toString());
1315         assertEquals("[B, C, a, b]",sublist.toString());
1316     }
1317 
1318     public void testSubListRemove() {
1319         list.add("A");
1320         list.add("B");
1321         list.add("C");
1322         list.add("D");
1323         list.add("E");
1324 
1325         List sublist = list.subList(1,4);
1326         assertEquals("[B, C, D]",sublist.toString());
1327         assertEquals("[A, B, C, D, E]",list.toString());
1328         sublist.remove("C");
1329         assertEquals("[B, D]",sublist.toString());
1330         assertEquals("[A, B, D, E]",list.toString());
1331         sublist.remove(1);
1332         assertEquals("[B]",sublist.toString());
1333         assertEquals("[A, B, E]",list.toString());
1334         sublist.clear();
1335         assertEquals("[]",sublist.toString());
1336         assertEquals("[A, E]",list.toString());
1337     }
1338 
1339     public void testToArray() {
1340         list.add("1");
1341         list.add("2");
1342         list.add("3");
1343         list.add("4");
1344         list.add("5");
1345 
1346         Object[] elts = list.toArray();
1347         assertEquals("1",elts[0]);
1348         assertEquals("2",elts[1]);
1349         assertEquals("3",elts[2]);
1350         assertEquals("4",elts[3]);
1351         assertEquals("5",elts[4]);
1352         assertEquals(5,elts.length);
1353 
1354         String[] elts2 = (String[])(list.toArray(new String[0]));
1355         assertEquals("1",elts2[0]);
1356         assertEquals("2",elts2[1]);
1357         assertEquals("3",elts2[2]);
1358         assertEquals("4",elts2[3]);
1359         assertEquals("5",elts2[4]);
1360         assertEquals(5,elts2.length);
1361 
1362         String[] elts3 = new String[5];
1363         assertSame(elts3,list.toArray(elts3));
1364         assertEquals("1",elts3[0]);
1365         assertEquals("2",elts3[1]);
1366         assertEquals("3",elts3[2]);
1367         assertEquals("4",elts3[3]);
1368         assertEquals("5",elts3[4]);
1369         assertEquals(5,elts3.length);
1370 
1371         String[] elts4 = new String[3];
1372         String[] elts4b = (String[])(list.toArray(elts4));
1373         assertTrue(elts4 != elts4b);
1374         assertEquals("1",elts4b[0]);
1375         assertEquals("2",elts4b[1]);
1376         assertEquals("3",elts4b[2]);
1377         assertEquals("4",elts4b[3]);
1378         assertEquals("5",elts4b[4]);
1379         assertEquals(5,elts4b.length);
1380     }
1381 
1382     public void testSerialization() throws Exception {
1383         list.add("A");
1384         list.add("B");
1385         list.add("C");
1386         list.add("D");
1387         list.add("E");
1388 
1389         java.io.ByteArrayOutputStream buf = new java.io.ByteArrayOutputStream();
1390         java.io.ObjectOutputStream out = new java.io.ObjectOutputStream(buf);
1391         out.writeObject(list);
1392         out.flush();
1393         out.close();
1394 
1395         java.io.ByteArrayInputStream bufin = new java.io.ByteArrayInputStream(buf.toByteArray());
1396         java.io.ObjectInputStream in = new java.io.ObjectInputStream(bufin);
1397         Object list2 = in.readObject();
1398 
1399         assertTrue(list != list2);
1400         assertTrue(list2.equals(list));
1401         assertTrue(list.equals(list2));
1402     }
1403 
1404     public void testSerializationWithOpenCursor() throws Exception {
1405         list.add("A");
1406         list.add("B");
1407         list.add("C");
1408         list.add("D");
1409         list.add("E");
1410         CursorableLinkedList.Cursor cursor = list.cursor();
1411 
1412         java.io.ByteArrayOutputStream buf = new java.io.ByteArrayOutputStream();
1413         java.io.ObjectOutputStream out = new java.io.ObjectOutputStream(buf);
1414         out.writeObject(list);
1415         out.flush();
1416         out.close();
1417 
1418         java.io.ByteArrayInputStream bufin = new java.io.ByteArrayInputStream(buf.toByteArray());
1419         java.io.ObjectInputStream in = new java.io.ObjectInputStream(bufin);
1420         Object list2 = in.readObject();
1421 
1422         assertTrue(list != list2);
1423         assertTrue(list2.equals(list));
1424         assertTrue(list.equals(list2));
1425     }
1426 
1427     public void testLongSerialization() throws Exception {
1428         // recursive serialization will cause a stack
1429         // overflow exception with long lists
1430         for(int i=0;i<10000;i++) {
1431             list.add(new Integer(i));
1432         }
1433 
1434         java.io.ByteArrayOutputStream buf = new java.io.ByteArrayOutputStream();
1435         java.io.ObjectOutputStream out = new java.io.ObjectOutputStream(buf);
1436         out.writeObject(list);
1437         out.flush();
1438         out.close();
1439 
1440         java.io.ByteArrayInputStream bufin = new java.io.ByteArrayInputStream(buf.toByteArray());
1441         java.io.ObjectInputStream in = new java.io.ObjectInputStream(bufin);
1442         Object list2 = in.readObject();
1443 
1444         assertTrue(list != list2);
1445         assertTrue(list2.equals(list));
1446         assertTrue(list.equals(list2));
1447     }
1448 
1449 
1450     /**
1451      *  Ignore the serialization tests for sublists and sub-sublists.
1452      *
1453      *  @return an array of sublist serialization test names 
1454      */
1455     public String[] ignoredTests() {
1456         ArrayList list = new ArrayList();
1457         String prefix = "TestCursorableLinkedList";
1458         String bulk = ".bulkTestSubList";
1459         String[] ignored = new String[] {
1460           ".testEmptyListSerialization",
1461           ".testFullListSerialization", 
1462           ".testEmptyListCompatibility", 
1463           ".testFullListCompatibility", 
1464           ".testSimpleSerialization",
1465           ".testCanonicalEmptyCollectionExists",
1466</