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