KickJava   Java API By Example, From Geeks To Geeks.

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


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 JavaDoc;
19 import java.util.Arrays JavaDoc;
20 import java.util.Iterator JavaDoc;
21 import java.util.List JavaDoc;
22 import java.util.NoSuchElementException JavaDoc;
23
24 import junit.framework.Test;
25 import junit.framework.TestSuite;
26
27 import org.apache.commons.collections.Predicate;
28
29 /**
30  * Test the filter iterator.
31  *
32  * @version $Revision: 1.9 $ $Date: 2004/02/18 01:20:33 $
33  *
34  * @author Jan Sorensen
35  * @author Ralph Wagner
36  */
37 public class TestFilterIterator extends AbstractTestIterator {
38
39     /** Creates new TestFilterIterator */
40     public TestFilterIterator(String JavaDoc name) {
41         super(name);
42     }
43
44     private String JavaDoc[] array;
45     private List JavaDoc list;
46     private FilterIterator iterator;
47     /**
48      * Set up instance variables required by this test case.
49      */
50     public void setUp() {
51         array = new String JavaDoc[] { "a", "b", "c" };
52         initIterator();
53     }
54
55     /**
56      * Tear down instance variables required by this test case.
57      */
58     public void tearDown() throws Exception JavaDoc {
59         iterator = null;
60     }
61
62     /**
63      * Return the tests included in this test suite.
64      */
65     public static Test suite() {
66         return (new TestSuite(TestFilterIterator.class));
67     }
68
69     /**
70      * Returns an full iterator wrapped in a
71      * FilterIterator that blocks all the elements
72      *
73      * @return "empty" FilterIterator
74      */
75     public Iterator JavaDoc makeEmptyIterator() {
76         return makeBlockAllFilter(new ArrayIterator(array));
77     }
78
79     /**
80      * Returns an array with elements wrapped in a pass-through
81      * FilterIterator
82      *
83      * @return
84      */
85     public Iterator JavaDoc makeFullIterator() {
86         array = new String JavaDoc[] { "a", "b", "c" };
87         list = new ArrayList JavaDoc(Arrays.asList(array));
88         return makePassThroughFilter(list.iterator());
89     }
90
91     public void testRepeatedHasNext() {
92         for (int i = 0; i <= array.length; i++) {
93             assertTrue(iterator.hasNext());
94         }
95     }
96
97     public void testRepeatedNext() {
98         for (int i = 0; i < array.length; i++)
99             iterator.next();
100         verifyNoMoreElements();
101     }
102
103     public void testReturnValues() {
104         verifyElementsInPredicate(new String JavaDoc[0]);
105         verifyElementsInPredicate(new String JavaDoc[] { "a" });
106         verifyElementsInPredicate(new String JavaDoc[] { "b" });
107         verifyElementsInPredicate(new String JavaDoc[] { "c" });
108         verifyElementsInPredicate(new String JavaDoc[] { "a", "b" });
109         verifyElementsInPredicate(new String JavaDoc[] { "a", "c" });
110         verifyElementsInPredicate(new String JavaDoc[] { "b", "c" });
111         verifyElementsInPredicate(new String JavaDoc[] { "a", "b", "c" });
112     }
113
114     private void verifyNoMoreElements() {
115         assertTrue(!iterator.hasNext());
116         try {
117             iterator.next();
118             fail("NoSuchElementException expected");
119         }
120         catch (NoSuchElementException JavaDoc e) {
121             // success
122 }
123     }
124
125     private void verifyElementsInPredicate(final String JavaDoc[] elements) {
126         Predicate pred = new Predicate() {
127             public boolean evaluate(Object JavaDoc x) {
128                 for (int i = 0; i < elements.length; i++)
129                     if (elements[i].equals(x))
130                         return true;
131                 return false;
132             }
133         };
134         initIterator();
135         iterator.setPredicate(pred);
136         for (int i = 0; i < elements.length; i++) {
137             String JavaDoc s = (String JavaDoc)iterator.next();
138             assertEquals(elements[i], s);
139             assertTrue(i == elements.length - 1 ? !iterator.hasNext() : iterator.hasNext());
140         }
141         verifyNoMoreElements();
142
143         // test removal
144 initIterator();
145         iterator.setPredicate(pred);
146         if (iterator.hasNext()) {
147             Object JavaDoc last = iterator.next();
148             iterator.remove();
149             assertTrue("Base of FilterIterator still contains removed element.", !list.contains(last));
150         }
151     }
152
153     private void initIterator() {
154         iterator = (FilterIterator) makeFullIterator();
155     }
156
157     /**
158      * Returns a FilterIterator that does not filter
159      * any of its elements
160      *
161      * @param i the Iterator to "filter"
162      * @return "filtered" iterator
163      */
164     protected FilterIterator makePassThroughFilter(Iterator JavaDoc i) {
165         Predicate pred = new Predicate() {
166                 public boolean evaluate(Object JavaDoc x) { return true; }
167         };
168         return new FilterIterator(i,pred);
169     }
170
171     /**
172      * Returns a FilterIterator that blocks
173      * all of its elements
174      *
175      * @param i the Iterator to "filter"
176      * @return "filtered" iterator
177      */
178     protected FilterIterator makeBlockAllFilter(Iterator JavaDoc i) {
179         Predicate pred = new Predicate() {
180                 public boolean evaluate(Object JavaDoc x) { return false; }
181         };
182         return new FilterIterator(i,pred);
183     }
184 }
185
186
Popular Tags