You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@commons.apache.org by gg...@apache.org on 2020/05/24 15:05:26 UTC
[commons-lang] branch master updated: Add ArrayUtils.isSameLength() to compare more array types #430.

This is an automated email from the ASF dual-hosted git repository.

ggregory pushed a commit to branch master
in repository https://gitbox.apache.org/repos/asf/commons-lang.git


The following commit(s) were added to refs/heads/master by this push:
     new daa4193  Add ArrayUtils.isSameLength() to compare more array types #430.
daa4193 is described below

commit daa4193fb289e57bd15e10555378f97f90d79dcd
Author: Gary Gregory <ga...@gmail.com>
AuthorDate: Sun May 24 11:05:21 2020 -0400

    Add ArrayUtils.isSameLength() to compare more array types #430.
---
 .../java/org/apache/commons/lang3/ArrayUtils.java  |   19 +-
 .../org/apache/commons/lang3/ArrayUtilsTest.java   | 1336 ++++++++++++++++++++
 2 files changed, 1353 insertions(+), 2 deletions(-)

diff --git a/src/main/java/org/apache/commons/lang3/ArrayUtils.java b/src/main/java/org/apache/commons/lang3/ArrayUtils.java
index 320fba6..d8d7ff5 100644
--- a/src/main/java/org/apache/commons/lang3/ArrayUtils.java
+++ b/src/main/java/org/apache/commons/lang3/ArrayUtils.java
@@ -3406,8 +3406,23 @@ public static int indexOf(final int[] array, final int valueToFind) {
         return getLength(array1) == getLength(array2);
     }
 
-    // Is same length
-    //-----------------------------------------------------------------------
+
+    /**
+     * <p>Checks whether two arrays are the same length, treating
+     * {@code null} arrays as length {@code 0}.
+     *
+     * <p>Any multi-dimensional aspects of the arrays are ignored.
+     *
+     * @param array1 the first array, may be {@code null}
+     * @param array2 the second array, may be {@code null}
+     * @return {@code true} if length of arrays matches, treating
+     *  {@code null} as an empty array
+     * @since 3.11
+     */
+    public static boolean isSameLength(final Object array1, final Object array2) {
+        return getLength(array1) == getLength(array2);
+    }
+
     /**
      * <p>Checks whether two arrays are the same length, treating
      * {@code null} arrays as length {@code 0}.
diff --git a/src/test/java/org/apache/commons/lang3/ArrayUtilsTest.java b/src/test/java/org/apache/commons/lang3/ArrayUtilsTest.java
index 3831f09..66b4d27 100644
--- a/src/test/java/org/apache/commons/lang3/ArrayUtilsTest.java
+++ b/src/test/java/org/apache/commons/lang3/ArrayUtilsTest.java
@@ -1405,6 +1405,1342 @@ public class ArrayUtilsTest {
         assertTrue(ArrayUtils.isSameLength(twoArray, twoArray));
     }
 
+    @Test
+    public void testSameLengthAll() {
+        final Object[] nullArrayObject = null;
+        final Object[] emptyArrayObject = new Object[0];
+        final Object[] oneArrayObject = new Object[]{"pick"};
+        final Object[] twoArrayObject = new Object[]{"pick", "stick"};
+        final boolean[] nullArrayBoolean = null;
+        final boolean[] emptyArrayBoolean = new boolean[0];
+        final boolean[] oneArrayBoolean = new boolean[]{true};
+        final boolean[] twoArrayBoolean = new boolean[]{true, false};
+        final long[] nullArrayLong = null;
+        final long[] emptyArrayLong = new long[0];
+        final long[] oneArrayLong = new long[]{0L};
+        final long[] twoArrayLong = new long[]{0L, 76L};
+        final int[] nullArrayInt = null;
+        final int[] emptyArrayInt = new int[0];
+        final int[] oneArrayInt = new int[]{4};
+        final int[] twoArrayInt = new int[]{5, 7};
+        final short[] nullArrayShort = null;
+        final short[] emptyArrayShort = new short[0];
+        final short[] oneArrayShort = new short[]{4};
+        final short[] twoArrayShort = new short[]{6, 8};
+        final char[] nullArrayChar = null;
+        final char[] emptyArrayChar = new char[0];
+        final char[] oneArrayChar = new char[]{'f'};
+        final char[] twoArrayChar = new char[]{'d', 't'};
+        final byte[] nullArrayByte = null;
+        final byte[] emptyArrayByte = new byte[0];
+        final byte[] oneArrayByte = new byte[]{3};
+        final byte[] twoArrayByte = new byte[]{4, 6};
+        final double[] nullArrayDouble = null;
+        final double[] emptyArrayDouble = new double[0];
+        final double[] oneArrayDouble = new double[]{1.3d};
+        final double[] twoArrayDouble = new double[]{4.5d, 6.3d};
+        final float[] nullArrayFloat = null;
+        final float[] emptyArrayFloat = new float[0];
+        final float[] oneArrayFloat = new float[]{2.5f};
+        final float[] twoArrayFloat = new float[]{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 testSameType() {