1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17 package org.apache.commons.collections.primitives;
18
19 import java.io.Serializable;
20 import java.util.ArrayList;
21 import java.util.ConcurrentModificationException;
22 import java.util.List;
23
24 import org.apache.commons.collections.primitives.adapters.BaseTestList;
25 import org.apache.commons.collections.primitives.adapters.FloatListList;
26 import org.apache.commons.collections.primitives.adapters.ListFloatList;
27
28
29
30
31
32 public abstract class TestFloatList extends BaseTestList {
33
34
35
36
37 public TestFloatList(String testName) {
38 super(testName);
39 }
40
41
42
43
44
45
46
47 protected abstract FloatList makeEmptyFloatList();
48
49 protected FloatList makeFullFloatList() {
50 FloatList list = makeEmptyFloatList();
51 float[] values = getFullFloats();
52 for(int i=0;i<values.length;i++) {
53 list.add(values[i]);
54 }
55 return list;
56 }
57
58 protected float[] getFullFloats() {
59 float[] result = new float[19];
60 for(int i = 0; i < result.length; i++) {
61 result[i] = (float)(i);
62 }
63 return result;
64 }
65
66 protected float[] getOtherFloats() {
67 float[] result = new float[16];
68 for(int i = 0; i < result.length; i++) {
69 result[i] = (float)(i + 43);
70 }
71 return result;
72 }
73
74
75
76
77 public List makeEmptyList() {
78 return new FloatListList(makeEmptyFloatList());
79 }
80
81 public Object[] getFullElements() {
82 return wrapArray(getFullFloats());
83 }
84
85 public Object[] getOtherElements() {
86 return wrapArray(getOtherFloats());
87 }
88
89
90
91
92 private Float[] wrapArray(float[] primitives) {
93 Float[] result = new Float[primitives.length];
94 for(int i=0;i<result.length;i++) {
95 result[i] = new Float(primitives[i]);
96 }
97 return result;
98 }
99
100
101
102
103 public void testExceptionOnConcurrentModification() {
104 FloatList list = makeFullFloatList();
105 FloatIterator iter = list.iterator();
106 iter.next();
107 list.add((float)3);
108 try {
109 iter.next();
110 fail("Expected ConcurrentModificationException");
111 } catch(ConcurrentModificationException e) {
112
113 }
114 }
115
116 public void testAddAllFloatListAtIndex() {
117 FloatList source = makeFullFloatList();
118 FloatList dest = makeFullFloatList();
119 dest.addAll(1,source);
120
121 FloatIterator iter = dest.iterator();
122 assertTrue(iter.hasNext());
123 assertEquals(source.get(0),iter.next(),0d);
124 for(int i=0;i<source.size();i++) {
125 assertTrue(iter.hasNext());
126 assertEquals(source.get(i),iter.next(),0d);
127 }
128 for(int i=1;i<source.size();i++) {
129 assertTrue(iter.hasNext());
130 assertEquals(source.get(i),iter.next(),0d);
131 }
132 assertFalse(iter.hasNext());
133 }
134
135 public void testToJustBigEnoughFloatArray() {
136 FloatList list = makeFullFloatList();
137 float[] dest = new float[list.size()];
138 assertSame(dest,list.toArray(dest));
139 int i=0;
140 for(FloatIterator iter = list.iterator(); iter.hasNext();i++) {
141 assertEquals(iter.next(),dest[i], 0f);
142 }
143 }
144
145 public void testToLargerThanNeededFloatArray() {
146 FloatList list = makeFullFloatList();
147 float[] dest = new float[list.size()*2];
148 for(int i=0;i<dest.length;i++) {
149 dest[i] = Float.MAX_VALUE;
150 }
151 assertSame(dest,list.toArray(dest));
152 int i=0;
153 for(FloatIterator iter = list.iterator(); iter.hasNext();i++) {
154 assertEquals(iter.next(),dest[i], 0f);
155 }
156 for(;i<dest.length;i++) {
157 assertEquals(Float.MAX_VALUE,dest[i], 0f);
158 }
159 }
160
161 public void testToSmallerThanNeededFloatArray() {
162 FloatList list = makeFullFloatList();
163 float[] dest = new float[list.size()/2];
164 float[] dest2 = list.toArray(dest);
165 assertTrue(dest != dest2);
166 int i=0;
167 for(FloatIterator iter = list.iterator(); iter.hasNext();i++) {
168 assertEquals(iter.next(),dest2[i], 0f);
169 }
170 }
171
172 public void testHashCodeSpecification() {
173 FloatList list = makeFullFloatList();
174 int hash = 1;
175 for(FloatIterator iter = list.iterator(); iter.hasNext(); ) {
176 hash = 31*hash + Float.floatToIntBits(iter.next());
177 }
178 assertEquals(hash,list.hashCode());
179 }
180
181 public void testEqualsWithTwoFloatLists() {
182 FloatList one = makeEmptyFloatList();
183 assertEquals("Equals is reflexive on empty list",one,one);
184 FloatList two = makeEmptyFloatList();
185 assertEquals("Empty lists are equal",one,two);
186 assertEquals("Equals is symmetric on empty lists",two,one);
187
188 one.add((float)1);
189 assertEquals("Equals is reflexive on non empty list",one,one);
190 assertTrue(!one.equals(two));
191 assertTrue(!two.equals(one));
192
193 two.add((float)1);
194 assertEquals("Non empty lists are equal",one,two);
195 assertEquals("Equals is symmetric on non empty list",one,two);
196
197 one.add((float)1); one.add((float)2); one.add((float)3); one.add((float)5); one.add((float)8);
198 assertEquals("Equals is reflexive on larger non empty list",one,one);
199 assertTrue(!one.equals(two));
200 assertTrue(!two.equals(one));
201
202 two.add((float)1); two.add((float)2); two.add((float)3); two.add((float)5); two.add((float)8);
203 assertEquals("Larger non empty lists are equal",one,two);
204 assertEquals("Equals is symmetric on larger non empty list",two,one);
205
206 one.add((float)9);
207 two.add((float)10);
208 assertTrue(!one.equals(two));
209 assertTrue(!two.equals(one));
210
211 }
212
213 public void testFloatSubListEquals() {
214 FloatList one = makeEmptyFloatList();
215 assertEquals(one,one.subList(0,0));
216 assertEquals(one.subList(0,0),one);
217
218 one.add((float)1);
219 assertEquals(one,one.subList(0,1));
220 assertEquals(one.subList(0,1),one);
221
222 one.add((float)1); one.add((float)2); one.add((float)3); one.add((float)5); one.add((float)8);
223 assertEquals(one.subList(0,4),one.subList(0,4));
224 assertEquals(one.subList(3,5),one.subList(3,5));
225 }
226
227 public void testEqualsWithFloatListAndList() {
228 FloatList ilist = makeEmptyFloatList();
229 List list = new ArrayList();
230
231 assertTrue("Unwrapped, empty List should not be equal to empty FloatList.",!ilist.equals(list));
232 assertTrue("Unwrapped, empty FloatList should not be equal to empty List.",!list.equals(ilist));
233
234 assertEquals(new ListFloatList(list),ilist);
235 assertEquals(ilist,new ListFloatList(list));
236 assertEquals(new FloatListList(ilist),list);
237 assertEquals(list,new FloatListList(ilist));
238
239 ilist.add((float)1);
240 list.add(new Float((float)1));
241
242 assertTrue("Unwrapped, non-empty List is not equal to non-empty FloatList.",!ilist.equals(list));
243 assertTrue("Unwrapped, non-empty FloatList is not equal to non-empty List.",!list.equals(ilist));
244
245 assertEquals(new ListFloatList(list),ilist);
246 assertEquals(ilist,new ListFloatList(list));
247 assertEquals(new FloatListList(ilist),list);
248 assertEquals(list,new FloatListList(ilist));
249
250 ilist.add((float)1); ilist.add((float)2); ilist.add((float)3); ilist.add((float)5); ilist.add((float)8);
251 list.add(new Float((float)1)); list.add(new Float((float)2)); list.add(new Float((float)3)); list.add(new Float((float)5)); list.add(new Float((float)8));
252
253 assertTrue("Unwrapped, non-empty List is not equal to non-empty FloatList.",!ilist.equals(list));
254 assertTrue("Unwrapped, non-empty FloatList is not equal to non-empty List.",!list.equals(ilist));
255
256 assertEquals(new ListFloatList(list),ilist);
257 assertEquals(ilist,new ListFloatList(list));
258 assertEquals(new FloatListList(ilist),list);
259 assertEquals(list,new FloatListList(ilist));
260
261 }
262
263 public void testClearAndSize() {
264 FloatList list = makeEmptyFloatList();
265 assertEquals(0, list.size());
266 for(int i = 0; i < 100; i++) {
267 list.add((float)i);
268 }
269 assertEquals(100, list.size());
270 list.clear();
271 assertEquals(0, list.size());
272 }
273
274 public void testRemoveViaSubList() {
275 FloatList list = makeEmptyFloatList();
276 for(int i = 0; i < 100; i++) {
277 list.add((float)i);
278 }
279 FloatList sub = list.subList(25,75);
280 assertEquals(50,sub.size());
281 for(int i = 0; i < 50; i++) {
282 assertEquals(100-i,list.size());
283 assertEquals(50-i,sub.size());
284 assertEquals((float)(25+i),sub.removeElementAt(0), 0f);
285 assertEquals(50-i-1,sub.size());
286 assertEquals(100-i-1,list.size());
287 }
288 assertEquals(0,sub.size());
289 assertEquals(50,list.size());
290 }
291
292 public void testAddGet() {
293 FloatList list = makeEmptyFloatList();
294 for (int i = 0; i < 255; i++) {
295 list.add((float)i);
296 }
297 for (int i = 0; i < 255; i++) {
298 assertEquals((float)i, list.get(i), 0f);
299 }
300 }
301
302 public void testAddAndShift() {
303 FloatList list = makeEmptyFloatList();
304 list.add(0, (float)1);
305 assertEquals("Should have one entry", 1, list.size());
306 list.add((float)3);
307 list.add((float)4);
308 list.add(1, (float)2);
309 for(int i = 0; i < 4; i++) {
310 assertEquals("Should get entry back", (float)(i + 1), list.get(i), 0f);
311 }
312 list.add(0, (float)0);
313 for (int i = 0; i < 5; i++) {
314 assertEquals("Should get entry back", (float)i, list.get(i), 0f);
315 }
316 }
317
318 public void testIsSerializable() throws Exception {
319 FloatList list = makeFullFloatList();
320 assertTrue(list instanceof Serializable);
321 byte[] ser = writeExternalFormToBytes((Serializable)list);
322 FloatList deser = (FloatList)(readExternalFormFromBytes(ser));
323 assertEquals(list,deser);
324 assertEquals(deser,list);
325 }
326
327 public void testFloatListSerializeDeserializeThenCompare() throws Exception {
328 FloatList list = makeFullFloatList();
329 if(list instanceof Serializable) {
330 byte[] ser = writeExternalFormToBytes((Serializable)list);
331 FloatList deser = (FloatList)(readExternalFormFromBytes(ser));
332 assertEquals("obj != deserialize(serialize(obj))",list,deser);
333 }
334 }
335
336 public void testSubListsAreNotSerializable() throws Exception {
337 FloatList list = makeFullFloatList().subList(2,3);
338 assertTrue( ! (list instanceof Serializable) );
339 }
340
341 public void testSubListOutOfBounds() throws Exception {
342 try {
343 makeEmptyFloatList().subList(2,3);
344 fail("Expected IndexOutOfBoundsException");
345 } catch(IndexOutOfBoundsException e) {
346
347 }
348
349 try {
350 makeFullFloatList().subList(-1,3);
351 fail("Expected IndexOutOfBoundsException");
352 } catch(IndexOutOfBoundsException e) {
353
354 }
355
356
357 try {
358 makeFullFloatList().subList(5,2);
359 fail("Expected IllegalArgumentException");
360 } catch(IllegalArgumentException e) {
361
362 }
363
364 try {
365 makeFullFloatList().subList(2,makeFullFloatList().size()+2);
366 fail("Expected IndexOutOfBoundsException");
367 } catch(IndexOutOfBoundsException e) {
368
369 }
370 }
371
372 public void testListIteratorOutOfBounds() throws Exception {
373 try {
374 makeEmptyFloatList().listIterator(2);
375 fail("Expected IndexOutOfBoundsException");
376 } catch(IndexOutOfBoundsException e) {
377
378 }
379
380 try {
381 makeFullFloatList().listIterator(-1);
382 fail("Expected IndexOutOfBoundsException");
383 } catch(IndexOutOfBoundsException e) {
384
385 }
386
387 try {
388 makeFullFloatList().listIterator(makeFullFloatList().size()+2);
389 fail("Expected IndexOutOfBoundsException");
390 } catch(IndexOutOfBoundsException e) {
391
392 }
393 }
394
395 public void testListIteratorSetWithoutNext() throws Exception {
396 FloatListIterator iter = makeFullFloatList().listIterator();
397 try {
398 iter.set((float)3);
399 fail("Expected IllegalStateException");
400 } catch(IllegalStateException e) {
401
402 }
403 }
404
405 public void testListIteratorSetAfterRemove() throws Exception {
406 FloatListIterator iter = makeFullFloatList().listIterator();
407 iter.next();
408 iter.remove();
409 try {
410 iter.set((float)3);
411 fail("Expected IllegalStateException");
412 } catch(IllegalStateException e) {
413
414 }
415 }
416
417 }