diff options
Diffstat (limited to 'src/test/java/org/apache/commons/lang3/ArrayUtilsRemoveMultipleTest.java')
| -rw-r--r-- | src/test/java/org/apache/commons/lang3/ArrayUtilsRemoveMultipleTest.java | 1264 |
1 files changed, 1264 insertions, 0 deletions
diff --git a/src/test/java/org/apache/commons/lang3/ArrayUtilsRemoveMultipleTest.java b/src/test/java/org/apache/commons/lang3/ArrayUtilsRemoveMultipleTest.java new file mode 100644 index 000000000..a5151d015 --- /dev/null +++ b/src/test/java/org/apache/commons/lang3/ArrayUtilsRemoveMultipleTest.java @@ -0,0 +1,1264 @@ +/* + * 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.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 remove and removeElement methods. + */ +public class ArrayUtilsRemoveMultipleTest extends AbstractLangTest { + + @Test + public void testRemoveAllBooleanArray() { + boolean[] array; + + array = ArrayUtils.removeAll(new boolean[] { true }, 0); + assertArrayEquals(ArrayUtils.EMPTY_BOOLEAN_ARRAY, array); + assertEquals(Boolean.TYPE, array.getClass().getComponentType()); + + array = ArrayUtils.removeAll(new boolean[] { true, false }, 0); + assertArrayEquals(new boolean[]{false}, array); + assertEquals(Boolean.TYPE, array.getClass().getComponentType()); + + array = ArrayUtils.removeAll(new boolean[] { true, false }, 1); + assertArrayEquals(new boolean[]{true}, array); + assertEquals(Boolean.TYPE, array.getClass().getComponentType()); + + array = ArrayUtils.removeAll(new boolean[] { true, false, true }, 1); + assertArrayEquals(new boolean[]{true, true}, array); + assertEquals(Boolean.TYPE, array.getClass().getComponentType()); + + array = ArrayUtils.removeAll(new boolean[] { true, false }, 0, 1); + assertArrayEquals(ArrayUtils.EMPTY_BOOLEAN_ARRAY, array); + assertEquals(Boolean.TYPE, array.getClass().getComponentType()); + + array = ArrayUtils.removeAll(new boolean[] { true, false, false }, 0, 1); + assertArrayEquals(new boolean[]{false}, array); + assertEquals(Boolean.TYPE, array.getClass().getComponentType()); + + array = ArrayUtils.removeAll(new boolean[] { true, false, false }, 0, 2); + assertArrayEquals(new boolean[]{false}, array); + assertEquals(Boolean.TYPE, array.getClass().getComponentType()); + + array = ArrayUtils.removeAll(new boolean[] { true, false, false }, 1, 2); + assertArrayEquals(new boolean[]{true}, array); + assertEquals(Boolean.TYPE, array.getClass().getComponentType()); + + array = ArrayUtils.removeAll(new boolean[] { true, false, true, false, true }, 0, 2, 4); + assertArrayEquals(new boolean[]{false, false}, array); + assertEquals(Boolean.TYPE, array.getClass().getComponentType()); + + array = ArrayUtils.removeAll(new boolean[] { true, false, true, false, true }, 1, 3); + assertArrayEquals(new boolean[]{true, true, true}, array); + assertEquals(Boolean.TYPE, array.getClass().getComponentType()); + + array = ArrayUtils.removeAll(new boolean[] { true, false, true, false, true }, 1, 3, 4); + assertArrayEquals(new boolean[]{true, true}, array); + assertEquals(Boolean.TYPE, array.getClass().getComponentType()); + + array = ArrayUtils.removeAll(new boolean[] { true, false, true, false, true, false, true }, 0, 2, 4, 6); + assertArrayEquals(new boolean[]{false, false, false}, array); + assertEquals(Boolean.TYPE, array.getClass().getComponentType()); + + array = ArrayUtils.removeAll(new boolean[] { true, false, true, false, true, false, true }, 1, 3, 5); + assertArrayEquals(new boolean[]{true, true, true, true}, array); + assertEquals(Boolean.TYPE, array.getClass().getComponentType()); + + array = ArrayUtils.removeAll(new boolean[] { true, false, true, false, true, false, true }, 0, 1, 2); + assertArrayEquals(new boolean[]{false, true, false, true}, array); + assertEquals(Boolean.TYPE, array.getClass().getComponentType()); + } + + @Test + public void testRemoveAllBooleanArrayNegativeIndex() { + assertThrows(IndexOutOfBoundsException.class, () -> ArrayUtils.removeAll(new boolean[] { true, false }, -1)); + } + + @Test + public void testRemoveAllBooleanArrayOutOfBoundsIndex() { + assertThrows(IndexOutOfBoundsException.class, () -> ArrayUtils.removeAll(new boolean[] { true, false }, 2)); + } + + @Test + public void testRemoveAllBooleanArrayRemoveNone() { + final boolean[] array1 = { true, false }; + final boolean[] array2 = ArrayUtils.removeAll(array1); + assertNotSame(array1, array2); + assertArrayEquals(array1, array2); + assertEquals(boolean.class, array2.getClass().getComponentType()); + } + + @Test + public void testRemoveAllByteArray() { + byte[] array; + + array = ArrayUtils.removeAll(new byte[] { 1 }, 0); + assertArrayEquals(ArrayUtils.EMPTY_BYTE_ARRAY, array); + assertEquals(Byte.TYPE, array.getClass().getComponentType()); + + array = ArrayUtils.removeAll(new byte[] { 1, 2 }, 0); + assertArrayEquals(new byte[]{2}, array); + assertEquals(Byte.TYPE, array.getClass().getComponentType()); + + array = ArrayUtils.removeAll(new byte[] { 1, 2 }, 1); + assertArrayEquals(new byte[]{1}, array); + assertEquals(Byte.TYPE, array.getClass().getComponentType()); + + array = ArrayUtils.removeAll(new byte[] { 1, 2, 1 }, 1); + assertArrayEquals(new byte[]{1, 1}, array); + assertEquals(Byte.TYPE, array.getClass().getComponentType()); + + array = ArrayUtils.removeAll(new byte[] { 1, 2 }, 0, 1); + assertArrayEquals(ArrayUtils.EMPTY_BYTE_ARRAY, array); + assertEquals(Byte.TYPE, array.getClass().getComponentType()); + + array = ArrayUtils.removeAll(new byte[] { 1, 2, 3 }, 0, 1); + assertArrayEquals(new byte[]{3}, array); + assertEquals(Byte.TYPE, array.getClass().getComponentType()); + + array = ArrayUtils.removeAll(new byte[] { 1, 2, 3 }, 1, 2); + assertArrayEquals(new byte[]{1}, array); + assertEquals(Byte.TYPE, array.getClass().getComponentType()); + + array = ArrayUtils.removeAll(new byte[] { 1, 2, 3 }, 0, 2); + assertArrayEquals(new byte[]{2}, array); + assertEquals(Byte.TYPE, array.getClass().getComponentType()); + + array = ArrayUtils.removeAll(new byte[] { 1, 2, 3, 4, 5 }, 1, 3); + assertArrayEquals(new byte[]{1, 3, 5}, array); + assertEquals(Byte.TYPE, array.getClass().getComponentType()); + + array = ArrayUtils.removeAll(new byte[] { 1, 2, 3, 4, 5 }, 0, 2, 4); + assertArrayEquals(new byte[]{2, 4}, array); + assertEquals(Byte.TYPE, array.getClass().getComponentType()); + + array = ArrayUtils.removeAll(new byte[] { 1, 2, 3, 4, 5, 6, 7 }, 1, 3, 5); + assertArrayEquals(new byte[]{1, 3, 5, 7}, array); + assertEquals(Byte.TYPE, array.getClass().getComponentType()); + + array = ArrayUtils.removeAll(new byte[] { 1, 2, 3, 4, 5, 6, 7 }, 0, 2, 4, 6); + assertArrayEquals(new byte[]{2, 4, 6}, array); + assertEquals(Byte.TYPE, array.getClass().getComponentType()); + } + + @Test + public void testRemoveAllByteArrayNegativeIndex() { + assertThrows(IndexOutOfBoundsException.class, () -> ArrayUtils.removeAll(new byte[] { 1, 2 }, -1)); + } + + @Test + public void testRemoveAllByteArrayOutOfBoundsIndex() { + assertThrows(IndexOutOfBoundsException.class, () -> ArrayUtils.removeAll(new byte[] { 1, 2 }, 2)); + } + + @Test + public void testRemoveAllByteArrayRemoveNone() { + final byte[] array1 = { 1, 2 }; + final byte[] array2 = ArrayUtils.removeAll(array1); + assertNotSame(array1, array2); + assertArrayEquals(array1, array2); + assertEquals(byte.class, array2.getClass().getComponentType()); + } + + @Test + public void testRemoveAllCharArray() { + char[] array; + + array = ArrayUtils.removeAll(new char[] { 'a' }, 0); + assertArrayEquals(ArrayUtils.EMPTY_CHAR_ARRAY, array); + assertEquals(Character.TYPE, array.getClass().getComponentType()); + + array = ArrayUtils.removeAll(new char[] { 'a', 'b' }, 0); + assertArrayEquals(new char[]{'b'}, array); + assertEquals(Character.TYPE, array.getClass().getComponentType()); + + array = ArrayUtils.removeAll(new char[] { 'a', 'b' }, 1); + assertArrayEquals(new char[]{'a'}, array); + assertEquals(Character.TYPE, array.getClass().getComponentType()); + + array = ArrayUtils.removeAll(new char[] { 'a', 'b', 'c' }, 1); + assertArrayEquals(new char[]{'a', 'c'}, array); + assertEquals(Character.TYPE, array.getClass().getComponentType()); + + array = ArrayUtils.removeAll(new char[] { 'a', 'b' }, 0, 1); + assertArrayEquals(ArrayUtils.EMPTY_CHAR_ARRAY, array); + assertEquals(Character.TYPE, array.getClass().getComponentType()); + + array = ArrayUtils.removeAll(new char[] { 'a', 'b', 'c' }, 0, 1); + assertArrayEquals(new char[]{'c'}, array); + assertEquals(Character.TYPE, array.getClass().getComponentType()); + + array = ArrayUtils.removeAll(new char[] { 'a', 'b', 'c' }, 1, 2); + assertArrayEquals(new char[]{'a'}, array); + assertEquals(Character.TYPE, array.getClass().getComponentType()); + + array = ArrayUtils.removeAll(new char[] { 'a', 'b', 'c' }, 0, 2); + assertArrayEquals(new char[]{'b'}, array); + assertEquals(Character.TYPE, array.getClass().getComponentType()); + + array = ArrayUtils.removeAll(new char[] { 'a', 'b', 'c', 'd', 'e' }, 1, 3); + assertArrayEquals(new char[]{'a', 'c', 'e'}, array); + assertEquals(Character.TYPE, array.getClass().getComponentType()); + + array = ArrayUtils.removeAll(new char[] { 'a', 'b', 'c', 'd', 'e' }, 0, 2, 4); + assertArrayEquals(new char[]{'b', 'd'}, array); + assertEquals(Character.TYPE, array.getClass().getComponentType()); + + array = ArrayUtils.removeAll(new char[] { 'a', 'b', 'c', 'd', 'e', 'f', 'g' }, 1, 3, 5); + assertArrayEquals(new char[]{'a', 'c', 'e', 'g'}, array); + assertEquals(Character.TYPE, array.getClass().getComponentType()); + + array = ArrayUtils.removeAll(new char[] { 'a', 'b', 'c', 'd', 'e', 'f', 'g' }, 0, 2, 4, 6); + assertArrayEquals(new char[]{'b', 'd', 'f'}, array); + assertEquals(Character.TYPE, array.getClass().getComponentType()); + } + + @Test + public void testRemoveAllCharArrayNegativeIndex() { + assertThrows(IndexOutOfBoundsException.class, () -> ArrayUtils.removeAll(new char[] { 'a', 'b' }, -1)); + } + + @Test + public void testRemoveAllCharArrayOutOfBoundsIndex() { + assertThrows(IndexOutOfBoundsException.class, () -> ArrayUtils.removeAll(new char[] { 'a', 'b' }, 2)); + } + + @Test + public void testRemoveAllCharArrayRemoveNone() { + final char[] array1 = { 'a', 'b' }; + final char[] array2 = ArrayUtils.removeAll(array1); + assertNotSame(array1, array2); + assertArrayEquals(array1, array2); + assertEquals(char.class, array2.getClass().getComponentType()); + } + + @Test + public void testRemoveAllDoubleArray() { + double[] array; + + array = ArrayUtils.removeAll(new double[] { 1 }, 0); + assertArrayEquals(ArrayUtils.EMPTY_DOUBLE_ARRAY, array); + assertEquals(Double.TYPE, array.getClass().getComponentType()); + + array = ArrayUtils.removeAll(new double[] { 1, 2 }, 0); + assertArrayEquals(new double[]{2}, array); + assertEquals(Double.TYPE, array.getClass().getComponentType()); + + array = ArrayUtils.removeAll(new double[] { 1, 2 }, 1); + assertArrayEquals(new double[]{1}, array); + assertEquals(Double.TYPE, array.getClass().getComponentType()); + + array = ArrayUtils.removeAll(new double[] { 1, 2, 1 }, 1); + assertArrayEquals(new double[]{1, 1}, array); + assertEquals(Double.TYPE, array.getClass().getComponentType()); + + array = ArrayUtils.removeAll(new double[] { 1, 2 }, 0, 1); + assertArrayEquals(ArrayUtils.EMPTY_DOUBLE_ARRAY, array); + assertEquals(Double.TYPE, array.getClass().getComponentType()); + + array = ArrayUtils.removeAll(new double[] { 1, 2, 3 }, 0, 1); + assertArrayEquals(new double[]{3}, array); + assertEquals(Double.TYPE, array.getClass().getComponentType()); + + array = ArrayUtils.removeAll(new double[] { 1, 2, 3 }, 1, 2); + assertArrayEquals(new double[]{1}, array); + assertEquals(Double.TYPE, array.getClass().getComponentType()); + + array = ArrayUtils.removeAll(new double[] { 1, 2, 3 }, 0, 2); + assertArrayEquals(new double[]{2}, array); + assertEquals(Double.TYPE, array.getClass().getComponentType()); + + array = ArrayUtils.removeAll(new double[] { 1, 2, 3, 4, 5 }, 1, 3); + assertArrayEquals(new double[]{1, 3, 5}, array); + assertEquals(Double.TYPE, array.getClass().getComponentType()); + + array = ArrayUtils.removeAll(new double[] { 1, 2, 3, 4, 5 }, 0, 2, 4); + assertArrayEquals(new double[]{2, 4}, array); + assertEquals(Double.TYPE, array.getClass().getComponentType()); + + array = ArrayUtils.removeAll(new double[] { 1, 2, 3, 4, 5, 6, 7 }, 1, 3, 5); + assertArrayEquals(new double[]{1, 3, 5, 7}, array); + assertEquals(Double.TYPE, array.getClass().getComponentType()); + + array = ArrayUtils.removeAll(new double[] { 1, 2, 3, 4, 5, 6, 7 }, 0, 2, 4, 6); + assertArrayEquals(new double[]{2, 4, 6}, array); + assertEquals(Double.TYPE, array.getClass().getComponentType()); + } + + @Test + public void testRemoveAllDoubleArrayNegativeIndex() { + assertThrows(IndexOutOfBoundsException.class, () -> ArrayUtils.removeAll(new double[] { 1, 2 }, -1)); + } + + @Test + public void testRemoveAllDoubleArrayOutOfBoundsIndex() { + assertThrows(IndexOutOfBoundsException.class, () -> ArrayUtils.removeAll(new double[] { 1, 2 }, 2)); + } + + @Test + public void testRemoveAllDoubleArrayRemoveNone() { + final double[] array1 = { 1, 2 }; + final double[] array2 = ArrayUtils.removeAll(array1); + assertNotSame(array1, array2); + assertArrayEquals(array1, array2); + assertEquals(double.class, array2.getClass().getComponentType()); + } + + @Test + public void testRemoveAllFloatArray() { + float[] array; + + array = ArrayUtils.removeAll(new float[] { 1 }, 0); + assertArrayEquals(ArrayUtils.EMPTY_FLOAT_ARRAY, array); + assertEquals(Float.TYPE, array.getClass().getComponentType()); + + array = ArrayUtils.removeAll(new float[] { 1, 2 }, 0); + assertArrayEquals(new float[]{2}, array); + assertEquals(Float.TYPE, array.getClass().getComponentType()); + + array = ArrayUtils.removeAll(new float[] { 1, 2 }, 1); + assertArrayEquals(new float[]{1}, array); + assertEquals(Float.TYPE, array.getClass().getComponentType()); + + array = ArrayUtils.removeAll(new float[] { 1, 2, 1 }, 1); + assertArrayEquals(new float[]{1, 1}, array); + assertEquals(Float.TYPE, array.getClass().getComponentType()); + + array = ArrayUtils.removeAll(new float[] { 1, 2 }, 0, 1); + assertArrayEquals(ArrayUtils.EMPTY_FLOAT_ARRAY, array); + assertEquals(Float.TYPE, array.getClass().getComponentType()); + + array = ArrayUtils.removeAll(new float[] { 1, 2, 3 }, 0, 1); + assertArrayEquals(new float[]{3}, array); + assertEquals(Float.TYPE, array.getClass().getComponentType()); + + array = ArrayUtils.removeAll(new float[] { 1, 2, 3 }, 1, 2); + assertArrayEquals(new float[]{1}, array); + assertEquals(Float.TYPE, array.getClass().getComponentType()); + + array = ArrayUtils.removeAll(new float[] { 1, 2, 3 }, 0, 2); + assertArrayEquals(new float[]{2}, array); + assertEquals(Float.TYPE, array.getClass().getComponentType()); + + array = ArrayUtils.removeAll(new float[] { 1, 2, 3, 4, 5 }, 1, 3); + assertArrayEquals(new float[]{1, 3, 5}, array); + assertEquals(Float.TYPE, array.getClass().getComponentType()); + + array = ArrayUtils.removeAll(new float[] { 1, 2, 3, 4, 5 }, 0, 2, 4); + assertArrayEquals(new float[]{2, 4}, array); + assertEquals(Float.TYPE, array.getClass().getComponentType()); + + array = ArrayUtils.removeAll(new float[] { 1, 2, 3, 4, 5, 6, 7 }, 1, 3, 5); + assertArrayEquals(new float[]{1, 3, 5, 7}, array); + assertEquals(Float.TYPE, array.getClass().getComponentType()); + + array = ArrayUtils.removeAll(new float[] { 1, 2, 3, 4, 5, 6, 7 }, 0, 2, 4, 6); + assertArrayEquals(new float[]{2, 4, 6}, array); + assertEquals(Float.TYPE, array.getClass().getComponentType()); + } + + @Test + public void testRemoveAllFloatArrayNegativeIndex() { + assertThrows(IndexOutOfBoundsException.class, () -> ArrayUtils.removeAll(new float[] { 1, 2 }, -1)); + } + + @Test + public void testRemoveAllFloatArrayOutOfBoundsIndex() { + assertThrows(IndexOutOfBoundsException.class, () -> ArrayUtils.removeAll(new float[] { 1, 2 }, 2)); + } + + @Test + public void testRemoveAllFloatArrayRemoveNone() { + final float[] array1 = { 1, 2 }; + final float[] array2 = ArrayUtils.removeAll(array1); + assertNotSame(array1, array2); + assertArrayEquals(array1, array2); + assertEquals(float.class, array2.getClass().getComponentType()); + } + + @Test + public void testRemoveAllIntArray() { + int[] array; + + array = ArrayUtils.removeAll(ArrayUtils.EMPTY_INT_ARRAY, ArrayUtils.EMPTY_INT_ARRAY); + assertArrayEquals(ArrayUtils.EMPTY_INT_ARRAY, array); + + array = ArrayUtils.removeAll(new int[] { 1 }, ArrayUtils.EMPTY_INT_ARRAY); + assertArrayEquals(new int[]{1}, array); + + array = ArrayUtils.removeAll(new int[] { 1 }, 0); + assertArrayEquals(ArrayUtils.EMPTY_INT_ARRAY, array); + assertEquals(Integer.TYPE, array.getClass().getComponentType()); + + array = ArrayUtils.removeAll(new int[] { 1, 2 }, 0); + assertArrayEquals(new int[]{2}, array); + assertEquals(Integer.TYPE, array.getClass().getComponentType()); + + array = ArrayUtils.removeAll(new int[] { 1, 2 }, 1); + assertArrayEquals(new int[]{1}, array); + assertEquals(Integer.TYPE, array.getClass().getComponentType()); + + array = ArrayUtils.removeAll(new int[] { 1, 2, 1 }, 1); + assertArrayEquals(new int[]{1, 1}, array); + assertEquals(Integer.TYPE, array.getClass().getComponentType()); + + array = ArrayUtils.removeAll(new int[] { 1, 2 }, 0, 1); + assertArrayEquals(ArrayUtils.EMPTY_INT_ARRAY, array); + assertEquals(Integer.TYPE, array.getClass().getComponentType()); + + array = ArrayUtils.removeAll(new int[] { 1, 2, 3 }, 0, 1); + assertArrayEquals(new int[]{3}, array); + assertEquals(Integer.TYPE, array.getClass().getComponentType()); + + array = ArrayUtils.removeAll(new int[] { 1, 2, 3 }, 1, 2); + assertArrayEquals(new int[]{1}, array); + assertEquals(Integer.TYPE, array.getClass().getComponentType()); + + array = ArrayUtils.removeAll(new int[] { 1, 2, 3 }, 0, 2); + assertArrayEquals(new int[]{2}, array); + assertEquals(Integer.TYPE, array.getClass().getComponentType()); + + array = ArrayUtils.removeAll(new int[] { 1, 2, 3, 4, 5 }, 1, 3); + assertArrayEquals(new int[]{1, 3, 5}, array); + assertEquals(Integer.TYPE, array.getClass().getComponentType()); + + array = ArrayUtils.removeAll(new int[] { 1, 2, 3, 4, 5 }, 0, 2, 4); + assertArrayEquals(new int[]{2, 4}, array); + assertEquals(Integer.TYPE, array.getClass().getComponentType()); + + array = ArrayUtils.removeAll(new int[] { 1, 2, 3, 4, 5, 6, 7 }, 1, 3, 5); + assertArrayEquals(new int[]{1, 3, 5, 7}, array); + assertEquals(Integer.TYPE, array.getClass().getComponentType()); + + array = ArrayUtils.removeAll(new int[] { 1, 2, 3, 4, 5, 6, 7 }, 0, 2, 4, 6); + assertArrayEquals(new int[]{2, 4, 6}, array); + assertEquals(Integer.TYPE, array.getClass().getComponentType()); + } + + @Test + public void testRemoveAllIntArrayNegativeIndex() { + assertThrows(IndexOutOfBoundsException.class, () -> ArrayUtils.removeAll(new int[] { 1, 2 }, -1)); + } + + @Test + public void testRemoveAllIntArrayOutOfBoundsIndex() { + assertThrows(IndexOutOfBoundsException.class, () -> ArrayUtils.removeAll(new int[] { 1, 2 }, 2)); + } + + @Test + public void testRemoveAllIntArrayRemoveNone() { + final int[] array1 = { 1, 2 }; + final int[] array2 = ArrayUtils.removeAll(array1); + assertNotSame(array1, array2); + assertArrayEquals(array1, array2); + assertEquals(int.class, array2.getClass().getComponentType()); + } + + @Test + public void testRemoveAllLongArray() { + long[] array; + + array = ArrayUtils.removeAll(new long[] { 1 }, 0); + assertArrayEquals(ArrayUtils.EMPTY_LONG_ARRAY, array); + assertEquals(Long.TYPE, array.getClass().getComponentType()); + + array = ArrayUtils.removeAll(new long[] { 1, 2 }, 0); + assertArrayEquals(new long[]{2}, array); + assertEquals(Long.TYPE, array.getClass().getComponentType()); + + array = ArrayUtils.removeAll(new long[] { 1, 2 }, 1); + assertArrayEquals(new long[]{1}, array); + assertEquals(Long.TYPE, array.getClass().getComponentType()); + + array = ArrayUtils.removeAll(new long[] { 1, 2, 1 }, 1); + assertArrayEquals(new long[]{1, 1}, array); + assertEquals(Long.TYPE, array.getClass().getComponentType()); + + array = ArrayUtils.removeAll(new long[] { 1, 2 }, 0, 1); + assertArrayEquals(ArrayUtils.EMPTY_LONG_ARRAY, array); + assertEquals(Long.TYPE, array.getClass().getComponentType()); + + array = ArrayUtils.removeAll(new long[] { 1, 2, 3 }, 0, 1); + assertArrayEquals(new long[]{3}, array); + assertEquals(Long.TYPE, array.getClass().getComponentType()); + + array = ArrayUtils.removeAll(new long[] { 1, 2, 3 }, 1, 2); + assertArrayEquals(new long[]{1}, array); + assertEquals(Long.TYPE, array.getClass().getComponentType()); + + array = ArrayUtils.removeAll(new long[] { 1, 2, 3 }, 0, 2); + assertArrayEquals(new long[]{2}, array); + assertEquals(Long.TYPE, array.getClass().getComponentType()); + + array = ArrayUtils.removeAll(new long[] { 1, 2, 3, 4, 5 }, 1, 3); + assertArrayEquals(new long[]{1, 3, 5}, array); + assertEquals(Long.TYPE, array.getClass().getComponentType()); + + array = ArrayUtils.removeAll(new long[] { 1, 2, 3, 4, 5 }, 0, 2, 4); + assertArrayEquals(new long[]{2, 4}, array); + assertEquals(Long.TYPE, array.getClass().getComponentType()); + + array = ArrayUtils.removeAll(new long[] { 1, 2, 3, 4, 5, 6, 7 }, 1, 3, 5); + assertArrayEquals(new long[]{1, 3, 5, 7}, array); + assertEquals(Long.TYPE, array.getClass().getComponentType()); + + array = ArrayUtils.removeAll(new long[] { 1, 2, 3, 4, 5, 6, 7 }, 0, 2, 4, 6); + assertArrayEquals(new long[]{2, 4, 6}, array); + assertEquals(Long.TYPE, array.getClass().getComponentType()); + } + + @Test + public void testRemoveAllLongArrayNegativeIndex() { + assertThrows(IndexOutOfBoundsException.class, () -> ArrayUtils.removeAll(new long[] { 1, 2 }, -1)); + } + + @Test + public void testRemoveAllLongArrayOutOfBoundsIndex() { + assertThrows(IndexOutOfBoundsException.class, () -> ArrayUtils.removeAll(new long[] { 1, 2 }, 2)); + } + + @Test + public void testRemoveAllLongArrayRemoveNone() { + final long[] array1 = { 1, 2 }; + final long[] array2 = ArrayUtils.removeAll(array1); + assertNotSame(array1, array2); + assertArrayEquals(array1, array2); + assertEquals(long.class, array2.getClass().getComponentType()); + } + + @Test + public void testRemoveAllNullBooleanArray() { + assertThrows(IndexOutOfBoundsException.class, () -> ArrayUtils.removeAll((boolean[]) null, 0)); + } + + @Test + public void testRemoveAllNullByteArray() { + assertThrows(IndexOutOfBoundsException.class, () -> ArrayUtils.removeAll((byte[]) null, 0)); + } + + @Test + public void testRemoveAllNullCharArray() { + assertThrows(IndexOutOfBoundsException.class, () -> ArrayUtils.removeAll((char[]) null, 0)); + } + + @Test + public void testRemoveAllNullDoubleArray() { + assertThrows(IndexOutOfBoundsException.class, () -> ArrayUtils.removeAll((double[]) null, 0)); + } + + @Test + public void testRemoveAllNullFloatArray() { + assertThrows(IndexOutOfBoundsException.class, () -> ArrayUtils.removeAll((float[]) null, 0)); + } + + @Test + public void testRemoveAllNullIntArray() { + assertThrows(IndexOutOfBoundsException.class, () -> ArrayUtils.removeAll((int[]) null, 0)); + } + + @Test + public void testRemoveAllNullLongArray() { + assertThrows(IndexOutOfBoundsException.class, () -> ArrayUtils.removeAll((long[]) null, 0)); + } + + @Test + public void testRemoveAllNullObjectArray() { + assertThrows(IndexOutOfBoundsException.class, () -> ArrayUtils.remove((Object[]) null, 0)); + } + + @Test + public void testRemoveAllNullShortArray() { + assertThrows(IndexOutOfBoundsException.class, () -> ArrayUtils.removeAll((short[]) null, 0)); + } + + @Test + public void testRemoveAllNumberArray() { + final Number[] inarray = { Integer.valueOf(1), Long.valueOf(2L), Byte.valueOf((byte) 3) }; + assertEquals(3, inarray.length); + Number[] outarray; + + outarray = ArrayUtils.removeAll(inarray, 1); + assertArrayEquals(new Number[] { Integer.valueOf(1), Byte.valueOf((byte) 3) }, outarray); + assertEquals(Number.class, outarray.getClass().getComponentType()); + + outarray = ArrayUtils.removeAll(outarray, 1); + assertArrayEquals(new Number[] { Integer.valueOf(1) }, outarray); + assertEquals(Number.class, outarray.getClass().getComponentType()); + + outarray = ArrayUtils.removeAll(outarray, 0); + assertEquals(0, outarray.length); + assertEquals(Number.class, outarray.getClass().getComponentType()); + + outarray = ArrayUtils.removeAll(inarray, 0, 1); + assertArrayEquals(new Number[] { Byte.valueOf((byte) 3) }, outarray); + assertEquals(Number.class, outarray.getClass().getComponentType()); + + outarray = ArrayUtils.removeAll(inarray, 0, 2); + assertArrayEquals(new Number[] { Long.valueOf(2L) }, outarray); + assertEquals(Number.class, outarray.getClass().getComponentType()); + + outarray = ArrayUtils.removeAll(inarray, 1, 2); + assertArrayEquals(new Number[] { Integer.valueOf(1) }, outarray); + assertEquals(Number.class, outarray.getClass().getComponentType()); + } + + @Test + public void testRemoveAllObjectArray() { + Object[] array; + + array = ArrayUtils.removeAll(new Object[] { "a" }, 0); + assertArrayEquals(ArrayUtils.EMPTY_OBJECT_ARRAY, array); + assertEquals(Object.class, array.getClass().getComponentType()); + + array = ArrayUtils.removeAll(new Object[] { "a", "b" }, 0, 1); + assertArrayEquals(ArrayUtils.EMPTY_OBJECT_ARRAY, array); + assertEquals(Object.class, array.getClass().getComponentType()); + + array = ArrayUtils.removeAll(new Object[] { "a", "b", "c" }, 1, 2); + assertArrayEquals(new Object[] { "a" }, array); + assertEquals(Object.class, array.getClass().getComponentType()); + + array = ArrayUtils.removeAll(new Object[] { "a", "b", "c", "d" }, 1, 2); + assertArrayEquals(new Object[] { "a", "d" }, array); + assertEquals(Object.class, array.getClass().getComponentType()); + + array = ArrayUtils.removeAll(new Object[] { "a", "b", "c", "d" }, 0, 3); + assertArrayEquals(new Object[] { "b", "c" }, array); + assertEquals(Object.class, array.getClass().getComponentType()); + + array = ArrayUtils.removeAll(new Object[] { "a", "b", "c", "d" }, 0, 1, 3); + assertArrayEquals(new Object[] { "c" }, array); + assertEquals(Object.class, array.getClass().getComponentType()); + + array = ArrayUtils.removeAll(new Object[] { "a", "b", "c", "d", "e" }, 0, 1, 3); + assertArrayEquals(new Object[] { "c", "e" }, array); + assertEquals(Object.class, array.getClass().getComponentType()); + + array = ArrayUtils.removeAll(new Object[] { "a", "b", "c", "d", "e" }, 0, 2, 4); + assertArrayEquals(new Object[] { "b", "d" }, array); + assertEquals(Object.class, array.getClass().getComponentType()); + + array = ArrayUtils.removeAll(new Object[] { "a", "b", "c", "d" }, 0, 1, 3, 0, 1, 3); + assertArrayEquals(new Object[] { "c" }, array); + assertEquals(Object.class, array.getClass().getComponentType()); + + array = ArrayUtils.removeAll(new Object[] { "a", "b", "c", "d" }, 2, 1, 0, 3); + assertArrayEquals(ArrayUtils.EMPTY_OBJECT_ARRAY, array); + assertEquals(Object.class, array.getClass().getComponentType()); + + array = ArrayUtils.removeAll(new Object[] { "a", "b", "c", "d" }, 2, 0, 1, 3, 0, 2, 1, 3); + assertArrayEquals(ArrayUtils.EMPTY_OBJECT_ARRAY, array); + assertEquals(Object.class, array.getClass().getComponentType()); + } + + @Test + public void testRemoveAllObjectArrayNegativeIndex() { + assertThrows(IndexOutOfBoundsException.class, () -> ArrayUtils.removeAll(new Object[] { "a", "b" }, -1)); + } + + @Test + public void testRemoveAllObjectArrayOutOfBoundsIndex() { + assertThrows(IndexOutOfBoundsException.class, () -> ArrayUtils.removeAll(new Object[] { "a", "b" }, 2)); + } + + @Test + public void testRemoveAllObjectArrayRemoveNone() { + final Object[] array1 = { "foo", "bar", "baz" }; + final Object[] array2 = ArrayUtils.removeAll(array1); + assertNotSame(array1, array2); + assertArrayEquals(array1, array2); + assertEquals(Object.class, array2.getClass().getComponentType()); + } + + @Test + public void testRemoveAllShortArray() { + short[] array; + + array = ArrayUtils.removeAll(new short[] { 1 }, 0); + assertArrayEquals(ArrayUtils.EMPTY_SHORT_ARRAY, array); + assertEquals(Short.TYPE, array.getClass().getComponentType()); + + array = ArrayUtils.removeAll(new short[] { 1, 2 }, 0); + assertArrayEquals(new short[]{2}, array); + assertEquals(Short.TYPE, array.getClass().getComponentType()); + + array = ArrayUtils.removeAll(new short[] { 1, 2 }, 1); + assertArrayEquals(new short[]{1}, array); + assertEquals(Short.TYPE, array.getClass().getComponentType()); + + array = ArrayUtils.removeAll(new short[] { 1, 2, 1 }, 1); + assertArrayEquals(new short[]{1, 1}, array); + assertEquals(Short.TYPE, array.getClass().getComponentType()); + + array = ArrayUtils.removeAll(new short[] { 1, 2 }, 0, 1); + assertArrayEquals(ArrayUtils.EMPTY_SHORT_ARRAY, array); + assertEquals(Short.TYPE, array.getClass().getComponentType()); + + array = ArrayUtils.removeAll(new short[] { 1, 2, 3 }, 0, 1); + assertArrayEquals(new short[]{3}, array); + assertEquals(Short.TYPE, array.getClass().getComponentType()); + + array = ArrayUtils.removeAll(new short[] { 1, 2, 3 }, 1, 2); + assertArrayEquals(new short[]{1}, array); + assertEquals(Short.TYPE, array.getClass().getComponentType()); + + array = ArrayUtils.removeAll(new short[] { 1, 2, 3 }, 0, 2); + assertArrayEquals(new short[]{2}, array); + assertEquals(Short.TYPE, array.getClass().getComponentType()); + + array = ArrayUtils.removeAll(new short[] { 1, 2, 3, 4, 5 }, 1, 3); + assertArrayEquals(new short[]{1, 3, 5}, array); + assertEquals(Short.TYPE, array.getClass().getComponentType()); + + array = ArrayUtils.removeAll(new short[] { 1, 2, 3, 4, 5 }, 0, 2, 4); + assertArrayEquals(new short[]{2, 4}, array); + assertEquals(Short.TYPE, array.getClass().getComponentType()); + + array = ArrayUtils.removeAll(new short[] { 1, 2, 3, 4, 5, 6, 7 }, 1, 3, 5); + assertArrayEquals(new short[]{1, 3, 5, 7}, array); + assertEquals(Short.TYPE, array.getClass().getComponentType()); + + array = ArrayUtils.removeAll(new short[] { 1, 2, 3, 4, 5, 6, 7 }, 0, 2, 4, 6); + assertArrayEquals(new short[]{2, 4, 6}, array); + assertEquals(Short.TYPE, array.getClass().getComponentType()); + } + + @Test + public void testRemoveAllShortArrayNegativeIndex() { + assertThrows(IndexOutOfBoundsException.class, () -> ArrayUtils.removeAll(new short[] { 1, 2 }, -1, 0)); + } + + @Test + public void testRemoveAllShortArrayOutOfBoundsIndex() { + assertThrows(IndexOutOfBoundsException.class, () -> ArrayUtils.removeAll(new short[] { 1, 2 }, 2, 0)); + } + + @Test + public void testRemoveAllShortArrayRemoveNone() { + final short[] array1 = { 1, 2 }; + final short[] array2 = ArrayUtils.removeAll(array1); + assertNotSame(array1, array2); + assertArrayEquals(array1, array2); + assertEquals(short.class, array2.getClass().getComponentType()); + } + + @Test + public void testRemoveElementBooleanArray() { + boolean[] array; + + array = ArrayUtils.removeElements((boolean[]) null, true); + assertNull(array); + + array = ArrayUtils.removeElements(ArrayUtils.EMPTY_BOOLEAN_ARRAY, true); + assertArrayEquals(ArrayUtils.EMPTY_BOOLEAN_ARRAY, array); + assertEquals(Boolean.TYPE, array.getClass().getComponentType()); + + array = ArrayUtils.removeElements(new boolean[] { true }, true); + assertArrayEquals(ArrayUtils.EMPTY_BOOLEAN_ARRAY, array); + assertEquals(Boolean.TYPE, array.getClass().getComponentType()); + + array = ArrayUtils.removeElements(new boolean[] { true, false }, true); + assertArrayEquals(new boolean[]{false}, array); + assertEquals(Boolean.TYPE, array.getClass().getComponentType()); + + array = ArrayUtils.removeElements(new boolean[] { true, false, true }, true); + assertArrayEquals(new boolean[]{false, true}, array); + assertEquals(Boolean.TYPE, array.getClass().getComponentType()); + + array = ArrayUtils.removeElements((boolean[]) null, true, false); + assertNull(array); + + array = ArrayUtils.removeElements(ArrayUtils.EMPTY_BOOLEAN_ARRAY, true, false); + assertArrayEquals(ArrayUtils.EMPTY_BOOLEAN_ARRAY, array); + assertEquals(Boolean.TYPE, array.getClass().getComponentType()); + + array = ArrayUtils.removeElements(new boolean[] { true }, true, false); + assertArrayEquals(ArrayUtils.EMPTY_BOOLEAN_ARRAY, array); + assertEquals(Boolean.TYPE, array.getClass().getComponentType()); + + array = ArrayUtils.removeElements(new boolean[] { true, false }, true, false); + assertArrayEquals(ArrayUtils.EMPTY_BOOLEAN_ARRAY, array); + assertEquals(Boolean.TYPE, array.getClass().getComponentType()); + + array = ArrayUtils.removeElements(new boolean[] { true, false }, true, true); + assertArrayEquals(new boolean[]{false}, array); + assertEquals(Boolean.TYPE, array.getClass().getComponentType()); + + array = ArrayUtils.removeElements(new boolean[] { true, false, true }, true, false); + assertArrayEquals(new boolean[]{true}, array); + assertEquals(Boolean.TYPE, array.getClass().getComponentType()); + + array = ArrayUtils.removeElements(new boolean[] { true, false, true }, true, true); + assertArrayEquals(new boolean[]{false}, array); + assertEquals(Boolean.TYPE, array.getClass().getComponentType()); + + array = ArrayUtils.removeElements(new boolean[] { true, false, true }, true, true, true, true); + assertArrayEquals(new boolean[]{false}, array); + assertEquals(Boolean.TYPE, array.getClass().getComponentType()); + } + + @Test + public void testRemoveElementByteArray() { + byte[] array; + + array = ArrayUtils.removeElements((byte[]) null, (byte) 1); + assertNull(array); + + array = ArrayUtils.removeElements(ArrayUtils.EMPTY_BYTE_ARRAY, (byte) 1); + assertArrayEquals(ArrayUtils.EMPTY_BYTE_ARRAY, array); + assertEquals(Byte.TYPE, array.getClass().getComponentType()); + + array = ArrayUtils.removeElements(new byte[] { 1 }, (byte) 1); + assertArrayEquals(ArrayUtils.EMPTY_BYTE_ARRAY, array); + assertEquals(Byte.TYPE, array.getClass().getComponentType()); + + array = ArrayUtils.removeElements(new byte[] { 1, 2 }, (byte) 1); + assertArrayEquals(new byte[]{2}, array); + assertEquals(Byte.TYPE, array.getClass().getComponentType()); + + array = ArrayUtils.removeElements(new byte[] { 1, 2, 1 }, (byte) 1); + assertArrayEquals(new byte[]{2, 1}, array); + assertEquals(Byte.TYPE, array.getClass().getComponentType()); + + array = ArrayUtils.removeElements((byte[]) null, (byte) 1, (byte) 2); + assertNull(array); + + array = ArrayUtils.removeElements(ArrayUtils.EMPTY_BYTE_ARRAY, (byte) 1, (byte) 2); + assertArrayEquals(ArrayUtils.EMPTY_BYTE_ARRAY, array); + assertEquals(Byte.TYPE, array.getClass().getComponentType()); + + array = ArrayUtils.removeElements(new byte[] { 1 }, (byte) 1, (byte) 2); + assertArrayEquals(ArrayUtils.EMPTY_BYTE_ARRAY, array); + assertEquals(Byte.TYPE, array.getClass().getComponentType()); + + array = ArrayUtils.removeElements(new byte[] { 1, 2 }, (byte) 1, (byte) 2); + assertArrayEquals(ArrayUtils.EMPTY_BYTE_ARRAY, array); + assertEquals(Byte.TYPE, array.getClass().getComponentType()); + + array = ArrayUtils.removeElements(new byte[] { 1, 2 }, (byte) 1, (byte) 1); + assertArrayEquals(new byte[]{2}, array); + assertEquals(Byte.TYPE, array.getClass().getComponentType()); + + array = ArrayUtils.removeElements(new byte[] { 1, 2, 1 }, (byte) 1, (byte) 2); + assertArrayEquals(new byte[]{1}, array); + assertEquals(Byte.TYPE, array.getClass().getComponentType()); + + array = ArrayUtils.removeElements(new byte[] { 1, 2, 1 }, (byte) 1, (byte) 1); + assertArrayEquals(new byte[]{2}, array); + assertEquals(Byte.TYPE, array.getClass().getComponentType()); + + array = ArrayUtils.removeElements(new byte[] { 1, 2, 1 }, (byte) 1, (byte) 1, (byte) 1, (byte) 1); + assertArrayEquals(new byte[]{2}, array); + assertEquals(Byte.TYPE, array.getClass().getComponentType()); + } + + @Test + public void testRemoveElementCharArray() { + char[] array; + + array = ArrayUtils.removeElements((char[]) null, 'a'); + assertNull(array); + + array = ArrayUtils.removeElements(ArrayUtils.EMPTY_CHAR_ARRAY, 'a'); + assertArrayEquals(ArrayUtils.EMPTY_CHAR_ARRAY, array); + assertEquals(Character.TYPE, array.getClass().getComponentType()); + + array = ArrayUtils.removeElements(new char[] { 'a' }, 'a'); + assertArrayEquals(ArrayUtils.EMPTY_CHAR_ARRAY, array); + assertEquals(Character.TYPE, array.getClass().getComponentType()); + + array = ArrayUtils.removeElements(new char[] { 'a', 'b' }, 'a'); + assertArrayEquals(new char[]{'b'}, array); + assertEquals(Character.TYPE, array.getClass().getComponentType()); + + array = ArrayUtils.removeElements(new char[] { 'a', 'b', 'a' }, 'a'); + assertArrayEquals(new char[]{'b', 'a'}, array); + assertEquals(Character.TYPE, array.getClass().getComponentType()); + + array = ArrayUtils.removeElements((char[]) null, 'a', 'b'); + assertNull(array); + + array = ArrayUtils.removeElements(ArrayUtils.EMPTY_CHAR_ARRAY, 'a', 'b'); + assertArrayEquals(ArrayUtils.EMPTY_CHAR_ARRAY, array); + assertEquals(Character.TYPE, array.getClass().getComponentType()); + + array = ArrayUtils.removeElements(new char[] { 'a' }, 'a', 'b'); + assertArrayEquals(ArrayUtils.EMPTY_CHAR_ARRAY, array); + assertEquals(Character.TYPE, array.getClass().getComponentType()); + + array = ArrayUtils.removeElements(new char[] { 'a', 'b' }, 'a', 'b'); + assertArrayEquals(ArrayUtils.EMPTY_CHAR_ARRAY, array); + assertEquals(Character.TYPE, array.getClass().getComponentType()); + + array = ArrayUtils.removeElements(new char[] { 'a', 'b' }, 'a', 'a'); + assertArrayEquals(new char[]{'b'}, array); + assertEquals(Character.TYPE, array.getClass().getComponentType()); + + array = ArrayUtils.removeElements(new char[] { 'a', 'b', 'a' }, 'a', 'b'); + assertArrayEquals(new char[]{'a'}, array); + assertEquals(Character.TYPE, array.getClass().getComponentType()); + + array = ArrayUtils.removeElements(new char[] { 'a', 'b', 'a' }, 'a', 'a'); + assertArrayEquals(new char[]{'b'}, array); + assertEquals(Character.TYPE, array.getClass().getComponentType()); + + array = ArrayUtils.removeElements(new char[] { 'a', 'b', 'a' }, 'a', 'a', 'a', 'a'); + assertArrayEquals(new char[]{'b'}, array); + assertEquals(Character.TYPE, array.getClass().getComponentType()); + } + + @Test + @SuppressWarnings("cast") + public void testRemoveElementDoubleArray() { + double[] array; + + array = ArrayUtils.removeElements((double[]) null, (double) 1); + assertNull(array); + + array = ArrayUtils.removeElements(ArrayUtils.EMPTY_DOUBLE_ARRAY, (double) 1); + assertArrayEquals(ArrayUtils.EMPTY_DOUBLE_ARRAY, array); + assertEquals(Double.TYPE, array.getClass().getComponentType()); + + array = ArrayUtils.removeElements(new double[] { 1 }, (double) 1); + assertArrayEquals(ArrayUtils.EMPTY_DOUBLE_ARRAY, array); + assertEquals(Double.TYPE, array.getClass().getComponentType()); + + array = ArrayUtils.removeElements(new double[] { 1, 2 }, (double) 1); + assertArrayEquals(new double[]{2}, array); + assertEquals(Double.TYPE, array.getClass().getComponentType()); + + array = ArrayUtils.removeElements(new double[] { 1, 2, 1 }, (double) 1); + assertArrayEquals(new double[]{2, 1}, array); + assertEquals(Double.TYPE, array.getClass().getComponentType()); + + array = ArrayUtils.removeElements((double[]) null, (double) 1, (double) 2); + assertNull(array); + + array = ArrayUtils.removeElements(ArrayUtils.EMPTY_DOUBLE_ARRAY, (double) 1, (double) 2); + assertArrayEquals(ArrayUtils.EMPTY_DOUBLE_ARRAY, array); + assertEquals(Double.TYPE, array.getClass().getComponentType()); + + array = ArrayUtils.removeElements(new double[] { 1 }, (double) 1, (double) 2); + assertArrayEquals(ArrayUtils.EMPTY_DOUBLE_ARRAY, array); + assertEquals(Double.TYPE, array.getClass().getComponentType()); + + array = ArrayUtils.removeElements(new double[] { 1, 2 }, (double) 1, (double) 2); + assertArrayEquals(ArrayUtils.EMPTY_DOUBLE_ARRAY, array); + assertEquals(Double.TYPE, array.getClass().getComponentType()); + + array = ArrayUtils.removeElements(new double[] { 1, 2 }, (double) 1, (double) 1); + assertArrayEquals(new double[]{2}, array); + assertEquals(Double.TYPE, array.getClass().getComponentType()); + + array = ArrayUtils.removeElements(new double[] { 1, 2, 1 }, (double) 1, (double) 2); + assertArrayEquals(new double[]{1}, array); + assertEquals(Double.TYPE, array.getClass().getComponentType()); + + array = ArrayUtils.removeElements(new double[] { 1, 2, 1 }, (double) 1, (double) 1); + assertArrayEquals(new double[]{2}, array); + assertEquals(Double.TYPE, array.getClass().getComponentType()); + + array = ArrayUtils.removeElements(new double[] { 1, 2, 1 }, (double) 1, (double) 1, (double) 1, (double) 1); + assertArrayEquals(new double[]{2}, array); + assertEquals(Double.TYPE, array.getClass().getComponentType()); + } + + @Test + @SuppressWarnings("cast") + public void testRemoveElementFloatArray() { + float[] array; + + array = ArrayUtils.removeElements((float[]) null, (float) 1); + assertNull(array); + + array = ArrayUtils.removeElements(ArrayUtils.EMPTY_FLOAT_ARRAY, (float) 1); + assertArrayEquals(ArrayUtils.EMPTY_FLOAT_ARRAY, array); + assertEquals(Float.TYPE, array.getClass().getComponentType()); + + array = ArrayUtils.removeElements(new float[] { 1 }, (float) 1); + assertArrayEquals(ArrayUtils.EMPTY_FLOAT_ARRAY, array); + assertEquals(Float.TYPE, array.getClass().getComponentType()); + + array = ArrayUtils.removeElements(new float[] { 1, 2 }, (float) 1); + assertArrayEquals(new float[]{2}, array); + assertEquals(Float.TYPE, array.getClass().getComponentType()); + + array = ArrayUtils.removeElements(new float[] { 1, 2, 1 }, (float) 1); + assertArrayEquals(new float[]{2, 1}, array); + assertEquals(Float.TYPE, array.getClass().getComponentType()); + + array = ArrayUtils.removeElements((float[]) null, (float) 1, (float) 1); + assertNull(array); + + array = ArrayUtils.removeElements(ArrayUtils.EMPTY_FLOAT_ARRAY, (float) 1, (float) 1); + assertArrayEquals(ArrayUtils.EMPTY_FLOAT_ARRAY, array); + assertEquals(Float.TYPE, array.getClass().getComponentType()); + + array = ArrayUtils.removeElements(new float[] { 1 }, (float) 1, (float) 1); + assertArrayEquals(ArrayUtils.EMPTY_FLOAT_ARRAY, array); + assertEquals(Float.TYPE, array.getClass().getComponentType()); + + array = ArrayUtils.removeElements(new float[] { 1, 2 }, (float) 1, (float) 2); + assertArrayEquals(ArrayUtils.EMPTY_FLOAT_ARRAY, array); + assertEquals(Float.TYPE, array.getClass().getComponentType()); + + array = ArrayUtils.removeElements(new float[] { 1, 2 }, (float) 1, (float) 1); + assertArrayEquals(new float[]{2}, array); + assertEquals(Float.TYPE, array.getClass().getComponentType()); + + array = ArrayUtils.removeElements(new float[] { 1, 2, 1 }, (float) 1, (float) 1); + assertArrayEquals(new float[]{2}, array); + assertEquals(Float.TYPE, array.getClass().getComponentType()); + + array = ArrayUtils.removeElements(new float[] { 1, 2, 1 }, (float) 1, (float) 2); + assertArrayEquals(new float[]{1}, array); + assertEquals(Float.TYPE, array.getClass().getComponentType()); + + array = ArrayUtils.removeElements(new float[] { 1, 2, 1 }, (float) 1, (float) 1, (float) 1, (float) 1); + assertArrayEquals(new float[]{2}, array); + assertEquals(Float.TYPE, array.getClass().getComponentType()); + } + + @Test + public void testRemoveElementIntArray() { + int[] array; + + array = ArrayUtils.removeElements((int[]) null, 1); + assertNull(array); + + array = ArrayUtils.removeElements(ArrayUtils.EMPTY_INT_ARRAY, 1); + assertArrayEquals(ArrayUtils.EMPTY_INT_ARRAY, array); + assertEquals(Integer.TYPE, array.getClass().getComponentType()); + + array = ArrayUtils.removeElements(new int[] { 1 }, 1); + assertArrayEquals(ArrayUtils.EMPTY_INT_ARRAY, array); + assertEquals(Integer.TYPE, array.getClass().getComponentType()); + + array = ArrayUtils.removeElements(new int[] { 1, 2 }, 1); + assertArrayEquals(new int[]{2}, array); + assertEquals(Integer.TYPE, array.getClass().getComponentType()); + + array = ArrayUtils.removeElements(new int[] { 1, 2, 1 }, 1); + assertArrayEquals(new int[]{2, 1}, array); + assertEquals(Integer.TYPE, array.getClass().getComponentType()); + + array = ArrayUtils.removeElements((int[]) null, 1); + assertNull(array); + + array = ArrayUtils.removeElements(ArrayUtils.EMPTY_INT_ARRAY, 1, 1); + assertArrayEquals(ArrayUtils.EMPTY_INT_ARRAY, array); + assertEquals(Integer.TYPE, array.getClass().getComponentType()); + + array = ArrayUtils.removeElements(new int[] { 1 }, 1, 1); + assertArrayEquals(ArrayUtils.EMPTY_INT_ARRAY, array); + assertEquals(Integer.TYPE, array.getClass().getComponentType()); + + array = ArrayUtils.removeElements(new int[] { 1, 2 }, 1, 2); + assertArrayEquals(ArrayUtils.EMPTY_INT_ARRAY, array); + assertEquals(Integer.TYPE, array.getClass().getComponentType()); + + array = ArrayUtils.removeElements(new int[] { 1, 2 }, 1, 1); + assertArrayEquals(new int[]{2}, array); + assertEquals(Integer.TYPE, array.getClass().getComponentType()); + + array = ArrayUtils.removeElements(new int[] { 1, 2, 1 }, 1, 2); + assertArrayEquals(new int[]{1}, array); + assertEquals(Integer.TYPE, array.getClass().getComponentType()); + + array = ArrayUtils.removeElements(new int[] { 1, 2, 1 }, 1, 1); + assertArrayEquals(new int[]{2}, array); + assertEquals(Integer.TYPE, array.getClass().getComponentType()); + + array = ArrayUtils.removeElements(new int[] { 1, 2, 1 }, 1, 1, 1, 1); + assertArrayEquals(new int[]{2}, array); + assertEquals(Integer.TYPE, array.getClass().getComponentType()); + } + + @Test + public void testRemoveElementLongArray() { + long[] array; + + array = ArrayUtils.removeElements((long[]) null, 1L); + assertNull(array); + + array = ArrayUtils.removeElements(ArrayUtils.EMPTY_LONG_ARRAY, 1L); + assertArrayEquals(ArrayUtils.EMPTY_LONG_ARRAY, array); + assertEquals(Long.TYPE, array.getClass().getComponentType()); + + array = ArrayUtils.removeElements(new long[] { 1 }, 1L); + assertArrayEquals(ArrayUtils.EMPTY_LONG_ARRAY, array); + assertEquals(Long.TYPE, array.getClass().getComponentType()); + + array = ArrayUtils.removeElements(new long[] { 1, 2 }, 1L); + assertArrayEquals(new long[]{2}, array); + assertEquals(Long.TYPE, array.getClass().getComponentType()); + + array = ArrayUtils.removeElements(new long[] { 1, 2, 1 }, 1L); + assertArrayEquals(new long[]{2, 1}, array); + assertEquals(Long.TYPE, array.getClass().getComponentType()); + + array = ArrayUtils.removeElements((long[]) null, 1L, 1L); + assertNull(array); + + array = ArrayUtils.removeElements(ArrayUtils.EMPTY_LONG_ARRAY, 1L, 1L); + assertArrayEquals(ArrayUtils.EMPTY_LONG_ARRAY, array); + assertEquals(Long.TYPE, array.getClass().getComponentType()); + + array = ArrayUtils.removeElements(new long[] { 1 }, 1L, 1L); + assertArrayEquals(ArrayUtils.EMPTY_LONG_ARRAY, array); + assertEquals(Long.TYPE, array.getClass().getComponentType()); + + array = ArrayUtils.removeElements(new long[] { 1, 2 }, 1L, 2L); + assertArrayEquals(ArrayUtils.EMPTY_LONG_ARRAY, array); + assertEquals(Long.TYPE, array.getClass().getComponentType()); + + array = ArrayUtils.removeElements(new long[] { 1, 2 }, 1L, 1L); + assertArrayEquals(new long[]{2}, array); + assertEquals(Long.TYPE, array.getClass().getComponentType()); + + array = ArrayUtils.removeElements(new long[] { 1, 2, 1 }, 1L, 1L); + assertArrayEquals(new long[]{2}, array); + assertEquals(Long.TYPE, array.getClass().getComponentType()); + + array = ArrayUtils.removeElements(new long[] { 1, 2, 1 }, 1L, 2L); + assertArrayEquals(new long[]{1}, array); + assertEquals(Long.TYPE, array.getClass().getComponentType()); + + array = ArrayUtils.removeElements(new long[] { 1, 2, 1 }, 1L, 1L, 1L, 1L); + assertArrayEquals(new long[]{2}, array); + assertEquals(Long.TYPE, array.getClass().getComponentType()); + } + + @Test + public void testRemoveElementShortArray() { + short[] array; + + array = ArrayUtils.removeElements((short[]) null, (short) 1); + assertNull(array); + + array = ArrayUtils.removeElements(ArrayUtils.EMPTY_SHORT_ARRAY, (short) 1); + assertArrayEquals(ArrayUtils.EMPTY_SHORT_ARRAY, array); + assertEquals(Short.TYPE, array.getClass().getComponentType()); + + array = ArrayUtils.removeElements(new short[] { 1 }, (short) 1); + assertArrayEquals(ArrayUtils.EMPTY_SHORT_ARRAY, array); + assertEquals(Short.TYPE, array.getClass().getComponentType()); + + array = ArrayUtils.removeElements(new short[] { 1, 2 }, (short) 1); + assertArrayEquals(new short[]{2}, array); + assertEquals(Short.TYPE, array.getClass().getComponentType()); + + array = ArrayUtils.removeElements(new short[] { 1, 2, 1 }, (short) 1); + assertArrayEquals(new short[]{2, 1}, array); + assertEquals(Short.TYPE, array.getClass().getComponentType()); + + array = ArrayUtils.removeElements((short[]) null, (short) 1, (short) 1); + assertNull(array); + + array = ArrayUtils.removeElements(ArrayUtils.EMPTY_SHORT_ARRAY, (short) 1, (short) 1); + assertArrayEquals(ArrayUtils.EMPTY_SHORT_ARRAY, array); + assertEquals(Short.TYPE, array.getClass().getComponentType()); + + array = ArrayUtils.removeElements(new short[] { 1 }, (short) 1, (short) 1); + assertArrayEquals(ArrayUtils.EMPTY_SHORT_ARRAY, array); + assertEquals(Short.TYPE, array.getClass().getComponentType()); + + array = ArrayUtils.removeElements(new short[] { 1, 2 }, (short) 1, (short) 2); + assertArrayEquals(ArrayUtils.EMPTY_SHORT_ARRAY, array); + assertEquals(Short.TYPE, array.getClass().getComponentType()); + + array = ArrayUtils.removeElements(new short[] { 1, 2 }, (short) 1, (short) 1); + assertArrayEquals(new short[]{2}, array); + assertEquals(Short.TYPE, array.getClass().getComponentType()); + + array = ArrayUtils.removeElements(new short[] { 1, 2, 1 }, (short) 1, (short) 1); + assertArrayEquals(new short[]{2}, array); + assertEquals(Short.TYPE, array.getClass().getComponentType()); + + array = ArrayUtils.removeElements(new short[] { 1, 2, 1 }, (short) 1, (short) 2); + assertArrayEquals(new short[]{1}, array); + assertEquals(Short.TYPE, array.getClass().getComponentType()); + + array = ArrayUtils.removeElements(new short[] { 1, 2, 1 }, (short) 1, (short) 1, (short) 1, (short) 1); + assertArrayEquals(new short[]{2}, array); + assertEquals(Short.TYPE, array.getClass().getComponentType()); + } + + @Test + public void testRemoveElementsObjectArray() { + Object[] array; + + array = ArrayUtils.removeElements((Object[]) null, "a"); + assertNull(array); + + array = ArrayUtils.removeElements(ArrayUtils.EMPTY_OBJECT_ARRAY, "a"); + assertArrayEquals(ArrayUtils.EMPTY_OBJECT_ARRAY, array); + assertEquals(Object.class, array.getClass().getComponentType()); + + array = ArrayUtils.removeElements(new Object[] { "a" }, "a"); + assertArrayEquals(ArrayUtils.EMPTY_OBJECT_ARRAY, array); + assertEquals(Object.class, array.getClass().getComponentType()); + + array = ArrayUtils.removeElements(new Object[] { "a", "b" }, "a"); + assertArrayEquals(new Object[]{"b"}, array); + assertEquals(Object.class, array.getClass().getComponentType()); + + array = ArrayUtils.removeElements(new Object[] { "a", "b", "a" }, "a"); + assertArrayEquals(new Object[]{"b", "a"}, array); + assertEquals(Object.class, array.getClass().getComponentType()); + + array = ArrayUtils.removeElements((Object[]) null, "a", "b"); + assertNull(array); + + array = ArrayUtils.removeElements(ArrayUtils.EMPTY_OBJECT_ARRAY, "a", "b"); + assertArrayEquals(ArrayUtils.EMPTY_OBJECT_ARRAY, array); + assertEquals(Object.class, array.getClass().getComponentType()); + + array = ArrayUtils.removeElements(new Object[] { "a" }, "a", "b"); + assertArrayEquals(ArrayUtils.EMPTY_OBJECT_ARRAY, array); + assertEquals(Object.class, array.getClass().getComponentType()); + + array = ArrayUtils.removeElements(new Object[] { "a", "b" }, "a", "c"); + assertArrayEquals(new Object[]{"b"}, array); + assertEquals(Object.class, array.getClass().getComponentType()); + + array = ArrayUtils.removeElements(new Object[] { "a", "b", "a" }, "a"); + assertArrayEquals(new Object[]{"b", "a"}, array); + assertEquals(Object.class, array.getClass().getComponentType()); + + array = ArrayUtils.removeElements(new Object[] { "a", "b", "a" }, "a", "b"); + assertArrayEquals(new Object[]{"a"}, array); + assertEquals(Object.class, array.getClass().getComponentType()); + + array = ArrayUtils.removeElements(new Object[] { "a", "b", "a" }, "a", "a"); + assertArrayEquals(new Object[]{"b"}, array); + assertEquals(Object.class, array.getClass().getComponentType()); + + array = ArrayUtils.removeElements(new Object[] { "a", "b", "a" }, "a", "a", "a", "a"); + assertArrayEquals(new Object[]{"b"}, array); + assertEquals(Object.class, array.getClass().getComponentType()); + } + +} |