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.ByteListList; 026import org.apache.commons.collections.primitives.adapters.ListByteList; 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 TestByteList extends BaseTestList { 033 034 // conventional 035 // ------------------------------------------------------------------------ 036 037 public TestByteList(String testName) { 038 super(testName); 039 } 040 041 // collections testing framework 042 // ------------------------------------------------------------------------ 043 044 // collections testing framework: byte list 045 // ------------------------------------------------------------------------ 046 047 protected abstract ByteList makeEmptyByteList(); 048 049 protected ByteList makeFullByteList() { 050 ByteList list = makeEmptyByteList(); 051 byte[] values = getFullBytes(); 052 for(int i=0;i<values.length;i++) { 053 list.add(values[i]); 054 } 055 return list; 056 } 057 058 protected byte[] getFullBytes() { 059 byte[] result = new byte[19]; 060 for(int i = 0; i < result.length; i++) { 061 result[i] = (byte)(i); 062 } 063 return result; 064 } 065 066 protected byte[] getOtherBytes() { 067 byte[] result = new byte[16]; 068 for(int i = 0; i < result.length; i++) { 069 result[i] = (byte)(i + 43); 070 } 071 return result; 072 } 073 074 // collections testing framework: inherited 075 // ------------------------------------------------------------------------ 076 077 public List makeEmptyList() { 078 return new ByteListList(makeEmptyByteList()); 079 } 080 081 public Object[] getFullElements() { 082 return wrapArray(getFullBytes()); 083 } 084 085 public Object[] getOtherElements() { 086 return wrapArray(getOtherBytes()); 087 } 088 089 // private utils 090 // ------------------------------------------------------------------------ 091 092 private Byte[] wrapArray(byte[] primitives) { 093 Byte[] result = new Byte[primitives.length]; 094 for(int i=0;i<result.length;i++) { 095 result[i] = new Byte(primitives[i]); 096 } 097 return result; 098 } 099 100 // tests 101 // ------------------------------------------------------------------------ 102 103 public void testExceptionOnConcurrentModification() { 104 ByteList list = makeFullByteList(); 105 ByteIterator iter = list.iterator(); 106 iter.next(); 107 list.add((byte)3); 108 try { 109 iter.next(); 110 fail("Expected ConcurrentModificationException"); 111 } catch(ConcurrentModificationException e) { 112 // expected 113 } 114 } 115 116 public void testAddAllByteListAtIndex() { 117 ByteList source = makeFullByteList(); 118 ByteList dest = makeFullByteList(); 119 dest.addAll(1,source); 120 121 ByteIterator iter = dest.iterator(); 122 assertTrue(iter.hasNext()); 123 assertEquals(source.get(0),iter.next()); 124 for(int i=0;i<source.size();i++) { 125 assertTrue(iter.hasNext()); 126 assertEquals(source.get(i),iter.next()); 127 } 128 for(int i=1;i<source.size();i++) { 129 assertTrue(iter.hasNext()); 130 assertEquals(source.get(i),iter.next()); 131 } 132 assertFalse(iter.hasNext()); 133 } 134 135 public void testToJustBigEnoughByteArray() { 136 ByteList list = makeFullByteList(); 137 byte[] dest = new byte[list.size()]; 138 assertSame(dest,list.toArray(dest)); 139 int i=0; 140 for(ByteIterator iter = list.iterator(); iter.hasNext();i++) { 141 assertEquals(iter.next(),dest[i]); 142 } 143 } 144 145 public void testToLargerThanNeededByteArray() { 146 ByteList list = makeFullByteList(); 147 byte[] dest = new byte[list.size()*2]; 148 for(int i=0;i<dest.length;i++) { 149 dest[i] = Byte.MAX_VALUE; 150 } 151 assertSame(dest,list.toArray(dest)); 152 int i=0; 153 for(ByteIterator iter = list.iterator(); iter.hasNext();i++) { 154 assertEquals(iter.next(),dest[i]); 155 } 156 for(;i<dest.length;i++) { 157 assertEquals(Byte.MAX_VALUE,dest[i]); 158 } 159 } 160 161 public void testToSmallerThanNeededByteArray() { 162 ByteList list = makeFullByteList(); 163 byte[] dest = new byte[list.size()/2]; 164 byte[] dest2 = list.toArray(dest); 165 assertTrue(dest != dest2); 166 int i=0; 167 for(ByteIterator iter = list.iterator(); iter.hasNext();i++) { 168 assertEquals(iter.next(),dest2[i]); 169 } 170 } 171 172 public void testHashCodeSpecification() { 173 ByteList list = makeFullByteList(); 174 int hash = 1; 175 for(ByteIterator iter = list.iterator(); iter.hasNext(); ) { 176 hash = 31*hash + ((int)iter.next()); 177 } 178 assertEquals(hash,list.hashCode()); 179 } 180 181 public void testEqualsWithTwoByteLists() { 182 ByteList one = makeEmptyByteList(); 183 assertEquals("Equals is reflexive on empty list",one,one); 184 ByteList two = makeEmptyByteList(); 185 assertEquals("Empty lists are equal",one,two); 186 assertEquals("Equals is symmetric on empty lists",two,one); 187 188 one.add((byte)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((byte)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((byte)1); one.add((byte)2); one.add((byte)3); one.add((byte)5); one.add((byte)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((byte)1); two.add((byte)2); two.add((byte)3); two.add((byte)5); two.add((byte)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((byte)9); 207 two.add((byte)10); 208 assertTrue(!one.equals(two)); 209 assertTrue(!two.equals(one)); 210 211 } 212 213 public void testByteSubListEquals() { 214 ByteList one = makeEmptyByteList(); 215 assertEquals(one,one.subList(0,0)); 216 assertEquals(one.subList(0,0),one); 217 218 one.add((byte)1); 219 assertEquals(one,one.subList(0,1)); 220 assertEquals(one.subList(0,1),one); 221 222 one.add((byte)1); one.add((byte)2); one.add((byte)3); one.add((byte)5); one.add((byte)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 testEqualsWithByteListAndList() { 228 ByteList ilist = makeEmptyByteList(); 229 List list = new ArrayList(); 230 231 assertTrue("Unwrapped, empty List should not be equal to empty ByteList.",!ilist.equals(list)); 232 assertTrue("Unwrapped, empty ByteList should not be equal to empty List.",!list.equals(ilist)); 233 234 assertEquals(new ListByteList(list),ilist); 235 assertEquals(ilist,new ListByteList(list)); 236 assertEquals(new ByteListList(ilist),list); 237 assertEquals(list,new ByteListList(ilist)); 238 239 ilist.add((byte)1); 240 list.add(new Byte((byte)1)); 241 242 assertTrue("Unwrapped, non-empty List is not equal to non-empty ByteList.",!ilist.equals(list)); 243 assertTrue("Unwrapped, non-empty ByteList is not equal to non-empty List.",!list.equals(ilist)); 244 245 assertEquals(new ListByteList(list),ilist); 246 assertEquals(ilist,new ListByteList(list)); 247 assertEquals(new ByteListList(ilist),list); 248 assertEquals(list,new ByteListList(ilist)); 249 250 ilist.add((byte)1); ilist.add((byte)2); ilist.add((byte)3); ilist.add((byte)5); ilist.add((byte)8); 251 list.add(new Byte((byte)1)); list.add(new Byte((byte)2)); list.add(new Byte((byte)3)); list.add(new Byte((byte)5)); list.add(new Byte((byte)8)); 252 253 assertTrue("Unwrapped, non-empty List is not equal to non-empty ByteList.",!ilist.equals(list)); 254 assertTrue("Unwrapped, non-empty ByteList is not equal to non-empty List.",!list.equals(ilist)); 255 256 assertEquals(new ListByteList(list),ilist); 257 assertEquals(ilist,new ListByteList(list)); 258 assertEquals(new ByteListList(ilist),list); 259 assertEquals(list,new ByteListList(ilist)); 260 261 } 262 263 public void testClearAndSize() { 264 ByteList list = makeEmptyByteList(); 265 assertEquals(0, list.size()); 266 for(int i = 0; i < 100; i++) { 267 list.add((byte)i); 268 } 269 assertEquals(100, list.size()); 270 list.clear(); 271 assertEquals(0, list.size()); 272 } 273 274 public void testRemoveViaSubList() { 275 ByteList list = makeEmptyByteList(); 276 for(int i = 0; i < 100; i++) { 277 list.add((byte)i); 278 } 279 ByteList 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((byte)(25+i),sub.removeElementAt(0)); 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 ByteList list = makeEmptyByteList(); 294 for (int i = 0; i < 255; i++) { 295 list.add((byte)i); 296 } 297 for (int i = 0; i < 255; i++) { 298 assertEquals((byte)i, list.get(i)); 299 } 300 } 301 302 public void testAddAndShift() { 303 ByteList list = makeEmptyByteList(); 304 list.add(0, (byte)1); 305 assertEquals("Should have one entry", 1, list.size()); 306 list.add((byte)3); 307 list.add((byte)4); 308 list.add(1, (byte)2); 309 for(int i = 0; i < 4; i++) { 310 assertEquals("Should get entry back", (byte)(i + 1), list.get(i)); 311 } 312 list.add(0, (byte)0); 313 for (int i = 0; i < 5; i++) { 314 assertEquals("Should get entry back", (byte)i, list.get(i)); 315 } 316 } 317 318 public void testIsSerializable() throws Exception { 319 ByteList list = makeFullByteList(); 320 assertTrue(list instanceof Serializable); 321 byte[] ser = writeExternalFormToBytes((Serializable)list); 322 ByteList deser = (ByteList)(readExternalFormFromBytes(ser)); 323 assertEquals(list,deser); 324 assertEquals(deser,list); 325 } 326 327 public void testByteListSerializeDeserializeThenCompare() throws Exception { 328 ByteList list = makeFullByteList(); 329 if(list instanceof Serializable) { 330 byte[] ser = writeExternalFormToBytes((Serializable)list); 331 ByteList deser = (ByteList)(readExternalFormFromBytes(ser)); 332 assertEquals("obj != deserialize(serialize(obj))",list,deser); 333 } 334 } 335 336 public void testSubListsAreNotSerializable() throws Exception { 337 ByteList list = makeFullByteList().subList(2,3); 338 assertTrue( ! (list instanceof Serializable) ); 339 } 340 341 public void testSubListOutOfBounds() throws Exception { 342 try { 343 makeEmptyByteList().subList(2,3); 344 fail("Expected IndexOutOfBoundsException"); 345 } catch(IndexOutOfBoundsException e) { 346 // expected 347 } 348 349 try { 350 makeFullByteList().subList(-1,3); 351 fail("Expected IndexOutOfBoundsException"); 352 } catch(IndexOutOfBoundsException e) { 353 // expected 354 } 355 356 357 try { 358 makeFullByteList().subList(5,2); 359 fail("Expected IllegalArgumentException"); 360 } catch(IllegalArgumentException e) { 361 // expected 362 } 363 364 try { 365 makeFullByteList().subList(2,makeFullByteList().size()+2); 366 fail("Expected IndexOutOfBoundsException"); 367 } catch(IndexOutOfBoundsException e) { 368 // expected 369 } 370 } 371 372 public void testListIteratorOutOfBounds() throws Exception { 373 try { 374 makeEmptyByteList().listIterator(2); 375 fail("Expected IndexOutOfBoundsException"); 376 } catch(IndexOutOfBoundsException e) { 377 // expected 378 } 379 380 try { 381 makeFullByteList().listIterator(-1); 382 fail("Expected IndexOutOfBoundsException"); 383 } catch(IndexOutOfBoundsException e) { 384 // expected 385 } 386 387 try { 388 makeFullByteList().listIterator(makeFullByteList().size()+2); 389 fail("Expected IndexOutOfBoundsException"); 390 } catch(IndexOutOfBoundsException e) { 391 // expected 392 } 393 } 394 395 public void testListIteratorSetWithoutNext() throws Exception { 396 ByteListIterator iter = makeFullByteList().listIterator(); 397 try { 398 iter.set((byte)3); 399 fail("Expected IllegalStateException"); 400 } catch(IllegalStateException e) { 401 // expected 402 } 403 } 404 405 public void testListIteratorSetAfterRemove() throws Exception { 406 ByteListIterator iter = makeFullByteList().listIterator(); 407 iter.next(); 408 iter.remove(); 409 try { 410 iter.set((byte)3); 411 fail("Expected IllegalStateException"); 412 } catch(IllegalStateException e) { 413 // expected 414 } 415 } 416 417}