content: /*
   * This file was automatically generated by UTestGen and EvoSuite
   * Tue Mar 19 17:40:29 GMT 2024
   */
  
  package org.apache.commons.math3.linear;
  
  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.io.ObjectInputStream;
  import org.apache.commons.math3.Field;
  import org.apache.commons.math3.fraction.BigFraction;
  import org.apache.commons.math3.fraction.Fraction;
  import org.apache.commons.math3.linear.AnyMatrix;
  import org.apache.commons.math3.linear.Array2DRowRealMatrix;
  import org.apache.commons.math3.linear.ArrayRealVector;
  import org.apache.commons.math3.linear.BlockRealMatrix;
  import org.apache.commons.math3.linear.DiagonalMatrix;
  import org.apache.commons.math3.linear.FieldMatrix;
  import org.apache.commons.math3.linear.FieldVector;
  import org.apache.commons.math3.linear.MatrixUtils;
  import org.apache.commons.math3.linear.RealMatrix;
  import org.apache.commons.math3.linear.RealVector;
  import org.apache.commons.math3.util.BigReal;
  import org.apache.commons.math3.util.Decimal64;
  import org.apache.commons.math3.util.Decimal64Field;
  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 MatrixUtils_Original_ESTest extends MatrixUtils_Original_ESTest_scaffolding {
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testCheckSubMatrixIndexTaking5Arguments() throws Throwable  {
        BlockRealMatrix arg0 = new BlockRealMatrix(270, 270);
        try { 
          MatrixUtils.checkSubMatrixIndex((AnyMatrix) arg0, 52, 52, 270, 44);
          fail("Expecting exception: IllegalArgumentException");
        
        } catch(IllegalArgumentException e) {
           //
           // column index (270)
           //
           verifyException("org.apache.commons.math3.linear.MatrixUtils", e);
        }
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testDeserializeRealVectorThrowsNullPointerException() throws Throwable  {
        Object arg0 = new Object();
        // Undeclared exception!
        try { 
          MatrixUtils.deserializeRealVector(arg0, "", (ObjectInputStream) null);
          fail("Expecting exception: NullPointerException");
        
        } catch(NullPointerException e) {
           //
           // no message in exception (getMessage() returned null)
           //
           verifyException("org.apache.commons.math3.linear.MatrixUtils", e);
        }
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testDeserializeRealMatrixThrowsNullPointerException() throws Throwable  {
        // Undeclared exception!
        try { 
          MatrixUtils.deserializeRealMatrix((Object) null, "", (ObjectInputStream) null);
          fail("Expecting exception: NullPointerException");
        
        } catch(NullPointerException e) {
           //
           // no message in exception (getMessage() returned null)
           //
           verifyException("org.apache.commons.math3.linear.MatrixUtils", e);
        }
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testCreateFieldVector() throws Throwable  {
        Fraction fraction = Fraction.ZERO;
        Fraction[] arg0 = new Fraction[1];
        arg0[0] = fraction;
        FieldVector<Fraction> createFieldVector = MatrixUtils.createFieldVector(arg0);
        assertEquals(1, createFieldVector.getDimension());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testCreateFieldMatrix() throws Throwable  {
        Fraction fraction = Fraction.ONE_THIRD;
        Fraction[][] arg0 = new Fraction[1][8];
        Fraction[] fractionArray = new Fraction[6];
        fractionArray[0] = fraction;
        arg0[0] = fractionArray;
        FieldMatrix<Fraction> createFieldMatrix = MatrixUtils.createFieldMatrix(arg0);
        assertNotNull(createFieldMatrix);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testCheckMultiplicationCompatibleAndCreateRealDiagonalMatrix() throws Throwable  {
        double[] arg0 = new double[1];
        RealMatrix arg1 = MatrixUtils.createRealDiagonalMatrix(arg0);
        MatrixUtils.checkMultiplicationCompatible(arg1, arg1);
        assertEquals(1, arg1.getColumnDimension());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testCheckSubtractionCompatible() throws Throwable  {
        Array2DRowRealMatrix arg1 = new Array2DRowRealMatrix();
        MatrixUtils.checkSubtractionCompatible(arg1, arg1);
        assertEquals(0, arg1.getRowDimension());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void test0() throws Throwable  {
        BlockRealMatrix blockRealMatrix = new BlockRealMatrix(270, 270);
        double[][] arg0 = new double[9][7];
        blockRealMatrix.setSubMatrix(arg0, 42, 52);
        assertEquals(9, arg0.length);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testCheckColumnIndex() throws Throwable  {
        BlockRealMatrix arg0 = new BlockRealMatrix(86, 86);
        MatrixUtils.checkColumnIndex(arg0, 39);
        assertEquals(86, arg0.getColumnDimension());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void test1() throws Throwable  {
        double[] doubleArray = new double[4];
        double[][] arg0 = new double[5][0];
        arg0[0] = doubleArray;
        arg0[1] = doubleArray;
        arg0[2] = doubleArray;
        arg0[3] = doubleArray;
        arg0[4] = doubleArray;
        Array2DRowRealMatrix array2DRowRealMatrix = new Array2DRowRealMatrix(arg0, false);
        RealVector rowVector = array2DRowRealMatrix.getRowVector(1);
        assertFalse(rowVector.isInfinite());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testCreateRealMatrixTaking2ArgumentsWithZeroAndZero() throws Throwable  {
        // Undeclared exception!
        try { 
          MatrixUtils.createRealMatrix(0, 0);
          fail("Expecting exception: IllegalArgumentException");
        
        } catch(IllegalArgumentException e) {
           //
           // 0 is smaller than, or equal to, the minimum (0)
           //
           verifyException("org.apache.commons.math3.linear.AbstractRealMatrix", e);
        }
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testBlockInverse() throws Throwable  {
        BlockRealMatrix arg0 = new BlockRealMatrix(3594, 1);
        // Undeclared exception!
        try { 
          MatrixUtils.blockInverse(arg0, 3594);
          fail("Expecting exception: IllegalArgumentException");
        
        } catch(IllegalArgumentException e) {
           //
           // non square (3,594x1) matrix
           //
           verifyException("org.apache.commons.math3.linear.MatrixUtils", e);
        }
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testSolveUpperTriangularSystemAndSolveUpperTriangularSystem() throws Throwable  {
        ArrayRealVector arg1 = new ArrayRealVector();
        Array2DRowRealMatrix arg0 = new Array2DRowRealMatrix();
        MatrixUtils.solveUpperTriangularSystem(arg0, arg1);
        assertFalse(arg1.isInfinite());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testSolveUpperTriangularSystem() throws Throwable  {
        Array2DRowRealMatrix arg0 = new Array2DRowRealMatrix();
        ArrayRealVector arg1 = new ArrayRealVector(288, 288);
        try { 
          MatrixUtils.solveUpperTriangularSystem(arg0, arg1);
          fail("Expecting exception: IllegalArgumentException");
        
        } catch(IllegalArgumentException e) {
           //
           // 0 != 288
           //
           verifyException("org.apache.commons.math3.linear.MatrixUtils", e);
        }
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testSolveUpperTriangularSystemWithNull0() throws Throwable  {
        Array2DRowRealMatrix arg0 = new Array2DRowRealMatrix();
        try { 
          MatrixUtils.solveUpperTriangularSystem(arg0, (RealVector) null);
          fail("Expecting exception: IllegalArgumentException");
        
        } catch(IllegalArgumentException e) {
           //
           // 0 != 0
           //
           verifyException("org.apache.commons.math3.linear.MatrixUtils", e);
        }
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testSolveUpperTriangularSystemWithNull1() throws Throwable  {
        ArrayRealVector arg1 = new ArrayRealVector();
        try { 
          MatrixUtils.solveUpperTriangularSystem((RealMatrix) null, arg1);
          fail("Expecting exception: IllegalArgumentException");
        
        } catch(IllegalArgumentException e) {
           //
           // 0 != 0
           //
           verifyException("org.apache.commons.math3.linear.MatrixUtils", e);
        }
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testSolveLowerTriangularSystem() throws Throwable  {
        ArrayRealVector arg1 = new ArrayRealVector();
        Array2DRowRealMatrix arg0 = new Array2DRowRealMatrix();
        MatrixUtils.solveLowerTriangularSystem(arg0, arg1);
        assertFalse(arg1.isInfinite());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testSolveLowerTriangularSystemWithNull0() throws Throwable  {
        Array2DRowRealMatrix arg0 = new Array2DRowRealMatrix();
        try { 
          MatrixUtils.solveLowerTriangularSystem(arg0, (RealVector) null);
          fail("Expecting exception: IllegalArgumentException");
        
        } catch(IllegalArgumentException e) {
           //
           // 0 != 0
           //
           verifyException("org.apache.commons.math3.linear.MatrixUtils", e);
        }
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testSolveLowerTriangularSystemWithNull1() throws Throwable  {
        ArrayRealVector arg1 = new ArrayRealVector();
        try { 
          MatrixUtils.solveLowerTriangularSystem((RealMatrix) null, arg1);
          fail("Expecting exception: IllegalArgumentException");
        
        } catch(IllegalArgumentException e) {
           //
           // 0 != 0
           //
           verifyException("org.apache.commons.math3.linear.MatrixUtils", e);
        }
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void test2() throws Throwable  {
        BlockRealMatrix blockRealMatrix = new BlockRealMatrix(86, 86);
        Array2DRowRealMatrix arg0 = new Array2DRowRealMatrix();
        try { 
          blockRealMatrix.preMultiply((RealMatrix) arg0);
          fail("Expecting exception: IllegalArgumentException");
        
        } catch(IllegalArgumentException e) {
           //
           // 0 != 86
           //
           verifyException("org.apache.commons.math3.linear.MatrixUtils", e);
        }
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void test3() throws Throwable  {
        BlockRealMatrix blockRealMatrix = new BlockRealMatrix(91, 91);
        BlockRealMatrix arg0 = new BlockRealMatrix(91, 52);
        try { 
          blockRealMatrix.subtract(arg0);
          fail("Expecting exception: IllegalArgumentException");
        
        } catch(IllegalArgumentException e) {
           //
           // got 91x91 but expected 91x52
           //
           verifyException("org.apache.commons.math3.linear.MatrixUtils", e);
        }
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testCreateRealMatrixTaking2Arguments() throws Throwable  {
        BlockRealMatrix createRealMatrix = (BlockRealMatrix)MatrixUtils.createRealMatrix(292, 292);
        BlockRealMatrix arg0 = new BlockRealMatrix(52, 292);
        try { 
          createRealMatrix.subtract(arg0);
          fail("Expecting exception: IllegalArgumentException");
        
        } catch(IllegalArgumentException e) {
           //
           // got 292x292 but expected 52x292
           //
           verifyException("org.apache.commons.math3.linear.MatrixUtils", e);
        }
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testCheckAdditionCompatible() throws Throwable  {
        Array2DRowRealMatrix arg1 = new Array2DRowRealMatrix();
        MatrixUtils.checkAdditionCompatible(arg1, arg1);
        assertEquals(0, arg1.getRowDimension());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void test4() throws Throwable  {
        BlockRealMatrix blockRealMatrix = new BlockRealMatrix(286, 286);
        BlockRealMatrix arg0 = new BlockRealMatrix(6, 286);
        try { 
          blockRealMatrix.add((RealMatrix) arg0);
          fail("Expecting exception: IllegalArgumentException");
        
        } catch(IllegalArgumentException e) {
           //
           // got 286x286 but expected 6x286
           //
           verifyException("org.apache.commons.math3.linear.MatrixUtils", e);
        }
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testCheckSubMatrixIndexTaking3ArgumentsWithEmptyArrayAndNonEmptyArray() throws Throwable  {
        Array2DRowRealMatrix arg0 = new Array2DRowRealMatrix();
        int[] arg1 = new int[9];
        int[] arg2 = new int[0];
        try { 
          MatrixUtils.checkSubMatrixIndex((AnyMatrix) arg0, arg1, arg2);
          fail("Expecting exception: IllegalArgumentException");
        
        } catch(IllegalArgumentException e) {
           //
           // empty selected column index array
           //
           verifyException("org.apache.commons.math3.linear.MatrixUtils", e);
        }
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testCheckSubMatrixIndexTaking3Arguments() throws Throwable  {
        BlockRealMatrix arg0 = new BlockRealMatrix(270, 270);
        int[] arg2 = new int[2];
        MatrixUtils.checkSubMatrixIndex((AnyMatrix) arg0, arg2, arg2);
        assertEquals(270, arg0.getRowDimension());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testCheckSubMatrixIndexTaking3ArgumentsWithNullAndNonEmptyArray() throws Throwable  {
        BlockRealMatrix arg0 = new BlockRealMatrix(292, 292);
        int[] arg1 = new int[5];
        try { 
          MatrixUtils.checkSubMatrixIndex((AnyMatrix) arg0, arg1, (int[]) null);
          fail("Expecting exception: IllegalArgumentException");
        
        } catch(IllegalArgumentException e) {
           //
           // null is not allowed
           //
           verifyException("org.apache.commons.math3.linear.MatrixUtils", e);
        }
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testCheckSubMatrixIndexTaking3ArgumentsWithNullAndNull() throws Throwable  {
        Array2DRowRealMatrix arg0 = new Array2DRowRealMatrix();
        try { 
          MatrixUtils.checkSubMatrixIndex((AnyMatrix) arg0, (int[]) null, (int[]) null);
          fail("Expecting exception: IllegalArgumentException");
        
        } catch(IllegalArgumentException e) {
           //
           // null is not allowed
           //
           verifyException("org.apache.commons.math3.linear.MatrixUtils", e);
        }
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testCheckSubMatrixIndexTaking3ArgumentsWithEmptyArrayAndEmptyArray() throws Throwable  {
        Array2DRowRealMatrix arg0 = new Array2DRowRealMatrix();
        int[] arg2 = new int[0];
        try { 
          MatrixUtils.checkSubMatrixIndex((AnyMatrix) arg0, arg2, arg2);
          fail("Expecting exception: IllegalArgumentException");
        
        } catch(IllegalArgumentException e) {
           //
           // empty selected row index array
           //
           verifyException("org.apache.commons.math3.linear.MatrixUtils", e);
        }
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void test5() throws Throwable  {
        DiagonalMatrix diagonalMatrix = new DiagonalMatrix(769);
        try { 
          diagonalMatrix.copySubMatrix(275, 399, 722, 241, (double[][]) null);
          fail("Expecting exception: IllegalArgumentException");
        
        } catch(IllegalArgumentException e) {
           //
           // initial column 722 after final column 241
           //
           verifyException("org.apache.commons.math3.linear.MatrixUtils", e);
        }
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void test6() throws Throwable  {
        Array2DRowRealMatrix array2DRowRealMatrix = new Array2DRowRealMatrix();
        try { 
          array2DRowRealMatrix.getColumnVector(381);
          fail("Expecting exception: IllegalArgumentException");
        
        } catch(IllegalArgumentException e) {
           //
           // column index (381)
           //
           verifyException("org.apache.commons.math3.linear.MatrixUtils", e);
        }
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void test7() throws Throwable  {
        Array2DRowRealMatrix array2DRowRealMatrix = new Array2DRowRealMatrix();
        try { 
          array2DRowRealMatrix.getColumnVector((-1));
          fail("Expecting exception: IllegalArgumentException");
        
        } catch(IllegalArgumentException e) {
           //
           // column index (-1)
           //
           verifyException("org.apache.commons.math3.linear.MatrixUtils", e);
        }
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testCheckSymmetricAndCheckSymmetric() throws Throwable  {
        BlockRealMatrix arg0 = new BlockRealMatrix(68, 68);
        MatrixUtils.checkSymmetric(arg0, 68);
        assertEquals(68, arg0.getColumnDimension());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testIsSymmetricReturningFalse() throws Throwable  {
        RealMatrix arg0 = MatrixUtils.createRealMatrix(64, 199);
        boolean symmetric = MatrixUtils.isSymmetric(arg0, 199);
        assertFalse(symmetric);
        assertEquals(64, arg0.getRowDimension());
        assertEquals(199, arg0.getColumnDimension());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testCreateColumnFieldMatrix() throws Throwable  {
        Fraction[] arg0 = new Fraction[2];
        Fraction fraction = Fraction.ONE_QUARTER;
        arg0[0] = fraction;
        FieldMatrix<Fraction> createColumnFieldMatrix = MatrixUtils.createColumnFieldMatrix(arg0);
        assertNotNull(createColumnFieldMatrix);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testCreateColumnFieldMatrixWithNull() throws Throwable  {
        try { 
          MatrixUtils.createColumnFieldMatrix((Decimal64[]) null);
          fail("Expecting exception: IllegalArgumentException");
        
        } catch(IllegalArgumentException e) {
           //
           // null is not allowed
           //
           verifyException("org.apache.commons.math3.linear.MatrixUtils", e);
        }
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testCreateColumnFieldMatrixWithEmptyArray() throws Throwable  {
        Fraction[] arg0 = new Fraction[0];
        try { 
          MatrixUtils.createColumnFieldMatrix(arg0);
          fail("Expecting exception: IllegalArgumentException");
        
        } catch(IllegalArgumentException e) {
           //
           // matrix must have at least one row
           //
           verifyException("org.apache.commons.math3.linear.MatrixUtils", e);
        }
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testCreateColumnRealMatrix() throws Throwable  {
        try { 
          MatrixUtils.createColumnRealMatrix((double[]) null);
          fail("Expecting exception: IllegalArgumentException");
        
        } catch(IllegalArgumentException e) {
           //
           // null is not allowed
           //
           verifyException("org.apache.commons.math3.linear.MatrixUtils", e);
        }
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testCreateRowFieldMatrixWithEmptyArray() throws Throwable  {
        Decimal64[] arg0 = new Decimal64[0];
        try { 
          MatrixUtils.createRowFieldMatrix(arg0);
          fail("Expecting exception: IllegalArgumentException");
        
        } catch(IllegalArgumentException e) {
           //
           // matrix must have at least one column
           //
           verifyException("org.apache.commons.math3.linear.MatrixUtils", e);
        }
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testCreateRowFieldMatrixWithNull() throws Throwable  {
        try { 
          MatrixUtils.createRowFieldMatrix((BigFraction[]) null);
          fail("Expecting exception: IllegalArgumentException");
        
        } catch(IllegalArgumentException e) {
           //
           // null is not allowed
           //
           verifyException("org.apache.commons.math3.linear.MatrixUtils", e);
        }
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testCreateRowRealMatrixWithNull() throws Throwable  {
        try { 
          MatrixUtils.createRowRealMatrix((double[]) null);
          fail("Expecting exception: IllegalArgumentException");
        
        } catch(IllegalArgumentException e) {
           //
           // null is not allowed
           //
           verifyException("org.apache.commons.math3.linear.MatrixUtils", e);
        }
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testCreateRowRealMatrix() throws Throwable  {
        double[] arg0 = new double[2];
        RealMatrix createRowRealMatrix = MatrixUtils.createRowRealMatrix(arg0);
        assertEquals(1, createRowRealMatrix.getRowDimension());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testCreateFieldVectorWithNull() throws Throwable  {
        try { 
          MatrixUtils.createFieldVector((Fraction[]) null);
          fail("Expecting exception: IllegalArgumentException");
        
        } catch(IllegalArgumentException e) {
           //
           // null is not allowed
           //
           verifyException("org.apache.commons.math3.linear.MatrixUtils", e);
        }
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testCreateFieldVectorWithEmptyArray() throws Throwable  {
        BigReal[] arg0 = new BigReal[0];
        try { 
          MatrixUtils.createFieldVector(arg0);
          fail("Expecting exception: IllegalArgumentException");
        
        } catch(IllegalArgumentException e) {
           //
           // vector must have at least one element
           //
           verifyException("org.apache.commons.math3.linear.MatrixUtils", e);
        }
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testCreateRealVectorWithNull() throws Throwable  {
        try { 
          MatrixUtils.createRealVector((double[]) null);
          fail("Expecting exception: IllegalArgumentException");
        
        } catch(IllegalArgumentException e) {
           //
           // null is not allowed
           //
           verifyException("org.apache.commons.math3.linear.MatrixUtils", e);
        }
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testCreateRealVector() throws Throwable  {
        double[] arg0 = new double[1];
        RealVector createRealVector = MatrixUtils.createRealVector(arg0);
        assertEquals(1, createRealVector.getDimension());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testCreateFieldIdentityMatrix() throws Throwable  {
        Decimal64Field arg0 = Decimal64Field.getInstance();
        FieldMatrix<Decimal64> createFieldIdentityMatrix = MatrixUtils.createFieldIdentityMatrix((Field<Decimal64>) arg0, 46);
        assertNotNull(createFieldIdentityMatrix);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testCreateFieldMatrixWithNull() throws Throwable  {
        try { 
          MatrixUtils.createFieldMatrix((Fraction[][]) null);
          fail("Expecting exception: IllegalArgumentException");
        
        } catch(IllegalArgumentException e) {
           //
           // null is not allowed
           //
           verifyException("org.apache.commons.math3.linear.MatrixUtils", e);
        }
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testCreateRealMatrixTakingDoubleArrayArray() throws Throwable  {
        try { 
          MatrixUtils.createRealMatrix((double[][]) null);
          fail("Expecting exception: IllegalArgumentException");
        
        } catch(IllegalArgumentException e) {
           //
           // null is not allowed
           //
           verifyException("org.apache.commons.math3.linear.MatrixUtils", e);
        }
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testCreateRowFieldMatrix() throws Throwable  {
        Fraction[] arg0 = new Fraction[1];
        Fraction fraction = Fraction.ONE_FIFTH;
        arg0[0] = fraction;
        FieldMatrix<Fraction> createRowFieldMatrix = MatrixUtils.createRowFieldMatrix(arg0);
        assertNotNull(createRowFieldMatrix);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testCheckMatrixIndex() throws Throwable  {
        RealMatrix arg0 = MatrixUtils.createRealMatrix(244, 244);
        try { 
          MatrixUtils.checkMatrixIndex(arg0, 244, 0);
          fail("Expecting exception: IllegalArgumentException");
        
        } catch(IllegalArgumentException e) {
           //
           // row index (244)
           //
           verifyException("org.apache.commons.math3.linear.MatrixUtils", e);
        }
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testCheckSymmetric() throws Throwable  {
        BlockRealMatrix arg0 = new BlockRealMatrix(263, 283);
        // Undeclared exception!
        try { 
          MatrixUtils.checkSymmetric(arg0, 283);
          fail("Expecting exception: IllegalArgumentException");
        
        } catch(IllegalArgumentException e) {
           //
           // non square (263x283) matrix
           //
           verifyException("org.apache.commons.math3.linear.MatrixUtils", e);
        }
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testIsSymmetricReturningTrue() throws Throwable  {
        Array2DRowRealMatrix arg0 = new Array2DRowRealMatrix();
        boolean symmetric = MatrixUtils.isSymmetric(arg0, 0.0);
        assertTrue(symmetric);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testCreateRealIdentityMatrix() throws Throwable  {
        RealMatrix createRealIdentityMatrix = MatrixUtils.createRealIdentityMatrix(51);
        assertEquals(51, createRealIdentityMatrix.getRowDimension());
        assertEquals(51, createRealIdentityMatrix.getColumnDimension());
    }
  }
  