KickJava   Java API By Example, From Geeks To Geeks.

Java > Open Source Codes > org > apache > commons > collections > primitives > TestByteList


1 /*
2  * Licensed to the Apache Software Foundation (ASF) under one or more
3  * contributor license agreements. See the NOTICE file distributed with
4  * this work for additional information regarding copyright ownership.
5  * The ASF licenses this file to You under the Apache License, Version 2.0
6  * (the "License"); you may not use this file except in compliance with
7  * the License. You may obtain a copy of the License at
8  *
9  * http://www.apache.org/licenses/LICENSE-2.0
10  *
11  * Unless required by applicable law or agreed to in writing, software
12  * distributed under the License is distributed on an "AS IS" BASIS,
13  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14  * See the License for the specific language governing permissions and
15  * limitations under the License.
16  */

17 package org.apache.commons.collections.primitives;
18
19 import java.io.Serializable JavaDoc;
20 import java.util.ArrayList JavaDoc;
21 import java.util.ConcurrentModificationException JavaDoc;
22 import java.util.List JavaDoc;
23
24 import org.apache.commons.collections.primitives.adapters.BaseTestList;
25 import org.apache.commons.collections.primitives.adapters.ByteListList;
26 import org.apache.commons.collections.primitives.adapters.ListByteList;
27
28 /**
29  * @version $Revision: 480451 $ $Date: 2006-11-28 23:45:08 -0800 (Tue, 28 Nov 2006) $
30  * @author Rodney Waldhoff
31  */

32 public abstract class TestByteList extends BaseTestList {
33
34     // conventional
35
// ------------------------------------------------------------------------
36

37     public TestByteList(String JavaDoc testName) {
38         super(testName);
39     }
40
41     // collections testing framework
42
// ------------------------------------------------------------------------
43

44     // collections testing framework: byte list
45
// ------------------------------------------------------------------------
46

47     protected abstract ByteList makeEmptyByteList();
48
49     protected ByteList makeFullByteList() {
50         ByteList list = makeEmptyByteList();
51         byte[] values = getFullBytes();
52         for(int i=0;i<values.length;i++) {
53             list.add(values[i]);
54         }
55         return list;
56     }
57
58     protected byte[] getFullBytes() {
59         byte[] result = new byte[19];
60         for(int i = 0; i < result.length; i++) {
61             result[i] = (byte)(i);
62         }
63         return result;
64     }
65
66     protected byte[] getOtherBytes() {
67         byte[] result = new byte[16];
68         for(int i = 0; i < result.length; i++) {
69             result[i] = (byte)(i + 43);
70         }
71         return result;
72     }
73     
74     // collections testing framework: inherited
75
// ------------------------------------------------------------------------
76

77     public List JavaDoc makeEmptyList() {
78         return new ByteListList(makeEmptyByteList());
79     }
80         
81     public Object JavaDoc[] getFullElements() {
82         return wrapArray(getFullBytes());
83     }
84
85     public Object JavaDoc[] getOtherElements() {
86         return wrapArray(getOtherBytes());
87     }
88
89     // private utils
90
// ------------------------------------------------------------------------
91

92     private Byte JavaDoc[] wrapArray(byte[] primitives) {
93         Byte JavaDoc[] result = new Byte JavaDoc[primitives.length];
94         for(int i=0;i<result.length;i++) {
95             result[i] = new Byte JavaDoc(primitives[i]);
96         }
97         return result;
98     }
99
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 JavaDoc 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 JavaDoc list = new ArrayList JavaDoc();
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 JavaDoc((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 JavaDoc((byte)1)); list.add(new Byte JavaDoc((byte)2)); list.add(new Byte JavaDoc((byte)3)); list.add(new Byte JavaDoc((byte)5)); list.add(new Byte JavaDoc((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 JavaDoc {
319         ByteList list = makeFullByteList();
320         assertTrue(list instanceof Serializable JavaDoc);
321         byte[] ser = writeExternalFormToBytes((Serializable JavaDoc)list);
322         ByteList deser = (ByteList)(readExternalFormFromBytes(ser));
323         assertEquals(list,deser);
324         assertEquals(deser,list);
325     }
326
327     public void testByteListSerializeDeserializeThenCompare() throws Exception JavaDoc {
328         ByteList list = makeFullByteList();
329         if(list instanceof Serializable JavaDoc) {
330             byte[] ser = writeExternalFormToBytes((Serializable JavaDoc)list);
331             ByteList deser = (ByteList)(readExternalFormFromBytes(ser));
332             assertEquals("obj != deserialize(serialize(obj))",list,deser);
333         }
334     }
335
336     public void testSubListsAreNotSerializable() throws Exception JavaDoc {
337         ByteList list = makeFullByteList().subList(2,3);
338         assertTrue( ! (list instanceof Serializable JavaDoc) );
339     }
340
341     public void testSubListOutOfBounds() throws Exception JavaDoc {
342         try {
343             makeEmptyByteList().subList(2,3);
344             fail("Expected IndexOutOfBoundsException");
345         } catch(IndexOutOfBoundsException JavaDoc e) {
346             // expected
347
}
348
349         try {
350             makeFullByteList().subList(-1,3);
351             fail("Expected IndexOutOfBoundsException");
352         } catch(IndexOutOfBoundsException JavaDoc e) {
353             // expected
354
}
355
356
357         try {
358             makeFullByteList().subList(5,2);
359             fail("Expected IllegalArgumentException");
360         } catch(IllegalArgumentException JavaDoc e) {
361             // expected
362
}
363
364         try {
365             makeFullByteList().subList(2,makeFullByteList().size()+2);
366             fail("Expected IndexOutOfBoundsException");
367         } catch(IndexOutOfBoundsException JavaDoc e) {
368             // expected
369
}
370     }
371
372     public void testListIteratorOutOfBounds() throws Exception JavaDoc {
373         try {
374             makeEmptyByteList().listIterator(2);
375             fail("Expected IndexOutOfBoundsException");
376         } catch(IndexOutOfBoundsException JavaDoc e) {
377             // expected
378
}
379
380         try {
381             makeFullByteList().listIterator(-1);
382             fail("Expected IndexOutOfBoundsException");
383         } catch(IndexOutOfBoundsException JavaDoc e) {
384             // expected
385
}
386
387         try {
388             makeFullByteList().listIterator(makeFullByteList().size()+2);
389             fail("Expected IndexOutOfBoundsException");
390         } catch(IndexOutOfBoundsException JavaDoc e) {
391             // expected
392
}
393     }
394
395     public void testListIteratorSetWithoutNext() throws Exception JavaDoc {
396         ByteListIterator iter = makeFullByteList().listIterator();
397         try {
398             iter.set((byte)3);
399             fail("Expected IllegalStateException");
400         } catch(IllegalStateException JavaDoc e) {
401             // expected
402
}
403     }
404
405     public void testListIteratorSetAfterRemove() throws Exception JavaDoc {
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 JavaDoc e) {
413             // expected
414
}
415     }
416
417 }
418
Popular Tags