diff options
Diffstat (limited to 'src/test/java/org/apache/commons/lang3/ArrayUtilsAddTest.java')
| -rw-r--r-- | src/test/java/org/apache/commons/lang3/ArrayUtilsAddTest.java | 675 |
1 files changed, 675 insertions, 0 deletions
diff --git a/src/test/java/org/apache/commons/lang3/ArrayUtilsAddTest.java b/src/test/java/org/apache/commons/lang3/ArrayUtilsAddTest.java new file mode 100644 index 000000000..f8ced87c4 --- /dev/null +++ b/src/test/java/org/apache/commons/lang3/ArrayUtilsAddTest.java @@ -0,0 +1,675 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package org.apache.commons.lang3; + +import static org.junit.jupiter.api.Assertions.assertArrayEquals; +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertNotNull; +import static org.junit.jupiter.api.Assertions.assertNotSame; +import static org.junit.jupiter.api.Assertions.assertNull; +import static org.junit.jupiter.api.Assertions.assertThrows; + +import org.junit.jupiter.api.Test; + +/** + * Tests ArrayUtils add methods. + */ +public class ArrayUtilsAddTest extends AbstractLangTest { + + @Test + public void testAddFirstBoolean() { + boolean[] newArray; + newArray = ArrayUtils.addFirst(null, false); + assertArrayEquals(new boolean[]{false}, newArray); + assertEquals(Boolean.TYPE, newArray.getClass().getComponentType()); + newArray = ArrayUtils.addFirst(null, true); + assertArrayEquals(new boolean[]{true}, newArray); + assertEquals(Boolean.TYPE, newArray.getClass().getComponentType()); + final boolean[] array1 = {true, false, true}; + newArray = ArrayUtils.addFirst(array1, false); + assertArrayEquals(new boolean[]{false, true, false, true}, newArray); + assertEquals(Boolean.TYPE, newArray.getClass().getComponentType()); + } + + @Test + public void testAddFirstByte() { + byte[] newArray; + newArray = ArrayUtils.addFirst((byte[]) null, (byte) 0); + assertArrayEquals(new byte[]{0}, newArray); + assertEquals(Byte.TYPE, newArray.getClass().getComponentType()); + newArray = ArrayUtils.addFirst((byte[]) null, (byte) 1); + assertArrayEquals(new byte[]{1}, newArray); + assertEquals(Byte.TYPE, newArray.getClass().getComponentType()); + final byte[] array1 = {1, 2, 3}; + newArray = ArrayUtils.addFirst(array1, (byte) 0); + assertArrayEquals(new byte[]{0, 1, 2, 3}, newArray); + assertEquals(Byte.TYPE, newArray.getClass().getComponentType()); + newArray = ArrayUtils.addFirst(array1, (byte) 4); + assertArrayEquals(new byte[]{4, 1, 2, 3}, newArray); + assertEquals(Byte.TYPE, newArray.getClass().getComponentType()); + } + + @Test + public void testAddFirstChar() { + char[] newArray; + newArray = ArrayUtils.addFirst((char[]) null, (char) 0); + assertArrayEquals(new char[]{0}, newArray); + assertEquals(Character.TYPE, newArray.getClass().getComponentType()); + newArray = ArrayUtils.addFirst((char[]) null, (char) 1); + assertArrayEquals(new char[]{1}, newArray); + assertEquals(Character.TYPE, newArray.getClass().getComponentType()); + final char[] array1 = {1, 2, 3}; + newArray = ArrayUtils.addFirst(array1, (char) 0); + assertArrayEquals(new char[]{0, 1, 2, 3}, newArray); + assertEquals(Character.TYPE, newArray.getClass().getComponentType()); + newArray = ArrayUtils.addFirst(array1, (char) 4); + assertArrayEquals(new char[]{4, 1, 2, 3}, newArray); + assertEquals(Character.TYPE, newArray.getClass().getComponentType()); + } + + @Test + public void testAddFirstDouble() { + double[] newArray; + newArray = ArrayUtils.addFirst((double[]) null, 0); + assertArrayEquals(new double[]{0}, newArray); + assertEquals(Double.TYPE, newArray.getClass().getComponentType()); + newArray = ArrayUtils.addFirst((double[]) null, 1); + assertArrayEquals(new double[]{1}, newArray); + assertEquals(Double.TYPE, newArray.getClass().getComponentType()); + final double[] array1 = {1, 2, 3}; + newArray = ArrayUtils.addFirst(array1, 0); + assertArrayEquals(new double[]{0, 1, 2, 3}, newArray); + assertEquals(Double.TYPE, newArray.getClass().getComponentType()); + newArray = ArrayUtils.addFirst(array1, 4); + assertArrayEquals(new double[]{4, 1, 2, 3}, newArray); + assertEquals(Double.TYPE, newArray.getClass().getComponentType()); + } + + @Test + public void testAddFirstFloat() { + float[] newArray; + newArray = ArrayUtils.addFirst((float[]) null, 0); + assertArrayEquals(new float[]{0}, newArray); + assertEquals(Float.TYPE, newArray.getClass().getComponentType()); + newArray = ArrayUtils.addFirst((float[]) null, 1); + assertArrayEquals(new float[]{1}, newArray); + assertEquals(Float.TYPE, newArray.getClass().getComponentType()); + final float[] array1 = {1, 2, 3}; + newArray = ArrayUtils.addFirst(array1, 0); + assertArrayEquals(new float[]{0, 1, 2, 3}, newArray); + assertEquals(Float.TYPE, newArray.getClass().getComponentType()); + newArray = ArrayUtils.addFirst(array1, 4); + assertArrayEquals(new float[]{4, 1, 2, 3}, newArray); + assertEquals(Float.TYPE, newArray.getClass().getComponentType()); + } + + @Test + public void testAddFirstInt() { + int[] newArray; + newArray = ArrayUtils.addFirst((int[]) null, 0); + assertArrayEquals(new int[]{0}, newArray); + assertEquals(Integer.TYPE, newArray.getClass().getComponentType()); + newArray = ArrayUtils.addFirst((int[]) null, 1); + assertArrayEquals(new int[]{1}, newArray); + assertEquals(Integer.TYPE, newArray.getClass().getComponentType()); + final int[] array1 = {1, 2, 3}; + newArray = ArrayUtils.addFirst(array1, 0); + assertArrayEquals(new int[]{0, 1, 2, 3}, newArray); + assertEquals(Integer.TYPE, newArray.getClass().getComponentType()); + newArray = ArrayUtils.addFirst(array1, 4); + assertArrayEquals(new int[]{4, 1, 2, 3}, newArray); + assertEquals(Integer.TYPE, newArray.getClass().getComponentType()); + } + + @Test + public void testAddFirstLong() { + long[] newArray; + newArray = ArrayUtils.addFirst((long[]) null, 0); + assertArrayEquals(new long[]{0}, newArray); + assertEquals(Long.TYPE, newArray.getClass().getComponentType()); + newArray = ArrayUtils.addFirst((long[]) null, 1); + assertArrayEquals(new long[]{1}, newArray); + assertEquals(Long.TYPE, newArray.getClass().getComponentType()); + final long[] array1 = {1, 2, 3}; + newArray = ArrayUtils.addFirst(array1, 0); + assertArrayEquals(new long[]{0, 1, 2, 3}, newArray); + assertEquals(Long.TYPE, newArray.getClass().getComponentType()); + newArray = ArrayUtils.addFirst(array1, 4); + assertArrayEquals(new long[]{4, 1, 2, 3}, newArray); + assertEquals(Long.TYPE, newArray.getClass().getComponentType()); + } + + @Test + public void testAddFirstObject() { + Object[] newArray; + + //show that not casting is okay + newArray = ArrayUtils.add((Object[]) null, "a"); + assertArrayEquals(new String[]{"a"}, newArray); + assertArrayEquals(new Object[]{"a"}, newArray); + assertEquals(String.class, newArray.getClass().getComponentType()); + + //show that not casting to Object[] is okay and will assume String based on "a" + final String[] newStringArray = ArrayUtils.add(null, "a"); + assertArrayEquals(new String[]{"a"}, newStringArray); + assertArrayEquals(new Object[]{"a"}, newStringArray); + assertEquals(String.class, newStringArray.getClass().getComponentType()); + + final String[] stringArray1 = { "a", "b", "c" }; + newArray = ArrayUtils.addFirst(stringArray1, null); + assertArrayEquals(new String[] { null, "a", "b", "c" }, newArray); + assertEquals(String.class, newArray.getClass().getComponentType()); + + newArray = ArrayUtils.addFirst(stringArray1, "d"); + assertArrayEquals(new String[] { "d", "a", "b", "c" }, newArray); + assertEquals(String.class, newArray.getClass().getComponentType()); + + Number[] numberArray1 = { Integer.valueOf(1), Double.valueOf(2) }; + newArray = ArrayUtils.addFirst(numberArray1, Float.valueOf(3)); + assertArrayEquals(new Number[] { Float.valueOf(3), Integer.valueOf(1), Double.valueOf(2) }, newArray); + assertEquals(Number.class, newArray.getClass().getComponentType()); + + numberArray1 = null; + newArray = ArrayUtils.addFirst(numberArray1, Float.valueOf(3)); + assertArrayEquals(new Float[] { Float.valueOf(3) }, newArray); + assertEquals(Float.class, newArray.getClass().getComponentType()); + } + + @Test + public void testAddFirstShort() { + short[] newArray; + newArray = ArrayUtils.addFirst((short[]) null, (short) 0); + assertArrayEquals(new short[]{0}, newArray); + assertEquals(Short.TYPE, newArray.getClass().getComponentType()); + newArray = ArrayUtils.addFirst((short[]) null, (short) 1); + assertArrayEquals(new short[]{1}, newArray); + assertEquals(Short.TYPE, newArray.getClass().getComponentType()); + final short[] array1 = {1, 2, 3}; + newArray = ArrayUtils.addFirst(array1, (short) 0); + assertArrayEquals(new short[]{0, 1, 2, 3}, newArray); + assertEquals(Short.TYPE, newArray.getClass().getComponentType()); + newArray = ArrayUtils.addFirst(array1, (short) 4); + assertArrayEquals(new short[]{4, 1, 2, 3}, newArray); + assertEquals(Short.TYPE, newArray.getClass().getComponentType()); + } + + @Test + public void testAddObjectArrayBoolean() { + boolean[] newArray; + newArray = ArrayUtils.add(null, false); + assertArrayEquals(new boolean[]{false}, newArray); + assertEquals(Boolean.TYPE, newArray.getClass().getComponentType()); + newArray = ArrayUtils.add(null, true); + assertArrayEquals(new boolean[]{true}, newArray); + assertEquals(Boolean.TYPE, newArray.getClass().getComponentType()); + final boolean[] array1 = {true, false, true}; + newArray = ArrayUtils.add(array1, false); + assertArrayEquals(new boolean[]{true, false, true, false}, newArray); + assertEquals(Boolean.TYPE, newArray.getClass().getComponentType()); + } + + @Test + public void testAddObjectArrayByte() { + byte[] newArray; + newArray = ArrayUtils.add((byte[]) null, (byte) 0); + assertArrayEquals(new byte[]{0}, newArray); + assertEquals(Byte.TYPE, newArray.getClass().getComponentType()); + newArray = ArrayUtils.add((byte[]) null, (byte) 1); + assertArrayEquals(new byte[]{1}, newArray); + assertEquals(Byte.TYPE, newArray.getClass().getComponentType()); + final byte[] array1 = {1, 2, 3}; + newArray = ArrayUtils.add(array1, (byte) 0); + assertArrayEquals(new byte[]{1, 2, 3, 0}, newArray); + assertEquals(Byte.TYPE, newArray.getClass().getComponentType()); + newArray = ArrayUtils.add(array1, (byte) 4); + assertArrayEquals(new byte[]{1, 2, 3, 4}, newArray); + assertEquals(Byte.TYPE, newArray.getClass().getComponentType()); + } + + @Test + public void testAddObjectArrayChar() { + char[] newArray; + newArray = ArrayUtils.add((char[]) null, (char) 0); + assertArrayEquals(new char[]{0}, newArray); + assertEquals(Character.TYPE, newArray.getClass().getComponentType()); + newArray = ArrayUtils.add((char[]) null, (char) 1); + assertArrayEquals(new char[]{1}, newArray); + assertEquals(Character.TYPE, newArray.getClass().getComponentType()); + final char[] array1 = {1, 2, 3}; + newArray = ArrayUtils.add(array1, (char) 0); + assertArrayEquals(new char[]{1, 2, 3, 0}, newArray); + assertEquals(Character.TYPE, newArray.getClass().getComponentType()); + newArray = ArrayUtils.add(array1, (char) 4); + assertArrayEquals(new char[]{1, 2, 3, 4}, newArray); + assertEquals(Character.TYPE, newArray.getClass().getComponentType()); + } + + @Test + public void testAddObjectArrayDouble() { + double[] newArray; + newArray = ArrayUtils.add((double[]) null, 0); + assertArrayEquals(new double[]{0}, newArray); + assertEquals(Double.TYPE, newArray.getClass().getComponentType()); + newArray = ArrayUtils.add((double[]) null, 1); + assertArrayEquals(new double[]{1}, newArray); + assertEquals(Double.TYPE, newArray.getClass().getComponentType()); + final double[] array1 = {1, 2, 3}; + newArray = ArrayUtils.add(array1, 0); + assertArrayEquals(new double[]{1, 2, 3, 0}, newArray); + assertEquals(Double.TYPE, newArray.getClass().getComponentType()); + newArray = ArrayUtils.add(array1, 4); + assertArrayEquals(new double[]{1, 2, 3, 4}, newArray); + assertEquals(Double.TYPE, newArray.getClass().getComponentType()); + } + + @Test + public void testAddObjectArrayFloat() { + float[] newArray; + newArray = ArrayUtils.add((float[]) null, 0); + assertArrayEquals(new float[]{0}, newArray); + assertEquals(Float.TYPE, newArray.getClass().getComponentType()); + newArray = ArrayUtils.add((float[]) null, 1); + assertArrayEquals(new float[]{1}, newArray); + assertEquals(Float.TYPE, newArray.getClass().getComponentType()); + final float[] array1 = {1, 2, 3}; + newArray = ArrayUtils.add(array1, 0); + assertArrayEquals(new float[]{1, 2, 3, 0}, newArray); + assertEquals(Float.TYPE, newArray.getClass().getComponentType()); + newArray = ArrayUtils.add(array1, 4); + assertArrayEquals(new float[]{1, 2, 3, 4}, newArray); + assertEquals(Float.TYPE, newArray.getClass().getComponentType()); + } + + @Test + public void testAddObjectArrayInt() { + int[] newArray; + newArray = ArrayUtils.add((int[]) null, 0); + assertArrayEquals(new int[]{0}, newArray); + assertEquals(Integer.TYPE, newArray.getClass().getComponentType()); + newArray = ArrayUtils.add((int[]) null, 1); + assertArrayEquals(new int[]{1}, newArray); + assertEquals(Integer.TYPE, newArray.getClass().getComponentType()); + final int[] array1 = {1, 2, 3}; + newArray = ArrayUtils.add(array1, 0); + assertArrayEquals(new int[]{1, 2, 3, 0}, newArray); + assertEquals(Integer.TYPE, newArray.getClass().getComponentType()); + newArray = ArrayUtils.add(array1, 4); + assertArrayEquals(new int[]{1, 2, 3, 4}, newArray); + assertEquals(Integer.TYPE, newArray.getClass().getComponentType()); + } + + @Test + public void testAddObjectArrayLong() { + long[] newArray; + newArray = ArrayUtils.add((long[]) null, 0); + assertArrayEquals(new long[]{0}, newArray); + assertEquals(Long.TYPE, newArray.getClass().getComponentType()); + newArray = ArrayUtils.add((long[]) null, 1); + assertArrayEquals(new long[]{1}, newArray); + assertEquals(Long.TYPE, newArray.getClass().getComponentType()); + final long[] array1 = {1, 2, 3}; + newArray = ArrayUtils.add(array1, 0); + assertArrayEquals(new long[]{1, 2, 3, 0}, newArray); + assertEquals(Long.TYPE, newArray.getClass().getComponentType()); + newArray = ArrayUtils.add(array1, 4); + assertArrayEquals(new long[]{1, 2, 3, 4}, newArray); + assertEquals(Long.TYPE, newArray.getClass().getComponentType()); + } + + @Test + public void testAddObjectArrayObject() { + Object[] newArray; + + //show that not casting is okay + newArray = ArrayUtils.add((Object[]) null, "a"); + assertArrayEquals(new String[]{"a"}, newArray); + assertArrayEquals(new Object[]{"a"}, newArray); + assertEquals(String.class, newArray.getClass().getComponentType()); + + //show that not casting to Object[] is okay and will assume String based on "a" + final String[] newStringArray = ArrayUtils.add(null, "a"); + assertArrayEquals(new String[]{"a"}, newStringArray); + assertArrayEquals(new Object[]{"a"}, newStringArray); + assertEquals(String.class, newStringArray.getClass().getComponentType()); + + final String[] stringArray1 = {"a", "b", "c"}; + newArray = ArrayUtils.add(stringArray1, null); + assertArrayEquals(new String[]{"a", "b", "c", null}, newArray); + assertEquals(String.class, newArray.getClass().getComponentType()); + + newArray = ArrayUtils.add(stringArray1, "d"); + assertArrayEquals(new String[]{"a", "b", "c", "d"}, newArray); + assertEquals(String.class, newArray.getClass().getComponentType()); + + Number[] numberArray1 = {Integer.valueOf(1), Double.valueOf(2)}; + newArray = ArrayUtils.add(numberArray1, Float.valueOf(3)); + assertArrayEquals(new Number[]{Integer.valueOf(1), Double.valueOf(2), Float.valueOf(3)}, newArray); + assertEquals(Number.class, newArray.getClass().getComponentType()); + + numberArray1 = null; + newArray = ArrayUtils.add(numberArray1, Float.valueOf(3)); + assertArrayEquals(new Float[]{Float.valueOf(3)}, newArray); + assertEquals(Float.class, newArray.getClass().getComponentType()); + } + + @Test + public void testAddObjectArrayShort() { + short[] newArray; + newArray = ArrayUtils.add((short[]) null, (short) 0); + assertArrayEquals(new short[]{0}, newArray); + assertEquals(Short.TYPE, newArray.getClass().getComponentType()); + newArray = ArrayUtils.add((short[]) null, (short) 1); + assertArrayEquals(new short[]{1}, newArray); + assertEquals(Short.TYPE, newArray.getClass().getComponentType()); + final short[] array1 = {1, 2, 3}; + newArray = ArrayUtils.add(array1, (short) 0); + assertArrayEquals(new short[]{1, 2, 3, 0}, newArray); + assertEquals(Short.TYPE, newArray.getClass().getComponentType()); + newArray = ArrayUtils.add(array1, (short) 4); + assertArrayEquals(new short[]{1, 2, 3, 4}, newArray); + assertEquals(Short.TYPE, newArray.getClass().getComponentType()); + } + + @Test + public void testAddObjectArrayToObjectArray() { + assertNull(ArrayUtils.addAll(null, (Object[]) null)); + Object[] newArray; + final String[] stringArray1 = {"a", "b", "c"}; + final String[] stringArray2 = {"1", "2", "3"}; + newArray = ArrayUtils.addAll(stringArray1, (String[]) null); + assertNotSame(stringArray1, newArray); + assertArrayEquals(stringArray1, newArray); + assertArrayEquals(new String[]{"a", "b", "c"}, newArray); + assertEquals(String.class, newArray.getClass().getComponentType()); + newArray = ArrayUtils.addAll(null, stringArray2); + assertNotSame(stringArray2, newArray); + assertArrayEquals(stringArray2, newArray); + assertArrayEquals(new String[]{"1", "2", "3"}, newArray); + assertEquals(String.class, newArray.getClass().getComponentType()); + newArray = ArrayUtils.addAll(stringArray1, stringArray2); + assertArrayEquals(new String[]{"a", "b", "c", "1", "2", "3"}, newArray); + assertEquals(String.class, newArray.getClass().getComponentType()); + newArray = ArrayUtils.addAll(ArrayUtils.EMPTY_STRING_ARRAY, (String[]) null); + assertArrayEquals(ArrayUtils.EMPTY_STRING_ARRAY, newArray); + assertArrayEquals(new String[]{}, newArray); + assertEquals(String.class, newArray.getClass().getComponentType()); + newArray = ArrayUtils.addAll(null, ArrayUtils.EMPTY_STRING_ARRAY); + assertArrayEquals(ArrayUtils.EMPTY_STRING_ARRAY, newArray); + assertArrayEquals(new String[]{}, newArray); + assertEquals(String.class, newArray.getClass().getComponentType()); + newArray = ArrayUtils.addAll(ArrayUtils.EMPTY_STRING_ARRAY, ArrayUtils.EMPTY_STRING_ARRAY); + assertArrayEquals(ArrayUtils.EMPTY_STRING_ARRAY, newArray); + assertArrayEquals(new String[]{}, newArray); + assertEquals(String.class, newArray.getClass().getComponentType()); + final String[] stringArrayNull = {null}; + newArray = ArrayUtils.addAll(stringArrayNull, stringArrayNull); + assertArrayEquals(new String[]{null, null}, newArray); + assertEquals(String.class, newArray.getClass().getComponentType()); + + // boolean + assertArrayEquals(new boolean[]{true, false, false, true}, ArrayUtils.addAll(new boolean[]{true, false}, false, true)); + + assertArrayEquals(new boolean[]{false, true}, ArrayUtils.addAll(null, new boolean[]{false, true})); + + assertArrayEquals(new boolean[]{true, false}, ArrayUtils.addAll(new boolean[]{true, false}, null)); + + // char + assertArrayEquals(new char[]{'a', 'b', 'c', 'd'}, ArrayUtils.addAll(new char[]{'a', 'b'}, 'c', 'd')); + + assertArrayEquals(new char[]{'c', 'd'}, ArrayUtils.addAll(null, new char[]{'c', 'd'})); + + assertArrayEquals(new char[]{'a', 'b'}, ArrayUtils.addAll(new char[]{'a', 'b'}, null)); + + // byte + assertArrayEquals(new byte[]{(byte) 0, (byte) 1, (byte) 2, (byte) 3}, ArrayUtils.addAll(new byte[]{(byte) 0, (byte) 1}, (byte) 2, (byte) 3)); + + assertArrayEquals(new byte[]{(byte) 2, (byte) 3}, ArrayUtils.addAll(null, new byte[]{(byte) 2, (byte) 3})); + + assertArrayEquals(new byte[]{(byte) 0, (byte) 1}, ArrayUtils.addAll(new byte[]{(byte) 0, (byte) 1}, null)); + + // short + assertArrayEquals(new short[]{(short) 10, (short) 20, (short) 30, (short) 40}, ArrayUtils.addAll(new short[]{(short) 10, (short) 20}, (short) 30, (short) 40)); + + assertArrayEquals(new short[]{(short) 30, (short) 40}, ArrayUtils.addAll(null, new short[]{(short) 30, (short) 40})); + + assertArrayEquals(new short[]{(short) 10, (short) 20}, ArrayUtils.addAll(new short[]{(short) 10, (short) 20}, null)); + + // int + assertArrayEquals(new int[]{1, 1000, -1000, -1}, ArrayUtils.addAll(new int[]{1, 1000}, -1000, -1)); + + assertArrayEquals(new int[]{-1000, -1}, ArrayUtils.addAll(null, new int[]{-1000, -1})); + + assertArrayEquals(new int[]{1, 1000}, ArrayUtils.addAll(new int[]{1, 1000}, null)); + + // long + assertArrayEquals(new long[]{1L, -1L, 1000L, -1000L}, ArrayUtils.addAll(new long[]{1L, -1L}, 1000L, -1000L)); + + assertArrayEquals(new long[]{1000L, -1000L}, ArrayUtils.addAll(null, new long[]{1000L, -1000L})); + + assertArrayEquals(new long[]{1L, -1L}, ArrayUtils.addAll(new long[]{1L, -1L}, null)); + + // float + assertArrayEquals(new float[]{10.5f, 10.1f, 1.6f, 0.01f}, ArrayUtils.addAll(new float[]{10.5f, 10.1f}, 1.6f, 0.01f)); + + assertArrayEquals(new float[]{1.6f, 0.01f}, ArrayUtils.addAll(null, new float[]{1.6f, 0.01f})); + + assertArrayEquals(new float[]{10.5f, 10.1f}, ArrayUtils.addAll(new float[]{10.5f, 10.1f}, null)); + + // double + assertArrayEquals(new double[]{Math.PI, -Math.PI, 0, 9.99}, ArrayUtils.addAll(new double[]{Math.PI, -Math.PI}, 0, 9.99)); + + assertArrayEquals(new double[]{0, 9.99}, ArrayUtils.addAll(null, new double[]{0, 9.99})); + + assertArrayEquals(new double[]{Math.PI, -Math.PI}, ArrayUtils.addAll(new double[]{Math.PI, -Math.PI}, null)); + + } + + @SuppressWarnings("deprecation") + @Test + public void testAddObjectAtIndex() { + Object[] newArray; + newArray = ArrayUtils.add((Object[]) null, 0, "a"); + assertArrayEquals(new String[]{"a"}, newArray); + assertArrayEquals(new Object[]{"a"}, newArray); + assertEquals(String.class, newArray.getClass().getComponentType()); + final String[] stringArray1 = {"a", "b", "c"}; + newArray = ArrayUtils.add(stringArray1, 0, null); + assertArrayEquals(new String[]{null, "a", "b", "c"}, newArray); + assertEquals(String.class, newArray.getClass().getComponentType()); + newArray = ArrayUtils.add(stringArray1, 1, null); + assertArrayEquals(new String[]{"a", null, "b", "c"}, newArray); + assertEquals(String.class, newArray.getClass().getComponentType()); + newArray = ArrayUtils.add(stringArray1, 3, null); + assertArrayEquals(new String[]{"a", "b", "c", null}, newArray); + assertEquals(String.class, newArray.getClass().getComponentType()); + newArray = ArrayUtils.add(stringArray1, 3, "d"); + assertArrayEquals(new String[]{"a", "b", "c", "d"}, newArray); + assertEquals(String.class, newArray.getClass().getComponentType()); + assertEquals(String.class, newArray.getClass().getComponentType()); + + final Object[] o = {"1", "2", "4"}; + final Object[] result = ArrayUtils.add(o, 2, "3"); + final Object[] result2 = ArrayUtils.add(o, 3, "5"); + + assertNotNull(result); + assertEquals(4, result.length); + assertEquals("1", result[0]); + assertEquals("2", result[1]); + assertEquals("3", result[2]); + assertEquals("4", result[3]); + assertNotNull(result2); + assertEquals(4, result2.length); + assertEquals("1", result2[0]); + assertEquals("2", result2[1]); + assertEquals("4", result2[2]); + assertEquals("5", result2[3]); + + // boolean tests + boolean[] booleanArray = ArrayUtils.add( null, 0, true ); + assertArrayEquals(new boolean[]{true}, booleanArray); + IndexOutOfBoundsException e = + assertThrows(IndexOutOfBoundsException.class, () -> ArrayUtils.add( null, -1, true)); + assertEquals("Index: -1, Length: 0", e.getMessage()); + booleanArray = ArrayUtils.add( new boolean[] { true }, 0, false); + assertArrayEquals(new boolean[]{false, true}, booleanArray); + booleanArray = ArrayUtils.add( new boolean[] { false }, 1, true); + assertArrayEquals(new boolean[]{false, true}, booleanArray); + booleanArray = ArrayUtils.add( new boolean[] { true, false }, 1, true); + assertArrayEquals(new boolean[]{true, true, false}, booleanArray); + e = assertThrows(IndexOutOfBoundsException.class, () -> ArrayUtils.add(new boolean[] { true, false }, 4, true)); + assertEquals("Index: 4, Length: 2", e.getMessage()); + e = assertThrows(IndexOutOfBoundsException.class, () -> ArrayUtils.add(new boolean[] { true, false }, -1, true)); + assertEquals("Index: -1, Length: 2", e.getMessage()); + + // char tests + char[] charArray = ArrayUtils.add( (char[]) null, 0, 'a' ); + assertArrayEquals(new char[]{'a'}, charArray); + e = assertThrows(IndexOutOfBoundsException.class, () -> ArrayUtils.add( (char[]) null, -1, 'a' )); + assertEquals("Index: -1, Length: 0", e.getMessage()); + charArray = ArrayUtils.add( new char[] { 'a' }, 0, 'b'); + assertArrayEquals(new char[]{'b', 'a'}, charArray); + charArray = ArrayUtils.add( new char[] { 'a', 'b' }, 0, 'c'); + assertArrayEquals(new char[]{'c', 'a', 'b'}, charArray); + charArray = ArrayUtils.add( new char[] { 'a', 'b' }, 1, 'k'); + assertArrayEquals(new char[]{'a', 'k', 'b'}, charArray); + charArray = ArrayUtils.add( new char[] { 'a', 'b', 'c' }, 1, 't'); + assertArrayEquals(new char[]{'a', 't', 'b', 'c'}, charArray); + e = assertThrows(IndexOutOfBoundsException.class, () -> ArrayUtils.add( new char[] { 'a', 'b' }, 4, 'c')); + assertEquals("Index: 4, Length: 2", e.getMessage()); + e = assertThrows(IndexOutOfBoundsException.class, () -> ArrayUtils.add( new char[] { 'a', 'b' }, -1, 'c')); + assertEquals("Index: -1, Length: 2", e.getMessage()); + + // short tests + short[] shortArray = ArrayUtils.add( new short[] { 1 }, 0, (short) 2); + assertArrayEquals(new short[]{2, 1}, shortArray); + e = assertThrows(IndexOutOfBoundsException.class, () -> ArrayUtils.add( (short[]) null, -1, (short) 2)); + assertEquals("Index: -1, Length: 0", e.getMessage()); + shortArray = ArrayUtils.add( new short[] { 2, 6 }, 2, (short) 10); + assertArrayEquals(new short[]{2, 6, 10}, shortArray); + shortArray = ArrayUtils.add( new short[] { 2, 6 }, 0, (short) -4); + assertArrayEquals(new short[]{-4, 2, 6}, shortArray); + shortArray = ArrayUtils.add( new short[] { 2, 6, 3 }, 2, (short) 1); + assertArrayEquals(new short[]{2, 6, 1, 3}, shortArray); + e = assertThrows(IndexOutOfBoundsException.class, () -> ArrayUtils.add( new short[] { 2, 6 }, 4, (short) 10)); + assertEquals("Index: 4, Length: 2", e.getMessage()); + e = assertThrows(IndexOutOfBoundsException.class, () -> ArrayUtils.add( new short[] { 2, 6 }, -1, (short) 10)); + assertEquals("Index: -1, Length: 2", e.getMessage()); + + // byte tests + byte[] byteArray = ArrayUtils.add( new byte[] { 1 }, 0, (byte) 2); + assertArrayEquals(new byte[]{2, 1}, byteArray); + e = assertThrows(IndexOutOfBoundsException.class, () -> ArrayUtils.add( (byte[]) null, -1, (byte) 2)); + assertEquals("Index: -1, Length: 0", e.getMessage()); + byteArray = ArrayUtils.add( new byte[] { 2, 6 }, 2, (byte) 3); + assertArrayEquals(new byte[]{2, 6, 3}, byteArray); + byteArray = ArrayUtils.add( new byte[] { 2, 6 }, 0, (byte) 1); + assertArrayEquals(new byte[]{1, 2, 6}, byteArray); + byteArray = ArrayUtils.add( new byte[] { 2, 6, 3 }, 2, (byte) 1); + assertArrayEquals(new byte[]{2, 6, 1, 3}, byteArray); + e = assertThrows(IndexOutOfBoundsException.class, () -> ArrayUtils.add( new byte[] { 2, 6 }, 4, (byte) 3)); + assertEquals("Index: 4, Length: 2", e.getMessage()); + e = assertThrows(IndexOutOfBoundsException.class, () -> ArrayUtils.add( new byte[] { 2, 6 }, -1, (byte) 3)); + assertEquals("Index: -1, Length: 2", e.getMessage()); + + // int tests + int[] intArray = ArrayUtils.add( new int[] { 1 }, 0, 2); + assertArrayEquals(new int[]{2, 1}, intArray); + e = assertThrows(IndexOutOfBoundsException.class, () -> ArrayUtils.add( (int[]) null, -1, 2)); + assertEquals("Index: -1, Length: 0", e.getMessage()); + intArray = ArrayUtils.add( new int[] { 2, 6 }, 2, 10); + assertArrayEquals(new int[]{2, 6, 10}, intArray); + intArray = ArrayUtils.add( new int[] { 2, 6 }, 0, -4); + assertArrayEquals(new int[]{-4, 2, 6}, intArray); + intArray = ArrayUtils.add( new int[] { 2, 6, 3 }, 2, 1); + assertArrayEquals(new int[]{2, 6, 1, 3}, intArray); + e = assertThrows(IndexOutOfBoundsException.class, () -> ArrayUtils.add( new int[] { 2, 6 }, 4, 10)); + assertEquals("Index: 4, Length: 2", e.getMessage()); + e = assertThrows(IndexOutOfBoundsException.class, () -> ArrayUtils.add( new int[] { 2, 6 }, -1, 10)); + assertEquals("Index: -1, Length: 2", e.getMessage()); + + // long tests + long[] longArray = ArrayUtils.add( new long[] { 1L }, 0, 2L); + assertArrayEquals(new long[]{2L, 1L}, longArray); + e = assertThrows(IndexOutOfBoundsException.class, () -> ArrayUtils.add( (long[]) null, -1, 2L)); + assertEquals("Index: -1, Length: 0", e.getMessage()); + longArray = ArrayUtils.add( new long[] { 2L, 6L }, 2, 10L); + assertArrayEquals(new long[]{2L, 6L, 10L}, longArray); + longArray = ArrayUtils.add( new long[] { 2L, 6L }, 0, -4L); + assertArrayEquals(new long[]{-4L, 2L, 6L}, longArray); + longArray = ArrayUtils.add( new long[] { 2L, 6L, 3L }, 2, 1L); + assertArrayEquals(new long[]{2L, 6L, 1L, 3L}, longArray); + e = assertThrows(IndexOutOfBoundsException.class, () -> ArrayUtils.add( new long[] { 2L, 6L }, 4, 10L)); + assertEquals("Index: 4, Length: 2", e.getMessage()); + e = assertThrows(IndexOutOfBoundsException.class, () -> ArrayUtils.add( new long[] { 2L, 6L }, -1, 10L)); + assertEquals("Index: -1, Length: 2", e.getMessage()); + + // float tests + float[] floatArray = ArrayUtils.add( new float[] { 1.1f }, 0, 2.2f); + assertArrayEquals(new float[]{2.2f, 1.1f}, floatArray); + e = assertThrows(IndexOutOfBoundsException.class, () -> ArrayUtils.add( (float[]) null, -1, 2.2f)); + assertEquals("Index: -1, Length: 0", e.getMessage()); + floatArray = ArrayUtils.add( new float[] { 2.3f, 6.4f }, 2, 10.5f); + assertArrayEquals(new float[]{2.3f, 6.4f, 10.5f}, floatArray); + floatArray = ArrayUtils.add( new float[] { 2.6f, 6.7f }, 0, -4.8f); + assertArrayEquals(new float[]{-4.8f, 2.6f, 6.7f}, floatArray); + floatArray = ArrayUtils.add( new float[] { 2.9f, 6.0f, 0.3f }, 2, 1.0f); + assertArrayEquals(new float[]{2.9f, 6.0f, 1.0f, 0.3f}, floatArray); + e = assertThrows(IndexOutOfBoundsException.class, () -> ArrayUtils.add( new float[] { 2.3f, 6.4f }, 4, 10.5f)); + assertEquals("Index: 4, Length: 2", e.getMessage()); + e = assertThrows(IndexOutOfBoundsException.class, () -> ArrayUtils.add( new float[] { 2.3f, 6.4f }, -1, 10.5f)); + assertEquals("Index: -1, Length: 2", e.getMessage()); + + // double tests + double[] doubleArray = ArrayUtils.add( new double[] { 1.1 }, 0, 2.2); + assertArrayEquals(new double[]{2.2, 1.1}, doubleArray); + e = assertThrows(IndexOutOfBoundsException.class, () -> ArrayUtils.add(null, -1, 2.2)); + assertEquals("Index: -1, Length: 0", e.getMessage()); + doubleArray = ArrayUtils.add( new double[] { 2.3, 6.4 }, 2, 10.5); + assertArrayEquals(new double[]{2.3, 6.4, 10.5}, doubleArray); + doubleArray = ArrayUtils.add( new double[] { 2.6, 6.7 }, 0, -4.8); + assertArrayEquals(new double[]{-4.8, 2.6, 6.7}, doubleArray); + doubleArray = ArrayUtils.add( new double[] { 2.9, 6.0, 0.3 }, 2, 1.0); + assertArrayEquals(new double[]{2.9, 6.0, 1.0, 0.3}, doubleArray); + e = assertThrows(IndexOutOfBoundsException.class, () -> ArrayUtils.add( new double[] { 2.3, 6.4 }, 4, 10.5)); + assertEquals("Index: 4, Length: 2", e.getMessage()); + e = assertThrows(IndexOutOfBoundsException.class, () -> ArrayUtils.add( new double[] { 2.3, 6.4 }, -1, 10.5)); + assertEquals("Index: -1, Length: 2", e.getMessage()); + } + + @Test + public void testJira567() { + final Number[] n; + // Valid array construction + n = ArrayUtils.addAll(new Number[]{Integer.valueOf(1)}, new Long[]{Long.valueOf(2)}); + assertEquals(2, n.length); + assertEquals(Number.class, n.getClass().getComponentType()); + // Invalid - can't store Long in Integer array + assertThrows(IllegalArgumentException.class, + () -> ArrayUtils.addAll(new Integer[]{Integer.valueOf(1)}, new Long[]{Long.valueOf(2)})); + } + + @Test + @SuppressWarnings("deprecation") + public void testLANG571() { + final String[] stringArray=null; + final String aString=null; + assertThrows(IllegalArgumentException.class, () -> ArrayUtils.add(stringArray, aString)); + assertThrows(IllegalArgumentException.class, () -> ArrayUtils.add(stringArray, 0, aString)); + } + +} |