content: /*
   * This file was automatically generated by UTestGen and EvoSuite
   * Tue Mar 19 17:48:29 GMT 2024
   */
  
  package org.apache.commons.math3.geometry.euclidean.oned;
  
  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 java.util.LinkedList;
  import org.apache.commons.math3.geometry.euclidean.oned.Euclidean1D;
  import org.apache.commons.math3.geometry.euclidean.oned.IntervalsSet;
  import org.apache.commons.math3.geometry.partitioning.SubHyperplane;
  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 IntervalsSet_ESTest extends IntervalsSet_ESTest_scaffolding {
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testGetSupReturningZero() throws Throwable  {
        // Given a set of intervals with a positive upper bound
        IntervalsSet intervalsSet = new IntervalsSet(1.5707963267948966, 0.0);
        
        // When the method getSup is called on the set
        double sup = intervalsSet.getSup();
        
        // Then the upper bound of the set should be equal to the given value
        assertEquals(0.0, sup, 0.01);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testGetInfReturningZero() throws Throwable  {
        // Given: An empty interval set
        IntervalsSet intervalsSet = new IntervalsSet(0.0, 0.0);
        
        // When: We call the getInf method on the interval set
        double inf = intervalsSet.getInf();
        
        // Then: The result should be equal to the lower bound of the first interval in the set
        assertEquals(0.0, inf, 0.01);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testGetInfReturningPositive() throws Throwable  {
        // Given a set of intervals with a known lower bound
        IntervalsSet intervalsSet = new IntervalsSet(0.7937005259840998, 827.3231324);
        
        // When the inf method is called on the set
        double inf = intervalsSet.getInf();
        
        // Then the lower bound of the set should be returned
        assertEquals(0.7937005259840998, inf, 0.01);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testGetSupReturningPositive() throws Throwable  {
        // Given a IntervalsSet object with some intervals
        IntervalsSet intervalsSet = new IntervalsSet();
        
        // When we call the getSup method on this object
        double sup = intervalsSet.getSup();
        
        // Then we expect the value returned to be Double.POSITIVE_INFINITY
        assertEquals(Double.POSITIVE_INFINITY, sup, 0.01);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testGetSupReturningNegative() throws Throwable  {
        // Given an IntervalsSet instance with a negative lower bound and a positive upper bound
        IntervalsSet intervalsSet = new IntervalsSet(-19.60972417526534, -0.1);
        
        // When the getSup method is called on the IntervalsSet object
        double sup = intervalsSet.getSup();
        
        // Then the upper bound of the IntervalsSet should be returned
        assertEquals(-0.1, sup, 0.01);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testGetInf0() throws Throwable  {
        // Test that getInf returns the correct value for an interval with a negative lower bound and 0 upper bound
        IntervalsSet intervalsSet = new IntervalsSet(-1.0, 0.0);
        double inf = intervalsSet.getInf();
        assertEquals(-1.0, inf, 0.01); // Assert that the value returned by getInf is equal to the lower bound of the interval, with a maximum absolute error of 0.01
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testGetInf1() throws Throwable  {
        // Given an IntervalsSet with negative infinity as the lower bound and negative infinity as the upper bound
        IntervalsSet intervalsSet = new IntervalsSet(Double.NEGATIVE_INFINITY, Double.NEGATIVE_INFINITY);
        
        // When we call getInf on the IntervalsSet
        double inf = intervalsSet.getInf();
        
        // Then we expect to receive negative infinity as the result
        assertEquals(Double.NEGATIVE_INFINITY, inf, 0.01);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testComputeGeometricalProperties0() throws Throwable  {
        // Test that the intervals set is not empty after computing its geometrical properties
        IntervalsSet intervalsSet = new IntervalsSet(Double.NEGATIVE_INFINITY, Double.NEGATIVE_INFINITY);
        intervalsSet.computeGeometricalProperties();
        assertFalse(intervalsSet.isEmpty());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testComputeGeometricalProperties1() throws Throwable  {
        // Given: An intervals set with a negative number and Double.NEGATIVE_INFINITY as the lower bound
        IntervalsSet intervalsSet = new IntervalsSet((-4637.41238), Double.NEGATIVE_INFINITY);
        
        // When: The computeGeometricalProperties() method is called on the intervals set
        intervalsSet.computeGeometricalProperties();
        
        // Then: The result of the computation should be false, indicating that the intervals set is not empty
        assertFalse(intervalsSet.isEmpty());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testCreatesIntervalsSetTaking2Arguments0() throws Throwable  {
        // Given: An empty interval set with infinite boundaries
        IntervalsSet intervalsSet = new IntervalsSet(Double.NEGATIVE_INFINITY, Double.POSITIVE_INFINITY);
        assertFalse(intervalsSet.isEmpty()); // Then: The interval set should not be empty
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testCreatesIntervalsSetTaking2Arguments1() throws Throwable  {
        // Given a set of intervals with the first interval having a lower bound of Double.NEGATIVE_INFINITY and an upper bound of 1.1730463525082348E-7
        IntervalsSet intervalsSet = new IntervalsSet(Double.NEGATIVE_INFINITY, 1.1730463525082348E-7);
        
        // When the set is checked for emptiness
        boolean result = intervalsSet.isEmpty();
        
        // Then the set should not be empty
        assertFalse(result);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testCreatesIntervalsSetTaking2Arguments2() throws Throwable  {
        // Given: An empty interval set with positive infinity as both bounds
        IntervalsSet intervalsSet = new IntervalsSet(Double.POSITIVE_INFINITY, Double.POSITIVE_INFINITY);
        
        // When: We check if the interval set is empty
        boolean result = intervalsSet.isEmpty();
        
        // Then: The result should be false, indicating that the interval set is not empty
        assertFalse(result);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testCreatesIntervalsSetTakingCollection() throws Throwable  {
        // rollbacked to evosuite
        LinkedList<SubHyperplane<Euclidean1D>> arg0 = new LinkedList<SubHyperplane<Euclidean1D>>();
        IntervalsSet intervalsSet = new IntervalsSet(arg0);
        assertFalse(intervalsSet.isEmpty());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testComputeGeometricalProperties2() throws Throwable  {
        // Given an intervals set with negative values
        IntervalsSet intervals = new IntervalsSet((-19.60972417526534), (-0.1));
        
        // When the computeGeometricalProperties method is called on the intervals set
        intervals.computeGeometricalProperties();
        
        // Then the method should not return an empty result
        assertFalse(intervals.isEmpty());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testCreatesIntervalsSetTakingNoArguments() throws Throwable  {
        // Given an empty intervals set
        IntervalsSet intervalsSet = new IntervalsSet();
        
        // When we compute the geometrical properties of the empty set
        intervalsSet.computeGeometricalProperties();
        
        // Then the set is empty
        assertTrue(intervalsSet.isEmpty());
    }
  }
  