2f6b7ed2852099d9f46399a00ea6d761e0063f10
[idea/community.git] / platform / util / testSrc / com / intellij / util / containers / SequenceIteratorTest.java
1 /*
2  * Copyright 2000-2009 JetBrains s.r.o.
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
17 package com.intellij.util.containers;
18
19 import com.intellij.util.Assertion;
20 import junit.framework.TestCase;
21
22 import java.util.ArrayList;
23 import java.util.Arrays;
24 import java.util.Iterator;
25 import java.util.List;
26
27 public class SequenceIteratorTest extends TestCase {
28   private final Assertion CHECK = new Assertion();
29
30   public void testOneIterator() {
31     Iterator<Object> iterator = iterate("1", "2");
32     Iterator<Object> seq = ContainerUtil.concatIterators(iterator);
33     CHECK.compareAll(new Object[]{"1", "2"}, ContainerUtil.collect(seq));
34   }
35
36   public void testTwoNotEmpties() {
37     Iterator<Object> seq = ContainerUtil.concatIterators(iterate("1", "2"), iterate("3", "4"));
38     CHECK.compareAll(new Object[]{"1", "2", "3", "4"}, ContainerUtil.collect(seq));
39   }
40
41   public void testAllEmpty() {
42     assertFalse(ContainerUtil.concatIterators(empty()).hasNext());
43     assertFalse(ContainerUtil.concatIterators(empty(), empty()).hasNext());
44   }
45
46   public void testIntermediateEmpty() {
47     Iterator<Object> seq = ContainerUtil.concatIterators(iterate("1", "2"), empty(), iterate("3", "4"));
48     CHECK.compareAll(new Object[]{"1", "2", "3", "4"}, ContainerUtil.collect(seq));
49   }
50
51   public void testFirstEmpty() {
52     Iterator<Object> seq = ContainerUtil.concatIterators(empty(), iterate("1", "2"));
53     CHECK.compareAll(new Object[]{"1", "2"}, ContainerUtil.collect(seq));
54   }
55
56   private static Iterator<Object> iterate(String first, String second) {
57     return Arrays.asList(new Object[]{first, second}).iterator();
58   }
59
60   private static Iterator empty() {
61     return new ArrayList().iterator();
62   }
63
64   public void testSimple() {
65     final Iterator<Integer> iterator = compose(Arrays.asList(iter(arr1), iter(arr2), iter(arr3)));
66     int cnt = 0;
67     while (iterator.hasNext()) {
68       iterator.next();
69       ++cnt;
70     }
71     assertEquals(arr1.length + arr2.length + arr3.length, cnt);
72   }
73
74   private static Iterator<Integer> compose(List<Iterator<Integer>> iterators) {
75     return ContainerUtil.concatIterators(iterators);
76   }
77
78   public void testOne() {
79     final Iterator<Integer> iterator = compose(Arrays.asList(iter(arr1)));
80     int cnt = 0;
81     while (iterator.hasNext()) {
82       iterator.next();
83       ++cnt;
84     }
85     assertEquals(arr1.length, cnt);
86   }
87
88   public void testOneOne() {
89     final Iterator<Integer> iterator = compose(Arrays.asList(iter(new Integer[]{1})));
90     int cnt = 0;
91     while (iterator.hasNext()) {
92       iterator.next();
93       ++cnt;
94     }
95     assertEquals(1, cnt);
96   }
97
98   public void testEmpty() {
99     final Iterator<Integer> iterator = compose(Arrays.asList(iter(new Integer[]{})));
100     int cnt = 0;
101     while (iterator.hasNext()) {
102       iterator.next();
103       ++cnt;
104     }
105     assertEquals(0, cnt);
106   }
107
108   public void testManyEmpty() {
109     final Iterator<Integer> iterator =
110       compose(Arrays.asList(iter(new Integer[]{}), iter(new Integer[]{}), iter(new Integer[]{})));
111     int cnt = 0;
112     while (iterator.hasNext()) {
113       iterator.next();
114       ++cnt;
115     }
116     assertEquals(0, cnt);
117   }
118
119   public void testRemoveSimple() {
120     final ArrayList<Integer> list1 = new ArrayList<>(Arrays.asList(arr1));
121     final ArrayList<Integer> list2 = new ArrayList<>(Arrays.asList(arr2));
122     final ArrayList<Integer> list3 = new ArrayList<>(Arrays.asList(arr3));
123
124     final Iterator<Integer> iterator =
125       compose(Arrays.asList(list1.iterator(), list2.iterator(), list3.iterator()));
126     int cnt = 0;
127     while (iterator.hasNext()) {
128       iterator.next();
129       if ((cnt - 2) % 5 == 0) {
130         iterator.remove();
131       }
132       ++cnt;
133     }
134     assertFalse(list1.contains(3));
135     assertFalse(list2.contains(13));
136     assertFalse(list3.contains(103));
137   }
138
139   public void testRemoveAfterLast() {
140     final ArrayList<Integer> list1 = new ArrayList<>(Arrays.asList(arr1));
141     final Iterator<Integer> it1 = list1.iterator();
142     while (it1.hasNext()) {
143       it1.next();
144     }
145     it1.remove(); // ok, removes last
146     assertFalse(list1.contains(5));
147     list1.add(5);
148
149     final ArrayList<Integer> list2 = new ArrayList<>(Arrays.asList(arr2));
150     final ArrayList<Integer> list3 = new ArrayList<>(Arrays.asList(arr3));
151
152     final Iterator<Integer> iterator =
153       compose(Arrays.asList(list1.iterator(), list2.iterator(), list3.iterator()));
154     while (iterator.hasNext()) {
155       iterator.next();
156     }
157     iterator.remove();
158     assertFalse(list3.contains(105));
159   }
160
161   public void testRemoveOnlyOne() {
162     final ArrayList<Integer> list1 = new ArrayList<>(Arrays.asList(1));
163     final Iterator<Integer> iterator = compose(Arrays.asList(list1.iterator()));
164     iterator.next();
165     iterator.remove();
166     assertTrue(list1.isEmpty());
167   }
168
169   public void testIterateWithEmptyInside() {
170     final Iterator<Integer> iterator = compose(Arrays.asList(iter(arr1), iter(new Integer[]{}), iter(arr3)));
171     int cnt = 0;
172     int sum = 0;
173     while (iterator.hasNext()) {
174       Integer next = iterator.next();
175       ++cnt;
176       sum += next;
177     }
178     assertEquals(arr1.length + arr3.length, cnt);
179     assertEquals(530, sum);
180   }
181
182   public void testRemoveIfNextNotCalled() {
183     final ArrayList<Integer> list1 = new ArrayList<>(Arrays.asList(1));
184     final Iterator<Integer> iterator = compose(Arrays.asList(list1.iterator()));
185     try {
186       iterator.remove();
187       fail();
188     }
189     catch (IllegalStateException e) {
190       // ok
191     }
192   }
193
194   public void testRemoveTwice() {
195     final ArrayList<Integer> list1 = new ArrayList<>(Arrays.asList(1, 2, 3, 4, 5));
196     final Iterator<Integer> iterator = compose(Arrays.asList(list1.iterator()));
197     try {
198       iterator.next();
199       iterator.remove();
200       iterator.remove();  // wrong, next() should be called inside
201       fail();
202     }
203     catch (IllegalStateException e) {
204       // ok
205     }
206   }
207
208   public void testRemoveAll() {
209     final ArrayList<Integer> list1 = new ArrayList<>(Arrays.asList(1, 2));
210     final ArrayList<Integer> list2 = new ArrayList<>(Arrays.asList(3, 4));
211     final ArrayList<Integer> list3 = new ArrayList<>(Arrays.asList(5, 6));
212
213     final Iterator<Integer> iterator =
214       compose(Arrays.asList(list1.iterator(), list2.iterator(), list3.iterator()));
215     while (iterator.hasNext()) {
216       iterator.next();
217       iterator.remove();
218     }
219     assertTrue(list1.isEmpty());
220     assertTrue(list2.isEmpty());
221     assertTrue(list3.isEmpty());
222   }
223
224   public void testRemoveAllWithEmptyInside() {
225     final ArrayList<Integer> list1 = new ArrayList<>(Arrays.asList(1, 2));
226     final ArrayList<Integer> list2 = new ArrayList<>();
227     final ArrayList<Integer> list3 = new ArrayList<>(Arrays.asList(5, 6));
228
229     final Iterator<Integer> iterator =
230       compose(Arrays.asList(list1.iterator(), list2.iterator(), list3.iterator()));
231     while (iterator.hasNext()) {
232       iterator.next();
233       iterator.remove();
234     }
235     assertTrue(list1.isEmpty());
236     assertTrue(list2.isEmpty());
237     assertTrue(list3.isEmpty());
238   }
239
240   public void testRemoveLastAndFirstINNext() {
241     final ArrayList<Integer> list1 = new ArrayList<>(Arrays.asList(1, 2));
242     final ArrayList<Integer> list2 = new ArrayList<>(Arrays.asList(3, 4));
243     final ArrayList<Integer> list3 = new ArrayList<>(Arrays.asList(5, 6));
244
245     final Iterator<Integer> iterator =
246       compose(Arrays.asList(list1.iterator(), list2.iterator(), list3.iterator()));
247     iterator.next();
248     iterator.next();
249     iterator.remove();
250     iterator.next();
251     iterator.remove();
252
253     assertTrue(list1.size() == 1 && !list1.contains(2));
254     assertTrue(list2.size() == 1 && !list1.contains(3));
255     assertEquals(2, list3.size());
256   }
257
258   private static final Integer[] arr1 = {1, 2, 3, 4, 5};
259   private static final Integer[] arr2 = {11, 12, 13, 14, 15};
260   private static final Integer[] arr3 = {101, 102, 103, 104, 105};
261
262   private static Iterator<Integer> iter(final Integer[] arr) {
263     return Arrays.asList(arr).iterator();
264   }
265 }