content: /*
   * This file was automatically generated by UTestGen and EvoSuite
   * Mon Mar 18 14:40:34 GMT 2024
   */
  
  package org.apache.commons.lang3;
  
  import org.junit.jupiter.api.Test;
  import static org.junit.jupiter.api.Assertions.*;
  import org.junit.jupiter.api.Timeout;
  import java.util.concurrent.TimeUnit;
  import static org.evosuite.runtime.EvoAssertions.*;
  import java.lang.reflect.Array;
  import java.util.AbstractMap;
  import java.util.Arrays;
  import java.util.BitSet;
  import java.util.Map;
  import org.apache.commons.lang3.ArrayUtils;
  import org.evosuite.runtime.EvoRunner;
  import org.evosuite.runtime.EvoRunnerParameters;
  import org.junit.runner.RunWith;
  
  @RunWith(EvoRunner.class) @EvoRunnerParameters(mockJVMNonDeterminism = true, useVFS = true, useVNET = true, resetStaticState = true, separateClassLoader = true) 
  public class ArrayUtils_Original_ESTest extends ArrayUtils_Original_ESTest_scaffolding {
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testRemoveAllTaking1And1ThrowsIllegalArgumentException() throws Throwable  {
        Byte arg0 = new Byte((byte) (-1));
        BitSet arg1 = new BitSet();
        // Undeclared exception!
        try { 
          ArrayUtils.removeAll((Object) arg0, arg1);
          fail("Expecting exception: IllegalArgumentException");
        
        } catch(IllegalArgumentException e) {
           //
           // Argument is not an array
           //
           verifyException("java.lang.reflect.Array", e);
        }
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testToStringTaking2ArgumentsReturningNull() throws Throwable  {
        String string = ArrayUtils.toString((Object) null, (String) null);
        assertNull(string);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testToArrayReturningNonEmptyArray() throws Throwable  {
        Byte[] arg0 = new Byte[8];
        Byte[] array = ArrayUtils.toArray(arg0);
        assertSame(arg0, array);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testToArrayReturningEmptyArray() throws Throwable  {
        AbstractMap.SimpleImmutableEntry<Byte, Byte>[] arg0 = (AbstractMap.SimpleImmutableEntry<Byte, Byte>[]) Array.newInstance(AbstractMap.SimpleImmutableEntry.class, 0);
        AbstractMap.SimpleImmutableEntry<Byte, Byte>[] array = ArrayUtils.toArray(arg0);
        assertSame(arg0, array);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testRemoveElementTaking1And1ReturningNonEmptyArrayAndRemoveElementTaking1And10() throws Throwable  {
        boolean[] arg0 = new boolean[1];
        boolean[] removeElement = ArrayUtils.removeElement(arg0, true);
        assertEquals(1, removeElement.length);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testRemoveElementTaking1And1ReturningNullAndRemoveElementTaking1And1AndRemoveElementTaking1And10() throws Throwable  {
        byte[] byteArray = new byte[6];
        Byte[] removeElement = ArrayUtils.removeElement((Byte[]) null, (Object) byteArray[3]);
        assertNull(removeElement);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testRemoveElementTaking1And1ReturningNullAndRemoveElementTaking1And1AndRemoveElementTaking1And11() throws Throwable  {
        long[] removeElement = ArrayUtils.removeElement((long[]) null, 4694L);
        assertNull(removeElement);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testRemoveElementTaking1And1ReturningEmptyArrayAndRemoveElementTaking1And10() throws Throwable  {
        int[] arg0 = new int[0];
        int[] removeElement = ArrayUtils.removeElement(arg0, (-1));
        assertArrayEquals(new int[] {}, removeElement);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testRemoveElementTaking1And1ReturningNullAndRemoveElementTaking1And1AndRemoveElementTaking1And12() throws Throwable  {
        float[] removeElement = ArrayUtils.removeElement((float[]) null, 8.0F);
        assertNull(removeElement);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testRemoveElementTaking1And1ReturningEmptyArrayAndRemoveElementTaking1And11() throws Throwable  {
        char[] arg0 = new char[0];
        char[] removeElement = ArrayUtils.removeElement(arg0, 'f');
        assertEquals(0, removeElement.length);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testRemoveElementTaking1And1ReturningEmptyArrayAndRemoveElementTaking1And12() throws Throwable  {
        byte[] arg0 = new byte[0];
        byte[] removeElement = ArrayUtils.removeElement(arg0, (byte)87);
        assertNotSame(arg0, removeElement);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testRemoveAllTaking1And1() throws Throwable  {
        boolean[] arg0 = new boolean[7];
        int[] arg1 = new int[1];
        boolean[] removeAll = ArrayUtils.removeAll(arg0, arg1);
        assertEquals(6, removeAll.length);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testRemoveAllTaking1And1ReturningNonEmptyArrayAndRemoveAllTaking1And1AndRemoveAllTaking1And10() throws Throwable  {
        short[] arg0 = new short[7];
        int[] arg1 = new int[0];
        short[] removeAll = ArrayUtils.removeAll(arg0, arg1);
        assertEquals(7, removeAll.length);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testRemoveAllTaking1And1ReturningEmptyArrayAndRemoveAllTaking1And1AndRemoveAllTaking1And10() throws Throwable  {
        int[] arg1 = new int[4];
        Byte[] arg0 = new Byte[1];
        Byte[] removeAll = ArrayUtils.removeAll(arg0, arg1);
        assertEquals(0, removeAll.length);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testRemoveAllTaking1And1ReturningNonEmptyArrayAndRemoveAllTaking1And1AndRemoveAllTaking1And11() throws Throwable  {
        int[] arg1 = new int[0];
        long[] arg0 = new long[7];
        long[] removeAll = ArrayUtils.removeAll(arg0, arg1);
        assertEquals(7, removeAll.length);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testRemoveAllTaking1And1ReturningNonEmptyArrayAndRemoveAllTaking1And1AndRemoveAllTaking1And12() throws Throwable  {
        double[] arg0 = new double[6];
        int[] arg1 = new int[0];
        double[] removeAll = ArrayUtils.removeAll(arg0, arg1);
        assertEquals(6, removeAll.length);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testRemoveAllTaking1And1ReturningEmptyArrayAndRemoveAllTaking1And1AndRemoveAllTaking1And11() throws Throwable  {
        int[] arg1 = new int[1];
        char[] arg0 = new char[1];
        char[] removeAll = ArrayUtils.removeAll(arg0, arg1);
        assertEquals(0, removeAll.length);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testRemoveAllTaking1And1ReturningNonEmptyArrayAndRemoveAllTaking1And1AndRemoveAllTaking1And13() throws Throwable  {
        byte[] arg0 = new byte[9];
        int[] arg1 = new int[0];
        byte[] removeAll = ArrayUtils.removeAll(arg0, arg1);
        assertEquals(9, removeAll.length);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testRemoveTaking1And1ReturningNonEmptyArrayAndRemoveTaking1And1AndRemoveTaking1And10() throws Throwable  {
        boolean[] arg0 = new boolean[4];
        boolean[] remove = ArrayUtils.remove(arg0, 3);
        assertEquals(3, remove.length);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testRemoveTaking1And1ReturningEmptyArrayAndRemoveTaking1And1AndRemoveTaking1And10() throws Throwable  {
        boolean[] arg0 = new boolean[1];
        boolean[] remove = ArrayUtils.remove(arg0, 0);
        assertEquals(0, remove.length);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testRemoveTaking1And1ReturningNonEmptyArrayAndRemoveTaking1And1AndRemoveTaking1And11() throws Throwable  {
        short[] arg0 = new short[7];
        short[] remove = ArrayUtils.remove(arg0, 1);
        assertEquals(6, remove.length);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testRemoveTaking1And1ReturningNonEmptyArrayAndRemoveTaking1And1AndRemoveTaking1And12() throws Throwable  {
        long[] arg0 = new long[9];
        long[] remove = ArrayUtils.remove(arg0, 6);
        assertEquals(8, remove.length);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testRemoveTaking1And1ReturningEmptyArrayAndRemoveTaking1And1AndRemoveTaking1And11() throws Throwable  {
        byte arg1 = (byte)0;
        double[] arg0 = new double[1];
        double[] remove = ArrayUtils.remove(arg0, (int) arg1);
        assertEquals(0, remove.length);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testRemoveTaking1And1ReturningNonEmptyArrayAndRemoveTaking1And1AndRemoveTaking1And13() throws Throwable  {
        char[] arg0 = new char[8];
        char[] remove = ArrayUtils.remove(arg0, 2);
        assertEquals(7, remove.length);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testRemoveTaking1And1ReturningNonEmptyArrayAndRemoveTaking1And1AndRemoveTaking1And14() throws Throwable  {
        byte[] arg0 = new byte[2];
        byte[] remove = ArrayUtils.remove(arg0, 1);
        assertEquals(1, remove.length);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testRemoveTaking1And1ReturningEmptyArrayAndRemoveTaking1And1AndRemoveTaking1And12() throws Throwable  {
        byte[] arg0 = new byte[1];
        byte[] remove = ArrayUtils.remove(arg0, 0);
        assertEquals(0, remove.length);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testLastIndexOfTaking11And1ReturningZeroAndLastIndexOfTaking11And1AndLastIndexOfTaking11And10() throws Throwable  {
        boolean[] arg0 = new boolean[4];
        arg0[0] = true;
        int lastIndexOf = ArrayUtils.lastIndexOf(arg0, true, (int) (byte)0);
        assertEquals(0, lastIndexOf);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testLastIndexOfTaking1And1ReturningZeroAndLastIndexOfTaking1And1AndLastIndexOfTaking1And10() throws Throwable  {
        boolean[] arg0 = new boolean[1];
        arg0[0] = true;
        int lastIndexOf = ArrayUtils.lastIndexOf(arg0, true);
        assertEquals(0, lastIndexOf);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testLastIndexOfTaking1And1ReturningPositiveAndLastIndexOfTaking1And1AndLastIndexOfTaking1And10() throws Throwable  {
        boolean[] arg0 = new boolean[6];
        arg0[1] = true;
        int lastIndexOf = ArrayUtils.lastIndexOf(arg0, true);
        assertEquals(1, lastIndexOf);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testLastIndexOfTaking11And1ReturningPositiveAndLastIndexOfTaking11And10() throws Throwable  {
        short[] arg0 = new short[5];
        arg0[3] = (short)3;
        int lastIndexOf = ArrayUtils.lastIndexOf(arg0, (short)3, 4);
        assertEquals(3, lastIndexOf);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testLastIndexOfTaking1And1ReturningZeroAndLastIndexOfTaking1And1AndLastIndexOfTaking1And11() throws Throwable  {
        short[] arg0 = new short[3];
        arg0[0] = (short)1160;
        int lastIndexOf = ArrayUtils.lastIndexOf(arg0, (short)1160);
        assertEquals(0, lastIndexOf);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testLastIndexOfTaking1And1ReturningPositiveAndLastIndexOfTaking1And1AndLastIndexOfTaking1And11() throws Throwable  {
        short[] arg0 = new short[4];
        arg0[1] = (short) (-1);
        int lastIndexOf = ArrayUtils.lastIndexOf(arg0, (short) (-1));
        assertEquals(1, lastIndexOf);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testLastIndexOfTaking1And1ReturningZeroAndLastIndexOfTaking1And1AndLastIndexOfTaking1And12() throws Throwable  {
        Object arg1 = new Object();
        Object[] arg0 = new Object[1];
        arg0[0] = arg1;
        int lastIndexOf = ArrayUtils.lastIndexOf(arg0, arg1);
        assertEquals(0, lastIndexOf);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testLastIndexOfTaking1And1ReturningNegativeAndLastIndexOfTaking1And1AndLastIndexOfTaking1And10() throws Throwable  {
        Byte arg1 = new Byte((byte) (-11));
        Byte[] arg0 = new Byte[8];
        int lastIndexOf = ArrayUtils.lastIndexOf((Object[]) arg0, (Object) arg1);
        assertEquals((-1), lastIndexOf);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testLastIndexOfTaking11And1ReturningPositiveAndLastIndexOfTaking11And11() throws Throwable  {
        long[] arg0 = new long[9];
        int lastIndexOf = ArrayUtils.lastIndexOf(arg0, 0L, (int) (byte)29);
        assertEquals(8, lastIndexOf);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testLastIndexOfTaking1And1ReturningZeroAndLastIndexOfTaking1And1AndLastIndexOfTaking1And13() throws Throwable  {
        byte _byte = (byte) (-5);
        long[] arg0 = new long[2];
        arg0[0] = (long) _byte;
        int lastIndexOf = ArrayUtils.lastIndexOf(arg0, (-5L));
        assertEquals(0, lastIndexOf);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testLastIndexOfTaking1And1ReturningPositiveAndLastIndexOfTaking1And1AndLastIndexOfTaking1And12() throws Throwable  {
        long[] arg0 = new long[8];
        arg0[7] = (-1611L);
        int lastIndexOf = ArrayUtils.lastIndexOf(arg0, (-1611L));
        assertEquals(7, lastIndexOf);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testLastIndexOfTaking1And2IntsReturningPositive() throws Throwable  {
        int[] arg0 = new int[8];
        arg0[3] = (-1818);
        int lastIndexOf = ArrayUtils.lastIndexOf(arg0, (-1818), 2842);
        assertEquals(3, lastIndexOf);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testLastIndexOfTaking1And1ReturningZeroAndLastIndexOfTaking1And1AndLastIndexOfTaking1And14() throws Throwable  {
        int[] arg0 = new int[3];
        arg0[0] = (-2441);
        int lastIndexOf = ArrayUtils.lastIndexOf(arg0, (-2441));
        assertEquals(0, lastIndexOf);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testLastIndexOfTaking1And1ReturningPositiveAndLastIndexOfTaking1And1AndLastIndexOfTaking1And13() throws Throwable  {
        int[] arg0 = new int[7];
        arg0[3] = (int) (short) (-23111);
        int lastIndexOf = ArrayUtils.lastIndexOf(arg0, (-23111));
        assertEquals(3, lastIndexOf);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testLastIndexOfTaking11And1ReturningPositiveAndLastIndexOfTaking11And12() throws Throwable  {
        float[] arg0 = new float[8];
        arg0[4] = (float) (-1);
        int lastIndexOf = ArrayUtils.lastIndexOf(arg0, (-1.0F), 1843);
        assertEquals(4, lastIndexOf);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testLastIndexOfTaking1And1ReturningZeroAndLastIndexOfTaking1And1AndLastIndexOfTaking1And15() throws Throwable  {
        float[] arg0 = new float[1];
        arg0[0] = (float) (byte) (-100);
        int lastIndexOf = ArrayUtils.lastIndexOf(arg0, (float) (byte) (-100));
        assertEquals(0, lastIndexOf);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testLastIndexOfTaking1And1ReturningPositiveAndLastIndexOfTaking1And1AndLastIndexOfTaking1And14() throws Throwable  {
        float[] arg0 = new float[5];
        int lastIndexOf = ArrayUtils.lastIndexOf(arg0, 0.0F);
        assertEquals(4, lastIndexOf);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testLastIndexOfTaking4ArgumentsReturningZero() throws Throwable  {
        double[] arg0 = new double[4];
        arg0[0] = (-1997.9437052250325);
        int lastIndexOf = ArrayUtils.lastIndexOf(arg0, (-1997.9437052250325), 1520, 1458.865663082693);
        assertEquals(0, lastIndexOf);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testLastIndexOfTaking1And2DoublesReturningZero() throws Throwable  {
        double[] arg0 = new double[3];
        arg0[0] = (-749.5999999999999);
        int lastIndexOf = ArrayUtils.lastIndexOf(arg0, (-749.5999999999999), 101.6032);
        assertEquals(0, lastIndexOf);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testLastIndexOfTaking1And2DoublesReturningNegative() throws Throwable  {
        double[] arg0 = new double[3];
        int lastIndexOf = ArrayUtils.lastIndexOf(arg0, (-162.1), (-371.0));
        assertEquals((-1), lastIndexOf);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testLastIndexOfTaking1And1ReturningZeroAndLastIndexOfTaking1And1AndLastIndexOfTaking1And16() throws Throwable  {
        double[] arg0 = new double[4];
        arg0[0] = (-190.86);
        int lastIndexOf = ArrayUtils.lastIndexOf(arg0, (-190.86));
        assertEquals(0, lastIndexOf);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testLastIndexOfTaking1And1ReturningPositiveAndLastIndexOfTaking1And1AndLastIndexOfTaking1And15() throws Throwable  {
        double[] arg0 = new double[8];
        arg0[1] = (double) (-1538);
        int lastIndexOf = ArrayUtils.lastIndexOf(arg0, (-1538.0));
        assertEquals(1, lastIndexOf);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testLastIndexOfTaking11And1ReturningZeroAndLastIndexOfTaking11And1AndLastIndexOfTaking11And11() throws Throwable  {
        char[] arg0 = new char[7];
        arg0[0] = 'M';
        int lastIndexOf = ArrayUtils.lastIndexOf(arg0, 'M', (int) (byte)0);
        assertEquals(0, lastIndexOf);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testLastIndexOfTaking1And1ReturningZeroAndLastIndexOfTaking1And1AndLastIndexOfTaking1And17() throws Throwable  {
        char[] arg0 = new char[5];
        arg0[0] = 'U';
        int lastIndexOf = ArrayUtils.lastIndexOf(arg0, 'U');
        assertEquals(0, lastIndexOf);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testLastIndexOfTaking1And1ReturningPositiveAndLastIndexOfTaking1And1AndLastIndexOfTaking1And16() throws Throwable  {
        char[] arg0 = new char[6];
        arg0[1] = 'h';
        int lastIndexOf = ArrayUtils.lastIndexOf(arg0, 'h');
        assertEquals(1, lastIndexOf);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testLastIndexOfTaking11And1ReturningPositiveAndLastIndexOfTaking11And13() throws Throwable  {
        byte[] arg0 = new byte[4];
        arg0[1] = (byte) (-71);
        int lastIndexOf = ArrayUtils.lastIndexOf(arg0, (byte) (-71), 2499);
        assertEquals(1, lastIndexOf);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testLastIndexOfTaking1And1ReturningPositiveAndLastIndexOfTaking1And1AndLastIndexOfTaking1And17() throws Throwable  {
        byte[] arg0 = new byte[6];
        arg0[4] = (byte) (-115);
        int lastIndexOf = ArrayUtils.lastIndexOf(arg0, (byte) (-115));
        assertEquals(4, lastIndexOf);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testIsSameTypeReturningFalse() throws Throwable  {
        Byte arg0 = new Byte((byte) (-112));
        Object arg1 = new Object();
        boolean sameType = ArrayUtils.isSameType(arg0, arg1);
        assertFalse(sameType);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testIsEqualsReturningFalse() throws Throwable  {
        Object arg1 = new Object();
        Byte arg0 = new Byte((byte)0);
        boolean equals = ArrayUtils.isEquals(arg0, arg1);
        assertFalse(equals);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testIndexOfTaking11And1ReturningPositiveAndIndexOfTaking11And1AndIndexOfTaking11And10() throws Throwable  {
        boolean[] arg0 = new boolean[2];
        arg0[1] = true;
        int indexOf = ArrayUtils.indexOf(arg0, true, (-148));
        assertEquals(1, indexOf);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testIndexOfTaking1And1ReturningZeroAndIndexOfTaking1And1AndIndexOfTaking1And10() throws Throwable  {
        boolean[] arg0 = new boolean[5];
        int indexOf = ArrayUtils.indexOf(arg0, false);
        assertEquals(0, indexOf);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testIndexOfTaking1And1ReturningPositiveAndIndexOfTaking1And1AndIndexOfTaking1And10() throws Throwable  {
        boolean[] arg0 = new boolean[6];
        arg0[0] = true;
        int indexOf = ArrayUtils.indexOf(arg0, false);
        assertEquals(1, indexOf);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testIndexOfTaking11And1ReturningPositiveAndIndexOfTaking11And1AndIndexOfTaking11And11() throws Throwable  {
        short[] arg0 = new short[7];
        arg0[1] = (short) (-1);
        int indexOf = ArrayUtils.indexOf(arg0, (short) (-1), (int) (short) (-26214));
        assertEquals(1, indexOf);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testIndexOfTaking1And1ReturningZeroAndIndexOfTaking1And1AndIndexOfTaking1And11() throws Throwable  {
        short[] arg0 = new short[4];
        arg0[0] = (short)1;
        int indexOf = ArrayUtils.indexOf(arg0, (short)1);
        assertEquals(0, indexOf);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testIndexOfTaking1And1ReturningPositiveAndIndexOfTaking1And1AndIndexOfTaking1And11() throws Throwable  {
        short[] arg0 = new short[7];
        arg0[3] = (short)18457;
        int indexOf = ArrayUtils.indexOf(arg0, (short)18457);
        assertEquals(3, indexOf);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testIndexOfTaking1And1ReturningZeroAndIndexOfTaking1And1AndIndexOfTaking1And12() throws Throwable  {
        Object[] arg0 = new Object[5];
        arg0[0] = (Object) 1076;
        arg0[1] = (Object) 1076;
        int indexOf = ArrayUtils.indexOf(arg0, arg0[1]);
        assertEquals(0, indexOf);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testIndexOfTaking11And1ReturningPositiveAndIndexOfTaking11And1AndIndexOfTaking11And12() throws Throwable  {
        long[] arg0 = new long[9];
        arg0[0] = (long) (short)2807;
        int indexOf = ArrayUtils.indexOf(arg0, (long) (short)0, (-148));
        assertEquals(1, indexOf);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testIndexOfTaking1And1ReturningPositiveAndIndexOfTaking1And1AndIndexOfTaking1And12() throws Throwable  {
        long[] arg0 = new long[3];
        arg0[0] = 527L;
        int indexOf = ArrayUtils.indexOf(arg0, 0L);
        assertEquals(1, indexOf);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testIndexOfTaking1And1ReturningNegativeAndIndexOfTaking1And1AndIndexOfTaking1And10() throws Throwable  {
        long[] arg0 = new long[8];
        int indexOf = ArrayUtils.indexOf(arg0, (long) (short)6);
        assertEquals((-1), indexOf);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testIndexOfTaking1And2IntsReturningZero() throws Throwable  {
        int[] arg0 = new int[9];
        arg0[0] = (int) (byte) (-71);
        int indexOf = ArrayUtils.indexOf(arg0, (-71), (-71));
        assertEquals(0, indexOf);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testIndexOfTaking1And1ReturningZeroAndIndexOfTaking1And1AndIndexOfTaking1And13() throws Throwable  {
        int[] arg0 = new int[1];
        arg0[0] = 4516;
        int indexOf = ArrayUtils.indexOf(arg0, 4516);
        assertEquals(0, indexOf);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testIndexOfTaking1And1ReturningPositiveAndIndexOfTaking1And1AndIndexOfTaking1And13() throws Throwable  {
        int[] arg0 = new int[4];
        arg0[3] = 213;
        int indexOf = ArrayUtils.indexOf(arg0, 213);
        assertEquals(3, indexOf);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testIndexOfTaking11And1ReturningPositiveAndIndexOfTaking11And1AndIndexOfTaking11And13() throws Throwable  {
        float[] arg0 = new float[6];
        arg0[2] = (-1595.35F);
        int indexOf = ArrayUtils.indexOf(arg0, (-1595.35F), (-81));
        assertEquals(2, indexOf);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testIndexOfTaking1And1ReturningPositiveAndIndexOfTaking1And1AndIndexOfTaking1And14() throws Throwable  {
        float[] arg0 = new float[4];
        arg0[1] = 1.0F;
        int indexOf = ArrayUtils.indexOf(arg0, 1.0F);
        assertEquals(1, indexOf);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testIndexOfTaking1And1ReturningNegativeAndIndexOfTaking1And1AndIndexOfTaking1And11() throws Throwable  {
        float[] arg0 = new float[4];
        int indexOf = ArrayUtils.indexOf(arg0, 1.0F);
        assertEquals((-1), indexOf);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testIndexOfTaking11And1ReturningPositiveAndIndexOfTaking11And1AndIndexOfTaking11And14() throws Throwable  {
        double[] arg0 = new double[9];
        arg0[2] = (-1243.391);
        int indexOf = ArrayUtils.indexOf(arg0, (-1243.391), (-1));
        assertEquals(2, indexOf);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testIndexOfTaking1And2DoublesReturningZero() throws Throwable  {
        double[] arg0 = new double[9];
        int indexOf = ArrayUtils.indexOf(arg0, 90.0, 2493.685);
        assertEquals(0, indexOf);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testIndexOfTaking1And2DoublesReturningPositive() throws Throwable  {
        double[] arg0 = new double[5];
        arg0[3] = (-1332.0);
        int indexOf = ArrayUtils.indexOf(arg0, (-1332.0), 0.0);
        assertEquals(3, indexOf);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testIndexOfTaking1And1ReturningZeroAndIndexOfTaking1And1AndIndexOfTaking1And14() throws Throwable  {
        double[] arg0 = new double[4];
        arg0[0] = (double) 103;
        int indexOf = ArrayUtils.indexOf(arg0, 103.0);
        assertEquals(0, indexOf);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testIndexOfTaking1And1ReturningPositiveAndIndexOfTaking1And1AndIndexOfTaking1And15() throws Throwable  {
        double[] arg0 = new double[2];
        arg0[1] = (double) (byte) (-104);
        int indexOf = ArrayUtils.indexOf(arg0, (-104.0));
        assertEquals(1, indexOf);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testIndexOfTaking11And1ReturningPositiveAndIndexOfTaking11And1AndIndexOfTaking11And15() throws Throwable  {
        char[] arg0 = new char[7];
        arg0[5] = ' ';
        int indexOf = ArrayUtils.indexOf(arg0, ' ', (int) (byte) (-1));
        assertEquals(5, indexOf);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testIndexOfTaking1And1ReturningZeroAndIndexOfTaking1And1AndIndexOfTaking1And15() throws Throwable  {
        char[] arg0 = new char[4];
        arg0[0] = '`';
        int indexOf = ArrayUtils.indexOf(arg0, '`');
        assertEquals(0, indexOf);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testIndexOfTaking1And1ReturningPositiveAndIndexOfTaking1And1AndIndexOfTaking1And16() throws Throwable  {
        char[] arg0 = new char[3];
        arg0[1] = 'T';
        int indexOf = ArrayUtils.indexOf(arg0, 'T');
        assertEquals(1, indexOf);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testIndexOfTaking11And1ReturningPositiveAndIndexOfTaking11And1AndIndexOfTaking11And16() throws Throwable  {
        byte[] arg0 = new byte[7];
        arg0[4] = (byte)3;
        int indexOf = ArrayUtils.indexOf(arg0, (byte)3, (-149));
        assertEquals(4, indexOf);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testIndexOfTaking1And1ReturningZeroAndIndexOfTaking1And1AndIndexOfTaking1And16() throws Throwable  {
        byte[] arg0 = new byte[3];
        arg0[0] = (byte) (-1);
        int indexOf = ArrayUtils.indexOf(arg0, (byte) (-1));
        assertEquals(0, indexOf);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testIndexOfTaking1And1ReturningPositiveAndIndexOfTaking1And1AndIndexOfTaking1And17() throws Throwable  {
        byte[] arg0 = new byte[6];
        arg0[2] = (byte)2;
        int indexOf = ArrayUtils.indexOf(arg0, (byte)2);
        assertEquals(2, indexOf);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testCloneTakingBooleanArrayReturningNonEmptyArray() throws Throwable  {
        boolean[] arg0 = new boolean[2];
        boolean[] clone = ArrayUtils.clone(arg0);
        assertEquals(2, clone.length);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testCloneTakingShortArrayReturningNonEmptyArray() throws Throwable  {
        short[] arg0 = new short[7];
        short[] clone = ArrayUtils.clone(arg0);
        assertEquals(7, clone.length);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testCloneTakingObjectArrayReturningNonEmptyArray() throws Throwable  {
        Byte[] arg0 = new Byte[6];
        Byte[] clone = ArrayUtils.clone(arg0);
        assertNotSame(arg0, clone);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testCloneTakingLongArrayReturningNonEmptyArray() throws Throwable  {
        long[] arg0 = new long[1];
        long[] clone = ArrayUtils.clone(arg0);
        assertEquals(1, clone.length);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testCloneTakingIntArrayReturningNonEmptyArray() throws Throwable  {
        int[] arg0 = new int[2];
        int[] clone = ArrayUtils.clone(arg0);
        assertEquals(2, clone.length);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testCloneTakingDoubleArrayReturningNonEmptyArray() throws Throwable  {
        double[] arg0 = new double[2];
        double[] clone = ArrayUtils.clone(arg0);
        assertEquals(2, clone.length);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testCloneTakingCharArrayReturningNonEmptyArray() throws Throwable  {
        char[] arg0 = new char[4];
        char[] clone = ArrayUtils.clone(arg0);
        assertEquals(4, clone.length);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testCloneTakingByteArrayReturningNonEmptyArray() throws Throwable  {
        byte[] arg0 = new byte[4];
        byte[] clone = ArrayUtils.clone(arg0);
        assertEquals(4, clone.length);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testAddAllTaking2ShortArraysReturningEmptyArray() throws Throwable  {
        short[] arg0 = new short[4];
        short[] arg1 = ArrayUtils.subarray(arg0, (int) (short)1398, (int) (short)0);
        short[] addAll = ArrayUtils.addAll(arg1, arg1);
        assertNotSame(addAll, arg1);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testAddTaking11And1AndAddTaking11And1AndAddTaking11And1ReturningNonEmptyArray0() throws Throwable  {
        short[] arg0 = new short[1];
        short[] add = ArrayUtils.add(arg0, (int) (short)0, (short)0);
        assertArrayEquals(new short[] {(short)0, (short)0}, add);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testRemoveAllTaking1And1ThrowsNullPointerException() throws Throwable  {
        // Undeclared exception!
        try { 
          ArrayUtils.removeAll((Object) null, (int[]) null);
          fail("Expecting exception: NullPointerException");
        
        } catch(NullPointerException e) {
           //
           // no message in exception (getMessage() returned null)
           //
           verifyException("org.apache.commons.lang3.ArrayUtils", e);
        }
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testIsNotEmptyTakingIntArrayWithNull() throws Throwable  {
        boolean notEmpty = ArrayUtils.isNotEmpty((int[]) null);
        assertFalse(notEmpty);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testIsNotEmptyTakingIntArrayWithEmptyArray() throws Throwable  {
        int[] arg0 = new int[0];
        boolean notEmpty = ArrayUtils.isNotEmpty(arg0);
        assertFalse(notEmpty);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testIsNotEmptyTakingIntArrayReturningTrue() throws Throwable  {
        int[] arg0 = new int[2];
        boolean notEmpty = ArrayUtils.isNotEmpty(arg0);
        assertTrue(notEmpty);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testIsEmptyTakingBooleanArrayReturningTrue() throws Throwable  {
        boolean empty = ArrayUtils.isEmpty((boolean[]) null);
        assertTrue(empty);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testIsEmptyTakingBooleanArrayReturningFalse() throws Throwable  {
        boolean[] arg0 = new boolean[1];
        boolean empty = ArrayUtils.isEmpty(arg0);
        assertFalse(empty);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testIsEmptyTakingFloatArrayReturningFalse() throws Throwable  {
        float[] arg0 = new float[1];
        boolean empty = ArrayUtils.isEmpty(arg0);
        assertFalse(empty);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testIsEmptyTakingFloatArrayWithNull() throws Throwable  {
        boolean empty = ArrayUtils.isEmpty((float[]) null);
        assertTrue(empty);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testIsEmptyTakingFloatArrayWithEmptyArray() throws Throwable  {
        float[] arg0 = new float[0];
        boolean empty = ArrayUtils.isEmpty(arg0);
        assertTrue(empty);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testIsEmptyTakingDoubleArrayWithNull() throws Throwable  {
        boolean empty = ArrayUtils.isEmpty((double[]) null);
        assertTrue(empty);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testIsEmptyTakingDoubleArrayReturningFalse() throws Throwable  {
        double[] arg0 = new double[1];
        boolean empty = ArrayUtils.isEmpty(arg0);
        assertFalse(empty);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testIsEmptyTakingDoubleArrayWithEmptyArray() throws Throwable  {
        double[] arg0 = new double[0];
        boolean empty = ArrayUtils.isEmpty(arg0);
        assertTrue(empty);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testIsEmptyTakingByteArrayReturningFalse() throws Throwable  {
        byte[] arg0 = new byte[5];
        boolean empty = ArrayUtils.isEmpty(arg0);
        assertFalse(empty);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testIsEmptyTakingCharArrayReturningFalse() throws Throwable  {
        char[] arg0 = new char[3];
        boolean empty = ArrayUtils.isEmpty(arg0);
        assertFalse(empty);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testIsEmptyTakingShortArrayReturningFalse() throws Throwable  {
        short[] arg0 = new short[7];
        boolean empty = ArrayUtils.isEmpty(arg0);
        assertFalse(empty);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testIsEmptyTakingIntArrayReturningFalse() throws Throwable  {
        int[] arg0 = new int[4];
        boolean empty = ArrayUtils.isEmpty(arg0);
        assertFalse(empty);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testIndexOfTaking11And1ReturningZeroAndIndexOfTaking11And1AndIndexOfTaking11And10() throws Throwable  {
        boolean[] arg0 = new boolean[8];
        int indexOf = ArrayUtils.indexOf(arg0, false, 0);
        assertEquals(0, indexOf);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testIndexOfTaking11And1WithNullAndIndexOfTaking11And1AndIndexOfTaking11And10() throws Throwable  {
        int indexOf = ArrayUtils.indexOf((boolean[]) null, true, (-2535));
        assertEquals((-1), indexOf);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testLastIndexOfTaking11And1AndLastIndexOfTaking11And1AndLastIndexOfTaking11And1ReturningNegative0() throws Throwable  {
        float[] arg0 = new float[1];
        int lastIndexOf = ArrayUtils.lastIndexOf(arg0, (-1.0F), 1679);
        assertEquals((-1), lastIndexOf);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testIndexOfTaking11And1ReturningZeroAndIndexOfTaking11And1AndIndexOfTaking11And11() throws Throwable  {
        float[] arg0 = new float[3];
        arg0[0] = (-1595.35F);
        int indexOf = ArrayUtils.indexOf(arg0, (-1595.35F), (-81));
        assertEquals(0, indexOf);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testIndexOfTaking11And1WithPositiveAndIndexOfTaking11And1AndIndexOfTaking11And10() throws Throwable  {
        float[] arg0 = new float[1];
        int indexOf = ArrayUtils.indexOf(arg0, 512.0F, 4);
        assertEquals((-1), indexOf);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testLastIndexOfTaking4ArgumentsReturningPositive() throws Throwable  {
        double[] arg0 = new double[4];
        int lastIndexOf = ArrayUtils.lastIndexOf(arg0, (double) (byte)2, (int) (byte)2, 2693.0);
        assertEquals(2, lastIndexOf);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testLastIndexOfTaking11And1WithZeroAndLastIndexOfTaking11And1AndLastIndexOfTaking11And10() throws Throwable  {
        double[] arg0 = new double[6];
        arg0[0] = (double) (short)1;
        int lastIndexOf = ArrayUtils.lastIndexOf(arg0, 0.0, (int) (short)0);
        assertEquals((-1), lastIndexOf);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testLastIndexOfTaking11And1ReturningZeroAndLastIndexOfTaking11And1AndLastIndexOfTaking11And12() throws Throwable  {
        double[] arg0 = new double[1];
        int lastIndexOf = ArrayUtils.lastIndexOf(arg0, 0.0, Integer.MAX_VALUE);
        assertEquals(0, lastIndexOf);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testIndexOfTaking4ArgumentsReturningPositive() throws Throwable  {
        double[] arg0 = new double[8];
        arg0[0] = (-1.0);
        int indexOf = ArrayUtils.indexOf(arg0, 0.0, (int) (byte) (-1), 0.0);
        assertEquals(1, indexOf);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testIndexOfTaking4ArgumentsWithNegativeAndPositive() throws Throwable  {
        double[] arg0 = new double[6];
        int indexOf = ArrayUtils.indexOf(arg0, (-4567.402540497), 2, 4373.0);
        assertEquals((-1), indexOf);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testIndexOfTaking11And1ReturningZeroAndIndexOfTaking11And1AndIndexOfTaking11And12() throws Throwable  {
        double[] arg0 = new double[2];
        arg0[0] = (-1243.391);
        int indexOf = ArrayUtils.indexOf(arg0, (-1243.391), (-1));
        assertEquals(0, indexOf);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testIndexOfTaking11And1ReturningNegative() throws Throwable  {
        double[] arg0 = new double[9];
        int indexOf = ArrayUtils.indexOf(arg0, (double) (byte)122, 1);
        assertEquals((-1), indexOf);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testLastIndexOfTaking11And1ReturningZeroAndLastIndexOfTaking11And1AndLastIndexOfTaking11And13() throws Throwable  {
        byte[] arg0 = new byte[4];
        arg0[0] = (byte) (-71);
        int lastIndexOf = ArrayUtils.lastIndexOf(arg0, (byte) (-71), 2499);
        assertEquals(0, lastIndexOf);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testLastIndexOfTaking11And1AndLastIndexOfTaking11And1AndLastIndexOfTaking11And1ReturningNegative1() throws Throwable  {
        byte[] arg0 = new byte[4];
        int lastIndexOf = ArrayUtils.lastIndexOf(arg0, (byte) (-71), 2499);
        assertEquals((-1), lastIndexOf);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testLastIndexOfTaking11And1WithNullAndLastIndexOfTaking11And1AndLastIndexOfTaking11And10() throws Throwable  {
        int lastIndexOf = ArrayUtils.lastIndexOf((byte[]) null, (byte) (-92), (int) (byte) (-92));
        assertEquals((-1), lastIndexOf);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testIndexOfTaking11And1ReturningZeroAndIndexOfTaking11And1AndIndexOfTaking11And13() throws Throwable  {
        byte[] arg0 = new byte[6];
        arg0[0] = (byte) (-85);
        int indexOf = ArrayUtils.indexOf(arg0, (byte) (-85), (int) (byte) (-85));
        assertEquals(0, indexOf);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testIndexOfTaking11And1WithNullAndIndexOfTaking11And1AndIndexOfTaking11And11() throws Throwable  {
        int indexOf = ArrayUtils.indexOf((byte[]) null, (byte)22, 1756);
        assertEquals((-1), indexOf);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testIndexOfTaking11And1ReturningZeroAndIndexOfTaking11And1AndIndexOfTaking11And14() throws Throwable  {
        char[] arg0 = new char[2];
        arg0[0] = '|';
        int indexOf = ArrayUtils.indexOf(arg0, '|', (int) (byte) (-100));
        assertEquals(0, indexOf);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testIndexOfTaking11And1AndIndexOfTaking11And1AndIndexOfTaking11And1ReturningNegative0() throws Throwable  {
        char[] arg0 = new char[5];
        int indexOf = ArrayUtils.indexOf(arg0, '|', 1068);
        assertEquals((-1), indexOf);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testIndexOfTaking11And1WithNullAndIndexOfTaking11And1AndIndexOfTaking11And12() throws Throwable  {
        int indexOf = ArrayUtils.indexOf((char[]) null, 'n', 4);
        assertEquals((-1), indexOf);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testIndexOfTaking11And1AndIndexOfTaking11And1AndIndexOfTaking11And1ReturningNegative1() throws Throwable  {
        short[] arg0 = new short[7];
        int indexOf = ArrayUtils.indexOf(arg0, (short) (-1), (int) (short) (-26214));
        assertEquals((-1), indexOf);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testIndexOfTaking11And1WithPositiveAndIndexOfTaking11And1AndIndexOfTaking11And11() throws Throwable  {
        short[] arg0 = new short[8];
        int indexOf = ArrayUtils.indexOf(arg0, (short)32, (int) (short)512);
        assertEquals((-1), indexOf);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testIndexOfTaking11And1WithNullAndIndexOfTaking11And1AndIndexOfTaking11And13() throws Throwable  {
        int indexOf = ArrayUtils.indexOf((short[]) null, (short)0, 569);
        assertEquals((-1), indexOf);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testLastIndexOfTaking1And2IntsWithNegativeAndPositive() throws Throwable  {
        int[] arg0 = new int[8];
        int lastIndexOf = ArrayUtils.lastIndexOf(arg0, (-1818), 2842);
        assertEquals((-1), lastIndexOf);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testIndexOfTaking1And2IntsReturningPositive() throws Throwable  {
        int[] arg0 = new int[7];
        arg0[1] = 2;
        int indexOf = ArrayUtils.indexOf(arg0, 2, (int) (short)0);
        assertEquals(1, indexOf);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testIndexOfTaking1And2IntsWithPositive() throws Throwable  {
        int[] arg0 = new int[8];
        int indexOf = ArrayUtils.indexOf(arg0, 1, 8);
        assertEquals((-1), indexOf);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testIndexOfTaking1And2IntsWithNull() throws Throwable  {
        int indexOf = ArrayUtils.indexOf((int[]) null, 32, (-5542));
        assertEquals((-1), indexOf);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testLastIndexOfTaking11And1WithNegativeAndLastIndexOfTaking11And1AndLastIndexOfTaking11And10() throws Throwable  {
        long[] arg0 = new long[3];
        int lastIndexOf = ArrayUtils.lastIndexOf(arg0, (-1797L), 1302);
        assertEquals((-1), lastIndexOf);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testIndexOfTaking11And1AndIndexOfTaking11And1AndIndexOfTaking11And1ReturningNegative2() throws Throwable  {
        long[] arg0 = new long[8];
        int indexOf = ArrayUtils.indexOf(arg0, (long) (byte)110, 3015);
        assertEquals((-1), indexOf);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testIndexOfTaking11And1WithNullAndIndexOfTaking11And1AndIndexOfTaking11And14() throws Throwable  {
        int indexOf = ArrayUtils.indexOf((long[]) null, 1490L, 2550);
        assertEquals((-1), indexOf);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testLastIndexOfTaking11And1ReturningPositiveAndLastIndexOfTaking11And14() throws Throwable  {
        Object[] arg0 = new Object[2];
        int lastIndexOf = ArrayUtils.lastIndexOf(arg0, arg0[0], (int) 'a');
        assertEquals(1, lastIndexOf);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testIndexOfTaking11And1ReturningZeroAndIndexOfTaking11And1AndIndexOfTaking11And15() throws Throwable  {
        Object arg1 = new Object();
        Object[] arg0 = new Object[1];
        arg0[0] = arg1;
        int indexOf = ArrayUtils.indexOf(arg0, arg1, (-1));
        assertEquals(0, indexOf);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testIndexOfTaking11And1WithNullAndIndexOfTaking11And1AndIndexOfTaking11And15() throws Throwable  {
        Object arg1 = new Object();
        int indexOf = ArrayUtils.indexOf((Object[]) null, arg1, (-1));
        assertEquals((-1), indexOf);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testReverseTaking1And2IntsWithEmptyArrayAndPositive() throws Throwable  {
        short[] arg0 = new short[0];
        ArrayUtils.reverse(arg0, 4, 2);
        assertArrayEquals(new short[] {}, arg0);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testReverseTaking1And2IntsWithPositiveAndZero() throws Throwable  {
        Object[] arg0 = new Object[5];
        ArrayUtils.reverse(arg0, 1310, 0);
        assertEquals(5, arg0.length);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testReverseTaking1And2IntsWithNegativeAndPositive0() throws Throwable  {
        long[] arg0 = new long[1];
        ArrayUtils.reverse(arg0, 575, (-2075));
        assertArrayEquals(new long[] {0L}, arg0);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testReverseTaking1And2IntsWithNegativeAndReverseTaking1And2IntsAndReverseTaking1And2Ints0() throws Throwable  {
        int[] arg0 = new int[2];
        ArrayUtils.reverse(arg0, (int) (byte)96, (-2230));
        assertArrayEquals(new int[] {0, 0}, arg0);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testReverseTaking1And2IntsWithNegativeAndReverseTaking1And2IntsAndReverseTaking1And2Ints1() throws Throwable  {
        float[] arg0 = new float[0];
        ArrayUtils.reverse(arg0, 4, (-703));
        assertArrayEquals(new float[] {}, arg0, 0.01F);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testReverseTaking1And2IntsWithZeroAndPositive() throws Throwable  {
        double[] arg0 = new double[4];
        ArrayUtils.reverse(arg0, 0, 121);
        assertArrayEquals(new double[] {0.0, 0.0, 0.0, 0.0}, arg0, 0.01);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testReverseTaking1And2IntsWithPositiveAndNegative0() throws Throwable  {
        char[] arg0 = new char[9];
        ArrayUtils.reverse(arg0, (int) (short)1, (-102));
        assertEquals(9, arg0.length);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testReverseTaking1And2IntsWithZero() throws Throwable  {
        byte[] arg0 = new byte[8];
        ArrayUtils.reverse(arg0, (int) (short)0, (-4883));
        assertArrayEquals(new byte[] {(byte)0, (byte)0, (byte)0, (byte)0, (byte)0, (byte)0, (byte)0, (byte)0}, arg0);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testReverseTaking1And2IntsWithNonEmptyArrayAndZero() throws Throwable  {
        boolean[] arg0 = new boolean[3];
        ArrayUtils.reverse(arg0, (int) (byte)0, (int) (byte)68);
        assertTrue(Arrays.equals(new boolean[] {false, false, false}, arg0));
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testGetLengthThrowsIllegalArgumentException() throws Throwable  {
        Byte arg0 = new Byte((byte)17);
        // Undeclared exception!
        try { 
          ArrayUtils.getLength(arg0);
          fail("Expecting exception: IllegalArgumentException");
        
        } catch(IllegalArgumentException e) {
           //
           // Argument is not an array
           //
           verifyException("java.lang.reflect.Array", e);
        }
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testGetLength() throws Throwable  {
        int length = ArrayUtils.getLength((Object) null);
        assertEquals(0, length);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testCloneTakingBooleanArrayReturningNull() throws Throwable  {
        boolean[] clone = ArrayUtils.clone((boolean[]) null);
        assertNull(clone);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testCloneTakingFloatArrayReturningNull() throws Throwable  {
        float[] clone = ArrayUtils.clone((float[]) null);
        assertNull(clone);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testCloneTakingFloatArrayReturningNonEmptyArray() throws Throwable  {
        float[] arg0 = new float[6];
        float[] clone = ArrayUtils.clone(arg0);
        assertEquals(6, clone.length);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testCloneTakingDoubleArrayReturningEmptyArray() throws Throwable  {
        double[] arg0 = new double[0];
        double[] clone = ArrayUtils.clone(arg0);
        assertEquals(0, clone.length);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testCloneTakingDoubleArrayReturningNull() throws Throwable  {
        double[] clone = ArrayUtils.clone((double[]) null);
        assertNull(clone);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testCloneTakingByteArrayReturningNull() throws Throwable  {
        byte[] clone = ArrayUtils.clone((byte[]) null);
        assertNull(clone);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testCloneTakingCharArrayReturningNull() throws Throwable  {
        char[] clone = ArrayUtils.clone((char[]) null);
        assertNull(clone);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testCloneTakingShortArrayReturningEmptyArray() throws Throwable  {
        short[] arg0 = new short[0];
        short[] clone = ArrayUtils.clone(arg0);
        assertNotSame(arg0, clone);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testCloneTakingShortArrayReturningNull() throws Throwable  {
        short[] clone = ArrayUtils.clone((short[]) null);
        assertNull(clone);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testCloneTakingIntArrayReturningEmptyArray() throws Throwable  {
        int[] arg0 = new int[0];
        int[] clone = ArrayUtils.clone(arg0);
        assertEquals(0, clone.length);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testCloneTakingIntArrayReturningNull() throws Throwable  {
        int[] clone = ArrayUtils.clone((int[]) null);
        assertNull(clone);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testCloneTakingLongArrayReturningNull() throws Throwable  {
        long[] clone = ArrayUtils.clone((long[]) null);
        assertNull(clone);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testCloneTakingLongArrayReturningEmptyArray() throws Throwable  {
        long[] arg0 = new long[0];
        long[] clone = ArrayUtils.clone(arg0);
        assertNotSame(arg0, clone);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testCloneTakingObjectArrayReturningNull() throws Throwable  {
        Byte[] clone = ArrayUtils.clone((Byte[]) null);
        assertNull(clone);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testToStringTaking2ArgumentsReturningNonEmptyString() throws Throwable  {
        Byte arg0 = new Byte((byte)40);
        String string = ArrayUtils.toString((Object) arg0, "java.vm.version");
        assertEquals("40", string);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testIndexOfTaking1And1ReturningZeroAndIndexOfTaking1And1AndIndexOfTaking1And17() throws Throwable  {
        float[] arg0 = new float[1];
        int indexOf = ArrayUtils.indexOf(arg0, (float) (byte)0);
        assertEquals(0, indexOf);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testRemoveTaking1And1AndRemoveTaking1And1AndRemoveTaking1And1ReturningNonEmptyArray0() throws Throwable  {
        float[] arg0 = new float[7];
        float[] remove = ArrayUtils.remove(arg0, 2);
        assertEquals(6, remove.length);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testIndexOfTaking1And1ReturningNegativeAndIndexOfTaking1And1AndIndexOfTaking1And12() throws Throwable  {
        boolean[] arg0 = new boolean[4];
        int indexOf = ArrayUtils.indexOf(arg0, true);
        assertEquals((-1), indexOf);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testIndexOfTaking1And1ReturningNegativeAndIndexOfTaking1And1AndIndexOfTaking1And13() throws Throwable  {
        byte[] arg0 = new byte[3];
        int indexOf = ArrayUtils.indexOf(arg0, (byte) (-1));
        assertEquals((-1), indexOf);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testRemoveTaking1And1ReturningNonEmptyArrayAndRemoveTaking1And1AndRemoveTaking1And15() throws Throwable  {
        double[] arg0 = new double[9];
        double[] remove = ArrayUtils.remove(arg0, 1);
        assertEquals(8, remove.length);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testIndexOfTaking1And1ReturningZeroAndIndexOfTaking1And1AndIndexOfTaking1And18() throws Throwable  {
        long[] arg0 = new long[8];
        int indexOf = ArrayUtils.indexOf(arg0, (long) (short)0);
        assertEquals(0, indexOf);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testIndexOfTaking1And1ReturningNegativeAndIndexOfTaking1And1AndIndexOfTaking1And14() throws Throwable  {
        double[] arg0 = new double[2];
        int indexOf = ArrayUtils.indexOf(arg0, (-104.0));
        assertEquals((-1), indexOf);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testRemoveAllTaking1And1ReturningNonEmptyArrayAndRemoveAllTaking1And1AndRemoveAllTaking1And14() throws Throwable  {
        float[] arg0 = new float[6];
        int[] arg1 = new int[3];
        float[] removeAll = ArrayUtils.removeAll(arg0, arg1);
        assertEquals(5, removeAll.length);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testRemoveAllTaking1And1ThrowsIndexOutOfBoundsException0() throws Throwable  {
        int[] arg1 = new int[6];
        // Undeclared exception!
        try { 
          ArrayUtils.removeAll((Object) null, arg1);
          fail("Expecting exception: IndexOutOfBoundsException");
        
        } catch(IndexOutOfBoundsException e) {
           //
           // Index: 0, Length: 0
           //
           verifyException("org.apache.commons.lang3.ArrayUtils", e);
        }
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testRemoveAllTaking1And1ThrowsIndexOutOfBoundsException1() throws Throwable  {
        int[] arg1 = new int[1];
        arg1[0] = (-1);
        // Undeclared exception!
        try { 
          ArrayUtils.removeAll((Object) null, arg1);
          fail("Expecting exception: IndexOutOfBoundsException");
        
        } catch(IndexOutOfBoundsException e) {
           //
           // Index: -1, Length: 0
           //
           verifyException("org.apache.commons.lang3.ArrayUtils", e);
        }
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testRemoveElementsTaking2BooleanArrays() throws Throwable  {
        boolean[] arg0 = new boolean[8];
        arg0[1] = true;
        boolean[] arg1 = new boolean[8];
        boolean[] removeElements = ArrayUtils.removeElements(arg0, arg1);
        assertEquals(1, removeElements.length);
        assertTrue(Arrays.equals(new boolean[] {true}, removeElements));
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testRemoveElementsTaking2BooleanArraysWithEmptyArray() throws Throwable  {
        boolean[] arg0 = new boolean[11];
        boolean[] arg1 = ArrayUtils.EMPTY_BOOLEAN_ARRAY;
        boolean[] removeElements = ArrayUtils.removeElements(arg0, arg1);
        assertEquals(11, removeElements.length);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testRemoveElementsTaking2BooleanArraysReturningNull() throws Throwable  {
        boolean[] removeElements = ArrayUtils.removeElements((boolean[]) null, (boolean[]) null);
        assertNull(removeElements);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testRemoveElementsTaking2DoubleArrays0() throws Throwable  {
        double[] arg0 = new double[4];
        double[] arg1 = new double[7];
        double[] removeElements = ArrayUtils.removeElements(arg0, arg1);
        assertEquals(0, removeElements.length);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testRemoveElementsTaking2DoubleArrays1() throws Throwable  {
        double[] arg1 = new double[3];
        double[] removeElements = ArrayUtils.removeElements(arg1, arg1);
        assertEquals(0, removeElements.length);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testRemoveElementsTaking2DoubleArraysReturningNonEmptyArray() throws Throwable  {
        double[] arg0 = new double[1];
        double[] removeElements = ArrayUtils.removeElements(arg0, (double[]) null);
        assertNotNull(removeElements);
        assertEquals(1, removeElements.length);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testRemoveElementsTaking2DoubleArraysReturningNull() throws Throwable  {
        double[] removeElements = ArrayUtils.removeElements((double[]) null, (double[]) null);
        assertNull(removeElements);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testRemoveElementsTaking2FloatArraysWithNonEmptyArray() throws Throwable  {
        float[] arg0 = new float[9];
        arg0[2] = (float) (byte)96;
        arg0[6] = (float) (byte)96;
        arg0[7] = (float) (byte)96;
        float[] arg1 = new float[7];
        float[] removeElements = ArrayUtils.removeElements(arg0, arg1);
        assertArrayEquals(new float[] {96.0F, 96.0F, 96.0F}, removeElements, 0.01F);
        assertEquals(3, removeElements.length);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testCloneTakingFloatArrayReturningEmptyArray() throws Throwable  {
        float[] arg1 = new float[6];
        float[] arg0 = ArrayUtils.removeElements(arg1, arg1);
        float[] clone = ArrayUtils.clone(arg0);
        assertEquals(0, clone.length);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testRemoveElementsTaking2FloatArraysWithNull() throws Throwable  {
        float[] arg0 = new float[5];
        float[] removeElements = ArrayUtils.removeElements(arg0, (float[]) null);
        assertEquals(5, removeElements.length);
        assertNotNull(removeElements);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testRemoveElementsTaking2FloatArraysReturningNull() throws Throwable  {
        float[] removeElements = ArrayUtils.removeElements((float[]) null, (float[]) null);
        assertNull(removeElements);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testRemoveElementsTaking2LongArraysReturningNonEmptyArray() throws Throwable  {
        long[] arg0 = new long[11];
        long[] arg1 = new long[8];
        arg1[2] = 56L;
        long[] removeElements = ArrayUtils.removeElements(arg0, arg1);
        assertEquals(4, removeElements.length);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testRemoveElementsTaking2LongArraysReturningEmptyArray() throws Throwable  {
        long[] arg1 = new long[11];
        long[] removeElements = ArrayUtils.removeElements(arg1, arg1);
        assertEquals(0, removeElements.length);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testRemoveElementsTaking2LongArraysWithEmptyArray() throws Throwable  {
        long[] arg0 = new long[7];
        long[] arg1 = new long[0];
        long[] removeElements = ArrayUtils.removeElements(arg0, arg1);
        assertEquals(7, removeElements.length);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testRemoveElementsTaking2LongArraysReturningNull() throws Throwable  {
        long[] removeElements = ArrayUtils.removeElements((long[]) null, (long[]) null);
        assertNull(removeElements);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testRemoveElementsTaking2CharArrays0() throws Throwable  {
        char[] arg1 = new char[7];
        char[] arg0 = new char[1];
        char[] removeElements = ArrayUtils.removeElements(arg0, arg1);
        assertEquals(0, removeElements.length);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testRemoveElementsTaking2CharArraysReturningNonEmptyArray() throws Throwable  {
        char[] arg0 = new char[8];
        char[] arg1 = new char[0];
        char[] removeElements = ArrayUtils.removeElements(arg0, arg1);
        assertEquals(8, removeElements.length);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testRemoveElementsTaking2CharArraysReturningNull() throws Throwable  {
        char[] removeElements = ArrayUtils.removeElements((char[]) null, (char[]) null);
        assertNull(removeElements);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testRemoveElementsTaking2IntArraysWithNonEmptyArray() throws Throwable  {
        int[] arg0 = new int[5];
        arg0[0] = (-1459);
        arg0[1] = (-1);
        arg0[2] = (-1854);
        arg0[3] = (-1837);
        int[] arg1 = new int[2];
        int[] removeElements = ArrayUtils.removeElements(arg0, arg1);
        assertArrayEquals(new int[] {(-1459), (-1), (-1854), (-1837)}, removeElements);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testRemoveElementsTaking2IntArraysWithNull() throws Throwable  {
        int[] arg0 = new int[1];
        int[] removeElements = ArrayUtils.removeElements(arg0, (int[]) null);
        assertEquals(1, removeElements.length);
        assertNotNull(removeElements);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testRemoveElementsTaking2IntArraysReturningNull() throws Throwable  {
        int[] removeElements = ArrayUtils.removeElements((int[]) null, (int[]) null);
        assertNull(removeElements);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testRemoveElementsTaking2ShortArrays0() throws Throwable  {
        short[] arg0 = new short[5];
        short[] arg1 = new short[9];
        short[] removeElements = ArrayUtils.removeElements(arg0, arg1);
        assertEquals(0, removeElements.length);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testRemoveElementsTaking2ShortArrays1() throws Throwable  {
        short[] arg1 = new short[6];
        short[] removeElements = ArrayUtils.removeElements(arg1, arg1);
        assertEquals(0, removeElements.length);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testRemoveElementsTaking2ShortArraysReturningNull() throws Throwable  {
        short[] removeElements = ArrayUtils.removeElements((short[]) null, (short[]) null);
        assertNull(removeElements);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testRemoveElementsTaking2ByteArrays0() throws Throwable  {
        byte[] arg0 = new byte[8];
        byte[] arg1 = new byte[9];
        byte[] removeElements = ArrayUtils.removeElements(arg0, arg1);
        assertEquals(0, removeElements.length);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testRemoveElementsTaking2ByteArrays1() throws Throwable  {
        byte[] arg1 = new byte[8];
        byte[] removeElements = ArrayUtils.removeElements(arg1, arg1);
        assertEquals(0, removeElements.length);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testRemoveElementsTaking2ByteArraysReturningNull() throws Throwable  {
        byte[] removeElements = ArrayUtils.removeElements((byte[]) null, (byte[]) null);
        assertNull(removeElements);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testRemoveElementsTaking2ObjectArrays0() throws Throwable  {
        Byte[] arg0 = new Byte[5];
        Byte[] arg1 = new Byte[8];
        Byte[] removeElements = ArrayUtils.removeElements(arg0, arg1);
        assertEquals(0, removeElements.length);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testRemoveElementsTaking2ObjectArraysReturningNonEmptyArray() throws Throwable  {
        Byte[] arg0 = new Byte[4];
        Byte[] arg1 = new Byte[0];
        Byte[] removeElements = ArrayUtils.removeElements(arg0, arg1);
        assertEquals(4, removeElements.length);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testRemoveElementsTaking2ObjectArrays1() throws Throwable  {
        Byte[] arg1 = new Byte[4];
        Byte[] removeElements = ArrayUtils.removeElements(arg1, arg1);
        assertEquals(0, removeElements.length);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testRemoveElementsTaking2ObjectArraysReturningNull() throws Throwable  {
        Byte[] removeElements = ArrayUtils.removeElements((Byte[]) null, (Byte[]) null);
        assertNull(removeElements);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testRemoveElementTaking1And1ReturningNonEmptyArrayAndRemoveElementTaking1And11() throws Throwable  {
        short[] arg0 = new short[7];
        arg0[2] = (short)1035;
        short[] removeElement = ArrayUtils.removeElement(arg0, (short)1035);
        assertArrayEquals(new short[] {(short)0, (short)0, (short)0, (short)0, (short)0, (short)0}, removeElement);
        assertArrayEquals(new short[] {(short)0, (short)0, (short)1035, (short)0, (short)0, (short)0, (short)0}, arg0);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testRemoveElementTaking1And1ReturningNonEmptyArrayAndRemoveElementTaking1And12() throws Throwable  {
        long[] arg0 = new long[8];
        arg0[0] = (long) 'a';
        long[] removeElement = ArrayUtils.removeElement(arg0, 97L);
        assertArrayEquals(new long[] {0L, 0L, 0L, 0L, 0L, 0L, 0L}, removeElement);
        assertArrayEquals(new long[] {97L, 0L, 0L, 0L, 0L, 0L, 0L, 0L}, arg0);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testRemoveElementTaking1And1ReturningNullAndRemoveElementTaking1And1AndRemoveElementTaking1And13() throws Throwable  {
        int[] removeElement = ArrayUtils.removeElement((int[]) null, 23);
        assertNull(removeElement);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testRemoveElementTaking1And1ReturningNonEmptyArrayAndRemoveElementTaking1And13() throws Throwable  {
        int[] arg0 = new int[4];
        arg0[0] = (int) (byte)96;
        int[] removeElement = ArrayUtils.removeElement(arg0, (int) (byte)96);
        assertArrayEquals(new int[] {0, 0, 0}, removeElement);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testRemoveElementTaking1And1ReturningNonEmptyArrayAndRemoveElementTaking1And14() throws Throwable  {
        char[] arg0 = new char[3];
        arg0[0] = 'a';
        char[] removeElement = ArrayUtils.removeElement(arg0, 'a');
        assertArrayEquals(new char[] {'\u0000', '\u0000'}, removeElement);
        assertArrayEquals(new char[] {'a', '\u0000', '\u0000'}, arg0);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testRemoveElementTaking1And1ReturningNullAndRemoveElementTaking1And1AndRemoveElementTaking1And14() throws Throwable  {
        byte[] removeElement = ArrayUtils.removeElement((byte[]) null, (byte)54);
        assertNull(removeElement);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testRemoveElementTaking1And1ReturningNullAndRemoveElementTaking1And1AndRemoveElementTaking1And15() throws Throwable  {
        boolean[] removeElement = ArrayUtils.removeElement((boolean[]) null, true);
        assertNull(removeElement);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testRemoveElementTaking1And1ReturningEmptyArrayAndRemoveElementTaking1And13() throws Throwable  {
        boolean[] arg0 = new boolean[1];
        boolean[] removeElement = ArrayUtils.removeElement(arg0, false);
        assertEquals(0, removeElement.length);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testAddTaking11And1WithNonEmptyArrayAndNegative() throws Throwable  {
        byte arg1 = (byte) (-11);
        Byte arg2 = new Byte((byte) (-11));
        Byte[] arg0 = new Byte[1];
        // Undeclared exception!
        try { 
          ArrayUtils.add(arg0, (int) arg1, arg2);
          fail("Expecting exception: IndexOutOfBoundsException");
        
        } catch(IndexOutOfBoundsException e) {
           //
           // Index: -11, Length: 1
           //
           verifyException("org.apache.commons.lang3.ArrayUtils", e);
        }
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testAddTaking11And1WithNullAndPositive() throws Throwable  {
        Byte arg2 = new Byte((byte)2);
        // Undeclared exception!
        try { 
          ArrayUtils.add((Byte[]) null, Integer.MAX_VALUE, arg2);
          fail("Expecting exception: IndexOutOfBoundsException");
        
        } catch(IndexOutOfBoundsException e) {
           //
           // Index: 2147483647, Length: 0
           //
           verifyException("org.apache.commons.lang3.ArrayUtils", e);
        }
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testAddTaking11And1AndAddTaking11And1AndAddTaking11And1ReturningNonEmptyArray1() throws Throwable  {
        Byte[] arg0 = new Byte[2];
        Byte arg2 = new Byte((byte)19);
        Byte[] add = ArrayUtils.add(arg0, 1, arg2);
        assertEquals(3, add.length);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testAddTaking11And1ThrowsIllegalArgumentException() throws Throwable  {
        // Undeclared exception!
        try { 
          ArrayUtils.add((Byte[]) null, (-1241), (Byte) null);
          fail("Expecting exception: IllegalArgumentException");
        
        } catch(IllegalArgumentException e) {
           //
           // Array and element cannot both be null
           //
           verifyException("org.apache.commons.lang3.ArrayUtils", e);
        }
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testAddTaking1And1() throws Throwable  {
        Byte arg1 = new Byte((byte) (-47));
        Byte[] add = ArrayUtils.add((Byte[]) null, arg1);
        assertEquals(1, add.length);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testAddTaking1And1WithEmptyArray() throws Throwable  {
        Byte[] arg0 = new Byte[0];
        Byte[] add = ArrayUtils.add(arg0, (Byte) null);
        assertEquals(1, add.length);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testAddTaking1And1ThrowsIllegalArgumentException() throws Throwable  {
        // Undeclared exception!
        try { 
          ArrayUtils.add((Byte[]) null, (Byte) null);
          fail("Expecting exception: IllegalArgumentException");
        
        } catch(IllegalArgumentException e) {
           //
           // Arguments cannot both be null
           //
           verifyException("org.apache.commons.lang3.ArrayUtils", e);
        }
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testAddAllTaking2DoubleArraysReturningNonEmptyArray() throws Throwable  {
        double[] arg0 = new double[2];
        double[] addAll = ArrayUtils.addAll(arg0, (double[]) null);
        assertNotNull(addAll);
        assertEquals(2, addAll.length);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testAddAllTaking2DoubleArraysReturningNull() throws Throwable  {
        double[] addAll = ArrayUtils.addAll((double[]) null, (double[]) null);
        assertNull(addAll);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testAddAllTaking2FloatArraysReturningNonEmptyArray() throws Throwable  {
        float[] arg0 = new float[5];
        float[] addAll = ArrayUtils.addAll(arg0, (float[]) null);
        assertNotNull(addAll);
        assertEquals(5, addAll.length);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testAddAllTaking2FloatArraysReturningEmptyArray() throws Throwable  {
        float[] arg1 = new float[0];
        float[] addAll = ArrayUtils.addAll(arg1, arg1);
        assertNotSame(addAll, arg1);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testAddAllTaking2LongArraysReturningNonEmptyArray() throws Throwable  {
        long[] arg0 = new long[3];
        long[] addAll = ArrayUtils.addAll(arg0, (long[]) null);
        assertEquals(3, addAll.length);
        assertNotNull(addAll);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testAddAllTaking2LongArraysReturningEmptyArray() throws Throwable  {
        long[] arg1 = new long[0];
        long[] addAll = ArrayUtils.addAll(arg1, arg1);
        assertNotSame(addAll, arg1);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testAddAllTaking2IntArraysReturningNonEmptyArray() throws Throwable  {
        int[] arg0 = new int[1];
        int[] addAll = ArrayUtils.addAll(arg0, (int[]) null);
        assertNotNull(addAll);
        assertEquals(1, addAll.length);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testAddAllTaking2IntArraysReturningNull() throws Throwable  {
        int[] addAll = ArrayUtils.addAll((int[]) null, (int[]) null);
        assertNull(addAll);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testAddAllTaking2IntArraysReturningEmptyArray() throws Throwable  {
        int[] arg1 = new int[0];
        int[] addAll = ArrayUtils.addAll(arg1, arg1);
        assertNotSame(addAll, arg1);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testAddAllTaking2ShortArraysWithNonEmptyArray() throws Throwable  {
        short[] arg1 = new short[1];
        short[] addAll = ArrayUtils.addAll(arg1, arg1);
        assertEquals(2, addAll.length);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testAddAllTaking2ShortArraysReturningNull() throws Throwable  {
        short[] addAll = ArrayUtils.addAll((short[]) null, (short[]) null);
        assertNull(addAll);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testAddAllTaking2ShortArrays() throws Throwable  {
        short[] arg0 = new short[1];
        short[] addAll = ArrayUtils.addAll(arg0, (short[]) null);
        assertEquals(1, addAll.length);
        assertNotNull(addAll);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testAddAllTaking2ByteArraysReturningEmptyArray() throws Throwable  {
        byte[] arg0 = ArrayUtils.nullToEmpty((byte[]) null);
        byte[] addAll = ArrayUtils.addAll(arg0, (byte[]) null);
        assertEquals(0, addAll.length);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testAddAllTaking2ByteArraysReturningNonEmptyArray() throws Throwable  {
        byte[] arg1 = new byte[1];
        byte[] addAll = ArrayUtils.addAll(arg1, arg1);
        assertEquals(2, addAll.length);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testAddAllTaking2CharArraysReturningNonEmptyArray() throws Throwable  {
        char[] arg0 = new char[1];
        char[] addAll = ArrayUtils.addAll(arg0, (char[]) null);
        assertEquals(1, addAll.length);
        assertNotNull(addAll);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testAddAllTaking2CharArraysReturningNull() throws Throwable  {
        char[] addAll = ArrayUtils.addAll((char[]) null, (char[]) null);
        assertNull(addAll);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testAddAllTaking2CharArraysReturningEmptyArray() throws Throwable  {
        char[] arg1 = new char[0];
        char[] addAll = ArrayUtils.addAll(arg1, arg1);
        assertNotSame(addAll, arg1);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testAddAllTaking2BooleanArraysReturningNonEmptyArray() throws Throwable  {
        boolean[] arg0 = new boolean[3];
        boolean[] addAll = ArrayUtils.addAll(arg0, (boolean[]) null);
        assertEquals(3, addAll.length);
        assertNotNull(addAll);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testAddAllTaking2BooleanArraysReturningEmptyArray() throws Throwable  {
        boolean[] arg1 = new boolean[0];
        boolean[] addAll = ArrayUtils.addAll(arg1, arg1);
        assertNotSame(addAll, arg1);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testAddAllTaking2ObjectArraysReturningNonEmptyArray() throws Throwable  {
        Byte[] arg0 = new Byte[1];
        Byte[] addAll = ArrayUtils.addAll(arg0, (Byte[]) null);
        assertNotSame(arg0, addAll);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testAddAllTaking2ObjectArraysReturningEmptyArray() throws Throwable  {
        Byte[] arg1 = new Byte[0];
        Byte[] addAll = ArrayUtils.addAll(arg1, arg1);
        assertNotSame(addAll, arg1);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testIsNotEmptyTakingBooleanArrayReturningTrue() throws Throwable  {
        boolean[] arg0 = new boolean[1];
        boolean notEmpty = ArrayUtils.isNotEmpty(arg0);
        assertTrue(notEmpty);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testIsNotEmptyTakingBooleanArrayWithEmptyArray() throws Throwable  {
        boolean[] arg0 = new boolean[0];
        boolean notEmpty = ArrayUtils.isNotEmpty(arg0);
        assertFalse(notEmpty);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testIsNotEmptyTakingBooleanArrayWithNull() throws Throwable  {
        boolean notEmpty = ArrayUtils.isNotEmpty((boolean[]) null);
        assertFalse(notEmpty);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testIsNotEmptyTakingFloatArrayReturningTrue() throws Throwable  {
        float[] arg0 = new float[1];
        boolean notEmpty = ArrayUtils.isNotEmpty(arg0);
        assertTrue(notEmpty);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testIsNotEmptyTakingFloatArrayReturningFalse() throws Throwable  {
        boolean notEmpty = ArrayUtils.isNotEmpty((float[]) null);
        assertFalse(notEmpty);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testIsNotEmptyTakingDoubleArrayReturningTrue() throws Throwable  {
        double[] arg0 = new double[4];
        boolean notEmpty = ArrayUtils.isNotEmpty(arg0);
        assertTrue(notEmpty);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testIsNotEmptyTakingDoubleArrayWithEmptyArray() throws Throwable  {
        double[] arg0 = new double[0];
        boolean notEmpty = ArrayUtils.isNotEmpty(arg0);
        assertFalse(notEmpty);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testIsNotEmptyTakingDoubleArrayWithNull() throws Throwable  {
        boolean notEmpty = ArrayUtils.isNotEmpty((double[]) null);
        assertFalse(notEmpty);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testIsNotEmptyTakingByteArrayReturningTrue() throws Throwable  {
        byte[] arg0 = new byte[1];
        boolean notEmpty = ArrayUtils.isNotEmpty(arg0);
        assertTrue(notEmpty);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testIsNotEmptyTakingByteArrayWithEmptyArray() throws Throwable  {
        byte[] arg0 = new byte[0];
        boolean notEmpty = ArrayUtils.isNotEmpty(arg0);
        assertFalse(notEmpty);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testIsNotEmptyTakingByteArrayWithNull() throws Throwable  {
        boolean notEmpty = ArrayUtils.isNotEmpty((byte[]) null);
        assertFalse(notEmpty);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testIsNotEmptyTakingCharArrayReturningTrue() throws Throwable  {
        char[] arg0 = new char[3];
        boolean notEmpty = ArrayUtils.isNotEmpty(arg0);
        assertTrue(notEmpty);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testIsNotEmptyTakingCharArrayWithEmptyArray() throws Throwable  {
        char[] arg0 = new char[0];
        boolean notEmpty = ArrayUtils.isNotEmpty(arg0);
        assertFalse(notEmpty);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testIsNotEmptyTakingCharArrayWithNull() throws Throwable  {
        boolean notEmpty = ArrayUtils.isNotEmpty((char[]) null);
        assertFalse(notEmpty);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testIsNotEmptyTakingShortArrayReturningTrue() throws Throwable  {
        short[] arg0 = new short[3];
        boolean notEmpty = ArrayUtils.isNotEmpty(arg0);
        assertTrue(notEmpty);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testIsNotEmptyTakingShortArrayWithEmptyArray() throws Throwable  {
        short[] arg0 = new short[0];
        boolean notEmpty = ArrayUtils.isNotEmpty(arg0);
        assertFalse(notEmpty);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testIsNotEmptyTakingShortArrayWithNull() throws Throwable  {
        boolean notEmpty = ArrayUtils.isNotEmpty((short[]) null);
        assertFalse(notEmpty);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testIsNotEmptyTakingLongArrayWithEmptyArray() throws Throwable  {
        long[] arg1 = new long[1];
        long[] arg0 = ArrayUtils.removeElements(arg1, arg1);
        boolean notEmpty = ArrayUtils.isNotEmpty(arg0);
        assertFalse(notEmpty);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testIsNotEmptyTakingLongArrayReturningTrue() throws Throwable  {
        long[] arg0 = new long[2];
        boolean notEmpty = ArrayUtils.isNotEmpty(arg0);
        assertTrue(notEmpty);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testIsNotEmptyTakingLongArrayWithNull() throws Throwable  {
        boolean notEmpty = ArrayUtils.isNotEmpty((long[]) null);
        assertFalse(notEmpty);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testIsNotEmptyTakingObjectArrayReturningTrue() throws Throwable  {
        Byte[] arg0 = new Byte[8];
        boolean notEmpty = ArrayUtils.isNotEmpty(arg0);
        assertTrue(notEmpty);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testIsNotEmptyTakingObjectArrayWithEmptyArray() throws Throwable  {
        Byte[] arg0 = new Byte[0];
        boolean notEmpty = ArrayUtils.isNotEmpty(arg0);
        assertFalse(notEmpty);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testIsNotEmptyTakingObjectArrayWithNull() throws Throwable  {
        boolean notEmpty = ArrayUtils.isNotEmpty((Byte[]) null);
        assertFalse(notEmpty);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testIndexOfTaking11And1WithNullAndIndexOfTaking11And1AndIndexOfTaking11And16() throws Throwable  {
        int indexOf = ArrayUtils.indexOf((float[]) null, (-2478.2769F), 1);
        assertEquals((-1), indexOf);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testIsEmptyTakingByteArrayWithEmptyArray() throws Throwable  {
        byte[] arg0 = ArrayUtils.nullToEmpty((byte[]) null);
        boolean empty = ArrayUtils.isEmpty(arg0);
        assertTrue(empty);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testRemoveElementsTaking2ByteArraysReturningNonEmptyArray() throws Throwable  {
        byte[] arg0 = new byte[1];
        byte[] removeElements = ArrayUtils.removeElements(arg0, (byte[]) null);
        assertNotNull(removeElements);
        assertEquals(1, removeElements.length);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testIsEmptyTakingByteArrayWithNull() throws Throwable  {
        boolean empty = ArrayUtils.isEmpty((byte[]) null);
        assertTrue(empty);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testIsEmptyTakingCharArrayWithEmptyArray() throws Throwable  {
        char[] arg0 = new char[0];
        boolean empty = ArrayUtils.isEmpty(arg0);
        assertTrue(empty);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testIsEmptyTakingCharArrayWithNull() throws Throwable  {
        boolean empty = ArrayUtils.isEmpty((char[]) null);
        assertTrue(empty);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testRemoveElementsTaking2ShortArraysReturningNonEmptyArray() throws Throwable  {
        short[] arg0 = new short[4];
        short[] removeElements = ArrayUtils.removeElements(arg0, (short[]) null);
        assertEquals(4, removeElements.length);
        assertNotNull(removeElements);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testIsEmptyTakingShortArrayWithEmptyArray() throws Throwable  {
        short[] arg0 = new short[0];
        boolean empty = ArrayUtils.isEmpty(arg0);
        assertTrue(empty);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testIsEmptyTakingShortArrayWithNull() throws Throwable  {
        boolean empty = ArrayUtils.isEmpty((short[]) null);
        assertTrue(empty);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testIsEmptyTakingIntArrayWithEmptyArray() throws Throwable  {
        int[] arg0 = new int[0];
        boolean empty = ArrayUtils.isEmpty(arg0);
        assertTrue(empty);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testIsEmptyTakingIntArrayWithNull() throws Throwable  {
        boolean empty = ArrayUtils.isEmpty((int[]) null);
        assertTrue(empty);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testIsEmptyTakingLongArrayReturningFalse() throws Throwable  {
        long[] arg0 = new long[1];
        boolean empty = ArrayUtils.isEmpty(arg0);
        assertFalse(empty);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testIsEmptyTakingLongArrayWithEmptyArray() throws Throwable  {
        long[] arg0 = new long[0];
        boolean empty = ArrayUtils.isEmpty(arg0);
        assertTrue(empty);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testIsEmptyTakingLongArrayWithNull() throws Throwable  {
        boolean empty = ArrayUtils.isEmpty((long[]) null);
        assertTrue(empty);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testIsEmptyTakingObjectArrayReturningFalse() throws Throwable  {
        Long[] arg0 = new Long[6];
        boolean empty = ArrayUtils.isEmpty((Object[]) arg0);
        assertFalse(empty);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testIsEmptyTakingObjectArrayWithEmptyArray() throws Throwable  {
        Float[] arg0 = new Float[0];
        boolean empty = ArrayUtils.isEmpty((Object[]) arg0);
        assertTrue(empty);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testIsEmptyTakingObjectArrayWithNull() throws Throwable  {
        boolean empty = ArrayUtils.isEmpty((Object[]) null);
        assertTrue(empty);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testToObjectTakingBooleanArrayReturningNonEmptyArray() throws Throwable  {
        boolean[] arg0 = new boolean[4];
        arg0[0] = true;
        Boolean[] object = ArrayUtils.toObject(arg0);
        assertEquals(4, object.length);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testToObjectTakingBooleanArrayReturningNull() throws Throwable  {
        Boolean[] object = ArrayUtils.toObject((boolean[]) null);
        assertNull(object);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testToObjectTakingBooleanArrayReturningEmptyArray() throws Throwable  {
        boolean[] arg0 = new boolean[0];
        Boolean[] object = ArrayUtils.toObject(arg0);
        assertEquals(0, object.length);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testToPrimitiveTaking1And1WithTrue() throws Throwable  {
        Boolean[] arg0 = new Boolean[1];
        Boolean valueOf = Boolean.valueOf("");
        arg0[0] = valueOf;
        boolean[] primitive = ArrayUtils.toPrimitive(arg0, true);
        assertEquals(1, primitive.length);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testToPrimitiveTaking1And1WithFalse() throws Throwable  {
        Boolean[] arg0 = new Boolean[3];
        boolean[] primitive = ArrayUtils.toPrimitive(arg0, false);
        assertTrue(Arrays.equals(new boolean[] {false, false, false}, primitive));
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testToPrimitiveTaking1And1ReturningNullAndToPrimitiveTaking1And1AndToPrimitiveTaking1And10() throws Throwable  {
        boolean[] primitive = ArrayUtils.toPrimitive((Boolean[]) null, false);
        assertNull(primitive);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testToPrimitiveTaking1And1ReturningEmptyArrayAndToPrimitiveTaking1And10() throws Throwable  {
        Boolean[] arg0 = new Boolean[0];
        boolean[] primitive = ArrayUtils.toPrimitive(arg0, true);
        assertTrue(Arrays.equals(new boolean[] {}, primitive));
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testToPrimitiveTakingBooleanArrayReturningNull() throws Throwable  {
        boolean[] primitive = ArrayUtils.toPrimitive((Boolean[]) null);
        assertNull(primitive);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testToPrimitiveTakingBooleanArrayReturningEmptyArray() throws Throwable  {
        Boolean[] arg0 = new Boolean[0];
        boolean[] primitive = ArrayUtils.toPrimitive(arg0);
        assertTrue(Arrays.equals(new boolean[] {}, primitive));
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testToObjectTakingFloatArrayReturningNonEmptyArray() throws Throwable  {
        float[] arg0 = new float[2];
        Float[] object = ArrayUtils.toObject(arg0);
        assertEquals(2, object.length);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testToObjectTakingFloatArrayReturningNull() throws Throwable  {
        Float[] object = ArrayUtils.toObject((float[]) null);
        assertNull(object);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testToObjectTakingFloatArrayReturningEmptyArray() throws Throwable  {
        float[] arg0 = new float[0];
        Float[] object = ArrayUtils.toObject(arg0);
        assertEquals(0, object.length);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testToPrimitiveTaking1And1ReturningNullAndToPrimitiveTaking1And1AndToPrimitiveTaking1And11() throws Throwable  {
        float[] primitive = ArrayUtils.toPrimitive((Float[]) null, (float) (short) (-160));
        assertNull(primitive);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testToPrimitiveTaking1And1ReturningEmptyArrayAndToPrimitiveTaking1And11() throws Throwable  {
        Float[] arg0 = new Float[0];
        float[] primitive = ArrayUtils.toPrimitive(arg0, 1.6F);
        assertEquals(0, primitive.length);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testToPrimitiveTakingFloatArray() throws Throwable  {
        float[] primitive = ArrayUtils.toPrimitive((Float[]) null);
        assertNull(primitive);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testToObjectTakingDoubleArrayReturningNull() throws Throwable  {
        Double[] object = ArrayUtils.toObject((double[]) null);
        assertNull(object);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testToPrimitiveTaking1And1ReturningNonEmptyArrayAndToPrimitiveTaking1And10() throws Throwable  {
        Double[] arg0 = new Double[1];
        double[] primitive = ArrayUtils.toPrimitive(arg0, 832.65228);
        assertArrayEquals(new double[] {832.65228}, primitive, 0.01);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testToPrimitiveTaking1And1ReturningNullAndToPrimitiveTaking1And1AndToPrimitiveTaking1And12() throws Throwable  {
        double[] primitive = ArrayUtils.toPrimitive((Double[]) null, (double) (byte) (-11));
        assertNull(primitive);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testToPrimitiveTaking1And1ReturningEmptyArrayAndToPrimitiveTaking1And12() throws Throwable  {
        Double[] arg0 = new Double[0];
        double[] primitive = ArrayUtils.toPrimitive(arg0, 504.1892182465972);
        assertEquals(0, primitive.length);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testToPrimitiveTakingDoubleArrayReturningNull() throws Throwable  {
        double[] primitive = ArrayUtils.toPrimitive((Double[]) null);
        assertNull(primitive);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testToPrimitiveTakingDoubleArrayReturningEmptyArray() throws Throwable  {
        Double[] arg0 = new Double[0];
        double[] primitive = ArrayUtils.toPrimitive(arg0);
        assertArrayEquals(new double[] {}, primitive, 0.01);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testToObjectTakingByteArrayReturningEmptyArray() throws Throwable  {
        byte[] arg0 = new byte[0];
        Byte[] object = ArrayUtils.toObject(arg0);
        assertEquals(0, object.length);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testToObjectTakingByteArrayReturningNull() throws Throwable  {
        Byte[] object = ArrayUtils.toObject((byte[]) null);
        assertNull(object);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testToPrimitiveTaking1And1ReturningNonEmptyArrayAndToPrimitiveTaking1And11() throws Throwable  {
        Byte[] arg0 = new Byte[1];
        byte arg1 = (byte) (-63);
        byte[] primitive = ArrayUtils.toPrimitive(arg0, arg1);
        assertArrayEquals(new byte[] {(byte) (-63)}, primitive);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testToPrimitiveTaking1And1ReturningNullAndToPrimitiveTaking1And1AndToPrimitiveTaking1And13() throws Throwable  {
        byte[] primitive = ArrayUtils.toPrimitive((Byte[]) null, (byte) (-115));
        assertNull(primitive);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testToPrimitiveTaking1And1ReturningEmptyArrayAndToPrimitiveTaking1And13() throws Throwable  {
        Byte[] arg0 = new Byte[0];
        byte[] primitive = ArrayUtils.toPrimitive(arg0, (byte) (-1));
        assertArrayEquals(new byte[] {}, primitive);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testToPrimitiveTakingByteArrayReturningNull() throws Throwable  {
        byte[] primitive = ArrayUtils.toPrimitive((Byte[]) null);
        assertNull(primitive);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testToPrimitiveTakingByteArrayReturningEmptyArray() throws Throwable  {
        Byte[] arg0 = new Byte[0];
        byte[] primitive = ArrayUtils.toPrimitive(arg0);
        assertArrayEquals(new byte[] {}, primitive);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testToObjectTakingShortArrayReturningNonEmptyArray() throws Throwable  {
        short[] arg0 = new short[6];
        Short[] object = ArrayUtils.toObject(arg0);
        assertEquals(6, object.length);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testToObjectTakingShortArrayReturningNull() throws Throwable  {
        Short[] object = ArrayUtils.toObject((short[]) null);
        assertNull(object);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testToObjectTakingShortArrayReturningEmptyArray() throws Throwable  {
        short[] arg0 = new short[0];
        Short[] object = ArrayUtils.toObject(arg0);
        assertEquals(0, object.length);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testToPrimitiveTaking1And1ReturningNullAndToPrimitiveTaking1And1AndToPrimitiveTaking1And14() throws Throwable  {
        short[] primitive = ArrayUtils.toPrimitive((Short[]) null, (short) (byte) (-71));
        assertNull(primitive);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testToPrimitiveTaking1And1ReturningEmptyArrayAndToPrimitiveTaking1And14() throws Throwable  {
        Short[] arg0 = new Short[0];
        short[] primitive = ArrayUtils.toPrimitive(arg0, (short)1278);
        assertEquals(0, primitive.length);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testToPrimitiveTakingShortArrayReturningNull() throws Throwable  {
        short[] primitive = ArrayUtils.toPrimitive((Short[]) null);
        assertNull(primitive);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testToPrimitiveTakingShortArrayReturningEmptyArray() throws Throwable  {
        Short[] arg0 = new Short[0];
        short[] primitive = ArrayUtils.toPrimitive(arg0);
        assertEquals(0, primitive.length);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testToObjectTakingIntArrayReturningNonEmptyArray() throws Throwable  {
        int[] arg0 = new int[4];
        Integer[] object = ArrayUtils.toObject(arg0);
        assertEquals(4, object.length);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testToObjectTakingIntArrayReturningNull() throws Throwable  {
        Integer[] object = ArrayUtils.toObject((int[]) null);
        assertNull(object);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testToObjectTakingIntArrayReturningEmptyArray() throws Throwable  {
        int[] arg0 = new int[0];
        Integer[] object = ArrayUtils.toObject(arg0);
        assertEquals(0, object.length);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testToPrimitiveTaking1And1ReturningNonEmptyArrayAndToPrimitiveTaking1And12() throws Throwable  {
        Integer integer = new Integer(2814);
        Integer[] arg0 = new Integer[6];
        arg0[0] = integer;
        int[] primitive = ArrayUtils.toPrimitive(arg0, 1);
        assertArrayEquals(new int[] {2814, 1, 1, 1, 1, 1}, primitive);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testToPrimitiveTaking1And1ReturningNullAndToPrimitiveTaking1And1AndToPrimitiveTaking1And15() throws Throwable  {
        int[] primitive = ArrayUtils.toPrimitive((Integer[]) null, 4);
        assertNull(primitive);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testToPrimitiveTaking1And1ReturningEmptyArrayAndToPrimitiveTaking1And15() throws Throwable  {
        Integer[] arg0 = new Integer[0];
        int[] primitive = ArrayUtils.toPrimitive(arg0, (-100));
        assertArrayEquals(new int[] {}, primitive);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testToPrimitiveTakingIntegerArrayReturningNonEmptyArray() throws Throwable  {
        Integer[] arg0 = new Integer[4];
        arg0[0] = (Integer) 0;
        arg0[1] = (Integer) (-21831);
        arg0[2] = (Integer) (-21831);
        arg0[3] = (Integer) (-21831);
        int[] primitive = ArrayUtils.toPrimitive(arg0);
        assertArrayEquals(new int[] {0, (-21831), (-21831), (-21831)}, primitive);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testToPrimitiveTakingIntegerArrayReturningNull() throws Throwable  {
        int[] primitive = ArrayUtils.toPrimitive((Integer[]) null);
        assertNull(primitive);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testToPrimitiveTakingIntegerArrayReturningEmptyArray() throws Throwable  {
        Integer[] arg0 = new Integer[0];
        int[] primitive = ArrayUtils.toPrimitive(arg0);
        assertArrayEquals(new int[] {}, primitive);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testToObjectTakingLongArrayReturningNonEmptyArray() throws Throwable  {
        long[] arg0 = new long[1];
        Long[] object = ArrayUtils.toObject(arg0);
        assertEquals(1, object.length);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testToObjectTakingLongArrayReturningNull() throws Throwable  {
        Long[] object = ArrayUtils.toObject((long[]) null);
        assertNull(object);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testToObjectTakingLongArrayReturningEmptyArray() throws Throwable  {
        long[] arg0 = new long[0];
        Long[] object = ArrayUtils.toObject(arg0);
        assertEquals(0, object.length);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testToPrimitiveTaking1And1ReturningNullAndToPrimitiveTaking1And1AndToPrimitiveTaking1And16() throws Throwable  {
        long[] primitive = ArrayUtils.toPrimitive((Long[]) null, (-1L));
        assertNull(primitive);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testToPrimitiveTaking1And1ReturningEmptyArrayAndToPrimitiveTaking1And16() throws Throwable  {
        Long[] arg0 = new Long[0];
        long[] primitive = ArrayUtils.toPrimitive(arg0, (long) (byte) (-47));
        assertArrayEquals(new long[] {}, primitive);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testToPrimitiveTakingLongArrayReturningNull() throws Throwable  {
        long[] primitive = ArrayUtils.toPrimitive((Long[]) null);
        assertNull(primitive);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testToPrimitiveTakingLongArrayReturningEmptyArray() throws Throwable  {
        Long[] arg0 = new Long[0];
        long[] primitive = ArrayUtils.toPrimitive(arg0);
        assertArrayEquals(new long[] {}, primitive);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testToObjectTakingCharArrayReturningNonEmptyArray() throws Throwable  {
        char[] arg0 = new char[3];
        Character[] object = ArrayUtils.toObject(arg0);
        assertEquals(3, object.length);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testToObjectTakingCharArrayReturningNull() throws Throwable  {
        Character[] object = ArrayUtils.toObject((char[]) null);
        assertNull(object);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testToObjectTakingCharArrayReturningEmptyArray() throws Throwable  {
        char[] arg0 = new char[0];
        Character[] object = ArrayUtils.toObject(arg0);
        assertEquals(0, object.length);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testToPrimitiveTaking1And1ReturningNonEmptyArrayAndToPrimitiveTaking1And13() throws Throwable  {
        Character valueOf = Character.valueOf('W');
        Character[] arg0 = new Character[5];
        arg0[1] = valueOf;
        char[] primitive = ArrayUtils.toPrimitive(arg0, '=');
        assertArrayEquals(new char[] {'=', 'W', '=', '=', '='}, primitive);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testToPrimitiveTaking1And1ReturningNullAndToPrimitiveTaking1And1AndToPrimitiveTaking1And17() throws Throwable  {
        char[] primitive = ArrayUtils.toPrimitive((Character[]) null, 'a');
        assertNull(primitive);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testToPrimitiveTaking1And1ReturningEmptyArrayAndToPrimitiveTaking1And17() throws Throwable  {
        Character[] arg0 = new Character[0];
        char[] primitive = ArrayUtils.toPrimitive(arg0, '6');
        assertEquals(0, primitive.length);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testToPrimitiveTakingCharacterArrayReturningNonEmptyArray() throws Throwable  {
        Character[] arg0 = new Character[2];
        Character character = new Character('j');
        arg0[0] = character;
        arg0[1] = character;
        char[] primitive = ArrayUtils.toPrimitive(arg0);
        assertArrayEquals(new char[] {'j', 'j'}, primitive);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testToPrimitiveTakingCharacterArrayReturningNull() throws Throwable  {
        char[] primitive = ArrayUtils.toPrimitive((Character[]) null);
        assertNull(primitive);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testToPrimitiveTakingCharacterArrayReturningEmptyArray() throws Throwable  {
        Character[] arg0 = new Character[0];
        char[] primitive = ArrayUtils.toPrimitive(arg0);
        assertArrayEquals(new char[] {}, primitive);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testContainsTaking1And1ReturningTrueAndContainsTaking1And1AndContainsTaking1And10() throws Throwable  {
        boolean[] arg0 = new boolean[10];
        boolean contains = ArrayUtils.contains(arg0, false);
        assertTrue(contains);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testLastIndexOfTaking11And1ReturningPositiveAndLastIndexOfTaking11And15() throws Throwable  {
        boolean[] arg0 = new boolean[2];
        int lastIndexOf = ArrayUtils.lastIndexOf(arg0, false, 2);
        assertEquals(1, lastIndexOf);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testLastIndexOfTaking11And1AndLastIndexOfTaking11And1AndLastIndexOfTaking11And1ReturningNegative2() throws Throwable  {
        boolean[] arg0 = new boolean[4];
        int lastIndexOf = ArrayUtils.lastIndexOf(arg0, true, (int) (byte)0);
        assertEquals((-1), lastIndexOf);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testLastIndexOfTaking11And1WithNegativeAndLastIndexOfTaking11And1AndLastIndexOfTaking11And11() throws Throwable  {
        boolean[] arg0 = new boolean[6];
        int lastIndexOf = ArrayUtils.lastIndexOf(arg0, true, (-1802));
        assertEquals((-1), lastIndexOf);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testLastIndexOfTaking11And1WithNullAndLastIndexOfTaking11And1AndLastIndexOfTaking11And11() throws Throwable  {
        int lastIndexOf = ArrayUtils.lastIndexOf((boolean[]) null, true, 0);
        assertEquals((-1), lastIndexOf);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testIndexOfTaking11And1AndIndexOfTaking11And1AndIndexOfTaking11And1ReturningNegative3() throws Throwable  {
        boolean[] arg0 = new boolean[5];
        int indexOf = ArrayUtils.indexOf(arg0, true, (-148));
        assertEquals((-1), indexOf);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testContainsTaking1And1ReturningTrueAndContainsTaking1And1AndContainsTaking1And11() throws Throwable  {
        float[] arg0 = new float[6];
        boolean contains = ArrayUtils.contains(arg0, 0.0F);
        assertTrue(contains);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testContainsTaking1And1ReturningFalseAndContainsTaking1And1AndContainsTaking1And10() throws Throwable  {
        float[] arg0 = new float[1];
        boolean contains = ArrayUtils.contains(arg0, 242.0F);
        assertFalse(contains);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testLastIndexOfTaking11And1ReturningZeroAndLastIndexOfTaking11And1AndLastIndexOfTaking11And14() throws Throwable  {
        float[] arg0 = new float[5];
        int lastIndexOf = ArrayUtils.lastIndexOf(arg0, 0.0F, 0);
        assertEquals(0, lastIndexOf);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testLastIndexOfTaking11And1WithPositiveAndLastIndexOfTaking11And1AndLastIndexOfTaking11And10() throws Throwable  {
        float[] arg0 = new float[9];
        int lastIndexOf = ArrayUtils.lastIndexOf(arg0, 1.1F, (-621));
        assertEquals((-1), lastIndexOf);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testLastIndexOfTaking11And1WithEmptyArrayAndLastIndexOfTaking11And1AndLastIndexOfTaking11And10() throws Throwable  {
        float[] arg0 = new float[0];
        int lastIndexOf = ArrayUtils.lastIndexOf(arg0, (-254.6F), (-3264));
        assertEquals((-1), lastIndexOf);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testContainsTaking3ArgumentsReturningTrue() throws Throwable  {
        double[] arg0 = new double[4];
        boolean contains = ArrayUtils.contains(arg0, 0.0, 0.0);
        assertTrue(contains);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testContainsTaking1And1ReturningTrueAndContainsTaking1And1AndContainsTaking1And12() throws Throwable  {
        double[] arg0 = new double[4];
        boolean contains = ArrayUtils.contains(arg0, 0.0);
        assertTrue(contains);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testContainsTaking1And1ReturningFalseAndContainsTaking1And1AndContainsTaking1And11() throws Throwable  {
        double[] arg0 = new double[1];
        arg0[0] = 1526.01887545;
        boolean contains = ArrayUtils.contains(arg0, 0.0);
        assertFalse(contains);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testLastIndexOfTaking4ArgumentsWithNegativeAndPositive() throws Throwable  {
        double[] arg0 = new double[1];
        int lastIndexOf = ArrayUtils.lastIndexOf(arg0, (double) (-3463), 327, 1.0);
        assertEquals((-1), lastIndexOf);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testLastIndexOfTaking4ArgumentsWithPositiveAndNegative() throws Throwable  {
        double[] arg0 = new double[3];
        int lastIndexOf = ArrayUtils.lastIndexOf(arg0, 1414.2465637973926, 2, (-1498.5270949));
        assertEquals((-1), lastIndexOf);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testLastIndexOfTaking4ArgumentsWithNegative() throws Throwable  {
        double[] arg0 = new double[3];
        int lastIndexOf = ArrayUtils.lastIndexOf(arg0, (-1727.707495), (-2537), (-1.0));
        assertEquals((-1), lastIndexOf);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testLastIndexOfTaking11And1WithNegativeAndNegative() throws Throwable  {
        double[] arg0 = new double[4];
        int lastIndexOf = ArrayUtils.lastIndexOf(arg0, (double) (short) (-996), (int) (short) (-996));
        assertEquals((-1), lastIndexOf);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testLastIndexOfTaking11And1WithNullAndPositive() throws Throwable  {
        int lastIndexOf = ArrayUtils.lastIndexOf((double[]) null, (double) 1936L, 1936);
        assertEquals((-1), lastIndexOf);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testContainsTaking3ArgumentsReturningFalse() throws Throwable  {
        double[] arg0 = new double[4];
        arg0[0] = (-1997.9437052250325);
        boolean contains = ArrayUtils.contains(arg0, (-1997.9437052250325), (-1997.9437052250325));
        assertFalse(contains);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testIndexOfTaking4ArgumentsReturningZero() throws Throwable  {
        double[] arg0 = new double[1];
        int indexOf = ArrayUtils.indexOf(arg0, 0.0, (int) (byte) (-1), 1.5);
        assertEquals(0, indexOf);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testIndexOfTaking4ArgumentsWithNegative() throws Throwable  {
        int indexOf = ArrayUtils.indexOf((double[]) null, 612.3807923, (int) (short)0, (-1398.804977));
        assertEquals((-1), indexOf);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testContainsTaking1And1ReturningTrueAndContainsTaking1And1AndContainsTaking1And13() throws Throwable  {
        byte[] arg0 = new byte[8];
        arg0[4] = (byte)69;
        boolean contains = ArrayUtils.contains(arg0, (byte)69);
        assertTrue(contains);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testLastIndexOfTaking1And1ReturningZeroAndLastIndexOfTaking1And1AndLastIndexOfTaking1And18() throws Throwable  {
        byte[] arg0 = new byte[3];
        arg0[0] = (byte) (-69);
        int lastIndexOf = ArrayUtils.lastIndexOf(arg0, (byte) (-69));
        assertEquals(0, lastIndexOf);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testLastIndexOfTaking1And1ReturningNegativeAndLastIndexOfTaking1And1AndLastIndexOfTaking1And11() throws Throwable  {
        byte[] arg0 = new byte[3];
        int lastIndexOf = ArrayUtils.lastIndexOf(arg0, (byte) (-69));
        assertEquals((-1), lastIndexOf);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testLastIndexOfTaking11And1WithPositiveAndLastIndexOfTaking11And1AndLastIndexOfTaking11And11() throws Throwable  {
        byte[] arg0 = new byte[9];
        int lastIndexOf = ArrayUtils.lastIndexOf(arg0, (byte)1, (int) (byte)7);
        assertEquals((-1), lastIndexOf);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testLastIndexOfTaking11And1WithEmptyArrayAndLastIndexOfTaking11And1AndLastIndexOfTaking11And11() throws Throwable  {
        byte[] arg0 = new byte[0];
        int lastIndexOf = ArrayUtils.lastIndexOf(arg0, (byte) (-1), (int) (byte) (-1));
        assertEquals((-1), lastIndexOf);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testRemoveElementTaking1And1ReturningNonEmptyArrayAndRemoveElementTaking1And15() throws Throwable  {
        byte[] arg0 = new byte[5];
        byte[] removeElement = ArrayUtils.removeElement(arg0, (byte)0);
        assertEquals(4, removeElement.length);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testIndexOfTaking11And1AndIndexOfTaking11And1AndIndexOfTaking11And1ReturningNegative4() throws Throwable  {
        byte[] arg0 = new byte[6];
        int indexOf = ArrayUtils.indexOf(arg0, (byte) (-85), (int) (byte) (-85));
        assertEquals((-1), indexOf);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testIndexOfTaking11And1WithEmptyArray() throws Throwable  {
        byte[] arg0 = new byte[0];
        int indexOf = ArrayUtils.indexOf(arg0, (byte)1, 6);
        assertEquals((-1), indexOf);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testContainsTaking1And1ReturningTrueAndContainsTaking1And1AndContainsTaking1And14() throws Throwable  {
        char[] arg0 = new char[6];
        arg0[1] = 'I';
        boolean contains = ArrayUtils.contains(arg0, 'I');
        assertTrue(contains);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testContainsTaking1And1ReturningFalseAndContainsTaking1And1AndContainsTaking1And12() throws Throwable  {
        char[] arg0 = new char[3];
        boolean contains = ArrayUtils.contains(arg0, 'f');
        assertFalse(contains);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testLastIndexOfTaking11And1ReturningPositiveAndLastIndexOfTaking11And16() throws Throwable  {
        char[] arg0 = new char[8];
        int lastIndexOf = ArrayUtils.lastIndexOf(arg0, '\u0000', 512);
        assertEquals(7, lastIndexOf);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testLastIndexOfTaking11And1WithZero() throws Throwable  {
        char[] arg0 = new char[6];
        int lastIndexOf = ArrayUtils.lastIndexOf(arg0, 'M', (int) (byte)0);
        assertEquals((-1), lastIndexOf);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testLastIndexOfTaking11And1WithNegative() throws Throwable  {
        char[] arg0 = new char[3];
        int lastIndexOf = ArrayUtils.lastIndexOf(arg0, 'w', (int) (byte) (-1));
        assertEquals((-1), lastIndexOf);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testLastIndexOfTaking11And1WithNullAndLastIndexOfTaking11And1AndLastIndexOfTaking11And12() throws Throwable  {
        int lastIndexOf = ArrayUtils.lastIndexOf((char[]) null, 'D', (-3111));
        assertEquals((-1), lastIndexOf);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testRemoveElementsTaking2CharArrays1() throws Throwable  {
        char[] arg1 = new char[3];
        char[] removeElements = ArrayUtils.removeElements(arg1, arg1);
        assertEquals(0, removeElements.length);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testIndexOfTaking1And1ReturningNegativeAndIndexOfTaking1And1AndIndexOfTaking1And15() throws Throwable  {
        char[] arg0 = new char[0];
        int indexOf = ArrayUtils.indexOf(arg0, ',');
        assertEquals((-1), indexOf);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testContainsTaking1And1ReturningTrueAndContainsTaking1And1AndContainsTaking1And15() throws Throwable  {
        short[] arg0 = new short[9];
        arg0[4] = (short) (-975);
        boolean contains = ArrayUtils.contains(arg0, (short) (-975));
        assertTrue(contains);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testContainsTaking1And1ReturningFalseAndContainsTaking1And1AndContainsTaking1And13() throws Throwable  {
        short[] arg0 = new short[9];
        boolean contains = ArrayUtils.contains(arg0, (short) (-975));
        assertFalse(contains);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testLastIndexOfTaking11And1ReturningZeroAndLastIndexOfTaking11And1AndLastIndexOfTaking11And15() throws Throwable  {
        short[] arg0 = new short[1];
        arg0[0] = (short)4;
        int lastIndexOf = ArrayUtils.lastIndexOf(arg0, (short)4, (int) (short)4);
        assertEquals(0, lastIndexOf);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testLastIndexOfTaking11And1AndLastIndexOfTaking11And1AndLastIndexOfTaking11And1ReturningNegative3() throws Throwable  {
        short[] arg0 = new short[5];
        int lastIndexOf = ArrayUtils.lastIndexOf(arg0, (short)3, 4);
        assertEquals((-1), lastIndexOf);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testLastIndexOfTaking11And1WithNegativeAndLastIndexOfTaking11And1AndLastIndexOfTaking11And12() throws Throwable  {
        short[] arg0 = new short[0];
        int lastIndexOf = ArrayUtils.lastIndexOf(arg0, (short) (-3025), (int) (byte) (-126));
        assertEquals((-1), lastIndexOf);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testLastIndexOfTaking11And1WithNullAndZero() throws Throwable  {
        int lastIndexOf = ArrayUtils.lastIndexOf((short[]) null, (short)8, 0);
        assertEquals((-1), lastIndexOf);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testIndexOfTaking1And1ReturningNegativeAndIndexOfTaking1And1AndIndexOfTaking1And16() throws Throwable  {
        short[] arg0 = new short[4];
        int indexOf = ArrayUtils.indexOf(arg0, (short)2760);
        assertEquals((-1), indexOf);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testIndexOfTaking11And1ReturningZeroAndIndexOfTaking11And1AndIndexOfTaking11And16() throws Throwable  {
        short[] arg0 = new short[4];
        int indexOf = ArrayUtils.indexOf(arg0, (short)0, (-3463));
        assertEquals(0, indexOf);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testContainsTaking1And1ReturningTrueAndContainsTaking1And1AndContainsTaking1And16() throws Throwable  {
        int[] arg0 = new int[3];
        arg0[0] = (-732);
        boolean contains = ArrayUtils.contains(arg0, (-732));
        assertTrue(contains);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testLastIndexOfTaking1And2IntsReturningZero() throws Throwable  {
        int[] arg0 = new int[3];
        int lastIndexOf = ArrayUtils.lastIndexOf(arg0, 0, 0);
        assertEquals(0, lastIndexOf);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testLastIndexOfTaking1And2IntsWithPositiveAndNegative() throws Throwable  {
        int[] arg0 = new int[5];
        int lastIndexOf = ArrayUtils.lastIndexOf(arg0, 2862, (-2141785322));
        assertEquals((-1), lastIndexOf);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testLastIndexOfTaking1And2IntsWithNull() throws Throwable  {
        int lastIndexOf = ArrayUtils.lastIndexOf((int[]) null, 16, (-536));
        assertEquals((-1), lastIndexOf);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testRemoveElementsTaking2IntArraysReturningEmptyArray() throws Throwable  {
        int[] arg1 = new int[4];
        int[] removeElements = ArrayUtils.removeElements(arg1, arg1);
        assertEquals(0, removeElements.length);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testContainsTaking1And1ReturningFalseAndContainsTaking1And1AndContainsTaking1And14() throws Throwable  {
        int[] arg0 = ArrayUtils.EMPTY_INT_ARRAY;
        boolean contains = ArrayUtils.contains(arg0, (-3386));
        assertFalse(contains);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testContainsTaking1And1ReturningTrueAndContainsTaking1And1AndContainsTaking1And17() throws Throwable  {
        long[] arg0 = new long[4];
        boolean contains = ArrayUtils.contains(arg0, 0L);
        assertTrue(contains);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testLastIndexOfTaking11And1ReturningZeroAndLastIndexOfTaking11And1AndLastIndexOfTaking11And16() throws Throwable  {
        long[] arg0 = new long[4];
        int lastIndexOf = ArrayUtils.lastIndexOf(arg0, 0L, (int) (byte)0);
        assertEquals(0, lastIndexOf);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testLastIndexOfTaking11And1AndLastIndexOfTaking11And1AndLastIndexOfTaking11And1ReturningNegative4() throws Throwable  {
        long[] arg0 = new long[1];
        int lastIndexOf = ArrayUtils.lastIndexOf(arg0, 0L, (-3676));
        assertEquals((-1), lastIndexOf);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testLastIndexOfTaking11And1WithNullAndLastIndexOfTaking11And1AndLastIndexOfTaking11And13() throws Throwable  {
        int lastIndexOf = ArrayUtils.lastIndexOf((long[]) null, 0L, (-3676));
        assertEquals((-1), lastIndexOf);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testIndexOfTaking11And1ReturningZeroAndIndexOfTaking11And1AndIndexOfTaking11And17() throws Throwable  {
        long[] arg0 = new long[1];
        int indexOf = ArrayUtils.indexOf(arg0, 0L, (-36));
        assertEquals(0, indexOf);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testContainsTaking1And1ReturningFalseAndContainsTaking1And1AndContainsTaking1And15() throws Throwable  {
        Object arg1 = new Object();
        boolean contains = ArrayUtils.contains((Object[]) null, arg1);
        assertFalse(contains);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testLastIndexOfTaking11And1WithNonNull() throws Throwable  {
        Short[] arg0 = new Short[3];
        Object arg1 = new Object();
        int lastIndexOf = ArrayUtils.lastIndexOf((Object[]) arg0, arg1, Integer.MAX_VALUE);
        assertEquals((-1), lastIndexOf);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testLastIndexOfTaking11And1WithZeroAndLastIndexOfTaking11And1AndLastIndexOfTaking11And11() throws Throwable  {
        Byte arg1 = new Byte((byte) (-97));
        Object[] arg0 = new Object[2];
        int lastIndexOf = ArrayUtils.lastIndexOf(arg0, (Object) arg1, 0);
        assertEquals((-1), lastIndexOf);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testLastIndexOfTaking11And1AndLastIndexOfTaking11And1AndLastIndexOfTaking11And1ReturningNegative5() throws Throwable  {
        Byte arg1 = new Byte((byte) (-71));
        Object[] arg0 = new Object[1];
        int lastIndexOf = ArrayUtils.lastIndexOf(arg0, (Object) arg1, (-736));
        assertEquals((-1), lastIndexOf);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testLastIndexOfTaking11And1WithNullAndLastIndexOfTaking11And1AndLastIndexOfTaking11And14() throws Throwable  {
        Byte arg1 = new Byte((byte) (-1));
        int lastIndexOf = ArrayUtils.lastIndexOf((Object[]) null, (Object) arg1, (-74));
        assertEquals((-1), lastIndexOf);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testIndexOfTaking1And1ReturningPositiveAndIndexOfTaking1And1AndIndexOfTaking1And18() throws Throwable  {
        Object[] arg0 = new Object[5];
        arg0[1] = (Object) 0;
        int indexOf = ArrayUtils.indexOf(arg0, arg0[1]);
        assertEquals(1, indexOf);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testRemoveElementTaking1And1ReturningEmptyArrayAndRemoveElementTaking1And14() throws Throwable  {
        Byte[] arg0 = new Byte[0];
        Object arg1 = new Object();
        Byte[] removeElement = ArrayUtils.removeElement(arg0, arg1);
        assertEquals(0, removeElement.length);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testIndexOfTaking11And1ReturningPositiveAndIndexOfTaking11And1AndIndexOfTaking11And17() throws Throwable  {
        Object[] arg0 = new Object[5];
        arg0[0] = (Object) 'n';
        int indexOf = ArrayUtils.indexOf(arg0, (Object) null, (-1));
        assertEquals(1, indexOf);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testIndexOfTaking11And1WithPositiveAndIndexOfTaking11And1AndIndexOfTaking11And12() throws Throwable  {
        String[] arg0 = new String[1];
        int indexOf = ArrayUtils.indexOf((Object[]) arg0, (Object) null, 1);
        assertEquals((-1), indexOf);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testIndexOfTaking11And1AndIndexOfTaking11And1AndIndexOfTaking11And1ReturningNegative5() throws Throwable  {
        Object arg1 = new Object();
        Object[] arg0 = new Object[1];
        int indexOf = ArrayUtils.indexOf(arg0, arg1, (-1));
        assertEquals((-1), indexOf);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testContainsTaking1And1ReturningTrueAndContainsTaking1And1AndContainsTaking1And18() throws Throwable  {
        Object[] arg0 = new Object[3];
        boolean contains = ArrayUtils.contains(arg0, arg0[1]);
        assertTrue(contains);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testReverseTaking1And2IntsWithNonEmptyArray() throws Throwable  {
        short[] arg0 = new short[6];
        ArrayUtils.reverse(arg0, (-3690), 2);
        assertArrayEquals(new short[] {(short)0, (short)0, (short)0, (short)0, (short)0, (short)0}, arg0);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testReverseTaking1And2IntsWithNullAndReverseTaking1And2IntsWithNegativeAndReverseTaking1And2Ints0() throws Throwable  {
        ArrayUtils.reverse((short[]) null, (int) (short) (-231), (int) (short) (-231));
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testReverseTaking1And2IntsWithPositiveAndReverseTaking1And2Ints() throws Throwable  {
        Integer[] arg0 = new Integer[4];
        ArrayUtils.reverse((Object[]) arg0, (-81), 1948);
        assertEquals(4, arg0.length);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testReverseTaking1And2IntsWithNullAndReverseTaking1And2IntsWithNegativeAndReverseTaking1And2Ints1() throws Throwable  {
        ArrayUtils.reverse((Object[]) null, (-1500), (-1500));
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testReverseTaking1And2IntsWithNegativeAndPositive1() throws Throwable  {
        long[] arg0 = new long[6];
        ArrayUtils.reverse(arg0, (-22), (int) (short)8);
        assertEquals(6, arg0.length);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testReverseTaking1And2IntsWithNullAndReverseTaking1And2IntsAndReverseTaking1And2Ints0() throws Throwable  {
        ArrayUtils.reverse((long[]) null, 5, 2133307888);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testReverseTaking1And2IntsWithNegativeAndReverseTaking1And2IntsWithPositiveAndReverseTaking1And2Ints0() throws Throwable  {
        int[] arg0 = new int[2];
        ArrayUtils.reverse(arg0, (-1941), 2055);
        assertArrayEquals(new int[] {0, 0}, arg0);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testReverseTaking1And2IntsWithNullAndReverseTaking1And2IntsWithZeroAndReverseTaking1And2Ints0() throws Throwable  {
        ArrayUtils.reverse((int[]) null, 1206, 0);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testReverseTaking1And2IntsWithNonEmptyArrayAndPositive() throws Throwable  {
        float[] arg0 = new float[7];
        ArrayUtils.reverse(arg0, (-837), (int) (byte)123);
        assertArrayEquals(new float[] {0.0F, 0.0F, 0.0F, 0.0F, 0.0F, 0.0F, 0.0F}, arg0, 0.01F);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testReverseTaking1And2IntsWithNullAndReverseTaking1And2IntsWithZeroAndReverseTaking1And2Ints1() throws Throwable  {
        ArrayUtils.reverse((float[]) null, (-1), (int) (byte)0);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testReverseTaking1And2Ints() throws Throwable  {
        double[] arg0 = new double[6];
        ArrayUtils.reverse(arg0, (-1990), (int) (short) (-3403));
        assertArrayEquals(new double[] {0.0, 0.0, 0.0, 0.0, 0.0, 0.0}, arg0, 0.01);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testReverseTaking1And2IntsWithNullAndReverseTaking1And2IntsAndReverseTaking1And2Ints1() throws Throwable  {
        ArrayUtils.reverse((double[]) null, (-3962), (-28));
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testReverseTaking1And2IntsWithPositiveAndNegative1() throws Throwable  {
        byte arg1 = (byte) (-58);
        char[] arg0 = new char[9];
        ArrayUtils.reverse(arg0, (int) arg1, 3);
        assertArrayEquals(new char[] {'\u0000', '\u0000', '\u0000', '\u0000', '\u0000', '\u0000', '\u0000', '\u0000', '\u0000'}, arg0);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testReverseTaking1And2IntsWithNullAndReverseTaking1And2IntsAndReverseTaking1And2Ints2() throws Throwable  {
        ArrayUtils.reverse((char[]) null, (int) (byte) (-11), (-1163));
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testReverseTaking1And2IntsWithNegativeAndReverseTaking1And2IntsWithPositiveAndReverseTaking1And2Ints1() throws Throwable  {
        byte[] arg0 = new byte[2];
        ArrayUtils.reverse(arg0, (-372), 67);
        assertArrayEquals(new byte[] {(byte)0, (byte)0}, arg0);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testReverseTaking1And2IntsWithNullAndPositive() throws Throwable  {
        ArrayUtils.reverse((byte[]) null, 2136852540, (-1566));
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testReverseTaking1And2IntsWithEmptyArray() throws Throwable  {
        boolean[] arg0 = new boolean[0];
        ArrayUtils.reverse(arg0, (-1), Integer.MAX_VALUE);
        assertEquals(0, arg0.length);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testReverseTaking1And2IntsWithNullAndReverseTaking1And2IntsWithNegativeAndReverseTaking1And2Ints2() throws Throwable  {
        ArrayUtils.reverse((boolean[]) null, (-970), (int) (short) (-1827));
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testReverseTakingBooleanArrayWithNull() throws Throwable  {
        ArrayUtils.reverse((boolean[]) null);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testReverseTakingBooleanArrayWithNonEmptyArray() throws Throwable  {
        boolean[] arg0 = new boolean[3];
        ArrayUtils.reverse(arg0);
        assertTrue(Arrays.equals(new boolean[] {false, false, false}, arg0));
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testReverseTakingFloatArrayWithNull() throws Throwable  {
        ArrayUtils.reverse((float[]) null);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testReverseTakingFloatArrayWithNonEmptyArray() throws Throwable  {
        float[] arg0 = new float[9];
        ArrayUtils.reverse(arg0);
        assertArrayEquals(new float[] {0.0F, 0.0F, 0.0F, 0.0F, 0.0F, 0.0F, 0.0F, 0.0F, 0.0F}, arg0, 0.01F);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testReverseTakingDoubleArrayWithNull() throws Throwable  {
        ArrayUtils.reverse((double[]) null);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testReverseTakingDoubleArrayWithNonEmptyArray() throws Throwable  {
        double[] arg0 = new double[6];
        ArrayUtils.reverse(arg0);
        assertArrayEquals(new double[] {0.0, 0.0, 0.0, 0.0, 0.0, 0.0}, arg0, 0.01);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testReverseTakingByteArrayWithNull() throws Throwable  {
        ArrayUtils.reverse((byte[]) null);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testReverseTakingByteArrayWithNonEmptyArray() throws Throwable  {
        byte[] arg0 = new byte[13];
        ArrayUtils.reverse(arg0);
        assertEquals(13, arg0.length);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testReverseTakingCharArrayWithNull() throws Throwable  {
        ArrayUtils.reverse((char[]) null);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testReverseTakingCharArrayWithNonEmptyArray() throws Throwable  {
        char[] arg0 = new char[3];
        ArrayUtils.reverse(arg0);
        assertArrayEquals(new char[] {'\u0000', '\u0000', '\u0000'}, arg0);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testReverseTakingShortArrayWithNull() throws Throwable  {
        ArrayUtils.reverse((short[]) null);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testReverseTakingShortArrayWithNonEmptyArray() throws Throwable  {
        short[] arg0 = new short[4];
        ArrayUtils.reverse(arg0);
        assertArrayEquals(new short[] {(short)0, (short)0, (short)0, (short)0}, arg0);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testReverseTakingIntArrayWithNull() throws Throwable  {
        ArrayUtils.reverse((int[]) null);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testReverseTakingIntArrayWithNonEmptyArray() throws Throwable  {
        int[] arg0 = new int[3];
        ArrayUtils.reverse(arg0);
        assertArrayEquals(new int[] {0, 0, 0}, arg0);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testReverseTakingLongArrayWithNull() throws Throwable  {
        ArrayUtils.reverse((long[]) null);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testReverseTakingLongArrayWithNonEmptyArray() throws Throwable  {
        long[] arg0 = new long[7];
        ArrayUtils.reverse(arg0);
        assertEquals(7, arg0.length);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testReverseTakingObjectArray() throws Throwable  {
        ArrayUtils.reverse((Object[]) null);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testIsSameTypeReturningTrue() throws Throwable  {
        Byte arg1 = new Byte((byte)13);
        boolean sameType = ArrayUtils.isSameType(arg1, arg1);
        assertTrue(sameType);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testIsSameTypeThrowsIllegalArgumentException() throws Throwable  {
        Byte arg0 = new Byte((byte)125);
        // Undeclared exception!
        try { 
          ArrayUtils.isSameType(arg0, (Object) null);
          fail("Expecting exception: IllegalArgumentException");
        
        } catch(IllegalArgumentException e) {
           //
           // The Array must not be null
           //
           verifyException("org.apache.commons.lang3.ArrayUtils", e);
        }
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testIsSameTypeWithNull() throws Throwable  {
        // Undeclared exception!
        try { 
          ArrayUtils.isSameType((Object) null, (Object) null);
          fail("Expecting exception: IllegalArgumentException");
        
        } catch(IllegalArgumentException e) {
           //
           // The Array must not be null
           //
           verifyException("org.apache.commons.lang3.ArrayUtils", e);
        }
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testRemoveElementsTaking2BooleanArraysReturningEmptyArray() throws Throwable  {
        boolean[] arg0 = new boolean[3];
        boolean[] arg1 = ArrayUtils.removeElements(arg0, arg0);
        boolean sameLength = ArrayUtils.isSameLength(arg0, arg1);
        assertEquals(0, arg1.length);
        assertFalse(sameLength);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testIsSameLengthTaking2BooleanArraysAndIsSameLengthTaking2BooleanArraysReturningTrue0() throws Throwable  {
        boolean[] arg1 = new boolean[3];
        boolean sameLength = ArrayUtils.isSameLength(arg1, arg1);
        assertTrue(sameLength);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testIsSameLengthTaking2BooleanArraysAndIsSameLengthTaking2BooleanArraysReturningFalse0() throws Throwable  {
        boolean[] arg0 = new boolean[3];
        boolean sameLength = ArrayUtils.isSameLength(arg0, (boolean[]) null);
        assertFalse(sameLength);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testIsSameLengthTaking2BooleanArraysAndIsSameLengthTaking2BooleanArraysReturningFalse1() throws Throwable  {
        boolean[] arg1 = new boolean[1];
        boolean sameLength = ArrayUtils.isSameLength((boolean[]) null, arg1);
        assertFalse(sameLength);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testIsSameLengthTaking2BooleanArraysWithEmptyArrayAndNull0() throws Throwable  {
        boolean[] arg1 = new boolean[0];
        boolean sameLength = ArrayUtils.isSameLength((boolean[]) null, arg1);
        assertTrue(sameLength);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testIsSameLengthTaking2BooleanArraysAndIsSameLengthTaking2BooleanArraysReturningTrue1() throws Throwable  {
        boolean sameLength = ArrayUtils.isSameLength((boolean[]) null, (boolean[]) null);
        assertTrue(sameLength);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testIsSameLengthTaking2BooleanArraysWithEmptyArrayAndNull1() throws Throwable  {
        boolean[] arg0 = new boolean[0];
        boolean sameLength = ArrayUtils.isSameLength(arg0, (boolean[]) null);
        assertTrue(sameLength);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testIsSameLengthTaking2FloatArraysAndIsSameLengthTaking2FloatArraysReturningFalse0() throws Throwable  {
        float[] arg0 = new float[2];
        float[] arg1 = ArrayUtils.EMPTY_FLOAT_ARRAY;
        boolean sameLength = ArrayUtils.isSameLength(arg0, arg1);
        assertFalse(sameLength);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testIsSameLengthTaking2FloatArraysAndIsSameLengthTaking2FloatArraysReturningTrue0() throws Throwable  {
        float[] arg1 = new float[0];
        boolean sameLength = ArrayUtils.isSameLength(arg1, arg1);
        assertTrue(sameLength);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testIsSameLengthTaking2FloatArraysAndIsSameLengthTaking2FloatArraysReturningFalse1() throws Throwable  {
        float[] arg0 = new float[1];
        boolean sameLength = ArrayUtils.isSameLength(arg0, (float[]) null);
        assertFalse(sameLength);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testIsSameLengthTaking2FloatArraysWithNonEmptyArray() throws Throwable  {
        float[] arg1 = new float[1];
        boolean sameLength = ArrayUtils.isSameLength((float[]) null, arg1);
        assertFalse(sameLength);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testIsSameLengthTaking2FloatArraysAndIsSameLengthTaking2FloatArraysReturningTrue1() throws Throwable  {
        float[] arg1 = new float[0];
        boolean sameLength = ArrayUtils.isSameLength((float[]) null, arg1);
        assertTrue(sameLength);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testIsSameLengthTaking2FloatArraysAndIsSameLengthTaking2FloatArraysReturningTrue2() throws Throwable  {
        boolean sameLength = ArrayUtils.isSameLength((float[]) null, (float[]) null);
        assertTrue(sameLength);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testIsSameLengthTaking2FloatArraysAndIsSameLengthTaking2FloatArraysReturningTrue3() throws Throwable  {
        float[] arg0 = new float[0];
        boolean sameLength = ArrayUtils.isSameLength(arg0, (float[]) null);
        assertTrue(sameLength);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testIsSameLengthTaking2DoubleArraysAndIsSameLengthTaking2DoubleArraysReturningFalse0() throws Throwable  {
        double[] arg0 = new double[1];
        double[] arg1 = new double[0];
        boolean sameLength = ArrayUtils.isSameLength(arg0, arg1);
        assertFalse(sameLength);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testIsSameLengthTaking2DoubleArraysAndIsSameLengthTaking2DoubleArraysReturningTrue0() throws Throwable  {
        double[] arg1 = new double[0];
        boolean sameLength = ArrayUtils.isSameLength(arg1, arg1);
        assertTrue(sameLength);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testIsSameLengthTaking2DoubleArraysAndIsSameLengthTaking2DoubleArraysReturningFalse1() throws Throwable  {
        double[] arg0 = new double[4];
        boolean sameLength = ArrayUtils.isSameLength(arg0, (double[]) null);
        assertFalse(sameLength);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testIsSameLengthTaking2DoubleArraysWithNonEmptyArray() throws Throwable  {
        double[] arg1 = new double[4];
        boolean sameLength = ArrayUtils.isSameLength((double[]) null, arg1);
        assertFalse(sameLength);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testIsSameLengthTaking2DoubleArraysAndIsSameLengthTaking2DoubleArraysReturningTrue1() throws Throwable  {
        double[] arg1 = new double[0];
        boolean sameLength = ArrayUtils.isSameLength((double[]) null, arg1);
        assertTrue(sameLength);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testIsSameLengthTaking2DoubleArraysAndIsSameLengthTaking2DoubleArraysReturningTrue2() throws Throwable  {
        boolean sameLength = ArrayUtils.isSameLength((double[]) null, (double[]) null);
        assertTrue(sameLength);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testIsSameLengthTaking2DoubleArraysAndIsSameLengthTaking2DoubleArraysReturningTrue3() throws Throwable  {
        double[] arg0 = new double[0];
        boolean sameLength = ArrayUtils.isSameLength(arg0, (double[]) null);
        assertTrue(sameLength);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testIsSameLengthTaking2ByteArrays() throws Throwable  {
        byte[] arg0 = new byte[2];
        byte[] arg1 = new byte[7];
        boolean sameLength = ArrayUtils.isSameLength(arg0, arg1);
        assertFalse(sameLength);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testIsSameLengthTaking2ByteArraysAndNullToEmptyTakingByteArrayAndIsSameLengthTaking2ByteArraysWithEmptyArray() throws Throwable  {
        byte[] arg0 = ArrayUtils.nullToEmpty((byte[]) null);
        boolean sameLength = ArrayUtils.isSameLength(arg0, (byte[]) null);
        assertTrue(sameLength);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testIsSameLengthTaking2ByteArraysAndIsSameLengthTaking2ByteArraysWithNull0() throws Throwable  {
        byte[] arg0 = new byte[5];
        boolean sameLength = ArrayUtils.isSameLength(arg0, (byte[]) null);
        assertFalse(sameLength);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testIsSameLengthTaking2ByteArraysAndIsSameLengthTaking2ByteArraysWithNull1() throws Throwable  {
        byte[] arg1 = new byte[1];
        boolean sameLength = ArrayUtils.isSameLength((byte[]) null, arg1);
        assertFalse(sameLength);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testIsSameLengthTaking2ByteArraysAndIsSameLengthTaking2ByteArraysReturningTrue() throws Throwable  {
        boolean sameLength = ArrayUtils.isSameLength((byte[]) null, (byte[]) null);
        assertTrue(sameLength);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testIsSameLengthTaking2ByteArraysAndIsSameLengthTaking2ByteArraysWithEmptyArray() throws Throwable  {
        byte[] arg1 = new byte[0];
        boolean sameLength = ArrayUtils.isSameLength(arg1, arg1);
        assertTrue(sameLength);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testIsSameLengthTaking2CharArraysAndIsSameLengthTaking2CharArraysReturningTrue0() throws Throwable  {
        char[] arg1 = new char[3];
        boolean sameLength = ArrayUtils.isSameLength(arg1, arg1);
        assertTrue(sameLength);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testIsSameLengthTaking2CharArraysAndIsSameLengthTaking2CharArraysReturningFalse0() throws Throwable  {
        char[] arg0 = new char[7];
        boolean sameLength = ArrayUtils.isSameLength(arg0, (char[]) null);
        assertFalse(sameLength);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testIsSameLengthTaking2CharArraysAndIsSameLengthTaking2CharArraysReturningFalse1() throws Throwable  {
        char[] arg1 = new char[1];
        boolean sameLength = ArrayUtils.isSameLength((char[]) null, arg1);
        assertFalse(sameLength);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testIsSameLengthTaking2CharArraysWithEmptyArrayAndNull0() throws Throwable  {
        char[] arg1 = new char[0];
        boolean sameLength = ArrayUtils.isSameLength((char[]) null, arg1);
        assertTrue(sameLength);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testIsSameLengthTaking2CharArraysAndIsSameLengthTaking2CharArraysReturningTrue1() throws Throwable  {
        boolean sameLength = ArrayUtils.isSameLength((char[]) null, (char[]) null);
        assertTrue(sameLength);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testIsSameLengthTaking2CharArraysWithEmptyArrayAndNull1() throws Throwable  {
        char[] arg0 = new char[0];
        boolean sameLength = ArrayUtils.isSameLength(arg0, (char[]) null);
        assertTrue(sameLength);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testIsSameLengthTaking2ShortArraysAndIsSameLengthTaking2ShortArraysReturningFalse0() throws Throwable  {
        short[] arg0 = new short[5];
        short[] arg1 = new short[0];
        boolean sameLength = ArrayUtils.isSameLength(arg0, arg1);
        assertFalse(sameLength);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testIsSameLengthTaking2ShortArraysAndIsSameLengthTaking2ShortArraysReturningTrue0() throws Throwable  {
        short[] arg1 = new short[0];
        boolean sameLength = ArrayUtils.isSameLength(arg1, arg1);
        assertTrue(sameLength);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testIsSameLengthTaking2ShortArraysAndIsSameLengthTaking2ShortArraysReturningFalse1() throws Throwable  {
        short[] arg0 = new short[1];
        boolean sameLength = ArrayUtils.isSameLength(arg0, (short[]) null);
        assertFalse(sameLength);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testIsSameLengthTaking2ShortArraysWithNonEmptyArray() throws Throwable  {
        short[] arg1 = new short[1];
        boolean sameLength = ArrayUtils.isSameLength((short[]) null, arg1);
        assertFalse(sameLength);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testIsSameLengthTaking2ShortArraysAndIsSameLengthTaking2ShortArraysReturningTrue1() throws Throwable  {
        short[] arg1 = new short[0];
        boolean sameLength = ArrayUtils.isSameLength((short[]) null, arg1);
        assertTrue(sameLength);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testIsSameLengthTaking2ShortArraysAndIsSameLengthTaking2ShortArraysReturningTrue2() throws Throwable  {
        boolean sameLength = ArrayUtils.isSameLength((short[]) null, (short[]) null);
        assertTrue(sameLength);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testIsSameLengthTaking2ShortArraysAndIsSameLengthTaking2ShortArraysReturningTrue3() throws Throwable  {
        short[] arg0 = new short[0];
        boolean sameLength = ArrayUtils.isSameLength(arg0, (short[]) null);
        assertTrue(sameLength);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testIsSameLengthTaking2IntArraysAndIsSameLengthTaking2IntArraysReturningFalse0() throws Throwable  {
        int[] arg1 = new int[1];
        int[] arg0 = new int[0];
        boolean sameLength = ArrayUtils.isSameLength(arg0, arg1);
        assertFalse(sameLength);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testIsSameLengthTaking2IntArraysAndIsSameLengthTaking2IntArraysReturningTrue0() throws Throwable  {
        int[] arg1 = new int[4];
        boolean sameLength = ArrayUtils.isSameLength(arg1, arg1);
        assertTrue(sameLength);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testIsSameLengthTaking2IntArraysAndIsSameLengthTaking2IntArraysReturningFalse1() throws Throwable  {
        int[] arg0 = new int[3];
        boolean sameLength = ArrayUtils.isSameLength(arg0, (int[]) null);
        assertFalse(sameLength);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testIsSameLengthTaking2IntArraysAndIsSameLengthTaking2IntArraysReturningFalse2() throws Throwable  {
        int[] arg1 = new int[1];
        boolean sameLength = ArrayUtils.isSameLength((int[]) null, arg1);
        assertFalse(sameLength);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testIsSameLengthTaking2IntArraysWithEmptyArray() throws Throwable  {
        int[] arg1 = new int[0];
        boolean sameLength = ArrayUtils.isSameLength((int[]) null, arg1);
        assertTrue(sameLength);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testIsSameLengthTaking2IntArraysAndIsSameLengthTaking2IntArraysReturningTrue1() throws Throwable  {
        boolean sameLength = ArrayUtils.isSameLength((int[]) null, (int[]) null);
        assertTrue(sameLength);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testIsSameLengthTaking2IntArraysAndIsSameLengthTaking2IntArraysReturningTrue2() throws Throwable  {
        int[] arg0 = new int[0];
        boolean sameLength = ArrayUtils.isSameLength(arg0, (int[]) null);
        assertTrue(sameLength);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testIsSameLengthTaking2LongArraysAndIsSameLengthTaking2LongArraysReturningFalse0() throws Throwable  {
        long[] arg0 = new long[3];
        long[] arg1 = new long[1];
        boolean sameLength = ArrayUtils.isSameLength(arg0, arg1);
        assertFalse(sameLength);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testIsSameLengthTaking2LongArraysAndIsSameLengthTaking2LongArraysReturningFalse1() throws Throwable  {
        long[] arg0 = new long[3];
        boolean sameLength = ArrayUtils.isSameLength(arg0, (long[]) null);
        assertFalse(sameLength);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testIsSameLengthTaking2LongArraysAndIsSameLengthTaking2LongArraysReturningTrue0() throws Throwable  {
        long[] arg0 = new long[0];
        boolean sameLength = ArrayUtils.isSameLength(arg0, (long[]) null);
        assertTrue(sameLength);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testIsSameLengthTaking2LongArraysAndIsSameLengthTaking2LongArraysReturningFalse2() throws Throwable  {
        long[] arg1 = new long[2];
        boolean sameLength = ArrayUtils.isSameLength((long[]) null, arg1);
        assertFalse(sameLength);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testIsSameLengthTaking2LongArraysAndIsSameLengthTaking2LongArraysReturningTrue1() throws Throwable  {
        long[] arg1 = ArrayUtils.EMPTY_LONG_ARRAY;
        boolean sameLength = ArrayUtils.isSameLength((long[]) null, arg1);
        assertTrue(sameLength);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testIsSameLengthTaking2LongArraysAndIsSameLengthTaking2LongArraysReturningTrue2() throws Throwable  {
        boolean sameLength = ArrayUtils.isSameLength((long[]) null, (long[]) null);
        assertTrue(sameLength);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testIsSameLengthTaking2LongArraysAndIsSameLengthTaking2LongArraysReturningTrue3() throws Throwable  {
        long[] arg1 = ArrayUtils.EMPTY_LONG_ARRAY;
        boolean sameLength = ArrayUtils.isSameLength(arg1, arg1);
        assertTrue(sameLength);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testIsSameLengthTaking2ObjectArraysReturningFalse() throws Throwable  {
        double[] arg0 = new double[1];
        Double[] arg1 = ArrayUtils.toObject(arg0);
        boolean sameLength = ArrayUtils.isSameLength((Object[]) null, (Object[]) arg1);
        assertFalse(sameLength);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testIsSameLengthTaking2ObjectArraysWithNull() throws Throwable  {
        boolean sameLength = ArrayUtils.isSameLength((Object[]) null, (Object[]) null);
        assertTrue(sameLength);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testSubarrayTaking1And2IntsReturningNonEmptyArrayAndSubarrayTaking1And2Ints0() throws Throwable  {
        boolean[] arg0 = new boolean[7];
        boolean[] subarray = ArrayUtils.subarray(arg0, (-223), 599);
        assertEquals(7, subarray.length);
        assertNotSame(subarray, arg0);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testSubarrayTaking1And2IntsReturningNullAndSubarrayTaking1And2IntsAndSubarrayTaking1And2Ints0() throws Throwable  {
        boolean[] subarray = ArrayUtils.subarray((boolean[]) null, 65, 5);
        assertNull(subarray);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testSubarrayTaking1And2IntsReturningEmptyArrayAndSubarrayTaking1And2Ints0() throws Throwable  {
        boolean[] arg0 = new boolean[5];
        boolean[] subarray = ArrayUtils.subarray(arg0, 599, (-1));
        assertEquals(0, subarray.length);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testSubarrayTaking1And2IntsReturningNonEmptyArrayAndSubarrayTaking1And2Ints1() throws Throwable  {
        float[] arg0 = new float[6];
        float[] subarray = ArrayUtils.subarray(arg0, (int) (byte) (-104), 8);
        assertNotSame(subarray, arg0);
        assertEquals(6, subarray.length);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testSubarrayTaking1And2IntsReturningNullAndSubarrayTaking1And2IntsAndSubarrayTaking1And2Ints1() throws Throwable  {
        float[] subarray = ArrayUtils.subarray((float[]) null, 4392, 4392);
        assertNull(subarray);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testSubarrayTaking1And2IntsReturningEmptyArrayAndSubarrayTaking1And2Ints1() throws Throwable  {
        float[] arg0 = new float[3];
        float[] subarray = ArrayUtils.subarray(arg0, 4392, (int) (byte)3);
        assertNotNull(subarray);
        assertEquals(0, subarray.length);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testSubarrayTaking1And2IntsReturningNonEmptyArrayAndSubarrayTaking1And2Ints2() throws Throwable  {
        double[] arg0 = new double[5];
        double[] subarray = ArrayUtils.subarray(arg0, 1, 885);
        assertEquals(4, subarray.length);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testSubarrayTaking1And2IntsAndSubarrayTaking1And2IntsAndSubarrayTaking1And2IntsReturningEmptyArray0() throws Throwable  {
        double[] arg0 = new double[5];
        double[] subarray = ArrayUtils.subarray(arg0, 1, 1);
        assertEquals(0, subarray.length);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testSubarrayTaking1And2IntsReturningNullAndSubarrayTaking1And2IntsAndSubarrayTaking1And2Ints2() throws Throwable  {
        double[] subarray = ArrayUtils.subarray((double[]) null, (int) ',', (-1));
        assertNull(subarray);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testSubarrayTaking1And2IntsWithNegative() throws Throwable  {
        double[] arg0 = new double[2];
        double[] subarray = ArrayUtils.subarray(arg0, (-1), (-1));
        assertEquals(0, subarray.length);
        assertNotNull(subarray);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testSubarrayTaking1And2IntsReturningNonEmptyArrayAndSubarrayTaking1And2Ints3() throws Throwable  {
        byte[] arg0 = new byte[9];
        byte[] subarray = ArrayUtils.subarray(arg0, (int) (byte)8, (int) (short)24);
        assertEquals(1, subarray.length);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testSubarrayTaking1And2IntsReturningNullAndSubarrayTaking1And2IntsAndSubarrayTaking1And2Ints3() throws Throwable  {
        byte[] subarray = ArrayUtils.subarray((byte[]) null, 760, (-485));
        assertNull(subarray);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testSubarrayTaking1And2IntsReturningEmptyArrayAndSubarrayTaking1And2Ints2() throws Throwable  {
        byte[] arg0 = new byte[9];
        byte[] subarray = ArrayUtils.subarray(arg0, (int) (byte) (-126), (int) (byte) (-126));
        assertNotNull(subarray);
        assertEquals(0, subarray.length);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testSubarrayTaking1And2IntsAndSubarrayTaking1And2IntsAndSubarrayTaking1And2IntsReturningEmptyArray1() throws Throwable  {
        char[] arg0 = new char[4];
        char[] subarray = ArrayUtils.subarray(arg0, (int) (byte)75, (int) (byte)75);
        assertEquals(0, subarray.length);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testSubarrayTaking1And2IntsReturningNullAndSubarrayTaking1And2IntsAndSubarrayTaking1And2Ints4() throws Throwable  {
        char[] subarray = ArrayUtils.subarray((char[]) null, 2, (int) (byte)2);
        assertNull(subarray);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testSubarrayTaking1And2IntsWithNegativeAndSubarrayTaking1And2IntsWithNegativeAndSubarrayTaking1And2Ints0() throws Throwable  {
        char[] arg0 = new char[3];
        char[] subarray = ArrayUtils.subarray(arg0, (-2124307015), (-2124307015));
        assertNotNull(subarray);
        assertEquals(0, subarray.length);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testSubarrayTaking1And2IntsWithNegativeAndSubarrayTaking1And2IntsWithNegativeAndSubarrayTaking1And2Ints1() throws Throwable  {
        short[] arg0 = new short[9];
        short[] subarray = ArrayUtils.subarray(arg0, (int) (short) (-685), (int) (short) (-65));
        assertEquals(0, subarray.length);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testSubarrayTaking1And2IntsReturningNullAndSubarrayTaking1And2IntsAndSubarrayTaking1And2Ints5() throws Throwable  {
        short[] subarray = ArrayUtils.subarray((short[]) null, 64, 1745);
        assertNull(subarray);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testSubarrayTaking1And2IntsReturningNonEmptyArrayAndSubarrayTaking1And2Ints4() throws Throwable  {
        short[] arg0 = new short[6];
        short[] subarray = ArrayUtils.subarray(arg0, 3, (int) (short)2113);
        assertEquals(3, subarray.length);
        assertNotNull(subarray);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testSubarrayTaking1And2IntsReturningNonEmptyArrayAndSubarrayTaking1And2Ints5() throws Throwable  {
        int[] arg0 = new int[8];
        int[] subarray = ArrayUtils.subarray(arg0, 0, 1076);
        assertEquals(8, subarray.length);
        assertNotSame(subarray, arg0);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testSubarrayTaking1And2IntsReturningEmptyArrayAndSubarrayTaking1And2Ints3() throws Throwable  {
        int[] arg0 = new int[4];
        int[] subarray = ArrayUtils.subarray(arg0, (-104), (-1548));
        assertEquals(0, subarray.length);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testSubarrayTaking1And2IntsReturningNullAndSubarrayTaking1And2IntsAndSubarrayTaking1And2Ints6() throws Throwable  {
        int[] subarray = ArrayUtils.subarray((int[]) null, (-3890), 512);
        assertNull(subarray);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testSubarrayTaking1And2IntsReturningNonEmptyArrayAndSubarrayTaking1And2Ints6() throws Throwable  {
        long[] arg0 = new long[7];
        long[] subarray = ArrayUtils.subarray(arg0, (int) (short)1, 14);
        assertEquals(6, subarray.length);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testSubarrayTaking1And2IntsReturningNullAndSubarrayTaking1And2IntsAndSubarrayTaking1And2Ints7() throws Throwable  {
        long[] subarray = ArrayUtils.subarray((long[]) null, 512, 2146219104);
        assertNull(subarray);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testSubarrayTaking1And2IntsReturningEmptyArrayAndSubarrayTaking1And2Ints4() throws Throwable  {
        long[] arg0 = new long[5];
        long[] subarray = ArrayUtils.subarray(arg0, (-1169), (-1169));
        assertEquals(0, subarray.length);
        assertNotNull(subarray);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testSubarrayTaking1And2IntsReturningNonEmptyArrayAndSubarrayTaking1And2Ints7() throws Throwable  {
        Byte[] arg0 = new Byte[6];
        Byte[] subarray = ArrayUtils.subarray(arg0, (-647), 4456);
        assertNotSame(subarray, arg0);
        assertEquals(6, subarray.length);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testSubarrayTaking1And2IntsWithPositive() throws Throwable  {
        Byte[] arg0 = new Byte[5];
        Byte[] subarray = ArrayUtils.subarray(arg0, 5, 1275);
        assertEquals(0, subarray.length);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testSubarrayTaking1And2IntsReturningNullAndSubarrayTaking1And2IntsAndSubarrayTaking1And2Ints8() throws Throwable  {
        Byte[] subarray = ArrayUtils.subarray((Byte[]) null, (int)  (-73), 1173);
        assertNull(subarray);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testSubarrayTaking1And2IntsWithEmptyArrayAndNegative() throws Throwable  {
        Byte[] arg0 = new Byte[0];
        Byte[] subarray = ArrayUtils.subarray(arg0, (int)  (-27), (-2819));
        assertNotSame(subarray, arg0);
        assertEquals(0, subarray.length);
        assertNotNull(subarray);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testNullToEmptyTakingBooleanArrayReturningNonEmptyArrayAndNullToEmptyTakingBooleanArray0() throws Throwable  {
        Boolean[] arg0 = new Boolean[1];
        Boolean[] nullToEmpty = ArrayUtils.nullToEmpty(arg0);
        assertEquals(1, nullToEmpty.length);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testNullToEmptyTakingBooleanArrayWithEmptyArrayAndNullToEmptyTakingBooleanArray0() throws Throwable  {
        Boolean[] arg0 = new Boolean[0];
        Boolean[] nullToEmpty = ArrayUtils.nullToEmpty(arg0);
        assertNotSame(nullToEmpty, arg0);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testNullToEmptyTakingBooleanArrayWithNullAndNullToEmptyTakingBooleanArray0() throws Throwable  {
        Boolean[] nullToEmpty = ArrayUtils.nullToEmpty((Boolean[]) null);
        assertEquals(0, nullToEmpty.length);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testNullToEmptyTakingFloatArrayReturningNonEmptyArrayAndNullToEmptyTakingFloatArray0() throws Throwable  {
        Float[] arg0 = new Float[1];
        Float[] nullToEmpty = ArrayUtils.nullToEmpty(arg0);
        assertEquals(1, nullToEmpty.length);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testNullToEmptyTakingFloatArrayReturningEmptyArrayAndNullToEmptyTakingFloatArray0() throws Throwable  {
        Float[] nullToEmpty = ArrayUtils.nullToEmpty((Float[]) null);
        assertEquals(0, nullToEmpty.length);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testNullToEmptyTakingDoubleArrayReturningNonEmptyArrayAndNullToEmptyTakingDoubleArray0() throws Throwable  {
        Double[] arg0 = new Double[1];
        Double[] nullToEmpty = ArrayUtils.nullToEmpty(arg0);
        assertEquals(1, nullToEmpty.length);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testNullToEmptyTakingDoubleArrayWithEmptyArrayAndNullToEmptyTakingDoubleArray0() throws Throwable  {
        Double[] arg0 = new Double[0];
        Double[] nullToEmpty = ArrayUtils.nullToEmpty(arg0);
        assertNotSame(nullToEmpty, arg0);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testNullToEmptyTakingDoubleArrayWithNullAndNullToEmptyTakingDoubleArray0() throws Throwable  {
        Double[] nullToEmpty = ArrayUtils.nullToEmpty((Double[]) null);
        assertEquals(0, nullToEmpty.length);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testNullToEmptyTakingByteArrayReturningNonEmptyArrayAndNullToEmptyTakingByteArray0() throws Throwable  {
        Byte[] arg0 = new Byte[1];
        Byte[] nullToEmpty = ArrayUtils.nullToEmpty(arg0);
        assertEquals(1, nullToEmpty.length);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testNullToEmptyTakingByteArrayWithEmptyArrayAndNullToEmptyTakingByteArray0() throws Throwable  {
        Byte[] arg0 = new Byte[0];
        Byte[] nullToEmpty = ArrayUtils.nullToEmpty(arg0);
        assertNotSame(nullToEmpty, arg0);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testNullToEmptyTakingByteArrayWithNull() throws Throwable  {
        Byte[] nullToEmpty = ArrayUtils.nullToEmpty((Byte[]) null);
        assertEquals(0, nullToEmpty.length);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testNullToEmptyTakingCharacterArrayReturningNonEmptyArray() throws Throwable  {
        Character[] arg0 = new Character[1];
        Character[] nullToEmpty = ArrayUtils.nullToEmpty(arg0);
        assertEquals(1, nullToEmpty.length);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testNullToEmptyTakingCharacterArrayWithEmptyArray() throws Throwable  {
        Character[] arg0 = new Character[0];
        Character[] nullToEmpty = ArrayUtils.nullToEmpty(arg0);
        assertNotSame(nullToEmpty, arg0);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testNullToEmptyTakingCharacterArrayWithNull() throws Throwable  {
        Character[] nullToEmpty = ArrayUtils.nullToEmpty((Character[]) null);
        assertEquals(0, nullToEmpty.length);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testNullToEmptyTakingShortArrayReturningNonEmptyArrayAndNullToEmptyTakingShortArray0() throws Throwable  {
        Short[] arg0 = new Short[1];
        Short[] nullToEmpty = ArrayUtils.nullToEmpty(arg0);
        assertEquals(1, nullToEmpty.length);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testNullToEmptyTakingShortArrayWithEmptyArrayAndNullToEmptyTakingShortArray0() throws Throwable  {
        Short[] arg0 = new Short[0];
        Short[] nullToEmpty = ArrayUtils.nullToEmpty(arg0);
        assertNotSame(nullToEmpty, arg0);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testNullToEmptyTakingShortArrayWithNullAndNullToEmptyTakingShortArrayAndNullToEmptyTakingShortArray0() throws Throwable  {
        Short[] nullToEmpty = ArrayUtils.nullToEmpty((Short[]) null);
        assertEquals(0, nullToEmpty.length);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testNullToEmptyTakingIntegerArrayReturningNonEmptyArray() throws Throwable  {
        Integer[] arg0 = new Integer[1];
        Integer[] nullToEmpty = ArrayUtils.nullToEmpty(arg0);
        assertEquals(1, nullToEmpty.length);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testNullToEmptyTakingIntegerArrayWithEmptyArray() throws Throwable  {
        Integer[] arg0 = new Integer[0];
        Integer[] nullToEmpty = ArrayUtils.nullToEmpty(arg0);
        assertNotSame(nullToEmpty, arg0);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testNullToEmptyTakingIntegerArrayWithNull() throws Throwable  {
        Integer[] nullToEmpty = ArrayUtils.nullToEmpty((Integer[]) null);
        assertEquals(0, nullToEmpty.length);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testNullToEmptyTakingLongArrayReturningNonEmptyArrayAndNullToEmptyTakingLongArray0() throws Throwable  {
        Long[] arg0 = new Long[1];
        Long[] nullToEmpty = ArrayUtils.nullToEmpty(arg0);
        assertEquals(1, nullToEmpty.length);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testNullToEmptyTakingLongArrayWithEmptyArrayAndNullToEmptyTakingLongArray0() throws Throwable  {
        Long[] arg0 = new Long[0];
        Long[] nullToEmpty = ArrayUtils.nullToEmpty(arg0);
        assertNotSame(nullToEmpty, arg0);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testIsSameLengthTaking2ObjectArraysWithEmptyArray() throws Throwable  {
        Long[] arg1 = ArrayUtils.nullToEmpty((Long[]) null);
        boolean sameLength = ArrayUtils.isSameLength((Object[]) null, (Object[]) arg1);
        assertTrue(sameLength);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testNullToEmptyTakingBooleanArrayReturningNonEmptyArrayAndNullToEmptyTakingBooleanArray1() throws Throwable  {
        boolean[] arg0 = new boolean[1];
        boolean[] nullToEmpty = ArrayUtils.nullToEmpty(arg0);
        assertEquals(1, nullToEmpty.length);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testNullToEmptyTakingBooleanArrayWithEmptyArrayAndNullToEmptyTakingBooleanArray1() throws Throwable  {
        boolean[] arg0 = new boolean[0];
        boolean[] nullToEmpty = ArrayUtils.nullToEmpty(arg0);
        assertNotSame(nullToEmpty, arg0);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testNullToEmptyTakingBooleanArrayWithNullAndNullToEmptyTakingBooleanArray1() throws Throwable  {
        boolean[] nullToEmpty = ArrayUtils.nullToEmpty((boolean[]) null);
        assertTrue(Arrays.equals(new boolean[] {}, nullToEmpty));
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testNullToEmptyTakingFloatArrayReturningNonEmptyArrayAndNullToEmptyTakingFloatArray1() throws Throwable  {
        float[] arg0 = new float[1];
        float[] nullToEmpty = ArrayUtils.nullToEmpty(arg0);
        assertEquals(1, nullToEmpty.length);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testNullToEmptyTakingFloatArrayReturningEmptyArrayAndNullToEmptyTakingFloatArray1() throws Throwable  {
        float[] nullToEmpty = ArrayUtils.nullToEmpty((float[]) null);
        assertArrayEquals(new float[] {}, nullToEmpty, 0.01F);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testNullToEmptyTakingDoubleArrayReturningNonEmptyArrayAndNullToEmptyTakingDoubleArray1() throws Throwable  {
        double[] arg0 = new double[1];
        double[] nullToEmpty = ArrayUtils.nullToEmpty(arg0);
        assertEquals(1, nullToEmpty.length);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testNullToEmptyTakingDoubleArrayWithEmptyArrayAndNullToEmptyTakingDoubleArray1() throws Throwable  {
        double[] arg0 = new double[0];
        double[] nullToEmpty = ArrayUtils.nullToEmpty(arg0);
        assertNotSame(nullToEmpty, arg0);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testNullToEmptyTakingDoubleArrayWithNullAndNullToEmptyTakingDoubleArray1() throws Throwable  {
        double[] nullToEmpty = ArrayUtils.nullToEmpty((double[]) null);
        assertArrayEquals(new double[] {}, nullToEmpty, 0.01);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testNullToEmptyTakingByteArrayReturningNonEmptyArrayAndNullToEmptyTakingByteArray1() throws Throwable  {
        byte[] arg0 = new byte[18];
        byte[] nullToEmpty = ArrayUtils.nullToEmpty(arg0);
        assertEquals(18, nullToEmpty.length);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testNullToEmptyTakingByteArrayWithEmptyArrayAndNullToEmptyTakingByteArray1() throws Throwable  {
        byte[] arg0 = ArrayUtils.EMPTY_BYTE_ARRAY;
        byte[] nullToEmpty = ArrayUtils.nullToEmpty(arg0);
        assertSame(nullToEmpty, arg0);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testIsSameLengthTaking2ByteArraysAndNullToEmptyTakingByteArrayAndIsSameLengthTaking2ByteArraysWithNull() throws Throwable  {
        byte[] arg1 = ArrayUtils.nullToEmpty((byte[]) null);
        boolean sameLength = ArrayUtils.isSameLength((byte[]) null, arg1);
        assertTrue(sameLength);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testNullToEmptyTakingCharArrayReturningNonEmptyArray() throws Throwable  {
        char[] arg0 = new char[1];
        char[] nullToEmpty = ArrayUtils.nullToEmpty(arg0);
        assertEquals(1, nullToEmpty.length);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testNullToEmptyTakingCharArrayWithEmptyArray() throws Throwable  {
        char[] arg0 = new char[0];
        char[] nullToEmpty = ArrayUtils.nullToEmpty(arg0);
        assertNotSame(nullToEmpty, arg0);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testNullToEmptyTakingCharArrayWithNull() throws Throwable  {
        char[] nullToEmpty = ArrayUtils.nullToEmpty((char[]) null);
        assertEquals(0, nullToEmpty.length);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testNullToEmptyTakingShortArrayReturningNonEmptyArrayAndNullToEmptyTakingShortArray1() throws Throwable  {
        short[] arg0 = new short[1];
        short[] nullToEmpty = ArrayUtils.nullToEmpty(arg0);
        assertEquals(1, nullToEmpty.length);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testNullToEmptyTakingShortArrayWithEmptyArrayAndNullToEmptyTakingShortArray1() throws Throwable  {
        short[] arg0 = new short[0];
        short[] nullToEmpty = ArrayUtils.nullToEmpty(arg0);
        assertNotSame(nullToEmpty, arg0);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testNullToEmptyTakingShortArrayWithNullAndNullToEmptyTakingShortArrayAndNullToEmptyTakingShortArray1() throws Throwable  {
        short[] nullToEmpty = ArrayUtils.nullToEmpty((short[]) null);
        assertArrayEquals(new short[] {}, nullToEmpty);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testNullToEmptyTakingIntArrayReturningNonEmptyArray() throws Throwable  {
        int[] arg0 = new int[1];
        int[] nullToEmpty = ArrayUtils.nullToEmpty(arg0);
        assertEquals(1, nullToEmpty.length);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testNullToEmptyTakingIntArrayWithEmptyArray() throws Throwable  {
        int[] arg0 = new int[0];
        int[] nullToEmpty = ArrayUtils.nullToEmpty(arg0);
        assertNotSame(nullToEmpty, arg0);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testNullToEmptyTakingIntArrayWithNull() throws Throwable  {
        int[] nullToEmpty = ArrayUtils.nullToEmpty((int[]) null);
        assertEquals(0, nullToEmpty.length);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testNullToEmptyTakingLongArrayReturningNonEmptyArrayAndNullToEmptyTakingLongArray1() throws Throwable  {
        long[] arg0 = new long[1];
        long[] nullToEmpty = ArrayUtils.nullToEmpty(arg0);
        assertEquals(1, nullToEmpty.length);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testNullToEmptyTakingLongArrayWithEmptyArrayAndNullToEmptyTakingLongArray1() throws Throwable  {
        long[] arg0 = new long[0];
        long[] nullToEmpty = ArrayUtils.nullToEmpty(arg0);
        assertNotSame(nullToEmpty, arg0);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testNullToEmptyTakingLongArrayWithNull() throws Throwable  {
        long[] nullToEmpty = ArrayUtils.nullToEmpty((long[]) null);
        assertArrayEquals(new long[] {}, nullToEmpty);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testNullToEmptyTakingStringArrayReturningNonEmptyArray() throws Throwable  {
        String[] arg0 = new String[1];
        String[] nullToEmpty = ArrayUtils.nullToEmpty(arg0);
        assertEquals(1, nullToEmpty.length);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testNullToEmptyTakingStringArrayWithEmptyArray() throws Throwable  {
        String[] arg0 = new String[0];
        String[] nullToEmpty = ArrayUtils.nullToEmpty(arg0);
        assertNotSame(nullToEmpty, arg0);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testNullToEmptyTakingStringArrayWithNull() throws Throwable  {
        String[] nullToEmpty = ArrayUtils.nullToEmpty((String[]) null);
        assertEquals(0, nullToEmpty.length);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testNullToEmptyTakingClassArrayReturningNonEmptyArray() throws Throwable  {
        Class<Byte>[] arg0 = (Class<Byte>[]) Array.newInstance(Class.class, 1);
        Class<?>[] nullToEmpty = ArrayUtils.nullToEmpty(arg0);
        assertEquals(1, nullToEmpty.length);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testNullToEmptyTakingClassArrayWithEmptyArray() throws Throwable  {
        Class<Byte>[] arg0 = (Class<Byte>[]) Array.newInstance(Class.class, 0);
        Class<?>[] nullToEmpty = ArrayUtils.nullToEmpty(arg0);
        assertEquals(0, nullToEmpty.length);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testNullToEmptyTakingClassArrayWithNull() throws Throwable  {
        Class<?>[] nullToEmpty = ArrayUtils.nullToEmpty((Class<?>[]) null);
        assertEquals(0, nullToEmpty.length);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testNullToEmptyTakingObjectArrayWithEmptyArray() throws Throwable  {
        Object[] arg0 = new Object[0];
        Object[] nullToEmpty = ArrayUtils.nullToEmpty(arg0);
        assertNotSame(nullToEmpty, arg0);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testNullToEmptyTakingObjectArrayReturningNonEmptyArray() throws Throwable  {
        Byte[] arg0 = new Byte[3];
        Object[] nullToEmpty = ArrayUtils.nullToEmpty((Object[]) arg0);
        assertEquals(3, nullToEmpty.length);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testNullToEmptyTakingObjectArrayWithNull() throws Throwable  {
        Object[] nullToEmpty = ArrayUtils.nullToEmpty((Object[]) null);
        assertEquals(0, nullToEmpty.length);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testAddAllTaking2BooleanArraysReturningNull() throws Throwable  {
        boolean[] addAll = ArrayUtils.addAll((boolean[]) null, (boolean[]) null);
        assertNull(addAll);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testCloneTakingBooleanArrayReturningEmptyArray() throws Throwable  {
        boolean[] arg0 = ArrayUtils.EMPTY_BOOLEAN_ARRAY;
        boolean[] clone = ArrayUtils.clone(arg0);
        assertEquals(0, clone.length);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testAddAllTaking2FloatArraysReturningNull() throws Throwable  {
        float[] addAll = ArrayUtils.addAll((float[]) null, (float[]) null);
        assertNull(addAll);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testRemoveElementTaking1And1ReturningEmptyArrayAndRemoveElementTaking1And15() throws Throwable  {
        float[] arg0 = new float[0];
        float[] removeElement = ArrayUtils.removeElement(arg0, 1.4F);
        assertNotSame(removeElement, arg0);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testRemoveElementTaking1And1ReturningEmptyArrayAndRemoveElementTaking1And16() throws Throwable  {
        double[] arg0 = ArrayUtils.EMPTY_DOUBLE_ARRAY;
        double[] removeElement = ArrayUtils.removeElement(arg0, 2363.6620835767);
        assertNotSame(removeElement, arg0);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testAddAllTaking2ByteArraysReturningNull() throws Throwable  {
        byte[] addAll = ArrayUtils.addAll((byte[]) null, (byte[]) null);
        assertNull(addAll);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testCloneTakingByteArrayReturningEmptyArray() throws Throwable  {
        byte[] arg0 = new byte[0];
        byte[] clone = ArrayUtils.clone(arg0);
        assertArrayEquals(new byte[] {}, clone);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testCloneTakingCharArrayReturningEmptyArray() throws Throwable  {
        char[] arg0 = ArrayUtils.EMPTY_CHAR_ARRAY;
        char[] clone = ArrayUtils.clone(arg0);
        assertEquals(0, clone.length);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testAddAllTaking2LongArraysReturningNull() throws Throwable  {
        long[] addAll = ArrayUtils.addAll((long[]) null, (long[]) null);
        assertNull(addAll);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testRemoveElementTaking1And1ReturningEmptyArrayAndRemoveElementTaking1And17() throws Throwable  {
        long[] arg0 = ArrayUtils.EMPTY_LONG_ARRAY;
        long[] removeElement = ArrayUtils.removeElement(arg0, (long) (-36));
        assertNotSame(removeElement, arg0);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testAddAllTaking2ObjectArraysReturningNull() throws Throwable  {
        Byte[] addAll = ArrayUtils.addAll((Byte[]) null, (Byte[]) null);
        assertNull(addAll);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testCloneTakingObjectArrayReturningEmptyArray() throws Throwable  {
        Byte[] arg0 = new Byte[0];
        Byte[] clone = ArrayUtils.clone(arg0);
        assertEquals(0, clone.length);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testToMapReturningMapWhereIsEmptyIsTrueAndMapWhereSizeIsZero() throws Throwable  {
        Short[] arg0 = new Short[0];
        Map<Object, Object> map = ArrayUtils.toMap(arg0);
        assertTrue(map.isEmpty());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testToMapReturningNull() throws Throwable  {
        Map<Object, Object> map = ArrayUtils.toMap((Object[]) null);
        assertNull(map);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testToMapThrowsIllegalArgumentException() throws Throwable  {
        Object[] arg0 = new Object[7];
        // Undeclared exception!
        try { 
          ArrayUtils.toMap(arg0);
          fail("Expecting exception: IllegalArgumentException");
        
        } catch(IllegalArgumentException e) {
           //
           // Array element 0, 'null', is neither of type Map.Entry nor an Array
           //
           verifyException("org.apache.commons.lang3.ArrayUtils", e);
        }
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testToStringTaking2ArgumentsReturningEmptyString() throws Throwable  {
        String string = ArrayUtils.toString((Object) null, "");
        assertEquals("", string);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testRemoveTaking1And1ThrowsIndexOutOfBoundsExceptionAndRemoveTaking1And10() throws Throwable  {
        // Undeclared exception!
        try { 
          ArrayUtils.remove((byte[]) null, 6);
          fail("Expecting exception: IndexOutOfBoundsException");
        
        } catch(IndexOutOfBoundsException e) {
           //
           // Index: 6, Length: 0
           //
           verifyException("org.apache.commons.lang3.ArrayUtils", e);
        }
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testRemoveAllTaking1And1ReturningEmptyArrayAndRemoveAllTaking1And1AndRemoveAllTaking1And12() throws Throwable  {
        int[] arg1 = new int[0];
        long[] arg0 = new long[0];
        long[] removeAll = ArrayUtils.removeAll(arg0, arg1);
        assertEquals(0, removeAll.length);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testRemoveAllTaking1And1ReturningEmptyArrayAndRemoveAllTaking1And1AndRemoveAllTaking1And13() throws Throwable  {
        double[] arg0 = new double[0];
        double[] removeAll = ArrayUtils.removeAll(arg0, (int[]) null);
        assertEquals(0, removeAll.length);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testAddTaking11And1AndAddTaking11And1AndAddTaking11And1ReturningNonEmptyArray2() throws Throwable  {
        char[] arg0 = new char[9];
        char[] add = ArrayUtils.add(arg0, (int) (short)6, '8');
        assertArrayEquals(new char[] {'\u0000', '\u0000', '\u0000', '\u0000', '\u0000', '\u0000', '8', '\u0000', '\u0000', '\u0000'}, add);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testIndexOfTaking1And1ReturningNegativeAndIndexOfTaking1And1AndIndexOfTaking1And17() throws Throwable  {
        int indexOf = ArrayUtils.indexOf((int[]) null, 14);
        assertEquals((-1), indexOf);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testRemoveTaking1And1AndRemoveTaking1And1AndRemoveTaking1And1ReturningNonEmptyArray1() throws Throwable  {
        int[] arg0 = new int[4];
        int[] remove = ArrayUtils.remove(arg0, 1);
        assertEquals(3, remove.length);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testRemoveTaking1And1ReturningEmptyArrayAndRemoveTaking1And1AndRemoveTaking1And13() throws Throwable  {
        long[] arg0 = new long[1];
        long[] remove = ArrayUtils.remove(arg0, 0);
        assertEquals(0, remove.length);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testLastIndexOfTaking1And1ReturningNegativeAndLastIndexOfTaking1And1AndLastIndexOfTaking1And12() throws Throwable  {
        double[] arg0 = new double[2];
        int lastIndexOf = ArrayUtils.lastIndexOf(arg0, 1464.25);
        assertEquals((-1), lastIndexOf);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testToArrayReturningNull() throws Throwable  {
        Byte[] array = ArrayUtils.toArray((Byte[]) null);
        assertNull(array);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testRemoveTaking1And1ThrowsIndexOutOfBoundsExceptionAndRemoveTaking1And11() throws Throwable  {
        // Undeclared exception!
        try { 
          ArrayUtils.remove((boolean[]) null, (-469));
          fail("Expecting exception: IndexOutOfBoundsException");
        
        } catch(IndexOutOfBoundsException e) {
           //
           // Index: -469, Length: 0
           //
           verifyException("org.apache.commons.lang3.ArrayUtils", e);
        }
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testRemoveElementTaking1And1ReturningNonEmptyArrayAndRemoveElementTaking1And16() throws Throwable  {
        double[] arg0 = new double[2];
        double[] removeElement = ArrayUtils.removeElement(arg0, 0.0);
        assertEquals(1, removeElement.length);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testAddTaking1And1AndAddTaking1And1AndAddTaking1And1ReturningNonEmptyArray0() throws Throwable  {
        long[] add = ArrayUtils.add((long[]) null, (-2526L));
        assertNotNull(add);
        assertArrayEquals(new long[] {(-2526L)}, add);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testAddTaking11And1AndAddTaking11And1AndAddTaking11And1ReturningNonEmptyArray3() throws Throwable  {
        float[] add = ArrayUtils.add((float[]) null, 0, (-104.0F));
        assertArrayEquals(new float[] {(-104.0F)}, add, 0.01F);
        assertNotNull(add);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testAddTaking1And1AndAddTaking1And1AndAddTaking1And1ReturningNonEmptyArray1() throws Throwable  {
        byte[] arg0 = new byte[0];
        byte[] add = ArrayUtils.add(arg0, (byte)21);
        assertArrayEquals(new byte[] {(byte)21}, add);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testRemoveAllTaking1And1ReturningEmptyArrayAndRemoveAllTaking1And1AndRemoveAllTaking1And14() throws Throwable  {
        float[] arg0 = new float[0];
        float[] removeAll = ArrayUtils.removeAll(arg0, (int[]) null);
        assertEquals(0, removeAll.length);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testAddTaking11And1AndAddTaking11And1AndAddTaking11And1ReturningNonEmptyArray4() throws Throwable  {
        double[] arg0 = new double[6];
        double[] add = ArrayUtils.add(arg0, 2, 39.0);
        assertArrayEquals(new double[] {0.0, 0.0, 39.0, 0.0, 0.0, 0.0, 0.0}, add, 0.01);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testRemoveTaking1And1ReturningEmptyArrayAndRemoveTaking1And1AndRemoveTaking1And14() throws Throwable  {
        char[] arg0 = new char[1];
        char[] remove = ArrayUtils.remove(arg0, 0);
        assertEquals(0, remove.length);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testLastIndexOfTaking1And1ReturningNegativeAndLastIndexOfTaking1And1AndLastIndexOfTaking1And13() throws Throwable  {
        short[] arg0 = new short[3];
        int lastIndexOf = ArrayUtils.lastIndexOf(arg0, (short)1160);
        assertEquals((-1), lastIndexOf);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testContainsTaking1And1ReturningFalseAndContainsTaking1And1AndContainsTaking1And16() throws Throwable  {
        boolean contains = ArrayUtils.contains((long[]) null, (long) (short)2);
        assertFalse(contains);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testCreatesArrayUtils() throws Throwable  {
        ArrayUtils arrayUtils = new ArrayUtils();
        short[] removeElement = ArrayUtils.removeElement(arrayUtils.EMPTY_SHORT_ARRAY, (short)512);
        assertEquals(0, removeElement.length);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testRemoveAllTaking1And1ReturningNonEmptyArrayAndRemoveAllTaking1And1AndRemoveAllTaking1And15() throws Throwable  {
        Byte[] arg0 = new Byte[9];
        int[] arg1 = new int[0];
        Byte[] removeAll = ArrayUtils.removeAll(arg0, arg1);
        assertEquals(9, removeAll.length);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testContainsTaking1And1ReturningFalseAndContainsTaking1And1AndContainsTaking1And17() throws Throwable  {
        boolean contains = ArrayUtils.contains((byte[]) null, (byte)0);
        assertFalse(contains);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testContainsTaking1And1ReturningFalseAndContainsTaking1And1AndContainsTaking1And18() throws Throwable  {
        boolean contains = ArrayUtils.contains((boolean[]) null, true);
        assertFalse(contains);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testLastIndexOfTaking1And1ReturningNegativeAndLastIndexOfTaking1And1AndLastIndexOfTaking1And14() throws Throwable  {
        char[] arg0 = new char[2];
        int lastIndexOf = ArrayUtils.lastIndexOf(arg0, 'Z');
        assertEquals((-1), lastIndexOf);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testIndexOfTaking1And2DoublesReturningNegative() throws Throwable  {
        double[] arg0 = new double[5];
        int indexOf = ArrayUtils.indexOf(arg0, (-1332.0), 0.0);
        assertEquals((-1), indexOf);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testRemoveAllTaking1And1ReturningEmptyArrayAndRemoveAllTaking1And1AndRemoveAllTaking1And15() throws Throwable  {
        short[] arg0 = new short[0];
        short[] removeAll = ArrayUtils.removeAll(arg0, (int[]) null);
        assertEquals(0, removeAll.length);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testAddTaking11And1ThrowsIndexOutOfBoundsException() throws Throwable  {
        short[] arg0 = new short[0];
        // Undeclared exception!
        try { 
          ArrayUtils.add(arg0, 2832, (short)279);
          fail("Expecting exception: IndexOutOfBoundsException");
        
        } catch(IndexOutOfBoundsException e) {
           //
           // Index: 2832, Length: 0
           //
           verifyException("org.apache.commons.lang3.ArrayUtils", e);
        }
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testRemoveElementTaking1And1ReturningNonEmptyArrayAndRemoveElementTaking1And17() throws Throwable  {
        float[] arg0 = new float[2];
        float[] removeElement = ArrayUtils.removeElement(arg0, (float) (short)0);
        assertEquals(1, removeElement.length);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testRemoveTaking1And1AndRemoveTaking1And1AndRemoveTaking1And1ReturningNonEmptyArray2() throws Throwable  {
        Byte[] arg0 = new Byte[38];
        Byte[] remove = ArrayUtils.remove(arg0, 36);
        assertEquals(37, remove.length);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testAddTaking1And1AndAddTaking1And1AndAddTaking1And1ReturningNonEmptyArray2() throws Throwable  {
        double[] add = ArrayUtils.add((double[]) null, 1035.0);
        assertNotNull(add);
        assertArrayEquals(new double[] {1035.0}, add, 0.01);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testIsEqualsReturningTrue() throws Throwable  {
        Byte arg1 = new Byte((byte) (-63));
        boolean equals = ArrayUtils.isEquals(arg1, arg1);
        assertTrue(equals);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testAddTaking11And1AndAddTaking11And1AndAddTaking11And1ReturningNonEmptyArray5() throws Throwable  {
        byte[] add = ArrayUtils.add((byte[]) null, 0, (byte)77);
        assertArrayEquals(new byte[] {(byte)77}, add);
        assertNotNull(add);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testAddTaking1And2Ints() throws Throwable  {
        int[] add = ArrayUtils.add((int[]) null, 0, (int) (byte)121);
        assertNotNull(add);
        assertArrayEquals(new int[] {121}, add);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testAddTaking1And1AndAddTaking1And1AndAddTaking1And1ReturningNonEmptyArray3() throws Throwable  {
        short[] add = ArrayUtils.add((short[]) null, (short)0);
        assertArrayEquals(new short[] {(short)0}, add);
        assertNotNull(add);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testHashCode() throws Throwable  {
        ArrayUtils.hashCode((Object) null);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testAddTaking11And1AndAddTaking11And1AndAddTaking11And1ReturningNonEmptyArray6() throws Throwable  {
        boolean[] arg0 = new boolean[4];
        boolean[] add = ArrayUtils.add(arg0, 1, true);
        assertTrue(Arrays.equals(new boolean[] {false, true, false, false, false}, add));
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testLastIndexOfTaking1And1ReturningNegativeAndLastIndexOfTaking1And1AndLastIndexOfTaking1And15() throws Throwable  {
        boolean[] arg0 = new boolean[6];
        int lastIndexOf = ArrayUtils.lastIndexOf(arg0, true);
        assertEquals((-1), lastIndexOf);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testRemoveElementTaking1And1ReturningNullAndRemoveElementTaking1And1AndRemoveElementTaking1And16() throws Throwable  {
        char[] removeElement = ArrayUtils.removeElement((char[]) null, '*');
        assertNull(removeElement);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testToStringTakingObject() throws Throwable  {
        Object arg0 = new Object();
        String string = ArrayUtils.toString(arg0);
        assertNotNull(string);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testRemoveAllTaking1And1ReturningEmptyArrayAndRemoveAllTaking1And1AndRemoveAllTaking1And16() throws Throwable  {
        byte[] arg0 = new byte[0];
        byte[] removeAll = ArrayUtils.removeAll(arg0, (int[]) null);
        assertEquals(0, removeAll.length);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testRemoveElementTaking1And1ReturningNullAndRemoveElementTaking1And1AndRemoveElementTaking1And17() throws Throwable  {
        short[] removeElement = ArrayUtils.removeElement((short[]) null, (short)6);
        assertNull(removeElement);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testLastIndexOfTaking1And1ReturningNegativeAndLastIndexOfTaking1And1AndLastIndexOfTaking1And16() throws Throwable  {
        long[] arg0 = new long[8];
        int lastIndexOf = ArrayUtils.lastIndexOf(arg0, (-1611L));
        assertEquals((-1), lastIndexOf);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testLastIndexOfTaking1And1ReturningNegativeAndLastIndexOfTaking1And1AndLastIndexOfTaking1And17() throws Throwable  {
        float[] arg0 = new float[1];
        int lastIndexOf = ArrayUtils.lastIndexOf(arg0, (float) (byte) (-100));
        assertEquals((-1), lastIndexOf);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testLastIndexOfTaking1And2DoublesReturningPositive() throws Throwable  {
        double[] arg0 = new double[3];
        int lastIndexOf = ArrayUtils.lastIndexOf(arg0, (-811.98095240529), 992.1195701245);
        assertEquals(2, lastIndexOf);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testAddTaking1And1AndAddTaking1And1AndAddTaking1And1ReturningNonEmptyArray4() throws Throwable  {
        boolean[] arg0 = new boolean[0];
        boolean[] add = ArrayUtils.add(arg0, false);
        assertTrue(Arrays.equals(new boolean[] {false}, add));
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testRemoveAllTaking2IntArrays() throws Throwable  {
        int[] arg1 = new int[1];
        int[] removeAll = ArrayUtils.removeAll(arg1, arg1);
        assertEquals(0, removeAll.length);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testIndexOfTaking1And1ReturningNegativeAndIndexOfTaking1And1AndIndexOfTaking1And18() throws Throwable  {
        Byte arg1 = new Byte((byte) (-1));
        int indexOf = ArrayUtils.indexOf((Object[]) null, (Object) arg1);
        assertEquals((-1), indexOf);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testRemoveAllTaking1And1ReturningNonEmptyArrayAndRemoveAllTaking1And1AndRemoveAllTaking1And16() throws Throwable  {
        char[] arg0 = new char[4];
        int[] arg1 = new int[0];
        char[] removeAll = ArrayUtils.removeAll(arg0, arg1);
        assertEquals(4, removeAll.length);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testLastIndexOfTaking1And1ReturningPositiveAndLastIndexOfTaking1And1AndLastIndexOfTaking1And18() throws Throwable  {
        Object[] arg0 = new Object[8];
        int lastIndexOf = ArrayUtils.lastIndexOf(arg0, arg0[2]);
        assertEquals(7, lastIndexOf);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testRemoveTaking1And1ReturningEmptyArrayAndRemoveTaking1And1AndRemoveTaking1And15() throws Throwable  {
        short[] arg0 = new short[1];
        short[] remove = ArrayUtils.remove(arg0, 0);
        assertEquals(0, remove.length);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testAddTaking1And1AndAddTaking1And1AndAddTaking1And1ReturningNonEmptyArray5() throws Throwable  {
        int[] add = ArrayUtils.add((int[]) null, (-650));
        assertArrayEquals(new int[] {(-650)}, add);
        assertNotNull(add);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testRemoveElementTaking1And1ReturningNullAndRemoveElementTaking1And1AndRemoveElementTaking1And18() throws Throwable  {
        double[] removeElement = ArrayUtils.removeElement((double[]) null, (double) 'g');
        assertNull(removeElement);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testAddTaking11And1AndAddTaking11And1AndAddTaking11And1ReturningNonEmptyArray7() throws Throwable  {
        long[] arg0 = new long[1];
        long[] add = ArrayUtils.add(arg0, (int) (short)1, 0L);
        assertEquals(2, add.length);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testAddTaking1And1AndIsSameLengthTaking2CharArrays() throws Throwable  {
        char[] arg0 = new char[1];
        char[] arg1 = ArrayUtils.add(arg0, '{');
        boolean sameLength = ArrayUtils.isSameLength(arg0, arg1);
        assertArrayEquals(new char[] {'\u0000', '{'}, arg1);
        assertFalse(sameLength);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testAddTaking1And1AndAddTaking1And1AndAddTaking1And1ReturningNonEmptyArray6() throws Throwable  {
        float[] add = ArrayUtils.add((float[]) null, (-2041.9781F));
        assertArrayEquals(new float[] {(-2041.9781F)}, add, 0.01F);
        assertNotNull(add);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testLastIndexOfTaking1And1ReturningNegativeAndLastIndexOfTaking1And1AndLastIndexOfTaking1And18() throws Throwable  {
        int[] arg0 = new int[4];
        int lastIndexOf = ArrayUtils.lastIndexOf(arg0, (-2441));
        assertEquals((-1), lastIndexOf);
    }
  }
  