1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17 package org.apache.commons.collections4.iterators;
18
19 import static org.junit.jupiter.api.Assertions.assertAll;
20 import static org.junit.jupiter.api.Assertions.assertEquals;
21 import static org.junit.jupiter.api.Assertions.assertFalse;
22 import static org.junit.jupiter.api.Assertions.assertThrows;
23 import static org.junit.jupiter.api.Assertions.assertTrue;
24
25 import java.util.ArrayList;
26 import java.util.Arrays;
27 import java.util.List;
28 import java.util.NoSuchElementException;
29
30 import org.junit.jupiter.api.Test;
31
32
33
34
35 public class LoopingListIteratorTest {
36
37
38
39
40 @Test
41 public void testAdd() {
42 List<String> list = new ArrayList<>(Arrays.asList("b", "e", "f"));
43 LoopingListIterator<String> loop = new LoopingListIterator<>(list);
44
45 loop.add("a");
46 assertEquals("b", loop.next());
47 loop.reset();
48 assertEquals("a", loop.next());
49 assertEquals("b", loop.next());
50
51 loop.add("c");
52 assertEquals("e", loop.next());
53 assertEquals("e", loop.previous());
54 assertEquals("c", loop.previous());
55 assertEquals("c", loop.next());
56
57 loop.add("d");
58 loop.reset();
59 assertEquals("a", loop.next());
60 assertEquals("b", loop.next());
61 assertEquals("c", loop.next());
62 assertEquals("d", loop.next());
63 assertEquals("e", loop.next());
64 assertEquals("f", loop.next());
65 assertEquals("a", loop.next());
66
67 list = new ArrayList<>(Arrays.asList("b", "e", "f"));
68 loop = new LoopingListIterator<>(list);
69
70 loop.add("a");
71 assertEquals("a", loop.previous());
72 loop.reset();
73 assertEquals("f", loop.previous());
74 assertEquals("e", loop.previous());
75
76 loop.add("d");
77 assertEquals("d", loop.previous());
78
79 loop.add("c");
80 assertEquals("c", loop.previous());
81
82 loop.reset();
83 assertEquals("a", loop.next());
84 assertEquals("b", loop.next());
85 assertEquals("c", loop.next());
86 assertEquals("d", loop.next());
87 assertEquals("e", loop.next());
88 assertEquals("f", loop.next());
89 assertEquals("a", loop.next());
90 }
91
92
93
94
95 @Test
96 public void testConstructorEx() {
97 assertThrows(NullPointerException.class, () -> new LoopingListIterator<>(null));
98 }
99
100
101
102
103
104 @Test
105 public void testJoggingNotOverBoundary() {
106 final List<String> list = Arrays.asList("a", "b");
107 final LoopingListIterator<String> loop = new LoopingListIterator<>(list);
108
109
110
111 loop.reset();
112 assertEquals("a", loop.next());
113 assertEquals("a", loop.previous());
114 assertEquals("a", loop.next());
115
116 assertEquals("b", loop.next());
117 assertEquals("b", loop.previous());
118 assertEquals("b", loop.next());
119 }
120
121
122
123
124
125 @Test
126 public void testJoggingOverBoundary() {
127 final List<String> list = Arrays.asList("a", "b");
128 final LoopingListIterator<String> loop = new LoopingListIterator<>(list);
129
130
131
132 assertEquals("b", loop.previous());
133 assertEquals("b", loop.next());
134 assertEquals("b", loop.previous());
135
136 assertEquals("a", loop.previous());
137 assertEquals("a", loop.next());
138 assertEquals("a", loop.previous());
139 }
140
141
142
143
144 @Test
145 public void testLooping0() {
146 final List<Object> list = new ArrayList<>();
147 final LoopingListIterator<Object> loop = new LoopingListIterator<>(list);
148 assertFalse(loop.hasNext());
149 assertFalse(loop.hasPrevious());
150 assertAll(
151 () -> assertThrows(NoSuchElementException.class, () -> loop.next()),
152 () -> assertThrows(NoSuchElementException.class, () -> loop.previous())
153 );
154 }
155
156
157
158
159
160 @Test
161 public void testLooping1() {
162 final List<String> list = Arrays.asList("a");
163 final LoopingListIterator<String> loop = new LoopingListIterator<>(list);
164
165 assertTrue(loop.hasNext());
166 assertEquals("a", loop.next());
167
168 assertTrue(loop.hasNext());
169 assertEquals("a", loop.next());
170
171 assertTrue(loop.hasNext());
172 assertEquals("a", loop.next());
173
174 assertTrue(loop.hasPrevious());
175 assertEquals("a", loop.previous());
176
177 assertTrue(loop.hasPrevious());
178 assertEquals("a", loop.previous());
179
180 assertTrue(loop.hasPrevious());
181 assertEquals("a", loop.previous());
182 }
183
184
185
186
187
188 @Test
189 public void testLooping2() {
190 final List<String> list = Arrays.asList("a", "b");
191 final LoopingListIterator<String> loop = new LoopingListIterator<>(list);
192
193 assertTrue(loop.hasNext());
194 assertEquals("a", loop.next());
195
196 assertTrue(loop.hasNext());
197 assertEquals("b", loop.next());
198
199 assertTrue(loop.hasNext());
200 assertEquals("a", loop.next());
201
202
203 loop.reset();
204
205 assertTrue(loop.hasPrevious());
206 assertEquals("b", loop.previous());
207
208 assertTrue(loop.hasPrevious());
209 assertEquals("a", loop.previous());
210
211 assertTrue(loop.hasPrevious());
212 assertEquals("b", loop.previous());
213 }
214
215
216
217
218 @Test
219 public void testNextAndPreviousIndex() {
220 final List<String> list = Arrays.asList("a", "b", "c");
221 final LoopingListIterator<String> loop = new LoopingListIterator<>(list);
222
223 assertEquals(0, loop.nextIndex());
224 assertEquals(2, loop.previousIndex());
225
226 assertEquals("a", loop.next());
227 assertEquals(1, loop.nextIndex());
228 assertEquals(0, loop.previousIndex());
229
230 assertEquals("a", loop.previous());
231 assertEquals(0, loop.nextIndex());
232 assertEquals(2, loop.previousIndex());
233
234 assertEquals("c", loop.previous());
235 assertEquals(2, loop.nextIndex());
236 assertEquals(1, loop.previousIndex());
237
238 assertEquals("b", loop.previous());
239 assertEquals(1, loop.nextIndex());
240 assertEquals(0, loop.previousIndex());
241
242 assertEquals("a", loop.previous());
243 assertEquals(0, loop.nextIndex());
244 assertEquals(2, loop.previousIndex());
245 }
246
247
248
249
250 @Test
251 public void testRemovingElementsAndIteratingBackwards() {
252 final List<String> list = new ArrayList<>(Arrays.asList("a", "b", "c"));
253 final LoopingListIterator<String> loop = new LoopingListIterator<>(list);
254
255 assertTrue(loop.hasPrevious());
256 assertEquals("c", loop.previous());
257 loop.remove();
258 assertEquals(2, list.size());
259
260 assertTrue(loop.hasPrevious());
261 assertEquals("b", loop.previous());
262 loop.remove();
263 assertEquals(1, list.size());
264
265 assertTrue(loop.hasPrevious());
266 assertEquals("a", loop.previous());
267 loop.remove();
268 assertEquals(0, list.size());
269
270 assertFalse(loop.hasPrevious());
271
272 assertThrows(NoSuchElementException.class, () -> loop.previous());
273 }
274
275
276
277
278 @Test
279 public void testRemovingElementsAndIteratingForward() {
280 final List<String> list = new ArrayList<>(Arrays.asList("a", "b", "c"));
281 final LoopingListIterator<String> loop = new LoopingListIterator<>(list);
282
283 assertTrue(loop.hasNext());
284 assertEquals("a", loop.next());
285 loop.remove();
286 assertEquals(2, list.size());
287
288 assertTrue(loop.hasNext());
289 assertEquals("b", loop.next());
290 loop.remove();
291 assertEquals(1, list.size());
292
293 assertTrue(loop.hasNext());
294 assertEquals("c", loop.next());
295 loop.remove();
296 assertEquals(0, list.size());
297
298 assertFalse(loop.hasNext());
299
300 assertThrows(NoSuchElementException.class, () -> loop.next());
301 }
302
303
304
305
306 @Test
307 public void testReset() {
308 final List<String> list = Arrays.asList("a", "b", "c");
309 final LoopingListIterator<String> loop = new LoopingListIterator<>(list);
310
311 assertEquals("a", loop.next());
312 assertEquals("b", loop.next());
313 loop.reset();
314 assertEquals("a", loop.next());
315 loop.reset();
316 assertEquals("a", loop.next());
317 assertEquals("b", loop.next());
318 assertEquals("c", loop.next());
319 loop.reset();
320
321 assertEquals("c", loop.previous());
322 assertEquals("b", loop.previous());
323 loop.reset();
324 assertEquals("c", loop.previous());
325 loop.reset();
326 assertEquals("c", loop.previous());
327 assertEquals("b", loop.previous());
328 assertEquals("a", loop.previous());
329 }
330
331
332
333
334 @Test
335 public void testSet() {
336 final List<String> list = Arrays.asList("q", "r", "z");
337 final LoopingListIterator<String> loop = new LoopingListIterator<>(list);
338
339 assertEquals("z", loop.previous());
340 loop.set("c");
341
342 loop.reset();
343 assertEquals("q", loop.next());
344 loop.set("a");
345
346 assertEquals("r", loop.next());
347 loop.set("b");
348
349 loop.reset();
350 assertEquals("a", loop.next());
351 assertEquals("b", loop.next());
352 assertEquals("c", loop.next());
353 }
354
355 }