| /* |
| * 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()); |
| } |
| |
| } |