content: /*
   * This file was automatically generated by UTestGen and EvoSuite
   * Mon Mar 18 14:40:32 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_ESTest extends ArrayUtils_ESTest_scaffolding {
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testRemoveAllTaking1And1ThrowsNullPointerExceptionAndRemoveAllTaking1And10() throws Throwable  {
        // Test that removeAll throws NullPointerException when given null as input
        try {
        ArrayUtils.removeAll((Object) null, (BitSet) null); // this line is causing the exception
        fail("Expecting exception: NullPointerException"); // we expect the method to throw a NullPointerException
        } catch(NullPointerException e) {
        // verify that the exception has the expected message
        verifyException("org.apache.commons.lang3.ArrayUtils", e);}
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testToStringTaking2ArgumentsReturningNull() throws Throwable  {
        // No Comments were added
        String string = ArrayUtils.toString((Object) null, (String) null);
        assertNull(string);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testToStringTaking2ArgumentsReturningNonEmptyString() throws Throwable  {
        // Test the toString() method of the ArrayUtils class with a non-null argument.
        String string = ArrayUtils.toString((Object) "java.vm.version", (String) null);
        assertEquals("java.vm.version", string);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testToArrayReturningNonEmptyArray() throws Throwable  {
        // Test that the toArray method returns a new array when passed an array of length 8
        Byte[] arg0 = new Byte[8];
        Byte[] array = ArrayUtils.toArray(arg0);
        assertNotSame(array, arg0);
        
        // Test that the toArray method returns an array with the same contents as the original array
        for (int i = 0; i < arg0.length; i++) {
        assertEquals(arg0[i], array[i]);
        }
        
        // Test that the toArray method returns a new array when passed null
        Byte[] array2 = ArrayUtils.toArray((Byte[]) null);
        assertNotSame(array2, null);
        
        // Test that the toArray method returns an empty array when passed an empty array
        Byte[] array3 = ArrayUtils.toArray(new Byte[0]);
        assertEquals(array3.length, 0);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testToArrayReturningEmptyArray() throws Throwable  {
        // No Comments were added
        AbstractMap.SimpleImmutableEntry<Byte, Byte>[] arg0 = (AbstractMap.SimpleImmutableEntry<Byte, Byte>[]) Array.newInstance(AbstractMap.SimpleImmutableEntry.class, 0);
        AbstractMap.SimpleImmutableEntry<Byte, Byte>[] array = ArrayUtils.toArray(arg0);
        assertEquals(0, array.length);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testRemoveElementTaking1And1ReturningNonEmptyArrayAndRemoveElementTaking1And10() throws Throwable  {
        // Given: an array of booleans with a single element set to true
        boolean[] arg0 = new boolean[1];
        arg0[0] = true;
        
        // When: the removeElement method is called with this array and the value true
        boolean[] result = ArrayUtils.removeElement(arg0, true);
        
        // Then: the resulting array should have a length of 0
        assertEquals(0, result.length);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testRemoveElementTaking1And1ReturningEmptyArrayAndRemoveElementTaking1And10() throws Throwable  {
        // Given an empty array of bytes, and an object to be removed
        Byte[] input = new Byte[0];
        Object elementToRemove = new Object();
        
        // When we call removeElement on the array with the element to remove
        Byte[] result = ArrayUtils.removeElement(input, elementToRemove);
        
        // Then the method should return an empty array of bytes
        assertEquals(0, result.length);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testRemoveElementTaking1And1ReturningNullAndRemoveElementTaking1And1AndRemoveElementTaking1And10() throws Throwable  {
        // Test that removing an element from a null array returns null
        long[] removeElement = ArrayUtils.removeElement((long[]) null, 4694L);
        assertNull(removeElement);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testRemoveElementTaking1And1ReturningEmptyArrayAndRemoveElementTaking1And11() throws Throwable  {
        // Given an empty array of integers
        int[] arg0 = new int[0];
        
        // When the element -1 is removed from the array
        int[] removeElement = ArrayUtils.removeElement(arg0, (-1));
        
        // Then the method should return a new array without the element
        assertNotSame(removeElement, arg0);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testRemoveElementTaking1And1ReturningNullAndRemoveElementTaking1And1AndRemoveElementTaking1And11() throws Throwable  {
        // Test that removing an element from a null array returns null
        float[] removeElement = ArrayUtils.removeElement((float[]) null, 8.0F);
        assertNull(removeElement);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testRemoveElementTaking1And1ReturningEmptyArrayAndRemoveElementTaking1And12() throws Throwable  {
        // Given an empty array of floats
        float[] arg0 = new float[0];
        
        // When we call the removeElement method with a value of 1.4F
        float[] removedElement = ArrayUtils.removeElement(arg0, 1.4F);
        
        // Then the returned array should be empty
        assertEquals(0, removedElement.length);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testRemoveElementTaking1And1ReturningNullAndRemoveElementTaking1And1AndRemoveElementTaking1And12() throws Throwable  {
        // Test that null input returns null output
        double[] removeElement = ArrayUtils.removeElement((double[]) null, (double) 'g');
        assertNull(removeElement);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testRemoveElementTaking1And1ReturningEmptyArrayAndRemoveElementTaking1And13() throws Throwable  {
        // Given: A char array with 0 elements and a target element to be removed
        char[] arg0 = new char[0];
        
        // When: The removeElement method is called on the char array with the target element 'f'
        char[] removeElement = ArrayUtils.removeElement(arg0, 'f');
        
        // Then: The return value of the method should not be the same as the original char array
        assertNotSame(removeElement, arg0);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testRemoveElementTaking1And1ReturningEmptyArrayAndRemoveElementTaking1And14() throws Throwable  {
        // Given a byte array containing no elements
        byte[] emptyArray = new byte[0];
        
        // When an element is removed from the array
        byte[] result = ArrayUtils.removeElement(emptyArray, (byte)87);
        
        // Then the result should not be the same as the original array
        assertNotSame(result, emptyArray);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testRemoveAllTaking1And1() throws Throwable  {
        // No Comments were added
        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  {
        // Given: An array of shorts and an empty array of integers
        short[] arg0 = new short[7];
        int[] arg1 = new int[0];
        
        // When: The "removeAll" method is called with these two arguments
        short[] removeAll = ArrayUtils.removeAll(arg0, arg1);
        
        // Then: The resulting array should have the same length as the original array (7)
        assertEquals(7, removeAll.length);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testRemoveAllTaking1And1ReturningEmptyArrayAndRemoveAllTaking1And1AndRemoveAllTaking1And10() throws Throwable  {
        // Given an empty short array and a null array of integers as argument
        short[] arg0 = new short[0];
        int[] toBeRemoved = null;
        
        // When we call the removeAll method with these arguments
        short[] removedElements = ArrayUtils.removeAll(arg0, toBeRemoved);
        
        // Then the returned array should be empty
        assertEquals(0, removedElements.length);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testRemoveAllTaking1And1ReturningEmptyArrayAndRemoveAllTaking1And1AndRemoveAllTaking1And11() throws Throwable  {
        // Given: An array of Bytes and an array of integers to be removed from the Byte array
        int[] arg1 = new int[4];
        Byte[] arg0 = new Byte[1];
        
        // When: The removeAll method is called with these arguments
        Byte[] removeAll = ArrayUtils.removeAll(arg0, arg1);
        
        // Then: The resulting array should be empty
        assertEquals(0, removeAll.length);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testRemoveAllTaking1And1ReturningNonEmptyArrayAndRemoveAllTaking1And1AndRemoveAllTaking1And11() throws Throwable  {
        // No Comments were added
        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 testRemoveAllTaking1And1ReturningEmptyArrayAndRemoveAllTaking1And1AndRemoveAllTaking1And12() throws Throwable  {
        // Given: an empty array of longs and an empty array of ints
        long[] arg0 = new long[0];
        int[] arg1 = new int[0];
        
        // When: we remove all elements from the first array that are not present in the second array
        long[] removeAll = ArrayUtils.removeAll(arg0, arg1);
        
        // Then: the resulting array should be empty
        assertEquals(0, removeAll.length);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testRemoveAllTaking1And1ReturningEmptyArrayAndRemoveAllTaking1And1AndRemoveAllTaking1And13() throws Throwable  {
        // Given: an empty array of floats and a null input for the elements to be removed
        float[] arg0 = new float[0];
        int[] nullInput = null;
        
        // When: we remove all elements from the array using the removeAll method with the null input
        float[] result = ArrayUtils.removeAll(arg0, nullInput);
        
        // Then: the resulting array should be empty
        assertEquals(0, result.length);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testRemoveAllTaking1And1ReturningNonEmptyArrayAndRemoveAllTaking1And1AndRemoveAllTaking1And12() throws Throwable  {
        // Given an array of doubles and an empty array of integers
        double[] arg0 = new double[]{1.0, 2.0, 3.0, 4.0, 5.0, 6.0};
        int[] arg1 = new int[0];
        
        // When the removeAll method is called with these arguments
        double[] result = ArrayUtils.removeAll(arg0, arg1);
        
        // Then the result should be an array of doubles with length 6
        assertEquals(6, result.length);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testRemoveAllTaking1And1ReturningEmptyArrayAndRemoveAllTaking1And1AndRemoveAllTaking1And14() throws Throwable  {
        // Given: a double array with no elements
        double[] arg0 = new double[0];
        
        // When: removing all elements from the array using ArrayUtils.removeAll() method
        double[] removeAll = ArrayUtils.removeAll(arg0, (int[]) null);
        
        // Then: the resulting array should be empty
        assertEquals(0, removeAll.length);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testRemoveAllTaking1And1ReturningNonEmptyArrayAndRemoveAllTaking1And1AndRemoveAllTaking1And13() throws Throwable  {
        char[] testArray = new char[4];
        int[] emptyArray = new int[0];
        char[] result = ArrayUtils.removeAll(testArray, emptyArray);
        assertEquals(4, result.length);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testRemoveAllTaking1And1ReturningEmptyArrayAndRemoveAllTaking1And1AndRemoveAllTaking1And15() throws Throwable  {
        int[] numbers = new int[1];
        char[] letters = new char[1];
        char[] removedLetters = ArrayUtils.removeAll(letters, numbers);
        // Assert that the length of the array containing the removed letters is 0
        assertEquals(0, removedLetters.length);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testRemoveAllTaking1And1ReturningNonEmptyArrayAndRemoveAllTaking1And1AndRemoveAllTaking1And14() throws Throwable  {
        // Given
        byte[] arg0 = new byte[9];
        int[] arg1 = new int[0];
        
        // When
        byte[] removeAll = ArrayUtils.removeAll(arg0, arg1);
        
        // Then
        assertEquals(9, removeAll.length);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testRemoveAllTaking1And1ReturningEmptyArrayAndRemoveAllTaking1And1AndRemoveAllTaking1And16() throws Throwable  {
        // Test that removing all elements from an empty array results in an empty array
        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 testRemoveTaking1And1ReturningNonEmptyArrayAndRemoveTaking1And1AndRemoveTaking1And10() throws Throwable  {
        // Given an array of booleans with 4 elements
        boolean[] arg0 = new boolean[4];
        
        // When we remove the third element from the array
        boolean[] remove = ArrayUtils.remove(arg0, 3);
        
        // Then the resulting array should have length 3 and contain all the other elements
        assertEquals(3, remove.length);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testRemoveTaking1And1ReturningEmptyArrayAndRemoveTaking1And1AndRemoveTaking1And10() throws Throwable  {
        // Given: A boolean array with one element
        boolean[] arg0 = new boolean[1];
        
        // When: The first element is removed from the array using ArrayUtils.remove()
        boolean[] remove = ArrayUtils.remove(arg0, 0);
        
        // Then: The resulting array should have length 0
        assertEquals(0, remove.length);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testRemoveTaking1And1ReturningNonEmptyArrayAndRemoveTaking1And1AndRemoveTaking1And11() throws Throwable  {
        // Given: A short array with 7 elements
        short[] arg0 = new short[7];
        
        // When: The first element is removed from the array
        short[] remove = ArrayUtils.remove(arg0, 1);
        
        // Then: The length of the remaining array should be 6
        assertEquals(6, remove.length);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testRemoveTaking1And1ReturningNonEmptyArrayAndRemoveTaking1And1AndRemoveTaking1And12() throws Throwable  {
        // Given an array of longs
        long[] arg0 = new long[]{1, 2, 3, 4, 5, 6, 7, 8, 9};
        
        // When the second element is removed from the array
        long[] remove = ArrayUtils.remove(arg0, 2);
        
        // Then the length of the resulting array should be 8
        assertEquals(8, remove.length);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testRemoveTaking1And1ReturningNonEmptyArrayAndRemoveTaking1And1AndRemoveTaking1And13() throws Throwable  {
        // Given an array of 9 elements
        double[] input = new double[9];
        
        // When we remove the second element from the array
        double[] result = ArrayUtils.remove(input, 1);
        
        // Then the resulting array should have 8 elements
        assertEquals(8, result.length);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testRemoveTaking1And1ReturningEmptyArrayAndRemoveTaking1And1AndRemoveTaking1And11() throws Throwable  {
        // Given an empty char array
        char[] arg0 = new char[1];
        
        // When we call the remove method with index 0
        char[] remove = ArrayUtils.remove(arg0, 0);
        
        // Then the result should be an empty char array
        assertEquals(0, remove.length);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testRemoveTaking1And1ReturningNonEmptyArrayAndRemoveTaking1And1AndRemoveTaking1And14() throws Throwable  {
        // Setup
        byte[] input = new byte[2];
        
        // Exercise
        byte[] output = ArrayUtils.remove(input, 1);
        
        // Verify
        assertEquals(1, output.length);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testRemoveTaking1And1ReturningEmptyArrayAndRemoveTaking1And1AndRemoveTaking1And12() throws Throwable  {
        // Given a byte array with one element
        byte[] arg0 = new byte[1];
        
        // When we call the remove method with index 0
        byte[] remove = ArrayUtils.remove(arg0, 0);
        
        // Then the returned array should have length 0
        assertEquals(0, remove.length);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testLastIndexOfTaking1And1ReturningZeroAndLastIndexOfTaking1And1AndLastIndexOfTaking1And10() throws Throwable  {
        // Given: an array of booleans with one element set to true
        boolean[] arg0 = new boolean[1];
        arg0[0] = true;
        
        // When: calling the lastIndexOf method on this array with the value true as a parameter
        int lastIndexOf = ArrayUtils.lastIndexOf(arg0, true);
        
        // Then: the index of the last occurrence of the value true in the array should be returned
        assertEquals(0, lastIndexOf);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testLastIndexOfTaking1And1ReturningPositiveAndLastIndexOfTaking1And1AndLastIndexOfTaking1And10() throws Throwable  {
        // Given: a boolean array with multiple elements and one element set to true
        boolean[] arg0 = new boolean[6];
        arg0[1] = true;
        
        // When: the method "lastIndexOf" is called on the array with the value true as an argument
        int lastIndexOf = ArrayUtils.lastIndexOf(arg0, true);
        
        // Then: the result should be the index of the last occurrence of the value true in the array
        assertEquals(1, lastIndexOf);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testLastIndexOfTaking11And1ReturningPositiveAndLastIndexOfTaking11And10() throws Throwable  {
        // Given an array of shorts with a certain element at index 3
        short[] arg0 = new short[5];
        arg0[3] = (short)3;
        
        // When we search for that element using lastIndexOf method
        int lastIndexOf = ArrayUtils.lastIndexOf(arg0, (short)3, 4);
        
        // Then the method should return the index of that element
        assertEquals(3, lastIndexOf);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testLastIndexOfTaking1And1ReturningZeroAndLastIndexOfTaking1And1AndLastIndexOfTaking1And11() throws Throwable  {
        // Given: an array of shorts containing the number 1160
        short[] arg0 = new short[3];
        arg0[0] = (short)1160;
        
        // When: finding the last index of the element 1160 in the array using ArrayUtils.lastIndexOf() method
        int lastIndexOf = ArrayUtils.lastIndexOf(arg0, (short)1160);
        
        // Then: the last index should be 0, as it is the only occurrence of the element in the array
        assertEquals(0, lastIndexOf);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testLastIndexOfTaking1And1ReturningPositiveAndLastIndexOfTaking1And1AndLastIndexOfTaking1And11() throws Throwable  {
        // Given an array of shorts containing a negative value at index 1
        short[] arg0 = new short[4];
        arg0[1] = (short) (-1);
        
        // When we call ArrayUtils.lastIndexOf() with the negative value as the search key
        int lastIndexOf = ArrayUtils.lastIndexOf(arg0, (short) (-1));
        
        // Then we expect the method to return the index of the first occurrence of the negative value in the array
        assertEquals(1, lastIndexOf);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testLastIndexOfTaking1And1ReturningZeroAndLastIndexOfTaking1And1AndLastIndexOfTaking1And12() throws Throwable  {
        // Given an array of objects and an object to search for
        Object[] arg0 = new Object[1];
        Object arg1 = new Object();
        arg0[0] = arg1;
        
        // When the lastIndexOf method is called with the array and the object
        int lastIndexOf = ArrayUtils.lastIndexOf(arg0, arg1);
        
        // Then the index of the last occurrence of the object in the array should be returned
        assertEquals(0, lastIndexOf);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testLastIndexOfTaking1And1ReturningNegativeAndLastIndexOfTaking1And1AndLastIndexOfTaking1And10() throws Throwable  {
        // Test that the method returns -1 when the element is not found
        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  {
        // rollbacked to evosuite
        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  {
        // Given: an array of longs containing a single element -5L
        long[] arg0 = new long[2];
        arg0[0] = (long) (byte) (-5);
        
        // When: the lastIndexOf method is called with -5L as the argument
        int lastIndexOf = ArrayUtils.lastIndexOf(arg0, (-5L));
        
        // Then: the method should return 0, indicating that -5L was found at index 0 in the array
        assertEquals(0, lastIndexOf);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testLastIndexOfTaking1And1ReturningPositiveAndLastIndexOfTaking1And1AndLastIndexOfTaking1And12() throws Throwable  {
        // Tests the last index of a long array that contains the given element
        // Setup
        long[] arg0 = new long[8];
        arg0[7] = -1611L;
        
        // Expected result
        int expectedResult = 7;
        
        // Actual result
        int actualResult = ArrayUtils.lastIndexOf(arg0, -1611L);
        
        // Assertions
        assertEquals(expectedResult, actualResult);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testLastIndexOfTaking1And2IntsReturningPositive() throws Throwable  {
        // Given a non-empty array of integers, and a target value.
        int[] arg0 = new int[8];
        arg0[3] = -1818;
        
        // When the method lastIndexOf is called with the target value and a starting index.
        int lastIndexOf = ArrayUtils.lastIndexOf(arg0, -1818, 2842);
        
        // Then the method should return the index of the last occurrence of the target value in the array, or -1 if the value is not found.
        assertEquals(3, lastIndexOf);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testLastIndexOfTaking1And1ReturningZeroAndLastIndexOfTaking1And1AndLastIndexOfTaking1And14() throws Throwable  {
        // Arrange
        int[] arr = new int[3];
        arr[0] = -2441;
        
        // Act
        int lastIndexOf = ArrayUtils.lastIndexOf(arr, (-2441));
        
        // Assert
        assertEquals(0, lastIndexOf);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testLastIndexOfTaking1And1ReturningPositiveAndLastIndexOfTaking1And1AndLastIndexOfTaking1And13() throws Throwable  {
        // Given an array of integers and a target value
        int[] arg0 = new int[7];
        arg0[3] = (int) (short) (-23111);
        
        // When calling the lastIndexOf method with the target value
        int lastIndexOf = ArrayUtils.lastIndexOf(arg0, (-23111));
        
        // Then the method should return the index of the last occurrence of the target value in the array
        assertEquals(3, lastIndexOf);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testLastIndexOfTaking11And1ReturningPositiveAndLastIndexOfTaking11And12() throws Throwable  {
        // Given a float array with values ranging from -1 to 1, and an input of -1.0F
        float[] arg0 = new float[8];
        arg0[4] = (float) (-1);
        
        // When the lastIndexOf method is called with this input and a starting index of 1843
        int lastIndexOf = ArrayUtils.lastIndexOf(arg0, (-1.0F), 1843);
        
        // Then the method should return the last index of -1 in the array, which is at position 4
        assertEquals(4, lastIndexOf);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testLastIndexOfTaking1And1ReturningZeroAndLastIndexOfTaking1And1AndLastIndexOfTaking1And15() throws Throwable  {
        // Given an array of floating-point numbers,
        float[] arg0 = new float[1];
        arg0[0] = (float) (byte) (-100);
        
        // When we call lastIndexOf() with the argument -100,
        int lastIndexOf = ArrayUtils.lastIndexOf(arg0, (float) (byte) (-100));
        
        // Then we expect the method to return 0 as the index of the last occurrence of -100 in the array.
        assertEquals(0, lastIndexOf);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testLastIndexOfTaking1And1ReturningPositiveAndLastIndexOfTaking1And1AndLastIndexOfTaking1And14() throws Throwable  {
        // No Comments were added
        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  {
        // Given a double array arg0 containing negative values
        double[] arg0 = new double[] { -1997.9437052250325, -1458.865663082693 };
        
        // When the method ArrayUtils.lastIndexOf is called with the first negative value and a start index of 1520
        int lastIndexOf = ArrayUtils.lastIndexOf(arg0, (-1997.9437052250325), 1520, 1458.865663082693);
        
        // Then the method should return the index of the first negative value in the array
        assertEquals(0, lastIndexOf);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testLastIndexOfTaking1And2DoublesReturningZero() throws Throwable  {
        double[] arg0 = new double[3];
        arg0[0] = (-749.5999999999999); // This is the array that will be searched
        int lastIndexOf = ArrayUtils.lastIndexOf(arg0, (-749.5999999999999), 101.6032); // This is the search value and the index where it should be found
        assertEquals(0, lastIndexOf); // We expect the search value to be found at index 0
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testLastIndexOfTaking1And2DoublesReturningNegative() throws Throwable  {
        // Given a double array with negative values
        double[] arg0 = new double[] {-162.1, -371.0};
        
        // When the last index of a negative value is searched for
        int lastIndexOf = ArrayUtils.lastIndexOf(arg0, (-162.1), (-371.0));
        
        // Then the expected result is returned
        assertEquals((-1), lastIndexOf);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testLastIndexOfTaking1And1ReturningZeroAndLastIndexOfTaking1And1AndLastIndexOfTaking1And16() throws Throwable  {
        // Given: an array of doubles containing a negative value
        double[] arg0 = new double[4];
        arg0[0] = -190.86;
        
        // When: the method ArrayUtils.lastIndexOf is called with the array and the negative value
        int lastIndexOf = ArrayUtils.lastIndexOf(arg0, (-190.86));
        
        // Then: the method should return 0, indicating that the negative value is located at index 0 of the array
        assertEquals(0, lastIndexOf);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testLastIndexOfTaking1And1ReturningPositiveAndLastIndexOfTaking1And1AndLastIndexOfTaking1And15() throws Throwable  {
        // Create a double array with 8 elements
        double[] arg0 = new double[8];
        
        // Set the value of the second element to -1538
        arg0[1] = (double) (-1538);
        
        // Use the lastIndexOf method to find the index of the last occurrence of -1538.0 in the array
        int lastIndexOf = ArrayUtils.lastIndexOf(arg0, (-1538.0));
        
        // Assert that the method returns the correct index (which should be 1)
        assertEquals(1, lastIndexOf);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testLastIndexOfTaking1And1ReturningZeroAndLastIndexOfTaking1And1AndLastIndexOfTaking1And17() throws Throwable  {
        // Given: we have a char array with 5 elements
        char[] arg0 = new char[5];
        arg0[0] = 'A';
        
        // When: we call the lastIndexOf method on this array with an element that appears in it
        int lastIndexOf = ArrayUtils.lastIndexOf(arg0, 'A');
        
        // Then: we expect the result to be 0, since the element 'A' is located at index 0
        assertEquals(0, lastIndexOf);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testLastIndexOfTaking1And1ReturningPositiveAndLastIndexOfTaking1And1AndLastIndexOfTaking1And16() throws Throwable  {
        // Given a character array with 6 elements
        char[] arg0 = new char[6];
        
        // When the last index of the character 'h' is searched for
        int lastIndexOf = ArrayUtils.lastIndexOf(arg0, 'h');
        
        // Then the correct index (1) should be returned
        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  {
        // Given an array with a single element
        byte[] arg0 = new byte[]{(byte) -115};
        
        // When the last index of the element is searched for
        int lastIndexOf = ArrayUtils.lastIndexOf(arg0, (byte) (-115));
        
        // Then the index of the single element should be returned
        assertEquals(0, lastIndexOf);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testIsSameTypeReturningFalse() throws Throwable  {
        // Given: we have two objects, one of type Byte and the other of type Object
        Byte byteArg = new Byte((byte) (-112));
        Object objectArg = new Object();
        
        // When: we check if they are of the same type using ArrayUtils.isSameType() method
        boolean sameType = ArrayUtils.isSameType(byteArg, objectArg);
        
        // Then: we assert that they are not of the same type
        assertFalse(sameType);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testIsEqualsReturningFalse() throws Throwable  {
        // Given
        Object arg1 = new Object();
        Byte arg0 = new Byte((byte) 0);
        
        // When
        boolean equals = ArrayUtils.isEquals(arg0, arg1);
        
        // Then
        assertFalse(equals);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testIndexOfTaking11And1ReturningPositiveAndIndexOfTaking11And1AndIndexOfTaking11And10() throws Throwable  {
        // Given: an array of booleans containing a single element with value "true"
        boolean[] arg0 = new boolean[2];
        arg0[1] = true;
        
        // When: searching for the index of the first "true" element in the array, starting from index -148
        int indexOf = ArrayUtils.indexOf(arg0, true, (-148));
        
        // Then: the method should return the index of the found element, which is 1
        assertEquals(1, indexOf);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testIndexOfTaking1And1ReturningZeroAndIndexOfTaking1And1AndIndexOfTaking1And10() throws Throwable  {
        // Given a boolean array with 5 elements
        boolean[] arr = new boolean[5];
        
        // When we search for the index of the first false element
        int indexOfFalse = ArrayUtils.indexOf(arr, false);
        
        // Then we expect to find the index of the first false element as 0
        assertEquals(0, indexOfFalse);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testIndexOfTaking1And1ReturningPositiveAndIndexOfTaking1And1AndIndexOfTaking1And10() throws Throwable  {
        // Given a boolean array with 6 elements, where the first element is true
        boolean[] arg0 = new boolean[6];
        arg0[0] = true;
        
        // When searching for the first false value in the array
        int indexOf = ArrayUtils.indexOf(arg0, false);
        
        // Then the method should return the index of the first false value (1)
        assertEquals(1, indexOf);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testIndexOfTaking11And1ReturningPositiveAndIndexOfTaking11And1AndIndexOfTaking11And11() throws Throwable  {
        // Create a new short array with 7 elements.
        short[] arg0 = new short[7];
        
        // Initialize the first element to -1.
        arg0[1] = (short) (-1);
        
        // Use ArrayUtils to find the index of -1 in the array.
        int indexOf = ArrayUtils.indexOf(arg0, (short) (-1), (int) (short) (-26214));
        
        // Assert that the index is 1.
        assertEquals(1, indexOf);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testIndexOfTaking1And1ReturningZeroAndIndexOfTaking1And1AndIndexOfTaking1And11() throws Throwable  {
        // Setup
        short[] arg0 = new short[4];
        arg0[0] = (short)1;
        
        // Action
        int indexOf = ArrayUtils.indexOf(arg0, (short)1);
        
        // Assertion
        assertEquals(0, indexOf);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testIndexOfTaking1And1ReturningPositiveAndIndexOfTaking1And1AndIndexOfTaking1And11() throws Throwable  {
        // Given a short array with 7 elements and an element at index 3 equal to 18457
        short[] arg0 = new short[7];
        arg0[3] = (short)18457;
        
        // When the method ArrayUtils.indexOf(arg0, (short)18457) is called with the array and the element to search for
        int indexOf = ArrayUtils.indexOf(arg0, (short)18457);
        
        // Then the method should return the index of the element in the array that matches the given element
        assertEquals(3, indexOf);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testIndexOfTaking1And1ReturningNegativeAndIndexOfTaking1And1AndIndexOfTaking1And10() throws Throwable  {
        // No Comments were added
        int indexOf = ArrayUtils.indexOf((Object[]) null, (Object) null);
        assertEquals((-1), indexOf);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testIndexOfTaking11And1ReturningPositiveAndIndexOfTaking11And1AndIndexOfTaking11And12() throws Throwable  {
        // Given a long array with a value of 2807 at index 0 and a negative value at index 148
        long[] arg0 = new long[9];
        arg0[0] = (long) (short) 2807;
        arg0[148] = -148;
        
        // When the index of the first occurrence of a negative value is searched
        int indexOf = ArrayUtils.indexOf(arg0, (long) (short) 0, (-148));
        
        // Then the method should return the index of the first negative value, which is at index 148
        assertEquals(148, indexOf);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testIndexOfTaking1And1ReturningNegativeAndIndexOfTaking1And1AndIndexOfTaking1And11() throws Throwable  {
        // This test case verifies that the "indexOf" method returns -1 when it cannot find a value in an array.
        // The test uses a long[] array with 8 elements and searches for the value (short)6, which is not present in the array.
        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  {
        // Given a sorted array of integers containing negative numbers
        int[] arg0 = new int[9];
        arg0[0] = (int) (byte) (-71);
        
        // When the method indexOf is called with the sorted array and a negative number as arguments
        int indexOf = ArrayUtils.indexOf(arg0, -71, -71);
        
        // Then the method should return the index of the first occurrence of the negative number in the array
        assertEquals(0, indexOf);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testIndexOfTaking1And1ReturningZeroAndIndexOfTaking1And1AndIndexOfTaking1And12() throws Throwable  {
        // No Comments were added
        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 testIndexOfTaking1And1ReturningPositiveAndIndexOfTaking1And1AndIndexOfTaking1And12() throws Throwable  {
        // Set up the input arguments for the method
        int[] arg0 = new int[4];
        arg0[3] = 213;
        
        // Call the method and get the result
        int indexOf = ArrayUtils.indexOf(arg0, 213);
        
        // Assert that the expected result is returned
        assertEquals(3, indexOf);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testIndexOfTaking11And1ReturningPositiveAndIndexOfTaking11And1AndIndexOfTaking11And13() throws Throwable  {
        // Initialize an array of floats with some values
        float[] arg0 = new float[6];
        arg0[2] = -1595.35F;
        
        // Use the ArrayUtils.indexOf method to find the index of a specific element in the array
        int indexOf = ArrayUtils.indexOf(arg0, (-1595.35F), (-81));
        
        // Assert that the index is 2
        assertEquals(2, indexOf);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testIndexOfTaking1And1ReturningPositiveAndIndexOfTaking1And1AndIndexOfTaking1And13() throws Throwable  {
        // Given: a float array with one element equal to 1.0F
        float[] arg0 = new float[4];
        arg0[1] = 1.0F;
        
        // When: the index of the first occurrence of 1.0F in the array is searched using ArrayUtils.indexOf()
        int indexOf = ArrayUtils.indexOf(arg0, 1.0F);
        
        // Then: the index of the element equal to 1.0F should be returned
        assertEquals(1, indexOf);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testIndexOfTaking1And1ReturningNegativeAndIndexOfTaking1And1AndIndexOfTaking1And12() throws Throwable  {
        // Given: A float array 'arg0' with four elements
        float[] arg0 = new float[4];
        
        // When: The function 'indexOf' is called with 1.0F as an argument
        int indexOf = ArrayUtils.indexOf(arg0, 1.0F);
        
        // Then: The function returns -1, indicating that the element was not found in the array
        assertEquals((-1), indexOf);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testIndexOfTaking11And1ReturningPositiveAndIndexOfTaking11And1AndIndexOfTaking11And14() throws Throwable  {
        // Given a double array with 9 elements
        double[] arg0 = new double[9];
        
        // When the index of (-1243.391) is searched for in the array
        int indexOf = ArrayUtils.indexOf(arg0, (-1243.391), (-1));
        
        // Then the expected value should be 2
        assertEquals(2, indexOf);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testIndexOfTaking1And2DoublesReturningZero() throws Throwable  {
        // Given a double array with 9 elements
        double[] arg0 = new double[9];
        
        // When searching for an element that is present in the array
        int indexOf = ArrayUtils.indexOf(arg0, 90.0, 2493.685);
        
        // Then the method should return the index of the first occurrence of the element
        assertEquals(0, indexOf);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testIndexOfTaking1And2DoublesReturningPositive() throws Throwable  {
        // Initialize an array of doubles with a negative number at index 3
        double[] arg0 = new double[5];
        arg0[3] = (-1332.0);
        
        // Use the ArrayUtils.indexOf method to find the index of the negative number in the array
        int indexOf = ArrayUtils.indexOf(arg0, (-1332.0), 0.0);
        
        // Assert that the index found is equal to 3, which is the index of the negative number in the array
        assertEquals(3, indexOf);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testIndexOfTaking1And1ReturningZeroAndIndexOfTaking1And1AndIndexOfTaking1And13() throws Throwable  {
        // No Comments were added
        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 testIndexOfTaking1And1ReturningPositiveAndIndexOfTaking1And1AndIndexOfTaking1And14() throws Throwable  {
        // Given
        double[] inputArray = new double[2];
        inputArray[1] = (double) (byte) (-104);
        
        // When
        int indexOf = ArrayUtils.indexOf(inputArray, -104.0);
        
        // Then
        assertEquals(1, indexOf);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testIndexOfTaking11And1ReturningPositiveAndIndexOfTaking11And1AndIndexOfTaking11And15() throws Throwable  {
        // Given a char array with an element at index 5
        char[] arg0 = new char[7];
        arg0[5] = ' ';
        
        // When the method is called with the element and starting index -1
        int indexOf = ArrayUtils.indexOf(arg0, ' ', (int) (byte) (-1));
        
        // Then the method returns the index of the element
        assertEquals(5, indexOf);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testIndexOfTaking1And1ReturningPositiveAndIndexOfTaking1And1AndIndexOfTaking1And15() throws Throwable  {
        // Given a char array with 3 elements
        char[] arg0 = new char[3];
        
        // When the character 'T' is searched for in the array
        int indexOf = ArrayUtils.indexOf(arg0, 'T');
        
        // Then the method should return the index of the first occurrence of the character 'T'
        assertEquals(1, indexOf);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testIndexOfTaking11And1ReturningPositiveAndIndexOfTaking11And1AndIndexOfTaking11And16() throws Throwable  {
        // Test that the index of a byte array is correctly identified when searching for a specific value
        // Given an array of bytes with a specific value at a particular index
        byte[] arg0 = new byte[7];
        arg0[4] = (byte)3;
        
        // When the index of the specified value is searched for in the array
        int indexOf = ArrayUtils.indexOf(arg0, (byte)3, (-149));
        
        // Then the expected index should be returned
        assertEquals(4, indexOf);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testIndexOfTaking1And1ReturningZeroAndIndexOfTaking1And1AndIndexOfTaking1And14() throws Throwable  {
        // Given an array of bytes containing a single value -1
        byte[] arg0 = new byte[3];
        arg0[0] = (byte) (-1);
        
        // When the method ArrayUtils.indexOf(arg0, (byte) (-1)) is called with this array as argument
        int indexOf = ArrayUtils.indexOf(arg0, (byte) (-1));
        
        // Then the method should return the index of the first occurrence of -1 in the array
        assertEquals(0, indexOf);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testIndexOfTaking1And1ReturningPositiveAndIndexOfTaking1And1AndIndexOfTaking1And16() throws Throwable  {
        // Given: a byte array with 6 elements
        byte[] arg0 = new byte[6];
        
        // When: the element at index 2 is set to 2
        arg0[2] = (byte)2;
        
        // Then: the method ArrayUtils.indexOf() should return 2, which is the index of the first occurrence of the element 2 in the array
        int indexOf = ArrayUtils.indexOf(arg0, (byte)2);
        assertEquals(2, indexOf);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testCloneTakingBooleanArrayReturningNonEmptyArray() throws Throwable  {
        // Given a boolean array with 2 elements
        boolean[] arg0 = new boolean[2];
        
        // When we clone the array
        boolean[] clone = ArrayUtils.clone(arg0);
        
        // Then we expect the clone to have the same length as the original array
        assertEquals(2, clone.length);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testCloneTakingShortArrayReturningNonEmptyArray() throws Throwable  {
        // Given a short array with 7 elements
        short[] arg0 = new short[7];
        
        // When the clone method is called on this array
        short[] clone = ArrayUtils.clone(arg0);
        
        // Then the cloned array should have a length of 7
        assertEquals(7, clone.length);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testCloneTakingObjectArrayReturningNonEmptyArray() throws Throwable  {
        // Given: we have a byte array with 6 elements
        Byte[] arg0 = new Byte[6];
        
        // When: we call the clone method on this array
        Byte[] clone = ArrayUtils.clone(arg0);
        
        // Then: the returned array is not the same instance as the original array
        assertNotSame(clone, arg0);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testCloneTakingLongArrayReturningNonEmptyArray() throws Throwable  {
        // Given: an array of length 1
        long[] arg0 = new long[1];
        
        // When: the array is cloned
        long[] clone = ArrayUtils.clone(arg0);
        
        // Then: the cloned array has the same length as the original array
        assertEquals(1, clone.length);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testCloneTakingIntArrayReturningNonEmptyArray() throws Throwable  {
        // Create a new array with two elements
        int[] arg0 = new int[2];
        
        // Clone the original array
        int[] clone = ArrayUtils.clone(arg0);
        
        // Assert that the cloned array has the same length as the original array
        assertEquals(2, clone.length);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testCloneTakingDoubleArrayReturningNonEmptyArray() throws Throwable  {
        // Test that the clone method returns a deep copy of the original array
        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  {
        // Given an array of characters arg0
        char[] arg0 = new char[4];
        
        // When we clone the array using ArrayUtils.clone()
        char[] clone = ArrayUtils.clone(arg0);
        
        // Then the length of the cloned array is 4
        assertEquals(4, clone.length);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testCloneTakingByteArrayReturningNonEmptyArray() throws Throwable  {
        // Given: we have a byte array with 4 elements
        byte[] arg0 = new byte[]{1, 2, 3, 4};
        
        // When: we call the clone method on this byte array
        byte[] clone = ArrayUtils.clone(arg0);
        
        // Then: we expect the cloned byte array to have the same length as the original
        assertEquals(4, clone.length);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testAddAllTaking2ShortArraysReturningEmptyArray() throws Throwable  {
        // Given: We have two short arrays with 4 elements each
        short[] arr0 = new short[4];
        short[] arr1 = ArrayUtils.subarray(arr0, (int) (short)1398, (int) (short)0);
        
        // When: We call the addAll method on the second array with itself as an argument
        short[] addedArray = ArrayUtils.addAll(arr1, arr1);
        
        // Then: The returned array should not be the same as the original array
        assertNotSame(addedArray, arr1);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testAddAllTaking2ObjectArraysReturningEmptyArray() throws Throwable  {
        // Given: a list of bytes and a list of bytes
        Byte[] arg1 = new Byte[0];
        Byte[] arg2 = new Byte[0];
        
        // When: we call the addAll method on the first list with the second list as an argument
        Byte[] result = ArrayUtils.addAll(arg1, arg2);
        
        // Then: the result should be a new list that contains all elements from both lists
        assertNotSame(result, arg1);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testAddTaking11And1AndAddTaking11And1AndAddTaking11And1ReturningNonEmptyArray0() throws Throwable  {
        // Given an array of length 1
        short[] arg0 = new short[1];
        
        // When adding a value to the array
        short[] add = ArrayUtils.add(arg0, (int) (short) 0, (short) 0);
        
        // Then the resulting array should have length 2 and contain both values
        assertArrayEquals(new short[] {(short) 0, (short) 0}, add);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testAddTaking11And1AndAddTaking11And1AndAddTaking11And1ReturningNonEmptyArray1() throws Throwable  {
        // Given an empty char array with length 9
        char[] arg0 = new char[9];
        
        // When we add a character at index 6 with the value '8'
        char[] add = ArrayUtils.add(arg0, (int) (short)6, '8');
        
        // Then the returned array should contain the expected characters
        assertArrayEquals(new char[] {'\u0000', '\u0000', '\u0000', '\u0000', '\u0000', '\u0000', '8', '\u0000', '\u0000', '\u0000'}, add);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testRemoveAllTaking1And1ThrowsNullPointerExceptionAndRemoveAllTaking1And11() throws Throwable  {
        int[] arg0 = new int[1];
        // Given: We have an array of integers with a single element.
        // When: We remove all occurrences of null from the array.
        ArrayUtils.removeAll((Object) arg0, (int[]) null);
        
        // Then: An exception should be thrown because null cannot be removed from an array of integers.
        try {
        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  {
        // Arrange
        // Set up the test data
        
        // Act
        // Call the method to be tested with the test data
        boolean notEmpty = ArrayUtils.isNotEmpty((int[]) null);
        
        // Assert
        // Verify that the result is false as expected
        assertFalse(notEmpty);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testIsNotEmptyTakingIntArrayReturningTrue() throws Throwable  {
        // Given an array with 2 elements
        int[] arg0 = new int[2];
        
        // When the method ArrayUtils.isNotEmpty is called on the array
        boolean notEmpty = ArrayUtils.isNotEmpty(arg0);
        
        // Then the result should be true, indicating that the array is not empty
        assertTrue(notEmpty);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testIsEmptyTakingBooleanArrayReturningTrue() throws Throwable  {
        // No Comments were added
        boolean empty = ArrayUtils.isEmpty((boolean[]) null);
        assertTrue(empty);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testIsEmptyTakingBooleanArrayReturningFalse() throws Throwable  {
        // Given an array with one element
        boolean[] arg0 = new boolean[1];
        
        // When the method is called on this array
        boolean empty = ArrayUtils.isEmpty(arg0);
        
        // Then it should return false, indicating that the array is not empty
        assertFalse(empty);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testIsEmptyTakingFloatArrayReturningFalse() throws Throwable  {
        // Given: A non-empty array of floats
        float[] arg0 = new float[]{1.0f};
        
        // When: The method is called with the array
        boolean empty = ArrayUtils.isEmpty(arg0);
        
        // Then: The method returns false, indicating that the array is not empty
        assertFalse(empty);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testIsEmptyTakingFloatArrayWithNull() throws Throwable  {
        // No Comments were added
        boolean empty = ArrayUtils.isEmpty((float[]) null);
        assertTrue(empty);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testIsEmptyTakingFloatArrayWithEmptyArray() throws Throwable  {
        // Given an empty array of floats
        float[] arg0 = new float[0];
        
        // When the "isEmpty" method is called with the array
        boolean empty = ArrayUtils.isEmpty(arg0);
        
        // Then the method should return true, indicating that the array is empty
        assertTrue(empty);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testIsEmptyTakingDoubleArrayWithNull() throws Throwable  {
        // No Comments were added
        boolean empty = ArrayUtils.isEmpty((double[]) null);
        assertTrue(empty);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testIsEmptyTakingDoubleArrayReturningFalse() throws Throwable  {
        // Given: a non-empty array of doubles
        double[] arg0 = new double[] {1.0, 2.0};
        
        // When: the isEmpty method is called with the array
        boolean empty = ArrayUtils.isEmpty(arg0);
        
        // Then: the result should be false
        assertFalse(empty);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testIsEmptyTakingDoubleArrayWithEmptyArray() throws Throwable  {
        // Given: An empty array of doubles
        double[] arg0 = new double[0];
        
        // When: Invoking the method ArrayUtils#isEmpty with the empty array as an argument
        boolean empty = ArrayUtils.isEmpty(arg0);
        
        // Then: The method should return true, indicating that the array is empty
        assertTrue(empty);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testIsEmptyTakingByteArrayReturningFalse() throws Throwable  {
        // given a non-empty array of bytes
        byte[] arg0 = new byte[]{1, 2, 3, 4, 5};
        
        // when the isEmpty method is called with the array
        boolean empty = ArrayUtils.isEmpty(arg0);
        
        // then the result should be false
        assertFalse(empty);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testIsEmptyTakingByteArrayWithNull() throws Throwable  {
        // No Comments were added
        boolean empty = ArrayUtils.isEmpty((byte[]) null);
        assertTrue(empty);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testIsEmptyTakingCharArrayWithNull() throws Throwable  {
        // Test that a null array returns true for isEmpty()
        boolean empty = ArrayUtils.isEmpty((char[]) null);
        assertTrue(empty);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testIsEmptyTakingShortArrayWithNull() throws Throwable  {
        // No Comments were added
        boolean empty = ArrayUtils.isEmpty((short[]) null);
        assertTrue(empty);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testIsEmptyTakingShortArrayReturningFalse() throws Throwable  {
        // Given a non-empty short array
        short[] arg0 = new short[7];
        
        // When we check if the array is empty
        boolean empty = ArrayUtils.isEmpty(arg0);
        
        // Then the result should be false
        assertFalse(empty);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testIsEmptyTakingIntArrayReturningFalse() throws Throwable  {
        // Given: We have an array of integers 'arg0' with length 4
        int[] arg0 = new int[4];
        
        // When: We check if the array is empty using ArrayUtils.isEmpty() method
        boolean empty = ArrayUtils.isEmpty(arg0);
        
        // Then: The array is not empty, so we expect the method to return false
        assertFalse(empty);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testIsEmptyTakingLongArrayWithNull() throws Throwable  {
        // No Comments were added
        boolean empty = ArrayUtils.isEmpty((long[]) null);
        assertTrue(empty);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testIsEmptyTakingObjectArrayReturningFalse() throws Throwable  {
        // Given: A test case where an array of Long values is passed to the ArrayUtils.isEmpty() method
        Long[] testArray = new Long[6];
        boolean expectedResult = false;
        
        // When: The ArrayUtils.isEmpty() method is called with the above array as its argument
        boolean actualResult = ArrayUtils.isEmpty((Object[]) testArray);
        
        // Then: The method returns false, indicating that the array is not empty
        assertEquals(expectedResult, actualResult);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testIsEmptyTakingObjectArrayWithNull() throws Throwable  {
        // Test that isEmpty returns true when passed a null array
        boolean empty = ArrayUtils.isEmpty((Object[]) null);
        assertTrue(empty);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testLastIndexOfTaking11And1AndLastIndexOfTaking11And1AndLastIndexOfTaking11And1ReturningNegative0() throws Throwable  {
        // Given: an array of boolean values with all true values and no false value
        boolean[] arg0 = new boolean[2];
        arg0[0] = true;
        arg0[1] = true;
        
        // When: calling the lastIndexOf method with the array, true as the value to search for, and 2 as the from index
        int lastIndexOf = ArrayUtils.lastIndexOf(arg0, true, 2);
        
        // Then: the result should be -1, indicating that no false value was found
        assertEquals(-1, lastIndexOf);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testLastIndexOfTaking11And1ReturningPositiveAndLastIndexOfTaking11And14() throws Throwable  {
        // This test checks that the last index of false is returned correctly when searching from the beginning of the array.
        boolean[] arg0 = new boolean[2];
        arg0[0] = true;
        arg0[1] = false;
        int lastIndexOf = ArrayUtils.lastIndexOf(arg0, false, 2);
        assertEquals(1, lastIndexOf);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testIndexOfTaking11And1ReturningZeroAndIndexOfTaking11And1AndIndexOfTaking11And10() throws Throwable  {
        // Given a boolean array with 8 elements
        boolean[] arg0 = new boolean[8];
        
        // When the first false element is found using ArrayUtils.indexOf(arg0, false, 0) method
        int indexOf = ArrayUtils.indexOf(arg0, false, 0);
        
        // Then assert that the first false element is located at index 0
        assertEquals(0, indexOf);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testIndexOfTaking11And1WithNullAndIndexOfTaking11And1AndIndexOfTaking11And10() throws Throwable  {
        // Test that the method returns -1 when passed a null array and a valid value
        int expected = -1;
        int actual = ArrayUtils.indexOf((boolean[]) null, true, (-2535));
        assertEquals(expected, actual);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testLastIndexOfTaking11And1AndLastIndexOfTaking11And1AndLastIndexOfTaking11And1ReturningNegative1() throws Throwable  {
        // Given an array of floats containing one element
        float[] arg0 = new float[1];
        
        // When the last index of a negative value is searched for in the array
        int lastIndexOf = ArrayUtils.lastIndexOf(arg0, (-1.0F), 1679);
        
        // Then the method should return -1 as the array does not contain any negative values
        assertEquals((-1), lastIndexOf);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testIndexOfTaking11And1ReturningZeroAndIndexOfTaking11And1AndIndexOfTaking11And11() throws Throwable  {
        // Given: We have a float array with 3 elements
        float[] arg0 = new float[3];
        arg0[0] = (-1595.35F);
        
        // When: We search for the index of a specific value in the array
        int indexOf = ArrayUtils.indexOf(arg0, (-1595.35F), (-81));
        
        // Then: The method should return the index of the first occurrence of the specified value in the array
        assertEquals(0, indexOf);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testIndexOfTaking11And1WithPositiveAndIndexOfTaking11And1AndIndexOfTaking11And10() throws Throwable  {
        // Given an array of floats with a size of 1 and a value of 512.0F
        float[] arg0 = new float[]{512.0F};
        
        // When the indexOf method is called with the float array, 512.0F, and an offset of 4
        int indexOf = ArrayUtils.indexOf(arg0, 512.0F, 4);
        
        // Then the returned value should be -1
        assertEquals(-1, indexOf);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testLastIndexOfTaking4ArgumentsReturningPositive() throws Throwable  {
        // Given a double array with 4 elements
        double[] input = new double[4];
        
        // When we search for the last index of a specific value in the array
        int lastIndex = ArrayUtils.lastIndexOf(input, (double) (byte)2, (int) (byte)2, 2693.0);
        
        // Then we expect the result to be the index of the last occurrence of that value in the array
        assertEquals(2, lastIndex);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testLastIndexOfTaking11And1WithZeroAndLastIndexOfTaking11And1AndLastIndexOfTaking11And10() throws Throwable  {
        // This test case ensures that the last index of a double value 0.0 in an array
        // of doubles is found correctly, even when the double value is represented
        // as a short.
        
        // Arrange
        double[] arg0 = new double[6];
        arg0[0] = (double) (short)1;
        
        // Act
        int lastIndexOf = ArrayUtils.lastIndexOf(arg0, 0.0, (int) (short)0);
        
        // Assert
        assertEquals((-1), lastIndexOf);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testLastIndexOfTaking11And1ReturningZeroAndLastIndexOfTaking11And1AndLastIndexOfTaking11And10() throws Throwable  {
        // Given: An array of doubles and a search value of 0.0
        double[] arg0 = new double[1];
        int expectedResult = 0;
        
        // When: Using the ArrayUtils class to find the last index of the search value in the array
        int actualResult = ArrayUtils.lastIndexOf(arg0, 0.0, Integer.MAX_VALUE);
        
        // Then: The result should be the expected result (i.e., the index of the search value in the array)
        assertEquals(expectedResult, actualResult);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testIndexOfTaking4ArgumentsReturningPositive() throws Throwable  {
        // Given: A double array with -1.0 in the second position
        double[] arg0 = new double[8];
        arg0[0] = (-1.0);
        
        // When: The method ArrayUtils.indexOf is called with the array, 0.0 as the element to search for, and a starting index of 0
        int indexOf = ArrayUtils.indexOf(arg0, 0.0, (int) (byte) (-1), 0.0);
        
        // Then: The method should return 1, which is the index of the second position where the element 0.0 was found in the array
        assertEquals(1, indexOf);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testIndexOfTaking4ArgumentsWithNegativeAndPositive() throws Throwable  {
        // Define an array of doubles that will be used for testing
        double[] arg0 = new double[]{1.234, 5.678, -4567.402540497, 90.123, 1e-3};
        
        // Use the ArrayUtils class to find the index of a value in the array
        int indexOf = ArrayUtils.indexOf(arg0, (-4567.402540497), 2, 4373.0);
        
        // Assert that the method returned -1, indicating that the value was not found in the array
        assertEquals(-1, indexOf);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testIndexOfTaking11And1ReturningZeroAndIndexOfTaking11And1AndIndexOfTaking11And12() throws Throwable  {
        // Given: an array of doubles with one element that is equal to the given value
        double[] arg0 = new double[2];
        arg0[0] = -1243.391;
        
        // When: calling the indexOf method on the array and passing in the given value as a parameter
        int indexOf = ArrayUtils.indexOf(arg0, -1243.391, -1);
        
        // Then: the method should return 0, indicating that the first element of the array is equal to the given value
        assertEquals(0, indexOf);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testIndexOfTaking11And1ReturningNegativeAndIndexOfTaking11And1AndIndexOfTaking11And10() throws Throwable  {
        // Given a byte array with the value 122 at position 0
        double[] arg0 = new double[]{122};
        
        // When we call the indexOf method to find the index of the value 122 in the array
        int indexOf = ArrayUtils.indexOf(arg0, (double) (byte)122, 1);
        
        // Then the result should be -1 as the value is not found
        assertEquals(-1, indexOf);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testLastIndexOfTaking11And1ReturningZeroAndLastIndexOfTaking11And1AndLastIndexOfTaking11And11() throws Throwable  {
        // Given an array of bytes containing negative values
        byte[] arg0 = new byte[4];
        arg0[0] = (byte) -71;
        int lastIndexOf = ArrayUtils.lastIndexOf(arg0, (byte) -71, 2499);
        
        // When the method is called with a negative value as the search key and a start index of 2499
        // Then the method should return the index of the first occurrence of the negative value in the array
        assertEquals(0, lastIndexOf);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testLastIndexOfTaking11And1AndLastIndexOfTaking11And1AndLastIndexOfTaking11And1ReturningNegative2() throws Throwable  {
        // Given a byte array with 4 elements
        byte[] arg0 = new byte[4];
        
        // When the method ArrayUtils.lastIndexOf is called with a negative value and an index greater than the length of the array
        int lastIndexOf = ArrayUtils.lastIndexOf(arg0, (byte) (-71), 2499);
        
        // Then the method should return -1 as there are no elements in the array that match the specified value
        assertEquals((-1), lastIndexOf);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testLastIndexOfTaking11And1WithNullAndLastIndexOfTaking11And1AndLastIndexOfTaking11And10() throws Throwable  {
        // No Comments were added
        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  {
        // rollbacked to evosuite
        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  {
        // Test the behavior of ArrayUtils.indexOf() with a null array and a positive starting position
        int indexOf = ArrayUtils.indexOf((byte[]) null, (byte)22, 1756);
        assertEquals((-1), indexOf);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testLastIndexOfTaking11And1ReturningPositiveAndLastIndexOfTaking11And15() throws Throwable  {
        // Given a character array with some elements and a specific element to search for
        char[] arg0 = new char[8];
        arg0[3] = '\u0000'; // This is the element we want to find the index of
        int expectedIndex = 7; // The expected index of the found element
        
        // When we call the lastIndexOf method with the element and a maximum index value
        int lastIndexOf = ArrayUtils.lastIndexOf(arg0, '\u0000', 512);
        
        // Then the method should return the expected index value
        assertEquals(expectedIndex, lastIndexOf);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testIndexOfTaking11And1ReturningZeroAndIndexOfTaking11And1AndIndexOfTaking11And14() throws Throwable  {
        // Given a char array containing the character '|'
        char[] arg0 = new char[2];
        arg0[0] = '|';
        
        // When searching for the character '|' with an offset of -100
        int indexOf = ArrayUtils.indexOf(arg0, '|', (int) (byte) (-100));
        
        // Then the method should return 0, since the offset is negative and it should start searching from the end of the array
        assertEquals(0, indexOf);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testIndexOfTaking11And1AndIndexOfTaking11And1AndIndexOfTaking11And1ReturningNegative0() throws Throwable  {
        // Given an array of characters arg0 and a character '|'
        char[] arg0 = new char[5];
        int indexOf = ArrayUtils.indexOf(arg0, '|', 1068);
        
        // When searching for the index of '|' in the array starting from index 1068
        assertEquals((-1), indexOf);
        
        // Then the method should return -1 as the character is not found in the array
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testIndexOfTaking11And1AndIndexOfTaking11And1AndIndexOfTaking11And1ReturningNegative1() throws Throwable  {
        // Given: An array of shorts with 7 elements and a target value of -1.
        short[] arg0 = new short[7];
        
        // When: The index of the target value is searched using ArrayUtils.indexOf().
        int indexOf = ArrayUtils.indexOf(arg0, (short) (-1), (int) (short) (-26214));
        
        // Then: The method should return -1 as the target value is not present in the array.
        assertEquals((-1), indexOf);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testIndexOfTaking11And1WithPositiveAndIndexOfTaking11And1AndIndexOfTaking11And11() throws Throwable  {
        // Arrange
        short[] arg0 = new short[8];
        
        // Act
        int indexOf = ArrayUtils.indexOf(arg0, (short)32, (int) (short)512);
        
        // Assert
        assertEquals(-1, indexOf);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testIndexOfTaking11And1WithNullAndIndexOfTaking11And1AndIndexOfTaking11And12() throws Throwable  {
        // No Comments were added
        int indexOf = ArrayUtils.indexOf((short[]) null, (short)0, 569);
        assertEquals((-1), indexOf);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testLastIndexOfTaking1And2IntsWithNegativeAndPositive() throws Throwable  {
        // This test case verifies that the lastIndexOf method returns -1 when the search value is negative.
        
        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  {
        // Given: an array of integers with 7 elements, and a value to search for (2)
        int[] arg0 = new int[7];
        arg0[1] = 2;
        
        // When: searching for the index of the specified value in the array
        int indexOf = ArrayUtils.indexOf(arg0, 2, (int) (short) 0);
        
        // Then: the method should return the index of the first occurrence of the value (1)
        assertEquals(1, indexOf);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testIndexOfTaking1And2IntsWithPositive() throws Throwable  {
        // Given an array of integers
        int[] arg0 = new int[8];
        
        // When the index of a specific value is searched for
        int indexOf = ArrayUtils.indexOf(arg0, 1, 8);
        
        // Then the method should return -1
        assertEquals((-1), indexOf);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testIndexOfTaking1And2IntsWithNull() throws Throwable  {
        // rollbacked to evosuite
        int indexOf = ArrayUtils.indexOf((int[]) null, 32, (-5542));
        assertEquals((-1), indexOf);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testLastIndexOfTaking11And1WithNegativeAndLastIndexOfTaking11And1AndLastIndexOfTaking11And10() throws Throwable  {
        // Test the lastIndexOf method with a negative value as the target and a non-empty array of longs.
        long[] arg0 = new long[3];
        int lastIndexOf = ArrayUtils.lastIndexOf(arg0, (-1797L), 1302);
        assertEquals((-1), lastIndexOf);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testIndexOfTaking11And1WithNegative() throws Throwable  {
        // Given: an array of longs, and a value to search for
        long[] arg0 = new long[]{147, -2254};
        int indexOf = ArrayUtils.indexOf(arg0, 147L, (-2254));
        
        // When: the value is searched in the array using the ArrayUtils.indexOf method
        
        // Then: the expected result should be returned (in this case -1)
        assertEquals((-1), indexOf);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testIndexOfTaking11And1WithPositive() throws Throwable  {
        // Given: An array of long values and a byte value
        long[] arg0 = new long[8];
        int indexOf = ArrayUtils.indexOf(arg0, (long) (byte) 110, 3015);
        
        // When: The method indexOf is called with the array, the byte value, and a starting index of 3015
        
        // Then: The expected result should be -1, as the byte value 110 is not present in the array
        assertEquals(-1, indexOf);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testIndexOfTaking11And1WithNullAndIndexOfTaking11And1AndIndexOfTaking11And13() throws Throwable  {
        // No Comments were added
        int indexOf = ArrayUtils.indexOf((long[]) null, 1490L, 2550);
        assertEquals((-1), indexOf);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testLastIndexOfTaking11And1ReturningPositiveAndLastIndexOfTaking11And16() throws Throwable  {
        // Given an array of objects and a search element
        Object[] arg0 = new Object[2];
        int searchElement = (int) 'a';
        
        // When we use the lastIndexOf method to find the index of the search element in the array
        int lastIndexOf = ArrayUtils.lastIndexOf(arg0, searchElement);
        
        // Then we expect the index of the search element to be 1
        assertEquals(1, lastIndexOf);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testIndexOfTaking11And1ReturningPositiveAndIndexOfTaking11And1AndIndexOfTaking11And17() throws Throwable  {
        // rollbacked to evosuite
        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 testIndexOfTaking11And1ReturningZero() throws Throwable  {
        // This test verifies the correctness of the ArrayUtils.indexOf() method when searching for a null value in an array with several elements.
        // Set up the test data: an array with five elements, where one element is null.
        Object[] arg0 = new Object[5];
        arg0[1] = null;
        
        // Call the method to be tested with the test data.
        int indexOf = ArrayUtils.indexOf(arg0, (Object) null, (-1));
        
        // Verify that the method returns the correct value.
        assertEquals(0, indexOf);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testIndexOfTaking11And1WithNullAndIndexOfTaking11And1AndIndexOfTaking11And14() throws Throwable  {
        // The argument used to search for in the array is an instance of the Object class.
        Object arg1 = new Object();
        
        // The returned index should be -1 because the array is null and there is no match for the argument.
        int indexOf = ArrayUtils.indexOf((Object[]) null, arg1, (-1));
        assertEquals((-1), indexOf);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testReverseTaking1And2IntsWithEmptyArrayAndPositive() throws Throwable  {
        // Given an empty short array
        short[] arg0 = new short[0];
        
        // When we reverse it with a start and end index of 4 and 2
        ArrayUtils.reverse(arg0, 4, 2);
        
        // Then the result should be an empty short array
        assertArrayEquals(new short[] {}, arg0);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testReverseTaking1And2IntsWithPositiveAndZero() throws Throwable  {
        // Given
        Object[] input = new Object[5];
        
        // When
        ArrayUtils.reverse(input, 1310, 0);
        
        // Then
        assertEquals(5, input.length);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testReverseTaking1And2IntsWithNegativeAndPositive0() throws Throwable  {
        // No Comments were added
        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  {
        // Initialize the array to be reversed
        int[] arg0 = new int[2];
        // Set the expected result
        int[] expectedResult = new int[] {0, 0};
        // Reverse the array with a negative start index
        ArrayUtils.reverse(arg0, (int) (byte)96, (-2230));
        // Assert that the reversed array is equal to the expected result
        assertArrayEquals(expectedResult, arg0);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testReverseTaking1And2IntsWithNegativeAndReverseTaking1And2IntsAndReverseTaking1And2Ints1() throws Throwable  {
        // Given: We have an array of floats "arg0" with length 0
        float[] arg0 = new float[0];
        
        // When: We call the method ArrayUtils.reverse() on "arg0" with a start index of 4 and an end index of (-703)
        ArrayUtils.reverse(arg0, 4, (-703));
        
        // Then: The length of "arg0" should be equal to 0
        assertEquals(0, arg0.length);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testReverseTaking1And2IntsWithZeroAndPositive() throws Throwable  {
        // Given a double array of length 4
        double[] input = new double[4];
        
        // When we reverse the array
        ArrayUtils.reverse(input, 0, 121);
        
        // Then the reversed array should be an empty array
        assertArrayEquals(new double[] {0.0, 0.0, 0.0, 0.0}, input, 0.01);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testReverseTaking1And2IntsWithPositiveAndNegative0() throws Throwable  {
        // Given an array of characters
        char[] arg0 = new char[9];
        
        // And a negative start index
        int start = (short)1;
        
        // And a negative end index
        int end = -102;
        
        // When the reverse method is called with the array and indices
        ArrayUtils.reverse(arg0, start, end);
        
        // Then the resulting array should be empty
        assertArrayEquals(new char[] {'\u0000', '\u0000', '\u0000', '\u0000', '\u0000', '\u0000', '\u0000', '\u0000', '\u0000'}, arg0);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testReverseTaking1And2IntsAndReverseTaking1And2Ints0() throws Throwable  {
        // Given: a small array of bytes to be reversed
        byte[] input = new byte[2];
        
        // When: the reverse method is called on the array
        ArrayUtils.reverse(input, 10, 100);
        
        // Then: the array should be unchanged
        assertArrayEquals(new byte[] {(byte)0, (byte)0}, input);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testReverseTaking1And2IntsWithNonEmptyArrayAndZero() throws Throwable  {
        // Given: A boolean array with 3 elements
        boolean[] input = new boolean[3];
        
        // When: The array is reversed using ArrayUtils.reverse() method
        ArrayUtils.reverse(input, (int) (byte)0, (int) (byte)68);
        
        // Then: The resulting array should be {false, false, false}
        assertTrue(Arrays.equals(new boolean[] {false, false, false}, input));
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testGetLengthThrowsIllegalArgumentException() throws Throwable  {
        // No Comments were added
        // Undeclared exception!
        try { 
          ArrayUtils.getLength("Hello World");
          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  {
        // No Comments were added
        int length = ArrayUtils.getLength((Object) null);
        assertEquals(0, length);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testCloneTakingBooleanArrayReturningNull() throws Throwable  {
        // Test that a clone of null returns null
        boolean[] clone = ArrayUtils.clone((boolean[]) null);
        assertNull(clone);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testCloneTakingBooleanArrayReturningEmptyArray() throws Throwable  {
        // Given: an array of booleans
        boolean[] arg0 = new boolean[]{true, false, true};
        
        // When: cloning the array
        boolean[] clone = ArrayUtils.clone(arg0);
        
        // Then: the cloned array should not be the same object as the original array
        assertNotSame(clone, arg0);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testCloneTakingFloatArrayReturningNull() throws Throwable  {
        // No Comments were added
        float[] clone = ArrayUtils.clone((float[]) null);
        assertNull(clone);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testCloneTakingFloatArrayReturningNonEmptyArray() throws Throwable  {
        // Given an array of floats with length 6
        float[] arg0 = new float[6];
        
        // When the array is cloned
        float[] clone = ArrayUtils.clone(arg0);
        
        // Then the cloned array has the same length as the original array
        assertEquals(6, clone.length);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testCloneTakingDoubleArrayReturningEmptyArray() throws Throwable  {
        // Given an empty array
        double[] arg0 = new double[0];
        
        // When we clone the array using ArrayUtils.clone(arg0)
        double[] clone = ArrayUtils.clone(arg0);
        
        // Then the returned array should have a length of 0
        assertEquals(0, clone.length);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testCloneTakingByteArrayReturningNull() throws Throwable  {
        // No Comments were added
        byte[] clone = ArrayUtils.clone((byte[]) null);
        assertNull(clone);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testCloneTakingCharArrayReturningNull() throws Throwable  {
        // No Comments were added
        char[] clone = ArrayUtils.clone((char[]) null);
        assertNull(clone);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testCloneTakingShortArrayReturningEmptyArray() throws Throwable  {
        // Given: A short array with zero elements
        short[] original = new short[0];
        
        // When: The array is cloned
        short[] clone = ArrayUtils.clone(original);
        
        // Then: The clone should not be the same as the original array
        assertNotSame(clone, original);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testCloneTakingShortArrayReturningNull() throws Throwable  {
        // No Comments were added
        short[] clone = ArrayUtils.clone((short[]) null);
        assertNull(clone);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testCloneTakingIntArrayReturningEmptyArray() throws Throwable  {
        // Given an array of length 0
        int[] arg0 = new int[0];
        
        // When the method is called on this array
        int[] clone = ArrayUtils.clone(arg0);
        
        // Then the returned array should have a length of 0
        assertEquals(0, clone.length);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testCloneTakingIntArrayReturningNull() throws Throwable  {
        // Given: The input array is null
        int[] inputArray = null;
        
        // When: We call the method ArrayUtils.clone() with the null input array
        int[] clone = ArrayUtils.clone((int[]) inputArray);
        
        // Then: The method should return a null value
        assertNull(clone);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testCloneTakingLongArrayReturningNull() throws Throwable  {
        // This test is checking that cloning a null array returns null
        long[] clone = ArrayUtils.clone((long[]) null);
        assertNull(clone);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testCloneTakingLongArrayReturningEmptyArray() throws Throwable  {
        // Test that the method clones an empty long array correctly
        long[] arg0 = new long[0];
        long[] clone = ArrayUtils.clone(arg0);
        assertArrayEquals(new long[] {}, clone);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testCloneTakingObjectArrayReturningEmptyArray() throws Throwable  {
        // Given an empty byte array
        Byte[] arg0 = new Byte[0];
        
        // When cloning the array
        Byte[] clone = ArrayUtils.clone(arg0);
        
        // Then the clone is not the same as the original array
        assertNotSame(arg0, clone);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testCloneTakingObjectArrayReturningNull() throws Throwable  {
        // Test that cloning a null array returns null
        Byte[] clone = ArrayUtils.clone((Byte[]) null);
        assertNull(clone);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testToStringTaking2ArgumentsReturningEmptyString() throws Throwable  {
        // Test that the toString method returns an empty string when given an array with a null element
        String string = ArrayUtils.toString((Object) "", (String) null);
        assertEquals("", string);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testIndexOfTaking1And1ReturningNegativeAndIndexOfTaking1And1AndIndexOfTaking1And13() throws Throwable  {
        // Given: A boolean array with four elements and a matching element
        boolean[] arg0 = new boolean[4];
        
        // When: The index of the matching element is determined
        int indexOf = ArrayUtils.indexOf(arg0, true);
        
        // Then: The index should be -1, indicating that no matching element was found
        assertEquals((-1), indexOf);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testIndexOfTaking1And1ReturningNegativeAndIndexOfTaking1And1AndIndexOfTaking1And14() throws Throwable  {
        // Given: A byte array with three elements
        byte[] arg0 = new byte[3];
        
        // When: We call the "indexOf" method on the array to find the index of a value that does not exist
        int indexOf = ArrayUtils.indexOf(arg0, (byte) (-1));
        
        // Then: The method should return -1 since the value does not exist in the array
        assertEquals((-1), indexOf);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testRemoveTaking1And1ReturningEmptyArrayAndRemoveTaking1And1AndRemoveTaking1And13() throws Throwable  {
        // Given: an array of length one with a value at index zero
        long[] arg0 = new long[1];
        arg0[0] = 1L;
        
        // When: the remove method is called with index zero
        long[] remove = ArrayUtils.remove(arg0, 0);
        
        // Then: the returned array should have a length of zero
        assertEquals(0, remove.length);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testRemoveTaking1And1AndRemoveTaking1And1AndRemoveTaking1And1ReturningNonEmptyArray0() throws Throwable  {
        // Given: An array of integers with a size of 4
        int[] arg0 = new int[4];
        
        // When: The element at index 1 is removed from the array
        int[] remove = ArrayUtils.remove(arg0, 1);
        
        // Then: The resulting array should have a length of 3
        assertEquals(3, remove.length);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testIndexOfTaking1And1ReturningNegativeAndIndexOfTaking1And1AndIndexOfTaking1And15() throws Throwable  {
        // Given an array of doubles, arg0, with 4 elements
        double[] arg0 = new double[4];
        
        // When the element to find is not present in the array
        int indexOf = ArrayUtils.indexOf(arg0, 103.0);
        
        // Then the method should return -1
        assertEquals(-1, indexOf);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testRemoveAllTaking1And1ReturningNonEmptyArrayAndRemoveAllTaking1And1AndRemoveAllTaking1And15() throws Throwable  {
        // Given a list of 9 Byte objects and an empty int array
        Byte[] arg0 = new Byte[9];
        int[] arg1 = new int[0];
        
        // When the method removeAll is called with these arguments
        Byte[] removedObjects = ArrayUtils.removeAll(arg0, arg1);
        
        // Then the resulting list should have a length of 9
        assertEquals(9, removedObjects.length);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testRemoveAllTaking1And1ReturningNonEmptyArrayAndRemoveAllTaking1And1AndRemoveAllTaking1And16() throws Throwable  {
        // Given two arrays of floats and integers
        float[] arg0 = new float[6];
        int[] arg1 = new int[3];
        
        // When the removeAll method is called on these arrays
        float[] removeAll = ArrayUtils.removeAll(arg0, arg1);
        
        // Then the resulting array should have 5 elements
        assertEquals(5, removeAll.length);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testRemoveAllTaking1And1ThrowsIndexOutOfBoundsException0() throws Throwable  {
        // rollbacked to evosuite
        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  {
        // rollbacked to evosuite
        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  {
        // Given two arrays of booleans, arg0 and arg1
        boolean[] arg0 = new boolean[8];
        arg0[1] = true;
        boolean[] arg1 = new boolean[8];
        
        // When the removeElements method is called with these arguments
        boolean[] removeElements = ArrayUtils.removeElements(arg0, arg1);
        
        // Then the resulting array should contain one element (true) and it should be equal to the expected result (new boolean[] {true})
        assertEquals(1, removeElements.length);
        assertTrue(Arrays.equals(new boolean[] {true}, removeElements));
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testRemoveElementsTaking2BooleanArraysWithEmptyArray() throws Throwable  {
        // Given a boolean array of size 11 and an empty boolean array
        boolean[] arg0 = new boolean[11];
        boolean[] arg1 = ArrayUtils.EMPTY_BOOLEAN_ARRAY;
        
        // When the removeElements method is called with these arguments
        boolean[] result = ArrayUtils.removeElements(arg0, arg1);
        
        // Then the length of the result array should be 11
        assertEquals(11, result.length);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testRemoveElementsTaking2BooleanArraysReturningNull() throws Throwable  {
        // No Comments were added
        boolean[] removeElements = ArrayUtils.removeElements((boolean[]) null, (boolean[]) null);
        assertNull(removeElements);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testRemoveElementsTaking2DoubleArrays0() throws Throwable  {
        // Given two arrays with different lengths
        double[] array1 = new double[4];
        double[] array2 = new double[7];
        
        // When we remove elements from the first array using ArrayUtils.removeElements
        double[] result = ArrayUtils.removeElements(array1, array2);
        
        // Then the length of the resulting array should be 0
        assertEquals(0, result.length);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testRemoveElementsTaking2DoubleArrays1() throws Throwable  {
        // Given: A double array with three elements
        double[] arg1 = new double[3];
        
        // When: Removing all elements from the array using ArrayUtils.removeElements() method
        double[] removeElements = ArrayUtils.removeElements(arg1, arg1);
        
        // Then: The resulting array should be empty
        assertEquals(0, removeElements.length);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testRemoveElementsTaking2DoubleArraysReturningNonEmptyArray() throws Throwable  {
        // Given an array of doubles and a null input for the elements to be removed
        double[] arg0 = new double[1];
        double[] removeElements = ArrayUtils.removeElements(arg0, (double[]) null);
        
        // When the method is called with the given inputs
        
        // Then the method should not return a null value
        assertNotNull(removeElements);
        
        // And the length of the returned array should be equal to the length of the input array
        assertEquals(1, removeElements.length);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testRemoveElementsTaking2DoubleArraysReturningNull() throws Throwable  {
        // No Comments were added
        double[] removeElements = ArrayUtils.removeElements((double[]) null, (double[]) null);
        assertNull(removeElements);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testRemoveElementsTaking2FloatArraysWithNonEmptyArray() throws Throwable  {
        // No Comments were added
        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  {
        // No Comments were added
        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  {
        // Given an array of floats with 5 elements
        float[] arg0 = new float[5];
        
        // When we remove all null values from the array
        float[] removeElements = ArrayUtils.removeElements(arg0, (float[]) null);
        
        // Then the resulting array should have a length of 5 and not contain any null values
        assertEquals(5, removeElements.length);
        assertNotNull(removeElements);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testRemoveElementsTaking2FloatArraysReturningNull() throws Throwable  {
        // Test that passing null arrays to removeElements returns null
        float[] actual = ArrayUtils.removeElements((float[]) null, (float[]) null);
        assertNull(actual);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testRemoveElementsTaking2LongArraysReturningNonEmptyArray() throws Throwable  {
        // Create two arrays of longs with different lengths
        long[] arg0 = new long[11];
        long[] arg1 = new long[8];
        
        // Populate the second array with a value that will be removed
        arg1[2] = 56L;
        
        // Remove elements from the first array based on the values in the second array
        long[] removeElements = ArrayUtils.removeElements(arg0, arg1);
        
        // Assert that the length of the resulting array is correct
        assertEquals(4, removeElements.length);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testRemoveElementsTaking2LongArraysReturningEmptyArray() throws Throwable  {
        // Given an array of 11 long values
        long[] input = new long[11];
        
        // When we remove all elements from the array
        long[] output = ArrayUtils.removeElements(input, input);
        
        // Then the resulting array should have a length of 0
        assertEquals(0, output.length);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testRemoveElementsTaking2LongArraysWithEmptyArray() throws Throwable  {
        // Given an array of length 7 and an empty array as the elements to be removed
        long[] arg0 = new long[]{1, 2, 3, 4, 5, 6, 7};
        long[] arg1 = new long[0];
        
        // When we call the removeElements method with these arguments
        long[] result = ArrayUtils.removeElements(arg0, arg1);
        
        // Then the resulting array should have a length of 7
        assertEquals(7, result.length);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testRemoveElementsTaking2CharArrays0() throws Throwable  {
        // Test that removing elements from two empty arrays results in an empty array
        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  {
        // Given
        char[] originalArray = new char[8];
        char[] elementsToRemove = new char[0];
        
        // When
        char[] result = ArrayUtils.removeElements(originalArray, elementsToRemove);
        
        // Then
        assertEquals(8, result.length);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testRemoveElementsTaking2CharArrays1() throws Throwable  {
        // Create a new array of size 3
        char[] input = new char[3];
        
        // Remove all elements from the array
        char[] expectedOutput = ArrayUtils.removeElements(input, input);
        
        // Assert that the output array is empty
        assertEquals(0, expectedOutput.length);
    }
  
    @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];
        arg1[0] = (-1); // element to remove
        int[] removeElements = ArrayUtils.removeElements(arg0, arg1);
        assertArrayEquals(new int[] {(-1459), (-1854), (-1837)}, removeElements);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testRemoveElementsTaking2IntArraysReturningEmptyArray() throws Throwable  {
        // Given: an empty array and a null input
        int[] arg1 = new int[4];
        int[] removeElements = null;
        
        // When: the removeElements method is called with a null input
        removeElements = ArrayUtils.removeElements(arg1, removeElements);
        
        // Then: the output should be an empty array
        assertEquals(0, removeElements.length);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testRemoveElementsTaking2IntArraysReturningNull() throws Throwable  {
        // No Comments were added
        int[] removeElements = ArrayUtils.removeElements((int[]) null, (int[]) null);
        assertNull(removeElements);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testRemoveElementsTaking2ShortArrays0() throws Throwable  {
        // Given two arrays of short integers
        short[] arg0 = new short[5];
        short[] arg1 = new short[9];
        
        // When we remove the common elements from both arrays
        short[] removeElements = ArrayUtils.removeElements(arg0, arg1);
        
        // Then the result array should have a length of zero
        assertEquals(0, removeElements.length);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testRemoveElementsTaking2ShortArrays1() throws Throwable  {
        short[] arg1 = new short[6]; // input array
        short[] expectedResult = new short[0]; // empty output array
        
        // Act
        short[] result = ArrayUtils.removeElements(arg1, arg1);
        
        // Assert
        assertEquals(expectedResult, result); // check if the resulting array is empty
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testRemoveElementsTaking2ShortArraysReturningNull() throws Throwable  {
        // Test that passing null arrays to removeElements() returns null
        short[] removeElements = ArrayUtils.removeElements((short[]) null, (short[]) null);
        assertNull(removeElements);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testRemoveElementsTaking2ByteArrays0() throws Throwable  {
        // Given two byte arrays with different lengths
        byte[] array1 = new byte[8];
        byte[] array2 = new byte[9];
        
        // When the removeElements method is called on these arrays
        byte[] result = ArrayUtils.removeElements(array1, array2);
        
        // Then the result should have a length of 0
        assertEquals(0, result.length);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testRemoveElementsTaking2ByteArrays1() throws Throwable  {
        // Given: An empty array of bytes
        byte[] arg1 = new byte[0];
        
        // When: The method is called with the empty array
        byte[] removeElements = ArrayUtils.removeElements(arg1, arg1);
        
        // Then: The returned array should be an empty array
        assertEquals(0, removeElements.length);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testRemoveElementsTaking2ObjectArrays0() throws Throwable  {
        // Given: Two arrays with different lengths
        Byte[] arrayA = new Byte[5];
        Byte[] arrayB = new Byte[8];
        
        // When: We call the removeElements method with these two arrays as arguments
        Byte[] result = ArrayUtils.removeElements(arrayA, arrayB);
        
        // Then: The result should be an empty array
        assertEquals(0, result.length);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testRemoveElementsTaking2ObjectArraysReturningNonEmptyArray() throws Throwable  {
        // Given two arrays of bytes with different lengths
        Byte[] arg0 = new Byte[4];
        Byte[] arg1 = new Byte[0];
        
        // When we remove elements from the first array using ArrayUtils.removeElements method
        Byte[] removeElements = ArrayUtils.removeElements(arg0, arg1);
        
        // Then the resulting array should have a length of 4, as it contains all the elements from the original array
        assertEquals(4, removeElements.length);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testRemoveTaking1And1ThrowsIndexOutOfBoundsExceptionAndRemoveTaking1And10() throws Throwable  {
        // No Comments were added
        // 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 testRemoveElementTaking1And1ReturningNonEmptyArrayAndRemoveElementTaking1And11() throws Throwable  {
        // Given an array of shorts
        short[] arg0 = new short[7];
        
        // When an element is removed from the array
        short[] removeElement = ArrayUtils.removeElement(arg0, (short)1035);
        
        // Then the removed element should be replaced with zeros
        assertArrayEquals(new short[] {(short)0, (short)0, (short)0, (short)0, (short)0, (short)0}, removeElement);
        
        // And the original array should be unchanged
        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 testRemoveElementTaking1And1ReturningNullAndRemoveElementTaking1And1AndRemoveElementTaking1And13() throws Throwable  {
        // Test that removing an element from a null array returns null
        int[] removeElement = ArrayUtils.removeElement((int[]) null, 23);
        assertNull(removeElement);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testRemoveElementTaking1And1ReturningNonEmptyArrayAndRemoveElementTaking1And12() throws Throwable  {
        // Given a float array with two elements
        float[] arg0 = new float[2];
        
        // When we remove the element at index 0
        float[] removeElement = ArrayUtils.removeElement(arg0, (float) (short) 0);
        
        // Then the length of the resulting array should be 1
        assertEquals(1, removeElement.length);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testRemoveElementTaking1And1ReturningNullAndRemoveElementTaking1And1AndRemoveElementTaking1And14() throws Throwable  {
        // Test that removing an element from a null array returns null
        char[] removeElement = ArrayUtils.removeElement((char[]) null, '*');
        assertNull(removeElement);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testRemoveElementTaking1And1ReturningNonEmptyArrayAndRemoveElementTaking1And13() throws Throwable  {
        // Test that removing an element from a character array works correctly
        char[] inputArray = new char[3];
        inputArray[0] = 'a';
        char[] expectedOutput = new char[] {'\u0000', '\u0000'};
        char[] actualOutput = ArrayUtils.removeElement(inputArray, 'a');
        assertArrayEquals(expectedOutput, actualOutput);
        
        // Test that the input array is not modified by the removeElement method
        assertArrayEquals(new char[] {'a', '\u0000', '\u0000'}, inputArray);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testRemoveElementTaking1And1ReturningNullAndRemoveElementTaking1And1AndRemoveElementTaking1And15() throws Throwable  {
        // Test that passing a null array to removeElement() returns null
        byte[] removeElement = ArrayUtils.removeElement((byte[]) null, (byte) 54);
        assertNull(removeElement);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testRemoveElementTaking1And1ReturningNullAndRemoveElementTaking1And1AndRemoveElementTaking1And16() throws Throwable  {
        // Test that removing an element from a null array returns null
        boolean[] removeElement = ArrayUtils.removeElement((boolean[]) null, true);
        assertNull(removeElement);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testRemoveElementTaking1And1ReturningEmptyArrayAndRemoveElementTaking1And15() throws Throwable  {
        // Given: A boolean array with one element set to false.
        boolean[] arg0 = new boolean[1];
        arg0[0] = false;
        
        // When: The element is removed from the array using ArrayUtils.removeElement method.
        boolean[] removeElement = ArrayUtils.removeElement(arg0, false);
        
        // Then: The resulting array should have zero length.
        assertEquals(0, removeElement.length);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testAddTaking11And1WithNonEmptyArrayAndNegative() throws Throwable  {
        // Setup
        Byte[] arg0 = new Byte[1];
        Byte arg2 = new Byte((byte) (-11));
        
        // Test
        try {
        ArrayUtils.add(arg0, (int)  (-11), arg2);
        fail("Expecting exception: IndexOutOfBoundsException");
        } catch(IndexOutOfBoundsException e) {
        // Verify exception
        verifyException("org.apache.commons.lang3.ArrayUtils", e);}
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testAddTaking11And1WithNullAndPositive() throws Throwable  {
        // Given
        Byte arg2 = new Byte((byte) 2);
        
        // When
        try {
        ArrayUtils.add(null, Integer.MAX_VALUE, arg2);
        
        // Then
        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 testAddTaking11And1AndAddTaking11And1AndAddTaking11And1ReturningNonEmptyArray2() throws Throwable  {
        // Given an array of bytes with two elements
        Byte[] arg0 = new Byte[2];
        
        // When we add a new element to the end of the array using ArrayUtils.add()
        Byte[] add = ArrayUtils.add(arg0, 2, (Byte) null);
        
        // Then the length of the resulting array should be three
        assertEquals(3, add.length);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testAddTaking11And1ThrowsIllegalArgumentException() throws Throwable  {
        // Test that an exception is thrown when adding a negative value to an array
        try {
        ArrayUtils.add((Byte[]) null, (-1241), (Byte) null);
        fail("Expecting exception: IllegalArgumentException");
        } catch(IllegalArgumentException e) {
        // Verify that the correct exception is thrown
        verifyException("org.apache.commons.lang3.ArrayUtils", e);}
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testAddTaking1And1() throws Throwable  {
        // Given: We have a Byte array that contains negative values
        Byte[] testArray = new Byte[] { (byte) -47 };
        
        // When: We call the ArrayUtils.add method with null as the first argument and a Byte object as the second argument
        Byte arg1 = new Byte((byte) (-47));
        Byte[] add = ArrayUtils.add((Byte[]) null, arg1);
        
        // Then: The method should return an array with one element that is equal to the original Byte object
        assertEquals(1, add.length);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testAddTaking1And1WithEmptyArray() throws Throwable  {
        // Given: We have a Byte array with length 0 and want to add a null element to it.
        // When: We use the ArrayUtils.add() method to add the null element to the Byte array.
        // Then: The resulting Byte array should have a length of 1, as the null element is added successfully.
        Byte[] arg0 = new Byte[0];
        Byte[] addedElement = ArrayUtils.add(arg0, (Byte) null);
        assertEquals(1, addedElement.length);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testAddTaking1And1ThrowsIllegalArgumentException() throws Throwable  {
        // No Comments were added
        // 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  {
        // Given an array of doubles
        double[] input = new double[2];
        
        // When the addAll method is called with null as an argument
        double[] addedValues = ArrayUtils.addAll(input, (double[]) null);
        
        // Then the result should not be null
        assertNotNull(addedValues);
        
        // And the length of the result should be equal to the input array's length
        assertEquals(2, addedValues.length);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testAddAllTaking2DoubleArraysReturningNull() throws Throwable  {
        // Test that the method returns null when called with null arguments
        double[] result = ArrayUtils.addAll((double[]) null, (double[]) null);
        assertNull(result);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testAddAllTaking2FloatArraysReturningNonEmptyArray() throws Throwable  {
        // Given an array of floats and a null array to be added
        float[] arg0 = new float[5];
        
        // When the addAll method is called with the null array
        float[] addAll = ArrayUtils.addAll(arg0, (float[]) null);
        
        // Then the result should not be null and have a length of 5
        assertNotNull(addAll);
        assertEquals(5, addAll.length);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testAddAllTaking2FloatArraysReturningEmptyArray() throws Throwable  {
        // Tests that addAll works correctly with an empty array as the first parameter.
        float[] arg1 = new float[0];
        float[] addAll = ArrayUtils.addAll(arg1, arg1);
        assertNotSame(addAll, arg1); // Asserts that the result of addAll is not the same object as arg1
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testAddAllTaking2LongArraysReturningEmptyArray() throws Throwable  {
        // This test checks that the "addAll" method of ArrayUtils returns a new array when given two arrays with different contents.
        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  {
        // Given: an array of integers and a null value
        int[] arg0 = new int[1];
        
        // When: the addAll method is called with the null value
        int[] addAll = ArrayUtils.addAll(arg0, (int[]) null);
        
        // Then: the returned array should not be null and have a length of 1
        assertNotNull(addAll);
        assertEquals(1, addAll.length);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testAddAllTaking2IntArraysReturningNull() throws Throwable  {
        // No Comments were added
        int[] addAll = ArrayUtils.addAll((int[]) null, (int[]) null);
        assertNull(addAll);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testAddAllTaking2IntArraysReturningEmptyArray() throws Throwable  {
        // Given: Two arrays of integers, one empty and the other containing duplicates
        int[] arg1 = new int[0];
        int[] arg2 = {1, 2, 3, 4, 5, 6};
        
        // When: Calling the addAll method with two arguments that are not null or empty
        int[] addAll = ArrayUtils.addAll(arg1, arg2);
        
        // Then: The resulting array should contain only unique elements from both arrays
        assertEquals(new int[]{1, 2, 3, 4, 5, 6}, addAll);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testAddAllTaking2ShortArraysWithNonEmptyArray() throws Throwable  {
        // Define input and expected output arrays
        short[] input = new short[4];
        short[] expectedOutput = new short[8];
        
        // Initialize input array with some values
        for (int i = 0; i < input.length; i++) {
        input[i] = (short) i;
        }
        
        // Add all elements from the input array to a new array
        short[] addAll = ArrayUtils.addAll(input, input);
        
        // Assert that the length of the output array is correct
        assertEquals(8, addAll.length);
        
        // Assert that all elements in the output array are equal to their corresponding inputs
        for (int i = 0; i < expectedOutput.length; i++) {
        assertEquals(expectedOutput[i], addAll[i]);}
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testAddAllTaking2ShortArraysReturningNull() throws Throwable  {
        // This test ensures that when both input arrays are null, the method returns null.
        short[] addAll = ArrayUtils.addAll((short[]) null, (short[]) null);
        assertNull(addAll);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testAddAllTaking2ByteArraysReturningEmptyArray() throws Throwable  {
        // Test that a null input returns an empty array
        byte[] arg0 = ArrayUtils.nullToEmpty((byte[]) null);
        assertEquals(new byte[] {}, arg0);
        
        // Test that adding a null input to a non-null array returns a new array with the original elements
        byte[] arg1 = { 1, 2, 3 };
        byte[] addAll = ArrayUtils.addAll(arg1, (byte[]) null);
        assertArrayEquals(new byte[] { 1, 2, 3 }, addAll);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testAddAllTaking2ByteArraysReturningNonEmptyArray() throws Throwable  {
        // Given: two arrays of bytes with the same length
        byte[] arg1 = new byte[]{0x01};
        byte[] arg2 = new byte[]{0x02};
        
        // When: adding both arrays together
        byte[] addAll = ArrayUtils.addAll(arg1, arg2);
        
        // Then: the resulting array should have twice the length of the original arrays
        assertEquals(3, addAll.length);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testAddAllTaking2CharArraysReturningNonEmptyArray() throws Throwable  {
        // Given: A char array with length 1
        char[] input = new char[1];
        
        // When: We call the addAll method with null as an argument
        char[] result = ArrayUtils.addAll(input, (char[]) null);
        
        // Then: The result should not be null and have a length of 1
        assertNotNull(result);
        assertEquals(1, result.length);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testAddAllTaking2CharArraysReturningEmptyArray() throws Throwable  {
        // Given: A char array with 0 elements
        char[] input = new char[0];
        
        // When: Adding the same array to itself using ArrayUtils.addAll
        char[] result = ArrayUtils.addAll(input, input);
        
        // Then: The resulting array should not be the same as the original array
        assertNotSame(result, input);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testAddAllTaking2BooleanArraysReturningEmptyArray() throws Throwable  {
        // Given an empty array of booleans
        boolean[] arg1 = new boolean[0];
        
        // When the method "addAll" is called with two arguments, both of which are the same empty array
        boolean[] addAll = ArrayUtils.addAll(arg1, arg1);
        
        // Then the returned value should not be the same as the original empty array
        assertNotSame(addAll, arg1);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testAddAllTaking2ObjectArraysReturningNonEmptyArray() throws Throwable  {
        // Given: An array of bytes and a null value
        Byte[] arg0 = new Byte[1];
        
        // When: The "addAll" method is called with the array and a null value
        Byte[] addAll = ArrayUtils.addAll(arg0, (Byte[]) null);
        
        // Then: The length of the returned array should be 1, as the null value is ignored
        assertEquals(1, addAll.length);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testAddAllTaking2ObjectArraysReturningNull() throws Throwable  {
        // No Comments were added
        Byte[] addAll = ArrayUtils.addAll((Byte[]) null, (Byte[]) null);
        assertNull(addAll);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testIsNotEmptyTakingBooleanArrayReturningTrue() throws Throwable  {
        // Given: an array of booleans with one element
        boolean[] arg0 = new boolean[]{true};
        
        // When: the method "ArrayUtils.isNotEmpty" is called with the array as argument
        boolean notEmpty = ArrayUtils.isNotEmpty(arg0);
        
        // Then: the result should be true, indicating that the array is not empty
        assertTrue(notEmpty);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testIsNotEmptyTakingBooleanArrayWithEmptyArray() throws Throwable  {
        // Given an empty array,
        boolean[] arg0 = new boolean[0];
        
        // When we check if it's not empty,
        boolean notEmpty = ArrayUtils.isNotEmpty(arg0);
        
        // Then the method should return false,
        assertFalse(notEmpty);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testIsNotEmptyTakingBooleanArrayWithNull() throws Throwable  {
        // Test that the method ArrayUtils.isNotEmpty() returns false when passed a null array
        boolean notEmpty = ArrayUtils.isNotEmpty((boolean[]) null);
        
        // Assert that the result of the method is false, which means that the array is empty
        assertFalse(notEmpty);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testIsNotEmptyTakingFloatArrayReturningTrue() throws Throwable  {
        // Given
        float[] array = new float[1];
        
        // When
        boolean isNotEmpty = ArrayUtils.isNotEmpty(array);
        
        // Then
        assertTrue(isNotEmpty);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testIsNotEmptyTakingFloatArrayWithNull() throws Throwable  {
        boolean notEmpty = ArrayUtils.isNotEmpty((float[]) null);
        assertFalse(notEmpty);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testIsNotEmptyTakingDoubleArrayReturningTrue() throws Throwable  {
        // Given a non-empty array of doubles
        double[] arg0 = {1.0, 2.0, 3.0, 4.0};
        
        // When the method is called with this argument
        boolean notEmpty = ArrayUtils.isNotEmpty(arg0);
        
        // Then the result should be true
        assertTrue(notEmpty);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testIsNotEmptyTakingDoubleArrayWithEmptyArray() throws Throwable  {
        // Given: A null array of doubles
        double[] arg0 = new double[0];
        
        // When: The method is called with the array
        boolean notEmpty = ArrayUtils.isNotEmpty(arg0);
        
        // Then: The result should be false, as the array is empty
        assertFalse(notEmpty);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testIsNotEmptyTakingDoubleArrayWithNull() throws Throwable  {
        // This test is checking that the method ArrayUtils.isNotEmpty returns false when passed a null array
        boolean notEmpty = ArrayUtils.isNotEmpty((double[]) null);
        assertFalse(notEmpty);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testIsNotEmptyTakingByteArrayWithEmptyArray() throws Throwable  {
        // Given: a null array of bytes
        byte[] arg0 = null;
        
        // When: invoking the isNotEmpty method on the array
        boolean notEmpty = ArrayUtils.isNotEmpty(arg0);
        
        // Then: the result should be false, indicating that the array is empty
        assertFalse(notEmpty);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testIsNotEmptyTakingByteArrayReturningTrue() throws Throwable  {
        // Given: A byte array with one element
        byte[] arg0 = new byte[1];
        
        // When: The method is called with the array as an argument
        boolean notEmpty = ArrayUtils.isNotEmpty(arg0);
        
        // Then: The method returns true, indicating that the array is not empty
        assertTrue(notEmpty);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testIsNotEmptyTakingByteArrayWithNull() throws Throwable  {
        // No Comments were added
        boolean notEmpty = ArrayUtils.isNotEmpty((byte[]) null);
        assertFalse(notEmpty);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testIsNotEmptyTakingCharArrayReturningTrue() throws Throwable  {
        // Given: a non-empty array of characters
        char[] arg0 = new char[3];
        
        // When: the method is called with the array
        boolean notEmpty = ArrayUtils.isNotEmpty(arg0);
        
        // Then: the method should return true
        assertTrue(notEmpty);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testIsNotEmptyTakingCharArrayWithEmptyArray() throws Throwable  {
        // Given an empty char array
        char[] arg0 = new char[0];
        
        // When we check if the array is not empty
        boolean notEmpty = ArrayUtils.isNotEmpty(arg0);
        
        // Then the result should be false
        assertFalse(notEmpty);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testIsNotEmptyTakingCharArrayWithNull() throws Throwable  {
        // Testing that ArrayUtils.isNotEmpty returns false when passed a null array
        boolean notEmpty = ArrayUtils.isNotEmpty((char[]) null);
        assertFalse(notEmpty);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testIsNotEmptyTakingShortArrayReturningTrue() throws Throwable  {
        // Setup: Create a new array of size 3
        short[] arg0 = new short[3];
        
        // Expected behavior: The array is not empty
        boolean notEmpty = ArrayUtils.isNotEmpty(arg0);
        assertTrue(notEmpty);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testIsNotEmptyTakingShortArrayWithEmptyArray() throws Throwable  {
        short[] arg0 = new short[0]; // empty array of shorts
        
        boolean notEmpty = ArrayUtils.isNotEmpty(arg0);
        
        assertFalse(notEmpty, "An empty short array should be considered not empty");
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testIsNotEmptyTakingShortArrayWithNull() throws Throwable  {
        // Test that the method returns false when given a null input
        boolean notEmpty = ArrayUtils.isNotEmpty((short[]) null);
        assertFalse(notEmpty);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testIsNotEmptyTakingIntArrayWithEmptyArray() throws Throwable  {
        // Test that an empty array does not pass the "isNotEmpty" check.
        int[] arg0 = new int[0];
        boolean notEmpty = ArrayUtils.isNotEmpty(arg0);
        assertFalse(notEmpty);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testIsNotEmptyTakingLongArrayWithEmptyArray() throws Throwable  {
        // Given a long array with one element
        long[] arg1 = new long[] { 10 };
        
        // When removing the element from the array
        long[] arg0 = ArrayUtils.removeElements(arg1, arg1);
        
        // Then the resulting array is empty
        assertTrue(ArrayUtils.isEmpty(arg0));
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testIsNotEmptyTakingLongArrayReturningTrue() throws Throwable  {
        // Given: A non-empty array of long values
        long[] arg0 = new long[] {1, 2};
        
        // When: The isNotEmpty method is called on the array
        boolean notEmpty = ArrayUtils.isNotEmpty(arg0);
        
        // Then: The method should return true since the array is not empty
        assertTrue(notEmpty);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testIsNotEmptyTakingLongArrayWithNull() throws Throwable  {
        // Test that a null array does not pass the isNotEmpty() method.
        boolean notEmpty = ArrayUtils.isNotEmpty((long[]) null);
        assertFalse(notEmpty);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testIsNotEmptyTakingObjectArrayReturningTrue() throws Throwable  {
        // Given: A byte array with 8 elements
        Byte[] arg0 = new Byte[8];
        
        // When: The array is passed to the ArrayUtils.isNotEmpty() method
        boolean notEmpty = ArrayUtils.isNotEmpty(arg0);
        
        // Then: The result should be true, as the array is not empty
        assertTrue(notEmpty);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testIsNotEmptyTakingObjectArrayWithEmptyArray() throws Throwable  {
        // Given: A non-empty array of bytes
        Byte[] inputBytes = new Byte[10];
        
        // When: Calling the isNotEmpty method with the input array as argument
        boolean result = ArrayUtils.isNotEmpty(inputBytes);
        
        // Then: The result should be false, since the array is not empty
        assertFalse(result);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testIsNotEmptyTakingObjectArrayWithNull() throws Throwable  {
        // Check that a null input returns false
        boolean notEmpty = ArrayUtils.isNotEmpty((Byte[]) null);
        assertFalse(notEmpty);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testIsEmptyTakingByteArrayWithEmptyArray() throws Throwable  {
        // Test that a null byte array is considered to be an empty array
        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  {
        // Given an array of one element
        byte[] inputArray = new byte[1];
        
        // When we remove elements from the array
        byte[] outputArray = ArrayUtils.removeElements(inputArray, (byte[]) null);
        
        // Then the resulting array should have a length of 1
        assertEquals(1, outputArray.length);
        
        // And the result should not be null
        assertNotNull(outputArray);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testRemoveElementsTaking2ByteArraysReturningNull() throws Throwable  {
        // No Comments were added
        byte[] removeElements = ArrayUtils.removeElements((byte[]) null, (byte[]) null);
        assertNull(removeElements);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testIsEmptyTakingCharArrayReturningFalse() throws Throwable  {
        // Given: An array of characters is passed as an argument to the method
        char[] arg0 = new char[3];
        
        // When: The method is called with the above array
        boolean empty = ArrayUtils.isEmpty(arg0);
        
        // Then: The method should return false, indicating that the array is not empty
        assertFalse(empty);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testIsEmptyTakingCharArrayWithEmptyArray() throws Throwable  {
        // Given an empty array of characters
        char[] arg0 = new char[0];
        
        // When the isEmpty method is called with the above array
        boolean empty = ArrayUtils.isEmpty(arg0);
        
        // Then it should return true, indicating that the array is empty
        assertTrue(empty);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testRemoveElementsTaking2CharArraysReturningNull() throws Throwable  {
        // Test that removing elements from a null array returns a null array
        char[] removeElements = ArrayUtils.removeElements((char[]) null, (char[]) null);
        assertNull(removeElements);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testIsEmptyTakingShortArrayWithEmptyArray() throws Throwable  {
        // Given an empty array of shorts
        short[] arg0 = new short[0];
        
        // When the isEmpty method is called on the array
        boolean empty = ArrayUtils.isEmpty(arg0);
        
        // Then it should return true, indicating that the array is empty
        assertTrue(empty);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testRemoveElementsTaking2ShortArraysReturningNonEmptyArray() throws Throwable  {
        // Given a short array with 4 elements
        short[] arg0 = new short[4];
        
        // When the method removeElements is called with null as input
        short[] removeElements = ArrayUtils.removeElements(arg0, (short[]) null);
        
        // Then the method should return a non-null array
        assertNotNull(removeElements);
        
        // And the length of the returned array should be equal to the original array length
        assertEquals(4, removeElements.length);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testRemoveElementsTaking2IntArraysWithNull() throws Throwable  {
        int[] inputArray = new int[1];
        int[] result = ArrayUtils.removeElements(inputArray, (int[]) null);
        assertNotNull(result);
        assertEquals(1, result.length);
        
        // Given: an array with one element and a null value for the elements to remove
        // When: calling the removeElements method with the input array and a null value for the elements to remove
        // Then: the method should return a new array with the original element and not modify the input array
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testIsEmptyTakingIntArrayWithEmptyArray() throws Throwable  {
        // Given an empty array of length 0
        int[] arg0 = new int[0];
        
        // When the method ArrayUtils.isEmpty is called with the argument
        boolean empty = ArrayUtils.isEmpty(arg0);
        
        // Then the result should be true, indicating that the array is empty
        assertTrue(empty);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testIsEmptyTakingIntArrayWithNull() throws Throwable  {
        // No Comments were added
        boolean empty = ArrayUtils.isEmpty((int[]) null);
        assertTrue(empty);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testIsEmptyTakingLongArrayReturningFalse() throws Throwable  {
        // Test case for the method isEmpty with a non-empty array as argument
        
        long[] arg0 = new long[1];
        boolean empty = ArrayUtils.isEmpty(arg0);
        assertFalse(empty);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testIsEmptyTakingLongArrayWithEmptyArray() throws Throwable  {
        // Given: An array of type "long" with no elements
        long[] arg0 = new long[0];
        
        // When: The method "ArrayUtils.isEmpty" is called on the array
        boolean empty = ArrayUtils.isEmpty(arg0);
        
        // Then: The method returns true, indicating that the array is empty
        assertTrue(empty);
        
        // And: No exception is thrown during the execution of the test
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testRemoveElementsTaking2LongArraysReturningNull() throws Throwable  {
        // No Comments were added
        long[] removeElements = ArrayUtils.removeElements((long[]) null, (long[]) null);
        assertNull(removeElements);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testIsEmptyTakingObjectArrayWithEmptyArray() throws Throwable  {
        // Arrange
        Float[] inputArray = new Float[0];
        
        // Act
        boolean result = ArrayUtils.isEmpty((Object[]) inputArray);
        
        // Assert
        assertTrue(result);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testRemoveElementsTaking2ObjectArrays1() throws Throwable  {
        // rollbacked to evosuite
        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  {
        // Test that removing elements from a null array returns null
        Byte[] removeElements = ArrayUtils.removeElements((Byte[]) null, (Byte[]) null);
        assertNull(removeElements);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testToObjectTakingBooleanArrayReturningNonEmptyArray() throws Throwable  {
        // Test that the toObject method correctly converts a boolean array to an object array
        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  {
        // rollbacked to evosuite
        Boolean[] object = ArrayUtils.toObject((boolean[]) null);
        assertNull(object);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testToObjectTakingBooleanArrayReturningEmptyArray() throws Throwable  {
        // Given an empty array of booleans
        boolean[] arg0 = new boolean[0];
        
        // When the method is called with this array
        Boolean[] object = ArrayUtils.toObject(arg0);
        
        // Then the resulting array should have a length of 0
        assertEquals(0, object.length);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testToPrimitiveTaking1And10() throws Throwable  {
        // Given an array of Boolean objects
        Boolean[] arg0 = new Boolean[1];
        arg0[0] = true;
        
        // When converting to a primitive boolean array
        boolean[] primitive = ArrayUtils.toPrimitive(arg0, true);
        
        // Then the resulting array should be equal to the expected value
        assertTrue(Arrays.equals(new boolean[] {true}, primitive));
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testToPrimitiveTaking1And1ReturningEmptyArrayAndToPrimitiveTaking1And10() throws Throwable  {
        // Given an empty array of Booleans
        Boolean[] arg0 = new Boolean[0];
        
        // When the method ArrayUtils.toPrimitive is called with the array as an argument and a default value (true)
        boolean[] primitive = ArrayUtils.toPrimitive(arg0, true);
        
        // Then the resulting primitive array should have length 0
        assertEquals(0, primitive.length);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testToPrimitiveTaking1And1ReturningNullAndToPrimitiveTaking1And1AndToPrimitiveTaking1And10() throws Throwable  {
        // No Comments were added
        boolean[] primitive = ArrayUtils.toPrimitive((Boolean[]) null, false);
        assertNull(primitive);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testToPrimitiveTaking1And11() throws Throwable  {
        // Given a Boolean array with a single element
        Boolean[] arg0 = new Boolean[1];
        
        // When the method to convert to a primitive boolean array is called
        boolean[] primitive = ArrayUtils.toPrimitive(arg0, true);
        
        // Then the resulting primitive array should have the same values as the original array
        assertTrue(Arrays.equals(new boolean[] {true}, primitive));
        
        // And the result should not be null
        assertNotNull(primitive);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testToPrimitiveTakingBooleanArrayReturningEmptyArray() throws Throwable  {
        // Given a Boolean array with zero elements
        Boolean[] arg0 = new Boolean[0];
        
        // When the method toPrimitive is called on this array
        boolean[] primitive = ArrayUtils.toPrimitive(arg0);
        
        // Then an empty boolean array should be returned
        assertTrue(Arrays.equals(new boolean[] {}, primitive));
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testToPrimitiveTakingBooleanArrayReturningNull() throws Throwable  {
        // No Comments were added
        boolean[] primitive = ArrayUtils.toPrimitive((Boolean[]) null);
        assertNull(primitive);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testToObjectTakingFloatArrayReturningNonEmptyArray() throws Throwable  {
        // Given: an array of floats
        float[] arg0 = new float[2];
        
        // When: converting the array to a list of objects
        Float[] object = ArrayUtils.toObject(arg0);
        
        // Then: the length of the list is 2
        assertEquals(2, object.length);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testToObjectTakingFloatArrayReturningNull() throws Throwable  {
        // This test ensures that the "toObject" method of the ArrayUtils class returns a null value when passed a null float array.
        // Given a null float array
        Float[] object = ArrayUtils.toObject((float[]) null);
        // Then the returned object should be null
        assertNull(object);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testToObjectTakingFloatArrayReturningEmptyArray() throws Throwable  {
        // This test verifies that the toObject method returns an empty array
        // when passed an empty float array as argument
        
        float[] arg0 = new float[0]; // empty float array
        Float[] object = ArrayUtils.toObject(arg0); // convert to Object array
        assertEquals(0, object.length); // check that the returned array has length 0
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testToPrimitiveTaking1And1ReturningNullAndToPrimitiveTaking1And1AndToPrimitiveTaking1And11() throws Throwable  {
        // This test ensures that the ArrayUtils.toPrimitive method returns null when given a null Float[] array.
        float[] primitive = ArrayUtils.toPrimitive((Float[]) null, (float) (short) (-160));
        assertNull(primitive);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testToPrimitiveTaking1And1ReturningEmptyArrayAndToPrimitiveTaking1And11() throws Throwable  {
        // Given an empty array of Floats
        Float[] arg0 = new Float[0];
        
        // When we call the toPrimitive method with a default value of 1.6F
        float[] primitive = ArrayUtils.toPrimitive(arg0, 1.6F);
        
        // Then the returned array should have a length of 0
        assertEquals(0, primitive.length);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testToPrimitiveTakingFloatArray() throws Throwable  {
        // No Comments were added
        float[] primitive = ArrayUtils.toPrimitive((Float[]) null);
        assertNull(primitive);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testToObjectTakingDoubleArrayReturningNull() throws Throwable  {
        // Given: The input array is null
        // When: The method is called with a null array
        Double[] result = ArrayUtils.toObject((double[]) null);
        // Then: The result should be null
        assertNull(result);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testToPrimitiveTaking1And1ReturningNonEmptyArrayAndToPrimitiveTaking1And10() throws Throwable  {
        // Given: An array of Doubles and a default value
        Double[] arg0 = new Double[1];
        double primitiveDefaultValue = 832.65228;
        
        // When: Calling the toPrimitive method with the array and the default value
        double[] primitive = ArrayUtils.toPrimitive(arg0, primitiveDefaultValue);
        
        // Then: The returned array should be a primitive double array with the same values as the input array
        assertArrayEquals(new double[] {primitiveDefaultValue}, primitive, 0.01);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testToPrimitiveTaking1And1ReturningNullAndToPrimitiveTaking1And1AndToPrimitiveTaking1And12() throws Throwable  {
        // No Comments were added
        double[] primitive = ArrayUtils.toPrimitive((Double[]) null, (double) (byte) (-11));
        assertNull(primitive);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testToPrimitiveTaking1And1ReturningEmptyArrayAndToPrimitiveTaking1And12() throws Throwable  {
        // Given: An array of Doubles and a default value for the primitive array
        Double[] arg0 = new Double[0];
        double[] primitive = ArrayUtils.toPrimitive(arg0, 504.1892182465972);
        
        // When: Calling the toPrimitive method with the given arguments
        double[] actual = primitive;
        
        // Then: The resulting array should be an empty array
        assertArrayEquals(new double[] {}, actual, 0.01);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testToPrimitiveTakingDoubleArrayReturningNull() throws Throwable  {
        // No Comments were added
        double[] primitive = ArrayUtils.toPrimitive((Double[]) null);
        assertNull(primitive);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testToPrimitiveTakingDoubleArrayReturningEmptyArray() throws Throwable  {
        // Given an empty array of Doubles
        Double[] arg0 = new Double[0];
        
        // When converting it to a primitive double array
        double[] primitive = ArrayUtils.toPrimitive(arg0);
        
        // Then we expect the resulting array to have zero length
        assertEquals(0, primitive.length);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testToObjectTakingByteArrayReturningEmptyArray() throws Throwable  {
        // Given: We have a byte array with 0 elements
        byte[] arg0 = new byte[0];
        
        // When: We convert the byte array to an object array
        Byte[] object = ArrayUtils.toObject(arg0);
        
        // Then: The resulting object array should have 0 elements
        assertEquals(0, object.length);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testToObjectTakingByteArrayReturningNull() throws Throwable  {
        // No Comments were added
        Byte[] object = ArrayUtils.toObject((byte[]) null);
        assertNull(object);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testToPrimitiveTaking1And1ReturningNonEmptyArrayAndToPrimitiveTaking1And11() throws Throwable  {
        // Given: An array of bytes with one element
        Byte[] arg0 = new Byte[] { (byte) 127 };
        
        // When: Converting the array to a primitive byte array using ArrayUtils.toPrimitive()
        byte[] primitive = ArrayUtils.toPrimitive(arg0, (byte) (-63));
        
        // Then: The result should be a primitive byte array with one element that is the same as the input array
        assertArrayEquals(new byte[] { (byte) 127 }, primitive);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testToPrimitiveTaking1And1ReturningNullAndToPrimitiveTaking1And1AndToPrimitiveTaking1And13() throws Throwable  {
        // No Comments were added
        byte[] primitive = ArrayUtils.toPrimitive((Byte[]) null, (byte) (-115));
        assertNull(primitive);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testToPrimitiveTaking1And1ReturningEmptyArrayAndToPrimitiveTaking1And13() throws Throwable  {
        // Given: a non-empty array of bytes
        Byte[] arg0 = new Byte[]{1, 2, 3};
        
        // When: the method toPrimitive is called on this array
        byte[] primitive = ArrayUtils.toPrimitive(arg0, (byte) (-1));
        
        // Then: an empty byte array should be returned
        assertArrayEquals(new byte[] {}, primitive);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testToPrimitiveTakingByteArrayReturningNull() throws Throwable  {
        // No Comments were added
        byte[] primitive = ArrayUtils.toPrimitive((Byte[]) null);
        assertNull(primitive);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testToPrimitiveTakingByteArrayReturningEmptyArray() throws Throwable  {
        // Given: An empty array of Byte objects
        Byte[] arg0 = new Byte[0];
        
        // When: We convert the array to a primitive byte array using ArrayUtils.toPrimitive() method
        byte[] primitive = ArrayUtils.toPrimitive(arg0);
        
        // Then: The resulting primitive byte array should have length 0
        assertEquals(0, primitive.length);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testToObjectTakingShortArrayReturningNonEmptyArray() throws Throwable  {
        // Given: an array of shorts and a method to convert it to an array of objects
        short[] arg0 = new short[6];
        Short[] object = ArrayUtils.toObject(arg0);
        
        // When: the method is called with the array of shorts
        
        // Then: the returned array should have the same length as the original array
        assertEquals(6, object.length);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testToObjectTakingShortArrayReturningNull() throws Throwable  {
        // This test ensures that the 'toObject' method of the 'ArrayUtils' class
        // returns a null value when given a null short array as input.
        Short[] object = ArrayUtils.toObject((short[]) null);
        assertNull(object);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testToObjectTakingShortArrayReturningEmptyArray() throws Throwable  {
        // Given an empty short array
        short[] arg0 = new short[0];
        
        // When converting to an object array using ArrayUtils.toObject()
        Short[] object = ArrayUtils.toObject(arg0);
        
        // Then the resulting object array should have a length of 0
        assertEquals(0, object.length);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testToPrimitiveTaking1And1ReturningNullAndToPrimitiveTaking1And1AndToPrimitiveTaking1And14() throws Throwable  {
        // Test the behavior of the toPrimitive method with a null input.
        short[] primitive = ArrayUtils.toPrimitive((Short[]) null, (short) (-71));
        
        assertNull(primitive);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testToPrimitiveTaking1And1ReturningEmptyArrayAndToPrimitiveTaking1And14() throws Throwable  {
        // Given: We have an array of shorts with zero elements
        Short[] arg0 = new Short[0];
        
        // When: We call the method ArrayUtils.toPrimitive() on this array with a default value of 1278
        short[] primitive = ArrayUtils.toPrimitive(arg0, (short)1278);
        
        // Then: The result should be an empty short array {}
        assertArrayEquals(new short[] {}, primitive);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testToPrimitiveTakingShortArrayReturningNull() throws Throwable  {
        // No Comments were added
        short[] primitive = ArrayUtils.toPrimitive((Short[]) null);
        assertNull(primitive);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testToPrimitiveTakingShortArrayReturningEmptyArray() throws Throwable  {
        // Given an empty Short array
        Short[] arg0 = new Short[0];
        
        // When converting to a primitive short array
        short[] primitive = ArrayUtils.toPrimitive(arg0);
        
        // Then the resulting array should be empty
        assertArrayEquals(new short[] {}, primitive);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testToObjectTakingIntArrayReturningNonEmptyArray() throws Throwable  {
        // Given an array of integers
        int[] arg0 = new int[4];
        
        // When the method to convert it to an object array is called
        Integer[] object = ArrayUtils.toObject(arg0);
        
        // Then the length of the object array should be 4
        assertEquals(4, object.length);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testToObjectTakingIntArrayReturningNull() throws Throwable  {
        // No Comments were added
        Integer[] object = ArrayUtils.toObject((int[]) null);
        assertNull(object);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testToObjectTakingIntArrayReturningEmptyArray() throws Throwable  {
        // Given an empty array of integers
        int[] arg0 = new int[0];
        
        // When the method toObject is called on this array
        Integer[] object = ArrayUtils.toObject(arg0);
        
        // Then the resulting object should have a length of 0
        assertEquals(0, object.length);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testToPrimitiveTaking1And1ReturningNonEmptyArrayAndToPrimitiveTaking1And12() throws Throwable  {
        // Tests that the ArrayUtils.toPrimitive method converts an array of Integers to a primitive integer array with the correct values
        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  {
        // No Comments were added
        int[] primitive = ArrayUtils.toPrimitive((Integer[]) null, 4);
        assertNull(primitive);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testToPrimitiveTaking1And1ReturningEmptyArrayAndToPrimitiveTaking1And15() throws Throwable  {
        // Given an empty Integer array and a default value of -100
        Integer[] arg0 = new Integer[0];
        int[] primitive = ArrayUtils.toPrimitive(arg0, (-100));
        
        // When the toPrimitive() method is called with this empty array and default value
        // Then an empty int array should be returned
        assertArrayEquals(new int[] {}, primitive);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testToPrimitiveTakingIntegerArrayReturningNonEmptyArray() throws Throwable  {
        // Given: We have an array of Integer objects and we want to convert it into a primitive int array.
        Integer[] arg0 = new Integer[4];
        arg0[0] = (Integer) 0;
        arg0[1] = (Integer) (-21831);
        arg0[2] = (Integer) (-21831);
        arg0[3] = (Integer) (-21831);
        
        // When: We use the ArrayUtils.toPrimitive method to convert the array of Integer objects into a primitive int array.
        int[] primitive = ArrayUtils.toPrimitive(arg0);
        
        // Then: The resulting primitive int array should be equal to the expected output, which is an array containing the values 0, -21831, -21831, and -21831 in that order.
        assertArrayEquals(new int[] {0, (-21831), (-21831), (-21831)}, primitive);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testToPrimitiveTakingIntegerArrayReturningEmptyArray() throws Throwable  {
        // Given an empty array of boxed integers
        Integer[] arg0 = new Integer[0];
        
        // When the toPrimitive method is called on this array
        int[] primitive = ArrayUtils.toPrimitive(arg0);
        
        // Then the result should be an empty array of primitives
        assertArrayEquals(new int[] {}, primitive);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testToPrimitiveTakingIntegerArrayReturningNull() throws Throwable  {
        // No Comments were added
        int[] primitive = ArrayUtils.toPrimitive((Integer[]) null);
        assertNull(primitive);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testToObjectTakingLongArrayReturningNonEmptyArray() throws Throwable  {
        // Given a single-element array of longs
        long[] arg0 = new long[]{42};
        
        // When the method "toObject" is called with this array
        Long[] object = ArrayUtils.toObject(arg0);
        
        // Then the result should be an array with a single element, which is a Long instance
        assertEquals(1, object.length);
        assertTrue(object[0] instanceof Long);
        assertEquals((long) 42, (long) object[0]);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testToObjectTakingLongArrayReturningNull() throws Throwable  {
        // Given a null input, when converting to an array of objects, the result should be null.
        Long[] object = ArrayUtils.toObject((long[]) null);
        assertNull(object);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testToObjectTakingLongArrayReturningEmptyArray() throws Throwable  {
        // Given an empty array of primitive longs
        long[] arg0 = new long[0];
        
        // When converting to an array of Long objects
        Long[] object = ArrayUtils.toObject(arg0);
        
        // Then the resulting array should have zero elements
        assertEquals(0, object.length);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testToPrimitiveTaking1And1ReturningNullAndToPrimitiveTaking1And1AndToPrimitiveTaking1And16() throws Throwable  {
        // No Comments were added
        long[] primitive = ArrayUtils.toPrimitive((Long[]) null, (-1L));
        assertNull(primitive);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testToPrimitiveTaking1And1ReturningEmptyArrayAndToPrimitiveTaking1And16() throws Throwable  {
        // Given: A non-empty array of Longs
        Long[] arg0 = new Long[0];
        
        // When: Converting the array to a primitive array of longs using ArrayUtils.toPrimitive() method
        long[] primitive = ArrayUtils.toPrimitive(arg0, (long) (byte) (-47));
        
        // Then: The resulting primitive array should be an empty array
        assertArrayEquals(new long[] {}, primitive);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testToPrimitiveTakingLongArrayReturningEmptyArray() throws Throwable  {
        // Given an empty Long array
        Long[] arg0 = new Long[0];
        
        // When we convert it to a primitive array using ArrayUtils.toPrimitive
        long[] primitive = ArrayUtils.toPrimitive(arg0);
        
        // Then the resulting primitive array should have length 0
        assertEquals(0, primitive.length);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testToPrimitiveTakingLongArrayReturningNull() throws Throwable  {
        // Test that converting a null Long array to a primitive long array returns null
        long[] primitive = ArrayUtils.toPrimitive((Long[]) null);
        assertNull(primitive);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testToObjectTakingCharArrayReturningNonEmptyArray() throws Throwable  {
        // Given an array of characters
        char[] arg0 = new char[3];
        
        // When the method toObject is called on this array
        Character[] object = ArrayUtils.toObject(arg0);
        
        // Then a new array of type Character should be returned
        assertEquals(3, object.length);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testToObjectTakingCharArrayReturningNull() throws Throwable  {
        // Given: The character array is null
        Character[] object = ArrayUtils.toObject((char[]) null);
        
        // When: We call the toObject method on the null character array
        assertNull(object);
        
        // Then: The method returns a null object reference
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testToObjectTakingCharArrayReturningEmptyArray() throws Throwable  {
        // Test that an empty array is converted to an empty object array
        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  {
        // Test that the toPrimitive method returns a primitive array with the correct values.
        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 testToPrimitiveTaking1And1ReturningEmptyArrayAndToPrimitiveTaking1And17() throws Throwable  {
        // No Comments were added
        Character[] arg0 = new Character[0];
        char[] primitive = ArrayUtils.toPrimitive(arg0, '6');
        assertArrayEquals(new char[] {}, primitive);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testToPrimitiveTaking1And1ReturningNullAndToPrimitiveTaking1And1AndToPrimitiveTaking1And17() throws Throwable  {
        // Test that toPrimitive() returns null when passed a null array
        char[] primitive = ArrayUtils.toPrimitive((Character[]) null, 'a');
        assertNull(primitive);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testToPrimitiveTakingCharacterArrayReturningNonEmptyArray() throws Throwable  {
        // Given two identical characters, arg0,
        Character[] arg0 = new Character[2];
        Character character = new Character('j');
        arg0[0] = character;
        arg0[1] = character;
        
        // When we convert the array to a primitive array of chars,
        char[] primitive = ArrayUtils.toPrimitive(arg0);
        
        // Then we should get an array with two identical characters, 'j'.
        assertArrayEquals(new char[] {'j', 'j'}, primitive);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testToPrimitiveTakingCharacterArrayReturningEmptyArray() throws Throwable  {
        // Given an empty array of Character objects
        Character[] arg0 = new Character[0];
        
        // When the toPrimitive method is called on this array
        char[] primitive = ArrayUtils.toPrimitive(arg0);
        
        // Then the resulting array should be an empty array of primitives (i.e. char[])
        assertArrayEquals(new char[] {}, primitive);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testToPrimitiveTakingCharacterArrayReturningNull() throws Throwable  {
        // Test that a null array of characters returns null
        char[] primitive = ArrayUtils.toPrimitive((Character[]) null);
        assertNull(primitive);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testContainsTaking1And1ReturningTrueAndContainsTaking1And1AndContainsTaking1And10() throws Throwable  {
        // Given a boolean array with some values
        boolean[] arg0 = new boolean[10];
        arg0[2] = true;
        
        // When we check if the array contains a false value
        boolean contains = ArrayUtils.contains(arg0, false);
        
        // Then it should return true because the array does contain a false value
        assertTrue(contains);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testLastIndexOfTaking11And1ReturningZeroAndLastIndexOfTaking11And1AndLastIndexOfTaking11And12() throws Throwable  {
        // Given: a boolean array with four elements
        boolean[] arg0 = new boolean[4];
        
        // When: calling the lastIndexOf method with false as the target element and starting from index 0
        int lastIndexOf = ArrayUtils.lastIndexOf(arg0, false, 0);
        
        // Then: the result should be 0, which is the index of the first occurrence of false in the array
        assertEquals(0, lastIndexOf);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testLastIndexOfTaking11And1WithNegativeAndLastIndexOfTaking11And1AndLastIndexOfTaking11And11() throws Throwable  {
        // Initialize an array of booleans with 6 elements, with the first element set to true
        boolean[] arg0 = new boolean[6];
        arg0[0] = true;
        
        // Use the lastIndexOf method to find the index of the last occurrence of true in the array
        int lastIndexOf = ArrayUtils.lastIndexOf(arg0, true);
        
        // Assert that the last index of true is -1, as there are no more elements after the first element
        assertEquals(-1, lastIndexOf);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testLastIndexOfTaking11And1WithNullAndLastIndexOfTaking11And1AndLastIndexOfTaking11And11() throws Throwable  {
        // Given a null boolean array and an index of 0, when invoking the lastIndexOf method
        int lastIndexOf = ArrayUtils.lastIndexOf((boolean[]) null, true, 0);
        
        // Then the method should return -1
        assertEquals(-1, lastIndexOf);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testIndexOfTaking11And1AndIndexOfTaking11And1AndIndexOfTaking11And1ReturningNegative2() throws Throwable  {
        // No Comments were added
        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  {
        // No Comments were added
        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  {
        // Given: an array of floats containing a single value (242.0)
        float[] arg0 = new float[1];
        arg0[0] = 242.0F;
        
        // When: the method "contains" is called with this array and a float parameter (242.0)
        boolean contains = ArrayUtils.contains(arg0, 242.0F);
        
        // Then: the method should return true since the array contains the given value
        assertTrue(contains);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testLastIndexOfTaking11And1ReturningZeroAndLastIndexOfTaking11And1AndLastIndexOfTaking11And13() throws Throwable  {
        // Given: An array with one element and a search value of 0.0F
        float[] arg0 = new float[] {1.0F};
        int lastIndexOf = ArrayUtils.lastIndexOf(arg0, 0.0F, 0);
        // Then: The result should be 0 (the index of the first element)
        assertEquals(0, lastIndexOf);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testLastIndexOfTaking11And1WithPositiveAndLastIndexOfTaking11And1AndLastIndexOfTaking11And10() throws Throwable  {
        // Given a float array with some values
        float[] arg0 = new float[9];
        arg0[0] = 1.1F;
        arg0[1] = 2.2F;
        arg0[2] = 3.3F;
        arg0[3] = 4.4F;
        arg0[4] = 5.5F;
        arg0[5] = 6.6F;
        arg0[6] = 7.7F;
        arg0[7] = 8.8F;
        arg0[8] = 9.9F;
        
        // When the lastIndexOf method is called with a value that does not exist in the array
        int lastIndexOf = ArrayUtils.lastIndexOf(arg0, 1.1F, (-621));
        
        // Then the method should return -1
        assertEquals((-1), lastIndexOf);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testLastIndexOfTaking11And1WithEmptyArrayAndLastIndexOfTaking11And1AndLastIndexOfTaking11And10() throws Throwable  {
        // Given an empty float array,
        float[] arg0 = new float[0];
        
        // When the last index of a value (-254.6F) is searched for with a default value of -3264,
        int lastIndexOf = ArrayUtils.lastIndexOf(arg0, (-254.6F), (-3264));
        
        // Then the result should be -1, indicating that the value was not found in the array.
        assertEquals((-1), lastIndexOf);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testIndexOfTaking11And1WithNullAndIndexOfTaking11And1AndIndexOfTaking11And15() throws Throwable  {
        // No Comments were added
        int indexOf = ArrayUtils.indexOf((float[]) null, (-2478.2769F), 1);
        assertEquals((-1), indexOf);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testContainsTaking3ArgumentsReturningTrue() throws Throwable  {
        // Tests if the "ArrayUtils" class contains a specific value in an array of doubles.
        // In this case, the test is checking if the array "arg0" contains the value 0.0.
        double[] arg0 = new double[4];
        boolean contains = ArrayUtils.contains(arg0, 0.0, 0.0);
        assertTrue(contains);
        
        // The above code is testing if a specific value (in this case 0.0) is present in the array "arg0".
        // The method "ArrayUtils.contains" is used to check if the value is present in the array.
        // The variable "contains" is set to true if the value is found in the array, and false otherwise.
        // The assertion is then made that the variable "contains" should be true, which will fail if the value 0.0 is not present in the array "arg0".
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testContainsTaking1And1ReturningTrueAndContainsTaking1And1AndContainsTaking1And12() throws Throwable  {
        // Setup
        double[] arg0 = new double[4];
        
        // Execute
        boolean contains = ArrayUtils.contains(arg0, 0.0);
        
        // Verify
        assertTrue(contains);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testLastIndexOfTaking4ArgumentsWithNegativeAndPositive() throws Throwable  {
        // Given: A double array with one element, arg0, and a value of -3463.
        double[] arg0 = new double[1];
        arg0[0] = -3463;
        
        // When: The lastIndexOf method is called on the array with the specified value and search starting from index 327 and ending at index 1.
        int lastIndexOf = ArrayUtils.lastIndexOf(arg0, (double) (-3463), 327, 1.0);
        
        // Then: The method should return -1 as the value is not present in the array starting from index 327 and ending at index 1.
        assertEquals((-1), lastIndexOf);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testLastIndexOfTaking4ArgumentsWithPositiveAndNegative() throws Throwable  {
        // Given an array of doubles and a value to search for
        double[] arg0 = new double[3];
        int lastIndexOf = ArrayUtils.lastIndexOf(arg0, 1414.2465637973926, 2, (-1498.5270949));
        
        // When the start index is negative
        assertEquals((-1), lastIndexOf);
        
        // Then the method should return -1
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testLastIndexOfTaking4ArgumentsWithNegative() throws Throwable  {
        // Given a double array with three elements
        double[] arg0 = new double[3];
        
        // When the method 'lastIndexOf' is called with a negative number as argument
        int lastIndexOf = ArrayUtils.lastIndexOf(arg0, (-1727.707495), (-2537), (-1.0));
        
        // Then the method should return -1
        assertEquals((-1), lastIndexOf);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testLastIndexOfTaking11And1WithNegativeAndNegative() throws Throwable  {
        // Given: we have an array of doubles and a value to search for
        double[] arg0 = new double[4];
        int lastIndexOf = ArrayUtils.lastIndexOf(arg0, (double) (short) (-996), (int) (short) (-996));
        
        // When: we call the lastIndexOf method with the array and the value to search for
        assertEquals((-1), lastIndexOf);
        
        // Then: the method should return -1, since the value is not present in the array
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testLastIndexOfTaking11And1WithNullAndPositive() throws Throwable  {
        // Test that the method returns -1 when the array is null
        int lastIndexOf = ArrayUtils.lastIndexOf((double[]) null, (double) 1936L, 1936);
        assertEquals(-1, lastIndexOf);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testContainsTaking3ArgumentsReturningFalse() throws Throwable  {
        // Given: A double array containing a single value
        double[] arg0 = new double[4];
        arg0[0] = -1997.9437052250325;
        
        // When: Checking if the array contains the given value
        boolean contains = ArrayUtils.contains(arg0, -1997.9437052250325, -1997.9437052250325);
        
        // Then: The method should return false, as the array does not contain the given value
        assertFalse(contains);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testIndexOfTaking4ArgumentsReturningZero() throws Throwable  {
        // Given a double array with one element
        double[] arg0 = new double[] { 1.5 };
        
        // When the method ArrayUtils.indexOf is called with the array, 0.0 as the search value, -1 as the start index, and 1.5 as the end index
        int indexOf = ArrayUtils.indexOf(arg0, 0.0, (int) (byte) (-1), 1.5);
        
        // Then the method should return the index of the first occurrence of the search value in the array within the specified range
        assertEquals(0, indexOf);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testIndexOfTaking4ArgumentsWithNegative() throws Throwable  {
        // Tests the ArrayUtils.indexOf() method with a null array and a negative starting index
        int expectedIndex = -1;
        int actualIndex = ArrayUtils.indexOf((double[]) null, 612.3807923, (int) (short) 0, (-1398.804977));
        assertEquals(expectedIndex, actualIndex);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testRemoveElementTaking1And1ReturningNonEmptyArrayAndRemoveElementTaking1And14() throws Throwable  {
        // Setup
        double[] arg0 = new double[2];
        arg0[0] = 0.0;
        arg0[1] = 1.0;
        
        // Action
        double[] removeElement = ArrayUtils.removeElement(arg0, 0.0);
        
        // Assertion
        assertEquals(1, removeElement.length);
        assertEquals(1.0, removeElement[0], 0.0);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testContainsTaking1And1ReturningTrueAndContainsTaking1And1AndContainsTaking1And13() throws Throwable  {
        // Given: a byte array with a specific value at index 4
        byte[] input = new byte[8];
        input[4] = (byte)69;
        
        // When: the contains method is called with the array and the value to search for
        boolean result = ArrayUtils.contains(input, (byte)69);
        
        // Then: the method should return true
        assertTrue(result);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testLastIndexOfTaking1And1ReturningZeroAndLastIndexOfTaking1And1AndLastIndexOfTaking1And18() throws Throwable  {
        // Test that the last index of a byte array containing only one element is found correctly.
        byte[] arg0 = new byte[3];
        arg0[0] = (byte) (-69);
        int expectedLastIndex = 0;
        int actualLastIndex = ArrayUtils.lastIndexOf(arg0, (byte) (-69));
        assertEquals(expectedLastIndex, actualLastIndex);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testLastIndexOfTaking1And1ReturningNegativeAndLastIndexOfTaking1And1AndLastIndexOfTaking1And11() throws Throwable  {
        // Setup
        byte[] arg0 = new byte[3];
        
        // Action
        int lastIndexOf = ArrayUtils.lastIndexOf(arg0, (byte) (-69));
        
        // Assertion
        assertEquals((-1), lastIndexOf);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testLastIndexOfTaking11And1WithPositiveAndLastIndexOfTaking11And1AndLastIndexOfTaking11And11() throws Throwable  {
        // Given a byte array with 9 elements
        byte[] arg0 = new byte[9];
        
        // When calling lastIndexOf with the non-existent value of 1 and the end index of 7
        int lastIndexOf = ArrayUtils.lastIndexOf(arg0, (byte)1, (int) (byte)7);
        
        // Then the result should be -1
        assertEquals((-1), lastIndexOf);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testLastIndexOfTaking11And1WithEmptyArrayAndLastIndexOfTaking11And1AndLastIndexOfTaking11And11() throws Throwable  {
        // Given an empty byte array
        byte[] arg0 = new byte[0];
        
        // When we call ArrayUtils.lastIndexOf with a negative value and an index that is out of bounds
        int lastIndexOf = ArrayUtils.lastIndexOf(arg0, (byte) -1, (int) (byte) -1);
        
        // Then the method should return -1
        assertEquals(-1, lastIndexOf);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testRemoveElementTaking1And1ReturningNonEmptyArrayAndRemoveElementTaking1And15() throws Throwable  {
        // Given: We have an array of bytes with a length of 5 and a value of 0
        byte[] arg0 = new byte[5];
        arg0[0] = (byte) 0;
        
        // When: We remove the element at index 0 from the array
        byte[] removeElement = ArrayUtils.removeElement(arg0, (byte) 0);
        
        // Then: The resulting array should have a length of 4 and contain only non-zero elements
        assertEquals(4, removeElement.length);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testIndexOfTaking11And1AndIndexOfTaking11And1AndIndexOfTaking11And1ReturningNegative3() throws Throwable  {
        // rollbacked to evosuite
        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  {
        // Given: We have a byte array with zero elements
        byte[] arg0 = new byte[0];
        
        // When: We call the method "indexOf" on the byte array, passing in the value 1 and an index of 6
        int indexOf = ArrayUtils.indexOf(arg0, (byte)1, 6);
        
        // Then: The method should return -1, as there is no element in the array with a value of 1 at index 6
        assertEquals((-1), indexOf);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testContainsTaking1And1ReturningTrueAndContainsTaking1And1AndContainsTaking1And14() throws Throwable  {
        // Given an array of characters containing the character to search for
        char[] arg0 = new char[6];
        arg0[1] = 'O';
        
        // When calling contains with the character to search for as argument
        boolean contains = ArrayUtils.contains(arg0, 'O');
        
        // Then it should return true since the character is in the array
        assertTrue(contains);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testContainsTaking1And1ReturningFalseAndContainsTaking1And1AndContainsTaking1And11() throws Throwable  {
        // Given: an array of characters with 6 elements
        char[] inputArray = new char[6];
        
        // When: checking if the array contains the character 'A'
        boolean contains = ArrayUtils.contains(inputArray, 'A');
        
        // Then: the method should return false
        assertFalse(contains);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testLastIndexOfTaking11And1ReturningZeroAndLastIndexOfTaking11And1AndLastIndexOfTaking11And14() throws Throwable  {
        // Given a char array with 7 elements
        char[] arg0 = new char[7];
        
        // When searching for the index of a character in the array from an offset of 0
        int lastIndexOf = ArrayUtils.lastIndexOf(arg0, 'J', 0);
        
        // Then the method should return the correct index (in this case 0)
        assertEquals(0, lastIndexOf);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testLastIndexOfTaking11And1WithZero() throws Throwable  {
        // Given: A character array with length 7 and a target value of 'J'
        char[] arg0 = new char[7];
        
        // When: The method lastIndexOf is called with the array, target value, and start index of 0
        int lastIndexOf = ArrayUtils.lastIndexOf(arg0, 'J', 0);
        
        // Then: The result should be -1 as the target value does not exist in the array
        assertEquals((-1), lastIndexOf);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testLastIndexOfTaking11And1WithNegative() throws Throwable  {
        // Test the lastIndexOf method with a valid input
        char[] array = new char[3];
        int expected = 2;
        int actual = ArrayUtils.lastIndexOf(array, 'w', (int) (byte) (-1));
        assertEquals(expected, actual);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testLastIndexOfTaking11And1WithNullAndLastIndexOfTaking11And1AndLastIndexOfTaking11And12() throws Throwable  {
        // Test that the method returns -1 when the array is null
        int lastIndexOf = ArrayUtils.lastIndexOf((char[]) null, 'D', (-3111));
        assertEquals(-1, lastIndexOf);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testIndexOfTaking1And1ReturningZeroAndIndexOfTaking1And1AndIndexOfTaking1And15() throws Throwable  {
        // Test that the index of a character in a char array is returned correctly
        char[] arg0 = new char[4];
        arg0[0] = '`';
        int indexOf = ArrayUtils.indexOf(arg0, '`');
        assertEquals(0, indexOf);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testIndexOfTaking11And1WithNullAndIndexOfTaking11And1AndIndexOfTaking11And16() throws Throwable  {
        // No Comments were added
        int indexOf = ArrayUtils.indexOf((char[]) null, 'n', 4);
        assertEquals((-1), indexOf);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testContainsTaking1And1ReturningTrueAndContainsTaking1And1AndContainsTaking1And15() throws Throwable  {
        // Given an array of shorts and a value to search for
        short[] arg0 = new short[9];
        arg0[4] = (short) (-975);
        
        // When the contains method is called with the value to search for
        boolean contains = ArrayUtils.contains(arg0, (short) (-975));
        
        // Then the method should return true
        assertTrue(contains);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testContainsTaking1And1ReturningFalseAndContainsTaking1And1AndContainsTaking1And12() throws Throwable  {
        // Test that the array does not contain the element -975
        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  {
        // Given a short array with one element
        short[] arg0 = new short[1];
        arg0[0] = (short)4;
        
        // When the lastIndexOf method is called with the element and the length of the array as parameters
        int lastIndexOf = ArrayUtils.lastIndexOf(arg0, (short)4, (int) (short)4);
        
        // Then the method should return 0, which represents the index of the first occurrence of the element in the array
        assertEquals(0, lastIndexOf);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testLastIndexOfTaking11And1AndLastIndexOfTaking11And1AndLastIndexOfTaking11And1ReturningNegative3() throws Throwable  {
        // Given: an array of shorts with a value of 3 at index 4
        short[] arg0 = new short[]{1, 2, 3, 4, 3};
        
        // When: the last index of the value 3 is searched in the array
        int lastIndexOf = ArrayUtils.lastIndexOf(arg0, (short)3, 4);
        
        // Then: the result should be -1 because the value 3 is not found in the array
        assertEquals(-1, lastIndexOf);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testLastIndexOfTaking11And1WithNegativeAndLastIndexOfTaking11And1AndLastIndexOfTaking11And12() throws Throwable  {
        // Given an empty short array
        short[] arg0 = new short[0];
        
        // When we call the lastIndexOf method with a negative value and a starting index of -126
        int lastIndexOf = ArrayUtils.lastIndexOf(arg0, (short) (-3025), (int) (byte) (-126));
        
        // Then the result should be -1
        assertEquals((-1), lastIndexOf);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testLastIndexOfTaking11And1WithNullAndZero() throws Throwable  {
        // No Comments were added
        int lastIndexOf = ArrayUtils.lastIndexOf((short[]) null, (short)8, 0);
        assertEquals((-1), lastIndexOf);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testIndexOfTaking1And1ReturningNegativeAndIndexOfTaking1And1AndIndexOfTaking1And16() throws Throwable  {
        // Setup
        short[] arg0 = new short[4];
        
        // Execute
        int indexOf = ArrayUtils.indexOf(arg0, (short)2760);
        
        // Verify
        assertEquals(-1, indexOf);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testIndexOfTaking11And1ReturningZeroAndIndexOfTaking11And1AndIndexOfTaking11And15() throws Throwable  {
        // Given: We have an array of shorts and a value to search for in the array
        short[] arg0 = new short[4];
        int indexOf = ArrayUtils.indexOf(arg0, (short)0, (-3463));
        
        // When: We call the indexOf method with the array and the value to search for
        // Then: The method returns the index of the first occurrence of the value in the array
        assertEquals(0, indexOf);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testContainsTaking1And1ReturningTrueAndContainsTaking1And1AndContainsTaking1And16() throws Throwable  {
        // Set up an array with three elements
        int[] arg0 = new int[3];
        arg0[0] = 10; // Initialize the first element to 10
        boolean contains = ArrayUtils.contains(arg0, 10); // Check if the array contains the value 10
        assertTrue(contains); // Assert that the array does contain the value 10
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testContainsTaking1And1ReturningFalseAndContainsTaking1And1AndContainsTaking1And13() throws Throwable  {
        // Given: An empty int array and a value of -3386
        int[] arg0 = ArrayUtils.EMPTY_INT_ARRAY;
        int targetValue = (-3386);
        
        // When: Calling the contains method on the empty int array with the target value
        boolean contains = ArrayUtils.contains(arg0, targetValue);
        
        // Then: The method should return false
        assertFalse(contains);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testLastIndexOfTaking1And2IntsReturningZero() throws Throwable  {
        // Create a new array of integers with length 3.
        int[] arg0 = new int[3];
        
        // Find the last index of a value in the array using ArrayUtils.lastIndexOf method.
        int lastIndexOf = ArrayUtils.lastIndexOf(arg0, 0, 0);
        
        // Assert that the last index is equal to 0.
        assertEquals(0, lastIndexOf);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testLastIndexOfTaking1And2IntsWithPositiveAndNegative() throws Throwable  {
        // Arrange
        int[] numbers = new int[5];
        
        // Act
        int lastIndexOf = ArrayUtils.lastIndexOf(numbers, 2862, (-2141785322));
        
        // Assert
        assertEquals(-1, lastIndexOf);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testLastIndexOfTaking1And2IntsWithNull() throws Throwable  {
        // No Comments were added
        int lastIndexOf = ArrayUtils.lastIndexOf((int[]) null, 16, (-536));
        assertEquals((-1), lastIndexOf);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testIndexOfTaking1And1ReturningNegativeAndIndexOfTaking1And1AndIndexOfTaking1And17() throws Throwable  {
        // No Comments were added
        int indexOf = ArrayUtils.indexOf((int[]) null, 14);
        assertEquals((-1), indexOf);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testContainsTaking1And1ReturningTrueAndContainsTaking1And1AndContainsTaking1And17() throws Throwable  {
        // Test that the array contains the value 0
        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  {
        // Test that the last index of a long array containing the value 0 is returned correctly
        long[] arg0 = new long[4];
        arg0[0] = 1L;
        arg0[1] = 2L;
        arg0[2] = 3L;
        arg0[3] = 0L;
        int lastIndexOf = ArrayUtils.lastIndexOf(arg0, 0L, (int) (byte) 0);
        assertEquals(3, lastIndexOf);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testLastIndexOfTaking11And1AndLastIndexOfTaking11And1AndLastIndexOfTaking11And1ReturningNegative4() throws Throwable  {
        // Test that the last index of a single-element array with a negative start index is -1
        long[] arg0 = new long[] { 0L };
        int lastIndexOf = ArrayUtils.lastIndexOf(arg0, 0L, -3676);
        assertEquals(-1, lastIndexOf);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testLastIndexOfTaking11And1WithNullAndLastIndexOfTaking11And1AndLastIndexOfTaking11And13() throws Throwable  {
        // No Comments were added
        int lastIndexOf = ArrayUtils.lastIndexOf((long[]) null, 0L, (-3676));
        assertEquals((-1), lastIndexOf);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testIndexOfTaking1And1ReturningPositiveAndIndexOfTaking1And1AndIndexOfTaking1And17() throws Throwable  {
        // Given: An array of long values and a value to search for
        long[] arg0 = new long[3];
        arg0[0] = 1234567890L;
        int expectedIndex = 1; // The index of the first occurrence of the value in the array
        
        // When: Searching for a specific value in the array using ArrayUtils.indexOf() method
        int actualIndex = ArrayUtils.indexOf(arg0, 0L);
        
        // Then: The returned index should be the expected one
        assertEquals(expectedIndex, actualIndex);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testRemoveElementTaking1And1ReturningEmptyArrayAndRemoveElementTaking1And16() throws Throwable  {
        // Given an empty array of longs
        long[] arg0 = ArrayUtils.EMPTY_LONG_ARRAY;
        
        // When we remove an element from it
        long[] removedElement = ArrayUtils.removeElement(arg0, (long) (-36));
        
        // Then the returned array should not be the same as the original empty array
        assertNotSame(arg0, removedElement);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testIndexOfTaking11And1ReturningZeroAndIndexOfTaking11And1AndIndexOfTaking11And16() throws Throwable  {
        // Given an array of integers and a target value
        long[] arg0 = new long[1];
        int targetValue = 0;
        
        // When we call ArrayUtils.indexOf with the array and target value
        int indexOf = ArrayUtils.indexOf(arg0, targetValue, (-36));
        
        // Then we expect the method to return the index of the first occurrence of the target value in the array
        assertEquals(0, indexOf);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testContainsTaking1And1ReturningFalseAndContainsTaking1And1AndContainsTaking1And14() throws Throwable  {
        // Test that ArrayUtils.contains() returns false when passed a null array and a long value
        boolean contains = ArrayUtils.contains((long[]) null, (long) (short)2);
        assertFalse(contains);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testContainsTaking1And1ReturningTrueAndContainsTaking1And1AndContainsTaking1And18() throws Throwable  {
        // Given: An array of objects and an object to search for in the array
        Object[] arg0 = new Object[3];
        boolean expectedContains = true;
        
        // When: Searching for the object in the array using ArrayUtils.contains() method
        boolean contains = ArrayUtils.contains(arg0, arg0[1]);
        
        // Then: The object is present in the array and the assertion should pass
        assertTrue(expectedContains);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testLastIndexOfTaking11And1WithNonNull() throws Throwable  {
        // Test that the method returns -1 when the element is not found in the array
        Short[] shorts = new Short[3];
        Object object = new Object();
        int lastIndex = ArrayUtils.lastIndexOf((Object[]) shorts, object, Integer.MAX_VALUE);
        assertEquals(-1, lastIndex);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testLastIndexOfTaking11And1WithZeroAndLastIndexOfTaking11And1AndLastIndexOfTaking11And11() throws Throwable  {
        Byte byteValue = new Byte((byte) (-97));
        Object[] array = new Object[2];
        int expectedLastIndex = -1;
        
        // Test that lastIndexOf returns -1 when the element is not in the array
        int actualLastIndex = ArrayUtils.lastIndexOf(array, (Object) byteValue, 0);
        assertEquals(expectedLastIndex, actualLastIndex);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testLastIndexOfTaking11And1AndLastIndexOfTaking11And1AndLastIndexOfTaking11And1ReturningNegative5() throws Throwable  {
        // Arrange
        Byte byteValue = new Byte((byte) -71);
        Object[] array = new Object[1];
        
        // Act
        int lastIndexOf = ArrayUtils.lastIndexOf(array, (Object) byteValue, -736);
        
        // Assert
        assertEquals(-1, lastIndexOf);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testLastIndexOfTaking11And1WithNullAndLastIndexOfTaking11And1AndLastIndexOfTaking11And14() throws Throwable  {
        // Given a null array and a byte value -1
        Byte arg1 = new Byte((byte) (-1));
        
        // When the lastIndexOf method is called with the null array and the byte value -1, starting from the end of the array
        int lastIndexOf = ArrayUtils.lastIndexOf((Object[]) null, (Object) arg1, (-74));
        
        // Then the result should be -1, since the array is null
        assertEquals((-1), lastIndexOf);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testIndexOfTaking11And1WithZero() throws Throwable  {
        // Given
        Object[] input = new Object[5];
        input[0] = (Object) 'a';
        
        // When
        int indexOf = ArrayUtils.indexOf(input, (Object) 'a', 0);
        
        // Then
        assertEquals(0, indexOf);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testIndexOfTaking1And1ReturningPositiveAndIndexOfTaking1And1AndIndexOfTaking1And18() throws Throwable  {
        // Given: an array of integers and a null element
        Object[] arg0 = new Object[5];
        arg0[0] = (Object) 1076;
        int indexOfNull = ArrayUtils.indexOf(arg0, (Object) null);
        
        // When: calling the indexOf method with the array and a null element as arguments
        int actualIndexOfNull = ArrayUtils.indexOf(arg0, (Object) null);
        
        // Then: the method should return 1, which is the index of the first null element in the array
        assertEquals(1, actualIndexOfNull);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testIndexOfTaking11And1WithPositiveAndIndexOfTaking11And1AndIndexOfTaking11And12() throws Throwable  {
        // Given an array of strings and a null element
        String[] arg0 = new String[1];
        arg0[0] = null;
        
        // When the method ArrayUtils.indexOf is called with the array and the null element
        int indexOf = ArrayUtils.indexOf(arg0, null, 1);
        
        // Then the returned value should be -1
        assertEquals((-1), indexOf);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testIndexOfTaking1And1ReturningZeroAndIndexOfTaking1And1AndIndexOfTaking1And16() throws Throwable  {
        // Given: an array of 5 elements
        Object[] arg0 = new Object[5];
        
        // When: searching for a null element
        int indexOf = ArrayUtils.indexOf(arg0, (Object) null);
        
        // Then: the method should return the index of the first null element
        assertEquals(0, indexOf);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testIndexOfTaking11And1ReturningNegativeAndIndexOfTaking11And1AndIndexOfTaking11And11() throws Throwable  {
        // Given an array of objects and a target object
        Object[] input = new Object[1];
        Object arg1 = new Object();
        input[0] = arg1;
        
        // When the index of the target object is found using ArrayUtils.indexOf
        int indexOf = ArrayUtils.indexOf(input, arg1, (-1));
        
        // Then the method should return the correct index
        assertEquals((-1), indexOf);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testReverseTaking1And2IntsWithNonEmptyArray() throws Throwable  {
        // No Comments were added
        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  {
        // Test that a null array is handled correctly by the reverse method
        assertThrows(IllegalArgumentException.class, () -> ArrayUtils.reverse((short[]) null, (int) (short) (-231), (int) (short) (-231)));
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testReverseTaking1And2IntsWithPositiveAndReverseTaking1And2Ints() throws Throwable  {
        // No Comments were added
        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  {
        // No Comments were added
        ArrayUtils.reverse((Object[]) null, (-1500), (-1500));
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testReverseTaking1And2IntsWithNegativeAndPositive1() throws Throwable  {
        // Given an array of longs
        long[] input = new long[6];
        
        // When we reverse the array with a start index of -22 and end index of 8
        ArrayUtils.reverse(input, -22, (int) (short) 8);
        
        // Then the array should be reversed, but only up to the specified end index
        assertArrayEquals(new long[] {0L, 0L, 0L, 0L, 0L, 0L}, input);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testReverseTaking1And2IntsWithNullAndReverseTaking1And2IntsAndReverseTaking1And2Ints0() throws Throwable  {
        // Test that the method throws an IllegalArgumentException when called with a null array
        ArrayUtils.reverse((long[]) null, 5, 2133307888);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testReverseTaking1And2IntsWithNegativeAndReverseTaking1And2IntsWithPositiveAndReverseTaking1And2Ints() throws Throwable  {
        // Test case for reversing an array with negative start index and positive end index
        int[] arr = new int[2];
        ArrayUtils.reverse(arr, -1941, 2055); // Reverse the array starting from index -1941 up to but not including index 2055
        assertArrayEquals(new int[] {0, 0}, arr); // Assert that the reversed array is equal to [0, 0]
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testReverseTaking1And2IntsWithNullAndReverseTaking1And2IntsWithZeroAndReverseTaking1And2Ints0() throws Throwable  {
        // No Comments were added
        ArrayUtils.reverse((int[]) null, 1206, 0);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testReverseTaking1And2IntsWithNonEmptyArrayAndPositive() throws Throwable  {
        // Tests the behavior of ArrayUtils.reverse() with a negative start index
        // Setup
        float[] arg0 = new float[7];
        
        // Precondition: The array has 7 elements
        assertEquals(7, arg0.length);
        
        // Execution
        ArrayUtils.reverse(arg0, (-837), (int) (byte)123);
        
        // Postcondition: The reversed array is equal to the expected result
        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  {
        // Test that reverse() throws a NullPointerException when passed a null array reference
        assertThrows(NullPointerException.class, () -> ArrayUtils.reverse((float[]) null, (-1), (int) (byte)0));
        
        // Test that reverse() throws an IllegalArgumentException when the start index is negative
        assertThrows(IllegalArgumentException.class, () -> ArrayUtils.reverse(new float[0], -1, 0));
        
        // Test that reverse() throws an IllegalArgumentException when the end index is negative
        assertThrows(IllegalArgumentException.class, () -> ArrayUtils.reverse(new float[0], 0, -1));
        
        // Test that reverse() throws an IllegalArgumentException when the start index is greater than the end index
        assertThrows(IllegalArgumentException.class, () -> ArrayUtils.reverse(new float[0], 1, 0));
        
        // Test that reverse() throws an IllegalArgumentException when the end index is greater than the length of the array
        assertThrows(IllegalArgumentException.class, () -> ArrayUtils.reverse(new float[1], 0, 2));
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testReverseTaking1And2IntsAndReverseTaking1And2Ints1() throws Throwable  {
        // Given a double array with six elements
        double[] input = new double[6];
        
        // When the reverse method is called on this array with negative indices
        ArrayUtils.reverse(input, -1990, (short) -3403);
        
        // Then the array should be reversed in place
        assertArrayEquals(new double[] {0.0, 0.0, 0.0, 0.0, 0.0, 0.0}, input, 0.01);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testReverseTaking1And2IntsWithNullAndReverseTaking1And2IntsAndReverseTaking1And2Ints1() throws Throwable  {
        // Test that a NullPointerException is thrown when the input array is null
        assertThrows(NullPointerException.class, () -> ArrayUtils.reverse((double[]) null, (-3962), (-28)));
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testReverseTaking1And2IntsWithPositiveAndNegative1() throws Throwable  {
        // Given an array of characters to be reversed
        char[] input = new char[9];
        
        // When we call the reverse method on the array
        ArrayUtils.reverse(input, (int) (byte) (-58), 3);
        
        // Then the reversed array should be equal to the expected output
        assertArrayEquals(new char[] {'\u0000', '\u0000', '\u0000', '\u0000', '\u0000', '\u0000', '\u0000', '\u0000', '\u0000'}, input);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testReverseTaking1And2IntsWithNullAndReverseTaking1And2IntsAndReverseTaking1And2Ints2() throws Throwable  {
        // Test that passing null as the first argument to reverse() throws a NullPointerException.
        ArrayUtils.reverse((char[]) null, (int) (byte) (-11), (-1163));
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testReverseTaking1And2IntsWithNegativeAndReverseTaking1And2IntsAndReverseTaking1And2Ints2() throws Throwable  {
        // Given: A byte array with a length of 2 and an index value of -372
        byte[] input = new byte[2];
        
        // When: The reverse method is called on the byte array with the specified index value of 67
        ArrayUtils.reverse(input, (-372), 67);
        
        // Then: The resulting byte array should be {0, 0}
        assertArrayEquals(new byte[] {(byte)0, (byte)0}, input);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testReverseTaking1And2IntsWithNullAndReverseTaking1And2IntsWithNegativeAndReverseTaking1And2Ints2() throws Throwable  {
        // rollbacked to evosuite
        ArrayUtils.reverse((byte[]) null, 2136852540, (-1566));
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testReverseTaking1And2IntsWithEmptyArray() throws Throwable  {
        // Given an empty array of booleans
        boolean[] arg0 = new boolean[0];
        
        // When the array is reversed with a start index of -1 and an end index of Integer.MAX_VALUE
        ArrayUtils.reverse(arg0, (-1), Integer.MAX_VALUE);
        
        // Then the length of the array should be 0
        assertEquals(0, arg0.length);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testReverseTaking1And2IntsWithNullAndReverseTaking1And2IntsWithNegativeAndReverseTaking1And2Ints3() throws Throwable  {
        // Test that a NullPointerException is thrown when passing a null array as input
        ArrayUtils.reverse((boolean[]) null, (-970), (int) (short) (-1827));
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testReverseTakingBooleanArrayWithNull() throws Throwable  {
        // No Comments were added
        ArrayUtils.reverse((boolean[]) null);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testReverseTakingBooleanArrayWithNonEmptyArray() throws Throwable  {
        // Create a new boolean array with three elements
        boolean[] arr = new boolean[3];
        
        // Reverse the order of the elements in the array
        ArrayUtils.reverse(arr);
        
        // Assert that the reversed array is equal to a new array with three false values
        assertTrue(Arrays.equals(new boolean[] {false, false, false}, arr));
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testReverseTakingFloatArrayWithNull() throws Throwable  {
        // Verify that a null array throws a NullPointerException
        ArrayUtils.reverse((float[]) null);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testReverseTakingFloatArrayWithNonEmptyArray() throws Throwable  {
        // Create a new array of floats with length 9
        float[] originalArray = new float[9];
        // Initialize the array with some values
        for (int i = 0; i < originalArray.length; i++) {
        originalArray[i] = i * 1.0F;
        }
        // Reverse the order of the elements in the array
        ArrayUtils.reverse(originalArray);
        // Check that the reversed array is as expected
        assertArrayEquals(new float[] {8.0F, 7.0F, 6.0F, 5.0F, 4.0F, 3.0F, 2.0F, 1.0F, 0.0F}, originalArray, 0.01F);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testReverseTakingDoubleArrayWithNull() throws Throwable  {
        // No Comments were added
        ArrayUtils.reverse((double[]) null);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testReverseTakingDoubleArrayWithNonEmptyArray() throws Throwable  {
        // Given an array of doubles
        double[] input = new double[] { 0.0, 0.0, 0.0, 0.0, 0.0, 0.0 };
        
        // When the reverse method is called on the array
        ArrayUtils.reverse(input);
        
        // Then the resulting array should be equal to a reversed copy of the original array
        assertArrayEquals(new double[] { 6.0, 5.0, 4.0, 3.0, 2.0, 1.0 }, input, 0.01);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testReverseTakingByteArrayWithNull() throws Throwable  {
        // No Comments were added
        ArrayUtils.reverse((byte[]) null);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testReverseTakingByteArrayWithNonEmptyArray() throws Throwable  {
        // Given a byte array with 13 elements
        byte[] input = new byte[13];
        
        // When the reverse method is called on the array
        ArrayUtils.reverse(input);
        
        // Then the array length should be 13
        assertEquals(13, input.length);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testReverseTakingCharArrayWithNull() throws Throwable  {
        // No Comments were added
        ArrayUtils.reverse((char[]) null);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testReverseTakingCharArrayWithNonEmptyArray() throws Throwable  {
        // Set up the input array that will be reversed
        char[] arg0 = new char[3];
        
        // Reverse the input array
        ArrayUtils.reverse(arg0);
        
        // Assert that the reversed array is equal to a pre-defined expected value
        assertArrayEquals(new char[] {'\u0000', '\u0000', '\u0000'}, arg0);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testReverseTakingShortArrayWithNull() throws Throwable  {
        // No Comments were added
        ArrayUtils.reverse((short[]) null);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testReverseTakingShortArrayWithNonEmptyArray() throws Throwable  {
        // Create a new short array with 4 elements
        short[] arg0 = new short[4];
        
        // Reverse the order of the elements in the array
        ArrayUtils.reverse(arg0);
        
        // Assert that the reversed array is equal to the expected value
        assertArrayEquals(new short[] {(short)0, (short)0, (short)0, (short)0}, arg0);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testReverseTakingIntArrayWithNull() throws Throwable  {
        // No Comments were added
        ArrayUtils.reverse((int[]) null);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testReverseTakingIntArrayWithNonEmptyArray() throws Throwable  {
        // Test that the reverse method works as expected for an array of integers
        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  {
        // Test that passing a null array to reverse() throws a NullPointerException
        ArrayUtils.reverse((long[]) null);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testReverseTakingLongArrayWithNonEmptyArray() throws Throwable  {
        // Create a new long array with 7 elements
        long[] arg0 = new long[7];
        
        // Reverse the order of the elements in the array using the ArrayUtils.reverse() method
        ArrayUtils.reverse(arg0);
        
        // Assert that the length of the reversed array is equal to 7, which means it has not been modified by the reverse() method
        assertEquals(7, arg0.length);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testReverseTakingObjectArray() throws Throwable  {
        // No Comments were added
        ArrayUtils.reverse((Object[]) null);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testIsSameTypeReturningTrue() throws Throwable  {
        // Given
        Byte arg1 = new Byte((byte) 13);
        
        // When
        boolean sameType = ArrayUtils.isSameType(arg1, arg1);
        
        // Then
        assertTrue(sameType);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testIsSameTypeThrowsIllegalArgumentException() throws Throwable  {
        // No Comments were added
        // Undeclared exception!
        try { 
          ArrayUtils.isSameType("Hello World", (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  {
        // No Comments were added
        // 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  {
        // Given a boolean array with three elements
        boolean[] arg0 = new boolean[3];
        
        // When the removeElements method is called with this array and itself as arguments
        boolean[] arg1 = ArrayUtils.removeElements(arg0, arg0);
        
        // Then the returned array should have zero length
        assertEquals(0, arg1.length);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testIsSameLengthTaking2BooleanArraysAndIsSameLengthTaking2BooleanArraysReturningTrue0() throws Throwable  {
        // Given: Two arrays with the same length
        boolean[] array1 = new boolean[3];
        boolean[] array2 = new boolean[3];
        
        // When: The method is called with these two arrays as arguments
        boolean sameLength = ArrayUtils.isSameLength(array1, array2);
        
        // Then: The method should return true, since the two arrays have the same length
        assertTrue(sameLength);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testIsSameLengthTaking2BooleanArraysAndIsSameLengthTaking2BooleanArraysReturningFalse0() throws Throwable  {
        // Given an array of booleans, and a null reference to another array
        boolean[] arg0 = new boolean[3];
        boolean[] otherArray = null;
        
        // When the method is called with the two arrays as arguments
        boolean sameLength = ArrayUtils.isSameLength(arg0, otherArray);
        
        // Then the method returns false
        assertFalse(sameLength);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testIsSameLengthTaking2BooleanArraysAndIsSameLengthTaking2BooleanArraysReturningFalse1() throws Throwable  {
        // Given a null array and a non-null array of length 1
        boolean[] arg1 = new boolean[1];
        boolean sameLength = ArrayUtils.isSameLength((boolean[]) null, arg1);
        
        // When the arrays are not of the same length
        assertFalse(sameLength);
        
        // Then the method should return false
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testIsSameLengthTaking2BooleanArraysWithEmptyArrayAndNull0() throws Throwable  {
        // Arrange
        boolean[] emptyArray = new boolean[0];
        
        // Act
        boolean sameLength = ArrayUtils.isSameLength(null, emptyArray);
        
        // Assert
        assertTrue(sameLength);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testIsSameLengthTaking2BooleanArraysAndIsSameLengthTaking2BooleanArraysReturningTrue1() throws Throwable  {
        // Test that isSameLength returns true when both inputs are null
        boolean sameLength = ArrayUtils.isSameLength((boolean[]) null, (boolean[]) null);
        assertTrue(sameLength);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testIsSameLengthTaking2BooleanArraysWithEmptyArrayAndNull1() throws Throwable  {
        // Given: two arguments of different lengths
        boolean[] arg0 = new boolean[0];
        boolean[] arg1 = null;
        
        // When: calling isSameLength with the two arguments
        boolean sameLength = ArrayUtils.isSameLength(arg0, arg1);
        
        // Then: the method should return true since both arrays are empty
        assertTrue(sameLength);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testIsSameLengthTaking2FloatArraysAndIsSameLengthTaking2FloatArraysReturningFalse0() throws Throwable  {
        // Given
        float[] arg0 = new float[2];
        float[] arg1 = ArrayUtils.EMPTY_FLOAT_ARRAY;
        
        // When
        boolean sameLength = ArrayUtils.isSameLength(arg0, arg1);
        
        // Then
        assertFalse(sameLength);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testIsSameLengthTaking2FloatArraysAndIsSameLengthTaking2FloatArraysReturningTrue0() throws Throwable  {
        // Given: Two empty arrays of floats
        float[] arr1 = new float[0];
        float[] arr2 = new float[0];
        
        // When: We check if the two arrays are of the same length
        boolean sameLength = ArrayUtils.isSameLength(arr1, arr2);
        
        // Then: The result should be true
        assertTrue(sameLength);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testIsSameLengthTaking2FloatArraysAndIsSameLengthTaking2FloatArraysReturningFalse1() throws Throwable  {
        // Given: A float array and a null reference to another float array
        float[] arg0 = new float[1];
        
        // When: The method is called with the given arrays
        boolean sameLength = ArrayUtils.isSameLength(arg0, (float[]) null);
        
        // Then: The method should return false
        assertFalse(sameLength);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testIsSameLengthTaking2FloatArraysWithNonEmptyArray() throws Throwable  {
        // Given a null array and an array with length 1
        float[] arg1 = new float[1];
        
        // When we check if the arrays have the same length
        boolean sameLength = ArrayUtils.isSameLength((float[]) null, arg1);
        
        // Then the result should be false
        assertFalse(sameLength);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testIsSameLengthTaking2FloatArraysAndIsSameLengthTaking2FloatArraysReturningTrue1() throws Throwable  {
        // Given
        float[] arg1 = new float[0];
        
        // When
        boolean sameLength = ArrayUtils.isSameLength((float[]) null, arg1);
        
        // Then
        assertTrue(sameLength);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testIsSameLengthTaking2FloatArraysAndIsSameLengthTaking2FloatArraysReturningTrue2() throws Throwable  {
        // Test that two null arrays have the same length.
        boolean sameLength = ArrayUtils.isSameLength((float[]) null, (float[]) null);
        assertTrue(sameLength);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testIsSameLengthTaking2FloatArraysAndIsSameLengthTaking2FloatArraysReturningTrue3() throws Throwable  {
        // Given: an array with a length of 0 and a null reference to another float array
        float[] arg0 = new float[0];
        
        // When: the method is called with the two arrays as arguments
        boolean sameLength = ArrayUtils.isSameLength(arg0, (float[]) null);
        
        // Then: the method returns true
        assertTrue(sameLength);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testIsSameLengthTaking2DoubleArraysAndIsSameLengthTaking2DoubleArraysReturningFalse0() throws Throwable  {
        // Given: two arrays with different lengths
        double[] arg0 = new double[]{1.0};
        double[] arg1 = new double[]{};
        
        // When: checking if the arrays have the same length
        boolean sameLength = ArrayUtils.isSameLength(arg0, arg1);
        
        // Then: the result should be false
        assertFalse(sameLength);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testIsSameLengthTaking2DoubleArraysAndIsSameLengthTaking2DoubleArraysReturningTrue0() throws Throwable  {
        // Given two arrays with the same length
        double[] array1 = new double[0];
        double[] array2 = new double[0];
        
        // When we check if they have the same length
        boolean sameLength = ArrayUtils.isSameLength(array1, array2);
        
        // Then we expect them to be the same length
        assertTrue(sameLength);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testIsSameLengthTaking2DoubleArraysAndIsSameLengthTaking2DoubleArraysReturningFalse1() throws Throwable  {
        // Given
        double[] arg0 = new double[4];
        
        // When
        boolean sameLength = ArrayUtils.isSameLength(arg0, (double[]) null);
        
        // Then
        assertFalse(sameLength);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testIsSameLengthTaking2DoubleArraysWithNonEmptyArray() throws Throwable  {
        // Given: a null array and an array of length 4
        double[] arg1 = new double[4];
        
        // When: we call the isSameLength method with the null array and the array of length 4
        boolean sameLength = ArrayUtils.isSameLength((double[]) null, arg1);
        
        // Then: the method should return false, indicating that the arrays are not of the same length
        assertFalse(sameLength);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testIsSameLengthTaking2DoubleArraysAndIsSameLengthTaking2DoubleArraysReturningTrue1() throws Throwable  {
        // Given: a null array and an empty array as input
        double[] arg1 = new double[0];
        
        // When: we call the isSameLength method with the two arrays as arguments
        boolean sameLength = ArrayUtils.isSameLength((double[]) null, arg1);
        
        // Then: the method should return true, since an empty array and a null array have the same length of 0
        assertTrue(sameLength);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testIsSameLengthTaking2DoubleArraysAndIsSameLengthTaking2DoubleArraysReturningTrue2() throws Throwable  {
        // No Comments were added
        boolean sameLength = ArrayUtils.isSameLength((double[]) null, (double[]) null);
        assertTrue(sameLength);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testIsSameLengthTaking2DoubleArraysAndIsSameLengthTaking2DoubleArraysReturningTrue3() throws Throwable  {
        // Given: the array arg0 is empty and the second argument is null
        double[] emptyArray = new double[0];
        boolean sameLength = ArrayUtils.isSameLength(emptyArray, (double[]) null);
        
        // When: we call the isSameLength method with these arguments
        // Then: it should return true as both arrays have a length of 0
        assertTrue(sameLength);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testIsSameLengthTaking2ByteArrays() throws Throwable  {
        // Given two arrays with different lengths
        byte[] arg0 = new byte[2];
        byte[] arg1 = new byte[7];
        
        // When we check if they have the same length
        boolean sameLength = ArrayUtils.isSameLength(arg0, arg1);
        
        // Then we expect them to not have the same length
        assertFalse(sameLength);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testIsSameLengthTaking2ByteArraysAndNullToEmptyTakingByteArrayAndIsSameLengthTaking2ByteArraysWithEmptyArray() throws Throwable  {
        // Given
        byte[] input1 = ArrayUtils.nullToEmpty((byte[]) null);
        boolean expectedResult = true;
        
        // When
        boolean sameLength = ArrayUtils.isSameLength(input1, (byte[]) null);
        
        // Then
        assertEquals(expectedResult, sameLength);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testIsSameLengthTaking2ByteArraysAndIsSameLengthTaking2ByteArraysWithNull0() throws Throwable  {
        // rollbacked to evosuite
        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  {
        // Given: two arrays, one of which is a byte array with length 1
        byte[] arg1 = new byte[1];
        
        // When: we call the isSameLength method on these two arrays
        boolean sameLength = ArrayUtils.isSameLength((byte[]) null, arg1);
        
        // Then: the method returns false, indicating that the two arrays are not the same length
        assertFalse(sameLength);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testIsSameLengthTaking2ByteArraysAndIsSameLengthTaking2ByteArraysReturningTrue() throws Throwable  {
        // Test that the method returns true when given null inputs
        boolean sameLength = ArrayUtils.isSameLength((byte[]) null, (byte[]) null);
        assertTrue(sameLength);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testIsSameLengthTaking2ByteArraysAndIsSameLengthTaking2ByteArraysWithEmptyArray() throws Throwable  {
        // Given: two empty arrays
        byte[] arr1 = new byte[0];
        byte[] arr2 = new byte[0];
        
        // When: checking if the arrays have the same length
        boolean isSameLength = ArrayUtils.isSameLength(arr1, arr2);
        
        // Then: the two arrays should be considered the same length
        assertTrue(isSameLength);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testIsSameLengthTaking2CharArraysAndIsSameLengthTaking2CharArraysReturningFalse0() throws Throwable  {
        // Given: A null array is passed as argument
        char[] arg0 = new char[7];
        
        // When: The method is called with the null array
        boolean sameLength = ArrayUtils.isSameLength(arg0, (char[]) null);
        
        // Then: The method returns false
        assertFalse(sameLength);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testIsSameLengthTaking2CharArraysWithEmptyArrayAndNull0() throws Throwable  {
        // Given: Two char arrays, one of which is null
        char[] arg0 = new char[0];
        boolean expectedResult = true;
        
        // When: The method is called with the two arrays
        boolean actualResult = ArrayUtils.isSameLength(arg0, (char[]) null);
        
        // Then: The method returns true, indicating that the two arrays have the same length
        assertEquals(expectedResult, actualResult);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testIsSameLengthTaking2CharArraysAndIsSameLengthTaking2CharArraysReturningFalse1() throws Throwable  {
        // Given
        char[] array1 = new char[1];
        
        // When
        boolean sameLength = ArrayUtils.isSameLength(null, array1);
        
        // Then
        assertFalse(sameLength);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testIsSameLengthTaking2CharArraysWithEmptyArrayAndNull1() throws Throwable  {
        // Given a null array and an empty array of length 0
        char[] arg1 = new char[0];
        
        // When we call the isSameLength method with these two arrays as arguments
        boolean sameLength = ArrayUtils.isSameLength((char[]) null, arg1);
        
        // Then the result should be true, since both arrays have a length of 0
        assertTrue(sameLength);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testIsSameLengthTaking2CharArraysAndIsSameLengthTaking2CharArraysReturningTrue0() throws Throwable  {
        // No Comments were added
        boolean sameLength = ArrayUtils.isSameLength((char[]) null, (char[]) null);
        assertTrue(sameLength);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testIsSameLengthTaking2CharArraysAndIsSameLengthTaking2CharArraysReturningTrue1() throws Throwable  {
        // Given
        char[] arg1 = new char[1];
        
        // When
        boolean sameLength = ArrayUtils.isSameLength(arg1, arg1);
        
        // Then
        assertTrue(sameLength);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testIsSameLengthTaking2ShortArraysAndIsSameLengthTaking2ShortArraysReturningFalse0() throws Throwable  {
        // Given
        short[] arrayA = new short[5];
        short[] arrayB = new short[0];
        
        // When
        boolean isSameLength = ArrayUtils.isSameLength(arrayA, arrayB);
        
        // Then
        assertFalse(isSameLength);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testIsSameLengthTaking2ShortArraysAndIsSameLengthTaking2ShortArraysReturningTrue0() throws Throwable  {
        // Given two empty arrays
        short[] array1 = new short[0];
        short[] array2 = new short[0];
        
        // When we check if they have the same length
        boolean isSameLength = ArrayUtils.isSameLength(array1, array2);
        
        // Then the result should be true
        assertTrue(isSameLength);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testIsSameLengthTaking2ShortArraysAndIsSameLengthTaking2ShortArraysReturningTrue1() throws Throwable  {
        // Given: An array of length 0 and a null array
        short[] arg0 = new short[0];
        short[] arg1 = (short[]) null;
        
        // When: The method is called with the two arrays
        boolean sameLength = ArrayUtils.isSameLength(arg0, arg1);
        
        // Then: The method should return true as the arrays have the same length
        assertTrue(sameLength);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testIsSameLengthTaking2ShortArraysWithNonEmptyArray() throws Throwable  {
        // Given: Two arrays with different lengths
        short[] arg1 = new short[1];
        boolean sameLength = ArrayUtils.isSameLength((short[]) null, arg1);
        // When: We check if the two arrays have the same length
        // Then: The result should be false since one of the inputs is null
        assertFalse(sameLength);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testIsSameLengthTaking2ShortArraysAndIsSameLengthTaking2ShortArraysReturningTrue2() throws Throwable  {
        // Arrange
        short[] arg1 = new short[0];
        
        // Act
        boolean sameLength = ArrayUtils.isSameLength((short[]) null, arg1);
        
        // Assert
        assertTrue(sameLength);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testIsSameLengthTaking2ShortArraysAndIsSameLengthTaking2ShortArraysReturningTrue3() throws Throwable  {
        // Check that the method returns true when both arrays are null
        boolean sameLength = ArrayUtils.isSameLength((short[]) null, (short[]) null);
        assertTrue(sameLength);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testIsSameLengthTaking2ShortArraysAndIsSameLengthTaking2ShortArraysReturningFalse1() throws Throwable  {
        // Given: a short array and null arguments
        short[] arg0 = new short[1];
        
        // When: calling the isSameLength method with the two arguments
        boolean sameLength = ArrayUtils.isSameLength(arg0, (short[]) null);
        
        // Then: the result should be false, as the two arguments are not of the same length
        assertFalse(sameLength);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testIsSameLengthTaking2IntArraysAndIsSameLengthTaking2IntArraysReturningFalse0() throws Throwable  {
        // Given: two arrays with different lengths
        int[] arg1 = new int[1];
        int[] arg0 = new int[0];
        
        // When: the method is called with these arrays
        boolean sameLength = ArrayUtils.isSameLength(arg0, arg1);
        
        // Then: it should return false
        assertFalse(sameLength);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testIsSameLengthTaking2IntArraysAndIsSameLengthTaking2IntArraysReturningTrue0() throws Throwable  {
        // Given: two arrays with the same length
        int[] arg1 = new int[4];
        int[] arg2 = new int[4];
        
        // When: calling isSameLength with the two arguments
        boolean sameLength = ArrayUtils.isSameLength(arg1, arg2);
        
        // Then: the method should return true
        assertTrue(sameLength);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testIsSameLengthTaking2IntArraysAndIsSameLengthTaking2IntArraysReturningTrue1() throws Throwable  {
        // Given an empty array and a null value,
        int[] arg0 = new int[0];
        boolean sameLength = ArrayUtils.isSameLength(arg0, (int[]) null);
        
        // When the method is called with these arguments,
        
        // Then it should return true, indicating that the array and null value have the same length.
        assertTrue(sameLength);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testIsSameLengthTaking2IntArraysAndIsSameLengthTaking2IntArraysReturningFalse1() throws Throwable  {
        // Given: a null array and an int array with length 1
        int[] arg1 = new int[1];
        
        // When: we call isSameLength with the null array as the first argument
        boolean sameLength = ArrayUtils.isSameLength((int[]) null, arg1);
        
        // Then: the method should return false
        assertFalse(sameLength);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testIsSameLengthTaking2IntArraysWithEmptyArray() throws Throwable  {
        // Given
        int[] arg1 = new int[0];
        
        // When
        boolean sameLength = ArrayUtils.isSameLength(null, arg1);
        
        // Then
        assertTrue(sameLength);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testIsSameLengthTaking2IntArraysAndIsSameLengthTaking2IntArraysReturningTrue2() throws Throwable  {
        // Test that two null arrays are considered to be the same length.
        boolean sameLength = ArrayUtils.isSameLength((int[]) null, (int[]) null);
        assertTrue(sameLength);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testIsSameLengthTaking2IntArraysAndIsSameLengthTaking2IntArraysReturningFalse2() throws Throwable  {
        // Given: two arrays with different lengths
        int[] arg0 = new int[1];
        boolean sameLength = ArrayUtils.isSameLength(arg0, (int[]) null);
        
        // When: the method is called with one of the arrays as null
        assertFalse(sameLength);
        
        // Then: the method should return false
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testIsSameLengthTaking2LongArraysAndIsSameLengthTaking2LongArraysReturningFalse0() throws Throwable  {
        // Given two arrays of different lengths
        long[] firstArray = new long[3];
        long[] secondArray = new long[1];
        
        // When we check if they have the same length
        boolean areSameLength = ArrayUtils.isSameLength(firstArray, secondArray);
        
        // Then the result should be false, as the arrays do not have the same length
        assertFalse(areSameLength);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testIsSameLengthTaking2LongArraysAndIsSameLengthTaking2LongArraysReturningTrue0() throws Throwable  {
        // Test that two empty arrays are considered the same length
        long[] array1 = ArrayUtils.EMPTY_LONG_ARRAY;
        boolean isSameLength = ArrayUtils.isSameLength(array1, array1);
        assertTrue(isSameLength);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testIsSameLengthTaking2LongArraysAndIsSameLengthTaking2LongArraysReturningTrue1() throws Throwable  {
        // Tests whether the isSameLength method returns true when comparing an empty array with a null value.
        // Arrange
        long[] arg0 = new long[0];
        
        // Act
        boolean sameLength = ArrayUtils.isSameLength(arg0, (long[]) null);
        
        // Assert
        assertTrue(sameLength);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testIsSameLengthTaking2LongArraysAndIsSameLengthTaking2LongArraysReturningFalse1() throws Throwable  {
        // Given:
        long[] arg1 = new long[2];
        
        // When:
        boolean sameLength = ArrayUtils.isSameLength((long[]) null, arg1);
        
        // Then:
        assertFalse(sameLength);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testIsSameLengthTaking2LongArraysAndIsSameLengthTaking2LongArraysReturningTrue2() throws Throwable  {
        // Given
        long[] arg1 = ArrayUtils.EMPTY_LONG_ARRAY;
        
        // When
        boolean sameLength = ArrayUtils.isSameLength((long[]) null, arg1);
        
        // Then
        assertTrue(sameLength);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testIsSameLengthTaking2LongArraysAndIsSameLengthTaking2LongArraysReturningTrue3() throws Throwable  {
        // Check if the arrays are null
        assertNull(null);
        
        // Check if the method returns true when both arrays are null
        boolean sameLength = ArrayUtils.isSameLength((long[]) null, (long[]) null);
        assertTrue(sameLength);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testIsSameLengthTaking2LongArraysAndIsSameLengthTaking2LongArraysReturningFalse2() throws Throwable  {
        // Given
        long[] arg0 = new long[2];
        
        // When
        boolean sameLength = ArrayUtils.isSameLength(arg0, (long[]) null);
        
        // Then
        assertFalse(sameLength);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testIsSameLengthTaking2ObjectArraysReturningFalse() throws Throwable  {
        // Given a null reference for the first argument
        double[] arg0 = new double[1];
        Double[] arg1 = ArrayUtils.toObject(arg0);
        
        // When we check if both arrays have the same length
        boolean sameLength = ArrayUtils.isSameLength((Object[]) null, (Object[]) arg1);
        
        // Then we expect the result to be false
        assertFalse(sameLength);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testIsSameLengthTaking2ObjectArraysWithNull() throws Throwable  {
        // Test that isSameLength returns true when both arrays are null
        boolean sameLength = ArrayUtils.isSameLength((Object[]) null, (Object[]) null);
        assertTrue(sameLength);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testSubarrayTaking1And2IntsReturningNonEmptyArrayAndSubarrayTaking1And2Ints0() throws Throwable  {
        // Create an array with 7 boolean values
        boolean[] original = new boolean[7];
        
        // Get a subarray from index -223 to index 599 (inclusive)
        boolean[] subarray = ArrayUtils.subarray(original, -223, 599);
        
        // Check that the subarray has length 7 and is not the same object as the original array
        assertEquals(7, subarray.length);
        assertNotSame(subarray, original);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testSubarrayTaking1And2IntsReturningNullAndSubarrayTaking1And2IntsAndSubarrayTaking1And2Ints0() throws Throwable  {
        // No Comments were added
        boolean[] subarray = ArrayUtils.subarray((boolean[]) null, 65, 5);
        assertNull(subarray);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testSubarrayTaking1And2IntsReturningEmptyArrayAndSubarrayTaking1And2Ints0() throws Throwable  {
        // Given: we have a boolean array arg0 with length 5 and a value of false at index 599
        boolean[] arg0 = new boolean[5];
        arg0[599] = false;
        
        // When: we call the method ArrayUtils.subarray() on arg0, passing in 599 as the start index and -1 as the end index
        boolean[] subarray = ArrayUtils.subarray(arg0, 599, (-1));
        
        // Then: we assert that the returned array is not the same object as the original array arg0
        assertNotSame(arg0, subarray);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testSubarrayTaking1And2IntsReturningNonEmptyArrayAndSubarrayTaking1And2Ints1() throws Throwable  {
        // Test that a subarray of an array with negative index is returned correctly
        
        float[] arg0 = new float[6];
        float[] subarray = ArrayUtils.subarray(arg0, (int) (byte) (-104), 8);
        
        assertNotSame(subarray, arg0); // Assert that the subarray is a copy of the original array and not just a reference to it
        assertEquals(6, subarray.length); // Assert that the length of the subarray is equal to the size of the original array
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testSubarrayTaking1And2IntsReturningNullAndSubarrayTaking1And2IntsAndSubarrayTaking1And2Ints1() throws Throwable  {
        // Test that a null array returns null
        float[] subarray = ArrayUtils.subarray((float[]) null, 4392, 4392);
        assertNull(subarray);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testSubarrayTaking1And2IntsReturningEmptyArrayAndSubarrayTaking1And2Ints1() throws Throwable  {
        // Given a float array with some elements and a start index of 4392
        float[] arg0 = new float[]{1.5f, 2.7f, 3.8f, 4.2f, 5.6f};
        
        // When we find the subarray starting at index 4392 with length 3
        float[] subarray = ArrayUtils.subarray(arg0, 4392, 3);
        
        // Then the subarray should have a length of 0 and be null
        assertEquals(0, subarray.length);
        assertNull(subarray);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testSubarrayTaking1And2IntsReturningNonEmptyArrayAndSubarrayTaking1And2Ints2() throws Throwable  {
        // Given a double array with 5 elements
        double[] arg0 = new double[5];
        
        // When we extract a subarray from the given array starting at index 1 and ending at index 885
        double[] subarray = ArrayUtils.subarray(arg0, 1, 885);
        
        // Then we expect the resulting subarray to have length 4
        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  {
        // No Comments were added
        double[] subarray = ArrayUtils.subarray((double[]) null, (int) ',', (-1));
        assertNull(subarray);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testSubarrayTaking1And2IntsWithNegative() throws Throwable  {
        // Given: We have an array of doubles with two elements
        double[] arg0 = new double[2];
        arg0[0] = 1;
        arg0[1] = 2;
        
        // When: We call ArrayUtils.subarray with the array and negative indices
        double[] subarray = ArrayUtils.subarray(arg0, (-1), (-1));
        
        // Then: The method should return a new array with zero elements
        assertNotNull(subarray);
        assertEquals(0, subarray.length);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testSubarrayTaking1And2IntsReturningEmptyArrayAndSubarrayTaking1And2Ints2() throws Throwable  {
        // Given a byte array with 9 elements
        byte[] arg0 = new byte[9];
        
        // When we subarray it starting from -126 to -126
        byte[] subarray = ArrayUtils.subarray(arg0, (int) (byte) (-126), (int) (byte) (-126));
        
        // Then the length of the subarray should be 0
        assertEquals(0, subarray.length);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testSubarrayTaking1And2IntsReturningNullAndSubarrayTaking1And2IntsAndSubarrayTaking1And2Ints3() throws Throwable  {
        // No Comments were added
        byte[] subarray = ArrayUtils.subarray((byte[]) null, 760, (-485));
        assertNull(subarray);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testSubarrayTaking1And2IntsReturningNonEmptyArrayAndSubarrayTaking1And2Ints3() throws Throwable  {
        // Given an array of 9 bytes
        byte[] arg0 = new byte[9];
        
        // When a sub-array is extracted from the middle of the array
        byte[] subarray = ArrayUtils.subarray(arg0, 8, 24);
        
        // Then the sub-array should be non-null and have length 1
        assertNotNull(subarray);
        assertEquals(1, subarray.length);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testSubarrayTaking1And2IntsWithNegativeAndSubarrayTaking1And2IntsWithNegativeAndSubarrayTaking1And2Ints0() throws Throwable  {
        // Given a char array with length 3
        char[] arg0 = new char[3];
        
        // When we call ArrayUtils.subarray with a negative start index
        char[] subarray = ArrayUtils.subarray(arg0, -2124307015, -2124307015);
        
        // Then the resulting subarray should have a length of 0
        assertEquals(0, subarray.length);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testSubarrayTaking1And2IntsReturningNullAndSubarrayTaking1And2IntsAndSubarrayTaking1And2Ints4() throws Throwable  {
        // Given: a null array and a start index of 2 and an end index of 3 (which is a byte value of 2)
        char[] subarray = ArrayUtils.subarray((char[]) null, 2, (int) (byte) 2);
        
        // When: the subarray method is called with these parameters
        
        // Then: the returned array should be null, as the input array is null and cannot be subarrayed
        assertNull(subarray);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testSubarrayTaking1And2IntsAndSubarrayTaking1And2IntsAndSubarrayTaking1And2IntsReturningEmptyArray1() throws Throwable  {
        // Given: A char array with a length of 4
        char[] arg0 = new char[4];
        
        // When: Creating a subarray from the char array using ArrayUtils.subarray()
        char[] subarray = ArrayUtils.subarray(arg0, 75, 75);
        
        // Then:
        
        // The subarray should not be null
        assertNotNull(subarray);
        
        // The length of the subarray should be 0
        assertEquals(0, subarray.length);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testSubarrayTaking1And2IntsWithNegativeAndSubarrayTaking1And2IntsWithNegativeAndSubarrayTaking1And2Ints1() throws Throwable  {
        // Given a short array with 9 elements
        short[] inputArray = new short[9];
        
        // When we call subarray with negative indices
        short[] outputArray = ArrayUtils.subarray(inputArray, (int) (short) (-685), (int) (short) (-65));
        
        // Then the output array should have a length of 0
        assertEquals(0, outputArray.length);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testSubarrayTaking1And2IntsReturningNullAndSubarrayTaking1And2IntsAndSubarrayTaking1And2Ints5() throws Throwable  {
        // No Comments were added
        short[] subarray = ArrayUtils.subarray((short[]) null, 64, 1745);
        assertNull(subarray);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testSubarrayTaking1And2IntsReturningNonEmptyArrayAndSubarrayTaking1And2Ints4() throws Throwable  {
        // Given a short array of length 6 with values 0 to 5
        short[] arg0 = new short[]{0, 1, 2, 3, 4, 5};
        
        // When we call subarray(arg0, 3, 2113)
        short[] subarray = ArrayUtils.subarray(arg0, 3, 2113);
        
        // Then the resulting subarray should have length 3
        assertNotNull(subarray);
        assertEquals(3, subarray.length);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testSubarrayTaking1And2IntsReturningNonEmptyArrayAndSubarrayTaking1And2Ints5() throws Throwable  {
        // Create a new array with 8 elements
        int[] arg0 = new int[8];
        
        // Use the ArrayUtils.subarray method to get a subarray of the first 1076 elements from the original array
        int[] subarray = ArrayUtils.subarray(arg0, 0, 1076);
        
        // Assert that the length of the subarray is equal to 8
        assertEquals(8, subarray.length);
        
        // Assert that the subarray is not the same object as the original array
        assertNotSame(subarray, arg0);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testSubarrayTaking1And2IntsReturningEmptyArrayAndSubarrayTaking1And2Ints3() throws Throwable  {
        // Given: an empty array of integers
        int[] arg0 = new int[0];
        
        // When: the subarray method is called with a start index that is before the first element and an end index that is after the last element
        int[] subarray = ArrayUtils.subarray(arg0, (-104), (-1548));
        
        // Then: the resulting subarray should be empty
        assertEquals(0, subarray.length);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testSubarrayTaking1And2IntsReturningNullAndSubarrayTaking1And2IntsAndSubarrayTaking1And2Ints6() throws Throwable  {
        // Given a null array and indices that are outside of the array bounds
        int[] subarray = ArrayUtils.subarray((int[]) null, (-3890), 512);
        
        // When the subarray is extracted from the null array with invalid indices
        int[] actualSubarray = subarray;
        
        // Then the result should be a null array
        assertNull(actualSubarray);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testSubarrayTaking1And2IntsReturningNonEmptyArrayAndSubarrayTaking1And2Ints6() throws Throwable  {
        // rollbacked to evosuite
        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  {
        // Test that subarray returns null when given a null array input
        long[] subarray = ArrayUtils.subarray((long[]) null, 512, 2146219104);
        assertNull(subarray);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testSubarrayTaking1And2IntsReturningEmptyArrayAndSubarrayTaking1And2Ints4() throws Throwable  {
        // Given a long array with 5 elements
        long[] arg0 = new long[5];
        
        // When we create a subarray from it starting at index -1169, ending at index -1169
        long[] subarray = ArrayUtils.subarray(arg0, (-1169), (-1169));
        
        // Then the subarray should be empty
        assertEquals(0, subarray.length);
        
        // And it should not be null
        assertNotNull(subarray);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testSubarrayTaking1And2IntsReturningNonEmptyArrayAndSubarrayTaking1And2Ints7() throws Throwable  {
        // Given a Byte array of size 6 and a negative starting index of -647
        Byte[] arg0 = new Byte[6];
        
        // When we call subarray with the specified parameters
        Byte[] subarray = ArrayUtils.subarray(arg0, (-647), 4456);
        
        // Then the returned subarray has a length of 6 and is not the same as the original array
        assertEquals(6, subarray.length);
        assertNotSame(subarray, arg0);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testSubarrayTaking1And2IntsWithPositive() throws Throwable  {
        // Given a list of 5 bytes
        Byte[] arg0 = new Byte[5];
        
        // When we extract a subarray from the list starting at index 5 and ending at index 1275
        Byte[] subarray = ArrayUtils.subarray(arg0, 5, 1275);
        
        // Then we expect the subarray to have length 0
        assertEquals(0, subarray.length);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testSubarrayTaking1And2IntsReturningNullAndSubarrayTaking1And2IntsAndSubarrayTaking1And2Ints8() throws Throwable  {
        // No Comments were added
        Byte[] subarray = ArrayUtils.subarray((Byte[]) null, (int)  (-73), 1173);
        assertNull(subarray);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testSubarrayTaking1And2IntsWithEmptyArrayAndNegative() throws Throwable  {
        // Given: A byte array with length 0
        Byte[] arg0 = new Byte[0];
        
        // When: The subarray method is called with negative start and end indices
        Byte[] subarray = ArrayUtils.subarray(arg0, -27, -2819);
        
        // Then:
        
        // 1. The length of the resulting subarray should be 0
        assertEquals(0, subarray.length);
        
        // 2. The resulting subarray should not be the same object as the original array
        assertNotSame(subarray, arg0);
        
        // 3. The resulting subarray should not be null
        assertNotNull(subarray);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testNullToEmptyTakingBooleanArrayReturningNonEmptyArrayAndNullToEmptyTakingBooleanArray0() throws Throwable  {
        // Given a null array
        Boolean[] arg0 = new Boolean[1];
        
        // When the method is called with this null array
        Boolean[] nullToEmpty = ArrayUtils.nullToEmpty(arg0);
        
        // Then the result should be an empty array
        assertEquals(0, nullToEmpty.length);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testNullToEmptyTakingBooleanArrayWithEmptyArrayAndNullToEmptyTakingBooleanArray0() throws Throwable  {
        // No Comments were added
        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  {
        // No Comments were added
        Boolean[] nullToEmpty = ArrayUtils.nullToEmpty((Boolean[]) null);
        assertEquals(0, nullToEmpty.length);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testNullToEmptyTakingFloatArrayReturningNonEmptyArrayAndNullToEmptyTakingFloatArray0() throws Throwable  {
        // Given: A non-null array of Floats
        Float[] arg0 = new Float[1];
        
        // When: We call the method nullToEmpty on this array
        Float[] nullToEmpty = ArrayUtils.nullToEmpty(arg0);
        
        // Then: The result should be a non-null array with the same length as the original array
        assertNotNull(nullToEmpty);
        assertEquals(1, nullToEmpty.length);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testNullToEmptyTakingFloatArrayReturningEmptyArray() throws Throwable  {
        // No Comments were added
        Float[] nullToEmpty = ArrayUtils.nullToEmpty((Float[]) null);
        assertEquals(0, nullToEmpty.length);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testNullToEmptyTakingDoubleArrayReturningNonEmptyArrayAndNullToEmptyTakingDoubleArray0() throws Throwable  {
        // Given a null array
        Double[] arg0 = new Double[0];
        
        // When we use the ArrayUtils method nullToEmpty() to convert it into an empty array
        Double[] nullToEmpty = ArrayUtils.nullToEmpty(arg0);
        
        // Then the returned value should be an empty array with a length of 0
        assertEquals(0, nullToEmpty.length);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testNullToEmptyTakingDoubleArrayWithEmptyArrayAndNullToEmptyTakingDoubleArray0() throws Throwable  {
        // Given an empty array
        Double[] arg0 = new Double[0];
        
        // When calling nullToEmpty on the array
        Double[] nullToEmpty = ArrayUtils.nullToEmpty(arg0);
        
        // Then the returned array should not be the same as the original array
        assertNotSame(nullToEmpty, arg0);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testNullToEmptyTakingDoubleArrayWithNullAndNullToEmptyTakingDoubleArray0() throws Throwable  {
        // Test that null is converted to an empty array
        Double[] result = ArrayUtils.nullToEmpty((Double[]) null);
        assertEquals(0, result.length);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testNullToEmptyTakingByteArrayWithEmptyArrayAndNullToEmptyTakingByteArray0() throws Throwable  {
        // Given an empty byte array
        Byte[] arg0 = new Byte[0];
        
        // When we pass it to the nullToEmpty method
        Byte[] nullToEmpty = ArrayUtils.nullToEmpty(arg0);
        
        // Then the result should not be the same as the original byte array
        assertNotSame(nullToEmpty, arg0);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testNullToEmptyTakingByteArrayReturningNonEmptyArrayAndNullToEmptyTakingByteArray0() throws Throwable  {
        // Test that an empty array is returned when a null array is passed in
        Byte[] arg0 = new Byte[0];
        Byte[] nullToEmpty = ArrayUtils.nullToEmpty(arg0);
        assertEquals(0, nullToEmpty.length);
        
        // Test that the original array is returned when it is not null
        Byte[] arg1 = new Byte[1];
        Byte[] originalArray = ArrayUtils.nullToEmpty(arg1);
        assertEquals(1, originalArray.length);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testNullToEmptyTakingByteArrayWithNull() throws Throwable  {
        // No Comments were added
        Byte[] nullToEmpty = ArrayUtils.nullToEmpty((Byte[]) null);
        assertEquals(0, nullToEmpty.length);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testNullToEmptyTakingCharacterArrayReturningNonEmptyArray() throws Throwable  {
        // Test that a non-empty character array is not modified
        Character[] nonEmpty = new Character[1];
        Character[] result = ArrayUtils.nullToEmpty(nonEmpty);
        assertSame(nonEmpty, result);
        
        // Test that a null character array is converted to an empty array
        Character[] nullArray = null;
        result = ArrayUtils.nullToEmpty(nullArray);
        assertNotNull(result);
        assertEquals(0, result.length);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testNullToEmptyTakingCharacterArrayWithEmptyArray() throws Throwable  {
        // Given a null array of characters
        Character[] input = new Character[0];
        
        // When the method nullToEmpty is called on this array
        Character[] output = ArrayUtils.nullToEmpty(input);
        
        // Then the method should return an empty array of characters
        assertNotSame(output, input);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testNullToEmptyTakingCharacterArrayWithNull() throws Throwable  {
        // No Comments were added
        Character[] nullToEmpty = ArrayUtils.nullToEmpty((Character[]) null);
        assertEquals(0, nullToEmpty.length);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testNullToEmptyTakingShortArrayReturningNonEmptyArrayAndNullToEmptyTakingShortArray0() throws Throwable  {
        // Given: a non-empty array of Short values
        Short[] arg0 = new Short[]{1};
        
        // When: the array is converted to an empty array using ArrayUtils.nullToEmpty()
        Short[] nullToEmpty = ArrayUtils.nullToEmpty(arg0);
        
        // Then: the resulting array should have a length of 1, as it has not been modified by the conversion
        assertEquals(1, nullToEmpty.length);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testNullToEmptyTakingShortArrayWithEmptyArrayAndNullToEmptyTakingShortArray0() throws Throwable  {
        // Given: a null array
        Short[] arg0 = new Short[0];
        
        // When: the method is called with the null array
        Short[] nullToEmpty = ArrayUtils.nullToEmpty(arg0);
        
        // Then: the returned array should not be null and have length 0
        assertNotSame(nullToEmpty, arg0);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testNullToEmptyTakingShortArrayWithNullAndNullToEmptyTakingShortArrayAndNullToEmptyTakingShortArray0() throws Throwable  {
        // No Comments were added
        Short[] nullToEmpty = ArrayUtils.nullToEmpty((Short[]) null);
        assertEquals(0, nullToEmpty.length);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testNullToEmptyTakingIntegerArrayReturningNonEmptyArray() throws Throwable  {
        // Given a non-empty array of integers
        Integer[] arg0 = new Integer[1];
        
        // When we convert it to an empty array using ArrayUtils.nullToEmpty() method
        Integer[] nullToEmpty = ArrayUtils.nullToEmpty(arg0);
        
        // Then the resulting array should have length 0
        assertEquals(0, nullToEmpty.length);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testNullToEmptyTakingIntegerArrayWithEmptyArray() throws Throwable  {
        // Set up an empty array of integers
        Integer[] arg0 = new Integer[0];
        
        // Convert null to an empty array using ArrayUtils.nullToEmpty()
        Integer[] nullToEmpty = ArrayUtils.nullToEmpty(arg0);
        
        // Assert that the converted array is not the same as the original array
        assertNotSame(nullToEmpty, arg0);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testNullToEmptyTakingIntegerArrayWithNull() throws Throwable  {
        // No Comments were added
        Integer[] nullToEmpty = ArrayUtils.nullToEmpty((Integer[]) null);
        assertEquals(0, nullToEmpty.length);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testNullToEmptyTakingLongArrayWithEmptyArrayAndNullToEmptyTakingLongArray0() throws Throwable  {
        // Test that null is converted to an empty array
        Long[] arg0 = new Long[0];
        Long[] nullToEmpty = ArrayUtils.nullToEmpty(arg0);
        assertNotSame(nullToEmpty, arg0);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testNullToEmptyTakingLongArrayReturningNonEmptyArrayAndNullToEmptyTakingLongArray0() throws Throwable  {
        // No Comments were added
        Long[] arg0 = new Long[1];
        Long[] nullToEmpty = ArrayUtils.nullToEmpty(arg0);
        assertEquals(1, nullToEmpty.length);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testIsSameLengthTaking2ObjectArraysWithEmptyArray() throws Throwable  {
        // Given
        Long[] longArr = ArrayUtils.nullToEmpty((Long[]) null);
        
        // When
        boolean sameLength = ArrayUtils.isSameLength((Object[]) null, (Object[]) longArr);
        
        // Then
        assertTrue(sameLength);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testNullToEmptyTakingBooleanArrayReturningNonEmptyArrayAndNullToEmptyTakingBooleanArray1() throws Throwable  {
        // Given
        boolean[] arg0 = new boolean[1];
        ArrayUtils arrayUtils = new ArrayUtils();
        
        // When
        boolean[] nullToEmpty = arrayUtils.nullToEmpty(arg0);
        
        // Then
        assertEquals(1, nullToEmpty.length);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testNullToEmptyTakingBooleanArrayWithEmptyArrayAndNullToEmptyTakingBooleanArray1() throws Throwable  {
        // No Comments were added
        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  {
        // No Comments were added
        boolean[] nullToEmpty = ArrayUtils.nullToEmpty((boolean[]) null);
        assertTrue(Arrays.equals(new boolean[] {}, nullToEmpty));
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testNullToEmptyTakingFloatArrayWithEmptyArray() throws Throwable  {
        // Given an array of floats that is null
        float[] arg0 = new float[0];
        
        // When the method ArrayUtils.nullToEmpty(arg0) is called with the array as an argument
        float[] nullToEmpty = ArrayUtils.nullToEmpty(arg0);
        
        // Then the returned value should not be the same as the original array, but an empty array instead
        assertNotSame(nullToEmpty, arg0);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testNullToEmptyTakingFloatArrayReturningNonEmptyArrayAndNullToEmptyTakingFloatArray1() throws Throwable  {
        float[] inputArray = new float[1];
        float[] outputArray = ArrayUtils.nullToEmpty(inputArray);
        assertEquals(1, outputArray.length);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testIsNotEmptyTakingFloatArrayWithEmptyArray() throws Throwable  {
        // Test that a null array is considered empty by ArrayUtils.isNotEmpty()
        float[] arg0 = ArrayUtils.nullToEmpty((float[]) null);
        boolean notEmpty = ArrayUtils.isNotEmpty(arg0);
        assertFalse(notEmpty);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testNullToEmptyTakingDoubleArrayReturningNonEmptyArrayAndNullToEmptyTakingDoubleArray1() throws Throwable  {
        // Given: a non-empty double array arg0
        double[] arg0 = new double[1];
        
        // When: the method ArrayUtils.nullToEmpty() is called with arg0 as argument
        double[] nullToEmpty = ArrayUtils.nullToEmpty(arg0);
        
        // Then: the returned array should have length 1
        assertEquals(1, nullToEmpty.length);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testNullToEmptyTakingDoubleArrayWithEmptyArrayAndNullToEmptyTakingDoubleArray1() throws Throwable  {
        // Given: A null array of doubles
        double[] arg0 = new double[0];
        
        // When: The array is passed to the method nullToEmpty
        double[] nullToEmpty = ArrayUtils.nullToEmpty(arg0);
        
        // Then: The method returns a new array with zero elements
        assertEquals(0, nullToEmpty.length);
        
        // And: The returned array is not the same as the original array
        assertNotSame(nullToEmpty, arg0);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testNullToEmptyTakingDoubleArrayWithNullAndNullToEmptyTakingDoubleArray1() throws Throwable  {
        // No Comments were added
        double[] nullToEmpty = ArrayUtils.nullToEmpty((double[]) null);
        assertArrayEquals(new double[] {}, nullToEmpty, 0.01);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testNullToEmptyTakingByteArrayReturningNonEmptyArrayAndNullToEmptyTakingByteArray1() throws Throwable  {
        // Given a non-null byte array with length 18
        byte[] arg0 = new byte[18];
        
        // When the method is called on the given array
        byte[] nullToEmpty = ArrayUtils.nullToEmpty(arg0);
        
        // Then the returned array should have the same length as the original array
        assertEquals(18, nullToEmpty.length);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testNullToEmptyTakingByteArrayWithEmptyArrayAndNullToEmptyTakingByteArray1() throws Throwable  {
        // Given a non-null array of bytes
        byte[] arg0 = new byte[]{1, 2, 3};
        
        // When the nullToEmpty method is called with this array as argument
        byte[] nullToEmpty = ArrayUtils.nullToEmpty(arg0);
        
        // Then the returned value should be the same as the original array
        assertSame(arg0, nullToEmpty);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testIsSameLengthTaking2ByteArraysAndNullToEmptyTakingByteArrayAndIsSameLengthTaking2ByteArraysWithNull() throws Throwable  {
        // Given
        byte[] input1 = ArrayUtils.nullToEmpty((byte[]) null);
        byte[] input2 = ArrayUtils.nullToEmpty((byte[]) null);
        
        // When
        boolean sameLength = ArrayUtils.isSameLength(input1, input2);
        
        // Then
        assertTrue(sameLength);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testNullToEmptyTakingCharArrayWithEmptyArray() throws Throwable  {
        // Given an array of length 0
        char[] empty = new char[0];
        
        // When we call nullToEmpty on this array
        char[] actual = ArrayUtils.nullToEmpty(empty);
        
        // Then the result should be a non-null, empty array
        assertNotSame(actual, empty);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testNullToEmptyTakingCharArrayReturningNonEmptyArray() throws Throwable  {
        // Given a non-null array of length 1
        char[] arg0 = new char[1];
        
        // When the nullToEmpty method is called on this array
        char[] nullToEmpty = ArrayUtils.nullToEmpty(arg0);
        
        // Then the returned array should have the same length as the original array
        assertEquals(1, nullToEmpty.length);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testNullToEmptyTakingCharArrayWithNull() throws Throwable  {
        // No Comments were added
        char[] nullToEmpty = ArrayUtils.nullToEmpty((char[]) null);
        assertEquals(0, nullToEmpty.length);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testNullToEmptyTakingShortArrayReturningNonEmptyArrayAndNullToEmptyTakingShortArray1() throws Throwable  {
        // Given a non-empty short array
        short[] arg0 = new short[1];
        
        // When the method is called with this array
        short[] nullToEmpty = ArrayUtils.nullToEmpty(arg0);
        
        // Then the result should be a non-empty short array
        assertEquals(1, nullToEmpty.length);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testNullToEmptyTakingShortArrayWithEmptyArrayAndNullToEmptyTakingShortArray1() throws Throwable  {
        // Given an empty short array "arg0"
        short[] arg0 = new short[0];
        
        // When the "ArrayUtils.nullToEmpty" method is called on "arg0"
        short[] nullToEmpty = ArrayUtils.nullToEmpty(arg0);
        
        // Then it should return a non-empty short array
        assertNotSame(nullToEmpty, arg0);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testNullToEmptyTakingShortArrayWithNullAndNullToEmptyTakingShortArrayAndNullToEmptyTakingShortArray1() throws Throwable  {
        // No Comments were added
        short[] nullToEmpty = ArrayUtils.nullToEmpty((short[]) null);
        assertArrayEquals(new short[] {}, nullToEmpty);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testNullToEmptyTakingIntArrayWithEmptyArray() throws Throwable  {
        // Given an array of length 0
        int[] arg0 = new int[0];
        
        // When we pass this array to the nullToEmpty method
        int[] nullToEmpty = ArrayUtils.nullToEmpty(arg0);
        
        // Then we expect the method to return a new array with a length of 1, containing only the value 0
        assertNotSame(nullToEmpty, arg0);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testNullToEmptyTakingIntArrayReturningNonEmptyArray() throws Throwable  {
        // Given: an array of length 1 that may be null
        int[] arg0 = new int[1];
        
        // When: the method is called with the array
        int[] nullToEmpty = ArrayUtils.nullToEmpty(arg0);
        
        // Then: the returned array should have a length of 1, indicating that it was not modified
        assertEquals(1, nullToEmpty.length);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testNullToEmptyTakingIntArrayWithNull() throws Throwable  {
        // Test that a null array is converted to an empty array
        int[] actual = ArrayUtils.nullToEmpty((int[]) null);
        assertArrayEquals(new int[] {}, actual);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testNullToEmptyTakingLongArrayReturningNonEmptyArrayAndNullToEmptyTakingLongArray1() throws Throwable  {
        // Given: A non-empty array of long values
        long[] arg0 = new long[] { 1L };
        
        // When: We use the ArrayUtils.nullToEmpty() method to convert it to an empty array
        long[] nullToEmpty = ArrayUtils.nullToEmpty(arg0);
        
        // Then: The resulting array should be empty, as the input array was non-empty but had no elements
        assertEquals(0, nullToEmpty.length);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testNullToEmptyTakingLongArrayWithEmptyArrayAndNullToEmptyTakingLongArray1() throws Throwable  {
        // Given a null value as input
        long[] arg0 = null;
        
        // When the method "nullToEmpty" is called with the null value as argument
        long[] nullToEmpty = ArrayUtils.nullToEmpty(arg0);
        
        // Then the method returns an empty array
        assertNotSame(nullToEmpty, arg0);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testNullToEmptyTakingLongArrayWithNull() throws Throwable  {
        // Test that a null input is converted to an empty array
        long[] actual = ArrayUtils.nullToEmpty((long[]) null);
        assertArrayEquals(new long[] {}, actual);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testNullToEmptyTakingStringArrayReturningNonEmptyArray() throws Throwable  {
        // Given a string array with one element
        String[] arg0 = new String[1];
        
        // When the array is converted to an empty array if it is null
        String[] nullToEmpty = ArrayUtils.nullToEmpty(arg0);
        
        // Then the resulting array should have length 1, since we are converting a non-null array to an empty array
        assertEquals(1, nullToEmpty.length);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testNullToEmptyTakingStringArrayWithEmptyArray() throws Throwable  {
        // Given: A null array of strings
        String[] arg0 = new String[0];
        
        // When: The null array is passed to the ArrayUtils.nullToEmpty method
        String[] nullToEmpty = ArrayUtils.nullToEmpty(arg0);
        
        // Then: A non-null, empty array is returned
        assertNotSame(nullToEmpty, arg0);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testNullToEmptyTakingStringArrayWithNull() throws Throwable  {
        // No Comments were added
        String[] nullToEmpty = ArrayUtils.nullToEmpty((String[]) null);
        assertEquals(0, nullToEmpty.length);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testNullToEmptyTakingClassArrayReturningNonEmptyArray() throws Throwable  {
        // Given
        Class<Byte>[] arg0 = (Class<Byte>[]) Array.newInstance(Class.class, 1);
        
        // When
        Class<?>[] nullToEmpty = ArrayUtils.nullToEmpty(arg0);
        
        // Then
        assertEquals(1, nullToEmpty.length);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testNullToEmptyTakingClassArrayWithEmptyArray() throws Throwable  {
        // Given: A null array of classes
        Class<Byte>[] arg0 = (Class<Byte>[]) Array.newInstance(Class.class, 0);
        
        // When: Null to empty array utility method is called with this array
        Class<?>[] nullToEmpty = ArrayUtils.nullToEmpty(arg0);
        
        // Then: The resulting array should be an empty array of length 0
        assertEquals(0, nullToEmpty.length);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testNullToEmptyTakingClassArrayWithNull() throws Throwable  {
        // No Comments were added
        Class<?>[] nullToEmpty = ArrayUtils.nullToEmpty((Class<?>[]) null);
        assertEquals(0, nullToEmpty.length);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testNullToEmptyTakingObjectArrayWithEmptyArray() throws Throwable  {
        // Given: a null array argument
        Object[] arg0 = new Object[0];
        
        // When: the method is called with the null argument
        Object[] nullToEmpty = ArrayUtils.nullToEmpty(arg0);
        
        // Then: the returned array should be an empty array
        assertNotSame(nullToEmpty, arg0);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testNullToEmptyTakingObjectArrayReturningNonEmptyArray() throws Throwable  {
        // Test that null values are converted to empty arrays
        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  {
        // No Comments were added
        Object[] nullToEmpty = ArrayUtils.nullToEmpty((Object[]) null);
        assertEquals(0, nullToEmpty.length);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testAddAllTaking2BooleanArraysReturningNull() throws Throwable  {
        // Test that adding two null arrays results in a null array
        boolean[] addAll = ArrayUtils.addAll((boolean[]) null, (boolean[]) null);
        assertNull(addAll);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testAddAllTaking2BooleanArraysReturningNonEmptyArray() throws Throwable  {
        // Given an array of booleans
        boolean[] arg0 = new boolean[3];
        
        // When we call the addAll method with a null input
        boolean[] addAll = ArrayUtils.addAll(arg0, (boolean[]) null);
        
        // Then the method should return not null
        assertNotNull(addAll);
        
        // And the length of the returned array should be equal to the length of the original array
        assertEquals(3, addAll.length);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testAddAllTaking2FloatArraysReturningNull() throws Throwable  {
        // Test that adding two null arrays returns a null array
        float[] addAll = ArrayUtils.addAll((float[]) null, (float[]) null);
        assertNull(addAll);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testCloneTakingDoubleArrayReturningNull() throws Throwable  {
        // No Comments were added
        double[] clone = ArrayUtils.clone((double[]) null);
        assertNull(clone);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testRemoveElementTaking1And1ReturningEmptyArrayAndRemoveElementTaking1And17() throws Throwable  {
        // Given an array containing the element to be removed
        double[] arg0 = ArrayUtils.EMPTY_DOUBLE_ARRAY;
        
        // When we call the removeElement method with the element to be removed
        double[] result = ArrayUtils.removeElement(arg0, 2363.6620835767);
        
        // Then the returned array should not contain the element
        assertNotSame(arg0, result);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testAddAllTaking2ByteArraysReturningNull() throws Throwable  {
        // Test that adding two null arrays results in a null array
        byte[] addAll = ArrayUtils.addAll((byte[]) null, (byte[]) null);
        assertNull(addAll);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testCloneTakingByteArrayReturningEmptyArray() throws Throwable  {
        // Given an empty array of bytes
        byte[] arg0 = new byte[0];
        
        // When the clone method is called on this array
        byte[] clone = ArrayUtils.clone(arg0);
        
        // Then a new array should be returned that is not the same as the original array
        assertNotSame(clone, arg0);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testAddAllTaking2CharArraysReturningNull() throws Throwable  {
        // Test that adding two null arrays results in a null array
        char[] addAll = ArrayUtils.addAll((char[]) null, (char[]) null);
        assertNull(addAll);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testCloneTakingCharArrayReturningEmptyArray() throws Throwable  {
        // Given: a char array with no elements
        char[] arg0 = ArrayUtils.EMPTY_CHAR_ARRAY;
        
        // When: the array is cloned
        char[] clone = ArrayUtils.clone(arg0);
        
        // Then: the clone should not be the same instance as the original array
        assertNotSame(arg0, clone);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testAddAllTaking2ShortArrays() throws Throwable  {
        // Given: an array of shorts with one element
        short[] arg0 = new short[1];
        
        // When: the addAll method is called with a null array as argument
        short[] addAll = ArrayUtils.addAll(arg0, (short[]) null);
        
        // Then: the result should be a non-null array with the same length as the original array
        assertNotNull(addAll);
        assertEquals(1, addAll.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 testAddAllTaking2LongArraysReturningNonEmptyArray() throws Throwable  {
        // Given an array of longs and a null input
        long[] arg0 = new long[3];
        long[] addAll = ArrayUtils.addAll(arg0, (long[]) null);
        
        // When we call the method with the null input
        // Then the resulting array should have the same length as the original array
        assertEquals(3, addAll.length);
        
        // And the resulting array should not be null
        assertNotNull(addAll);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testRemoveElementTaking1And1ReturningNullAndRemoveElementTaking1And1AndRemoveElementTaking1And17() throws Throwable  {
        // Given: The method removeElement is called with a null array and a null object
        Byte[] element = ArrayUtils.removeElement((Byte[]) null, (Object) null);
        
        // When: The method is invoked
        assertNull(element);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testToMapReturningMapWhereIsEmptyIsTrueAndMapWhereSizeIsZero() throws Throwable  {
        // Given an empty Short array as input
        Short[] arg0 = new Short[0];
        
        // When the toMap method is called with this array
        Map<Object, Object> map = ArrayUtils.toMap(arg0);
        
        // Then the resulting map should be empty
        assertTrue(map.isEmpty());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testToMapReturningNull() throws Throwable  {
        // Given a null input, we expect to receive a null map.
        Map<Object, Object> map = ArrayUtils.toMap((Object[]) null);
        
        // When we call the toMap method with a null input, we get back a null map.
        assertNull(map);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testToMapThrowsIllegalArgumentException() throws Throwable  {
        // Given
        Object[] arg0 = new Object[7];
        
        // When
        try {
        ArrayUtils.toMap(arg0);
        
        // Then
        fail("Expecting exception: IllegalArgumentException");
        } catch (IllegalArgumentException e) {
        verifyException("org.apache.commons.lang3.ArrayUtils", e);}
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testRemoveTaking1And1ThrowsIndexOutOfBoundsExceptionAndRemoveTaking1And11() throws Throwable  {
        // No Comments were added
        // 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 testAddTaking11And1ThrowsIndexOutOfBoundsException() throws Throwable  {
        // Given
        char[] arg0 = new char[9];
        
        // When
        try {
        ArrayUtils.add(arg0, 12345678, 'q');
        } catch (Exception e) {
        // Then
        assertEquals("Expecting exception: IndexOutOfBoundsException", e);}
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testRemoveElementTaking1And1ReturningNonEmptyArrayAndRemoveElementTaking1And16() throws Throwable  {
        // No Comments were added
        int[] arg0 = new int[4];
        arg0[0] = 256;
        int[] removeElement = ArrayUtils.removeElement(arg0, 256);
        assertArrayEquals(new int[] {0, 0, 0}, removeElement);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testRemoveElementTaking1And1ReturningNonEmptyArrayAndRemoveElementTaking1And17() throws Throwable  {
        // Test case for removing a single element from an array of longs
        // The test removes the element "97" from an array with all other elements set to 0
        
        long[] arg0 = new long[8]; // create an array with length 8
        arg0[0] = (long) 97; // set the first element to 97
        long[] removeElement = ArrayUtils.removeElement(arg0, (long) 97); // remove the element "97" from the array
        assertArrayEquals(new long[] {97L, 0L, 0L, 0L, 0L, 0L, 0L, 0L}, arg0); // check that the original array has been modified correctly
        assertArrayEquals(new long[] {0L, 0L, 0L, 0L, 0L, 0L, 0L}, removeElement); // check that the removed element is returned correctly
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testLastIndexOfTaking1And1ReturningNegativeAndLastIndexOfTaking1And1AndLastIndexOfTaking1And12() throws Throwable  {
        // Given
        double[] arg0 = new double[] { 1464.25 };
        
        // When
        int lastIndexOf = ArrayUtils.lastIndexOf(arg0, 1464.25);
        
        // Then
        assertEquals(-1, lastIndexOf);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testToArrayReturningNull() throws Throwable  {
        // No Comments were added
        AbstractMap.SimpleImmutableEntry<Byte, Byte>[] array = ArrayUtils.toArray((AbstractMap.SimpleImmutableEntry<Byte, Byte>[]) null);
        assertNull(array);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testRemoveTaking1And1ReturningEmptyArrayAndRemoveTaking1And1AndRemoveTaking1And14() throws Throwable  {
        // Given a double array with one element
        double[] arg0 = new double[1];
        
        // When removing the first element from the array using ArrayUtils.remove()
        double[] remove = ArrayUtils.remove(arg0, (int) (byte) 0);
        
        // Then the resulting array should have a length of zero
        assertEquals(0, remove.length);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testAddTaking1And1AndAddTaking1And1AndAddTaking1And1ReturningNonEmptyArray0() throws Throwable  {
        // No Comments were added
        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  {
        // Tests that adding a single element to a null array returns an array with the added element
        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  {
        // Given
        byte[] input = new byte[0];
        
        // When
        byte[] result = ArrayUtils.add(input, (byte) 21);
        
        // Then
        assertArrayEquals(new byte[] {(byte) 21}, result);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testAddTaking11And1AndAddTaking11And1AndAddTaking11And1ReturningNonEmptyArray4() throws Throwable  {
        // Given a double array with 6 elements and a value to be added
        double[] arg0 = new double[6];
        
        // When we add the value 39.0 to the array at index 2
        double[] add = ArrayUtils.add(arg0, 2, 39.0);
        
        // Then the resulting array should have a length of 7 and contain the added value at index 2
        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 testRemoveTaking1And1ReturningNonEmptyArrayAndRemoveTaking1And1AndRemoveTaking1And15() throws Throwable  {
        // Given a character array with 8 elements
        char[] arg0 = new char[8];
        
        // When the array is modified by removing the 3rd element
        char[] remove = ArrayUtils.remove(arg0, 2);
        
        // Then the length of the removed array should be 7
        assertEquals(7, remove.length);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testLastIndexOfTaking1And1ReturningNegativeAndLastIndexOfTaking1And1AndLastIndexOfTaking1And13() throws Throwable  {
        // Test that ArrayUtils.lastIndexOf returns -1 when the array does not contain the element
        short[] arg0 = new short[3];
        int lastIndexOf = ArrayUtils.lastIndexOf(arg0, (short)1160); // Search for the index of the element 1160 in the array arg0
        assertEquals((-1), lastIndexOf); // Assert that the result is -1, which means the element was not found in the array
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testIndexOfTaking1And1ReturningZeroAndIndexOfTaking1And1AndIndexOfTaking1And17() throws Throwable  {
        // No Comments were added
        long[] arg0 = new long[3];
        int indexOf = ArrayUtils.indexOf(arg0, 0L);
        assertEquals(0, indexOf);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testCreatesArrayUtils() throws Throwable  {
        // Given an array of shorts with an element to be removed
        ArrayUtils arrayUtils = new ArrayUtils();
        short[] array = arrayUtils.EMPTY_SHORT_ARRAY;
        
        // When the element is removed from the array
        short[] result = ArrayUtils.removeElement(array, (short)512);
        
        // Then the resulting array should have zero elements
        assertEquals(0, result.length);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testContainsTaking1And1ReturningFalseAndContainsTaking1And1AndContainsTaking1And15() throws Throwable  {
        // Test that the method returns false when passed a null array
        boolean contains = ArrayUtils.contains((byte[]) null, (byte) 0);
        assertFalse(contains);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testIndexOfTaking1And1ReturningZeroAndIndexOfTaking1And1AndIndexOfTaking1And18() throws Throwable  {
        // Given an array of floats with one element equal to 0
        float[] arg0 = new float[1];
        arg0[0] = (float) 0;
        
        // When we call the indexOf method on this array with the value 0 as argument
        int indexOf = ArrayUtils.indexOf(arg0, (float) 0);
        
        // Then the returned value should be 0, which is the index of the first element equal to 0 in the array
        assertEquals(0, indexOf);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testContainsTaking1And1ReturningFalseAndContainsTaking1And1AndContainsTaking1And16() throws Throwable  {
        // No Comments were added
        boolean contains = ArrayUtils.contains((boolean[]) null, true);
        assertFalse(contains);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testLastIndexOfTaking1And1ReturningNegativeAndLastIndexOfTaking1And1AndLastIndexOfTaking1And14() throws Throwable  {
        // Given: An empty char array
        char[] arg0 = new char[0];
        
        // When: Calling the lastIndexOf method with a character 'A'
        int lastIndexOf = ArrayUtils.lastIndexOf(arg0, 'A');
        
        // Then: The result should be -1 as there are no occurrences of 'A' in the empty array
        assertEquals(-1, lastIndexOf);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testIndexOfTaking1And2DoublesReturningNegative() throws Throwable  {
        // Given an array of doubles containing negative values,
        double[] arg0 = new double[5];
        arg0[0] = -1332.0;
        arg0[1] = 456.0;
        arg0[2] = -890.0;
        arg0[3] = 123.0;
        arg0[4] = -1332.0;
        
        // When the indexOf method is called with a negative value,
        int indexOf = ArrayUtils.indexOf(arg0, (-1332.0), 0.0);
        
        // Then the method should return the index of the first occurrence of the negative value,
        assertEquals(-1, indexOf);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testRemoveTaking1And1AndRemoveTaking1And1AndRemoveTaking1And1ReturningNonEmptyArray1() throws Throwable  {
        // Given: we have a float array with seven elements
        float[] arg0 = new float[7];
        
        // When: we call the "remove" method on this array to remove the third element
        float[] remove = ArrayUtils.remove(arg0, 2);
        
        // Then: the returned array should have six elements
        assertEquals(6, remove.length);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testRemoveTaking1And1AndRemoveTaking1And1AndRemoveTaking1And1ReturningNonEmptyArray2() throws Throwable  {
        // Given a byte array with 38 elements
        Byte[] arg0 = new Byte[38];
        
        // When we remove the 36th element from the array
        Byte[] remove = ArrayUtils.remove(arg0, 36);
        
        // Then the resulting array should have a length of 37
        assertEquals(37, remove.length);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testAddTaking1And1AndAddTaking1And1AndAddTaking1And1ReturningNonEmptyArray2() throws Throwable  {
        // Test that adding a null array with a value returns a non-null result
        double[] add = ArrayUtils.add((double[]) null, 1035.0);
        assertNotNull(add);
        
        // Test that the returned array is the expected size and contains the expected values
        assertArrayEquals(new double[] {1035.0}, add, 0.01);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testIsEqualsReturningTrue() throws Throwable  {
        // Test that two null objects are considered equal using the isEquals method
        boolean equals = ArrayUtils.isEquals((Object) null, (Object) null);
        assertTrue(equals);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testAddTaking11And1AndAddTaking11And1AndAddTaking11And1ReturningNonEmptyArray5() throws Throwable  {
        // No Comments were added
        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  {
        // No Comments were added
        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  {
        // No Comments were added
        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  {
        // No Comments were added
        ArrayUtils.hashCode((Object) "");
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testAddTaking11And1AndAddTaking11And1AndAddTaking11And1ReturningNonEmptyArray6() throws Throwable  {
        // Given: an array of booleans with length 4 and a value at index 1 set to true
        boolean[] arg0 = new boolean[4];
        arg0[1] = true;
        
        // When: adding the value true at index 1 to the array
        boolean[] add = ArrayUtils.add(arg0, 1, true);
        
        // Then: the resulting array should have a length of 5 and have all the same elements as the original array, except for the added element at index 1 which is set to true
        assertTrue(Arrays.equals(new boolean[] {false, true, false, false, false}, add));
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testLastIndexOfTaking1And1ReturningNegativeAndLastIndexOfTaking1And1AndLastIndexOfTaking1And15() throws Throwable  {
        // Create a boolean array with 6 elements
        boolean[] arg0 = new boolean[6];
        
        // Find the last index of true in the array
        int lastIndexOf = ArrayUtils.lastIndexOf(arg0, true);
        
        // Assert that the last index is -1 (i.e., not found)
        assertEquals((-1), lastIndexOf);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testIndexOfTaking1And1ReturningNegativeAndIndexOfTaking1And1AndIndexOfTaking1And18() throws Throwable  {
        // Given a character array with 4 characters
        char[] arg0 = new char[4];
        
        // When the method is called with a non-existing character as argument
        int indexOf = ArrayUtils.indexOf(arg0, '`');
        
        // Then the method should return -1
        assertEquals(-1, indexOf);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testToStringTakingObject() throws Throwable  {
        // Given: A non-null object is passed as an argument to the method
        Object arg0 = new Object();
        
        // When: The method is called with the object argument
        String string = ArrayUtils.toString(arg0);
        
        // Then: The method should return a non-null string
        assertNotNull(string);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testRemoveElementTaking1And1ReturningNullAndRemoveElementTaking1And1AndRemoveElementTaking1And18() throws Throwable  {
        // Remove an element from a null array
        short[] removeElement = ArrayUtils.removeElement((short[]) null, (short) 6);
        assertNull(removeElement);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testLastIndexOfTaking1And1ReturningNegativeAndLastIndexOfTaking1And1AndLastIndexOfTaking1And16() throws Throwable  {
        // Given an array of longs and a value to search for
        long[] arg0 = new long[8];
        int valueToSearchFor = -1611;
        
        // When we use ArrayUtils.lastIndexOf() with the array and the value to search for
        int lastIndexOf = ArrayUtils.lastIndexOf(arg0, valueToSearchFor);
        
        // Then the result should be -1, indicating that the value was not found in the array
        assertEquals(-1, lastIndexOf);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testLastIndexOfTaking1And1ReturningNegativeAndLastIndexOfTaking1And1AndLastIndexOfTaking1And17() throws Throwable  {
        // Given: A float array with one element that is equal to -100
        float[] arg0 = new float[]{ -100 };
        
        // When: The lastIndexOf method is called on the array with a negative value of -100
        int lastIndexOf = ArrayUtils.lastIndexOf(arg0, (float) (-100));
        
        // Then: The result should be -1, as the array does not contain the specified element
        assertEquals(-1, lastIndexOf);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testLastIndexOfTaking1And2DoublesReturningPositive() throws Throwable  {
        // Given: a double array with three elements and a value to search for
        double[] arg0 = new double[3];
        arg0[0] = 1.0;
        arg0[1] = -811.98095240529;
        arg0[2] = 992.1195701245;
        
        // When: searching for the last index of a value in the array
        int lastIndexOf = ArrayUtils.lastIndexOf(arg0, (-811.98095240529), 992.1195701245);
        
        // Then: the method should return the index of the last occurrence of the value in the array
        assertEquals(2, lastIndexOf);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testAddTaking1And1AndAddTaking1And1AndAddTaking1And1ReturningNonEmptyArray4() throws Throwable  {
        // Given: We have an empty array of booleans 'arg0' and a boolean value to be added 'false'.
        boolean[] arg0 = new boolean[0];
        boolean[] add = ArrayUtils.add(arg0, false);
        
        // When: The method 'ArrayUtils.add' is called with 'arg0' as the first argument and 'false' as the second argument.
        
        // Then: The result of the method call should be a new array with the boolean value 'false' added to it.
        assertTrue(Arrays.equals(new boolean[] {false}, add));
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testRemoveAllTaking2IntArrays() throws Throwable  {
        // Given: An array of length 1 with no elements
        int[] input = new int[1];
        
        // When: Removing all elements from the array
        int[] result = ArrayUtils.removeAll(input, input);
        
        // Then: The resulting array should be empty
        assertEquals(0, result.length);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testContainsTaking1And1ReturningFalseAndContainsTaking1And1AndContainsTaking1And17() throws Throwable  {
        // No Comments were added
        boolean contains = ArrayUtils.contains((Object[]) null, (Object) null);
        assertFalse(contains);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testLastIndexOfTaking1And1ReturningPositiveAndLastIndexOfTaking1And1AndLastIndexOfTaking1And18() throws Throwable  {
        // Given an array of 8 bytes
        Byte[] bytes = new Byte[8];
        
        // When we search for the last index of null in the array
        int lastIndexOfNull = ArrayUtils.lastIndexOf((Object[]) bytes, (Object) null);
        
        // Then the result should be 7 (the last index of the array)
        assertEquals(7, lastIndexOfNull);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testRemoveTaking1And1ReturningEmptyArrayAndRemoveTaking1And1AndRemoveTaking1And15() throws Throwable  {
        // Given: A short array with one element
        short[] arg0 = new short[1];
        
        // When: The first element is removed from the array
        short[] remove = ArrayUtils.remove(arg0, 0);
        
        // Then: The length of the resulting array should be zero
        assertEquals(0, remove.length);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testAddTaking1And1AndAddTaking1And1AndAddTaking1And1ReturningNonEmptyArray5() throws Throwable  {
        // Test that adding an integer element to a null array returns a new array with the added element
        int[] add = ArrayUtils.add((int[]) null, (-650));
        assertArrayEquals(new int[] {(-650)}, add);
        assertNotNull(add);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testContainsTaking1And1ReturningFalseAndContainsTaking1And1AndContainsTaking1And18() throws Throwable  {
        // Test that the method returns false when the element is not present in the array
        double[] arg0 = new double[1];
        boolean contains = ArrayUtils.contains(arg0, 2.71828);
        assertFalse(contains);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testAddTaking11And1AndAddTaking11And1AndAddTaking11And1ReturningNonEmptyArray7() throws Throwable  {
        // Given: A long array with a single element
        long[] arg0 = new long[1];
        
        // When: Adding two elements to the array using ArrayUtils.add() method
        long[] add = ArrayUtils.add(arg0, 1, 10L);
        
        // Then: The resulting array should have two elements with values 0 and 10 respectively
        assertArrayEquals(new long[] {0L, 10L}, add);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testAddTaking1And1AndIsSameLengthTaking2CharArrays() throws Throwable  {
        // No Comments were added
        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  {
        // Test adding a single value to a null array
        float[] add = ArrayUtils.add((float[]) null, (-2041.9781F));
        
        // Assert that the result is not null
        assertNotNull(add);
        
        // Assert that the result is an array of floats with a single value
        assertArrayEquals(new float[] {(-2041.9781F)}, add, 0.01F);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testLastIndexOfTaking1And1ReturningNegativeAndLastIndexOfTaking1And1AndLastIndexOfTaking1And18() throws Throwable  {
        // No Comments were added
        int[] arg0 = new int[3];
        int lastIndexOf = ArrayUtils.lastIndexOf(arg0, 5);
        assertEquals((-1), lastIndexOf);
    }
  }
  