• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
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 
18 package org.apache.commons.lang3;
19 
20 import static org.junit.jupiter.api.Assertions.assertArrayEquals;
21 import static org.junit.jupiter.api.Assertions.assertEquals;
22 import static org.junit.jupiter.api.Assertions.assertNotNull;
23 import static org.junit.jupiter.api.Assertions.assertNotSame;
24 import static org.junit.jupiter.api.Assertions.assertNull;
25 import static org.junit.jupiter.api.Assertions.assertThrows;
26 
27 import org.junit.jupiter.api.Test;
28 
29 /**
30  * Tests ArrayUtils add methods.
31  */
32 public class ArrayUtilsAddTest extends AbstractLangTest {
33 
34     @Test
testAddFirstBoolean()35     public void testAddFirstBoolean() {
36         boolean[] newArray;
37         newArray = ArrayUtils.addFirst(null, false);
38         assertArrayEquals(new boolean[]{false}, newArray);
39         assertEquals(Boolean.TYPE, newArray.getClass().getComponentType());
40         newArray = ArrayUtils.addFirst(null, true);
41         assertArrayEquals(new boolean[]{true}, newArray);
42         assertEquals(Boolean.TYPE, newArray.getClass().getComponentType());
43         final boolean[] array1 = {true, false, true};
44         newArray = ArrayUtils.addFirst(array1, false);
45         assertArrayEquals(new boolean[]{false, true, false, true}, newArray);
46         assertEquals(Boolean.TYPE, newArray.getClass().getComponentType());
47     }
48 
49     @Test
testAddFirstByte()50     public void testAddFirstByte() {
51         byte[] newArray;
52         newArray = ArrayUtils.addFirst((byte[]) null, (byte) 0);
53         assertArrayEquals(new byte[]{0}, newArray);
54         assertEquals(Byte.TYPE, newArray.getClass().getComponentType());
55         newArray = ArrayUtils.addFirst((byte[]) null, (byte) 1);
56         assertArrayEquals(new byte[]{1}, newArray);
57         assertEquals(Byte.TYPE, newArray.getClass().getComponentType());
58         final byte[] array1 = {1, 2, 3};
59         newArray = ArrayUtils.addFirst(array1, (byte) 0);
60         assertArrayEquals(new byte[]{0, 1, 2, 3}, newArray);
61         assertEquals(Byte.TYPE, newArray.getClass().getComponentType());
62         newArray = ArrayUtils.addFirst(array1, (byte) 4);
63         assertArrayEquals(new byte[]{4, 1, 2, 3}, newArray);
64         assertEquals(Byte.TYPE, newArray.getClass().getComponentType());
65     }
66 
67     @Test
testAddFirstChar()68     public void testAddFirstChar() {
69         char[] newArray;
70         newArray = ArrayUtils.addFirst((char[]) null, (char) 0);
71         assertArrayEquals(new char[]{0}, newArray);
72         assertEquals(Character.TYPE, newArray.getClass().getComponentType());
73         newArray = ArrayUtils.addFirst((char[]) null, (char) 1);
74         assertArrayEquals(new char[]{1}, newArray);
75         assertEquals(Character.TYPE, newArray.getClass().getComponentType());
76         final char[] array1 = {1, 2, 3};
77         newArray = ArrayUtils.addFirst(array1, (char) 0);
78         assertArrayEquals(new char[]{0, 1, 2, 3}, newArray);
79         assertEquals(Character.TYPE, newArray.getClass().getComponentType());
80         newArray = ArrayUtils.addFirst(array1, (char) 4);
81         assertArrayEquals(new char[]{4, 1, 2, 3}, newArray);
82         assertEquals(Character.TYPE, newArray.getClass().getComponentType());
83     }
84 
85     @Test
testAddFirstDouble()86     public void testAddFirstDouble() {
87         double[] newArray;
88         newArray = ArrayUtils.addFirst((double[]) null, 0);
89         assertArrayEquals(new double[]{0}, newArray);
90         assertEquals(Double.TYPE, newArray.getClass().getComponentType());
91         newArray = ArrayUtils.addFirst((double[]) null, 1);
92         assertArrayEquals(new double[]{1}, newArray);
93         assertEquals(Double.TYPE, newArray.getClass().getComponentType());
94         final double[] array1 = {1, 2, 3};
95         newArray = ArrayUtils.addFirst(array1, 0);
96         assertArrayEquals(new double[]{0, 1, 2, 3}, newArray);
97         assertEquals(Double.TYPE, newArray.getClass().getComponentType());
98         newArray = ArrayUtils.addFirst(array1, 4);
99         assertArrayEquals(new double[]{4, 1, 2, 3}, newArray);
100         assertEquals(Double.TYPE, newArray.getClass().getComponentType());
101     }
102 
103     @Test
testAddFirstFloat()104     public void testAddFirstFloat() {
105         float[] newArray;
106         newArray = ArrayUtils.addFirst((float[]) null, 0);
107         assertArrayEquals(new float[]{0}, newArray);
108         assertEquals(Float.TYPE, newArray.getClass().getComponentType());
109         newArray = ArrayUtils.addFirst((float[]) null, 1);
110         assertArrayEquals(new float[]{1}, newArray);
111         assertEquals(Float.TYPE, newArray.getClass().getComponentType());
112         final float[] array1 = {1, 2, 3};
113         newArray = ArrayUtils.addFirst(array1, 0);
114         assertArrayEquals(new float[]{0, 1, 2, 3}, newArray);
115         assertEquals(Float.TYPE, newArray.getClass().getComponentType());
116         newArray = ArrayUtils.addFirst(array1, 4);
117         assertArrayEquals(new float[]{4, 1, 2, 3}, newArray);
118         assertEquals(Float.TYPE, newArray.getClass().getComponentType());
119     }
120 
121     @Test
testAddFirstInt()122     public void testAddFirstInt() {
123         int[] newArray;
124         newArray = ArrayUtils.addFirst((int[]) null, 0);
125         assertArrayEquals(new int[]{0}, newArray);
126         assertEquals(Integer.TYPE, newArray.getClass().getComponentType());
127         newArray = ArrayUtils.addFirst((int[]) null, 1);
128         assertArrayEquals(new int[]{1}, newArray);
129         assertEquals(Integer.TYPE, newArray.getClass().getComponentType());
130         final int[] array1 = {1, 2, 3};
131         newArray = ArrayUtils.addFirst(array1, 0);
132         assertArrayEquals(new int[]{0, 1, 2, 3}, newArray);
133         assertEquals(Integer.TYPE, newArray.getClass().getComponentType());
134         newArray = ArrayUtils.addFirst(array1, 4);
135         assertArrayEquals(new int[]{4, 1, 2, 3}, newArray);
136         assertEquals(Integer.TYPE, newArray.getClass().getComponentType());
137     }
138 
139     @Test
testAddFirstLong()140     public void testAddFirstLong() {
141         long[] newArray;
142         newArray = ArrayUtils.addFirst((long[]) null, 0);
143         assertArrayEquals(new long[]{0}, newArray);
144         assertEquals(Long.TYPE, newArray.getClass().getComponentType());
145         newArray = ArrayUtils.addFirst((long[]) null, 1);
146         assertArrayEquals(new long[]{1}, newArray);
147         assertEquals(Long.TYPE, newArray.getClass().getComponentType());
148         final long[] array1 = {1, 2, 3};
149         newArray = ArrayUtils.addFirst(array1, 0);
150         assertArrayEquals(new long[]{0, 1, 2, 3}, newArray);
151         assertEquals(Long.TYPE, newArray.getClass().getComponentType());
152         newArray = ArrayUtils.addFirst(array1, 4);
153         assertArrayEquals(new long[]{4, 1, 2, 3}, newArray);
154         assertEquals(Long.TYPE, newArray.getClass().getComponentType());
155     }
156 
157     @Test
testAddFirstObject()158     public void testAddFirstObject() {
159         Object[] newArray;
160 
161         //show that not casting is okay
162         newArray = ArrayUtils.add((Object[]) null, "a");
163         assertArrayEquals(new String[]{"a"}, newArray);
164         assertArrayEquals(new Object[]{"a"}, newArray);
165         assertEquals(String.class, newArray.getClass().getComponentType());
166 
167         //show that not casting to Object[] is okay and will assume String based on "a"
168         final String[] newStringArray = ArrayUtils.add(null, "a");
169         assertArrayEquals(new String[]{"a"}, newStringArray);
170         assertArrayEquals(new Object[]{"a"}, newStringArray);
171         assertEquals(String.class, newStringArray.getClass().getComponentType());
172 
173         final String[] stringArray1 = { "a", "b", "c" };
174         newArray = ArrayUtils.addFirst(stringArray1, null);
175         assertArrayEquals(new String[] { null, "a", "b", "c" }, newArray);
176         assertEquals(String.class, newArray.getClass().getComponentType());
177 
178         newArray = ArrayUtils.addFirst(stringArray1, "d");
179         assertArrayEquals(new String[] { "d", "a", "b", "c" }, newArray);
180         assertEquals(String.class, newArray.getClass().getComponentType());
181 
182         Number[] numberArray1 = { Integer.valueOf(1), Double.valueOf(2) };
183         newArray = ArrayUtils.addFirst(numberArray1, Float.valueOf(3));
184         assertArrayEquals(new Number[] { Float.valueOf(3), Integer.valueOf(1), Double.valueOf(2) }, newArray);
185         assertEquals(Number.class, newArray.getClass().getComponentType());
186 
187         numberArray1 = null;
188         newArray = ArrayUtils.addFirst(numberArray1, Float.valueOf(3));
189         assertArrayEquals(new Float[] { Float.valueOf(3) }, newArray);
190         assertEquals(Float.class, newArray.getClass().getComponentType());
191     }
192 
193     @Test
testAddFirstShort()194     public void testAddFirstShort() {
195         short[] newArray;
196         newArray = ArrayUtils.addFirst((short[]) null, (short) 0);
197         assertArrayEquals(new short[]{0}, newArray);
198         assertEquals(Short.TYPE, newArray.getClass().getComponentType());
199         newArray = ArrayUtils.addFirst((short[]) null, (short) 1);
200         assertArrayEquals(new short[]{1}, newArray);
201         assertEquals(Short.TYPE, newArray.getClass().getComponentType());
202         final short[] array1 = {1, 2, 3};
203         newArray = ArrayUtils.addFirst(array1, (short) 0);
204         assertArrayEquals(new short[]{0, 1, 2, 3}, newArray);
205         assertEquals(Short.TYPE, newArray.getClass().getComponentType());
206         newArray = ArrayUtils.addFirst(array1, (short) 4);
207         assertArrayEquals(new short[]{4, 1, 2, 3}, newArray);
208         assertEquals(Short.TYPE, newArray.getClass().getComponentType());
209     }
210 
211     @Test
testAddObjectArrayBoolean()212     public void testAddObjectArrayBoolean() {
213         boolean[] newArray;
214         newArray = ArrayUtils.add(null, false);
215         assertArrayEquals(new boolean[]{false}, newArray);
216         assertEquals(Boolean.TYPE, newArray.getClass().getComponentType());
217         newArray = ArrayUtils.add(null, true);
218         assertArrayEquals(new boolean[]{true}, newArray);
219         assertEquals(Boolean.TYPE, newArray.getClass().getComponentType());
220         final boolean[] array1 = {true, false, true};
221         newArray = ArrayUtils.add(array1, false);
222         assertArrayEquals(new boolean[]{true, false, true, false}, newArray);
223         assertEquals(Boolean.TYPE, newArray.getClass().getComponentType());
224     }
225 
226     @Test
testAddObjectArrayByte()227     public void testAddObjectArrayByte() {
228         byte[] newArray;
229         newArray = ArrayUtils.add((byte[]) null, (byte) 0);
230         assertArrayEquals(new byte[]{0}, newArray);
231         assertEquals(Byte.TYPE, newArray.getClass().getComponentType());
232         newArray = ArrayUtils.add((byte[]) null, (byte) 1);
233         assertArrayEquals(new byte[]{1}, newArray);
234         assertEquals(Byte.TYPE, newArray.getClass().getComponentType());
235         final byte[] array1 = {1, 2, 3};
236         newArray = ArrayUtils.add(array1, (byte) 0);
237         assertArrayEquals(new byte[]{1, 2, 3, 0}, newArray);
238         assertEquals(Byte.TYPE, newArray.getClass().getComponentType());
239         newArray = ArrayUtils.add(array1, (byte) 4);
240         assertArrayEquals(new byte[]{1, 2, 3, 4}, newArray);
241         assertEquals(Byte.TYPE, newArray.getClass().getComponentType());
242     }
243 
244     @Test
testAddObjectArrayChar()245     public void testAddObjectArrayChar() {
246         char[] newArray;
247         newArray = ArrayUtils.add((char[]) null, (char) 0);
248         assertArrayEquals(new char[]{0}, newArray);
249         assertEquals(Character.TYPE, newArray.getClass().getComponentType());
250         newArray = ArrayUtils.add((char[]) null, (char) 1);
251         assertArrayEquals(new char[]{1}, newArray);
252         assertEquals(Character.TYPE, newArray.getClass().getComponentType());
253         final char[] array1 = {1, 2, 3};
254         newArray = ArrayUtils.add(array1, (char) 0);
255         assertArrayEquals(new char[]{1, 2, 3, 0}, newArray);
256         assertEquals(Character.TYPE, newArray.getClass().getComponentType());
257         newArray = ArrayUtils.add(array1, (char) 4);
258         assertArrayEquals(new char[]{1, 2, 3, 4}, newArray);
259         assertEquals(Character.TYPE, newArray.getClass().getComponentType());
260     }
261 
262     @Test
testAddObjectArrayDouble()263     public void testAddObjectArrayDouble() {
264         double[] newArray;
265         newArray = ArrayUtils.add((double[]) null, 0);
266         assertArrayEquals(new double[]{0}, newArray);
267         assertEquals(Double.TYPE, newArray.getClass().getComponentType());
268         newArray = ArrayUtils.add((double[]) null, 1);
269         assertArrayEquals(new double[]{1}, newArray);
270         assertEquals(Double.TYPE, newArray.getClass().getComponentType());
271         final double[] array1 = {1, 2, 3};
272         newArray = ArrayUtils.add(array1, 0);
273         assertArrayEquals(new double[]{1, 2, 3, 0}, newArray);
274         assertEquals(Double.TYPE, newArray.getClass().getComponentType());
275         newArray = ArrayUtils.add(array1, 4);
276         assertArrayEquals(new double[]{1, 2, 3, 4}, newArray);
277         assertEquals(Double.TYPE, newArray.getClass().getComponentType());
278     }
279 
280     @Test
testAddObjectArrayFloat()281     public void testAddObjectArrayFloat() {
282         float[] newArray;
283         newArray = ArrayUtils.add((float[]) null, 0);
284         assertArrayEquals(new float[]{0}, newArray);
285         assertEquals(Float.TYPE, newArray.getClass().getComponentType());
286         newArray = ArrayUtils.add((float[]) null, 1);
287         assertArrayEquals(new float[]{1}, newArray);
288         assertEquals(Float.TYPE, newArray.getClass().getComponentType());
289         final float[] array1 = {1, 2, 3};
290         newArray = ArrayUtils.add(array1, 0);
291         assertArrayEquals(new float[]{1, 2, 3, 0}, newArray);
292         assertEquals(Float.TYPE, newArray.getClass().getComponentType());
293         newArray = ArrayUtils.add(array1, 4);
294         assertArrayEquals(new float[]{1, 2, 3, 4}, newArray);
295         assertEquals(Float.TYPE, newArray.getClass().getComponentType());
296     }
297 
298     @Test
testAddObjectArrayInt()299     public void testAddObjectArrayInt() {
300         int[] newArray;
301         newArray = ArrayUtils.add((int[]) null, 0);
302         assertArrayEquals(new int[]{0}, newArray);
303         assertEquals(Integer.TYPE, newArray.getClass().getComponentType());
304         newArray = ArrayUtils.add((int[]) null, 1);
305         assertArrayEquals(new int[]{1}, newArray);
306         assertEquals(Integer.TYPE, newArray.getClass().getComponentType());
307         final int[] array1 = {1, 2, 3};
308         newArray = ArrayUtils.add(array1, 0);
309         assertArrayEquals(new int[]{1, 2, 3, 0}, newArray);
310         assertEquals(Integer.TYPE, newArray.getClass().getComponentType());
311         newArray = ArrayUtils.add(array1, 4);
312         assertArrayEquals(new int[]{1, 2, 3, 4}, newArray);
313         assertEquals(Integer.TYPE, newArray.getClass().getComponentType());
314     }
315 
316     @Test
testAddObjectArrayLong()317     public void testAddObjectArrayLong() {
318         long[] newArray;
319         newArray = ArrayUtils.add((long[]) null, 0);
320         assertArrayEquals(new long[]{0}, newArray);
321         assertEquals(Long.TYPE, newArray.getClass().getComponentType());
322         newArray = ArrayUtils.add((long[]) null, 1);
323         assertArrayEquals(new long[]{1}, newArray);
324         assertEquals(Long.TYPE, newArray.getClass().getComponentType());
325         final long[] array1 = {1, 2, 3};
326         newArray = ArrayUtils.add(array1, 0);
327         assertArrayEquals(new long[]{1, 2, 3, 0}, newArray);
328         assertEquals(Long.TYPE, newArray.getClass().getComponentType());
329         newArray = ArrayUtils.add(array1, 4);
330         assertArrayEquals(new long[]{1, 2, 3, 4}, newArray);
331         assertEquals(Long.TYPE, newArray.getClass().getComponentType());
332     }
333 
334     @Test
testAddObjectArrayObject()335     public void testAddObjectArrayObject() {
336         Object[] newArray;
337 
338         //show that not casting is okay
339         newArray = ArrayUtils.add((Object[]) null, "a");
340         assertArrayEquals(new String[]{"a"}, newArray);
341         assertArrayEquals(new Object[]{"a"}, newArray);
342         assertEquals(String.class, newArray.getClass().getComponentType());
343 
344         //show that not casting to Object[] is okay and will assume String based on "a"
345         final String[] newStringArray = ArrayUtils.add(null, "a");
346         assertArrayEquals(new String[]{"a"}, newStringArray);
347         assertArrayEquals(new Object[]{"a"}, newStringArray);
348         assertEquals(String.class, newStringArray.getClass().getComponentType());
349 
350         final String[] stringArray1 = {"a", "b", "c"};
351         newArray = ArrayUtils.add(stringArray1, null);
352         assertArrayEquals(new String[]{"a", "b", "c", null}, newArray);
353         assertEquals(String.class, newArray.getClass().getComponentType());
354 
355         newArray = ArrayUtils.add(stringArray1, "d");
356         assertArrayEquals(new String[]{"a", "b", "c", "d"}, newArray);
357         assertEquals(String.class, newArray.getClass().getComponentType());
358 
359         Number[] numberArray1 = {Integer.valueOf(1), Double.valueOf(2)};
360         newArray = ArrayUtils.add(numberArray1, Float.valueOf(3));
361         assertArrayEquals(new Number[]{Integer.valueOf(1), Double.valueOf(2), Float.valueOf(3)}, newArray);
362         assertEquals(Number.class, newArray.getClass().getComponentType());
363 
364         numberArray1 = null;
365         newArray = ArrayUtils.add(numberArray1, Float.valueOf(3));
366         assertArrayEquals(new Float[]{Float.valueOf(3)}, newArray);
367         assertEquals(Float.class, newArray.getClass().getComponentType());
368     }
369 
370     @Test
testAddObjectArrayShort()371     public void testAddObjectArrayShort() {
372         short[] newArray;
373         newArray = ArrayUtils.add((short[]) null, (short) 0);
374         assertArrayEquals(new short[]{0}, newArray);
375         assertEquals(Short.TYPE, newArray.getClass().getComponentType());
376         newArray = ArrayUtils.add((short[]) null, (short) 1);
377         assertArrayEquals(new short[]{1}, newArray);
378         assertEquals(Short.TYPE, newArray.getClass().getComponentType());
379         final short[] array1 = {1, 2, 3};
380         newArray = ArrayUtils.add(array1, (short) 0);
381         assertArrayEquals(new short[]{1, 2, 3, 0}, newArray);
382         assertEquals(Short.TYPE, newArray.getClass().getComponentType());
383         newArray = ArrayUtils.add(array1, (short) 4);
384         assertArrayEquals(new short[]{1, 2, 3, 4}, newArray);
385         assertEquals(Short.TYPE, newArray.getClass().getComponentType());
386     }
387 
388     @Test
testAddObjectArrayToObjectArray()389     public void testAddObjectArrayToObjectArray() {
390         assertNull(ArrayUtils.addAll(null, (Object[]) null));
391         Object[] newArray;
392         final String[] stringArray1 = {"a", "b", "c"};
393         final String[] stringArray2 = {"1", "2", "3"};
394         newArray = ArrayUtils.addAll(stringArray1, (String[]) null);
395         assertNotSame(stringArray1, newArray);
396         assertArrayEquals(stringArray1, newArray);
397         assertArrayEquals(new String[]{"a", "b", "c"}, newArray);
398         assertEquals(String.class, newArray.getClass().getComponentType());
399         newArray = ArrayUtils.addAll(null, stringArray2);
400         assertNotSame(stringArray2, newArray);
401         assertArrayEquals(stringArray2, newArray);
402         assertArrayEquals(new String[]{"1", "2", "3"}, newArray);
403         assertEquals(String.class, newArray.getClass().getComponentType());
404         newArray = ArrayUtils.addAll(stringArray1, stringArray2);
405         assertArrayEquals(new String[]{"a", "b", "c", "1", "2", "3"}, newArray);
406         assertEquals(String.class, newArray.getClass().getComponentType());
407         newArray = ArrayUtils.addAll(ArrayUtils.EMPTY_STRING_ARRAY, (String[]) null);
408         assertArrayEquals(ArrayUtils.EMPTY_STRING_ARRAY, newArray);
409         assertArrayEquals(new String[]{}, newArray);
410         assertEquals(String.class, newArray.getClass().getComponentType());
411         newArray = ArrayUtils.addAll(null, ArrayUtils.EMPTY_STRING_ARRAY);
412         assertArrayEquals(ArrayUtils.EMPTY_STRING_ARRAY, newArray);
413         assertArrayEquals(new String[]{}, newArray);
414         assertEquals(String.class, newArray.getClass().getComponentType());
415         newArray = ArrayUtils.addAll(ArrayUtils.EMPTY_STRING_ARRAY, ArrayUtils.EMPTY_STRING_ARRAY);
416         assertArrayEquals(ArrayUtils.EMPTY_STRING_ARRAY, newArray);
417         assertArrayEquals(new String[]{}, newArray);
418         assertEquals(String.class, newArray.getClass().getComponentType());
419         final String[] stringArrayNull = {null};
420         newArray = ArrayUtils.addAll(stringArrayNull, stringArrayNull);
421         assertArrayEquals(new String[]{null, null}, newArray);
422         assertEquals(String.class, newArray.getClass().getComponentType());
423 
424         // boolean
425         assertArrayEquals(new boolean[]{true, false, false, true}, ArrayUtils.addAll(new boolean[]{true, false}, false, true));
426 
427         assertArrayEquals(new boolean[]{false, true}, ArrayUtils.addAll(null, new boolean[]{false, true}));
428 
429         assertArrayEquals(new boolean[]{true, false}, ArrayUtils.addAll(new boolean[]{true, false}, null));
430 
431         // char
432         assertArrayEquals(new char[]{'a', 'b', 'c', 'd'}, ArrayUtils.addAll(new char[]{'a', 'b'}, 'c', 'd'));
433 
434         assertArrayEquals(new char[]{'c', 'd'}, ArrayUtils.addAll(null, new char[]{'c', 'd'}));
435 
436         assertArrayEquals(new char[]{'a', 'b'}, ArrayUtils.addAll(new char[]{'a', 'b'}, null));
437 
438         // byte
439         assertArrayEquals(new byte[]{(byte) 0, (byte) 1, (byte) 2, (byte) 3}, ArrayUtils.addAll(new byte[]{(byte) 0, (byte) 1}, (byte) 2, (byte) 3));
440 
441         assertArrayEquals(new byte[]{(byte) 2, (byte) 3}, ArrayUtils.addAll(null, new byte[]{(byte) 2, (byte) 3}));
442 
443         assertArrayEquals(new byte[]{(byte) 0, (byte) 1}, ArrayUtils.addAll(new byte[]{(byte) 0, (byte) 1}, null));
444 
445         // short
446         assertArrayEquals(new short[]{(short) 10, (short) 20, (short) 30, (short) 40}, ArrayUtils.addAll(new short[]{(short) 10, (short) 20}, (short) 30, (short) 40));
447 
448         assertArrayEquals(new short[]{(short) 30, (short) 40}, ArrayUtils.addAll(null, new short[]{(short) 30, (short) 40}));
449 
450         assertArrayEquals(new short[]{(short) 10, (short) 20}, ArrayUtils.addAll(new short[]{(short) 10, (short) 20}, null));
451 
452         // int
453         assertArrayEquals(new int[]{1, 1000, -1000, -1}, ArrayUtils.addAll(new int[]{1, 1000}, -1000, -1));
454 
455         assertArrayEquals(new int[]{-1000, -1}, ArrayUtils.addAll(null, new int[]{-1000, -1}));
456 
457         assertArrayEquals(new int[]{1, 1000}, ArrayUtils.addAll(new int[]{1, 1000}, null));
458 
459         // long
460         assertArrayEquals(new long[]{1L, -1L, 1000L, -1000L}, ArrayUtils.addAll(new long[]{1L, -1L}, 1000L, -1000L));
461 
462         assertArrayEquals(new long[]{1000L, -1000L}, ArrayUtils.addAll(null, new long[]{1000L, -1000L}));
463 
464         assertArrayEquals(new long[]{1L, -1L}, ArrayUtils.addAll(new long[]{1L, -1L}, null));
465 
466         // float
467         assertArrayEquals(new float[]{10.5f, 10.1f, 1.6f, 0.01f}, ArrayUtils.addAll(new float[]{10.5f, 10.1f}, 1.6f, 0.01f));
468 
469         assertArrayEquals(new float[]{1.6f, 0.01f}, ArrayUtils.addAll(null, new float[]{1.6f, 0.01f}));
470 
471         assertArrayEquals(new float[]{10.5f, 10.1f}, ArrayUtils.addAll(new float[]{10.5f, 10.1f}, null));
472 
473         // double
474         assertArrayEquals(new double[]{Math.PI, -Math.PI, 0, 9.99}, ArrayUtils.addAll(new double[]{Math.PI, -Math.PI}, 0, 9.99));
475 
476         assertArrayEquals(new double[]{0, 9.99}, ArrayUtils.addAll(null, new double[]{0, 9.99}));
477 
478         assertArrayEquals(new double[]{Math.PI, -Math.PI}, ArrayUtils.addAll(new double[]{Math.PI, -Math.PI}, null));
479 
480     }
481 
482     @SuppressWarnings("deprecation")
483     @Test
testAddObjectAtIndex()484     public void testAddObjectAtIndex() {
485         Object[] newArray;
486         newArray = ArrayUtils.add((Object[]) null, 0, "a");
487         assertArrayEquals(new String[]{"a"}, newArray);
488         assertArrayEquals(new Object[]{"a"}, newArray);
489         assertEquals(String.class, newArray.getClass().getComponentType());
490         final String[] stringArray1 = {"a", "b", "c"};
491         newArray = ArrayUtils.add(stringArray1, 0, null);
492         assertArrayEquals(new String[]{null, "a", "b", "c"}, newArray);
493         assertEquals(String.class, newArray.getClass().getComponentType());
494         newArray = ArrayUtils.add(stringArray1, 1, null);
495         assertArrayEquals(new String[]{"a", null, "b", "c"}, newArray);
496         assertEquals(String.class, newArray.getClass().getComponentType());
497         newArray = ArrayUtils.add(stringArray1, 3, null);
498         assertArrayEquals(new String[]{"a", "b", "c", null}, newArray);
499         assertEquals(String.class, newArray.getClass().getComponentType());
500         newArray = ArrayUtils.add(stringArray1, 3, "d");
501         assertArrayEquals(new String[]{"a", "b", "c", "d"}, newArray);
502         assertEquals(String.class, newArray.getClass().getComponentType());
503         assertEquals(String.class, newArray.getClass().getComponentType());
504 
505         final Object[] o = {"1", "2", "4"};
506         final Object[] result = ArrayUtils.add(o, 2, "3");
507         final Object[] result2 = ArrayUtils.add(o, 3, "5");
508 
509         assertNotNull(result);
510         assertEquals(4, result.length);
511         assertEquals("1", result[0]);
512         assertEquals("2", result[1]);
513         assertEquals("3", result[2]);
514         assertEquals("4", result[3]);
515         assertNotNull(result2);
516         assertEquals(4, result2.length);
517         assertEquals("1", result2[0]);
518         assertEquals("2", result2[1]);
519         assertEquals("4", result2[2]);
520         assertEquals("5", result2[3]);
521 
522         // boolean tests
523         boolean[] booleanArray = ArrayUtils.add( null, 0, true );
524         assertArrayEquals(new boolean[]{true}, booleanArray);
525         IndexOutOfBoundsException e =
526                 assertThrows(IndexOutOfBoundsException.class, () -> ArrayUtils.add( null, -1, true));
527         assertEquals("Index: -1, Length: 0", e.getMessage());
528         booleanArray = ArrayUtils.add( new boolean[] { true }, 0, false);
529         assertArrayEquals(new boolean[]{false, true}, booleanArray);
530         booleanArray = ArrayUtils.add( new boolean[] { false }, 1, true);
531         assertArrayEquals(new boolean[]{false, true}, booleanArray);
532         booleanArray = ArrayUtils.add( new boolean[] { true, false }, 1, true);
533         assertArrayEquals(new boolean[]{true, true, false}, booleanArray);
534         e = assertThrows(IndexOutOfBoundsException.class, () -> ArrayUtils.add(new boolean[] { true, false }, 4, true));
535         assertEquals("Index: 4, Length: 2", e.getMessage());
536         e = assertThrows(IndexOutOfBoundsException.class, () -> ArrayUtils.add(new boolean[] { true, false }, -1, true));
537         assertEquals("Index: -1, Length: 2", e.getMessage());
538 
539         // char tests
540         char[] charArray = ArrayUtils.add( (char[]) null, 0, 'a' );
541         assertArrayEquals(new char[]{'a'}, charArray);
542         e = assertThrows(IndexOutOfBoundsException.class, () -> ArrayUtils.add( (char[]) null, -1, 'a' ));
543         assertEquals("Index: -1, Length: 0", e.getMessage());
544         charArray = ArrayUtils.add( new char[] { 'a' }, 0, 'b');
545         assertArrayEquals(new char[]{'b', 'a'}, charArray);
546         charArray = ArrayUtils.add( new char[] { 'a', 'b' }, 0, 'c');
547         assertArrayEquals(new char[]{'c', 'a', 'b'}, charArray);
548         charArray = ArrayUtils.add( new char[] { 'a', 'b' }, 1, 'k');
549         assertArrayEquals(new char[]{'a', 'k', 'b'}, charArray);
550         charArray = ArrayUtils.add( new char[] { 'a', 'b', 'c' }, 1, 't');
551         assertArrayEquals(new char[]{'a', 't', 'b', 'c'}, charArray);
552         e = assertThrows(IndexOutOfBoundsException.class, () -> ArrayUtils.add( new char[] { 'a', 'b' }, 4, 'c'));
553         assertEquals("Index: 4, Length: 2", e.getMessage());
554         e = assertThrows(IndexOutOfBoundsException.class, () -> ArrayUtils.add( new char[] { 'a', 'b' }, -1, 'c'));
555         assertEquals("Index: -1, Length: 2", e.getMessage());
556 
557         // short tests
558         short[] shortArray = ArrayUtils.add( new short[] { 1 }, 0, (short) 2);
559         assertArrayEquals(new short[]{2, 1}, shortArray);
560         e = assertThrows(IndexOutOfBoundsException.class, () -> ArrayUtils.add( (short[]) null, -1, (short) 2));
561         assertEquals("Index: -1, Length: 0", e.getMessage());
562         shortArray = ArrayUtils.add( new short[] { 2, 6 }, 2, (short) 10);
563         assertArrayEquals(new short[]{2, 6, 10}, shortArray);
564         shortArray = ArrayUtils.add( new short[] { 2, 6 }, 0, (short) -4);
565         assertArrayEquals(new short[]{-4, 2, 6}, shortArray);
566         shortArray = ArrayUtils.add( new short[] { 2, 6, 3 }, 2, (short) 1);
567         assertArrayEquals(new short[]{2, 6, 1, 3}, shortArray);
568         e = assertThrows(IndexOutOfBoundsException.class, () -> ArrayUtils.add( new short[] { 2, 6 }, 4, (short) 10));
569         assertEquals("Index: 4, Length: 2", e.getMessage());
570         e = assertThrows(IndexOutOfBoundsException.class, () -> ArrayUtils.add( new short[] { 2, 6 }, -1, (short) 10));
571         assertEquals("Index: -1, Length: 2", e.getMessage());
572 
573         // byte tests
574         byte[] byteArray = ArrayUtils.add( new byte[] { 1 }, 0, (byte) 2);
575         assertArrayEquals(new byte[]{2, 1}, byteArray);
576         e = assertThrows(IndexOutOfBoundsException.class, () -> ArrayUtils.add( (byte[]) null, -1, (byte) 2));
577         assertEquals("Index: -1, Length: 0", e.getMessage());
578         byteArray = ArrayUtils.add( new byte[] { 2, 6 }, 2, (byte) 3);
579         assertArrayEquals(new byte[]{2, 6, 3}, byteArray);
580         byteArray = ArrayUtils.add( new byte[] { 2, 6 }, 0, (byte) 1);
581         assertArrayEquals(new byte[]{1, 2, 6}, byteArray);
582         byteArray = ArrayUtils.add( new byte[] { 2, 6, 3 }, 2, (byte) 1);
583         assertArrayEquals(new byte[]{2, 6, 1, 3}, byteArray);
584         e = assertThrows(IndexOutOfBoundsException.class, () -> ArrayUtils.add( new byte[] { 2, 6 }, 4, (byte) 3));
585         assertEquals("Index: 4, Length: 2", e.getMessage());
586         e = assertThrows(IndexOutOfBoundsException.class, () -> ArrayUtils.add( new byte[] { 2, 6 }, -1, (byte) 3));
587         assertEquals("Index: -1, Length: 2", e.getMessage());
588 
589         // int tests
590         int[] intArray = ArrayUtils.add( new int[] { 1 }, 0, 2);
591         assertArrayEquals(new int[]{2, 1}, intArray);
592         e = assertThrows(IndexOutOfBoundsException.class, () -> ArrayUtils.add( (int[]) null, -1, 2));
593         assertEquals("Index: -1, Length: 0", e.getMessage());
594         intArray = ArrayUtils.add( new int[] { 2, 6 }, 2, 10);
595         assertArrayEquals(new int[]{2, 6, 10}, intArray);
596         intArray = ArrayUtils.add( new int[] { 2, 6 }, 0, -4);
597         assertArrayEquals(new int[]{-4, 2, 6}, intArray);
598         intArray = ArrayUtils.add( new int[] { 2, 6, 3 }, 2, 1);
599         assertArrayEquals(new int[]{2, 6, 1, 3}, intArray);
600         e = assertThrows(IndexOutOfBoundsException.class, () -> ArrayUtils.add( new int[] { 2, 6 }, 4, 10));
601         assertEquals("Index: 4, Length: 2", e.getMessage());
602         e = assertThrows(IndexOutOfBoundsException.class, () -> ArrayUtils.add( new int[] { 2, 6 }, -1, 10));
603         assertEquals("Index: -1, Length: 2", e.getMessage());
604 
605         // long tests
606         long[] longArray = ArrayUtils.add( new long[] { 1L }, 0, 2L);
607         assertArrayEquals(new long[]{2L, 1L}, longArray);
608         e = assertThrows(IndexOutOfBoundsException.class, () -> ArrayUtils.add( (long[]) null, -1, 2L));
609         assertEquals("Index: -1, Length: 0", e.getMessage());
610         longArray = ArrayUtils.add( new long[] { 2L, 6L }, 2, 10L);
611         assertArrayEquals(new long[]{2L, 6L, 10L}, longArray);
612         longArray = ArrayUtils.add( new long[] { 2L, 6L }, 0, -4L);
613         assertArrayEquals(new long[]{-4L, 2L, 6L}, longArray);
614         longArray = ArrayUtils.add( new long[] { 2L, 6L, 3L }, 2, 1L);
615         assertArrayEquals(new long[]{2L, 6L, 1L, 3L}, longArray);
616         e = assertThrows(IndexOutOfBoundsException.class, () -> ArrayUtils.add( new long[] { 2L, 6L }, 4, 10L));
617         assertEquals("Index: 4, Length: 2", e.getMessage());
618         e = assertThrows(IndexOutOfBoundsException.class, () -> ArrayUtils.add( new long[] { 2L, 6L }, -1, 10L));
619         assertEquals("Index: -1, Length: 2", e.getMessage());
620 
621         // float tests
622         float[] floatArray = ArrayUtils.add( new float[] { 1.1f }, 0, 2.2f);
623         assertArrayEquals(new float[]{2.2f, 1.1f}, floatArray);
624         e = assertThrows(IndexOutOfBoundsException.class, () -> ArrayUtils.add( (float[]) null, -1, 2.2f));
625         assertEquals("Index: -1, Length: 0", e.getMessage());
626         floatArray = ArrayUtils.add( new float[] { 2.3f, 6.4f }, 2, 10.5f);
627         assertArrayEquals(new float[]{2.3f, 6.4f, 10.5f}, floatArray);
628         floatArray = ArrayUtils.add( new float[] { 2.6f, 6.7f }, 0, -4.8f);
629         assertArrayEquals(new float[]{-4.8f, 2.6f, 6.7f}, floatArray);
630         floatArray = ArrayUtils.add( new float[] { 2.9f, 6.0f, 0.3f }, 2, 1.0f);
631         assertArrayEquals(new float[]{2.9f, 6.0f, 1.0f, 0.3f}, floatArray);
632         e = assertThrows(IndexOutOfBoundsException.class, () -> ArrayUtils.add( new float[] { 2.3f, 6.4f }, 4, 10.5f));
633         assertEquals("Index: 4, Length: 2", e.getMessage());
634         e = assertThrows(IndexOutOfBoundsException.class, () -> ArrayUtils.add( new float[] { 2.3f, 6.4f }, -1, 10.5f));
635         assertEquals("Index: -1, Length: 2", e.getMessage());
636 
637         // double tests
638         double[] doubleArray = ArrayUtils.add( new double[] { 1.1 }, 0, 2.2);
639         assertArrayEquals(new double[]{2.2, 1.1}, doubleArray);
640         e = assertThrows(IndexOutOfBoundsException.class, () -> ArrayUtils.add(null, -1, 2.2));
641         assertEquals("Index: -1, Length: 0", e.getMessage());
642         doubleArray = ArrayUtils.add( new double[] { 2.3, 6.4 }, 2, 10.5);
643         assertArrayEquals(new double[]{2.3, 6.4, 10.5}, doubleArray);
644         doubleArray = ArrayUtils.add( new double[] { 2.6, 6.7 }, 0, -4.8);
645         assertArrayEquals(new double[]{-4.8, 2.6, 6.7}, doubleArray);
646         doubleArray = ArrayUtils.add( new double[] { 2.9, 6.0, 0.3 }, 2, 1.0);
647         assertArrayEquals(new double[]{2.9, 6.0, 1.0, 0.3}, doubleArray);
648         e = assertThrows(IndexOutOfBoundsException.class, () -> ArrayUtils.add( new double[] { 2.3, 6.4 }, 4, 10.5));
649         assertEquals("Index: 4, Length: 2", e.getMessage());
650         e = assertThrows(IndexOutOfBoundsException.class, () -> ArrayUtils.add( new double[] { 2.3, 6.4 }, -1, 10.5));
651         assertEquals("Index: -1, Length: 2", e.getMessage());
652     }
653 
654     @Test
testJira567()655     public void testJira567() {
656         final Number[] n;
657         // Valid array construction
658         n = ArrayUtils.addAll(new Number[]{Integer.valueOf(1)}, new Long[]{Long.valueOf(2)});
659         assertEquals(2, n.length);
660         assertEquals(Number.class, n.getClass().getComponentType());
661         // Invalid - can't store Long in Integer array
662         assertThrows(IllegalArgumentException.class,
663                 () -> ArrayUtils.addAll(new Integer[]{Integer.valueOf(1)}, new Long[]{Long.valueOf(2)}));
664     }
665 
666     @Test
667     @SuppressWarnings("deprecation")
testLANG571()668     public void testLANG571() {
669         final String[] stringArray=null;
670         final String aString=null;
671         assertThrows(IllegalArgumentException.class, () -> ArrayUtils.add(stringArray, aString));
672         assertThrows(IllegalArgumentException.class, () -> ArrayUtils.add(stringArray, 0, aString));
673     }
674 
675 }
676