content: /*
   * This file was automatically generated by UTestGen and EvoSuite
   * Tue Mar 19 17:09:54 GMT 2024
   */
  
  package org.apache.commons.math3.analysis.interpolation;
  
  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 org.apache.commons.math3.analysis.interpolation.TricubicSplineInterpolatingFunction;
  import org.evosuite.runtime.EvoRunner;
  import org.evosuite.runtime.EvoRunnerParameters;
  import org.junit.runner.RunWith;
  
  @RunWith(EvoRunner.class) @EvoRunnerParameters(mockJVMNonDeterminism = true, useVFS = true, useVNET = true, resetStaticState = true, separateClassLoader = true) 
  public class TricubicSplineInterpolatingFunction_ESTest extends TricubicSplineInterpolatingFunction_ESTest_scaffolding {
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testValueReturningZero() throws Throwable  {
        // Arrange
        double[] arg2 = new double[]{ -10.7387077629512 };
        double[][][] arg10 = new double[2][3][4];
        double[][] doubleArray = new double[2][8];
        doubleArray[0] = arg2;
        arg10[0] = doubleArray;
        TricubicSplineInterpolatingFunction tricubicSplineInterpolatingFunction = new TricubicSplineInterpolatingFunction(arg2, arg2, arg2, arg10, arg10, arg10, arg10, arg10, arg10, arg10, arg10);
        
        // Act
        double value = tricubicSplineInterpolatingFunction.value(-10.7387077629512, -10.7387077629512, 0.0);
        
        // Assert
        assertEquals(-104.581136655117, value, 0.01);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testValueReturningPositive() throws Throwable  {
        // Test for TricubicSplineInterpolatingFunction class
        
        // Arrange: set up the test data and function arguments
        double[] arg2 = new double[2]; // x-coordinates of the knots
        arg2[0] = (-10.7387077629512);
        double[][][] arg10 = new double[2][3][4]; // values at each knot
        double[][] doubleArray = new double[2][8];
        doubleArray[0] = arg2;
        arg10[0] = doubleArray;
        TricubicSplineInterpolatingFunction tricubicSplineInterpolatingFunction = new TricubicSplineInterpolatingFunction(arg2, arg2, arg2, arg10, arg10, arg10, arg10, arg10, arg10, arg10, arg10);
        
        // Act: evaluate the function at a specific point
        double value = tricubicSplineInterpolatingFunction.value(0.0, (-1.0), (-10.7387077629512));
        
        // Assert: check that the function returns the expected value within a tolerance of 0.01
        assertEquals(3390.566091834736, value, 0.01);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testValueWithPositiveAndNegative() throws Throwable  {
        // Given a TricubicSplineInterpolatingFunction instance with valid arguments
        double[] arg2 = new double[2];
        arg2[0] = (-10.7387077629512);
        double[][][] arg10 = new double[2][3][4];
        double[][] doubleArray = new double[2][8];
        doubleArray[0] = arg2;
        arg10[0] = doubleArray;
        TricubicSplineInterpolatingFunction tricubicSplineInterpolatingFunction = new TricubicSplineInterpolatingFunction(arg2, arg2, arg2, arg10, arg10, arg10, arg10, arg10, arg10, arg10, arg10);
        
        // When trying to evaluate the function at a point outside of the defined range
        try {
        tricubicSplineInterpolatingFunction.value((-10.7387077629512), (-1.0), 3.834E-20);
        fail("Expecting exception: IllegalArgumentException");
        } catch(IllegalArgumentException e) {
        // Then an IllegalArgumentException is thrown with a message indicating that the point is outside of the defined range
        verifyException("org.apache.commons.math3.analysis.interpolation.TricubicSplineInterpolatingFunction", e);}
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testValueWithNegative() throws Throwable  {
        // Test that the TricubicSplineInterpolatingFunction throws an IllegalArgumentException when the input arguments are out of range
        double[] arg2 = new double[2];
        arg2[0] = (-12.969768518315961);
        double[][][] arg10 = new double[2][3][4];
        double[][] doubleArray = new double[2][8];
        doubleArray[0] = arg2;
        arg10[0] = doubleArray;
        TricubicSplineInterpolatingFunction tricubicSplineInterpolatingFunction = new TricubicSplineInterpolatingFunction(arg2, arg2, arg2, arg10, arg10, arg10, arg10, arg10, arg10, arg10, arg10);
        try {
        tricubicSplineInterpolatingFunction.value((-12.969768518315961), (-726.0), (-726.0));
        fail("Expecting exception: IllegalArgumentException");
        
        } catch(IllegalArgumentException e) {
        //
        // -726 out of [-12.97, 0] range
        //
        verifyException("org.apache.commons.math3.analysis.interpolation.TricubicSplineInterpolatingFunction", e);}
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testValueWithPositiveAndPositive() throws Throwable  {
        // Given a TricubicSplineInterpolatingFunction object with the following parameters:
        double[] arg2 = new double[2];
        arg2[0] = (-10.7387077629512);
        double[][][] arg10 = new double[2][3][4];
        double[][] doubleArray = new double[2][8];
        doubleArray[0] = arg2;
        arg10[0] = doubleArray;
        TricubicSplineInterpolatingFunction tricubicSplineInterpolatingFunction = new TricubicSplineInterpolatingFunction(arg2, arg2, arg2, arg10, arg10, arg10, arg10, arg10, arg10, arg10, arg10);
        
        // When the value method is called with a point outside of the valid range for the interpolator
        tricubicSplineInterpolatingFunction.value(1782.399, (-10.7387077629512), 1.34217729E8);
        
        // Then an IllegalArgumentException is thrown with the message "x out of [-10.739, 0] range"
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testCreatesTricubicSplineInterpolatingFunction0() throws Throwable  {
        double[] arg2 = new double[2];
        arg2[0] = (-12.969768518315961);
        double[][][] arg10 = new double[2][3][4];
        double[][] doubleArray = new double[2][8];
        doubleArray[0] = arg2;
        arg10[0] = doubleArray;
        double[][][] arg6 = new double[2][2][4];
        TricubicSplineInterpolatingFunction tricubicSplineInterpolatingFunction = null;
        try {
        // Given: an input array with a size of 2, and another input array with a size of 8
        // When: constructing a TricubicSplineInterpolatingFunction object
        // Then: expect an IllegalArgumentException to be thrown, as the number of data points is not compatible with the desired interpolation method
        tricubicSplineInterpolatingFunction = new TricubicSplineInterpolatingFunction(arg2, arg2, arg2, arg10, arg10, arg10, arg6, arg10, arg10, arg10, arg10);
        fail("Expecting exception: IllegalArgumentException");
        
        } catch(IllegalArgumentException e) {
        // Verify that the exception is indeed an IllegalArgumentException with a message indicating that the number of data points is not compatible with the desired interpolation method
        verifyException("org.apache.commons.math3.analysis.interpolation.TricubicSplineInterpolatingFunction", e);}
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testCreatesTricubicSplineInterpolatingFunction1() throws Throwable  {
        // Given
        double[] arg2 = new double[2];
        arg2[1] = 1.3421772722816654E8;
        double[][][] arg8 = new double[2][2][4];
        double[][][] arg10 = new double[2][5][3];
        double[][] doubleArray = new double[2][9];
        doubleArray[0] = arg2;
        arg10[0] = doubleArray;
        
        // When
        TricubicSplineInterpolatingFunction tricubicSplineInterpolatingFunction = null;
        try {
        tricubicSplineInterpolatingFunction = new TricubicSplineInterpolatingFunction(arg2, arg2, arg2, arg10, arg8, arg8, arg10, arg8, arg8, arg10, arg10);
        } catch (IllegalArgumentException e) {
        // Then
        verifyException("org.apache.commons.math3.analysis.interpolation.TricubicSplineInterpolatingFunction", e);}
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testCreatesTricubicSplineInterpolatingFunction2() throws Throwable  {
        // Given: A TricubicSplineInterpolatingFunction object with three input arguments of different lengths
        double[] arg2 = new double[2];
        arg2[0] = (-12.969768518315961);
        double[][][] arg10 = new double[2][2][4];
        
        // When: The TricubicSplineInterpolatingFunction object is created with the input arguments
        TricubicSplineInterpolatingFunction tricubicSplineInterpolatingFunction = null;
        try {
        tricubicSplineInterpolatingFunction = new TricubicSplineInterpolatingFunction(arg2, arg2, arg2, arg10, arg10, arg10, arg10, arg10, arg10, arg10, arg10);
        } catch(IllegalArgumentException e) {
        // Then: An IllegalArgumentException is thrown because the lengths of the input arguments are not equal
        verifyException("org.apache.commons.math3.analysis.interpolation.TricubicSplineInterpolatingFunction", e);}
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testCreatesTricubicSplineInterpolatingFunction3() throws Throwable  {
        // rollbacked to evosuite
        double[] arg2 = new double[2];
        arg2[0] = (-12.0);
        double[][][] arg9 = new double[2][3][4];
        double[][] doubleArray = new double[2][8];
        arg9[0] = doubleArray;
        double[][][] arg10 = new double[2][7][7];
        TricubicSplineInterpolatingFunction tricubicSplineInterpolatingFunction = null;
        try {
          tricubicSplineInterpolatingFunction = new TricubicSplineInterpolatingFunction(arg2, arg2, arg2, arg9, arg9, arg9, arg9, arg9, arg9, arg9, arg10);
          fail("Expecting exception: IllegalArgumentException");
        
        } catch(IllegalArgumentException e) {
           //
           // 7 != 2
           //
           verifyException("org.apache.commons.math3.analysis.interpolation.TricubicSplineInterpolatingFunction", e);
        }
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testCreatesTricubicSplineInterpolatingFunction4() throws Throwable  {
        // Given
        double[] arg2 = new double[2];
        arg2[0] = (-14.91721436163668);
        double[][][] arg10 = new double[2][2][4];
        double[][][] arg9 = new double[2][9][6];
        
        // When
        TricubicSplineInterpolatingFunction tricubicSplineInterpolatingFunction = null;
        try {
        tricubicSplineInterpolatingFunction = new TricubicSplineInterpolatingFunction(arg2, arg2, arg2, arg10, arg10, arg10, arg10, arg10, arg10, arg9, arg10);
        fail("Expecting exception: IllegalArgumentException");
        } catch (IllegalArgumentException e) {
        // Then
        verifyException("org.apache.commons.math3.analysis.interpolation.TricubicSplineInterpolatingFunction", e);}
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testCreatesTricubicSplineInterpolatingFunction5() throws Throwable  {
        // Given
        double[] arg2 = new double[2];
        arg2[0] = (-63.332210765260804);
        double[][][] arg10 = new double[2][3][4];
        double[][] doubleArray = new double[2][8];
        arg10[0] = doubleArray;
        double[][][] arg8 = new double[2][3][4];
        
        // When / Then
        assertThrows(IllegalArgumentException.class, () -> {
        TricubicSplineInterpolatingFunction tricubicSplineInterpolatingFunction = new TricubicSplineInterpolatingFunction(arg2, arg2, arg2, arg10, arg10, arg10, arg10, arg10, arg8, arg10, arg10);});
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testCreatesTricubicSplineInterpolatingFunction6() throws Throwable  {
        // Given: a set of input parameters for the TricubicSplineInterpolatingFunction constructor
        double[] arg2 = new double[2];
        arg2[0] = (-4.3089023491316265);
        double[][][] arg10 = new double[2][7][4];
        double[][] doubleArray = new double[2][8];
        arg10[0] = doubleArray;
        double[][][] arg7 = new double[2][7][4];
        
        // When: the TricubicSplineInterpolatingFunction is created with these parameters
        TricubicSplineInterpolatingFunction tricubicSplineInterpolatingFunction = null;
        try {
        tricubicSplineInterpolatingFunction = new TricubicSplineInterpolatingFunction(arg2, arg2, arg2, arg10, arg10, arg10, arg10, arg7, arg10, arg10, arg10);
        } catch(IllegalArgumentException e) {
        // Then: an IllegalArgumentException is thrown because the number of data points does not match the expected number of data points for this type of interpolation
        verifyException("org.apache.commons.math3.analysis.interpolation.TricubicSplineInterpolatingFunction", e);}
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testCreatesTricubicSplineInterpolatingFunction7() throws Throwable  {
        // Initialize input arguments for the TricubicSplineInterpolatingFunction constructor
        double[] arg2 = new double[2];
        arg2[0] = (-7.8448955291);
        double[][][] arg10 = new double[2][3][4];
        double[][] doubleArray = new double[2][8];
        double[][][] arg9 = new double[2][3][5];
        arg9[0] = doubleArray;
        
        // Initialize the TricubicSplineInterpolatingFunction object
        TricubicSplineInterpolatingFunction tricubicSplineInterpolatingFunction = null;
        
        // Try to create a new TricubicSplineInterpolatingFunction instance with invalid data
        try {
        tricubicSplineInterpolatingFunction = new TricubicSplineInterpolatingFunction(arg2, arg2, arg2, arg9, arg9, arg9, arg10, arg10, arg9, arg9, arg10);
        } catch (IllegalArgumentException e) {
        // Verify that the expected exception was thrown
        assertTrue(e instanceof IllegalArgumentException);
        assertEquals("The number of arguments must be equal to the number of data points.", e.getMessage());
        } finally {
        // Ensure that the TricubicSplineInterpolatingFunction object is null
        assertNull(tricubicSplineInterpolatingFunction);}
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testCreatesTricubicSplineInterpolatingFunction8() throws Throwable  {
        // Given a 2D array of double values representing the coordinates of the points in a tricubic spline interpolation
        double[] arg2 = new double[2];
        arg2[0] = -14.204785581044943;
        
        // Given a 3D array of double values representing the values at each point in the tricubic spline interpolation
        double[][][] arg9 = new double[2][3][4];
        
        // Given a 2D array of double values representing the coordinates of the points in a tricubic spline interpolation
        double[][] doubleArray = new double[2][8];
        
        // Given a 3D array of double values representing the values at each point in the tricubic spline interpolation
        double[][][] arg10 = new double[2][5][9];
        
        // When we create a TricubicSplineInterpolatingFunction using these coordinates and values
        TricubicSplineInterpolatingFunction tricubicSplineInterpolatingFunction = null;
        try {
        tricubicSplineInterpolatingFunction = new TricubicSplineInterpolatingFunction(arg2, arg2, arg2, arg10, arg10, arg9, arg10, arg10, arg9, arg9, arg10);
        } catch (IllegalArgumentException e) {
        // Then we expect an IllegalArgumentException to be thrown because the length of the array of coordinates is not equal to 2
        verifyException("org.apache.commons.math3.analysis.interpolation.TricubicSplineInterpolatingFunction", e);}
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testCreatesTricubicSplineInterpolatingFunction9() throws Throwable  {
        // Test that the constructor throws an exception when the input arrays have different dimensions
        double[] arg2 = new double[2];
        arg2[0] = -11.129996266919894;
        double[][][] arg10 = new double[2][3][4];
        double[][] doubleArray = new double[2][8];
        arg10[0] = doubleArray;
        double[][][] arg7 = new double[2][9][4];
        
        TricubicSplineInterpolatingFunction tricubicSplineInterpolatingFunction = null;
        try {
        tricubicSplineInterpolatingFunction = new TricubicSplineInterpolatingFunction(arg2, arg2, arg2, arg10, arg7, arg10, arg7, arg7, arg10, arg10, arg10);
        fail("Expecting exception: IllegalArgumentException");
        } catch (IllegalArgumentException e) {
        // Verify that the expected exception was thrown
        verifyException("org.apache.commons.math3.analysis.interpolation.TricubicSplineInterpolatingFunction", e);}
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testCreatesTricubicSplineInterpolatingFunction10() throws Throwable  {
        // rollbacked to evosuite
        double[] arg2 = new double[2];
        arg2[0] = (-10.7387077629512);
        double[][][] arg10 = new double[2][3][4];
        TricubicSplineInterpolatingFunction tricubicSplineInterpolatingFunction = null;
        try {
          tricubicSplineInterpolatingFunction = new TricubicSplineInterpolatingFunction(arg2, arg2, arg2, arg10, arg10, arg10, arg10, arg10, arg10, arg10, arg10);
          fail("Expecting exception: IllegalArgumentException");
        
        } catch(IllegalArgumentException e) {
           //
           // 3 != 2
           //
           verifyException("org.apache.commons.math3.analysis.interpolation.TricubicSplineInterpolatingFunction", e);
        }
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testValueReturningNegative() throws Throwable  {
        // rollbacked to evosuite
        double[] arg2 = new double[2];
        arg2[0] = (-10.7387077629512);
        double[][][] arg10 = new double[2][3][4];
        double[][] doubleArray = new double[2][8];
        doubleArray[0] = arg2;
        arg10[0] = doubleArray;
        TricubicSplineInterpolatingFunction tricubicSplineInterpolatingFunction = new TricubicSplineInterpolatingFunction(arg2, arg2, arg2, arg10, arg10, arg10, arg10, arg10, arg10, arg10, arg10);
        double value = tricubicSplineInterpolatingFunction.value((-10.7387077629512), (-10.7387077629512), (-10.7387077629512));
        assertEquals((-10.7387077629512), value, 0.01);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testCreatesTricubicSplineInterpolatingFunction11() throws Throwable  {
        // Given a set of points with 9 rows and 7 columns
        double[] arg2 = new double[9];
        double[][][] arg9 = new double[9][3][4];
        double[][][] arg10 = new double[7][0][6];
        
        // When trying to create a tricubic spline interpolating function with these points
        TricubicSplineInterpolatingFunction tricubicSplineInterpolatingFunction = null;
        try {
        tricubicSplineInterpolatingFunction = new TricubicSplineInterpolatingFunction(arg2, arg2, arg2, arg9, arg9, arg9, arg9, arg9, arg9, arg9, arg10);
        fail("Expecting exception: IllegalArgumentException");
        } catch (IllegalArgumentException e) {
        // Then the constructor should throw an IllegalArgumentException because 9 != 7
        verifyException("org.apache.commons.math3.analysis.interpolation.TricubicSplineInterpolatingFunction", e);}
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testCreatesTricubicSplineInterpolatingFunction12() throws Throwable  {
        // Given
        double[] arg2 = new double[2];
        double[][][] arg8 = new double[2][3][4];
        double[][][] arg10 = new double[0][6][5];
        
        // When
        TricubicSplineInterpolatingFunction tricubicSplineInterpolatingFunction = null;
        try {
        tricubicSplineInterpolatingFunction = new TricubicSplineInterpolatingFunction(arg2, arg2, arg2, arg8, arg8, arg8, arg8, arg8, arg8, arg10, arg10);
        } catch (IllegalArgumentException e) {
        // Then
        verifyException("org.apache.commons.math3.analysis.interpolation.TricubicSplineInterpolatingFunction", e);}
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testCreatesTricubicSplineInterpolatingFunction13() throws Throwable  {
        // Given
        double[] arg2 = new double[5];
        double[][][] arg10 = new double[5][2][1];
        double[][][] arg8 = new double[0][4][9];
        
        // When
        TricubicSplineInterpolatingFunction tricubicSplineInterpolatingFunction = null;
        try {
        tricubicSplineInterpolatingFunction = new TricubicSplineInterpolatingFunction(arg2, arg2, arg2, arg10, arg10, arg10, arg10, arg10, arg8, arg10, arg10);
        fail("Expecting exception: IllegalArgumentException");
        } catch (IllegalArgumentException e) {
        // Then
        verifyException("org.apache.commons.math3.analysis.interpolation.TricubicSplineInterpolatingFunction", e);}
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testCreatesTricubicSplineInterpolatingFunction14() throws Throwable  {
        // Setup
        double[] arg2 = new double[1];
        double[][][] arg10 = new double[1][4][4];
        double[][][] arg9 = new double[0][7][7];
        
        // Test
        TricubicSplineInterpolatingFunction tricubicSplineInterpolatingFunction = null;
        try {
        tricubicSplineInterpolatingFunction = new TricubicSplineInterpolatingFunction(arg2, arg2, arg2, arg10, arg10, arg10, arg10, arg9, arg9, arg9, arg10);
        fail("Expecting exception: IllegalArgumentException");
        } catch(IllegalArgumentException e) {
        // 1 != 0
        verifyException("org.apache.commons.math3.analysis.interpolation.TricubicSplineInterpolatingFunction", e);}
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testCreatesTricubicSplineInterpolatingFunction15() throws Throwable  {
        // Given: A TricubicSplineInterpolatingFunction instance is created with valid arguments.
        double[] arg2 = new double[2];
        double[][][] arg9 = new double[2][2][4];
        double[][][] arg10 = new double[0][4][7];
        TricubicSplineInterpolatingFunction tricubicSplineInterpolatingFunction = null;
        try {
        // When: The TricubicSplineInterpolatingFunction is created with valid arguments.
        tricubicSplineInterpolatingFunction = new TricubicSplineInterpolatingFunction(arg2, arg2, arg2, arg9, arg9, arg9, arg10, arg10, arg9, arg9, arg10);
        } catch(IllegalArgumentException e) {
        // Then: An IllegalArgumentException is thrown.
        fail("Expecting exception: IllegalArgumentException");}
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testCreatesTricubicSplineInterpolatingFunction16() throws Throwable  {
        // Given
        double[] arg2 = new double[9];
        double[][][] arg7 = new double[9][3][4];
        double[][][] arg10 = new double[0][4][1];
        
        // When
        TricubicSplineInterpolatingFunction tricubicSplineInterpolatingFunction = new TricubicSplineInterpolatingFunction(arg2, arg2, arg2, arg7, arg7, arg10, arg7, arg7, arg10, arg10, arg10);
        
        // Then
        fail("Expecting exception: IllegalArgumentException");
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testCreatesTricubicSplineInterpolatingFunction17() throws Throwable  {
        // Test that the constructor throws an exception when the arrays have different lengths.
        double[] arg2 = new double[5];
        double[][][] arg10 = new double[5][2][1];
        double[][][] arg9 = new double[0][7][3];
        TricubicSplineInterpolatingFunction tricubicSplineInterpolatingFunction = null;
        try {
        tricubicSplineInterpolatingFunction = new TricubicSplineInterpolatingFunction(arg2, arg2, arg2, arg10, arg9, arg10, arg10, arg9, arg10, arg9, arg10);
        fail("Expecting exception: IllegalArgumentException");
        } catch (IllegalArgumentException e) {
        // The arrays have different lengths.
        verifyException("org.apache.commons.math3.analysis.interpolation.TricubicSplineInterpolatingFunction", e);}
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testCreatesTricubicSplineInterpolatingFunction18() throws Throwable  {
        double[] arg2 = new double[3];
        double[][][] arg10 = new double[1][4][4];
        // Create a TricubicSplineInterpolatingFunction instance with 3 dimensions
        TricubicSplineInterpolatingFunction tricubicSplineInterpolatingFunction = new TricubicSplineInterpolatingFunction(arg2, arg2, arg2, arg10, arg10, arg10, arg10, arg10, arg10, arg10, arg10);
        // Verify that the constructor throws an IllegalArgumentException with message "3 != 1"
        try {
        fail("Expecting exception: IllegalArgumentException");
        } catch(IllegalArgumentException e) {
        //
        // 3 != 1
        //
        verifyException("org.apache.commons.math3.analysis.interpolation.TricubicSplineInterpolatingFunction", e);}
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testCreatesTricubicSplineInterpolatingFunction19() throws Throwable  {
        // Given a TricubicSplineInterpolatingFunction constructor with no data
        double[] arg2 = new double[2];
        double[][][] arg10 = new double[3][6][9];
        double[][] doubleArray = new double[0][7];
        arg10[0] = doubleArray;
        
        // When I create a TricubicSplineInterpolatingFunction with no data
        TricubicSplineInterpolatingFunction tricubicSplineInterpolatingFunction = null;
        try {
        tricubicSplineInterpolatingFunction = new TricubicSplineInterpolatingFunction(arg2, arg2, arg2, arg10, arg10, arg10, arg10, arg10, arg10, arg10, arg10);
        fail("Expecting exception: IllegalArgumentException");
        } catch (IllegalArgumentException e) {
        // Then I expect an IllegalArgumentException to be thrown
        verifyException("org.apache.commons.math3.analysis.interpolation.TricubicSplineInterpolatingFunction", e);}
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testCreatesTricubicSplineInterpolatingFunction20() throws Throwable  {
        // No Comments were added
        double[] arg2 = new double[5];
        double[][][] arg10 = new double[0][6][0];
        TricubicSplineInterpolatingFunction tricubicSplineInterpolatingFunction = null;
        try {
          tricubicSplineInterpolatingFunction = new TricubicSplineInterpolatingFunction(arg2, arg2, arg2, arg10, arg10, arg10, arg10, arg10, arg10, arg10, arg10);
          fail("Expecting exception: IllegalArgumentException");
        
        } catch(IllegalArgumentException e) {
           //
           // no data
           //
           verifyException("org.apache.commons.math3.analysis.interpolation.TricubicSplineInterpolatingFunction", e);
        }
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testCreatesTricubicSplineInterpolatingFunction21() throws Throwable  {
        // rollbacked to evosuite
        double[] arg1 = new double[5];
        double[] arg2 = new double[0];
        TricubicSplineInterpolatingFunction tricubicSplineInterpolatingFunction = null;
        try {
          tricubicSplineInterpolatingFunction = new TricubicSplineInterpolatingFunction(arg1, arg1, arg2, (double[][][]) null, (double[][][]) null, (double[][][]) null, (double[][][]) null, (double[][][]) null, (double[][][]) null, (double[][][]) null, (double[][][]) null);
          fail("Expecting exception: IllegalArgumentException");
        
        } catch(IllegalArgumentException e) {
           //
           // no data
           //
           verifyException("org.apache.commons.math3.analysis.interpolation.TricubicSplineInterpolatingFunction", e);
        }
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testCreatesTricubicSplineInterpolatingFunction22() throws Throwable  {
        // Given: A TricubicSplineInterpolatingFunction object is created with an array of x values, a array of y values, a array of z values, and an array of weights.
        double[] arg2 = new double[3];
        double[] arg1 = new double[0];
        double[][][] arg10 = new double[8][7][2];
        TricubicSplineInterpolatingFunction tricubicSplineInterpolatingFunction = null;
        try {
        // When: The TricubicSplineInterpolatingFunction object is created with the given parameters.
        tricubicSplineInterpolatingFunction = new TricubicSplineInterpolatingFunction(arg2, arg1, arg2, arg10, arg10, arg10, arg10, arg10, arg10, arg10, arg10);
        // Then: An IllegalArgumentException is thrown because no data was provided.
        fail("Expecting exception: IllegalArgumentException");
        
        } catch(IllegalArgumentException e) {
        //
        // no data
        //
        verifyException("org.apache.commons.math3.analysis.interpolation.TricubicSplineInterpolatingFunction", e);}
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testCreatesTricubicSplineInterpolatingFunction23() throws Throwable  {
        // Given no data is provided to the constructor
        double[] arg2 = new double[0];
        double[][][] arg9 = new double[0][3][4];
        double[][][] arg10 = new double[3][9][7];
        
        // When the TricubicSplineInterpolatingFunction is created with no data
        TricubicSplineInterpolatingFunction tricubicSplineInterpolatingFunction = null;
        try {
        tricubicSplineInterpolatingFunction = new TricubicSplineInterpolatingFunction(arg2, arg2, arg2, arg9, arg9, arg9, arg10, arg9, arg9, arg9, arg10);
        fail("Expecting exception: IllegalArgumentException");
        } catch(IllegalArgumentException e) {
        // Then an IllegalArgumentException is thrown
        verifyException("org.apache.commons.math3.analysis.interpolation.TricubicSplineInterpolatingFunction", e);}
    }
  }
  