001/* 002 * Licensed to the Apache Software Foundation (ASF) under one or more 003 * contributor license agreements. See the NOTICE file distributed with 004 * this work for additional information regarding copyright ownership. 005 * The ASF licenses this file to You under the Apache License, Version 2.0 006 * (the "License"); you may not use this file except in compliance with 007 * the License. You may obtain a copy of the License at 008 * 009 * http://www.apache.org/licenses/LICENSE-2.0 010 * 011 * Unless required by applicable law or agreed to in writing, software 012 * distributed under the License is distributed on an "AS IS" BASIS, 013 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 014 * See the License for the specific language governing permissions and 015 * limitations under the License. 016 */ 017package org.apache.commons.collections.primitives; 018 019import java.io.Serializable; 020import java.util.ArrayList; 021import java.util.ConcurrentModificationException; 022import java.util.List; 023 024import org.apache.commons.collections.primitives.adapters.BaseTestList; 025import org.apache.commons.collections.primitives.adapters.FloatListList; 026import org.apache.commons.collections.primitives.adapters.ListFloatList; 027 028/** 029 * @version $Revision: 480451 $ $Date: 2006-11-29 02:45:08 -0500 (Wed, 29 Nov 2006) $ 030 * @author Rodney Waldhoff 031 */ 032public abstract class TestFloatList extends BaseTestList { 033 034 // conventional 035 // ------------------------------------------------------------------------ 036 037 public TestFloatList(String testName) { 038 super(testName); 039 } 040 041 // collections testing framework 042 // ------------------------------------------------------------------------ 043 044 // collections testing framework: float list 045 // ------------------------------------------------------------------------ 046 047 protected abstract FloatList makeEmptyFloatList(); 048 049 protected FloatList makeFullFloatList() { 050 FloatList list = makeEmptyFloatList(); 051 float[] values = getFullFloats(); 052 for(int i=0;i<values.length;i++) { 053 list.add(values[i]); 054 } 055 return list; 056 } 057 058 protected float[] getFullFloats() { 059 float[] result = new float[19]; 060 for(int i = 0; i < result.length; i++) { 061 result[i] = (float)(i); 062 } 063 return result; 064 } 065 066 protected float[] getOtherFloats() { 067 float[] result = new float[16]; 068 for(int i = 0; i < result.length; i++) { 069 result[i] = (float)(i + 43); 070 } 071 return result; 072 } 073 074 // collections testing framework: inherited 075 // ------------------------------------------------------------------------ 076 077 public List makeEmptyList() { 078 return new FloatListList(makeEmptyFloatList()); 079 } 080 081 public Object[] getFullElements() { 082 return wrapArray(getFullFloats()); 083 } 084 085 public Object[] getOtherElements() { 086 return wrapArray(getOtherFloats()); 087 } 088 089 // private utils 090 // ------------------------------------------------------------------------ 091 092 private Float[] wrapArray(float[] primitives) { 093 Float[] result = new Float[primitives.length]; 094 for(int i=0;i<result.length;i++) { 095 result[i] = new Float(primitives[i]); 096 } 097 return result; 098 } 099 100 // tests 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 // expected 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 // expected 347 } 348 349 try { 350 makeFullFloatList().subList(-1,3); 351 fail("Expected IndexOutOfBoundsException"); 352 } catch(IndexOutOfBoundsException e) { 353 // expected 354 } 355 356 357 try { 358 makeFullFloatList().subList(5,2); 359 fail("Expected IllegalArgumentException"); 360 } catch(IllegalArgumentException e) { 361 // expected 362 } 363 364 try { 365 makeFullFloatList().subList(2,makeFullFloatList().size()+2); 366 fail("Expected IndexOutOfBoundsException"); 367 } catch(IndexOutOfBoundsException e) { 368 // expected 369 } 370 } 371 372 public void testListIteratorOutOfBounds() throws Exception { 373 try { 374 makeEmptyFloatList().listIterator(2); 375 fail("Expected IndexOutOfBoundsException"); 376 } catch(IndexOutOfBoundsException e) { 377 // expected 378 } 379 380 try { 381 makeFullFloatList().listIterator(-1); 382 fail("Expected IndexOutOfBoundsException"); 383 } catch(IndexOutOfBoundsException e) { 384 // expected 385 } 386 387 try { 388 makeFullFloatList().listIterator(makeFullFloatList().size()+2); 389 fail("Expected IndexOutOfBoundsException"); 390 } catch(IndexOutOfBoundsException e) { 391 // expected 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 // expected 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 // expected 414 } 415 } 416 417}