1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17 package org.apache.commons.collections4.set;
18
19 import java.util.ArrayList;
20 import java.util.Collection;
21 import java.util.HashSet;
22 import java.util.Iterator;
23 import java.util.List;
24 import java.util.Set;
25
26 import org.apache.commons.collections4.IteratorUtils;
27
28
29
30
31
32
33
34 public class ListOrderedSetTest<E>
35 extends AbstractSetTest<E> {
36
37 private static final Integer ZERO = Integer.valueOf(0);
38
39 private static final Integer ONE = Integer.valueOf(1);
40
41 private static final Integer TWO = Integer.valueOf(2);
42
43 private static final Integer THREE = Integer.valueOf(3);
44
45 public ListOrderedSetTest(final String testName) {
46 super(testName);
47 }
48
49 @Override
50 public ListOrderedSet<E> makeObject() {
51 return ListOrderedSet.listOrderedSet(new HashSet<E>());
52 }
53
54 @SuppressWarnings("unchecked")
55 protected ListOrderedSet<E> setupSet() {
56 final ListOrderedSet<E> set = makeObject();
57
58 for (int i = 0; i < 10; i++) {
59 set.add((E) Integer.toString(i));
60 }
61 return set;
62 }
63
64 @SuppressWarnings("unchecked")
65 public void testOrdering() {
66 final ListOrderedSet<E> set = setupSet();
67 Iterator<E> it = set.iterator();
68
69 for (int i = 0; i < 10; i++) {
70 assertEquals("Sequence is wrong", Integer.toString(i), it.next());
71 }
72
73 for (int i = 0; i < 10; i += 2) {
74 assertTrue("Must be able to remove int",
75 set.remove(Integer.toString(i)));
76 }
77
78 it = set.iterator();
79 for (int i = 1; i < 10; i += 2) {
80 assertEquals("Sequence is wrong after remove ",
81 Integer.toString(i), it.next());
82 }
83
84 for (int i = 0; i < 10; i++) {
85 set.add((E) Integer.toString(i));
86 }
87
88 assertEquals("Size of set is wrong!", 10, set.size());
89
90 it = set.iterator();
91 for (int i = 1; i < 10; i += 2) {
92 assertEquals("Sequence is wrong", Integer.toString(i), it.next());
93 }
94 for (int i = 0; i < 10; i += 2) {
95 assertEquals("Sequence is wrong", Integer.toString(i), it.next());
96 }
97 }
98
99 @SuppressWarnings("unchecked")
100 public void testListAddRemove() {
101 final ListOrderedSet<E> set = makeObject();
102 final List<E> view = set.asList();
103 set.add((E) ZERO);
104 set.add((E) ONE);
105 set.add((E) TWO);
106
107 assertEquals(3, set.size());
108 assertSame(ZERO, set.get(0));
109 assertSame(ONE, set.get(1));
110 assertSame(TWO, set.get(2));
111 assertEquals(3, view.size());
112 assertSame(ZERO, view.get(0));
113 assertSame(ONE, view.get(1));
114 assertSame(TWO, view.get(2));
115
116 assertEquals(0, set.indexOf(ZERO));
117 assertEquals(1, set.indexOf(ONE));
118 assertEquals(2, set.indexOf(TWO));
119
120 set.remove(1);
121 assertEquals(2, set.size());
122 assertSame(ZERO, set.get(0));
123 assertSame(TWO, set.get(1));
124 assertEquals(2, view.size());
125 assertSame(ZERO, view.get(0));
126 assertSame(TWO, view.get(1));
127 }
128
129 @SuppressWarnings("unchecked")
130 public void testListAddIndexed() {
131 final ListOrderedSet<E> set = makeObject();
132 set.add((E) ZERO);
133 set.add((E) TWO);
134
135 set.add(1, (E) ONE);
136 assertEquals(3, set.size());
137 assertSame(ZERO, set.get(0));
138 assertSame(ONE, set.get(1));
139 assertSame(TWO, set.get(2));
140
141 set.add(0, (E) ONE);
142 assertEquals(3, set.size());
143 assertSame(ZERO, set.get(0));
144 assertSame(ONE, set.get(1));
145 assertSame(TWO, set.get(2));
146
147 final List<E> list = new ArrayList<>();
148 list.add((E) ZERO);
149 list.add((E) TWO);
150
151 set.addAll(0, list);
152 assertEquals(3, set.size());
153 assertSame(ZERO, set.get(0));
154 assertSame(ONE, set.get(1));
155 assertSame(TWO, set.get(2));
156
157 list.add(0, (E) THREE);
158 set.remove(TWO);
159 set.addAll(1, list);
160 assertEquals(4, set.size());
161 assertSame(ZERO, set.get(0));
162 assertSame(THREE, set.get(1));
163 assertSame(TWO, set.get(2));
164 assertSame(ONE, set.get(3));
165 }
166
167 @SuppressWarnings("unchecked")
168 public void testListAddReplacing() {
169 final ListOrderedSet<E> set = makeObject();
170 final A a = new A();
171 final B b = new B();
172 set.add((E) a);
173 assertEquals(1, set.size());
174 set.add((E) b);
175 assertEquals(1, set.size());
176 assertSame(a, set.decorated().iterator().next());
177 assertSame(a, set.iterator().next());
178 assertSame(a, set.get(0));
179 assertSame(a, set.asList().get(0));
180 }
181
182 @SuppressWarnings("unchecked")
183 public void testRetainAll() {
184 final List<E> list = new ArrayList<>(10);
185 final Set<E> set = new HashSet<>(10);
186 final ListOrderedSet<E> orderedSet = ListOrderedSet.listOrderedSet(set, list);
187 for (int i = 0; i < 10; ++i) {
188 orderedSet.add((E) Integer.valueOf(10 - i - 1));
189 }
190
191 final Collection<E> retained = new ArrayList<>(5);
192 for (int i = 0; i < 5; ++i) {
193 retained.add((E) Integer.valueOf(i * 2));
194 }
195
196 assertTrue(orderedSet.retainAll(retained));
197 assertEquals(5, orderedSet.size());
198
199 assertEquals(Integer.valueOf(8), orderedSet.get(0));
200 assertEquals(Integer.valueOf(6), orderedSet.get(1));
201 assertEquals(Integer.valueOf(4), orderedSet.get(2));
202 assertEquals(Integer.valueOf(2), orderedSet.get(3));
203 assertEquals(Integer.valueOf(0), orderedSet.get(4));
204 }
205
206 @SuppressWarnings("unchecked")
207 public void testDuplicates() {
208 final List<E> list = new ArrayList<>(10);
209 list.add((E) Integer.valueOf(1));
210 list.add((E) Integer.valueOf(2));
211 list.add((E) Integer.valueOf(3));
212 list.add((E) Integer.valueOf(1));
213
214 final ListOrderedSet<E> orderedSet = ListOrderedSet.listOrderedSet(list);
215
216 assertEquals(3, orderedSet.size());
217 assertEquals(3, IteratorUtils.toArray(orderedSet.iterator()).length);
218
219
220 assertEquals(Integer.valueOf(1), orderedSet.get(0));
221 assertEquals(Integer.valueOf(2), orderedSet.get(1));
222 assertEquals(Integer.valueOf(3), orderedSet.get(2));
223 }
224
225 static class A {
226
227 @Override
228 public boolean equals(final Object obj) {
229 return obj instanceof A || obj instanceof B;
230 }
231
232 @Override
233 public int hashCode() {
234 return 1;
235 }
236 }
237
238 static class B {
239
240 @Override
241 public boolean equals(final Object obj) {
242 return obj instanceof A || obj instanceof B;
243 }
244
245 @Override
246 public int hashCode() {
247 return 1;
248 }
249 }
250
251 public void testDecorator() {
252 try {
253 ListOrderedSet.listOrderedSet((List<E>) null);
254 fail();
255 } catch (final NullPointerException ex) {
256 }
257 try {
258 ListOrderedSet.listOrderedSet((Set<E>) null);
259 fail();
260 } catch (final NullPointerException ex) {
261 }
262 try {
263 ListOrderedSet.listOrderedSet(null, null);
264 fail();
265 } catch (final NullPointerException ex) {
266 }
267 try {
268 ListOrderedSet.listOrderedSet(new HashSet<E>(), null);
269 fail();
270 } catch (final NullPointerException ex) {
271 }
272 try {
273 ListOrderedSet.listOrderedSet(null, new ArrayList<E>());
274 fail();
275 } catch (final NullPointerException ex) {
276 }
277 }
278
279 @Override
280 public String getCompatibilityVersion() {
281 return "4";
282 }
283
284
285
286
287
288
289
290
291 }