content: /*
   * This file was automatically generated by UTestGen and EvoSuite
   * Mon Mar 18 17:46:50 GMT 2024
   */
  
  package org.apache.commons.lang3.builder;
  
  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.shaded.org.mockito.Mockito.*;
  import static org.evosuite.runtime.EvoAssertions.*;
  import java.util.Collection;
  import java.util.Comparator;
  import java.util.LinkedList;
  import org.apache.commons.lang3.builder.CompareToBuilder;
  import org.evosuite.runtime.EvoRunner;
  import org.evosuite.runtime.EvoRunnerParameters;
  import org.evosuite.runtime.ViolatedAssumptionAnswer;
  import org.junit.runner.RunWith;
  
  @RunWith(EvoRunner.class) @EvoRunnerParameters(mockJVMNonDeterminism = true, useVFS = true, useVNET = true, resetStaticState = true, separateClassLoader = true) 
  public class CompareToBuilder_ESTest extends CompareToBuilder_ESTest_scaffolding {
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testToComparisonReturningPositive() throws Throwable  {
        // Given a CompareToBuilder object that has been used to compare two values
        CompareToBuilder compareToBuilder = new CompareToBuilder();
        compareToBuilder.appendSuper(170);
        int comparison = compareToBuilder.toComparison();
        
        // When comparing the two values using the CompareToBuilder
        assertEquals(170, (int)compareToBuilder.build());
        
        // Then we expect the comparison to be equal to 170
        assertEquals(170, comparison);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testReflectionCompareTaking2ObjectsAnd1ReturningNegativeAndReflectionCompareTaking2ObjectsAnd10() throws Throwable  {
        // This test asserts that the String "8.qLjvF4$v)%" is less than the String "java.runtie.version" when compared using the CompareToBuilder class.
        String[] args = new String[14];
        int reflectionCompare = CompareToBuilder.reflectionCompare((Object)"8.qLjvF4$v)%", (Object)"java.runtie.version", args);
        assertEquals(-1, reflectionCompare);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testReflectionCompareTaking2ObjectsAnd1ReturningZeroAndReflectionCompareTaking2ObjectsAnd10() throws Throwable  {
        // Test that the reflection compare method returns 0 when comparing two objects
        // Arrange
        int reflectionCompare = CompareToBuilder.reflectionCompare((Object) 0, (Object) 0, false);
        
        // Act
        assertEquals(0, reflectionCompare);
        
        // Assert
        // The test should pass when the reflection compare method returns 0
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testReflectionCompareTaking2ObjectsAnd1ReturningPositiveAndReflectionCompareTaking2ObjectsAnd10() throws Throwable  {
        // No Comments were added
        int reflectionCompare = CompareToBuilder.reflectionCompare((Object) "Dn90fo%U(=", (Object) "|", true);
        assertEquals(1, reflectionCompare);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testReflectionCompareTaking2ObjectsAnd1ReturningNegativeAndReflectionCompareTaking2ObjectsAnd11() throws Throwable  {
        // Given two Integer objects, arg0 and arg1, with values -727 and 2147 respectively
        Integer arg0 = new Integer((-727));
        Integer arg1 = new Integer(2147);
        
        // And a LinkedList<String> object, arg2, which is empty
        LinkedList<String> arg2 = new LinkedList<String>();
        
        // When we compare the two objects using the reflectionCompare method of the CompareToBuilder class
        int reflectionCompare = CompareToBuilder.reflectionCompare((Object) arg0, (Object) arg1, (Collection<String>) arg2);
        
        // Then the result should be -1, indicating that arg0 is less than arg1
        assertEquals(-1, reflectionCompare);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testReflectionCompareTaking2ArgumentsReturningPositive() throws Throwable  {
        // Given two Integers with different values
        Integer a = new Integer(36);
        Integer b = new Integer(-2396);
        
        // When we compare them using ReflectionCompareBuilder
        int reflectionCompare = CompareToBuilder.reflectionCompare((Object) a, (Object) b);
        
        // Then the result should be 1, indicating that a is greater than b
        assertEquals(1, reflectionCompare);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testReflectionCompareTaking2ArgumentsReturningNegative() throws Throwable  {
        // Given two integers, -727 and 2147,
        Integer givenInteger1 = new Integer(-727);
        Integer givenInteger2 = new Integer(2147);
        
        // When we compare them using the CompareToBuilder class,
        int reflectionCompare = CompareToBuilder.reflectionCompare((Object) givenInteger1, (Object) givenInteger2);
        
        // Then we expect the result to be -1, indicating that the first integer is less than the second.
        assertEquals(-1, reflectionCompare);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testAppendSuperReturningCompareToBuilderWhereToComparisonIsZero() throws Throwable  {
        // Given a CompareToBuilder instance
        CompareToBuilder compareToBuilder = new CompareToBuilder();
        
        // When we append the superclass result with 0
        CompareToBuilder appendSuper = compareToBuilder.appendSuper(0);
        
        // Then the comparison should be equal to 0
        assertEquals(0, appendSuper.toComparison());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testAppendTaking2ObjectsReturningCompareToBuilderWhereToComparisonIsZero() throws Throwable  {
        // Tests whether comparing two null objects using the CompareToBuilder returns 0
        CompareToBuilder compareToBuilder = new CompareToBuilder();
        int result = compareToBuilder.append((Object) null, (Object) null).build();
        assertEquals(0, result);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testAppendTaking2ObjectsReturningCompareToBuilderWhereToComparisonIsNegative() throws Throwable  {
        // Given
        CompareToBuilder compareToBuilder = new CompareToBuilder();
        
        // When
        compareToBuilder.append("abc", "def");
        
        // Then
        assertEquals(-3, compareToBuilder.toComparison());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testAppendTaking2FloatsReturningCompareToBuilderWhereToComparisonIsPositive() throws Throwable  {
        // Create a new instance of CompareToBuilder
        CompareToBuilder compareToBuilder = new CompareToBuilder();
        
        // Assert that the comparison result is equal to 0
        assertEquals(0, compareToBuilder.toComparison());
        
        // Create a long array with one element
        long[] arg0 = new long[1];
        
        // Append the long array and null value to the CompareToBuilder instance
        CompareToBuilder append = compareToBuilder.append(arg0, (long[]) null);
        
        // Assert that the comparison result is equal to 1
        assertEquals(1, (int)compareToBuilder.build());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testAppendTaking2DoublesReturningCompareToBuilderWhereToComparisonIsZero() throws Throwable  {
        // Given
        CompareToBuilder compareToBuilder = new CompareToBuilder();
        
        // When
        int result = compareToBuilder.append(0.0, 0.0).build();
        
        // Then
        assertEquals(0, result);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testAppendTaking2CharArraysAndAppendTaking2CharArraysReturningCompareToBuilderWhereToComparisonIsZero() throws Throwable  {
        // Given two empty arrays of length 3
        char[] array1 = new char[3];
        char[] array2 = new char[3];
        
        // When we append the arrays using the CompareToBuilder
        CompareToBuilder compareToBuilder = new CompareToBuilder();
        compareToBuilder.append(array1, array2);
        
        // Then the comparison result should be 0
        assertEquals(0, compareToBuilder.toComparison());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testAppendTaking2CharArrays0() throws Throwable  {
        // Given: A CompareToBuilder object with some appended values
        CompareToBuilder compareToBuilder = new CompareToBuilder();
        char[] arg0 = new char[3];
        char[] arg1 = new char[1];
        compareToBuilder.append(arg0, arg1);
        
        // When: Calling the toComparison method on the CompareToBuilder object
        int comparisonResult = compareToBuilder.toComparison();
        
        // Then: The comparison result should be 1
        assertEquals(1, comparisonResult);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testAppendTaking2CharArraysAndAppendTaking2CharArraysWithEmptyArray() throws Throwable  {
        // Given: We have two arrays of characters, arg0 and arg1
        char[] arg0 = new char[0];
        char[] arg1 = new char[4];
        
        // When: We use the CompareToBuilder to compare these arrays
        CompareToBuilder compareToBuilder = new CompareToBuilder();
        compareToBuilder.append(arg0, arg1);
        
        // Then: The result of comparing these arrays is -1, since arg0 is shorter than arg1
        assertEquals((-1), (int)compareToBuilder.build());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testAppendTaking2ObjectArraysAnd1AndAppendTaking2ObjectArraysAnd1ReturningCompareToBuilderWhereToComparisonIsZero0() throws Throwable  {
        // Given
        CompareToBuilder compareToBuilder = new CompareToBuilder();
        Object[] arg0 = new Object[1];
        Object[] arg1 = new Object[1];
        Comparator<Integer> comparator = mock(Comparator.class, new ViolatedAssumptionAnswer());
        
        // When
        compareToBuilder.append(arg0, arg1, comparator);
        int result = (int)compareToBuilder.build();
        
        // Then
        assertEquals(0, result);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testAppendTaking2ObjectArraysAnd1ReturningCompareToBuilderWhereToComparisonIsNegative() throws Throwable  {
        // Set up the inputs for the test
        Object[] arg0 = new Object[2];
        Object[] arg1 = new Object[4];
        Comparator<Integer> arg2 = (Comparator<Integer>) mock(Comparator.class, new ViolatedAssumptionAnswer());
        
        // Create a new CompareToBuilder instance and append the inputs
        CompareToBuilder compareToBuilder = new CompareToBuilder();
        compareToBuilder.append(arg0, arg1, arg2);
        
        // Verify that the comparison result is as expected
        assertEquals((-1), compareToBuilder.toComparison());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testAppendTaking2ObjectArraysAnd1WithNullAndAppendTaking2ObjectArraysAnd1ReturningCompareToBuilderWhereToComparisonIsPositive() throws Throwable  {
        // Given a CompareToBuilder object and some input arguments
        CompareToBuilder compareToBuilder = new CompareToBuilder();
        Object[] arg0 = new Object[3];
        Comparator<Integer> arg2 = (Comparator<Integer>) mock(Comparator.class, new ViolatedAssumptionAnswer());
        
        // When we append the arguments to the builder and call build()
        compareToBuilder.append(arg0, (Object[]) null, arg2);
        
        // Then the result of calling build() should be 1
        assertEquals(1, compareToBuilder.toComparison());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testAppendTaking2ObjectArraysAnd1AndAppendTaking2ObjectArraysAnd1ReturningCompareToBuilderWhereToComparisonIsZero1() throws Throwable  {
        // Set up the input arguments for the test case
        Object[] arg1 = new Object[2];
        Comparator<Integer> arg2 = mock(Comparator.class, new ViolatedAssumptionAnswer());
        
        // Create a new instance of CompareToBuilder and append the input arguments
        CompareToBuilder compareToBuilder = new CompareToBuilder();
        compareToBuilder.append(arg1, arg1, arg2);
        
        // Build the comparison result and assert that it is equal to 0
        int result = (int) compareToBuilder.build();
        assertEquals(0, result);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testAppendTaking2FloatsReturningCompareToBuilderWhereToComparisonIsZero() throws Throwable  {
        // No Comments were added
        CompareToBuilder compareToBuilder = new CompareToBuilder();
        CompareToBuilder append = compareToBuilder.append((-1210.7922F), (-1210.7922F));
        assertEquals(0, append.toComparison());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testAppendTaking2CharsReturningCompareToBuilderWhereToComparisonIsZero() throws Throwable  {
        // No Comments were added
        CompareToBuilder compareToBuilder = new CompareToBuilder();
        CompareToBuilder append = compareToBuilder.append('c', 'c');
        assertEquals(0, (int)append.build());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testAppendTaking2LongsReturningCompareToBuilderWhereToComparisonIsPositive() throws Throwable  {
        // Create a new instance of CompareToBuilder
        CompareToBuilder compareToBuilder = new CompareToBuilder();
        
        // Assert that the comparison between two long values is equal to zero
        assertEquals(0, compareToBuilder.toComparison());
        
        // Append the comparison between two long values with a negative result
        compareToBuilder.append(-1368L, 1364L);
        
        // Assert that the comparison between two long values is equal to one
        assertEquals(1, compareToBuilder.toComparison());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testAppendTaking2ObjectsAnd1ThrowsClassCastException() throws Throwable  {
        // Given: A CompareToBuilder instance and an object to compare with
        CompareToBuilder builder = new CompareToBuilder();
        Object obj = new Object();
        
        // When: We try to append the object to the CompareToBuilder using a null comparator
        builder.append(obj, (Comparator<?>) null);
        
        // Then: A ClassCastException is thrown because the CompareToBuilder cannot be cast to Comparable
        try {
        fail("Expecting exception: ClassCastException");
        } catch(ClassCastException e) {
        verifyException("org.apache.commons.lang3.builder.CompareToBuilder", e);}
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testAppendTaking2ObjectsAnd1ReturningCompareToBuilderWhereToComparisonIsPositive() throws Throwable  {
        // Create a new CompareToBuilder instance
        CompareToBuilder compareToBuilder = new CompareToBuilder();
        
        // Assert that the built comparison is equal to 0 for the first case
        assertEquals(0, (int)compareToBuilder.build());
        
        // Define an integer value of -479 and a Comparator object with a ViolatedAssumptionAnswer
        Integer arg0 = new Integer((-479));
        Comparator<Integer> arg2 = (Comparator<Integer>) mock(Comparator.class, new ViolatedAssumptionAnswer());
        
        // Append the integer value to the comparison builder
        compareToBuilder.append((Object) arg0, (Object) null, (Comparator<?>) arg2);
        
        // Assert that the built comparison is greater than 0 for the second case
        assertEquals(1, (int)compareToBuilder.build());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testAppendTaking2ObjectsAnd1WithNull() throws Throwable  {
        // Given
        CompareToBuilder compareToBuilder = new CompareToBuilder();
        
        // When
        CompareToBuilder append = compareToBuilder.append((Object) null, (Object) null, (Comparator<?>) null);
        
        // Then
        assertEquals(0, (int)append.build());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testReflectionCompareTaking5ArgumentsReturningNegative() throws Throwable  {
        // Given two integers with different values
        Integer arg1 = 2573;
        Integer arg0 = 191;
        
        // When we compare them using the CompareToBuilder
        Class<Integer> arg3 = Integer.TYPE;
        String[] arg4 = new String[3];
        int reflectionCompare = CompareToBuilder.reflectionCompare((Object) arg0, (Object) arg1, true, (Class<?>) arg3, arg4);
        
        // Then we expect the comparison to return negative one (-1)
        assertEquals(-1, reflectionCompare);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testReflectionCompareTaking5ArgumentsReturningZero() throws Throwable  {
        // Test that the CompareToBuilder correctly compares two null objects
        Class<Integer> arg3 = Integer.class;
        String[] arg4 = new String[2];
        int reflectionCompare = CompareToBuilder.reflectionCompare((Object) null, (Object) null, true, arg3, arg4);
        assertEquals(0, reflectionCompare);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testToComparisonReturningZero() throws Throwable  {
        // rollbacked to evosuite
        CompareToBuilder compareToBuilder = new CompareToBuilder();
        int comparison = compareToBuilder.toComparison();
        assertEquals(0, comparison);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testAppendTaking2BooleanArraysAndAppendTaking2BooleanArraysReturningCompareToBuilderWhereToComparisonIsNegative0() throws Throwable  {
        // Given two arrays of booleans with different values at index 0
        boolean[] arg0 = new boolean[5];
        arg0[0] = true;
        boolean[] arg1 = new boolean[5];
        arg1[0] = false;
        
        // When we use the CompareToBuilder to compare them
        CompareToBuilder compareToBuilder = new CompareToBuilder();
        compareToBuilder.append(arg0, arg1);
        
        // Then the comparison should return -1 (i.e., the first array is considered less than the second)
        assertEquals((-1), compareToBuilder.toComparison());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testAppendTaking2BooleanArraysAndAppendTaking2BooleanArraysReturningCompareToBuilderWhereToComparisonIsPositive0() throws Throwable  {
        // rollbacked to evosuite
        CompareToBuilder compareToBuilder = new CompareToBuilder();
        assertEquals(0, compareToBuilder.toComparison());
        
        boolean[] arg0 = new boolean[8];
        boolean[] arg1 = new boolean[3];
        compareToBuilder.append(arg0, arg1);
        assertEquals(1, compareToBuilder.toComparison());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testAppendTaking2BooleanArraysAndAppendTaking2BooleanArraysReturningCompareToBuilderWhereToComparisonIsZero0() throws Throwable  {
        // No Comments were added
        CompareToBuilder compareToBuilder = new CompareToBuilder();
        boolean[] arg0 = new boolean[5];
        boolean[] arg1 = new boolean[5];
        CompareToBuilder append = compareToBuilder.append(arg0, arg1);
        assertEquals(0, append.toComparison());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testAppendTaking2BooleanArraysAndAppendTaking2BooleanArraysReturningCompareToBuilderWhereToComparisonIsNegative1() throws Throwable  {
        // Given: two boolean arrays with different sizes
        boolean[] arg0 = new boolean[1];
        boolean[] arg1 = new boolean[3];
        
        // When: we compare the two arrays using CompareToBuilder
        CompareToBuilder compareToBuilder = new CompareToBuilder();
        int result = compareToBuilder.append(arg0, arg1).build();
        
        // Then: the result should be -1 because the first array has a size of 1 and the second array has a size of 3
        assertEquals(-1, result);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testAppendTaking2BooleanArraysAndAppendTaking2BooleanArraysReturningCompareToBuilderWhereToComparisonIsNegative2() throws Throwable  {
        // Given a CompareToBuilder instance and a boolean array
        CompareToBuilder compareToBuilder = new CompareToBuilder();
        boolean[] arg1 = new boolean[8];
        
        // When append is called with null and the boolean array as arguments
        compareToBuilder.append((boolean[]) null, arg1);
        
        // Then the result of build should be -1
        assertEquals(-1, (int)compareToBuilder.build());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testAppendTaking2BooleanArraysAndAppendTaking2BooleanArraysReturningCompareToBuilderWhereToComparisonIsPositive1() throws Throwable  {
        // Given
        CompareToBuilder compareToBuilder = new CompareToBuilder();
        boolean[] arg0 = new boolean[8];
        
        // When
        compareToBuilder.append(arg0, (boolean[]) null);
        
        // Then
        assertEquals(1, compareToBuilder.toComparison());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testAppendTaking2LongArraysAndAppendTaking2BooleanArrays() throws Throwable  {
        // Create a new instance of the CompareToBuilder
        CompareToBuilder compareToBuilder = new CompareToBuilder();
        
        // Append an array of longs to the builder, with null value
        long[] arg0 = new long[1];
        compareToBuilder.append(arg0, (long[]) null);
        
        // Append two arrays of booleans to the builder, with null values
        compareToBuilder.append((boolean[]) null, (boolean[]) null);
        
        // Assert that the comparison is equal to 1
        assertEquals(1, (int)compareToBuilder.build());
        
        // Assert that the comparison is equal to 1
        assertEquals(1, compareToBuilder.toComparison());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testAppendTaking2BooleanArraysAndAppendTaking2BooleanArraysReturningCompareToBuilderWhereToComparisonIsZero1() throws Throwable  {
        // Set up the test using a new CompareToBuilder instance
        CompareToBuilder compareToBuilder = new CompareToBuilder();
        
        // Append two null arrays to the builder
        CompareToBuilder append = compareToBuilder.append((boolean[]) null, (boolean[]) null);
        
        // Assert that the comparison result is 0
        assertEquals(0, append.toComparison());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testAppendTaking2FloatArrays0() throws Throwable  {
        CompareToBuilder compareToBuilder = new CompareToBuilder();
        // Asserts that the built object has a value of 0
        assertEquals(0, (int)compareToBuilder.build());
        
        float[] arg0 = new float[3];
        arg0[0] = 1487.9973F;
        float[] arg1 = new float[3];
        // Appends the values of two arrays to the builder
        compareToBuilder.append(arg0, arg1);
        // Asserts that the built object has a value of 1 after appending the values of two arrays
        assertEquals(1, (int)compareToBuilder.build());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testAppendTaking2FloatArraysReturningCompareToBuilderWhereToComparisonIsNegative() throws Throwable  {
        // Given
        CompareToBuilder compareToBuilder = new CompareToBuilder();
        float[] arg0 = new float[1];
        float[] arg1 = new float[5];
        
        // When
        compareToBuilder.append(arg0, arg1);
        
        // Then
        assertEquals((-1), (int)compareToBuilder.build());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testAppendTaking2FloatArrays1() throws Throwable  {
        // Given: Two arrays of floats with different lengths
        float[] arg0 = new float[16];
        float[] arg1 = new float[7];
        
        // When: Appending the two arrays using CompareToBuilder
        CompareToBuilder compareToBuilder = new CompareToBuilder();
        compareToBuilder.append(arg0, arg1);
        
        // Then: The result of building the comparison should be 1
        assertEquals(1, (int)compareToBuilder.build());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testAppendTaking2FloatArraysWithNullAndAppendTaking2FloatArraysReturningCompareToBuilderWhereToComparisonIsPositive() throws Throwable  {
        // This test ensures that the CompareToBuilder class returns the correct value when comparing two arrays of different sizes.
        // The first array is smaller than the second array in length, so it should be considered less than the second array.
        
        CompareToBuilder compareToBuilder = new CompareToBuilder();
        float[] arg0 = new float[1]; // The first array has one element
        compareToBuilder.append(arg0, (float[]) null); // The second array is null
        assertEquals(-1, compareToBuilder.build());
        
        // This test ensures that the CompareToBuilder class returns the correct value when comparing two arrays of the same length.
        // Both arrays have one element and the values are equal, so the result should be 0.
        
        CompareToBuilder compareToBuilder2 = new CompareToBuilder();
        float[] arg1 = new float[1]; // The first array has one element with value 5.0
        arg1[0] = 5.0f;
        compareToBuilder2.append(arg1, (float[]) null); // The second array is null
        assertEquals(0, compareToBuilder2.build());
        
        // This test ensures that the CompareToBuilder class returns the correct value when comparing two arrays of the same length.
        // Both arrays have one element and the values are different, so the result should be -1.
        
        CompareToBuilder compareToBuilder3 = new CompareToBuilder();
        float[] arg2 = new float[1]; // The first array has one element with value 5.0
        arg2[0] = 5.0f;
        compareToBuilder3.append(arg2, (float[]) null); // The second array is null
        assertEquals(-1, compareToBuilder3.build());
        
        // This test ensures that the CompareToBuilder class returns the correct value when comparing two arrays of different lengths.
        // The first array is longer than the second array in length, so it should be considered greater than the second array.
        
        CompareToBuilder compareToBuilder4 = new CompareToBuilder();
        float[] arg3 = new float[2]; // The first array has two elements with values 5.0 and 6.0
        arg3[0] = 5.0f;
        arg3[1] = 6.0f;
        compareToBuilder4.append(arg3, (float[]) null); // The second array is null
        assertEquals(1, compareToBuilder4.build());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testAppendTaking2FloatArraysWithEmptyArray() throws Throwable  {
        // Given: we have two float arrays, one of which is null
        float[] arg1 = new float[0];
        
        // When: we compare the two arrays using CompareToBuilder
        CompareToBuilder compareToBuilder = new CompareToBuilder();
        compareToBuilder.append((float[]) null, arg1);
        
        // Then: the comparison result is -1
        assertEquals(-1, compareToBuilder.toComparison());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testAppendTaking2FloatArraysWithNullAndAppendTaking2FloatArraysReturningCompareToBuilderWhereToComparisonIsZero() throws Throwable  {
        // Given
        CompareToBuilder compareToBuilder = new CompareToBuilder();
        
        // When
        CompareToBuilder append = compareToBuilder.append((float[]) null, (float[]) null);
        
        // Then
        assertEquals(0, append.toComparison());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testAppendTaking2DoubleArrays0() throws Throwable  {
        // No Comments were added
        CompareToBuilder compareToBuilder = new CompareToBuilder();
        assertEquals(0, (int)compareToBuilder.build());
        
        double[] arg0 = new double[3];
        arg0[1] = 3236.3006466943;
        double[] arg1 = new double[3];
        compareToBuilder.append(arg0, arg1);
        assertEquals(1, (int)compareToBuilder.build());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testAppendTaking2DoubleArrays1() throws Throwable  {
        // rollbacked to evosuite
        CompareToBuilder compareToBuilder = new CompareToBuilder();
        assertEquals(0, compareToBuilder.toComparison());
        
        double[] arg0 = new double[3];
        double[] arg1 = new double[2];
        compareToBuilder.append(arg0, arg1);
        assertEquals(1, (int)compareToBuilder.build());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testAppendTaking2DoubleArraysAndAppendTaking2DoubleArraysReturningCompareToBuilderWhereToComparisonIsZero() throws Throwable  {
        // Given two arrays of doubles, arg0 and arg1
        double[] arg0 = new double[1];
        double[] arg1 = new double[1];
        
        // When we use the CompareToBuilder to compare them
        CompareToBuilder compareToBuilder = new CompareToBuilder();
        compareToBuilder.append(arg0, arg1);
        
        // Then we expect the result to be 0 (i.e., the arrays are equal)
        assertEquals(0, (int)compareToBuilder.build());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testAppendTaking2DoubleArraysWithEmptyArrayAndNonEmptyArray() throws Throwable  {
        // Given two empty double arrays
        double[] arg0 = new double[0];
        double[] arg1 = new double[1];
        
        // When we use the CompareToBuilder to compare them
        CompareToBuilder compareToBuilder = new CompareToBuilder();
        compareToBuilder.append(arg0, arg1);
        
        // Then the result should be -1
        assertEquals(-1, (int)compareToBuilder.build());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testAppendTaking2DoubleArraysAndAppendTaking2DoubleArraysWithNullAndAppendTaking2DoubleArraysReturningCompareToBuilderWhereToComparisonIsPositive() throws Throwable  {
        // Given a CompareToBuilder instance with two doubles
        CompareToBuilder compareToBuilder = new CompareToBuilder();
        double[] arg0 = new double[4];
        compareToBuilder.append(arg0, (double[]) null);
        
        // When the append method is called with null values
        int result = (int)compareToBuilder.build();
        
        // Then the result should be 1
        assertEquals(1, result);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testAppendTaking2DoubleArraysWithEmptyArrayAndNull() throws Throwable  {
        // Given: A CompareToBuilder instance with a null array to be compared
        CompareToBuilder compareToBuilder = new CompareToBuilder();
        
        // And: An array of doubles as the argument to be compared against
        double[] arg1 = new double[0];
        
        // When: The method is called with the null array and the argument array
        compareToBuilder.append((double[]) null, arg1);
        
        // Then: The comparison result should be -1
        assertEquals(-1, compareToBuilder.toComparison());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testAppendTaking2CharArraysAndAppendTaking2DoubleArrays() throws Throwable  {
        // No Comments were added
        CompareToBuilder compareToBuilder = new CompareToBuilder();
        assertEquals(0, (int)compareToBuilder.build());
        
        double[] arg1 = new double[4];
        char[] arg0 = new char[0];
        compareToBuilder.append(arg0, (char[]) null);
        compareToBuilder.append((double[]) null, arg1);
        assertEquals(1, compareToBuilder.toComparison());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testAppendTaking2DoubleArraysAndAppendTaking2DoubleArraysWithNullAndAppendTaking2DoubleArraysReturningCompareToBuilderWhereToComparisonIsZero() throws Throwable  {
        // Given
        double[] array1 = null;
        double[] array2 = null;
        
        // When
        CompareToBuilder compareToBuilder = new CompareToBuilder();
        CompareToBuilder append = compareToBuilder.append(array1, array2);
        
        // Then
        assertEquals(0, (int)append.build());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testBuildReturningPositive() throws Throwable  {
        // Create a new instance of CompareToBuilder
        CompareToBuilder compareToBuilder = new CompareToBuilder();
        
        // Define two byte arrays to use as arguments for the comparison method
        byte[] arg0 = new byte[3];
        arg0[0] = (byte)105;
        byte[] arg1 = new byte[3];
        
        // Append the first argument to the CompareToBuilder instance
        compareToBuilder.append(arg0, arg1);
        
        // Build the comparison result
        int comparisonResult = compareToBuilder.build();
        
        // Assert that the comparison result is equal to 1
        assertEquals(1, comparisonResult);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testAppendTaking2ByteArraysAndAppendTaking2ByteArraysReturningCompareToBuilderWhereToComparisonIsNegative0() throws Throwable  {
        // rollbacked to evosuite
        CompareToBuilder compareToBuilder = new CompareToBuilder();
        byte[] arg0 = new byte[1];
        byte[] arg1 = new byte[5];
        compareToBuilder.append(arg0, arg1);
        assertEquals((-1), (int)compareToBuilder.build());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testAppendTaking2ByteArraysAndAppendTaking2ByteArraysReturningCompareToBuilderWhereToComparisonIsZero0() throws Throwable  {
        // Set up the data we want to compare
        byte[] arg0 = new byte[]{1};
        byte[] arg1 = new byte[]{2};
        
        // Create a new CompareToBuilder instance and append the data
        CompareToBuilder compareToBuilder = new CompareToBuilder();
        compareToBuilder.append(arg0, arg1);
        
        // Verify that the comparison result is 0 (equal)
        assertEquals(0, compareToBuilder.toComparison());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testAppendTaking2ByteArraysAndAppendTaking2ByteArraysReturningCompareToBuilderWhereToComparisonIsPositive0() throws Throwable  {
        // Given two byte arrays, arg0 and arg1
        byte[] arg0 = new byte[1];
        byte[] arg1 = new byte[0];
        
        // When we compare them using CompareToBuilder
        CompareToBuilder compareToBuilder = new CompareToBuilder();
        compareToBuilder.append(arg0, arg1);
        
        // Then the result should be 1
        assertEquals(1, (int)compareToBuilder.build());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testAppendTaking2ByteArraysAndAppendTaking2ByteArraysReturningCompareToBuilderWhereToComparisonIsNegative1() throws Throwable  {
        // Given a CompareToBuilder instance
        CompareToBuilder compareToBuilder = new CompareToBuilder();
        
        // And an array of bytes to append
        byte[] arg1 = new byte[0];
        
        // When we call the append method with a null argument and the array of bytes
        compareToBuilder.append((byte[]) null, arg1);
        
        // Then the comparison result should be -1
        assertEquals(-1, compareToBuilder.toComparison());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testAppendTaking2ByteArraysAndAppendTaking2ByteArraysReturningCompareToBuilderWhereToComparisonIsPositive1() throws Throwable  {
        // Arrange
        CompareToBuilder compareToBuilder = new CompareToBuilder();
        
        byte[] arg0 = new byte[17];
        
        // Act
        compareToBuilder.append(arg0, (byte[]) null);
        compareToBuilder.append(arg0, (byte[]) null);
        
        // Assert
        assertEquals(1, (int)compareToBuilder.build());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testAppendTaking2ByteArraysAndAppendTaking2ByteArraysReturningCompareToBuilderWhereToComparisonIsZero1() throws Throwable  {
        // Create two objects to compare using the CompareToBuilder class
        Object object1 = new Object();
        Object object2 = new Object();
        
        // Use the CompareToBuilder class to compare the two objects and append the results
        CompareToBuilder compareToBuilder = new CompareToBuilder();
        CompareToBuilder append = compareToBuilder.append(object1, object2);
        
        // Assert that the comparison result is equal to 0
        assertEquals(0, (int)append.build());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testReflectionCompareTaking2ObjectsAnd1ReturningPositiveAndReflectionCompareTaking2ObjectsAnd11() throws Throwable  {
        // No Comments were added
        int reflectionCompare = CompareToBuilder.reflectionCompare((Object) "lion", (Object) "%", (String[]) null);
        assertEquals(1, reflectionCompare);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testAppendTaking2CharArraysAndAppendTaking2CharArraysReturningCompareToBuilderWhereToComparisonIsNegative() throws Throwable  {
        // Given
        CompareToBuilder compareToBuilder = new CompareToBuilder();
        char[] arg1 = new char[8];
        
        // When
        compareToBuilder.append((char[]) null, arg1);
        
        // Then
        assertEquals(-1, (int) compareToBuilder.build());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testAppendTaking2CharArraysAndAppendTaking2CharArraysWithNull() throws Throwable  {
        // Given
        CompareToBuilder compareToBuilder = new CompareToBuilder();
        
        // When
        CompareToBuilder append = compareToBuilder.append((char[]) null, (char[]) null);
        
        // Then
        assertEquals(0, (int)append.build());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testAppendTaking2CharArrays1() throws Throwable  {
        // No Comments were added
        CompareToBuilder compareToBuilder = new CompareToBuilder();
        assertEquals(0, compareToBuilder.toComparison());
        
        char[] arg0 = new char[4];
        arg0[2] = 'c';
        char[] arg1 = new char[4];
        compareToBuilder.append(arg0, arg1);
        compareToBuilder.append(arg1, arg1);
        assertEquals(1, compareToBuilder.toComparison());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testAppendTaking2ShortArraysAndAppendTaking2ShortArraysReturningCompareToBuilderWhereToComparisonIsPositive0() throws Throwable  {
        // Given two arrays of shorts with different values
        short[] array1 = new short[5];
        array1[0] = Short.MAX_VALUE;
        short[] array2 = new short[5];
        array2[0] = (short) 32767;
        
        // When we compare the arrays using CompareToBuilder
        CompareToBuilder compareToBuilder = new CompareToBuilder();
        compareToBuilder.append(array1, array2);
        
        // Then we expect the comparison to be 1
        assertEquals(1, compareToBuilder.toComparison());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testAppendTaking2ShortArraysAndAppendTaking2ShortArraysReturningCompareToBuilderWhereToComparisonIsPositive1() throws Throwable  {
        // Set up the test data
        short[] arg0 = new short[9];
        short[] arg1 = new short[1];
        
        // Execute the compareTo method and compare the result with the expected value
        CompareToBuilder compareToBuilder = new CompareToBuilder();
        assertEquals(0, compareToBuilder.toComparison());
        compareToBuilder.append(arg0, arg1);
        assertEquals(1, (int)compareToBuilder.build());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testAppendTaking2ShortArraysWithEmptyArray() throws Throwable  {
        CompareToBuilder builder = new CompareToBuilder();
        // arg0 is an empty short array
        short[] arg0 = new short[0];
        // arg1 is a non-empty short array
        short[] arg1 = new short[1];
        builder.append(arg0, arg1);
        // Assert that the comparison result is -1 (i.e., the empty array should come before the non-empty array)
        assertEquals((-1), builder.toComparison());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testAppendTaking2ShortArraysWithNull() throws Throwable  {
        // Create a new CompareToBuilder instance
        CompareToBuilder compareToBuilder = new CompareToBuilder();
        
        // Append two null arrays to the builder
        short[] arg0 = new short[2];
        compareToBuilder.append(arg0, (short[]) null);
        
        // Assert that the comparison is 1
        assertEquals(1, compareToBuilder.toComparison());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testAppendTaking2ShortArraysWithNullAndEmptyArray() throws Throwable  {
        // Given a CompareToBuilder instance and two short arrays
        CompareToBuilder compareToBuilder = new CompareToBuilder();
        short[] arg1 = new short[0];
        
        // When the append method is called with the second array as null
        compareToBuilder.append((short[]) null, arg1);
        
        // Then the return value should be -1
        assertEquals(-1, (int)compareToBuilder.build());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testAppendTaking2ShortArraysAndAppendTaking2ShortArraysReturningCompareToBuilderWhereToComparisonIsZero0() throws Throwable  {
        // Test that the compareTo method returns 0 when comparing two arrays of shorts with the same elements
        CompareToBuilder compareToBuilder = new CompareToBuilder();
        short[] arg0 = new short[5];
        short[] arg1 = new short[5];
        for (int i = 0; i < arg0.length; i++) {
        arg0[i] = (short) i;
        arg1[i] = (short) i;
        }
        CompareToBuilder append = compareToBuilder.append(arg0, arg1);
        assertEquals(0, (int) append.build());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testAppendTaking2ShortArraysAndAppendTaking2ShortArraysReturningCompareToBuilderWhereToComparisonIsZero1() throws Throwable  {
        // Test that the CompareToBuilder correctly compares two short arrays
        CompareToBuilder compareToBuilder = new CompareToBuilder();
        short[] arg1 = new short[5];
        short[] arg2 = new short[5];
        compareToBuilder.append(arg1, arg2);
        assertEquals(0, (int)compareToBuilder.build());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testAppendTaking2IntArrays0() throws Throwable  {
        // No Comments were added
        CompareToBuilder compareToBuilder = new CompareToBuilder();
        int[] arg0 = new int[4];
        arg0[0] = (-4317);
        int[] arg1 = new int[4];
        compareToBuilder.append(arg0, arg1);
        assertEquals((-1), compareToBuilder.toComparison());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testAppendTaking2IntArrays1() throws Throwable  {
        // Given two arrays of integers, arg0 and arg1
        int[] arg0 = new int[8];
        int[] arg1 = new int[9];
        
        // When we use the CompareToBuilder to compare them
        CompareToBuilder compareToBuilder = new CompareToBuilder();
        compareToBuilder.append(arg0, arg1);
        
        // Then the result should be -1
        assertEquals((-1), (int)compareToBuilder.build());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testAppendTaking2IntArraysReturningCompareToBuilderWhereToComparisonIsZero() throws Throwable  {
        // Given: two arrays of integers with the same elements
        int[] arg0 = new int[]{1, 2, 3};
        int[] arg1 = new int[]{1, 2, 3};
        
        // When: we use the CompareToBuilder to compare them
        CompareToBuilder compareToBuilder = new CompareToBuilder();
        CompareToBuilder append = compareToBuilder.append(arg0, arg1);
        
        // Then: the comparison result is 0
        assertEquals(0, append.toComparison());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testAppendTaking2IntArraysWithEmptyArrayAndNonEmptyArray() throws Throwable  {
        // Setup
        CompareToBuilder compareToBuilder = new CompareToBuilder();
        
        int[] arg0 = new int[10];
        int[] arg1 = new int[0];
        
        // Execute
        compareToBuilder.append(arg0, arg1);
        
        // Verify
        assertEquals(1, compareToBuilder.toComparison());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testAppendTaking2IntArraysWithNullAndAppendTaking2IntArraysReturningCompareToBuilderWhereToComparisonIsNegative() throws Throwable  {
        // Given: the CompareToBuilder and two arrays of integers
        CompareToBuilder compareToBuilder = new CompareToBuilder();
        int[] arg1 = new int[]{4, 8, 15, 16};
        int[] arg2 = new int[]{10, 20, 30, 40};
        
        // When: we append the two arrays to the CompareToBuilder and convert the result to a comparison
        compareToBuilder.append(arg1, arg2);
        int comparison = compareToBuilder.toComparison();
        
        // Then: the comparison should be -1, indicating that arg1 is less than arg2
        assertEquals(-1, comparison);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testAppendTaking2IntArraysWithEmptyArrayAndNull() throws Throwable  {
        CompareToBuilder compareToBuilder = new CompareToBuilder();
        // Given: We have two arrays, arg0 and arg1, with different lengths
        int[] arg0 = new int[0];
        int[] arg1 = new int[1];
        // When: We append the first array to the CompareToBuilder
        compareToBuilder.append(arg0, arg1);
        // Then: The built value should be non-zero, indicating that the arrays are not equal
        assertEquals(1, (int) compareToBuilder.build());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testAppendTaking2IntArraysWithNullAndAppendTaking2IntArraysReturningCompareToBuilderWhereToComparisonIsZero() throws Throwable  {
        // rollbacked to evosuite
        CompareToBuilder compareToBuilder = new CompareToBuilder();
        CompareToBuilder append = compareToBuilder.append((int[]) null, (int[]) null);
        assertEquals(0, (int)append.build());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testAppendTaking2LongArraysReturningCompareToBuilderWhereToComparisonIsZero() throws Throwable  {
        // Create two arrays of longs with the same value
        long[] arg0 = new long[1];
        long[] arg1 = new long[1];
        arg0[0] = 5;
        arg1[0] = 5;
        
        // Use CompareToBuilder to compare the arrays
        CompareToBuilder compareToBuilder = new CompareToBuilder();
        int result = (int) compareToBuilder.append(arg0, arg1).build();
        
        // Assert that the result is equal to 0
        assertEquals(0, result);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testAppendTaking2LongArraysWithEmptyArrayAndAppendTaking2LongArraysReturningCompareToBuilderWhereToComparisonIsPositive() throws Throwable  {
        // Given: two long arrays with different lengths
        long[] arg0 = new long[3];
        long[] arg1 = new long[0];
        
        // When: we use CompareToBuilder to compare the two arrays
        CompareToBuilder compareToBuilder = new CompareToBuilder();
        compareToBuilder.append(arg0, arg1);
        
        // Then: the result should be 1, since the second array is shorter than the first one
        assertEquals(1, (int)compareToBuilder.build());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testAppendTaking2LongArraysWithEmptyArrayAndAppendTaking2LongArraysReturningCompareToBuilderWhereToComparisonIsNegative() throws Throwable  {
        // Given two empty long arrays
        long[] arg0 = new long[0];
        long[] arg1 = new long[3];
        
        // When we call the CompareToBuilder with these arrays as arguments
        CompareToBuilder compareToBuilder = new CompareToBuilder();
        compareToBuilder.append(arg0, arg1);
        
        // Then the result should be -1, indicating that the first array is less than the second
        assertEquals((-1), (int)compareToBuilder.build());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testBuildReturningNegative() throws Throwable  {
        // Setup
        long[] arg1 = new long[0];
        long[] arg2 = new long[1];
        
        // When
        CompareToBuilder compareToBuilder = new CompareToBuilder();
        compareToBuilder.append(arg1, arg2);
        int comparisonResult = compareToBuilder.build();
        
        // Then
        assertEquals(-1, comparisonResult);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testAppendTaking2LongArraysWithNull() throws Throwable  {
        // Given
        CompareToBuilder compareToBuilder = new CompareToBuilder();
        
        // When
        compareToBuilder.append((long[]) null, (long[]) null);
        
        // Then
        assertEquals(0, (int)compareToBuilder.build());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testAppendTaking2LongArrays() throws Throwable  {
        // Create a new CompareToBuilder instance
        CompareToBuilder compareToBuilder = new CompareToBuilder();
        
        // Append two null arrays to the builder, expecting 0 as the result
        assertEquals(0, (int)compareToBuilder.build());
        
        // Append two empty arrays to the builder, expecting 1 as the result
        long[] arg0 = new long[1];
        CompareToBuilder append = compareToBuilder.append(arg0, (long[]) null);
        assertEquals(1, (int)compareToBuilder.build());
        
        // Append two non-null arrays to the builder, expecting a different result than before
        append.append(arg0, (long[]) null);
        assertNotEquals(1, compareToBuilder.toComparison());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testAppendTaking2ObjectArraysAnd1AndAppendTaking2ObjectArraysAnd1ReturningCompareToBuilderWhereToComparisonIsPositive0() throws Throwable  {
        // Given: a CompareToBuilder instance and two arrays of integers
        CompareToBuilder compareToBuilder = new CompareToBuilder();
        Object[] arg1 = new Object[2];
        Integer[] intArray1 = { 1, 2 };
        arg1[0] = (Object) intArray1;
        Integer[] intArray2 = { 3, 4 };
        arg1[1] = (Object) intArray2;
        
        // When: we call the append method with the arrays and a comparator
        Comparator<Integer> comparator = (Comparator<Integer>) mock(Comparator.class, new ViolatedAssumptionAnswer());
        Object[] arg0 = new Object[2];
        arg0[0] = (Object) comparator;
        Comparator<Integer> arg2 = (Comparator<Integer>) mock(Comparator.class, new ViolatedAssumptionAnswer());
        compareToBuilder.append(arg0, arg1, arg2);
        
        // Then: the comparison result should be 1
        assertEquals(1, compareToBuilder.toComparison());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testAppendTaking2ObjectArraysAnd1AndAppendTaking2ObjectArraysAnd1ReturningCompareToBuilderWhereToComparisonIsPositive1() throws Throwable  {
        // Create two arrays with different lengths
        Object[] arg0 = new Object[8];
        Object[] arg1 = new Object[1];
        
        // Mock a Comparator to use in the compareTo method
        Comparator<Integer> comparator = mock(Comparator.class, new ViolatedAssumptionAnswer());
        
        // Create a CompareToBuilder and append the two arrays with the mocked Comparator
        CompareToBuilder compareToBuilder = new CompareToBuilder();
        compareToBuilder.append(arg0, arg1, comparator);
        
        // Assert that the comparison is 1 (i.e., the first array is greater than the second)
        assertEquals(1, (int)compareToBuilder.build());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testAppendTaking2ObjectArraysReturningCompareToBuilderWhereToComparisonIsNegative() throws Throwable  {
        // Given: Set up two arrays with different lengths
        Object[] arg0 = new Object[1];
        Object[] arg1 = new Object[2];
        
        // When: Compare the two arrays using the compareToBuilder
        CompareToBuilder builder = new CompareToBuilder();
        int result = builder.append(arg0, arg1).build();
        
        // Then: Ensure that the comparison is correct
        assertEquals(-1, result);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testAppendTaking2ObjectArraysReturningCompareToBuilderWhereToComparisonIsPositive() throws Throwable  {
        // Set up the compareToBuilder with an initial value of 0
        CompareToBuilder compareToBuilder = new CompareToBuilder();
        assertEquals(0, compareToBuilder.toComparison());
        
        // Append a null argument to the builder
        Object[] arg0 = new Object[0];
        compareToBuilder.append(arg0, (Object[]) null);
        
        // Assert that the comparison is equal to 1
        assertEquals(1, (int)compareToBuilder.build());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testAppendTaking2ObjectArraysAnd1WithNullAndAppendTaking2ObjectArraysAnd1ReturningCompareToBuilderWhereToComparisonIsNegative() throws Throwable  {
        // Given a CompareToBuilder with null array and non-null objects
        CompareToBuilder compareToBuilder = new CompareToBuilder();
        Object[] arg1 = new Object[7];
        Comparator<Integer> arg2 = (Comparator<Integer>) mock(Comparator.class, new ViolatedAssumptionAnswer());
        
        // When we append null array and non-null objects to the builder
        compareToBuilder.append((Object[]) null, arg1, arg2);
        
        // Then the result should be -1
        assertEquals(-1, (int)compareToBuilder.build());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testAppendTaking2BooleansWithFalse() throws Throwable  {
        CompareToBuilder compareToBuilder = new CompareToBuilder();
        
        // Given that we have two short arrays, arg1 and arg2
        short[] arg1 = new short[1];
        short[] arg2 = new short[1];
        
        // When we append them to the compareToBuilder
        compareToBuilder.append(arg1, arg2);
        
        // Then the result of the comparison should be -1
        assertEquals((-1), (int)compareToBuilder.build());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testAppendTaking2BooleansReturningCompareToBuilderWhereToComparisonIsPositive() throws Throwable  {
        // Given: A CompareToBuilder instance with no appended values
        CompareToBuilder compareToBuilder = new CompareToBuilder();
        
        // When: Appending a boolean value of "true" and a boolean value of "false"
        compareToBuilder.append(true, false);
        
        // Then: The result of the comparison should be 1 (meaning true is greater than false)
        assertEquals(1, compareToBuilder.toComparison());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testAppendTaking2BooleansReturningCompareToBuilderWhereToComparisonIsNegative() throws Throwable  {
        // Given two objects to be compared
        Object arg1 = new Object();
        Comparator<Integer> arg2 = (Comparator<Integer>) mock(Comparator.class, new ViolatedAssumptionAnswer());
        
        // When we append the first object to the CompareToBuilder
        CompareToBuilder compareToBuilder = new CompareToBuilder();
        compareToBuilder.append((Object) null, arg1, arg2);
        
        // Then we expect a comparison of -1
        assertEquals(-1, compareToBuilder.toComparison());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testAppendTaking2BooleansReturningCompareToBuilderWhereToComparisonIsZero() throws Throwable  {
        // No Comments were added
        CompareToBuilder compareToBuilder = new CompareToBuilder();
        CompareToBuilder append = compareToBuilder.append(true, true);
        assertEquals(0, append.toComparison());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testAppendTaking2FloatsReturningCompareToBuilderWhereToComparisonIsNegative() throws Throwable  {
        // Create a new instance of CompareToBuilder
        CompareToBuilder compareToBuilder = new CompareToBuilder();
        
        // Append the result of calling "appendSuper" method with -68 as argument
        compareToBuilder.appendSuper((-68));
        
        // Append the float values -68 and -68 using the "append" method
        compareToBuilder.append((float) (-68), (float) (-68));
        
        // Assert that the comparison result is equal to -68
        assertEquals((-68), (int)compareToBuilder.build());
        
        // Assert that the comparison result is equal to -68 using "toComparison" method
        assertEquals((-68), compareToBuilder.toComparison());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testAppendTaking2FloatArraysReturningCompareToBuilderWhereToComparisonIsZero() throws Throwable  {
        // rollbacked to evosuite
        CompareToBuilder compareToBuilder = new CompareToBuilder();
        float[] arg0 = new float[3];
        float[] arg1 = new float[3];
        CompareToBuilder append = compareToBuilder.append(arg0, arg1);
        assertEquals(0, append.toComparison());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testAppendTaking2DoublesReturningCompareToBuilderWhereToComparisonIsPositive() throws Throwable  {
        // Given a CompareToBuilder instance
        CompareToBuilder compareToBuilder = new CompareToBuilder();
        
        // When we append a superclass value
        compareToBuilder.appendSuper(5);
        
        // And we append a subclass value
        compareToBuilder.append((double) 5, 1.0);
        
        // Then the comparison result should be 5
        assertEquals(5, compareToBuilder.toComparison());
        
        // And the built comparison result should also be 5
        assertEquals(5, (int)compareToBuilder.build());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testAppendTaking2DoublesReturningCompareToBuilderWhereToComparisonIsNegative() throws Throwable  {
        // Create a new instance of the CompareToBuilder class
        CompareToBuilder compareToBuilder = new CompareToBuilder();
        
        // Append the two float values to be compared
        compareToBuilder.append(0.1f, 0.2f);
        
        // Assert that the comparison results in -1
        assertEquals((-1), (int)compareToBuilder.build());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testAppendTaking2BytesReturningCompareToBuilderWhereToComparisonIsPositive() throws Throwable  {
        // Given a CompareToBuilder instance with two byte values
        CompareToBuilder compareToBuilder = new CompareToBuilder();
        compareToBuilder.append((byte) 55, (byte) 30);
        
        // When we append an array of Objects and a Comparator to the builder
        Object[] arg1 = new Object[0];
        Comparator<Integer> arg2 = (Comparator<Integer>) mock(Comparator.class, new ViolatedAssumptionAnswer());
        compareToBuilder.append(arg1, arg1, arg2);
        
        // Then the builder should have a non-zero comparison result
        assertNotEquals(0, compareToBuilder.toComparison());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testAppendTaking2BytesReturningCompareToBuilderWhereToComparisonIsZero() throws Throwable  {
        // No Comments were added
        CompareToBuilder compareToBuilder = new CompareToBuilder();
        CompareToBuilder append = compareToBuilder.append((byte)28, (byte)28);
        assertEquals(0, append.toComparison());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testAppendSuperReturningCompareToBuilderWhereToComparisonIsNegative() throws Throwable  {
        // Given a CompareToBuilder instance with a super comparison result of -128
        CompareToBuilder compareToBuilder = new CompareToBuilder();
        compareToBuilder.appendSuper((byte) (-128));
        
        // When we append another comparison result of -128 to the same type
        compareToBuilder.append((byte) (-128), (byte) (-128));
        
        // Then the final comparison result should be -128
        assertEquals((-128), compareToBuilder.toComparison());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testAppendTaking2Bytes() throws Throwable  {
        // Test the CompareToBuilder class to check if it correctly compares two bytes
        CompareToBuilder compareToBuilder = new CompareToBuilder();
        compareToBuilder.append((byte) -85, (byte) -4);
        assertEquals(-1, compareToBuilder.toComparison());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testAppendTaking2CharsReturningCompareToBuilderWhereToComparisonIsPositive() throws Throwable  {
        // Create a new CompareToBuilder instance
        CompareToBuilder compareToBuilder = new CompareToBuilder();
        
        // Append two strings to the builder, one with a 'z' and one with a '9'
        compareToBuilder.append('z', '9');
        compareToBuilder.append('z', 'z');
        
        // Assert that the comparison is equal to 1
        assertEquals(1, compareToBuilder.toComparison());
        
        // Assert that the built comparison is also equal to 1
        assertEquals(1, (int)compareToBuilder.build());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testAppendTaking2ShortsReturningCompareToBuilderWhereToComparisonIsZero() throws Throwable  {
        // rollbacked to evosuite
        CompareToBuilder compareToBuilder = new CompareToBuilder();
        CompareToBuilder append = compareToBuilder.append((short) (-1221), (short) (-1221));
        assertEquals(0, append.toComparison());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testAppendTaking2ShortsReturningCompareToBuilderWhereToComparisonIsNegative() throws Throwable  {
        // Given
        CompareToBuilder compareToBuilder = new CompareToBuilder();
        
        // When
        compareToBuilder.append((short) (-246), (short) 5);
        
        // Then
        assertEquals(-1, (int) compareToBuilder.build());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testAppendTaking2ShortsReturningCompareToBuilderWhereToComparisonIsPositive() throws Throwable  {
        // rollbacked to evosuite
        CompareToBuilder compareToBuilder = new CompareToBuilder();
        assertEquals(0, (int)compareToBuilder.build());
        
        char[] arg0 = new char[0];
        CompareToBuilder append = compareToBuilder.append(arg0, (char[]) null);
        append.append((short) (-1192), (short)1);
        assertEquals(1, (int)compareToBuilder.build());
        assertEquals(1, compareToBuilder.toComparison());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testAppendTaking2IntsReturningCompareToBuilderWhereToComparisonIsZero() throws Throwable  {
        // No Comments were added
        CompareToBuilder compareToBuilder = new CompareToBuilder();
        CompareToBuilder append = compareToBuilder.append(4, 4);
        assertEquals(0, append.toComparison());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testToComparison() throws Throwable  {
        // Create a new CompareToBuilder instance and append the values 0 and 2482
        CompareToBuilder compareToBuilder = new CompareToBuilder();
        CompareToBuilder append = compareToBuilder.append(0, 2482);
        
        // Build the comparison result using the toComparison() method
        int comparison = append.toComparison();
        
        // Assert that the comparison result is negative (i.e., 0 < 2482)
        assertEquals((-1), (int)compareToBuilder.build());
        
        // Assert that the comparison result is also negative (i.e., 0 < 2482)
        assertEquals((-1), comparison);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testAppendSuperReturningCompareToBuilderWhereToComparisonIsPositive() throws Throwable  {
        CompareToBuilder compareToBuilder = new CompareToBuilder();
        // Append a superclass field with a value of 10
        compareToBuilder.appendSuper(10);
        // Append two fields with values of 10 and 20 respectively
        compareToBuilder.append(10, 20);
        // Assert that the comparison result is equal to 10
        assertEquals(10, compareToBuilder.toComparison());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testAppendTaking2Ints() throws Throwable  {
        // rollbacked to evosuite
        CompareToBuilder compareToBuilder = new CompareToBuilder();
        assertEquals(0, (int)compareToBuilder.build());
        
        compareToBuilder.append(10, 5);
        assertEquals(1, compareToBuilder.toComparison());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testAppendTaking2LongArraysWithNonEmptyArray() throws Throwable  {
        // This test ensures that the CompareToBuilder class behaves as expected when comparing two long arrays with different lengths
        // Set up the test data
        long[] arg0 = new long[3];
        arg0[0] = 95L;
        long[] arg1 = new long[4];
        arg1[0] = 95L;
        
        // Create a new CompareToBuilder and append the two arrays
        CompareToBuilder compareToBuilder = new CompareToBuilder();
        compareToBuilder.append(arg0, arg1);
        
        // Verify that the comparison is correct
        assertEquals(1, compareToBuilder.toComparison());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testAppendTaking2Longs() throws Throwable  {
        // Given
        CompareToBuilder compareToBuilder = new CompareToBuilder();
        
        // When
        compareToBuilder.append(318L, 1454L);
        
        // Then
        assertEquals(-1, (int)compareToBuilder.build());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testAppendTaking2LongsReturningCompareToBuilderWhereToComparisonIsZero() throws Throwable  {
        // Arrange
        CompareToBuilder compareToBuilder = new CompareToBuilder();
        
        // Act
        int result = compareToBuilder.append(1234567890L, 1234567890L).toComparison();
        
        // Assert
        assertEquals(0, result);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testAppendTaking2ObjectsAnd1ReturningCompareToBuilderWhereToComparisonIsZero() throws Throwable  {
        // Given
        CompareToBuilder compareToBuilder = new CompareToBuilder();
        Object object1 = new Object();
        Comparator<Integer> comparator = mock(Comparator.class, new ViolatedAssumptionAnswer());
        doReturn(0).when(comparator).compare(anyInt(), anyInt());
        
        // When
        CompareToBuilder append = compareToBuilder.append(1234567890, object1, comparator);
        
        // Then
        assertEquals(0, (int) append.build());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testAppendTaking2ObjectsReturningCompareToBuilderWhereToComparisonIsPositive() throws Throwable  {
        // rollbacked to evosuite
        CompareToBuilder arg0 = new CompareToBuilder();
        assertEquals(0, (int)arg0.build());
        
        arg0.append((Object) arg0, (Object) null);
        assertEquals(1, (int)arg0.build());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testAppendTaking2ObjectsAnd1ReturningCompareToBuilderWhereToComparisonIsNegative() throws Throwable  {
        // Given
        Object arg1 = new Object();
        Comparator<Integer> arg2 = (Comparator<Integer>) mock(Comparator.class, new ViolatedAssumptionAnswer());
        
        // When
        CompareToBuilder compareToBuilder = new CompareToBuilder();
        compareToBuilder.append((Object) null, arg1, arg2);
        compareToBuilder.append(2473L, 2473L);
        
        // Then
        assertEquals(-1, (int) compareToBuilder.build());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testAppendTaking2ObjectArraysReturningCompareToBuilderWhereToComparisonIsZero() throws Throwable  {
        // Given
        CompareToBuilder compareToBuilder = new CompareToBuilder();
        Object[] arg0 = new Object[1];
        Object[] arg1 = new Object[1];
        
        // When
        CompareToBuilder append = compareToBuilder.append(arg0, arg1);
        
        // Then
        assertEquals(0, (int)append.build());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testAppendTaking2CharsReturningCompareToBuilderWhereToComparisonIsNegative() throws Throwable  {
        // No Comments were added
        CompareToBuilder compareToBuilder = new CompareToBuilder();
        Object arg1 = new Object();
        compareToBuilder.append('[', 'g');
        Comparator<Integer> arg2 = (Comparator<Integer>) mock(Comparator.class, new ViolatedAssumptionAnswer());
        compareToBuilder.append(arg1, arg1, arg2);
        assertEquals((-1), compareToBuilder.toComparison());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testAppendTaking2ShortsWithPositive() throws Throwable  {
        // Testing the compareTo method with a positive number
        CompareToBuilder compareToBuilder = new CompareToBuilder();
        int result = compareToBuilder.build();
        assertEquals(0, result);
        
        // Testing the append method with a negative number
        compareToBuilder.append((short)522, (short) (-836));
        assertEquals(1, compareToBuilder.toComparison());
        
        // Testing the appendSuper method with a negative number
        compareToBuilder.appendSuper((-2292));
        assertEquals(1, compareToBuilder.toComparison());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testReflectionCompareTaking2ObjectsAnd1ReturningZeroAndReflectionCompareTaking2ObjectsAnd11() throws Throwable  {
        // Given a String array of length 17 containing the names of some attributes to compare
        String[] arg2 = new String[17];
        
        // When we use the reflectionCompare method from Apache Commons Lang's CompareToBuilder class
        int reflectionCompare = CompareToBuilder.reflectionCompare((Object) "java.runtime.version", (Object) "java.runtime.version", arg2);
        
        // Then the result of the comparison should be 0, as both strings are equal
        assertEquals(0, reflectionCompare);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testBuildReturningZero() throws Throwable  {
        // No Comments were added
        CompareToBuilder compareToBuilder = new CompareToBuilder();
        Integer arg0 = new Integer(1234567890);
        Integer arg1 = compareToBuilder.build();
        assertEquals(0, (int)arg1);
        
        LinkedList<String> arg2 = new LinkedList<String>();
        int reflectionCompare = CompareToBuilder.reflectionCompare((Object) arg0, (Object) arg1, (Collection<String>) arg2);
        assertEquals(1, reflectionCompare);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testReflectionCompareTaking5ArgumentsReturningPositive() throws Throwable  {
        // Given: a pair of Integers with different values
        Integer arg0 = new Integer(46);
        Integer arg1 = new Integer(-3614);
        
        // When: we compare the two Integers using reflection
        Class<Integer> arg3 = Integer.class;
        String[] arg4 = new String[8];
        int reflectionCompare = CompareToBuilder.reflectionCompare((Object) arg0, (Object) arg1, true, (Class<?>) arg3, arg4);
        
        // Then: the result of the comparison should be 1
        assertEquals(1, reflectionCompare);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testReflectionCompareTaking5ArgumentsThrowsClassCastException() throws Throwable  {
        // Given
        Integer arg0 = new Integer((-1));
        Object arg1 = new Object();
        Class<Integer> arg3 = Integer.class;
        String[] arg4 = new String[4];
        
        // When
        try {
        CompareToBuilder.reflectionCompare(arg0, arg1, true, arg3, arg4);
        fail("Expecting exception: ClassCastException");
        } catch (ClassCastException e) {
        // Then
        verifyException("org.apache.commons.lang3.builder.CompareToBuilder", e);}
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testReflectionCompareTaking5ArgumentsWithNonNull() throws Throwable  {
        // Test that reflectionCompare throws a NullPointerException when the first argument is null
        // Given
        Object arg0 = null;
        Class<Integer> arg3 = Integer.class;
        String[] arg4 = new String[1];
        
        // When
        try {
        CompareToBuilder.reflectionCompare(arg0, (Object) null, false, (Class<?>) arg3, arg4);
        fail("Expecting exception: NullPointerException");
        } catch(NullPointerException e) {
        // Then
        assertEquals("No message in exception", null, e.getMessage());}
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testReflectionCompareTaking5ArgumentsThrowsNullPointerException() throws Throwable  {
        // Given
        Object arg1 = null;
        Class<Integer> arg3 = Integer.class;
        String[] arg4 = new String[2];
        
        // When
        try {
        CompareToBuilder.reflectionCompare(arg1, arg1, false, arg3, arg4);
        fail("Expecting exception: NullPointerException");
        } catch (NullPointerException e) {
        verifyException("org.apache.commons.lang3.builder.CompareToBuilder", e);
        }
        
        // Then
        // Verify that the method throws a NullPointerException if the first argument is null
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testReflectionCompareTaking2ArgumentsReturningZero() throws Throwable  {
        // Given: Two objects are created with the same values for all fields
        Object obj1 = new Object();
        Object obj2 = new Object();
        
        // When: We compare the two objects using the CompareToBuilder class
        int reflectionCompare = CompareToBuilder.reflectionCompare(obj1, obj2);
        
        // Then: The result of the comparison should be 0, indicating that the two objects are equal
        assertEquals(0, reflectionCompare);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testReflectionCompareTaking2ObjectsAnd1ReturningZeroAndReflectionCompareTaking2ObjectsAnd12() throws Throwable  {
        // Given: Two integers with the same value
        Integer arg1 = new Integer(1234567890);
        
        // When: We compare them using the CompareToBuilder
        int reflectionCompare = CompareToBuilder.reflectionCompare((Object) arg1, (Object) arg1, (Collection<String>) null);
        
        // Then: The comparison should return 0
        assertEquals(0, reflectionCompare);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testReflectionCompareTaking2ObjectsAnd1ReturningNegativeAndReflectionCompareTaking2ObjectsAnd12() throws Throwable  {
        // This test verifies that the CompareToBuilder.reflectionCompare method correctly compares two objects.
        // The method is expected to return -1 since "apple" comes before "banana" in alphabetical order.
        
        int reflectionCompare = CompareToBuilder.reflectionCompare((Object) "apple", (Object) "banana", true);
        assertEquals((-1), reflectionCompare);
    }
  }
  