content: /*
   * This file was automatically generated by UTestGen and EvoSuite
   * Tue Mar 19 09:45:19 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.util.Arrays;
  import java.util.UUID;
  import org.apache.commons.lang3.Conversion;
  import org.evosuite.runtime.EvoRunner;
  import org.evosuite.runtime.EvoRunnerParameters;
  import org.evosuite.runtime.mock.java.util.MockUUID;
  import org.junit.runner.RunWith;
  
  @RunWith(EvoRunner.class) @EvoRunnerParameters(mockJVMNonDeterminism = true, useVFS = true, useVNET = true, resetStaticState = true, separateClassLoader = true) 
  public class Conversion_ESTest extends Conversion_ESTest_scaffolding {
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testUuidToByteArrayReturningEmptyArray() throws Throwable  {
        // rollbacked to evosuite
        UUID arg0 = MockUUID.fromString("RocLmWP[^hLb*{Lx<t");
        byte[] arg1 = new byte[0];
        byte[] uuidToByteArray = Conversion.uuidToByteArray(arg0, arg1, (-2412), (-2412));
        assertArrayEquals(new byte[] {}, uuidToByteArray);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testShortToByteArrayReturningNonEmptyArray() throws Throwable  {
        // rollbacked to evosuite
        byte[] arg2 = new byte[1];
        byte[] shortToByteArray = Conversion.shortToByteArray((short) (-3652), (-605), arg2, 101, (short) (-3652));
        assertSame(arg2, shortToByteArray);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testShortArrayToLongReturningZero() throws Throwable  {
        // Given: A short array with a length of 8 and some initial values
        short[] arg0 = new short[8];
        
        // When: The method is called with the array, starting index, and end index
        long shortArrayToLong = Conversion.shortArrayToLong(arg0, 0, 0L, (short) (-1995), 0);
        
        // Then: The result should be equal to 0L
        assertEquals(0L, shortArrayToLong);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testLongToShortArrayReturningNonEmptyArray() throws Throwable  {
        // Arrange
        short[] expected = new short[5];
        short[] actual = Conversion.longToShortArray((byte) 0, (-2517), expected, 59, (-378));
        
        // Act
        // Convert long values to short array using the Conversion class
        
        // Assert
        assertSame(actual, expected);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testLongToIntArrayReturningEmptyArray() throws Throwable  {
        // No Comments were added
        int[] arg2 = new int[0];
        int[] longToIntArray = Conversion.longToIntArray(3150L, 58, arg2, 58, (-2274));
        assertSame(longToIntArray, arg2);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testLongToHexReturningEmptyString() throws Throwable  {
        // Given a number of different types (short, int, and long) and their corresponding hexadecimal values
        String longToHex = Conversion.longToHex((short)0, (-582), "", (-582), (-738));
        
        // When we convert these numbers to hexadecimal using the longToHex method
        assertEquals("", longToHex);
        
        // Then we expect the resulting string to be empty, as all of the input values are invalid and cannot be represented in hexadecimal format.
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testLongToByteArrayReturningEmptyArray() throws Throwable  {
        // rollbacked to evosuite
        byte[] arg2 = new byte[0];
        byte[] longToByteArray = Conversion.longToByteArray(0L, (-813), arg2, 0, 0);
        assertSame(longToByteArray, arg2);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testLongToBinaryReturningNonEmptyArray() throws Throwable  {
        // Convert the long value 176 to a binary array with a length of 370
        boolean[] arg2 = new boolean[5];
        boolean[] longToBinary = Conversion.longToBinary(176L, 370, arg2, (-1509), 0);
        
        // Assert that the returned array is equal to the expected value
        assertTrue(Arrays.equals(new boolean[] {false, false, false, false, false}, longToBinary));
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testIntToShortArrayReturningEmptyArray() throws Throwable  {
        // Given an input integer array with 0 elements
        short[] arg2 = new short[0];
        
        // When converting the input to a short array
        short[] intToShortArray = Conversion.intToShortArray((-1583), (-1583), arg2, (-1583), (-1583));
        
        // Then assert that the output is an empty short array
        assertArrayEquals(new short[] {}, intToShortArray);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testIntToHexDigitReturningDigit() throws Throwable  {
        // Given a number 4, when it is converted to a hexadecimal digit using the intToHexDigit method, then the resulting value should be the character '4'.
        char intToHexDigit = Conversion.intToHexDigit(4);
        assertEquals('4', intToHexDigit);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testIntToHexReturningNull() throws Throwable  {
        // No Comments were added
        String intToHex = Conversion.intToHex(4, 62, (String) null, 0, 0);
        assertNull(intToHex);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testIntToByteArrayReturningNull() throws Throwable  {
        // No Comments were added
        byte[] intToByteArray = Conversion.intToByteArray(1764, 1, (byte[]) null, 0, 0);
        assertNull(intToByteArray);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testIntToBinaryReturningEmptyArray() throws Throwable  {
        // No Comments were added
        boolean[] arg2 = new boolean[0];
        boolean[] intToBinary = Conversion.intToBinary(10, 69, arg2, 10, (-1775));
        assertSame(intToBinary, arg2);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testHexToShortReturningZero() throws Throwable  {
        // Convert a negative hexadecimal number to a short value.
        // The input is a string representing the hexadecimal number.
        // The output should be the decimal representation of the input number.
        
        short expected = (short) 0;
        short actual = Conversion.hexToShort("", 1297, (short)0, 4786, (-2517));
        
        assertEquals(expected, actual);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testHexToLongReturningNegative() throws Throwable  {
        long hexToLong = Conversion.hexToLong("s07c/)x@1Q>", (-48), (-48), 1, (-48));
        assertEquals((-48L), hexToLong);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testHexToIntReturningNegative() throws Throwable  {
        // No Comments were added
        int hexToInt = Conversion.hexToInt((String) null, (-1624), (-1624), 0, 0);
        assertEquals((-1624), hexToInt);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testHexDigitToIntReturningZero() throws Throwable  {
        // No Comments were added
        int hexDigitToInt = Conversion.hexDigitToInt('0');
        assertEquals(0, hexDigitToInt);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testByteArrayToShortReturningPositive() throws Throwable  {
        // Given a byte array of length 5 and a set of short values to convert to.
        byte[] arg0 = new byte[5];
        short byteArrayToShort = Conversion.byteArrayToShort(arg0, (short) (-2819), (byte)22, 95, (byte) (-56));
        
        // When the method is called with the array and the set of short values.
        assertEquals((short)22, byteArrayToShort);
        
        // Then the method should return the correct converted value of type short.
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testByteArrayToLongReturningNegative() throws Throwable  {
        // Given a byte array containing bytes representing a long value
        byte[] arg0 = new byte[7];
        
        // When the byte array is converted to a long using the Conversion class
        long byteArrayToLong = Conversion.byteArrayToLong(arg0, 0, (-76L), (byte)51, (byte) (-124));
        
        // Then the resulting long value should be equal to the expected value
        assertEquals((-76L), byteArrayToLong);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testBinaryToShortReturningZero() throws Throwable  {
        // Given a boolean array arg0 with length 3 and initial value (1, 0, 93, 0)
        boolean[] arg0 = new boolean[]{true, false, true, false};
        
        // When the binaryToShort method is called with arg0, 1, (short)0, 93, 0
        short result = Conversion.binaryToShort(arg0, 1, (short)0, 93, 0);
        
        // Then the result should be (short)0
        assertEquals((short)0, result);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testBinaryToIntReturningZero() throws Throwable  {
        // Given an empty array of booleans
        boolean[] arg0 = new boolean[0];
        
        // When the method is called with this empty array
        int binaryToInt = Conversion.binaryToInt(arg0, (-793), 0, (-793), (-793));
        
        // Then the result should be 0
        assertEquals(0, binaryToInt);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testLongToByteArrayThrowsArrayIndexOutOfBoundsException() throws Throwable  {
        // Given: A byte array of length 5
        byte[] arg2 = new byte[5];
        
        // When: We call the longToByteArray method with a negative value and an offset greater than the length of the array
        try {
        Conversion.longToByteArray(-1877, -1877, arg2, 0, 50);
        fail("Expecting exception: ArrayIndexOutOfBoundsException");
        
        } catch (ArrayIndexOutOfBoundsException e) {
        // Then: We expect an ArrayIndexOutOfBoundsException to be thrown
        verifyException("org.apache.commons.lang3.Conversion", e);}
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testLongToByteArrayReturningNull() throws Throwable  {
        // No Comments were added
        byte[] longToByteArray = Conversion.longToByteArray((-330), 56, (byte[]) null, (-330), (-330));
        assertNull(longToByteArray);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testByteArrayToLongThrowsArrayIndexOutOfBoundsException() throws Throwable  {
        // Given
        byte[] input = new byte[5];
        
        // When
        try {
        Conversion.byteArrayToLong(input, (byte) 4, (-748), (-1071), (byte) 4);
        fail("Expecting exception: ArrayIndexOutOfBoundsException");
        } catch (ArrayIndexOutOfBoundsException e) {
        // Then
        verifyException("org.apache.commons.lang3.Conversion", e);}
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testIntToHexDigitReturningAlphabeticChar() throws Throwable  {
        // Given: We have a method called 'intToHexDigit' that takes an integer as input and returns its corresponding hexadecimal character representation.
        
        char intToHexDigit = Conversion.intToHexDigit(14);
        
        // When: We pass the integer 14 to the method 'intToHexDigit'.
        
        // Then: The returned value should be the hexadecimal character 'e'.
        
        assertEquals('e', intToHexDigit);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testBinaryBeMsb0ToHexDigitTaking2ArgumentsAndBinaryBeMsb0ToHexDigitTaking2ArgumentsReturningDigit0() throws Throwable  {
        // No Comments were added
        boolean[] arg0 = new boolean[3];
        arg0[0] = true;
        arg0[1] = true;
        char binaryBeMsb0ToHexDigit = Conversion.binaryBeMsb0ToHexDigit(arg0, 1);
        assertEquals('3', binaryBeMsb0ToHexDigit);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testBinaryBeMsb0ToHexDigitTaking2ArgumentsAndBinaryBeMsb0ToHexDigitTaking2ArgumentsReturningDigit1() throws Throwable  {
        // Given: we have a boolean array containing 6 values
        boolean[] arg0 = new boolean[6];
        
        // When: we call the Conversion.binaryBeMsb0ToHexDigit method with the first value of the array (index 1)
        char binaryBeMsb0ToHexDigit = Conversion.binaryBeMsb0ToHexDigit(arg0, 1);
        
        // Then: we assert that the result is the hexadecimal character '4'
        assertEquals('4', binaryBeMsb0ToHexDigit);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testBinaryBeMsb0ToHexDigitTaking2ArgumentsAndBinaryBeMsb0ToHexDigitTaking2ArgumentsReturningDigit2() throws Throwable  {
        // Given
        boolean[] arg0 = new boolean[7];
        arg0[0] = true;
        arg0[1] = true;
        arg0[2] = true;
        
        // When
        char binaryBeMsb0ToHexDigit = Conversion.binaryBeMsb0ToHexDigit(arg0, (int) (short)4);
        
        // Then
        assertEquals('7', binaryBeMsb0ToHexDigit);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testBinaryBeMsb0ToHexDigitTaking2ArgumentsAndBinaryBeMsb0ToHexDigitTaking2ArgumentsReturningDigit3() throws Throwable  {
        // Given a binary number represented as an array of bits, where the most significant bit is at the 5th index and the least significant bit is at the 6th index
        boolean[] arg0 = new boolean[8];
        arg0[5] = true;
        arg0[6] = true;
        
        // When the binary number is converted to a hexadecimal digit using the MSB-first (big endian) representation of the binary number
        char binaryBeMsb0ToHexDigit = Conversion.binaryBeMsb0ToHexDigit(arg0, (int) (byte) 0);
        
        // Then the hexadecimal equivalent of the binary number is returned as a character
        assertEquals('6', binaryBeMsb0ToHexDigit);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testBinaryBeMsb0ToHexDigitTaking2ArgumentsAndHexDigitMsb0ToBinary() throws Throwable  {
        // No Comments were added
        boolean[] arg0 = Conversion.hexDigitMsb0ToBinary('A');
        char binaryBeMsb0ToHexDigit = Conversion.binaryBeMsb0ToHexDigit(arg0, 1);
        assertEquals('5', binaryBeMsb0ToHexDigit);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testBinaryBeMsb0ToHexDigitTaking2ArgumentsAndBinaryBeMsb0ToHexDigitTaking2ArgumentsReturningAlphabeticChar0() throws Throwable  {
        // Arrange
        boolean[] arg0 = new boolean[5];
        arg0[1] = true;
        arg0[2] = true;
        arg0[3] = true;
        arg0[4] = true;
        
        // Act
        char binaryBeMsb0ToHexDigit = Conversion.binaryBeMsb0ToHexDigit(arg0, (int) (short) 0);
        
        // Assert
        assertEquals('f', binaryBeMsb0ToHexDigit);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testBinaryBeMsb0ToHexDigitTaking2ArgumentsAndBinaryBeMsb0ToHexDigitTaking2ArgumentsReturningAlphabeticChar1() throws Throwable  {
        // Given: an array of boolean values representing a binary number
        boolean[] arg0 = new boolean[9];
        arg0[5] = true;
        arg0[6] = true;
        arg0[7] = true;
        
        // When: the binary number is converted to a hexadecimal digit using the Conversion.binaryBeMsb0ToHexDigit() method
        char hexDigit = Conversion.binaryBeMsb0ToHexDigit(arg0, 0);
        
        // Then: the resulting hexadecimal digit should be 'e'
        assertEquals('e', hexDigit);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testBinaryToHexDigitMsb0_4bitsTaking2ArgumentsAndBinaryToHexDigitMsb0_4bitsTaking2ArgumentsReturningAlphabeticChar0() throws Throwable  {
        // Given a boolean array containing only 0s and 1s
        boolean[] arg0 = new boolean[5];
        arg0[0] = true;
        arg0[1] = true;
        
        // When the method Conversion.binaryToHexDigitMsb0_4bits is called with the array as input
        char binaryToHexDigitMsb0_4bits = Conversion.binaryToHexDigitMsb0_4bits(arg0, (int) (byte) 0);
        
        // Then the output should be the hexadecimal character 'c'
        assertEquals('c', binaryToHexDigitMsb0_4bits);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testBinaryToHexDigitMsb0_4bitsTaking2ArgumentsAndBinaryToHexDigitMsb0_4bitsTaking2ArgumentsReturningAlphabeticChar1() throws Throwable  {
        // Setup
        boolean[] arg0 = new boolean[5];
        arg0[0] = true;
        arg0[2] = true;
        
        // Expected behavior
        char expectedResult = 'a';
        
        // Actual result
        char actualResult = Conversion.binaryToHexDigitMsb0_4bits(arg0, (int) (byte) 0);
        
        // Assertion
        assertEquals(expectedResult, actualResult);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testBinaryToHexDigitMsb0_4bitsTaking2ArgumentsAndBinaryToHexDigitMsb0_4bitsTaking2ArgumentsReturningDigit0() throws Throwable  {
        // Given: A boolean array containing a single true value at index 2
        boolean[] arg0 = new boolean[4];
        arg0[2] = true;
        
        // When: The binaryToHexDigitMsb0_4bits function is called with the array and an offset of 0
        char binaryToHexDigitMsb0_4bits = Conversion.binaryToHexDigitMsb0_4bits(arg0, 0);
        
        // Then: The function returns the hexadecimal character '2'
        assertEquals('2', binaryToHexDigitMsb0_4bits);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testBinaryToHexDigitMsb0_4bitsTaking2ArgumentsAndBinaryToHexDigitMsb0_4bitsTaking2ArgumentsReturningAlphabeticChar2() throws Throwable  {
        // Test the method to convert a 4-bit binary number to its corresponding hexadecimal digit (most significant bit first)
        boolean[] arg0 = new boolean[5];
        arg0[0] = true;
        arg0[1] = true;
        arg0[3] = true;
        char actualResult = Conversion.binaryToHexDigitMsb0_4bits(arg0, (int) (byte) 0);
        assertEquals('d', actualResult);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testBinaryToHexDigitMsb0_4bitsTaking2ArgumentsAndBinaryToHexDigitMsb0_4bitsTaking2ArgumentsReturningDigit1() throws Throwable  {
        // No Comments were added
        boolean[] arg0 = new boolean[5];
        arg0[1] = true;
        arg0[3] = true;
        char binaryToHexDigitMsb0_4bits = Conversion.binaryToHexDigitMsb0_4bits(arg0, (int) (byte)0);
        assertEquals('5', binaryToHexDigitMsb0_4bits);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testBinaryToHexDigitMsb0_4bitsTaking2ArgumentsAndBinaryToHexDigitMsb0_4bitsTaking2ArgumentsReturningAlphabeticChar3() throws Throwable  {
        // Given a boolean array with four elements
        boolean[] arg0 = new boolean[6];
        
        // When the first element is true, and the second through fourth elements are also true
        arg0[1] = true;
        arg0[2] = true;
        arg0[3] = true;
        arg0[4] = true;
        
        // Then the result of calling binaryToHexDigitMsb0_4bits with arg0 and 1 as arguments should be 'f'
        char binaryToHexDigitMsb0_4bits = Conversion.binaryToHexDigitMsb0_4bits(arg0, 1);
        assertEquals('f', binaryToHexDigitMsb0_4bits);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testBinaryToHexDigitTaking2ArgumentsAndBinaryToHexDigitTaking2ArgumentsReturningDigit0() throws Throwable  {
        // Given: An array of booleans representing a binary number
        boolean[] arg0 = new boolean[5];
        arg0[0] = true;
        arg0[1] = true;
        
        // When: Calling the method to convert the binary number to a hexadecimal digit
        char binaryToHexDigit = Conversion.binaryToHexDigit(arg0, 0);
        
        // Then: The resulting hexadecimal digit should be '3'
        assertEquals('3', binaryToHexDigit);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testBinaryToHexDigitTaking2ArgumentsAndBinaryToHexDigitTaking2ArgumentsReturningAlphabeticChar0() throws Throwable  {
        // Given: A boolean array with a value of true at indices 0 and 1
        boolean[] arg0 = new boolean[8];
        arg0[0] = true;
        arg0[1] = true;
        
        // When: Calling the binaryToHexDigit method with the given array and index 0
        char binaryToHexDigit = Conversion.binaryToHexDigit(arg0, 0);
        
        // Then: The result should be the hexadecimal character 'b'
        assertEquals('b', binaryToHexDigit);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testByteArrayToUuidThrowsIllegalArgumentException() throws Throwable  {
        // Test that an exception is thrown when the input byte array has fewer than 16 bytes.
        byte[] arg0 = new byte[5];
        try {
        Conversion.byteArrayToUuid(arg0, 1079);
        fail("Expecting exception: IllegalArgumentException");
        } catch (IllegalArgumentException e) {
        // Verify that the correct exception is thrown
        verifyException("org.apache.commons.lang3.Conversion", e);
        
        // Need at least 16 bytes for UUID
        assertEquals(e.getMessage(), "Need at least 16 bytes for UUID");}
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testUuidToByteArrayReturningNull() throws Throwable  {
        // Create a random UUID object
        UUID arg0 = MockUUID.randomUUID();
        
        // Convert the UUID object into a byte array using the Conversion class
        byte[] uuidToByteArray = Conversion.uuidToByteArray(arg0, (byte[]) null, 1, (-2412));
        
        // Assert that the conversion result is null because of an invalid input parameter
        assertNull(uuidToByteArray);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testUuidToByteArrayThrowsIllegalArgumentException() throws Throwable  {
        UUID arg0 = MockUUID.randomUUID();
        byte[] arg1 = new byte[26];
        // Test for exception when nBytes is greater than 16
        try {
        Conversion.uuidToByteArray(arg0, arg1, 0, 1984);
        fail("Expecting exception: IllegalArgumentException");
        } catch (IllegalArgumentException e) {
        // Verify that the correct exception is thrown
        verifyException("org.apache.commons.lang3.Conversion", e);}
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testUuidToByteArrayWithZero() throws Throwable  {
        // Given a UUID and an empty byte array with length 2
        UUID arg0 = MockUUID.randomUUID();
        byte[] arg1 = new byte[2];
        
        // When converting the UUID to a byte array using the `Conversion.uuidToByteArray` method
        byte[] uuidToByteArray = Conversion.uuidToByteArray(arg0, arg1, (byte)0, (byte)0);
        
        // Then the resulting byte array has length 2 and contains the UUID's bytes in the correct order
        assertEquals(2, uuidToByteArray.length);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testByteToBinaryThrowsArrayIndexOutOfBoundsException() throws Throwable  {
        boolean[] arg2 = new boolean[9];
        
        // When
        try {
        Conversion.byteToBinary((byte) (-58), (byte) (-58), arg2, 1, 57);
        
        // Then
        fail("Expecting exception: ArrayIndexOutOfBoundsException");
        } catch(ArrayIndexOutOfBoundsException e) {
        verifyException("org.apache.commons.lang3.Conversion", e);}
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testByteToBinaryReturningNonEmptyArray() throws Throwable  {
        // No Comments were added
        boolean[] arg2 = new boolean[4];
        boolean[] byteToBinary = Conversion.byteToBinary((byte)2, (byte)2, arg2, (byte)2, (byte)2);
        assertTrue(Arrays.equals(new boolean[] {false, false, false, false}, byteToBinary));
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testByteToBinaryThrowsIllegalArgumentException() throws Throwable  {
        // Arrange
        boolean[] dest = new boolean[6];
        
        try {
        // Act
        Conversion.byteToBinary((byte) 13, (byte) 13, dest, (byte) 13, (byte) 13);
        
        // Assert
        fail("Expecting exception: IllegalArgumentException");
        } catch (IllegalArgumentException e) {
        // Assert
        verifyException("org.apache.commons.lang3.Conversion", e);}
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testByteToBinaryReturningEmptyArray() throws Throwable  {
        // Given a byte value of -20 and a byte array with a length of 0
        byte inputByte = (byte) -20;
        boolean[] arg2 = new boolean[0];
        
        // When converting the byte to binary using the Conversion.byteToBinary method
        boolean[] byteToBinary = Conversion.byteToBinary(inputByte, (-3765), arg2, (byte) -20, 0);
        
        // Then the resulting array should have a length of 0
        assertEquals(0, byteToBinary.length);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testByteToBinaryReturningNull() throws Throwable  {
        // No Comments were added
        boolean[] byteToBinary = Conversion.byteToBinary((byte) (-110), 116, (boolean[]) null, 97, (byte) (-110));
        assertNull(byteToBinary);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testShortToBinaryWithNegative() throws Throwable  {
        // No Comments were added
        boolean[] arg2 = new boolean[6];
        boolean[] shortToBinary = Conversion.shortToBinary((short) (-1), 1, arg2, 1, 1);
        assertTrue(Arrays.equals(new boolean[] {false, true, false, false, false, false}, shortToBinary));
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testShortToBinaryWithPositive() throws Throwable  {
        // Convert a short value to its binary representation using the Conversion.shortToBinary method
        boolean[] arg2 = new boolean[4];
        boolean[] shortToBinary = Conversion.shortToBinary((short)1, (short)1, arg2, (short)1, (short)1);
        
        // Verify that the resulting binary representation is correct
        assertTrue(Arrays.equals(new boolean[] {false, false, false, false}, shortToBinary));
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testShortToBinaryThrowsIllegalArgumentException() throws Throwable  {
        // No Comments were added
        boolean[] arg2 = new boolean[0];
        // Undeclared exception!
        try { 
          Conversion.shortToBinary((short)49, (short)49, arg2, (short)49, (short)49);
          fail("Expecting exception: IllegalArgumentException");
        
        } catch(IllegalArgumentException e) {
           //
           // nBools-1+srcPos is greather or equal to than 16
           //
           verifyException("org.apache.commons.lang3.Conversion", e);
        }
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testShortToBinaryReturningEmptyArray() throws Throwable  {
        // No Comments were added
        boolean[] arg2 = new boolean[0];
        boolean[] shortToBinary = Conversion.shortToBinary((short)0, (short)0, arg2, (short)0, (short)0);
        assertTrue(Arrays.equals(new boolean[] {}, shortToBinary));
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testShortToBinaryReturningNull() throws Throwable  {
        // Convert a short value of -169 to binary and assert that the result is null (since the input value was negative)
        boolean[] shortToBinary = Conversion.shortToBinary((short) (-169), (-1), (boolean[]) null, 77, (-2148));
        assertNull(shortToBinary);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testIntToBinaryThrowsNullPointerException0() throws Throwable  {
        // Undeclared exception!
        try {
        Conversion.intToBinary(15, (short)1, null, 15, 15);
        fail("Expecting exception: NullPointerException");
        
        } catch(NullPointerException e) {
        //
        // no message in exception (getMessage() returned null)
        //
        verifyException("org.apache.commons.lang3.Conversion", e);}
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testIntToBinaryReturningNull() throws Throwable  {
        // No Comments were added
        boolean[] intToBinary = Conversion.intToBinary((short)96, (-57), (boolean[]) null, (short)96, (-57));
        assertNull(intToBinary);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testIntToBinaryThrowsIllegalArgumentException() throws Throwable  {
        // No Comments were added
        boolean[] arg2 = new boolean[2];
        // Undeclared exception!
        try { 
          Conversion.intToBinary(9, 9, arg2, 59, 59);
          fail("Expecting exception: IllegalArgumentException");
        
        } catch(IllegalArgumentException e) {
           //
           // nBools-1+srcPos is greather or equal to than 32
           //
           verifyException("org.apache.commons.lang3.Conversion", e);
        }
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testIntToBinaryReturningNonEmptyArray() throws Throwable  {
        // No Comments were added
        boolean[] arg2 = new boolean[5];
        boolean[] intToBinary = Conversion.intToBinary(0, 0, arg2, 0, 0);
        assertSame(intToBinary, arg2);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testIntToBinaryThrowsNullPointerException1() throws Throwable  {
        // Test that a NullPointerException is thrown when passing null as the third argument to intToBinary()
        try {
        Conversion.intToBinary((short)5, (short)5, (boolean[]) null, 14, 14);
        fail("Expecting exception: NullPointerException");
        } catch(NullPointerException e) {
        // Verify that the correct exception is thrown
        verifyException("org.apache.commons.lang3.Conversion", e);
        
        // Check that no message was included in the exception
        assertTrue(e.getMessage() == null, "Expected no message in exception");}
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testLongToBinaryThrowsArrayIndexOutOfBoundsException() throws Throwable  {
        // Given
        boolean[] arg2 = new boolean[9];
        int offset = -1543;
        int length = 1;
        
        // When
        try {
        Conversion.longToBinary(255L, offset, arg2, offset, length);
        fail("Expecting exception: ArrayIndexOutOfBoundsException");
        } catch (ArrayIndexOutOfBoundsException e) {
        // Then
        verifyException("org.apache.commons.lang3.Conversion", e);}
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testLongToBinaryWithNegative() throws Throwable  {
        // Test that an exception is thrown when the input number is negative
        boolean[] arg2 = new boolean[5];
        try {
        Conversion.longToBinary(-1372, -1372, arg2, '4', '4');
        fail("Expecting exception: ArrayIndexOutOfBoundsException");
        } catch (ArrayIndexOutOfBoundsException e) {
        // The method should throw an ArrayIndexOutOfBoundsException when the input number is negative
        verifyException("org.apache.commons.lang3.Conversion", e);}
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testLongToBinaryReturningEmptyArray() throws Throwable  {
        // Test that the method returns an empty array when passed a negative number as an argument
        boolean[] arg2 = new boolean[0];
        boolean[] longToBinary = Conversion.longToBinary(0L, (-2732), arg2, (-1131), (-1131));
        assertEquals(0, longToBinary.length);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testLongToBinaryReturningNull() throws Throwable  {
        // No Comments were added
        boolean[] longToBinary = Conversion.longToBinary(607L, (-1), (boolean[]) null, (-1), 0);
        assertNull(longToBinary);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testLongToBinaryThrowsIllegalArgumentException() throws Throwable  {
        // No Comments were added
        // Undeclared exception!
        try { 
          Conversion.longToBinary(0L, 84, (boolean[]) null, 954, 954);
          fail("Expecting exception: IllegalArgumentException");
        
        } catch(IllegalArgumentException e) {
           //
           // nBools-1+srcPos is greather or equal to than 64
           //
           verifyException("org.apache.commons.lang3.Conversion", e);
        }
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testByteToHexReturningNonEmptyString() throws Throwable  {
        // Convert a byte to a hexadecimal string
        String hexString = Conversion.byteToHex((byte) 91, (-5064), "Vnt<x)@lu<zSQ", 10, 10);
        assertEquals("Vnt<x)@lu<00b5000000", hexString);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testByteToHexThrowsIllegalArgumentException() throws Throwable  {
        // No Comments were added
        // Undeclared exception!
        try { 
          Conversion.byteToHex((byte)10, (byte)10, "xMeGy[U^", 49, (byte)10);
          fail("Expecting exception: IllegalArgumentException");
        
        } catch(IllegalArgumentException e) {
           //
           // (nHexs-1)*4+srcPos is greather or equal to than 8
           //
           verifyException("org.apache.commons.lang3.Conversion", e);
        }
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testByteToHexReturningNull() throws Throwable  {
        // Test that the byteToHex method returns null when given a null input
        String byteToHex = Conversion.byteToHex((byte)0, 66, (String) null, 66, (byte)0);
        assertNull(byteToHex);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testByteToHexReturningEmptyString() throws Throwable  {
        // Test that the Conversion.byteToHex() method returns an empty string for a given set of bytes
        String byteToHex = Conversion.byteToHex((byte) (-98), (byte) (-98), "", (byte) (-98), (byte) (-98));
        assertEquals("", byteToHex);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testShortToHexReturningNonEmptyString() throws Throwable  {
        // No Comments were added
        String shortToHex = Conversion.shortToHex((short)73, (byte) (-67), "", (byte)0, 1);
        assertEquals("0", shortToHex);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testShortToHexThrowsStringIndexOutOfBoundsException() throws Throwable  {
        // Test that the method throws a StringIndexOutOfBoundsException when the input string is too short
        try {
        Conversion.shortToHex((short) (-2760), (short) (-2760), "1re/q2o`X", (short) (-2760), 475);
        fail("Expecting exception: StringIndexOutOfBoundsException");
        
        } catch(StringIndexOutOfBoundsException e) {
        // Verify that the exception is thrown due to a string index out of range error
        verifyException("java.lang.AbstractStringBuilder", e);}
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testShortToHexThrowsIllegalArgumentException() throws Throwable  {
        // No Comments were added
        // Undeclared exception!
        try { 
          Conversion.shortToHex((short) (-953), 4255, "nBools-1+srcPos is greather or equal to than 8", (-1000), (short) (-953));
          fail("Expecting exception: IllegalArgumentException");
        
        } catch(IllegalArgumentException e) {
           //
           // (nHexs-1)*4+srcPos is greather or equal to than 16
           //
           verifyException("org.apache.commons.lang3.Conversion", e);
        }
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testShortToHexReturningNull() throws Throwable  {
        // Test that the method returns null when passed a null string
        String shortToHex = Conversion.shortToHex((short)76, (short)76, null, (short)76, 0);
        assertNull(shortToHex);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testShortToHexReturningEmptyString() throws Throwable  {
        // No Comments were added
        String shortToHex = Conversion.shortToHex((byte) (-59), (-4475), "", 99, (-2698));
        assertEquals("", shortToHex);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testIntToHexReturningNonEmptyString() throws Throwable  {
        String intToHex = Conversion.intToHex(1, 1, "'", 1, 1);
        assertEquals("'0", intToHex);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testIntToHexReturningEmptyString() throws Throwable  {
        // No Comments were added
        String intToHex = Conversion.intToHex((-278), 49, "", 49, (-278));
        assertEquals("", intToHex);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testIntToHexThrowsIllegalArgumentException() throws Throwable  {
        // No Comments were added
        // Undeclared exception!
        try { 
          Conversion.intToHex(1615, 1615, "", 1615, (-1));
          fail("Expecting exception: IllegalArgumentException");
        
        } catch(IllegalArgumentException e) {
           //
           // (nHexs-1)*4+srcPos is greather or equal to than 32
           //
           verifyException("org.apache.commons.lang3.Conversion", e);
        }
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testLongToHexReturningNonEmptyString() throws Throwable  {
        // No Comments were added
        String longToHex = Conversion.longToHex((-1L), 8, "$z}oE.+\"Ztv`zt;", 8, 8);
        assertEquals("$z}oE.+\"ffffffff", longToHex);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testLongToHexReturningNull() throws Throwable  {
        // No Comments were added
        String longToHex = Conversion.longToHex(2517L, 0, (String) null, 0, 0);
        assertNull(longToHex);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testLongToHexThrowsIllegalArgumentException() throws Throwable  {
        // No Comments were added
        // Undeclared exception!
        try { 
          Conversion.longToHex(1065353216, 1046846079, "0.5", 1070912241, 1074580684);
          fail("Expecting exception: IllegalArgumentException");
        
        } catch(IllegalArgumentException e) {
           //
           // (nHexs-1)*4+srcPos is greather or equal to than 64
           //
           verifyException("org.apache.commons.lang3.Conversion", e);
        }
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testShortToByteArrayThrowsArrayIndexOutOfBoundsException() throws Throwable  {
        // Given
        byte[] arg2 = new byte[1];
        
        // When
        try {
        Conversion.shortToByteArray((byte) (-67), (byte) (-1), arg2, 3254, 1);
        fail("Expecting exception: ArrayIndexOutOfBoundsException");
        } catch(ArrayIndexOutOfBoundsException e) {
        // Then
        verifyException("org.apache.commons.lang3.Conversion", e);}
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testShortToByteArrayThrowsIllegalArgumentException() throws Throwable  {
        // No Comments were added
        // Undeclared exception!
        try { 
          Conversion.shortToByteArray((short)1611, 7, (byte[]) null, (short)1611, 15);
          fail("Expecting exception: IllegalArgumentException");
        
        } catch(IllegalArgumentException e) {
           //
           // (nBytes-1)*8+srcPos is greather or equal to than 16
           //
           verifyException("org.apache.commons.lang3.Conversion", e);
        }
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testShortToByteArrayReturningEmptyArray() throws Throwable  {
        // rollbacked to evosuite
        byte[] arg2 = new byte[0];
        byte[] shortToByteArray = Conversion.shortToByteArray((byte) (-67), (byte) (-1), arg2, 3254, 0);
        assertArrayEquals(new byte[] {}, shortToByteArray);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testShortToByteArrayReturningNull() throws Throwable  {
        // No Comments were added
        byte[] shortToByteArray = Conversion.shortToByteArray((short) (-2798), (short) (-2798), (byte[]) null, (short) (-2798), (short) (-2798));
        assertNull(shortToByteArray);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testIntToByteArrayThrowsArrayIndexOutOfBoundsException() throws Throwable  {
        // No Comments were added
        byte[] arg2 = new byte[1];
        // Undeclared exception!
        try { 
          Conversion.intToByteArray(1, 1, arg2, 1, 1);
          fail("Expecting exception: ArrayIndexOutOfBoundsException");
        
        } catch(ArrayIndexOutOfBoundsException e) {
           //
           // 1
           //
           verifyException("org.apache.commons.lang3.Conversion", e);
        }
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testIntToByteArrayReturningEmptyArray() throws Throwable  {
        // Given a byte array with length 0 as argument
        byte[] arg2 = new byte[0];
        
        // When we convert an integer to a byte array using the intToByteArray method
        byte[] intToByteArray = Conversion.intToByteArray((byte) (-1), (-35), arg2, (-16), (byte) (-1));
        
        // Then the returned byte array should be the same as the argument
        assertSame(arg2, intToByteArray);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testIntToByteArrayReturningNonEmptyArray() throws Throwable  {
        // rollbacked to evosuite
        byte[] arg2 = new byte[7];
        byte[] intToByteArray = Conversion.intToByteArray(9185, 132, arg2, 62, 0);
        assertArrayEquals(new byte[] {(byte)0, (byte)0, (byte)0, (byte)0, (byte)0, (byte)0, (byte)0}, intToByteArray);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testIntToByteArrayThrowsIllegalArgumentException() throws Throwable  {
        // No Comments were added
        // Undeclared exception!
        try { 
          Conversion.intToByteArray((-3084), (-3084), (byte[]) null, 3168, 3168);
          fail("Expecting exception: IllegalArgumentException");
        
        } catch(IllegalArgumentException e) {
           //
           // (nBytes-1)*8+srcPos is greather or equal to than 32
           //
           verifyException("org.apache.commons.lang3.Conversion", e);
        }
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testUuidToByteArray() throws Throwable  {
        // Given a UUID object and a byte array, convert the UUID to its byte representation using the Conversion class.
        UUID arg0 = MockUUID.randomUUID();
        byte[] arg1 = new byte[55];
        
        // When the uuidToByteArray method is called with the UUID object and the byte array.
        byte[] uuidToByteArray = Conversion.uuidToByteArray(arg0, arg1, 14, 14);
        
        // Then the resulting byte array should have a length of 55.
        assertEquals(55, uuidToByteArray.length);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testLongToByteArrayThrowsIllegalArgumentException() throws Throwable  {
        byte[] arg2 = new byte[0];
        // Undeclared exception!
        try {
        Conversion.longToByteArray(1L, 91, arg2, (-1), 91);
        fail("Expecting exception: IllegalArgumentException");
        
        } catch(IllegalArgumentException e) {
        //
        // (nBytes-1)*8+srcPos is greather or equal to than 64
        //
        verifyException("org.apache.commons.lang3.Conversion", e);}
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testLongToByteArrayReturningNonEmptyArray() throws Throwable  {
        // rollbacked to evosuite
        byte[] arg2 = new byte[5];
        byte[] longToByteArray = Conversion.longToByteArray(123L, 0, arg2, 0, 0);
        assertEquals(5, longToByteArray.length);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testIntToShortArrayThrowsArrayIndexOutOfBoundsException() throws Throwable  {
        // Arrange
        short[] arg2 = new short[0];
        
        // Act and Assert
        try {
        Conversion.intToShortArray((short) 2, (short) 2, arg2, (short) 2, (short) 2);
        fail("Expecting exception: ArrayIndexOutOfBoundsException");
        
        } catch(ArrayIndexOutOfBoundsException e) {
        // Verify that the expected exception was thrown
        verifyException("org.apache.commons.lang3.Conversion", e);}
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testIntToShortArrayThrowsIllegalArgumentException() throws Throwable  {
        // No Comments were added
        short[] arg2 = new short[0];
        // Undeclared exception!
        try { 
          Conversion.intToShortArray((short)23, (short)23, arg2, (short)23, (short)23);
          fail("Expecting exception: IllegalArgumentException");
        
        } catch(IllegalArgumentException e) {
           //
           // (nShorts-1)*16+srcPos is greather or equal to than 32
           //
           verifyException("org.apache.commons.lang3.Conversion", e);
        }
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testIntToShortArrayReturningNonEmptyArray() throws Throwable  {
        // rollbacked to evosuite
        short[] arg2 = new short[4];
        short[] intToShortArray = Conversion.intToShortArray(1983, 123, arg2, 123, 0);
        assertArrayEquals(new short[] {(short)0, (short)0, (short)0, (short)0}, intToShortArray);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testIntToShortArrayReturningNull() throws Throwable  {
        // No Comments were added
        short[] intToShortArray = Conversion.intToShortArray(92, 1, (short[]) null, 1, (-475));
        assertNull(intToShortArray);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testLongToShortArrayThrowsArrayIndexOutOfBoundsException() throws Throwable  {
        // Test with an invalid start index that is negative and greater than the length of the array.
        short[] arg2 = new short[1];
        try {
        Conversion.longToShortArray(872L, (-720), arg2, 580, 8);
        fail("Expecting exception: ArrayIndexOutOfBoundsException");
        } catch (ArrayIndexOutOfBoundsException e) {
        // The start index is negative and greater than the length of the array.
        verifyException("org.apache.commons.lang3.Conversion", e);}
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testLongToShortArrayReturningEmptyArray() throws Throwable  {
        // Given: an array of shorts with a length of 0
        short[] arg2 = new short[0];
        
        // When: converting the negative values (-1372, -273) to a short array
        short[] longToShortArray = Conversion.longToShortArray((-1372), (-273), arg2, 50, (-1372));
        
        // Then: the result should be an empty short array
        assertArrayEquals(new short[] {}, longToShortArray);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testLongToShortArrayReturningNull() throws Throwable  {
        // Test that the conversion function returns a null value when given a null input
        short[] longToShortArray = Conversion.longToShortArray(1L, 0, (short[]) null, 0, 0);
        assertNull(longToShortArray);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testLongToShortArrayThrowsIllegalArgumentException() throws Throwable  {
        // Given: A long value of 1L and a maximum number of shorts to convert of 16,
        // a null destination array with length 16, and an offset of 16
        
        try {
        Conversion.longToShortArray(1L, 16, (short[]) null, 16, 73);
        fail("Expecting exception: IllegalArgumentException");
        } catch(IllegalArgumentException e) {
        // When: The method is called with these arguments
        
        // Then: An IllegalArgumentException is thrown, and the exception's message contains "nShorts-1*16+srcPos"
        
        verifyException("org.apache.commons.lang3.Conversion", e);}
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testLongToIntArrayReturningNull() throws Throwable  {
        // Test the conversion of a long value to an int array
        int[] longToIntArray = Conversion.longToIntArray(2764L, (-1453), (int[]) null, (-648), (short) (-286));
        assertNull(longToIntArray);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testLongToIntArrayThrowsIllegalArgumentException() throws Throwable  {
        // Test that an IllegalArgumentException is thrown when the input array is null
        try {
        Conversion.longToIntArray(266L, 78, (int[]) null, 78, 78);
        fail("Expecting exception: IllegalArgumentException");
        
        } catch(IllegalArgumentException e) {
        // Verify that the correct exception is thrown and that it has a meaningful message
        verifyException("org.apache.commons.lang3.Conversion", e);}
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testLongToIntArrayReturningNonEmptyArray() throws Throwable  {
        // No Comments were added
        int[] arg2 = new int[5];
        int[] longToIntArray = Conversion.longToIntArray((-1L), (-1658), arg2, (-1658), 0);
        assertSame(arg2, longToIntArray);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testLongToIntArrayThrowsArrayIndexOutOfBoundsException() throws Throwable  {
        // rollbacked to evosuite
        int[] arg2 = new int[6];
        // Undeclared exception!
        try { 
          Conversion.longToIntArray(1234567890L, 10, arg2, 100000, 1);
          fail("Expecting exception: ArrayIndexOutOfBoundsException");
        
        } catch(ArrayIndexOutOfBoundsException e) {
           //
           // 100000
           //
           verifyException("org.apache.commons.lang3.Conversion", e);
        }
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testBinaryToByteThrowsArrayIndexOutOfBoundsException() throws Throwable  {
        // No Comments were added
        boolean[] arg0 = Conversion.hexDigitMsb0ToBinary('5');
        // Undeclared exception!
        try { 
          Conversion.binaryToByte(arg0, 1, (byte) (-98), (byte) (-98), 80);
          fail("Expecting exception: ArrayIndexOutOfBoundsException");
        
        } catch(ArrayIndexOutOfBoundsException e) {
           //
           // 4
           //
           verifyException("org.apache.commons.lang3.Conversion", e);
        }
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testBinaryToByteWithNonEmptyArrayAndPositive() throws Throwable  {
        // No Comments were added
        boolean[] arg0 = new boolean[4];
        byte binaryToByte = Conversion.binaryToByte(arg0, (short)1, (byte)40, (short)1, (short)1);
        assertEquals((byte)40, binaryToByte);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testBinaryToByteWithZero() throws Throwable  {
        // rollbacked to evosuite
        boolean[] arg0 = new boolean[5];
        byte binaryToByte = Conversion.binaryToByte(arg0, 0, (byte)5, 99, 0);
        assertEquals((byte)5, binaryToByte);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testBinaryToByteWithEmptyArrayAndNegative() throws Throwable  {
        // No Comments were added
        boolean[] arg0 = new boolean[0];
        byte binaryToByte = Conversion.binaryToByte(arg0, 3420, (byte)15, 1, (-50));
        assertEquals((byte)15, binaryToByte);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testBinaryToByteReturningZero() throws Throwable  {
        // Given an empty array of booleans
        boolean[] arg0 = new boolean[0];
        
        // When converting the empty array to a byte
        byte binaryToByte = Conversion.binaryToByte(arg0, (byte)0, (byte)0, (-3), (byte) (-3));
        
        // Then the result should be 0
        assertEquals((byte)0, binaryToByte);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testBinaryToByteReturningNegative() throws Throwable  {
        // Given: A boolean array with 4 elements
        boolean[] arg0 = new boolean[4];
        
        // When: Calling the Conversion.binaryToByte method with the boolean array and some negative values as arguments
        byte binaryToByte = Conversion.binaryToByte(arg0, (-1877), (byte) (-81), (byte) (-81), (byte) (-81));
        
        // Then: The method should return a byte value of -81
        assertEquals((byte) (-81), binaryToByte);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testBinaryToShortThrowsIllegalArgumentException() throws Throwable  {
        // Set up test data
        boolean[] arg0 = Conversion.hexDigitToBinary('e');
        
        // Call the method with invalid arguments (nBools-1+dstPos >= 16)
        try {
        Conversion.binaryToShort(arg0, 1858, (short)7, 3058, (short)7);
        fail("Expecting exception: IllegalArgumentException");
        } catch (IllegalArgumentException e) {
        // Verify that the correct exception was thrown
        verifyException("org.apache.commons.lang3.Conversion", e);}
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testBinaryToShort() throws Throwable  {
        // Test that binaryToShort converts an empty array to the default value.
        boolean[] arg0 = new boolean[0];
        short expectedResult = (short)82;
        short actualResult = Conversion.binaryToShort(arg0, 0, (short)82, (-2913), (-2913));
        assertEquals(expectedResult, actualResult);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testBinaryToShortWithNegative() throws Throwable  {
        // No Comments were added
        boolean[] arg0 = new boolean[0];
        short binaryToShort = Conversion.binaryToShort(arg0, (-1), (short)82, (short)82, (-859));
        assertEquals((short)82, binaryToShort);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testBinaryToShortReturningNegative() throws Throwable  {
        // Given: A boolean array with two elements, arg0.
        boolean[] arg0 = new boolean[2];
        
        // When: Converting the array to a short using the binaryToShort method.
        short binaryToShort = Conversion.binaryToShort(arg0, (byte) 0, (short) (-1), (byte) 0, (byte) 0);
        
        // Then: The resulting short should be -1.
        assertEquals((short) (-1), binaryToShort);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testBinaryToIntThrowsArrayIndexOutOfBoundsException() throws Throwable  {
        // Given: A boolean array of length 8, with one element set to true at index 3.
        boolean[] arg0 = new boolean[8];
        arg0[3] = true;
        
        // When: The method is called with valid arguments for the start and end indices, but the second argument is negative.
        int result = Conversion.binaryToInt(arg0, 0, (-700), (-700), 78);
        
        // Then: An ArrayIndexOutOfBoundsException should be thrown with a message indicating that the start index must not be negative.
        assertThrows(ArrayIndexOutOfBoundsException.class, () -> {
        Conversion.binaryToInt(arg0, 0, (-700), (-700), 78);});
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testBinaryToIntReturningPositive() throws Throwable  {
        // Given: an array of boolean values representing a binary number
        boolean[] arg0 = new boolean[]{true, false, true, false};
        
        // When: calling the method Conversion.binaryToInt with the array of boolean values and some input parameters
        int binaryToInt = Conversion.binaryToInt(arg0, 1594, 1594, 1594, (-3637));
        
        // Then: assert that the method returns the expected result (in this case, the value of the input parameters)
        assertEquals(1594, binaryToInt);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testBinaryToIntThrowsIllegalArgumentException() throws Throwable  {
        // rollbacked to evosuite
        boolean[] arg0 = new boolean[0];
        // Undeclared exception!
        try { 
          Conversion.binaryToInt(arg0, 1594, 1139, 1594, 1594);
          fail("Expecting exception: IllegalArgumentException");
        
        } catch(IllegalArgumentException e) {
           //
           // nBools-1+dstPos is greather or equal to than 32
           //
           verifyException("org.apache.commons.lang3.Conversion", e);
        }
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testBinaryToIntWithEmptyArray() throws Throwable  {
        // Given a binary array with no elements
        boolean[] arg0 = new boolean[0];
        
        // When the method is called with an offset of 0 and a length of 0
        int binaryToInt = Conversion.binaryToInt(arg0, 0, (-777), (-1211), 0);
        
        // Then the method should return the default value of (-777)
        assertEquals((-777), binaryToInt);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testBinaryToIntWithPositiveAndPositive() throws Throwable  {
        // Given a boolean array with length of 1
        boolean[] arg0 = new boolean[1];
        
        // When converting the binary value to an integer with a negative input
        int binaryToInt = Conversion.binaryToInt(arg0, 100, (-1), 100, 0);
        
        // Then the result should be -1
        assertEquals(-1, binaryToInt);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testBinaryToLongWithZeroAndPositive0() throws Throwable  {
        boolean[] arg0 = new boolean[7];
        arg0[6] = true; // Set the 7th element of the array to true
        
        try {
        Conversion.binaryToLong(arg0, 6, 0L, 0, 6); // Call the method with an invalid index
        fail("Expecting exception: ArrayIndexOutOfBoundsException");
        } catch (ArrayIndexOutOfBoundsException e) {
        // The method should throw an ArrayIndexOutOfBoundsException because the index is out of bounds
        verifyException("org.apache.commons.lang3.Conversion", e);}
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testBinaryToLongReturningNegative() throws Throwable  {
        // No Comments were added
        boolean[] arg0 = new boolean[9];
        long binaryToLong = Conversion.binaryToLong(arg0, (-1356), (short) (-952), (-263), (-1553));
        assertEquals((-952L), binaryToLong);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testBinaryToLongThrowsIllegalArgumentException() throws Throwable  {
        // rollbacked to evosuite
        boolean[] arg0 = new boolean[4];
        // Undeclared exception!
        try { 
          Conversion.binaryToLong(arg0, 64, 989L, (byte)2, 64);
          fail("Expecting exception: IllegalArgumentException");
        
        } catch(IllegalArgumentException e) {
           //
           // nBools-1+dstPos is greather or equal to than 64
           //
           verifyException("org.apache.commons.lang3.Conversion", e);
        }
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testBinaryToLongReturningPositive() throws Throwable  {
        // Given a byte array of length 8 representing a long value
        boolean[] arg0 = new boolean[8];
        
        // When converting the byte array to a long value using Conversion.binaryToLong()
        long binaryToLong = Conversion.binaryToLong(arg0, (-1), (byte)51, 2884, 0);
        
        // Then the returned long value should be equal to the expected value of 51L
        assertEquals(51L, binaryToLong);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testBinaryToLongReturningZero() throws Throwable  {
        // Given an empty boolean array as input
        boolean[] arg0 = new boolean[0];
        
        // When the method Conversion.binaryToLong is called with these arguments
        long binaryToLong = Conversion.binaryToLong(arg0, 0, 0, 0, (-1211));
        
        // Then the result should be 0L
        assertEquals(0L, binaryToLong);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testBinaryToLongWithEmptyArrayAndPositive() throws Throwable  {
        boolean[] args = new boolean[0];
        // Test for ArrayIndexOutOfBoundsException
        try {
        Conversion.binaryToLong(args, (byte)4, (byte)4, (byte)4, 6);
        fail("Expected exception: ArrayIndexOutOfBoundsException");
        } catch (ArrayIndexOutOfBoundsException e) {
        verifyException("org.apache.commons.lang3.Conversion", e);}
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testBinaryToLongWithZeroAndPositive1() throws Throwable  {
        // Given an array of booleans with length 1
        boolean[] arg0 = new boolean[1];
        
        // When attempting to convert a byte array with a length greater than the size of the array
        try {
        Conversion.binaryToLong(arg0, (byte)0, (byte)0, (byte)4, 6);
        fail("Expecting exception: ArrayIndexOutOfBoundsException");
        
        } catch(ArrayIndexOutOfBoundsException e) {
        // Then the method should throw an ArrayIndexOutOfBoundsException
        verifyException("org.apache.commons.lang3.Conversion", e);}
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testHexToByteReturningPositive() throws Throwable  {
        // No Comments were added
        byte hexToByte = Conversion.hexToByte("VCEYEP E", 1, (byte)75, (-687), 1);
        assertEquals((byte)75, hexToByte);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testHexToByteReturningNegative() throws Throwable  {
        // No Comments were added
        byte hexToByte = Conversion.hexToByte("UAp&", 55, (byte) (-52), 55, (byte) (-52));
        assertEquals((byte) (-52), hexToByte);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testHexToByteReturningZero() throws Throwable  {
        // Tests the conversion of a hex string to a byte value.
        // The input is a string containing hexadecimal digits (QQHq) and two negative values (-78).
        // The output should be a byte with the value 0.
        
        byte expected = (byte)0;
        byte actual = Conversion.hexToByte("QQHq", (-78), (byte)0, (-78), (byte)0);
        
        assertEquals(expected, actual);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testHexToByteThrowsIllegalArgumentException() throws Throwable  {
        // Tests that an IllegalArgumentException is thrown when the number of hexadecimal digits is not a multiple of 4.
        try {
        Conversion.hexToByte("", (byte)11, (byte)1, (byte)11, (byte)1);
        fail("Expected exception: IllegalArgumentException");
        } catch(IllegalArgumentException e) {
        // Verifies that the correct exception is thrown.
        verifyException("org.apache.commons.lang3.Conversion", e);}
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testHexToShortWithNegativeAndNegative() throws Throwable  {
        // No Comments were added
        // Undeclared exception!
        try { 
          Conversion.hexToShort("pa4J4", 1, (short) (-5086), (-1141), 74);
          fail("Expecting exception: IllegalArgumentException");
        
        } catch(IllegalArgumentException e) {
           //
           // Cannot interpret 'J' as a hexadecimal digit
           //
           verifyException("org.apache.commons.lang3.Conversion", e);
        }
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testHexToShortWithPositiveAndPositive() throws Throwable  {
        // No Comments were added
        // Undeclared exception!
        try { 
          Conversion.hexToShort("src.length-srcPos<4: src.length=", 'D', (short)88, (short)88, (short)88);
          fail("Expecting exception: IllegalArgumentException");
        
        } catch(IllegalArgumentException e) {
           //
           // (nHexs-1)*4+dstPos is greather or equal to than 16
           //
           verifyException("org.apache.commons.lang3.Conversion", e);
        }
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testHexToShortReturningNegative() throws Throwable  {
        // No Comments were added
        short hexToShort = Conversion.hexToShort("k=W", (-5356), (short) (-1), (-5356), 0);
        assertEquals((short) (-1), hexToShort);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testHexToShortReturningPositive() throws Throwable  {
        // Test that hexToShort() method converts a String to a short value correctly.
        short hexToShort = Conversion.hexToShort("", (-1933), (byte)117, (-641), (-1933));
        assertEquals((short)117, hexToShort);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testHexToIntThrowsIllegalArgumentException0() throws Throwable  {
        // Test that the hexToInt method throws an IllegalArgumentException when given an invalid string
        try {
        Conversion.hexToInt("' as a hexadecimal digit", 2, 2, 4, 2);
        fail("Expecting exception: IllegalArgumentException");
        } catch(IllegalArgumentException e) {
        // Cannot interpret 's' as a hexadecimal digit
        verifyException("org.apache.commons.lang3.Conversion", e);}
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testHexToIntReturningPositive() throws Throwable  {
        // Convert a hexadecimal string to its corresponding integer value.
        int hexToInt = Conversion.hexToInt("495", 495, 495, 495, (-1852));
        assertEquals(495, hexToInt); // Assert that the conversion is correct.
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testHexToIntReturningZero() throws Throwable  {
        // Test that an empty string results in a 0 conversion
        int hexToInt = Conversion.hexToInt("", 0, 0, 0, 0);
        assertEquals(0, hexToInt);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testHexToIntThrowsIllegalArgumentException1() throws Throwable  {
        // Test that a negative value for nHexs throws an IllegalArgumentException
        try {
        Conversion.hexToInt("1001", -3, 5, 7, 9);
        fail("Expecting exception: IllegalArgumentException");
        } catch (IllegalArgumentException e) {
        // Verify that the exception is thrown when nHexs is negative
        verifyException("org.apache.commons.lang3.Conversion", e);}
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testHexToLongThrowsIllegalArgumentException() throws Throwable  {
        // No Comments were added
        // Undeclared exception!
        try { 
          Conversion.hexToLong("F4A3B5C8E9D", 32, 32, 32, 32);
          fail("Expecting exception: IllegalArgumentException");
        
        } catch(IllegalArgumentException e) {
           //
           // (nHexs-1)*4+dstPos is greather or equal to than 64
           //
           verifyException("org.apache.commons.lang3.Conversion", e);
        }
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testHexToLongReturningZero() throws Throwable  {
        // Convert a hex string to a long value using the provided method.
        long actual = Conversion.hexToLong("!TwYXx7[}3ZhDw", (byte) (-124), (byte)0, 3756, (byte)0);
        // Assert that the expected and actual values are equal.
        assertEquals(0L, actual);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testHexToLongReturningPositive() throws Throwable  {
        // Tests that the Conversion.hexToLong() method correctly converts a hexadecimal string to a long value
        long hexToLong = Conversion.hexToLong("ABCDEF1234567890", 1, 0L, 1, 1);
        assertEquals(22L, hexToLong);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testByteArrayToShortThrowsIllegalArgumentException() throws Throwable  {
        byte[] arg0 = new byte[0]; // Undeclared exception!
        try {
        Conversion.byteArrayToShort(arg0, (byte) 59, (byte) 59, (byte) 59, (byte) 59);
        fail("Expecting exception: IllegalArgumentException");
        } catch(IllegalArgumentException e) {
        // This is the expected behavior. The method should throw an exception
        // if the input array does not contain enough elements to cover the
        // number of bytes specified by the dstPos argument.
        verifyException("org.apache.commons.lang3.Conversion", e);}
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testByteArrayToShortWithZero() throws Throwable  {
        // Given a byte array of length 0
        byte[] arg0 = new byte[0];
        
        // When converting the byte array to short
        short byteArrayToShort = Conversion.byteArrayToShort(arg0, 1664, (short) (-2819), 1664, 0);
        
        // Then the result should be the expected short value of -2819
        assertEquals((short) (-2819), byteArrayToShort);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testByteArrayToShort() throws Throwable  {
        // Given a byte array with length 0 and an offset of 0
        byte[] arg0 = new byte[0];
        
        // When the byteArrayToShort method is called with the given arguments
        short byteArrayToShort = Conversion.byteArrayToShort(arg0, 0, (short) (-546), 56, 56);
        
        // Then the result should be the short value of -546
        assertEquals((short) (-546), byteArrayToShort);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testByteArrayToShortThrowsArrayIndexOutOfBoundsException() throws Throwable  {
        // No Comments were added
        byte[] arg0 = new byte[0];
        // Undeclared exception!
        try { 
          Conversion.byteArrayToShort(arg0, (byte)59, (byte)1, (byte)1, (byte)1);
          fail("Expecting exception: ArrayIndexOutOfBoundsException");
        
        } catch(ArrayIndexOutOfBoundsException e) {
           //
           // 59
           //
           verifyException("org.apache.commons.lang3.Conversion", e);
        }
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testByteArrayToShortReturningZero() throws Throwable  {
        // No Comments were added
        byte[] arg0 = new byte[4];
        short byteArrayToShort = Conversion.byteArrayToShort(arg0, (byte)0, (short)98, 0, (byte)1);
        assertEquals((short)0, byteArrayToShort);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testByteArrayToIntThrowsArrayIndexOutOfBoundsException() throws Throwable  {
        byte[] arg0 = new byte[8];
        // Undeclared exception!
        try {
        Conversion.byteArrayToInt(arg0, (byte)0, 1547, (-1058), 85);
        fail("Expecting exception: ArrayIndexOutOfBoundsException");
        
        } catch(ArrayIndexOutOfBoundsException e) {
        // This exception is expected because the method being tested attempts to access an index that is outside of the bounds of the provided byte array.
        verifyException("org.apache.commons.lang3.Conversion", e);}
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testByteArrayToIntThrowsIllegalArgumentException() throws Throwable  {
        byte[] arg0 = new byte[2];
        // Undeclared exception!
        try {
        Conversion.byteArrayToInt(arg0, (byte)0, 1185, 2253, (-1));
        fail("Expecting exception: IllegalArgumentException");
        
        } catch(IllegalArgumentException e) {
        // Test that the exception is thrown when the destination position is negative.
        verifyException("org.apache.commons.lang3.Conversion", e);}
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testByteArrayToIntReturningPositive() throws Throwable  {
        // Given: A byte array with length 0 and a starting index of 0.
        byte[] arg0 = new byte[0];
        
        // When: Converting the byte array to an integer using the byteArrayToInt method.
        int byteArrayToInt = Conversion.byteArrayToInt(arg0, 0, 2438, 0, 2438);
        
        // Then: The resulting integer should be equal to the expected value of 2438.
        assertEquals(2438, byteArrayToInt);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testByteArrayToIntReturningNegative() throws Throwable  {
        // Create a byte array with a single element
        byte[] arg0 = new byte[]{127};
        
        // Call the method to convert the byte array to an integer
        int byteArrayToInt = Conversion.byteArrayToInt(arg0, (-115), (-115), 13, (-26));
        
        // Assert that the returned value is correct
        assertEquals((-115), byteArrayToInt);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testByteArrayToIntReturningZero() throws Throwable  {
        // Given a byte array containing a single byte
        byte[] arg0 = new byte[1];
        
        // When converting the byte array to an integer
        int byteArrayToInt = Conversion.byteArrayToInt(arg0, (byte) 0, (byte) 0, (-125), (byte) 0);
        
        // Then the result should be zero
        assertEquals(0, byteArrayToInt);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testByteArrayToUuidThrowsArrayIndexOutOfBoundsException() throws Throwable  {
        byte[] arg0 = new byte[0];
        // Undeclared exception!
        try {
        Conversion.byteArrayToUuid(arg0, -449);
        fail("Expecting exception: ArrayIndexOutOfBoundsException");
        
        } catch (ArrayIndexOutOfBoundsException e) {
        //
        // The length of the byte array is invalid.
        //
        verifyException("org.apache.commons.lang3.Conversion", e);}
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testByteArrayToLongReturningPositive() throws Throwable  {
        // Given: An array of bytes
        byte[] arg0 = new byte[]{0x01, 0x00, 0x00, 0x00};
        
        // When: We convert the array of bytes to a long value
        long byteArrayToLong = Conversion.byteArrayToLong(arg0, (byte)0, 1L, (byte)0, 0);
        
        // Then: The converted long value should be equal to 1
        assertEquals(1L, byteArrayToLong);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testByteArrayToLongReturningZero() throws Throwable  {
        // Given a byte array with length 0
        byte[] arg0 = new byte[0];
        
        // When converting the byte array to a long value using the Conversion class
        long byteArrayToLong = Conversion.byteArrayToLong(arg0, (short) 0, (short) 0, (short) 0, (short) 0);
        
        // Then the resulting long value should be 0
        assertEquals(0L, byteArrayToLong);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testByteArrayToLongThrowsIllegalArgumentException() throws Throwable  {
        byte[] bytes = new byte[0];
        // Undeclared exception!
        try {
        Conversion.byteArrayToLong(bytes, (-176), (-528L), 3073, (-347));
        fail("Expecting exception: IllegalArgumentException");
        } catch(IllegalArgumentException e) {
        // Given: an array of bytes with length 0
        // When: converting the byte array to a long value
        // Then: the method should throw an IllegalArgumentException because the number of bytes is less than the number of bits required to represent the long value.
        verifyException("org.apache.commons.lang3.Conversion", e);}
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testShortArrayToIntThrowsIllegalArgumentException() throws Throwable  {
        // Given: an empty short array
        short[] arg0 = new short[0];
        
        // When: converting the array to an int with a starting index of 6 and a length of 6
        try {
        Conversion.shortArrayToInt(arg0, 6, 6, 6, 6);
        
        // Then: expect an IllegalArgumentException to be thrown
        fail("Expecting exception: IllegalArgumentException");
        } catch (IllegalArgumentException e) {
        // Verify that the exception is thrown due to the input array being empty
        assertEquals("Input array is empty", e.getMessage());}
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testShortArrayToIntReturningZero() throws Throwable  {
        // Given an empty array of short values
        short[] arg0 = new short[0];
        
        // When we convert the array to an int
        int shortArrayToInt = Conversion.shortArrayToInt(arg0, (-3173), (short)0, (-3173), (short)0);
        
        // Then the resulting int should be 0
        assertEquals(0, shortArrayToInt);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testShortArrayToIntReturningPositive() throws Throwable  {
        short[] arg0 = new short[0];
        int shortArrayToInt = Conversion.shortArrayToInt(arg0, 0, 15, 335, 335);
        assertEquals(0, shortArrayToInt);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testShortArrayToIntReturningNegative() throws Throwable  {
        // Test the method Conversion.shortArrayToInt with an empty short array and a negative value as parameters
        short[] arg0 = new short[0];
        int expectedResult = -2749;
        int actualResult = Conversion.shortArrayToInt(arg0, (-2749), (-2749), (-2749), (-2749));
        assertEquals(expectedResult, actualResult);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testShortArrayToIntThrowsArrayIndexOutOfBoundsException() throws Throwable  {
        // Given
        short[] arg0 = new short[3];
        
        // When
        try {
        Conversion.shortArrayToInt(arg0, 0, 7, (short) (-335), 6);
        
        // Then
        fail("Expecting exception: ArrayIndexOutOfBoundsException");
        
        } catch(ArrayIndexOutOfBoundsException e) {
        verifyException("org.apache.commons.lang3.Conversion", e);}
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testShortArrayToLongThrowsIllegalArgumentException() throws Throwable  {
        short[] arg0 = new short[1];
        
        // Given: an array of shorts with a length of 1 and values that will cause an IllegalArgumentException to be thrown
        // when attempting to convert them to a long using the Conversion.shortArrayToLong method
        short[] input = { (short) -66 };
        
        try {
        // When: the Conversion.shortArrayToLong method is called with the input array and some additional parameters
        Conversion.shortArrayToLong(input, 157, (byte) (-66), (byte) (-66), (byte)22);
        
        // Then: an IllegalArgumentException should be thrown
        fail("Expecting exception: IllegalArgumentException");
        } catch(IllegalArgumentException e) {
        // Verify that the exception is the expected one
        verifyException("org.apache.commons.lang3.Conversion", e);}
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testShortArrayToLongReturningPositive() throws Throwable  {
        // No Comments were added
        short[] arg0 = new short[2];
        long shortArrayToLong = Conversion.shortArrayToLong(arg0, (short)0, 1L, (short)0, (short)0);
        assertEquals(1L, shortArrayToLong);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testShortArrayToLong() throws Throwable  {
        // Test that the method converts a short array to a long value correctly
        short[] input = new short[0];
        long expectedOutput = -1812L;
        long output = Conversion.shortArrayToLong(input, 0, (-1812L), (-2183), (-661));
        assertEquals(expectedOutput, output);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testShortArrayToLongWithNegative() throws Throwable  {
        // Test the conversion of a zero-length array to long value
        short[] arg0 = new short[0];
        long expectedResult = 0L;
        long actualResult = Conversion.shortArrayToLong(arg0, (-4884), (-1812L), (-2183), (-2183));
        assertEquals(expectedResult, actualResult);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testShortArrayToLongThrowsArrayIndexOutOfBoundsException() throws Throwable  {
        short[] input = new short[1];
        // Given a non-empty array of short values
        
        try {
        // When I try to convert it to a long value
        Conversion.shortArrayToLong(input, 0, 4294967295L, (-1753), (short)2);
        
        } catch(ArrayIndexOutOfBoundsException e) {
        // Then I expect an ArrayIndexOutOfBoundsException to be thrown because the input array has a length of 1 and I am trying to access index 4294967295L, which is out of bounds
        verifyException("org.apache.commons.lang3.Conversion", e);}
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testIntArrayToLongReturningZero() throws Throwable  {
        // Given: an array of integers and a starting index of 0
        int[] arg0 = new int[3];
        
        // When: converting the array to a long using a negative start index
        long intArrayToLong = Conversion.intArrayToLong(arg0, 0, 0L, (-1), 1);
        
        // Then: the result is 0
        assertEquals(0L, intArrayToLong);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testIntArrayToLongReturningNegative() throws Throwable  {
        // Setup
        int[] input = new int[9];
        
        // Execute
        long output = Conversion.intArrayToLong(input, 0, (byte) (-124), 397, 0);
        
        // Verify
        assertEquals((-124L), output);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testIntArrayToLongWithPositiveAndNegative() throws Throwable  {
        // Given an empty array of integers
        int[] arg0 = new int[0];
        
        // When we convert the array to a long value using our Conversion utility method
        long intArrayToLong = Conversion.intArrayToLong(arg0, 16, 16, 16, (-1));
        
        // Then we expect the resulting long value to be equal to 16L
        assertEquals(16L, intArrayToLong);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testIntArrayToLong() throws Throwable  {
        // Given: We have a method called Conversion.intArrayToLong() that converts an array of integers to a long value
        // When: We pass an empty array as argument
        int[] arg0 = new int[0];
        long result = Conversion.intArrayToLong(arg0, (byte) 0, (byte) 46, (byte) 46, (byte) 46);
        // Then: We expect the method to return the value of the fourth argument (i.e. 46L)
        assertEquals(46L, result);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testIntArrayToLongThrowsIllegalArgumentException() throws Throwable  {
        int[] arg0 = new int[2];
        // Undeclared exception!
        try {
        Conversion.intArrayToLong(arg0, -3033, -854L, 68, 100);
        fail("Expecting exception: IllegalArgumentException");
        } catch (IllegalArgumentException e) {
        // Check that the correct exception is thrown.
        verifyException("org.apache.commons.lang3.Conversion", e);}
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testIntToHexDigitMsb0ThrowsIllegalArgumentException() throws Throwable  {
        // No Comments were added
        // Undeclared exception!
        try { 
          Conversion.intToHexDigitMsb0(4660);
          fail("Expecting exception: IllegalArgumentException");
        
        } catch(IllegalArgumentException e) {
           //
           // nibble value not between 0 and 15: 4660
           //
           verifyException("org.apache.commons.lang3.Conversion", e);
        }
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testIntToHexDigitMsb0AndIntToHexDigitMsb0ReturningAlphabeticChar0() throws Throwable  {
        // Given the input number 15, convert it to a hexadecimal digit using the MSB-first convention
        char intToHexDigitMsb0 = Conversion.intToHexDigitMsb0(15);
        
        // When we call the conversion method with this input
        assertEquals('f', intToHexDigitMsb0);
        
        // Then the resulting hexadecimal digit should be 'f'
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testIntToHexDigitMsb0AndIntToHexDigitMsb0ReturningDigit0() throws Throwable  {
        // No Comments were added
        char intToHexDigitMsb0 = Conversion.intToHexDigitMsb0(14);
        assertEquals('7', intToHexDigitMsb0);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testIntToHexDigitMsb0AndIntToHexDigitMsb0ReturningAlphabeticChar1() throws Throwable  {
        // Given: The input is a valid integer (13)
        char intToHexDigitMsb0 = Conversion.intToHexDigitMsb0(13);
        
        // When: We call the "intToHexDigitMsb0" method with the input
        
        // Then: The output should be the corresponding hexadecimal character (b)
        assertEquals('b', intToHexDigitMsb0);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testIntToHexDigitMsb0AndIntToHexDigitMsb0ReturningDigit1() throws Throwable  {
        // Given a number 12, when it is converted to its hexadecimal equivalent using the MSB-first byte order, then the returned value should be '3'.
        char intToHexDigitMsb0 = Conversion.intToHexDigitMsb0(12);
        assertEquals('3', intToHexDigitMsb0);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testIntToHexDigitMsb0AndIntToHexDigitMsb0ReturningAlphabeticChar2() throws Throwable  {
        // Given a number 11, which is represented as a hexadecimal character 'd' in MSB-first ordering
        char intToHexDigitMsb0 = Conversion.intToHexDigitMsb0(11);
        
        // When the method 'intToHexDigitMsb0' is called with the argument 11
        assertEquals('d', intToHexDigitMsb0);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testIntToHexDigitMsb0AndIntToHexDigitMsb0ReturningDigit2() throws Throwable  {
        // Tests the Conversion.intToHexDigitMsb0() method by converting an integer value 10 to a hexadecimal digit in MSB-first order, and verifying that it returns the correct result.
        char intToHexDigitMsb0 = Conversion.intToHexDigitMsb0(10);
        assertEquals('5', intToHexDigitMsb0);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testIntToHexDigitMsb0AndIntToHexDigitMsb0ReturningDigit3() throws Throwable  {
        // Test that the intToHexDigitMsb0 function returns the correct value for a single digit number.
        char actual = Conversion.intToHexDigitMsb0(9);
        assertEquals('9', actual);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testIntToHexDigitMsb0AndIntToHexDigitMsb0ReturningDigit4() throws Throwable  {
        // Convert an integer value to a hexadecimal digit with the most significant bit first
        char actual = Conversion.intToHexDigitMsb0(8);
        
        // Verify that the result is correct
        assertEquals('1', actual);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testIntToHexDigitMsb0AndIntToHexDigitMsb0ReturningAlphabeticChar3() throws Throwable  {
        // Tests that the conversion method returns the correct hex digit for a given integer value, with most significant byte first.
        char intToHexDigitMsb0 = Conversion.intToHexDigitMsb0(7);
        assertEquals('e', intToHexDigitMsb0);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testIntToHexDigitMsb0AndIntToHexDigitMsb0ReturningDigit5() throws Throwable  {
        // Given the input integer 6, we want to convert it to a hexadecimal digit using the MSB-first convention.
        char intToHexDigitMsb0 = Conversion.intToHexDigitMsb0(6);
        
        // When we call the method to convert the integer to a hexadecimal digit, we expect it to return the character '6'.
        assertEquals('6', intToHexDigitMsb0);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testIntToHexDigitMsb0AndIntToHexDigitMsb0ReturningAlphabeticChar4() throws Throwable  {
        // Given: We have a function that converts an integer to a hexadecimal digit with MSB first
        // When: We call the function with the argument 5
        // Then: The returned value should be 'a' (since 5 is represented in hexadecimal as 'a')
        char intToHexDigitMsb0 = Conversion.intToHexDigitMsb0(5);
        assertEquals('a', intToHexDigitMsb0);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testIntToHexDigitMsb0AndIntToHexDigitMsb0ReturningDigit6() throws Throwable  {
        // Given a number 4, when converting it to a hexadecimal digit with the most significant bit first, then the result should be '2' (the ASCII code for '2').
        char intToHexDigitMsb0 = Conversion.intToHexDigitMsb0(4);
        assertEquals('2', intToHexDigitMsb0);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testIntToHexDigitMsb0AndIntToHexDigitMsb0ReturningAlphabeticChar5() throws Throwable  {
        // Test the method Conversion.intToHexDigitMsb0(int)
        char intToHexDigitMsb0 = Conversion.intToHexDigitMsb0(3);
        assertEquals('c', intToHexDigitMsb0);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testIntToHexDigitMsb0AndIntToHexDigitMsb0ReturningDigit7() throws Throwable  {
        // Convert an integer to a hexadecimal digit, with the most significant bit (MSB) first.
        char intToHexDigitMsb0 = Conversion.intToHexDigitMsb0(2);
        
        // Assert that the converted value is equal to the expected result.
        assertEquals('4', intToHexDigitMsb0);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testIntToHexDigitMsb0AndIntToHexDigitMsb0ReturningDigit8() throws Throwable  {
        // Test the conversion of an integer to a hexadecimal digit (most significant byte first)
        char intToHexDigitMsb0 = Conversion.intToHexDigitMsb0(1);
        assertEquals('8', intToHexDigitMsb0);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testIntToHexDigitMsb0WithZero() throws Throwable  {
        // Test that the function converts an integer to its corresponding hexadecimal digit (MSB first)
        char convertedDigit = Conversion.intToHexDigitMsb0(0);
        assertEquals('0', convertedDigit);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testIntToHexDigitThrowsIllegalArgumentException() throws Throwable  {
        // Declare the expected exception type to make the test more readable
        IllegalArgumentException e = null;
        
        // Try to convert a value that is not between 0 and 15
        try {
        Conversion.intToHexDigit(20);
        fail("Expecting exception: IllegalArgumentException");
        
        } catch(IllegalArgumentException ex) {
        // Save the caught exception for verification later
        e = ex;
        
        // Verify that the exception message contains the expected error message
        verifyException("org.apache.commons.lang3.Conversion", e);
        
        // Verify that the exception message mentions the invalid nibble value (20)
        assertTrue(e.getMessage().contains("nibble value not between 0 and 15: 20"));}
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testIntToHexThrowsStringIndexOutOfBoundsException() throws Throwable  {
        // No Comments were added
        // Undeclared exception!
        try { 
          Conversion.intToHex(1, (-345140), "Hello World!", 16, 2);
          fail("Expecting exception: StringIndexOutOfBoundsException");
        
        } catch(StringIndexOutOfBoundsException e) {
           //
           // String index out of range: 16
           //
           verifyException("java.lang.AbstractStringBuilder", e);
        }
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testBinaryBeMsb0ToHexDigitTaking2ArgumentsAndBinaryBeMsb0ToHexDigitTaking2ArgumentsReturningDigit4() throws Throwable  {
        // Given a boolean array representing a binary number with MSB first order,
        // and an index for the digit to be converted.
        // When we call the method binaryBeMsb0ToHexDigit on this array,
        // with the specified index.
        boolean[] arg0 = new boolean[6];
        arg0[4] = true;
        char binaryBeMsb0ToHexDigit = Conversion.binaryBeMsb0ToHexDigit(arg0, 1);
        // Then we expect the method to return the corresponding hexadecimal digit '1'.
        assertEquals('1', binaryBeMsb0ToHexDigit);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testBinaryBeMsb0ToHexDigitTaking2ArgumentsAndBinaryBeMsb0ToHexDigitTaking2ArgumentsReturningDigit5() throws Throwable  {
        // given a boolean array with six elements
        boolean[] arg0 = new boolean[6];
        
        // when the method is called to convert the array to a hex digit
        char binaryBeMsb0ToHexDigit = Conversion.binaryBeMsb0ToHexDigit(arg0, 1);
        
        // then the result should be the hex digit "0"
        assertEquals('0', binaryBeMsb0ToHexDigit);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testBinaryBeMsb0ToHexDigitTaking2ArgumentsAndHexDigitToBinary() throws Throwable  {
        // Arrange
        boolean[] arg0 = Conversion.hexDigitToBinary('A');
        
        // Act
        char binaryBeMsb0ToHexDigit = Conversion.binaryBeMsb0ToHexDigit(arg0, 1);
        
        // Assert
        assertEquals('2', binaryBeMsb0ToHexDigit);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testBinaryBeMsb0ToHexDigitTaking2ArgumentsAndBinaryBeMsb0ToHexDigitTaking2ArgumentsReturningDigit6() throws Throwable  {
        // Test that the binaryBeMsb0ToHexDigit method correctly converts a binary string to a hexadecimal digit.
        boolean[] arg0 = new boolean[8];
        arg0[3] = true;
        arg0[6] = true;
        char expectedResult = '9';
        char actualResult = Conversion.binaryBeMsb0ToHexDigit(arg0, 1);
        assertEquals(expectedResult, actualResult);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testBinaryBeMsb0ToHexDigitTaking2ArgumentsAndBinaryBeMsb0ToHexDigitTaking2ArgumentsReturningAlphabeticChar2() throws Throwable  {
        // Given: an array of booleans representing a binary number with most significant bit (MSB) at index 0
        boolean[] arg0 = new boolean[5];
        arg0[1] = true;
        arg0[3] = true;
        arg0[4] = true;
        
        // When: the binaryBeMsb0ToHexDigit function is called with this array and an index of 0
        char hexDigit = Conversion.binaryBeMsb0ToHexDigit(arg0, 0);
        
        // Then: the returned value should be the hexadecimal digit corresponding to the binary number in the array
        assertEquals('b', hexDigit);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testBinaryBeMsb0ToHexDigitTaking2ArgumentsAndBinaryBeMsb0ToHexDigitTaking2ArgumentsReturningAlphabeticChar3() throws Throwable  {
        // Given a boolean array with values true and false
        boolean[] arg0 = new boolean[5];
        arg0[1] = true;
        arg0[3] = true;
        
        // When converting the array to a hex digit using the binaryBeMsb0ToHexDigit method
        char hexDigit = Conversion.binaryBeMsb0ToHexDigit(arg0, 0);
        
        // Then the hex digit should be 'a'
        assertEquals('a', hexDigit);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testBinaryBeMsb0ToHexDigitTaking2ArgumentsAndBinaryBeMsb0ToHexDigitTaking2ArgumentsReturningAlphabeticChar4() throws Throwable  {
        // Given: we have a boolean array with some true values
        boolean[] arg0 = new boolean[8];
        arg0[3] = true;
        arg0[4] = true;
        arg0[6] = true;
        
        // When: we call the binaryBeMsb0ToHexDigit method on this array
        char hexDigit = Conversion.binaryBeMsb0ToHexDigit(arg0, (int) (short) 1);
        
        // Then: we expect the hex digit to be 'd'
        assertEquals('d', hexDigit);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testBinaryBeMsb0ToHexDigitTakingBooleanArrayAndHexDigitToBinaryAndBinaryBeMsb0ToHexDigitTakingBooleanArrayReturningAlphabeticChar() throws Throwable  {
        // No Comments were added
        boolean[] arg0 = Conversion.hexDigitToBinary('F');
        char binaryBeMsb0ToHexDigit = Conversion.binaryBeMsb0ToHexDigit(arg0);
        assertEquals('f', binaryBeMsb0ToHexDigit);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testBinaryBeMsb0ToHexDigitTaking2ArgumentsAndBinaryBeMsb0ToHexDigitTaking2ArgumentsReturningAlphabeticChar5() throws Throwable  {
        // Create a boolean array with 8 elements, where element 3 and 4 are set to true.
        boolean[] arg0 = new boolean[8];
        arg0[3] = true;
        arg0[4] = true;
        
        // Convert the boolean array using Conversion.binaryBeMsb0ToHexDigit()
        char hexDigit = Conversion.binaryBeMsb0ToHexDigit(arg0, (int) (short)1);
        
        // Assert that the result is equal to 'c'.
        assertEquals('c', hexDigit);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testBinaryBeMsb0ToHexDigitTaking2ArgumentsAndBinaryBeMsb0ToHexDigitTaking2ArgumentsReturningDigit7() throws Throwable  {
        // Given an array of boolean values representing a binary number
        boolean[] arg0 = new boolean[5];
        arg0[1] = true;
        
        // When we convert the binary number to a hexadecimal digit using the method under test
        char hexDigit = Conversion.binaryBeMsb0ToHexDigit(arg0, 0);
        
        // Then we expect the result to be '8'
        assertEquals('8', hexDigit);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testBinaryBeMsb0ToHexDigitTaking2ArgumentsThrowsIllegalArgumentException() throws Throwable  {
        // No Comments were added
        boolean[] arg0 = new boolean[0];
        // Undeclared exception!
        try { 
          Conversion.binaryBeMsb0ToHexDigit(arg0, (-186));
          fail("Expecting exception: IllegalArgumentException");
        
        } catch(IllegalArgumentException e) {
           //
           // Cannot convert an empty array.
           //
           verifyException("org.apache.commons.lang3.Conversion", e);
        }
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testBinaryBeMsb0ToHexDigitTakingBooleanArrayAndHexDigitToBinaryAndHexDigitToBinaryWithAlphabeticChar() throws Throwable  {
        // No Comments were added
        boolean[] arg0 = Conversion.hexDigitToBinary('A');
        char binaryBeMsb0ToHexDigit = Conversion.binaryBeMsb0ToHexDigit(arg0);
        assertEquals('5', binaryBeMsb0ToHexDigit);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testBinaryToHexDigitMsb0_4bitsTaking2ArgumentsAndBinaryToHexDigitMsb0_4bitsTaking2ArgumentsReturningDigit2() throws Throwable  {
        // Set up the input and expected output values
        boolean[] arg0 = new boolean[5];
        arg0[0] = true;
        char expected = '8';
        
        // Invoke the method being tested
        char actual = Conversion.binaryToHexDigitMsb0_4bits(arg0, 0);
        
        // Verify the results
        assertEquals(expected, actual);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testBinaryToHexDigitMsb0_4bitsTaking2ArgumentsAndBinaryToHexDigitMsb0_4bitsTaking2ArgumentsReturningDigit3() throws Throwable  {
        // Given: an array of 5 booleans with the first element set to true
        boolean[] input = new boolean[5];
        input[1] = true;
        
        // When: calling binaryToHexDigitMsb0_4bits on this array and the index 0
        char actual = Conversion.binaryToHexDigitMsb0_4bits(input, 0);
        
        // Then: the method should return the hex digit '4'
        assertEquals('4', actual);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testBinaryToHexDigitMsb0_4bitsTaking2ArgumentsAndBinaryToHexDigitMsb0_4bitsTaking2ArgumentsReturningDigit4() throws Throwable  {
        // Given a boolean array with two values, where the first value is true and the second value is also true
        boolean[] arg0 = new boolean[4];
        arg0[1] = true;
        arg0[2] = true;
        
        // When we call the binaryToHexDigitMsb0_4bits method with the first index of 0 and a 4-bit input array
        char actualValue = Conversion.binaryToHexDigitMsb0_4bits(arg0, 0);
        
        // Then the method should return the correct hexadecimal value for the given input
        assertEquals('6', actualValue);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testBinaryToHexDigitMsb0_4bitsTaking2ArgumentsAndBinaryToHexDigitMsb0_4bitsTaking2ArgumentsReturningDigit5() throws Throwable  {
        // Given a boolean array representing a 4-bit binary number
        boolean[] input = new boolean[8];
        input[0] = true;
        input[3] = true;
        
        // When the method is called with the input
        char result = Conversion.binaryToHexDigitMsb0_4bits(input, 0);
        
        // Then the expected hexadecimal digit should be returned
        assertEquals('9', result);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testBinaryToHexDigitMsb0_4bitsTaking2ArgumentsAndBinaryToHexDigitMsb0_4bitsTaking2ArgumentsReturningDigit6() throws Throwable  {
        // Given a 6-bit binary number
        boolean[] arg0 = new boolean[6];
        arg0[2] = true;
        arg0[3] = true;
        arg0[4] = true;
        
        // When the method is called with the binary number and the position of the most significant bit (MSB)
        char binaryToHexDigitMsb0_4bits = Conversion.binaryToHexDigitMsb0_4bits(arg0, 1);
        
        // Then the corresponding hexadecimal digit should be returned
        assertEquals('7', binaryToHexDigitMsb0_4bits);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testBinaryToHexDigitMsb0_4bitsTaking2ArgumentsAndBinaryToHexDigitMsb0_4bitsTaking2ArgumentsReturningDigit7() throws Throwable  {
        // Test data
        boolean[] input = new boolean[6];
        input[3] = true;
        input[4] = true;
        
        // Execute method under test
        char hexDigit = Conversion.binaryToHexDigitMsb0_4bits(input, 1);
        
        // Assertions
        assertEquals('3', hexDigit);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testBinaryToHexDigitMsb0_4bitsTaking2ArgumentsAndBinaryToHexDigitMsb0_4bitsTaking2ArgumentsReturningDigit8() throws Throwable  {
        // Given: We have a boolean array with 8 elements and the 4th element is set to true.
        boolean[] arg0 = new boolean[8];
        arg0[3] = true;
        
        // When: We convert this boolean array of length 8 with the 4th element set to true to a hex digit using Conversion.binaryToHexDigitMsb0_4bits() method.
        char binaryToHexDigitMsb0_4bits = Conversion.binaryToHexDigitMsb0_4bits(arg0, 0);
        
        // Then: We assert that the returned hex digit is '1'.
        assertEquals('1', binaryToHexDigitMsb0_4bits);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testBinaryToHexDigitMsb0_4bitsTaking2ArgumentsAndBinaryToHexDigitMsb0_4bitsTaking2ArgumentsReturningDigit9() throws Throwable  {
        // No Comments were added
        boolean[] arg0 = new boolean[5];
        char binaryToHexDigitMsb0_4bits = Conversion.binaryToHexDigitMsb0_4bits(arg0, 0);
        assertEquals('0', binaryToHexDigitMsb0_4bits);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testBinaryToHexDigitMsb0_4bitsTaking2ArgumentsThrowsIllegalArgumentException0() throws Throwable  {
        // Test that the method throws an IllegalArgumentException when the source array has fewer than 4 bits remaining
        boolean[] arg0 = Conversion.hexDigitMsb0ToBinary('F');
        try {
        // Try to convert the binary representation of a hexadecimal digit to its MSB-first, 4-bit representation
        Conversion.binaryToHexDigitMsb0_4bits(arg0, 15);
        // If we reach this point, it means that no exception was thrown and that the method returned successfully
        fail("Expecting exception: IllegalArgumentException");
        } catch(IllegalArgumentException e) {
        // Verify that the exception is indeed an IllegalArgumentException
        verifyException("org.apache.commons.lang3.Conversion", e);
        // Check that the message of the exception matches our expectation
        assertEquals("src.length-srcPos<4: src.length=4, srcPos=15", e.getMessage());}
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testBinaryToHexDigitMsb0_4bitsTaking2ArgumentsThrowsIllegalArgumentException1() throws Throwable  {
        // Given a binary array of length 9 and an input value of 2,
        boolean[] inputBinaryArray = new boolean[9];
        int inputValue = 2;
        
        try {
        // When attempting to convert the binary array to a hexadecimal digit using the MSB-first method with 4 bits,
        Conversion.binaryToHexDigitMsb0_4bits(inputBinaryArray, inputValue);
        
        // Then an IllegalArgumentException is thrown because the source length (9) exceeds the maximum allowed value (8).
        fail("Expecting exception: IllegalArgumentException");
        } catch(IllegalArgumentException e) {
        // Verify that the correct exception was thrown with the expected message.
        verifyException("org.apache.commons.lang3.Conversion", e);}
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testBinaryToHexDigitMsb0_4bitsTakingBooleanArrayAndHexDigitToBinary0() throws Throwable  {
        // No Comments were added
        boolean[] arg0 = Conversion.hexDigitToBinary('F');
        char binaryToHexDigitMsb0_4bits = Conversion.binaryToHexDigitMsb0_4bits(arg0);
        assertEquals('f', binaryToHexDigitMsb0_4bits);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testBinaryToHexDigitTaking2ArgumentsAndBinaryToHexDigitTaking2ArgumentsReturningDigit1() throws Throwable  {
        // No Comments were added
        boolean[] arg0 = new boolean[5];
        arg0[0] = true;
        char binaryToHexDigit = Conversion.binaryToHexDigit(arg0, 0);
        assertEquals('1', binaryToHexDigit);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testBinaryToHexDigitTaking2ArgumentsAndBinaryToHexDigitTaking2ArgumentsReturningDigit2() throws Throwable  {
        // Given a boolean array with 5 elements
        boolean[] arg0 = new boolean[5];
        
        // When converting the boolean array to a hexadecimal digit using the Conversion class' binaryToHexDigit method
        char binaryToHexDigit = Conversion.binaryToHexDigit(arg0, 0);
        
        // Then the result should be the ASCII value of '0' (48)
        assertEquals((char) 48, binaryToHexDigit);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testBinaryToHexDigitTaking2ArgumentsAndBinaryToHexDigitTaking2ArgumentsReturningDigit3() throws Throwable  {
        // Given: A boolean array containing five elements
        boolean[] arg0 = new boolean[5];
        
        // When: The element at index 2 is set to true
        arg0[2] = true;
        
        // Then: The method binaryToHexDigit should return the hexadecimal digit '4'
        char binaryToHexDigit = Conversion.binaryToHexDigit(arg0, 0);
        assertEquals('4', binaryToHexDigit);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testBinaryToHexDigitTaking2ArgumentsAndBinaryToHexDigitTaking2ArgumentsReturningDigit4() throws Throwable  {
        // Given a binary array of length 5 with values true at indices 1 and 2
        boolean[] arg0 = new boolean[5];
        arg0[1] = true;
        arg0[0] = true;
        arg0[2] = true;
        
        // When the binaryToHexDigit method is called with the array and an index of 0
        char hexDigit = Conversion.binaryToHexDigit(arg0, 0);
        
        // Then the returned value should be the hexadecimal digit '7'
        assertEquals('7', hexDigit);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testBinaryToHexDigitTaking2ArgumentsAndBinaryToHexDigitTaking2ArgumentsReturningDigit5() throws Throwable  {
        // Given a boolean array with a length of 5
        boolean[] arg0 = new boolean[5];
        
        // When the binaryToHexDigit method is called with the array and an index of 0
        char result = Conversion.binaryToHexDigit(arg0, 0);
        
        // Then the resulting hex digit should be '6'
        assertEquals('6', result);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testBinaryToHexDigitTaking2ArgumentsWithPositive() throws Throwable  {
        // Test for converting a hex digit (A) to its MSB-first binary representation
        // and then back to the original hex digit using the binaryToHexDigit function.
        
        boolean[] arg0 = Conversion.hexDigitMsb0ToBinary('A');
        char binaryToHexDigit = Conversion.binaryToHexDigit(arg0, 1);
        assertEquals('2', binaryToHexDigit);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testBinaryToHexDigitTaking2ArgumentsAndBinaryToHexDigitTaking2ArgumentsReturningDigit6() throws Throwable  {
        // No Comments were added
        boolean[] arg0 = new boolean[5];
        arg0[0] = true;
        arg0[3] = true;
        char binaryToHexDigit = Conversion.binaryToHexDigit(arg0, 0);
        assertEquals('9', binaryToHexDigit);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testBinaryToHexDigitTaking2ArgumentsAndBinaryToHexDigitTaking2ArgumentsReturningAlphabeticChar1() throws Throwable  {
        // Arrange
        boolean[] arg0 = new boolean[4];
        arg0[1] = true;
        arg0[3] = true;
        
        // Act
        char binaryToHexDigit = Conversion.binaryToHexDigit(arg0, 0);
        
        // Assert
        assertEquals('a', binaryToHexDigit);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testBinaryToHexDigitTaking2ArgumentsAndBinaryToHexDigitTaking2ArgumentsReturningAlphabeticChar2() throws Throwable  {
        // Given: an array of booleans representing a binary number
        boolean[] arg0 = new boolean[6];
        
        // When: the method is called with the binary number and 0 as the starting index
        char binaryToHexDigit = Conversion.binaryToHexDigit(arg0, 0);
        
        // Then: the method should return the corresponding hexadecimal digit ('d')
        assertEquals('d', binaryToHexDigit);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testBinaryToHexDigitTaking2ArgumentsAndBinaryToHexDigitTaking2ArgumentsReturningAlphabeticChar3() throws Throwable  {
        // Given a binary array of length 4 with values "1010" (i.e., true for the first and third elements)
        boolean[] arg0 = new boolean[4];
        arg0[1] = true;
        arg0[2] = true;
        arg0[3] = true;
        
        // When converting the binary array to a hexadecimal digit using the Conversion.binaryToHexDigit method
        char actualValue = Conversion.binaryToHexDigit(arg0, 0);
        
        // Then the actual value should be "e" (i.e., the decimal representation of the binary number)
        assertEquals('e', actualValue);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testBinaryToHexDigitTaking2ArgumentsAndBinaryToHexDigitTaking2ArgumentsReturningDigit7() throws Throwable  {
        // Given a boolean array representing a binary number
        boolean[] input = new boolean[4];
        input[3] = true;
        
        // When we convert the binary number to hexadecimal using Conversion.binaryToHexDigit()
        char output = Conversion.binaryToHexDigit(input, 0);
        
        // Then the resulting hexadecimal character should be '8'
        assertEquals('8', output);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testBinaryToHexDigitTaking2ArgumentsThrowsIllegalArgumentException() throws Throwable  {
        // Given: An empty boolean array as input
        boolean[] arg0 = new boolean[0];
        
        try {
        // When: Calling the binaryToHexDigit method with an empty array
        Conversion.binaryToHexDigit(arg0, 1905);
        
        // Then: An IllegalArgumentException is thrown because it cannot convert an empty array
        fail("Expecting exception: IllegalArgumentException");
        } catch (IllegalArgumentException e) {
        // Cannot convert an empty array.
        verifyException("org.apache.commons.lang3.Conversion", e);}
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testHexDigitMsb0ToBinaryThrowsIllegalArgumentException0() throws Throwable  {
        // No Comments were added
        // Undeclared exception!
        try { 
          Conversion.hexDigitMsb0ToBinary('h');
          fail("Expecting exception: IllegalArgumentException");
        
        } catch(IllegalArgumentException e) {
           //
           // Cannot interpret 'h' as a hexadecimal digit
           //
           verifyException("org.apache.commons.lang3.Conversion", e);
        }
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testHexDigitMsb0ToBinary0() throws Throwable  {
        // Test that the method converts a single hex digit to an array of 4 binary digits
        boolean[] hexDigitMsb0ToBinary = Conversion.hexDigitMsb0ToBinary('f');
        assertEquals(4, hexDigitMsb0ToBinary.length);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testHexDigitMsb0ToBinary1() throws Throwable  {
        // No Comments were added
        boolean[] hexDigitMsb0ToBinary = Conversion.hexDigitMsb0ToBinary('e');
        assertEquals(4, hexDigitMsb0ToBinary.length);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testHexDigitMsb0ToBinary2() throws Throwable  {
        // Given a hexadecimal digit 'd' in MSB-first order
        // When the digit is converted to binary representation
        // Then the binary representation should be 1101 (MSB first)
        boolean[] hexDigitMsb0ToBinary = Conversion.hexDigitMsb0ToBinary('d');
        assertTrue(Arrays.equals(new boolean[] {true, true, false, true}, hexDigitMsb0ToBinary));
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testBinaryToHexDigitMsb0_4bitsTakingBooleanArrayAndHexDigitMsb0ToBinary() throws Throwable  {
        // No Comments were added
        boolean[] arg0 = Conversion.hexDigitMsb0ToBinary('c');
        char binaryToHexDigitMsb0_4bits = Conversion.binaryToHexDigitMsb0_4bits(arg0);
        assertEquals('c', binaryToHexDigitMsb0_4bits);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testBinaryToHexDigitMsb0_4bitsTaking2ArgumentsAndHexDigitMsb0ToBinary() throws Throwable  {
        // rollbacked to evosuite
        boolean[] arg0 = Conversion.hexDigitMsb0ToBinary('b');
        char binaryToHexDigitMsb0_4bits = Conversion.binaryToHexDigitMsb0_4bits(arg0, (int) (byte)0);
        assertEquals('b', binaryToHexDigitMsb0_4bits);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testHexDigitMsb0ToBinaryAndHexDigitMsb0ToBinaryWithAlphabeticChar() throws Throwable  {
        // No Comments were added
        boolean[] hexDigitMsb0ToBinary = Conversion.hexDigitMsb0ToBinary('a');
        assertEquals(4, hexDigitMsb0ToBinary.length);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testHexDigitMsb0ToBinaryThrowsIllegalArgumentExceptionAndHexDigitMsb0ToBinaryWithOtherChar0() throws Throwable  {
        // rollbacked to evosuite
        // Undeclared exception!
        try { 
          Conversion.hexDigitMsb0ToBinary('`');
          fail("Expecting exception: IllegalArgumentException");
        
        } catch(IllegalArgumentException e) {
           //
           // Cannot interpret '`' as a hexadecimal digit
           //
           verifyException("org.apache.commons.lang3.Conversion", e);
        }
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testHexDigitMsb0ToBinaryThrowsIllegalArgumentExceptionAndHexDigitMsb0ToBinaryWithOtherChar1() throws Throwable  {
        // Undeclared exception!
        try {
        Conversion.hexDigitMsb0ToBinary('_');
        fail("Expecting exception: IllegalArgumentException");
        
        } catch(IllegalArgumentException e) {
        //
        // Cannot interpret '_' as a hexadecimal digit
        //
        verifyException("org.apache.commons.lang3.Conversion", e);}
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testHexDigitMsb0ToBinaryThrowsIllegalArgumentExceptionAndHexDigitMsb0ToBinaryWithOtherChar2() throws Throwable  {
        // Test that an exception is thrown when attempting to convert an invalid hexadecimal digit
        try {
        // Call the method with a string that contains an invalid hexadecimal digit (^)
        Conversion.hexDigitMsb0ToBinary('^');
        // Assert that an IllegalArgumentException is thrown
        fail("Expecting exception: IllegalArgumentException");
        } catch(IllegalArgumentException e) {
        // Verify that the expected exception was thrown and provide a descriptive message
        verifyException("org.apache.commons.lang3.Conversion", e);}
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testHexDigitMsb0ToBinaryThrowsIllegalArgumentExceptionAndHexDigitMsb0ToBinaryWithOtherChar3() throws Throwable  {
        // No Comments were added
        // Undeclared exception!
        try { 
          Conversion.hexDigitMsb0ToBinary(']');
          fail("Expecting exception: IllegalArgumentException");
        
        } catch(IllegalArgumentException e) {
           //
           // Cannot interpret ']' as a hexadecimal digit
           //
           verifyException("org.apache.commons.lang3.Conversion", e);
        }
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testHexDigitMsb0ToBinaryThrowsIllegalArgumentExceptionAndHexDigitMsb0ToBinaryWithOtherChar4() throws Throwable  {
        // Test that an exception is thrown when passing an invalid hexadecimal digit to the hexDigitMsb0ToBinary method
        try {
        // Pass a character that cannot be interpreted as a hexadecimal digit
        Conversion.hexDigitMsb0ToBinary('\\');
        
        // Fail the test if no exception is thrown
        fail("Expecting exception: IllegalArgumentException");
        } catch(IllegalArgumentException e) {
        // Verify that the correct exception was thrown
        verifyException("org.apache.commons.lang3.Conversion", e);}
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testHexDigitMsb0ToBinaryThrowsIllegalArgumentExceptionAndHexDigitMsb0ToBinaryWithOtherChar5() throws Throwable  {
        // No Comments were added
        // Undeclared exception!
        try { 
          Conversion.hexDigitMsb0ToBinary('[');
          fail("Expecting exception: IllegalArgumentException");
        
        } catch(IllegalArgumentException e) {
           //
           // Cannot interpret '[' as a hexadecimal digit
           //
           verifyException("org.apache.commons.lang3.Conversion", e);
        }
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testHexDigitMsb0ToBinaryThrowsIllegalArgumentExceptionAndHexDigitMsb0ToBinaryWithAlphabeticChar() throws Throwable  {
        // Test that an exception is thrown when passing a character that cannot be interpreted as a hexadecimal digit
        try {
        Conversion.hexDigitMsb0ToBinary('Z');
        fail("Expecting exception: IllegalArgumentException");
        } catch(IllegalArgumentException e) {
        // Verify the expected exception is thrown with the correct message
        verifyException("org.apache.commons.lang3.Conversion", e);
        assertEquals("Cannot interpret 'Z' as a hexadecimal digit", e.getMessage());}
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testHexDigitMsb0ToBinaryThrowsIllegalArgumentException1() throws Throwable  {
        // No Comments were added
        // Undeclared exception!
        try { 
          Conversion.hexDigitMsb0ToBinary('Y');
          fail("Expecting exception: IllegalArgumentException");
        
        } catch(IllegalArgumentException e) {
           //
           // Cannot interpret 'Y' as a hexadecimal digit
           //
           verifyException("org.apache.commons.lang3.Conversion", e);
        }
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testHexDigitMsb0ToBinaryThrowsIllegalArgumentException2() throws Throwable  {
        // No Comments were added
        // Undeclared exception!
        try { 
          Conversion.hexDigitMsb0ToBinary('X');
          fail("Expecting exception: IllegalArgumentException");
        
        } catch(IllegalArgumentException e) {
           //
           // Cannot interpret 'X' as a hexadecimal digit
           //
           verifyException("org.apache.commons.lang3.Conversion", e);
        }
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testHexDigitMsb0ToBinaryThrowsIllegalArgumentException3() throws Throwable  {
        // No Comments were added
        // Undeclared exception!
        try { 
          Conversion.hexDigitMsb0ToBinary('W');
          fail("Expecting exception: IllegalArgumentException");
        
        } catch(IllegalArgumentException e) {
           //
           // Cannot interpret 'W' as a hexadecimal digit
           //
           verifyException("org.apache.commons.lang3.Conversion", e);
        }
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testHexDigitMsb0ToBinaryThrowsIllegalArgumentException4() throws Throwable  {
        // Test that the method throws an IllegalArgumentException when given an invalid input
        try {
        Conversion.hexDigitMsb0ToBinary('V');
        fail("Expecting exception: IllegalArgumentException");
        } catch(IllegalArgumentException e) {
        // Verify that the exception is thrown due to an illegal hexadecimal digit
        verifyException("org.apache.commons.lang3.Conversion", e);}
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testHexDigitMsb0ToBinaryThrowsIllegalArgumentException5() throws Throwable  {
        // Undeclared exception!
        try {
        Conversion.hexDigitMsb0ToBinary('U');
        fail("Expecting exception: IllegalArgumentException");
        
        } catch(IllegalArgumentException e) {
        //
        // Cannot interpret 'U' as a hexadecimal digit
        //
        verifyException("org.apache.commons.lang3.Conversion", e);
        }
        
        // Test case for the method Conversion.hexDigitMsb0ToBinary(char)
        // Verifies that an IllegalArgumentException is thrown when a character cannot be converted to binary
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testHexDigitMsb0ToBinaryThrowsIllegalArgumentException6() throws Throwable  {
        // No Comments were added
        // Undeclared exception!
        try { 
          Conversion.hexDigitMsb0ToBinary('T');
          fail("Expecting exception: IllegalArgumentException");
        
        } catch(IllegalArgumentException e) {
           //
           // Cannot interpret 'T' as a hexadecimal digit
           //
           verifyException("org.apache.commons.lang3.Conversion", e);
        }
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testHexDigitMsb0ToBinaryThrowsIllegalArgumentException7() throws Throwable  {
        // Test that an exception is thrown when trying to convert an invalid hexadecimal digit to binary
        try {
        Conversion.hexDigitMsb0ToBinary('S');
        fail("Expecting exception: IllegalArgumentException");
        } catch(IllegalArgumentException e) {
        // Verify that the exception is correctly thrown when an invalid hexadecimal digit is passed in
        verifyException("org.apache.commons.lang3.Conversion", e);}
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testHexDigitMsb0ToBinaryThrowsIllegalArgumentException8() throws Throwable  {
        // No Comments were added
        // Undeclared exception!
        try { 
          Conversion.hexDigitMsb0ToBinary('R');
          fail("Expecting exception: IllegalArgumentException");
        
        } catch(IllegalArgumentException e) {
           //
           // Cannot interpret 'R' as a hexadecimal digit
           //
           verifyException("org.apache.commons.lang3.Conversion", e);
        }
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testHexDigitMsb0ToBinaryThrowsIllegalArgumentException9() throws Throwable  {
        // Test that the method throws an exception when given a string that cannot be interpreted as a hexadecimal digit
        try {
        Conversion.hexDigitMsb0ToBinary('Q');
        fail("Expecting exception: IllegalArgumentException");
        } catch(IllegalArgumentException e) {
        verifyException("org.apache.commons.lang3.Conversion", e);}
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testHexDigitMsb0ToBinaryThrowsIllegalArgumentException10() throws Throwable  {
        // No Comments were added
        // Undeclared exception!
        try { 
          Conversion.hexDigitMsb0ToBinary('P');
          fail("Expecting exception: IllegalArgumentException");
        
        } catch(IllegalArgumentException e) {
           //
           // Cannot interpret 'P' as a hexadecimal digit
           //
           verifyException("org.apache.commons.lang3.Conversion", e);
        }
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testHexDigitMsb0ToBinaryThrowsIllegalArgumentException11() throws Throwable  {
        // No Comments were added
        // Undeclared exception!
        try { 
          Conversion.hexDigitMsb0ToBinary('O');
          fail("Expecting exception: IllegalArgumentException");
        
        } catch(IllegalArgumentException e) {
           //
           // Cannot interpret 'O' as a hexadecimal digit
           //
           verifyException("org.apache.commons.lang3.Conversion", e);
        }
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testHexDigitMsb0ToBinaryThrowsIllegalArgumentException12() throws Throwable  {
        // No Comments were added
        // Undeclared exception!
        try { 
          Conversion.hexDigitMsb0ToBinary('N');
          fail("Expecting exception: IllegalArgumentException");
        
        } catch(IllegalArgumentException e) {
           //
           // Cannot interpret 'N' as a hexadecimal digit
           //
           verifyException("org.apache.commons.lang3.Conversion", e);
        }
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testHexDigitMsb0ToBinaryThrowsIllegalArgumentException13() throws Throwable  {
        // Undeclared exception!
        try {
        Conversion.hexDigitMsb0ToBinary('M');
        fail("Expecting exception: IllegalArgumentException");
        
        } catch(IllegalArgumentException e) {
        // Cannot interpret 'M' as a hexadecimal digit
        verifyException("org.apache.commons.lang3.Conversion", e);}
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testHexDigitMsb0ToBinaryThrowsIllegalArgumentException14() throws Throwable  {
        // rollbacked to evosuite
        // Undeclared exception!
        try { 
          Conversion.hexDigitMsb0ToBinary('L');
          fail("Expecting exception: IllegalArgumentException");
        
        } catch(IllegalArgumentException e) {
           //
           // Cannot interpret 'L' as a hexadecimal digit
           //
           verifyException("org.apache.commons.lang3.Conversion", e);
        }
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testHexDigitMsb0ToBinaryThrowsIllegalArgumentException15() throws Throwable  {
        // No Comments were added
        // Undeclared exception!
        try { 
          Conversion.hexDigitMsb0ToBinary('K');
          fail("Expecting exception: IllegalArgumentException");
        
        } catch(IllegalArgumentException e) {
           //
           // Cannot interpret 'K' as a hexadecimal digit
           //
           verifyException("org.apache.commons.lang3.Conversion", e);
        }
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testHexDigitMsb0ToBinaryThrowsIllegalArgumentException16() throws Throwable  {
        // No Comments were added
        // Undeclared exception!
        try { 
          Conversion.hexDigitMsb0ToBinary('J');
          fail("Expecting exception: IllegalArgumentException");
        
        } catch(IllegalArgumentException e) {
           //
           // Cannot interpret 'J' as a hexadecimal digit
           //
           verifyException("org.apache.commons.lang3.Conversion", e);
        }
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testHexDigitMsb0ToBinaryThrowsIllegalArgumentException17() throws Throwable  {
        // No Comments were added
        // Undeclared exception!
        try { 
          Conversion.hexDigitMsb0ToBinary('I');
          fail("Expecting exception: IllegalArgumentException");
        
        } catch(IllegalArgumentException e) {
           //
           // Cannot interpret 'I' as a hexadecimal digit
           //
           verifyException("org.apache.commons.lang3.Conversion", e);
        }
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testHexDigitMsb0ToBinaryThrowsIllegalArgumentException18() throws Throwable  {
        // No Comments were added
        // Undeclared exception!
        try { 
          Conversion.hexDigitMsb0ToBinary('H');
          fail("Expecting exception: IllegalArgumentException");
        
        } catch(IllegalArgumentException e) {
           //
           // Cannot interpret 'H' as a hexadecimal digit
           //
           verifyException("org.apache.commons.lang3.Conversion", e);
        }
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testHexDigitMsb0ToBinaryThrowsIllegalArgumentException19() throws Throwable  {
        // Verify that an exception is thrown when an invalid hexadecimal digit is passed in
        try {
        Conversion.hexDigitMsb0ToBinary('G');
        fail("Expecting exception: IllegalArgumentException");
        } catch(IllegalArgumentException e) {
        // Verify that the expected exception was thrown with the correct message
        verifyException("org.apache.commons.lang3.Conversion", e);}
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testBinaryToHexDigitTaking2ArgumentsAndHexDigitMsb0ToBinary() throws Throwable  {
        // Convert hex digit 'F' to binary using the conversion method.
        boolean[] arg0 = Conversion.hexDigitMsb0ToBinary('F');
        
        // Convert the binary array back to a hex digit using the conversion method.
        char binaryToHexDigit = Conversion.binaryToHexDigit(arg0, 0);
        
        // Assert that the converted hex digit is equal to 'f'.
        assertEquals('f', binaryToHexDigit);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testBinaryBeMsb0ToHexDigitTakingBooleanArrayAndHexDigitMsb0ToBinaryAndBinaryBeMsb0ToHexDigitTakingBooleanArrayReturningAlphabeticChar() throws Throwable  {
        // Convert the hexadecimal digit 'e' to its binary representation with MSB=0.
        boolean[] arg0 = Conversion.hexDigitMsb0ToBinary('E');
        
        // Convert the binary representation back to a hexadecimal digit with MSB=0.
        char binaryBeMsb0ToHexDigit = Conversion.binaryBeMsb0ToHexDigit(arg0);
        
        // Assert that the converted value is equal to the original value.
        assertEquals('e', binaryBeMsb0ToHexDigit);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testBinaryToHexDigitTakingBooleanArrayReturningAlphabeticChar() throws Throwable  {
        // No Comments were added
        boolean[] arg0 = Conversion.hexDigitMsb0ToBinary('D');
        char binaryToHexDigit = Conversion.binaryToHexDigit(arg0);
        assertEquals('b', binaryToHexDigit);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testBinaryToHexDigitTakingBooleanArrayReturningDigit() throws Throwable  {
        // Tests the conversion of a single hexadecimal digit to its binary representation,
        // and then converts it back to its original hexadecimal form.
        boolean[] arg0 = Conversion.hexDigitMsb0ToBinary('C');
        char binaryToHexDigit = Conversion.binaryToHexDigit(arg0);
        assertEquals('3', binaryToHexDigit);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testHexDigitMsb0ToBinary3() throws Throwable  {
        // When converting the hexadecimal digit 'B' in MSB-first (big-endian) order to binary representation
        boolean[] hexDigitMsb0ToBinary = Conversion.hexDigitMsb0ToBinary('B');
        
        // Then the resulting array should have a length of 4, representing the binary representation of the digit 'B'
        assertEquals(4, hexDigitMsb0ToBinary.length);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testHexDigitMsb0ToBinaryThrowsIllegalArgumentExceptionAndHexDigitMsb0ToBinaryWithOtherChar6() throws Throwable  {
        // rollbacked to evosuite
        // Undeclared exception!
        try { 
          Conversion.hexDigitMsb0ToBinary('@');
          fail("Expecting exception: IllegalArgumentException");
        
        } catch(IllegalArgumentException e) {
           //
           // Cannot interpret '@' as a hexadecimal digit
           //
           verifyException("org.apache.commons.lang3.Conversion", e);
        }
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testHexDigitMsb0ToBinaryThrowsIllegalArgumentExceptionAndHexDigitMsb0ToBinaryWithOtherChar7() throws Throwable  {
        // Test that an exception is thrown when trying to convert an invalid hexadecimal digit to binary
        try {
        // Try to convert a character that is not a valid hexadecimal digit to binary
        Conversion.hexDigitMsb0ToBinary('?');
        fail("Expecting exception: IllegalArgumentException");
        } catch(IllegalArgumentException e) {
        // Verify that the expected exception was thrown
        verifyException("org.apache.commons.lang3.Conversion", e);
        
        // Check that the exception message is correct
        assertEquals("Cannot interpret '?' as a hexadecimal digit", e.getMessage());}
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testHexDigitMsb0ToBinaryThrowsIllegalArgumentExceptionAndHexDigitMsb0ToBinaryWithOtherChar8() throws Throwable  {
        // Undeclared exception!
        try {
        Conversion.hexDigitMsb0ToBinary('>');
        fail("Expecting exception: IllegalArgumentException");
        
        } catch(IllegalArgumentException e) {
        // Verify that the correct exception is thrown with the correct message.
        assertEquals(e.getMessage(), "The character '>' is not a valid hexadecimal digit.");}
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testHexDigitMsb0ToBinaryThrowsIllegalArgumentExceptionAndHexDigitMsb0ToBinaryWithOtherChar9() throws Throwable  {
        // Undeclared exception!
        try {
        Conversion.hexDigitMsb0ToBinary('=');
        fail("Expecting exception: IllegalArgumentException");
        
        } catch(IllegalArgumentException e) {
        //
        // Cannot interpret '=' as a hexadecimal digit
        //
        verifyException("org.apache.commons.lang3.Conversion", e);}
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testHexDigitMsb0ToBinaryThrowsIllegalArgumentExceptionAndHexDigitMsb0ToBinaryWithOtherChar10() throws Throwable  {
        // Undeclared exception!
        try {
        Conversion.hexDigitMsb0ToBinary('<');
        fail("Expecting exception: IllegalArgumentException");
        
        } catch(IllegalArgumentException e) {
        //
        // Test that the method throws an IllegalArgumentException when passed a character that cannot be interpreted as a hexadecimal digit.
        // The '<' character is not a valid hexadecimal digit and should cause the test to fail.
        //
        verifyException("org.apache.commons.lang3.Conversion", e);}
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testHexDigitMsb0ToBinaryThrowsIllegalArgumentExceptionAndHexDigitMsb0ToBinaryWithOtherChar11() throws Throwable  {
        // No Comments were added
        // Undeclared exception!
        try { 
          Conversion.hexDigitMsb0ToBinary(';');
          fail("Expecting exception: IllegalArgumentException");
        
        } catch(IllegalArgumentException e) {
           //
           // Cannot interpret ';' as a hexadecimal digit
           //
           verifyException("org.apache.commons.lang3.Conversion", e);
        }
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testHexDigitMsb0ToBinaryThrowsIllegalArgumentExceptionAndHexDigitMsb0ToBinaryWithOtherChar12() throws Throwable  {
        // No Comments were added
        // Undeclared exception!
        try { 
          Conversion.hexDigitMsb0ToBinary(':');
          fail("Expecting exception: IllegalArgumentException");
        
        } catch(IllegalArgumentException e) {
           //
           // Cannot interpret ':' as a hexadecimal digit
           //
           verifyException("org.apache.commons.lang3.Conversion", e);
        }
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testHexDigitMsb0ToBinaryAndHexDigitMsb0ToBinaryWithDigit0() throws Throwable  {
        // rollbacked to evosuite
        boolean[] hexDigitMsb0ToBinary = Conversion.hexDigitMsb0ToBinary('9');
        assertTrue(Arrays.equals(new boolean[] {true, false, false, true}, hexDigitMsb0ToBinary));
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testHexDigitMsb0ToBinaryAndHexDigitMsb0ToBinaryWithDigit1() throws Throwable  {
        // The goal of this test is to verify that a hex digit (in this case '8') is converted correctly to its binary representation.
        boolean[] hexDigitMsb0ToBinary = Conversion.hexDigitMsb0ToBinary('8');
        assertTrue(Arrays.equals(new boolean[] {true, false, false, false}, hexDigitMsb0ToBinary));
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testHexDigitMsb0ToBinaryAndHexDigitMsb0ToBinaryWithDigit2() throws Throwable  {
        // Test that the conversion from hexadecimal digit MSB-first to binary is correct.
        boolean[] hexDigitMsb0ToBinary = Conversion.hexDigitMsb0ToBinary('7');
        assertTrue(Arrays.equals(new boolean[] {false, true, true, true}, hexDigitMsb0ToBinary));
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testBinaryBeMsb0ToHexDigitTakingBooleanArrayAndHexDigitMsb0ToBinaryAndBinaryBeMsb0ToHexDigitTakingBooleanArrayReturningDigit() throws Throwable  {
        // Convert a binary number represented as an array of booleans from most significant bit (MSB) to least significant bit (LSB) to a hexadecimal digit.
        boolean[] arg0 = {true, false, true, false};
        char binaryBeMsb0ToHexDigit = Conversion.binaryBeMsb0ToHexDigit(arg0);
        assertEquals('6', binaryBeMsb0ToHexDigit);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testBinaryToShortThrowsArrayIndexOutOfBoundsException() throws Throwable  {
        // Test that binaryToShort throws an ArrayIndexOutOfBoundsException when
        // trying to convert a hex digit with an invalid length.
        
        boolean[] arg0 = Conversion.hexDigitMsb0ToBinary('5');
        try {
        Conversion.binaryToShort(arg0, 1, (short) 0, (-1485), 83);
        fail("Expecting exception: ArrayIndexOutOfBoundsException");
        } catch(ArrayIndexOutOfBoundsException e) {
        // The method binaryToShort should throw an ArrayIndexOutOfBoundsException when
        // the length of the input array is not equal to 8.
        verifyException("org.apache.commons.lang3.Conversion", e);}
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testHexDigitMsb0ToBinaryAndHexDigitMsb0ToBinaryWithDigit3() throws Throwable  {
        // Given: A hexadecimal digit '4' represented as a char
        char hexDigit = '4';
        
        // When: Converting the hexadecimal digit to its binary representation using MSB-0 encoding
        boolean[] hexDigitMsb0ToBinary = Conversion.hexDigitMsb0ToBinary(hexDigit);
        
        // Then: The binary representation of the hexadecimal digit is [false, true, false, false]
        assertTrue(Arrays.equals(new boolean[] {false, true, false, false}, hexDigitMsb0ToBinary));
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testBinaryToHexDigitTaking2ArgumentsAndHexDigitMsb0ToBinaryAndHexDigitMsb0ToBinaryWithDigit() throws Throwable  {
        // rollbacked to evosuite
        boolean[] arg0 = Conversion.hexDigitMsb0ToBinary('3');
        char binaryToHexDigit = Conversion.binaryToHexDigit(arg0, 0);
        assertEquals(4, arg0.length);
        assertEquals('c', binaryToHexDigit);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testBinaryToHexDigitMsb0_4bitsTakingBooleanArrayReturningDigit() throws Throwable  {
        // No Comments were added
        boolean[] arg0 = Conversion.hexDigitMsb0ToBinary('2');
        char binaryToHexDigitMsb0_4bits = Conversion.binaryToHexDigitMsb0_4bits(arg0);
        assertEquals('2', binaryToHexDigitMsb0_4bits);
        assertEquals(4, arg0.length);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testHexDigitMsb0ToBinaryAndHexDigitMsb0ToBinaryWithDigit4() throws Throwable  {
        // No Comments were added
        boolean[] hexDigitMsb0ToBinary = Conversion.hexDigitMsb0ToBinary('1');
        assertTrue(Arrays.equals(new boolean[] {false, false, false, true}, hexDigitMsb0ToBinary));
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testBinaryToHexDigitTaking2ArgumentsAndHexDigitMsb0ToBinaryAndBinaryToHexDigitTaking2ArgumentsReturningDigit() throws Throwable  {
        // This test verifies that the conversion from hexadecimal digits to binary representation
        // is performed correctly when the input is a single digit.
        
        // Setup:
        // Create an array of bytes representing the hexadecimal digit 'A'.
        boolean[] arg0 = Conversion.hexDigitMsb0ToBinary('A');
        
        // Exercise:
        // Call the method "binaryToHexDigit" with the input parameter "arg0".
        char binaryToHexDigit = Conversion.binaryToHexDigit(arg0, 0);
        
        // Verify:
        // Assert that the output of the method is equal to the expected value '5'.
        assertEquals('5', binaryToHexDigit);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testHexDigitMsb0ToBinaryAndHexDigitMsb0ToBinaryWithDigit5() throws Throwable  {
        // Test that converting a zero digit in MSB-first order to binary returns the expected result
        boolean[] testHexDigitMsb0ToBinary = Conversion.hexDigitMsb0ToBinary('0');
        assertTrue(Arrays.equals(new boolean[] {false, false, false, false}, testHexDigitMsb0ToBinary));
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testHexDigitToBinaryThrowsIllegalArgumentException0() throws Throwable  {
        // No Comments were added
        // Undeclared exception!
        try { 
          Conversion.hexDigitToBinary('k');
          fail("Expecting exception: IllegalArgumentException");
        
        } catch(IllegalArgumentException e) {
           //
           // Cannot interpret 'k' as a hexadecimal digit
           //
           verifyException("org.apache.commons.lang3.Conversion", e);
        }
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testHexDigitToBinary0() throws Throwable  {
        // Convert a single hexadecimal digit to its binary representation.
        boolean[] hexDigitToBinary = Conversion.hexDigitToBinary('f');
        assertTrue(Arrays.equals(new boolean[] {true, true, true, true}, hexDigitToBinary));
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testHexDigitToBinary1() throws Throwable  {
        // Given: a hexadecimal digit 'd'
        char hexDigit = 'd';
        
        // When: converting the hexadecimal digit to binary
        boolean[] hexDigitToBinary = Conversion.hexDigitToBinary(hexDigit);
        
        // Then: the resulting array should be {true, false, true, true}
        assertTrue(Arrays.equals(new boolean[] {true, false, true, true}, hexDigitToBinary));
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testBinaryBeMsb0ToHexDigitTakingBooleanArrayAndHexDigitToBinary() throws Throwable  {
        // No Comments were added
        boolean[] arg0 = Conversion.hexDigitToBinary('c');
        char binaryBeMsb0ToHexDigit = Conversion.binaryBeMsb0ToHexDigit(arg0);
        assertEquals('3', binaryBeMsb0ToHexDigit);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testHexDigitToBinary2() throws Throwable  {
        // No Comments were added
        boolean[] hexDigitToBinary = Conversion.hexDigitToBinary('b');
        assertTrue(Arrays.equals(new boolean[] {true, true, false, true}, hexDigitToBinary));
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testBinaryToByteThrowsIllegalArgumentException() throws Throwable  {
        // rollbacked to evosuite
        boolean[] arg0 = Conversion.hexDigitToBinary('a');
        // Undeclared exception!
        try { 
          Conversion.binaryToByte(arg0, (-841), (byte) (-124), 53, 53);
          fail("Expecting exception: IllegalArgumentException");
        
        } catch(IllegalArgumentException e) {
           //
           // nBools-1+dstPos is greather or equal to than 8
           //
           verifyException("org.apache.commons.lang3.Conversion", e);
        }
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testHexDigitToBinaryThrowsIllegalArgumentExceptionAndHexDigitToBinaryWithOtherChar0() throws Throwable  {
        // Test that an IllegalArgumentException is thrown when attempting to convert an invalid hexadecimal digit to binary
        try {
        Conversion.hexDigitToBinary('`');
        fail("Expecting exception: IllegalArgumentException");
        } catch (IllegalArgumentException e) {
        // Verify that the exception is of the correct type and has the expected message
        verifyException("org.apache.commons.lang3.Conversion", e);}
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testHexDigitToBinaryThrowsIllegalArgumentExceptionAndHexDigitToBinaryWithOtherChar1() throws Throwable  {
        // Undeclared exception!
        try {
        Conversion.hexDigitToBinary('_');
        fail("Expecting exception: IllegalArgumentException");
        
        } catch(IllegalArgumentException e) {
        //
        // Cannot interpret '_' as a hexadecimal digit
        //
        verifyException("org.apache.commons.lang3.Conversion", e);}
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testHexDigitToBinaryThrowsIllegalArgumentExceptionAndHexDigitToBinaryWithOtherChar2() throws Throwable  {
        // Test that an exception is thrown when passing an invalid hexadecimal digit to the method
        try {
        Conversion.hexDigitToBinary('^');
        fail("Expecting exception: IllegalArgumentException");
        } catch(IllegalArgumentException e) {
        // Verify that the correct exception was thrown
        verifyException("org.apache.commons.lang3.Conversion", e);}
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testHexDigitToBinaryThrowsIllegalArgumentExceptionAndHexDigitToBinaryWithOtherChar3() throws Throwable  {
        // No Comments were added
        // Undeclared exception!
        try { 
          Conversion.hexDigitToBinary(']');
          fail("Expecting exception: IllegalArgumentException");
        
        } catch(IllegalArgumentException e) {
           //
           // Cannot interpret ']' as a hexadecimal digit
           //
           verifyException("org.apache.commons.lang3.Conversion", e);
        }
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testHexDigitToBinaryThrowsIllegalArgumentExceptionAndHexDigitToBinaryWithOtherChar4() throws Throwable  {
        // No Comments were added
        // Undeclared exception!
        try { 
          Conversion.hexDigitToBinary('\\');
          fail("Expecting exception: IllegalArgumentException");
        
        } catch(IllegalArgumentException e) {
           //
           // Cannot interpret '\\' as a hexadecimal digit
           //
           verifyException("org.apache.commons.lang3.Conversion", e);
        }
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testHexDigitToBinaryThrowsIllegalArgumentExceptionAndHexDigitToBinaryWithOtherChar5() throws Throwable  {
        // No Comments were added
        // Undeclared exception!
        try { 
          Conversion.hexDigitToBinary('[');
          fail("Expecting exception: IllegalArgumentException");
        
        } catch(IllegalArgumentException e) {
           //
           // Cannot interpret '[' as a hexadecimal digit
           //
           verifyException("org.apache.commons.lang3.Conversion", e);
        }
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testHexDigitToBinaryThrowsIllegalArgumentExceptionAndHexDigitToBinaryWithAlphabeticChar() throws Throwable  {
        // No Comments were added
        // Undeclared exception!
        try { 
          Conversion.hexDigitToBinary('Z');
          fail("Expecting exception: IllegalArgumentException");
        
        } catch(IllegalArgumentException e) {
           //
           // Cannot interpret 'Z' as a hexadecimal digit
           //
           verifyException("org.apache.commons.lang3.Conversion", e);
        }
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testHexDigitToBinaryThrowsIllegalArgumentException1() throws Throwable  {
        // No Comments were added
        // Undeclared exception!
        try { 
          Conversion.hexDigitToBinary('Y');
          fail("Expecting exception: IllegalArgumentException");
        
        } catch(IllegalArgumentException e) {
           //
           // Cannot interpret 'Y' as a hexadecimal digit
           //
           verifyException("org.apache.commons.lang3.Conversion", e);
        }
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testHexDigitToBinaryThrowsIllegalArgumentException2() throws Throwable  {
        // Test that an exception is thrown when a non-hexadecimal digit is passed as input
        try {
        // Try to convert a non-hexadecimal character ('X') to binary
        Conversion.hexDigitToBinary('X');
        
        // If we reach this point, it means that no exception was thrown, which is unexpected
        fail("Expecting exception: IllegalArgumentException");
        } catch(IllegalArgumentException e) {
        // Verify that the correct exception was thrown
        verifyException("org.apache.commons.lang3.Conversion", e);}
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testHexDigitToBinaryThrowsIllegalArgumentException3() throws Throwable  {
        // No Comments were added
        // Undeclared exception!
        try { 
          Conversion.hexDigitToBinary('W');
          fail("Expecting exception: IllegalArgumentException");
        
        } catch(IllegalArgumentException e) {
           //
           // Cannot interpret 'W' as a hexadecimal digit
           //
           verifyException("org.apache.commons.lang3.Conversion", e);
        }
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testHexDigitToBinaryThrowsIllegalArgumentException4() throws Throwable  {
        // Test that an IllegalArgumentException is thrown when trying to convert a hexadecimal digit that is not recognized
        try {
        Conversion.hexDigitToBinary('V');
        fail("Expecting exception: IllegalArgumentException");
        
        } catch(IllegalArgumentException e) {
        // Verify that the expected exception was thrown
        verifyException("org.apache.commons.lang3.Conversion", e);
        
        // Check that the error message contains the correct information about the invalid hexadecimal digit
        assertEquals("Invalid hexadecimal digit: 'V'", e.getMessage());}
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testHexDigitToBinaryThrowsIllegalArgumentException5() throws Throwable  {
        // Undeclared exception!
        try {
        // Attempting to convert the character 'U' to binary using the hexadecimal digit conversion method
        Conversion.hexDigitToBinary('U');
        // Fail if no exception is thrown
        fail("Expecting exception: IllegalArgumentException");
        } catch(IllegalArgumentException e) {
        // Verifying that the correct exception is thrown with a descriptive message
        verifyException("org.apache.commons.lang3.Conversion", e);}
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testHexDigitToBinaryThrowsIllegalArgumentException6() throws Throwable  {
        // No Comments were added
        // Undeclared exception!
        try { 
          Conversion.hexDigitToBinary('T');
          fail("Expecting exception: IllegalArgumentException");
        
        } catch(IllegalArgumentException e) {
           //
           // Cannot interpret 'T' as a hexadecimal digit
           //
           verifyException("org.apache.commons.lang3.Conversion", e);
        }
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testHexDigitToBinaryThrowsIllegalArgumentException7() throws Throwable  {
        // No Comments were added
        // Undeclared exception!
        try { 
          Conversion.hexDigitToBinary('S');
          fail("Expecting exception: IllegalArgumentException");
        
        } catch(IllegalArgumentException e) {
           //
           // Cannot interpret 'S' as a hexadecimal digit
           //
           verifyException("org.apache.commons.lang3.Conversion", e);
        }
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testHexDigitToBinaryThrowsIllegalArgumentException8() throws Throwable  {
        // Test that an IllegalArgumentException is thrown when a non-hexadecimal digit is passed to hexDigitToBinary() method
        try {
        Conversion.hexDigitToBinary('R');
        fail("Expecting exception: IllegalArgumentException");
        } catch(IllegalArgumentException e) {
        // Verify that the correct exception was thrown
        verifyException("org.apache.commons.lang3.Conversion", e);
        // Verify that the error message is as expected
        assertEquals("Cannot interpret 'R' as a hexadecimal digit", e.getMessage());}
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testHexDigitToBinaryThrowsIllegalArgumentException9() throws Throwable  {
        // No Comments were added
        // Undeclared exception!
        try { 
          Conversion.hexDigitToBinary('Q');
          fail("Expecting exception: IllegalArgumentException");
        
        } catch(IllegalArgumentException e) {
           //
           // Cannot interpret 'Q' as a hexadecimal digit
           //
           verifyException("org.apache.commons.lang3.Conversion", e);
        }
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testHexDigitToBinaryThrowsIllegalArgumentException10() throws Throwable  {
        // Undeclared exception!
        try {
        Conversion.hexDigitToBinary('P');
        fail("Expecting exception: IllegalArgumentException");
        
        } catch(IllegalArgumentException e) {
        //
        // Cannot interpret 'P' as a hexadecimal digit
        //
        verifyException("org.apache.commons.lang3.Conversion", e);}
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testHexDigitToBinaryThrowsIllegalArgumentException11() throws Throwable  {
        // Test that an IllegalArgumentException is thrown when passing an invalid hexadecimal digit to the hexDigitToBinary method
        try {
        Conversion.hexDigitToBinary('O'); // Invalid hexadecimal digit 'O'
        fail("Expecting exception: IllegalArgumentException");
        } catch (IllegalArgumentException e) {
        // Cannot interpret 'O' as a hexadecimal digit
        verifyException("org.apache.commons.lang3.Conversion", e);}
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testHexDigitToBinaryThrowsIllegalArgumentException12() throws Throwable  {
        try {
        Conversion.hexDigitToBinary('N');
        fail("Expecting exception: IllegalArgumentException");
        } catch (IllegalArgumentException e) {
        /*
        * Verifies that the thrown exception is an IllegalArgumentException and has the expected message.
        */
        verifyException("org.apache.commons.lang3.Conversion", e);}
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testHexDigitToBinaryThrowsIllegalArgumentException13() throws Throwable  {
        // No Comments were added
        // Undeclared exception!
        try { 
          Conversion.hexDigitToBinary('M');
          fail("Expecting exception: IllegalArgumentException");
        
        } catch(IllegalArgumentException e) {
           //
           // Cannot interpret 'M' as a hexadecimal digit
           //
           verifyException("org.apache.commons.lang3.Conversion", e);
        }
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testHexDigitToBinaryThrowsIllegalArgumentException14() throws Throwable  {
        // Test that an IllegalArgumentException is thrown when passing a character that cannot be interpreted as a hexadecimal digit to the hexDigitToBinary method of the Conversion class
        try {
        // Act
        Conversion.hexDigitToBinary('L');
        
        // Assert
        fail("Expecting exception: IllegalArgumentException");
        
        } catch(IllegalArgumentException e) {
        // Verify that the correct exception is thrown with the correct message
        verifyException("org.apache.commons.lang3.Conversion", e);}
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testHexDigitToBinaryThrowsIllegalArgumentException15() throws Throwable  {
        // Given a hexadecimal digit 'K' that cannot be converted to a binary value
        try {
        Conversion.hexDigitToBinary('K');
        fail("Expecting exception: IllegalArgumentException");
        } catch(IllegalArgumentException e) {
        // When the method is called with an invalid hexadecimal digit
        // Then an IllegalArgumentException should be thrown indicating that the input cannot be converted to a binary value
        verifyException("org.apache.commons.lang3.Conversion", e);}
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testHexDigitToBinaryThrowsIllegalArgumentException16() throws Throwable  {
        // Test that Conversion.hexDigitToBinary throws IllegalArgumentException for invalid input characters
        try {
        // Try to convert a non-hexadecimal character (J) to binary using Conversion.hexDigitToBinary
        Conversion.hexDigitToBinary('J');
        
        // If the conversion succeeds, fail the test with an error message indicating that we expected it to throw IllegalArgumentException
        fail("Expecting exception: IllegalArgumentException");
        } catch(IllegalArgumentException e) {
        // Verify that the exception is of type IllegalArgumentException
        verifyException("org.apache.commons.lang3.Conversion", e);
        
        // Assert that the message of the exception matches the expected value
        assertEquals("Invalid hexadecimal digit 'J'", e.getMessage());}
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testHexDigitToBinaryThrowsIllegalArgumentException17() throws Throwable  {
        // No Comments were added
        // Undeclared exception!
        try { 
          Conversion.hexDigitToBinary('I');
          fail("Expecting exception: IllegalArgumentException");
        
        } catch(IllegalArgumentException e) {
           //
           // Cannot interpret 'I' as a hexadecimal digit
           //
           verifyException("org.apache.commons.lang3.Conversion", e);
        }
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testHexDigitToBinaryThrowsIllegalArgumentException18() throws Throwable  {
        // No Comments were added
        // Undeclared exception!
        try { 
          Conversion.hexDigitToBinary('H');
          fail("Expecting exception: IllegalArgumentException");
        
        } catch(IllegalArgumentException e) {
           //
           // Cannot interpret 'H' as a hexadecimal digit
           //
           verifyException("org.apache.commons.lang3.Conversion", e);
        }
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testHexDigitToBinaryThrowsIllegalArgumentException19() throws Throwable  {
        // No Comments were added
        // Undeclared exception!
        try { 
          Conversion.hexDigitToBinary('G');
          fail("Expecting exception: IllegalArgumentException");
        
        } catch(IllegalArgumentException e) {
           //
           // Cannot interpret 'G' as a hexadecimal digit
           //
           verifyException("org.apache.commons.lang3.Conversion", e);
        }
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testBinaryToHexDigitTaking2ArgumentsThrowsArrayIndexOutOfBoundsException() throws Throwable  {
        // No Comments were added
        boolean[] arg0 = Conversion.hexDigitToBinary('F');
        // Undeclared exception!
        try { 
          Conversion.binaryToHexDigit(arg0, 15);
          fail("Expecting exception: ArrayIndexOutOfBoundsException");
        
        } catch(ArrayIndexOutOfBoundsException e) {
           //
           // 15
           //
           verifyException("org.apache.commons.lang3.Conversion", e);
        }
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testHexDigitToBinary3() throws Throwable  {
        // No Comments were added
        boolean[] hexDigitToBinary = Conversion.hexDigitToBinary('E');
        assertTrue(Arrays.equals(new boolean[] {false, true, true, true}, hexDigitToBinary));
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testHexDigitToBinary4() throws Throwable  {
        // Convert a single hexadecimal digit to its binary representation.
        boolean[] hexDigitToBinary = Conversion.hexDigitToBinary('D');
        assertEquals(4, hexDigitToBinary.length);
        
        // Verify that the length of the binary array is 4.
        // This is an important check to ensure that the conversion process is correct.
        assertEquals(4, hexDigitToBinary.length);
        
        // Verify that the first element in the binary array is set to true.
        // This indicates that the digit 'D' corresponds to a single bit pattern of 1001 in binary.
        assertTrue(hexDigitToBinary[0]);
        
        // Verify that the second and third elements in the binary array are both false.
        // This indicates that the digit 'D' does not correspond to any bits in positions 2 or 3 of the binary pattern.
        assertFalse(hexDigitToBinary[1]);
        assertFalse(hexDigitToBinary[2]);
        
        // Verify that the fourth element in the binary array is set to true.
        // This indicates that the digit 'D' corresponds to a single bit pattern of 1001 in binary.
        assertTrue(hexDigitToBinary[3]);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testHexDigitToBinary5() throws Throwable  {
        // No Comments were added
        boolean[] hexDigitToBinary = Conversion.hexDigitToBinary('C');
        assertEquals(4, hexDigitToBinary.length);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testBinaryToHexDigitMsb0_4bitsTakingBooleanArrayAndHexDigitToBinary1() throws Throwable  {
        // Tests the conversion from a hexadecimal digit (in this case, 'B') to its binary representation.
        // The result should be the 4-bit binary number representing the hexadecimal digit 'd'.
        boolean[] arg0 = Conversion.hexDigitToBinary('B');
        char binaryToHexDigitMsb0_4bits = Conversion.binaryToHexDigitMsb0_4bits(arg0);
        assertEquals('d', binaryToHexDigitMsb0_4bits);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testHexDigitToBinaryThrowsIllegalArgumentExceptionAndHexDigitToBinaryWithOtherChar6() throws Throwable  {
        // No Comments were added
        // Undeclared exception!
        try { 
          Conversion.hexDigitToBinary('@');
          fail("Expecting exception: IllegalArgumentException");
        
        } catch(IllegalArgumentException e) {
           //
           // Cannot interpret '@' as a hexadecimal digit
           //
           verifyException("org.apache.commons.lang3.Conversion", e);
        }
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testHexDigitToBinaryThrowsIllegalArgumentExceptionAndHexDigitToBinaryWithOtherChar7() throws Throwable  {
        // No Comments were added
        // Undeclared exception!
        try { 
          Conversion.hexDigitToBinary('?');
          fail("Expecting exception: IllegalArgumentException");
        
        } catch(IllegalArgumentException e) {
           //
           // Cannot interpret '?' as a hexadecimal digit
           //
           verifyException("org.apache.commons.lang3.Conversion", e);
        }
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testHexDigitToBinaryThrowsIllegalArgumentExceptionAndHexDigitToBinaryWithOtherChar8() throws Throwable  {
        // Test that an exception is thrown when the input is not a valid hexadecimal digit
        try {
        Conversion.hexDigitToBinary('>');
        fail("Expecting exception: IllegalArgumentException");
        
        } catch(IllegalArgumentException e) {
        verifyException("org.apache.commons.lang3.Conversion", e);}
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testHexDigitToBinaryThrowsIllegalArgumentExceptionAndHexDigitToBinaryWithOtherChar9() throws Throwable  {
        // No Comments were added
        // Undeclared exception!
        try { 
          Conversion.hexDigitToBinary('=');
          fail("Expecting exception: IllegalArgumentException");
        
        } catch(IllegalArgumentException e) {
           //
           // Cannot interpret '=' as a hexadecimal digit
           //
           verifyException("org.apache.commons.lang3.Conversion", e);
        }
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testHexDigitToBinaryThrowsIllegalArgumentExceptionAndHexDigitToBinaryWithOtherChar10() throws Throwable  {
        // No Comments were added
        // Undeclared exception!
        try { 
          Conversion.hexDigitToBinary('<');
          fail("Expecting exception: IllegalArgumentException");
        
        } catch(IllegalArgumentException e) {
           //
           // Cannot interpret '<' as a hexadecimal digit
           //
           verifyException("org.apache.commons.lang3.Conversion", e);
        }
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testHexDigitToBinaryThrowsIllegalArgumentExceptionAndHexDigitToBinaryWithOtherChar11() throws Throwable  {
        // No Comments were added
        // Undeclared exception!
        try { 
          Conversion.hexDigitToBinary(';');
          fail("Expecting exception: IllegalArgumentException");
        
        } catch(IllegalArgumentException e) {
           //
           // Cannot interpret ';' as a hexadecimal digit
           //
           verifyException("org.apache.commons.lang3.Conversion", e);
        }
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testHexDigitToBinaryThrowsIllegalArgumentExceptionAndHexDigitToBinaryWithOtherChar12() throws Throwable  {
        // No Comments were added
        // Undeclared exception!
        try { 
          Conversion.hexDigitToBinary(':');
          fail("Expecting exception: IllegalArgumentException");
        
        } catch(IllegalArgumentException e) {
           //
           // Cannot interpret ':' as a hexadecimal digit
           //
           verifyException("org.apache.commons.lang3.Conversion", e);
        }
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testHexDigitToBinaryAndHexDigitToBinaryWithDigit0() throws Throwable  {
        // Setup
        Conversion conversion = new Conversion();
        
        // Test
        boolean[] hexDigitToBinary = conversion.hexDigitToBinary('9');
        
        // Verify
        assertTrue(Arrays.equals(new boolean[] {true, false, false, true}, hexDigitToBinary));
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testHexDigitToBinaryAndHexDigitToBinaryWithDigit1() throws Throwable  {
        // No Comments were added
        boolean[] hexDigitToBinary = Conversion.hexDigitToBinary('8');
        assertTrue(Arrays.equals(new boolean[] {false, false, false, true}, hexDigitToBinary));
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testBinaryToHexDigitMsb0_4bitsTaking2ArgumentsAndHexDigitToBinary() throws Throwable  {
        // rollbacked to evosuite
        boolean[] arg0 = Conversion.hexDigitToBinary('7');
        char binaryToHexDigitMsb0_4bits = Conversion.binaryToHexDigitMsb0_4bits(arg0, 0);
        assertEquals('e', binaryToHexDigitMsb0_4bits);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testHexDigitToBinaryAndHexDigitToBinaryWithDigit2() throws Throwable  {
        // Test that the conversion from a hex digit to its binary representation is correct
        // The test converts the hex digit '6' to its binary representation and compares it with the expected result
        boolean[] hexDigitToBinary = Conversion.hexDigitToBinary('6');
        assertTrue(Arrays.equals(new boolean[] {false, true, true, false}, hexDigitToBinary));
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testBinaryToHexDigitMsb0_4bitsTakingBooleanArrayAndHexDigitToBinaryAndHexDigitToBinaryWithDigit() throws Throwable  {
        // No Comments were added
        boolean[] arg0 = Conversion.hexDigitToBinary('5');
        char binaryToHexDigitMsb0_4bits = Conversion.binaryToHexDigitMsb0_4bits(arg0);
        assertEquals('a', binaryToHexDigitMsb0_4bits);
        assertEquals(4, arg0.length);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testHexDigitToBinaryAndHexDigitToBinaryWithDigit3() throws Throwable  {
        // No Comments were added
        boolean[] hexDigitToBinary = Conversion.hexDigitToBinary('4');
        assertTrue(Arrays.equals(new boolean[] {false, false, true, false}, hexDigitToBinary));
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testBinaryToIntWithNegative() throws Throwable  {
        boolean[] arg0 = Conversion.hexDigitToBinary('3');
        try {
        // Undeclared exception!
        int result = Conversion.binaryToInt(arg0, -1917, -3385, -1917, 55);
        fail("Expecting exception: ArrayIndexOutOfBoundsException");
        } catch (ArrayIndexOutOfBoundsException e) {
        // The index is invalid
        verifyException("org.apache.commons.lang3.Conversion", e);}
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testBinaryBeMsb0ToHexDigitTakingBooleanArrayAndHexDigitToBinaryAndHexDigitToBinaryWithDigit() throws Throwable  {
        // No Comments were added
        boolean[] arg0 = Conversion.hexDigitToBinary('2');
        char binaryBeMsb0ToHexDigit = Conversion.binaryBeMsb0ToHexDigit(arg0);
        assertEquals('4', binaryBeMsb0ToHexDigit);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testHexDigitToBinaryAndHexDigitToBinaryWithDigit4() throws Throwable  {
        // rollbacked to evosuite
        boolean[] hexDigitToBinary = Conversion.hexDigitToBinary('1');
        assertTrue(Arrays.equals(new boolean[] {true, false, false, false}, hexDigitToBinary));
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testHexDigitToBinaryAndHexDigitToBinaryWithDigit5() throws Throwable  {
        // Test that the conversion from a hexadecimal digit to its binary representation is correct.
        boolean[] hexDigitToBinary = Conversion.hexDigitToBinary('0');
        assertTrue(Arrays.equals(new boolean[] {false, false, false, false}, hexDigitToBinary));
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testHexDigitMsb0ToIntThrowsIllegalArgumentException0() throws Throwable  {
        // No Comments were added
        // Undeclared exception!
        try { 
          Conversion.hexDigitMsb0ToInt('x');
          fail("Expecting exception: IllegalArgumentException");
        
        } catch(IllegalArgumentException e) {
           //
           // Cannot interpret 'x' as a hexadecimal digit
           //
           verifyException("org.apache.commons.lang3.Conversion", e);
        }
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testHexDigitMsb0ToInt0() throws Throwable  {
        // No Comments were added
        int hexDigitMsb0ToInt = Conversion.hexDigitMsb0ToInt('f');
        assertEquals(15, hexDigitMsb0ToInt);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testHexDigitMsb0ToInt1() throws Throwable  {
        // Convert a hex digit to its integer representation with the most significant bit (MSB) first
        int hexDigitMsb0ToInt = Conversion.hexDigitMsb0ToInt('e');
        assertEquals(7, hexDigitMsb0ToInt);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testHexDigitMsb0ToInt2() throws Throwable  {
        // No Comments were added
        int hexDigitMsb0ToInt = Conversion.hexDigitMsb0ToInt('d');
        assertEquals(11, hexDigitMsb0ToInt);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testHexDigitMsb0ToInt3() throws Throwable  {
        // No Comments were added
        int hexDigitMsb0ToInt = Conversion.hexDigitMsb0ToInt('c');
        assertEquals(3, hexDigitMsb0ToInt);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testHexDigitMsb0ToInt4() throws Throwable  {
        // Convert a hexadecimal digit represented as a character to an integer value
        int hexDigitToInt = Conversion.hexDigitToInt('b');
        assertEquals(13, hexDigitToInt); // Assert that the conversion is correct
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testHexDigitMsb0ToIntAndHexDigitMsb0ToIntWithAlphabeticChar0() throws Throwable  {
        // Convert a hexadecimal digit represented as an MSB-first 4-bit nibble to its corresponding integer value.
        int hexDigitMsb0ToInt = Conversion.hexDigitMsb0ToInt('a');
        assertEquals(5, hexDigitMsb0ToInt);
        
        // This test verifies that the 'a' hexadecimal digit is correctly converted to its integer value of 5.
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testHexDigitMsb0ToIntThrowsIllegalArgumentExceptionAndHexDigitMsb0ToIntWithOtherChar0() throws Throwable  {
        // No Comments were added
        // Undeclared exception!
        try { 
          Conversion.hexDigitMsb0ToInt('`');
          fail("Expecting exception: IllegalArgumentException");
        
        } catch(IllegalArgumentException e) {
           //
           // Cannot interpret '`' as a hexadecimal digit
           //
           verifyException("org.apache.commons.lang3.Conversion", e);
        }
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testHexDigitMsb0ToIntThrowsIllegalArgumentExceptionAndHexDigitMsb0ToIntWithOtherChar1() throws Throwable  {
        // Undeclared exception!
        try {
        Conversion.hexDigitMsb0ToInt('_');
        fail("Expecting exception: IllegalArgumentException");
        
        } catch(IllegalArgumentException e) {
        //
        // Cannot interpret '_' as a hexadecimal digit
        //
        verifyException("org.apache.commons.lang3.Conversion", e);}
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testHexDigitMsb0ToIntThrowsIllegalArgumentExceptionAndHexDigitMsb0ToIntWithOtherChar2() throws Throwable  {
        // No Comments were added
        // Undeclared exception!
        try { 
          Conversion.hexDigitMsb0ToInt('^');
          fail("Expecting exception: IllegalArgumentException");
        
        } catch(IllegalArgumentException e) {
           //
           // Cannot interpret '^' as a hexadecimal digit
           //
           verifyException("org.apache.commons.lang3.Conversion", e);
        }
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testHexDigitMsb0ToIntThrowsIllegalArgumentExceptionAndHexDigitMsb0ToIntWithOtherChar3() throws Throwable  {
        // No Comments were added
        // Undeclared exception!
        try { 
          Conversion.hexDigitMsb0ToInt(']');
          fail("Expecting exception: IllegalArgumentException");
        
        } catch(IllegalArgumentException e) {
           //
           // Cannot interpret ']' as a hexadecimal digit
           //
           verifyException("org.apache.commons.lang3.Conversion", e);
        }
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testHexDigitMsb0ToIntThrowsIllegalArgumentExceptionAndHexDigitMsb0ToIntWithOtherChar4() throws Throwable  {
        // Undeclared exception!
        try {
        Conversion.hexDigitMsb0ToInt('\\');
        fail("Expecting exception: IllegalArgumentException");
        
        } catch(IllegalArgumentException e) {
        // Verify that the exception is thrown when trying to convert an invalid hexadecimal digit
        verifyException("org.apache.commons.lang3.Conversion", e);}
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testHexDigitMsb0ToIntThrowsIllegalArgumentExceptionAndHexDigitMsb0ToIntWithOtherChar5() throws Throwable  {
        // No Comments were added
        // Undeclared exception!
        try { 
          Conversion.hexDigitMsb0ToInt('[');
          fail("Expecting exception: IllegalArgumentException");
        
        } catch(IllegalArgumentException e) {
           //
           // Cannot interpret '[' as a hexadecimal digit
           //
           verifyException("org.apache.commons.lang3.Conversion", e);
        }
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testHexDigitMsb0ToIntThrowsIllegalArgumentExceptionAndHexDigitMsb0ToIntWithAlphabeticChar() throws Throwable  {
        // No Comments were added
        // Undeclared exception!
        try { 
          Conversion.hexDigitMsb0ToInt('Z');
          fail("Expecting exception: IllegalArgumentException");
        
        } catch(IllegalArgumentException e) {
           //
           // Cannot interpret 'Z' as a hexadecimal digit
           //
           verifyException("org.apache.commons.lang3.Conversion", e);
        }
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testHexDigitMsb0ToIntThrowsIllegalArgumentException1() throws Throwable  {
        // No Comments were added
        // Undeclared exception!
        try { 
          Conversion.hexDigitMsb0ToInt('Y');
          fail("Expecting exception: IllegalArgumentException");
        
        } catch(IllegalArgumentException e) {
           //
           // Cannot interpret 'Y' as a hexadecimal digit
           //
           verifyException("org.apache.commons.lang3.Conversion", e);
        }
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testHexDigitMsb0ToIntThrowsIllegalArgumentException2() throws Throwable  {
        // No Comments were added
        // Undeclared exception!
        try { 
          Conversion.hexDigitMsb0ToInt('X');
          fail("Expecting exception: IllegalArgumentException");
        
        } catch(IllegalArgumentException e) {
           //
           // Cannot interpret 'X' as a hexadecimal digit
           //
           verifyException("org.apache.commons.lang3.Conversion", e);
        }
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testHexDigitMsb0ToIntThrowsIllegalArgumentException3() throws Throwable  {
        // No Comments were added
        // Undeclared exception!
        try { 
          Conversion.hexDigitMsb0ToInt('W');
          fail("Expecting exception: IllegalArgumentException");
        
        } catch(IllegalArgumentException e) {
           //
           // Cannot interpret 'W' as a hexadecimal digit
           //
           verifyException("org.apache.commons.lang3.Conversion", e);
        }
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testHexDigitMsb0ToIntThrowsIllegalArgumentException4() throws Throwable  {
        // No Comments were added
        // Undeclared exception!
        try { 
          Conversion.hexDigitMsb0ToInt('V');
          fail("Expecting exception: IllegalArgumentException");
        
        } catch(IllegalArgumentException e) {
           //
           // Cannot interpret 'V' as a hexadecimal digit
           //
           verifyException("org.apache.commons.lang3.Conversion", e);
        }
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testHexDigitMsb0ToIntThrowsIllegalArgumentException5() throws Throwable  {
        // No Comments were added
        // Undeclared exception!
        try { 
          Conversion.hexDigitMsb0ToInt('U');
          fail("Expecting exception: IllegalArgumentException");
        
        } catch(IllegalArgumentException e) {
           //
           // Cannot interpret 'U' as a hexadecimal digit
           //
           verifyException("org.apache.commons.lang3.Conversion", e);
        }
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testHexDigitMsb0ToIntThrowsIllegalArgumentException6() throws Throwable  {
        // No Comments were added
        // Undeclared exception!
        try { 
          Conversion.hexDigitMsb0ToInt('T');
          fail("Expecting exception: IllegalArgumentException");
        
        } catch(IllegalArgumentException e) {
           //
           // Cannot interpret 'T' as a hexadecimal digit
           //
           verifyException("org.apache.commons.lang3.Conversion", e);
        }
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testHexDigitMsb0ToIntThrowsIllegalArgumentException7() throws Throwable  {
        // No Comments were added
        // Undeclared exception!
        try { 
          Conversion.hexDigitMsb0ToInt('S');
          fail("Expecting exception: IllegalArgumentException");
        
        } catch(IllegalArgumentException e) {
           //
           // Cannot interpret 'S' as a hexadecimal digit
           //
           verifyException("org.apache.commons.lang3.Conversion", e);
        }
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testHexDigitMsb0ToIntThrowsIllegalArgumentException8() throws Throwable  {
        // Test that an IllegalArgumentException is thrown when trying to convert an invalid hexadecimal digit
        try {
        Conversion.hexDigitMsb0ToInt('R');
        fail("Expected exception: IllegalArgumentException");
        } catch(IllegalArgumentException e) {
        verifyException("org.apache.commons.lang3.Conversion", e);}
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testHexDigitMsb0ToIntThrowsIllegalArgumentException9() throws Throwable  {
        // Test that an IllegalArgumentException is thrown when the input string contains a character that cannot be interpreted as a hexadecimal digit.
        try {
        Conversion.hexDigitMsb0ToInt('Q');
        fail("Expecting exception: IllegalArgumentException");
        } catch (IllegalArgumentException e) {
        verifyException("org.apache.commons.lang3.Conversion", e);}
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testHexDigitMsb0ToIntThrowsIllegalArgumentException10() throws Throwable  {
        // Test that an IllegalArgumentException is thrown when a hexadecimal digit cannot be interpreted
        try {
        // Convert the character 'P' to an integer using the MSB-first (big-endian) method
        Conversion.hexDigitMsb0ToInt('P');
        fail("Expecting exception: IllegalArgumentException");
        } catch(IllegalArgumentException e) {
        // Verify that the correct exception was thrown
        verifyException("org.apache.commons.lang3.Conversion", e);}
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testHexDigitMsb0ToIntThrowsIllegalArgumentException11() throws Throwable  {
        // No Comments were added
        // Undeclared exception!
        try { 
          Conversion.hexDigitMsb0ToInt('O');
          fail("Expecting exception: IllegalArgumentException");
        
        } catch(IllegalArgumentException e) {
           //
           // Cannot interpret 'O' as a hexadecimal digit
           //
           verifyException("org.apache.commons.lang3.Conversion", e);
        }
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testHexDigitMsb0ToIntThrowsIllegalArgumentException12() throws Throwable  {
        // No Comments were added
        // Undeclared exception!
        try { 
          Conversion.hexDigitMsb0ToInt('N');
          fail("Expecting exception: IllegalArgumentException");
        
        } catch(IllegalArgumentException e) {
           //
           // Cannot interpret 'N' as a hexadecimal digit
           //
           verifyException("org.apache.commons.lang3.Conversion", e);
        }
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testHexDigitMsb0ToIntThrowsIllegalArgumentException13() throws Throwable  {
        // No Comments were added
        // Undeclared exception!
        try { 
          Conversion.hexDigitMsb0ToInt('M');
          fail("Expecting exception: IllegalArgumentException");
        
        } catch(IllegalArgumentException e) {
           //
           // Cannot interpret 'M' as a hexadecimal digit
           //
           verifyException("org.apache.commons.lang3.Conversion", e);
        }
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testHexDigitMsb0ToIntThrowsIllegalArgumentException14() throws Throwable  {
        // No Comments were added
        // Undeclared exception!
        try { 
          Conversion.hexDigitMsb0ToInt('L');
          fail("Expecting exception: IllegalArgumentException");
        
        } catch(IllegalArgumentException e) {
           //
           // Cannot interpret 'L' as a hexadecimal digit
           //
           verifyException("org.apache.commons.lang3.Conversion", e);
        }
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testHexDigitMsb0ToIntThrowsIllegalArgumentException15() throws Throwable  {
        // No Comments were added
        // Undeclared exception!
        try { 
          Conversion.hexDigitMsb0ToInt('K');
          fail("Expecting exception: IllegalArgumentException");
        
        } catch(IllegalArgumentException e) {
           //
           // Cannot interpret 'K' as a hexadecimal digit
           //
           verifyException("org.apache.commons.lang3.Conversion", e);
        }
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testHexDigitMsb0ToIntThrowsIllegalArgumentException16() throws Throwable  {
        // Undeclared exception!
        try {
        Conversion.hexDigitMsb0ToInt('J'); // Convert a hexadecimal digit 'J' from MSB-first to LSB-first
        fail("Expecting exception: IllegalArgumentException");
        
        } catch(IllegalArgumentException e) {
        //
        // Cannot interpret 'J' as a hexadecimal digit
        //
        verifyException("org.apache.commons.lang3.Conversion", e);}
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testHexDigitMsb0ToIntThrowsIllegalArgumentException17() throws Throwable  {
        // Test that Conversion.hexDigitMsb0ToInt() throws an exception when passed a non-hexadecimal character.
        try {
        // Try to convert a non-hexadecimal character using Conversion.hexDigitMsb0ToInt().
        Conversion.hexDigitMsb0ToInt('I');
        
        // Assert that an IllegalArgumentException is thrown.
        fail("Expecting exception: IllegalArgumentException");
        } catch(IllegalArgumentException e) {
        // Verify that the correct exception is thrown.
        verifyException("org.apache.commons.lang3.Conversion", e);
        
        // Assert that the exception message contains the expected information.
        assertEquals("The character 'I' cannot be interpreted as a hexadecimal digit.", e.getMessage());}
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testHexDigitMsb0ToIntThrowsIllegalArgumentException18() throws Throwable  {
        // No Comments were added
        // Undeclared exception!
        try { 
          Conversion.hexDigitMsb0ToInt('H');
          fail("Expecting exception: IllegalArgumentException");
        
        } catch(IllegalArgumentException e) {
           //
           // Cannot interpret 'H' as a hexadecimal digit
           //
           verifyException("org.apache.commons.lang3.Conversion", e);
        }
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testHexDigitMsb0ToIntThrowsIllegalArgumentException19() throws Throwable  {
        // Test that Conversion.hexDigitMsb0ToInt() throws an IllegalArgumentException if the input character cannot be interpreted as a hexadecimal digit.
        try {
        // The following line should throw an IllegalArgumentException because 'G' is not a valid hexadecimal digit.
        Conversion.hexDigitMsb0ToInt('G');
        
        // If the previous line did not throw an exception, this fail() method call will cause the test to fail.
        fail("Expecting exception: IllegalArgumentException");
        
        } catch(IllegalArgumentException e) {
        // This verifyException() method call is used to verify that the correct type of exception was thrown and that the message contained the expected value.
        verifyException("org.apache.commons.lang3.Conversion", e);}
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testHexDigitMsb0ToInt5() throws Throwable  {
        // No Comments were added
        int hexDigitMsb0ToInt = Conversion.hexDigitMsb0ToInt('E');
        assertEquals(7, hexDigitMsb0ToInt);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testHexDigitMsb0ToInt6() throws Throwable  {
        // No Comments were added
        int hexDigitMsb0ToInt = Conversion.hexDigitMsb0ToInt('D');
        assertEquals(11, hexDigitMsb0ToInt);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testHexDigitMsb0ToInt7() throws Throwable  {
        // Tests the conversion of a single hexadecimal digit (MSB-first) to its integer value
        int hexDigitMsb0ToInt = Conversion.hexDigitMsb0ToInt('C');
        assertEquals(3, hexDigitMsb0ToInt);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testHexDigitMsb0ToInt8() throws Throwable  {
        // No Comments were added
        int hexDigitMsb0ToInt = Conversion.hexDigitMsb0ToInt('B');
        assertEquals(13, hexDigitMsb0ToInt);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testHexDigitMsb0ToIntAndHexDigitMsb0ToIntWithAlphabeticChar1() throws Throwable  {
        // Convert the hexadecimal digit 'A' to its integer representation in big endian format
        int actualValue = Conversion.hexDigitMsb0ToInt('A');
        
        // Verify that the converted value is 5
        assertEquals(5, actualValue);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testHexDigitMsb0ToIntThrowsIllegalArgumentExceptionAndHexDigitMsb0ToIntWithOtherChar6() throws Throwable  {
        // No Comments were added
        // Undeclared exception!
        try { 
          Conversion.hexDigitMsb0ToInt('@');
          fail("Expecting exception: IllegalArgumentException");
        
        } catch(IllegalArgumentException e) {
           //
           // Cannot interpret '@' as a hexadecimal digit
           //
           verifyException("org.apache.commons.lang3.Conversion", e);
        }
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testHexDigitMsb0ToIntThrowsIllegalArgumentExceptionAndHexDigitMsb0ToIntWithOtherChar7() throws Throwable  {
        // No Comments were added
        // Undeclared exception!
        try { 
          Conversion.hexDigitMsb0ToInt('?');
          fail("Expecting exception: IllegalArgumentException");
        
        } catch(IllegalArgumentException e) {
           //
           // Cannot interpret '?' as a hexadecimal digit
           //
           verifyException("org.apache.commons.lang3.Conversion", e);
        }
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testHexDigitMsb0ToIntThrowsIllegalArgumentExceptionAndHexDigitMsb0ToIntWithOtherChar8() throws Throwable  {
        // No Comments were added
        // Undeclared exception!
        try { 
          Conversion.hexDigitMsb0ToInt('>');
          fail("Expecting exception: IllegalArgumentException");
        
        } catch(IllegalArgumentException e) {
           //
           // Cannot interpret '>' as a hexadecimal digit
           //
           verifyException("org.apache.commons.lang3.Conversion", e);
        }
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testHexDigitMsb0ToIntThrowsIllegalArgumentExceptionAndHexDigitMsb0ToIntWithOtherChar9() throws Throwable  {
        // Test that Conversion.hexDigitMsb0ToInt() throws an IllegalArgumentException when passed a non-hexadecimal character
        try {
        // Pass a single character string '=' which is not a hexadecimal digit
        Conversion.hexDigitMsb0ToInt('=');
        fail("Expecting exception: IllegalArgumentException");
        } catch(IllegalArgumentException e) {
        // Verify that the correct exception was thrown
        verifyException("org.apache.commons.lang3.Conversion", e);
        
        // Verify that the error message is as expected
        assertEquals("The character '=' is not a valid hexadecimal digit", e.getMessage());}
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testHexDigitMsb0ToIntThrowsIllegalArgumentExceptionAndHexDigitMsb0ToIntWithOtherChar10() throws Throwable  {
        // No Comments were added
        // Undeclared exception!
        try { 
          Conversion.hexDigitMsb0ToInt('<');
          fail("Expecting exception: IllegalArgumentException");
        
        } catch(IllegalArgumentException e) {
           //
           // Cannot interpret '<' as a hexadecimal digit
           //
           verifyException("org.apache.commons.lang3.Conversion", e);
        }
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testHexDigitMsb0ToIntThrowsIllegalArgumentExceptionAndHexDigitMsb0ToIntWithOtherChar11() throws Throwable  {
        // No Comments were added
        // Undeclared exception!
        try { 
          Conversion.hexDigitMsb0ToInt(';');
          fail("Expecting exception: IllegalArgumentException");
        
        } catch(IllegalArgumentException e) {
           //
           // Cannot interpret ';' as a hexadecimal digit
           //
           verifyException("org.apache.commons.lang3.Conversion", e);
        }
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testHexDigitMsb0ToIntThrowsIllegalArgumentExceptionAndHexDigitMsb0ToIntWithOtherChar12() throws Throwable  {
        // No Comments were added
        // Undeclared exception!
        try { 
          Conversion.hexDigitMsb0ToInt(':');
          fail("Expecting exception: IllegalArgumentException");
        
        } catch(IllegalArgumentException e) {
           //
           // Cannot interpret ':' as a hexadecimal digit
           //
           verifyException("org.apache.commons.lang3.Conversion", e);
        }
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testHexDigitMsb0ToIntAndHexDigitMsb0ToIntWithDigit0() throws Throwable  {
        // Test the conversion of a hexadecimal digit (MSB-first) to an integer
        int hexDigitMsb0ToInt = Conversion.hexDigitMsb0ToInt('9');
        assertEquals(9, hexDigitMsb0ToInt);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testHexDigitMsb0ToIntAndHexDigitMsb0ToIntWithDigit1() throws Throwable  {
        // No Comments were added
        int hexDigitMsb0ToInt = Conversion.hexDigitMsb0ToInt('8');
        assertEquals(1, hexDigitMsb0ToInt);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testHexDigitMsb0ToIntAndHexDigitMsb0ToIntWithDigit2() throws Throwable  {
        // No Comments were added
        int hexDigitMsb0ToInt = Conversion.hexDigitMsb0ToInt('7');
        assertEquals(14, hexDigitMsb0ToInt);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testHexDigitMsb0ToIntAndHexDigitMsb0ToIntWithDigit3() throws Throwable  {
        // Test the conversion of a hex digit to its integer representation (most significant bit first)
        int hexDigitMsb0ToInt = Conversion.hexDigitMsb0ToInt('6');
        assertEquals(6, hexDigitMsb0ToInt);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testHexDigitMsb0ToIntAndHexDigitMsb0ToIntWithDigit4() throws Throwable  {
        // Convert a hexadecimal digit from MSB 0 to an integer value.
        int hexDigit = Conversion.hexDigitMsb0ToInt('5');
        assertEquals(10, hexDigit);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testHexDigitMsb0ToIntAndHexDigitMsb0ToIntWithDigit5() throws Throwable  {
        // Test case for converting a hexadecimal digit (most significant bit first) to an integer
        int hexDigitMsb0ToInt = Conversion.hexDigitMsb0ToInt('4');
        assertEquals(2, hexDigitMsb0ToInt); // The most significant bit of the hex digit 4 is 1, so the result should be 2
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testHexDigitMsb0ToIntAndHexDigitMsb0ToIntWithDigit6() throws Throwable  {
        // Convert a hexadecimal digit character to its corresponding integer value, with the most significant bit first.
        int hexDigitMsb0ToInt = Conversion.hexDigitMsb0ToInt('3');
        assertEquals(12, hexDigitMsb0ToInt);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testHexDigitMsb0ToIntAndHexDigitMsb0ToIntWithDigit7() throws Throwable  {
        // Convert the hex digit '2' to an integer value with most significant bit (MSB) order, which is 4.
        int hexDigitMsb0ToInt = Conversion.hexDigitMsb0ToInt('2');
        assertEquals(4, hexDigitMsb0ToInt);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testHexDigitMsb0ToIntAndHexDigitMsb0ToIntWithDigit8() throws Throwable  {
        // Convert a hex digit from most significant bit 0 to an integer value
        int result = Conversion.hexDigitMsb0ToInt('1');
        assertEquals(8, result);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testHexDigitMsb0ToInt9() throws Throwable  {
        int hexDigitMsb0ToInt = Conversion.hexDigitMsb0ToInt('F');
        assertEquals(15, hexDigitMsb0ToInt);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testHexDigitMsb0ToIntReturningZero() throws Throwable  {
        // Convert a hex digit from MSB-first order to integer representation
        int hexDigit = Conversion.hexDigitMsb0ToInt('0');
        assertEquals(0, hexDigit);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testHexDigitToIntThrowsIllegalArgumentException() throws Throwable  {
        // No Comments were added
        // Undeclared exception!
        try { 
          Conversion.hexDigitToInt('(');
          fail("Expecting exception: IllegalArgumentException");
        
        } catch(IllegalArgumentException e) {
           //
           // Cannot interpret '(' as a hexadecimal digit
           //
           verifyException("org.apache.commons.lang3.Conversion", e);
        }
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testHexDigitToIntReturningPositive() throws Throwable  {
        // No Comments were added
        int hexDigitToInt = Conversion.hexDigitToInt('F');
        assertEquals(15, hexDigitToInt);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testCreatesConversion() throws Throwable  {
        // rollbacked to evosuite
        Conversion conversion = new Conversion();
    }
  }
  