/* * 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 extends AbstractLangTest { 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[] 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.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")); assertFalse(ArrayUtils.contains(array, "notInArray")); assertTrue(ArrayUtils.contains(array, null)); } @Test public void testContainsAny() { final Object[] array = {"0", "1", "2", "3", null, "0"}; assertFalse(ArrayUtils.containsAny(null, null)); assertFalse(ArrayUtils.containsAny(null, "1")); assertTrue(ArrayUtils.containsAny(array, "0")); assertTrue(ArrayUtils.containsAny(array, "1")); assertTrue(ArrayUtils.containsAny(array, "2")); assertTrue(ArrayUtils.containsAny(array, "3")); assertFalse(ArrayUtils.containsAny(array, "notInArray")); assertTrue(ArrayUtils.containsAny(array, new String[] {null})); } @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.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 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.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 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(NullPointerException.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() { @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})); assertArrayEquals(new boolean[]{true, false}, 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("{}", ArrayUtils.toString(new String[]{null})); assertEquals("{pink,blue}", ArrayUtils.toString(new String[]{"pink", "blue"})); assertEquals("", ArrayUtils.toString(null, "")); assertEquals("{}", ArrayUtils.toString(new Object[0], "")); assertEquals("{}", ArrayUtils.toString(new String[0], "")); assertEquals("{}", ArrayUtils.toString(new String[]{null}, "")); assertEquals("{pink,blue}", ArrayUtils.toString(new String[]{"pink", "blue"}, "")); } @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)); } }