Java > Open Source Codes > org > apache > commons > collections > iterators > TestFilterListIterator


1 /*
2  * Copyright 2001-2004 The Apache Software Foundation
3  *
4  * Licensed under the Apache License, Version 2.0 (the "License");
5  * you may not use this file except in compliance with the License.
6  * You may obtain a copy of the License at
7  *
8  * http://www.apache.org/licenses/LICENSE-2.0
9  *
10  * Unless required by applicable law or agreed to in writing, software
11  * distributed under the License is distributed on an "AS IS" BASIS,
12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13  * See the License for the specific language governing permissions and
14  * limitations under the License.
15  */
16 package org.apache.commons.collections.iterators;
17
18 import java.util.ArrayList ;
19 import java.util.List ;
20 import java.util.ListIterator ;
21 import java.util.Random ;
22
23 import junit.framework.Test;
24 import junit.framework.TestCase;
25 import junit.framework.TestSuite;
26
27 import org.apache.commons.collections.Predicate;
28
29 /**
30  * Tests the FilterListIterator class.
31  *
32  * @version $Revision: 1.9 $ $Date: 2004/02/18 01:20:33 $
33  *
34  * @author Rodney Waldhoff
35  */
36 public class TestFilterListIterator extends TestCase {
37     public TestFilterListIterator(String testName) {
38         super(testName);
39     }
40
41     public static Test suite() {
42         return new TestSuite(TestFilterListIterator.class);
43     }
44
45     public static void main(String args[]) {
46         String [] testCaseName = { TestFilterListIterator.class.getName() };
47         junit.textui.TestRunner.main(testCaseName);
48     }
49
50     private ArrayList list = null;
51     private ArrayList odds = null;
52     private ArrayList evens = null;
53     private ArrayList threes = null;
54     private ArrayList fours = null;
55     private ArrayList sixes = null;
56     private Predicate truePred = null;
57     private Predicate falsePred = null;
58     private Predicate evenPred = null;
59     private Predicate oddPred = null;
60     private Predicate threePred = null;
61     private Predicate fourPred = null;
62     private Random random = new Random ();
63
64     public void setUp() {
65         list = new ArrayList ();
66         odds = new ArrayList ();
67         evens = new ArrayList ();
68         threes = new ArrayList ();
69         fours = new ArrayList ();
70         sixes = new ArrayList ();
71         for(int i=0;i<20;i++) {
72             list.add(new Integer (i));
73             if(i%2 == 0) { evens.add(new Integer (i)); }
74             if(i%2 == 1) { odds.add(new Integer (i)); }
75             if(i%3 == 0) { threes.add(new Integer (i)); }
76             if(i%4 == 0) { fours.add(new Integer (i)); }
77             if(i%6 == 0) { sixes.add(new Integer (i)); }
78         }
79
80         truePred = new Predicate() {
81             public boolean evaluate(Object x) {
82                 return true;
83             }
84         };
85
86         falsePred = new Predicate() {
87             public boolean evaluate(Object x) {
88                 return true;
89             }
90         };
91
92         evenPred = new Predicate() {
93             public boolean evaluate(Object x) {
94                 return (((Integer )x).intValue()%2 == 0);
95             }
96         };
97
98         oddPred = new Predicate() {
99             public boolean evaluate(Object x) {
100                 return (((Integer )x).intValue()%2 == 1);
101             }
102         };
103
104         threePred = new Predicate() {
105             public boolean evaluate(Object x) {
106                 return (((Integer )x).intValue()%3 == 0);
107             }
108         };
109
110         fourPred = new Predicate() {
111             public boolean evaluate(Object x) {
112                 return (((Integer )x).intValue()%4 == 0);
113             }
114         };
115
116     }
117
118     public void tearDown() throws Exception {
119         list = null;
120         odds = null;
121         evens = null;
122         threes = null;
123         fours = null;
124         sixes = null;
125         truePred = null;
126         falsePred = null;
127         evenPred = null;
128         oddPred = null;
129         threePred = null;
130         fourPred = null;
131     }
132
133     public void testWalkLists() {
134         // this just confirms that our walkLists method works OK
135 walkLists(list,list.listIterator());
136     }
137
138     public void testManual() {
139         // do this one "by hand" as a sanity check
140 FilterListIterator filtered = new FilterListIterator(list.listIterator(),threePred);
141         
142         assertEquals(new Integer (0),filtered.next());
143         assertEquals(new Integer (3),filtered.next());
144         assertEquals(new Integer (6),filtered.next());
145         assertEquals(new Integer (9),filtered.next());
146         assertEquals(new Integer (12),filtered.next());
147         assertEquals(new Integer (15),filtered.next());
148         assertEquals(new Integer (18),filtered.next());
149
150         assertEquals(new Integer (18),filtered.previous());
151         assertEquals(new Integer (15),filtered.previous());
152         assertEquals(new Integer (12),filtered.previous());
153         assertEquals(new Integer (9),filtered.previous());
154         assertEquals(new Integer (6),filtered.previous());
155         assertEquals(new Integer (3),filtered.previous());
156         assertEquals(new Integer (0),filtered.previous());
157     
158         assertTrue(!filtered.hasPrevious());
159
160         assertEquals(new Integer (0),filtered.next());
161         assertEquals(new Integer (3),filtered.next());
162         assertEquals(new Integer (6),filtered.next());
163         assertEquals(new Integer (9),filtered.next());
164         assertEquals(new Integer (12),filtered.next());
165         assertEquals(new Integer (15),filtered.next());
166         assertEquals(new Integer (18),filtered.next());
167
168         assertTrue(!filtered.hasNext());
169
170         assertEquals(new Integer (18),filtered.previous());
171         assertEquals(new Integer (15),filtered.previous());
172         assertEquals(new Integer (12),filtered.previous());
173         assertEquals(new Integer (9),filtered.previous());
174         assertEquals(new Integer (6),filtered.previous());
175         assertEquals(new Integer (3),filtered.previous());
176         assertEquals(new Integer (0),filtered.previous());
177
178         assertEquals(new Integer (0),filtered.next());
179         assertEquals(new Integer (0),filtered.previous());
180         assertEquals(new Integer (0),filtered.next());
181         
182         assertEquals(new Integer (3),filtered.next());
183         assertEquals(new Integer (6),filtered.next());
184         assertEquals(new Integer (6),filtered.previous());
185         assertEquals(new Integer (3),filtered.previous());
186         assertEquals(new Integer (3),filtered.next());
187         assertEquals(new Integer (6),filtered.next());
188
189         assertEquals(new Integer (9),filtered.next());
190         assertEquals(new Integer (12),filtered.next());
191         assertEquals(new Integer (15),filtered.next());
192         assertEquals(new Integer (15),filtered.previous());
193         assertEquals(new Integer (12),filtered.previous());
194         assertEquals(new Integer (9),filtered.previous());
195
196     }
197
198     public void testTruePredicate() {
199         FilterListIterator filtered = new FilterListIterator(list.listIterator(),truePred);
200         walkLists(list,filtered);
201     }
202     
203     public void testFalsePredicate() {
204         FilterListIterator filtered = new FilterListIterator(list.listIterator(),falsePred);
205         walkLists(new ArrayList (),filtered);
206     }
207
208     public void testEvens() {
209         FilterListIterator filtered = new FilterListIterator(list.listIterator(),evenPred);
210         walkLists(evens,filtered);
211     }
212     
213     public void testOdds() {
214         FilterListIterator filtered = new FilterListIterator(list.listIterator(),oddPred);
215         walkLists(odds,filtered);
216     }
217
218     public void testThrees() {
219         FilterListIterator filtered = new FilterListIterator(list.listIterator(),threePred);
220         walkLists(threes,filtered);
221     }
222
223     public void testFours() {
224         FilterListIterator filtered = new FilterListIterator(list.listIterator(),fourPred);
225         walkLists(fours,filtered);
226     }
227
228     public void testNestedSixes() {
229         FilterListIterator filtered = new FilterListIterator(
230                                         new FilterListIterator(list.listIterator(),threePred),
231                                         evenPred
232                                       );
233         walkLists(sixes,filtered);
234     }
235
236     public void testNestedSixes2() {
237         FilterListIterator filtered = new FilterListIterator(
238                                         new FilterListIterator(list.listIterator(),evenPred),
239                                         threePred
240                                       );
241         walkLists(sixes,filtered);
242     }
243
244     public void testNestedSixes3() {
245         FilterListIterator filtered = new FilterListIterator(
246                                         new FilterListIterator(list.listIterator(),threePred),
247                                         evenPred
248                                       );
249         walkLists(sixes,new FilterListIterator(filtered,truePred));
250     }
251
252     public void testNextChangesPrevious() {
253         {
254             FilterListIterator filtered = new FilterListIterator(list.listIterator(),threePred);
255             nextNextPrevious(threes.listIterator(),filtered);
256         }
257     
258         {
259             FilterListIterator filtered = new FilterListIterator(list.listIterator(),truePred);
260             nextNextPrevious(list.listIterator(),filtered);
261         }
262     }
263
264     public void testPreviousChangesNext() {
265         {
266             FilterListIterator filtered = new FilterListIterator(list.listIterator(),threePred);
267             ListIterator expected = threes.listIterator();
268             walkForward(expected,filtered);
269             previousPreviousNext(expected,filtered);
270         }
271         {
272             FilterListIterator filtered = new FilterListIterator(list.listIterator(),truePred);
273             ListIterator expected = list.listIterator();
274             walkForward(expected,filtered);
275             previousPreviousNext(expected,filtered);
276         }
277     }
278
279     public void testFailingHasNextBug() {
280         FilterListIterator filtered = new FilterListIterator(list.listIterator(),fourPred);
281         ListIterator expected = fours.listIterator();
282         while(expected.hasNext()) {
283             expected.next();
284             filtered.next();
285         }
286         assertTrue(filtered.hasPrevious());
287         assertTrue(!filtered.hasNext());
288         assertEquals(expected.previous(),filtered.previous());
289     }
290
291     // Utilities
292
293     private void walkForward(ListIterator expected, ListIterator testing) {
294         while(expected.hasNext()) {
295             assertEquals(expected.nextIndex(),testing.nextIndex());
296             assertEquals(expected.previousIndex(),testing.previousIndex());
297             assertTrue(testing.hasNext());
298             assertEquals(expected.next(),testing.next());
299         }
300     }
301
302     private void walkBackward(ListIterator expected, ListIterator testing) {
303         while(expected.hasPrevious()) {
304             assertEquals(expected.nextIndex(),testing.nextIndex());
305             assertEquals(expected.previousIndex(),testing.previousIndex());
306             assertTrue(testing.hasPrevious());
307             assertEquals(expected.previous(),testing.previous());
308         }
309     }
310
311     private void nextNextPrevious(ListIterator expected, ListIterator testing) {
312         // calls to next() should change the value returned by previous()
313 // even after previous() has been set by a call to hasPrevious()
314 assertEquals(expected.next(),testing.next());
315         assertEquals(expected.hasPrevious(),testing.hasPrevious());
316         Object expecteda = expected.next();
317         Object testinga = testing.next();
318         assertEquals(expecteda,testinga);
319         Object expectedb = expected.previous();
320         Object testingb = testing.previous();
321         assertEquals(expecteda,expectedb);
322         assertEquals(testinga,testingb);
323     }
324
325     private void previousPreviousNext(ListIterator expected, ListIterator testing) {
326         // calls to previous() should change the value returned by next()
327 // even after next() has been set by a call to hasNext()
328 assertEquals(expected.previous(),testing.previous());
329         assertEquals(expected.hasNext(),testing.hasNext());
330         Object expecteda = expected.previous();
331         Object testinga = testing.previous();
332         assertEquals(expecteda,testinga);
333         Object expectedb = expected.next();
334         Object testingb = testing.next();
335         assertEquals(expecteda,testingb);
336         assertEquals(expecteda,expectedb);
337         assertEquals(testinga,testingb);
338     }
339
340     private void walkLists(List list, ListIterator testing) {
341         ListIterator expected = list.listIterator();
342
343         // walk all the way forward
344 walkForward(expected,testing);
345
346         // walk all the way back
347 walkBackward(expected,testing);
348
349         // forward,back,forward
350 while(expected.hasNext()) {
351             assertEquals(expected.nextIndex(),testing.nextIndex());
352             assertEquals(expected.previousIndex(),testing.previousIndex());
353             assertTrue(testing.hasNext());
354             assertEquals(expected.next(),testing.next());
355             assertTrue(testing.hasPrevious());
356             assertEquals(expected.previous(),testing.previous());
357             assertTrue(testing.hasNext());
358             assertEquals(expected.next(),testing.next());
359         }
360
361
362         // walk all the way back
363 walkBackward(expected,testing);
364
365         for(int i=0;i<list.size();i++) {
366             // walk forward i
367 for(int j=0;j<i;j++) {
368                 assertEquals(expected.nextIndex(),testing.nextIndex());
369                 assertEquals(expected.previousIndex(),testing.previousIndex());
370                 assertTrue(expected.hasNext()); // if this one fails we've got a logic error in the test
371 assertTrue(testing.hasNext());
372                 assertEquals(expected.next(),testing.next());
373             }
374             // walk back i/2
375 for(int j=0;j<i/2;j++) {
376                 assertEquals(expected.nextIndex(),testing.nextIndex());
377                 assertEquals(expected.previousIndex(),testing.previousIndex());
378                 assertTrue(expected.hasPrevious()); // if this one fails we've got a logic error in the test
379 assertTrue(testing.hasPrevious());
380                 assertEquals(expected.previous(),testing.previous());
381             }
382             // walk forward i/2
383 for(int j=0;j<i/2;j++) {
384                 assertEquals(expected.nextIndex(),testing.nextIndex());
385                 assertEquals(expected.previousIndex(),testing.previousIndex());
386                 assertTrue(expected.hasNext()); // if this one fails we've got a logic error in the test
387 assertTrue(testing.hasNext());
388                 assertEquals(expected.next(),testing.next());
389             }
390             // walk back i
391 for(int j=0;j<i;j++) {
392                 assertEquals(expected.nextIndex(),testing.nextIndex());
393                 assertEquals(expected.previousIndex(),testing.previousIndex());
394                 assertTrue(expected.hasPrevious()); // if this one fails we've got a logic error in the test
395 assertTrue(testing.hasPrevious());
396                 assertEquals(expected.previous(),testing.previous());
397             }
398         }
399
400         // random walk
401 StringBuffer walkdescr = new StringBuffer (500);
402         for(int i=0;i<500;i++) {
403             if(random.nextBoolean()) {
404                 // step forward
405 walkdescr.append("+");
406                 if(expected.hasNext()) {
407                     assertEquals(walkdescr.toString(),expected.next(),testing.next());
408                 }
409             } else {
410                 // step backward
411 walkdescr.append("-");
412                 if(expected.hasPrevious()) {
413                     assertEquals(walkdescr.toString(),expected.previous(),testing.previous());
414                 }
415             }
416             assertEquals(walkdescr.toString(),expected.nextIndex(),testing.nextIndex());
417             assertEquals(walkdescr.toString(),expected.previousIndex(),testing.previousIndex());
418         }
419
420     }
421
422 }
423

A to Z: JavaDoc & Examples

---

Daily Java News & Articles

---

Open Source Projects

---

Open Source Codes

---

Free Computer Books

---

Remove Frame

---

Popular Tags