| /* |
| * 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.assertFalse; |
| import static org.junit.jupiter.api.Assertions.assertNotEquals; |
| import static org.junit.jupiter.api.Assertions.assertNotNull; |
| import static org.junit.jupiter.api.Assertions.assertNotSame; |
| import static org.junit.jupiter.api.Assertions.assertNull; |
| import static org.junit.jupiter.api.Assertions.assertSame; |
| import static org.junit.jupiter.api.Assertions.assertThrows; |
| import static org.junit.jupiter.api.Assertions.assertTrue; |
| |
| import java.lang.reflect.Constructor; |
| import java.lang.reflect.Modifier; |
| import java.util.Arrays; |
| import java.util.BitSet; |
| import java.util.Collections; |
| import java.util.Comparator; |
| import java.util.Date; |
| import java.util.Map; |
| import java.util.Random; |
| |
| import org.junit.jupiter.api.Test; |
| |
| /** |
| * Unit tests {@link org.apache.commons.lang3.ArrayUtils}. |
| */ |
| @SuppressWarnings("deprecation") // deliberate use of deprecated code |
| public class ArrayUtilsTest { |
| |
| private class TestClass { |
| // empty |
| } |
| |
| /** A predefined seed used to initialize {@link Random} in order to get predictable results */ |
| private static final long SEED = 16111981L; |
| |
| @SafeVarargs |
| private static <T> T[] toArrayPropagatingType(final T... items) { |
| return ArrayUtils.toArray(items); |
| } |
| |
| private void assertIsEquals(final Object array1, final Object array2, final Object array3) { |
| assertTrue(ArrayUtils.isEquals(array1, array1)); |
| assertTrue(ArrayUtils.isEquals(array2, array2)); |
| assertTrue(ArrayUtils.isEquals(array3, array3)); |
| assertFalse(ArrayUtils.isEquals(array1, array2)); |
| assertFalse(ArrayUtils.isEquals(array2, array1)); |
| assertFalse(ArrayUtils.isEquals(array1, array3)); |
| assertFalse(ArrayUtils.isEquals(array3, array1)); |
| assertFalse(ArrayUtils.isEquals(array1, array2)); |
| assertFalse(ArrayUtils.isEquals(array2, array1)); |
| } |
| |
| /** |
| * Tests generic array creation with parameters of same type. |
| */ |
| @Test |
| public void testArrayCreation() { |
| final String[] array = ArrayUtils.toArray("foo", "bar"); |
| assertEquals(2, array.length); |
| assertEquals("foo", array[0]); |
| assertEquals("bar", array[1]); |
| } |
| /** |
| * Tests generic array creation with parameters of common base type. |
| */ |
| @Test |
| public void testArrayCreationWithDifferentTypes() { |
| final Number[] array = ArrayUtils.<Number>toArray(Integer.valueOf(42), Double.valueOf(Math.PI)); |
| assertEquals(2, array.length); |
| assertEquals(Integer.valueOf(42), array[0]); |
| assertEquals(Double.valueOf(Math.PI), array[1]); |
| } |
| |
| /** |
| * Tests generic array creation with general return type. |
| */ |
| @Test |
| public void testArrayCreationWithGeneralReturnType() { |
| final Object obj = ArrayUtils.toArray("foo", "bar"); |
| assertTrue(obj instanceof String[]); |
| } |
| |
| @Test |
| public void testClone() { |
| assertArrayEquals(null, ArrayUtils.clone((Object[]) null)); |
| Object[] original1 = {}; |
| Object[] cloned1 = ArrayUtils.clone(original1); |
| assertArrayEquals(original1, cloned1); |
| assertNotSame(original1, cloned1); |
| |
| final StringBuilder builder = new StringBuilder("pick"); |
| original1 = new Object[]{builder, "a", new String[]{"stick"}}; |
| cloned1 = ArrayUtils.clone(original1); |
| assertArrayEquals(original1, cloned1); |
| assertNotSame(original1, cloned1); |
| assertSame(original1[0], cloned1[0]); |
| assertSame(original1[1], cloned1[1]); |
| assertSame(original1[2], cloned1[2]); |
| } |
| |
| @Test |
| public void testCloneBoolean() { |
| assertNull(ArrayUtils.clone((boolean[]) null)); |
| final boolean[] original = {true, false}; |
| final boolean[] cloned = ArrayUtils.clone(original); |
| assertArrayEquals(original, cloned); |
| assertNotSame(original, cloned); |
| } |
| |
| @Test |
| public void testCloneByte() { |
| assertNull(ArrayUtils.clone((byte[]) null)); |
| final byte[] original = {1, 6}; |
| final byte[] cloned = ArrayUtils.clone(original); |
| assertArrayEquals(original, cloned); |
| assertNotSame(original, cloned); |
| } |
| |
| @Test |
| public void testCloneChar() { |
| assertNull(ArrayUtils.clone((char[]) null)); |
| final char[] original = {'a', '4'}; |
| final char[] cloned = ArrayUtils.clone(original); |
| assertArrayEquals(original, cloned); |
| assertNotSame(original, cloned); |
| } |
| |
| @Test |
| public void testCloneDouble() { |
| assertNull(ArrayUtils.clone((double[]) null)); |
| final double[] original = {2.4d, 5.7d}; |
| final double[] cloned = ArrayUtils.clone(original); |
| assertArrayEquals(original, cloned); |
| assertNotSame(original, cloned); |
| } |
| |
| @Test |
| public void testCloneFloat() { |
| assertNull(ArrayUtils.clone((float[]) null)); |
| final float[] original = {2.6f, 6.4f}; |
| final float[] cloned = ArrayUtils.clone(original); |
| assertArrayEquals(original, cloned); |
| assertNotSame(original, cloned); |
| } |
| |
| @Test |
| public void testCloneInt() { |
| assertNull(ArrayUtils.clone((int[]) null)); |
| final int[] original = {5, 8}; |
| final int[] cloned = ArrayUtils.clone(original); |
| assertArrayEquals(original, cloned); |
| assertNotSame(original, cloned); |
| } |
| |
| @Test |
| public void testCloneLong() { |
| assertNull(ArrayUtils.clone((long[]) null)); |
| final long[] original = {0L, 1L}; |
| final long[] cloned = ArrayUtils.clone(original); |
| assertArrayEquals(original, cloned); |
| assertNotSame(original, cloned); |
| } |
| |
| @Test |
| public void testCloneShort() { |
| assertNull(ArrayUtils.clone((short[]) null)); |
| final short[] original = {1, 4}; |
| final short[] cloned = ArrayUtils.clone(original); |
| assertArrayEquals(original, cloned); |
| assertNotSame(original, cloned); |
| } |
| |
| @Test |
| public void testConstructor() { |
| assertNotNull(new ArrayUtils()); |
| final Constructor<?>[] cons = ArrayUtils.class.getDeclaredConstructors(); |
| assertEquals(1, cons.length); |
| assertTrue(Modifier.isPublic(cons[0].getModifiers())); |
| assertTrue(Modifier.isPublic(ArrayUtils.class.getModifiers())); |
| assertFalse(Modifier.isFinal(ArrayUtils.class.getModifiers())); |
| } |
| |
| @Test |
| public void testContains() { |
| final Object[] array = {"0", "1", "2", "3", null, "0"}; |
| assertFalse(ArrayUtils.contains(null, null)); |
| assertFalse(ArrayUtils.contains(null, "1")); |
| assertTrue(ArrayUtils.contains(array, "0")); |
| assertTrue(ArrayUtils.contains(array, "1")); |
| assertTrue(ArrayUtils.contains(array, "2")); |
| assertTrue(ArrayUtils.contains(array, "3")); |
| assertTrue(ArrayUtils.contains(array, null)); |
| assertFalse(ArrayUtils.contains(array, "notInArray")); |
| } |
| |
| @Test |
| public void testContains_LANG_1261() { |
| |
| class LANG1261ParentObject { |
| @Override |
| public boolean equals(final Object o) { |
| return true; |
| } |
| } |
| |
| class LANG1261ChildObject extends LANG1261ParentObject { |
| // empty. |
| } |
| |
| final Object[] array = new LANG1261ChildObject[]{new LANG1261ChildObject()}; |
| |
| assertTrue(ArrayUtils.contains(array, new LANG1261ParentObject())); |
| } |
| |
| @Test |
| public void testContainsBoolean() { |
| boolean[] array = null; |
| assertFalse(ArrayUtils.contains(array, true)); |
| array = new boolean[]{true, false, true}; |
| assertTrue(ArrayUtils.contains(array, true)); |
| assertTrue(ArrayUtils.contains(array, false)); |
| array = new boolean[]{true, true}; |
| assertTrue(ArrayUtils.contains(array, true)); |
| assertFalse(ArrayUtils.contains(array, false)); |
| } |
| |
| @Test |
| public void testContainsByte() { |
| byte[] array = null; |
| assertFalse(ArrayUtils.contains(array, (byte) 1)); |
| array = new byte[]{0, 1, 2, 3, 0}; |
| assertTrue(ArrayUtils.contains(array, (byte) 0)); |
| assertTrue(ArrayUtils.contains(array, (byte) 1)); |
| assertTrue(ArrayUtils.contains(array, (byte) 2)); |
| assertTrue(ArrayUtils.contains(array, (byte) 3)); |
| assertFalse(ArrayUtils.contains(array, (byte) 99)); |
| } |
| |
| @Test |
| public void testContainsChar() { |
| char[] array = null; |
| assertFalse(ArrayUtils.contains(array, 'b')); |
| array = new char[]{'a', 'b', 'c', 'd', 'a'}; |
| assertTrue(ArrayUtils.contains(array, 'a')); |
| assertTrue(ArrayUtils.contains(array, 'b')); |
| assertTrue(ArrayUtils.contains(array, 'c')); |
| assertTrue(ArrayUtils.contains(array, 'd')); |
| assertFalse(ArrayUtils.contains(array, 'e')); |
| } |
| |
| @SuppressWarnings("cast") |
| @Test |
| public void testContainsDouble() { |
| double[] array = null; |
| assertFalse(ArrayUtils.contains(array, (double) 1)); |
| array = new double[]{0, 1, 2, 3, 0}; |
| assertTrue(ArrayUtils.contains(array, (double) 0)); |
| assertTrue(ArrayUtils.contains(array, (double) 1)); |
| assertTrue(ArrayUtils.contains(array, (double) 2)); |
| assertTrue(ArrayUtils.contains(array, (double) 3)); |
| assertFalse(ArrayUtils.contains(array, (double) 99)); |
| } |
| |
| @Test |
| public void testContainsDoubleNaN() { |
| final double[] a = { Double.NEGATIVE_INFINITY, Double.NaN, Double.POSITIVE_INFINITY }; |
| assertTrue(ArrayUtils.contains(a, Double.POSITIVE_INFINITY)); |
| assertTrue(ArrayUtils.contains(a, Double.NEGATIVE_INFINITY)); |
| assertTrue(ArrayUtils.contains(a, Double.NaN)); |
| } |
| |
| @SuppressWarnings("cast") |
| @Test |
| public void testContainsDoubleTolerance() { |
| double[] array = null; |
| assertFalse(ArrayUtils.contains(array, (double) 1, (double) 0)); |
| array = new double[]{0, 1, 2, 3, 0}; |
| assertFalse(ArrayUtils.contains(array, 4.0, 0.33)); |
| assertFalse(ArrayUtils.contains(array, 2.5, 0.49)); |
| assertTrue(ArrayUtils.contains(array, 2.5, 0.50)); |
| assertTrue(ArrayUtils.contains(array, 2.5, 0.51)); |
| } |
| |
| @SuppressWarnings("cast") |
| @Test |
| public void testContainsFloat() { |
| float[] array = null; |
| assertFalse(ArrayUtils.contains(array, (float) 1)); |
| array = new float[]{0, 1, 2, 3, 0}; |
| assertTrue(ArrayUtils.contains(array, (float) 0)); |
| assertTrue(ArrayUtils.contains(array, (float) 1)); |
| assertTrue(ArrayUtils.contains(array, (float) 2)); |
| assertTrue(ArrayUtils.contains(array, (float) 3)); |
| assertFalse(ArrayUtils.contains(array, (float) 99)); |
| } |
| |
| @Test |
| public void testContainsFloatNaN() { |
| final float[] array = { Float.NEGATIVE_INFINITY, Float.NaN, Float.POSITIVE_INFINITY }; |
| assertTrue(ArrayUtils.contains(array, Float.POSITIVE_INFINITY)); |
| assertTrue(ArrayUtils.contains(array, Float.NEGATIVE_INFINITY)); |
| assertTrue(ArrayUtils.contains(array, Float.NaN)); |
| } |
| |
| @Test |
| public void testContainsInt() { |
| int[] array = null; |
| assertFalse(ArrayUtils.contains(array, 1)); |
| array = new int[]{0, 1, 2, 3, 0}; |
| assertTrue(ArrayUtils.contains(array, 0)); |
| assertTrue(ArrayUtils.contains(array, 1)); |
| assertTrue(ArrayUtils.contains(array, 2)); |
| assertTrue(ArrayUtils.contains(array, 3)); |
| assertFalse(ArrayUtils.contains(array, 99)); |
| } |
| |
| @Test |
| public void testContainsLong() { |
| long[] array = null; |
| assertFalse(ArrayUtils.contains(array, 1)); |
| array = new long[]{0, 1, 2, 3, 0}; |
| assertTrue(ArrayUtils.contains(array, 0)); |
| assertTrue(ArrayUtils.contains(array, 1)); |
| assertTrue(ArrayUtils.contains(array, 2)); |
| assertTrue(ArrayUtils.contains(array, 3)); |
| assertFalse(ArrayUtils.contains(array, 99)); |
| } |
| |
| @Test |
| public void testContainsShort() { |
| short[] array = null; |
| assertFalse(ArrayUtils.contains(array, (short) 1)); |
| array = new short[]{0, 1, 2, 3, 0}; |
| assertTrue(ArrayUtils.contains(array, (short) 0)); |
| assertTrue(ArrayUtils.contains(array, (short) 1)); |
| assertTrue(ArrayUtils.contains(array, (short) 2)); |
| assertTrue(ArrayUtils.contains(array, (short) 3)); |
| assertFalse(ArrayUtils.contains(array, (short) 99)); |
| } |
| |
| @Test |
| public void testCreatePrimitiveArray() { |
| assertNull(ArrayUtils.toPrimitive((Object[]) null)); |
| assertArrayEquals(new boolean[]{true}, ArrayUtils.toPrimitive(new Boolean[]{true})); |
| assertArrayEquals(new char[]{'a'}, ArrayUtils.toPrimitive(new Character[]{'a'})); |
| assertArrayEquals(new byte[]{1}, ArrayUtils.toPrimitive(new Byte[]{1})); |
| assertArrayEquals(new int[]{}, ArrayUtils.toPrimitive(new Integer[]{})); |
| assertArrayEquals(new short[]{2}, ArrayUtils.toPrimitive(new Short[]{2})); |
| assertArrayEquals(new long[]{2, 3}, ArrayUtils.toPrimitive(new Long[]{2L, 3L})); |
| assertArrayEquals(new float[]{3.14f}, ArrayUtils.toPrimitive(new Float[]{3.14f}), 0.1f); |
| assertArrayEquals(new double[]{2.718}, ArrayUtils.toPrimitive(new Double[]{2.718}), 0.1); |
| } |
| |
| @Test |
| public void testCreatePrimitiveArrayViaObjectArray() { |
| assertNull(ArrayUtils.toPrimitive((Object) null)); |
| assertArrayEquals(new boolean[]{true}, (boolean[]) ArrayUtils.toPrimitive((Object) new Boolean[]{true})); |
| assertArrayEquals(new char[]{'a'}, (char[]) ArrayUtils.toPrimitive((Object) new Character[]{'a'})); |
| assertArrayEquals(new byte[]{1}, (byte[]) ArrayUtils.toPrimitive((Object) new Byte[]{1})); |
| assertArrayEquals(new int[]{}, (int[]) ArrayUtils.toPrimitive((Object) new Integer[]{})); |
| assertArrayEquals(new short[]{2}, (short[]) ArrayUtils.toPrimitive((Object) new Short[]{2})); |
| assertArrayEquals(new long[]{2, 3}, (long[]) ArrayUtils.toPrimitive((Object) new Long[]{2L, 3L})); |
| assertArrayEquals(new float[]{3.14f}, (float[]) ArrayUtils.toPrimitive((Object) new Float[]{3.14f}), 0.1f); |
| assertArrayEquals(new double[]{2.718}, (double[]) ArrayUtils.toPrimitive((Object) new Double[]{2.718}), 0.1); |
| } |
| |
| /** |
| * Tests generic empty array creation with generic type. |
| */ |
| @Test |
| public void testEmptyArrayCreation() { |
| final String[] array = ArrayUtils.<String>toArray(); |
| assertEquals(0, array.length); |
| } |
| |
| @Test |
| public void testGet() { |
| assertNull(ArrayUtils.get(null, -1)); |
| assertNull(ArrayUtils.get(null, 0)); |
| assertNull(ArrayUtils.get(null, 1)); |
| final String[] array0 = {}; |
| assertNull(ArrayUtils.get(array0, -1)); |
| assertNull(ArrayUtils.get(array0, 0)); |
| assertNull(ArrayUtils.get(array0, 1)); |
| final String[] array1 = { StringUtils.EMPTY }; |
| assertNull(ArrayUtils.get(array1, -1)); |
| assertEquals(StringUtils.EMPTY, ArrayUtils.get(array1, 0)); |
| assertNull(ArrayUtils.get(array1, 1)); |
| } |
| |
| @Test |
| public void testGetComponentType() { |
| final TestClass[] newArray = {}; |
| // No type-cast required. |
| final Class<TestClass> componentType = ArrayUtils.getComponentType(newArray); |
| assertEquals(TestClass.class, componentType); |
| assertNull(ArrayUtils.getComponentType(null)); |
| } |
| |
| @Test |
| public void testGetDefault() { |
| // null default |
| { |
| assertNull(ArrayUtils.get(null, -1, null)); |
| assertNull(ArrayUtils.get(null, 0, null)); |
| assertNull(ArrayUtils.get(null, 1, null)); |
| final String[] array0 = {}; |
| assertNull(ArrayUtils.get(array0, -1, null)); |
| assertNull(ArrayUtils.get(array0, 0, null)); |
| assertNull(ArrayUtils.get(array0, 1, null)); |
| final String[] array1 = { StringUtils.EMPTY }; |
| assertNull(ArrayUtils.get(array1, -1, null)); |
| assertEquals(StringUtils.EMPTY, ArrayUtils.get(array1, 0, null)); |
| assertNull(ArrayUtils.get(array1, 1, null)); |
| } |
| // non-null default |
| { |
| final String defaultValue = "defaultValue"; |
| final String[] array1 = { StringUtils.EMPTY }; |
| assertEquals(defaultValue, ArrayUtils.get(array1, -1, defaultValue)); |
| assertEquals(StringUtils.EMPTY, ArrayUtils.get(array1, 0, defaultValue)); |
| assertEquals(defaultValue, ArrayUtils.get(array1, 1, defaultValue)); |
| } |
| } |
| |
| @Test |
| public void testGetLength() { |
| assertEquals(0, ArrayUtils.getLength(null)); |
| |
| final Object[] emptyObjectArray = {}; |
| final Object[] notEmptyObjectArray = {"aValue"}; |
| assertEquals(0, ArrayUtils.getLength(null)); |
| assertEquals(0, ArrayUtils.getLength(emptyObjectArray)); |
| assertEquals(1, ArrayUtils.getLength(notEmptyObjectArray)); |
| |
| final int[] emptyIntArray = {}; |
| final int[] notEmptyIntArray = {1}; |
| assertEquals(0, ArrayUtils.getLength(null)); |
| assertEquals(0, ArrayUtils.getLength(emptyIntArray)); |
| assertEquals(1, ArrayUtils.getLength(notEmptyIntArray)); |
| |
| final short[] emptyShortArray = {}; |
| final short[] notEmptyShortArray = {1}; |
| assertEquals(0, ArrayUtils.getLength(null)); |
| assertEquals(0, ArrayUtils.getLength(emptyShortArray)); |
| assertEquals(1, ArrayUtils.getLength(notEmptyShortArray)); |
| |
| final char[] emptyCharArray = {}; |
| final char[] notEmptyCharArray = {1}; |
| assertEquals(0, ArrayUtils.getLength(null)); |
| assertEquals(0, ArrayUtils.getLength(emptyCharArray)); |
| assertEquals(1, ArrayUtils.getLength(notEmptyCharArray)); |
| |
| final byte[] emptyByteArray = {}; |
| final byte[] notEmptyByteArray = {1}; |
| assertEquals(0, ArrayUtils.getLength(null)); |
| assertEquals(0, ArrayUtils.getLength(emptyByteArray)); |
| assertEquals(1, ArrayUtils.getLength(notEmptyByteArray)); |
| |
| final double[] emptyDoubleArray = {}; |
| final double[] notEmptyDoubleArray = {1.0}; |
| assertEquals(0, ArrayUtils.getLength(null)); |
| assertEquals(0, ArrayUtils.getLength(emptyDoubleArray)); |
| assertEquals(1, ArrayUtils.getLength(notEmptyDoubleArray)); |
| |
| final float[] emptyFloatArray = {}; |
| final float[] notEmptyFloatArray = {1.0F}; |
| assertEquals(0, ArrayUtils.getLength(null)); |
| assertEquals(0, ArrayUtils.getLength(emptyFloatArray)); |
| assertEquals(1, ArrayUtils.getLength(notEmptyFloatArray)); |
| |
| final boolean[] emptyBooleanArray = {}; |
| final boolean[] notEmptyBooleanArray = {true}; |
| assertEquals(0, ArrayUtils.getLength(null)); |
| assertEquals(0, ArrayUtils.getLength(emptyBooleanArray)); |
| assertEquals(1, ArrayUtils.getLength(notEmptyBooleanArray)); |
| |
| assertThrows(IllegalArgumentException.class, () -> ArrayUtils.getLength("notAnArray")); |
| } |
| |
| @Test |
| public void testHashCode() { |
| final long[][] array1 = {{2, 5}, {4, 5}}; |
| final long[][] array2 = {{2, 5}, {4, 6}}; |
| assertEquals(ArrayUtils.hashCode(array1), ArrayUtils.hashCode(array1)); |
| assertNotEquals(ArrayUtils.hashCode(array1), ArrayUtils.hashCode(array2)); |
| |
| final Object[] array3 = {new String(new char[]{'A', 'B'})}; |
| final Object[] array4 = {"AB"}; |
| assertEquals(ArrayUtils.hashCode(array3), ArrayUtils.hashCode(array3)); |
| assertEquals(ArrayUtils.hashCode(array3), ArrayUtils.hashCode(array4)); |
| |
| final Object[] arrayA = {new boolean[]{true, false}, new int[]{6, 7}}; |
| final Object[] arrayB = {new boolean[]{true, false}, new int[]{6, 7}}; |
| assertEquals(ArrayUtils.hashCode(arrayB), ArrayUtils.hashCode(arrayA)); |
| } |
| |
| @Test |
| public void testIndexesOf() { |
| final Object[] array = {"0", "1", "2", "3", null, "0"}; |
| final BitSet emptySet = new BitSet(); |
| final BitSet testSet = new BitSet(); |
| assertEquals(emptySet, ArrayUtils.indexesOf((Object[]) null, null)); |
| assertEquals(emptySet, ArrayUtils.indexesOf(new Object[0], "0")); |
| testSet.set(5); |
| testSet.set(0); |
| assertEquals(testSet, ArrayUtils.indexesOf(array, "0")); |
| testSet.clear(); |
| testSet.set(2); |
| assertEquals(testSet, ArrayUtils.indexesOf(array, "2")); |
| testSet.clear(); |
| testSet.set(3); |
| assertEquals(testSet, ArrayUtils.indexesOf(array, "3")); |
| testSet.clear(); |
| testSet.set(4); |
| assertEquals(testSet, ArrayUtils.indexesOf(array, null)); |
| assertEquals(emptySet, ArrayUtils.indexesOf(array, "notInArray")); |
| } |
| |
| @Test |
| public void testIndexesOfBoolean() { |
| boolean[] array = null; |
| final BitSet emptySet = new BitSet(); |
| final BitSet testSet = new BitSet(); |
| assertEquals(emptySet, ArrayUtils.indexesOf(array, true)); |
| array = new boolean[0]; |
| assertEquals(emptySet, ArrayUtils.indexesOf(array, true)); |
| array = new boolean[]{true, false, true}; |
| testSet.set(0); |
| testSet.set(2); |
| assertEquals(testSet, ArrayUtils.indexesOf(array, true)); |
| testSet.clear(); |
| testSet.set(1); |
| assertEquals(testSet, ArrayUtils.indexesOf(array, false)); |
| array = new boolean[]{true, true}; |
| assertEquals(emptySet, ArrayUtils.indexesOf(array, false)); |
| } |
| |
| @Test |
| public void testIndexesOfBooleanWithStartIndex() { |
| boolean[] array = null; |
| final BitSet emptySet = new BitSet(); |
| final BitSet testSet = new BitSet(); |
| assertEquals(emptySet, ArrayUtils.indexesOf(array, true, 0)); |
| array = new boolean[0]; |
| assertEquals(emptySet, ArrayUtils.indexesOf(array, true, 0)); |
| array = new boolean[]{true, false, true}; |
| testSet.set(2); |
| assertEquals(testSet, ArrayUtils.indexesOf(array, true, 1)); |
| testSet.set(0); |
| assertEquals(testSet, ArrayUtils.indexesOf(array, true, 0)); |
| testSet.clear(); |
| testSet.set(1); |
| assertEquals(testSet, ArrayUtils.indexesOf(array, false, 1)); |
| array = new boolean[]{true, true}; |
| assertEquals(emptySet, ArrayUtils.indexesOf(array, false, 0)); |
| assertEquals(emptySet, ArrayUtils.indexesOf(array, false, -1)); |
| } |
| |
| @Test |
| public void testIndexesOfByte() { |
| byte[] array = null; |
| final BitSet emptySet = new BitSet(); |
| final BitSet testSet = new BitSet(); |
| assertEquals(emptySet, ArrayUtils.indexesOf(array, (byte) 0)); |
| array = new byte[]{0, 1, 2, 3, 0}; |
| testSet.set(0); |
| testSet.set(4); |
| assertEquals(testSet, ArrayUtils.indexesOf(array, (byte) 0)); |
| testSet.clear(); |
| testSet.set(1); |
| assertEquals(testSet, ArrayUtils.indexesOf(array, (byte) 1)); |
| testSet.clear(); |
| testSet.set(2); |
| assertEquals(testSet, ArrayUtils.indexesOf(array, (byte) 2)); |
| testSet.clear(); |
| testSet.set(3); |
| assertEquals(testSet, ArrayUtils.indexesOf(array, (byte) 3)); |
| assertEquals(emptySet, ArrayUtils.indexesOf(array, (byte) 99)); |
| } |
| |
| @Test |
| public void testIndexesOfByteWithStartIndex() { |
| byte[] array = null; |
| final BitSet emptySet = new BitSet(); |
| final BitSet testSet = new BitSet(); |
| assertEquals(emptySet, ArrayUtils.indexesOf(array, (byte) 0, 2)); |
| array = new byte[]{0, 1, 2, 3, 0}; |
| testSet.set(4); |
| assertEquals(testSet, ArrayUtils.indexesOf(array, (byte) 0, 2)); |
| testSet.set(0); |
| assertEquals(testSet, ArrayUtils.indexesOf(array, (byte) 0, 0)); |
| testSet.clear(); |
| testSet.set(1); |
| assertEquals(testSet, ArrayUtils.indexesOf(array, (byte) 1, 1)); |
| testSet.clear(); |
| testSet.set(2); |
| assertEquals(testSet, ArrayUtils.indexesOf(array, (byte) 2, 0)); |
| testSet.clear(); |
| testSet.set(3); |
| assertEquals(testSet, ArrayUtils.indexesOf(array, (byte) 3, 0)); |
| assertEquals(testSet, ArrayUtils.indexesOf(array, (byte) 3, -1)); |
| assertEquals(emptySet, ArrayUtils.indexesOf(array, (byte) 99, 0)); |
| } |
| |
| @Test |
| public void testIndexesOfChar() { |
| char[] array = null; |
| final BitSet emptySet = new BitSet(); |
| final BitSet testSet = new BitSet(); |
| assertEquals(emptySet, ArrayUtils.indexesOf(array, 'a')); |
| array = new char[]{'a', 'b', 'c', 'd', 'a'}; |
| testSet.set(0); |
| testSet.set(4); |
| assertEquals(testSet, ArrayUtils.indexesOf(array, 'a')); |
| testSet.clear(); |
| testSet.set(1); |
| assertEquals(testSet, ArrayUtils.indexesOf(array, 'b')); |
| testSet.clear(); |
| testSet.set(2); |
| assertEquals(testSet, ArrayUtils.indexesOf(array, 'c')); |
| testSet.clear(); |
| testSet.set(3); |
| assertEquals(testSet, ArrayUtils.indexesOf(array, 'd')); |
| assertEquals(emptySet, ArrayUtils.indexesOf(array, 'e')); |
| } |
| |
| @Test |
| public void testIndexesOfCharWithStartIndex() { |
| char[] array = null; |
| final BitSet emptySet = new BitSet(); |
| final BitSet testSet = new BitSet(); |
| assertEquals(emptySet, ArrayUtils.indexesOf(array, 'a', 0)); |
| array = new char[]{'a', 'b', 'c', 'd', 'a'}; |
| testSet.set(4); |
| assertEquals(testSet, ArrayUtils.indexesOf(array, 'a', 2)); |
| testSet.set(0); |
| assertEquals(testSet, ArrayUtils.indexesOf(array, 'a', 0)); |
| assertEquals(testSet, ArrayUtils.indexesOf(array, 'a', -1)); |
| testSet.clear(); |
| testSet.set(1); |
| assertEquals(testSet, ArrayUtils.indexesOf(array, 'b', 1)); |
| testSet.clear(); |
| testSet.set(2); |
| assertEquals(testSet, ArrayUtils.indexesOf(array, 'c', 0)); |
| testSet.clear(); |
| testSet.set(3); |
| assertEquals(testSet, ArrayUtils.indexesOf(array, 'd', 0)); |
| assertEquals(emptySet, ArrayUtils.indexesOf(array, 'd', 5)); |
| assertEquals(emptySet, ArrayUtils.indexesOf(array, 'e', 0)); |
| } |
| |
| @Test |
| public void testIndexesOfDouble() { |
| double[] array = null; |
| final BitSet emptySet = new BitSet(); |
| final BitSet testSet = new BitSet(); |
| assertEquals(emptySet, ArrayUtils.indexesOf(array, 0)); |
| array = new double[]{0, 1, 2, 3, 0}; |
| testSet.set(0); |
| testSet.set(4); |
| assertEquals(testSet, ArrayUtils.indexesOf(array, 0)); |
| testSet.clear(); |
| testSet.set(1); |
| assertEquals(testSet, ArrayUtils.indexesOf(array, 1)); |
| testSet.clear(); |
| testSet.set(2); |
| assertEquals(testSet, ArrayUtils.indexesOf(array, 2)); |
| testSet.clear(); |
| testSet.set(3); |
| assertEquals(testSet, ArrayUtils.indexesOf(array, 3)); |
| assertEquals(emptySet, ArrayUtils.indexesOf(array, 99)); |
| } |
| |
| @SuppressWarnings("cast") |
| @Test |
| public void testIndexesOfDoubleTolerance() { |
| double[] array = null; |
| final BitSet emptySet = new BitSet(); |
| final BitSet testSet = new BitSet(); |
| assertEquals(emptySet, ArrayUtils.indexesOf(array, (double) 0, (double) 0)); |
| array = new double[0]; |
| assertEquals(emptySet, ArrayUtils.indexesOf(array, (double) 0, (double) 0)); |
| array = new double[]{0, 1, 2, 3, 0}; |
| testSet.set(0); |
| testSet.set(4); |
| assertEquals(testSet, ArrayUtils.indexesOf(array, (double) 0, 0.3)); |
| testSet.clear(); |
| testSet.set(3); |
| assertEquals(testSet, ArrayUtils.indexesOf(array, 4.15, 2.0)); |
| testSet.clear(); |
| testSet.set(1); |
| assertEquals(testSet, ArrayUtils.indexesOf(array, 1.00001324, 0.0001)); |
| } |
| |
| @Test |
| public void testIndexesOfDoubleWithStartIndex() { |
| double[] array = null; |
| final BitSet emptySet = new BitSet(); |
| final BitSet testSet = new BitSet(); |
| assertEquals(emptySet, ArrayUtils.indexesOf(array, 0, 2)); |
| array = new double[]{0, 1, 2, 3, 0}; |
| testSet.set(4); |
| assertEquals(testSet, ArrayUtils.indexesOf(array, 0, 2)); |
| testSet.set(0); |
| assertEquals(testSet, ArrayUtils.indexesOf(array, 0, 0)); |
| testSet.clear(); |
| testSet.set(1); |
| assertEquals(testSet, ArrayUtils.indexesOf(array, 1, 1)); |
| testSet.clear(); |
| testSet.set(2); |
| assertEquals(testSet, ArrayUtils.indexesOf(array, 2, 0)); |
| testSet.clear(); |
| testSet.set(3); |
| assertEquals(testSet, ArrayUtils.indexesOf(array, 3, 0)); |
| assertEquals(testSet, ArrayUtils.indexesOf(array, 3, -1)); |
| assertEquals(emptySet, ArrayUtils.indexesOf(array, 99, 0)); |
| } |
| |
| @SuppressWarnings("cast") |
| @Test |
| public void testIndexesOfDoubleWithStartIndexTolerance() { |
| double[] array = null; |
| final BitSet emptySet = new BitSet(); |
| final BitSet testSet = new BitSet(); |
| assertEquals(emptySet, ArrayUtils.indexesOf(array, (double) 0, 0, (double) 0)); |
| array = new double[0]; |
| assertEquals(emptySet, ArrayUtils.indexesOf(array, (double) 0, 0, (double) 0)); |
| array = new double[]{0, 1, 2, 3, 0}; |
| testSet.set(4); |
| assertEquals(testSet, ArrayUtils.indexesOf(array, (double) 0, 1, 0.3)); |
| testSet.set(0); |
| assertEquals(testSet, ArrayUtils.indexesOf(array, (double) 0, 0, 0.3)); |
| testSet.clear(); |
| testSet.set(2); |
| assertEquals(testSet, ArrayUtils.indexesOf(array, 2, 0, 0.35)); |
| assertEquals(testSet, ArrayUtils.indexesOf(array, 2, 2, 0.35)); |
| assertEquals(testSet, ArrayUtils.indexesOf(array, 2, -1, 0.35)); |
| assertEquals(emptySet, ArrayUtils.indexesOf(array, 2, 3, 0.35)); |
| testSet.clear(); |
| testSet.set(3); |
| assertEquals(testSet, ArrayUtils.indexesOf(array, 4.15, 0, 2.0)); |
| testSet.clear(); |
| testSet.set(1); |
| assertEquals(testSet, ArrayUtils.indexesOf(array, 1.00001324, 0, 0.0001)); |
| } |
| |
| @Test |
| public void testIndexesOfFloat() { |
| float[] array = null; |
| final BitSet emptySet = new BitSet(); |
| final BitSet testSet = new BitSet(); |
| assertEquals(emptySet, ArrayUtils.indexesOf(array, 0)); |
| array = new float[]{0, 1, 2, 3, 0}; |
| testSet.set(0); |
| testSet.set(4); |
| assertEquals(testSet, ArrayUtils.indexesOf(array, 0)); |
| testSet.clear(); |
| testSet.set(1); |
| assertEquals(testSet, ArrayUtils.indexesOf(array, 1)); |
| testSet.clear(); |
| testSet.set(2); |
| assertEquals(testSet, ArrayUtils.indexesOf(array, 2)); |
| testSet.clear(); |
| testSet.set(3); |
| assertEquals(testSet, ArrayUtils.indexesOf(array, 3)); |
| assertEquals(emptySet, ArrayUtils.indexesOf(array, 99)); |
| } |
| |
| @Test |
| public void testIndexesOfFloatWithStartIndex() { |
| float[] array = null; |
| final BitSet emptySet = new BitSet(); |
| final BitSet testSet = new BitSet(); |
| assertEquals(emptySet, ArrayUtils.indexesOf(array, 0, 2)); |
| array = new float[]{0, 1, 2, 3, 0}; |
| testSet.set(4); |
| assertEquals(testSet, ArrayUtils.indexesOf(array, 0, 2)); |
| testSet.set(0); |
| assertEquals(testSet, ArrayUtils.indexesOf(array, 0, 0)); |
| testSet.clear(); |
| testSet.set(1); |
| assertEquals(testSet, ArrayUtils.indexesOf(array, 1, 1)); |
| testSet.clear(); |
| testSet.set(2); |
| assertEquals(testSet, ArrayUtils.indexesOf(array, 2, 0)); |
| testSet.clear(); |
| testSet.set(3); |
| assertEquals(testSet, ArrayUtils.indexesOf(array, 3, 0)); |
| assertEquals(testSet, ArrayUtils.indexesOf(array, 3, -1)); |
| assertEquals(emptySet, ArrayUtils.indexesOf(array, 99, 0)); |
| } |
| |
| @Test |
| public void testIndexesOfIntWithStartIndex() { |
| int[] array = null; |
| final BitSet emptySet = new BitSet(); |
| final BitSet testSet = new BitSet(); |
| assertEquals(emptySet, ArrayUtils.indexesOf(array, 0, 2)); |
| array = new int[]{0, 1, 2, 3, 0}; |
| testSet.set(4); |
| assertEquals(testSet, ArrayUtils.indexesOf(array, 0, 2)); |
| testSet.set(0); |
| assertEquals(testSet, ArrayUtils.indexesOf(array, 0, 0)); |
| testSet.clear(); |
| testSet.set(1); |
| assertEquals(testSet, ArrayUtils.indexesOf(array, 1, 1)); |
| testSet.clear(); |
| testSet.set(2); |
| assertEquals(testSet, ArrayUtils.indexesOf(array, 2, 0)); |
| testSet.clear(); |
| testSet.set(3); |
| assertEquals(testSet, ArrayUtils.indexesOf(array, 3, 0)); |
| assertEquals(testSet, ArrayUtils.indexesOf(array, 3, -1)); |
| assertEquals(emptySet, ArrayUtils.indexesOf(array, 99, 0)); |
| } |
| |
| @Test |
| public void testIndexesOfLong() { |
| final long[] array = {0, 1, 2, 3}; |
| final BitSet emptySet = new BitSet(); |
| final BitSet testSet = new BitSet(); |
| assertEquals(emptySet, ArrayUtils.indexesOf((long[]) null, 0)); |
| assertEquals(emptySet, ArrayUtils.indexesOf(array, 4)); |
| testSet.set(0); |
| assertEquals(testSet, ArrayUtils.indexesOf(array, 0)); |
| testSet.clear(); |
| testSet.set(1); |
| assertEquals(testSet, ArrayUtils.indexesOf(array, 1)); |
| testSet.clear(); |
| testSet.set(2); |
| assertEquals(testSet, ArrayUtils.indexesOf(array, 2)); |
| testSet.clear(); |
| testSet.set(3); |
| assertEquals(testSet, ArrayUtils.indexesOf(array, 3)); |
| } |
| |
| @Test |
| public void testIndexesOfLongWithStartIndex() { |
| final long[] array = {0, 1, 2, 3, 2, 1, 0, 1}; |
| final BitSet emptySet = new BitSet(); |
| final BitSet testSet = new BitSet(); |
| assertEquals(emptySet, ArrayUtils.indexesOf((long[]) null, 0, 0)); |
| assertEquals(emptySet, ArrayUtils.indexesOf(array, 4, 0)); |
| testSet.set(6); |
| assertEquals(testSet, ArrayUtils.indexesOf(array, 0, 1)); |
| testSet.set(0); |
| assertEquals(testSet, ArrayUtils.indexesOf(array, 0, 0)); |
| testSet.clear(); |
| testSet.set(1); |
| testSet.set(5); |
| testSet.set(7); |
| assertEquals(testSet, ArrayUtils.indexesOf(array, 1, 0)); |
| testSet.clear(); |
| testSet.set(2); |
| testSet.set(4); |
| assertEquals(testSet, ArrayUtils.indexesOf(array, 2, 0)); |
| testSet.clear(); |
| testSet.set(3); |
| assertEquals(testSet, ArrayUtils.indexesOf(array, 3, 0)); |
| assertEquals(emptySet, ArrayUtils.indexesOf(array, 3, 8)); |
| } |
| |
| @Test |
| public void testIndexesOfShort() { |
| short[] array = null; |
| final BitSet emptySet = new BitSet(); |
| final BitSet testSet = new BitSet(); |
| assertEquals(emptySet, ArrayUtils.indexesOf(array, (short) 0)); |
| array = new short[]{0, 1, 2, 3, 0}; |
| testSet.set(0); |
| testSet.set(4); |
| assertEquals(testSet, ArrayUtils.indexesOf(array, (short) 0)); |
| testSet.clear(); |
| testSet.set(1); |
| assertEquals(testSet, ArrayUtils.indexesOf(array, (short) 1)); |
| testSet.clear(); |
| testSet.set(2); |
| assertEquals(testSet, ArrayUtils.indexesOf(array, (short) 2)); |
| testSet.clear(); |
| testSet.set(3); |
| assertEquals(testSet, ArrayUtils.indexesOf(array, (short) 3)); |
| assertEquals(emptySet, ArrayUtils.indexesOf(array, (short) 99)); |
| } |
| |
| @Test |
| public void testIndexesOfShortWithStartIndex() { |
| short[] array = null; |
| final BitSet emptySet = new BitSet(); |
| final BitSet testSet = new BitSet(); |
| assertEquals(emptySet, ArrayUtils.indexesOf(array, (short) 0, 2)); |
| array = new short[]{0, 1, 2, 3, 0}; |
| testSet.set(4); |
| assertEquals(testSet, ArrayUtils.indexesOf(array, (short) 0, 2)); |
| testSet.set(0); |
| assertEquals(testSet, ArrayUtils.indexesOf(array, (short) 0, 0)); |
| testSet.clear(); |
| testSet.set(1); |
| assertEquals(testSet, ArrayUtils.indexesOf(array, (short) 1, 1)); |
| testSet.clear(); |
| testSet.set(2); |
| assertEquals(testSet, ArrayUtils.indexesOf(array, (short) 2, 0)); |
| testSet.clear(); |
| testSet.set(3); |
| assertEquals(testSet, ArrayUtils.indexesOf(array, (short) 3, 0)); |
| assertEquals(testSet, ArrayUtils.indexesOf(array, (short) 3, -1)); |
| assertEquals(emptySet, ArrayUtils.indexesOf(array, (short) 99, 0)); |
| } |
| |
| @Test |
| public void testIndexesOfWithStartIndex() { |
| final Object[] array = {"0", "1", "2", "3", "2", "3", "1", null, "0"}; |
| final BitSet emptySet = new BitSet(); |
| final BitSet testSet = new BitSet(); |
| assertEquals(emptySet, ArrayUtils.indexesOf(null, null, 2)); |
| assertEquals(emptySet, ArrayUtils.indexesOf(new Object[0], "0", 0)); |
| assertEquals(emptySet, ArrayUtils.indexesOf(null, "0", 2)); |
| testSet.set(8); |
| assertEquals(testSet, ArrayUtils.indexesOf(array, "0", 8)); |
| testSet.set(0); |
| assertEquals(testSet, ArrayUtils.indexesOf(array, "0", 0)); |
| testSet.clear(); |
| testSet.set(6); |
| testSet.set(1); |
| assertEquals(testSet, ArrayUtils.indexesOf(array, "1", 0)); |
| assertEquals(emptySet, ArrayUtils.indexesOf(array, "1", 9)); |
| testSet.clear(); |
| testSet.set(4); |
| assertEquals(testSet, ArrayUtils.indexesOf(array, "2", 3)); |
| testSet.set(2); |
| assertEquals(testSet, ArrayUtils.indexesOf(array, "2", 0)); |
| testSet.clear(); |
| testSet.set(3); |
| testSet.set(5); |
| assertEquals(testSet, ArrayUtils.indexesOf(array, "3", 0)); |
| testSet.clear(); |
| testSet.set(7); |
| assertEquals(testSet, ArrayUtils.indexesOf(array, null, 0)); |
| |
| } |
| |
| @Test |
| public void testIndexOf() { |
| final Object[] array = {"0", "1", "2", "3", null, "0"}; |
| assertEquals(-1, ArrayUtils.indexOf(null, null)); |
| assertEquals(-1, ArrayUtils.indexOf(null, "0")); |
| assertEquals(-1, ArrayUtils.indexOf(new Object[0], "0")); |
| assertEquals(0, ArrayUtils.indexOf(array, "0")); |
| assertEquals(1, ArrayUtils.indexOf(array, "1")); |
| assertEquals(2, ArrayUtils.indexOf(array, "2")); |
| assertEquals(3, ArrayUtils.indexOf(array, "3")); |
| assertEquals(4, ArrayUtils.indexOf(array, null)); |
| assertEquals(-1, ArrayUtils.indexOf(array, "notInArray")); |
| } |
| |
| @Test |
| public void testIndexOfBoolean() { |
| boolean[] array = null; |
| assertEquals(-1, ArrayUtils.indexOf(array, true)); |
| array = new boolean[0]; |
| assertEquals(-1, ArrayUtils.indexOf(array, true)); |
| array = new boolean[]{true, false, true}; |
| assertEquals(0, ArrayUtils.indexOf(array, true)); |
| assertEquals(1, ArrayUtils.indexOf(array, false)); |
| array = new boolean[]{true, true}; |
| assertEquals(-1, ArrayUtils.indexOf(array, false)); |
| } |
| |
| @Test |
| public void testIndexOfBooleanWithStartIndex() { |
| boolean[] array = null; |
| assertEquals(-1, ArrayUtils.indexOf(array, true, 2)); |
| array = new boolean[0]; |
| assertEquals(-1, ArrayUtils.indexOf(array, true, 2)); |
| array = new boolean[]{true, false, true}; |
| assertEquals(2, ArrayUtils.indexOf(array, true, 1)); |
| assertEquals(-1, ArrayUtils.indexOf(array, false, 2)); |
| assertEquals(1, ArrayUtils.indexOf(array, false, 0)); |
| assertEquals(1, ArrayUtils.indexOf(array, false, -1)); |
| array = new boolean[]{true, true}; |
| assertEquals(-1, ArrayUtils.indexOf(array, false, 0)); |
| assertEquals(-1, ArrayUtils.indexOf(array, false, -1)); |
| } |
| |
| @Test |
| public void testIndexOfByte() { |
| byte[] array = null; |
| assertEquals(-1, ArrayUtils.indexOf(array, (byte) 0)); |
| array = new byte[]{0, 1, 2, 3, 0}; |
| assertEquals(0, ArrayUtils.indexOf(array, (byte) 0)); |
| assertEquals(1, ArrayUtils.indexOf(array, (byte) 1)); |
| assertEquals(2, ArrayUtils.indexOf(array, (byte) 2)); |
| assertEquals(3, ArrayUtils.indexOf(array, (byte) 3)); |
| assertEquals(-1, ArrayUtils.indexOf(array, (byte) 99)); |
| } |
| |
| @Test |
| public void testIndexOfByteWithStartIndex() { |
| byte[] array = null; |
| assertEquals(-1, ArrayUtils.indexOf(array, (byte) 0, 2)); |
| array = new byte[]{0, 1, 2, 3, 0}; |
| assertEquals(4, ArrayUtils.indexOf(array, (byte) 0, 2)); |
| assertEquals(-1, ArrayUtils.indexOf(array, (byte) 1, 2)); |
| assertEquals(2, ArrayUtils.indexOf(array, (byte) 2, 2)); |
| assertEquals(3, ArrayUtils.indexOf(array, (byte) 3, 2)); |
| assertEquals(3, ArrayUtils.indexOf(array, (byte) 3, -1)); |
| assertEquals(-1, ArrayUtils.indexOf(array, (byte) 99, 0)); |
| assertEquals(-1, ArrayUtils.indexOf(array, (byte) 0, 6)); |
| } |
| |
| @Test |
| public void testIndexOfChar() { |
| char[] array = null; |
| assertEquals(-1, ArrayUtils.indexOf(array, 'a')); |
| array = new char[]{'a', 'b', 'c', 'd', 'a'}; |
| assertEquals(0, ArrayUtils.indexOf(array, 'a')); |
| assertEquals(1, ArrayUtils.indexOf(array, 'b')); |
| assertEquals(2, ArrayUtils.indexOf(array, 'c')); |
| assertEquals(3, ArrayUtils.indexOf(array, 'd')); |
| assertEquals(-1, ArrayUtils.indexOf(array, 'e')); |
| } |
| |
| @Test |
| public void testIndexOfCharWithStartIndex() { |
| char[] array = null; |
| assertEquals(-1, ArrayUtils.indexOf(array, 'a', 2)); |
| array = new char[]{'a', 'b', 'c', 'd', 'a'}; |
| assertEquals(4, ArrayUtils.indexOf(array, 'a', 2)); |
| assertEquals(-1, ArrayUtils.indexOf(array, 'b', 2)); |
| assertEquals(2, ArrayUtils.indexOf(array, 'c', 2)); |
| assertEquals(3, ArrayUtils.indexOf(array, 'd', 2)); |
| assertEquals(3, ArrayUtils.indexOf(array, 'd', -1)); |
| assertEquals(-1, ArrayUtils.indexOf(array, 'e', 0)); |
| assertEquals(-1, ArrayUtils.indexOf(array, 'a', 6)); |
| } |
| |
| @SuppressWarnings("cast") |
| @Test |
| public void testIndexOfDouble() { |
| double[] array = null; |
| assertEquals(-1, ArrayUtils.indexOf(array, (double) 0)); |
| array = new double[0]; |
| assertEquals(-1, ArrayUtils.indexOf(array, (double) 0)); |
| array = new double[]{0, 1, 2, 3, 0}; |
| assertEquals(0, ArrayUtils.indexOf(array, (double) 0)); |
| assertEquals(1, ArrayUtils.indexOf(array, (double) 1)); |
| assertEquals(2, ArrayUtils.indexOf(array, (double) 2)); |
| assertEquals(3, ArrayUtils.indexOf(array, (double) 3)); |
| assertEquals(3, ArrayUtils.indexOf(array, (double) 3, -1)); |
| assertEquals(-1, ArrayUtils.indexOf(array, (double) 99)); |
| } |
| |
| @Test |
| public void testIndexOfDoubleNaN() { |
| final double[] array = { Double.NEGATIVE_INFINITY, Double.NaN, Double.POSITIVE_INFINITY, Double.NaN }; |
| assertEquals(0, ArrayUtils.indexOf(array, Double.NEGATIVE_INFINITY)); |
| assertEquals(1, ArrayUtils.indexOf(array, Double.NaN)); |
| assertEquals(2, ArrayUtils.indexOf(array, Double.POSITIVE_INFINITY)); |
| |
| } |
| |
| @SuppressWarnings("cast") |
| @Test |
| public void testIndexOfDoubleTolerance() { |
| double[] array = null; |
| assertEquals(-1, ArrayUtils.indexOf(array, (double) 0, (double) 0)); |
| array = new double[0]; |
| assertEquals(-1, ArrayUtils.indexOf(array, (double) 0, (double) 0)); |
| array = new double[]{0, 1, 2, 3, 0}; |
| assertEquals(0, ArrayUtils.indexOf(array, (double) 0, 0.3)); |
| assertEquals(2, ArrayUtils.indexOf(array, 2.2, 0.35)); |
| assertEquals(3, ArrayUtils.indexOf(array, 4.15, 2.0)); |
| assertEquals(1, ArrayUtils.indexOf(array, 1.00001324, 0.0001)); |
| } |
| |
| @SuppressWarnings("cast") |
| @Test |
| public void testIndexOfDoubleWithStartIndex() { |
| double[] array = null; |
| assertEquals(-1, ArrayUtils.indexOf(array, (double) 0, 2)); |
| array = new double[0]; |
| assertEquals(-1, ArrayUtils.indexOf(array, (double) 0, 2)); |
| array = new double[]{0, 1, 2, 3, 0}; |
| assertEquals(4, ArrayUtils.indexOf(array, (double) 0, 2)); |
| assertEquals(-1, ArrayUtils.indexOf(array, (double) 1, 2)); |
| assertEquals(2, ArrayUtils.indexOf(array, (double) 2, 2)); |
| assertEquals(3, ArrayUtils.indexOf(array, (double) 3, 2)); |
| assertEquals(-1, ArrayUtils.indexOf(array, (double) 99, 0)); |
| assertEquals(-1, ArrayUtils.indexOf(array, (double) 0, 6)); |
| } |
| |
| @SuppressWarnings("cast") |
| @Test |
| public void testIndexOfDoubleWithStartIndexTolerance() { |
| double[] array = null; |
| assertEquals(-1, ArrayUtils.indexOf(array, (double) 0, 2, (double) 0)); |
| array = new double[0]; |
| assertEquals(-1, ArrayUtils.indexOf(array, (double) 0, 2, (double) 0)); |
| array = new double[]{0, 1, 2, 3, 0}; |
| assertEquals(-1, ArrayUtils.indexOf(array, (double) 0, 99, 0.3)); |
| assertEquals(0, ArrayUtils.indexOf(array, (double) 0, 0, 0.3)); |
| assertEquals(4, ArrayUtils.indexOf(array, (double) 0, 3, 0.3)); |
| assertEquals(2, ArrayUtils.indexOf(array, 2.2, 0, 0.35)); |
| assertEquals(3, ArrayUtils.indexOf(array, 4.15, 0, 2.0)); |
| assertEquals(1, ArrayUtils.indexOf(array, 1.00001324, 0, 0.0001)); |
| assertEquals(3, ArrayUtils.indexOf(array, 4.15, -1, 2.0)); |
| assertEquals(1, ArrayUtils.indexOf(array, 1.00001324, -300, 0.0001)); |
| } |
| |
| @SuppressWarnings("cast") |
| @Test |
| public void testIndexOfFloat() { |
| float[] array = null; |
| assertEquals(-1, ArrayUtils.indexOf(array, (float) 0)); |
| array = new float[0]; |
| assertEquals(-1, ArrayUtils.indexOf(array, (float) 0)); |
| array = new float[]{0, 1, 2, 3, 0}; |
| assertEquals(0, ArrayUtils.indexOf(array, (float) 0)); |
| assertEquals(1, ArrayUtils.indexOf(array, (float) 1)); |
| assertEquals(2, ArrayUtils.indexOf(array, (float) 2)); |
| assertEquals(3, ArrayUtils.indexOf(array, (float) 3)); |
| assertEquals(-1, ArrayUtils.indexOf(array, (float) 99)); |
| } |
| |
| @Test |
| public void testIndexOfFloatNaN() { |
| final float[] array = { Float.NEGATIVE_INFINITY, Float.NaN, Float.POSITIVE_INFINITY, Float.NaN }; |
| assertEquals(0, ArrayUtils.indexOf(array, Float.NEGATIVE_INFINITY)); |
| assertEquals(1, ArrayUtils.indexOf(array, Float.NaN)); |
| assertEquals(2, ArrayUtils.indexOf(array, Float.POSITIVE_INFINITY)); |
| } |
| |
| @SuppressWarnings("cast") |
| @Test |
| public void testIndexOfFloatWithStartIndex() { |
| float[] array = null; |
| assertEquals(-1, ArrayUtils.indexOf(array, (float) 0, 2)); |
| array = new float[0]; |
| assertEquals(-1, ArrayUtils.indexOf(array, (float) 0, 2)); |
| array = new float[]{0, 1, 2, 3, 0}; |
| assertEquals(4, ArrayUtils.indexOf(array, (float) 0, 2)); |
| assertEquals(-1, ArrayUtils.indexOf(array, (float) 1, 2)); |
| assertEquals(2, ArrayUtils.indexOf(array, (float) 2, 2)); |
| assertEquals(3, ArrayUtils.indexOf(array, (float) 3, 2)); |
| assertEquals(3, ArrayUtils.indexOf(array, (float) 3, -1)); |
| assertEquals(-1, ArrayUtils.indexOf(array, (float) 99, 0)); |
| assertEquals(-1, ArrayUtils.indexOf(array, (float) 0, 6)); |
| } |
| |
| @Test |
| public void testIndexOfInt() { |
| int[] array = null; |
| assertEquals(-1, ArrayUtils.indexOf(array, 0)); |
| array = new int[]{0, 1, 2, 3, 0}; |
| assertEquals(0, ArrayUtils.indexOf(array, 0)); |
| assertEquals(1, ArrayUtils.indexOf(array, 1)); |
| assertEquals(2, ArrayUtils.indexOf(array, 2)); |
| assertEquals(3, ArrayUtils.indexOf(array, 3)); |
| assertEquals(-1, ArrayUtils.indexOf(array, 99)); |
| } |
| |
| @Test |
| public void testIndexOfIntWithStartIndex() { |
| int[] array = null; |
| assertEquals(-1, ArrayUtils.indexOf(array, 0, 2)); |
| array = new int[]{0, 1, 2, 3, 0}; |
| assertEquals(4, ArrayUtils.indexOf(array, 0, 2)); |
| assertEquals(-1, ArrayUtils.indexOf(array, 1, 2)); |
| assertEquals(2, ArrayUtils.indexOf(array, 2, 2)); |
| assertEquals(3, ArrayUtils.indexOf(array, 3, 2)); |
| assertEquals(3, ArrayUtils.indexOf(array, 3, -1)); |
| assertEquals(-1, ArrayUtils.indexOf(array, 99, 0)); |
| assertEquals(-1, ArrayUtils.indexOf(array, 0, 6)); |
| } |
| |
| @Test |
| public void testIndexOfLong() { |
| long[] array = null; |
| assertEquals(-1, ArrayUtils.indexOf(array, 0)); |
| array = new long[]{0, 1, 2, 3, 0}; |
| assertEquals(0, ArrayUtils.indexOf(array, 0)); |
| assertEquals(1, ArrayUtils.indexOf(array, 1)); |
| assertEquals(2, ArrayUtils.indexOf(array, 2)); |
| assertEquals(3, ArrayUtils.indexOf(array, 3)); |
| assertEquals(-1, ArrayUtils.indexOf(array, 99)); |
| } |
| |
| @Test |
| public void testIndexOfLongWithStartIndex() { |
| long[] array = null; |
| assertEquals(-1, ArrayUtils.indexOf(array, 0, 2)); |
| array = new long[]{0, 1, 2, 3, 0}; |
| assertEquals(4, ArrayUtils.indexOf(array, 0, 2)); |
| assertEquals(-1, ArrayUtils.indexOf(array, 1, 2)); |
| assertEquals(2, ArrayUtils.indexOf(array, 2, 2)); |
| assertEquals(3, ArrayUtils.indexOf(array, 3, 2)); |
| assertEquals(3, ArrayUtils.indexOf(array, 3, -1)); |
| assertEquals(-1, ArrayUtils.indexOf(array, 99, 0)); |
| assertEquals(-1, ArrayUtils.indexOf(array, 0, 6)); |
| } |
| |
| @Test |
| public void testIndexOfShort() { |
| short[] array = null; |
| assertEquals(-1, ArrayUtils.indexOf(array, (short) 0)); |
| array = new short[]{0, 1, 2, 3, 0}; |
| assertEquals(0, ArrayUtils.indexOf(array, (short) 0)); |
| assertEquals(1, ArrayUtils.indexOf(array, (short) 1)); |
| assertEquals(2, ArrayUtils.indexOf(array, (short) 2)); |
| assertEquals(3, ArrayUtils.indexOf(array, (short) 3)); |
| assertEquals(-1, ArrayUtils.indexOf(array, (short) 99)); |
| } |
| |
| @Test |
| public void testIndexOfShortWithStartIndex() { |
| short[] array = null; |
| assertEquals(-1, ArrayUtils.indexOf(array, (short) 0, 2)); |
| array = new short[]{0, 1, 2, 3, 0}; |
| assertEquals(4, ArrayUtils.indexOf(array, (short) 0, 2)); |
| assertEquals(-1, ArrayUtils.indexOf(array, (short) 1, 2)); |
| assertEquals(2, ArrayUtils.indexOf(array, (short) 2, 2)); |
| assertEquals(3, ArrayUtils.indexOf(array, (short) 3, 2)); |
| assertEquals(3, ArrayUtils.indexOf(array, (short) 3, -1)); |
| assertEquals(-1, ArrayUtils.indexOf(array, (short) 99, 0)); |
| assertEquals(-1, ArrayUtils.indexOf(array, (short) 0, 6)); |
| } |
| |
| @Test |
| public void testIndexOfWithStartIndex() { |
| final Object[] array = {"0", "1", "2", "3", null, "0"}; |
| assertEquals(-1, ArrayUtils.indexOf(null, null, 2)); |
| assertEquals(-1, ArrayUtils.indexOf(new Object[0], "0", 0)); |
| assertEquals(-1, ArrayUtils.indexOf(null, "0", 2)); |
| assertEquals(5, ArrayUtils.indexOf(array, "0", 2)); |
| assertEquals(-1, ArrayUtils.indexOf(array, "1", 2)); |
| assertEquals(2, ArrayUtils.indexOf(array, "2", 2)); |
| assertEquals(3, ArrayUtils.indexOf(array, "3", 2)); |
| assertEquals(4, ArrayUtils.indexOf(array, null, 2)); |
| assertEquals(-1, ArrayUtils.indexOf(array, "notInArray", 2)); |
| |
| assertEquals(4, ArrayUtils.indexOf(array, null, -1)); |
| assertEquals(-1, ArrayUtils.indexOf(array, null, 8)); |
| assertEquals(-1, ArrayUtils.indexOf(array, "0", 8)); |
| } |
| |
| /** |
| * Tests generic array creation with generic type. |
| */ |
| @Test |
| public void testIndirectArrayCreation() { |
| final String[] array = toArrayPropagatingType("foo", "bar"); |
| assertEquals(2, array.length); |
| assertEquals("foo", array[0]); |
| assertEquals("bar", array[1]); |
| } |
| |
| /** |
| * Tests indirect generic empty array creation with generic type. |
| */ |
| @Test |
| public void testIndirectEmptyArrayCreation() { |
| final String[] array = ArrayUtilsTest.<String>toArrayPropagatingType(); |
| assertEquals(0, array.length); |
| } |
| |
| @Test |
| public void testIsArrayIndexValid() { |
| assertFalse(ArrayUtils.isArrayIndexValid(null, 0)); |
| final String[] array = new String[1]; |
| |
| //too big |
| assertFalse(ArrayUtils.isArrayIndexValid(array, 1)); |
| |
| //negative index |
| assertFalse(ArrayUtils.isArrayIndexValid(array, -1)); |
| |
| //good to go |
| assertTrue(ArrayUtils.isArrayIndexValid(array, 0)); |
| } |
| |
| /** |
| * Test for {@link ArrayUtils#isEmpty(java.lang.Object[])}. |
| */ |
| @Test |
| public void testIsEmptyObject() { |
| final Object[] emptyArray = {}; |
| final Object[] notEmptyArray = {"Value"}; |
| assertTrue(ArrayUtils.isEmpty((Object[]) null)); |
| assertTrue(ArrayUtils.isEmpty(emptyArray)); |
| assertFalse(ArrayUtils.isEmpty(notEmptyArray)); |
| } |
| |
| /** |
| * Tests for {@link ArrayUtils#isEmpty(long[])}, |
| * {@link ArrayUtils#isEmpty(int[])}, |
| * {@link ArrayUtils#isEmpty(short[])}, |
| * {@link ArrayUtils#isEmpty(char[])}, |
| * {@link ArrayUtils#isEmpty(byte[])}, |
| * {@link ArrayUtils#isEmpty(double[])}, |
| * {@link ArrayUtils#isEmpty(float[])} and |
| * {@link ArrayUtils#isEmpty(boolean[])}. |
| */ |
| @Test |
| public void testIsEmptyPrimitives() { |
| final long[] emptyLongArray = {}; |
| final long[] notEmptyLongArray = {1L}; |
| assertTrue(ArrayUtils.isEmpty((long[]) null)); |
| assertTrue(ArrayUtils.isEmpty(emptyLongArray)); |
| assertFalse(ArrayUtils.isEmpty(notEmptyLongArray)); |
| |
| final int[] emptyIntArray = {}; |
| final int[] notEmptyIntArray = {1}; |
| assertTrue(ArrayUtils.isEmpty((int[]) null)); |
| assertTrue(ArrayUtils.isEmpty(emptyIntArray)); |
| assertFalse(ArrayUtils.isEmpty(notEmptyIntArray)); |
| |
| final short[] emptyShortArray = {}; |
| final short[] notEmptyShortArray = {1}; |
| assertTrue(ArrayUtils.isEmpty((short[]) null)); |
| assertTrue(ArrayUtils.isEmpty(emptyShortArray)); |
| assertFalse(ArrayUtils.isEmpty(notEmptyShortArray)); |
| |
| final char[] emptyCharArray = {}; |
| final char[] notEmptyCharArray = {1}; |
| assertTrue(ArrayUtils.isEmpty((char[]) null)); |
| assertTrue(ArrayUtils.isEmpty(emptyCharArray)); |
| assertFalse(ArrayUtils.isEmpty(notEmptyCharArray)); |
| |
| final byte[] emptyByteArray = {}; |
| final byte[] notEmptyByteArray = {1}; |
| assertTrue(ArrayUtils.isEmpty((byte[]) null)); |
| assertTrue(ArrayUtils.isEmpty(emptyByteArray)); |
| assertFalse(ArrayUtils.isEmpty(notEmptyByteArray)); |
| |
| final double[] emptyDoubleArray = {}; |
| final double[] notEmptyDoubleArray = {1.0}; |
| assertTrue(ArrayUtils.isEmpty((double[]) null)); |
| assertTrue(ArrayUtils.isEmpty(emptyDoubleArray)); |
| assertFalse(ArrayUtils.isEmpty(notEmptyDoubleArray)); |
| |
| final float[] emptyFloatArray = {}; |
| final float[] notEmptyFloatArray = {1.0F}; |
| assertTrue(ArrayUtils.isEmpty((float[]) null)); |
| assertTrue(ArrayUtils.isEmpty(emptyFloatArray)); |
| assertFalse(ArrayUtils.isEmpty(notEmptyFloatArray)); |
| |
| final boolean[] emptyBooleanArray = {}; |
| final boolean[] notEmptyBooleanArray = {true}; |
| assertTrue(ArrayUtils.isEmpty((boolean[]) null)); |
| assertTrue(ArrayUtils.isEmpty(emptyBooleanArray)); |
| assertFalse(ArrayUtils.isEmpty(notEmptyBooleanArray)); |
| } |
| |
| @Test |
| public void testIsEquals() { |
| final long[][] larray1 = {{2, 5}, {4, 5}}; |
| final long[][] larray2 = {{2, 5}, {4, 6}}; |
| final long[] larray3 = {2, 5}; |
| this.assertIsEquals(larray1, larray2, larray3); |
| |
| final int[][] iarray1 = {{2, 5}, {4, 5}}; |
| final int[][] iarray2 = {{2, 5}, {4, 6}}; |
| final int[] iarray3 = {2, 5}; |
| this.assertIsEquals(iarray1, iarray2, iarray3); |
| |
| final short[][] sarray1 = {{2, 5}, {4, 5}}; |
| final short[][] sarray2 = {{2, 5}, {4, 6}}; |
| final short[] sarray3 = {2, 5}; |
| this.assertIsEquals(sarray1, sarray2, sarray3); |
| |
| final float[][] farray1 = {{2, 5}, {4, 5}}; |
| final float[][] farray2 = {{2, 5}, {4, 6}}; |
| final float[] farray3 = {2, 5}; |
| this.assertIsEquals(farray1, farray2, farray3); |
| |
| final double[][] darray1 = {{2, 5}, {4, 5}}; |
| final double[][] darray2 = {{2, 5}, {4, 6}}; |
| final double[] darray3 = {2, 5}; |
| this.assertIsEquals(darray1, darray2, darray3); |
| |
| final byte[][] byteArray1 = {{2, 5}, {4, 5}}; |
| final byte[][] byteArray2 = {{2, 5}, {4, 6}}; |
| final byte[] byteArray3 = {2, 5}; |
| this.assertIsEquals(byteArray1, byteArray2, byteArray3); |
| |
| final char[][] charArray1 = {{2, 5}, {4, 5}}; |
| final char[][] charArray2 = {{2, 5}, {4, 6}}; |
| final char[] charArray3 = {2, 5}; |
| this.assertIsEquals(charArray1, charArray2, charArray3); |
| |
| final boolean[][] barray1 = {{true, false}, {true, true}}; |
| final boolean[][] barray2 = {{true, false}, {true, false}}; |
| final boolean[] barray3 = {false, true}; |
| this.assertIsEquals(barray1, barray2, barray3); |
| |
| final Object[] array3 = {new String(new char[]{'A', 'B'})}; |
| final Object[] array4 = {"AB"}; |
| assertTrue(ArrayUtils.isEquals(array3, array3)); |
| assertTrue(ArrayUtils.isEquals(array3, array4)); |
| |
| assertTrue(ArrayUtils.isEquals(null, null)); |
| assertFalse(ArrayUtils.isEquals(null, array4)); |
| } |
| |
| /** |
| * Test for {@link ArrayUtils#isNotEmpty(java.lang.Object[])}. |
| */ |
| @Test |
| public void testIsNotEmptyObject() { |
| final Object[] emptyArray = {}; |
| final Object[] notEmptyArray = {"Value"}; |
| assertFalse(ArrayUtils.isNotEmpty((Object[]) null)); |
| assertFalse(ArrayUtils.isNotEmpty(emptyArray)); |
| assertTrue(ArrayUtils.isNotEmpty(notEmptyArray)); |
| } |
| |
| /** |
| * Tests for {@link ArrayUtils#isNotEmpty(long[])}, |
| * {@link ArrayUtils#isNotEmpty(int[])}, |
| * {@link ArrayUtils#isNotEmpty(short[])}, |
| * {@link ArrayUtils#isNotEmpty(char[])}, |
| * {@link ArrayUtils#isNotEmpty(byte[])}, |
| * {@link ArrayUtils#isNotEmpty(double[])}, |
| * {@link ArrayUtils#isNotEmpty(float[])} and |
| * {@link ArrayUtils#isNotEmpty(boolean[])}. |
| */ |
| @Test |
| public void testIsNotEmptyPrimitives() { |
| final long[] emptyLongArray = {}; |
| final long[] notEmptyLongArray = {1L}; |
| assertFalse(ArrayUtils.isNotEmpty((long[]) null)); |
| assertFalse(ArrayUtils.isNotEmpty(emptyLongArray)); |
| assertTrue(ArrayUtils.isNotEmpty(notEmptyLongArray)); |
| |
| final int[] emptyIntArray = {}; |
| final int[] notEmptyIntArray = {1}; |
| assertFalse(ArrayUtils.isNotEmpty((int[]) null)); |
| assertFalse(ArrayUtils.isNotEmpty(emptyIntArray)); |
| assertTrue(ArrayUtils.isNotEmpty(notEmptyIntArray)); |
| |
| final short[] emptyShortArray = {}; |
| final short[] notEmptyShortArray = {1}; |
| assertFalse(ArrayUtils.isNotEmpty((short[]) null)); |
| assertFalse(ArrayUtils.isNotEmpty(emptyShortArray)); |
| assertTrue(ArrayUtils.isNotEmpty(notEmptyShortArray)); |
| |
| final char[] emptyCharArray = {}; |
| final char[] notEmptyCharArray = {1}; |
| assertFalse(ArrayUtils.isNotEmpty((char[]) null)); |
| assertFalse(ArrayUtils.isNotEmpty(emptyCharArray)); |
| assertTrue(ArrayUtils.isNotEmpty(notEmptyCharArray)); |
| |
| final byte[] emptyByteArray = {}; |
| final byte[] notEmptyByteArray = {1}; |
| assertFalse(ArrayUtils.isNotEmpty((byte[]) null)); |
| assertFalse(ArrayUtils.isNotEmpty(emptyByteArray)); |
| assertTrue(ArrayUtils.isNotEmpty(notEmptyByteArray)); |
| |
| final double[] emptyDoubleArray = {}; |
| final double[] notEmptyDoubleArray = {1.0}; |
| assertFalse(ArrayUtils.isNotEmpty((double[]) null)); |
| assertFalse(ArrayUtils.isNotEmpty(emptyDoubleArray)); |
| assertTrue(ArrayUtils.isNotEmpty(notEmptyDoubleArray)); |
| |
| final float[] emptyFloatArray = {}; |
| final float[] notEmptyFloatArray = {1.0F}; |
| assertFalse(ArrayUtils.isNotEmpty((float[]) null)); |
| assertFalse(ArrayUtils.isNotEmpty(emptyFloatArray)); |
| assertTrue(ArrayUtils.isNotEmpty(notEmptyFloatArray)); |
| |
| final boolean[] emptyBooleanArray = {}; |
| final boolean[] notEmptyBooleanArray = {true}; |
| assertFalse(ArrayUtils.isNotEmpty((boolean[]) null)); |
| assertFalse(ArrayUtils.isNotEmpty(emptyBooleanArray)); |
| assertTrue(ArrayUtils.isNotEmpty(notEmptyBooleanArray)); |
| } |
| |
| @Test |
| public void testIsSorted() { |
| Integer[] array = null; |
| assertTrue(ArrayUtils.isSorted(array)); |
| |
| array = new Integer[]{1}; |
| assertTrue(ArrayUtils.isSorted(array)); |
| |
| array = new Integer[]{1, 2, 3}; |
| assertTrue(ArrayUtils.isSorted(array)); |
| |
| array = new Integer[]{1, 3, 2}; |
| assertFalse(ArrayUtils.isSorted(array)); |
| } |
| |
| @Test |
| public void testIsSortedBool() { |
| boolean[] array = null; |
| assertTrue(ArrayUtils.isSorted(array)); |
| |
| array = new boolean[]{true}; |
| assertTrue(ArrayUtils.isSorted(array)); |
| |
| array = new boolean[]{false, true}; |
| assertTrue(ArrayUtils.isSorted(array)); |
| |
| array = new boolean[]{true, false}; |
| assertFalse(ArrayUtils.isSorted(array)); |
| } |
| |
| @Test |
| public void testIsSortedByte() { |
| byte[] array = null; |
| assertTrue(ArrayUtils.isSorted(array)); |
| |
| array = new byte[]{0x10}; |
| assertTrue(ArrayUtils.isSorted(array)); |
| |
| array = new byte[]{0x10, 0x20, 0x30}; |
| assertTrue(ArrayUtils.isSorted(array)); |
| |
| array = new byte[]{0x10, 0x30, 0x20}; |
| assertFalse(ArrayUtils.isSorted(array)); |
| } |
| |
| @Test |
| public void testIsSortedChar() { |
| char[] array = null; |
| assertTrue(ArrayUtils.isSorted(array)); |
| |
| array = new char[]{'a'}; |
| assertTrue(ArrayUtils.isSorted(array)); |
| |
| array = new char[]{'a', 'b', 'c'}; |
| assertTrue(ArrayUtils.isSorted(array)); |
| |
| array = new char[]{'a', 'c', 'b'}; |
| assertFalse(ArrayUtils.isSorted(array)); |
| } |
| |
| @Test |
| public void testIsSortedComparator() { |
| final Comparator<Integer> c = Comparator.reverseOrder(); |
| |
| Integer[] array = null; |
| assertTrue(ArrayUtils.isSorted(array, c)); |
| |
| array = new Integer[]{1}; |
| assertTrue(ArrayUtils.isSorted(array, c)); |
| |
| array = new Integer[]{3, 2, 1}; |
| assertTrue(ArrayUtils.isSorted(array, c)); |
| |
| array = new Integer[]{1, 3, 2}; |
| assertFalse(ArrayUtils.isSorted(array, c)); |
| } |
| |
| @Test |
| public void testIsSortedDouble() { |
| double[] array = null; |
| assertTrue(ArrayUtils.isSorted(array)); |
| |
| array = new double[]{0.0}; |
| assertTrue(ArrayUtils.isSorted(array)); |
| |
| array = new double[]{-1.0, 0.0, 0.1, 0.2}; |
| assertTrue(ArrayUtils.isSorted(array)); |
| |
| array = new double[]{-1.0, 0.2, 0.1, 0.0}; |
| assertFalse(ArrayUtils.isSorted(array)); |
| } |
| |
| @Test |
| public void testIsSortedFloat() { |
| float[] array = null; |
| assertTrue(ArrayUtils.isSorted(array)); |
| |
| array = new float[]{0f}; |
| assertTrue(ArrayUtils.isSorted(array)); |
| |
| array = new float[]{-1f, 0f, 0.1f, 0.2f}; |
| assertTrue(ArrayUtils.isSorted(array)); |
| |
| array = new float[]{-1f, 0.2f, 0.1f, 0f}; |
| assertFalse(ArrayUtils.isSorted(array)); |
| } |
| |
| @Test |
| public void testIsSortedInt() { |
| int[] array = null; |
| assertTrue(ArrayUtils.isSorted(array)); |
| |
| array = new int[]{1}; |
| assertTrue(ArrayUtils.isSorted(array)); |
| |
| array = new int[]{1, 2, 3}; |
| assertTrue(ArrayUtils.isSorted(array)); |
| |
| array = new int[]{1, 3, 2}; |
| assertFalse(ArrayUtils.isSorted(array)); |
| } |
| |
| @Test |
| public void testIsSortedLong() { |
| long[] array = null; |
| assertTrue(ArrayUtils.isSorted(array)); |
| |
| array = new long[]{0L}; |
| assertTrue(ArrayUtils.isSorted(array)); |
| |
| array = new long[]{-1L, 0L, 1L}; |
| assertTrue(ArrayUtils.isSorted(array)); |
| |
| array = new long[]{-1L, 1L, 0L}; |
| assertFalse(ArrayUtils.isSorted(array)); |
| } |
| |
| @Test |
| public void testIsSortedNullComparator() { |
| assertThrows(IllegalArgumentException.class, () -> ArrayUtils.isSorted(null, null)); |
| } |
| |
| @Test |
| public void testIsSortedShort() { |
| short[] array = null; |
| assertTrue(ArrayUtils.isSorted(array)); |
| |
| array = new short[]{0}; |
| assertTrue(ArrayUtils.isSorted(array)); |
| |
| array = new short[]{-1, 0, 1}; |
| assertTrue(ArrayUtils.isSorted(array)); |
| |
| array = new short[]{-1, 1, 0}; |
| assertFalse(ArrayUtils.isSorted(array)); |
| } |
| |
| @Test |
| public void testLastIndexOf() { |
| final Object[] array = {"0", "1", "2", "3", null, "0"}; |
| assertEquals(-1, ArrayUtils.lastIndexOf(null, null)); |
| assertEquals(-1, ArrayUtils.lastIndexOf(null, "0")); |
| assertEquals(5, ArrayUtils.lastIndexOf(array, "0")); |
| assertEquals(1, ArrayUtils.lastIndexOf(array, "1")); |
| assertEquals(2, ArrayUtils.lastIndexOf(array, "2")); |
| assertEquals(3, ArrayUtils.lastIndexOf(array, "3")); |
| assertEquals(4, ArrayUtils.lastIndexOf(array, null)); |
| assertEquals(-1, ArrayUtils.lastIndexOf(array, "notInArray")); |
| } |
| |
| @Test |
| public void testLastIndexOfBoolean() { |
| boolean[] array = null; |
| assertEquals(-1, ArrayUtils.lastIndexOf(array, true)); |
| array = new boolean[0]; |
| assertEquals(-1, ArrayUtils.lastIndexOf(array, true)); |
| array = new boolean[]{true, false, true}; |
| assertEquals(2, ArrayUtils.lastIndexOf(array, true)); |
| assertEquals(1, ArrayUtils.lastIndexOf(array, false)); |
| array = new boolean[]{true, true}; |
| assertEquals(-1, ArrayUtils.lastIndexOf(array, false)); |
| } |
| |
| @Test |
| public void testLastIndexOfBooleanWithStartIndex() { |
| boolean[] array = null; |
| assertEquals(-1, ArrayUtils.lastIndexOf(array, true, 2)); |
| array = new boolean[0]; |
| assertEquals(-1, ArrayUtils.lastIndexOf(array, true, 2)); |
| array = new boolean[]{true, false, true}; |
| assertEquals(2, ArrayUtils.lastIndexOf(array, true, 2)); |
| assertEquals(0, ArrayUtils.lastIndexOf(array, true, 1)); |
| assertEquals(1, ArrayUtils.lastIndexOf(array, false, 2)); |
| assertEquals(-1, ArrayUtils.lastIndexOf(array, true, -1)); |
| array = new boolean[]{true, true}; |
| assertEquals(-1, ArrayUtils.lastIndexOf(array, false, 2)); |
| assertEquals(-1, ArrayUtils.lastIndexOf(array, true, -1)); |
| } |
| |
| @Test |
| public void testLastIndexOfByte() { |
| byte[] array = null; |
| assertEquals(-1, ArrayUtils.lastIndexOf(array, (byte) 0)); |
| array = new byte[]{0, 1, 2, 3, 0}; |
| assertEquals(4, ArrayUtils.lastIndexOf(array, (byte) 0)); |
| assertEquals(1, ArrayUtils.lastIndexOf(array, (byte) 1)); |
| assertEquals(2, ArrayUtils.lastIndexOf(array, (byte) 2)); |
| assertEquals(3, ArrayUtils.lastIndexOf(array, (byte) 3)); |
| assertEquals(-1, ArrayUtils.lastIndexOf(array, (byte) 99)); |
| } |
| |
| @Test |
| public void testLastIndexOfByteWithStartIndex() { |
| byte[] array = null; |
| assertEquals(-1, ArrayUtils.lastIndexOf(array, (byte) 0, 2)); |
| array = new byte[]{0, 1, 2, 3, 0}; |
| assertEquals(0, ArrayUtils.lastIndexOf(array, (byte) 0, 2)); |
| assertEquals(1, ArrayUtils.lastIndexOf(array, (byte) 1, 2)); |
| assertEquals(2, ArrayUtils.lastIndexOf(array, (byte) 2, 2)); |
| assertEquals(-1, ArrayUtils.lastIndexOf(array, (byte) 3, 2)); |
| assertEquals(-1, ArrayUtils.lastIndexOf(array, (byte) 3, -1)); |
| assertEquals(-1, ArrayUtils.lastIndexOf(array, (byte) 99)); |
| assertEquals(4, ArrayUtils.lastIndexOf(array, (byte) 0, 88)); |
| } |
| |
| @Test |
| public void testLastIndexOfChar() { |
| char[] array = null; |
| assertEquals(-1, ArrayUtils.lastIndexOf(array, 'a')); |
| array = new char[]{'a', 'b', 'c', 'd', 'a'}; |
| assertEquals(4, ArrayUtils.lastIndexOf(array, 'a')); |
| assertEquals(1, ArrayUtils.lastIndexOf(array, 'b')); |
| assertEquals(2, ArrayUtils.lastIndexOf(array, 'c')); |
| assertEquals(3, ArrayUtils.lastIndexOf(array, 'd')); |
| assertEquals(-1, ArrayUtils.lastIndexOf(array, 'e')); |
| } |
| |
| @Test |
| public void testLastIndexOfCharWithStartIndex() { |
| char[] array = null; |
| assertEquals(-1, ArrayUtils.lastIndexOf(array, 'a', 2)); |
| array = new char[]{'a', 'b', 'c', 'd', 'a'}; |
| assertEquals(0, ArrayUtils.lastIndexOf(array, 'a', 2)); |
| assertEquals(1, ArrayUtils.lastIndexOf(array, 'b', 2)); |
| assertEquals(2, ArrayUtils.lastIndexOf(array, 'c', 2)); |
| assertEquals(-1, ArrayUtils.lastIndexOf(array, 'd', 2)); |
| assertEquals(-1, ArrayUtils.lastIndexOf(array, 'd', -1)); |
| assertEquals(-1, ArrayUtils.lastIndexOf(array, 'e')); |
| assertEquals(4, ArrayUtils.lastIndexOf(array, 'a', 88)); |
| } |
| |
| @SuppressWarnings("cast") |
| @Test |
| public void testLastIndexOfDouble() { |
| double[] array = null; |
| assertEquals(-1, ArrayUtils.lastIndexOf(array, (double) 0)); |
| array = new double[0]; |
| assertEquals(-1, ArrayUtils.lastIndexOf(array, (double) 0)); |
| array = new double[]{0, 1, 2, 3, 0}; |
| assertEquals(4, ArrayUtils.lastIndexOf(array, (double) 0)); |
| assertEquals(1, ArrayUtils.lastIndexOf(array, (double) 1)); |
| assertEquals(2, ArrayUtils.lastIndexOf(array, (double) 2)); |
| assertEquals(3, ArrayUtils.lastIndexOf(array, (double) 3)); |
| assertEquals(-1, ArrayUtils.lastIndexOf(array, (double) 99)); |
| } |
| |
| @SuppressWarnings("cast") |
| @Test |
| public void testLastIndexOfDoubleTolerance() { |
| double[] array = null; |
| assertEquals(-1, ArrayUtils.lastIndexOf(array, (double) 0, (double) 0)); |
| array = new double[0]; |
| assertEquals(-1, ArrayUtils.lastIndexOf(array, (double) 0, (double) 0)); |
| array = new double[]{0, 1, 2, 3, 0}; |
| assertEquals(4, ArrayUtils.lastIndexOf(array, (double) 0, 0.3)); |
| assertEquals(2, ArrayUtils.lastIndexOf(array, 2.2, 0.35)); |
| assertEquals(3, ArrayUtils.lastIndexOf(array, 4.15, 2.0)); |
| assertEquals(1, ArrayUtils.lastIndexOf(array, 1.00001324, 0.0001)); |
| } |
| |
| @SuppressWarnings("cast") |
| @Test |
| public void testLastIndexOfDoubleWithStartIndex() { |
| double[] array = null; |
| assertEquals(-1, ArrayUtils.lastIndexOf(array, (double) 0, 2)); |
| array = new double[0]; |
| assertEquals(-1, ArrayUtils.lastIndexOf(array, (double) 0, 2)); |
| array = new double[]{0, 1, 2, 3, 0}; |
| assertEquals(0, ArrayUtils.lastIndexOf(array, (double) 0, 2)); |
| assertEquals(1, ArrayUtils.lastIndexOf(array, (double) 1, 2)); |
| assertEquals(2, ArrayUtils.lastIndexOf(array, (double) 2, 2)); |
| assertEquals(-1, ArrayUtils.lastIndexOf(array, (double) 3, 2)); |
| assertEquals(-1, ArrayUtils.lastIndexOf(array, (double) 3, -1)); |
| assertEquals(-1, ArrayUtils.lastIndexOf(array, (double) 99)); |
| assertEquals(4, ArrayUtils.lastIndexOf(array, (double) 0, 88)); |
| } |
| |
| @SuppressWarnings("cast") |
| @Test |
| public void testLastIndexOfDoubleWithStartIndexTolerance() { |
| double[] array = null; |
| assertEquals(-1, ArrayUtils.lastIndexOf(array, (double) 0, 2, (double) 0)); |
| array = new double[0]; |
| assertEquals(-1, ArrayUtils.lastIndexOf(array, (double) 0, 2, (double) 0)); |
| array = new double[]{(double) 3}; |
| assertEquals(-1, ArrayUtils.lastIndexOf(array, (double) 1, 0, (double) 0)); |
| array = new double[]{0, 1, 2, 3, 0}; |
| assertEquals(4, ArrayUtils.lastIndexOf(array, (double) 0, 99, 0.3)); |
| assertEquals(0, ArrayUtils.lastIndexOf(array, (double) 0, 3, 0.3)); |
| assertEquals(2, ArrayUtils.lastIndexOf(array, 2.2, 3, 0.35)); |
| assertEquals(3, ArrayUtils.lastIndexOf(array, 4.15, array.length, 2.0)); |
| assertEquals(1, ArrayUtils.lastIndexOf(array, 1.00001324, array.length, 0.0001)); |
| assertEquals(-1, ArrayUtils.lastIndexOf(array, 4.15, -200, 2.0)); |
| } |
| |
| @SuppressWarnings("cast") |
| @Test |
| public void testLastIndexOfFloat() { |
| float[] array = null; |
| assertEquals(-1, ArrayUtils.lastIndexOf(array, (float) 0)); |
| array = new float[0]; |
| assertEquals(-1, ArrayUtils.lastIndexOf(array, (float) 0)); |
| array = new float[]{0, 1, 2, 3, 0}; |
| assertEquals(4, ArrayUtils.lastIndexOf(array, (float) 0)); |
| assertEquals(1, ArrayUtils.lastIndexOf(array, (float) 1)); |
| assertEquals(2, ArrayUtils.lastIndexOf(array, (float) 2)); |
| assertEquals(3, ArrayUtils.lastIndexOf(array, (float) 3)); |
| assertEquals(-1, ArrayUtils.lastIndexOf(array, (float) 99)); |
| } |
| |
| @SuppressWarnings("cast") |
| @Test |
| public void testLastIndexOfFloatWithStartIndex() { |
| float[] array = null; |
| assertEquals(-1, ArrayUtils.lastIndexOf(array, (float) 0, 2)); |
| array = new float[0]; |
| assertEquals(-1, ArrayUtils.lastIndexOf(array, (float) 0, 2)); |
| array = new float[]{0, 1, 2, 3, 0}; |
| assertEquals(0, ArrayUtils.lastIndexOf(array, (float) 0, 2)); |
| assertEquals(1, ArrayUtils.lastIndexOf(array, (float) 1, 2)); |
| assertEquals(2, ArrayUtils.lastIndexOf(array, (float) 2, 2)); |
| assertEquals(-1, ArrayUtils.lastIndexOf(array, (float) 3, 2)); |
| assertEquals(-1, ArrayUtils.lastIndexOf(array, (float) 3, -1)); |
| assertEquals(-1, ArrayUtils.lastIndexOf(array, (float) 99)); |
| assertEquals(4, ArrayUtils.lastIndexOf(array, (float) 0, 88)); |
| } |
| |
| @Test |
| public void testLastIndexOfInt() { |
| int[] array = null; |
| assertEquals(-1, ArrayUtils.lastIndexOf(array, 0)); |
| array = new int[]{0, 1, 2, 3, 0}; |
| assertEquals(4, ArrayUtils.lastIndexOf(array, 0)); |
| assertEquals(1, ArrayUtils.lastIndexOf(array, 1)); |
| assertEquals(2, ArrayUtils.lastIndexOf(array, 2)); |
| assertEquals(3, ArrayUtils.lastIndexOf(array, 3)); |
| assertEquals(-1, ArrayUtils.lastIndexOf(array, 99)); |
| } |
| |
| @Test |
| public void testLastIndexOfIntWithStartIndex() { |
| int[] array = null; |
| assertEquals(-1, ArrayUtils.lastIndexOf(array, 0, 2)); |
| array = new int[]{0, 1, 2, 3, 0}; |
| assertEquals(0, ArrayUtils.lastIndexOf(array, 0, 2)); |
| assertEquals(1, ArrayUtils.lastIndexOf(array, 1, 2)); |
| assertEquals(2, ArrayUtils.lastIndexOf(array, 2, 2)); |
| assertEquals(-1, ArrayUtils.lastIndexOf(array, 3, 2)); |
| assertEquals(-1, ArrayUtils.lastIndexOf(array, 3, -1)); |
| assertEquals(-1, ArrayUtils.lastIndexOf(array, 99)); |
| assertEquals(4, ArrayUtils.lastIndexOf(array, 0, 88)); |
| } |
| |
| @Test |
| public void testLastIndexOfLong() { |
| long[] array = null; |
| assertEquals(-1, ArrayUtils.lastIndexOf(array, 0)); |
| array = new long[]{0, 1, 2, 3, 0}; |
| assertEquals(4, ArrayUtils.lastIndexOf(array, 0)); |
| assertEquals(1, ArrayUtils.lastIndexOf(array, 1)); |
| assertEquals(2, ArrayUtils.lastIndexOf(array, 2)); |
| assertEquals(3, ArrayUtils.lastIndexOf(array, 3)); |
| assertEquals(-1, ArrayUtils.lastIndexOf(array, 99)); |
| } |
| |
| @Test |
| public void testLastIndexOfLongWithStartIndex() { |
| long[] array = null; |
| assertEquals(-1, ArrayUtils.lastIndexOf(array, 0, 2)); |
| array = new long[]{0, 1, 2, 3, 0}; |
| assertEquals(0, ArrayUtils.lastIndexOf(array, 0, 2)); |
| assertEquals(1, ArrayUtils.lastIndexOf(array, 1, 2)); |
| assertEquals(2, ArrayUtils.lastIndexOf(array, 2, 2)); |
| assertEquals(-1, ArrayUtils.lastIndexOf(array, 3, 2)); |
| assertEquals(-1, ArrayUtils.lastIndexOf(array, 3, -1)); |
| assertEquals(-1, ArrayUtils.lastIndexOf(array, 99, 4)); |
| assertEquals(4, ArrayUtils.lastIndexOf(array, 0, 88)); |
| } |
| |
| @Test |
| public void testLastIndexOfShort() { |
| short[] array = null; |
| assertEquals(-1, ArrayUtils.lastIndexOf(array, (short) 0)); |
| array = new short[]{0, 1, 2, 3, 0}; |
| assertEquals(4, ArrayUtils.lastIndexOf(array, (short) 0)); |
| assertEquals(1, ArrayUtils.lastIndexOf(array, (short) 1)); |
| assertEquals(2, ArrayUtils.lastIndexOf(array, (short) 2)); |
| assertEquals(3, ArrayUtils.lastIndexOf(array, (short) 3)); |
| assertEquals(-1, ArrayUtils.lastIndexOf(array, (short) 99)); |
| } |
| |
| @Test |
| public void testLastIndexOfShortWithStartIndex() { |
| short[] array = null; |
| assertEquals(-1, ArrayUtils.lastIndexOf(array, (short) 0, 2)); |
| array = new short[]{0, 1, 2, 3, 0}; |
| assertEquals(0, ArrayUtils.lastIndexOf(array, (short) 0, 2)); |
| assertEquals(1, ArrayUtils.lastIndexOf(array, (short) 1, 2)); |
| assertEquals(2, ArrayUtils.lastIndexOf(array, (short) 2, 2)); |
| assertEquals(-1, ArrayUtils.lastIndexOf(array, (short) 3, 2)); |
| assertEquals(-1, ArrayUtils.lastIndexOf(array, (short) 3, -1)); |
| assertEquals(-1, ArrayUtils.lastIndexOf(array, (short) 99)); |
| assertEquals(4, ArrayUtils.lastIndexOf(array, (short) 0, 88)); |
| } |
| |
| @Test |
| public void testLastIndexOfWithStartIndex() { |
| final Object[] array = {"0", "1", "2", "3", null, "0"}; |
| assertEquals(-1, ArrayUtils.lastIndexOf(null, null, 2)); |
| assertEquals(-1, ArrayUtils.lastIndexOf(null, "0", 2)); |
| assertEquals(0, ArrayUtils.lastIndexOf(array, "0", 2)); |
| assertEquals(1, ArrayUtils.lastIndexOf(array, "1", 2)); |
| assertEquals(2, ArrayUtils.lastIndexOf(array, "2", 2)); |
| assertEquals(-1, ArrayUtils.lastIndexOf(array, "3", 2)); |
| assertEquals(-1, ArrayUtils.lastIndexOf(array, "3", -1)); |
| assertEquals(4, ArrayUtils.lastIndexOf(array, null, 5)); |
| assertEquals(-1, ArrayUtils.lastIndexOf(array, null, 2)); |
| assertEquals(-1, ArrayUtils.lastIndexOf(array, "notInArray", 5)); |
| |
| assertEquals(-1, ArrayUtils.lastIndexOf(array, null, -1)); |
| assertEquals(5, ArrayUtils.lastIndexOf(array, "0", 88)); |
| } |
| |
| @Test |
| public void testNullToEmptyBoolean() { |
| final boolean[] original = {true, false}; |
| assertEquals(original, ArrayUtils.nullToEmpty(original)); |
| } |
| |
| @Test |
| public void testNullToEmptyBooleanEmptyArray() { |
| final boolean[] empty = {}; |
| final boolean[] result = ArrayUtils.nullToEmpty(empty); |
| assertEquals(ArrayUtils.EMPTY_BOOLEAN_ARRAY, result); |
| assertNotSame(empty, result); |
| } |
| |
| @Test |
| public void testNullToEmptyBooleanNull() { |
| assertEquals(ArrayUtils.EMPTY_BOOLEAN_ARRAY, ArrayUtils.nullToEmpty((boolean[]) null)); |
| } |
| |
| @Test |
| public void testNullToEmptyBooleanObject() { |
| final Boolean[] original = {Boolean.TRUE, Boolean.FALSE}; |
| assertArrayEquals(original, ArrayUtils.nullToEmpty(original)); |
| } |
| |
| @Test |
| public void testNullToEmptyBooleanObjectEmptyArray() { |
| final Boolean[] empty = {}; |
| final Boolean[] result = ArrayUtils.nullToEmpty(empty); |
| assertArrayEquals(ArrayUtils.EMPTY_BOOLEAN_OBJECT_ARRAY, result); |
| assertNotSame(empty, result); |
| } |
| |
| @Test |
| public void testNullToEmptyBooleanObjectNull() { |
| assertArrayEquals(ArrayUtils.EMPTY_BOOLEAN_OBJECT_ARRAY, ArrayUtils.nullToEmpty((Boolean[]) null)); |
| } |
| |
| @Test |
| public void testNullToEmptyByte() { |
| final byte[] original = {0x0F, 0x0E}; |
| assertEquals(original, ArrayUtils.nullToEmpty(original)); |
| } |
| |
| @Test |
| public void testNullToEmptyByteEmptyArray() { |
| final byte[] empty = {}; |
| final byte[] result = ArrayUtils.nullToEmpty(empty); |
| assertEquals(ArrayUtils.EMPTY_BYTE_ARRAY, result); |
| assertNotSame(empty, result); |
| } |
| |
| @Test |
| public void testNullToEmptyByteNull() { |
| assertEquals(ArrayUtils.EMPTY_BYTE_ARRAY, ArrayUtils.nullToEmpty((byte[]) null)); |
| } |
| |
| @Test |
| public void testNullToEmptyByteObject() { |
| final Byte[] original = {0x0F, 0x0E}; |
| assertArrayEquals(original, ArrayUtils.nullToEmpty(original)); |
| } |
| |
| @Test |
| public void testNullToEmptyByteObjectEmptyArray() { |
| final Byte[] empty = {}; |
| final Byte[] result = ArrayUtils.nullToEmpty(empty); |
| assertArrayEquals(ArrayUtils.EMPTY_BYTE_OBJECT_ARRAY, result); |
| assertNotSame(empty, result); |
| } |
| |
| @Test |
| public void testNullToEmptyByteObjectNull() { |
| assertArrayEquals(ArrayUtils.EMPTY_BYTE_OBJECT_ARRAY, ArrayUtils.nullToEmpty((Byte[]) null)); |
| } |
| |
| @Test |
| public void testNullToEmptyChar() { |
| final char[] original = {'a', 'b'}; |
| assertEquals(original, ArrayUtils.nullToEmpty(original)); |
| } |
| |
| @Test |
| public void testNullToEmptyCharEmptyArray() { |
| final char[] empty = {}; |
| final char[] result = ArrayUtils.nullToEmpty(empty); |
| assertEquals(ArrayUtils.EMPTY_CHAR_ARRAY, result); |
| assertNotSame(empty, result); |
| } |
| |
| @Test |
| public void testNullToEmptyCharNull() { |
| assertEquals(ArrayUtils.EMPTY_CHAR_ARRAY, ArrayUtils.nullToEmpty((char[]) null)); |
| } |
| |
| @Test |
| public void testNullToEmptyCharObject() { |
| final Character[] original = {'a', 'b'}; |
| assertArrayEquals(original, ArrayUtils.nullToEmpty(original)); |
| } |
| |
| @Test |
| public void testNullToEmptyCharObjectEmptyArray() { |
| final Character[] empty = {}; |
| final Character[] result = ArrayUtils.nullToEmpty(empty); |
| assertArrayEquals(ArrayUtils.EMPTY_CHARACTER_OBJECT_ARRAY, result); |
| assertNotSame(empty, result); |
| } |
| |
| @Test |
| public void testNUllToEmptyCharObjectNull() { |
| assertArrayEquals(ArrayUtils.EMPTY_CHARACTER_OBJECT_ARRAY, ArrayUtils.nullToEmpty((Character[]) null)); |
| } |
| |
| @Test |
| public void testNullToEmptyClass() { |
| final Class<?>[] original = {Object.class, String.class}; |
| assertArrayEquals(original, ArrayUtils.nullToEmpty(original)); |
| } |
| |
| @Test |
| public void testNullToEmptyClassEmptyArray() { |
| final Class<?>[] empty = {}; |
| final Class<?>[] result = ArrayUtils.nullToEmpty(empty); |
| assertArrayEquals(ArrayUtils.EMPTY_CLASS_ARRAY, result); |
| assertNotSame(empty, result); |
| } |
| |
| @Test |
| public void testNullToEmptyClassNull() { |
| assertArrayEquals(ArrayUtils.EMPTY_CLASS_ARRAY, ArrayUtils.nullToEmpty((Class<?>[]) null)); |
| } |
| |
| @Test |
| public void testNullToEmptyDouble() { |
| final double[] original = {1L, 2L}; |
| assertEquals(original, ArrayUtils.nullToEmpty(original)); |
| } |
| |
| @Test |
| public void testNullToEmptyDoubleEmptyArray() { |
| final double[] empty = {}; |
| final double[] result = ArrayUtils.nullToEmpty(empty); |
| assertEquals(ArrayUtils.EMPTY_DOUBLE_ARRAY, result); |
| assertNotSame(empty, result); |
| } |
| |
| @Test |
| public void testNullToEmptyDoubleNull() { |
| assertEquals(ArrayUtils.EMPTY_DOUBLE_ARRAY, ArrayUtils.nullToEmpty((double[]) null)); |
| } |
| |
| @Test |
| public void testNullToEmptyDoubleObject() { |
| final Double[] original = {1D, 2D}; |
| assertArrayEquals(original, ArrayUtils.nullToEmpty(original)); |
| } |
| |
| @Test |
| public void testNullToEmptyDoubleObjectEmptyArray() { |
| final Double[] empty = {}; |
| final Double[] result = ArrayUtils.nullToEmpty(empty); |
| assertArrayEquals(ArrayUtils.EMPTY_DOUBLE_OBJECT_ARRAY, result); |
| assertNotSame(empty, result); |
| } |
| |
| @Test |
| public void testNullToEmptyDoubleObjectNull() { |
| assertArrayEquals(ArrayUtils.EMPTY_DOUBLE_OBJECT_ARRAY, ArrayUtils.nullToEmpty((Double[]) null)); |
| } |
| |
| @Test |
| public void testNullToEmptyFloat() { |
| final float[] original = {2.6f, 3.8f}; |
| assertEquals(original, ArrayUtils.nullToEmpty(original)); |
| } |
| |
| @Test |
| public void testNullToEmptyFloatEmptyArray() { |
| final float[] empty = {}; |
| final float[] result = ArrayUtils.nullToEmpty(empty); |
| assertEquals(ArrayUtils.EMPTY_FLOAT_ARRAY, result); |
| assertNotSame(empty, result); |
| } |
| |
| @Test |
| public void testNullToEmptyFloatNull() { |
| assertEquals(ArrayUtils.EMPTY_FLOAT_ARRAY, ArrayUtils.nullToEmpty((float[]) null)); |
| } |
| |
| @Test |
| public void testNullToEmptyFloatObject() { |
| final Float[] original = {2.6f, 3.8f}; |
| assertArrayEquals(original, ArrayUtils.nullToEmpty(original)); |
| } |
| |
| @Test |
| public void testNullToEmptyFloatObjectEmptyArray() { |
| final Float[] empty = {}; |
| final Float[] result = ArrayUtils.nullToEmpty(empty); |
| assertArrayEquals(ArrayUtils.EMPTY_FLOAT_OBJECT_ARRAY, result); |
| assertNotSame(empty, result); |
| } |
| |
| @Test |
| public void testNullToEmptyFloatObjectNull() { |
| assertArrayEquals(ArrayUtils.EMPTY_FLOAT_OBJECT_ARRAY, ArrayUtils.nullToEmpty((Float[]) null)); |
| } |
| |
| @Test |
| public void testNullToEmptyGeneric() { |
| final TestClass[] input = {new TestClass(), new TestClass()}; |
| final TestClass[] output = ArrayUtils.nullToEmpty(input, TestClass[].class); |
| |
| assertSame(input, output); |
| } |
| |
| @Test |
| public void testNullToEmptyGenericEmpty() { |
| final TestClass[] input = {}; |
| final TestClass[] output = ArrayUtils.nullToEmpty(input, TestClass[].class); |
| |
| assertSame(input, output); |
| } |
| |
| @Test |
| public void testNullToEmptyGenericNull() { |
| final TestClass[] output = ArrayUtils.nullToEmpty(null, TestClass[].class); |
| |
| assertNotNull(output); |
| assertEquals(0, output.length); |
| } |
| |
| @Test |
| public void testNullToEmptyGenericNullType() { |
| final TestClass[] input = {}; |
| assertThrows(IllegalArgumentException.class, () -> ArrayUtils.nullToEmpty(input, null)); |
| } |
| |
| @Test |
| public void testNullToEmptyInt() { |
| final int[] original = {1, 2}; |
| assertEquals(original, ArrayUtils.nullToEmpty(original)); |
| } |
| |
| @Test |
| public void testNullToEmptyIntEmptyArray() { |
| final int[] empty = {}; |
| final int[] result = ArrayUtils.nullToEmpty(empty); |
| assertEquals(ArrayUtils.EMPTY_INT_ARRAY, result); |
| assertNotSame(empty, result); |
| } |
| |
| @Test |
| public void testNullToEmptyIntNull() { |
| assertEquals(ArrayUtils.EMPTY_INT_ARRAY, ArrayUtils.nullToEmpty((int[]) null)); |
| } |
| |
| @Test |
| public void testNullToEmptyIntObject() { |
| final Integer[] original = {1, 2}; |
| assertArrayEquals(original, ArrayUtils.nullToEmpty(original)); |
| } |
| |
| @Test |
| public void testNullToEmptyIntObjectEmptyArray() { |
| final Integer[] empty = {}; |
| final Integer[] result = ArrayUtils.nullToEmpty(empty); |
| assertArrayEquals(ArrayUtils.EMPTY_INTEGER_OBJECT_ARRAY, result); |
| assertNotSame(empty, result); |
| } |
| |
| @Test |
| public void testNullToEmptyIntObjectNull() { |
| assertArrayEquals(ArrayUtils.EMPTY_INTEGER_OBJECT_ARRAY, ArrayUtils.nullToEmpty((Integer[]) null)); |
| } |
| |
| @Test |
| public void testNullToEmptyLong() { |
| final long[] original = {1L, 2L}; |
| assertEquals(original, ArrayUtils.nullToEmpty(original)); |
| } |
| |
| @Test |
| public void testNullToEmptyLongEmptyArray() { |
| final long[] empty = {}; |
| final long[] result = ArrayUtils.nullToEmpty(empty); |
| assertEquals(ArrayUtils.EMPTY_LONG_ARRAY, result); |
| assertNotSame(empty, result); |
| } |
| |
| @Test |
| public void testNullToEmptyLongNull() { |
| assertEquals(ArrayUtils.EMPTY_LONG_ARRAY, ArrayUtils.nullToEmpty((long[]) null)); |
| } |
| |
| @Test |
| public void testNullToEmptyLongObject() { |
| @SuppressWarnings("boxing") final Long[] original = {1L, 2L}; |
| assertArrayEquals(original, ArrayUtils.nullToEmpty(original)); |
| } |
| |
| @Test |
| public void testNullToEmptyLongObjectEmptyArray() { |
| final Long[] empty = {}; |
| final Long[] result = ArrayUtils.nullToEmpty(empty); |
| assertArrayEquals(ArrayUtils.EMPTY_LONG_OBJECT_ARRAY, result); |
| assertNotSame(empty, result); |
| } |
| |
| @Test |
| public void testNullToEmptyLongObjectNull() { |
| assertArrayEquals(ArrayUtils.EMPTY_LONG_OBJECT_ARRAY, ArrayUtils.nullToEmpty((Long[]) null)); |
| } |
| |
| @Test |
| public void testNullToEmptyObject() { |
| final Object[] original = {Boolean.TRUE, Boolean.FALSE}; |
| assertArrayEquals(original, ArrayUtils.nullToEmpty(original)); |
| } |
| |
| @Test |
| public void testNullToEmptyObjectEmptyArray() { |
| final Object[] empty = {}; |
| final Object[] result = ArrayUtils.nullToEmpty(empty); |
| assertArrayEquals(ArrayUtils.EMPTY_OBJECT_ARRAY, result); |
| assertNotSame(empty, result); |
| } |
| |
| @Test |
| public void testNullToEmptyObjectNull() { |
| assertArrayEquals(ArrayUtils.EMPTY_OBJECT_ARRAY, ArrayUtils.nullToEmpty((Object[]) null)); |
| } |
| |
| @Test |
| public void testNullToEmptyShort() { |
| final short[] original = {1, 2}; |
| assertEquals(original, ArrayUtils.nullToEmpty(original)); |
| } |
| |
| @Test |
| public void testNullToEmptyShortEmptyArray() { |
| final short[] empty = {}; |
| final short[] result = ArrayUtils.nullToEmpty(empty); |
| assertEquals(ArrayUtils.EMPTY_SHORT_ARRAY, result); |
| assertNotSame(empty, result); |
| } |
| |
| @Test |
| public void testNullToEmptyShortNull() { |
| assertEquals(ArrayUtils.EMPTY_SHORT_ARRAY, ArrayUtils.nullToEmpty((short[]) null)); |
| } |
| |
| @Test |
| public void testNullToEmptyShortObject() { |
| @SuppressWarnings("boxing") final Short[] original = {1, 2}; |
| assertArrayEquals(original, ArrayUtils.nullToEmpty(original)); |
| } |
| |
| @Test |
| public void testNullToEmptyShortObjectEmptyArray() { |
| final Short[] empty = {}; |
| final Short[] result = ArrayUtils.nullToEmpty(empty); |
| assertArrayEquals(ArrayUtils.EMPTY_SHORT_OBJECT_ARRAY, result); |
| assertNotSame(empty, result); |
| } |
| |
| @Test |
| public void testNullToEmptyShortObjectNull() { |
| assertArrayEquals(ArrayUtils.EMPTY_SHORT_OBJECT_ARRAY, ArrayUtils.nullToEmpty((Short[]) null)); |
| } |
| |
| @Test |
| public void testNullToEmptyString() { |
| final String[] original = {"abc", "def"}; |
| assertArrayEquals(original, ArrayUtils.nullToEmpty(original)); |
| } |
| |
| @Test |
| public void testNullToEmptyStringEmptyArray() { |
| final String[] empty = {}; |
| final String[] result = ArrayUtils.nullToEmpty(empty); |
| assertArrayEquals(ArrayUtils.EMPTY_STRING_ARRAY, result); |
| assertNotSame(empty, result); |
| } |
| |
| @Test |
| public void testNullToEmptyStringNull() { |
| assertArrayEquals(ArrayUtils.EMPTY_STRING_ARRAY, ArrayUtils.nullToEmpty((String[]) null)); |
| } |
| |
| @Test |
| public void testReverse() { |
| final StringBuffer str1 = new StringBuffer("pick"); |
| final String str2 = "a"; |
| final String[] str3 = {"stick"}; |
| final String str4 = "up"; |
| |
| Object[] array = {str1, str2, str3}; |
| ArrayUtils.reverse(array); |
| assertEquals(array[0], str3); |
| assertEquals(array[1], str2); |
| assertEquals(array[2], str1); |
| |
| array = new Object[]{str1, str2, str3, str4}; |
| ArrayUtils.reverse(array); |
| assertEquals(array[0], str4); |
| assertEquals(array[1], str3); |
| assertEquals(array[2], str2); |
| assertEquals(array[3], str1); |
| |
| array = null; |
| ArrayUtils.reverse(array); |
| assertArrayEquals(null, array); |
| } |
| |
| @Test |
| public void testReverseBoolean() { |
| boolean[] array = {false, false, true}; |
| ArrayUtils.reverse(array); |
| assertTrue(array[0]); |
| assertFalse(array[1]); |
| assertFalse(array[2]); |
| |
| array = null; |
| ArrayUtils.reverse(array); |
| assertNull(array); |
| } |
| |
| @Test |
| public void testReverseBooleanRange() { |
| boolean[] array = {false, false, true}; |
| // The whole array |
| ArrayUtils.reverse(array, 0, 3); |
| assertTrue(array[0]); |
| assertFalse(array[1]); |
| assertFalse(array[2]); |
| // a range |
| array = new boolean[]{false, false, true}; |
| ArrayUtils.reverse(array, 0, 2); |
| assertFalse(array[0]); |
| assertFalse(array[1]); |
| assertTrue(array[2]); |
| // a range with a negative start |
| array = new boolean[]{false, false, true}; |
| ArrayUtils.reverse(array, -1, 3); |
| assertTrue(array[0]); |
| assertFalse(array[1]); |
| assertFalse(array[2]); |
| // a range with a large stop index |
| array = new boolean[]{false, false, true}; |
| ArrayUtils.reverse(array, -1, array.length + 1000); |
| assertTrue(array[0]); |
| assertFalse(array[1]); |
| assertFalse(array[2]); |
| // null |
| array = null; |
| ArrayUtils.reverse(array, 0, 3); |
| assertNull(array); |
| } |
| |
| @Test |
| public void testReverseByte() { |
| byte[] array = {2, 3, 4}; |
| ArrayUtils.reverse(array); |
| assertEquals(array[0], 4); |
| assertEquals(array[1], 3); |
| assertEquals(array[2], 2); |
| |
| array = null; |
| ArrayUtils.reverse(array); |
| assertNull(array); |
| } |
| |
| @Test |
| public void testReverseByteRange() { |
| byte[] array = {1, 2, 3}; |
| // The whole array |
| ArrayUtils.reverse(array, 0, 3); |
| assertEquals(3, array[0]); |
| assertEquals(2, array[1]); |
| assertEquals(1, array[2]); |
| // a range |
| array = new byte[]{1, 2, 3}; |
| ArrayUtils.reverse(array, 0, 2); |
| assertEquals(2, array[0]); |
| assertEquals(1, array[1]); |
| assertEquals(3, array[2]); |
| // a range with a negative start |
| array = new byte[]{1, 2, 3}; |
| ArrayUtils.reverse(array, -1, 3); |
| assertEquals(3, array[0]); |
| assertEquals(2, array[1]); |
| assertEquals(1, array[2]); |
| // a range with a large stop index |
| array = new byte[]{1, 2, 3}; |
| ArrayUtils.reverse(array, -1, array.length + 1000); |
| assertEquals(3, array[0]); |
| assertEquals(2, array[1]); |
| assertEquals(1, array[2]); |
| // null |
| array = null; |
| ArrayUtils.reverse(array, 0, 3); |
| assertNull(array); |
| } |
| |
| @Test |
| public void testReverseChar() { |
| char[] array = {'a', 'f', 'C'}; |
| ArrayUtils.reverse(array); |
| assertEquals(array[0], 'C'); |
| assertEquals(array[1], 'f'); |
| assertEquals(array[2], 'a'); |
| |
| array = null; |
| ArrayUtils.reverse(array); |
| assertNull(array); |
| } |
| |
| @Test |
| public void testReverseCharRange() { |
| char[] array = {1, 2, 3}; |
| // The whole array |
| ArrayUtils.reverse(array, 0, 3); |
| assertEquals(3, array[0]); |
| assertEquals(2, array[1]); |
| assertEquals(1, array[2]); |
| // a range |
| array = new char[]{1, 2, 3}; |
| ArrayUtils.reverse(array, 0, 2); |
| assertEquals(2, array[0]); |
| assertEquals(1, array[1]); |
| assertEquals(3, array[2]); |
| // a range with a negative start |
| array = new char[]{1, 2, 3}; |
| ArrayUtils.reverse(array, -1, 3); |
| assertEquals(3, array[0]); |
| assertEquals(2, array[1]); |
| assertEquals(1, array[2]); |
| // a range with a large stop index |
| array = new char[]{1, 2, 3}; |
| ArrayUtils.reverse(array, -1, array.length + 1000); |
| assertEquals(3, array[0]); |
| assertEquals(2, array[1]); |
| assertEquals(1, array[2]); |
| // null |
| array = null; |
| ArrayUtils.reverse(array, 0, 3); |
| assertNull(array); |
| } |
| |
| @Test |
| public void testReverseDouble() { |
| double[] array = {0.3d, 0.4d, 0.5d}; |
| ArrayUtils.reverse(array); |
| assertEquals(0.5d, array[0]); |
| assertEquals(0.4d, array[1]); |
| assertEquals(0.3d, array[2]); |
| |
| array = null; |
| ArrayUtils.reverse(array); |
| assertNull(array); |
| } |
| |
| @Test |
| public void testReverseDoubleRange() { |
| double[] array = {1, 2, 3}; |
| // The whole array |
| ArrayUtils.reverse(array, 0, 3); |
| assertEquals(3, array[0]); |
| assertEquals(2, array[1]); |
| assertEquals(1, array[2]); |
| // a range |
| array = new double[]{1, 2, 3}; |
| ArrayUtils.reverse(array, 0, 2); |
| assertEquals(2, array[0]); |
| assertEquals(1, array[1]); |
| assertEquals(3, array[2]); |
| // a range with a negative start |
| array = new double[]{1, 2, 3}; |
| ArrayUtils.reverse(array, -1, 3); |
| assertEquals(3, array[0]); |
| assertEquals(2, array[1]); |
| assertEquals(1, array[2]); |
| // a range with a large stop index |
| array = new double[]{1, 2, 3}; |
| ArrayUtils.reverse(array, -1, array.length + 1000); |
| assertEquals(3, array[0]); |
| assertEquals(2, array[1]); |
| assertEquals(1, array[2]); |
| // null |
| array = null; |
| ArrayUtils.reverse(array, 0, 3); |
| assertNull(array); |
| } |
| |
| @Test |
| public void testReverseFloat() { |
| float[] array = {0.3f, 0.4f, 0.5f}; |
| ArrayUtils.reverse(array); |
| assertEquals(0.5f, array[0]); |
| assertEquals(0.4f, array[1]); |
| assertEquals(0.3f, array[2]); |
| |
| array = null; |
| ArrayUtils.reverse(array); |
| assertNull(array); |
| } |
| |
| @Test |
| public void testReverseFloatRange() { |
| float[] array = {1, 2, 3}; |
| // The whole array |
| ArrayUtils.reverse(array, 0, 3); |
| assertEquals(3, array[0]); |
| assertEquals(2, array[1]); |
| assertEquals(1, array[2]); |
| // a range |
| array = new float[]{1, 2, 3}; |
| ArrayUtils.reverse(array, 0, 2); |
| assertEquals(2, array[0]); |
| assertEquals(1, array[1]); |
| assertEquals(3, array[2]); |
| // a range with a negative start |
| array = new float[]{1, 2, 3}; |
| ArrayUtils.reverse(array, -1, 3); |
| assertEquals(3, array[0]); |
| assertEquals(2, array[1]); |
| assertEquals(1, array[2]); |
| // a range with a large stop index |
| array = new float[]{1, 2, 3}; |
| ArrayUtils.reverse(array, -1, array.length + 1000); |
| assertEquals(3, array[0]); |
| assertEquals(2, array[1]); |
| assertEquals(1, array[2]); |
| // null |
| array = null; |
| ArrayUtils.reverse(array, 0, 3); |
| assertNull(array); |
| } |
| |
| @Test |
| public void testReverseInt() { |
| int[] array = {1, 2, 3}; |
| ArrayUtils.reverse(array); |
| assertEquals(array[0], 3); |
| assertEquals(array[1], 2); |
| assertEquals(array[2], 1); |
| |
| array = null; |
| ArrayUtils.reverse(array); |
| assertNull(array); |
| } |
| |
| @Test |
| public void testReverseIntRange() { |
| int[] array = {1, 2, 3}; |
| // The whole array |
| ArrayUtils.reverse(array, 0, 3); |
| assertEquals(3, array[0]); |
| assertEquals(2, array[1]); |
| assertEquals(1, array[2]); |
| // a range |
| array = new int[]{1, 2, 3}; |
| ArrayUtils.reverse(array, 0, 2); |
| assertEquals(2, array[0]); |
| assertEquals(1, array[1]); |
| assertEquals(3, array[2]); |
| // a range with a negative start |
| array = new int[]{1, 2, 3}; |
| ArrayUtils.reverse(array, -1, 3); |
| assertEquals(3, array[0]); |
| assertEquals(2, array[1]); |
| assertEquals(1, array[2]); |
| // a range with a large stop index |
| array = new int[]{1, 2, 3}; |
| ArrayUtils.reverse(array, -1, array.length + 1000); |
| assertEquals(3, array[0]); |
| assertEquals(2, array[1]); |
| assertEquals(1, array[2]); |
| // null |
| array = null; |
| ArrayUtils.reverse(array, 0, 3); |
| assertNull(array); |
| } |
| |
| @Test |
| public void testReverseLong() { |
| long[] array = {1L, 2L, 3L}; |
| ArrayUtils.reverse(array); |
| assertEquals(array[0], 3L); |
| assertEquals(array[1], 2L); |
| assertEquals(array[2], 1L); |
| |
| array = null; |
| ArrayUtils.reverse(array); |
| assertNull(array); |
| } |
| |
| @Test |
| public void testReverseLongRange() { |
| long[] array = {1, 2, 3}; |
| // The whole array |
| ArrayUtils.reverse(array, 0, 3); |
| assertEquals(3, array[0]); |
| assertEquals(2, array[1]); |
| assertEquals(1, array[2]); |
| // a range |
| array = new long[]{1, 2, 3}; |
| ArrayUtils.reverse(array, 0, 2); |
| assertEquals(2, array[0]); |
| assertEquals(1, array[1]); |
| assertEquals(3, array[2]); |
| // a range with a negative start |
| array = new long[]{1, 2, 3}; |
| ArrayUtils.reverse(array, -1, 3); |
| assertEquals(3, array[0]); |
| assertEquals(2, array[1]); |
| assertEquals(1, array[2]); |
| // a range with a large stop index |
| array = new long[]{1, 2, 3}; |
| ArrayUtils.reverse(array, -1, array.length + 1000); |
| assertEquals(3, array[0]); |
| assertEquals(2, array[1]); |
| assertEquals(1, array[2]); |
| // null |
| array = null; |
| ArrayUtils.reverse(array, 0, 3); |
| assertNull(array); |
| } |
| |
| @Test |
| public void testReverseObjectRange() { |
| String[] array = {"1", "2", "3"}; |
| // The whole array |
| ArrayUtils.reverse(array, 0, 3); |
| assertEquals("3", array[0]); |
| assertEquals("2", array[1]); |
| assertEquals("1", array[2]); |
| // a range |
| array = new String[]{"1", "2", "3"}; |
| ArrayUtils.reverse(array, 0, 2); |
| assertEquals("2", array[0]); |
| assertEquals("1", array[1]); |
| assertEquals("3", array[2]); |
| // a range with a negative start |
| array = new String[]{"1", "2", "3"}; |
| ArrayUtils.reverse(array, -1, 3); |
| assertEquals("3", array[0]); |
| assertEquals("2", array[1]); |
| assertEquals("1", array[2]); |
| // a range with a large stop index |
| array = new String[]{"1", "2", "3"}; |
| ArrayUtils.reverse(array, -1, array.length + 1000); |
| assertEquals("3", array[0]); |
| assertEquals("2", array[1]); |
| assertEquals("1", array[2]); |
| // null |
| array = null; |
| ArrayUtils.reverse(array, 0, 3); |
| assertNull(array); |
| } |
| |
| @Test |
| public void testReverseShort() { |
| short[] array = {1, 2, 3}; |
| ArrayUtils.reverse(array); |
| assertEquals(array[0], 3); |
| assertEquals(array[1], 2); |
| assertEquals(array[2], 1); |
| |
| array = null; |
| ArrayUtils.reverse(array); |
| assertNull(array); |
| } |
| |
| @Test |
| public void testReverseShortRange() { |
| short[] array = {1, 2, 3}; |
| // The whole array |
| ArrayUtils.reverse(array, 0, 3); |
| assertEquals(3, array[0]); |
| assertEquals(2, array[1]); |
| assertEquals(1, array[2]); |
| // a range |
| array = new short[]{1, 2, 3}; |
| ArrayUtils.reverse(array, 0, 2); |
| assertEquals(2, array[0]); |
| assertEquals(1, array[1]); |
| assertEquals(3, array[2]); |
| // a range with a negative start |
| array = new short[]{1, 2, 3}; |
| ArrayUtils.reverse(array, -1, 3); |
| assertEquals(3, array[0]); |
| assertEquals(2, array[1]); |
| assertEquals(1, array[2]); |
| // a range with a large stop index |
| array = new short[]{1, 2, 3}; |
| ArrayUtils.reverse(array, -1, array.length + 1000); |
| assertEquals(3, array[0]); |
| assertEquals(2, array[1]); |
| assertEquals(1, array[2]); |
| // null |
| array = null; |
| ArrayUtils.reverse(array, 0, 3); |
| assertNull(array); |
| } |
| |
| @Test |
| public void testSameLength() { |
| final Object[] nullArray = null; |
| final Object[] emptyArray = {}; |
| final Object[] oneArray = {"pick"}; |
| final Object[] twoArray = {"pick", "stick"}; |
| |
| assertTrue(ArrayUtils.isSameLength(nullArray, nullArray)); |
| assertTrue(ArrayUtils.isSameLength(nullArray, emptyArray)); |
| assertFalse(ArrayUtils.isSameLength(nullArray, oneArray)); |
| assertFalse(ArrayUtils.isSameLength(nullArray, twoArray)); |
| |
| assertTrue(ArrayUtils.isSameLength(emptyArray, nullArray)); |
| assertTrue(ArrayUtils.isSameLength(emptyArray, emptyArray)); |
| assertFalse(ArrayUtils.isSameLength(emptyArray, oneArray)); |
| assertFalse(ArrayUtils.isSameLength(emptyArray, twoArray)); |
| |
| assertFalse(ArrayUtils.isSameLength(oneArray, nullArray)); |
| assertFalse(ArrayUtils.isSameLength(oneArray, emptyArray)); |
| assertTrue(ArrayUtils.isSameLength(oneArray, oneArray)); |
| assertFalse(ArrayUtils.isSameLength(oneArray, twoArray)); |
| |
| assertFalse(ArrayUtils.isSameLength(twoArray, nullArray)); |
| assertFalse(ArrayUtils.isSameLength(twoArray, emptyArray)); |
| assertFalse(ArrayUtils.isSameLength(twoArray, oneArray)); |
| assertTrue(ArrayUtils.isSameLength(twoArray, twoArray)); |
| } |
| |
| @Test |
| public void testSameLengthAll() { |
| final Object[] nullArrayObject = null; |
| final Object[] emptyArrayObject = {}; |
| final Object[] oneArrayObject = {"pick"}; |
| final Object[] twoArrayObject = {"pick", "stick"}; |
| final boolean[] nullArrayBoolean = null; |
| final boolean[] emptyArrayBoolean = {}; |
| final boolean[] oneArrayBoolean = {true}; |
| final boolean[] twoArrayBoolean = {true, false}; |
| final long[] nullArrayLong = null; |
| final long[] emptyArrayLong = {}; |
| final long[] oneArrayLong = {0L}; |
| final long[] twoArrayLong = {0L, 76L}; |
| final int[] nullArrayInt = null; |
| final int[] emptyArrayInt = {}; |
| final int[] oneArrayInt = {4}; |
| final int[] twoArrayInt = {5, 7}; |
| final short[] nullArrayShort = null; |
| final short[] emptyArrayShort = {}; |
| final short[] oneArrayShort = {4}; |
| final short[] twoArrayShort = {6, 8}; |
| final char[] nullArrayChar = null; |
| final char[] emptyArrayChar = {}; |
| final char[] oneArrayChar = {'f'}; |
| final char[] twoArrayChar = {'d', 't'}; |
| final byte[] nullArrayByte = null; |
| final byte[] emptyArrayByte = {}; |
| final byte[] oneArrayByte = {3}; |
| final byte[] twoArrayByte = {4, 6}; |
| final double[] nullArrayDouble = null; |
| final double[] emptyArrayDouble = {}; |
| final double[] oneArrayDouble = {1.3d}; |
| final double[] twoArrayDouble = {4.5d, 6.3d}; |
| final float[] nullArrayFloat = null; |
| final float[] emptyArrayFloat = {}; |
| final float[] oneArrayFloat = {2.5f}; |
| final float[] twoArrayFloat = {6.4f, 5.8f}; |
| assertTrue(ArrayUtils.isSameLength(nullArrayObject, nullArrayObject)); |
| assertTrue(ArrayUtils.isSameLength(nullArrayObject, nullArrayBoolean)); |
| assertTrue(ArrayUtils.isSameLength(nullArrayObject, nullArrayLong)); |
| assertTrue(ArrayUtils.isSameLength(nullArrayObject, nullArrayInt)); |
| assertTrue(ArrayUtils.isSameLength(nullArrayObject, nullArrayShort)); |
| assertTrue(ArrayUtils.isSameLength(nullArrayObject, nullArrayChar)); |
| assertTrue(ArrayUtils.isSameLength(nullArrayObject, nullArrayByte)); |
| assertTrue(ArrayUtils.isSameLength(nullArrayObject, nullArrayDouble)); |
| assertTrue(ArrayUtils.isSameLength(nullArrayObject, nullArrayFloat)); |
| assertTrue(ArrayUtils.isSameLength(nullArrayBoolean, nullArrayObject)); |
| assertTrue(ArrayUtils.isSameLength(nullArrayBoolean, nullArrayBoolean)); |
| assertTrue(ArrayUtils.isSameLength(nullArrayBoolean, nullArrayLong)); |
| assertTrue(ArrayUtils.isSameLength(nullArrayBoolean, nullArrayInt)); |
| assertTrue(ArrayUtils.isSameLength(nullArrayBoolean, nullArrayShort)); |
| assertTrue(ArrayUtils.isSameLength(nullArrayBoolean, nullArrayChar)); |
| assertTrue(ArrayUtils.isSameLength(nullArrayBoolean, nullArrayByte)); |
| assertTrue(ArrayUtils.isSameLength(nullArrayBoolean, nullArrayDouble)); |
| assertTrue(ArrayUtils.isSameLength(nullArrayBoolean, nullArrayFloat)); |
| assertTrue(ArrayUtils.isSameLength(nullArrayLong, nullArrayObject)); |
| assertTrue(ArrayUtils.isSameLength(nullArrayLong, nullArrayBoolean)); |
| assertTrue(ArrayUtils.isSameLength(nullArrayLong, nullArrayLong)); |
| assertTrue(ArrayUtils.isSameLength(nullArrayLong, nullArrayInt)); |
| assertTrue(ArrayUtils.isSameLength(nullArrayLong, nullArrayShort)); |
| assertTrue(ArrayUtils.isSameLength(nullArrayLong, nullArrayChar)); |
| assertTrue(ArrayUtils.isSameLength(nullArrayLong, nullArrayByte)); |
| assertTrue(ArrayUtils.isSameLength(nullArrayLong, nullArrayDouble)); |
| assertTrue(ArrayUtils.isSameLength(nullArrayLong, nullArrayFloat)); |
| assertTrue(ArrayUtils.isSameLength(nullArrayInt, nullArrayObject)); |
| assertTrue(ArrayUtils.isSameLength(nullArrayInt, nullArrayBoolean)); |
| assertTrue(ArrayUtils.isSameLength(nullArrayInt, nullArrayLong)); |
| assertTrue(ArrayUtils.isSameLength(nullArrayInt, nullArrayInt)); |
| assertTrue(ArrayUtils.isSameLength(nullArrayInt, nullArrayShort)); |
| assertTrue(ArrayUtils.isSameLength(nullArrayInt, nullArrayChar)); |
| assertTrue(ArrayUtils.isSameLength(nullArrayInt, nullArrayByte)); |
| assertTrue(ArrayUtils.isSameLength(nullArrayInt, nullArrayDouble)); |
| assertTrue(ArrayUtils.isSameLength(nullArrayInt, nullArrayFloat)); |
| assertTrue(ArrayUtils.isSameLength(nullArrayShort, nullArrayObject)); |
| assertTrue(ArrayUtils.isSameLength(nullArrayShort, nullArrayBoolean)); |
| assertTrue(ArrayUtils.isSameLength(nullArrayShort, nullArrayLong)); |
| assertTrue(ArrayUtils.isSameLength(nullArrayShort, nullArrayInt)); |
| assertTrue(ArrayUtils.isSameLength(nullArrayShort, nullArrayShort)); |
| assertTrue(ArrayUtils.isSameLength(nullArrayShort, nullArrayChar)); |
| assertTrue(ArrayUtils.isSameLength(nullArrayShort, nullArrayByte)); |
| assertTrue(ArrayUtils.isSameLength(nullArrayShort, nullArrayDouble)); |
| assertTrue(ArrayUtils.isSameLength(nullArrayShort, nullArrayFloat)); |
| assertTrue(ArrayUtils.isSameLength(nullArrayChar, nullArrayObject)); |
| assertTrue(ArrayUtils.isSameLength(nullArrayChar, nullArrayBoolean)); |
| assertTrue(ArrayUtils.isSameLength(nullArrayChar, nullArrayLong)); |
| assertTrue(ArrayUtils.isSameLength(nullArrayChar, nullArrayInt)); |
| assertTrue(ArrayUtils.isSameLength(nullArrayChar, nullArrayShort)); |
| assertTrue(ArrayUtils.isSameLength(nullArrayChar, nullArrayChar)); |
| assertTrue(ArrayUtils.isSameLength(nullArrayChar, nullArrayByte)); |
| assertTrue(ArrayUtils.isSameLength(nullArrayChar, nullArrayDouble)); |
| assertTrue(ArrayUtils.isSameLength(nullArrayChar, nullArrayFloat)); |
| assertTrue(ArrayUtils.isSameLength(nullArrayByte, nullArrayObject)); |
| assertTrue(ArrayUtils.isSameLength(nullArrayByte, nullArrayBoolean)); |
| assertTrue(ArrayUtils.isSameLength(nullArrayByte, nullArrayLong)); |
| assertTrue(ArrayUtils.isSameLength(nullArrayByte, nullArrayInt)); |
| assertTrue(ArrayUtils.isSameLength(nullArrayByte, nullArrayShort)); |
| assertTrue(ArrayUtils.isSameLength(nullArrayByte, nullArrayChar)); |
| assertTrue(ArrayUtils.isSameLength(nullArrayByte, nullArrayByte)); |
| assertTrue(ArrayUtils.isSameLength(nullArrayByte, nullArrayDouble)); |
| assertTrue(ArrayUtils.isSameLength(nullArrayByte, nullArrayFloat)); |
| assertTrue(ArrayUtils.isSameLength(nullArrayDouble, nullArrayObject)); |
| assertTrue(ArrayUtils.isSameLength(nullArrayDouble, nullArrayBoolean)); |
| assertTrue(ArrayUtils.isSameLength(nullArrayDouble, nullArrayLong)); |
| assertTrue(ArrayUtils.isSameLength(nullArrayDouble, nullArrayInt)); |
| assertTrue(ArrayUtils.isSameLength(nullArrayDouble, nullArrayShort)); |
| assertTrue(ArrayUtils.isSameLength(nullArrayDouble, nullArrayChar)); |
| assertTrue(ArrayUtils.isSameLength(nullArrayDouble, nullArrayByte)); |
| assertTrue(ArrayUtils.isSameLength(nullArrayDouble, nullArrayDouble)); |
| assertTrue(ArrayUtils.isSameLength(nullArrayDouble, nullArrayFloat)); |
| assertTrue(ArrayUtils.isSameLength(nullArrayFloat, nullArrayObject)); |
| assertTrue(ArrayUtils.isSameLength(nullArrayFloat, nullArrayBoolean)); |
| assertTrue(ArrayUtils.isSameLength(nullArrayFloat, nullArrayLong)); |
| assertTrue(ArrayUtils.isSameLength(nullArrayFloat, nullArrayInt)); |
| assertTrue(ArrayUtils.isSameLength(nullArrayFloat, nullArrayShort)); |
| assertTrue(ArrayUtils.isSameLength(nullArrayFloat, nullArrayChar)); |
| assertTrue(ArrayUtils.isSameLength(nullArrayFloat, nullArrayByte)); |
| assertTrue(ArrayUtils.isSameLength(nullArrayFloat, nullArrayDouble)); |
| assertTrue(ArrayUtils.isSameLength(nullArrayFloat, nullArrayFloat)); |
| assertTrue(ArrayUtils.isSameLength(nullArrayObject, emptyArrayObject)); |
| assertTrue(ArrayUtils.isSameLength(nullArrayObject, emptyArrayBoolean)); |
| assertTrue(ArrayUtils.isSameLength(nullArrayObject, emptyArrayLong)); |
| assertTrue(ArrayUtils.isSameLength(nullArrayObject, emptyArrayInt)); |
| assertTrue(ArrayUtils.isSameLength(nullArrayObject, emptyArrayShort)); |
| assertTrue(ArrayUtils.isSameLength(nullArrayObject, emptyArrayChar)); |
| assertTrue(ArrayUtils.isSameLength(nullArrayObject, emptyArrayByte)); |
| assertTrue(ArrayUtils.isSameLength(nullArrayObject, emptyArrayDouble)); |
| assertTrue(ArrayUtils.isSameLength(nullArrayObject, emptyArrayFloat)); |
| assertTrue(ArrayUtils.isSameLength(nullArrayBoolean, emptyArrayObject)); |
| assertTrue(ArrayUtils.isSameLength(nullArrayBoolean, emptyArrayBoolean)); |
| assertTrue(ArrayUtils.isSameLength(nullArrayBoolean, emptyArrayLong)); |
| assertTrue(ArrayUtils.isSameLength(nullArrayBoolean, emptyArrayInt)); |
| assertTrue(ArrayUtils.isSameLength(nullArrayBoolean, emptyArrayShort)); |
| assertTrue(ArrayUtils.isSameLength(nullArrayBoolean, emptyArrayChar)); |
| assertTrue(ArrayUtils.isSameLength(nullArrayBoolean, emptyArrayByte)); |
| assertTrue(ArrayUtils.isSameLength(nullArrayBoolean, emptyArrayDouble)); |
| assertTrue(ArrayUtils.isSameLength(nullArrayBoolean, emptyArrayFloat)); |
| assertTrue(ArrayUtils.isSameLength(nullArrayLong, emptyArrayObject)); |
| assertTrue(ArrayUtils.isSameLength(nullArrayLong, emptyArrayBoolean)); |
| assertTrue(ArrayUtils.isSameLength(nullArrayLong, emptyArrayLong)); |
| assertTrue(ArrayUtils.isSameLength(nullArrayLong, emptyArrayInt)); |
| assertTrue(ArrayUtils.isSameLength(nullArrayLong, emptyArrayShort)); |
| assertTrue(ArrayUtils.isSameLength(nullArrayLong, emptyArrayChar)); |
| assertTrue(ArrayUtils.isSameLength(nullArrayLong, emptyArrayByte)); |
| assertTrue(ArrayUtils.isSameLength(nullArrayLong, emptyArrayDouble)); |
| assertTrue(ArrayUtils.isSameLength(nullArrayLong, emptyArrayFloat)); |
| assertTrue(ArrayUtils.isSameLength(nullArrayInt, emptyArrayObject)); |
| assertTrue(ArrayUtils.isSameLength(nullArrayInt, emptyArrayBoolean)); |
| assertTrue(ArrayUtils.isSameLength(nullArrayInt, emptyArrayLong)); |
| assertTrue(ArrayUtils.isSameLength(nullArrayInt, emptyArrayInt)); |
| assertTrue(ArrayUtils.isSameLength(nullArrayInt, emptyArrayShort)); |
| assertTrue(ArrayUtils.isSameLength(nullArrayInt, emptyArrayChar)); |
| assertTrue(ArrayUtils.isSameLength(nullArrayInt, emptyArrayByte)); |
| assertTrue(ArrayUtils.isSameLength(nullArrayInt, emptyArrayDouble)); |
| assertTrue(ArrayUtils.isSameLength(nullArrayInt, emptyArrayFloat)); |
| assertTrue(ArrayUtils.isSameLength(nullArrayShort, emptyArrayObject)); |
| assertTrue(ArrayUtils.isSameLength(nullArrayShort, emptyArrayBoolean)); |
| assertTrue(ArrayUtils.isSameLength(nullArrayShort, emptyArrayLong)); |
| assertTrue(ArrayUtils.isSameLength(nullArrayShort, emptyArrayInt)); |
| assertTrue(ArrayUtils.isSameLength(nullArrayShort, emptyArrayShort)); |
| assertTrue(ArrayUtils.isSameLength(nullArrayShort, emptyArrayChar)); |
| assertTrue(ArrayUtils.isSameLength(nullArrayShort, emptyArrayByte)); |
| assertTrue(ArrayUtils.isSameLength(nullArrayShort, emptyArrayDouble)); |
| assertTrue(ArrayUtils.isSameLength(nullArrayShort, emptyArrayFloat)); |
| assertTrue(ArrayUtils.isSameLength(nullArrayChar, emptyArrayObject)); |
| assertTrue(ArrayUtils.isSameLength(nullArrayChar, emptyArrayBoolean)); |
| assertTrue(ArrayUtils.isSameLength(nullArrayChar, emptyArrayLong)); |
| assertTrue(ArrayUtils.isSameLength(nullArrayChar, emptyArrayInt)); |
| assertTrue(ArrayUtils.isSameLength(nullArrayChar, emptyArrayShort)); |
| assertTrue(ArrayUtils.isSameLength(nullArrayChar, emptyArrayChar)); |
| assertTrue(ArrayUtils.isSameLength(nullArrayChar, emptyArrayByte)); |
| assertTrue(ArrayUtils.isSameLength(nullArrayChar, emptyArrayDouble)); |
| assertTrue(ArrayUtils.isSameLength(nullArrayChar, emptyArrayFloat)); |
| assertTrue(ArrayUtils.isSameLength(nullArrayByte, emptyArrayObject)); |
| assertTrue(ArrayUtils.isSameLength(nullArrayByte, emptyArrayBoolean)); |
| assertTrue(ArrayUtils.isSameLength(nullArrayByte, emptyArrayLong)); |
| assertTrue(ArrayUtils.isSameLength(nullArrayByte, emptyArrayInt)); |
| assertTrue(ArrayUtils.isSameLength(nullArrayByte, emptyArrayShort)); |
| assertTrue(ArrayUtils.isSameLength(nullArrayByte, emptyArrayChar)); |
| assertTrue(ArrayUtils.isSameLength(nullArrayByte, emptyArrayByte)); |
| assertTrue(ArrayUtils.isSameLength(nullArrayByte, emptyArrayDouble)); |
| assertTrue(ArrayUtils.isSameLength(nullArrayByte, emptyArrayFloat)); |
| assertTrue(ArrayUtils.isSameLength(nullArrayDouble, emptyArrayObject)); |
| assertTrue(ArrayUtils.isSameLength(nullArrayDouble, emptyArrayBoolean)); |
| assertTrue(ArrayUtils.isSameLength(nullArrayDouble, emptyArrayLong)); |
| assertTrue(ArrayUtils.isSameLength(nullArrayDouble, emptyArrayInt)); |
| assertTrue(ArrayUtils.isSameLength(nullArrayDouble, emptyArrayShort)); |
| assertTrue(ArrayUtils.isSameLength(nullArrayDouble, emptyArrayChar)); |
| assertTrue(ArrayUtils.isSameLength(nullArrayDouble, emptyArrayByte)); |
| assertTrue(ArrayUtils.isSameLength(nullArrayDouble, emptyArrayDouble)); |
| assertTrue(ArrayUtils.isSameLength(nullArrayDouble, emptyArrayFloat)); |
| assertTrue(ArrayUtils.isSameLength(nullArrayFloat, emptyArrayObject)); |
| assertTrue(ArrayUtils.isSameLength(nullArrayFloat, emptyArrayBoolean)); |
| assertTrue(ArrayUtils.isSameLength(nullArrayFloat, emptyArrayLong)); |
| assertTrue(ArrayUtils.isSameLength(nullArrayFloat, emptyArrayInt)); |
| assertTrue(ArrayUtils.isSameLength(nullArrayFloat, emptyArrayShort)); |
| assertTrue(ArrayUtils.isSameLength(nullArrayFloat, emptyArrayChar)); |
| assertTrue(ArrayUtils.isSameLength(nullArrayFloat, emptyArrayByte)); |
| assertTrue(ArrayUtils.isSameLength(nullArrayFloat, emptyArrayDouble)); |
| assertTrue(ArrayUtils.isSameLength(nullArrayFloat, emptyArrayFloat)); |
| assertFalse(ArrayUtils.isSameLength(nullArrayObject, oneArrayObject)); |
| assertFalse(ArrayUtils.isSameLength(nullArrayObject, oneArrayBoolean)); |
| assertFalse(ArrayUtils.isSameLength(nullArrayObject, oneArrayLong)); |
| assertFalse(ArrayUtils.isSameLength(nullArrayObject, oneArrayInt)); |
| assertFalse(ArrayUtils.isSameLength(nullArrayObject, oneArrayShort)); |
| assertFalse(ArrayUtils.isSameLength(nullArrayObject, oneArrayChar)); |
| assertFalse(ArrayUtils.isSameLength(nullArrayObject, oneArrayByte)); |
| assertFalse(ArrayUtils.isSameLength(nullArrayObject, oneArrayDouble)); |
| assertFalse(ArrayUtils.isSameLength(nullArrayObject, oneArrayFloat)); |
| assertFalse(ArrayUtils.isSameLength(nullArrayBoolean, oneArrayObject)); |
| assertFalse(ArrayUtils.isSameLength(nullArrayBoolean, oneArrayBoolean)); |
| assertFalse(ArrayUtils.isSameLength(nullArrayBoolean, oneArrayLong)); |
| assertFalse(ArrayUtils.isSameLength(nullArrayBoolean, oneArrayInt)); |
| assertFalse(ArrayUtils.isSameLength(nullArrayBoolean, oneArrayShort)); |
| assertFalse(ArrayUtils.isSameLength(nullArrayBoolean, oneArrayChar)); |
| assertFalse(ArrayUtils.isSameLength(nullArrayBoolean, oneArrayByte)); |
| assertFalse(ArrayUtils.isSameLength(nullArrayBoolean, oneArrayDouble)); |
| assertFalse(ArrayUtils.isSameLength(nullArrayBoolean, oneArrayFloat)); |
| assertFalse(ArrayUtils.isSameLength(nullArrayLong, oneArrayObject)); |
| assertFalse(ArrayUtils.isSameLength(nullArrayLong, oneArrayBoolean)); |
| assertFalse(ArrayUtils.isSameLength(nullArrayLong, oneArrayLong)); |
| assertFalse(ArrayUtils.isSameLength(nullArrayLong, oneArrayInt)); |
| assertFalse(ArrayUtils.isSameLength(nullArrayLong, oneArrayShort)); |
| assertFalse(ArrayUtils.isSameLength(nullArrayLong, oneArrayChar)); |
| assertFalse(ArrayUtils.isSameLength(nullArrayLong, oneArrayByte)); |
| assertFalse(ArrayUtils.isSameLength(nullArrayLong, oneArrayDouble)); |
| assertFalse(ArrayUtils.isSameLength(nullArrayLong, oneArrayFloat)); |
| assertFalse(ArrayUtils.isSameLength(nullArrayInt, oneArrayObject)); |
| assertFalse(ArrayUtils.isSameLength(nullArrayInt, oneArrayBoolean)); |
| assertFalse(ArrayUtils.isSameLength(nullArrayInt, oneArrayLong)); |
| assertFalse(ArrayUtils.isSameLength(nullArrayInt, oneArrayInt)); |
| assertFalse(ArrayUtils.isSameLength(nullArrayInt, oneArrayShort)); |
| assertFalse(ArrayUtils.isSameLength(nullArrayInt, oneArrayChar)); |
| assertFalse(ArrayUtils.isSameLength(nullArrayInt, oneArrayByte)); |
| assertFalse(ArrayUtils.isSameLength(nullArrayInt, oneArrayDouble)); |
| assertFalse(ArrayUtils.isSameLength(nullArrayInt, oneArrayFloat)); |
| assertFalse(ArrayUtils.isSameLength(nullArrayShort, oneArrayObject)); |
| assertFalse(ArrayUtils.isSameLength(nullArrayShort, oneArrayBoolean)); |
| assertFalse(ArrayUtils.isSameLength(nullArrayShort, oneArrayLong)); |
| assertFalse(ArrayUtils.isSameLength(nullArrayShort, oneArrayInt)); |
| assertFalse(ArrayUtils.isSameLength(nullArrayShort, oneArrayShort)); |
| assertFalse(ArrayUtils.isSameLength(nullArrayShort, oneArrayChar)); |
| assertFalse(ArrayUtils.isSameLength(nullArrayShort, oneArrayByte)); |
| assertFalse(ArrayUtils.isSameLength(nullArrayShort, oneArrayDouble)); |
| assertFalse(ArrayUtils.isSameLength(nullArrayShort, oneArrayFloat)); |
| assertFalse(ArrayUtils.isSameLength(nullArrayChar, oneArrayObject)); |
| assertFalse(ArrayUtils.isSameLength(nullArrayChar, oneArrayBoolean)); |
| assertFalse(ArrayUtils.isSameLength(nullArrayChar, oneArrayLong)); |
| assertFalse(ArrayUtils.isSameLength(nullArrayChar, oneArrayInt)); |
| assertFalse(ArrayUtils.isSameLength(nullArrayChar, oneArrayShort)); |
| assertFalse(ArrayUtils.isSameLength(nullArrayChar, oneArrayChar)); |
| assertFalse(ArrayUtils.isSameLength(nullArrayChar, oneArrayByte)); |
| assertFalse(ArrayUtils.isSameLength(nullArrayChar, oneArrayDouble)); |
| assertFalse(ArrayUtils.isSameLength(nullArrayChar, oneArrayFloat)); |
| assertFalse(ArrayUtils.isSameLength(nullArrayByte, oneArrayObject)); |
| assertFalse(ArrayUtils.isSameLength(nullArrayByte, oneArrayBoolean)); |
| assertFalse(ArrayUtils.isSameLength(nullArrayByte, oneArrayLong)); |
| assertFalse(ArrayUtils.isSameLength(nullArrayByte, oneArrayInt)); |
| assertFalse(ArrayUtils.isSameLength(nullArrayByte, oneArrayShort)); |
| assertFalse(ArrayUtils.isSameLength(nullArrayByte, oneArrayChar)); |
| assertFalse(ArrayUtils.isSameLength(nullArrayByte, oneArrayByte)); |
| assertFalse(ArrayUtils.isSameLength(nullArrayByte, oneArrayDouble)); |
| assertFalse(ArrayUtils.isSameLength(nullArrayByte, oneArrayFloat)); |
| assertFalse(ArrayUtils.isSameLength(nullArrayDouble, oneArrayObject)); |
| assertFalse(ArrayUtils.isSameLength(nullArrayDouble, oneArrayBoolean)); |
| assertFalse(ArrayUtils.isSameLength(nullArrayDouble, oneArrayLong)); |
| assertFalse(ArrayUtils.isSameLength(nullArrayDouble, oneArrayInt)); |
| assertFalse(ArrayUtils.isSameLength(nullArrayDouble, oneArrayShort)); |
| assertFalse(ArrayUtils.isSameLength(nullArrayDouble, oneArrayChar)); |
| assertFalse(ArrayUtils.isSameLength(nullArrayDouble, oneArrayByte)); |
| assertFalse(ArrayUtils.isSameLength(nullArrayDouble, oneArrayDouble)); |
| assertFalse(ArrayUtils.isSameLength(nullArrayDouble, oneArrayFloat)); |
| assertFalse(ArrayUtils.isSameLength(nullArrayFloat, oneArrayObject)); |
| assertFalse(ArrayUtils.isSameLength(nullArrayFloat, oneArrayBoolean)); |
| assertFalse(ArrayUtils.isSameLength(nullArrayFloat, oneArrayLong)); |
| assertFalse(ArrayUtils.isSameLength(nullArrayFloat, oneArrayInt)); |
| assertFalse(ArrayUtils.isSameLength(nullArrayFloat, oneArrayShort)); |
| assertFalse(ArrayUtils.isSameLength(nullArrayFloat, oneArrayChar)); |
| assertFalse(ArrayUtils.isSameLength(nullArrayFloat, oneArrayByte)); |
| assertFalse(ArrayUtils.isSameLength(nullArrayFloat, oneArrayDouble)); |
| assertFalse(ArrayUtils.isSameLength(nullArrayFloat, oneArrayFloat)); |
| assertFalse(ArrayUtils.isSameLength(nullArrayObject, twoArrayObject)); |
| assertFalse(ArrayUtils.isSameLength(nullArrayObject, twoArrayBoolean)); |
| assertFalse(ArrayUtils.isSameLength(nullArrayObject, twoArrayLong)); |
| assertFalse(ArrayUtils.isSameLength(nullArrayObject, twoArrayInt)); |
| assertFalse(ArrayUtils.isSameLength(nullArrayObject, twoArrayShort)); |
| assertFalse(ArrayUtils.isSameLength(nullArrayObject, twoArrayChar)); |
| assertFalse(ArrayUtils.isSameLength(nullArrayObject, twoArrayByte)); |
| assertFalse(ArrayUtils.isSameLength(nullArrayObject, twoArrayDouble)); |
| assertFalse(ArrayUtils.isSameLength(nullArrayObject, twoArrayFloat)); |
| assertFalse(ArrayUtils.isSameLength(nullArrayBoolean, twoArrayObject)); |
| assertFalse(ArrayUtils.isSameLength(nullArrayBoolean, twoArrayBoolean)); |
| assertFalse(ArrayUtils.isSameLength(nullArrayBoolean, twoArrayLong)); |
| assertFalse(ArrayUtils.isSameLength(nullArrayBoolean, twoArrayInt)); |
| assertFalse(ArrayUtils.isSameLength(nullArrayBoolean, twoArrayShort)); |
| assertFalse(ArrayUtils.isSameLength(nullArrayBoolean, twoArrayChar)); |
| assertFalse(ArrayUtils.isSameLength(nullArrayBoolean, twoArrayByte)); |
| assertFalse(ArrayUtils.isSameLength(nullArrayBoolean, twoArrayDouble)); |
| assertFalse(ArrayUtils.isSameLength(nullArrayBoolean, twoArrayFloat)); |
| assertFalse(ArrayUtils.isSameLength(nullArrayLong, twoArrayObject)); |
| assertFalse(ArrayUtils.isSameLength(nullArrayLong, twoArrayBoolean)); |
| assertFalse(ArrayUtils.isSameLength(nullArrayLong, twoArrayLong)); |
| assertFalse(ArrayUtils.isSameLength(nullArrayLong, twoArrayInt)); |
| assertFalse(ArrayUtils.isSameLength(nullArrayLong, twoArrayShort)); |
| assertFalse(ArrayUtils.isSameLength(nullArrayLong, twoArrayChar)); |
| assertFalse(ArrayUtils.isSameLength(nullArrayLong, twoArrayByte)); |
| assertFalse(ArrayUtils.isSameLength(nullArrayLong, twoArrayDouble)); |
| assertFalse(ArrayUtils.isSameLength(nullArrayLong, twoArrayFloat)); |
| assertFalse(ArrayUtils.isSameLength(nullArrayInt, twoArrayObject)); |
| assertFalse(ArrayUtils.isSameLength(nullArrayInt, twoArrayBoolean)); |
| assertFalse(ArrayUtils.isSameLength(nullArrayInt, twoArrayLong)); |
| assertFalse(ArrayUtils.isSameLength(nullArrayInt, twoArrayInt)); |
| assertFalse(ArrayUtils.isSameLength(nullArrayInt, twoArrayShort)); |
| assertFalse(ArrayUtils.isSameLength(nullArrayInt, twoArrayChar)); |
| assertFalse(ArrayUtils.isSameLength(nullArrayInt, twoArrayByte)); |
| assertFalse(ArrayUtils.isSameLength(nullArrayInt, twoArrayDouble)); |
| assertFalse(ArrayUtils.isSameLength(nullArrayInt, twoArrayFloat)); |
| assertFalse(ArrayUtils.isSameLength(nullArrayShort, twoArrayObject)); |
| assertFalse(ArrayUtils.isSameLength(nullArrayShort, twoArrayBoolean)); |
| assertFalse(ArrayUtils.isSameLength(nullArrayShort, twoArrayLong)); |
| assertFalse(ArrayUtils.isSameLength(nullArrayShort, twoArrayInt)); |
| assertFalse(ArrayUtils.isSameLength(nullArrayShort, twoArrayShort)); |
| assertFalse(ArrayUtils.isSameLength(nullArrayShort, twoArrayChar)); |
| assertFalse(ArrayUtils.isSameLength(nullArrayShort, twoArrayByte)); |
| assertFalse(ArrayUtils.isSameLength(nullArrayShort, twoArrayDouble)); |
| assertFalse(ArrayUtils.isSameLength(nullArrayShort, twoArrayFloat)); |
| assertFalse(ArrayUtils.isSameLength(nullArrayChar, twoArrayObject)); |
| assertFalse(ArrayUtils.isSameLength(nullArrayChar, twoArrayBoolean)); |
| assertFalse(ArrayUtils.isSameLength(nullArrayChar, twoArrayLong)); |
| assertFalse(ArrayUtils.isSameLength(nullArrayChar, twoArrayInt)); |
| assertFalse(ArrayUtils.isSameLength(nullArrayChar, twoArrayShort)); |
| assertFalse(ArrayUtils.isSameLength(nullArrayChar, twoArrayChar)); |
| assertFalse(ArrayUtils.isSameLength(nullArrayChar, twoArrayByte)); |
| assertFalse(ArrayUtils.isSameLength(nullArrayChar, twoArrayDouble)); |
| assertFalse(ArrayUtils.isSameLength(nullArrayChar, twoArrayFloat)); |
| assertFalse(ArrayUtils.isSameLength(nullArrayByte, twoArrayObject)); |
| assertFalse(ArrayUtils.isSameLength(nullArrayByte, twoArrayBoolean)); |
| assertFalse(ArrayUtils.isSameLength(nullArrayByte, twoArrayLong)); |
| assertFalse(ArrayUtils.isSameLength(nullArrayByte, twoArrayInt)); |
| assertFalse(ArrayUtils.isSameLength(nullArrayByte, twoArrayShort)); |
| assertFalse(ArrayUtils.isSameLength(nullArrayByte, twoArrayChar)); |
| assertFalse(ArrayUtils.isSameLength(nullArrayByte, twoArrayByte)); |
| assertFalse(ArrayUtils.isSameLength(nullArrayByte, twoArrayDouble)); |
| assertFalse(ArrayUtils.isSameLength(nullArrayByte, twoArrayFloat)); |
| assertFalse(ArrayUtils.isSameLength(nullArrayDouble, twoArrayObject)); |
| assertFalse(ArrayUtils.isSameLength(nullArrayDouble, twoArrayBoolean)); |
| assertFalse(ArrayUtils.isSameLength(nullArrayDouble, twoArrayLong)); |
| assertFalse(ArrayUtils.isSameLength(nullArrayDouble, twoArrayInt)); |
| assertFalse(ArrayUtils.isSameLength(nullArrayDouble, twoArrayShort)); |
| assertFalse(ArrayUtils.isSameLength(nullArrayDouble, twoArrayChar)); |
| assertFalse(ArrayUtils.isSameLength(nullArrayDouble, twoArrayByte)); |
| assertFalse(ArrayUtils.isSameLength(nullArrayDouble, twoArrayDouble)); |
| assertFalse(ArrayUtils.isSameLength(nullArrayDouble, twoArrayFloat)); |
| assertFalse(ArrayUtils.isSameLength(nullArrayFloat, twoArrayObject)); |
| assertFalse(ArrayUtils.isSameLength(nullArrayFloat, twoArrayBoolean)); |
| assertFalse(ArrayUtils.isSameLength(nullArrayFloat, twoArrayLong)); |
| assertFalse(ArrayUtils.isSameLength(nullArrayFloat, twoArrayInt)); |
| assertFalse(ArrayUtils.isSameLength(nullArrayFloat, twoArrayShort)); |
| assertFalse(ArrayUtils.isSameLength(nullArrayFloat, twoArrayChar)); |
| assertFalse(ArrayUtils.isSameLength(nullArrayFloat, twoArrayByte)); |
| assertFalse(ArrayUtils.isSameLength(nullArrayFloat, twoArrayDouble)); |
| assertFalse(ArrayUtils.isSameLength(nullArrayFloat, twoArrayFloat)); |
| assertTrue(ArrayUtils.isSameLength(emptyArrayObject, nullArrayObject)); |
| assertTrue(ArrayUtils.isSameLength(emptyArrayObject, nullArrayBoolean)); |
| assertTrue(ArrayUtils.isSameLength(emptyArrayObject, nullArrayLong)); |
| assertTrue(ArrayUtils.isSameLength(emptyArrayObject, nullArrayInt)); |
| assertTrue(ArrayUtils.isSameLength(emptyArrayObject, nullArrayShort)); |
| assertTrue(ArrayUtils.isSameLength(emptyArrayObject, nullArrayChar)); |
| assertTrue(ArrayUtils.isSameLength(emptyArrayObject, nullArrayByte)); |
| assertTrue(ArrayUtils.isSameLength(emptyArrayObject, nullArrayDouble)); |
| assertTrue(ArrayUtils.isSameLength(emptyArrayObject, nullArrayFloat)); |
| assertTrue(ArrayUtils.isSameLength(emptyArrayBoolean, nullArrayObject)); |
| assertTrue(ArrayUtils.isSameLength(emptyArrayBoolean, nullArrayBoolean)); |
| assertTrue(ArrayUtils.isSameLength(emptyArrayBoolean, nullArrayLong)); |
| assertTrue(ArrayUtils.isSameLength(emptyArrayBoolean, nullArrayInt)); |
| assertTrue(ArrayUtils.isSameLength(emptyArrayBoolean, nullArrayShort)); |
| assertTrue(ArrayUtils.isSameLength(emptyArrayBoolean, nullArrayChar)); |
| assertTrue(ArrayUtils.isSameLength(emptyArrayBoolean, nullArrayByte)); |
| assertTrue(ArrayUtils.isSameLength(emptyArrayBoolean, nullArrayDouble)); |
| assertTrue(ArrayUtils.isSameLength(emptyArrayBoolean, nullArrayFloat)); |
| assertTrue(ArrayUtils.isSameLength(emptyArrayLong, nullArrayObject)); |
| assertTrue(ArrayUtils.isSameLength(emptyArrayLong, nullArrayBoolean)); |
| assertTrue(ArrayUtils.isSameLength(emptyArrayLong, nullArrayLong)); |
| assertTrue(ArrayUtils.isSameLength(emptyArrayLong, nullArrayInt)); |
| assertTrue(ArrayUtils.isSameLength(emptyArrayLong, nullArrayShort)); |
| assertTrue(ArrayUtils.isSameLength(emptyArrayLong, nullArrayChar)); |
| assertTrue(ArrayUtils.isSameLength(emptyArrayLong, nullArrayByte)); |
| assertTrue(ArrayUtils.isSameLength(emptyArrayLong, nullArrayDouble)); |
| assertTrue(ArrayUtils.isSameLength(emptyArrayLong, nullArrayFloat)); |
| assertTrue(ArrayUtils.isSameLength(emptyArrayInt, nullArrayObject)); |
| assertTrue(ArrayUtils.isSameLength(emptyArrayInt, nullArrayBoolean)); |
| assertTrue(ArrayUtils.isSameLength(emptyArrayInt, nullArrayLong)); |
| assertTrue(ArrayUtils.isSameLength(emptyArrayInt, nullArrayInt)); |
| assertTrue(ArrayUtils.isSameLength(emptyArrayInt, nullArrayShort)); |
| assertTrue(ArrayUtils.isSameLength(emptyArrayInt, nullArrayChar)); |
| assertTrue(ArrayUtils.isSameLength(emptyArrayInt, nullArrayByte)); |
| assertTrue(ArrayUtils.isSameLength(emptyArrayInt, nullArrayDouble)); |
| assertTrue(ArrayUtils.isSameLength(emptyArrayInt, nullArrayFloat)); |
| assertTrue(ArrayUtils.isSameLength(emptyArrayShort, nullArrayObject)); |
| assertTrue(ArrayUtils.isSameLength(emptyArrayShort, nullArrayBoolean)); |
| assertTrue(ArrayUtils.isSameLength(emptyArrayShort, nullArrayLong)); |
| assertTrue(ArrayUtils.isSameLength(emptyArrayShort, nullArrayInt)); |
| assertTrue(ArrayUtils.isSameLength(emptyArrayShort, nullArrayShort)); |
| assertTrue(ArrayUtils.isSameLength(emptyArrayShort, nullArrayChar)); |
| assertTrue(ArrayUtils.isSameLength(emptyArrayShort, nullArrayByte)); |
| assertTrue(ArrayUtils.isSameLength(emptyArrayShort, nullArrayDouble)); |
| assertTrue(ArrayUtils.isSameLength(emptyArrayShort, nullArrayFloat)); |
| assertTrue(ArrayUtils.isSameLength(emptyArrayChar, nullArrayObject)); |
| assertTrue(ArrayUtils.isSameLength(emptyArrayChar, nullArrayBoolean)); |
| assertTrue(ArrayUtils.isSameLength(emptyArrayChar, nullArrayLong)); |
| assertTrue(ArrayUtils.isSameLength(emptyArrayChar, nullArrayInt)); |
| assertTrue(ArrayUtils.isSameLength(emptyArrayChar, nullArrayShort)); |
| assertTrue(ArrayUtils.isSameLength(emptyArrayChar, nullArrayChar)); |
| assertTrue(ArrayUtils.isSameLength(emptyArrayChar, nullArrayByte)); |
| assertTrue(ArrayUtils.isSameLength(emptyArrayChar, nullArrayDouble)); |
| assertTrue(ArrayUtils.isSameLength(emptyArrayChar, nullArrayFloat)); |
| assertTrue(ArrayUtils.isSameLength(emptyArrayByte, nullArrayObject)); |
| assertTrue(ArrayUtils.isSameLength(emptyArrayByte, nullArrayBoolean)); |
| assertTrue(ArrayUtils.isSameLength(emptyArrayByte, nullArrayLong)); |
| assertTrue(ArrayUtils.isSameLength(emptyArrayByte, nullArrayInt)); |
| assertTrue(ArrayUtils.isSameLength(emptyArrayByte, nullArrayShort)); |
| assertTrue(ArrayUtils.isSameLength(emptyArrayByte, nullArrayChar)); |
| assertTrue(ArrayUtils.isSameLength(emptyArrayByte, nullArrayByte)); |
| assertTrue(ArrayUtils.isSameLength(emptyArrayByte, nullArrayDouble)); |
| assertTrue(ArrayUtils.isSameLength(emptyArrayByte, nullArrayFloat)); |
| assertTrue(ArrayUtils.isSameLength(emptyArrayDouble, nullArrayObject)); |
| assertTrue(ArrayUtils.isSameLength(emptyArrayDouble, nullArrayBoolean)); |
| assertTrue(ArrayUtils.isSameLength(emptyArrayDouble, nullArrayLong)); |
| assertTrue(ArrayUtils.isSameLength(emptyArrayDouble, nullArrayInt)); |
| assertTrue(ArrayUtils.isSameLength(emptyArrayDouble, nullArrayShort)); |
| assertTrue(ArrayUtils.isSameLength(emptyArrayDouble, nullArrayChar)); |
| assertTrue(ArrayUtils.isSameLength(emptyArrayDouble, nullArrayByte)); |
| assertTrue(ArrayUtils.isSameLength(emptyArrayDouble, nullArrayDouble)); |
| assertTrue(ArrayUtils.isSameLength(emptyArrayDouble, nullArrayFloat)); |
| assertTrue(ArrayUtils.isSameLength(emptyArrayFloat, nullArrayObject)); |
| assertTrue(ArrayUtils.isSameLength(emptyArrayFloat, nullArrayBoolean)); |
| assertTrue(ArrayUtils.isSameLength(emptyArrayFloat, nullArrayLong)); |
| assertTrue(ArrayUtils.isSameLength(emptyArrayFloat, nullArrayInt)); |
| assertTrue(ArrayUtils.isSameLength(emptyArrayFloat, nullArrayShort)); |
| assertTrue(ArrayUtils.isSameLength(emptyArrayFloat, nullArrayChar)); |
| assertTrue(ArrayUtils.isSameLength(emptyArrayFloat, nullArrayByte)); |
| assertTrue(ArrayUtils.isSameLength(emptyArrayFloat, nullArrayDouble)); |
| assertTrue(ArrayUtils.isSameLength(emptyArrayFloat, nullArrayFloat)); |
| assertTrue(ArrayUtils.isSameLength(emptyArrayObject, emptyArrayObject)); |
| assertTrue(ArrayUtils.isSameLength(emptyArrayObject, emptyArrayBoolean)); |
| assertTrue(ArrayUtils.isSameLength(emptyArrayObject, emptyArrayLong)); |
| assertTrue(ArrayUtils.isSameLength(emptyArrayObject, emptyArrayInt)); |
| assertTrue(ArrayUtils.isSameLength(emptyArrayObject, emptyArrayShort)); |
| assertTrue(ArrayUtils.isSameLength(emptyArrayObject, emptyArrayChar)); |
| assertTrue(ArrayUtils.isSameLength(emptyArrayObject, emptyArrayByte)); |
| assertTrue(ArrayUtils.isSameLength(emptyArrayObject, emptyArrayDouble)); |
| assertTrue(ArrayUtils.isSameLength(emptyArrayObject, emptyArrayFloat)); |
| assertTrue(ArrayUtils.isSameLength(emptyArrayBoolean, emptyArrayObject)); |
| assertTrue(ArrayUtils.isSameLength(emptyArrayBoolean, emptyArrayBoolean)); |
| assertTrue(ArrayUtils.isSameLength(emptyArrayBoolean, emptyArrayLong)); |
| assertTrue(ArrayUtils.isSameLength(emptyArrayBoolean, emptyArrayInt)); |
| assertTrue(ArrayUtils.isSameLength(emptyArrayBoolean, emptyArrayShort)); |
| assertTrue(ArrayUtils.isSameLength(emptyArrayBoolean, emptyArrayChar)); |
| assertTrue(ArrayUtils.isSameLength(emptyArrayBoolean, emptyArrayByte)); |
| assertTrue(ArrayUtils.isSameLength(emptyArrayBoolean, emptyArrayDouble)); |
| assertTrue(ArrayUtils.isSameLength(emptyArrayBoolean, emptyArrayFloat)); |
| assertTrue(ArrayUtils.isSameLength(emptyArrayLong, emptyArrayObject)); |
| assertTrue(ArrayUtils.isSameLength(emptyArrayLong, emptyArrayBoolean)); |
| assertTrue(ArrayUtils.isSameLength(emptyArrayLong, emptyArrayLong)); |
| assertTrue(ArrayUtils.isSameLength(emptyArrayLong, emptyArrayInt)); |
| assertTrue(ArrayUtils.isSameLength(emptyArrayLong, emptyArrayShort)); |
| assertTrue(ArrayUtils.isSameLength(emptyArrayLong, emptyArrayChar)); |
| assertTrue(ArrayUtils.isSameLength(emptyArrayLong, emptyArrayByte)); |
| assertTrue(ArrayUtils.isSameLength(emptyArrayLong, emptyArrayDouble)); |
| assertTrue(ArrayUtils.isSameLength(emptyArrayLong, emptyArrayFloat)); |
| assertTrue(ArrayUtils.isSameLength(emptyArrayInt, emptyArrayObject)); |
| assertTrue(ArrayUtils.isSameLength(emptyArrayInt, emptyArrayBoolean)); |
| assertTrue(ArrayUtils.isSameLength(emptyArrayInt, emptyArrayLong)); |
| assertTrue(ArrayUtils.isSameLength(emptyArrayInt, emptyArrayInt)); |
| assertTrue(ArrayUtils.isSameLength(emptyArrayInt, emptyArrayShort)); |
| assertTrue(ArrayUtils.isSameLength(emptyArrayInt, emptyArrayChar)); |
| assertTrue(ArrayUtils.isSameLength(emptyArrayInt, emptyArrayByte)); |
| assertTrue(ArrayUtils.isSameLength(emptyArrayInt, emptyArrayDouble)); |
| assertTrue(ArrayUtils.isSameLength(emptyArrayInt, emptyArrayFloat)); |
| assertTrue(ArrayUtils.isSameLength(emptyArrayShort, emptyArrayObject)); |
| assertTrue(ArrayUtils.isSameLength(emptyArrayShort, emptyArrayBoolean)); |
| assertTrue(ArrayUtils.isSameLength(emptyArrayShort, emptyArrayLong)); |
| assertTrue(ArrayUtils.isSameLength(emptyArrayShort, emptyArrayInt)); |
| assertTrue(ArrayUtils.isSameLength(emptyArrayShort, emptyArrayShort)); |
| assertTrue(ArrayUtils.isSameLength(emptyArrayShort, emptyArrayChar)); |
| assertTrue(ArrayUtils.isSameLength(emptyArrayShort, emptyArrayByte)); |
| assertTrue(ArrayUtils.isSameLength(emptyArrayShort, emptyArrayDouble)); |
| assertTrue(ArrayUtils.isSameLength(emptyArrayShort, emptyArrayFloat)); |
| assertTrue(ArrayUtils.isSameLength(emptyArrayChar, emptyArrayObject)); |
| assertTrue(ArrayUtils.isSameLength(emptyArrayChar, emptyArrayBoolean)); |
| assertTrue(ArrayUtils.isSameLength(emptyArrayChar, emptyArrayLong)); |
| assertTrue(ArrayUtils.isSameLength(emptyArrayChar, emptyArrayInt)); |
| assertTrue(ArrayUtils.isSameLength(emptyArrayChar, emptyArrayShort)); |
| assertTrue(ArrayUtils.isSameLength(emptyArrayChar, emptyArrayChar)); |
| assertTrue(ArrayUtils.isSameLength(emptyArrayChar, emptyArrayByte)); |
| assertTrue(ArrayUtils.isSameLength(emptyArrayChar, emptyArrayDouble)); |
| assertTrue(ArrayUtils.isSameLength(emptyArrayChar, emptyArrayFloat)); |
| assertTrue(ArrayUtils.isSameLength(emptyArrayByte, emptyArrayObject)); |
| assertTrue(ArrayUtils.isSameLength(emptyArrayByte, emptyArrayBoolean)); |
| assertTrue(ArrayUtils.isSameLength(emptyArrayByte, emptyArrayLong)); |
| assertTrue(ArrayUtils.isSameLength(emptyArrayByte, emptyArrayInt)); |
| assertTrue(ArrayUtils.isSameLength(emptyArrayByte, emptyArrayShort)); |
| assertTrue(ArrayUtils.isSameLength(emptyArrayByte, emptyArrayChar)); |
| assertTrue(ArrayUtils.isSameLength(emptyArrayByte, emptyArrayByte)); |
| assertTrue(ArrayUtils.isSameLength(emptyArrayByte, emptyArrayDouble)); |
| assertTrue(ArrayUtils.isSameLength(emptyArrayByte, emptyArrayFloat)); |
| assertTrue(ArrayUtils.isSameLength(emptyArrayDouble, emptyArrayObject)); |
| assertTrue(ArrayUtils.isSameLength(emptyArrayDouble, emptyArrayBoolean)); |
| assertTrue(ArrayUtils.isSameLength(emptyArrayDouble, emptyArrayLong)); |
| assertTrue(ArrayUtils.isSameLength(emptyArrayDouble, emptyArrayInt)); |
| assertTrue(ArrayUtils.isSameLength(emptyArrayDouble, emptyArrayShort)); |
| assertTrue(ArrayUtils.isSameLength(emptyArrayDouble, emptyArrayChar)); |
| assertTrue(ArrayUtils.isSameLength(emptyArrayDouble, emptyArrayByte)); |
| assertTrue(ArrayUtils.isSameLength(emptyArrayDouble, emptyArrayDouble)); |
| assertTrue(ArrayUtils.isSameLength(emptyArrayDouble, emptyArrayFloat)); |
| assertTrue(ArrayUtils.isSameLength(emptyArrayFloat, emptyArrayObject)); |
| assertTrue(ArrayUtils.isSameLength(emptyArrayFloat, emptyArrayBoolean)); |
| assertTrue(ArrayUtils.isSameLength(emptyArrayFloat, emptyArrayLong)); |
| assertTrue(ArrayUtils.isSameLength(emptyArrayFloat, emptyArrayInt)); |
| assertTrue(ArrayUtils.isSameLength(emptyArrayFloat, emptyArrayShort)); |
| assertTrue(ArrayUtils.isSameLength(emptyArrayFloat, emptyArrayChar)); |
| assertTrue(ArrayUtils.isSameLength(emptyArrayFloat, emptyArrayByte)); |
| assertTrue(ArrayUtils.isSameLength(emptyArrayFloat, emptyArrayDouble)); |
| assertTrue(ArrayUtils.isSameLength(emptyArrayFloat, emptyArrayFloat)); |
| assertFalse(ArrayUtils.isSameLength(emptyArrayObject, oneArrayObject)); |
| assertFalse(ArrayUtils.isSameLength(emptyArrayObject, oneArrayBoolean)); |
| assertFalse(ArrayUtils.isSameLength(emptyArrayObject, oneArrayLong)); |
| assertFalse(ArrayUtils.isSameLength(emptyArrayObject, oneArrayInt)); |
| assertFalse(ArrayUtils.isSameLength(emptyArrayObject, oneArrayShort)); |
| assertFalse(ArrayUtils.isSameLength(emptyArrayObject, oneArrayChar)); |
| assertFalse(ArrayUtils.isSameLength(emptyArrayObject, oneArrayByte)); |
| assertFalse(ArrayUtils.isSameLength(emptyArrayObject, oneArrayDouble)); |
| assertFalse(ArrayUtils.isSameLength(emptyArrayObject, oneArrayFloat)); |
| assertFalse(ArrayUtils.isSameLength(emptyArrayBoolean, oneArrayObject)); |
| assertFalse(ArrayUtils.isSameLength(emptyArrayBoolean, oneArrayBoolean)); |
| assertFalse(ArrayUtils.isSameLength(emptyArrayBoolean, oneArrayLong)); |
| assertFalse(ArrayUtils.isSameLength(emptyArrayBoolean, oneArrayInt)); |
| assertFalse(ArrayUtils.isSameLength(emptyArrayBoolean, oneArrayShort)); |
| assertFalse(ArrayUtils.isSameLength(emptyArrayBoolean, oneArrayChar)); |
| assertFalse(ArrayUtils.isSameLength(emptyArrayBoolean, oneArrayByte)); |
| assertFalse(ArrayUtils.isSameLength(emptyArrayBoolean, oneArrayDouble)); |
| assertFalse(ArrayUtils.isSameLength(emptyArrayBoolean, oneArrayFloat)); |
| assertFalse(ArrayUtils.isSameLength(emptyArrayLong, oneArrayObject)); |
| assertFalse(ArrayUtils.isSameLength(emptyArrayLong, oneArrayBoolean)); |
| assertFalse(ArrayUtils.isSameLength(emptyArrayLong, oneArrayLong)); |
| assertFalse(ArrayUtils.isSameLength(emptyArrayLong, oneArrayInt)); |
| assertFalse(ArrayUtils.isSameLength(emptyArrayLong, oneArrayShort)); |
| assertFalse(ArrayUtils.isSameLength(emptyArrayLong, oneArrayChar)); |
| assertFalse(ArrayUtils.isSameLength(emptyArrayLong, oneArrayByte)); |
| assertFalse(ArrayUtils.isSameLength(emptyArrayLong, oneArrayDouble)); |
| assertFalse(ArrayUtils.isSameLength(emptyArrayLong, oneArrayFloat)); |
| assertFalse(ArrayUtils.isSameLength(emptyArrayInt, oneArrayObject)); |
| assertFalse(ArrayUtils.isSameLength(emptyArrayInt, oneArrayBoolean)); |
| assertFalse(ArrayUtils.isSameLength(emptyArrayInt, oneArrayLong)); |
| assertFalse(ArrayUtils.isSameLength(emptyArrayInt, oneArrayInt)); |
| assertFalse(ArrayUtils.isSameLength(emptyArrayInt, oneArrayShort)); |
| assertFalse(ArrayUtils.isSameLength(emptyArrayInt, oneArrayChar)); |
| assertFalse(ArrayUtils.isSameLength(emptyArrayInt, oneArrayByte)); |
| assertFalse(ArrayUtils.isSameLength(emptyArrayInt, oneArrayDouble)); |
| assertFalse(ArrayUtils.isSameLength(emptyArrayInt, oneArrayFloat)); |
| assertFalse(ArrayUtils.isSameLength(emptyArrayShort, oneArrayObject)); |
| assertFalse(ArrayUtils.isSameLength(emptyArrayShort, oneArrayBoolean)); |
| assertFalse(ArrayUtils.isSameLength(emptyArrayShort, oneArrayLong)); |
| assertFalse(ArrayUtils.isSameLength(emptyArrayShort, oneArrayInt)); |
| assertFalse(ArrayUtils.isSameLength(emptyArrayShort, oneArrayShort)); |
| assertFalse(ArrayUtils.isSameLength(emptyArrayShort, oneArrayChar)); |
| assertFalse(ArrayUtils.isSameLength(emptyArrayShort, oneArrayByte)); |
| assertFalse(ArrayUtils.isSameLength(emptyArrayShort, oneArrayDouble)); |
| assertFalse(ArrayUtils.isSameLength(emptyArrayShort, oneArrayFloat)); |
| assertFalse(ArrayUtils.isSameLength(emptyArrayChar, oneArrayObject)); |
| assertFalse(ArrayUtils.isSameLength(emptyArrayChar, oneArrayBoolean)); |
| assertFalse(ArrayUtils.isSameLength(emptyArrayChar, oneArrayLong)); |
| assertFalse(ArrayUtils.isSameLength(emptyArrayChar, oneArrayInt)); |
| assertFalse(ArrayUtils.isSameLength(emptyArrayChar, oneArrayShort)); |
| assertFalse(ArrayUtils.isSameLength(emptyArrayChar, oneArrayChar)); |
| assertFalse(ArrayUtils.isSameLength(emptyArrayChar, oneArrayByte)); |
| assertFalse(ArrayUtils.isSameLength(emptyArrayChar, oneArrayDouble)); |
| assertFalse(ArrayUtils.isSameLength(emptyArrayChar, oneArrayFloat)); |
| assertFalse(ArrayUtils.isSameLength(emptyArrayByte, oneArrayObject)); |
| assertFalse(ArrayUtils.isSameLength(emptyArrayByte, oneArrayBoolean)); |
| assertFalse(ArrayUtils.isSameLength(emptyArrayByte, oneArrayLong)); |
| assertFalse(ArrayUtils.isSameLength(emptyArrayByte, oneArrayInt)); |
| assertFalse(ArrayUtils.isSameLength(emptyArrayByte, oneArrayShort)); |
| assertFalse(ArrayUtils.isSameLength(emptyArrayByte, oneArrayChar)); |
| assertFalse(ArrayUtils.isSameLength(emptyArrayByte, oneArrayByte)); |
| assertFalse(ArrayUtils.isSameLength(emptyArrayByte, oneArrayDouble)); |
| assertFalse(ArrayUtils.isSameLength(emptyArrayByte, oneArrayFloat)); |
| assertFalse(ArrayUtils.isSameLength(emptyArrayDouble, oneArrayObject)); |
| assertFalse(ArrayUtils.isSameLength(emptyArrayDouble, oneArrayBoolean)); |
| assertFalse(ArrayUtils.isSameLength(emptyArrayDouble, oneArrayLong)); |
| assertFalse(ArrayUtils.isSameLength(emptyArrayDouble, oneArrayInt)); |
| assertFalse(ArrayUtils.isSameLength(emptyArrayDouble, oneArrayShort)); |
| assertFalse(ArrayUtils.isSameLength(emptyArrayDouble, oneArrayChar)); |
| assertFalse(ArrayUtils.isSameLength(emptyArrayDouble, oneArrayByte)); |
| assertFalse(ArrayUtils.isSameLength(emptyArrayDouble, oneArrayDouble)); |
| assertFalse(ArrayUtils.isSameLength(emptyArrayDouble, oneArrayFloat)); |
| assertFalse(ArrayUtils.isSameLength(emptyArrayFloat, oneArrayObject)); |
| assertFalse(ArrayUtils.isSameLength(emptyArrayFloat, oneArrayBoolean)); |
| assertFalse(ArrayUtils.isSameLength(emptyArrayFloat, oneArrayLong)); |
| assertFalse(ArrayUtils.isSameLength(emptyArrayFloat, oneArrayInt)); |
| assertFalse(ArrayUtils.isSameLength(emptyArrayFloat, oneArrayShort)); |
| assertFalse(ArrayUtils.isSameLength(emptyArrayFloat, oneArrayChar)); |
| assertFalse(ArrayUtils.isSameLength(emptyArrayFloat, oneArrayByte)); |
| assertFalse(ArrayUtils.isSameLength(emptyArrayFloat, oneArrayDouble)); |
| assertFalse(ArrayUtils.isSameLength(emptyArrayFloat, oneArrayFloat)); |
| assertFalse(ArrayUtils.isSameLength(emptyArrayObject, twoArrayObject)); |
| assertFalse(ArrayUtils.isSameLength(emptyArrayObject, twoArrayBoolean)); |
| assertFalse(ArrayUtils.isSameLength(emptyArrayObject, twoArrayLong)); |
| assertFalse(ArrayUtils.isSameLength(emptyArrayObject, twoArrayInt)); |
| assertFalse(ArrayUtils.isSameLength(emptyArrayObject, twoArrayShort)); |
| assertFalse(ArrayUtils.isSameLength(emptyArrayObject, twoArrayChar)); |
| assertFalse(ArrayUtils.isSameLength(emptyArrayObject, twoArrayByte)); |
| assertFalse(ArrayUtils.isSameLength(emptyArrayObject, twoArrayDouble)); |
| assertFalse(ArrayUtils.isSameLength(emptyArrayObject, twoArrayFloat)); |
| assertFalse(ArrayUtils.isSameLength(emptyArrayBoolean, twoArrayObject)); |
| assertFalse(ArrayUtils.isSameLength(emptyArrayBoolean, twoArrayBoolean)); |
| assertFalse(ArrayUtils.isSameLength(emptyArrayBoolean, twoArrayLong)); |
| assertFalse(ArrayUtils.isSameLength(emptyArrayBoolean, twoArrayInt)); |
| assertFalse(ArrayUtils.isSameLength(emptyArrayBoolean, twoArrayShort)); |
| assertFalse(ArrayUtils.isSameLength(emptyArrayBoolean, twoArrayChar)); |
| assertFalse(ArrayUtils.isSameLength(emptyArrayBoolean, twoArrayByte)); |
| assertFalse(ArrayUtils.isSameLength(emptyArrayBoolean, twoArrayDouble)); |
| assertFalse(ArrayUtils.isSameLength(emptyArrayBoolean, twoArrayFloat)); |
| assertFalse(ArrayUtils.isSameLength(emptyArrayLong, twoArrayObject)); |
| assertFalse(ArrayUtils.isSameLength(emptyArrayLong, twoArrayBoolean)); |
| assertFalse(ArrayUtils.isSameLength(emptyArrayLong, twoArrayLong)); |
| assertFalse(ArrayUtils.isSameLength(emptyArrayLong, twoArrayInt)); |
| assertFalse(ArrayUtils.isSameLength(emptyArrayLong, twoArrayShort)); |
| assertFalse(ArrayUtils.isSameLength(emptyArrayLong, twoArrayChar)); |
| assertFalse(ArrayUtils.isSameLength(emptyArrayLong, twoArrayByte)); |
| assertFalse(ArrayUtils.isSameLength(emptyArrayLong, twoArrayDouble)); |
| assertFalse(ArrayUtils.isSameLength(emptyArrayLong, twoArrayFloat)); |
| assertFalse(ArrayUtils.isSameLength(emptyArrayInt, twoArrayObject)); |
| assertFalse(ArrayUtils.isSameLength(emptyArrayInt, twoArrayBoolean)); |
| assertFalse(ArrayUtils.isSameLength(emptyArrayInt, twoArrayLong)); |
| assertFalse(ArrayUtils.isSameLength(emptyArrayInt, twoArrayInt)); |
| assertFalse(ArrayUtils.isSameLength(emptyArrayInt, twoArrayShort)); |
| assertFalse(ArrayUtils.isSameLength(emptyArrayInt, twoArrayChar)); |
| assertFalse(ArrayUtils.isSameLength(emptyArrayInt, twoArrayByte)); |
| assertFalse(ArrayUtils.isSameLength(emptyArrayInt, twoArrayDouble)); |
| assertFalse(ArrayUtils.isSameLength(emptyArrayInt, twoArrayFloat)); |
| assertFalse(ArrayUtils.isSameLength(emptyArrayShort, twoArrayObject)); |
| assertFalse(ArrayUtils.isSameLength(emptyArrayShort, twoArrayBoolean)); |
| assertFalse(ArrayUtils.isSameLength(emptyArrayShort, twoArrayLong)); |
| assertFalse(ArrayUtils.isSameLength(emptyArrayShort, twoArrayInt)); |
| assertFalse(ArrayUtils.isSameLength(emptyArrayShort, twoArrayShort)); |
| assertFalse(ArrayUtils.isSameLength(emptyArrayShort, twoArrayChar)); |
| assertFalse(ArrayUtils.isSameLength(emptyArrayShort, twoArrayByte)); |
| assertFalse(ArrayUtils.isSameLength(emptyArrayShort, twoArrayDouble)); |
| assertFalse(ArrayUtils.isSameLength(emptyArrayShort, twoArrayFloat)); |
| assertFalse(ArrayUtils.isSameLength(emptyArrayChar, twoArrayObject)); |
| assertFalse(ArrayUtils.isSameLength(emptyArrayChar, twoArrayBoolean)); |
| assertFalse(ArrayUtils.isSameLength(emptyArrayChar, twoArrayLong)); |
| assertFalse(ArrayUtils.isSameLength(emptyArrayChar, twoArrayInt)); |
| assertFalse(ArrayUtils.isSameLength(emptyArrayChar, twoArrayShort)); |
| assertFalse(ArrayUtils.isSameLength(emptyArrayChar, twoArrayChar)); |
| assertFalse(ArrayUtils.isSameLength(emptyArrayChar, twoArrayByte)); |
| assertFalse(ArrayUtils.isSameLength(emptyArrayChar, twoArrayDouble)); |
| assertFalse(ArrayUtils.isSameLength(emptyArrayChar, twoArrayFloat)); |
| assertFalse(ArrayUtils.isSameLength(emptyArrayByte, twoArrayObject)); |
| assertFalse(ArrayUtils.isSameLength(emptyArrayByte, twoArrayBoolean)); |
| assertFalse(ArrayUtils.isSameLength(emptyArrayByte, twoArrayLong)); |
| assertFalse(ArrayUtils.isSameLength(emptyArrayByte, twoArrayInt)); |
| assertFalse(ArrayUtils.isSameLength(emptyArrayByte, twoArrayShort)); |
| assertFalse(ArrayUtils.isSameLength(emptyArrayByte, twoArrayChar)); |
| assertFalse(ArrayUtils.isSameLength(emptyArrayByte, twoArrayByte)); |
| assertFalse(ArrayUtils.isSameLength(emptyArrayByte, twoArrayDouble)); |
| assertFalse(ArrayUtils.isSameLength(emptyArrayByte, twoArrayFloat)); |
| assertFalse(ArrayUtils.isSameLength(emptyArrayDouble, twoArrayObject)); |
| assertFalse(ArrayUtils.isSameLength(emptyArrayDouble, twoArrayBoolean)); |
| assertFalse(ArrayUtils.isSameLength(emptyArrayDouble, twoArrayLong)); |
| assertFalse(ArrayUtils.isSameLength(emptyArrayDouble, twoArrayInt)); |
| assertFalse(ArrayUtils.isSameLength(emptyArrayDouble, twoArrayShort)); |
| assertFalse(ArrayUtils.isSameLength(emptyArrayDouble, twoArrayChar)); |
| assertFalse(ArrayUtils.isSameLength(emptyArrayDouble, twoArrayByte)); |
| assertFalse(ArrayUtils.isSameLength(emptyArrayDouble, twoArrayDouble)); |
| assertFalse(ArrayUtils.isSameLength(emptyArrayDouble, twoArrayFloat)); |
| assertFalse(ArrayUtils.isSameLength(emptyArrayFloat, twoArrayObject)); |
| assertFalse(ArrayUtils.isSameLength(emptyArrayFloat, twoArrayBoolean)); |
| assertFalse(ArrayUtils.isSameLength(emptyArrayFloat, twoArrayLong)); |
| assertFalse(ArrayUtils.isSameLength(emptyArrayFloat, twoArrayInt)); |
| assertFalse(ArrayUtils.isSameLength(emptyArrayFloat, twoArrayShort)); |
| assertFalse(ArrayUtils.isSameLength(emptyArrayFloat, twoArrayChar)); |
| assertFalse(ArrayUtils.isSameLength(emptyArrayFloat, twoArrayByte)); |
| assertFalse(ArrayUtils.isSameLength(emptyArrayFloat, twoArrayDouble)); |
| assertFalse(ArrayUtils.isSameLength(emptyArrayFloat, twoArrayFloat)); |
| assertFalse(ArrayUtils.isSameLength(oneArrayObject, nullArrayObject)); |
| assertFalse(ArrayUtils.isSameLength(oneArrayObject, nullArrayBoolean)); |
| assertFalse(ArrayUtils.isSameLength(oneArrayObject, nullArrayLong)); |
| assertFalse(ArrayUtils.isSameLength(oneArrayObject, nullArrayInt)); |
| assertFalse(ArrayUtils.isSameLength(oneArrayObject, nullArrayShort)); |
| assertFalse(ArrayUtils.isSameLength(oneArrayObject, nullArrayChar)); |
| assertFalse(ArrayUtils.isSameLength(oneArrayObject, nullArrayByte)); |
| assertFalse(ArrayUtils.isSameLength(oneArrayObject, nullArrayDouble)); |
| assertFalse(ArrayUtils.isSameLength(oneArrayObject, nullArrayFloat)); |
| assertFalse(ArrayUtils.isSameLength(oneArrayBoolean, nullArrayObject)); |
| assertFalse(ArrayUtils.isSameLength(oneArrayBoolean, nullArrayBoolean)); |
| assertFalse(ArrayUtils.isSameLength(oneArrayBoolean, nullArrayLong)); |
| assertFalse(ArrayUtils.isSameLength(oneArrayBoolean, nullArrayInt)); |
| assertFalse(ArrayUtils.isSameLength(oneArrayBoolean, nullArrayShort)); |
| assertFalse(ArrayUtils.isSameLength(oneArrayBoolean, nullArrayChar)); |
| assertFalse(ArrayUtils.isSameLength(oneArrayBoolean, nullArrayByte)); |
| assertFalse(ArrayUtils.isSameLength(oneArrayBoolean, nullArrayDouble)); |
| assertFalse(ArrayUtils.isSameLength(oneArrayBoolean, nullArrayFloat)); |
| assertFalse(ArrayUtils.isSameLength(oneArrayLong, nullArrayObject)); |
| assertFalse(ArrayUtils.isSameLength(oneArrayLong, nullArrayBoolean)); |
| assertFalse(ArrayUtils.isSameLength(oneArrayLong, nullArrayLong)); |
| assertFalse(ArrayUtils.isSameLength(oneArrayLong, nullArrayInt)); |
| assertFalse(ArrayUtils.isSameLength(oneArrayLong, nullArrayShort)); |
| assertFalse(ArrayUtils.isSameLength(oneArrayLong, nullArrayChar)); |
| assertFalse(ArrayUtils.isSameLength(oneArrayLong, nullArrayByte)); |
| assertFalse(ArrayUtils.isSameLength(oneArrayLong, nullArrayDouble)); |
| assertFalse(ArrayUtils.isSameLength(oneArrayLong, nullArrayFloat)); |
| assertFalse(ArrayUtils.isSameLength(oneArrayInt, nullArrayObject)); |
| assertFalse(ArrayUtils.isSameLength(oneArrayInt, nullArrayBoolean)); |
| assertFalse(ArrayUtils.isSameLength(oneArrayInt, nullArrayLong)); |
| assertFalse(ArrayUtils.isSameLength(oneArrayInt, nullArrayInt)); |
| assertFalse(ArrayUtils.isSameLength(oneArrayInt, nullArrayShort)); |
| assertFalse(ArrayUtils.isSameLength(oneArrayInt, nullArrayChar)); |
| assertFalse(ArrayUtils.isSameLength(oneArrayInt, nullArrayByte)); |
| assertFalse(ArrayUtils.isSameLength(oneArrayInt, nullArrayDouble)); |
| assertFalse(ArrayUtils.isSameLength(oneArrayInt, nullArrayFloat)); |
| assertFalse(ArrayUtils.isSameLength(oneArrayShort, nullArrayObject)); |
| assertFalse(ArrayUtils.isSameLength(oneArrayShort, nullArrayBoolean)); |
| assertFalse(ArrayUtils.isSameLength(oneArrayShort, nullArrayLong)); |
| assertFalse(ArrayUtils.isSameLength(oneArrayShort, nullArrayInt)); |
| assertFalse(ArrayUtils.isSameLength(oneArrayShort, nullArrayShort)); |
| assertFalse(ArrayUtils.isSameLength(oneArrayShort, nullArrayChar)); |
| assertFalse(ArrayUtils.isSameLength(oneArrayShort, nullArrayByte)); |
| assertFalse(ArrayUtils.isSameLength(oneArrayShort, nullArrayDouble)); |
| assertFalse(ArrayUtils.isSameLength(oneArrayShort, nullArrayFloat)); |
| assertFalse(ArrayUtils.isSameLength(oneArrayChar, nullArrayObject)); |
| assertFalse(ArrayUtils.isSameLength(oneArrayChar, nullArrayBoolean)); |
| assertFalse(ArrayUtils.isSameLength(oneArrayChar, nullArrayLong)); |
| assertFalse(ArrayUtils.isSameLength(oneArrayChar, nullArrayInt)); |
| assertFalse(ArrayUtils.isSameLength(oneArrayChar, nullArrayShort)); |
| assertFalse(ArrayUtils.isSameLength(oneArrayChar, nullArrayChar)); |
| assertFalse(ArrayUtils.isSameLength(oneArrayChar, nullArrayByte)); |
| assertFalse(ArrayUtils.isSameLength(oneArrayChar, nullArrayDouble)); |
| assertFalse(ArrayUtils.isSameLength(oneArrayChar, nullArrayFloat)); |
| assertFalse(ArrayUtils.isSameLength(oneArrayByte, nullArrayObject)); |
| assertFalse(ArrayUtils.isSameLength(oneArrayByte, nullArrayBoolean)); |
| assertFalse(ArrayUtils.isSameLength(oneArrayByte, nullArrayLong)); |
| assertFalse(ArrayUtils.isSameLength(oneArrayByte, nullArrayInt)); |
| assertFalse(ArrayUtils.isSameLength(oneArrayByte, nullArrayShort)); |
| assertFalse(ArrayUtils.isSameLength(oneArrayByte, nullArrayChar)); |
| assertFalse(ArrayUtils.isSameLength(oneArrayByte, nullArrayByte)); |
| assertFalse(ArrayUtils.isSameLength(oneArrayByte, nullArrayDouble)); |
| assertFalse(ArrayUtils.isSameLength(oneArrayByte, nullArrayFloat)); |
| assertFalse(ArrayUtils.isSameLength(oneArrayDouble, nullArrayObject)); |
| assertFalse(ArrayUtils.isSameLength(oneArrayDouble, nullArrayBoolean)); |
| assertFalse(ArrayUtils.isSameLength(oneArrayDouble, nullArrayLong)); |
| assertFalse(ArrayUtils.isSameLength(oneArrayDouble, nullArrayInt)); |
| assertFalse(ArrayUtils.isSameLength(oneArrayDouble, nullArrayShort)); |
| assertFalse(ArrayUtils.isSameLength(oneArrayDouble, nullArrayChar)); |
| assertFalse(ArrayUtils.isSameLength(oneArrayDouble, nullArrayByte)); |
| assertFalse(ArrayUtils.isSameLength(oneArrayDouble, nullArrayDouble)); |
| assertFalse(ArrayUtils.isSameLength(oneArrayDouble, nullArrayFloat)); |
| assertFalse(ArrayUtils.isSameLength(oneArrayFloat, nullArrayObject)); |
| assertFalse(ArrayUtils.isSameLength(oneArrayFloat, nullArrayBoolean)); |
| assertFalse(ArrayUtils.isSameLength(oneArrayFloat, nullArrayLong)); |
| assertFalse(ArrayUtils.isSameLength(oneArrayFloat, nullArrayInt)); |
| assertFalse(ArrayUtils.isSameLength(oneArrayFloat, nullArrayShort)); |
| assertFalse(ArrayUtils.isSameLength(oneArrayFloat, nullArrayChar)); |
| assertFalse(ArrayUtils.isSameLength(oneArrayFloat, nullArrayByte)); |
| assertFalse(ArrayUtils.isSameLength(oneArrayFloat, nullArrayDouble)); |
| assertFalse(ArrayUtils.isSameLength(oneArrayFloat, nullArrayFloat)); |
| assertFalse(ArrayUtils.isSameLength(oneArrayObject, emptyArrayObject)); |
| assertFalse(ArrayUtils.isSameLength(oneArrayObject, emptyArrayBoolean)); |
| assertFalse(ArrayUtils.isSameLength(oneArrayObject, emptyArrayLong)); |
| assertFalse(ArrayUtils.isSameLength(oneArrayObject, emptyArrayInt)); |
| assertFalse(ArrayUtils.isSameLength(oneArrayObject, emptyArrayShort)); |
| assertFalse(ArrayUtils.isSameLength(oneArrayObject, emptyArrayChar)); |
| assertFalse(ArrayUtils.isSameLength(oneArrayObject, emptyArrayByte)); |
| assertFalse(ArrayUtils.isSameLength(oneArrayObject, emptyArrayDouble)); |
| assertFalse(ArrayUtils.isSameLength(oneArrayObject, emptyArrayFloat)); |
| assertFalse(ArrayUtils.isSameLength(oneArrayBoolean, emptyArrayObject)); |
| assertFalse(ArrayUtils.isSameLength(oneArrayBoolean, emptyArrayBoolean)); |
| assertFalse(ArrayUtils.isSameLength(oneArrayBoolean, emptyArrayLong)); |
| assertFalse(ArrayUtils.isSameLength(oneArrayBoolean, emptyArrayInt)); |
| assertFalse(ArrayUtils.isSameLength(oneArrayBoolean, emptyArrayShort)); |
| assertFalse(ArrayUtils.isSameLength(oneArrayBoolean, emptyArrayChar)); |
| assertFalse(ArrayUtils.isSameLength(oneArrayBoolean, emptyArrayByte)); |
| assertFalse(ArrayUtils.isSameLength(oneArrayBoolean, emptyArrayDouble)); |
| assertFalse(ArrayUtils.isSameLength(oneArrayBoolean, emptyArrayFloat)); |
| assertFalse(ArrayUtils.isSameLength(oneArrayLong, emptyArrayObject)); |
| assertFalse(ArrayUtils.isSameLength(oneArrayLong, emptyArrayBoolean)); |
| assertFalse(ArrayUtils.isSameLength(oneArrayLong, emptyArrayLong)); |
| assertFalse(ArrayUtils.isSameLength(oneArrayLong, emptyArrayInt)); |
| assertFalse(ArrayUtils.isSameLength(oneArrayLong, emptyArrayShort)); |
| assertFalse(ArrayUtils.isSameLength(oneArrayLong, emptyArrayChar)); |
| assertFalse(ArrayUtils.isSameLength(oneArrayLong, emptyArrayByte)); |
| assertFalse(ArrayUtils.isSameLength(oneArrayLong, emptyArrayDouble)); |
| assertFalse(ArrayUtils.isSameLength(oneArrayLong, emptyArrayFloat)); |
| assertFalse(ArrayUtils.isSameLength(oneArrayInt, emptyArrayObject)); |
| assertFalse(ArrayUtils.isSameLength(oneArrayInt, emptyArrayBoolean)); |
| assertFalse(ArrayUtils.isSameLength(oneArrayInt, emptyArrayLong)); |
| assertFalse(ArrayUtils.isSameLength(oneArrayInt, emptyArrayInt)); |
| assertFalse(ArrayUtils.isSameLength(oneArrayInt, emptyArrayShort)); |
| assertFalse(ArrayUtils.isSameLength(oneArrayInt, emptyArrayChar)); |
| assertFalse(ArrayUtils.isSameLength(oneArrayInt, emptyArrayByte)); |
| assertFalse(ArrayUtils.isSameLength(oneArrayInt, emptyArrayDouble)); |
| assertFalse(ArrayUtils.isSameLength(oneArrayInt, emptyArrayFloat)); |
| assertFalse(ArrayUtils.isSameLength(oneArrayShort, emptyArrayObject)); |
| assertFalse(ArrayUtils.isSameLength(oneArrayShort, emptyArrayBoolean)); |
| assertFalse(ArrayUtils.isSameLength(oneArrayShort, emptyArrayLong)); |
| assertFalse(ArrayUtils.isSameLength(oneArrayShort, emptyArrayInt)); |
| assertFalse(ArrayUtils.isSameLength(oneArrayShort, emptyArrayShort)); |
| assertFalse(ArrayUtils.isSameLength(oneArrayShort, emptyArrayChar)); |
| assertFalse(ArrayUtils.isSameLength(oneArrayShort, emptyArrayByte)); |
| assertFalse(ArrayUtils.isSameLength(oneArrayShort, emptyArrayDouble)); |
| assertFalse(ArrayUtils.isSameLength(oneArrayShort, emptyArrayFloat)); |
| assertFalse(ArrayUtils.isSameLength(oneArrayChar, emptyArrayObject)); |
| assertFalse(ArrayUtils.isSameLength(oneArrayChar, emptyArrayBoolean)); |
| assertFalse(ArrayUtils.isSameLength(oneArrayChar, emptyArrayLong)); |
| assertFalse(ArrayUtils.isSameLength(oneArrayChar, emptyArrayInt)); |
| assertFalse(ArrayUtils.isSameLength(oneArrayChar, emptyArrayShort)); |
| assertFalse(ArrayUtils.isSameLength(oneArrayChar, emptyArrayChar)); |
| assertFalse(ArrayUtils.isSameLength(oneArrayChar, emptyArrayByte)); |
| assertFalse(ArrayUtils.isSameLength(oneArrayChar, emptyArrayDouble)); |
| assertFalse(ArrayUtils.isSameLength(oneArrayChar, emptyArrayFloat)); |
| assertFalse(ArrayUtils.isSameLength(oneArrayByte, emptyArrayObject)); |
| assertFalse(ArrayUtils.isSameLength(oneArrayByte, emptyArrayBoolean)); |
| assertFalse(ArrayUtils.isSameLength(oneArrayByte, emptyArrayLong)); |
| assertFalse(ArrayUtils.isSameLength(oneArrayByte, emptyArrayInt)); |
| assertFalse(ArrayUtils.isSameLength(oneArrayByte, emptyArrayShort)); |
| assertFalse(ArrayUtils.isSameLength(oneArrayByte, emptyArrayChar)); |
| assertFalse(ArrayUtils.isSameLength(oneArrayByte, emptyArrayByte)); |
| assertFalse(ArrayUtils.isSameLength(oneArrayByte, emptyArrayDouble)); |
| assertFalse(ArrayUtils.isSameLength(oneArrayByte, emptyArrayFloat)); |
| assertFalse(ArrayUtils.isSameLength(oneArrayDouble, emptyArrayObject)); |
| assertFalse(ArrayUtils.isSameLength(oneArrayDouble, emptyArrayBoolean)); |
| assertFalse(ArrayUtils.isSameLength(oneArrayDouble, emptyArrayLong)); |
| assertFalse(ArrayUtils.isSameLength(oneArrayDouble, emptyArrayInt)); |
| assertFalse(ArrayUtils.isSameLength(oneArrayDouble, emptyArrayShort)); |
| assertFalse(ArrayUtils.isSameLength(oneArrayDouble, emptyArrayChar)); |
| assertFalse(ArrayUtils.isSameLength(oneArrayDouble, emptyArrayByte)); |
| assertFalse(ArrayUtils.isSameLength(oneArrayDouble, emptyArrayDouble)); |
| assertFalse(ArrayUtils.isSameLength(oneArrayDouble, emptyArrayFloat)); |
| assertFalse(ArrayUtils.isSameLength(oneArrayFloat, emptyArrayObject)); |
| assertFalse(ArrayUtils.isSameLength(oneArrayFloat, emptyArrayBoolean)); |
| assertFalse(ArrayUtils.isSameLength(oneArrayFloat, emptyArrayLong)); |
| assertFalse(ArrayUtils.isSameLength(oneArrayFloat, emptyArrayInt)); |
| assertFalse(ArrayUtils.isSameLength(oneArrayFloat, emptyArrayShort)); |
| assertFalse(ArrayUtils.isSameLength(oneArrayFloat, emptyArrayChar)); |
| assertFalse(ArrayUtils.isSameLength(oneArrayFloat, emptyArrayByte)); |
| assertFalse(ArrayUtils.isSameLength(oneArrayFloat, emptyArrayDouble)); |
| assertFalse(ArrayUtils.isSameLength(oneArrayFloat, emptyArrayFloat)); |
| assertTrue(ArrayUtils.isSameLength(oneArrayObject, oneArrayObject)); |
| assertTrue(ArrayUtils.isSameLength(oneArrayObject, oneArrayBoolean)); |
| assertTrue(ArrayUtils.isSameLength(oneArrayObject, oneArrayLong)); |
| assertTrue(ArrayUtils.isSameLength(oneArrayObject, oneArrayInt)); |
| assertTrue(ArrayUtils.isSameLength(oneArrayObject, oneArrayShort)); |
| assertTrue(ArrayUtils.isSameLength(oneArrayObject, oneArrayChar)); |
| assertTrue(ArrayUtils.isSameLength(oneArrayObject, oneArrayByte)); |
| assertTrue(ArrayUtils.isSameLength(oneArrayObject, oneArrayDouble)); |
| assertTrue(ArrayUtils.isSameLength(oneArrayObject, oneArrayFloat)); |
| assertTrue(ArrayUtils.isSameLength(oneArrayBoolean, oneArrayObject)); |
| assertTrue(ArrayUtils.isSameLength(oneArrayBoolean, oneArrayBoolean)); |
| assertTrue(ArrayUtils.isSameLength(oneArrayBoolean, oneArrayLong)); |
| assertTrue(ArrayUtils.isSameLength(oneArrayBoolean, oneArrayInt)); |
| assertTrue(ArrayUtils.isSameLength(oneArrayBoolean, oneArrayShort)); |
| assertTrue(ArrayUtils.isSameLength(oneArrayBoolean, oneArrayChar)); |
| assertTrue(ArrayUtils.isSameLength(oneArrayBoolean, oneArrayByte)); |
| assertTrue(ArrayUtils.isSameLength(oneArrayBoolean, oneArrayDouble)); |
| assertTrue(ArrayUtils.isSameLength(oneArrayBoolean, oneArrayFloat)); |
| assertTrue(ArrayUtils.isSameLength(oneArrayLong, oneArrayObject)); |
| assertTrue(ArrayUtils.isSameLength(oneArrayLong, oneArrayBoolean)); |
| assertTrue(ArrayUtils.isSameLength(oneArrayLong, oneArrayLong)); |
| assertTrue(ArrayUtils.isSameLength(oneArrayLong, oneArrayInt)); |
| assertTrue(ArrayUtils.isSameLength(oneArrayLong, oneArrayShort)); |
| assertTrue(ArrayUtils.isSameLength(oneArrayLong, oneArrayChar)); |
| assertTrue(ArrayUtils.isSameLength(oneArrayLong, oneArrayByte)); |
| assertTrue(ArrayUtils.isSameLength(oneArrayLong, oneArrayDouble)); |
| assertTrue(ArrayUtils.isSameLength(oneArrayLong, oneArrayFloat)); |
| assertTrue(ArrayUtils.isSameLength(oneArrayInt, oneArrayObject)); |
| assertTrue(ArrayUtils.isSameLength(oneArrayInt, oneArrayBoolean)); |
| assertTrue(ArrayUtils.isSameLength(oneArrayInt, oneArrayLong)); |
| assertTrue(ArrayUtils.isSameLength(oneArrayInt, oneArrayInt)); |
| assertTrue(ArrayUtils.isSameLength(oneArrayInt, oneArrayShort)); |
| assertTrue(ArrayUtils.isSameLength(oneArrayInt, oneArrayChar)); |
| assertTrue(ArrayUtils.isSameLength(oneArrayInt, oneArrayByte)); |
| assertTrue(ArrayUtils.isSameLength(oneArrayInt, oneArrayDouble)); |
| assertTrue(ArrayUtils.isSameLength(oneArrayInt, oneArrayFloat)); |
| assertTrue(ArrayUtils.isSameLength(oneArrayShort, oneArrayObject)); |
| assertTrue(ArrayUtils.isSameLength(oneArrayShort, oneArrayBoolean)); |
| assertTrue(ArrayUtils.isSameLength(oneArrayShort, oneArrayLong)); |
| assertTrue(ArrayUtils.isSameLength(oneArrayShort, oneArrayInt)); |
| assertTrue(ArrayUtils.isSameLength(oneArrayShort, oneArrayShort)); |
| assertTrue(ArrayUtils.isSameLength(oneArrayShort, oneArrayChar)); |
| assertTrue(ArrayUtils.isSameLength(oneArrayShort, oneArrayByte)); |
| assertTrue(ArrayUtils.isSameLength(oneArrayShort, oneArrayDouble)); |
| assertTrue(ArrayUtils.isSameLength(oneArrayShort, oneArrayFloat)); |
| assertTrue(ArrayUtils.isSameLength(oneArrayChar, oneArrayObject)); |
| assertTrue(ArrayUtils.isSameLength(oneArrayChar, oneArrayBoolean)); |
| assertTrue(ArrayUtils.isSameLength(oneArrayChar, oneArrayLong)); |
| assertTrue(ArrayUtils.isSameLength(oneArrayChar, oneArrayInt)); |
| assertTrue(ArrayUtils.isSameLength(oneArrayChar, oneArrayShort)); |
| assertTrue(ArrayUtils.isSameLength(oneArrayChar, oneArrayChar)); |
| assertTrue(ArrayUtils.isSameLength(oneArrayChar, oneArrayByte)); |
| assertTrue(ArrayUtils.isSameLength(oneArrayChar, oneArrayDouble)); |
| assertTrue(ArrayUtils.isSameLength(oneArrayChar, oneArrayFloat)); |
| assertTrue(ArrayUtils.isSameLength(oneArrayByte, oneArrayObject)); |
| assertTrue(ArrayUtils.isSameLength(oneArrayByte, oneArrayBoolean)); |
| assertTrue(ArrayUtils.isSameLength(oneArrayByte, oneArrayLong)); |
| assertTrue(ArrayUtils.isSameLength(oneArrayByte, oneArrayInt)); |
| assertTrue(ArrayUtils.isSameLength(oneArrayByte, oneArrayShort)); |
| assertTrue(ArrayUtils.isSameLength(oneArrayByte, oneArrayChar)); |
| assertTrue(ArrayUtils.isSameLength(oneArrayByte, oneArrayByte)); |
| assertTrue(ArrayUtils.isSameLength(oneArrayByte, oneArrayDouble)); |
| assertTrue(ArrayUtils.isSameLength(oneArrayByte, oneArrayFloat)); |
| assertTrue(ArrayUtils.isSameLength(oneArrayDouble, oneArrayObject)); |
| assertTrue(ArrayUtils.isSameLength(oneArrayDouble, oneArrayBoolean)); |
| assertTrue(ArrayUtils.isSameLength(oneArrayDouble, oneArrayLong)); |
| assertTrue(ArrayUtils.isSameLength(oneArrayDouble, oneArrayInt)); |
| assertTrue(ArrayUtils.isSameLength(oneArrayDouble, oneArrayShort)); |
| assertTrue(ArrayUtils.isSameLength(oneArrayDouble, oneArrayChar)); |
| assertTrue(ArrayUtils.isSameLength(oneArrayDouble, oneArrayByte)); |
| assertTrue(ArrayUtils.isSameLength(oneArrayDouble, oneArrayDouble)); |
| assertTrue(ArrayUtils.isSameLength(oneArrayDouble, oneArrayFloat)); |
| assertTrue(ArrayUtils.isSameLength(oneArrayFloat, oneArrayObject)); |
| assertTrue(ArrayUtils.isSameLength(oneArrayFloat, oneArrayBoolean)); |
| assertTrue(ArrayUtils.isSameLength(oneArrayFloat, oneArrayLong)); |
| assertTrue(ArrayUtils.isSameLength(oneArrayFloat, oneArrayInt)); |
| assertTrue(ArrayUtils.isSameLength(oneArrayFloat, oneArrayShort)); |
| assertTrue(ArrayUtils.isSameLength(oneArrayFloat, oneArrayChar)); |
| assertTrue(ArrayUtils.isSameLength(oneArrayFloat, oneArrayByte)); |
| assertTrue(ArrayUtils.isSameLength(oneArrayFloat, oneArrayDouble)); |
| assertTrue(ArrayUtils.isSameLength(oneArrayFloat, oneArrayFloat)); |
| assertFalse(ArrayUtils.isSameLength(oneArrayObject, twoArrayObject)); |
| assertFalse(ArrayUtils.isSameLength(oneArrayObject, twoArrayBoolean)); |
| assertFalse(ArrayUtils.isSameLength(oneArrayObject, twoArrayLong)); |
| assertFalse(ArrayUtils.isSameLength(oneArrayObject, twoArrayInt)); |
| assertFalse(ArrayUtils.isSameLength(oneArrayObject, twoArrayShort)); |
| assertFalse(ArrayUtils.isSameLength(oneArrayObject, twoArrayChar)); |
| assertFalse(ArrayUtils.isSameLength(oneArrayObject, twoArrayByte)); |
| assertFalse(ArrayUtils.isSameLength(oneArrayObject, twoArrayDouble)); |
| assertFalse(ArrayUtils.isSameLength(oneArrayObject, twoArrayFloat)); |
| assertFalse(ArrayUtils.isSameLength(oneArrayBoolean, twoArrayObject)); |
| assertFalse(ArrayUtils.isSameLength(oneArrayBoolean, twoArrayBoolean)); |
| assertFalse(ArrayUtils.isSameLength(oneArrayBoolean, twoArrayLong)); |
| assertFalse(ArrayUtils.isSameLength(oneArrayBoolean, twoArrayInt)); |
| assertFalse(ArrayUtils.isSameLength(oneArrayBoolean, twoArrayShort)); |
| assertFalse(ArrayUtils.isSameLength(oneArrayBoolean, twoArrayChar)); |
| assertFalse(ArrayUtils.isSameLength(oneArrayBoolean, twoArrayByte)); |
| assertFalse(ArrayUtils.isSameLength(oneArrayBoolean, twoArrayDouble)); |
| assertFalse(ArrayUtils.isSameLength(oneArrayBoolean, twoArrayFloat)); |
| assertFalse(ArrayUtils.isSameLength(oneArrayLong, twoArrayObject)); |
| assertFalse(ArrayUtils.isSameLength(oneArrayLong, twoArrayBoolean)); |
| assertFalse(ArrayUtils.isSameLength(oneArrayLong, twoArrayLong)); |
| assertFalse(ArrayUtils.isSameLength(oneArrayLong, twoArrayInt)); |
| assertFalse(ArrayUtils.isSameLength(oneArrayLong, twoArrayShort)); |
| assertFalse(ArrayUtils.isSameLength(oneArrayLong, twoArrayChar)); |
| assertFalse(ArrayUtils.isSameLength(oneArrayLong, twoArrayByte)); |
| assertFalse(ArrayUtils.isSameLength(oneArrayLong, twoArrayDouble)); |
| assertFalse(ArrayUtils.isSameLength(oneArrayLong, twoArrayFloat)); |
| assertFalse(ArrayUtils.isSameLength(oneArrayInt, twoArrayObject)); |
| assertFalse(ArrayUtils.isSameLength(oneArrayInt, twoArrayBoolean)); |
| assertFalse(ArrayUtils.isSameLength(oneArrayInt, twoArrayLong)); |
| assertFalse(ArrayUtils.isSameLength(oneArrayInt, twoArrayInt)); |
| assertFalse(ArrayUtils.isSameLength(oneArrayInt, twoArrayShort)); |
| assertFalse(ArrayUtils.isSameLength(oneArrayInt, twoArrayChar)); |
| assertFalse(ArrayUtils.isSameLength(oneArrayInt, twoArrayByte)); |
| assertFalse(ArrayUtils.isSameLength(oneArrayInt, twoArrayDouble)); |
| assertFalse(ArrayUtils.isSameLength(oneArrayInt, twoArrayFloat)); |
| assertFalse(ArrayUtils.isSameLength(oneArrayShort, twoArrayObject)); |
| assertFalse(ArrayUtils.isSameLength(oneArrayShort, twoArrayBoolean)); |
| assertFalse(ArrayUtils.isSameLength(oneArrayShort, twoArrayLong)); |
| assertFalse(ArrayUtils.isSameLength(oneArrayShort, twoArrayInt)); |
| assertFalse(ArrayUtils.isSameLength(oneArrayShort, twoArrayShort)); |
| assertFalse(ArrayUtils.isSameLength(oneArrayShort, twoArrayChar)); |
| assertFalse(ArrayUtils.isSameLength(oneArrayShort, twoArrayByte)); |
| assertFalse(ArrayUtils.isSameLength(oneArrayShort, twoArrayDouble)); |
| assertFalse(ArrayUtils.isSameLength(oneArrayShort, twoArrayFloat)); |
| assertFalse(ArrayUtils.isSameLength(oneArrayChar, twoArrayObject)); |
| assertFalse(ArrayUtils.isSameLength(oneArrayChar, twoArrayBoolean)); |
| assertFalse(ArrayUtils.isSameLength(oneArrayChar, twoArrayLong)); |
| assertFalse(ArrayUtils.isSameLength(oneArrayChar, twoArrayInt)); |
| assertFalse(ArrayUtils.isSameLength(oneArrayChar, twoArrayShort)); |
| assertFalse(ArrayUtils.isSameLength(oneArrayChar, twoArrayChar)); |
| assertFalse(ArrayUtils.isSameLength(oneArrayChar, twoArrayByte)); |
| assertFalse(ArrayUtils.isSameLength(oneArrayChar, twoArrayDouble)); |
| assertFalse(ArrayUtils.isSameLength(oneArrayChar, twoArrayFloat)); |
| assertFalse(ArrayUtils.isSameLength(oneArrayByte, twoArrayObject)); |
| assertFalse(ArrayUtils.isSameLength(oneArrayByte, twoArrayBoolean)); |
| assertFalse(ArrayUtils.isSameLength(oneArrayByte, twoArrayLong)); |
| assertFalse(ArrayUtils.isSameLength(oneArrayByte, twoArrayInt)); |
| assertFalse(ArrayUtils.isSameLength(oneArrayByte, twoArrayShort)); |
| assertFalse(ArrayUtils.isSameLength(oneArrayByte, twoArrayChar)); |
| assertFalse(ArrayUtils.isSameLength(oneArrayByte, twoArrayByte)); |
| assertFalse(ArrayUtils.isSameLength(oneArrayByte, twoArrayDouble)); |
| assertFalse(ArrayUtils.isSameLength(oneArrayByte, twoArrayFloat)); |
| assertFalse(ArrayUtils.isSameLength(oneArrayDouble, twoArrayObject)); |
| assertFalse(ArrayUtils.isSameLength(oneArrayDouble, twoArrayBoolean)); |
| assertFalse(ArrayUtils.isSameLength(oneArrayDouble, twoArrayLong)); |
| assertFalse(ArrayUtils.isSameLength(oneArrayDouble, twoArrayInt)); |
| assertFalse(ArrayUtils.isSameLength(oneArrayDouble, twoArrayShort)); |
| assertFalse(ArrayUtils.isSameLength(oneArrayDouble, twoArrayChar)); |
| assertFalse(ArrayUtils.isSameLength(oneArrayDouble, twoArrayByte)); |
| assertFalse(ArrayUtils.isSameLength(oneArrayDouble, twoArrayDouble)); |
| assertFalse(ArrayUtils.isSameLength(oneArrayDouble, twoArrayFloat)); |
| assertFalse(ArrayUtils.isSameLength(oneArrayFloat, twoArrayObject)); |
| assertFalse(ArrayUtils.isSameLength(oneArrayFloat, twoArrayBoolean)); |
| assertFalse(ArrayUtils.isSameLength(oneArrayFloat, twoArrayLong)); |
| assertFalse(ArrayUtils.isSameLength(oneArrayFloat, twoArrayInt)); |
| assertFalse(ArrayUtils.isSameLength(oneArrayFloat, twoArrayShort)); |
| assertFalse(ArrayUtils.isSameLength(oneArrayFloat, twoArrayChar)); |
| assertFalse(ArrayUtils.isSameLength(oneArrayFloat, twoArrayByte)); |
| assertFalse(ArrayUtils.isSameLength(oneArrayFloat, twoArrayDouble)); |
| assertFalse(ArrayUtils.isSameLength(oneArrayFloat, twoArrayFloat)); |
| assertFalse(ArrayUtils.isSameLength(twoArrayObject, nullArrayObject)); |
| assertFalse(ArrayUtils.isSameLength(twoArrayObject, nullArrayBoolean)); |
| assertFalse(ArrayUtils.isSameLength(twoArrayObject, nullArrayLong)); |
| assertFalse(ArrayUtils.isSameLength(twoArrayObject, nullArrayInt)); |
| assertFalse(ArrayUtils.isSameLength(twoArrayObject, nullArrayShort)); |
| assertFalse(ArrayUtils.isSameLength(twoArrayObject, nullArrayChar)); |
| assertFalse(ArrayUtils.isSameLength(twoArrayObject, nullArrayByte)); |
| assertFalse(ArrayUtils.isSameLength(twoArrayObject, nullArrayDouble)); |
| assertFalse(ArrayUtils.isSameLength(twoArrayObject, nullArrayFloat)); |
| assertFalse(ArrayUtils.isSameLength(twoArrayBoolean, nullArrayObject)); |
| assertFalse(ArrayUtils.isSameLength(twoArrayBoolean, nullArrayBoolean)); |
| assertFalse(ArrayUtils.isSameLength(twoArrayBoolean, nullArrayLong)); |
| assertFalse(ArrayUtils.isSameLength(twoArrayBoolean, nullArrayInt)); |
| assertFalse(ArrayUtils.isSameLength(twoArrayBoolean, nullArrayShort)); |
| assertFalse(ArrayUtils.isSameLength(twoArrayBoolean, nullArrayChar)); |
| assertFalse(ArrayUtils.isSameLength(twoArrayBoolean, nullArrayByte)); |
| assertFalse(ArrayUtils.isSameLength(twoArrayBoolean, nullArrayDouble)); |
| assertFalse(ArrayUtils.isSameLength(twoArrayBoolean, nullArrayFloat)); |
| assertFalse(ArrayUtils.isSameLength(twoArrayLong, nullArrayObject)); |
| assertFalse(ArrayUtils.isSameLength(twoArrayLong, nullArrayBoolean)); |
| assertFalse(ArrayUtils.isSameLength(twoArrayLong, nullArrayLong)); |
| assertFalse(ArrayUtils.isSameLength(twoArrayLong, nullArrayInt)); |
| assertFalse(ArrayUtils.isSameLength(twoArrayLong, nullArrayShort)); |
| assertFalse(ArrayUtils.isSameLength(twoArrayLong, nullArrayChar)); |
| assertFalse(ArrayUtils.isSameLength(twoArrayLong, nullArrayByte)); |
| assertFalse(ArrayUtils.isSameLength(twoArrayLong, nullArrayDouble)); |
| assertFalse(ArrayUtils.isSameLength(twoArrayLong, nullArrayFloat)); |
| assertFalse(ArrayUtils.isSameLength(twoArrayInt, nullArrayObject)); |
| assertFalse(ArrayUtils.isSameLength(twoArrayInt, nullArrayBoolean)); |
| assertFalse(ArrayUtils.isSameLength(twoArrayInt, nullArrayLong)); |
| assertFalse(ArrayUtils.isSameLength(twoArrayInt, nullArrayInt)); |
| assertFalse(ArrayUtils.isSameLength(twoArrayInt, nullArrayShort)); |
| assertFalse(ArrayUtils.isSameLength(twoArrayInt, nullArrayChar)); |
| assertFalse(ArrayUtils.isSameLength(twoArrayInt, nullArrayByte)); |
| assertFalse(ArrayUtils.isSameLength(twoArrayInt, nullArrayDouble)); |
| assertFalse(ArrayUtils.isSameLength(twoArrayInt, nullArrayFloat)); |
| assertFalse(ArrayUtils.isSameLength(twoArrayShort, nullArrayObject)); |
| assertFalse(ArrayUtils.isSameLength(twoArrayShort, nullArrayBoolean)); |
| assertFalse(ArrayUtils.isSameLength(twoArrayShort, nullArrayLong)); |
| assertFalse(ArrayUtils.isSameLength(twoArrayShort, nullArrayInt)); |
| assertFalse(ArrayUtils.isSameLength(twoArrayShort, nullArrayShort)); |
| assertFalse(ArrayUtils.isSameLength(twoArrayShort, nullArrayChar)); |
| assertFalse(ArrayUtils.isSameLength(twoArrayShort, nullArrayByte)); |
| assertFalse(ArrayUtils.isSameLength(twoArrayShort, nullArrayDouble)); |
| assertFalse(ArrayUtils.isSameLength(twoArrayShort, nullArrayFloat)); |
| assertFalse(ArrayUtils.isSameLength(twoArrayChar, nullArrayObject)); |
| assertFalse(ArrayUtils.isSameLength(twoArrayChar, nullArrayBoolean)); |
| assertFalse(ArrayUtils.isSameLength(twoArrayChar, nullArrayLong)); |
| assertFalse(ArrayUtils.isSameLength(twoArrayChar, nullArrayInt)); |
| assertFalse(ArrayUtils.isSameLength(twoArrayChar, nullArrayShort)); |
| assertFalse(ArrayUtils.isSameLength(twoArrayChar, nullArrayChar)); |
| assertFalse(ArrayUtils.isSameLength(twoArrayChar, nullArrayByte)); |
| assertFalse(ArrayUtils.isSameLength(twoArrayChar, nullArrayDouble)); |
| assertFalse(ArrayUtils.isSameLength(twoArrayChar, nullArrayFloat)); |
| assertFalse(ArrayUtils.isSameLength(twoArrayByte, nullArrayObject)); |
| assertFalse(ArrayUtils.isSameLength(twoArrayByte, nullArrayBoolean)); |
| assertFalse(ArrayUtils.isSameLength(twoArrayByte, nullArrayLong)); |
| assertFalse(ArrayUtils.isSameLength(twoArrayByte, nullArrayInt)); |
| assertFalse(ArrayUtils.isSameLength(twoArrayByte, nullArrayShort)); |
| assertFalse(ArrayUtils.isSameLength(twoArrayByte, nullArrayChar)); |
| assertFalse(ArrayUtils.isSameLength(twoArrayByte, nullArrayByte)); |
| assertFalse(ArrayUtils.isSameLength(twoArrayByte, nullArrayDouble)); |
| assertFalse(ArrayUtils.isSameLength(twoArrayByte, nullArrayFloat)); |
| assertFalse(ArrayUtils.isSameLength(twoArrayDouble, nullArrayObject)); |
| assertFalse(ArrayUtils.isSameLength(twoArrayDouble, nullArrayBoolean)); |
| assertFalse(ArrayUtils.isSameLength(twoArrayDouble, nullArrayLong)); |
| assertFalse(ArrayUtils.isSameLength(twoArrayDouble, nullArrayInt)); |
| assertFalse(ArrayUtils.isSameLength(twoArrayDouble, nullArrayShort)); |
| assertFalse(ArrayUtils.isSameLength(twoArrayDouble, nullArrayChar)); |
| assertFalse(ArrayUtils.isSameLength(twoArrayDouble, nullArrayByte)); |
| assertFalse(ArrayUtils.isSameLength(twoArrayDouble, nullArrayDouble)); |
| assertFalse(ArrayUtils.isSameLength(twoArrayDouble, nullArrayFloat)); |
| assertFalse(ArrayUtils.isSameLength(twoArrayFloat, nullArrayObject)); |
| assertFalse(ArrayUtils.isSameLength(twoArrayFloat, nullArrayBoolean)); |
| assertFalse(ArrayUtils.isSameLength(twoArrayFloat, nullArrayLong)); |
| assertFalse(ArrayUtils.isSameLength(twoArrayFloat, nullArrayInt)); |
| assertFalse(ArrayUtils.isSameLength(twoArrayFloat, nullArrayShort)); |
| assertFalse(ArrayUtils.isSameLength(twoArrayFloat, nullArrayChar)); |
| assertFalse(ArrayUtils.isSameLength(twoArrayFloat, nullArrayByte)); |
| assertFalse(ArrayUtils.isSameLength(twoArrayFloat, nullArrayDouble)); |
| assertFalse(ArrayUtils.isSameLength(twoArrayFloat, nullArrayFloat)); |
| assertFalse(ArrayUtils.isSameLength(twoArrayObject, emptyArrayObject)); |
| assertFalse(ArrayUtils.isSameLength(twoArrayObject, emptyArrayBoolean)); |
| assertFalse(ArrayUtils.isSameLength(twoArrayObject, emptyArrayLong)); |
| assertFalse(ArrayUtils.isSameLength(twoArrayObject, emptyArrayInt)); |
| assertFalse(ArrayUtils.isSameLength(twoArrayObject, emptyArrayShort)); |
| assertFalse(ArrayUtils.isSameLength(twoArrayObject, emptyArrayChar)); |
| assertFalse(ArrayUtils.isSameLength(twoArrayObject, emptyArrayByte)); |
| assertFalse(ArrayUtils.isSameLength(twoArrayObject, emptyArrayDouble)); |
| assertFalse(ArrayUtils.isSameLength(twoArrayObject, emptyArrayFloat)); |
| assertFalse(ArrayUtils.isSameLength(twoArrayBoolean, emptyArrayObject)); |
| assertFalse(ArrayUtils.isSameLength(twoArrayBoolean, emptyArrayBoolean)); |
| assertFalse(ArrayUtils.isSameLength(twoArrayBoolean, emptyArrayLong)); |
| assertFalse(ArrayUtils.isSameLength(twoArrayBoolean, emptyArrayInt)); |
| assertFalse(ArrayUtils.isSameLength(twoArrayBoolean, emptyArrayShort)); |
| assertFalse(ArrayUtils.isSameLength(twoArrayBoolean, emptyArrayChar)); |
| assertFalse(ArrayUtils.isSameLength(twoArrayBoolean, emptyArrayByte)); |
| assertFalse(ArrayUtils.isSameLength(twoArrayBoolean, emptyArrayDouble)); |
| assertFalse(ArrayUtils.isSameLength(twoArrayBoolean, emptyArrayFloat)); |
| assertFalse(ArrayUtils.isSameLength(twoArrayLong, emptyArrayObject)); |
| assertFalse(ArrayUtils.isSameLength(twoArrayLong, emptyArrayBoolean)); |
| assertFalse(ArrayUtils.isSameLength(twoArrayLong, emptyArrayLong)); |
| assertFalse(ArrayUtils.isSameLength(twoArrayLong, emptyArrayInt)); |
| assertFalse(ArrayUtils.isSameLength(twoArrayLong, emptyArrayShort)); |
| assertFalse(ArrayUtils.isSameLength(twoArrayLong, emptyArrayChar)); |
| assertFalse(ArrayUtils.isSameLength(twoArrayLong, emptyArrayByte)); |
| assertFalse(ArrayUtils.isSameLength(twoArrayLong, emptyArrayDouble)); |
| assertFalse(ArrayUtils.isSameLength(twoArrayLong, emptyArrayFloat)); |
| assertFalse(ArrayUtils.isSameLength(twoArrayInt, emptyArrayObject)); |
| assertFalse(ArrayUtils.isSameLength(twoArrayInt, emptyArrayBoolean)); |
| assertFalse(ArrayUtils.isSameLength(twoArrayInt, emptyArrayLong)); |
| assertFalse(ArrayUtils.isSameLength(twoArrayInt, emptyArrayInt)); |
| assertFalse(ArrayUtils.isSameLength(twoArrayInt, emptyArrayShort)); |
| assertFalse(ArrayUtils.isSameLength(twoArrayInt, emptyArrayChar)); |
| assertFalse(ArrayUtils.isSameLength(twoArrayInt, emptyArrayByte)); |
| assertFalse(ArrayUtils.isSameLength(twoArrayInt, emptyArrayDouble)); |
| assertFalse(ArrayUtils.isSameLength(twoArrayInt, emptyArrayFloat)); |
| assertFalse(ArrayUtils.isSameLength(twoArrayShort, emptyArrayObject)); |
| assertFalse(ArrayUtils.isSameLength(twoArrayShort, emptyArrayBoolean)); |
| assertFalse(ArrayUtils.isSameLength(twoArrayShort, emptyArrayLong)); |
| assertFalse(ArrayUtils.isSameLength(twoArrayShort, emptyArrayInt)); |
| assertFalse(ArrayUtils.isSameLength(twoArrayShort, emptyArrayShort)); |
| assertFalse(ArrayUtils.isSameLength(twoArrayShort, emptyArrayChar)); |
| assertFalse(ArrayUtils.isSameLength(twoArrayShort, emptyArrayByte)); |
| assertFalse(ArrayUtils.isSameLength(twoArrayShort, emptyArrayDouble)); |
| assertFalse(ArrayUtils.isSameLength(twoArrayShort, emptyArrayFloat)); |
| assertFalse(ArrayUtils.isSameLength(twoArrayChar, emptyArrayObject)); |
| assertFalse(ArrayUtils.isSameLength(twoArrayChar, emptyArrayBoolean)); |
| assertFalse(ArrayUtils.isSameLength(twoArrayChar, emptyArrayLong)); |
| assertFalse(ArrayUtils.isSameLength(twoArrayChar, emptyArrayInt)); |
| assertFalse(ArrayUtils.isSameLength(twoArrayChar, emptyArrayShort)); |
| assertFalse(ArrayUtils.isSameLength(twoArrayChar, emptyArrayChar)); |
| assertFalse(ArrayUtils.isSameLength(twoArrayChar, emptyArrayByte)); |
| assertFalse(ArrayUtils.isSameLength(twoArrayChar, emptyArrayDouble)); |
| assertFalse(ArrayUtils.isSameLength(twoArrayChar, emptyArrayFloat)); |
| assertFalse(ArrayUtils.isSameLength(twoArrayByte, emptyArrayObject)); |
| assertFalse(ArrayUtils.isSameLength(twoArrayByte, emptyArrayBoolean)); |
| assertFalse(ArrayUtils.isSameLength(twoArrayByte, emptyArrayLong)); |
| assertFalse(ArrayUtils.isSameLength(twoArrayByte, emptyArrayInt)); |
| assertFalse(ArrayUtils.isSameLength(twoArrayByte, emptyArrayShort)); |
| assertFalse(ArrayUtils.isSameLength(twoArrayByte, emptyArrayChar)); |
| assertFalse(ArrayUtils.isSameLength(twoArrayByte, emptyArrayByte)); |
| assertFalse(ArrayUtils.isSameLength(twoArrayByte, emptyArrayDouble)); |
| assertFalse(ArrayUtils.isSameLength(twoArrayByte, emptyArrayFloat)); |
| assertFalse(ArrayUtils.isSameLength(twoArrayDouble, emptyArrayObject)); |
| assertFalse(ArrayUtils.isSameLength(twoArrayDouble, emptyArrayBoolean)); |
| assertFalse(ArrayUtils.isSameLength(twoArrayDouble, emptyArrayLong)); |
| assertFalse(ArrayUtils.isSameLength(twoArrayDouble, emptyArrayInt)); |
| assertFalse(ArrayUtils.isSameLength(twoArrayDouble, emptyArrayShort)); |
| assertFalse(ArrayUtils.isSameLength(twoArrayDouble, emptyArrayChar)); |
| assertFalse(ArrayUtils.isSameLength(twoArrayDouble, emptyArrayByte)); |
| assertFalse(ArrayUtils.isSameLength(twoArrayDouble, emptyArrayDouble)); |
| assertFalse(ArrayUtils.isSameLength(twoArrayDouble, emptyArrayFloat)); |
| assertFalse(ArrayUtils.isSameLength(twoArrayFloat, emptyArrayObject)); |
| assertFalse(ArrayUtils.isSameLength(twoArrayFloat, emptyArrayBoolean)); |
| assertFalse(ArrayUtils.isSameLength(twoArrayFloat, emptyArrayLong)); |
| assertFalse(ArrayUtils.isSameLength(twoArrayFloat, emptyArrayInt)); |
| assertFalse(ArrayUtils.isSameLength(twoArrayFloat, emptyArrayShort)); |
| assertFalse(ArrayUtils.isSameLength(twoArrayFloat, emptyArrayChar)); |
| assertFalse(ArrayUtils.isSameLength(twoArrayFloat, emptyArrayByte)); |
| assertFalse(ArrayUtils.isSameLength(twoArrayFloat, emptyArrayDouble)); |
| assertFalse(ArrayUtils.isSameLength(twoArrayFloat, emptyArrayFloat)); |
| assertFalse(ArrayUtils.isSameLength(twoArrayObject, oneArrayObject)); |
| assertFalse(ArrayUtils.isSameLength(twoArrayObject, oneArrayBoolean)); |
| assertFalse(ArrayUtils.isSameLength(twoArrayObject, oneArrayLong)); |
| assertFalse(ArrayUtils.isSameLength(twoArrayObject, oneArrayInt)); |
| assertFalse(ArrayUtils.isSameLength(twoArrayObject, oneArrayShort)); |
| assertFalse(ArrayUtils.isSameLength(twoArrayObject, oneArrayChar)); |
| assertFalse(ArrayUtils.isSameLength(twoArrayObject, oneArrayByte)); |
| assertFalse(ArrayUtils.isSameLength(twoArrayObject, oneArrayDouble)); |
| assertFalse(ArrayUtils.isSameLength(twoArrayObject, oneArrayFloat)); |
| assertFalse(ArrayUtils.isSameLength(twoArrayBoolean, oneArrayObject)); |
| assertFalse(ArrayUtils.isSameLength(twoArrayBoolean, oneArrayBoolean)); |
| assertFalse(ArrayUtils.isSameLength(twoArrayBoolean, oneArrayLong)); |
| assertFalse(ArrayUtils.isSameLength(twoArrayBoolean, oneArrayInt)); |
| assertFalse(ArrayUtils.isSameLength(twoArrayBoolean, oneArrayShort)); |
| assertFalse(ArrayUtils.isSameLength(twoArrayBoolean, oneArrayChar)); |
| assertFalse(ArrayUtils.isSameLength(twoArrayBoolean, oneArrayByte)); |
| assertFalse(ArrayUtils.isSameLength(twoArrayBoolean, oneArrayDouble)); |
| assertFalse(ArrayUtils.isSameLength(twoArrayBoolean, oneArrayFloat)); |
| assertFalse(ArrayUtils.isSameLength(twoArrayLong, oneArrayObject)); |
| assertFalse(ArrayUtils.isSameLength(twoArrayLong, oneArrayBoolean)); |
| assertFalse(ArrayUtils.isSameLength(twoArrayLong, oneArrayLong)); |
| assertFalse(ArrayUtils.isSameLength(twoArrayLong, oneArrayInt)); |
| assertFalse(ArrayUtils.isSameLength(twoArrayLong, oneArrayShort)); |
| assertFalse(ArrayUtils.isSameLength(twoArrayLong, oneArrayChar)); |
| assertFalse(ArrayUtils.isSameLength(twoArrayLong, oneArrayByte)); |
| assertFalse(ArrayUtils.isSameLength(twoArrayLong, oneArrayDouble)); |
| assertFalse(ArrayUtils.isSameLength(twoArrayLong, oneArrayFloat)); |
| assertFalse(ArrayUtils.isSameLength(twoArrayInt, oneArrayObject)); |
| assertFalse(ArrayUtils.isSameLength(twoArrayInt, oneArrayBoolean)); |
| assertFalse(ArrayUtils.isSameLength(twoArrayInt, oneArrayLong)); |
| assertFalse(ArrayUtils.isSameLength(twoArrayInt, oneArrayInt)); |
| assertFalse(ArrayUtils.isSameLength(twoArrayInt, oneArrayShort)); |
| assertFalse(ArrayUtils.isSameLength(twoArrayInt, oneArrayChar)); |
| assertFalse(ArrayUtils.isSameLength(twoArrayInt, oneArrayByte)); |
| assertFalse(ArrayUtils.isSameLength(twoArrayInt, oneArrayDouble)); |
| assertFalse(ArrayUtils.isSameLength(twoArrayInt, oneArrayFloat)); |
| assertFalse(ArrayUtils.isSameLength(twoArrayShort, oneArrayObject)); |
| assertFalse(ArrayUtils.isSameLength(twoArrayShort, oneArrayBoolean)); |
| assertFalse(ArrayUtils.isSameLength(twoArrayShort, oneArrayLong)); |
| assertFalse(ArrayUtils.isSameLength(twoArrayShort, oneArrayInt)); |
| assertFalse(ArrayUtils.isSameLength(twoArrayShort, oneArrayShort)); |
| assertFalse(ArrayUtils.isSameLength(twoArrayShort, oneArrayChar)); |
| assertFalse(ArrayUtils.isSameLength(twoArrayShort, oneArrayByte)); |
| assertFalse(ArrayUtils.isSameLength(twoArrayShort, oneArrayDouble)); |
| assertFalse(ArrayUtils.isSameLength(twoArrayShort, oneArrayFloat)); |
| assertFalse(ArrayUtils.isSameLength(twoArrayChar, oneArrayObject)); |
| assertFalse(ArrayUtils.isSameLength(twoArrayChar, oneArrayBoolean)); |
| assertFalse(ArrayUtils.isSameLength(twoArrayChar, oneArrayLong)); |
| assertFalse(ArrayUtils.isSameLength(twoArrayChar, oneArrayInt)); |
| assertFalse(ArrayUtils.isSameLength(twoArrayChar, oneArrayShort)); |
| assertFalse(ArrayUtils.isSameLength(twoArrayChar, oneArrayChar)); |
| assertFalse(ArrayUtils.isSameLength(twoArrayChar, oneArrayByte)); |
| assertFalse(ArrayUtils.isSameLength(twoArrayChar, oneArrayDouble)); |
| assertFalse(ArrayUtils.isSameLength(twoArrayChar, oneArrayFloat)); |
| assertFalse(ArrayUtils.isSameLength(twoArrayByte, oneArrayObject)); |
| assertFalse(ArrayUtils.isSameLength(twoArrayByte, oneArrayBoolean)); |
| assertFalse(ArrayUtils.isSameLength(twoArrayByte, oneArrayLong)); |
| assertFalse(ArrayUtils.isSameLength(twoArrayByte, oneArrayInt)); |
| assertFalse(ArrayUtils.isSameLength(twoArrayByte, oneArrayShort)); |
| assertFalse(ArrayUtils.isSameLength(twoArrayByte, oneArrayChar)); |
| assertFalse(ArrayUtils.isSameLength(twoArrayByte, oneArrayByte)); |
| assertFalse(ArrayUtils.isSameLength(twoArrayByte, oneArrayDouble)); |
| assertFalse(ArrayUtils.isSameLength(twoArrayByte, oneArrayFloat)); |
| assertFalse(ArrayUtils.isSameLength(twoArrayDouble, oneArrayObject)); |
| assertFalse(ArrayUtils.isSameLength(twoArrayDouble, oneArrayBoolean)); |
| assertFalse(ArrayUtils.isSameLength(twoArrayDouble, oneArrayLong)); |
| assertFalse(ArrayUtils.isSameLength(twoArrayDouble, oneArrayInt)); |
| assertFalse(ArrayUtils.isSameLength(twoArrayDouble, oneArrayShort)); |
| assertFalse(ArrayUtils.isSameLength(twoArrayDouble, oneArrayChar)); |
| assertFalse(ArrayUtils.isSameLength(twoArrayDouble, oneArrayByte)); |
| assertFalse(ArrayUtils.isSameLength(twoArrayDouble, oneArrayDouble)); |
| assertFalse(ArrayUtils.isSameLength(twoArrayDouble, oneArrayFloat)); |
| assertFalse(ArrayUtils.isSameLength(twoArrayFloat, oneArrayObject)); |
| assertFalse(ArrayUtils.isSameLength(twoArrayFloat, oneArrayBoolean)); |
| assertFalse(ArrayUtils.isSameLength(twoArrayFloat, oneArrayLong)); |
| assertFalse(ArrayUtils.isSameLength(twoArrayFloat, oneArrayInt)); |
| assertFalse(ArrayUtils.isSameLength(twoArrayFloat, oneArrayShort)); |
| assertFalse(ArrayUtils.isSameLength(twoArrayFloat, oneArrayChar)); |
| assertFalse(ArrayUtils.isSameLength(twoArrayFloat, oneArrayByte)); |
| assertFalse(ArrayUtils.isSameLength(twoArrayFloat, oneArrayDouble)); |
| assertFalse(ArrayUtils.isSameLength(twoArrayFloat, oneArrayFloat)); |
| assertTrue(ArrayUtils.isSameLength(twoArrayObject, twoArrayObject)); |
| assertTrue(ArrayUtils.isSameLength(twoArrayObject, twoArrayBoolean)); |
| assertTrue(ArrayUtils.isSameLength(twoArrayObject, twoArrayLong)); |
| assertTrue(ArrayUtils.isSameLength(twoArrayObject, twoArrayInt)); |
| assertTrue(ArrayUtils.isSameLength(twoArrayObject, twoArrayShort)); |
| assertTrue(ArrayUtils.isSameLength(twoArrayObject, twoArrayChar)); |
| assertTrue(ArrayUtils.isSameLength(twoArrayObject, twoArrayByte)); |
| assertTrue(ArrayUtils.isSameLength(twoArrayObject, twoArrayDouble)); |
| assertTrue(ArrayUtils.isSameLength(twoArrayObject, twoArrayFloat)); |
| assertTrue(ArrayUtils.isSameLength(twoArrayBoolean, twoArrayObject)); |
| assertTrue(ArrayUtils.isSameLength(twoArrayBoolean, twoArrayBoolean)); |
| assertTrue(ArrayUtils.isSameLength(twoArrayBoolean, twoArrayLong)); |
| assertTrue(ArrayUtils.isSameLength(twoArrayBoolean, twoArrayInt)); |
| assertTrue(ArrayUtils.isSameLength(twoArrayBoolean, twoArrayShort)); |
| assertTrue(ArrayUtils.isSameLength(twoArrayBoolean, twoArrayChar)); |
| assertTrue(ArrayUtils.isSameLength(twoArrayBoolean, twoArrayByte)); |
| assertTrue(ArrayUtils.isSameLength(twoArrayBoolean, twoArrayDouble)); |
| assertTrue(ArrayUtils.isSameLength(twoArrayBoolean, twoArrayFloat)); |
| assertTrue(ArrayUtils.isSameLength(twoArrayLong, twoArrayObject)); |
| assertTrue(ArrayUtils.isSameLength(twoArrayLong, twoArrayBoolean)); |
| assertTrue(ArrayUtils.isSameLength(twoArrayLong, twoArrayLong)); |
| assertTrue(ArrayUtils.isSameLength(twoArrayLong, twoArrayInt)); |
| assertTrue(ArrayUtils.isSameLength(twoArrayLong, twoArrayShort)); |
| assertTrue(ArrayUtils.isSameLength(twoArrayLong, twoArrayChar)); |
| assertTrue(ArrayUtils.isSameLength(twoArrayLong, twoArrayByte)); |
| assertTrue(ArrayUtils.isSameLength(twoArrayLong, twoArrayDouble)); |
| assertTrue(ArrayUtils.isSameLength(twoArrayLong, twoArrayFloat)); |
| assertTrue(ArrayUtils.isSameLength(twoArrayInt, twoArrayObject)); |
| assertTrue(ArrayUtils.isSameLength(twoArrayInt, twoArrayBoolean)); |
| assertTrue(ArrayUtils.isSameLength(twoArrayInt, twoArrayLong)); |
| assertTrue(ArrayUtils.isSameLength(twoArrayInt, twoArrayInt)); |
| assertTrue(ArrayUtils.isSameLength(twoArrayInt, twoArrayShort)); |
| assertTrue(ArrayUtils.isSameLength(twoArrayInt, twoArrayChar)); |
| assertTrue(ArrayUtils.isSameLength(twoArrayInt, twoArrayByte)); |
| assertTrue(ArrayUtils.isSameLength(twoArrayInt, twoArrayDouble)); |
| assertTrue(ArrayUtils.isSameLength(twoArrayInt, twoArrayFloat)); |
| assertTrue(ArrayUtils.isSameLength(twoArrayShort, twoArrayObject)); |
| assertTrue(ArrayUtils.isSameLength(twoArrayShort, twoArrayBoolean)); |
| assertTrue(ArrayUtils.isSameLength(twoArrayShort, twoArrayLong)); |
| assertTrue(ArrayUtils.isSameLength(twoArrayShort, twoArrayInt)); |
| assertTrue(ArrayUtils.isSameLength(twoArrayShort, twoArrayShort)); |
| assertTrue(ArrayUtils.isSameLength(twoArrayShort, twoArrayChar)); |
| assertTrue(ArrayUtils.isSameLength(twoArrayShort, twoArrayByte)); |
| assertTrue(ArrayUtils.isSameLength(twoArrayShort, twoArrayDouble)); |
| assertTrue(ArrayUtils.isSameLength(twoArrayShort, twoArrayFloat)); |
| assertTrue(ArrayUtils.isSameLength(twoArrayChar, twoArrayObject)); |
| assertTrue(ArrayUtils.isSameLength(twoArrayChar, twoArrayBoolean)); |
| assertTrue(ArrayUtils.isSameLength(twoArrayChar, twoArrayLong)); |
| assertTrue(ArrayUtils.isSameLength(twoArrayChar, twoArrayInt)); |
| assertTrue(ArrayUtils.isSameLength(twoArrayChar, twoArrayShort)); |
| assertTrue(ArrayUtils.isSameLength(twoArrayChar, twoArrayChar)); |
| assertTrue(ArrayUtils.isSameLength(twoArrayChar, twoArrayByte)); |
| assertTrue(ArrayUtils.isSameLength(twoArrayChar, twoArrayDouble)); |
| assertTrue(ArrayUtils.isSameLength(twoArrayChar, twoArrayFloat)); |
| assertTrue(ArrayUtils.isSameLength(twoArrayByte, twoArrayObject)); |
| assertTrue(ArrayUtils.isSameLength(twoArrayByte, twoArrayBoolean)); |
| assertTrue(ArrayUtils.isSameLength(twoArrayByte, twoArrayLong)); |
| assertTrue(ArrayUtils.isSameLength(twoArrayByte, twoArrayInt)); |
| assertTrue(ArrayUtils.isSameLength(twoArrayByte, twoArrayShort)); |
| assertTrue(ArrayUtils.isSameLength(twoArrayByte, twoArrayChar)); |
| assertTrue(ArrayUtils.isSameLength(twoArrayByte, twoArrayByte)); |
| assertTrue(ArrayUtils.isSameLength(twoArrayByte, twoArrayDouble)); |
| assertTrue(ArrayUtils.isSameLength(twoArrayByte, twoArrayFloat)); |
| assertTrue(ArrayUtils.isSameLength(twoArrayDouble, twoArrayObject)); |
| assertTrue(ArrayUtils.isSameLength(twoArrayDouble, twoArrayBoolean)); |
| assertTrue(ArrayUtils.isSameLength(twoArrayDouble, twoArrayLong)); |
| assertTrue(ArrayUtils.isSameLength(twoArrayDouble, twoArrayInt)); |
| assertTrue(ArrayUtils.isSameLength(twoArrayDouble, twoArrayShort)); |
| assertTrue(ArrayUtils.isSameLength(twoArrayDouble, twoArrayChar)); |
| assertTrue(ArrayUtils.isSameLength(twoArrayDouble, twoArrayByte)); |
| assertTrue(ArrayUtils.isSameLength(twoArrayDouble, twoArrayDouble)); |
| assertTrue(ArrayUtils.isSameLength(twoArrayDouble, twoArrayFloat)); |
| assertTrue(ArrayUtils.isSameLength(twoArrayFloat, twoArrayObject)); |
| assertTrue(ArrayUtils.isSameLength(twoArrayFloat, twoArrayBoolean)); |
| assertTrue(ArrayUtils.isSameLength(twoArrayFloat, twoArrayLong)); |
| assertTrue(ArrayUtils.isSameLength(twoArrayFloat, twoArrayInt)); |
| assertTrue(ArrayUtils.isSameLength(twoArrayFloat, twoArrayShort)); |
| assertTrue(ArrayUtils.isSameLength(twoArrayFloat, twoArrayChar)); |
| assertTrue(ArrayUtils.isSameLength(twoArrayFloat, twoArrayByte)); |
| assertTrue(ArrayUtils.isSameLength(twoArrayFloat, twoArrayDouble)); |
| assertTrue(ArrayUtils.isSameLength(twoArrayFloat, twoArrayFloat)); |
| } |
| |
| @Test |
| public void testSameLengthBoolean() { |
| final boolean[] nullArray = null; |
| final boolean[] emptyArray = {}; |
| final boolean[] oneArray = {true}; |
| final boolean[] twoArray = {true, false}; |
| |
| assertTrue(ArrayUtils.isSameLength(nullArray, nullArray)); |
| assertTrue(ArrayUtils.isSameLength(nullArray, emptyArray)); |
| assertFalse(ArrayUtils.isSameLength(nullArray, oneArray)); |
| assertFalse(ArrayUtils.isSameLength(nullArray, twoArray)); |
| |
| assertTrue(ArrayUtils.isSameLength(emptyArray, nullArray)); |
| assertTrue(ArrayUtils.isSameLength(emptyArray, emptyArray)); |
| assertFalse(ArrayUtils.isSameLength(emptyArray, oneArray)); |
| assertFalse(ArrayUtils.isSameLength(emptyArray, twoArray)); |
| |
| assertFalse(ArrayUtils.isSameLength(oneArray, nullArray)); |
| assertFalse(ArrayUtils.isSameLength(oneArray, emptyArray)); |
| assertTrue(ArrayUtils.isSameLength(oneArray, oneArray)); |
| assertFalse(ArrayUtils.isSameLength(oneArray, twoArray)); |
| |
| assertFalse(ArrayUtils.isSameLength(twoArray, nullArray)); |
| assertFalse(ArrayUtils.isSameLength(twoArray, emptyArray)); |
| assertFalse(ArrayUtils.isSameLength(twoArray, oneArray)); |
| assertTrue(ArrayUtils.isSameLength(twoArray, twoArray)); |
| } |
| |
| @Test |
| public void testSameLengthByte() { |
| final byte[] nullArray = null; |
| final byte[] emptyArray = {}; |
| final byte[] oneArray = {3}; |
| final byte[] twoArray = {4, 6}; |
| |
| assertTrue(ArrayUtils.isSameLength(nullArray, nullArray)); |
| assertTrue(ArrayUtils.isSameLength(nullArray, emptyArray)); |
| assertFalse(ArrayUtils.isSameLength(nullArray, oneArray)); |
| assertFalse(ArrayUtils.isSameLength(nullArray, twoArray)); |
| |
| assertTrue(ArrayUtils.isSameLength(emptyArray, nullArray)); |
| assertTrue(ArrayUtils.isSameLength(emptyArray, emptyArray)); |
| assertFalse(ArrayUtils.isSameLength(emptyArray, oneArray)); |
| assertFalse(ArrayUtils.isSameLength(emptyArray, twoArray)); |
| |
| assertFalse(ArrayUtils.isSameLength(oneArray, nullArray)); |
| assertFalse(ArrayUtils.isSameLength(oneArray, emptyArray)); |
| assertTrue(ArrayUtils.isSameLength(oneArray, oneArray)); |
| assertFalse(ArrayUtils.isSameLength(oneArray, twoArray)); |
| |
| assertFalse(ArrayUtils.isSameLength(twoArray, nullArray)); |
| assertFalse(ArrayUtils.isSameLength(twoArray, emptyArray)); |
| assertFalse(ArrayUtils.isSameLength(twoArray, oneArray)); |
| assertTrue(ArrayUtils.isSameLength(twoArray, twoArray)); |
| } |
| |
| @Test |
| public void testSameLengthChar() { |
| final char[] nullArray = null; |
| final char[] emptyArray = {}; |
| final char[] oneArray = {'f'}; |
| final char[] twoArray = {'d', 't'}; |
| |
| assertTrue(ArrayUtils.isSameLength(nullArray, nullArray)); |
| assertTrue(ArrayUtils.isSameLength(nullArray, emptyArray)); |
| assertFalse(ArrayUtils.isSameLength(nullArray, oneArray)); |
| assertFalse(ArrayUtils.isSameLength(nullArray, twoArray)); |
| |
| assertTrue(ArrayUtils.isSameLength(emptyArray, nullArray)); |
| assertTrue(ArrayUtils.isSameLength(emptyArray, emptyArray)); |
| assertFalse(ArrayUtils.isSameLength(emptyArray, oneArray)); |
| assertFalse(ArrayUtils.isSameLength(emptyArray, twoArray)); |
| |
| assertFalse(ArrayUtils.isSameLength(oneArray, nullArray)); |
| assertFalse(ArrayUtils.isSameLength(oneArray, emptyArray)); |
| assertTrue(ArrayUtils.isSameLength(oneArray, oneArray)); |
| assertFalse(ArrayUtils.isSameLength(oneArray, twoArray)); |
| |
| assertFalse(ArrayUtils.isSameLength(twoArray, nullArray)); |
| assertFalse(ArrayUtils.isSameLength(twoArray, emptyArray)); |
| assertFalse(ArrayUtils.isSameLength(twoArray, oneArray)); |
| assertTrue(ArrayUtils.isSameLength(twoArray, twoArray)); |
| } |
| |
| @Test |
| public void testSameLengthDouble() { |
| final double[] nullArray = null; |
| final double[] emptyArray = {}; |
| final double[] oneArray = {1.3d}; |
| final double[] twoArray = {4.5d, 6.3d}; |
| |
| assertTrue(ArrayUtils.isSameLength(nullArray, nullArray)); |
| assertTrue(ArrayUtils.isSameLength(nullArray, emptyArray)); |
| assertFalse(ArrayUtils.isSameLength(nullArray, oneArray)); |
| assertFalse(ArrayUtils.isSameLength(nullArray, twoArray)); |
| |
| assertTrue(ArrayUtils.isSameLength(emptyArray, nullArray)); |
| assertTrue(ArrayUtils.isSameLength(emptyArray, emptyArray)); |
| assertFalse(ArrayUtils.isSameLength(emptyArray, oneArray)); |
| assertFalse(ArrayUtils.isSameLength(emptyArray, twoArray)); |
| |
| assertFalse(ArrayUtils.isSameLength(oneArray, nullArray)); |
| assertFalse(ArrayUtils.isSameLength(oneArray, emptyArray)); |
| assertTrue(ArrayUtils.isSameLength(oneArray, oneArray)); |
| assertFalse(ArrayUtils.isSameLength(oneArray, twoArray)); |
| |
| assertFalse(ArrayUtils.isSameLength(twoArray, nullArray)); |
| assertFalse(ArrayUtils.isSameLength(twoArray, emptyArray)); |
| assertFalse(ArrayUtils.isSameLength(twoArray, oneArray)); |
| assertTrue(ArrayUtils.isSameLength(twoArray, twoArray)); |
| } |
| |
| @Test |
| public void testSameLengthFloat() { |
| final float[] nullArray = null; |
| final float[] emptyArray = {}; |
| final float[] oneArray = {2.5f}; |
| final float[] twoArray = {6.4f, 5.8f}; |
| |
| assertTrue(ArrayUtils.isSameLength(nullArray, nullArray)); |
| assertTrue(ArrayUtils.isSameLength(nullArray, emptyArray)); |
| assertFalse(ArrayUtils.isSameLength(nullArray, oneArray)); |
| assertFalse(ArrayUtils.isSameLength(nullArray, twoArray)); |
| |
| assertTrue(ArrayUtils.isSameLength(emptyArray, nullArray)); |
| assertTrue(ArrayUtils.isSameLength(emptyArray, emptyArray)); |
| assertFalse(ArrayUtils.isSameLength(emptyArray, oneArray)); |
| assertFalse(ArrayUtils.isSameLength(emptyArray, twoArray)); |
| |
| assertFalse(ArrayUtils.isSameLength(oneArray, nullArray)); |
| assertFalse(ArrayUtils.isSameLength(oneArray, emptyArray)); |
| assertTrue(ArrayUtils.isSameLength(oneArray, oneArray)); |
| assertFalse(ArrayUtils.isSameLength(oneArray, twoArray)); |
| |
| assertFalse(ArrayUtils.isSameLength(twoArray, nullArray)); |
| assertFalse(ArrayUtils.isSameLength(twoArray, emptyArray)); |
| assertFalse(ArrayUtils.isSameLength(twoArray, oneArray)); |
| assertTrue(ArrayUtils.isSameLength(twoArray, twoArray)); |
| } |
| |
| @Test |
| public void testSameLengthInt() { |
| final int[] nullArray = null; |
| final int[] emptyArray = {}; |
| final int[] oneArray = {4}; |
| final int[] twoArray = {5, 7}; |
| |
| assertTrue(ArrayUtils.isSameLength(nullArray, nullArray)); |
| assertTrue(ArrayUtils.isSameLength(nullArray, emptyArray)); |
| assertFalse(ArrayUtils.isSameLength(nullArray, oneArray)); |
| assertFalse(ArrayUtils.isSameLength(nullArray, twoArray)); |
| |
| assertTrue(ArrayUtils.isSameLength(emptyArray, nullArray)); |
| assertTrue(ArrayUtils.isSameLength(emptyArray, emptyArray)); |
| assertFalse(ArrayUtils.isSameLength(emptyArray, oneArray)); |
| assertFalse(ArrayUtils.isSameLength(emptyArray, twoArray)); |
| |
| assertFalse(ArrayUtils.isSameLength(oneArray, nullArray)); |
| assertFalse(ArrayUtils.isSameLength(oneArray, emptyArray)); |
| assertTrue(ArrayUtils.isSameLength(oneArray, oneArray)); |
| assertFalse(ArrayUtils.isSameLength(oneArray, twoArray)); |
| |
| assertFalse(ArrayUtils.isSameLength(twoArray, nullArray)); |
| assertFalse(ArrayUtils.isSameLength(twoArray, emptyArray)); |
| assertFalse(ArrayUtils.isSameLength(twoArray, oneArray)); |
| assertTrue(ArrayUtils.isSameLength(twoArray, twoArray)); |
| } |
| |
| @Test |
| public void testSameLengthLong() { |
| final long[] nullArray = null; |
| final long[] emptyArray = {}; |
| final long[] oneArray = {0L}; |
| final long[] twoArray = {0L, 76L}; |
| |
| assertTrue(ArrayUtils.isSameLength(nullArray, nullArray)); |
| assertTrue(ArrayUtils.isSameLength(nullArray, emptyArray)); |
| assertFalse(ArrayUtils.isSameLength(nullArray, oneArray)); |
| assertFalse(ArrayUtils.isSameLength(nullArray, twoArray)); |
| |
| assertTrue(ArrayUtils.isSameLength(emptyArray, nullArray)); |
| assertTrue(ArrayUtils.isSameLength(emptyArray, emptyArray)); |
| assertFalse(ArrayUtils.isSameLength(emptyArray, oneArray)); |
| assertFalse(ArrayUtils.isSameLength(emptyArray, twoArray)); |
| |
| assertFalse(ArrayUtils.isSameLength(oneArray, nullArray)); |
| assertFalse(ArrayUtils.isSameLength(oneArray, emptyArray)); |
| assertTrue(ArrayUtils.isSameLength(oneArray, oneArray)); |
| assertFalse(ArrayUtils.isSameLength(oneArray, twoArray)); |
| |
| assertFalse(ArrayUtils.isSameLength(twoArray, nullArray)); |
| assertFalse(ArrayUtils.isSameLength(twoArray, emptyArray)); |
| assertFalse(ArrayUtils.isSameLength(twoArray, oneArray)); |
| assertTrue(ArrayUtils.isSameLength(twoArray, twoArray)); |
| } |
| |
| @Test |
| public void testSameLengthShort() { |
| final short[] nullArray = null; |
| final short[] emptyArray = {}; |
| final short[] oneArray = {4}; |
| final short[] twoArray = {6, 8}; |
| |
| assertTrue(ArrayUtils.isSameLength(nullArray, nullArray)); |
| assertTrue(ArrayUtils.isSameLength(nullArray, emptyArray)); |
| assertFalse(ArrayUtils.isSameLength(nullArray, oneArray)); |
| assertFalse(ArrayUtils.isSameLength(nullArray, twoArray)); |
| |
| assertTrue(ArrayUtils.isSameLength(emptyArray, nullArray)); |
| assertTrue(ArrayUtils.isSameLength(emptyArray, emptyArray)); |
| assertFalse(ArrayUtils.isSameLength(emptyArray, oneArray)); |
| assertFalse(ArrayUtils.isSameLength(emptyArray, twoArray)); |
| |
| assertFalse(ArrayUtils.isSameLength(oneArray, nullArray)); |
| assertFalse(ArrayUtils.isSameLength(oneArray, emptyArray)); |
| assertTrue(ArrayUtils.isSameLength(oneArray, oneArray)); |
| assertFalse(ArrayUtils.isSameLength(oneArray, twoArray)); |
| |
| assertFalse(ArrayUtils.isSameLength(twoArray, nullArray)); |
| assertFalse(ArrayUtils.isSameLength(twoArray, emptyArray)); |
| assertFalse(ArrayUtils.isSameLength(twoArray, oneArray)); |
| assertTrue(ArrayUtils.isSameLength(twoArray, twoArray)); |
| } |
| |
| @Test |
| public void testSameType() { |
| assertThrows(IllegalArgumentException.class, () -> ArrayUtils.isSameType(null, null)); |
| assertThrows(IllegalArgumentException.class, () -> ArrayUtils.isSameType(null, new Object[0])); |
| assertThrows(IllegalArgumentException.class, () -> ArrayUtils.isSameType(new Object[0], null)); |
| |
| assertTrue(ArrayUtils.isSameType(new Object[0], new Object[0])); |
| assertFalse(ArrayUtils.isSameType(new String[0], new Object[0])); |
| assertTrue(ArrayUtils.isSameType(new String[0][0], new String[0][0])); |
| assertFalse(ArrayUtils.isSameType(new String[0], new String[0][0])); |
| assertFalse(ArrayUtils.isSameType(new String[0][0], new String[0])); |
| } |
| |
| @Test |
| public void testShiftAllByte() { |
| final byte[] array = {1, 2, 3, 4}; |
| ArrayUtils.shift(array, 4); |
| assertEquals(1, array[0]); |
| assertEquals(2, array[1]); |
| assertEquals(3, array[2]); |
| assertEquals(4, array[3]); |
| ArrayUtils.shift(array, -4); |
| assertEquals(1, array[0]); |
| assertEquals(2, array[1]); |
| assertEquals(3, array[2]); |
| assertEquals(4, array[3]); |
| } |
| |
| @Test |
| public void testShiftAllChar() { |
| final char[] array = {1, 2, 3, 4}; |
| ArrayUtils.shift(array, 4); |
| assertEquals(1, array[0]); |
| assertEquals(2, array[1]); |
| assertEquals(3, array[2]); |
| assertEquals(4, array[3]); |
| ArrayUtils.shift(array, -4); |
| assertEquals(1, array[0]); |
| assertEquals(2, array[1]); |
| assertEquals(3, array[2]); |
| assertEquals(4, array[3]); |
| } |
| |
| @Test |
| public void testShiftAllDouble() { |
| final double[] array = {1, 2, 3, 4}; |
| ArrayUtils.shift(array, 4); |
| assertEquals(1, array[0]); |
| assertEquals(2, array[1]); |
| assertEquals(3, array[2]); |
| assertEquals(4, array[3]); |
| ArrayUtils.shift(array, -4); |
| assertEquals(1, array[0]); |
| assertEquals(2, array[1]); |
| assertEquals(3, array[2]); |
| assertEquals(4, array[3]); |
| } |
| |
| @Test |
| public void testShiftAllFloat() { |
| final float[] array = {1, 2, 3, 4}; |
| ArrayUtils.shift(array, 4); |
| assertEquals(1, array[0]); |
| assertEquals(2, array[1]); |
| assertEquals(3, array[2]); |
| assertEquals(4, array[3]); |
| ArrayUtils.shift(array, -4); |
| assertEquals(1, array[0]); |
| assertEquals(2, array[1]); |
| assertEquals(3, array[2]); |
| assertEquals(4, array[3]); |
| } |
| |
| @Test |
| public void testShiftAllInt() { |
| final int[] array = {1, 2, 3, 4}; |
| ArrayUtils.shift(array, 4); |
| assertEquals(1, array[0]); |
| assertEquals(2, array[1]); |
| assertEquals(3, array[2]); |
| assertEquals(4, array[3]); |
| ArrayUtils.shift(array, -4); |
| assertEquals(1, array[0]); |
| assertEquals(2, array[1]); |
| assertEquals(3, array[2]); |
| assertEquals(4, array[3]); |
| } |
| |
| @Test |
| public void testShiftAllLong() { |
| final long[] array = {1, 2, 3, 4}; |
| ArrayUtils.shift(array, 4); |
| assertEquals(1, array[0]); |
| assertEquals(2, array[1]); |
| assertEquals(3, array[2]); |
| assertEquals(4, array[3]); |
| ArrayUtils.shift(array, -4); |
| assertEquals(1, array[0]); |
| assertEquals(2, array[1]); |
| assertEquals(3, array[2]); |
| assertEquals(4, array[3]); |
| } |
| |
| @Test |
| public void testShiftAllObject() { |
| final String[] array = {"1", "2", "3", "4"}; |
| ArrayUtils.shift(array, 4); |
| assertEquals("1", array[0]); |
| assertEquals("2", array[1]); |
| assertEquals("3", array[2]); |
| assertEquals("4", array[3]); |
| ArrayUtils.shift(array, -4); |
| assertEquals("1", array[0]); |
| assertEquals("2", array[1]); |
| assertEquals("3", array[2]); |
| assertEquals("4", array[3]); |
| } |
| |
| @Test |
| public void testShiftAllShort() { |
| final short[] array = {1, 2, 3, 4}; |
| ArrayUtils.shift(array, 4); |
| assertEquals(1, array[0]); |
| assertEquals(2, array[1]); |
| assertEquals(3, array[2]); |
| assertEquals(4, array[3]); |
| ArrayUtils.shift(array, -4); |
| assertEquals(1, array[0]); |
| assertEquals(2, array[1]); |
| assertEquals(3, array[2]); |
| assertEquals(4, array[3]); |
| } |
| |
| @Test |
| public void testShiftBoolean() { |
| final boolean[] array = {true, true, false, false}; |
| |
| ArrayUtils.shift(array, 1); |
| assertFalse(array[0]); |
| assertTrue(array[1]); |
| assertTrue(array[2]); |
| assertFalse(array[3]); |
| |
| ArrayUtils.shift(array, -1); |
| assertTrue(array[0]); |
| assertTrue(array[1]); |
| assertFalse(array[2]); |
| assertFalse(array[3]); |
| |
| ArrayUtils.shift(array, 5); |
| assertFalse(array[0]); |
| assertTrue(array[1]); |
| assertTrue(array[2]); |
| assertFalse(array[3]); |
| |
| ArrayUtils.shift(array, -3); |
| assertFalse(array[0]); |
| assertFalse(array[1]); |
| assertTrue(array[2]); |
| assertTrue(array[3]); |
| } |
| |
| @Test |
| public void testShiftByte() { |
| final byte[] array = {1, 2, 3, 4}; |
| ArrayUtils.shift(array, 1); |
| assertEquals(4, array[0]); |
| assertEquals(1, array[1]); |
| assertEquals(2, array[2]); |
| assertEquals(3, array[3]); |
| ArrayUtils.shift(array, -1); |
| assertEquals(1, array[0]); |
| assertEquals(2, array[1]); |
| assertEquals(3, array[2]); |
| assertEquals(4, array[3]); |
| ArrayUtils.shift(array, 5); |
| assertEquals(4, array[0]); |
| assertEquals(1, array[1]); |
| assertEquals(2, array[2]); |
| assertEquals(3, array[3]); |
| ArrayUtils.shift(array, -3); |
| assertEquals(3, array[0]); |
| assertEquals(4, array[1]); |
| assertEquals(1, array[2]); |
| assertEquals(2, array[3]); |
| } |
| |
| @Test |
| public void testShiftChar() { |
| final char[] array = {1, 2, 3, 4}; |
| ArrayUtils.shift(array, 1); |
| assertEquals(4, array[0]); |
| assertEquals(1, array[1]); |
| assertEquals(2, array[2]); |
| assertEquals(3, array[3]); |
| ArrayUtils.shift(array, -1); |
| assertEquals(1, array[0]); |
| assertEquals(2, array[1]); |
| assertEquals(3, array[2]); |
| assertEquals(4, array[3]); |
| ArrayUtils.shift(array, 5); |
| assertEquals(4, array[0]); |
| assertEquals(1, array[1]); |
| assertEquals(2, array[2]); |
| assertEquals(3, array[3]); |
| ArrayUtils.shift(array, -3); |
| assertEquals(3, array[0]); |
| assertEquals(4, array[1]); |
| assertEquals(1, array[2]); |
| assertEquals(2, array[3]); |
| } |
| |
| @Test |
| public void testShiftDouble() { |
| final double[] array = {1, 2, 3, 4}; |
| ArrayUtils.shift(array, 1); |
| assertEquals(4, array[0]); |
| assertEquals(1, array[1]); |
| assertEquals(2, array[2]); |
| assertEquals(3, array[3]); |
| ArrayUtils.shift(array, -1); |
| assertEquals(1, array[0]); |
| assertEquals(2, array[1]); |
| assertEquals(3, array[2]); |
| assertEquals(4, array[3]); |
| ArrayUtils.shift(array, 5); |
| assertEquals(4, array[0]); |
| assertEquals(1, array[1]); |
| assertEquals(2, array[2]); |
| assertEquals(3, array[3]); |
| ArrayUtils.shift(array, -3); |
| assertEquals(3, array[0]); |
| assertEquals(4, array[1]); |
| assertEquals(1, array[2]); |
| assertEquals(2, array[3]); |
| } |
| |
| @Test |
| public void testShiftFloat() { |
| final float[] array = {1, 2, 3, 4}; |
| ArrayUtils.shift(array, 1); |
| assertEquals(4, array[0]); |
| assertEquals(1, array[1]); |
| assertEquals(2, array[2]); |
| assertEquals(3, array[3]); |
| ArrayUtils.shift(array, -1); |
| assertEquals(1, array[0]); |
| assertEquals(2, array[1]); |
| assertEquals(3, array[2]); |
| assertEquals(4, array[3]); |
| ArrayUtils.shift(array, 5); |
| assertEquals(4, array[0]); |
| assertEquals(1, array[1]); |
| assertEquals(2, array[2]); |
| assertEquals(3, array[3]); |
| ArrayUtils.shift(array, -3); |
| assertEquals(3, array[0]); |
| assertEquals(4, array[1]); |
| assertEquals(1, array[2]); |
| assertEquals(2, array[3]); |
| } |
| |
| |
| @Test |
| public void testShiftInt() { |
| final int[] array = {1, 2, 3, 4}; |
| ArrayUtils.shift(array, 1); |
| assertEquals(4, array[0]); |
| assertEquals(1, array[1]); |
| assertEquals(2, array[2]); |
| assertEquals(3, array[3]); |
| ArrayUtils.shift(array, -1); |
| assertEquals(1, array[0]); |
| assertEquals(2, array[1]); |
| assertEquals(3, array[2]); |
| assertEquals(4, array[3]); |
| ArrayUtils.shift(array, 5); |
| assertEquals(4, array[0]); |
| assertEquals(1, array[1]); |
| assertEquals(2, array[2]); |
| assertEquals(3, array[3]); |
| ArrayUtils.shift(array, -3); |
| assertEquals(3, array[0]); |
| assertEquals(4, array[1]); |
| assertEquals(1, array[2]); |
| assertEquals(2, array[3]); |
| } |
| |
| @Test |
| public void testShiftLong() { |
| final long[] array = {1, 2, 3, 4}; |
| ArrayUtils.shift(array, 1); |
| assertEquals(4, array[0]); |
| assertEquals(1, array[1]); |
| assertEquals(2, array[2]); |
| assertEquals(3, array[3]); |
| ArrayUtils.shift(array, -1); |
| assertEquals(1, array[0]); |
| assertEquals(2, array[1]); |
| assertEquals(3, array[2]); |
| assertEquals(4, array[3]); |
| ArrayUtils.shift(array, 5); |
| assertEquals(4, array[0]); |
| assertEquals(1, array[1]); |
| assertEquals(2, array[2]); |
| assertEquals(3, array[3]); |
| ArrayUtils.shift(array, -3); |
| assertEquals(3, array[0]); |
| assertEquals(4, array[1]); |
| assertEquals(1, array[2]); |
| assertEquals(2, array[3]); |
| } |
| |
| @Test |
| public void testShiftNullBoolean() { |
| final boolean[] array = null; |
| |
| ArrayUtils.shift(array, 1); |
| assertNull(array); |
| } |
| |
| @Test |
| public void testShiftNullDouble() { |
| final double[] array = null; |
| |
| ArrayUtils.shift(array, 1); |
| assertNull(array); |
| } |
| |
| @Test |
| public void testShiftNullFloat() { |
| final float[] array = null; |
| |
| ArrayUtils.shift(array, 1); |
| assertNull(array); |
| } |
| |
| @Test |
| public void testShiftNullInt() { |
| final int[] array = null; |
| |
| ArrayUtils.shift(array, 1); |
| assertNull(array); |
| } |
| |
| @Test |
| public void testShiftNullLong() { |
| final long[] array = null; |
| |
| ArrayUtils.shift(array, 1); |
| assertNull(array); |
| } |
| |
| @Test |
| public void testShiftNullObject() { |
| final String[] array = null; |
| |
| ArrayUtils.shift(array, 1); |
| assertNull(array); |
| } |
| |
| @Test |
| public void testShiftNullShort() { |
| final short[] array = null; |
| |
| ArrayUtils.shift(array, 1); |
| assertNull(array); |
| } |
| |
| @Test |
| public void testShiftObject() { |
| final String[] array = {"1", "2", "3", "4"}; |
| ArrayUtils.shift(array, 1); |
| assertEquals("4", array[0]); |
| assertEquals("1", array[1]); |
| assertEquals("2", array[2]); |
| assertEquals("3", array[3]); |
| ArrayUtils.shift(array, -1); |
| assertEquals("1", array[0]); |
| assertEquals("2", array[1]); |
| assertEquals("3", array[2]); |
| assertEquals("4", array[3]); |
| ArrayUtils.shift(array, 5); |
| assertEquals("4", array[0]); |
| assertEquals("1", array[1]); |
| assertEquals("2", array[2]); |
| assertEquals("3", array[3]); |
| ArrayUtils.shift(array, -3); |
| assertEquals("3", array[0]); |
| assertEquals("4", array[1]); |
| assertEquals("1", array[2]); |
| assertEquals("2", array[3]); |
| } |
| |
| @Test |
| public void testShiftRangeByte() { |
| final byte[] array = {1, 2, 3, 4, 5}; |
| ArrayUtils.shift(array, 1, 3, 1); |
| assertEquals(1, array[0]); |
| assertEquals(3, array[1]); |
| assertEquals(2, array[2]); |
| assertEquals(4, array[3]); |
| assertEquals(5, array[4]); |
| ArrayUtils.shift(array, 1, 4, 2); |
| assertEquals(1, array[0]); |
| assertEquals(2, array[1]); |
| assertEquals(4, array[2]); |
| assertEquals(3, array[3]); |
| assertEquals(5, array[4]); |
| } |
| |
| @Test |
| public void testShiftRangeChar() { |
| final char[] array = {1, 2, 3, 4, 5}; |
| ArrayUtils.shift(array, 1, 3, 1); |
| assertEquals(1, array[0]); |
| assertEquals(3, array[1]); |
| assertEquals(2, array[2]); |
| assertEquals(4, array[3]); |
| assertEquals(5, array[4]); |
| ArrayUtils.shift(array, 1, 4, 2); |
| assertEquals(1, array[0]); |
| assertEquals(2, array[1]); |
| assertEquals(4, array[2]); |
| assertEquals(3, array[3]); |
| assertEquals(5, array[4]); |
| } |
| |
| @Test |
| public void testShiftRangeDouble() { |
| final double[] array = {1, 2, 3, 4, 5}; |
| ArrayUtils.shift(array, 1, 3, 1); |
| assertEquals(1, array[0]); |
| assertEquals(3, array[1]); |
| assertEquals(2, array[2]); |
| assertEquals(4, array[3]); |
| assertEquals(5, array[4]); |
| ArrayUtils.shift(array, 1, 4, 2); |
| assertEquals(1, array[0]); |
| assertEquals(2, array[1]); |
| assertEquals(4, array[2]); |
| assertEquals(3, array[3]); |
| assertEquals(5, array[4]); |
| } |
| |
| @Test |
| public void testShiftRangeFloat() { |
| final float[] array = {1, 2, 3, 4, 5}; |
| ArrayUtils.shift(array, 1, 3, 1); |
| assertEquals(1, array[0]); |
| assertEquals(3, array[1]); |
| assertEquals(2, array[2]); |
| assertEquals(4, array[3]); |
| assertEquals(5, array[4]); |
| ArrayUtils.shift(array, 1, 4, 2); |
| assertEquals(1, array[0]); |
| assertEquals(2, array[1]); |
| assertEquals(4, array[2]); |
| assertEquals(3, array[3]); |
| assertEquals(5, array[4]); |
| } |
| |
| @Test |
| public void testShiftRangeInt() { |
| final int[] array = {1, 2, 3, 4, 5}; |
| ArrayUtils.shift(array, 1, 3, 1); |
| assertEquals(1, array[0]); |
| assertEquals(3, array[1]); |
| assertEquals(2, array[2]); |
| assertEquals(4, array[3]); |
| assertEquals(5, array[4]); |
| ArrayUtils.shift(array, 1, 4, 2); |
| assertEquals(1, array[0]); |
| assertEquals(2, array[1]); |
| assertEquals(4, array[2]); |
| assertEquals(3, array[3]); |
| assertEquals(5, array[4]); |
| } |
| |
| @Test |
| public void testShiftRangeLong() { |
| final long[] array = {1, 2, 3, 4, 5}; |
| ArrayUtils.shift(array, 1, 3, 1); |
| assertEquals(1, array[0]); |
| assertEquals(3, array[1]); |
| assertEquals(2, array[2]); |
| assertEquals(4, array[3]); |
| assertEquals(5, array[4]); |
| ArrayUtils.shift(array, 1, 4, 2); |
| assertEquals(1, array[0]); |
| assertEquals(2, array[1]); |
| assertEquals(4, array[2]); |
| assertEquals(3, array[3]); |
| assertEquals(5, array[4]); |
| } |
| |
| @Test |
| public void testShiftRangeNoElemByte() { |
| final byte[] array = {1, 2, 3, 4}; |
| ArrayUtils.shift(array, 1, 1, 1); |
| assertEquals(1, array[0]); |
| assertEquals(2, array[1]); |
| assertEquals(3, array[2]); |
| assertEquals(4, array[3]); |
| } |
| |
| @Test |
| public void testShiftRangeNoElemChar() { |
| final char[] array = {1, 2, 3, 4}; |
| ArrayUtils.shift(array, 1, 1, 1); |
| assertEquals(1, array[0]); |
| assertEquals(2, array[1]); |
| assertEquals(3, array[2]); |
| assertEquals(4, array[3]); |
| } |
| |
| @Test |
| public void testShiftRangeNoElemDouble() { |
| final double[] array = {1, 2, 3, 4}; |
| ArrayUtils.shift(array, 1, 1, 1); |
| assertEquals(1, array[0]); |
| assertEquals(2, array[1]); |
| assertEquals(3, array[2]); |
| assertEquals(4, array[3]); |
| } |
| |
| @Test |
| public void testShiftRangeNoElemFloat() { |
| final float[] array = {1, 2, 3, 4}; |
| ArrayUtils.shift(array, 1, 1, 1); |
| assertEquals(1, array[0]); |
| assertEquals(2, array[1]); |
| assertEquals(3, array[2]); |
| assertEquals(4, array[3]); |
| } |
| |
| @Test |
| public void testShiftRangeNoElemInt() { |
| final int[] array = {1, 2, 3, 4}; |
| ArrayUtils.shift(array, 1, 1, 1); |
| assertEquals(1, array[0]); |
| assertEquals(2, array[1]); |
| assertEquals(3, array[2]); |
| assertEquals(4, array[3]); |
| } |
| |
| @Test |
| public void testShiftRangeNoElemLong() { |
| final long[] array = {1, 2, 3, 4}; |
| ArrayUtils.shift(array, 1, 1, 1); |
| assertEquals(1, array[0]); |
| assertEquals(2, array[1]); |
| assertEquals(3, array[2]); |
| assertEquals(4, array[3]); |
| } |
| |
| @Test |
| public void testShiftRangeNoElemObject() { |
| final String[] array = {"1", "2", "3", "4"}; |
| ArrayUtils.shift(array, 1, 1, 1); |
| assertEquals("1", array[0]); |
| assertEquals("2", array[1]); |
| assertEquals("3", array[2]); |
| assertEquals("4", array[3]); |
| } |
| |
| @Test |
| public void testShiftRangeNoElemShort() { |
| final short[] array = {1, 2, 3, 4}; |
| ArrayUtils.shift(array, 1, 1, 1); |
| assertEquals(1, array[0]); |
| assertEquals(2, array[1]); |
| assertEquals(3, array[2]); |
| assertEquals(4, array[3]); |
| } |
| |
| @Test |
| public void testShiftRangeNullByte() { |
| final byte[] array = null; |
| ArrayUtils.shift(array, 1, 1, 1); |
| assertNull(array); |
| } |
| |
| @Test |
| public void testShiftRangeNullChar() { |
| final char[] array = null; |
| ArrayUtils.shift(array, 1, 1, 1); |
| assertNull(array); |
| } |
| |
| @Test |
| public void testShiftRangeNullDouble() { |
| final double[] array = null; |
| ArrayUtils.shift(array, 1, 1, 1); |
| assertNull(array); |
| } |
| |
| @Test |
| public void testShiftRangeNullFloat() { |
| final float[] array = null; |
| ArrayUtils.shift(array, 1, 1, 1); |
| assertNull(array); |
| } |
| |
| @Test |
| public void testShiftRangeNullInt() { |
| final int[] array = null; |
| ArrayUtils.shift(array, 1, 1, 1); |
| assertNull(array); |
| } |
| |
| @Test |
| public void testShiftRangeNullLong() { |
| final long[] array = null; |
| ArrayUtils.shift(array, 1, 1, 1); |
| assertNull(array); |
| } |
| |
| @Test |
| public void testShiftRangeNullObject() { |
| final String[] array = null; |
| ArrayUtils.shift(array, 1, 1, 1); |
| assertNull(array); |
| } |
| |
| @Test |
| public void testShiftRangeNullShort() { |
| final short[] array = null; |
| |
| ArrayUtils.shift(array, 1, 1, 1); |
| assertNull(array); |
| } |
| |
| @Test |
| public void testShiftRangeObject() { |
| final String[] array = {"1", "2", "3", "4", "5"}; |
| ArrayUtils.shift(array, 1, 3, 1); |
| assertEquals("1", array[0]); |
| assertEquals("3", array[1]); |
| assertEquals("2", array[2]); |
| assertEquals("4", array[3]); |
| assertEquals("5", array[4]); |
| ArrayUtils.shift(array, 1, 4, 2); |
| assertEquals("1", array[0]); |
| assertEquals("2", array[1]); |
| assertEquals("4", array[2]); |
| assertEquals("3", array[3]); |
| assertEquals("5", array[4]); |
| } |
| |
| @Test |
| public void testShiftRangeShort() { |
| final short[] array = {1, 2, 3, 4, 5}; |
| ArrayUtils.shift(array, 1, 3, 1); |
| assertEquals(1, array[0]); |
| assertEquals(3, array[1]); |
| assertEquals(2, array[2]); |
| assertEquals(4, array[3]); |
| assertEquals(5, array[4]); |
| ArrayUtils.shift(array, 1, 4, 2); |
| assertEquals(1, array[0]); |
| assertEquals(2, array[1]); |
| assertEquals(4, array[2]); |
| assertEquals(3, array[3]); |
| assertEquals(5, array[4]); |
| } |
| |
| @Test |
| public void testShiftShort() { |
| short[] array = {1, 2, 3, 4}; |
| ArrayUtils.shift(array, 1); |
| assertEquals(4, array[0]); |
| assertEquals(1, array[1]); |
| assertEquals(2, array[2]); |
| assertEquals(3, array[3]); |
| ArrayUtils.shift(array, -1); |
| assertEquals(1, array[0]); |
| assertEquals(2, array[1]); |
| assertEquals(3, array[2]); |
| assertEquals(4, array[3]); |
| ArrayUtils.shift(array, 5); |
| assertEquals(4, array[0]); |
| assertEquals(1, array[1]); |
| assertEquals(2, array[2]); |
| assertEquals(3, array[3]); |
| ArrayUtils.shift(array, -3); |
| assertEquals(3, array[0]); |
| assertEquals(4, array[1]); |
| assertEquals(1, array[2]); |
| assertEquals(2, array[3]); |
| array = new short[]{1, 2, 3, 4, 5}; |
| ArrayUtils.shift(array, 2); |
| assertEquals(4, array[0]); |
| assertEquals(5, array[1]); |
| assertEquals(1, array[2]); |
| assertEquals(2, array[3]); |
| assertEquals(3, array[4]); |
| } |
| |
| @Test |
| public void testShuffle() { |
| final String[] array1 = {"1", "2", "3", "4", "5", "6", "7", "8", "9", "10"}; |
| final String[] array2 = ArrayUtils.clone(array1); |
| |
| ArrayUtils.shuffle(array1, new Random(SEED)); |
| assertFalse(Arrays.equals(array1, array2)); |
| for (final String element : array2) { |
| assertTrue(ArrayUtils.contains(array1, element), "Element " + element + " not found"); |
| } |
| } |
| |
| @Test |
| public void testShuffleBoolean() { |
| final boolean[] array1 = {true, false, true, true, false, false, true, false, false, true}; |
| final boolean[] array2 = ArrayUtils.clone(array1); |
| |
| ArrayUtils.shuffle(array1, new Random(SEED)); |
| assertFalse(Arrays.equals(array1, array2)); |
| assertEquals(5, ArrayUtils.removeAllOccurrences(array1, true).length); |
| } |
| |
| @Test |
| public void testShuffleByte() { |
| final byte[] array1 = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10}; |
| final byte[] array2 = ArrayUtils.clone(array1); |
| |
| ArrayUtils.shuffle(array1, new Random(SEED)); |
| assertFalse(Arrays.equals(array1, array2)); |
| for (final byte element : array2) { |
| assertTrue(ArrayUtils.contains(array1, element), "Element " + element + " not found"); |
| } |
| } |
| |
| @Test |
| public void testShuffleChar() { |
| final char[] array1 = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10}; |
| final char[] array2 = ArrayUtils.clone(array1); |
| |
| ArrayUtils.shuffle(array1, new Random(SEED)); |
| assertFalse(Arrays.equals(array1, array2)); |
| for (final char element : array2) { |
| assertTrue(ArrayUtils.contains(array1, element), "Element " + element + " not found"); |
| } |
| } |
| |
| @Test |
| public void testShuffleDouble() { |
| final double[] array1 = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10}; |
| final double[] array2 = ArrayUtils.clone(array1); |
| |
| ArrayUtils.shuffle(array1, new Random(SEED)); |
| assertFalse(Arrays.equals(array1, array2)); |
| for (final double element : array2) { |
| assertTrue(ArrayUtils.contains(array1, element), "Element " + element + " not found"); |
| } |
| } |
| |
| @Test |
| public void testShuffleFloat() { |
| final float[] array1 = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10}; |
| final float[] array2 = ArrayUtils.clone(array1); |
| |
| ArrayUtils.shuffle(array1, new Random(SEED)); |
| assertFalse(Arrays.equals(array1, array2)); |
| for (final float element : array2) { |
| assertTrue(ArrayUtils.contains(array1, element), "Element " + element + " not found"); |
| } |
| } |
| |
| @Test |
| public void testShuffleInt() { |
| final int[] array1 = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10}; |
| final int[] array2 = ArrayUtils.clone(array1); |
| |
| ArrayUtils.shuffle(array1, new Random(SEED)); |
| assertFalse(Arrays.equals(array1, array2)); |
| for (final int element : array2) { |
| assertTrue(ArrayUtils.contains(array1, element), "Element " + element + " not found"); |
| } |
| } |
| |
| @Test |
| public void testShuffleLong() { |
| final long[] array1 = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10}; |
| final long[] array2 = ArrayUtils.clone(array1); |
| |
| ArrayUtils.shuffle(array1, new Random(SEED)); |
| assertFalse(Arrays.equals(array1, array2)); |
| for (final long element : array2) { |
| assertTrue(ArrayUtils.contains(array1, element), "Element " + element + " not found"); |
| } |
| } |
| |
| @Test |
| public void testShuffleShort() { |
| final short[] array1 = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10}; |
| final short[] array2 = ArrayUtils.clone(array1); |
| |
| ArrayUtils.shuffle(array1, new Random(SEED)); |
| assertFalse(Arrays.equals(array1, array2)); |
| for (final short element : array2) { |
| assertTrue(ArrayUtils.contains(array1, element), "Element " + element + " not found"); |
| } |
| } |
| |
| @Test |
| public void testSubarrayBoolean() { |
| final boolean[] nullArray = null; |
| final boolean[] array = {true, true, false, true, false, true}; |
| final boolean[] leftSubarray = {true, true, false, true}; |
| final boolean[] midSubarray = {true, false, true, false}; |
| final boolean[] rightSubarray = {false, true, false, true}; |
| |
| assertTrue(ArrayUtils.isEquals(leftSubarray, ArrayUtils.subarray(array, 0, 4)), "0 start, mid end"); |
| assertTrue(ArrayUtils.isEquals(array, ArrayUtils.subarray(array, 0, array.length)), "0 start, length end"); |
| assertTrue(ArrayUtils.isEquals(midSubarray, ArrayUtils.subarray(array, 1, 5)), "mid start, mid end"); |
| assertTrue(ArrayUtils.isEquals(rightSubarray, ArrayUtils.subarray(array, 2, array.length)), |
| "mid start, length end"); |
| |
| assertNull(ArrayUtils.subarray(nullArray, 0, 3), "null input"); |
| assertEquals(ArrayUtils.EMPTY_BOOLEAN_ARRAY, ArrayUtils.subarray(ArrayUtils.EMPTY_BOOLEAN_ARRAY, 1, 2), |
| "empty array"); |
| assertEquals(ArrayUtils.EMPTY_BOOLEAN_ARRAY, ArrayUtils.subarray(array, 4, 2), "start > end"); |
| assertEquals(ArrayUtils.EMPTY_BOOLEAN_ARRAY, ArrayUtils.subarray(array, 3, 3), "start == end"); |
| assertTrue(ArrayUtils.isEquals(leftSubarray, ArrayUtils.subarray(array, -2, 4)), |
| "start undershoot, normal end"); |
| assertEquals(ArrayUtils.EMPTY_BOOLEAN_ARRAY, ArrayUtils.subarray(array, 33, 4), "start overshoot, any end"); |
| assertTrue(ArrayUtils.isEquals(rightSubarray, ArrayUtils.subarray(array, 2, 33)), |
| "normal start, end overshoot"); |
| assertTrue(ArrayUtils.isEquals(array, ArrayUtils.subarray(array, -2, 12)), "start undershoot, end overshoot"); |
| |
| // empty-return tests |
| |
| assertSame(ArrayUtils.EMPTY_BOOLEAN_ARRAY, ArrayUtils.subarray(ArrayUtils.EMPTY_BOOLEAN_ARRAY, 1, 2), |
| "empty array, object test"); |
| assertSame(ArrayUtils.EMPTY_BOOLEAN_ARRAY, ArrayUtils.subarray(array, 4, 1), "start > end, object test"); |
| assertSame(ArrayUtils.EMPTY_BOOLEAN_ARRAY, ArrayUtils.subarray(array, 3, 3), "start == end, object test"); |
| assertSame(ArrayUtils.EMPTY_BOOLEAN_ARRAY, ArrayUtils.subarray(array, 8733, 4), |
| "start overshoot, any end, object test"); |
| |
| // array type tests |
| |
| assertSame(boolean.class, ArrayUtils.subarray(array, 2, 4).getClass().getComponentType(), "boolean type"); |
| } |
| |
| @Test |
| public void testSubarrayByte() { |
| final byte[] nullArray = null; |
| final byte[] array = {10, 11, 12, 13, 14, 15}; |
| final byte[] leftSubarray = {10, 11, 12, 13}; |
| final byte[] midSubarray = {11, 12, 13, 14}; |
| final byte[] rightSubarray = {12, 13, 14, 15}; |
| |
| assertTrue(ArrayUtils.isEquals(leftSubarray, ArrayUtils.subarray(array, 0, 4)), "0 start, mid end"); |
| assertTrue(ArrayUtils.isEquals(array, ArrayUtils.subarray(array, 0, array.length)), "0 start, length end"); |
| assertTrue(ArrayUtils.isEquals(midSubarray, ArrayUtils.subarray(array, 1, 5)), "mid start, mid end"); |
| assertTrue(ArrayUtils.isEquals(rightSubarray, ArrayUtils.subarray(array, 2, array.length)), |
| "mid start, length end"); |
| |
| assertNull(ArrayUtils.subarray(nullArray, 0, 3), "null input"); |
| assertEquals(ArrayUtils.EMPTY_BYTE_ARRAY, ArrayUtils.subarray(ArrayUtils.EMPTY_BYTE_ARRAY, 1, 2), |
| "empty array"); |
| assertEquals(ArrayUtils.EMPTY_BYTE_ARRAY, ArrayUtils.subarray(array, 4, 2), "start > end"); |
| assertEquals(ArrayUtils.EMPTY_BYTE_ARRAY, ArrayUtils.subarray(array, 3, 3), "start == end"); |
| assertTrue(ArrayUtils.isEquals(leftSubarray, ArrayUtils.subarray(array, -2, 4)), |
| "start undershoot, normal end"); |
| assertEquals(ArrayUtils.EMPTY_BYTE_ARRAY, ArrayUtils.subarray(array, 33, 4), "start overshoot, any end"); |
| assertTrue(ArrayUtils.isEquals(rightSubarray, ArrayUtils.subarray(array, 2, 33)), |
| "normal start, end overshoot"); |
| assertTrue(ArrayUtils.isEquals(array, ArrayUtils.subarray(array, -2, 12)), "start undershoot, end overshoot"); |
| |
| // empty-return tests |
| |
| assertSame(ArrayUtils.EMPTY_BYTE_ARRAY, ArrayUtils.subarray(ArrayUtils.EMPTY_BYTE_ARRAY, 1, 2), |
| "empty array, object test"); |
| assertSame(ArrayUtils.EMPTY_BYTE_ARRAY, ArrayUtils.subarray(array, 4, 1), "start > end, object test"); |
| assertSame(ArrayUtils.EMPTY_BYTE_ARRAY, ArrayUtils.subarray(array, 3, 3), "start == end, object test"); |
| assertSame(ArrayUtils.EMPTY_BYTE_ARRAY, ArrayUtils.subarray(array, 8733, 4), |
| "start overshoot, any end, object test"); |
| |
| // array type tests |
| |
| assertSame(byte.class, ArrayUtils.subarray(array, 2, 4).getClass().getComponentType(), "byte type"); |
| } |
| |
| @Test |
| public void testSubarrayDouble() { |
| final double[] nullArray = null; |
| final double[] array = {10.123, 11.234, 12.345, 13.456, 14.567, 15.678}; |
| final double[] leftSubarray = {10.123, 11.234, 12.345, 13.456}; |
| final double[] midSubarray = {11.234, 12.345, 13.456, 14.567}; |
| final double[] rightSubarray = {12.345, 13.456, 14.567, 15.678}; |
| |
| assertTrue(ArrayUtils.isEquals(leftSubarray, ArrayUtils.subarray(array, 0, 4)), "0 start, mid end"); |
| assertTrue(ArrayUtils.isEquals(array, ArrayUtils.subarray(array, 0, array.length)), "0 start, length end"); |
| assertTrue(ArrayUtils.isEquals(midSubarray, ArrayUtils.subarray(array, 1, 5)), "mid start, mid end"); |
| assertTrue(ArrayUtils.isEquals(rightSubarray, ArrayUtils.subarray(array, 2, array.length)), |
| "mid start, length end"); |
| |
| assertNull(ArrayUtils.subarray(nullArray, 0, 3), "null input"); |
| assertEquals(ArrayUtils.EMPTY_DOUBLE_ARRAY, ArrayUtils.subarray(ArrayUtils.EMPTY_DOUBLE_ARRAY, 1, 2), |
| "empty array"); |
| assertEquals(ArrayUtils.EMPTY_DOUBLE_ARRAY, ArrayUtils.subarray(array, 4, 2), "start > end"); |
| assertEquals(ArrayUtils.EMPTY_DOUBLE_ARRAY, ArrayUtils.subarray(array, 3, 3), "start == end"); |
| assertTrue(ArrayUtils.isEquals(leftSubarray, ArrayUtils.subarray(array, -2, 4)), |
| "start undershoot, normal end"); |
| assertEquals(ArrayUtils.EMPTY_DOUBLE_ARRAY, ArrayUtils.subarray(array, 33, 4), "start overshoot, any end"); |
| assertTrue(ArrayUtils.isEquals(rightSubarray, ArrayUtils.subarray(array, 2, 33)), |
| "normal start, end overshoot"); |
| assertTrue(ArrayUtils.isEquals(array, ArrayUtils.subarray(array, -2, 12)), "start undershoot, end overshoot"); |
| |
| // empty-return tests |
| |
| assertSame(ArrayUtils.EMPTY_DOUBLE_ARRAY, ArrayUtils.subarray(ArrayUtils.EMPTY_DOUBLE_ARRAY, 1, 2), |
| "empty array, object test"); |
| assertSame(ArrayUtils.EMPTY_DOUBLE_ARRAY, ArrayUtils.subarray(array, 4, 1), "start > end, object test"); |
| assertSame(ArrayUtils.EMPTY_DOUBLE_ARRAY, ArrayUtils.subarray(array, 3, 3), "start == end, object test"); |
| assertSame(ArrayUtils.EMPTY_DOUBLE_ARRAY, ArrayUtils.subarray(array, 8733, 4), |
| "start overshoot, any end, object test"); |
| |
| // array type tests |
| |
| assertSame(double.class, ArrayUtils.subarray(array, 2, 4).getClass().getComponentType(), "double type"); |
| } |
| |
| @Test |
| public void testSubarrayFloat() { |
| final float[] nullArray = null; |
| final float[] array = {10, 11, 12, 13, 14, 15}; |
| final float[] leftSubarray = {10, 11, 12, 13}; |
| final float[] midSubarray = {11, 12, 13, 14}; |
| final float[] rightSubarray = {12, 13, 14, 15}; |
| |
| assertTrue(ArrayUtils.isEquals(leftSubarray, ArrayUtils.subarray(array, 0, 4)), "0 start, mid end"); |
| assertTrue(ArrayUtils.isEquals(array, ArrayUtils.subarray(array, 0, array.length)), "0 start, length end"); |
| assertTrue(ArrayUtils.isEquals(midSubarray, ArrayUtils.subarray(array, 1, 5)), "mid start, mid end"); |
| assertTrue(ArrayUtils.isEquals(rightSubarray, ArrayUtils.subarray(array, 2, array.length)), |
| "mid start, length end"); |
| |
| assertNull(ArrayUtils.subarray(nullArray, 0, 3), "null input"); |
| assertEquals(ArrayUtils.EMPTY_FLOAT_ARRAY, ArrayUtils.subarray(ArrayUtils.EMPTY_FLOAT_ARRAY, 1, 2), |
| "empty array"); |
| assertEquals(ArrayUtils.EMPTY_FLOAT_ARRAY, ArrayUtils.subarray(array, 4, 2), "start > end"); |
| assertEquals(ArrayUtils.EMPTY_FLOAT_ARRAY, ArrayUtils.subarray(array, 3, 3), "start == end"); |
| assertTrue(ArrayUtils.isEquals(leftSubarray, ArrayUtils.subarray(array, -2, 4)), |
| "start undershoot, normal end"); |
| assertEquals(ArrayUtils.EMPTY_FLOAT_ARRAY, ArrayUtils.subarray(array, 33, 4), "start overshoot, any end"); |
| assertTrue(ArrayUtils.isEquals(rightSubarray, ArrayUtils.subarray(array, 2, 33)), |
| "normal start, end overshoot"); |
| assertTrue(ArrayUtils.isEquals(array, ArrayUtils.subarray(array, -2, 12)), "start undershoot, end overshoot"); |
| |
| // empty-return tests |
| |
| assertSame(ArrayUtils.EMPTY_FLOAT_ARRAY, ArrayUtils.subarray(ArrayUtils.EMPTY_FLOAT_ARRAY, 1, 2), |
| "empty array, object test"); |
| assertSame(ArrayUtils.EMPTY_FLOAT_ARRAY, ArrayUtils.subarray(array, 4, 1), "start > end, object test"); |
| assertSame(ArrayUtils.EMPTY_FLOAT_ARRAY, ArrayUtils.subarray(array, 3, 3), "start == end, object test"); |
| assertSame(ArrayUtils.EMPTY_FLOAT_ARRAY, ArrayUtils.subarray(array, 8733, 4), |
| "start overshoot, any end, object test"); |
| |
| // array type tests |
| |
| assertSame(float.class, ArrayUtils.subarray(array, 2, 4).getClass().getComponentType(), "float type"); |
| } |
| |
| @Test |
| public void testSubarrayInt() { |
| final int[] nullArray = null; |
| final int[] array = {10, 11, 12, 13, 14, 15}; |
| final int[] leftSubarray = {10, 11, 12, 13}; |
| final int[] midSubarray = {11, 12, 13, 14}; |
| final int[] rightSubarray = {12, 13, 14, 15}; |
| |
| |
| assertTrue(ArrayUtils.isEquals(leftSubarray, ArrayUtils.subarray(array, 0, 4)), "0 start, mid end"); |
| |
| assertTrue(ArrayUtils.isEquals(array, ArrayUtils.subarray(array, 0, array.length)), "0 start, length end"); |
| |
| assertTrue(ArrayUtils.isEquals(midSubarray, ArrayUtils.subarray(array, 1, 5)), "mid start, mid end"); |
| |
| assertTrue(ArrayUtils.isEquals(rightSubarray, ArrayUtils.subarray(array, 2, array.length)), |
| "mid start, length end"); |
| |
| |
| assertNull(ArrayUtils.subarray(nullArray, 0, 3), "null input"); |
| |
| assertEquals(ArrayUtils.EMPTY_INT_ARRAY, ArrayUtils.subarray(ArrayUtils.EMPTY_INT_ARRAY, 1, 2), "empty array"); |
| |
| assertEquals(ArrayUtils.EMPTY_INT_ARRAY, ArrayUtils.subarray(array, 4, 2), "start > end"); |
| |
| assertEquals(ArrayUtils.EMPTY_INT_ARRAY, ArrayUtils.subarray(array, 3, 3), "start == end"); |
| |
| assertTrue(ArrayUtils.isEquals(leftSubarray, ArrayUtils.subarray(array, -2, 4)), |
| "start undershoot, normal end"); |
| |
| assertEquals(ArrayUtils.EMPTY_INT_ARRAY, ArrayUtils.subarray(array, 33, 4), "start overshoot, any end"); |
| |
| assertTrue(ArrayUtils.isEquals(rightSubarray, ArrayUtils.subarray(array, 2, 33)), |
| "normal start, end overshoot"); |
| |
| assertTrue(ArrayUtils.isEquals(array, ArrayUtils.subarray(array, -2, 12)), "start undershoot, end overshoot"); |
| |
| // empty-return tests |
| |
| assertSame(ArrayUtils.EMPTY_INT_ARRAY, ArrayUtils.subarray(ArrayUtils.EMPTY_INT_ARRAY, 1, 2), |
| "empty array, object test"); |
| |
| assertSame(ArrayUtils.EMPTY_INT_ARRAY, ArrayUtils.subarray(array, 4, 1), "start > end, object test"); |
| |
| assertSame(ArrayUtils.EMPTY_INT_ARRAY, ArrayUtils.subarray(array, 3, 3), "start == end, object test"); |
| |
| assertSame(ArrayUtils.EMPTY_INT_ARRAY, ArrayUtils.subarray(array, 8733, 4), |
| "start overshoot, any end, object test"); |
| |
| // array type tests |
| |
| assertSame(int.class, ArrayUtils.subarray(array, 2, 4).getClass().getComponentType(), "int type"); |
| } |
| |
| @Test |
| public void testSubarrayLong() { |
| final long[] nullArray = null; |
| final long[] array = {999910, 999911, 999912, 999913, 999914, 999915}; |
| final long[] leftSubarray = {999910, 999911, 999912, 999913}; |
| final long[] midSubarray = {999911, 999912, 999913, 999914}; |
| final long[] rightSubarray = {999912, 999913, 999914, 999915}; |
| |
| assertTrue(ArrayUtils.isEquals(leftSubarray, ArrayUtils.subarray(array, 0, 4)), "0 start, mid end"); |
| |
| assertTrue(ArrayUtils.isEquals(array, ArrayUtils.subarray(array, 0, array.length)), "0 start, length end"); |
| |
| assertTrue(ArrayUtils.isEquals(midSubarray, ArrayUtils.subarray(array, 1, 5)), "mid start, mid end"); |
| |
| assertTrue(ArrayUtils.isEquals(rightSubarray, ArrayUtils.subarray(array, 2, array.length)), |
| "mid start, length end"); |
| |
| assertNull(ArrayUtils.subarray(nullArray, 0, 3), "null input"); |
| |
| assertEquals(ArrayUtils.EMPTY_LONG_ARRAY, ArrayUtils.subarray(ArrayUtils.EMPTY_LONG_ARRAY, 1, 2), |
| "empty array"); |
| |
| assertEquals(ArrayUtils.EMPTY_LONG_ARRAY, ArrayUtils.subarray(array, 4, 2), "start > end"); |
| |
| assertEquals(ArrayUtils.EMPTY_LONG_ARRAY, ArrayUtils.subarray(array, 3, 3), "start == end"); |
| |
| assertTrue(ArrayUtils.isEquals(leftSubarray, ArrayUtils.subarray(array, -2, 4)), |
| "start undershoot, normal end"); |
| |
| assertEquals(ArrayUtils.EMPTY_LONG_ARRAY, ArrayUtils.subarray(array, 33, 4), "start overshoot, any end"); |
| |
| assertTrue(ArrayUtils.isEquals(rightSubarray, ArrayUtils.subarray(array, 2, 33)), |
| "normal start, end overshoot"); |
| |
| assertTrue(ArrayUtils.isEquals(array, ArrayUtils.subarray(array, -2, 12)), "start undershoot, end overshoot"); |
| |
| // empty-return tests |
| |
| assertSame(ArrayUtils.EMPTY_LONG_ARRAY, ArrayUtils.subarray(ArrayUtils.EMPTY_LONG_ARRAY, 1, 2), |
| "empty array, object test"); |
| |
| assertSame(ArrayUtils.EMPTY_LONG_ARRAY, ArrayUtils.subarray(array, 4, 1), "start > end, object test"); |
| |
| assertSame(ArrayUtils.EMPTY_LONG_ARRAY, ArrayUtils.subarray(array, 3, 3), "start == end, object test"); |
| |
| assertSame(ArrayUtils.EMPTY_LONG_ARRAY, ArrayUtils.subarray(array, 8733, 4), |
| "start overshoot, any end, object test"); |
| |
| // array type tests |
| |
| assertSame(long.class, ArrayUtils.subarray(array, 2, 4).getClass().getComponentType(), "long type"); |
| |
| } |
| |
| @Test |
| public void testSubarrayObject() { |
| final Object[] nullArray = null; |
| final Object[] objectArray = {"a", "b", "c", "d", "e", "f"}; |
| |
| assertEquals("abcd", StringUtils.join(ArrayUtils.subarray(objectArray, 0, 4)), "0 start, mid end"); |
| assertEquals("abcdef", StringUtils.join(ArrayUtils.subarray(objectArray, 0, objectArray.length)), |
| "0 start, length end"); |
| assertEquals("bcd", StringUtils.join(ArrayUtils.subarray(objectArray, 1, 4)), "mid start, mid end"); |
| assertEquals("bcdef", StringUtils.join(ArrayUtils.subarray(objectArray, 1, objectArray.length)), |
| "mid start, length end"); |
| |
| assertNull(ArrayUtils.subarray(nullArray, 0, 3), "null input"); |
| assertEquals("", StringUtils.join(ArrayUtils.subarray(ArrayUtils.EMPTY_OBJECT_ARRAY, 1, 2)), "empty array"); |
| assertEquals("", StringUtils.join(ArrayUtils.subarray(objectArray, 4, 2)), "start > end"); |
| assertEquals("", StringUtils.join(ArrayUtils.subarray(objectArray, 3, 3)), "start == end"); |
| assertEquals("abcd", StringUtils.join(ArrayUtils.subarray(objectArray, -2, 4)), "start undershoot, normal end"); |
| assertEquals("", StringUtils.join(ArrayUtils.subarray(objectArray, 33, 4)), "start overshoot, any end"); |
| assertEquals("cdef", StringUtils.join(ArrayUtils.subarray(objectArray, 2, 33)), "normal start, end overshoot"); |
| assertEquals("abcdef", StringUtils.join(ArrayUtils.subarray(objectArray, -2, 12)), |
| "start undershoot, end overshoot"); |
| |
| // array type tests |
| final Date[] dateArray = {new java.sql.Date(new Date().getTime()), |
| new Date(), new Date(), new Date(), new Date()}; |
| |
| assertSame(Object.class, ArrayUtils.subarray(objectArray, 2, 4).getClass().getComponentType(), "Object type"); |
| assertSame(Date.class, ArrayUtils.subarray(dateArray, 1, 4).getClass().getComponentType(), |
| "java.util.Date type"); |
| assertNotSame(java.sql.Date.class, ArrayUtils.subarray(dateArray, 1, 4).getClass().getComponentType(), |
| "java.sql.Date type"); |
| assertThrows(ClassCastException.class, |
| () -> java.sql.Date[].class.cast(ArrayUtils.subarray(dateArray, 1, 3)), |
| "Invalid downcast"); |
| } |
| |
| @Test |
| public void testSubarrayShort() { |
| final short[] nullArray = null; |
| final short[] array = {10, 11, 12, 13, 14, 15}; |
| final short[] leftSubarray = {10, 11, 12, 13}; |
| final short[] midSubarray = {11, 12, 13, 14}; |
| final short[] rightSubarray = {12, 13, 14, 15}; |
| |
| assertTrue(ArrayUtils.isEquals(leftSubarray, ArrayUtils.subarray(array, 0, 4)), "0 start, mid end"); |
| assertTrue(ArrayUtils.isEquals(array, ArrayUtils.subarray(array, 0, array.length)), "0 start, length end"); |
| assertTrue(ArrayUtils.isEquals(midSubarray, ArrayUtils.subarray(array, 1, 5)), "mid start, mid end"); |
| assertTrue(ArrayUtils.isEquals(rightSubarray, ArrayUtils.subarray(array, 2, array.length)), |
| "mid start, length end"); |
| |
| assertNull(ArrayUtils.subarray(nullArray, 0, 3), "null input"); |
| assertEquals(ArrayUtils.EMPTY_SHORT_ARRAY, ArrayUtils.subarray(ArrayUtils.EMPTY_SHORT_ARRAY, 1, 2), |
| "empty array"); |
| assertEquals(ArrayUtils.EMPTY_SHORT_ARRAY, ArrayUtils.subarray(array, 4, 2), "start > end"); |
| assertEquals(ArrayUtils.EMPTY_SHORT_ARRAY, ArrayUtils.subarray(array, 3, 3), "start == end"); |
| assertTrue(ArrayUtils.isEquals(leftSubarray, ArrayUtils.subarray(array, -2, 4)), |
| "start undershoot, normal end"); |
| assertEquals(ArrayUtils.EMPTY_SHORT_ARRAY, ArrayUtils.subarray(array, 33, 4), "start overshoot, any end"); |
| assertTrue(ArrayUtils.isEquals(rightSubarray, ArrayUtils.subarray(array, 2, 33)), |
| "normal start, end overshoot"); |
| assertTrue(ArrayUtils.isEquals(array, ArrayUtils.subarray(array, -2, 12)), "start undershoot, end overshoot"); |
| |
| // empty-return tests |
| |
| assertSame(ArrayUtils.EMPTY_SHORT_ARRAY, ArrayUtils.subarray(ArrayUtils.EMPTY_SHORT_ARRAY, 1, 2), |
| "empty array, object test"); |
| assertSame(ArrayUtils.EMPTY_SHORT_ARRAY, ArrayUtils.subarray(array, 4, 1), "start > end, object test"); |
| assertSame(ArrayUtils.EMPTY_SHORT_ARRAY, ArrayUtils.subarray(array, 3, 3), "start == end, object test"); |
| assertSame(ArrayUtils.EMPTY_SHORT_ARRAY, ArrayUtils.subarray(array, 8733, 4), |
| "start overshoot, any end, object test"); |
| |
| // array type tests |
| |
| assertSame(short.class, ArrayUtils.subarray(array, 2, 4).getClass().getComponentType(), "short type"); |
| } |
| |
| @Test |
| public void testSubarrChar() { |
| final char[] nullArray = null; |
| final char[] array = {'a', 'b', 'c', 'd', 'e', 'f'}; |
| final char[] leftSubarray = {'a', 'b', 'c', 'd'}; |
| final char[] midSubarray = {'b', 'c', 'd', 'e'}; |
| final char[] rightSubarray = {'c', 'd', 'e', 'f'}; |
| |
| assertTrue(ArrayUtils.isEquals(leftSubarray, ArrayUtils.subarray(array, 0, 4)), "0 start, mid end"); |
| assertTrue(ArrayUtils.isEquals(array, ArrayUtils.subarray(array, 0, array.length)), "0 start, length end"); |
| assertTrue(ArrayUtils.isEquals(midSubarray, ArrayUtils.subarray(array, 1, 5)), "mid start, mid end"); |
| assertTrue(ArrayUtils.isEquals(rightSubarray, ArrayUtils.subarray(array, 2, array.length)), |
| "mid start, length end"); |
| |
| assertNull(ArrayUtils.subarray(nullArray, 0, 3), "null input"); |
| assertEquals(ArrayUtils.EMPTY_CHAR_ARRAY, ArrayUtils.subarray(ArrayUtils.EMPTY_CHAR_ARRAY, 1, 2), |
| "empty array"); |
| assertEquals(ArrayUtils.EMPTY_CHAR_ARRAY, ArrayUtils.subarray(array, 4, 2), "start > end"); |
| assertEquals(ArrayUtils.EMPTY_CHAR_ARRAY, ArrayUtils.subarray(array, 3, 3), "start == end"); |
| assertTrue(ArrayUtils.isEquals(leftSubarray, ArrayUtils.subarray(array, -2, 4)), |
| "start undershoot, normal end"); |
| assertEquals(ArrayUtils.EMPTY_CHAR_ARRAY, ArrayUtils.subarray(array, 33, 4), "start overshoot, any end"); |
| assertTrue(ArrayUtils.isEquals(rightSubarray, ArrayUtils.subarray(array, 2, 33)), |
| "normal start, end overshoot"); |
| assertTrue(ArrayUtils.isEquals(array, ArrayUtils.subarray(array, -2, 12)), "start undershoot, end overshoot"); |
| |
| // empty-return tests |
| |
| assertSame(ArrayUtils.EMPTY_CHAR_ARRAY, ArrayUtils.subarray(ArrayUtils.EMPTY_CHAR_ARRAY, 1, 2), |
| "empty array, object test"); |
| assertSame(ArrayUtils.EMPTY_CHAR_ARRAY, ArrayUtils.subarray(array, 4, 1), "start > end, object test"); |
| assertSame(ArrayUtils.EMPTY_CHAR_ARRAY, ArrayUtils.subarray(array, 3, 3), "start == end, object test"); |
| assertSame(ArrayUtils.EMPTY_CHAR_ARRAY, ArrayUtils.subarray(array, 8733, 4), |
| "start overshoot, any end, object test"); |
| |
| // array type tests |
| |
| assertSame(char.class, ArrayUtils.subarray(array, 2, 4).getClass().getComponentType(), "char type"); |
| } |
| |
| @Test |
| public void testSwapBoolean() { |
| final boolean[] array = {true, false, false}; |
| ArrayUtils.swap(array, 0, 2); |
| assertFalse(array[0]); |
| assertFalse(array[1]); |
| assertTrue(array[2]); |
| } |
| |
| @Test |
| public void testSwapBooleanRange() { |
| boolean[] array = {false, false, true, true}; |
| ArrayUtils.swap(array, 0, 2, 2); |
| assertTrue(array[0]); |
| assertTrue(array[1]); |
| assertFalse(array[2]); |
| assertFalse(array[3]); |
| |
| array = new boolean[]{false, true, false}; |
| ArrayUtils.swap(array, 0, 3); |
| assertFalse(array[0]); |
| assertTrue(array[1]); |
| assertFalse(array[2]); |
| |
| array = new boolean[]{true, true, false}; |
| ArrayUtils.swap(array, 0, 2, 2); |
| assertFalse(array[0]); |
| assertTrue(array[1]); |
| assertTrue(array[2]); |
| |
| array = new boolean[]{true, true, false}; |
| ArrayUtils.swap(array, -1, 2, 2); |
| assertFalse(array[0]); |
| assertTrue(array[1]); |
| assertTrue(array[2]); |
| |
| array = new boolean[]{true, true, false}; |
| ArrayUtils.swap(array, 0, -1, 2); |
| assertTrue(array[0]); |
| assertTrue(array[1]); |
| assertFalse(array[2]); |
| |
| array = new boolean[]{true, true, false}; |
| ArrayUtils.swap(array, -1, -1, 2); |
| assertTrue(array[0]); |
| assertTrue(array[1]); |
| assertFalse(array[2]); |
| } |
| |
| @Test |
| public void testSwapByte() { |
| final byte[] array = {1, 2, 3}; |
| ArrayUtils.swap(array, 0, 2); |
| assertEquals(3, array[0]); |
| assertEquals(2, array[1]); |
| assertEquals(1, array[2]); |
| } |
| |
| @Test |
| public void testSwapByteRange() { |
| byte[] array = {1, 2, 3, 4}; |
| ArrayUtils.swap(array, 0, 2, 2); |
| assertEquals(3, array[0]); |
| assertEquals(4, array[1]); |
| assertEquals(1, array[2]); |
| assertEquals(2, array[3]); |
| |
| array = new byte[]{1, 2, 3}; |
| ArrayUtils.swap(array, 0, 3); |
| assertEquals(1, array[0]); |
| assertEquals(2, array[1]); |
| assertEquals(3, array[2]); |
| |
| array = new byte[]{1, 2, 3}; |
| ArrayUtils.swap(array, 0, 2, 2); |
| assertEquals(3, array[0]); |
| assertEquals(2, array[1]); |
| assertEquals(1, array[2]); |
| |
| array = new byte[]{1, 2, 3}; |
| ArrayUtils.swap(array, -1, 2, 2); |
| assertEquals(3, array[0]); |
| assertEquals(2, array[1]); |
| assertEquals(1, array[2]); |
| |
| array = new byte[]{1, 2, 3}; |
| ArrayUtils.swap(array, 0, -1, 2); |
| assertEquals(1, array[0]); |
| assertEquals(2, array[1]); |
| assertEquals(3, array[2]); |
| |
| array = new byte[]{1, 2, 3}; |
| ArrayUtils.swap(array, -1, -1, 2); |
| assertEquals(1, array[0]); |
| assertEquals(2, array[1]); |
| assertEquals(3, array[2]); |
| } |
| |
| @Test |
| public void testSwapChar() { |
| char[] array = {1, 2, 3}; |
| ArrayUtils.swap(array, 0, 2); |
| assertArrayEquals(new char[]{3, 2, 1}, array); |
| |
| array = new char[]{1, 2, 3}; |
| ArrayUtils.swap(array, 0, 0); |
| assertArrayEquals(new char[]{1, 2, 3}, array); |
| |
| array = new char[]{1, 2, 3}; |
| ArrayUtils.swap(array, 1, 0); |
| assertArrayEquals(new char[]{2, 1, 3}, array); |
| } |
| |
| @Test |
| public void testSwapCharRange() { |
| char[] array = {1, 2, 3, 4}; |
| ArrayUtils.swap(array, 0, 2, 2); |
| assertEquals(3, array[0]); |
| assertEquals(4, array[1]); |
| assertEquals(1, array[2]); |
| assertEquals(2, array[3]); |
| |
| array = new char[]{1, 2, 3}; |
| ArrayUtils.swap(array, 0, 3); |
| assertEquals(1, array[0]); |
| assertEquals(2, array[1]); |
| assertEquals(3, array[2]); |
| |
| array = new char[]{1, 2, 3}; |
| ArrayUtils.swap(array, 0, 2, 2); |
| assertEquals(3, array[0]); |
| assertEquals(2, array[1]); |
| assertEquals(1, array[2]); |
| |
| array = new char[]{1, 2, 3}; |
| ArrayUtils.swap(array, -1, 2, 2); |
| assertEquals(3, array[0]); |
| assertEquals(2, array[1]); |
| assertEquals(1, array[2]); |
| |
| array = new char[]{1, 2, 3}; |
| ArrayUtils.swap(array, 0, -1, 2); |
| assertEquals(1, array[0]); |
| assertEquals(2, array[1]); |
| assertEquals(3, array[2]); |
| |
| array = new char[]{1, 2, 3}; |
| ArrayUtils.swap(array, -1, -1, 2); |
| assertEquals(1, array[0]); |
| assertEquals(2, array[1]); |
| assertEquals(3, array[2]); |
| } |
| |
| @Test |
| public void testSwapDouble() { |
| final double[] array = {1, 2, 3}; |
| ArrayUtils.swap(array, 0, 2); |
| assertEquals(3, array[0]); |
| assertEquals(2, array[1]); |
| assertEquals(1, array[2]); |
| } |
| |
| @Test |
| public void testSwapDoubleRange() { |
| double[] array = {1, 2, 3, 4}; |
| ArrayUtils.swap(array, 0, 2, 2); |
| assertEquals(3, array[0]); |
| assertEquals(4, array[1]); |
| assertEquals(1, array[2]); |
| assertEquals(2, array[3]); |
| |
| array = new double[]{1, 2, 3}; |
| ArrayUtils.swap(array, 0, 3); |
| assertEquals(1, array[0]); |
| assertEquals(2, array[1]); |
| assertEquals(3, array[2]); |
| |
| array = new double[]{1, 2, 3}; |
| ArrayUtils.swap(array, 0, 2, 2); |
| assertEquals(3, array[0]); |
| assertEquals(2, array[1]); |
| assertEquals(1, array[2]); |
| |
| array = new double[]{1, 2, 3}; |
| ArrayUtils.swap(array, -1, 2, 2); |
| assertEquals(3, array[0]); |
| assertEquals(2, array[1]); |
| assertEquals(1, array[2]); |
| |
| array = new double[]{1, 2, 3}; |
| ArrayUtils.swap(array, 0, -1, 2); |
| assertEquals(1, array[0]); |
| assertEquals(2, array[1]); |
| assertEquals(3, array[2]); |
| |
| array = new double[]{1, 2, 3}; |
| ArrayUtils.swap(array, -1, -1, 2); |
| assertEquals(1, array[0]); |
| assertEquals(2, array[1]); |
| assertEquals(3, array[2]); |
| } |
| |
| @Test |
| public void testSwapEmptyBooleanArray() { |
| final boolean[] array = {}; |
| ArrayUtils.swap(array, 0, 2); |
| assertEquals(0, array.length); |
| } |
| |
| @Test |
| public void testSwapEmptyByteArray() { |
| final byte[] array = {}; |
| ArrayUtils.swap(array, 0, 2); |
| assertEquals(0, array.length); |
| } |
| |
| @Test |
| public void testSwapEmptyCharArray() { |
| final char[] array = {}; |
| ArrayUtils.swap(array, 0, 2); |
| assertEquals(0, array.length); |
| } |
| |
| @Test |
| public void testSwapEmptyDoubleArray() { |
| final double[] array = {}; |
| ArrayUtils.swap(array, 0, 2); |
| assertEquals(0, array.length); |
| } |
| |
| @Test |
| public void testSwapEmptyFloatArray() { |
| final float[] array = {}; |
| ArrayUtils.swap(array, 0, 2); |
| assertEquals(0, array.length); |
| } |
| |
| @Test |
| public void testSwapEmptyIntArray() { |
| final int[] array = {}; |
| ArrayUtils.swap(array, 0, 2); |
| assertEquals(0, array.length); |
| } |
| |
| @Test |
| public void testSwapEmptyLongArray() { |
| final long[] array = {}; |
| ArrayUtils.swap(array, 0, 2); |
| assertEquals(0, array.length); |
| } |
| |
| @Test |
| public void testSwapEmptyObjectArray() { |
| final String[] array = {}; |
| ArrayUtils.swap(array, 0, 2); |
| assertEquals(0, array.length); |
| } |
| |
| @Test |
| public void testSwapEmptyShortArray() { |
| final short[] array = {}; |
| ArrayUtils.swap(array, 0, 2); |
| assertEquals(0, array.length); |
| } |
| |
| @Test |
| public void testSwapFloat() { |
| final float[] array = {1, 2, 3}; |
| ArrayUtils.swap(array, 0, 2); |
| assertEquals(3, array[0]); |
| assertEquals(2, array[1]); |
| assertEquals(1, array[2]); |
| } |
| |
| @Test |
| public void testSwapFloatRange() { |
| float[] array = {1, 2, 3, 4}; |
| ArrayUtils.swap(array, 0, 2, 2); |
| assertEquals(3, array[0]); |
| assertEquals(4, array[1]); |
| assertEquals(1, array[2]); |
| assertEquals(2, array[3]); |
| |
| array = new float[]{1, 2, 3}; |
| ArrayUtils.swap(array, 0, 3); |
| assertEquals(1, array[0]); |
| assertEquals(2, array[1]); |
| assertEquals(3, array[2]); |
| |
| array = new float[]{1, 2, 3}; |
| ArrayUtils.swap(array, 0, 2, 2); |
| assertEquals(3, array[0]); |
| assertEquals(2, array[1]); |
| assertEquals(1, array[2]); |
| |
| array = new float[]{1, 2, 3}; |
| ArrayUtils.swap(array, -1, 2, 2); |
| assertEquals(3, array[0]); |
| assertEquals(2, array[1]); |
| assertEquals(1, array[2]); |
| |
| array = new float[]{1, 2, 3}; |
| ArrayUtils.swap(array, 0, -1, 2); |
| assertEquals(1, array[0]); |
| assertEquals(2, array[1]); |
| assertEquals(3, array[2]); |
| |
| array = new float[]{1, 2, 3}; |
| ArrayUtils.swap(array, -1, -1, 2); |
| assertEquals(1, array[0]); |
| assertEquals(2, array[1]); |
| assertEquals(3, array[2]); |
| } |
| |
| @Test |
| public void testSwapInt() { |
| final int[] array = {1, 2, 3}; |
| ArrayUtils.swap(array, 0, 2); |
| assertEquals(3, array[0]); |
| assertEquals(2, array[1]); |
| assertEquals(1, array[2]); |
| } |
| |
| @Test |
| public void testSwapIntExchangedOffsets() { |
| int[] array; |
| array = new int[]{1, 2, 3}; |
| ArrayUtils.swap(array, 0, 1, 2); |
| assertArrayEquals(new int[]{2, 3, 1}, array); |
| |
| array = new int[]{1, 2, 3}; |
| ArrayUtils.swap(array, 1, 0, 2); |
| assertArrayEquals(new int[]{2, 3, 1}, array); |
| } |
| |
| @Test |
| public void testSwapIntRange() { |
| int[] array = {1, 2, 3, 4}; |
| ArrayUtils.swap(array, 0, 2, 2); |
| assertEquals(3, array[0]); |
| assertEquals(4, array[1]); |
| assertEquals(1, array[2]); |
| assertEquals(2, array[3]); |
| |
| array = new int[]{1, 2, 3}; |
| ArrayUtils.swap(array, 3, 0); |
| assertEquals(1, array[0]); |
| assertEquals(2, array[1]); |
| assertEquals(3, array[2]); |
| |
| array = new int[]{1, 2, 3}; |
| ArrayUtils.swap(array, 0, 2, 2); |
| assertEquals(3, array[0]); |
| assertEquals(2, array[1]); |
| assertEquals(1, array[2]); |
| |
| array = new int[]{1, 2, 3}; |
| ArrayUtils.swap(array, -1, 2, 2); |
| assertEquals(3, array[0]); |
| assertEquals(2, array[1]); |
| assertEquals(1, array[2]); |
| |
| array = new int[]{1, 2, 3}; |
| ArrayUtils.swap(array, 0, -1, 2); |
| assertEquals(1, array[0]); |
| assertEquals(2, array[1]); |
| assertEquals(3, array[2]); |
| |
| array = new int[]{1, 2, 3}; |
| ArrayUtils.swap(array, -1, -1, 2); |
| assertEquals(1, array[0]); |
| assertEquals(2, array[1]); |
| assertEquals(3, array[2]); |
| } |
| |
| @Test |
| public void testSwapLong() { |
| final long[] array = {1, 2, 3}; |
| ArrayUtils.swap(array, 0, 2); |
| assertEquals(3, array[0]); |
| assertEquals(2, array[1]); |
| assertEquals(1, array[2]); |
| } |
| |
| @Test |
| public void testSwapLongRange() { |
| long[] array = {1, 2, 3, 4}; |
| ArrayUtils.swap(array, 0, 2, 2); |
| assertEquals(3, array[0]); |
| assertEquals(4, array[1]); |
| assertEquals(1, array[2]); |
| assertEquals(2, array[3]); |
| |
| array = new long[]{1, 2, 3}; |
| ArrayUtils.swap(array, 0, 3); |
| assertEquals(1, array[0]); |
| assertEquals(2, array[1]); |
| assertEquals(3, array[2]); |
| |
| array = new long[]{1, 2, 3}; |
| ArrayUtils.swap(array, 0, 2, 2); |
| assertEquals(3, array[0]); |
| assertEquals(2, array[1]); |
| assertEquals(1, array[2]); |
| |
| array = new long[]{1, 2, 3}; |
| ArrayUtils.swap(array, -1, 2, 2); |
| assertEquals(3, array[0]); |
| assertEquals(2, array[1]); |
| assertEquals(1, array[2]); |
| |
| array = new long[]{1, 2, 3}; |
| ArrayUtils.swap(array, 0, -1, 2); |
| assertEquals(1, array[0]); |
| assertEquals(2, array[1]); |
| assertEquals(3, array[2]); |
| |
| array = new long[]{1, 2, 3}; |
| ArrayUtils.swap(array, -1, -1, 2); |
| assertEquals(1, array[0]); |
| assertEquals(2, array[1]); |
| assertEquals(3, array[2]); |
| } |
| |
| @Test |
| public void testSwapNullBooleanArray() { |
| final boolean[] array = null; |
| ArrayUtils.swap(array, 0, 2); |
| assertNull(array); |
| } |
| |
| @Test |
| public void testSwapNullByteArray() { |
| final byte[] array = null; |
| ArrayUtils.swap(array, 0, 2); |
| assertNull(array); |
| } |
| |
| @Test |
| public void testSwapNullCharArray() { |
| final char[] array = null; |
| ArrayUtils.swap(array, 0, 2); |
| assertNull(array); |
| } |
| |
| @Test |
| public void testSwapNullDoubleArray() { |
| final double[] array = null; |
| ArrayUtils.swap(array, 0, 2); |
| assertNull(array); |
| } |
| |
| @Test |
| public void testSwapNullFloatArray() { |
| final float[] array = null; |
| ArrayUtils.swap(array, 0, 2); |
| assertNull(array); |
| } |
| |
| @Test |
| public void testSwapNullIntArray() { |
| final int[] array = null; |
| ArrayUtils.swap(array, 0, 2); |
| assertNull(array); |
| } |
| |
| @Test |
| public void testSwapNullLongArray() { |
| final long[] array = null; |
| ArrayUtils.swap(array, 0, 2); |
| assertNull(array); |
| } |
| |
| @Test |
| public void testSwapNullObjectArray() { |
| final String[] array = null; |
| ArrayUtils.swap(array, 0, 2); |
| assertNull(array); |
| } |
| |
| @Test |
| public void testSwapNullShortArray() { |
| final short[] array = null; |
| ArrayUtils.swap(array, 0, 2); |
| assertNull(array); |
| } |
| |
| @Test |
| public void testSwapObject() { |
| final String[] array = {"1", "2", "3"}; |
| ArrayUtils.swap(array, 0, 2); |
| assertEquals("3", array[0]); |
| assertEquals("2", array[1]); |
| assertEquals("1", array[2]); |
| } |
| |
| @Test |
| public void testSwapObjectRange() { |
| String[] array = {"1", "2", "3", "4"}; |
| ArrayUtils.swap(array, 0, 2, 2); |
| assertEquals("3", array[0]); |
| assertEquals("4", array[1]); |
| assertEquals("1", array[2]); |
| assertEquals("2", array[3]); |
| |
| array = new String[]{"1", "2", "3", "4"}; |
| ArrayUtils.swap(array, -1, 2, 3); |
| assertEquals("3", array[0]); |
| assertEquals("4", array[1]); |
| assertEquals("1", array[2]); |
| assertEquals("2", array[3]); |
| |
| array = new String[]{"1", "2", "3", "4", "5"}; |
| ArrayUtils.swap(array, -3, 2, 3); |
| assertEquals("3", array[0]); |
| assertEquals("4", array[1]); |
| assertEquals("5", array[2]); |
| assertEquals("2", array[3]); |
| assertEquals("1", array[4]); |
| |
| array = new String[]{"1", "2", "3", "4", "5"}; |
| ArrayUtils.swap(array, 2, -2, 3); |
| assertEquals("3", array[0]); |
| assertEquals("4", array[1]); |
| assertEquals("5", array[2]); |
| assertEquals("2", array[3]); |
| assertEquals("1", array[4]); |
| |
| array = new String[0]; |
| ArrayUtils.swap(array, 0, 2, 2); |
| assertEquals(0, array.length); |
| |
| array = null; |
| ArrayUtils.swap(array, 0, 2, 2); |
| assertNull(array); |
| } |
| |
| @Test |
| public void testSwapShort() { |
| final short[] array = {1, 2, 3}; |
| ArrayUtils.swap(array, 0, 2); |
| assertEquals(3, array[0]); |
| assertEquals(2, array[1]); |
| assertEquals(1, array[2]); |
| } |
| |
| @Test |
| public void testSwapShortRange() { |
| short[] array = {1, 2, 3, 4}; |
| ArrayUtils.swap(array, 0, 2, 2); |
| assertEquals(3, array[0]); |
| assertEquals(4, array[1]); |
| assertEquals(1, array[2]); |
| assertEquals(2, array[3]); |
| |
| array = new short[]{1, 2, 3}; |
| ArrayUtils.swap(array, 3, 0); |
| assertEquals(1, array[0]); |
| assertEquals(2, array[1]); |
| assertEquals(3, array[2]); |
| |
| array = new short[]{1, 2, 3}; |
| ArrayUtils.swap(array, 0, 2, 2); |
| assertEquals(3, array[0]); |
| assertEquals(2, array[1]); |
| assertEquals(1, array[2]); |
| |
| array = new short[]{1, 2, 3}; |
| ArrayUtils.swap(array, -1, 2, 2); |
| assertEquals(3, array[0]); |
| assertEquals(2, array[1]); |
| assertEquals(1, array[2]); |
| |
| array = new short[]{1, 2, 3}; |
| ArrayUtils.swap(array, 0, -1, 2); |
| assertEquals(1, array[0]); |
| assertEquals(2, array[1]); |
| assertEquals(3, array[2]); |
| |
| array = new short[]{1, 2, 3}; |
| ArrayUtils.swap(array, -1, -1, 2); |
| assertEquals(1, array[0]); |
| assertEquals(2, array[1]); |
| assertEquals(3, array[2]); |
| } |
| |
| @Test |
| public void testToMap() { |
| Map<?, ?> map = ArrayUtils.toMap(new String[][]{{"foo", "bar"}, {"hello", "world"}}); |
| |
| assertEquals("bar", map.get("foo")); |
| assertEquals("world", map.get("hello")); |
| |
| assertNull(ArrayUtils.toMap(null)); |
| assertThrows(IllegalArgumentException.class, () -> |
| ArrayUtils.toMap(new String[][]{{"foo", "bar"}, {"short"}})); |
| assertThrows(IllegalArgumentException.class, () -> |
| ArrayUtils.toMap(new Object[]{new Object[]{"foo", "bar"}, "illegal type"})); |
| assertThrows(IllegalArgumentException.class, () -> |
| ArrayUtils.toMap(new Object[]{new Object[]{"foo", "bar"}, null})); |
| |
| map = ArrayUtils.toMap(new Object[]{new Map.Entry<Object, Object>() { |
| @Override |
| public boolean equals(final Object o) { |
| throw new UnsupportedOperationException(); |
| } |
| |
| @Override |
| public Object getKey() { |
| return "foo"; |
| } |
| |
| @Override |
| public Object getValue() { |
| return "bar"; |
| } |
| |
| @Override |
| public int hashCode() { |
| throw new UnsupportedOperationException(); |
| } |
| |
| @Override |
| public Object setValue(final Object value) { |
| throw new UnsupportedOperationException(); |
| } |
| }}); |
| assertEquals("bar", map.get("foo")); |
| |
| // Return empty map when got input array with length = 0 |
| assertEquals(Collections.emptyMap(), ArrayUtils.toMap(new Object[0])); |
| |
| // Test all null values |
| map = ArrayUtils.toMap(new Object[][] { {null, null}, {null, null} }); |
| assertEquals(Collections.singletonMap(null, null), map); |
| |
| // Test duplicate keys |
| map = ArrayUtils.toMap(new Object[][] { {"key", "value2"}, {"key", "value1"} }); |
| assertEquals(Collections.singletonMap("key", "value1"), map); |
| } |
| |
| @Test |
| public void testToObject_boolean() { |
| final boolean[] b = null; |
| assertArrayEquals(null, ArrayUtils.toObject(b)); |
| assertSame(ArrayUtils.EMPTY_BOOLEAN_OBJECT_ARRAY, ArrayUtils.toObject(new boolean[0])); |
| assertArrayEquals(new Boolean[]{Boolean.TRUE, Boolean.FALSE, Boolean.TRUE}, ArrayUtils.toObject(new boolean[]{true, false, true})); |
| } |
| |
| @Test |
| public void testToObject_byte() { |
| final byte[] b = null; |
| assertArrayEquals(null, ArrayUtils.toObject(b)); |
| |
| assertSame(ArrayUtils.EMPTY_BYTE_OBJECT_ARRAY, |
| ArrayUtils.toObject(new byte[0])); |
| |
| assertArrayEquals(new Byte[]{Byte.valueOf(Byte.MIN_VALUE), |
| Byte.valueOf(Byte.MAX_VALUE), Byte.valueOf((byte) 9999999)}, ArrayUtils.toObject(new byte[]{Byte.MIN_VALUE, Byte.MAX_VALUE, |
| (byte) 9999999})); |
| } |
| |
| @Test |
| public void testToObject_char() { |
| final char[] b = null; |
| assertArrayEquals(null, ArrayUtils.toObject(b)); |
| |
| assertSame(ArrayUtils.EMPTY_CHARACTER_OBJECT_ARRAY, |
| ArrayUtils.toObject(new char[0])); |
| |
| assertArrayEquals(new Character[]{Character.valueOf(Character.MIN_VALUE), |
| Character.valueOf(Character.MAX_VALUE), Character.valueOf('0')}, ArrayUtils.toObject(new char[]{Character.MIN_VALUE, Character.MAX_VALUE, |
| '0'})); |
| } |
| |
| @Test |
| public void testToObject_double() { |
| final double[] b = null; |
| assertArrayEquals(null, ArrayUtils.toObject(b)); |
| |
| assertSame( |
| ArrayUtils.EMPTY_DOUBLE_OBJECT_ARRAY, |
| ArrayUtils.toObject(new double[0])); |
| |
| assertArrayEquals(new Double[]{ |
| Double.valueOf(Double.MIN_VALUE), |
| Double.valueOf(Double.MAX_VALUE), |
| Double.valueOf(9999999)}, ArrayUtils.toObject( |
| new double[]{Double.MIN_VALUE, Double.MAX_VALUE, 9999999})); |
| } |
| |
| @Test |
| public void testToObject_float() { |
| final float[] b = null; |
| assertArrayEquals(null, ArrayUtils.toObject(b)); |
| |
| assertSame( |
| ArrayUtils.EMPTY_FLOAT_OBJECT_ARRAY, |
| ArrayUtils.toObject(new float[0])); |
| |
| assertArrayEquals(new Float[]{ |
| Float.valueOf(Float.MIN_VALUE), |
| Float.valueOf(Float.MAX_VALUE), |
| Float.valueOf(9999999)}, ArrayUtils.toObject( |
| new float[]{Float.MIN_VALUE, Float.MAX_VALUE, 9999999})); |
| } |
| |
| @Test |
| public void testToObject_int() { |
| final int[] b = null; |
| assertArrayEquals(null, ArrayUtils.toObject(b)); |
| |
| assertSame( |
| ArrayUtils.EMPTY_INTEGER_OBJECT_ARRAY, |
| ArrayUtils.toObject(new int[0])); |
| |
| assertArrayEquals(new Integer[]{ |
| Integer.valueOf(Integer.MIN_VALUE), |
| Integer.valueOf(Integer.MAX_VALUE), |
| Integer.valueOf(9999999)}, ArrayUtils.toObject( |
| new int[]{Integer.MIN_VALUE, Integer.MAX_VALUE, 9999999})); |
| } |
| |
| @Test |
| public void testToObject_long() { |
| final long[] b = null; |
| assertArrayEquals(null, ArrayUtils.toObject(b)); |
| |
| assertSame( |
| ArrayUtils.EMPTY_LONG_OBJECT_ARRAY, |
| ArrayUtils.toObject(new long[0])); |
| |
| assertArrayEquals(new Long[]{ |
| Long.valueOf(Long.MIN_VALUE), |
| Long.valueOf(Long.MAX_VALUE), |
| Long.valueOf(9999999)}, ArrayUtils.toObject( |
| new long[]{Long.MIN_VALUE, Long.MAX_VALUE, 9999999})); |
| } |
| |
| @Test |
| public void testToObject_short() { |
| final short[] b = null; |
| assertArrayEquals(null, ArrayUtils.toObject(b)); |
| |
| assertSame(ArrayUtils.EMPTY_SHORT_OBJECT_ARRAY, |
| ArrayUtils.toObject(new short[0])); |
| |
| assertArrayEquals(new Short[]{Short.valueOf(Short.MIN_VALUE), Short.valueOf(Short.MAX_VALUE), |
| Short.valueOf((short) 9999999)}, ArrayUtils.toObject(new short[]{Short.MIN_VALUE, Short.MAX_VALUE, |
| (short) 9999999})); |
| } |
| |
| // testToPrimitive/Object for boolean |
| // ----------------------------------------------------------------------- |
| @Test |
| public void testToPrimitive_boolean() { |
| final Boolean[] b = null; |
| assertNull(ArrayUtils.toPrimitive(b)); |
| assertSame(ArrayUtils.EMPTY_BOOLEAN_ARRAY, ArrayUtils.toPrimitive(new Boolean[0])); |
| assertArrayEquals(new boolean[]{true, false, true}, ArrayUtils.toPrimitive(new Boolean[]{Boolean.TRUE, Boolean.FALSE, Boolean.TRUE})); |
| |
| assertThrows(NullPointerException.class, () -> ArrayUtils.toPrimitive(new Boolean[]{Boolean.TRUE, null})); |
| } |
| |
| @Test |
| public void testToPrimitive_boolean_boolean() { |
| assertNull(ArrayUtils.toPrimitive(null, false)); |
| assertSame(ArrayUtils.EMPTY_BOOLEAN_ARRAY, ArrayUtils.toPrimitive(new Boolean[0], false)); |
| assertArrayEquals(new boolean[]{true, false, true}, ArrayUtils.toPrimitive(new Boolean[]{Boolean.TRUE, Boolean.FALSE, Boolean.TRUE}, false)); |
| assertArrayEquals(new boolean[]{true, false, false}, ArrayUtils.toPrimitive(new Boolean[]{Boolean.TRUE, null, Boolean.FALSE}, false)); |
| assertArrayEquals(new boolean[]{true, true, false}, ArrayUtils.toPrimitive(new Boolean[]{Boolean.TRUE, null, Boolean.FALSE}, true)); |
| } |
| |
| // testToPrimitive/Object for byte |
| // ----------------------------------------------------------------------- |
| @Test |
| public void testToPrimitive_byte() { |
| final Byte[] b = null; |
| assertNull(ArrayUtils.toPrimitive(b)); |
| |
| assertSame(ArrayUtils.EMPTY_BYTE_ARRAY, ArrayUtils.toPrimitive(new Byte[0])); |
| |
| assertArrayEquals(new byte[]{Byte.MIN_VALUE, Byte.MAX_VALUE, (byte) 9999999}, ArrayUtils.toPrimitive(new Byte[]{Byte.valueOf(Byte.MIN_VALUE), |
| Byte.valueOf(Byte.MAX_VALUE), Byte.valueOf((byte) 9999999)})); |
| |
| assertThrows(NullPointerException.class, |
| () -> ArrayUtils.toPrimitive(new Byte[]{Byte.valueOf(Byte.MIN_VALUE), null})); |
| } |
| |
| @Test |
| public void testToPrimitive_byte_byte() { |
| final Byte[] b = null; |
| assertNull(ArrayUtils.toPrimitive(b, Byte.MIN_VALUE)); |
| |
| assertSame(ArrayUtils.EMPTY_BYTE_ARRAY, |
| ArrayUtils.toPrimitive(new Byte[0], (byte) 1)); |
| |
| assertArrayEquals(new byte[]{Byte.MIN_VALUE, Byte.MAX_VALUE, (byte) 9999999}, ArrayUtils.toPrimitive(new Byte[]{Byte.valueOf(Byte.MIN_VALUE), |
| Byte.valueOf(Byte.MAX_VALUE), Byte.valueOf((byte) 9999999)}, |
| Byte.MIN_VALUE)); |
| |
| assertArrayEquals(new byte[]{Byte.MIN_VALUE, Byte.MAX_VALUE, (byte) 9999999}, ArrayUtils.toPrimitive(new Byte[]{Byte.valueOf(Byte.MIN_VALUE), null, |
| Byte.valueOf((byte) 9999999)}, Byte.MAX_VALUE)); |
| } |
| |
| // testToPrimitive/Object for byte |
| // ----------------------------------------------------------------------- |
| @Test |
| public void testToPrimitive_char() { |
| final Character[] b = null; |
| assertNull(ArrayUtils.toPrimitive(b)); |
| |
| assertSame(ArrayUtils.EMPTY_CHAR_ARRAY, ArrayUtils.toPrimitive(new Character[0])); |
| |
| assertArrayEquals(new char[]{Character.MIN_VALUE, Character.MAX_VALUE, '0'}, ArrayUtils.toPrimitive(new Character[]{Character.valueOf(Character.MIN_VALUE), |
| Character.valueOf(Character.MAX_VALUE), Character.valueOf('0')})); |
| |
| assertThrows(NullPointerException.class, |
| () -> ArrayUtils.toPrimitive(new Character[]{Character.valueOf(Character.MIN_VALUE), null})); |
| } |
| |
| @Test |
| public void testToPrimitive_char_char() { |
| final Character[] b = null; |
| assertNull(ArrayUtils.toPrimitive(b, Character.MIN_VALUE)); |
| |
| assertSame(ArrayUtils.EMPTY_CHAR_ARRAY, |
| ArrayUtils.toPrimitive(new Character[0], (char) 0)); |
| |
| assertArrayEquals(new char[]{Character.MIN_VALUE, Character.MAX_VALUE, '0'}, ArrayUtils.toPrimitive(new Character[]{Character.valueOf(Character.MIN_VALUE), |
| Character.valueOf(Character.MAX_VALUE), Character.valueOf('0')}, |
| Character.MIN_VALUE)); |
| |
| assertArrayEquals(new char[]{Character.MIN_VALUE, Character.MAX_VALUE, '0'}, ArrayUtils.toPrimitive(new Character[]{Character.valueOf(Character.MIN_VALUE), null, |
| Character.valueOf('0')}, Character.MAX_VALUE)); |
| } |
| |
| // testToPrimitive/Object for double |
| // ----------------------------------------------------------------------- |
| @Test |
| public void testToPrimitive_double() { |
| final Double[] b = null; |
| assertNull(ArrayUtils.toPrimitive(b)); |
| |
| assertSame(ArrayUtils.EMPTY_DOUBLE_ARRAY, |
| ArrayUtils.toPrimitive(new Double[0])); |
| |
| assertArrayEquals(new double[]{Double.MIN_VALUE, Double.MAX_VALUE, 9999999}, ArrayUtils.toPrimitive(new Double[]{Double.valueOf(Double.MIN_VALUE), |
| Double.valueOf(Double.MAX_VALUE), Double.valueOf(9999999)})); |
| |
| assertThrows(NullPointerException.class, |
| () -> ArrayUtils.toPrimitive(new Float[]{Float.valueOf(Float.MIN_VALUE), null})); |
| } |
| |
| @Test |
| public void testToPrimitive_double_double() { |
| final Double[] l = null; |
| assertNull(ArrayUtils.toPrimitive(l, Double.MIN_VALUE)); |
| |
| assertSame(ArrayUtils.EMPTY_DOUBLE_ARRAY, |
| ArrayUtils.toPrimitive(new Double[0], 1)); |
| |
| assertArrayEquals(new double[]{Double.MIN_VALUE, Double.MAX_VALUE, 9999999}, ArrayUtils.toPrimitive(new Double[]{Double.valueOf(Double.MIN_VALUE), |
| Double.valueOf(Double.MAX_VALUE), Double.valueOf(9999999)}, 1)); |
| |
| assertArrayEquals(new double[]{Double.MIN_VALUE, Double.MAX_VALUE, 9999999}, ArrayUtils.toPrimitive(new Double[]{Double.valueOf(Double.MIN_VALUE), |
| null, Double.valueOf(9999999)}, Double.MAX_VALUE)); |
| } |
| |
| // testToPrimitive/Object for float |
| // ----------------------------------------------------------------------- |
| @Test |
| public void testToPrimitive_float() { |
| final Float[] b = null; |
| assertNull(ArrayUtils.toPrimitive(b)); |
| |
| assertSame(ArrayUtils.EMPTY_FLOAT_ARRAY, |
| ArrayUtils.toPrimitive(new Float[0])); |
| |
| assertArrayEquals(new float[]{Float.MIN_VALUE, Float.MAX_VALUE, 9999999}, ArrayUtils.toPrimitive(new Float[]{Float.valueOf(Float.MIN_VALUE), |
| Float.valueOf(Float.MAX_VALUE), Float.valueOf(9999999)})); |
| |
| assertThrows(NullPointerException.class, |
| () -> ArrayUtils.toPrimitive(new Float[]{Float.valueOf(Float.MIN_VALUE), null})); |
| } |
| |
| @Test |
| public void testToPrimitive_float_float() { |
| final Float[] l = null; |
| assertNull(ArrayUtils.toPrimitive(l, Float.MIN_VALUE)); |
| |
| assertSame(ArrayUtils.EMPTY_FLOAT_ARRAY, |
| ArrayUtils.toPrimitive(new Float[0], 1)); |
| |
| assertArrayEquals(new float[]{Float.MIN_VALUE, Float.MAX_VALUE, 9999999}, ArrayUtils.toPrimitive(new Float[]{Float.valueOf(Float.MIN_VALUE), |
| Float.valueOf(Float.MAX_VALUE), Float.valueOf(9999999)}, 1)); |
| |
| assertArrayEquals(new float[]{Float.MIN_VALUE, Float.MAX_VALUE, 9999999}, ArrayUtils.toPrimitive(new Float[]{Float.valueOf(Float.MIN_VALUE), |
| null, Float.valueOf(9999999)}, Float.MAX_VALUE)); |
| } |
| |
| // testToPrimitive/Object for int |
| // ----------------------------------------------------------------------- |
| @Test |
| public void testToPrimitive_int() { |
| final Integer[] b = null; |
| assertNull(ArrayUtils.toPrimitive(b)); |
| assertSame(ArrayUtils.EMPTY_INT_ARRAY, ArrayUtils.toPrimitive(new Integer[0])); |
| assertArrayEquals(new int[]{Integer.MIN_VALUE, Integer.MAX_VALUE, 9999999}, ArrayUtils.toPrimitive(new Integer[]{Integer.valueOf(Integer.MIN_VALUE), |
| Integer.valueOf(Integer.MAX_VALUE), Integer.valueOf(9999999)})); |
| |
| assertThrows(NullPointerException.class, |
| () -> ArrayUtils.toPrimitive(new Integer[]{Integer.valueOf(Integer.MIN_VALUE), null})); |
| } |
| |
| @Test |
| public void testToPrimitive_int_int() { |
| final Long[] l = null; |
| assertNull(ArrayUtils.toPrimitive(l, Integer.MIN_VALUE)); |
| assertSame(ArrayUtils.EMPTY_INT_ARRAY, |
| ArrayUtils.toPrimitive(new Integer[0], 1)); |
| assertArrayEquals(new int[]{Integer.MIN_VALUE, Integer.MAX_VALUE, 9999999}, ArrayUtils.toPrimitive(new Integer[]{Integer.valueOf(Integer.MIN_VALUE), |
| Integer.valueOf(Integer.MAX_VALUE), Integer.valueOf(9999999)}, 1)); |
| assertArrayEquals(new int[]{Integer.MIN_VALUE, Integer.MAX_VALUE, 9999999}, ArrayUtils.toPrimitive(new Integer[]{Integer.valueOf(Integer.MIN_VALUE), |
| null, Integer.valueOf(9999999)}, Integer.MAX_VALUE)); |
| } |
| |
| @Test |
| public void testToPrimitive_intNull() { |
| final Integer[] iArray = null; |
| assertNull(ArrayUtils.toPrimitive(iArray, Integer.MIN_VALUE)); |
| } |
| |
| // testToPrimitive/Object for long |
| // ----------------------------------------------------------------------- |
| @Test |
| public void testToPrimitive_long() { |
| final Long[] b = null; |
| assertNull(ArrayUtils.toPrimitive(b)); |
| |
| assertSame(ArrayUtils.EMPTY_LONG_ARRAY, |
| ArrayUtils.toPrimitive(new Long[0])); |
| |
| assertArrayEquals(new long[]{Long.MIN_VALUE, Long.MAX_VALUE, 9999999}, ArrayUtils.toPrimitive(new Long[]{Long.valueOf(Long.MIN_VALUE), |
| Long.valueOf(Long.MAX_VALUE), Long.valueOf(9999999)})); |
| |
| assertThrows(NullPointerException.class, |
| () -> ArrayUtils.toPrimitive(new Long[]{Long.valueOf(Long.MIN_VALUE), null})); |
| } |
| |
| @Test |
| public void testToPrimitive_long_long() { |
| final Long[] l = null; |
| assertNull(ArrayUtils.toPrimitive(l, Long.MIN_VALUE)); |
| |
| assertSame(ArrayUtils.EMPTY_LONG_ARRAY, |
| ArrayUtils.toPrimitive(new Long[0], 1)); |
| |
| assertArrayEquals(new long[]{Long.MIN_VALUE, Long.MAX_VALUE, 9999999}, ArrayUtils.toPrimitive(new Long[]{Long.valueOf(Long.MIN_VALUE), |
| Long.valueOf(Long.MAX_VALUE), Long.valueOf(9999999)}, 1)); |
| |
| assertArrayEquals(new long[]{Long.MIN_VALUE, Long.MAX_VALUE, 9999999}, ArrayUtils.toPrimitive(new Long[]{Long.valueOf(Long.MIN_VALUE), |
| null, Long.valueOf(9999999)}, Long.MAX_VALUE)); |
| } |
| |
| // testToPrimitive/Object for short |
| // ----------------------------------------------------------------------- |
| @Test |
| public void testToPrimitive_short() { |
| final Short[] b = null; |
| assertNull(ArrayUtils.toPrimitive(b)); |
| |
| assertSame(ArrayUtils.EMPTY_SHORT_ARRAY, ArrayUtils.toPrimitive(new Short[0])); |
| |
| assertArrayEquals(new short[]{Short.MIN_VALUE, Short.MAX_VALUE, (short) 9999999}, ArrayUtils.toPrimitive(new Short[]{Short.valueOf(Short.MIN_VALUE), |
| Short.valueOf(Short.MAX_VALUE), Short.valueOf((short) 9999999)})); |
| |
| assertThrows(NullPointerException.class, |
| () -> ArrayUtils.toPrimitive(new Short[]{Short.valueOf(Short.MIN_VALUE), null})); |
| } |
| |
| @Test |
| public void testToPrimitive_short_short() { |
| final Short[] s = null; |
| assertNull(ArrayUtils.toPrimitive(s, Short.MIN_VALUE)); |
| |
| assertSame(ArrayUtils.EMPTY_SHORT_ARRAY, ArrayUtils.toPrimitive(new Short[0], |
| Short.MIN_VALUE)); |
| |
| assertArrayEquals(new short[]{Short.MIN_VALUE, Short.MAX_VALUE, (short) 9999999}, ArrayUtils.toPrimitive(new Short[]{Short.valueOf(Short.MIN_VALUE), |
| Short.valueOf(Short.MAX_VALUE), Short.valueOf((short) 9999999)}, Short.MIN_VALUE)); |
| |
| assertArrayEquals(new short[]{Short.MIN_VALUE, Short.MAX_VALUE, (short) 9999999}, ArrayUtils.toPrimitive(new Short[]{Short.valueOf(Short.MIN_VALUE), null, |
| Short.valueOf((short) 9999999)}, Short.MAX_VALUE)); |
| } |
| |
| @Test |
| public void testToString() { |
| assertEquals("{}", ArrayUtils.toString(null)); |
| assertEquals("{}", ArrayUtils.toString(new Object[0])); |
| assertEquals("{}", ArrayUtils.toString(new String[0])); |
| assertEquals("{<null>}", ArrayUtils.toString(new String[]{null})); |
| assertEquals("{pink,blue}", ArrayUtils.toString(new String[]{"pink", "blue"})); |
| |
| assertEquals("<empty>", ArrayUtils.toString(null, "<empty>")); |
| assertEquals("{}", ArrayUtils.toString(new Object[0], "<empty>")); |
| assertEquals("{}", ArrayUtils.toString(new String[0], "<empty>")); |
| assertEquals("{<null>}", ArrayUtils.toString(new String[]{null}, "<empty>")); |
| assertEquals("{pink,blue}", ArrayUtils.toString(new String[]{"pink", "blue"}, "<empty>")); |
| } |
| |
| @Test |
| public void testToStringArray_array() { |
| assertNull(ArrayUtils.toStringArray(null)); |
| |
| assertArrayEquals(new String[0], ArrayUtils.toStringArray(new Object[0])); |
| |
| final Object[] array = {1, 2, 3, "array", "test"}; |
| assertArrayEquals(new String[]{"1", "2", "3", "array", "test"}, ArrayUtils.toStringArray(array)); |
| |
| assertThrows(NullPointerException.class, () -> ArrayUtils.toStringArray(new Object[]{null})); |
| } |
| |
| @Test |
| public void testToStringArray_array_string() { |
| assertNull(ArrayUtils.toStringArray(null, "")); |
| |
| assertArrayEquals(new String[0], ArrayUtils.toStringArray(new Object[0], "")); |
| |
| final Object[] array = {1, null, "test"}; |
| assertArrayEquals(new String[]{"1", "valueForNullElements", "test"}, |
| ArrayUtils.toStringArray(array, "valueForNullElements")); |
| } |
| |
| @Test |
| public void textIndexesOfInt() { |
| int[] array = null; |
| final BitSet emptySet = new BitSet(); |
| final BitSet testSet = new BitSet(); |
| assertEquals(emptySet, ArrayUtils.indexesOf(array, 0)); |
| array = new int[]{0, 1, 2, 3, 0}; |
| testSet.set(0); |
| testSet.set(4); |
| assertEquals(testSet, ArrayUtils.indexesOf(array, 0)); |
| testSet.clear(); |
| testSet.set(1); |
| assertEquals(testSet, ArrayUtils.indexesOf(array, 1)); |
| testSet.clear(); |
| testSet.set(2); |
| assertEquals(testSet, ArrayUtils.indexesOf(array, 2)); |
| testSet.clear(); |
| testSet.set(3); |
| assertEquals(testSet, ArrayUtils.indexesOf(array, 3)); |
| assertEquals(emptySet, ArrayUtils.indexesOf(array, 99)); |
| } |
| } |