001: /*
002: * Copyright 2004 The Apache Software Foundation
003: *
004: * Licensed under the Apache License, Version 2.0 (the "License");
005: * you may not use this file except in compliance with the License.
006: * You may obtain a copy of the License at
007: *
008: * http://www.apache.org/licenses/LICENSE-2.0
009: *
010: * Unless required by applicable law or agreed to in writing, software
011: * distributed under the License is distributed on an "AS IS" BASIS,
012: * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
013: * See the License for the specific language governing permissions and
014: * limitations under the License.
015: */
016: package org.apache.commons.collections.iterators;
017:
018: import java.util.ArrayList;
019: import java.util.Arrays;
020: import java.util.List;
021: import java.util.NoSuchElementException;
022:
023: import junit.framework.Test;
024: import junit.framework.TestCase;
025: import junit.framework.TestSuite;
026:
027: /**
028: * Tests the LoopingListIterator class.
029: *
030: * @version $Revision: 155406 $ $Date: 2005-02-26 12:55:26 +0000 (Sat, 26 Feb 2005) $
031: *
032: * @author Eric Crampton <ccesc@eonomine.com>
033: */
034: public class TestLoopingListIterator extends TestCase {
035:
036: public TestLoopingListIterator(String testName) {
037: super (testName);
038: }
039:
040: public static Test suite() {
041: return new TestSuite(TestLoopingListIterator.class);
042: }
043:
044: /**
045: * Tests constructor exception.
046: */
047: public void testConstructorEx() throws Exception {
048: try {
049: new LoopingListIterator(null);
050: fail();
051: } catch (NullPointerException ex) {
052: }
053: }
054:
055: /**
056: * Tests whether an empty looping list iterator works.
057: */
058: public void testLooping0() throws Exception {
059: List list = new ArrayList();
060: LoopingListIterator loop = new LoopingListIterator(list);
061: assertFalse(loop.hasNext());
062: assertFalse(loop.hasPrevious());
063:
064: try {
065: loop.next();
066: fail();
067: } catch (NoSuchElementException ex) {
068: }
069:
070: try {
071: loop.previous();
072: fail();
073: } catch (NoSuchElementException ex) {
074: }
075: }
076:
077: /**
078: * Tests whether a looping list iterator works on a list with only
079: * one element.
080: */
081: public void testLooping1() throws Exception {
082: List list = new ArrayList(Arrays.asList(new String[] { "a" }));
083: LoopingListIterator loop = new LoopingListIterator(list); // <a>
084:
085: assertTrue(loop.hasNext());
086: assertEquals("a", loop.next()); // <a>
087:
088: assertTrue(loop.hasNext());
089: assertEquals("a", loop.next()); // <a>
090:
091: assertTrue(loop.hasNext());
092: assertEquals("a", loop.next()); // <a>
093:
094: assertTrue(loop.hasPrevious());
095: assertEquals("a", loop.previous()); // <a>
096:
097: assertTrue(loop.hasPrevious());
098: assertEquals("a", loop.previous()); // <a>
099:
100: assertTrue(loop.hasPrevious());
101: assertEquals("a", loop.previous()); // <a>
102: }
103:
104: /**
105: * Tests whether a looping list iterator works on a list with two
106: * elements.
107: */
108: public void testLooping2() throws Exception {
109: List list = new ArrayList(Arrays
110: .asList(new String[] { "a", "b" }));
111: LoopingListIterator loop = new LoopingListIterator(list); // <a> b
112:
113: assertTrue(loop.hasNext());
114: assertEquals("a", loop.next()); // a <b>
115:
116: assertTrue(loop.hasNext());
117: assertEquals("b", loop.next()); // <a> b
118:
119: assertTrue(loop.hasNext());
120: assertEquals("a", loop.next()); // a <b>
121:
122: // Reset the iterator and try using previous.
123: loop.reset(); // <a> b
124:
125: assertTrue(loop.hasPrevious());
126: assertEquals("b", loop.previous()); // a <b>
127:
128: assertTrue(loop.hasPrevious());
129: assertEquals("a", loop.previous()); // <a> b
130:
131: assertTrue(loop.hasPrevious());
132: assertEquals("b", loop.previous()); // a <b>
133: }
134:
135: /**
136: * Tests jogging back and forth between two elements, but not over
137: * the begin/end boundary of the list.
138: */
139: public void testJoggingNotOverBoundary() {
140: List list = new ArrayList(Arrays
141: .asList(new String[] { "a", "b" }));
142: LoopingListIterator loop = new LoopingListIterator(list); // <a> b
143:
144: // Try jogging back and forth between the elements, but not
145: // over the begin/end boundary.
146: loop.reset();
147: assertEquals("a", loop.next()); // a <b>
148: assertEquals("a", loop.previous()); // <a> b
149: assertEquals("a", loop.next()); // a <b>
150:
151: assertEquals("b", loop.next()); // <a> b
152: assertEquals("b", loop.previous()); // a <b>
153: assertEquals("b", loop.next()); // <a> b
154: }
155:
156: /**
157: * Tests jogging back and forth between two elements over the
158: * begin/end boundary of the list.
159: */
160: public void testJoggingOverBoundary() {
161: List list = new ArrayList(Arrays
162: .asList(new String[] { "a", "b" }));
163: LoopingListIterator loop = new LoopingListIterator(list); // <a> b
164:
165: // Try jogging back and forth between the elements, but not
166: // over the begin/end boundary.
167: assertEquals("b", loop.previous()); // a <b>
168: assertEquals("b", loop.next()); // <a> b
169: assertEquals("b", loop.previous()); // a <b>
170:
171: assertEquals("a", loop.previous()); // <a> b
172: assertEquals("a", loop.next()); // a <b>
173: assertEquals("a", loop.previous()); // <a> b
174: }
175:
176: /**
177: * Tests removing an element from a wrapped ArrayList.
178: */
179: public void testRemovingElementsAndIteratingForward() {
180: List list = new ArrayList(Arrays.asList(new String[] { "a",
181: "b", "c" }));
182: LoopingListIterator loop = new LoopingListIterator(list); // <a> b c
183:
184: assertTrue(loop.hasNext());
185: assertEquals("a", loop.next()); // a <b> c
186: loop.remove(); // <b> c
187: assertEquals(2, list.size());
188:
189: assertTrue(loop.hasNext());
190: assertEquals("b", loop.next()); // b <c>
191: loop.remove(); // <c>
192: assertEquals(1, list.size());
193:
194: assertTrue(loop.hasNext());
195: assertEquals("c", loop.next()); // <c>
196: loop.remove(); // ---
197: assertEquals(0, list.size());
198:
199: assertFalse(loop.hasNext());
200: try {
201: loop.next();
202: fail();
203: } catch (NoSuchElementException ex) {
204: }
205: }
206:
207: /**
208: * Tests removing an element from a wrapped ArrayList.
209: */
210: public void testRemovingElementsAndIteratingBackwards() {
211: List list = new ArrayList(Arrays.asList(new String[] { "a",
212: "b", "c" }));
213: LoopingListIterator loop = new LoopingListIterator(list); // <a> b c
214:
215: assertTrue(loop.hasPrevious());
216: assertEquals("c", loop.previous()); // a b <c>
217: loop.remove(); // <a> b
218: assertEquals(2, list.size());
219:
220: assertTrue(loop.hasPrevious());
221: assertEquals("b", loop.previous()); // a <b>
222: loop.remove(); // <a>
223: assertEquals(1, list.size());
224:
225: assertTrue(loop.hasPrevious());
226: assertEquals("a", loop.previous()); // <a>
227: loop.remove(); // ---
228: assertEquals(0, list.size());
229:
230: assertFalse(loop.hasPrevious());
231: try {
232: loop.previous();
233: fail();
234: } catch (NoSuchElementException ex) {
235: }
236: }
237:
238: /**
239: * Tests the reset method.
240: */
241: public void testReset() {
242: List list = new ArrayList(Arrays.asList(new String[] { "a",
243: "b", "c" }));
244: LoopingListIterator loop = new LoopingListIterator(list); // <a> b c
245:
246: assertEquals("a", loop.next()); // a <b> c
247: assertEquals("b", loop.next()); // a b <c>
248: loop.reset(); // <a> b c
249: assertEquals("a", loop.next()); // a <b> c
250: loop.reset(); // <a> b c
251: assertEquals("a", loop.next()); // a <b> c
252: assertEquals("b", loop.next()); // a b <c>
253: assertEquals("c", loop.next()); // <a> b c
254: loop.reset(); // <a> b c
255:
256: assertEquals("c", loop.previous()); // a b <c>
257: assertEquals("b", loop.previous()); // a <b> c
258: loop.reset(); // <a> b c
259: assertEquals("c", loop.previous()); // a b <c>
260: loop.reset(); // <a> b c
261: assertEquals("c", loop.previous()); // a b <c>
262: assertEquals("b", loop.previous()); // a <b> c
263: assertEquals("a", loop.previous()); // <a> b c
264: }
265:
266: /**
267: * Tests the add method.
268: */
269: public void testAdd() {
270: List list = new ArrayList(Arrays.asList(new String[] { "b",
271: "e", "f" }));
272: LoopingListIterator loop = new LoopingListIterator(list); // <b> e f
273:
274: loop.add("a"); // <a> b e f
275: assertEquals("b", loop.next()); // a <b> e f
276: loop.reset(); // <a> b e f
277: assertEquals("a", loop.next()); // a <b> e f
278: assertEquals("b", loop.next()); // a b <e> f
279:
280: loop.add("c"); // a b c <e> f
281: assertEquals("e", loop.next()); // a b c e <f>
282: assertEquals("e", loop.previous()); // a b c <e> f
283: assertEquals("c", loop.previous()); // a b <c> e f
284: assertEquals("c", loop.next()); // a b c <e> f
285:
286: loop.add("d"); // a b c d <e> f
287: loop.reset(); // <a> b c d e f
288: assertEquals("a", loop.next()); // a <b> c d e f
289: assertEquals("b", loop.next()); // a b <c> d e f
290: assertEquals("c", loop.next()); // a b c <d> e f
291: assertEquals("d", loop.next()); // a b c d <e> f
292: assertEquals("e", loop.next()); // a b c d e <f>
293: assertEquals("f", loop.next()); // <a> b c d e f
294: assertEquals("a", loop.next()); // a <b> c d e f
295:
296: list = new ArrayList(Arrays
297: .asList(new String[] { "b", "e", "f" }));
298: loop = new LoopingListIterator(list); // <b> e f
299:
300: loop.add("a"); // a <b> e f
301: assertEquals("a", loop.previous()); // a b e <f>
302: loop.reset(); // <a> b e f
303: assertEquals("f", loop.previous()); // a b e <f>
304: assertEquals("e", loop.previous()); // a b <e> f
305:
306: loop.add("d"); // a b d <e> f
307: assertEquals("d", loop.previous()); // a b <d> e f
308:
309: loop.add("c"); // a b c <d> e f
310: assertEquals("c", loop.previous()); // a b <c> d e f
311:
312: loop.reset();
313: assertEquals("a", loop.next()); // a <b> c d e f
314: assertEquals("b", loop.next()); // a b <c> d e f
315: assertEquals("c", loop.next()); // a b c <d> e f
316: assertEquals("d", loop.next()); // a b c d <e> f
317: assertEquals("e", loop.next()); // a b c d e <f>
318: assertEquals("f", loop.next()); // <a> b c d e f
319: assertEquals("a", loop.next()); // a <b> c d e f
320: }
321:
322: /**
323: * Tests nextIndex and previousIndex.
324: */
325: public void testNextAndPreviousIndex() {
326: List list = new ArrayList(Arrays.asList(new String[] { "a",
327: "b", "c" }));
328: LoopingListIterator loop = new LoopingListIterator(list); // <a> b c
329:
330: assertEquals(0, loop.nextIndex());
331: assertEquals(2, loop.previousIndex());
332:
333: assertEquals("a", loop.next()); // a <b> c
334: assertEquals(1, loop.nextIndex());
335: assertEquals(0, loop.previousIndex());
336:
337: assertEquals("a", loop.previous()); // <a> b c
338: assertEquals(0, loop.nextIndex());
339: assertEquals(2, loop.previousIndex());
340:
341: assertEquals("c", loop.previous()); // a b <c>
342: assertEquals(2, loop.nextIndex());
343: assertEquals(1, loop.previousIndex());
344:
345: assertEquals("b", loop.previous()); // a <b> c
346: assertEquals(1, loop.nextIndex());
347: assertEquals(0, loop.previousIndex());
348:
349: assertEquals("a", loop.previous()); // <a> b c
350: assertEquals(0, loop.nextIndex());
351: assertEquals(2, loop.previousIndex());
352: }
353:
354: /**
355: * Tests using the set method to change elements.
356: */
357: public void testSet() {
358: List list = new ArrayList(Arrays.asList(new String[] { "q",
359: "r", "z" }));
360: LoopingListIterator loop = new LoopingListIterator(list); // <q> r z
361:
362: assertEquals("z", loop.previous()); // q r <z>
363: loop.set("c"); // q r <c>
364:
365: loop.reset(); // <q> r c
366: assertEquals("q", loop.next()); // q <r> c
367: loop.set("a"); // a <r> c
368:
369: assertEquals("r", loop.next()); // a r <c>
370: loop.set("b"); // a b <c>
371:
372: loop.reset(); // <a> b c
373: assertEquals("a", loop.next()); // a <b> c
374: assertEquals("b", loop.next()); // a b <c>
375: assertEquals("c", loop.next()); // <a> b c
376: }
377:
378: }
|