content: /*
   * This file was automatically generated by UTestGen and EvoSuite
   * Wed Mar 20 04:43:25 GMT 2024
   */
  
  package org.jfree.chart.axis;
  
  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.awt.Color;
  import java.awt.Font;
  import java.awt.Graphics2D;
  import java.awt.Paint;
  import java.awt.Stroke;
  import java.awt.geom.Rectangle2D;
  import java.awt.image.BufferedImage;
  import org.evosuite.runtime.EvoRunner;
  import org.evosuite.runtime.EvoRunnerParameters;
  import org.jfree.chart.ChartRenderingInfo;
  import org.jfree.chart.JFreeChart;
  import org.jfree.chart.axis.CategoryAxis;
  import org.jfree.chart.axis.CategoryAxis3D;
  import org.jfree.chart.axis.CyclicNumberAxis;
  import org.jfree.chart.axis.DateAxis;
  import org.jfree.chart.axis.ExtendedCategoryAxis;
  import org.jfree.chart.axis.LogarithmicAxis;
  import org.jfree.chart.axis.NumberAxis;
  import org.jfree.chart.axis.NumberAxis3D;
  import org.jfree.chart.axis.SubCategoryAxis;
  import org.jfree.chart.axis.ValueAxis;
  import org.jfree.chart.event.AxisChangeListener;
  import org.jfree.chart.plot.CombinedDomainCategoryPlot;
  import org.jfree.chart.plot.MultiplePiePlot;
  import org.jfree.chart.plot.PlotOrientation;
  import org.jfree.chart.plot.PlotRenderingInfo;
  import org.jfree.chart.plot.ThermometerPlot;
  import org.jfree.chart.title.Title;
  import org.jfree.data.xy.DefaultTableXYDataset;
  import org.jfree.ui.RectangleEdge;
  import org.jfree.ui.RectangleInsets;
  import org.junit.runner.RunWith;
  
  @RunWith(EvoRunner.class) @EvoRunnerParameters(mockJVMNonDeterminism = true, useVFS = true, useVNET = true, resetStaticState = true, separateClassLoader = true) 
  public class Axis_ESTest extends Axis_ESTest_scaffolding {
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testAddChangeListener() throws Throwable  {
        // Given a CategoryAxis3D instance
        CategoryAxis3D categoryAxis3D = new CategoryAxis3D();
        
        // When adding a change listener to the axis
        categoryAxis3D.addChangeListener((AxisChangeListener) null);
        
        // Then the tick mark inside length should be 0.0F
        assertEquals(0.0F, categoryAxis3D.getTickMarkInsideLength(), 0.01F);
        
        // And the label angle should be 0.0
        assertEquals(0.0, categoryAxis3D.getLabelAngle(), 0.01);
        
        // And the axis should be visible
        assertTrue(categoryAxis3D.isVisible());
        
        // And the tick marks should not be visible
        assertFalse(categoryAxis3D.isTickMarksVisible());
        
        // And the axis line should be visible
        assertTrue(categoryAxis3D.isAxisLineVisible());
        
        // And the tick mark outside length should be 2.0F
        assertEquals(2.0F, categoryAxis3D.getTickMarkOutsideLength(), 0.01F);
        
        // And the tick labels should be visible
        assertTrue(categoryAxis3D.isTickLabelsVisible());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testIsVisible() throws Throwable  {
        // Given a CategoryAxis3D instance with some customized settings
        CategoryAxis3D categoryAxis3D = new CategoryAxis3D();
        categoryAxis3D.setVisible(true);
        categoryAxis3D.setAxisLineVisible(false);
        categoryAxis3D.setTickLabelsVisible(false);
        categoryAxis3D.setTickMarksVisible(true);
        categoryAxis3D.setTickMarkOutsideLength(2.0F);
        categoryAxis3D.setLabelAngle(0.0);
        categoryAxis3D.setTickMarkInsideLength(0.0F);
        
        // When the properties of the CategoryAxis3D instance are accessed
        boolean visible = categoryAxis3D.isVisible();
        assertTrue(visible); // The axis is visible
        
        assertFalse(categoryAxis3D.isAxisLineVisible()); // The axis line is not visible
        assertFalse(categoryAxis3D.isTickLabelsVisible()); // The tick labels are not visible
        assertTrue(categoryAxis3D.isTickMarksVisible()); // The tick marks are visible
        
        float tickMarkOutsideLength = categoryAxis3D.getTickMarkOutsideLength();
        assertEquals(2.0F, tickMarkOutsideLength, 0.01F); // The outside length of the tick marks is 2.0
        
        double labelAngle = categoryAxis3D.getLabelAngle();
        assertEquals(0.0, labelAngle, 0.01); // The angle of the labels is 0.0 degrees
        
        float tickMarkInsideLength = categoryAxis3D.getTickMarkInsideLength();
        assertEquals(0.0F, tickMarkInsideLength, 0.01F); // The inside length of the tick marks is 0.0
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testIsTickMarksVisibleReturningTrue() throws Throwable  {
        // Test that the axis line is visible and the tick marks are not visible by default
        CyclicNumberAxis cyclicNumberAxis = new CyclicNumberAxis((-316.904221877));
        assertTrue(cyclicNumberAxis.isAxisLineVisible());
        assertFalse(cyclicNumberAxis.isTickMarksVisible());
        
        // Test that the tick marks are visible when set to true
        cyclicNumberAxis.setTickMarksVisible(true);
        assertTrue(cyclicNumberAxis.isTickMarksVisible());
        
        // Test that the axis line is not visible when set to false
        cyclicNumberAxis.setAxisLineVisible(false);
        assertFalse(cyclicNumberAxis.isAxisLineVisible());
        
        // Test that the tick labels are visible by default and can be set to invisible
        assertTrue(cyclicNumberAxis.isTickLabelsVisible());
        cyclicNumberAxis.setTickLabelsVisible(false);
        assertFalse(cyclicNumberAxis.isTickLabelsVisible());
        
        // Test that the label angle is 0 by default and can be set to a non-zero value
        assertEquals(0.0, cyclicNumberAxis.getLabelAngle(), 0.01);
        cyclicNumberAxis.setLabelAngle(90.0F);
        assertEquals(90.0F, cyclicNumberAxis.getLabelAngle(), 0.01);
        
        // Test that the tick mark outside length is 2 by default and can be set to a non-default value
        assertEquals(2.0F, cyclicNumberAxis.getTickMarkOutsideLength(), 0.01F);
        cyclicNumberAxis.setTickMarkOutsideLength(5.0F);
        assertEquals(5.0F, cyclicNumberAxis.getTickMarkOutsideLength(), 0.01F);
        
        // Test that the tick mark inside length is 0 by default and can be set to a non-default value
        assertEquals(0.0F, cyclicNumberAxis.getTickMarkInsideLength(), 0.01F);
        cyclicNumberAxis.setTickMarkInsideLength(2.5F);
        assertEquals(2.5F, cyclicNumberAxis.getTickMarkInsideLength(), 0.01F);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testIsTickMarksVisibleReturningFalse() throws Throwable  {
        // Create a new SubCategoryAxis instance with a null category label
        SubCategoryAxis subCategoryAxis = new SubCategoryAxis(null);
        
        // Test that the tick marks are not visible by default
        assertFalse(subCategoryAxis.isTickMarksVisible());
        
        // Test that the label angle is 0 by default
        assertEquals(0.0, subCategoryAxis.getLabelAngle(), 0.01);
        
        // Test that the tick labels are visible by default
        assertTrue(subCategoryAxis.isTickLabelsVisible());
        
        // Test that the outside length of the tick marks is 2.0F by default
        assertEquals(2.0F, subCategoryAxis.getTickMarkOutsideLength(), 0.01F);
        
        // Test that the axis line is visible by default
        assertTrue(subCategoryAxis.isAxisLineVisible());
        
        // Test that the SubCategoryAxis is visible by default
        assertTrue(subCategoryAxis.isVisible());
        
        // Test that the inside length of the tick marks is 0.0F by default
        assertEquals(0.0F, subCategoryAxis.getTickMarkInsideLength(), 0.01F);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testIsTickLabelsVisible() throws Throwable  {
        // Create a new NumberAxis3D instance
        NumberAxis3D numberAxis3D = new NumberAxis3D();
        
        // Assert that the axis line is not visible by default
        assertFalse(numberAxis3D.isAxisLineVisible());
        
        // Assert that the tick marks are visible and have the correct lengths
        assertTrue(numberAxis3D.isTickMarksVisible());
        assertEquals(0.0F, numberAxis3D.getTickMarkInsideLength(), 0.01F);
        assertEquals(2.0F, numberAxis3D.getTickMarkOutsideLength(), 0.01F);
        
        // Assert that the tick labels are visible and have the correct angle
        assertTrue(numberAxis3D.isTickLabelsVisible());
        assertEquals(0.0, numberAxis3D.getLabelAngle(), 0.01);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testIsAxisLineVisibleReturningTrue() throws Throwable  {
        // Given a CyclicNumberAxis with tick labels and marks visible
        CyclicNumberAxis cyclicNumberAxis = new CyclicNumberAxis(2800.6);
        cyclicNumberAxis.setTickLabelsVisible(true);
        cyclicNumberAxis.setTickMarksVisible(true);
        
        // When the axis line visibility is checked
        boolean axisLineVisible = cyclicNumberAxis.isAxisLineVisible();
        
        // Then the axis line should be visible
        assertTrue(axisLineVisible);
        
        // And the label angle should be 0
        assertEquals(0.0, cyclicNumberAxis.getLabelAngle(), 0.01);
        
        // And the tick mark inside length should be 0
        assertEquals(0.0F, cyclicNumberAxis.getTickMarkInsideLength(), 0.01F);
        
        // And the tick mark outside length should be 2
        assertEquals(2.0F, cyclicNumberAxis.getTickMarkOutsideLength(), 0.01F);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testIsAxisLineVisibleReturningFalse() throws Throwable  {
        // Given a NumberAxis3D object, we want to test its properties and methods
        NumberAxis3D numberAxis3D = new NumberAxis3D();
        
        // When the axis line visibility is changed to true
        numberAxis3D.setAxisLineVisible(true);
        
        // Then the tick label visibility should also be set to true
        assertTrue(numberAxis3D.isTickLabelsVisible());
        
        // When the tick mark inside length is set to 0.0F
        numberAxis3D.setTickMarkInsideLength(0.0F);
        
        // Then the tick mark outside length should be set to 2.0F
        assertEquals(2.0F, numberAxis3D.getTickMarkOutsideLength(), 0.01F);
        
        // When the axis line visibility is changed to false
        numberAxis3D.setAxisLineVisible(false);
        
        // Then the tick label angle should be set to 0.0
        assertEquals(0.0, numberAxis3D.getLabelAngle(), 0.01);
        
        // When the tick mark visibility is changed to false
        numberAxis3D.setTickMarksVisible(false);
        
        // Then the axis visibility should also be set to false
        assertFalse(numberAxis3D.isVisible());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testGetTickMarkStroke() throws Throwable  {
        // rollbacked to evosuite
        NumberAxis3D numberAxis3D = new NumberAxis3D();
        numberAxis3D.getTickMarkStroke();
        assertFalse(numberAxis3D.isAxisLineVisible());
        assertEquals(0.0F, numberAxis3D.getTickMarkInsideLength(), 0.01F);
        assertEquals(2.0F, numberAxis3D.getTickMarkOutsideLength(), 0.01F);
        assertTrue(numberAxis3D.isTickMarksVisible());
        assertTrue(numberAxis3D.isTickLabelsVisible());
        assertTrue(numberAxis3D.isVisible());
        assertEquals(0.0, numberAxis3D.getLabelAngle(), 0.01);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testGetTickMarkPaint() throws Throwable  {
        // Given a NumberAxis3D instance with default settings
        NumberAxis3D numberAxis3D = new NumberAxis3D();
        
        // When we call getTickMarkPaint()
        Color tickMarkPaint = (Color)numberAxis3D.getTickMarkPaint();
        
        // Then the return value is a Color instance with blue color
        assertEquals(0.0, numberAxis3D.getLabelAngle(), 0.01);
        assertTrue(numberAxis3D.isTickMarksVisible());
        assertTrue(numberAxis3D.isVisible());
        assertFalse(numberAxis3D.isAxisLineVisible());
        assertEquals(0.0F, numberAxis3D.getTickMarkInsideLength(), 0.01F);
        assertEquals(128, tickMarkPaint.getBlue());
        assertTrue(numberAxis3D.isTickLabelsVisible());
        assertEquals(2.0F, numberAxis3D.getTickMarkOutsideLength(), 0.01F);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testGetTickMarkOutsideLengthReturningPositive() throws Throwable  {
        // Test the visibility of a NumberAxis3D object and its tick marks
        NumberAxis3D numberAxis3D = new NumberAxis3D();
        
        // Verify that the axis is visible
        assertTrue(numberAxis3D.isVisible());
        
        // Verify that the tick marks are visible outside the axis line
        float tickMarkOutsideLength = numberAxis3D.getTickMarkOutsideLength();
        assertEquals(2.0F, tickMarkOutsideLength, 0.01F);
        
        // Verify that the tick labels are visible
        assertTrue(numberAxis3D.isTickLabelsVisible());
        
        // Verify that the axis line is not visible
        assertFalse(numberAxis3D.isAxisLineVisible());
        
        // Verify that the tick marks are not visible inside the axis line
        assertEquals(0.0F, numberAxis3D.getTickMarkInsideLength(), 0.01F);
        
        // Verify that the label angle is zero (i.e., horizontal)
        assertEquals(0.0, numberAxis3D.getLabelAngle(), 0.01);
        
        // Verify that the tick marks are visible
        assertTrue(numberAxis3D.isTickMarksVisible());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testGetTickMarkOutsideLengthReturningNegative() throws Throwable  {
        // Given a NumberAxis3D object with default settings
        NumberAxis3D numberAxis3D = new NumberAxis3D();
        
        // When the tick mark outside length is set to -2.0F
        numberAxis3D.setTickMarkOutsideLength((-2.0F));
        
        // Then the getTickMarkOutsideLength method returns the expected value (-2.0F) with a tolerance of 0.01F
        float tickMarkOutsideLength = numberAxis3D.getTickMarkOutsideLength();
        assertEquals((-2.0F), tickMarkOutsideLength, 0.01F);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testGetTickMarkInsideLength() throws Throwable  {
        // Set up the axis with default values
        NumberAxis3D numberAxis3D = new NumberAxis3D();
        
        // Assert that the tick marks are visible and have a length of 2.0F
        assertTrue(numberAxis3D.isTickMarksVisible());
        assertEquals(2.0F, numberAxis3D.getTickMarkOutsideLength(), 0.01F);
        
        // Assert that the axis line is not visible and has a label angle of 0.0
        assertFalse(numberAxis3D.isAxisLineVisible());
        assertEquals(0.0, numberAxis3D.getLabelAngle(), 0.01);
        
        // Assert that the tick mark inside length is 0.0F
        float tickMarkInsideLength = numberAxis3D.getTickMarkInsideLength();
        assertEquals(0.0F, tickMarkInsideLength, 0.01F);
        
        // Assert that the axis is visible
        assertTrue(numberAxis3D.isVisible());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testGetTickLabelPaint() throws Throwable  {
        // Create a new instance of NumberAxis3D and verify its properties
        NumberAxis3D numberAxis3D = new NumberAxis3D();
        
        // Verify that the tick labels are visible by default
        assertTrue(numberAxis3D.isTickLabelsVisible());
        
        // Verify that the tick mark outside length is 2.0F
        assertEquals(2.0F, numberAxis3D.getTickMarkOutsideLength(), 0.01F);
        
        // Verify that the tick mark inside length is 0.0F
        assertEquals(0.0F, numberAxis3D.getTickMarkInsideLength(), 0.01F);
        
        // Verify that the color of the tick label paint is black by default
        Color tickLabelPaint = (Color)numberAxis3D.getTickLabelPaint();
        assertEquals(0, tickLabelPaint.getRed());
        
        // Verify that the axis line is not visible by default
        assertFalse(numberAxis3D.isAxisLineVisible());
        
        // Verify that the label angle is 0.0 by default
        assertEquals(0.0, numberAxis3D.getLabelAngle(), 0.01);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testGetTickLabelInsets() throws Throwable  {
        // Given a CategoryAxis3D object with default settings
        CategoryAxis3D categoryAxis3D = new CategoryAxis3D();
        
        // When the tick marks are visible and tick labels are visible
        categoryAxis3D.setTickMarksVisible(true);
        categoryAxis3D.setTickLabelsVisible(true);
        
        // Then the tick mark outside length is set to 2.0F
        assertEquals(2.0F, categoryAxis3D.getTickMarkOutsideLength(), 0.01F);
        
        // And the axis line is visible
        assertTrue(categoryAxis3D.isAxisLineVisible());
        
        // And the tick mark inside length is set to 0.0F
        assertEquals(0.0F, categoryAxis3D.getTickMarkInsideLength(), 0.01F);
        
        // And the label angle is set to 0.0
        assertEquals(0.0, categoryAxis3D.getLabelAngle(), 0.01);
        
        // And the tick labels are drawn with a top inset of 2.0
        assertEquals(2.0, categoryAxis3D.getTickLabelInsets().getTop(), 0.01);
        
        // And the axis is visible
        assertTrue(categoryAxis3D.isVisible());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testGetTickLabelFont() throws Throwable  {
        // No Comments were added
        NumberAxis3D numberAxis3D = new NumberAxis3D();
        Font tickLabelFont = numberAxis3D.getTickLabelFont();
        assertEquals(0.0, numberAxis3D.getLabelAngle(), 0.01);
        assertTrue(numberAxis3D.isTickMarksVisible());
        assertEquals(2.0F, numberAxis3D.getTickMarkOutsideLength(), 0.01F);
        assertEquals(0.0F, numberAxis3D.getTickMarkInsideLength(), 0.01F);
        assertTrue(numberAxis3D.isTickLabelsVisible());
        assertEquals(10, tickLabelFont.getSize());
        assertTrue(numberAxis3D.isVisible());
        assertFalse(numberAxis3D.isAxisLineVisible());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testGetPlotReturningNull() throws Throwable  {
        // Test the properties of the CyclicNumberAxis class
        // Create a new instance of the CyclicNumberAxis class with some initial values
        CyclicNumberAxis cyclicNumberAxis = new CyclicNumberAxis(230.18720882119, (-1490.203147732349), "e<\"\"f#zgkf");
        
        // Test the plot method
        cyclicNumberAxis.getPlot();
        assertEquals(2.0F, cyclicNumberAxis.getTickMarkOutsideLength(), 0.01F);
        
        // Test the visibility of the axis line and labels
        assertTrue(cyclicNumberAxis.isAxisLineVisible());
        assertTrue(cyclicNumberAxis.isVisible());
        
        // Test the label angle
        assertEquals(0.0, cyclicNumberAxis.getLabelAngle(), 0.01);
        
        // Test the visibility of tick marks and labels
        assertTrue(cyclicNumberAxis.isTickMarksVisible());
        assertEquals(0.0F, cyclicNumberAxis.getTickMarkInsideLength(), 0.01F);
        
        // Test the tick mark outside length
        assertEquals(2.0F, cyclicNumberAxis.getTickMarkOutsideLength(), 0.01F);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testGetPlotReturningPlotWhereIsSubplotIsFalse() throws Throwable  {
        // Create a new ThermometerPlot instance
        ThermometerPlot thermometerPlot = new ThermometerPlot();
        
        // Get the range axis of the plot and check that tick marks are visible
        ValueAxis rangeAxis = thermometerPlot.getRangeAxis();
        assertTrue(rangeAxis.isTickMarksVisible());
        
        // Check that the label angle is 0.0, within a tolerance of 0.01
        assertEquals(0.0, rangeAxis.getLabelAngle(), 0.01);
        
        // Check that the axis line is not visible
        assertFalse(rangeAxis.isAxisLineVisible());
        
        // Check that the axis is visible
        assertTrue(rangeAxis.isVisible());
        
        // Check that tick labels are visible
        assertTrue(rangeAxis.isTickLabelsVisible());
        
        // Check that the inside length of tick marks is 0.0F, within a tolerance of 0.01F
        assertEquals(0.0F, rangeAxis.getTickMarkInsideLength(), 0.01F);
        
        // Check that the outside length of tick marks is 2.0F, within a tolerance of 0.01F
        assertEquals(2.0F, rangeAxis.getTickMarkOutsideLength(), 0.01F);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testGetLabelReturningNull() throws Throwable  {
        // Given a NumberAxis3D object with default properties
        NumberAxis3D numberAxis3D = new NumberAxis3D();
        
        // When the axis is created
        
        // Then the axis line is not visible by default
        assertFalse(numberAxis3D.isAxisLineVisible());
        
        // And the tick marks are not visible by default
        assertTrue(numberAxis3D.isTickMarksVisible());
        
        // And the label angle is 0 degrees by default
        assertEquals(0.0, numberAxis3D.getLabelAngle(), 0.01);
        
        // And the tick mark inside length is 0.0F by default
        assertEquals(0.0F, numberAxis3D.getTickMarkInsideLength(), 0.01F);
        
        // And the tick mark outside length is 2.0F by default
        assertEquals(2.0F, numberAxis3D.getTickMarkOutsideLength(), 0.01F);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testGetLabelReturningNonEmptyString() throws Throwable  {
        // Test that CategoryAxis3D class has correct default values for its properties
        CategoryAxis3D categoryAxis3D = new CategoryAxis3D("N");
        
        // Test that the label angle is 0.0 (i.e., no rotation)
        assertEquals(0.0, categoryAxis3D.getLabelAngle(), 0.01);
        
        // Test that tick marks are not visible by default
        assertFalse(categoryAxis3D.isTickMarksVisible());
        
        // Test that the outside length of the tick mark is equal to 2.0F (i.e., the length of the axis line)
        assertEquals(2.0F, categoryAxis3D.getTickMarkOutsideLength(), 0.01F);
        
        // Test that the inside length of the tick mark is equal to 0.0F (i.e., no inside length)
        assertEquals(0.0F, categoryAxis3D.getTickMarkInsideLength(), 0.01F);
        
        // Test that tick labels are visible by default
        assertTrue(categoryAxis3D.isTickLabelsVisible());
        
        // Test that the axis is visible by default
        assertTrue(categoryAxis3D.isVisible());
        
        // Test that the axis line is visible by default
        assertTrue(categoryAxis3D.isAxisLineVisible());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testGetLabelReturningEmptyString() throws Throwable  {
        // No Comments were added
        CategoryAxis3D categoryAxis3D = new CategoryAxis3D("");
        categoryAxis3D.getLabel();
        assertFalse(categoryAxis3D.isTickMarksVisible());
        assertEquals(0.0, categoryAxis3D.getLabelAngle(), 0.01);
        assertTrue(categoryAxis3D.isVisible());
        assertEquals(2.0F, categoryAxis3D.getTickMarkOutsideLength(), 0.01F);
        assertEquals(0.0F, categoryAxis3D.getTickMarkInsideLength(), 0.01F);
        assertTrue(categoryAxis3D.isTickLabelsVisible());
        assertTrue(categoryAxis3D.isAxisLineVisible());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testGetFixedDimension() throws Throwable  {
        // rollbacked to evosuite
        NumberAxis3D numberAxis3D = new NumberAxis3D();
        double fixedDimension = numberAxis3D.getFixedDimension();
        assertEquals(0.0, fixedDimension, 0.01);
        assertTrue(numberAxis3D.isTickLabelsVisible());
        assertTrue(numberAxis3D.isVisible());
        assertEquals(2.0F, numberAxis3D.getTickMarkOutsideLength(), 0.01F);
        assertEquals(0.0, numberAxis3D.getLabelAngle(), 0.01);
        assertTrue(numberAxis3D.isTickMarksVisible());
        assertFalse(numberAxis3D.isAxisLineVisible());
        assertEquals(0.0F, numberAxis3D.getTickMarkInsideLength(), 0.01F);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testGetAxisLineStroke() throws Throwable  {
        // Set up a NumberAxis3D object for testing
        NumberAxis3D numberAxis3D = new NumberAxis3D();
        
        // Test that the axis line stroke is set correctly
        assertEquals(2.0F, numberAxis3D.getTickMarkOutsideLength(), 0.01F); // The tick mark outside length should be 2.0F
        assertFalse(numberAxis3D.isAxisLineVisible()); // The axis line should not be visible
        
        // Test that the tick labels and marks are visible
        assertTrue(numberAxis3D.isTickLabelsVisible()); // Tick labels should be visible
        assertTrue(numberAxis3D.isTickMarksVisible()); // Tick marks should be visible
        
        // Test that the axis is visible
        assertTrue(numberAxis3D.isVisible()); // The axis should be visible
        
        // Test that the label angle is set correctly
        assertEquals(0.0F, numberAxis3D.getLabelAngle(), 0.01); // The label angle should be 0.0F
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testGetAxisLinePaint() throws Throwable  {
        // Set up a new NumberAxis3D object
        NumberAxis3D numberAxis3D = new NumberAxis3D();
        
        // Get the color of the axis line
        Color axisLinePaint = (Color)numberAxis3D.getAxisLinePaint();
        
        // Assert that the axis line is not visible
        assertFalse(numberAxis3D.isAxisLineVisible());
        
        // Assert that the tick marks are visible
        assertTrue(numberAxis3D.isTickMarksVisible());
        
        // Assert that the tick labels are visible
        assertTrue(numberAxis3D.isTickLabelsVisible());
        
        // Assert that the axis is visible
        assertTrue(numberAxis3D.isVisible());
        
        // Assert that the label angle is 0 degrees
        assertEquals(0.0, numberAxis3D.getLabelAngle(), 0.01);
        
        // Assert that the tick mark outside length is 2.0F
        assertEquals(2.0F, numberAxis3D.getTickMarkOutsideLength(), 0.01F);
        
        // Assert that the tick mark inside length is 0.0F
        assertEquals(0.0F, numberAxis3D.getTickMarkInsideLength(), 0.01F);
        
        // Assert that the color of the axis line is red (255, 0, 0)
        assertEquals(new Color(255, 0, 0), axisLinePaint);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testClone() throws Throwable  {
        // Given a NumberAxis object
        NumberAxis numberAxis = new NumberAxis();
        
        // When cloning the NumberAxis object
        NumberAxis clone = (NumberAxis)numberAxis.clone();
        
        // Then the clone should have the same axis line visibility as the original
        assertTrue(clone.isAxisLineVisible());
        
        // And the clone should have the same tick mark inside length as the original
        assertEquals(0.0F, clone.getTickMarkInsideLength(), 0.01F);
        
        // And the clone should not be the same object as the original
        assertNotSame(clone, numberAxis);
        
        // And the clone should have the same tick mark outside length as the original
        assertEquals(2.0F, clone.getTickMarkOutsideLength(), 0.01F);
        
        // And the clone should have the same visibility for tick labels and tick marks as the original
        assertTrue(clone.isTickLabelsVisible());
        assertTrue(clone.isTickMarksVisible());
        
        // And the clone should be visible
        assertTrue(clone.isVisible());
        
        // And the clone should have the same label angle as the original
        assertEquals(0.0, clone.getLabelAngle(), 0.01);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testSetFixedDimension() throws Throwable  {
        // Test that two CategoryAxis3D objects with the same properties are equal
        CategoryAxis3D arg0 = new CategoryAxis3D();
        CategoryAxis3D categoryAxis3D = new CategoryAxis3D();
        assertTrue(categoryAxis3D.equals((Object)arg0));
        
        // Test that setting a property of one object does not affect the equality of another object with the same properties
        categoryAxis3D.setFixedDimension(0.05);
        boolean equals = categoryAxis3D.equals(arg0);
        assertFalse(equals);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testSetTickMarkOutsideLengthWithPositive() throws Throwable  {
        // rollbacked to evosuite
        CategoryAxis3D arg0 = new CategoryAxis3D();
        CategoryAxis3D categoryAxis3D = new CategoryAxis3D();
        assertEquals(2.0F, categoryAxis3D.getTickMarkOutsideLength(), 0.01F);
        
        categoryAxis3D.setTickMarkOutsideLength(760.432F);
        boolean equals = categoryAxis3D.equals(arg0);
        assertFalse(equals);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testSetTickMarkInsideLength() throws Throwable  {
        // Create two CategoryAxis3D objects, arg0 and categoryAxis3D
        CategoryAxis3D arg0 = new CategoryAxis3D();
        CategoryAxis3D categoryAxis3D = new CategoryAxis3D();
        
        // Set a value for the tickMarkInsideLength property of categoryAxis3D to 2.0F
        categoryAxis3D.setTickMarkInsideLength(2.0F);
        
        // Test if categoryAxis3D is equal to arg0, which should be false because they are different objects
        boolean equals = categoryAxis3D.equals(arg0);
        assertEquals(false, equals);
        
        // Test the value of the tickMarkInsideLength property for categoryAxis3D and compare it to a known value (2.0F) with a tolerance of 0.01F
        assertEquals(2.0F, categoryAxis3D.getTickMarkInsideLength(), 0.01F);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testSetTickMarksVisibleWithTrue() throws Throwable  {
        // Given a CategoryAxis3D instance with tick marks visible set to false
        CategoryAxis3D categoryAxis3D = new CategoryAxis3D();
        assertFalse(categoryAxis3D.isTickMarksVisible());
        
        // When tick marks are set to visible
        categoryAxis3D.setTickMarksVisible(true);
        
        // Then the instance should have tick marks visible set to true
        assertTrue(categoryAxis3D.isTickMarksVisible());
        
        // And the equals method should return false when comparing with a different CategoryAxis3D instance
        CategoryAxis3D other = new CategoryAxis3D();
        assertFalse(categoryAxis3D.equals(other));
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testSetTickLabelInsets() throws Throwable  {
        // No Comments were added
        CategoryAxis3D arg0 = new CategoryAxis3D();
        CategoryAxis3D categoryAxis3D = new CategoryAxis3D();
        assertTrue(categoryAxis3D.equals((Object)arg0));
        
        categoryAxis3D.setTickLabelInsets(arg0.DEFAULT_AXIS_LABEL_INSETS);
        boolean equals = categoryAxis3D.equals(arg0);
        assertFalse(categoryAxis3D.equals((Object)arg0));
        assertFalse(equals);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testSetTickLabelPaint() throws Throwable  {
        // Create a new CategoryAxis3D object
        CategoryAxis3D arg0 = new CategoryAxis3D();
        
        // Create another CategoryAxis3D object with default settings
        CategoryAxis3D categoryAxis3D = new CategoryAxis3D();
        
        // Assert that the two objects are equal (they should be, since they have the same settings)
        assertTrue(categoryAxis3D.equals((Object)arg0));
        
        // Modify one of the objects' properties to make it different from the other object
        categoryAxis3D.setTickLabelPaint(arg0.DEFAULT_TICK_MARK_PAINT);
        
        // Assert that the two objects are no longer equal (they should not be, since they have different settings)
        assertFalse(categoryAxis3D.equals((Object)arg0));
        
        // Check if the modified object is still equal to itself (it should be)
        assertTrue(categoryAxis3D.equals((Object)categoryAxis3D));
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testEqualsAndSetTickLabelFont() throws Throwable  {
        // rollbacked to evosuite
        CategoryAxis3D categoryAxis3D = new CategoryAxis3D();
        CategoryAxis3D arg0 = new CategoryAxis3D();
        assertTrue(arg0.equals((Object)categoryAxis3D));
        
        arg0.setTickLabelFont(categoryAxis3D.DEFAULT_AXIS_LABEL_FONT);
        boolean equals = categoryAxis3D.equals(arg0);
        assertFalse(equals);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testSetAxisLinePaint() throws Throwable  {
        // Given a CategoryAxis3D object and a CategoryAxis3D argument,
        CategoryAxis3D categoryAxis3D = new CategoryAxis3D();
        CategoryAxis3D arg0 = new CategoryAxis3D();
        
        // When the equals method is called with the argument,
        boolean equals = categoryAxis3D.equals(arg0);
        
        // Then the result should be false since the axis line paint has been modified.
        assertFalse(equals);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testSetAxisLineVisible() throws Throwable  {
        // No Comments were added
        CategoryAxis3D arg0 = new CategoryAxis3D();
        CategoryAxis3D categoryAxis3D = new CategoryAxis3D();
        categoryAxis3D.setAxisLineVisible(false);
        boolean equals = categoryAxis3D.equals(arg0);
        assertFalse(categoryAxis3D.isAxisLineVisible());
        assertFalse(equals);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testSetLabelAngle() throws Throwable  {
        // Test that CategoryAxis3D has a correct label angle
        CategoryAxis3D arg0 = new CategoryAxis3D();
        CategoryAxis3D categoryAxis3D = new CategoryAxis3D();
        categoryAxis3D.setLabelAngle(0.2);
        boolean equals = categoryAxis3D.equals(arg0);
        assertEquals(0.2, categoryAxis3D.getLabelAngle(), 0.01); // Assert that the label angle is equal to 0.2 within a tolerance of 0.01
        assertFalse(equals); // Assert that the equals method returns false when comparing two CategoryAxis3D objects with different label angles
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testEqualsAndSetLabelInsets() throws Throwable  {
        // Create a new CategoryAxis3D object and clone it
        CategoryAxis3D categoryAxis3D = new CategoryAxis3D();
        CategoryAxis3D arg0 = (CategoryAxis3D)categoryAxis3D.clone();
        
        // Check if the cloned object is equal to the original object
        assertTrue(arg0.equals((Object)categoryAxis3D));
        
        // Modify the cloned object by setting a new label inset value
        arg0.setLabelInsets(categoryAxis3D.DEFAULT_TICK_LABEL_INSETS);
        
        // Check if the modified cloned object is equal to the original object
        boolean equals = categoryAxis3D.equals(arg0);
        assertFalse(equals);
        
        // Check if the modified cloned object is not equal to the original object
        assertFalse(arg0.equals((Object)categoryAxis3D));
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testEquals() throws Throwable  {
        // No Comments were added
        CategoryAxis3D arg0 = new CategoryAxis3D();
        CategoryAxis3D categoryAxis3D = new CategoryAxis3D("P5fR/\"/i7*~<\u0007+");
        boolean equals = categoryAxis3D.equals(arg0);
        assertEquals(2.0F, categoryAxis3D.getTickMarkOutsideLength(), 0.01F);
        assertFalse(equals);
        assertTrue(categoryAxis3D.isTickLabelsVisible());
        assertEquals(0.0F, categoryAxis3D.getTickMarkInsideLength(), 0.01F);
        assertTrue(categoryAxis3D.isVisible());
        assertEquals(0.0, categoryAxis3D.getLabelAngle(), 0.01);
        assertFalse(categoryAxis3D.isTickMarksVisible());
        assertTrue(categoryAxis3D.isAxisLineVisible());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testEqualsReturningTrue() throws Throwable  {
        // Test that two CategoryAxis3D objects are equal if they have the same properties
        CategoryAxis3D categoryAxis3D = new CategoryAxis3D();
        CategoryAxis3D arg0 = new CategoryAxis3D();
        
        // Test that the axes are equal by using the equals() method
        boolean equals = categoryAxis3D.equals(arg0);
        assertTrue(equals);
        
        // Test that the axis is visible and has tick labels visible
        assertTrue(arg0.isVisible());
        assertTrue(arg0.isTickLabelsVisible());
        
        // Test that the axis line is visible
        assertTrue(arg0.isAxisLineVisible());
        
        // Test that the label angle is 0.0
        assertEquals(0.0, arg0.getLabelAngle(), 0.01);
        
        // Test that the tick marks are not visible
        assertFalse(arg0.isTickMarksVisible());
        
        // Test that the tick mark outside length is 2.0F
        assertEquals(2.0F, arg0.getTickMarkOutsideLength(), 0.01F);
        
        // Test that the tick mark inside length is 0.0F
        assertEquals(0.0F, arg0.getTickMarkInsideLength(), 0.01F);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void test0() throws Throwable  {
        // rollbacked to evosuite
        CombinedDomainCategoryPlot combinedDomainCategoryPlot = new CombinedDomainCategoryPlot();
        RectangleEdge arg4 = combinedDomainCategoryPlot.getRangeAxisEdge(500);
        ExtendedCategoryAxis extendedCategoryAxis = new ExtendedCategoryAxis("^Z7g$A|");
        ChartRenderingInfo arg0 = new ChartRenderingInfo();
        PlotRenderingInfo arg5 = new PlotRenderingInfo(arg0);
        // Undeclared exception!
        try { 
          extendedCategoryAxis.draw((Graphics2D) null, 1.0E-8, (Rectangle2D) null, (Rectangle2D) null, arg4, arg5);
          fail("Expecting exception: NullPointerException");
        
        } catch(NullPointerException e) {
           //
           // no message in exception (getMessage() returned null)
           //
           verifyException("org.jfree.chart.axis.Axis", e);
        }
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void test1() throws Throwable  {
        // Create a new instance of CombinedDomainCategoryPlot
        CombinedDomainCategoryPlot arg2 = new CombinedDomainCategoryPlot();
        
        // Set the orientation of the plot to horizontal
        PlotOrientation arg0 = PlotOrientation.HORIZONTAL;
        arg2.setOrientation(arg0);
        
        // Create a new instance of JFreeChart with the specified parameters
        JFreeChart jFreeChart = new JFreeChart("Null Hlocation' argPment.", arg2.DEFAULT_VALUE_LABEL_FONT, arg2, false);
        
        // Create a buffered image with the specified size
        BufferedImage createBufferedImage = jFreeChart.createBufferedImage(10, 10);
        
        // Check that the y offset of the tile grid is equal to zero
        assertEquals(0, createBufferedImage.getTileGridYOffset());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testGetLabelEnclosure() throws Throwable  {
        CyclicNumberAxis cyclicNumberAxis = new CyclicNumberAxis(2.0F, 2.302585092994046, "Exception while loading module: ");
        RectangleEdge arg1 = Title.DEFAULT_POSITION;
        BufferedImage bufferedImage = new BufferedImage(500, 60, 12);
        Graphics2D arg0 = bufferedImage.createGraphics();
        Rectangle2D.Double labelEnclosure = (Rectangle2D.Double)cyclicNumberAxis.getLabelEnclosure(arg0, arg1);
        
        // Assert that the axis is visible and has tick marks and labels visible
        assertTrue(cyclicNumberAxis.isVisible());
        assertTrue(cyclicNumberAxis.isTickMarksVisible());
        assertTrue(cyclicNumberAxis.isTickLabelsVisible());
        
        // Assert that the label angle is 0 and the tick mark outside length is equal to 2.0F
        assertEquals(0.0, cyclicNumberAxis.getLabelAngle(), 0.01);
        assertEquals(2.0F, cyclicNumberAxis.getTickMarkOutsideLength(), 0.01F);
        
        // Assert that the tick mark inside length is equal to 0 and the label enclosure has a y value of -14.138671875
        assertEquals(0.0F, cyclicNumberAxis.getTickMarkInsideLength(), 0.01F);
        assertEquals((-14.138671875), labelEnclosure.y, 0.01);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testHasListener() throws Throwable  {
        // Given a LogarithmicAxis with custom label and tick mark settings
        LogarithmicAxis logarithmicAxis = new LogarithmicAxis("{OhEN,U!eT?T_n4K%");
        
        // When the properties of the axis are accessed
        boolean listener = logarithmicAxis.hasListener(new DefaultTableXYDataset());
        assertFalse(listener);
        assertTrue(logarithmicAxis.isTickMarksVisible());
        assertEquals(0.0, logarithmicAxis.getLabelAngle(), 0.01);
        assertTrue(logarithmicAxis.isVisible());
        assertTrue(logarithmicAxis.isAxisLineVisible());
        assertEquals(2.0F, logarithmicAxis.getTickMarkOutsideLength(), 0.01F);
        assertTrue(logarithmicAxis.isTickLabelsVisible());
        assertEquals(0.0F, logarithmicAxis.getTickMarkInsideLength(), 0.01F);
        
        // Then the properties of the axis should be properly set
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testRemoveChangeListener0() throws Throwable  {
        // Create a new CategoryAxis3D and set some properties
        CategoryAxis3D categoryAxis3D = new CategoryAxis3D();
        categoryAxis3D.setTickMarkOutsideLength(2.0F);
        categoryAxis3D.setTickMarkInsideLength(0.0F);
        categoryAxis3D.setLabelAngle(0.0);
        categoryAxis3D.setAxisLineVisible(true);
        categoryAxis3D.setVisible(true);
        categoryAxis3D.setTickMarksVisible(false);
        categoryAxis3D.setTickLabelsVisible(true);
        
        // Verify that the properties are set correctly
        assertEquals(2.0F, categoryAxis3D.getTickMarkOutsideLength(), 0.01F);
        assertEquals(0.0F, categoryAxis3D.getTickMarkInsideLength(), 0.01F);
        assertEquals(0.0, categoryAxis3D.getLabelAngle(), 0.01);
        assertTrue(categoryAxis3D.isAxisLineVisible());
        assertTrue(categoryAxis3D.isVisible());
        assertFalse(categoryAxis3D.isTickMarksVisible());
        assertTrue(categoryAxis3D.isTickLabelsVisible());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testRemoveChangeListener1() throws Throwable  {
        // No Comments were added
        ThermometerPlot arg0 = new ThermometerPlot();
        SubCategoryAxis subCategoryAxis = new SubCategoryAxis("*lQ_wZmR m\"wt0");
        subCategoryAxis.removeChangeListener(arg0);
        assertEquals(0.0, subCategoryAxis.getLabelAngle(), 0.01);
        assertTrue(subCategoryAxis.isVisible());
        assertEquals(2.0F, subCategoryAxis.getTickMarkOutsideLength(), 0.01F);
        assertFalse(subCategoryAxis.isTickMarksVisible());
        assertEquals(0.0F, subCategoryAxis.getTickMarkInsideLength(), 0.01F);
        assertTrue(subCategoryAxis.isTickLabelsVisible());
        assertTrue(subCategoryAxis.isAxisLineVisible());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testSetTickMarkPaintThrowsIllegalArgumentException() throws Throwable  {
        // No Comments were added
        NumberAxis3D numberAxis3D = new NumberAxis3D();
        // Undeclared exception!
        try { 
          numberAxis3D.setTickMarkPaint((Paint) null);
          fail("Expecting exception: IllegalArgumentException");
        
        } catch(IllegalArgumentException e) {
           //
           // Null 'paint' argument.
           //
           verifyException("org.jfree.chart.axis.Axis", e);
        }
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testSetTickMarkStrokeThrowsIllegalArgumentException() throws Throwable  {
        // Given: A CategoryAxis3D object is created with a null value for the tickMarkStroke parameter.
        CategoryAxis3D categoryAxis3D = new CategoryAxis3D();
        
        // When: The setTickMarkStroke method is called with a null value.
        try {
        categoryAxis3D.setTickMarkStroke((Stroke) null);
        
        } catch(IllegalArgumentException e) {
        //
        // Null 'stroke' argument.
        //
        verifyException("org.jfree.chart.axis.Axis", e);
        }
        
        // Then: An IllegalArgumentException is thrown and the exception is verified.
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testSetTickMarkStroke() throws Throwable  {
        // Given a CategoryAxis3D instance
        CategoryAxis3D categoryAxis3D = new CategoryAxis3D();
        
        // When the tick mark stroke is set to the default value
        categoryAxis3D.setTickMarkStroke(categoryAxis3D.DEFAULT_TICK_MARK_STROKE);
        
        // Then the tick marks are visible
        assertTrue(categoryAxis3D.isTickLabelsVisible());
        
        // And the tick mark outside length is 2.0F
        assertEquals(2.0F, categoryAxis3D.getTickMarkOutsideLength(), 0.01F);
        
        // And the tick mark inside length is 0.0F
        assertEquals(0.0F, categoryAxis3D.getTickMarkInsideLength(), 0.01F);
        
        // And the axis line is visible
        assertTrue(categoryAxis3D.isVisible());
        
        // And the label angle is 0.0
        assertEquals(0.0, categoryAxis3D.getLabelAngle(), 0.01);
        
        // And the tick marks are not visible
        assertFalse(categoryAxis3D.isTickMarksVisible());
        
        // And the axis line is visible
        assertTrue(categoryAxis3D.isAxisLineVisible());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testSetTickMarksVisibleWithFalse() throws Throwable  {
        // Test that the CategoryAxis3D is initialized with the correct defaults
        CategoryAxis3D categoryAxis3D = new CategoryAxis3D();
        
        // Verify that tick marks are not visible by default
        assertFalse(categoryAxis3D.isTickMarksVisible());
        
        // Verify that the label angle is 0.0 by default
        assertEquals(0.0, categoryAxis3D.getLabelAngle(), 0.01);
        
        // Verify that the axis line is visible by default
        assertTrue(categoryAxis3D.isAxisLineVisible());
        
        // Verify that the tick mark outside length is 2.0 by default
        assertEquals(2.0F, categoryAxis3D.getTickMarkOutsideLength(), 0.01F);
        
        // Verify that the tick mark inside length is 0.0 by default
        assertEquals(0.0F, categoryAxis3D.getTickMarkInsideLength(), 0.01F);
        
        // Verify that tick labels are visible by default
        assertTrue(categoryAxis3D.isTickLabelsVisible());
        
        // Verify that the axis is visible by default
        assertTrue(categoryAxis3D.isVisible());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testSetTickLabelInsetsThrowsIllegalArgumentException() throws Throwable  {
        // Create a new CategoryAxis3D object.
        CategoryAxis3D categoryAxis3D = new CategoryAxis3D();
        
        // Attempt to set the tick label insets to null.
        try {
        // Set the tick label insets to null.
        categoryAxis3D.setTickLabelInsets((RectangleInsets) null);
        
        // Fail the test if an exception is not thrown.
        fail("Expecting exception: IllegalArgumentException");
        
        } catch(IllegalArgumentException e) {
        // Verify that an exception was thrown as expected.
        verifyException("org.jfree.chart.axis.Axis", e);}
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testSetTickLabelPaintThrowsIllegalArgumentException() throws Throwable  {
        LogarithmicAxis logarithmicAxis = new LogarithmicAxis(",");
        // Undeclared exception!
        try {
        logarithmicAxis.setTickLabelPaint((Paint) null);
        fail("Expecting exception: IllegalArgumentException");
        
        } catch(IllegalArgumentException e) {
        // Verify that the expected exception was thrown
        verifyException("org.jfree.chart.axis.Axis", e);
        
        // Test that the exception message is as expected
        assertEquals("Expected 'paint' argument to be non-null", e.getMessage());}
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testSetTickLabelFontThrowsIllegalArgumentException() throws Throwable  {
        CategoryAxis3D categoryAxis3D = new CategoryAxis3D();
        try {
        categoryAxis3D.setTickLabelFont(null);
        fail("Expected exception: IllegalArgumentException");
        } catch (IllegalArgumentException e) {
        verifyException("org.jfree.chart.axis.Axis", e);}
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testSetTickLabelFont() throws Throwable  {
        // Given a CategoryAxis3D instance with default settings
        CategoryAxis3D categoryAxis3D = new CategoryAxis3D();
        
        // When setting the tick label font to a specific value
        categoryAxis3D.setTickLabelFont(categoryAxis3D.DEFAULT_TICK_LABEL_FONT);
        
        // Then the tick mark inside length should be 0.0, the tick mark outside length should be 2.0, and tick labels should be visible
        assertEquals(0.0F, categoryAxis3D.getTickMarkInsideLength(), 0.01F);
        assertEquals(2.0F, categoryAxis3D.getTickMarkOutsideLength(), 0.01F);
        assertTrue(categoryAxis3D.isTickLabelsVisible());
        
        // And the other properties of the axis should remain unchanged
        assertFalse(categoryAxis3D.isTickMarksVisible());
        assertTrue(categoryAxis3D.isVisible());
        assertTrue(categoryAxis3D.isAxisLineVisible());
        assertEquals(0.0, categoryAxis3D.getLabelAngle(), 0.01);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testSetTickLabelsVisibleWithFalse() throws Throwable  {
        // Given
        CategoryAxis3D arg0 = new CategoryAxis3D();
        arg0.setTickLabelsVisible(false);
        
        // When
        CategoryAxis3D categoryAxis3D = new CategoryAxis3D();
        boolean equals = categoryAxis3D.equals(arg0);
        
        // Then
        assertFalse(arg0.isTickLabelsVisible());
        assertFalse(equals);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testSetTickLabelsVisibleWithTrue() throws Throwable  {
        // rollbacked to evosuite
        CategoryAxis3D categoryAxis3D = new CategoryAxis3D();
        assertTrue(categoryAxis3D.isTickLabelsVisible());
        
        categoryAxis3D.setTickLabelsVisible(true);
        assertFalse(categoryAxis3D.isTickMarksVisible());
        assertTrue(categoryAxis3D.isVisible());
        assertEquals(2.0F, categoryAxis3D.getTickMarkOutsideLength(), 0.01F);
        assertEquals(0.0F, categoryAxis3D.getTickMarkInsideLength(), 0.01F);
        assertTrue(categoryAxis3D.isAxisLineVisible());
        assertEquals(0.0, categoryAxis3D.getLabelAngle(), 0.01);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testSetAxisLineStrokeThrowsIllegalArgumentException() throws Throwable  {
        // No Comments were added
        DateAxis dateAxis = new DateAxis();
        // Undeclared exception!
        try { 
          dateAxis.setAxisLineStroke((Stroke) null);
          fail("Expecting exception: IllegalArgumentException");
        
        } catch(IllegalArgumentException e) {
           //
           // Null 'stroke' argument.
           //
           verifyException("org.jfree.chart.axis.Axis", e);
        }
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testSetAxisLinePaintThrowsIllegalArgumentException() throws Throwable  {
        CategoryAxis3D categoryAxis3D = new CategoryAxis3D();
        // Undeclared exception!
        try {
        categoryAxis3D.setAxisLinePaint(null);
        fail("Expecting exception: IllegalArgumentException");
        } catch (IllegalArgumentException e) {
        verifyException("org.jfree.chart.axis.Axis", e);}
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testSetLabelInsetsThrowsIllegalArgumentException() throws Throwable  {
        // Given
        CyclicNumberAxis cyclicNumberAxis = new CyclicNumberAxis((-1030.554031141433));
        
        // When
        try {
        cyclicNumberAxis.setLabelInsets(null);
        fail("Expecting exception: IllegalArgumentException");
        } catch (IllegalArgumentException e) {
        // Then
        verifyException("org.jfree.chart.axis.Axis", e);}
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testSetLabelInsets() throws Throwable  {
        // Given a cyclic number axis with default settings
        CyclicNumberAxis cyclicNumberAxis = new CyclicNumberAxis(0.0);
        
        // When we set the label insets to the default value
        cyclicNumberAxis.setLabelInsets(cyclicNumberAxis.DEFAULT_AXIS_LABEL_INSETS);
        
        // Then the tick mark outside length should be 2.0F, and the tick mark inside length should be 0.0F
        assertEquals(2.0F, cyclicNumberAxis.getTickMarkOutsideLength(), 0.01F);
        assertEquals(0.0F, cyclicNumberAxis.getTickMarkInsideLength(), 0.01F);
        
        // And the tick labels should be visible and the axis line should be visible
        assertTrue(cyclicNumberAxis.isTickLabelsVisible());
        assertTrue(cyclicNumberAxis.isAxisLineVisible());
        
        // And the label angle should be 0.0, and the axis should be visible and the tick marks should be visible
        assertEquals(0.0, cyclicNumberAxis.getLabelAngle(), 0.01);
        assertTrue(cyclicNumberAxis.isVisible());
        assertTrue(cyclicNumberAxis.isTickMarksVisible());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testSetLabelPaintThrowsIllegalArgumentException() throws Throwable  {
        CategoryAxis3D categoryAxis3D = new CategoryAxis3D();
        // Test that a null 'paint' argument throws an IllegalArgumentException.
        try {
        categoryAxis3D.setLabelPaint(null);
        fail("Expecting exception: IllegalArgumentException");
        } catch (IllegalArgumentException e) {
        verifyException("org.jfree.chart.axis.Axis", e);}
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testSetLabelPaint() throws Throwable  {
        // Given the CategoryAxis3D class instance
        CategoryAxis3D categoryAxis3D = new CategoryAxis3D();
        
        // When the default settings are applied to the axis
        categoryAxis3D.setLabelPaint(categoryAxis3D.DEFAULT_TICK_MARK_PAINT);
        
        // Then the axis should be visible and have tick marks and labels visible
        assertTrue(categoryAxis3D.isVisible());
        assertFalse(categoryAxis3D.isTickMarksVisible());
        assertTrue(categoryAxis3D.isTickLabelsVisible());
        
        // And the tick mark outside length should equal 2.0F, with a tolerance of 0.01F
        assertEquals(2.0F, categoryAxis3D.getTickMarkOutsideLength(), 0.01F);
        
        // And the label angle should be 0.0, with a tolerance of 0.01
        assertEquals(0.0, categoryAxis3D.getLabelAngle(), 0.01);
        
        // And the tick mark inside length should equal 0.0F, with a tolerance of 0.01F
        assertEquals(0.0F, categoryAxis3D.getTickMarkInsideLength(), 0.01F);
        
        // And the axis line should be visible
        assertTrue(categoryAxis3D.isAxisLineVisible());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testSetLabelFontThrowsIllegalArgumentException() throws Throwable  {
        // No Comments were added
        CategoryAxis3D categoryAxis3D = new CategoryAxis3D();
        // Undeclared exception!
        try { 
          categoryAxis3D.setLabelFont((Font) null);
          fail("Expecting exception: IllegalArgumentException");
        
        } catch(IllegalArgumentException e) {
           //
           // Null 'font' argument.
           //
           verifyException("org.jfree.chart.axis.Axis", e);
        }
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testSetLabelFont() throws Throwable  {
        // No Comments were added
        CategoryAxis3D categoryAxis3D = new CategoryAxis3D();
        categoryAxis3D.setLabelFont(categoryAxis3D.DEFAULT_TICK_LABEL_FONT);
        CategoryAxis3D arg0 = new CategoryAxis3D();
        boolean equals = categoryAxis3D.equals(arg0);
        assertEquals(2.0F, arg0.getTickMarkOutsideLength(), 0.01F);
        assertTrue(arg0.isTickLabelsVisible());
        assertFalse(arg0.isTickMarksVisible());
        assertEquals(0.0F, arg0.getTickMarkInsideLength(), 0.01F);
        assertTrue(arg0.isAxisLineVisible());
        assertFalse(equals);
        assertEquals(0.0, arg0.getLabelAngle(), 0.01);
        assertFalse(arg0.equals((Object)categoryAxis3D));
        assertTrue(arg0.isVisible());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testSetLabelAndSetLabelWithNonEmptyString0() throws Throwable  {
        // Create a new instance of CyclicNumberAxis with a negative number as the label
        CyclicNumberAxis cyclicNumberAxis = new CyclicNumberAxis(-1019.5247603);
        
        // Set the label for the axis
        cyclicNumberAxis.setLabel("dialog");
        
        // Assert that the tick mark outside length is equal to 2.0F with a delta of 0.01F
        assertEquals(2.0F, cyclicNumberAxis.getTickMarkOutsideLength(), 0.01F);
        
        // Assert that the tick marks are visible
        assertTrue(cyclicNumberAxis.isTickMarksVisible());
        
        // Assert that the axis is visible
        assertTrue(cyclicNumberAxis.isVisible());
        
        // Assert that the label angle is equal to 0.0 with a delta of 0.01
        assertEquals(0.0, cyclicNumberAxis.getLabelAngle(), 0.01);
        
        // Assert that the axis line is visible
        assertTrue(cyclicNumberAxis.isAxisLineVisible());
        
        // Assert that the tick mark inside length is equal to 0.0F with a delta of 0.01F
        assertEquals(0.0F, cyclicNumberAxis.getTickMarkInsideLength(), 0.01F);
        
        // Assert that the tick labels are visible
        assertTrue(cyclicNumberAxis.isTickLabelsVisible());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testSetLabelAndSetLabelWithNull0() throws Throwable  {
        // Given a cyclic number axis with label "e<\"\"f#zgkf" and angle 230.19
        CyclicNumberAxis cyclicNumberAxis = new CyclicNumberAxis(230.19, "e<\"\"f#zgkf");
        
        // When the label is set to null
        cyclicNumberAxis.setLabel((String) null);
        
        // Then the label angle should be 0.0
        assertEquals(0.0, cyclicNumberAxis.getLabelAngle(), 0.01);
        
        // And tick marks are visible
        assertTrue(cyclicNumberAxis.isTickMarksVisible());
        
        // And tick mark inside length should be 0.0F
        assertEquals(0.0F, cyclicNumberAxis.getTickMarkInsideLength(), 0.01F);
        
        // And axis line is visible
        assertTrue(cyclicNumberAxis.isVisible());
        
        // And tick labels are visible
        assertTrue(cyclicNumberAxis.isTickLabelsVisible());
        
        // And tick mark outside length should be 2.0F
        assertEquals(2.0F, cyclicNumberAxis.getTickMarkOutsideLength(), 0.01F);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testSetLabelAndSetLabelWithNonEmptyString1() throws Throwable  {
        // Create a new CategoryAxis3D instance with a label
        CategoryAxis3D categoryAxis3D = new CategoryAxis3D("#@GpyQ/u`S/xV~w");
        
        // Set the label of the axis
        categoryAxis3D.setLabel("#@GpyQ/u`S/xV~w");
        
        // Check that the label angle is 0.0 and the tick labels are visible
        assertEquals(0.0, categoryAxis3D.getLabelAngle(), 0.01);
        assertTrue(categoryAxis3D.isVisible());
        assertTrue(categoryAxis3D.isTickLabelsVisible());
        
        // Check that the tick marks are not visible and the axis line is visible
        assertFalse(categoryAxis3D.isTickMarksVisible());
        assertTrue(categoryAxis3D.isAxisLineVisible());
        
        // Check that the tick mark inside length is 0.0 and the tick mark outside length is 2.0
        assertEquals(0.0F, categoryAxis3D.getTickMarkInsideLength(), 0.01F);
        assertEquals(2.0F, categoryAxis3D.getTickMarkOutsideLength(), 0.01F);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testSetLabelAndSetLabelWithNull1() throws Throwable  {
        // Test the properties of a CategoryAxis3D
        // Given a new CategoryAxis3D instance
        CategoryAxis3D categoryAxis3D = new CategoryAxis3D();
        
        // When we set the label to null
        categoryAxis3D.setLabel(null);
        
        // Then the getLabelAngle method should return 0.0
        assertEquals(0.0, categoryAxis3D.getLabelAngle(), 0.01);
        
        // And the isTickMarksVisible method should return false
        assertFalse(categoryAxis3D.isTickMarksVisible());
        
        // When we set the tick mark outside length to 2.0
        categoryAxis3D.setTickMarkOutsideLength(2.0F);
        
        // Then the getTickMarkOutsideLength method should return 2.0
        assertEquals(2.0, categoryAxis3D.getTickMarkOutsideLength(), 0.01);
        
        // When we set the tick mark inside length to 0.0
        categoryAxis3D.setTickMarkInsideLength(0.0F);
        
        // Then the getTickMarkInsideLength method should return 0.0
        assertEquals(0.0, categoryAxis3D.getTickMarkInsideLength(), 0.01);
        
        // When we set the tick labels visible property to true
        categoryAxis3D.setTickLabelsVisible(true);
        
        // Then the isTickLabelsVisible method should return true
        assertTrue(categoryAxis3D.isTickLabelsVisible());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testSetVisibleWithFalse() throws Throwable  {
        // Given
        CategoryAxis3D categoryAxis3D = new CategoryAxis3D();
        categoryAxis3D.setVisible(false);
        
        // When
        CategoryAxis3D arg0 = new CategoryAxis3D();
        boolean equals = categoryAxis3D.equals(arg0);
        
        // Then
        assertFalse(equals);
        assertFalse(categoryAxis3D.isVisible());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testSetVisibleWithTrue() throws Throwable  {
        // Given a CategoryAxis3D instance
        CategoryAxis3D categoryAxis3D = new CategoryAxis3D();
        
        // When the visibility of the axis is set to true
        categoryAxis3D.setVisible(true);
        
        // Then the tick mark inside length should be 0.0F
        assertEquals(0.0F, categoryAxis3D.getTickMarkInsideLength(), 0.01F);
        
        // And the label angle should be 0.0
        assertEquals(0.0, categoryAxis3D.getLabelAngle(), 0.01);
        
        // And the axis line visibility should be true
        assertTrue(categoryAxis3D.isAxisLineVisible());
        
        // And the tick marks visibility should be false
        assertFalse(categoryAxis3D.isTickMarksVisible());
        
        // And the tick labels visibility should be true
        assertTrue(categoryAxis3D.isTickLabelsVisible());
        
        // And the tick mark outside length should be 2.0F
        assertEquals(2.0F, categoryAxis3D.getTickMarkOutsideLength(), 0.01F);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testGetLabelAngle() throws Throwable  {
        // Test the properties of a CategoryAxis instance
        CategoryAxis categoryAxis = new CategoryAxis();
        
        // Verify the label angle is 0.0
        assertEquals(0.0, categoryAxis.getLabelAngle(), 0.01);
        
        // Verify the tick mark inside length is 0.0F
        assertEquals(0.0F, categoryAxis.getTickMarkInsideLength(), 0.01F);
        
        // Verify the tick mark outside length is 2.0F
        assertEquals(2.0F, categoryAxis.getTickMarkOutsideLength(), 0.01F);
        
        // Verify the visibility of the axis line and tick labels
        assertTrue(categoryAxis.isVisible());
        assertTrue(categoryAxis.isAxisLineVisible());
        assertTrue(categoryAxis.isTickLabelsVisible());
        
        // Verify the visibility of the tick marks is false
        assertFalse(categoryAxis.isTickMarksVisible());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testGetLabelPaint() throws Throwable  {
        // Given a NumberAxis3D object "axis"
        NumberAxis3D axis = new NumberAxis3D();
        
        // When we get the label paint color
        Color labelPaint = (Color)axis.getLabelPaint();
        
        // Then we expect the color to be transparent black
        assertEquals(new Color(0, 0, 0, 0), labelPaint);
        
        // And we expect the tick mark inside length to be 0
        assertEquals(0.0F, axis.getTickMarkInsideLength(), 0.01F);
        
        // And we expect the tick mark outside length to be 2
        assertEquals(2.0F, axis.getTickMarkOutsideLength(), 0.01F);
        
        // And we expect the tick labels to be visible
        assertTrue(axis.isTickLabelsVisible());
        
        // And we expect the tick marks to be visible
        assertTrue(axis.isTickMarksVisible());
        
        // But we do not expect the axis line to be visible
        assertFalse(axis.isAxisLineVisible());
        
        // And we expect the label angle to be 0
        assertEquals(0.0, axis.getLabelAngle(), 0.01);
        
        // And we expect the axis to be visible
        assertTrue(axis.isVisible());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testGetLabelInsets() throws Throwable  {
        // Arrange
        CategoryAxis3D categoryAxis3D = new CategoryAxis3D();
        
        // Act and Assert
        assertTrue(categoryAxis3D.isAxisLineVisible()); // The axis line should be visible by default
        assertTrue(categoryAxis3D.isVisible()); // The axis should be visible by default
        assertFalse(categoryAxis3D.isTickMarksVisible()); // Tick marks should not be visible by default
        assertTrue(categoryAxis3D.isTickLabelsVisible()); // Tick labels should be visible by default
        assertEquals(2.0F, categoryAxis3D.getTickMarkOutsideLength(), 0.01F); // The outside length of the tick marks should be 2.0 by default
        assertEquals(0.0F, categoryAxis3D.getTickMarkInsideLength(), 0.01F); // The inside length of the tick marks should be 0.0 by default
        
        RectangleInsets labelInsets = categoryAxis3D.getLabelInsets();
        assertEquals(3.0, labelInsets.getTop(), 0.01); // The top inset of the label should be 3.0 by default
        assertEquals(0.0, categoryAxis3D.getLabelAngle(), 0.01); // The angle of the labels should be 0.0 by default
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testEqualsAndSetLabelPaint() throws Throwable  {
        CategoryAxis3D categoryAxis3D = new CategoryAxis3D();
        // Create a clone of the original category axis
        CategoryAxis3D cloneAxis = (CategoryAxis3D)categoryAxis3D.clone();
        
        // Test that the clone is equal to the original axis
        assertTrue(cloneAxis.equals((Object)categoryAxis3D));
        
        // Modify the label paint property of the cloned axis
        cloneAxis.setLabelPaint(categoryAxis3D.DEFAULT_TICK_MARK_PAINT);
        
        // Test that the modified clone is not equal to the original axis
        assertFalse(cloneAxis.equals((Object)categoryAxis3D));
        
        // Test that the equals method returns false when comparing a modified clone with the original axis
        boolean equals = categoryAxis3D.equals(cloneAxis);
        assertFalse(equals);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testGetLabelFont() throws Throwable  {
        // rollbacked to evosuite
        NumberAxis3D numberAxis3D = new NumberAxis3D();
        Font labelFont = numberAxis3D.getLabelFont();
        assertTrue(numberAxis3D.isTickLabelsVisible());
        assertTrue(numberAxis3D.isVisible());
        assertEquals(2.0F, numberAxis3D.getTickMarkOutsideLength(), 0.01F);
        assertEquals(0.0, numberAxis3D.getLabelAngle(), 0.01);
        assertTrue(numberAxis3D.isTickMarksVisible());
        assertFalse(numberAxis3D.isAxisLineVisible());
        assertEquals(0.0F, numberAxis3D.getTickMarkInsideLength(), 0.01F);
        assertEquals(12.0F, labelFont.getSize2D(), 0.01F);
    }
  }
  