Java > Open Source Codes > org > apache > commons > lang > ArrayUtilsTest


1 /*
2  * Copyright 2002-2005 The Apache Software Foundation.
3  *
4  * Licensed under the Apache License, Version 2.0 (the "License");
5  * you may not use this file except in compliance with the License.
6  * You may obtain a copy of the License at
7  *
8  * http://www.apache.org/licenses/LICENSE-2.0
9  *
10  * Unless required by applicable law or agreed to in writing, software
11  * distributed under the License is distributed on an "AS IS" BASIS,
12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13  * See the License for the specific language governing permissions and
14  * limitations under the License.
15  */
16 package org.apache.commons.lang;
17
18 import java.lang.reflect.Constructor ;
19 import java.lang.reflect.Modifier ;
20 import java.util.Arrays ;
21 import java.util.Date ;
22 import java.util.Map ;
23
24 import junit.framework.Test;
25 import junit.framework.TestCase;
26 import junit.framework.TestSuite;
27 import junit.textui.TestRunner;
28
29 /**
30  * Unit tests {@link org.apache.commons.lang.ArrayUtils}.
31  *
32  * @author Stephen Colebourne
33  * @author Moritz Petersen
34  * @author Nikolay Metchev
35  * @author Matthew Hawthorne
36  * @author Tim O'Brien
37  * @author <a HREF="mailto:equinus100@hotmail.com">Ashwin S</a>
38  * @author Fredrik Westermarck
39  * @author Gary Gregory
40  * @author Maarten Coene
41  * @version $Id: ArrayUtilsTest.java 161244 2005-04-14 06:16:36Z ggregory $
42  */
43 public class ArrayUtilsTest extends TestCase {
44
45     public ArrayUtilsTest(String name) {
46         super(name);
47     }
48
49     public static void main(String [] args) {
50         TestRunner.run(suite());
51     }
52
53     public static Test suite() {
54         TestSuite suite = new TestSuite(ArrayUtilsTest.class);
55         suite.setName("ArrayUtils Tests");
56         return suite;
57     }
58
59     protected void setUp() throws Exception {
60         super.setUp();
61     }
62
63     protected void tearDown() throws Exception {
64         super.tearDown();
65     }
66
67     //-----------------------------------------------------------------------
68 public void testConstructor() {
69         assertNotNull(new ArrayUtils());
70         Constructor [] cons = ArrayUtils.class.getDeclaredConstructors();
71         assertEquals(1, cons.length);
72         assertEquals(true, Modifier.isPublic(cons[0].getModifiers()));
73         assertEquals(true, Modifier.isPublic(ArrayUtils.class.getModifiers()));
74         assertEquals(false, Modifier.isFinal(ArrayUtils.class.getModifiers()));
75     }
76     
77     //-----------------------------------------------------------------------
78 public void testToString() {
79         assertEquals("{}", ArrayUtils.toString(null));
80         assertEquals("{}", ArrayUtils.toString(new Object [0]));
81         assertEquals("{}", ArrayUtils.toString(new String [0]));
82         assertEquals("{<null>}", ArrayUtils.toString(new String [] {null}));
83         assertEquals("{pink,blue}", ArrayUtils.toString(new String [] {"pink","blue"}));
84         
85         assertEquals("<empty>", ArrayUtils.toString(null, "<empty>"));
86         assertEquals("{}", ArrayUtils.toString(new Object [0], "<empty>"));
87         assertEquals("{}", ArrayUtils.toString(new String [0], "<empty>"));
88         assertEquals("{<null>}", ArrayUtils.toString(new String [] {null}, "<empty>"));
89         assertEquals("{pink,blue}", ArrayUtils.toString(new String [] {"pink","blue"}, "<empty>"));
90     }
91
92     //-----------------------------------------------------------------------
93 public void testHashCode() {
94         long[][] array1 = new long[][] {{2,5}, {4,5}};
95         long[][] array2 = new long[][] {{2,5}, {4,6}};
96         assertEquals(true, ArrayUtils.hashCode(array1) == ArrayUtils.hashCode(array1));
97         assertEquals(false, ArrayUtils.hashCode(array1) == ArrayUtils.hashCode(array2));
98         
99         Object [] array3 = new Object [] {new String (new char[] {'A', 'B'})};
100         Object [] array4 = new Object [] {"AB"};
101         assertEquals(true, ArrayUtils.hashCode(array3) == ArrayUtils.hashCode(array3));
102         assertEquals(true, ArrayUtils.hashCode(array3) == ArrayUtils.hashCode(array4));
103     }
104
105     //-----------------------------------------------------------------------
106 private void assertIsEquals(Object array1, Object array2, Object array3) {
107         assertEquals(true, ArrayUtils.isEquals(array1, array1));
108         assertEquals(true, ArrayUtils.isEquals(array2, array2));
109         assertEquals(true, ArrayUtils.isEquals(array3, array3));
110         assertEquals(false, ArrayUtils.isEquals(array1, array2));
111         assertEquals(false, ArrayUtils.isEquals(array2, array1));
112         assertEquals(false, ArrayUtils.isEquals(array1, array3));
113         assertEquals(false, ArrayUtils.isEquals(array3, array1));
114         assertEquals(false, ArrayUtils.isEquals(array1, array2));
115         assertEquals(false, ArrayUtils.isEquals(array2, array1));
116     }
117
118     public void testIsEquals() {
119         long[][] larray1 = new long[][]{{2, 5}, {4, 5}};
120         long[][] larray2 = new long[][]{{2, 5}, {4, 6}};
121         long[] larray3 = new long[]{2, 5};
122         this.assertIsEquals(larray1, larray2, larray3);
123
124         int[][] iarray1 = new int[][]{{2, 5}, {4, 5}};
125         int[][] iarray2 = new int[][]{{2, 5}, {4, 6}};
126         int[] iarray3 = new int[]{2, 5};
127         this.assertIsEquals(iarray1, iarray2, iarray3);
128
129         short[][] sarray1 = new short[][]{{2, 5}, {4, 5}};
130         short[][] sarray2 = new short[][]{{2, 5}, {4, 6}};
131         short[] sarray3 = new short[]{2, 5};
132         this.assertIsEquals(sarray1, sarray2, sarray3);
133
134         float[][] farray1 = new float[][]{{2, 5}, {4, 5}};
135         float[][] farray2 = new float[][]{{2, 5}, {4, 6}};
136         float[] farray3 = new float[]{2, 5};
137         this.assertIsEquals(farray1, farray2, farray3);
138
139         double[][] darray1 = new double[][]{{2, 5}, {4, 5}};
140         double[][] darray2 = new double[][]{{2, 5}, {4, 6}};
141         double[] darray3 = new double[]{2, 5};
142         this.assertIsEquals(darray1, darray2, darray3);
143
144         byte[][] byteArray1 = new byte[][]{{2, 5}, {4, 5}};
145         byte[][] byteArray2 = new byte[][]{{2, 5}, {4, 6}};
146         byte[] byteArray3 = new byte[]{2, 5};
147         this.assertIsEquals(byteArray1, byteArray2, byteArray3);
148
149         char[][] charArray1 = new char[][]{{2, 5}, {4, 5}};
150         char[][] charArray2 = new char[][]{{2, 5}, {4, 6}};
151         char[] charArray3 = new char[]{2, 5};
152         this.assertIsEquals(charArray1, charArray2, charArray3);
153
154         boolean[][] barray1 = new boolean[][]{{true, false}, {true, true}};
155         boolean[][] barray2 = new boolean[][]{{true, false}, {true, false}};
156         boolean[] barray3 = new boolean[]{false, true};
157         this.assertIsEquals(barray1, barray2, barray3);
158
159         Object [] array3 = new Object []{new String (new char[]{'A', 'B'})};
160         Object [] array4 = new Object []{"AB"};
161         assertEquals(true, ArrayUtils.isEquals(array3, array3));
162         assertEquals(true, ArrayUtils.isEquals(array3, array4));
163
164         assertEquals(true, ArrayUtils.isEquals(null, null));
165         assertEquals(false, ArrayUtils.isEquals(null, array4));
166     }
167     
168     //-----------------------------------------------------------------------
169 public void testToMap() {
170         Map map = ArrayUtils.toMap(new String [][] {{"foo", "bar"}, {"hello", "world"}});
171         
172         assertEquals("bar", map.get("foo"));
173         assertEquals("world", map.get("hello"));
174         
175         assertEquals(null, ArrayUtils.toMap(null));
176         try {
177             ArrayUtils.toMap(new String [][] {{"foo", "bar"}, {"short"}});
178             fail("exception expected");
179         } catch (IllegalArgumentException ex) {}
180         try {
181             ArrayUtils.toMap(new Object [] {new Object [] {"foo", "bar"}, "illegal type"});
182             fail("exception expected");
183         } catch (IllegalArgumentException ex) {}
184         try {
185             ArrayUtils.toMap(new Object [] {new Object [] {"foo", "bar"}, null});
186             fail("exception expected");
187         } catch (IllegalArgumentException ex) {}
188         
189         map = ArrayUtils.toMap(new Object [] {new Map.Entry () {
190             public Object getKey() {
191                 return "foo";
192             }
193             public Object getValue() {
194                 return "bar";
195             }
196             public Object setValue(Object value) {
197                 throw new UnsupportedOperationException ();
198             }
199             public boolean equals(Object o) {
200                 throw new UnsupportedOperationException ();
201             }
202             public int hashCode() {
203                 throw new UnsupportedOperationException ();
204             }
205         }});
206         assertEquals("bar", map.get("foo"));
207     }
208
209     //-----------------------------------------------------------------------
210 public void testClone() {
211         assertEquals(null, ArrayUtils.clone((Object []) null));
212         Object [] original1 = new Object [0];
213         Object [] cloned1 = ArrayUtils.clone(original1);
214         assertTrue(Arrays.equals(original1, cloned1));
215         assertTrue(original1 != cloned1);
216         
217         StringBuffer buf = new StringBuffer ("pick");
218         original1 = new Object [] {buf, "a", new String [] {"stick"}};
219         cloned1 = ArrayUtils.clone(original1);
220         assertTrue(Arrays.equals(original1, cloned1));
221         assertTrue(original1 != cloned1);
222         assertSame(original1[0], cloned1[0]);
223         assertSame(original1[1], cloned1[1]);
224         assertSame(original1[2], cloned1[2]);
225     }
226
227     public void testCloneBoolean() {
228         assertEquals(null, ArrayUtils.clone((boolean[]) null));
229         boolean[] original = new boolean[] {true, false};
230         boolean[] cloned = ArrayUtils.clone(original);
231         assertTrue(Arrays.equals(original, cloned));
232         assertTrue(original != cloned);
233     }
234     
235     public void testCloneLong() {
236         assertEquals(null, ArrayUtils.clone((long[]) null));
237         long[] original = new long[] {0L, 1L};
238         long[] cloned = ArrayUtils.clone(original);
239         assertTrue(Arrays.equals(original, cloned));
240         assertTrue(original != cloned);
241     }
242     
243     public void testCloneInt() {
244         assertEquals(null, ArrayUtils.clone((int[]) null));
245         int[] original = new int[] {5, 8};
246         int[] cloned = ArrayUtils.clone(original);
247         assertTrue(Arrays.equals(original, cloned));
248         assertTrue(original != cloned);
249     }
250     
251     public void testCloneShort() {
252         assertEquals(null, ArrayUtils.clone((short[]) null));
253         short[] original = new short[] {1, 4};
254         short[] cloned = ArrayUtils.clone(original);
255         assertTrue(Arrays.equals(original, cloned));
256         assertTrue(original != cloned);
257     }
258     
259     public void testCloneChar() {
260         assertEquals(null, ArrayUtils.clone((char[]) null));
261         char[] original = new char[] {'a', '4'};
262         char[] cloned = ArrayUtils.clone(original);
263         assertTrue(Arrays.equals(original, cloned));
264         assertTrue(original != cloned);
265     }
266     
267     public void testCloneByte() {
268         assertEquals(null, ArrayUtils.clone((byte[]) null));
269         byte[] original = new byte[] {1, 6};
270         byte[] cloned = ArrayUtils.clone(original);
271         assertTrue(Arrays.equals(original, cloned));
272         assertTrue(original != cloned);
273     }
274     
275     public void testCloneDouble() {
276         assertEquals(null, ArrayUtils.clone((double[]) null));
277         double[] original = new double[] {2.4d, 5.7d};
278         double[] cloned = ArrayUtils.clone(original);
279         assertTrue(Arrays.equals(original, cloned));
280         assertTrue(original != cloned);
281     }
282     
283     public void testCloneFloat() {
284         assertEquals(null, ArrayUtils.clone((float[]) null));
285         float[] original = new float[] {2.6f, 6.4f};
286         float[] cloned = ArrayUtils.clone(original);
287         assertTrue(Arrays.equals(original, cloned));
288         assertTrue(original != cloned);
289     }
290
291     //-----------------------------------------------------------------------
292
293     public void testSubarrayObject() {
294         Object [] nullArray = null;
295         Object [] objectArray = { "a", "b", "c", "d", "e", "f"};
296
297         assertEquals("0 start, mid end", "abcd",
298             StringUtils.join(ArrayUtils.subarray(objectArray, 0, 4)));
299         assertEquals("0 start, length end", "abcdef",
300             StringUtils.join(ArrayUtils.subarray(objectArray, 0, objectArray.length)));
301         assertEquals("mid start, mid end", "bcd",
302             StringUtils.join(ArrayUtils.subarray(objectArray, 1, 4)));
303         assertEquals("mid start, length end", "bcdef",
304             StringUtils.join(ArrayUtils.subarray(objectArray, 1, objectArray.length)));
305
306         assertNull("null input", ArrayUtils.subarray(nullArray, 0, 3));
307         assertEquals("empty array", "",
308             StringUtils.join(ArrayUtils.subarray(ArrayUtils.EMPTY_OBJECT_ARRAY, 1, 2)));
309         assertEquals("start > end", "",
310             StringUtils.join(ArrayUtils.subarray(objectArray, 4, 2)));
311         assertEquals("start == end", "",
312             StringUtils.join(ArrayUtils.subarray(objectArray, 3, 3)));
313         assertEquals("start undershoot, normal end", "abcd",
314             StringUtils.join(ArrayUtils.subarray(objectArray, -2, 4)));
315         assertEquals("start overshoot, any end", "",
316             StringUtils.join(ArrayUtils.subarray(objectArray, 33, 4)));
317         assertEquals("normal start, end overshoot", "cdef",
318             StringUtils.join(ArrayUtils.subarray(objectArray, 2, 33)));
319         assertEquals("start undershoot, end overshoot", "abcdef",
320             StringUtils.join(ArrayUtils.subarray(objectArray, -2, 12)));
321             
322         // array type tests
323 Date [] dateArray = { new java.sql.Date (new Date ().getTime()),
324             new Date (), new Date (), new Date (), new Date () };
325
326         assertSame("Object type", Object .class,
327             ArrayUtils.subarray(objectArray, 2, 4).getClass().getComponentType());
328         assertSame("java.util.Date type", java.util.Date .class,
329             ArrayUtils.subarray(dateArray, 1, 4).getClass().getComponentType());
330         assertNotSame("java.sql.Date type", java.sql.Date .class,
331             ArrayUtils.subarray(dateArray, 1, 4).getClass().getComponentType());
332         try {
333             Object dummy = (java.sql.Date [])ArrayUtils.subarray(dateArray, 1,3);
334             fail("Invalid downcast");
335         } catch (ClassCastException e) {}
336     }
337
338     public void testSubarrayLong() {
339         long[] nullArray = null;
340         long[] array = { 999910, 999911, 999912, 999913, 999914, 999915 };
341         long[] leftSubarray = { 999910, 999911, 999912, 999913 };
342         long[] midSubarray = { 999911, 999912, 999913, 999914 };
343         long[] rightSubarray = { 999912, 999913, 999914, 999915 };
344
345         assertTrue("0 start, mid end",
346             ArrayUtils.isEquals(leftSubarray,
347                 ArrayUtils.subarray(array, 0, 4)));
348
349         assertTrue("0 start, length end",
350             ArrayUtils.isEquals(array,
351                 ArrayUtils.subarray(array, 0, array.length)));
352
353         assertTrue("mid start, mid end",
354             ArrayUtils.isEquals(midSubarray,
355                 ArrayUtils.subarray(array, 1, 5)));
356
357         assertTrue("mid start, length end",
358             ArrayUtils.isEquals(rightSubarray,
359                 ArrayUtils.subarray(array, 2, array.length)));
360
361
362         assertNull("null input", ArrayUtils.subarray(nullArray, 0, 3));
363
364         assertEquals("empty array", ArrayUtils.EMPTY_LONG_ARRAY,
365             ArrayUtils.subarray(ArrayUtils.EMPTY_LONG_ARRAY, 1, 2));
366
367         assertEquals("start > end", ArrayUtils.EMPTY_LONG_ARRAY,
368             ArrayUtils.subarray(array, 4, 2));
369
370         assertEquals("start == end", ArrayUtils.EMPTY_LONG_ARRAY,
371             ArrayUtils.subarray(array, 3, 3));
372
373         assertTrue("start undershoot, normal end",
374             ArrayUtils.isEquals(leftSubarray,
375                 ArrayUtils.subarray(array, -2, 4)));
376
377         assertEquals("start overshoot, any end",
378             ArrayUtils.EMPTY_LONG_ARRAY,
379                 ArrayUtils.subarray(array, 33, 4));
380
381         assertTrue("normal start, end overshoot",
382             ArrayUtils.isEquals(rightSubarray,
383                 ArrayUtils.subarray(array, 2, 33)));
384
385         assertTrue("start undershoot, end overshoot",
386             ArrayUtils.isEquals(array,
387                 ArrayUtils.subarray(array, -2, 12)));
388
389         // empty-return tests
390
391         assertSame("empty array, object test",
392             ArrayUtils.EMPTY_LONG_ARRAY,
393                 ArrayUtils.subarray(ArrayUtils.EMPTY_LONG_ARRAY, 1, 2));
394
395         assertSame("start > end, object test",
396             ArrayUtils.EMPTY_LONG_ARRAY,
397                 ArrayUtils.subarray(array, 4, 1));
398
399         assertSame("start == end, object test",
400             ArrayUtils.EMPTY_LONG_ARRAY,
401                 ArrayUtils.subarray(array, 3, 3));
402
403         assertSame("start overshoot, any end, object test",
404             ArrayUtils.EMPTY_LONG_ARRAY,
405                 ArrayUtils.subarray(array, 8733, 4));
406
407         // array type tests
408
409         assertSame("long type", long.class,
410             ArrayUtils.subarray(array, 2, 4).getClass().getComponentType());
411
412     }
413
414     public void testSubarrayInt() {
415         int[] nullArray = null;
416         int[] array = { 10, 11, 12, 13, 14, 15 };
417         int[] leftSubarray = { 10, 11, 12, 13 };
418         int[] midSubarray = { 11, 12, 13, 14 };
419         int[] rightSubarray = { 12, 13, 14, 15 };
420
421
422         assertTrue("0 start, mid end",
423             ArrayUtils.isEquals(leftSubarray,
424                 ArrayUtils.subarray(array, 0, 4)));
425
426         assertTrue("0 start, length end",
427             ArrayUtils.isEquals(array,
428                 ArrayUtils.subarray(array, 0, array.length)));
429
430         assertTrue("mid start, mid end",
431             ArrayUtils.isEquals(midSubarray,
432                 ArrayUtils.subarray(array, 1, 5)));
433
434         assertTrue("mid start, length end",
435             ArrayUtils.isEquals(rightSubarray,
436                 ArrayUtils.subarray(array, 2, array.length)));
437
438
439         assertNull("null input", ArrayUtils.subarray(nullArray, 0, 3));
440
441         assertEquals("empty array", ArrayUtils.EMPTY_INT_ARRAY,
442             ArrayUtils.subarray(ArrayUtils.EMPTY_INT_ARRAY, 1, 2));
443
444         assertEquals("start > end", ArrayUtils.EMPTY_INT_ARRAY,
445             ArrayUtils.subarray(array, 4, 2));
446
447         assertEquals("start == end", ArrayUtils.EMPTY_INT_ARRAY,
448             ArrayUtils.subarray(array, 3, 3));
449
450         assertTrue("start undershoot, normal end",
451             ArrayUtils.isEquals(leftSubarray,
452                 ArrayUtils.subarray(array, -2, 4)));
453
454         assertEquals("start overshoot, any end",
455             ArrayUtils.EMPTY_INT_ARRAY,
456                 ArrayUtils.subarray(array, 33, 4));
457
458         assertTrue("normal start, end overshoot",
459             ArrayUtils.isEquals(rightSubarray,
460                 ArrayUtils.subarray(array, 2, 33)));
461
462         assertTrue("start undershoot, end overshoot",
463             ArrayUtils.isEquals(array,
464                 ArrayUtils.subarray(array, -2, 12)));
465
466         // empty-return tests
467
468         assertSame("empty array, object test",
469             ArrayUtils.EMPTY_INT_ARRAY,
470                 ArrayUtils.subarray(ArrayUtils.EMPTY_INT_ARRAY, 1, 2));
471
472         assertSame("start > end, object test",
473             ArrayUtils.EMPTY_INT_ARRAY,
474                 ArrayUtils.subarray(array, 4, 1));
475
476         assertSame("start == end, object test",
477             ArrayUtils.EMPTY_INT_ARRAY,
478                 ArrayUtils.subarray(array, 3, 3));
479
480         assertSame("start overshoot, any end, object test",
481             ArrayUtils.EMPTY_INT_ARRAY,
482                 ArrayUtils.subarray(array, 8733, 4));
483
484         // array type tests
485
486         assertSame("int type", int.class,
487             ArrayUtils.subarray(array, 2, 4).getClass().getComponentType());
488
489     }
490
491     public void testSubarrayShort() {
492         short[] nullArray = null;
493         short[] array = { 10, 11, 12, 13, 14, 15 };
494         short[] leftSubarray = { 10, 11, 12, 13 };
495         short[] midSubarray = { 11, 12, 13, 14 };
496         short[] rightSubarray = { 12, 13, 14, 15 };
497
498
499         assertTrue("0 start, mid end",
500             ArrayUtils.isEquals(leftSubarray,
501                 ArrayUtils.subarray(array, 0, 4)));
502
503         assertTrue("0 start, length end",
504             ArrayUtils.isEquals(array,
505                 ArrayUtils.subarray(array, 0, array.length)));
506
507         assertTrue("mid start, mid end",
508             ArrayUtils.isEquals(midSubarray,
509                 ArrayUtils.subarray(array, 1, 5)));
510
511         assertTrue("mid start, length end",
512             ArrayUtils.isEquals(rightSubarray,
513                 ArrayUtils.subarray(array, 2, array.length)));
514
515
516         assertNull("null input", ArrayUtils.subarray(nullArray, 0, 3));
517
518         assertEquals("empty array", ArrayUtils.EMPTY_SHORT_ARRAY,
519             ArrayUtils.subarray(ArrayUtils.EMPTY_SHORT_ARRAY, 1, 2));
520
521         assertEquals("start > end", ArrayUtils.EMPTY_SHORT_ARRAY,
522             ArrayUtils.subarray(array, 4, 2));
523
524         assertEquals("start == end", ArrayUtils.EMPTY_SHORT_ARRAY,
525             ArrayUtils.subarray(array, 3, 3));
526
527         assertTrue("start undershoot, normal end",
528             ArrayUtils.isEquals(leftSubarray,
529                 ArrayUtils.subarray(array, -2, 4)));
530
531         assertEquals("start overshoot, any end",
532             ArrayUtils.EMPTY_SHORT_ARRAY,
533                 ArrayUtils.subarray(array, 33, 4));
534
535         assertTrue("normal start, end overshoot",
536             ArrayUtils.isEquals(rightSubarray,
537                 ArrayUtils.subarray(array, 2, 33)));
538
539         assertTrue("start undershoot, end overshoot",
540             ArrayUtils.isEquals(array,
541                 ArrayUtils.subarray(array, -2, 12)));
542
543         // empty-return tests
544
545         assertSame("empty array, object test",
546             ArrayUtils.EMPTY_SHORT_ARRAY,
547                 ArrayUtils.subarray(ArrayUtils.EMPTY_SHORT_ARRAY, 1, 2));
548
549         assertSame("start > end, object test",
550             ArrayUtils.EMPTY_SHORT_ARRAY,
551                 ArrayUtils.subarray(array, 4, 1));
552
553         assertSame("start == end, object test",
554             ArrayUtils.EMPTY_SHORT_ARRAY,
555                 ArrayUtils.subarray(array, 3, 3));
556
557         assertSame("start overshoot, any end, object test",
558             ArrayUtils.EMPTY_SHORT_ARRAY,
559                 ArrayUtils.subarray(array, 8733, 4));
560
561         // array type tests
562
563         assertSame("short type", short.class,
564             ArrayUtils.subarray(array, 2, 4).getClass().getComponentType());
565
566     }
567
568     public void testSubarrChar() {
569         char[] nullArray = null;
570         char[] array = { 'a', 'b', 'c', 'd', 'e', 'f' };
571         char[] leftSubarray = { 'a', 'b', 'c', 'd', };
572         char[] midSubarray = { 'b', 'c', 'd', 'e', };
573         char[] rightSubarray = { 'c', 'd', 'e', 'f', };
574
575
576         assertTrue("0 start, mid end",
577             ArrayUtils.isEquals(leftSubarray,
578                 ArrayUtils.subarray(array, 0, 4)));
579
580         assertTrue("0 start, length end",
581             ArrayUtils.isEquals(array,
582                 ArrayUtils.subarray(array, 0, array.length)));
583
584         assertTrue("mid start, mid end",
585             ArrayUtils.isEquals(midSubarray,
586                 ArrayUtils.subarray(array, 1, 5)));
587
588         assertTrue("mid start, length end",
589             ArrayUtils.isEquals(rightSubarray,
590                 ArrayUtils.subarray(array, 2, array.length)));
591
592
593         assertNull("null input", ArrayUtils.subarray(nullArray, 0, 3));
594
595         assertEquals("empty array", ArrayUtils.EMPTY_CHAR_ARRAY,
596             ArrayUtils.subarray(ArrayUtils.EMPTY_CHAR_ARRAY, 1, 2));
597
598         assertEquals("start > end", ArrayUtils.EMPTY_CHAR_ARRAY,
599             ArrayUtils.subarray(array, 4, 2));
600
601         assertEquals("start == end", ArrayUtils.EMPTY_CHAR_ARRAY,
602             ArrayUtils.subarray(array, 3, 3));
603
604         assertTrue("start undershoot, normal end",
605             ArrayUtils.isEquals(leftSubarray,
606                 ArrayUtils.subarray(array, -2, 4)));
607
608         assertEquals("start overshoot, any end",
609             ArrayUtils.EMPTY_CHAR_ARRAY,
610                 ArrayUtils.subarray(array, 33, 4));
611
612         assertTrue("normal start, end overshoot",
613             ArrayUtils.isEquals(rightSubarray,
614                 ArrayUtils.subarray(array, 2, 33)));
615
616         assertTrue("start undershoot, end overshoot",
617             ArrayUtils.isEquals(array,
618                 ArrayUtils.subarray(array, -2, 12)));
619
620         // empty-return tests
621
622         assertSame("empty array, object test",
623             ArrayUtils.EMPTY_CHAR_ARRAY,
624                 ArrayUtils.subarray(ArrayUtils.EMPTY_CHAR_ARRAY, 1, 2));
625
626         assertSame("start > end, object test",
627             ArrayUtils.EMPTY_CHAR_ARRAY,
628                 ArrayUtils.subarray(array, 4, 1));
629
630         assertSame("start == end, object test",
631             ArrayUtils.EMPTY_CHAR_ARRAY,
632                 ArrayUtils.subarray(array, 3, 3));
633
634         assertSame("start overshoot, any end, object test",
635             ArrayUtils.EMPTY_CHAR_ARRAY,
636                 ArrayUtils.subarray(array, 8733, 4));
637
638         // array type tests
639
640         assertSame("char type", char.class,
641             ArrayUtils.subarray(array, 2, 4).getClass().getComponentType());
642
643     }
644
645     public void testSubarrayByte() {
646         byte[] nullArray = null;
647         byte[] array = { 10, 11, 12, 13, 14, 15 };
648         byte[] leftSubarray = { 10, 11, 12, 13 };
649         byte[] midSubarray = { 11, 12, 13, 14 };
650         byte[] rightSubarray = { 12, 13, 14, 15 };
651
652
653         assertTrue("0 start, mid end",
654             ArrayUtils.isEquals(leftSubarray,
655                 ArrayUtils.subarray(array, 0, 4)));
656
657         assertTrue("0 start, length end",
658             ArrayUtils.isEquals(array,
659                 ArrayUtils.subarray(array, 0, array.length)));
660
661         assertTrue("mid start, mid end",
662             ArrayUtils.isEquals(midSubarray,
663                 ArrayUtils.subarray(array, 1, 5)));
664
665         assertTrue("mid start, length end",
666             ArrayUtils.isEquals(rightSubarray,
667                 ArrayUtils.subarray(array, 2, array.length)));
668
669
670         assertNull("null input", ArrayUtils.subarray(nullArray, 0, 3));
671
672         assertEquals("empty array", ArrayUtils.EMPTY_BYTE_ARRAY,
673             ArrayUtils.subarray(ArrayUtils.EMPTY_BYTE_ARRAY, 1, 2));
674
675         assertEquals("start > end", ArrayUtils.EMPTY_BYTE_ARRAY,
676             ArrayUtils.subarray(array, 4, 2));
677
678         assertEquals("start == end", ArrayUtils.EMPTY_BYTE_ARRAY,
679             ArrayUtils.subarray(array, 3, 3));
680
681         assertTrue("start undershoot, normal end",
682             ArrayUtils.isEquals(leftSubarray,
683                 ArrayUtils.subarray(array, -2, 4)));
684
685         assertEquals("start overshoot, any end",
686             ArrayUtils.EMPTY_BYTE_ARRAY,
687                 ArrayUtils.subarray(array, 33, 4));
688
689         assertTrue("normal start, end overshoot",
690             ArrayUtils.isEquals(rightSubarray,
691                 ArrayUtils.subarray(array, 2, 33)));
692
693         assertTrue("start undershoot, end overshoot",
694             ArrayUtils.isEquals(array,
695                 ArrayUtils.subarray(array, -2, 12)));
696
697         // empty-return tests
698
699         assertSame("empty array, object test",
700             ArrayUtils.EMPTY_BYTE_ARRAY,
701                 ArrayUtils.subarray(ArrayUtils.EMPTY_BYTE_ARRAY, 1, 2));
702
703         assertSame("start > end, object test",
704             ArrayUtils.EMPTY_BYTE_ARRAY,
705                 ArrayUtils.subarray(array, 4, 1));
706
707         assertSame("start == end, object test",
708             ArrayUtils.EMPTY_BYTE_ARRAY,
709                 ArrayUtils.subarray(array, 3, 3));
710
711         assertSame("start overshoot, any end, object test",
712             ArrayUtils.EMPTY_BYTE_ARRAY,
713                 ArrayUtils.subarray(array, 8733, 4));
714
715         // array type tests
716
717         assertSame("byte type", byte.class,
718             ArrayUtils.subarray(array, 2, 4).getClass().getComponentType());
719
720     }
721
722     public void testSubarrayDouble() {
723         double[] nullArray = null;
724         double[] array = { 10.123, 11.234, 12.345, 13.456, 14.567, 15.678 };
725         double[] leftSubarray = { 10.123, 11.234, 12.345, 13.456, };
726         double[] midSubarray = { 11.234, 12.345,