content: /*
   * This file was automatically generated by UTestGen and EvoSuite
   * Wed Mar 20 05:49:16 GMT 2024
   */
  
  package org.jfree.chart.plot;
  
  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.shaded.org.mockito.Mockito.*;
  import static org.evosuite.runtime.EvoAssertions.*;
  import java.awt.BasicStroke;
  import java.awt.Color;
  import java.awt.Graphics2D;
  import java.awt.GridBagLayout;
  import java.awt.Paint;
  import java.awt.Point;
  import java.awt.Rectangle;
  import java.awt.Stroke;
  import java.awt.geom.Point2D;
  import java.awt.geom.Rectangle2D;
  import java.awt.image.BufferedImage;
  import java.sql.Connection;
  import java.util.ArrayList;
  import java.util.List;
  import java.util.SimpleTimeZone;
  import java.util.TimeZone;
  import java.util.Vector;
  import javax.swing.JViewport;
  import javax.swing.text.DefaultCaret;
  import org.evosuite.runtime.EvoRunner;
  import org.evosuite.runtime.EvoRunnerParameters;
  import org.evosuite.runtime.ViolatedAssumptionAnswer;
  import org.jfree.chart.ChartRenderingInfo;
  import org.jfree.chart.JFreeChart;
  import org.jfree.chart.LegendItemCollection;
  import org.jfree.chart.annotations.XYAnnotation;
  import org.jfree.chart.annotations.XYShapeAnnotation;
  import org.jfree.chart.annotations.XYTextAnnotation;
  import org.jfree.chart.axis.AxisLocation;
  import org.jfree.chart.axis.AxisSpace;
  import org.jfree.chart.axis.ColorBar;
  import org.jfree.chart.axis.CyclicNumberAxis;
  import org.jfree.chart.axis.DateAxis;
  import org.jfree.chart.axis.ModuloAxis;
  import org.jfree.chart.axis.NumberAxis;
  import org.jfree.chart.axis.NumberAxis3D;
  import org.jfree.chart.axis.PeriodAxis;
  import org.jfree.chart.axis.SegmentedTimeline;
  import org.jfree.chart.axis.SymbolAxis;
  import org.jfree.chart.axis.ValueAxis;
  import org.jfree.chart.entity.StandardEntityCollection;
  import org.jfree.chart.plot.CategoryMarker;
  import org.jfree.chart.plot.CategoryPlot;
  import org.jfree.chart.plot.CombinedDomainXYPlot;
  import org.jfree.chart.plot.CombinedRangeCategoryPlot;
  import org.jfree.chart.plot.CombinedRangeXYPlot;
  import org.jfree.chart.plot.CrosshairState;
  import org.jfree.chart.plot.DatasetRenderingOrder;
  import org.jfree.chart.plot.IntervalMarker;
  import org.jfree.chart.plot.Marker;
  import org.jfree.chart.plot.PlotOrientation;
  import org.jfree.chart.plot.PlotRenderingInfo;
  import org.jfree.chart.plot.PlotState;
  import org.jfree.chart.plot.PolarPlot;
  import org.jfree.chart.plot.SeriesRenderingOrder;
  import org.jfree.chart.plot.ThermometerPlot;
  import org.jfree.chart.plot.ValueMarker;
  import org.jfree.chart.plot.XYPlot;
  import org.jfree.chart.renderer.AbstractRenderer;
  import org.jfree.chart.renderer.xy.ClusteredXYBarRenderer;
  import org.jfree.chart.renderer.xy.DefaultXYItemRenderer;
  import org.jfree.chart.renderer.xy.StackedXYBarRenderer;
  import org.jfree.chart.renderer.xy.XYAreaRenderer2;
  import org.jfree.chart.renderer.xy.XYBarRenderer;
  import org.jfree.chart.renderer.xy.XYBlockRenderer;
  import org.jfree.chart.renderer.xy.XYErrorRenderer;
  import org.jfree.chart.renderer.xy.XYItemRenderer;
  import org.jfree.data.Range;
  import org.jfree.data.general.CombinedDataset;
  import org.jfree.data.jdbc.JDBCXYDataset;
  import org.jfree.data.statistics.DefaultBoxAndWhiskerCategoryDataset;
  import org.jfree.data.time.TimeTableXYDataset;
  import org.jfree.data.xy.DefaultTableXYDataset;
  import org.jfree.data.xy.DefaultXYZDataset;
  import org.jfree.data.xy.MatrixSeriesCollection;
  import org.jfree.data.xy.XYDataset;
  import org.jfree.data.xy.XYSeriesCollection;
  import org.jfree.data.xy.YIntervalSeriesCollection;
  import org.jfree.ui.Layer;
  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 XYPlot_ESTest extends XYPlot_ESTest_scaffolding {
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testDrawQuadrants() throws Throwable  {
        // No Comments were added
        Graphics2D graphics2D = null;
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testDrawThrowsNullPointerException() throws Throwable  {
        CombinedDomainXYPlot combinedDomainXYPlot = new CombinedDomainXYPlot();
        Rectangle rect = new Rectangle();
        JViewport viewPort = new JViewport();
        Point viewPosition = viewPort.getViewPosition();
        PlotState plotState = new PlotState();
        StandardEntityCollection entities = new StandardEntityCollection();
        ChartRenderingInfo chartRenderingInfo = new ChartRenderingInfo(entities);
        PlotRenderingInfo plotInfo = chartRenderingInfo.getPlotInfo();
        // Undeclared exception!
        try {
        combinedDomainXYPlot.draw((Graphics2D) null, rect, viewPosition, plotState, plotInfo);
        fail("Expecting exception: NullPointerException");
        
        } catch(NullPointerException e) {
        //
        // no message in exception (getMessage() returned null)
        //
        verifyException("org.jfree.chart.axis.ValueAxis", e);}
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testSetRangeAxisLocationTakingAxisLocation() throws Throwable  {
        // Given a CombinedDomainXYPlot object with a CategoryPlot child plot and a domain axis location set to 10
        CombinedDomainXYPlot combinedDomainXYPlot = new CombinedDomainXYPlot();
        CategoryPlot categoryPlot = new CategoryPlot();
        AxisLocation arg0 = categoryPlot.getDomainAxisLocation(10);
        combinedDomainXYPlot.setRangeAxisLocation(arg0);
        
        // When the range axis location is set to the same value as the domain axis location
        combinedDomainXYPlot.setRangeAxisLocation(arg0);
        
        // Then the CombinedDomainXYPlot object should have its range crosshair locked on data, and the weight of the plot should be 1
        assertTrue(combinedDomainXYPlot.isDomainCrosshairLockedOnData());
        assertEquals(1, combinedDomainXYPlot.getWeight());
        assertTrue(combinedDomainXYPlot.isRangeCrosshairLockedOnData());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testIsDomainCrosshairVisibleReturningTrue() throws Throwable  {
        // Create a new CombinedDomainXYPlot object
        CombinedDomainXYPlot combinedDomainXYPlot = new CombinedDomainXYPlot();
        
        // Set the domain crosshair visibility to true
        combinedDomainXYPlot.setDomainCrosshairVisible(true);
        
        // Verify that the domain crosshair visibility is set correctly
        boolean domainCrosshairVisible = combinedDomainXYPlot.isDomainCrosshairVisible();
        assertTrue(domainCrosshairVisible);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testGetRendererTakingNoArgumentsReturningXYItemRendererWhereGetPassCountIsPositive() throws Throwable  {
        // Given a XYSeriesCollection, SimpleTimeZone, DateAxis, XYErrorRenderer, and an XYPlot
        XYSeriesCollection series = new XYSeriesCollection();
        SimpleTimeZone timeZone = (SimpleTimeZone) SegmentedTimeline.NO_DST_TIME_ZONE;
        DateAxis dateAxis = new DateAxis(">MO]ds", timeZone);
        XYErrorRenderer errorRenderer = new XYErrorRenderer();
        XYPlot plot = new XYPlot(series, dateAxis, dateAxis, errorRenderer);
        
        // When the XYPlot is created with these arguments
        
        
        // Then the XYItemRenderer for the plot should not be null
        assertNotNull(plot.getRenderer());
        
        // And the domain crosshair locking should be enabled on the data
        assertTrue(plot.isDomainCrosshairLockedOnData());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testGetRangeAxisForDatasetReturningNull() throws Throwable  {
        // rollbacked to evosuite
        CombinedDomainXYPlot combinedDomainXYPlot = new CombinedDomainXYPlot();
        combinedDomainXYPlot.getRangeAxisForDataset(0);
        assertTrue(combinedDomainXYPlot.isRangeCrosshairLockedOnData());
        assertEquals(1, combinedDomainXYPlot.getWeight());
        assertTrue(combinedDomainXYPlot.isDomainCrosshairLockedOnData());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testGetRangeAxisForDatasetReturningValueAxisWhereIsNegativeArrowVisibleIsTrue() throws Throwable  {
        // Create a new DateAxis object
        DateAxis dateAxis = new DateAxis();
        
        // Create a new CombinedRangeXYPlot object, passing in the date axis as an argument
        CombinedRangeXYPlot combinedRangeXYPlot = new CombinedRangeXYPlot(dateAxis);
        
        // Set the negative arrow visibility to true for the date axis
        dateAxis.setNegativeArrowVisible(true);
        
        // Get the range axis for dataset 0 from the combined range xy plot
        ValueAxis rangeAxisForDataset = combinedRangeXYPlot.getRangeAxisForDataset(0);
        
        // Assert that the weight of the combined range xy plot is 1
        assertEquals(1, combinedRangeXYPlot.getWeight());
        
        // Assert that the range crosshair is locked on data for the combined range xy plot
        assertTrue(combinedRangeXYPlot.isRangeCrosshairLockedOnData());
        
        // Assert that the range axis for dataset 0 is not null
        assertNotNull(rangeAxisForDataset);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testGetRangeAxisForDatasetReturningValueAxisWhereIsNegativeArrowVisibleIsFalse() throws Throwable  {
        // rollbacked to evosuite
        ThermometerPlot thermometerPlot = new ThermometerPlot();
        ValueAxis arg2 = thermometerPlot.getRangeAxis();
        CombinedDataset arg0 = new CombinedDataset();
        XYBlockRenderer arg3 = new XYBlockRenderer();
        XYPlot xYPlot = new XYPlot(arg0, arg2, arg2, arg3);
        ValueAxis rangeAxisForDataset = xYPlot.getRangeAxisForDataset(0);
        assertNotNull(rangeAxisForDataset);
        assertTrue(xYPlot.isDomainCrosshairLockedOnData());
        assertEquals(1, xYPlot.getWeight());
        assertTrue(xYPlot.isRangeCrosshairLockedOnData());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testGetRangeAxisTakingNoArgumentsReturningNull() throws Throwable  {
        // rollbacked to evosuite
        CombinedRangeXYPlot combinedRangeXYPlot = new CombinedRangeXYPlot((ValueAxis) null);
        combinedRangeXYPlot.getRangeAxis();
        assertEquals(1, combinedRangeXYPlot.getWeight());
        assertTrue(combinedRangeXYPlot.isDomainCrosshairLockedOnData());
        assertTrue(combinedRangeXYPlot.isRangeCrosshairLockedOnData());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testGetRangeAxisTakingNoArgumentsReturningValueAxisWhereGetLowerBoundIsPositive() throws Throwable  {
        // Set up a CyclicNumberAxis with a range of 1642.1550779831 to positive infinity
        CyclicNumberAxis axis = new CyclicNumberAxis(Double.POSITIVE_INFINITY, 1642.1550779831);
        
        // Set the range of the axis to the same value as its initial range
        axis.setRange(1642.1550779831, Double.POSITIVE_INFINITY);
        
        // Create a CombinedRangeXYPlot with the CyclicNumberAxis as the primary axis
        CombinedRangeXYPlot combinedRangeXYPlot = new CombinedRangeXYPlot(axis);
        
        // Get the ValueAxis of the CombinedRangeXYPlot and assert that it is not null
        ValueAxis rangeAxis = combinedRangeXYPlot.getRangeAxis();
        assertNotNull(rangeAxis);
        
        // Assert that the domain crosshair is locked on data in the CombinedRangeXYPlot
        assertTrue(combinedRangeXYPlot.isDomainCrosshairLockedOnData());
        
        // Assert that the range crosshair is locked on data in the CombinedRangeXYPlot
        assertTrue(combinedRangeXYPlot.isRangeCrosshairLockedOnData());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testGetRangeAxisTakingNoArgumentsReturningValueAxisWhereGetLowerBoundIsNegative() throws Throwable  {
        // Given a CyclicNumberAxis instance with a value of 931.2362932587
        CyclicNumberAxis arg0 = new CyclicNumberAxis(931.2362932587);
        
        // When a CombinedRangeXYPlot is created using the instance as its range axis
        CombinedRangeXYPlot combinedRangeXYPlot = new CombinedRangeXYPlot(arg0);
        
        // Then the range axis of the plot should be locked on data
        assertTrue(combinedRangeXYPlot.isRangeCrosshairLockedOnData());
        
        // And the returned plot should have a weight of 1
        assertEquals(1, combinedRangeXYPlot.getWeight());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testGetPlotTypeReturningNonEmptyString() throws Throwable  {
        // Given a CombinedDomainXYPlot object
        CombinedDomainXYPlot combinedDomainXYPlot = new CombinedDomainXYPlot();
        
        // When we call getPlotType() on the plot
        String plotType = combinedDomainXYPlot.getPlotType();
        
        // Then we expect to receive a specific string value
        assertEquals("CombinedDomainXYPlot", plotType);
        
        // And we expect the range crosshair to be locked on data
        assertTrue(combinedDomainXYPlot.isRangeCrosshairLockedOnData());
        
        // And we expect the weight of the plot to be 1
        assertEquals(1, combinedDomainXYPlot.getWeight());
        
        // And we expect the domain crosshair to be locked on data
        assertTrue(combinedDomainXYPlot.isDomainCrosshairLockedOnData());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testGetIndexOfReturningZero() throws Throwable  {
        // Test the constructor of CombinedDomainXYPlot class
        CombinedDomainXYPlot combinedDomainXYPlot = new CombinedDomainXYPlot();
        
        // Test the getIndexOf method with a null XYItemRenderer parameter
        assertThrows(IllegalArgumentException.class, () -> combinedDomainXYPlot.getIndexOf((XYItemRenderer) null));
        
        // Test the isRangeCrosshairLockedOnData method with a value of true
        combinedDomainXYPlot.setRangeCrosshairLockedOnData(true);
        assertTrue(combinedDomainXYPlot.isRangeCrosshairLockedOnData());
        
        // Test the setWeight method with an integer parameter
        combinedDomainXYPlot.setWeight(1);
        assertEquals(1, combinedDomainXYPlot.getWeight());
        
        // Test the isDomainCrosshairLockedOnData method with a value of true
        combinedDomainXYPlot.setDomainCrosshairLockedOnData(true);
        assertTrue(combinedDomainXYPlot.isDomainCrosshairLockedOnData());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testGetIndexOfReturningPositive() throws Throwable  {
        // Given a CombinedDomainXYPlot object
        CombinedDomainXYPlot combinedDomainXYPlot = new CombinedDomainXYPlot();
        
        // When a new XYBarRenderer is added to the plot
        XYBarRenderer xyBarRenderer = new XYBarRenderer(1.0F);
        combinedDomainXYPlot.setRenderer(10, (XYItemRenderer)xyBarRenderer, false);
        
        // Then the renderer should be associated with the index of 10
        int expectedIndex = 10;
        assertEquals(expectedIndex, combinedDomainXYPlot.getIndexOf(xyBarRenderer));
        
        // And the range crosshair should be locked on data
        assertTrue(combinedDomainXYPlot.isRangeCrosshairLockedOnData());
        
        // And the weight of the plot should be 1
        int expectedWeight = 1;
        assertEquals(expectedWeight, combinedDomainXYPlot.getWeight());
        
        // And the domain crosshair should be locked on data
        assertTrue(combinedDomainXYPlot.isDomainCrosshairLockedOnData());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testGetFixedLegendItems() throws Throwable  {
        // rollbacked to evosuite
        CombinedDomainXYPlot combinedDomainXYPlot = new CombinedDomainXYPlot();
        combinedDomainXYPlot.getFixedLegendItems();
        assertTrue(combinedDomainXYPlot.isDomainCrosshairLockedOnData());
        assertEquals(1, combinedDomainXYPlot.getWeight());
        assertTrue(combinedDomainXYPlot.isRangeCrosshairLockedOnData());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testGetFixedDomainAxisSpace() throws Throwable  {
        // Test that the CombinedRangeXYPlot is correctly initialized with a weight of 1 and crosshair locked on data.
        CombinedRangeXYPlot combinedRangeXYPlot = new CombinedRangeXYPlot();
        assertTrue(combinedRangeXYPlot.isRangeCrosshairLockedOnData()); // Test that the range crosshair is locked on data.
        assertTrue(combinedRangeXYPlot.isDomainCrosshairLockedOnData()); // Test that the domain crosshair is locked on data.
        assertEquals(1, combinedRangeXYPlot.getWeight()); // Test that the weight of the plot is 1.
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testSetDomainCrosshairValueTakingDouble() throws Throwable  {
        // Given a CombinedDomainXYPlot object with a domain crosshair value of 0.05
        CombinedDomainXYPlot plot = new CombinedDomainXYPlot();
        plot.setDomainCrosshairValue(0.05);
        
        // When the getDomainCrosshairValue method is called
        double crosshairValue = plot.getDomainCrosshairValue();
        
        // Then the returned value should be equal to the set value with a delta of 0.01
        assertEquals(0.05, crosshairValue, 0.01);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testGetDomainAxisEdgeTakingNoArguments() throws Throwable  {
        // rollbacked to evosuite
        XYPlot xYPlot = new XYPlot();
        xYPlot.getDomainAxisEdge();
        assertTrue(xYPlot.isRangeCrosshairLockedOnData());
        assertEquals(1, xYPlot.getWeight());
        assertTrue(xYPlot.isDomainCrosshairLockedOnData());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testGetDomainAxisTakingIntReturningValueAxisWhereIsAutoTickUnitSelectionIsFalse() throws Throwable  {
        // Given a SymbolAxis with null label and empty string array as arguments
        String[] arg1 = new String[0];
        SymbolAxis arg0 = new SymbolAxis((String) null, arg1);
        
        // When creating a new CombinedDomainXYPlot instance with the SymbolAxis argument
        CombinedDomainXYPlot combinedDomainXYPlot = new CombinedDomainXYPlot(arg0);
        
        // Then the getWeight method should return 1
        assertEquals(1, combinedDomainXYPlot.getWeight());
        
        // And the isDomainCrosshairLockedOnData method should return true
        assertTrue(combinedDomainXYPlot.isDomainCrosshairLockedOnData());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testGetDomainAxisTakingNoArgumentsReturningNull() throws Throwable  {
        // rollbacked to evosuite
        CombinedRangeXYPlot combinedRangeXYPlot = new CombinedRangeXYPlot();
        combinedRangeXYPlot.getDomainAxis();
        assertEquals(1, combinedRangeXYPlot.getWeight());
        assertTrue(combinedRangeXYPlot.isDomainCrosshairLockedOnData());
        assertTrue(combinedRangeXYPlot.isRangeCrosshairLockedOnData());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testGetDomainAxisTakingNoArgumentsReturningValueAxisWhereGetUpperBoundIsZero() throws Throwable  {
        // Test that the dataset has a range of 0 to 3 for the index, as specified by the ModuloAxis constructor.
        DefaultBoxAndWhiskerCategoryDataset defaultBoxAndWhiskerCategoryDataset = new DefaultBoxAndWhiskerCategoryDataset();
        Range arg1 = defaultBoxAndWhiskerCategoryDataset.getRangeBounds(false);
        ModuloAxis arg0 = new ModuloAxis("The index should be in the range 0 to 3.", arg1);
        CombinedDomainXYPlot combinedDomainXYPlot = new CombinedDomainXYPlot(arg0);
        
        // Test that the domain axis of the plot is locked on data.
        assertTrue(combinedDomainXYPlot.isDomainCrosshairLockedOnData());
        
        // Test that the weight of the plot is 1.
        assertEquals(1, combinedDomainXYPlot.getWeight());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testGetDomainAxisTakingNoArgumentsReturningValueAxisWhereGetTickMarkInsideLengthIsNegative() throws Throwable  {
        // No Comments were added
        NumberAxis3D arg0 = new NumberAxis3D("");
        arg0.setTickMarkInsideLength((-1790.2037F));
        CombinedDomainXYPlot combinedDomainXYPlot = new CombinedDomainXYPlot(arg0);
        combinedDomainXYPlot.getDomainAxis();
        assertTrue(combinedDomainXYPlot.isRangeCrosshairLockedOnData());
        assertTrue(combinedDomainXYPlot.isDomainCrosshairLockedOnData());
        assertEquals(1, combinedDomainXYPlot.getWeight());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testGetDomainAxisTakingNoArgumentsReturningValueAxisWhereGetFixedAutoRangeIsPositive() throws Throwable  {
        // Given a CyclicNumberAxis with 10 equally spaced values and a weight of 1
        CyclicNumberAxis arg0 = new CyclicNumberAxis(2177.19695424425, 10);
        
        // When the combinedDomainXYPlot is created with the CyclicNumberAxis
        CombinedDomainXYPlot combinedDomainXYPlot = new CombinedDomainXYPlot(arg0);
        
        // Then the domain axis should be set to the same as the CyclicNumberAxis
        assertEquals(1, combinedDomainXYPlot.getWeight());
        
        // And the range crosshair lock should be locked on data
        assertTrue(combinedDomainXYPlot.isRangeCrosshairLockedOnData());
        
        // And the domain crosshair lock should also be locked on data
        assertTrue(combinedDomainXYPlot.isDomainCrosshairLockedOnData());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testEquals() throws Throwable  {
        // Given a CombinedDomainXYPlot object, when we call its equals method,
        // Then it returns the same instance of the plot.
        CombinedDomainXYPlot plot = new CombinedDomainXYPlot();
        assertSame(plot, plot.equals(plot));
        
        // Given that the domain crosshair is locked on data and range crosshair is locked on data for a CombinedDomainXYPlot object,
        // When we call its isDomainCrosshairLockedOnData method,
        // Then it returns true.
        plot.setDomainCrosshairLockedOnData(true);
        plot.setRangeCrosshairLockedOnData(true);
        assertTrue(plot.isDomainCrosshairLockedOnData());
        
        // Given that the domain crosshair is not locked on data and range crosshair is locked on data for a CombinedDomainXYPlot object,
        // When we call its isDomainCrosshairLockedOnData method,
        // Then it returns false.
        plot.setDomainCrosshairLockedOnData(false);
        assertFalse(plot.isDomainCrosshairLockedOnData());
        
        // Given that the domain crosshair is locked on data and range crosshair is not locked on data for a CombinedDomainXYPlot object,
        // When we call its isRangeCrosshairLockedOnData method,
        // Then it returns false.
        plot.setRangeCrosshairLockedOnData(false);
        assertFalse(plot.isRangeCrosshairLockedOnData());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testGetRangeCrosshairValueReturningNegative() throws Throwable  {
        CombinedDomainXYPlot combinedDomainXYPlot = new CombinedDomainXYPlot();
        // Set the range crosshair value to -930.18689359599
        combinedDomainXYPlot.setRangeCrosshairValue((-930.18689359599), false);
        // Get the current range crosshair value
        double actualRangeCrosshairValue = combinedDomainXYPlot.getRangeCrosshairValue();
        // Assert that the expected and actual values are equal within a tolerance of 0.01
        assertEquals((-930.18689359599), actualRangeCrosshairValue, 0.01);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testGetDomainCrosshairValueReturningNegative() throws Throwable  {
        // Given a CombinedDomainXYPlot instance with a domain crosshair value of -1029.0
        CombinedDomainXYPlot combinedDomainXYPlot = new CombinedDomainXYPlot();
        combinedDomainXYPlot.setDomainCrosshairValue(-1029.0, false);
        
        // When the domain crosshair value is retrieved
        double domainCrosshairValue = combinedDomainXYPlot.getDomainCrosshairValue();
        
        // Then the domain crosshair value should be -1029.0 with a maximum absolute error of 0.01
        assertEquals(-1029.0, domainCrosshairValue, 0.01);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testGetDataRange() throws Throwable  {
        // rollbacked to evosuite
        PeriodAxis arg0 = new PeriodAxis("Null 'stroke' argument.");
        XYBarRenderer arg3 = new XYBarRenderer(0.0);
        XYPlot xYPlot = new XYPlot((XYDataset) null, arg0, arg0, arg3);
        xYPlot.getDataRange(arg0);
        assertTrue(xYPlot.isDomainCrosshairLockedOnData());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testGetRangeAxisIndexReturningNegative() throws Throwable  {
        // Create a new DateAxis object
        DateAxis arg0 = new DateAxis();
        
        // Create a new CombinedDomainXYPlot object
        CombinedDomainXYPlot combinedDomainXYPlot = new CombinedDomainXYPlot();
        
        // Check if the range axis index of the CombinedDomainXYPlot object contains the DateAxis object
        int rangeAxisIndex = combinedDomainXYPlot.getRangeAxisIndex(arg0);
        
        // Assert that the range axis index is -1, indicating that the DateAxis object is not in the range of the CombinedDomainXYPlot object
        assertEquals(-1, rangeAxisIndex);
        
        // Check if the crosshair is locked to the data for both the domain and range axes
        assertTrue(combinedDomainXYPlot.isRangeCrosshairLockedOnData());
        assertTrue(combinedDomainXYPlot.isDomainCrosshairLockedOnData());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testGetRangeAxisIndexReturningZero() throws Throwable  {
        // Given a CombinedDomainXYPlot object
        CombinedDomainXYPlot combinedDomainXYPlot = new CombinedDomainXYPlot();
        
        // When we retrieve the range axis index for the given value axis (null)
        int rangeAxisIndex = combinedDomainXYPlot.getRangeAxisIndex((ValueAxis) null);
        
        // Then the returned index is 0
        assertEquals(0, rangeAxisIndex);
        
        // And the domain crosshair is locked on data
        assertTrue(combinedDomainXYPlot.isDomainCrosshairLockedOnData());
        
        // When we retrieve the weight for the combined domain
        int weight = combinedDomainXYPlot.getWeight();
        
        // Then the returned weight is 1
        assertEquals(1, weight);
        
        // And the range crosshair is locked on data
        assertTrue(combinedDomainXYPlot.isRangeCrosshairLockedOnData());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testGetDomainAxisIndexReturningNegative() throws Throwable  {
        // Given a DateAxis object and a CombinedRangeXYPlot
        DateAxis dateAxis = new DateAxis();
        CombinedRangeXYPlot combinedRangeXYPlot = new CombinedRangeXYPlot();
        
        // When the domain axis is locked to data on the CombinedRangeXYPlot
        int domainAxisIndex = combinedRangeXYPlot.getDomainAxisIndex(dateAxis);
        
        // Then the method returns -1, indicating that the DateAxis is not part of the plot
        assertEquals(-1, domainAxisIndex);
        
        // And the CombinedRangeXYPlot has a weight of 1
        assertEquals(1, combinedRangeXYPlot.getWeight());
        
        // And the range crosshair is locked to data on the CombinedRangeXYPlot
        assertTrue(combinedRangeXYPlot.isRangeCrosshairLockedOnData());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testGetDomainAxisIndexReturningZero() throws Throwable  {
        // Given a CombinedRangeXYPlot object
        CombinedRangeXYPlot combinedRangeXYPlot = new CombinedRangeXYPlot();
        
        // When the domain axis index is obtained for a null ValueAxis
        int domainAxisIndex = combinedRangeXYPlot.getDomainAxisIndex((ValueAxis) null);
        
        // Then the domain axis index should be 0
        assertEquals(0, domainAxisIndex);
        
        // And the range crosshair locking is enabled for the plot
        assertTrue(combinedRangeXYPlot.isRangeCrosshairLockedOnData());
        
        // And the weight of the plot should be 1
        assertEquals(1, combinedRangeXYPlot.getWeight());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testGetRangeMarkersTaking2ArgumentsWithNull() throws Throwable  {
        // rollbacked to evosuite
        CombinedRangeXYPlot combinedRangeXYPlot = new CombinedRangeXYPlot();
        combinedRangeXYPlot.getRangeMarkers(10, (Layer) null);
        assertTrue(combinedRangeXYPlot.isRangeCrosshairLockedOnData());
        assertTrue(combinedRangeXYPlot.isDomainCrosshairLockedOnData());
        assertEquals(1, combinedRangeXYPlot.getWeight());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testGetDomainMarkersTaking2ArgumentsWithPositive() throws Throwable  {
        // rollbacked to evosuite
        CombinedRangeXYPlot combinedRangeXYPlot = new CombinedRangeXYPlot();
        Layer arg1 = Layer.BACKGROUND;
        combinedRangeXYPlot.getDomainMarkers(10, arg1);
        assertTrue(combinedRangeXYPlot.isRangeCrosshairLockedOnData());
        assertEquals(1, combinedRangeXYPlot.getWeight());
        assertTrue(combinedRangeXYPlot.isDomainCrosshairLockedOnData());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testGetDomainMarkersTaking2ArgumentsWithNull() throws Throwable  {
        // Create a DateAxis object
        DateAxis dateAxis = new DateAxis();
        
        // Create a CombinedRangeXYPlot object with the DateAxis as its domain axis
        CombinedRangeXYPlot combinedRangeXYPlot = new CombinedRangeXYPlot(dateAxis);
        
        // Check that the crosshair is locked on data for both the domain and range axes
        assertTrue(combinedRangeXYPlot.isDomainCrosshairLockedOnData());
        assertTrue(combinedRangeXYPlot.isRangeCrosshairLockedOnData());
        
        // Check that the weight of the CombinedRangeXYPlot is 1
        assertEquals(1, combinedRangeXYPlot.getWeight());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testClearRangeMarkersTakingInt() throws Throwable  {
        // Given a CombinedDomainXYPlot instance
        CombinedDomainXYPlot combinedDomainXYPlot = new CombinedDomainXYPlot();
        
        // When clearing range markers with an argument of 10
        combinedDomainXYPlot.clearRangeMarkers(10);
        
        // Then the plot's domain crosshair is locked on data
        assertTrue(combinedDomainXYPlot.isDomainCrosshairLockedOnData());
        
        // And the plot's weight is 1
        assertEquals(1, combinedDomainXYPlot.getWeight());
        
        // And the plot's range crosshair is locked on data
        assertTrue(combinedDomainXYPlot.isRangeCrosshairLockedOnData());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testAddRangeMarkerTaking3ArgumentsAndClearRangeMarkersTakingInt() throws Throwable  {
        // Create a new instance of CombinedRangeXYPlot and add a range marker with the specified category and layer
        CombinedRangeXYPlot combinedRangeXYPlot = new CombinedRangeXYPlot();
        CategoryMarker arg1 = new CategoryMarker("Apple");
        Layer arg2 = Layer.FOREGROUND;
        combinedRangeXYPlot.addRangeMarker(649, (Marker) arg1, arg2);
        
        // Verify that the range marker has been added to the plot and that it is visible
        assertTrue(combinedRangeXYPlot.isDomainCrosshairLockedOnData());
        assertEquals(1, combinedRangeXYPlot.getWeight());
        assertTrue(combinedRangeXYPlot.isRangeCrosshairLockedOnData());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testClearDomainMarkersTakingInt() throws Throwable  {
        // rollbacked to evosuite
        CombinedDomainXYPlot combinedDomainXYPlot = new CombinedDomainXYPlot();
        combinedDomainXYPlot.clearDomainMarkers(10);
        assertTrue(combinedDomainXYPlot.isRangeCrosshairLockedOnData());
        assertEquals(1, combinedDomainXYPlot.getWeight());
        assertTrue(combinedDomainXYPlot.isDomainCrosshairLockedOnData());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testGetRendererForDatasetReturningXYItemRendererWhereGetPassCountIsPositive() throws Throwable  {
        // No Comments were added
        DefaultTableXYDataset arg0 = new DefaultTableXYDataset(false);
        PeriodAxis arg2 = new PeriodAxis("\"<i7A");
        XYAreaRenderer2 arg3 = new XYAreaRenderer2();
        XYPlot xYPlot = new XYPlot(arg0, arg2, arg2, arg3);
        XYItemRenderer rendererForDataset = xYPlot.getRendererForDataset(arg0);
        assertTrue(xYPlot.isDomainCrosshairLockedOnData());
        assertTrue(xYPlot.isRangeCrosshairLockedOnData());
        assertNotNull(rendererForDataset);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testGetRendererForDatasetWithNull() throws Throwable  {
        // rollbacked to evosuite
        CombinedRangeXYPlot combinedRangeXYPlot = new CombinedRangeXYPlot();
        combinedRangeXYPlot.getRendererForDataset((XYDataset) null);
        assertTrue(combinedRangeXYPlot.isDomainCrosshairLockedOnData());
        assertEquals(1, combinedRangeXYPlot.getWeight());
        assertTrue(combinedRangeXYPlot.isRangeCrosshairLockedOnData());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testSetRendererTaking3ArgumentsWithTrue() throws Throwable  {
        // Given a CombinedDomainXYPlot object and two XYBarRenderer objects
        CombinedDomainXYPlot combinedDomainXYPlot = new CombinedDomainXYPlot();
        ClusteredXYBarRenderer renderer1 = new ClusteredXYBarRenderer();
        ClusteredXYBarRenderer renderer2 = new ClusteredXYBarRenderer();
        
        // When the renderer is set to be locked on data for both renderers
        combinedDomainXYPlot.setRenderer(10, (XYItemRenderer) renderer1, false);
        combinedDomainXYPlot.setRenderer(10, (XYItemRenderer) renderer2, true);
        
        // Then the domain crosshair should be locked on data for both renderers
        assertTrue(combinedDomainXYPlot.isDomainCrosshairLockedOnData());
        
        // And the weight of the plot should be 1
        assertEquals(1, combinedDomainXYPlot.getWeight());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testSetRendererTaking3ArgumentsWithNull() throws Throwable  {
        // Create a new combined domain XY plot object
        CombinedDomainXYPlot combinedDomainXYPlot = new CombinedDomainXYPlot();
        
        // Set the renderer for the plot to be null, meaning that no data will be rendered
        combinedDomainXYPlot.setRenderer(989, (XYItemRenderer) null, false);
        
        // Assert that the domain crosshair is locked on data
        assertTrue(combinedDomainXYPlot.isDomainCrosshairLockedOnData());
        
        // Assert that the weight of the plot is 1
        assertEquals(1, combinedDomainXYPlot.getWeight());
        
        // Assert that the range crosshair is locked on data
        assertTrue(combinedDomainXYPlot.isRangeCrosshairLockedOnData());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testGetRendererTakingIntWithNegative() throws Throwable  {
        // Create a new CyclicNumberAxis object with a starting value of 0.0
        CyclicNumberAxis axis = new CyclicNumberAxis(0.0);
        
        // Create a new CombinedDomainXYPlot object and pass the axis as an argument
        CombinedDomainXYPlot combinedPlot = new CombinedDomainXYPlot(axis);
        
        // Test that the plot is locked to the data range for both the domain and range crosshairs
        assertTrue(combinedPlot.isRangeCrosshairLockedOnData());
        assertEquals(1, combinedPlot.getWeight());
        assertTrue(combinedPlot.isDomainCrosshairLockedOnData());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testGetRendererTakingIntWithPositive() throws Throwable  {
        // rollbacked to evosuite
        CombinedDomainXYPlot combinedDomainXYPlot = new CombinedDomainXYPlot();
        combinedDomainXYPlot.getRenderer(106);
        assertEquals(1, combinedDomainXYPlot.getWeight());
        assertTrue(combinedDomainXYPlot.isRangeCrosshairLockedOnData());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testGetDatasetTakingInt() throws Throwable  {
        // rollbacked to evosuite
        CombinedDomainXYPlot combinedDomainXYPlot = new CombinedDomainXYPlot();
        combinedDomainXYPlot.getDataset(500);
        assertTrue(combinedDomainXYPlot.isDomainCrosshairLockedOnData());
        assertEquals(1, combinedDomainXYPlot.getWeight());
        assertTrue(combinedDomainXYPlot.isRangeCrosshairLockedOnData());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testConfigureRangeAxes() throws Throwable  {
        // Given a CombinedDomainXYPlot instance
        CombinedDomainXYPlot combinedDomainXYPlot = new CombinedDomainXYPlot();
        
        // When the range axes are configured
        combinedDomainXYPlot.configureRangeAxes();
        
        // Then the range crosshair is locked on data
        assertTrue(combinedDomainXYPlot.isRangeCrosshairLockedOnData());
        
        // And the weight of the plot is 1
        assertEquals(1, combinedDomainXYPlot.getWeight());
        
        // And the domain crosshair is locked on data
        assertTrue(combinedDomainXYPlot.isDomainCrosshairLockedOnData());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testGetRangeAxisTakingInt0() throws Throwable  {
        // rollbacked to evosuite
        CombinedRangeXYPlot combinedRangeXYPlot = new CombinedRangeXYPlot();
        combinedRangeXYPlot.getRangeAxis(10);
        assertTrue(combinedRangeXYPlot.isRangeCrosshairLockedOnData());
        assertEquals(1, combinedRangeXYPlot.getWeight());
        assertTrue(combinedRangeXYPlot.isDomainCrosshairLockedOnData());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testGetRangeAxisTakingIntReturningValueAxisWhereIsVisibleIsTrue() throws Throwable  {
        // Given a CombinedRangeXYPlot object with a DateAxis and a ValueAxis
        DateAxis dateAxis = new DateAxis();
        CombinedRangeXYPlot combinedRangeXYPlot = new CombinedRangeXYPlot(dateAxis);
        
        // When the range axis is retrieved from the plot
        ValueAxis rangeAxis = combinedRangeXYPlot.getRangeAxis(0);
        
        // Then the range axis should not be null and the crosshairs should be locked on data
        assertNotNull(rangeAxis);
        assertTrue(combinedRangeXYPlot.isDomainCrosshairLockedOnData());
        assertEquals(1, combinedRangeXYPlot.getWeight());
        assertTrue(combinedRangeXYPlot.isRangeCrosshairLockedOnData());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testSetRangeAxisLocationTaking1And1ThrowsIllegalArgumentException() throws Throwable  {
        CombinedDomainXYPlot combinedDomainXYPlot = new CombinedDomainXYPlot();
        // Expecting exception: IllegalArgumentException
        try {
        combinedDomainXYPlot.setRangeAxisLocation(null, false);
        fail("Expecting exception");
        } catch(IllegalArgumentException e) {
        // Verify that the correct exception is thrown
        verifyException("org.jfree.chart.plot.XYPlot", e);}
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testGetDomainAxisLocationTakingIntWithZero() throws Throwable  {
        // Given a CombinedDomainXYPlot with a single dataset
        CombinedDomainXYPlot combinedDomainXYPlot = new CombinedDomainXYPlot();
        
        // When the domain axis location is requested for the first dataset
        AxisLocation domainAxisLocation = combinedDomainXYPlot.getDomainAxisLocation(0);
        
        // Then the domain axis should be located at the bottom or left of the plot
        assertEquals("AxisLocation.BOTTOM_OR_LEFT", domainAxisLocation.toString());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testConfigureDomainAxes() throws Throwable  {
        // Given a DateAxis instance with a specific time zone
        TimeZone timeZone = TimeZone.getTimeZone("|");
        DateAxis dateAxis = new DateAxis("", timeZone);
        
        // When the domain axes are configured on the CombinedRangeXYPlot instance
        CombinedRangeXYPlot combinedRangeXYPlot = new CombinedRangeXYPlot(dateAxis);
        combinedRangeXYPlot.configureDomainAxes();
        
        // Then the range crosshair is locked on data and the weight is set to 1
        assertTrue(combinedRangeXYPlot.isRangeCrosshairLockedOnData());
        assertEquals(1, combinedRangeXYPlot.getWeight());
        
        // And the domain crosshair is also locked on data
        assertTrue(combinedRangeXYPlot.isDomainCrosshairLockedOnData());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testSetDomainAxisLocationTaking1And1AndSetDomainAxisLocationTaking1And10() throws Throwable  {
        // rollbacked to evosuite
        CombinedDomainXYPlot combinedDomainXYPlot = new CombinedDomainXYPlot();
        CombinedRangeCategoryPlot combinedRangeCategoryPlot = new CombinedRangeCategoryPlot();
        AxisLocation arg0 = combinedRangeCategoryPlot.getDomainAxisLocation(10);
        combinedDomainXYPlot.setDomainAxisLocation(arg0, true);
        assertTrue(combinedDomainXYPlot.isRangeCrosshairLockedOnData());
        assertTrue(combinedDomainXYPlot.isDomainCrosshairLockedOnData());
        assertEquals(1, combinedDomainXYPlot.getWeight());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testSetDomainAxisTaking3ArgumentsWithNull() throws Throwable  {
        // Given a CombinedRangeXYPlot object
        CombinedRangeXYPlot combinedRangeXYPlot = new CombinedRangeXYPlot();
        
        // When the domain axis is set to null
        combinedRangeXYPlot.setDomainAxis(0, (ValueAxis) null, false);
        
        // Then the weight of the plot is 1
        assertEquals(1, combinedRangeXYPlot.getWeight());
        
        // And the domain crosshair is locked on data
        assertTrue(combinedRangeXYPlot.isDomainCrosshairLockedOnData());
        
        // And the range crosshair is locked on data
        assertTrue(combinedRangeXYPlot.isRangeCrosshairLockedOnData());
        
        // And the domain axis count is 1
        assertEquals(1, combinedRangeXYPlot.getDomainAxisCount());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testSetDomainAxisTaking3Arguments() throws Throwable  {
        // Given a CombinedDomainXYPlot instance with one domain axis and crosshair locking enabled
        CombinedDomainXYPlot plot = new CombinedDomainXYPlot();
        NumberAxis domainAxis = new NumberAxis();
        plot.setDomainAxis(0, (ValueAxis) domainAxis, false);
        
        // When the domain axis is set and crosshair locking is enabled
        plot.setDomainAxis(0, (ValueAxis) domainAxis, true);
        
        // Then the domain axis count should be 1 and crosshair locking should be enabled
        assertEquals(1, plot.getDomainAxisCount());
        assertTrue(plot.isDomainCrosshairLockedOnData());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testGetDomainAxisTakingIntReturningValueAxisWhereIsAutoTickUnitSelectionIsTrue() throws Throwable  {
        // rollbacked to evosuite
        ColorBar colorBar = new ColorBar("te991t''28");
        ValueAxis arg0 = colorBar.getAxis();
        CombinedDomainXYPlot combinedDomainXYPlot = new CombinedDomainXYPlot(arg0);
        combinedDomainXYPlot.getDomainAxis(0);
        assertTrue(combinedDomainXYPlot.isDomainCrosshairLockedOnData());
        assertTrue(combinedDomainXYPlot.isRangeCrosshairLockedOnData());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testGetDomainAxisTakingIntWithNegative() throws Throwable  {
        // Given a CombinedDomainXYPlot object with a null domain axis
        CombinedDomainXYPlot combinedDomainXYPlot = new CombinedDomainXYPlot();
        
        // When we call the getDomainAxis method with a specific index
        ValueAxis domainAxis = combinedDomainXYPlot.getDomainAxis(1);
        
        // Then the method should return null
        assertNull(domainAxis);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testGetDomainAxisTakingIntWithPositive() throws Throwable  {
        // Given a CombinedDomainXYPlot instance with a domain axis
        CombinedDomainXYPlot combinedDomainXYPlot = new CombinedDomainXYPlot();
        assertNotNull(combinedDomainXYPlot.getDomainAxis());
        
        // When the getDomainAxis method is called with an argument of 10
        combinedDomainXYPlot.getDomainAxis(10);
        
        // Then the crosshair should be locked on data for the domain axis
        assertTrue(combinedDomainXYPlot.isRangeCrosshairLockedOnData());
        
        // And the weight of the plot should be 1
        assertEquals(1, combinedDomainXYPlot.getWeight());
        
        // And the crosshair should be locked on data for the domain axis
        assertTrue(combinedDomainXYPlot.isDomainCrosshairLockedOnData());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testGetRangeTickBandPaintReturningNull() throws Throwable  {
        // rollbacked to evosuite
        CombinedDomainXYPlot combinedDomainXYPlot = new CombinedDomainXYPlot();
        combinedDomainXYPlot.getRangeTickBandPaint();
        assertTrue(combinedDomainXYPlot.isRangeCrosshairLockedOnData());
        assertTrue(combinedDomainXYPlot.isDomainCrosshairLockedOnData());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testSetRendererTaking2Arguments() throws Throwable  {
        // Given a CombinedDomainXYPlot object with a StackedXYBarRenderer
        CombinedDomainXYPlot combinedDomainXYPlot = new CombinedDomainXYPlot();
        StackedXYBarRenderer arg1 = new StackedXYBarRenderer();
        
        // When the renderer is set for the plot
        combinedDomainXYPlot.setRenderer(10, (XYItemRenderer) arg1);
        
        // Then the crosshairs should be locked on data
        assertTrue(combinedDomainXYPlot.isDomainCrosshairLockedOnData());
        assertTrue(combinedDomainXYPlot.isRangeCrosshairLockedOnData());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testMapDatasetToRangeAxis() throws Throwable  {
        // Given a CombinedRangeXYPlot with 10 datasets and a weight of 1
        CombinedRangeXYPlot combinedRangeXYPlot = new CombinedRangeXYPlot();
        combinedRangeXYPlot.mapDatasetToRangeAxis(10, 10);
        
        // When we call the getWeight method
        double weight = combinedRangeXYPlot.getWeight();
        
        // Then the returned weight is 1
        assertEquals(1, weight);
        
        // And the domain crosshair is locked on data
        assertTrue(combinedRangeXYPlot.isDomainCrosshairLockedOnData());
        
        // And the range crosshair is locked on data
        assertTrue(combinedRangeXYPlot.isRangeCrosshairLockedOnData());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testIsRangeZeroBaselineVisible() throws Throwable  {
        // Given a CombinedDomainXYPlot object, which represents a combination of multiple XY plots
        CombinedDomainXYPlot combinedDomainXYPlot = new CombinedDomainXYPlot();
        
        // When the isRangeZeroBaselineVisible method is called on this plot
        boolean isRangeZeroBaselineVisible = combinedDomainXYPlot.isRangeZeroBaselineVisible();
        
        // Then it should return true, indicating that the range zero baseline is visible
        assertTrue(isRangeZeroBaselineVisible);
        
        // Given the CombinedDomainXYPlot object, which has a weight of 1
        int weight = combinedDomainXYPlot.getWeight();
        
        // Then it should return true, indicating that the weight is 1
        assertEquals(1, weight);
        
        // When the areDomainCrosshairLockedOnData method is called on this plot
        boolean isDomainCrosshairLockedOnData = combinedDomainXYPlot.isDomainCrosshairLockedOnData();
        
        // Then it should return true, indicating that the domain crosshair is locked to data
        assertTrue(isDomainCrosshairLockedOnData);
        
        // When the areRangeCrosshairLockedOnData method is called on this plot
        boolean isRangeCrosshairLockedOnData = combinedDomainXYPlot.isRangeCrosshairLockedOnData();
        
        // Then it should return true, indicating that the range crosshair is locked to data
        assertTrue(isRangeCrosshairLockedOnData);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testIsDomainGridlinesVisibleReturningTrue() throws Throwable  {
        // Given a CombinedRangeXYPlot object
        CombinedRangeXYPlot combinedRangeXYPlot = new CombinedRangeXYPlot();
        
        // When we check if the domain gridlines are visible
        boolean domainGridlinesVisible = combinedRangeXYPlot.isDomainGridlinesVisible();
        
        // Then we expect the domain gridlines to be visible
        assertTrue(domainGridlinesVisible);
        
        // And we expect the range crosshair to be locked on data
        assertTrue(combinedRangeXYPlot.isRangeCrosshairLockedOnData());
        
        // And we expect the domain crosshair to be locked on data
        assertTrue(combinedRangeXYPlot.isDomainCrosshairLockedOnData());
        
        // And we expect the weight of the combined plot to be 1
        assertEquals(1, combinedRangeXYPlot.getWeight());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testIsDomainCrosshairVisibleReturningFalse() throws Throwable  {
        // Given a CombinedRangeXYPlot instance
        CombinedRangeXYPlot combinedRangeXYPlot = new CombinedRangeXYPlot();
        
        // When a property of the plot is set
        combinedRangeXYPlot.setDomainCrosshairVisible(true);
        combinedRangeXYPlot.setRangeCrosshairLockedOnData(false);
        
        // Then the properties are set correctly
        assertTrue(combinedRangeXYPlot.getWeight() == 1);
        assertFalse(combinedRangeXYPlot.isDomainCrosshairLockedOnData());
        assertFalse(combinedRangeXYPlot.isRangeCrosshairLockedOnData());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testGetDomainGridlinePaint() throws Throwable  {
        // Create a new combined domain XY plot
        CombinedDomainXYPlot combinedDomainXYPlot = new CombinedDomainXYPlot();
        
        // Check that the weight is set to 1
        assertEquals(1, combinedDomainXYPlot.getWeight());
        
        // Check that the domain crosshair is locked on data
        assertTrue(combinedDomainXYPlot.isDomainCrosshairLockedOnData());
        
        // Check that the range crosshair is locked on data
        assertTrue(combinedDomainXYPlot.isRangeCrosshairLockedOnData());
        
        // Get the domain gridline paint
        Color domainGridlinePaint = (Color) combinedDomainXYPlot.getDomainGridlinePaint();
        
        // Check that the blue value of the domain gridline paint is 192
        assertEquals(192, domainGridlinePaint.getBlue());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testMapDatasetToDomainAxis() throws Throwable  {
        // Given a ModuloAxis with a default range and a CombinedRangeXYPlot instance
        Range arg1 = ValueAxis.DEFAULT_RANGE;
        ModuloAxis arg0 = new ModuloAxis("", arg1);
        CombinedRangeXYPlot combinedRangeXYPlot = new CombinedRangeXYPlot(arg0);
        
        // When we map the dataset to the domain axis and set some properties
        combinedRangeXYPlot.mapDatasetToDomainAxis(15, 2);
        combinedRangeXYPlot.setRangeCrosshairLockedOnData(true);
        combinedRangeXYPlot.setDomainCrosshairLockedOnData(true);
        combinedRangeXYPlot.setWeight(1);
        
        // Then the properties should be set as expected and the crosshairs should be locked on data
        assertTrue(combinedRangeXYPlot.isRangeCrosshairLockedOnData());
        assertTrue(combinedRangeXYPlot.isDomainCrosshairLockedOnData());
        assertEquals(1, combinedRangeXYPlot.getWeight());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testSetDomainAxisTaking2Arguments() throws Throwable  {
        // Given a CombinedDomainXYPlot instance
        CombinedDomainXYPlot plot = new CombinedDomainXYPlot();
        
        // When the domain axis is set
        NumberAxis xAxis = new NumberAxis();
        plot.setDomainAxis(211, (ValueAxis) xAxis);
        
        // Then the domain axis count should be 212
        assertEquals(212, plot.getDomainAxisCount());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testGetRendererTakingNoArgumentsReturningNull() throws Throwable  {
        // rollbacked to evosuite
        CombinedDomainXYPlot combinedDomainXYPlot = new CombinedDomainXYPlot();
        combinedDomainXYPlot.getRenderer();
        assertTrue(combinedDomainXYPlot.isDomainCrosshairLockedOnData());
        assertEquals(1, combinedDomainXYPlot.getWeight());
        assertTrue(combinedDomainXYPlot.isRangeCrosshairLockedOnData());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testGetDatasetCount() throws Throwable  {
        XYPlot xyPlot = new XYPlot();
        // Create a new instance of XYPlot
        
        xyPlot.getDatasetCount();
        // Get the number of datasets in the XYPlot
        
        assertTrue(xyPlot.isRangeCrosshairLockedOnData());
        // Check if the range crosshair is locked on data
        
        assertEquals(1, xyPlot.getWeight());
        // Assert that the weight of the XYPlot is equal to 1
        
        assertTrue(xyPlot.isDomainCrosshairLockedOnData());
        // Check if the domain crosshair is locked on data
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testIsRangeCrosshairVisible() throws Throwable  {
        // rollbacked to evosuite
        CombinedRangeXYPlot combinedRangeXYPlot = new CombinedRangeXYPlot();
        combinedRangeXYPlot.isRangeCrosshairVisible();
        assertTrue(combinedRangeXYPlot.isRangeCrosshairLockedOnData());
        assertEquals(1, combinedRangeXYPlot.getWeight());
        assertTrue(combinedRangeXYPlot.isDomainCrosshairLockedOnData());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testCreatesXYPlotTaking4ArgumentsAndCallsClone() throws Throwable  {
        // Given an XYPlot with a range axis and a crosshair lock
        DateAxis dateAxis = new DateAxis();
        XYErrorRenderer xyErrorRenderer = new XYErrorRenderer();
        DefaultXYZDataset dataset = new DefaultXYZDataset();
        XYPlot plot = new XYPlot(dataset, dateAxis, dateAxis, xyErrorRenderer);
        plot.setRangeCrosshairLockedOnData(true);
        
        // When the plot is cloned
        XYPlot clone = (XYPlot) plot.clone();
        
        // Then the cloned plot should have the same properties as the original plot
        assertEquals(plot.getWeight(), clone.getWeight());
        assertEquals(plot.getRangeAxisCount(), clone.getRangeAxisCount());
        assertTrue(plot.isRangeCrosshairLockedOnData());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testCloneAndSetDatasetTaking2Arguments() throws Throwable  {
        // rollbacked to evosuite
        DateAxis arg0 = new DateAxis();
        CombinedRangeXYPlot combinedRangeXYPlot = new CombinedRangeXYPlot(arg0);
        CombinedDataset arg1 = new CombinedDataset();
        combinedRangeXYPlot.setDataset(500, (XYDataset) arg1);
        combinedRangeXYPlot.clone();
        assertEquals(501, combinedRangeXYPlot.getDatasetCount());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testClone() throws Throwable  {
        // Given a CombinedDomainXYPlot instance with some data and configuration
        CombinedDomainXYPlot combinedDomainXYPlot = new CombinedDomainXYPlot();
        // When we clone the plot
        CombinedDomainXYPlot clonedPlot = (CombinedDomainXYPlot) combinedDomainXYPlot.clone();
        // Then the clone should have the same data and configuration as the original plot
        assertTrue(clonedPlot.isDomainCrosshairLockedOnData());
        assertTrue(combinedDomainXYPlot.equals(clonedPlot));
        assertTrue(clonedPlot.equals((Object) combinedDomainXYPlot));
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testGetLegendItems() throws Throwable  {
        TimeTableXYDataset dataset = new TimeTableXYDataset();
        NumberAxis axisX = new NumberAxis();
        XYPlot plot = new XYPlot(dataset, axisX, axisX, (XYItemRenderer) null);
        
        // Given a valid XYPlot object with a TimeTableXYDataset and NumberAxis objects
        
        plot.getLegendItems();
        
        // When we call getLegendItems() on the plot object
        
        assertTrue(plot.isDomainCrosshairLockedOnData());
        assertTrue(plot.isRangeCrosshairLockedOnData());
        
        // Then we expect the crosshairs to be locked on data, as we have set the domain and range axes to be identical
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testGetSeriesCount() throws Throwable  {
        // Given a CombinedRangeXYPlot object with no series
        CombinedRangeXYPlot combinedRangeXYPlot = new CombinedRangeXYPlot();
        
        // When we get the number of series in the plot
        int seriesCount = combinedRangeXYPlot.getSeriesCount();
        
        // Then the number of series should be 0
        assertEquals(0, seriesCount);
        
        // And the plot should have a weight of 1
        assertEquals(1, combinedRangeXYPlot.getWeight());
        
        // And the domain crosshair should be locked on data
        assertTrue(combinedRangeXYPlot.isDomainCrosshairLockedOnData());
        
        // And the range crosshair should be locked on data
        assertTrue(combinedRangeXYPlot.isRangeCrosshairLockedOnData());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void test0() throws Throwable  {
        // Set up a new CombinedRangeXYPlot instance
        CombinedRangeXYPlot combinedRangeXYPlot = new CombinedRangeXYPlot();
        
        // Create a new StandardEntityCollection for the plot's data
        StandardEntityCollection entityCollection = new StandardEntityCollection();
        ChartRenderingInfo chartRenderingInfo = new ChartRenderingInfo(entityCollection);
        
        // Get the PlotRenderingInfo object for the combined range XY plot
        PlotRenderingInfo plotRenderingInfo = chartRenderingInfo.getPlotInfo();
        
        // Set up a new GridBagLayout instance
        GridBagLayout gridBagLayout = new GridBagLayout();
        
        // Get the layout origin point for the combined range XY plot
        Point layoutOrigin = gridBagLayout.getLayoutOrigin();
        
        // Zoom in on the domain and range axes of the combined range XY plot
        combinedRangeXYPlot.zoomRangeAxes(1321.0, 1321.0, plotRenderingInfo, (Point2D) layoutOrigin);
        
        // Assert that the combined range XY plot has a weight of 1
        assertEquals(1, combinedRangeXYPlot.getWeight());
        
        // Assert that the domain and range axes are locked to the data in the combined range XY plot
        assertTrue(combinedRangeXYPlot.isDomainCrosshairLockedOnData());
        assertTrue(combinedRangeXYPlot.isRangeCrosshairLockedOnData());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testZoomRangeAxesTaking4Arguments() throws Throwable  {
        // rollbacked to evosuite
        ChartRenderingInfo arg0 = new ChartRenderingInfo();
        PlotRenderingInfo arg2 = new PlotRenderingInfo(arg0);
        CombinedRangeXYPlot combinedRangeXYPlot = new CombinedRangeXYPlot((ValueAxis) null);
        combinedRangeXYPlot.zoomRangeAxes((double) 3685, 0.0, arg2, (Point2D) null);
        assertEquals(1, combinedRangeXYPlot.getWeight());
        assertTrue(combinedRangeXYPlot.isDomainCrosshairLockedOnData());
        assertTrue(combinedRangeXYPlot.isRangeCrosshairLockedOnData());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testZoomRangeAxesTaking3Arguments0() throws Throwable  {
        // Create a new instance of the CombinedRangeXYPlot class
        CombinedRangeXYPlot combinedRangeXYPlot = new CombinedRangeXYPlot();
        
        // Create a new instance of the ChartRenderingInfo class
        ChartRenderingInfo chartRenderingInfo = new ChartRenderingInfo();
        
        // Get the PlotRenderingInfo from the chartRenderingInfo object
        PlotRenderingInfo plotRenderingInfo = chartRenderingInfo.getPlotInfo();
        
        // Create a new instance of the GridBagLayout class
        GridBagLayout gridBagLayout = new GridBagLayout();
        
        // Get the layout origin from the gridBagLayout object
        Point layoutOrigin = gridBagLayout.getLayoutOrigin();
        
        // Zoom in on the range axes with a factor of 0.5 using the plotRenderingInfo and layoutOrigin as arguments
        combinedRangeXYPlot.zoomRangeAxes(0.5, plotRenderingInfo, (Point2D) layoutOrigin);
        
        // Check that the weight is set to 1
        assertEquals(1, combinedRangeXYPlot.getWeight());
        
        // Check that the domain crosshair is locked on data
        assertTrue(combinedRangeXYPlot.isDomainCrosshairLockedOnData());
        
        // Check that the range crosshair is locked on data
        assertTrue(combinedRangeXYPlot.isRangeCrosshairLockedOnData());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testZoomRangeAxesTaking3Arguments1() throws Throwable  {
        // Given a CombinedRangeXYPlot and a ChartRenderingInfo object
        CombinedRangeXYPlot combinedRangeXYPlot = new CombinedRangeXYPlot((ValueAxis) null);
        ChartRenderingInfo chartRenderingInfo = new ChartRenderingInfo();
        
        // When we zoom in on the range axes with a scale factor of 0.5 using the plot rendering info and layout origin as arguments
        combinedRangeXYPlot.zoomRangeAxes(0.5, chartRenderingInfo.getPlotInfo(), (Point2D) new Point(100, 100));
        
        // Then we expect the domain crosshair to be locked on the data and the weight to be set to 1
        assertTrue(combinedRangeXYPlot.isDomainCrosshairLockedOnData());
        assertEquals(1, combinedRangeXYPlot.getWeight());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testZoomDomainAxesTaking4ArgumentsWithNonNull() throws Throwable  {
        // Given a ChartRenderingInfo object containing a PlotRenderingInfo object
        ChartRenderingInfo chartRenderingInfo = new ChartRenderingInfo();
        PlotRenderingInfo plotRenderingInfo = chartRenderingInfo.getPlotInfo();
        
        // When the combinedDomainXYPlot is zoomed in on the domain axes with a fixed range of 10
        CombinedDomainXYPlot combinedDomainXYPlot = new CombinedDomainXYPlot((ValueAxis) null);
        combinedDomainXYPlot.zoomDomainAxes((double) 10, (double) 10, plotRenderingInfo, (Point2D) null);
        
        // Then the combinedDomainXYPlot should have its range crosshair locked on data
        assertTrue(combinedDomainXYPlot.isRangeCrosshairLockedOnData());
        
        // And the weight of the combinedDomainXYPlot should be 1
        assertEquals(1, combinedDomainXYPlot.getWeight());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testZoomDomainAxesTaking4ArgumentsWithNull() throws Throwable  {
        // Given a CombinedDomainXYPlot instance with domain and range crosshairs locked on data
        CombinedDomainXYPlot combinedDomainXYPlot = new CombinedDomainXYPlot();
        combinedDomainXYPlot.setDomainCrosshairLockedOnData(true);
        combinedDomainXYPlot.setRangeCrosshairLockedOnData(true);
        
        // When zooming in on the plot using the zoomDomainAxes method
        ChartRenderingInfo chartRenderingInfo = new ChartRenderingInfo();
        PlotRenderingInfo arg2 = chartRenderingInfo.getPlotInfo();
        combinedDomainXYPlot.zoomDomainAxes((double) 400, (double) 400, arg2, (Point2D) null);
        
        // Then the domain crosshair should be locked on data and the weight of the plot should be 1
        assertTrue(combinedDomainXYPlot.isDomainCrosshairLockedOnData());
        assertEquals(1, combinedDomainXYPlot.getWeight());
        
        // And the range crosshair should still be locked on data
        assertTrue(combinedDomainXYPlot.isRangeCrosshairLockedOnData());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testZoomDomainAxesTaking3ArgumentsWithNonNull() throws Throwable  {
        // rollbacked to evosuite
        ChartRenderingInfo chartRenderingInfo = new ChartRenderingInfo();
        PlotRenderingInfo arg1 = chartRenderingInfo.getPlotInfo();
        Point2D.Double arg2 = new Point2D.Double();
        CombinedDomainXYPlot combinedDomainXYPlot = new CombinedDomainXYPlot((ValueAxis) null);
        combinedDomainXYPlot.zoomDomainAxes(1867.43774124, arg1, (Point2D) arg2);
        assertEquals(1, combinedDomainXYPlot.getWeight());
        assertTrue(combinedDomainXYPlot.isDomainCrosshairLockedOnData());
        assertTrue(combinedDomainXYPlot.isRangeCrosshairLockedOnData());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testZoomDomainAxesTaking3ArgumentsWithNull() throws Throwable  {
        // Given a CombinedDomainXYPlot object
        CombinedDomainXYPlot combinedDomainXYPlot = new CombinedDomainXYPlot();
        
        // When the plot is zoomed in with a crosshair lock on the data
        ChartRenderingInfo chartRenderingInfo = new ChartRenderingInfo();
        PlotRenderingInfo arg1 = chartRenderingInfo.getPlotInfo();
        combinedDomainXYPlot.zoomDomainAxes(1.0F, arg1, null);
        
        // Then the domain crosshair is locked on data and the range crosshair is also locked on data
        assertTrue(combinedDomainXYPlot.isDomainCrosshairLockedOnData());
        assertEquals(1, combinedDomainXYPlot.getWeight());
        assertTrue(combinedDomainXYPlot.isRangeCrosshairLockedOnData());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testSetRangeCrosshairValueTaking2ArgumentsAndSetRangeCrosshairVisible() throws Throwable  {
        // Given a CombinedDomainXYPlot instance with range crosshair visible and value set to 3.14F
        CombinedDomainXYPlot combinedDomainXYPlot = new CombinedDomainXYPlot();
        combinedDomainXYPlot.setRangeCrosshairVisible(true);
        combinedDomainXYPlot.setRangeCrosshairValue((double) 3.14F, false);
        
        // When the range crosshair value is retrieved
        double actualRangeCrosshairValue = combinedDomainXYPlot.getRangeCrosshairValue();
        
        // Then the returned value should be equal to 3.140000104904175 with an acceptable margin of error (0.01)
        assertEquals(3.140000104904175, actualRangeCrosshairValue, 0.01);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testSetRangeCrosshairValueTaking2ArgumentsWithTrue() throws Throwable  {
        // rollbacked to evosuite
        CombinedDomainXYPlot combinedDomainXYPlot = new CombinedDomainXYPlot();
        combinedDomainXYPlot.setRangeCrosshairVisible(true);
        combinedDomainXYPlot.setRangeCrosshairValue((double) 100.0F, true);
        assertTrue(combinedDomainXYPlot.isRangeCrosshairVisible());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testSetRangeCrosshairLockedOnDataWithFalse() throws Throwable  {
        // Create a new combined domain XY plot.
        CombinedDomainXYPlot combinedDomainXYPlot = new CombinedDomainXYPlot();
        
        // Assert that the range crosshair is locked on data by default.
        assertTrue(combinedDomainXYPlot.isRangeCrosshairLockedOnData());
        
        // Set the range crosshair to be unlocked from data.
        combinedDomainXYPlot.setRangeCrosshairLockedOnData(false);
        
        // Assert that the range crosshair is no longer locked on data.
        assertFalse(combinedDomainXYPlot.isRangeCrosshairLockedOnData());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testSetRangeCrosshairLockedOnDataWithTrue() throws Throwable  {
        // Given a CombinedDomainXYPlot instance with crosshair locked on data
        CombinedDomainXYPlot combinedDomainXYPlot = new CombinedDomainXYPlot();
        combinedDomainXYPlot.setRangeCrosshairLockedOnData(true);
        
        // When the range crosshair is unlocked
        combinedDomainXYPlot.setRangeCrosshairLockedOnData(false);
        
        // Then the range crosshair should not be locked on data
        assertFalse(combinedDomainXYPlot.isRangeCrosshairLockedOnData());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testSetRangeCrosshairVisibleWithFalse() throws Throwable  {
        // Given a CombinedRangeXYPlot object with crosshair visibility and locking set to false
        CombinedRangeXYPlot combinedRangeXYPlot = new CombinedRangeXYPlot();
        combinedRangeXYPlot.setRangeCrosshairVisible(false);
        combinedRangeXYPlot.setDomainCrosshairVisible(false);
        
        // When the CombinedRangeXYPlot object is instantiated with default values
        
        // Then the crosshair visibility and locking should be set to false by default
        assertFalse(combinedRangeXYPlot.isRangeCrosshairVisible());
        assertFalse(combinedRangeXYPlot.isDomainCrosshairVisible());
        assertFalse(combinedRangeXYPlot.isRangeCrosshairLockedOnData());
        assertFalse(combinedRangeXYPlot.isDomainCrosshairLockedOnData());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testSetDomainCrosshairPaintThrowsIllegalArgumentException() throws Throwable  {
        CombinedDomainXYPlot combinedDomainXYPlot = new CombinedDomainXYPlot();
        // Undeclared exception!
        try {
        // Setting the crosshair paint to null is not allowed.
        combinedDomainXYPlot.setDomainCrosshairPaint((Paint) null);
        fail("Expecting exception: IllegalArgumentException");
        
        } catch(IllegalArgumentException e) {
        //
        // Verifying that the correct exception is thrown.
        //
        verifyException("org.jfree.chart.plot.XYPlot", e);}
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testSetDomainCrosshairPaint() throws Throwable  {
        // Given a CombinedDomainXYPlot instance with a default weight
        CombinedDomainXYPlot combinedDomainXYPlot = new CombinedDomainXYPlot();
        
        // When we set the domain crosshair paint to a specific color
        combinedDomainXYPlot.setDomainCrosshairPaint(Color.darkGray);
        
        // Then the domain crosshair paint should be updated
        assertEquals(Color.darkGray, combinedDomainXYPlot.getDomainCrosshairPaint());
        
        // And the range crosshair lock should not be on data
        assertFalse(combinedDomainXYPlot.isRangeCrosshairLockedOnData());
        
        // And the weight of the plot should remain at 1
        assertEquals(1, combinedDomainXYPlot.getWeight());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testSetDomainCrosshairStrokeThrowsIllegalArgumentException() throws Throwable  {
        CombinedRangeXYPlot combinedRangeXYPlot = new CombinedRangeXYPlot();
        try {
        combinedRangeXYPlot.setDomainCrosshairStroke(null);
        fail("Expecting exception: IllegalArgumentException");
        } catch (IllegalArgumentException e) {
        verifyException("org.jfree.chart.plot.XYPlot", e);}
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testSetDomainCrosshairLockedOnDataWithFalse() throws Throwable  {
        // Given a CombinedDomainXYPlot object,
        CombinedDomainXYPlot combinedDomainXYPlot = new CombinedDomainXYPlot();
        
        // When the domain crosshair is locked on data,
        combinedDomainXYPlot.setDomainCrosshairLockedOnData(false);
        
        // Then the domain crosshair should be unlocked on data,
        assertFalse(combinedDomainXYPlot.isDomainCrosshairLockedOnData());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testSetDomainCrosshairLockedOnDataWithTrue() throws Throwable  {
        // Given: A CombinedRangeXYPlot instance is created with the default settings.
        CombinedRangeXYPlot combinedRangeXYPlot = new CombinedRangeXYPlot();
        
        // When: The domain crosshair is locked on data and the range crosshair is also locked on data.
        combinedRangeXYPlot.setDomainCrosshairLockedOnData(true);
        assertTrue(combinedRangeXYPlot.isDomainCrosshairLockedOnData());
        assertTrue(combinedRangeXYPlot.isRangeCrosshairLockedOnData());
        
        // Then: The weight of the plot is equal to 1.
        assertEquals(1, combinedRangeXYPlot.getWeight());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testSetDomainCrosshairValueTaking2ArgumentsWithPositiveAndTrue() throws Throwable  {
        // Given a CombinedDomainXYPlot instance with domainCrosshairVisible set to true
        CombinedDomainXYPlot combinedDomainXYPlot = new CombinedDomainXYPlot();
        combinedDomainXYPlot.setDomainCrosshairVisible(true);
        
        // When the domainCrosshairValue is set to 1000.0
        combinedDomainXYPlot.setDomainCrosshairValue(1000.0, true);
        
        // Then the domainCrosshairValue should be equal to 1000.0 within a tolerance of 0.01
        assertEquals(1000.0, combinedDomainXYPlot.getDomainCrosshairValue(), 0.01);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testSetDomainCrosshairVisibleWithFalse() throws Throwable  {
        // Given: A new instance of CombinedDomainXYPlot
        CombinedDomainXYPlot combinedDomainXYPlot = new CombinedDomainXYPlot();
        
        // When: The domain crosshair is set to visible false and the range crosshair is locked on data true
        combinedDomainXYPlot.setDomainCrosshairVisible(false);
        combinedDomainXYPlot.setRangeCrosshairLockedOnData(true);
        
        // Then: The domain crosshair is not visible, the range crosshair is locked on data, and the weight of the plot is 1
        assertFalse(combinedDomainXYPlot.isDomainCrosshairVisible());
        assertTrue(combinedDomainXYPlot.isRangeCrosshairLockedOnData());
        assertEquals(1, combinedDomainXYPlot.getWeight());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testSetRangeAxisTaking3Arguments() throws Throwable  {
        // Given a DateAxis object and an XYPlot object
        DateAxis dateAxis = new DateAxis();
        XYPlot xyPlot = new XYPlot();
        
        // When the setRangeAxis method is called with the DateAxis object as an argument and the third parameter as true
        xyPlot.setRangeAxis(3, (ValueAxis)dateAxis, true);
        
        // Then the range axis count of the XYPlot should be 4
        assertEquals(4, xyPlot.getRangeAxisCount());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testSetDomainAxisTaking3ArgumentsWithTrue() throws Throwable  {
        // Given: a new XYPlot object and a CyclicNumberAxis with a lower bound of -9.0
        XYPlot xyPlot = new XYPlot();
        CyclicNumberAxis axis = new CyclicNumberAxis(10, 1.0F);
        
        // When: the domain axis is set to the CyclicNumberAxis object
        xyPlot.setDomainAxis(10, (ValueAxis) axis, true);
        
        // Then: the lower bound of the domain axis should be -9.0
        assertEquals(-9.0, axis.getLowerBound(), 0.01);
        
        // And: the range crosshair is locked on data
        assertTrue(xyPlot.isRangeCrosshairLockedOnData());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testHandleClick() throws Throwable  {
        // No Comments were added
        XYPlot xYPlot = new XYPlot();
        ChartRenderingInfo arg0 = new ChartRenderingInfo();
        PlotRenderingInfo arg2 = new PlotRenderingInfo(arg0);
        xYPlot.handleClick(10, 10, arg2);
        assertTrue(xYPlot.isDomainCrosshairLockedOnData());
        assertTrue(xYPlot.isRangeCrosshairLockedOnData());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testDrawRangeCrosshairThrowsNullPointerException() throws Throwable  {
        CombinedRangeXYPlot combinedRangeXYPlot = new CombinedRangeXYPlot();
        Rectangle rectangle = new Rectangle(10, 10, 10, 10);
        CyclicNumberAxis cyclicNumberAxis = new CyclicNumberAxis(10, "org.jfree.chart.entity.XYAnnotationEntity");
        PolarPlot polarPlot = new PolarPlot();
        PlotOrientation orientation = polarPlot.getOrientation();
        // Undeclared exception!
        try {
        combinedRangeXYPlot.drawRangeCrosshair((Graphics2D) null, rectangle, orientation, 1.0F, cyclicNumberAxis, cyclicNumberAxis.DEFAULT_ADVANCE_LINE_STROKE, cyclicNumberAxis.DEFAULT_AXIS_LABEL_PAINT);
        fail("Expecting exception: NullPointerException");
        } catch(NullPointerException e) {
        //
        // no message in exception (getMessage() returned null)
        //
        verifyException("org.jfree.chart.plot.XYPlot", e);}
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testGetOrientation() throws Throwable  {
        // Create a new CombinedRangeXYPlot and a Rectangle for the plot area
        CombinedRangeXYPlot combinedRangeXYPlot = new CombinedRangeXYPlot();
        Rectangle plotArea = new Rectangle(10, 10, 10, 10);
        
        // Set the orientation of the plot and create a NumberAxis for the domain axis
        PlotOrientation orientation = combinedRangeXYPlot.getOrientation();
        NumberAxis domainAxis = new NumberAxis();
        
        // Draw the range crosshair on the plot area with the default settings
        combinedRangeXYPlot.drawRangeCrosshair(null, plotArea, orientation, 10, domainAxis, domainAxis.DEFAULT_AXIS_LINE_STROKE, domainAxis.DEFAULT_TICK_MARK_PAINT);
        
        // Assert that the crosshair is locked on the data and has a weight of 1
        assertTrue(combinedRangeXYPlot.isDomainCrosshairLockedOnData());
        assertEquals(1, combinedRangeXYPlot.getWeight());
        
        // Assert that the range crosshair is also locked on the data
        assertTrue(combinedRangeXYPlot.isRangeCrosshairLockedOnData());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testDrawVerticalLineWithNonNullAndZero() throws Throwable  {
        // Arrange
        CombinedDomainXYPlot combinedDomainXYPlot = new CombinedDomainXYPlot();
        CyclicNumberAxis cyclicNumberAxis = new CyclicNumberAxis((-167.808697), 10);
        JFreeChart jFreeChart = new JFreeChart("u@", cyclicNumberAxis.DEFAULT_TICK_LABEL_FONT, combinedDomainXYPlot, false);
        ChartRenderingInfo chartRenderingInfo = new ChartRenderingInfo();
        BufferedImage bufferedImage = jFreeChart.createBufferedImage(805, 500, 1.0, 0.0, chartRenderingInfo);
        Graphics2D graphics2D = bufferedImage.createGraphics();
        Rectangle2D.Double rectangle2D = new Rectangle2D.Double();
        combinedDomainXYPlot.drawVerticalLine(graphics2D, rectangle2D, 0.0, cyclicNumberAxis.DEFAULT_TICK_MARK_STROKE, combinedDomainXYPlot.DEFAULT_GRIDLINE_PAINT);
        
        // Act
        boolean isDomainCrosshairLockedOnData = combinedDomainXYPlot.isDomainCrosshairLockedOnData();
        int weight = combinedDomainXYPlot.getWeight();
        
        // Assert
        assertTrue(isDomainCrosshairLockedOnData);
        assertEquals(1, weight);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testDrawVerticalLineWithNullAndPositive() throws Throwable  {
        // rollbacked to evosuite
        Rectangle2D.Double arg1 = new Rectangle2D.Double();
        NumberAxis numberAxis = new NumberAxis();
        CombinedDomainXYPlot combinedDomainXYPlot = new CombinedDomainXYPlot();
        combinedDomainXYPlot.drawVerticalLine((Graphics2D) null, arg1, 2.0F, numberAxis.DEFAULT_TICK_MARK_STROKE, numberAxis.DEFAULT_TICK_MARK_PAINT);
        assertTrue(combinedDomainXYPlot.isRangeCrosshairLockedOnData());
        assertEquals(1, combinedDomainXYPlot.getWeight());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testDrawDomainCrosshair() throws Throwable  {
        // rollbacked to evosuite
        CombinedDomainXYPlot combinedDomainXYPlot = new CombinedDomainXYPlot();
        StandardEntityCollection arg0 = new StandardEntityCollection();
        ChartRenderingInfo chartRenderingInfo = new ChartRenderingInfo(arg0);
        PlotRenderingInfo plotInfo = chartRenderingInfo.getPlotInfo();
        Rectangle2D arg1 = plotInfo.getDataArea();
        PlotOrientation arg2 = PlotOrientation.VERTICAL;
        CyclicNumberAxis arg4 = new CyclicNumberAxis(0.0, (String) null);
        combinedDomainXYPlot.drawDomainCrosshair((Graphics2D) null, arg1, arg2, 3208.16, arg4, arg4.DEFAULT_AXIS_LINE_STROKE, arg4.DEFAULT_ADVANCE_LINE_PAINT);
        assertTrue(combinedDomainXYPlot.isRangeCrosshairLockedOnData());
        assertTrue(combinedDomainXYPlot.isDomainCrosshairLockedOnData());
        assertEquals(1, combinedDomainXYPlot.getWeight());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testDrawHorizontalLine() throws Throwable  {
        // Given a CombinedRangeXYPlot object
        CombinedRangeXYPlot combinedRangeXYPlot = new CombinedRangeXYPlot();
        
        // When the drawHorizontalLine method is called with some arguments
        Rectangle arg1 = new Rectangle(10, 10);
        CyclicNumberAxis cyclicNumberAxis = new CyclicNumberAxis(10, "C6$ROk<Wg'6xixD$(N");
        combinedRangeXYPlot.drawHorizontalLine((Graphics2D) null, arg1, 10, cyclicNumberAxis.DEFAULT_AXIS_LINE_STROKE, cyclicNumberAxis.DEFAULT_TICK_LABEL_PAINT);
        
        // Then the domain crosshair is locked on data and the range crosshair is also locked on data
        assertTrue(combinedRangeXYPlot.isDomainCrosshairLockedOnData());
        assertEquals(1, combinedRangeXYPlot.getWeight());
        assertTrue(combinedRangeXYPlot.isRangeCrosshairLockedOnData());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testGetRangeMarkersTaking2Arguments0() throws Throwable  {
        // rollbacked to evosuite
        CombinedRangeXYPlot combinedRangeXYPlot = new CombinedRangeXYPlot();
        Layer arg1 = Layer.BACKGROUND;
        combinedRangeXYPlot.getRangeMarkers(61, arg1);
        assertTrue(combinedRangeXYPlot.isRangeCrosshairLockedOnData());
        assertEquals(1, combinedRangeXYPlot.getWeight());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testGetRangeMarkersTaking2Arguments1() throws Throwable  {
        // Create a new CombinedDomainXYPlot instance
        CombinedDomainXYPlot combinedDomainXYPlot = new CombinedDomainXYPlot();
        
        // Set the layer to FOREGROUND
        Layer arg1 = Layer.FOREGROUND;
        
        // Call getRangeMarkers with 3 as the first argument and FOREGROUND as the second argument
        combinedDomainXYPlot.getRangeMarkers(3, arg1);
        
        // Assert that the range crosshair is locked on data
        assertTrue(combinedDomainXYPlot.isRangeCrosshairLockedOnData());
        
        // Assert that the weight is 1
        assertEquals(1, combinedDomainXYPlot.getWeight());
        
        // Assert that the domain crosshair is locked on data
        assertTrue(combinedDomainXYPlot.isDomainCrosshairLockedOnData());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testGetDomainMarkersTakingLayer() throws Throwable  {
        // rollbacked to evosuite
        CombinedRangeXYPlot combinedRangeXYPlot = new CombinedRangeXYPlot();
        Layer arg0 = Layer.BACKGROUND;
        combinedRangeXYPlot.getDomainMarkers(arg0);
        assertEquals(1, combinedRangeXYPlot.getWeight());
        assertTrue(combinedRangeXYPlot.isRangeCrosshairLockedOnData());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testGetDomainMarkersTaking2Arguments() throws Throwable  {
        // rollbacked to evosuite
        CombinedRangeXYPlot combinedRangeXYPlot = new CombinedRangeXYPlot();
        Layer arg1 = Layer.FOREGROUND;
        combinedRangeXYPlot.getDomainMarkers((-1377), arg1);
        assertTrue(combinedRangeXYPlot.isRangeCrosshairLockedOnData());
        assertEquals(1, combinedRangeXYPlot.getWeight());
        assertTrue(combinedRangeXYPlot.isDomainCrosshairLockedOnData());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testDrawRangeMarkers() throws Throwable  {
        // Given a CombinedRangeXYPlot instance with some data and properties set
        CombinedRangeXYPlot combinedRangeXYPlot = new CombinedRangeXYPlot();
        Rectangle2D.Double arg1 = new Rectangle2D.Double();
        Layer arg3 = Layer.BACKGROUND;
        
        // When the drawRangeMarkers() method is called with a Graphics2D instance and some arguments
        combinedRangeXYPlot.drawRangeMarkers((Graphics2D) null, arg1, 10, arg3);
        
        // Then the range crosshair should be locked on data
        assertTrue(combinedRangeXYPlot.isRangeCrosshairLockedOnData());
        
        // And the weight of the CombinedRangeXYPlot instance should be equal to 1
        assertEquals(1, combinedRangeXYPlot.getWeight());
        
        // And the domain crosshair should also be locked on data
        assertTrue(combinedRangeXYPlot.isDomainCrosshairLockedOnData());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testDrawDomainMarkers() throws Throwable  {
        Rectangle2D.Double rect = new Rectangle2D.Double();
        Layer layer = Layer.FOREGROUND;
        CombinedRangeXYPlot combinedRangeXYPlot = new CombinedRangeXYPlot();
        
        // Test that the domain markers are drawn correctly
        combinedRangeXYPlot.drawDomainMarkers((Graphics2D) null, rect, 10, layer);
        assertEquals(1, combinedRangeXYPlot.getWeight());
        
        // Test that the domain crosshair is locked on data
        assertTrue(combinedRangeXYPlot.isDomainCrosshairLockedOnData());
        
        // Test that the range crosshair is locked on data
        assertTrue(combinedRangeXYPlot.isRangeCrosshairLockedOnData());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testDrawAnnotations() throws Throwable  {
        // Create a new combined range XY plot and render it on a chart.
        CombinedRangeXYPlot combinedRangeXYPlot = new CombinedRangeXYPlot();
        ChartRenderingInfo chartRenderingInfo = new ChartRenderingInfo();
        
        // Get the plot rendering info for the combined range XY plot.
        PlotRenderingInfo arg2 = chartRenderingInfo.getPlotInfo();
        
        // Draw annotations on the combined range XY plot using a Graphics2D object.
        combinedRangeXYPlot.drawAnnotations((Graphics2D) null, new Rectangle2D.Double(), arg2);
        
        // Check that the domain crosshair is locked to data in the combined range XY plot.
        assertTrue(combinedRangeXYPlot.isDomainCrosshairLockedOnData());
        
        // Check that the weight of the combined range XY plot is 1.
        assertEquals(1, combinedRangeXYPlot.getWeight());
        
        // Check that the range crosshair is locked to data in the combined range XY plot.
        assertTrue(combinedRangeXYPlot.isRangeCrosshairLockedOnData());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testDrawRangeGridlinesThrowsNullPointerException() throws Throwable  {
        // Setup
        Rectangle2D.Double arg1 = new Rectangle2D.Double();
        Vector<XYTextAnnotation> arg2 = new Vector<XYTextAnnotation>();
        arg2.add((XYTextAnnotation) null);
        CombinedRangeXYPlot combinedRangeXYPlot = new CombinedRangeXYPlot();
        
        // Test: Pass a null graphics object to the method, which should throw a NullPointerException
        try {
        combinedRangeXYPlot.drawRangeGridlines((Graphics2D) null, arg1, arg2);
        fail("Expected exception: NullPointerException");
        
        } catch(NullPointerException e) {
        // Verify that the exception is thrown due to a null graphics object being passed as an argument
        verifyException("org.jfree.chart.plot.XYPlot", e);}
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testDrawRangeGridlines0() throws Throwable  {
        // No Comments were added
        Rectangle2D.Double arg1 = new Rectangle2D.Double();
        Vector<XYTextAnnotation> arg2 = new Vector<XYTextAnnotation>();
        CombinedRangeXYPlot combinedRangeXYPlot = new CombinedRangeXYPlot((ValueAxis) null);
        combinedRangeXYPlot.drawRangeGridlines((Graphics2D) null, arg1, arg2);
        assertTrue(combinedRangeXYPlot.isDomainCrosshairLockedOnData());
        assertTrue(combinedRangeXYPlot.isRangeCrosshairLockedOnData());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testDrawRangeGridlines1() throws Throwable  {
        // No Comments were added
        ArrayList<XYTextAnnotation> arg2 = new ArrayList<XYTextAnnotation>();
        Rectangle2D.Float arg1 = new Rectangle2D.Float();
        CombinedRangeXYPlot combinedRangeXYPlot = new CombinedRangeXYPlot();
        combinedRangeXYPlot.drawRangeGridlines((Graphics2D) null, arg1, arg2);
        assertTrue(combinedRangeXYPlot.isRangeCrosshairLockedOnData());
        assertTrue(combinedRangeXYPlot.isDomainCrosshairLockedOnData());
        assertEquals(1, combinedRangeXYPlot.getWeight());
        assertTrue(combinedRangeXYPlot.isRangeGridlinesVisible());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testDrawDomainGridlines() throws Throwable  {
        // rollbacked to evosuite
        CombinedDomainXYPlot combinedDomainXYPlot = new CombinedDomainXYPlot();
        combinedDomainXYPlot.drawDomainGridlines((Graphics2D) null, (Rectangle2D) null, (List) null);
        assertTrue(combinedDomainXYPlot.isDomainCrosshairLockedOnData());
        assertEquals(1, combinedDomainXYPlot.getWeight());
        assertTrue(combinedDomainXYPlot.isRangeCrosshairLockedOnData());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testGetRangeAxisForDatasetWithPositive() throws Throwable  {
        DateAxis arg0 = new DateAxis();
        CombinedRangeXYPlot combinedRangeXYPlot = new CombinedRangeXYPlot(arg0);
        
        // Given: a combined range XY plot with one date axis
        // and an index that is out of bounds (1)
        int index = 1;
        
        try {
        // When: we call getRangeAxisForDataset with the out-of-bounds index
        combinedRangeXYPlot.getRangeAxisForDataset(index);
        
        // Then: an IllegalArgumentException is thrown
        fail("Expecting exception: IllegalArgumentException");
        } catch (IllegalArgumentException e) {
        // Verify that the correct exception was thrown
        verifyException("org.jfree.chart.plot.XYPlot", e);
        
        // Verify that the message of the exception is as expected
        assertEquals(
        "Index 'index' out of bounds.",
        e.getMessage()
        );}
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testGetRangeAxisForDatasetWithNegative() throws Throwable  {
        // This test verifies that an IllegalArgumentException is thrown when a negative value is passed as the index to the getRangeAxisForDataset method.
        XYPlot xYPlot = new XYPlot();
        try {
        xYPlot.getRangeAxisForDataset(-1314); // Index out of bounds.
        fail("Expecting exception: IllegalArgumentException");
        } catch(IllegalArgumentException e) {
        verifyException("org.jfree.chart.plot.XYPlot", e);}
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testGetDomainAxisForDatasetReturningNull() throws Throwable  {
        // rollbacked to evosuite
        CombinedRangeXYPlot combinedRangeXYPlot = new CombinedRangeXYPlot();
        Connection arg0 = mock(Connection.class, new ViolatedAssumptionAnswer());
        JDBCXYDataset arg1 = new JDBCXYDataset(arg0);
        combinedRangeXYPlot.setDataset(769, (XYDataset) arg1);
        combinedRangeXYPlot.getDomainAxisForDataset(2);
        assertEquals(770, combinedRangeXYPlot.getDatasetCount());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testGetDomainAxisForDatasetReturningValueAxisWhereIsVisibleIsTrue() throws Throwable  {
        // Test that the CombinedDomainXYPlot has a non-null domain axis for dataset 0 and that the domain crosshair is locked on data.
        CombinedDomainXYPlot combinedDomainXYPlot = new CombinedDomainXYPlot();
        assertNotNull(combinedDomainXYPlot.getDomainAxisForDataset(0));
        assertTrue(combinedDomainXYPlot.isDomainCrosshairLockedOnData());
        
        // Test that the weight of the CombinedDomainXYPlot is set to 1 and that the range crosshair is locked on data.
        assertEquals(1, combinedDomainXYPlot.getWeight());
        assertTrue(combinedDomainXYPlot.isRangeCrosshairLockedOnData());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testGetDomainAxisForDatasetWithNegative() throws Throwable  {
        // Given a CombinedRangeXYPlot object with some datasets
        CombinedRangeXYPlot combinedRangeXYPlot = new CombinedRangeXYPlot();
        
        // When the method getDomainAxisForDataset is called with an out-of-bounds index
        int index = -2866;
        try {
        combinedRangeXYPlot.getDomainAxisForDataset(index);
        fail("Expecting exception: IllegalArgumentException");
        } catch(IllegalArgumentException e) {
        // Then a IllegalArgumentException is thrown
        verifyException("org.jfree.chart.plot.XYPlot", e);}
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testRender() throws Throwable  {
        // Set up a new CombinedRangeXYPlot with default settings
        CombinedRangeXYPlot combinedRangeXYPlot = new CombinedRangeXYPlot();
        
        // Set up a new ChartRenderingInfo with default settings
        ChartRenderingInfo chartRenderingInfo = new ChartRenderingInfo();
        
        // Set up a new PlotRenderingInfo with default settings
        PlotRenderingInfo plotRenderingInfo = chartRenderingInfo.getPlotInfo();
        
        // Create a new CrosshairState object with the "crosshairLockedOnData" property set to true
        CrosshairState crosshairState = new CrosshairState(true);
        
        // Set up a new Rectangle object with the dimensions of the plot area
        Rectangle rect = new Rectangle(10, 10);
        
        // Render the combined range XY plot using a null Graphics2D context and the plot area rectangle
        boolean render = combinedRangeXYPlot.render((Graphics2D) null, rect, 0, plotRenderingInfo, crosshairState);
        
        // Verify that the domain crosshair is locked on data and the weight is set to 1
        assertTrue(combinedRangeXYPlot.isDomainCrosshairLockedOnData());
        assertEquals(1, combinedRangeXYPlot.getWeight());
        
        // Verify that the range crosshair is also locked on data
        assertTrue(combinedRangeXYPlot.isRangeCrosshairLockedOnData());
        
        // Verify that rendering was successful
        assertFalse(render);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testDrawAxesThrowsNullPointerException() throws Throwable  {
        Rectangle2D.Double arg2 = new Rectangle2D.Double();
        CombinedRangeXYPlot combinedRangeXYPlot = new CombinedRangeXYPlot();
        ChartRenderingInfo chartRenderingInfo = new ChartRenderingInfo();
        PlotRenderingInfo arg3 = chartRenderingInfo.getPlotInfo();
        
        // Check if the method throws a NullPointerException when given a null Graphics2D object
        try {
        combinedRangeXYPlot.drawAxes((Graphics2D) null, arg2, arg2, arg3);
        fail("Expecting exception: NullPointerException");
        } catch(NullPointerException e) {
        // The method should throw a NullPointerException when given a null Graphics2D object
        verifyException("org.jfree.chart.axis.ValueAxis", e);}
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testDrawDomainTickBands() throws Throwable  {
        // rollbacked to evosuite
        CombinedRangeXYPlot combinedRangeXYPlot = new CombinedRangeXYPlot();
        ArrayList<XYTextAnnotation> arg2 = new ArrayList<XYTextAnnotation>();
        combinedRangeXYPlot.drawDomainTickBands((Graphics2D) null, (Rectangle2D) null, arg2);
        assertTrue(combinedRangeXYPlot.isRangeCrosshairLockedOnData());
        assertEquals(1, combinedRangeXYPlot.getWeight());
        assertTrue(combinedRangeXYPlot.isDomainCrosshairLockedOnData());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testCalculateRangeAxisSpace() throws Throwable  {
        DefaultCaret arg1 = new DefaultCaret();
        CombinedDomainXYPlot combinedDomainXYPlot = new CombinedDomainXYPlot();
        // Calculate the range axis space for the plot
        AxisSpace calculateRangeAxisSpace = combinedDomainXYPlot.calculateRangeAxisSpace((Graphics2D) null, arg1, (AxisSpace) null);
        // Assert that the method did not return a null value
        assertNotNull(calculateRangeAxisSpace);
        // Assert that the weight of the plot is 1
        assertEquals(1, combinedDomainXYPlot.getWeight());
        // Assert that the domain crosshair is locked on data for the plot
        assertTrue(combinedDomainXYPlot.isDomainCrosshairLockedOnData());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testCalculateDomainAxisSpace() throws Throwable  {
        // Arrange
        Rectangle2D.Double rectangle = new Rectangle2D.Double();
        CombinedRangeXYPlot combinedRangeXYPlot = new CombinedRangeXYPlot();
        
        // Act
        combinedRangeXYPlot.calculateDomainAxisSpace((Graphics2D) null, rectangle, (AxisSpace) null);
        
        // Assert
        assertEquals(1, combinedRangeXYPlot.getWeight());
        assertTrue(combinedRangeXYPlot.isDomainCrosshairLockedOnData());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testRemoveAnnotationThrowsIllegalArgumentException() throws Throwable  {
        CombinedDomainXYPlot combinedDomainXYPlot = new CombinedDomainXYPlot();
        // Undeclared exception!
        try {
        combinedDomainXYPlot.removeAnnotation((XYAnnotation) null);
        fail("Expecting exception: IllegalArgumentException");
        
        } catch(IllegalArgumentException e) {
        //
        // Null 'annotation' argument.
        //
        verifyException("org.jfree.chart.plot.XYPlot", e);}
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testRemoveAnnotation() throws Throwable  {
        // Given a CombinedDomainXYPlot instance with an XYShapeAnnotation
        CombinedDomainXYPlot combinedDomainXYPlot = new CombinedDomainXYPlot();
        XYShapeAnnotation annotation = new XYShapeAnnotation(combinedDomainXYPlot.DEFAULT_LEGEND_ITEM_BOX);
        
        // When the annotation is removed from the plot
        combinedDomainXYPlot.removeAnnotation(annotation);
        
        // Then the weight of the plot should be 1
        assertEquals(1, combinedDomainXYPlot.getWeight());
        
        // And the range crosshair should be locked on data
        assertTrue(combinedDomainXYPlot.isRangeCrosshairLockedOnData());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testAddAnnotationThrowsIllegalArgumentException() throws Throwable  {
        // Given: A CombinedRangeXYPlot object has been instantiated
        CombinedRangeXYPlot combinedRangeXYPlot = new CombinedRangeXYPlot();
        
        // When: The addAnnotation method is called with a null 'annotation' argument
        try {
        combinedRangeXYPlot.addAnnotation(null);
        fail("Expected exception: IllegalArgumentException");
        } catch (IllegalArgumentException e) {
        // Then: A NullPointerException is thrown due to the null 'annotation' argument
        verifyException("org.jfree.chart.plot.XYPlot", e);}
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testAddAnnotation() throws Throwable  {
        // rollbacked to evosuite
        CombinedRangeXYPlot combinedRangeXYPlot = new CombinedRangeXYPlot();
        XYShapeAnnotation arg0 = new XYShapeAnnotation(combinedRangeXYPlot.DEFAULT_LEGEND_ITEM_CIRCLE, combinedRangeXYPlot.DEFAULT_CROSSHAIR_STROKE, combinedRangeXYPlot.DEFAULT_BACKGROUND_PAINT, combinedRangeXYPlot.DEFAULT_OUTLINE_PAINT);
        combinedRangeXYPlot.addAnnotation(arg0);
        assertTrue(combinedRangeXYPlot.isRangeCrosshairLockedOnData());
        assertEquals(1, combinedRangeXYPlot.getWeight());
        assertTrue(combinedRangeXYPlot.isDomainCrosshairLockedOnData());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testAddRangeMarkerTaking3Arguments() throws Throwable  {
        // Set up a new CombinedDomainXYPlot instance with two range markers.
        CombinedDomainXYPlot combinedDomainXYPlot = new CombinedDomainXYPlot();
        ValueMarker arg1 = new ValueMarker(10);
        Layer arg2 = Layer.BACKGROUND;
        combinedDomainXYPlot.addRangeMarker(10, (Marker) arg1, arg2);
        combinedDomainXYPlot.addRangeMarker(10, (Marker) arg1, arg2);
        
        // Assert that the plot has a weight of 1 and that the range crosshair is locked on data.
        assertEquals(1, combinedDomainXYPlot.getWeight());
        assertTrue(combinedDomainXYPlot.isRangeCrosshairLockedOnData());
        
        // Assert that the domain crosshair is also locked on data.
        assertTrue(combinedDomainXYPlot.isDomainCrosshairLockedOnData());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testAddRangeMarkerTaking3ArgumentsWithNull() throws Throwable  {
        // Given a CombinedDomainXYPlot instance with no range markers
        CombinedDomainXYPlot combinedDomainXYPlot = new CombinedDomainXYPlot();
        
        // When we add a range marker at position 50
        combinedDomainXYPlot.addRangeMarker(50, new CategoryMarker(1.0F, combinedDomainXYPlot.DEFAULT_CROSSHAIR_PAINT, combinedDomainXYPlot.DEFAULT_CROSSHAIR_STROKE), null);
        
        // Then the range marker is added to the plot
        assertTrue(combinedDomainXYPlot.isRangeCrosshairLockedOnData());
        
        // And the crosshairs are locked on data
        assertTrue(combinedDomainXYPlot.isDomainCrosshairLockedOnData());
        
        // And the weight of the range marker is 1
        assertEquals(1, combinedDomainXYPlot.getWeight());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testAddRangeMarkerTaking2Arguments() throws Throwable  {
        // Given a CombinedDomainXYPlot instance and a ValueMarker instance
        CombinedDomainXYPlot combinedDomainXYPlot = new CombinedDomainXYPlot();
        ValueMarker valueMarker = new ValueMarker(10.0F, combinedDomainXYPlot.DEFAULT_GRIDLINE_PAINT, combinedDomainXYPlot.DEFAULT_GRIDLINE_STROKE);
        
        // When a range marker is added to the plot
        Layer layer = Layer.FOREGROUND;
        combinedDomainXYPlot.addRangeMarker(valueMarker, layer);
        
        // Then the plot's range markers are updated and the crosshair is locked on data
        assertTrue(combinedDomainXYPlot.isDomainCrosshairLockedOnData());
        assertEquals(1, combinedDomainXYPlot.getWeight());
        assertTrue(combinedDomainXYPlot.isRangeCrosshairLockedOnData());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testClearRangeMarkersTakingNoArguments() throws Throwable  {
        // No Comments were added
        XYPlot xYPlot = new XYPlot();
        IntervalMarker arg1 = new IntervalMarker(10, 500.0);
        Layer arg2 = Layer.BACKGROUND;
        xYPlot.addRangeMarker(200, (Marker) arg1, arg2);
        xYPlot.clearRangeMarkers();
        assertTrue(xYPlot.isDomainCrosshairLockedOnData());
        assertEquals(1, xYPlot.getWeight());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testAddDomainMarkerTaking3Arguments() throws Throwable  {
        // Create a combined range XY plot and set its weight to 1
        CombinedRangeXYPlot combinedRangeXYPlot = new CombinedRangeXYPlot();
        combinedRangeXYPlot.setWeight(1);
        
        // Add a domain marker at x-value 10 with a value of 10 and layer BACKGROUND
        ValueMarker domainMarker = new ValueMarker(10);
        Layer layer = Layer.BACKGROUND;
        combinedRangeXYPlot.addDomainMarker(10, domainMarker, layer);
        
        // Verify that the weight of the plot is 1 and that the range crosshair is locked on data
        assertEquals(1, combinedRangeXYPlot.getWeight());
        assertTrue(combinedRangeXYPlot.isRangeCrosshairLockedOnData());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testAddDomainMarkerTakingMarker() throws Throwable  {
        // No Comments were added
        XYPlot xYPlot = new XYPlot();
        ValueMarker arg0 = new ValueMarker(1.0F, xYPlot.DEFAULT_OUTLINE_PAINT, xYPlot.DEFAULT_OUTLINE_STROKE);
        xYPlot.addDomainMarker((Marker) arg0);
        xYPlot.addDomainMarker((Marker) arg0);
        assertTrue(xYPlot.isRangeCrosshairLockedOnData());
        assertEquals(1, xYPlot.getWeight());
        assertTrue(xYPlot.isDomainCrosshairLockedOnData());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testAddDomainMarkerTaking3ArgumentsThrowsIllegalArgumentException() throws Throwable  {
        CombinedRangeXYPlot combinedRangeXYPlot = new CombinedRangeXYPlot();
        ValueMarker valueMarker = new ValueMarker(10);
        try {
        combinedRangeXYPlot.addDomainMarker(10, (Marker) valueMarker, null);
        fail("Expecting exception: IllegalArgumentException");
        } catch (IllegalArgumentException e) {
        verifyException("org.jfree.chart.plot.XYPlot", e);}
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testAddDomainMarkerTaking3ArgumentsWithZeroAndNull() throws Throwable  {
        DateAxis dateAxis = new DateAxis();
        CombinedRangeXYPlot combinedRangeXYPlot = new CombinedRangeXYPlot(dateAxis);
        // Undeclared exception!
        try {
        combinedRangeXYPlot.addDomainMarker(0, (Marker) null, (Layer) null);
        fail("Expecting exception: IllegalArgumentException");
        
        } catch(IllegalArgumentException e) {
        //
        // Null 'marker' not permitted.
        //
        verifyException("org.jfree.chart.plot.XYPlot", e);}
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testAddDomainMarkerTaking3ArgumentsAndClearDomainMarkersTakingNoArguments0() throws Throwable  {
        // rollbacked to evosuite
        CombinedRangeXYPlot combinedRangeXYPlot = new CombinedRangeXYPlot();
        ValueMarker arg1 = new ValueMarker(10);
        Layer arg2 = Layer.FOREGROUND;
        combinedRangeXYPlot.addDomainMarker(10, (Marker) arg1, arg2);
        combinedRangeXYPlot.clearDomainMarkers();
        assertTrue(combinedRangeXYPlot.isDomainCrosshairLockedOnData());
        assertTrue(combinedRangeXYPlot.isRangeCrosshairLockedOnData());
        assertEquals(1, combinedRangeXYPlot.getWeight());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testAddDomainMarkerTaking3ArgumentsAndClearDomainMarkersTakingNoArguments1() throws Throwable  {
        // rollbacked to evosuite
        CombinedRangeXYPlot combinedRangeXYPlot = new CombinedRangeXYPlot();
        ValueMarker arg1 = new ValueMarker(10);
        Layer arg2 = Layer.BACKGROUND;
        combinedRangeXYPlot.addDomainMarker(10, (Marker) arg1, arg2);
        combinedRangeXYPlot.clearDomainMarkers();
        assertTrue(combinedRangeXYPlot.isDomainCrosshairLockedOnData());
        assertEquals(1, combinedRangeXYPlot.getWeight());
        assertTrue(combinedRangeXYPlot.isRangeCrosshairLockedOnData());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testSetQuadrantPaintWithPositive() throws Throwable  {
        // rollbacked to evosuite
        DateAxis dateAxis = new DateAxis();
        CombinedDomainXYPlot combinedDomainXYPlot = new CombinedDomainXYPlot();
        // Undeclared exception!
        try { 
          combinedDomainXYPlot.setQuadrantPaint(500, dateAxis.DEFAULT_TICK_MARK_PAINT);
          fail("Expecting exception: IllegalArgumentException");
        
        } catch(IllegalArgumentException e) {
           //
           // The index should be in the range 0 to 3.
           //
           verifyException("org.jfree.chart.plot.XYPlot", e);
        }
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testSetQuadrantPaint() throws Throwable  {
        // Given a CombinedDomainXYPlot object
        CombinedDomainXYPlot combinedDomainXYPlot = new CombinedDomainXYPlot();
        
        // When setting the quadrant paint to null
        combinedDomainXYPlot.setQuadrantPaint(0, (Paint) null);
        
        // Then the domain crosshair is locked on data and the range crosshair is also locked on data
        assertTrue(combinedDomainXYPlot.isDomainCrosshairLockedOnData());
        assertTrue(combinedDomainXYPlot.isRangeCrosshairLockedOnData());
        
        // And the weight of the plot is 1
        assertEquals(1, combinedDomainXYPlot.getWeight());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testSetQuadrantPaintWithNegative() throws Throwable  {
        CombinedDomainXYPlot combinedDomainXYPlot = new CombinedDomainXYPlot();
        
        // Try to set the paint for a quadrant with an index out of range (negative value)
        try {
        combinedDomainXYPlot.setQuadrantPaint(-143, combinedDomainXYPlot.DEFAULT_BACKGROUND_PAINT);
        fail("Expecting exception: IllegalArgumentException");
        } catch(IllegalArgumentException e) {
        // The index should be in the range 0 to 3.
        verifyException("org.jfree.chart.plot.XYPlot", e);}
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testGetQuadrantPaintThrowsIllegalArgumentException() throws Throwable  {
        // No Comments were added
        CombinedRangeXYPlot combinedRangeXYPlot = new CombinedRangeXYPlot();
        // Undeclared exception!
        try { 
          combinedRangeXYPlot.getQuadrantPaint(1458);
          fail("Expecting exception: IllegalArgumentException");
        
        } catch(IllegalArgumentException e) {
           //
           // The index should be in the range 0 to 3.
           //
           verifyException("org.jfree.chart.plot.XYPlot", e);
        }
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testGetQuadrantPaint() throws Throwable  {
        // Create a new CombinedRangeXYPlot instance
        CombinedRangeXYPlot combinedRangeXYPlot = new CombinedRangeXYPlot();
        
        // Call the getQuadrantPaint method with an argument of 1
        combinedRangeXYPlot.getQuadrantPaint(1);
        
        // Verify that the range crosshair is locked to the data
        assertTrue(combinedRangeXYPlot.isRangeCrosshairLockedOnData());
        
        // Verify that the domain crosshair is locked to the data
        assertTrue(combinedRangeXYPlot.isDomainCrosshairLockedOnData());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testGetQuadrantPaintWithNegative() throws Throwable  {
        // Create a new combined range XY plot
        CombinedRangeXYPlot combinedRangeXYPlot = new CombinedRangeXYPlot();
        
        // Try to get the paint for an index that is out of bounds (negative)
        try {
        combinedRangeXYPlot.getQuadrantPaint((-153));
        fail("Expecting exception: IllegalArgumentException");
        
        } catch(IllegalArgumentException e) {
        // The index should be in the range 0 to 3.
        verifyException("org.jfree.chart.plot.XYPlot", e);}
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testSetQuadrantOriginThrowsIllegalArgumentException() throws Throwable  {
        CombinedDomainXYPlot combinedDomainXYPlot = new CombinedDomainXYPlot();
        // Given a null origin argument for setQuadrantOrigin()
        try {
        combinedDomainXYPlot.setQuadrantOrigin((Point2D) null);
        } catch(IllegalArgumentException e) {
        // When the null origin is passed to setQuadrantOrigin()
        // Then an IllegalArgumentException should be thrown
        verifyException("org.jfree.chart.plot.XYPlot", e);}
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testSetQuadrantOrigin() throws Throwable  {
        // Create a new instance of the CombinedDomainXYPlot class
        CombinedDomainXYPlot combinedDomainXYPlot = new CombinedDomainXYPlot();
        
        // Set the quadrant origin for the plot to (0, 0)
        combinedDomainXYPlot.setQuadrantOrigin(new Point2D.Double(0, 0));
        
        // Assert that the range crosshair is locked on data
        assertTrue(combinedDomainXYPlot.isRangeCrosshairLockedOnData());
        
        // Assert that the domain crosshair is locked on data
        assertTrue(combinedDomainXYPlot.isDomainCrosshairLockedOnData());
        
        // Assert that the weight of the plot is 1
        assertEquals(1, combinedDomainXYPlot.getWeight());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testSetRangeZeroBaselinePaintThrowsIllegalArgumentException() throws Throwable  {
        // rollbacked to evosuite
        CombinedDomainXYPlot combinedDomainXYPlot = new CombinedDomainXYPlot();
        // Undeclared exception!
        try { 
          combinedDomainXYPlot.setRangeZeroBaselinePaint((Paint) null);
          fail("Expecting exception: IllegalArgumentException");
        
        } catch(IllegalArgumentException e) {
           //
           // Null 'paint' argument.
           //
           verifyException("org.jfree.chart.plot.XYPlot", e);
        }
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testSetRangeZeroBaselinePaint() throws Throwable  {
        // rollbacked to evosuite
        DateAxis arg0 = new DateAxis();
        CombinedDomainXYPlot combinedDomainXYPlot = new CombinedDomainXYPlot(arg0);
        combinedDomainXYPlot.setRangeZeroBaselinePaint(arg0.DEFAULT_TICK_MARK_PAINT);
        assertEquals(1, combinedDomainXYPlot.getWeight());
        assertTrue(combinedDomainXYPlot.isDomainCrosshairLockedOnData());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testSetRangeZeroBaselineStrokeThrowsIllegalArgumentException() throws Throwable  {
        // Tests that a null 'stroke' argument to setRangeZeroBaselineStroke() throws an IllegalArgumentException.
        XYPlot xyPlot = new XYPlot();
        try {
        xyPlot.setRangeZeroBaselineStroke((Stroke) null);
        fail("Expecting exception: IllegalArgumentException");
        } catch(IllegalArgumentException e) {
        // This exception is expected and can be verified.
        verifyException("org.jfree.chart.plot.XYPlot", e);}
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testSetRangeZeroBaselineStroke() throws Throwable  {
        // Given a CombinedDomainXYPlot and a PolarPlot with a radius gridline stroke
        CombinedDomainXYPlot combinedDomainXYPlot = new CombinedDomainXYPlot();
        PolarPlot polarPlot = new PolarPlot();
        Stroke arg0 = polarPlot.getRadiusGridlineStroke();
        
        // When the range zero baseline stroke is set on the CombinedDomainXYPlot
        combinedDomainXYPlot.setRangeZeroBaselineStroke(arg0);
        
        // Then the range crosshair is locked on data and the domain crosshair is also locked on data
        assertTrue(combinedDomainXYPlot.isRangeCrosshairLockedOnData());
        assertTrue(combinedDomainXYPlot.isDomainCrosshairLockedOnData());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testSetRangeGridlinePaintThrowsIllegalArgumentException() throws Throwable  {
        // rollbacked to evosuite
        CombinedRangeXYPlot combinedRangeXYPlot = new CombinedRangeXYPlot();
        // Undeclared exception!
        try { 
          combinedRangeXYPlot.setRangeGridlinePaint((Paint) null);
          fail("Expecting exception: IllegalArgumentException");
        
        } catch(IllegalArgumentException e) {
           //
           // Null 'paint' argument.
           //
           verifyException("org.jfree.chart.plot.XYPlot", e);
        }
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testSetRangeGridlinePaint() throws Throwable  {
        // Given a CombinedRangeXYPlot instance
        CombinedRangeXYPlot plot = new CombinedRangeXYPlot();
        
        // When I set the range gridline paint to the default outline paint
        plot.setRangeGridlinePaint(CombinedRangeXYPlot.DEFAULT_OUTLINE_PAINT);
        
        // Then I expect the range crosshair to be locked on data
        assertTrue(plot.isRangeCrosshairLockedOnData());
        
        // And I expect the domain crosshair to be locked on data
        assertTrue(plot.isDomainCrosshairLockedOnData());
        
        // And I expect the weight of the plot to be 1
        assertEquals(1, plot.getWeight());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testSetRangeGridlineStrokeThrowsIllegalArgumentException() throws Throwable  {
        CombinedDomainXYPlot combinedDomainXYPlot = new CombinedDomainXYPlot();
        try {
        combinedDomainXYPlot.setRangeGridlineStroke(null);
        fail("Expecting exception: IllegalArgumentException");
        } catch (IllegalArgumentException e) {
        // Verify that the thrown exception is an instance of NullPointerException.
        verifyException("org.jfree.chart.plot.XYPlot", e);}
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testSetRangeGridlineStroke() throws Throwable  {
        // Given a CombinedDomainXYPlot object with default settings
        CombinedDomainXYPlot plot = new CombinedDomainXYPlot();
        
        // When the range gridline stroke is set to DEFAULT_OUTLINE_STROKE
        plot.setRangeGridlineStroke(plot.DEFAULT_OUTLINE_STROKE);
        
        // Then the range crosshair should be locked on data
        assertTrue(plot.isRangeCrosshairLockedOnData());
        
        // And the domain crosshair should also be locked on data
        assertTrue(plot.isDomainCrosshairLockedOnData());
        
        // And the weight of the plot should be 1
        assertEquals(1, plot.getWeight());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testSetRangeGridlinesVisibleWithFalse() throws Throwable  {
        // Given: We have a CombinedDomainXYPlot object named "combinedDomainXYPlot"
        CombinedDomainXYPlot combinedDomainXYPlot = new CombinedDomainXYPlot();
        
        // When: We set the range gridlines visibility to false for this plot
        combinedDomainXYPlot.setRangeGridlinesVisible(false);
        
        // Then: The range gridlines visibility should be set to false for this plot
        assertFalse(combinedDomainXYPlot.isRangeGridlinesVisible());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testSetRangeGridlinesVisibleWithTrue() throws Throwable  {
        // Given a DateAxis and a CombinedRangeXYPlot,
        DateAxis dateAxis = new DateAxis();
        CombinedRangeXYPlot combinedRangeXYPlot = new CombinedRangeXYPlot(dateAxis);
        
        // When the range gridlines are set to visible,
        combinedRangeXYPlot.setRangeGridlinesVisible(true);
        
        // Then the domain crosshair should be locked on data and the weight should be 1.
        assertTrue(combinedRangeXYPlot.isDomainCrosshairLockedOnData());
        assertEquals(1, combinedRangeXYPlot.getWeight());
        
        // And the range crosshair should also be locked on data.
        assertTrue(combinedRangeXYPlot.isRangeCrosshairLockedOnData());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testSetDomainGridlinePaintThrowsIllegalArgumentException() throws Throwable  {
        CombinedDomainXYPlot combinedDomainXYPlot = new CombinedDomainXYPlot();
        // Check that a null 'paint' argument throws an exception.
        try {
        combinedDomainXYPlot.setDomainGridlinePaint(null);
        fail("Expecting exception: IllegalArgumentException");
        } catch(IllegalArgumentException e) {
        verifyException("org.jfree.chart.plot.XYPlot", e);}
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testSetDomainGridlinePaint() throws Throwable  {
        // Given a CombinedDomainXYPlot object
        CombinedDomainXYPlot combinedDomainXYPlot = new CombinedDomainXYPlot();
        
        // When setting the domain gridline paint to a default outline paint
        Color arg0 = (Color)AbstractRenderer.DEFAULT_OUTLINE_PAINT;
        combinedDomainXYPlot.setDomainGridlinePaint(arg0);
        
        // Then the weight of the plot should be 1
        assertEquals(1, combinedDomainXYPlot.getWeight());
        
        // And the domain crosshair should be locked on data
        assertTrue(combinedDomainXYPlot.isDomainCrosshairLockedOnData());
        
        // And the range crosshair should also be locked on data
        assertTrue(combinedDomainXYPlot.isRangeCrosshairLockedOnData());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testSetDomainGridlineStrokeThrowsIllegalArgumentException() throws Throwable  {
        CombinedRangeXYPlot combinedRangeXYPlot = new CombinedRangeXYPlot();
        
        try {
        combinedRangeXYPlot.setDomainGridlineStroke(null);
        fail("Expecting exception: IllegalArgumentException");
        } catch (IllegalArgumentException e) {
        // Null 'stroke' argument.
        verifyException("org.jfree.chart.plot.XYPlot", e);}
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testSetDomainGridlineStroke() throws Throwable  {
        // Create a new DateAxis and CombinedRangeXYPlot objects
        DateAxis dateAxis = new DateAxis();
        CombinedRangeXYPlot combinedRangeXYPlot = new CombinedRangeXYPlot();
        
        // Set the domain gridline stroke for the CombinedRangeXYPlot to the default tick mark stroke
        combinedRangeXYPlot.setDomainGridlineStroke(dateAxis.DEFAULT_TICK_MARK_STROKE);
        
        // Test that the weight of the CombinedRangeXYPlot is equal to 1
        assertEquals(1, combinedRangeXYPlot.getWeight());
        
        // Test that the range crosshair is locked on data for the CombinedRangeXYPlot
        assertTrue(combinedRangeXYPlot.isRangeCrosshairLockedOnData());
        
        // Test that the domain crosshair is locked on data for the CombinedRangeXYPlot
        assertTrue(combinedRangeXYPlot.isDomainCrosshairLockedOnData());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testIsDomainGridlinesVisibleReturningFalse() throws Throwable  {
        // Given a DateAxis and a CombinedRangeXYPlot with domain gridlines visible
        DateAxis dateAxis = new DateAxis();
        CombinedRangeXYPlot combinedRangeXYPlot = new CombinedRangeXYPlot(dateAxis);
        combinedRangeXYPlot.setDomainGridlinesVisible(true);
        
        // When setting the domain gridlines to be invisible
        combinedRangeXYPlot.setDomainGridlinesVisible(false);
        
        // Then the domain gridlines should be invisible
        assertFalse(combinedRangeXYPlot.isDomainGridlinesVisible());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testSetDomainGridlinesVisibleWithTrue() throws Throwable  {
        // Test that the crosshairs are locked on data by default
        CombinedDomainXYPlot combinedDomainXYPlot = new CombinedDomainXYPlot();
        combinedDomainXYPlot.setDomainGridlinesVisible(true);
        assertEquals(1, combinedDomainXYPlot.getWeight()); // Check that the weight is set correctly
        assertTrue(combinedDomainXYPlot.isDomainCrosshairLockedOnData()); // Check that the domain crosshair is locked on data
        assertTrue(combinedDomainXYPlot.isRangeCrosshairLockedOnData()); // Check that the range crosshair is locked on data
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testGetRendererForDataset() throws Throwable  {
        // Given a CombinedDomainXYPlot and YIntervalSeriesCollection
        CombinedDomainXYPlot combinedDomainXYPlot = new CombinedDomainXYPlot();
        YIntervalSeriesCollection arg0 = new YIntervalSeriesCollection();
        
        // When the renderer is requested for the dataset
        Object renderer = combinedDomainXYPlot.getRendererForDataset(arg0);
        
        // Then the range crosshair is locked on data
        assertTrue(combinedDomainXYPlot.isRangeCrosshairLockedOnData());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testSetSeriesRenderingOrderThrowsIllegalArgumentException() throws Throwable  {
        // No Comments were added
        XYPlot xYPlot = new XYPlot();
        // Undeclared exception!
        try { 
          xYPlot.setSeriesRenderingOrder((SeriesRenderingOrder) null);
          fail("Expecting exception: IllegalArgumentException");
        
        } catch(IllegalArgumentException e) {
           //
           // Null 'order' argument.
           //
           verifyException("org.jfree.chart.plot.XYPlot", e);
        }
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testSetDatasetRenderingOrderThrowsIllegalArgumentException() throws Throwable  {
        CombinedDomainXYPlot combinedDomainXYPlot = new CombinedDomainXYPlot();
        try {
        combinedDomainXYPlot.setDatasetRenderingOrder(null);
        fail("Expecting exception: IllegalArgumentException");
        } catch (IllegalArgumentException e) {
        // Verify that the exception is thrown when a null 'order' argument is passed.
        verifyException("org.jfree.chart.plot.XYPlot", e);}
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testSetRendererTakingXYItemRenderer() throws Throwable  {
        // Given an XYPlot instance with an XYBarRenderer
        XYPlot xyPlot = new XYPlot();
        XYBarRenderer renderer = new XYBarRenderer(1.0F);
        xyPlot.setRenderer((XYItemRenderer) renderer);
        
        // When the range crosshair is locked on data
        xyPlot.setRangeCrosshairLockedOnData(true);
        
        // Then the range crosshair is locked on data
        assertTrue(xyPlot.isRangeCrosshairLockedOnData());
        
        // When the domain crosshair is locked on data
        xyPlot.setDomainCrosshairLockedOnData(true);
        
        // Then the domain crosshair is locked on data
        assertTrue(xyPlot.isDomainCrosshairLockedOnData());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testIndexOfReturningZero() throws Throwable  {
        // Given a CombinedRangeXYPlot object, combinedRangeXYPlot
        CombinedRangeXYPlot combinedRangeXYPlot = new CombinedRangeXYPlot();
        
        // When the index of a null XYDataset is looked up in the plot
        int indexOfNullDataset = combinedRangeXYPlot.indexOf((XYDataset) null);
        
        // Then the index should be 0
        assertEquals(0, indexOfNullDataset);
        
        // And the domain crosshair should be locked on data
        assertTrue(combinedRangeXYPlot.isDomainCrosshairLockedOnData());
        
        // And the range crosshair should also be locked on data
        assertTrue(combinedRangeXYPlot.isRangeCrosshairLockedOnData());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testIndexOfReturningNegative() throws Throwable  {
        // Given a CombinedDomainXYPlot instance and a MatrixSeriesCollection object
        CombinedDomainXYPlot combinedDomainXYPlot = new CombinedDomainXYPlot();
        MatrixSeriesCollection arg0 = new MatrixSeriesCollection();
        
        // When the indexOf method is called with the MatrixSeriesCollection object as an argument
        int indexOf = combinedDomainXYPlot.indexOf(arg0);
        
        // Then the method returns -1, indicating that the specified series was not found in the plot
        assertEquals(-1, indexOf);
        
        // And the weight of the plot is 1
        assertEquals(1, combinedDomainXYPlot.getWeight());
        
        // And the domain crosshair is locked on data
        assertTrue(combinedDomainXYPlot.isDomainCrosshairLockedOnData());
        
        // And the range crosshair is also locked on data
        assertTrue(combinedDomainXYPlot.isRangeCrosshairLockedOnData());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testSetDatasetTaking2ArgumentsWithNull() throws Throwable  {
        // Given a new instance of CombinedDomainXYPlot with null dataset
        CombinedDomainXYPlot combinedDomainXYPlot = new CombinedDomainXYPlot();
        
        // When setDataset method is called with index 1198 and null dataset
        combinedDomainXYPlot.setDataset(1198, (XYDataset) null);
        
        // Then the dataset count should be 1199
        assertEquals(1199, combinedDomainXYPlot.getDatasetCount());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testSetDatasetTaking2ArgumentsWithZero() throws Throwable  {
        // Create a new XYPlot with a DefaultXYZDataset and a DateAxis
        DefaultXYZDataset dataset = new DefaultXYZDataset();
        DateAxis domainAxis = new DateAxis();
        XYErrorRenderer renderer = new XYErrorRenderer();
        XYPlot plot = new XYPlot(dataset, domainAxis, domainAxis, renderer);
        
        // Set the dataset using the setDataset() method and check that it is properly set
        plot.setDataset(0, (XYDataset) dataset);
        assertEquals(1, plot.getDatasetCount());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testGetRangeAxisEdgeTakingInt() throws Throwable  {
        // Given: A DateAxis and a CombinedRangeXYPlot with the DateAxis as the range axis
        DateAxis dateAxis = new DateAxis();
        CombinedRangeXYPlot combinedRangeXYPlot = new CombinedRangeXYPlot(dateAxis);
        
        // When: The range axis edge of the CombinedRangeXYPlot is set to -1845
        combinedRangeXYPlot.getRangeAxisEdge(-1845);
        
        // Then: The crosshair for the range axis is locked on data, and the domain axis crosshair is also locked on data
        assertTrue(combinedRangeXYPlot.isRangeCrosshairLockedOnData());
        assertTrue(combinedRangeXYPlot.isDomainCrosshairLockedOnData());
        
        // And: The weight of the CombinedRangeXYPlot is 1
        assertEquals(1, combinedRangeXYPlot.getWeight());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testGetRangeAxisLocationTakingIntWithZero() throws Throwable  {
        CombinedDomainXYPlot combinedDomainXYPlot = new CombinedDomainXYPlot();
        AxisLocation rangeAxisLocation = combinedDomainXYPlot.getRangeAxisLocation(0);
        
        // Check if the domain crosshair is locked to the data
        assertTrue(combinedDomainXYPlot.isDomainCrosshairLockedOnData());
        
        // Check the location of the range axis
        assertEquals("AxisLocation.BOTTOM_OR_LEFT", rangeAxisLocation.toString());
        
        // Check the weight of the combined plot
        assertEquals(1, combinedDomainXYPlot.getWeight());
        
        // Check if the range crosshair is locked to the data
        assertTrue(combinedDomainXYPlot.isRangeCrosshairLockedOnData());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testClearRangeAxes() throws Throwable  {
        // Given a CombinedDomainXYPlot instance
        CombinedDomainXYPlot combinedDomainXYPlot = new CombinedDomainXYPlot();
        
        // When the range axes are cleared
        combinedDomainXYPlot.clearRangeAxes();
        
        // Then the range crosshair is locked on data
        assertTrue(combinedDomainXYPlot.isRangeCrosshairLockedOnData());
        
        // And the weight is set to 1
        assertEquals(1, combinedDomainXYPlot.getWeight());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testSetRangeAxisTaking3ArgumentsWithNull() throws Throwable  {
        // Given a CombinedRangeXYPlot object
        CombinedRangeXYPlot combinedRangeXYPlot = new CombinedRangeXYPlot();
        
        // When we set the range axis to a specific value
        combinedRangeXYPlot.setRangeAxis(253, (ValueAxis) null, true);
        
        // Then the range axis count should be equal to the specified value
        assertEquals(254, combinedRangeXYPlot.getRangeAxisCount());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testSetRangeAxisTaking3ArgumentsWithFalse() throws Throwable  {
        // No Comments were added
        CombinedDomainXYPlot combinedDomainXYPlot = new CombinedDomainXYPlot();
        PeriodAxis arg1 = new PeriodAxis("DR\"M4G578p7B?rvN");
        combinedDomainXYPlot.setRangeAxis(10, (ValueAxis) arg1, false);
        combinedDomainXYPlot.setRangeAxis(10, (ValueAxis) arg1, false);
        assertEquals(11, combinedDomainXYPlot.getRangeAxisCount());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testSetRangeAxisLocationTaking1And1AndSetRangeAxisLocationTaking1And1AndSetRangeAxisLocationTaking1And1WithFalse() throws Throwable  {
        // Given
        CombinedDomainXYPlot combinedDomainXYPlot = new CombinedDomainXYPlot();
        AxisLocation axisLocation = AxisLocation.BOTTOM_OR_LEFT;
        
        // When
        combinedDomainXYPlot.setRangeAxisLocation(axisLocation, false);
        
        // Then
        assertEquals(1, combinedDomainXYPlot.getWeight());
        assertTrue(combinedDomainXYPlot.isRangeCrosshairLockedOnData());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testSetRangeAxisLocationTaking1And1WithTrue() throws Throwable  {
        // Test that the range axis location is set correctly
        AxisLocation arg0 = AxisLocation.BOTTOM_OR_LEFT;
        CombinedDomainXYPlot combinedDomainXYPlot = new CombinedDomainXYPlot();
        combinedDomainXYPlot.setRangeAxisLocation(arg0, true);
        assertEquals(1, combinedDomainXYPlot.getWeight()); // Check that the weight is set to 1
        assertTrue(combinedDomainXYPlot.isDomainCrosshairLockedOnData()); // Check that the domain crosshair is locked on data
        assertTrue(combinedDomainXYPlot.isRangeCrosshairLockedOnData()); // Check that the range crosshair is locked on data
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testSetRangeAxisTakingValueAxis() throws Throwable  {
        // Given a CombinedDomainXYPlot with a DateAxis and a ValueAxis
        DateAxis dateAxis = new DateAxis();
        CombinedDomainXYPlot combinedDomainXYPlot = new CombinedDomainXYPlot(dateAxis);
        combinedDomainXYPlot.setRangeAxis((ValueAxis) dateAxis);
        
        // When the crosshair is locked on data for the range axis
        combinedDomainXYPlot.setRangeCrosshairLockedOnData(true);
        
        // Then the combined plot should have a weight of 1
        assertEquals(1, combinedDomainXYPlot.getWeight());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testGetDomainAxisEdgeTakingInt() throws Throwable  {
        CombinedDomainXYPlot testCombinedDomainXYPlot = new CombinedDomainXYPlot();
        // Given a CombinedDomainXYPlot object with a domain axis edge set to BOTTOM
        RectangleEdge domainAxisEdge = testCombinedDomainXYPlot.getDomainAxisEdge(0);
        assertTrue(testCombinedDomainXYPlot.isDomainCrosshairLockedOnData());
        // When the CombinedDomainXYPlot object is initialized with a weight of 1
        assertEquals("RectangleEdge.BOTTOM", domainAxisEdge.toString());
        assertEquals(1, testCombinedDomainXYPlot.getWeight());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testGetDomainAxisLocationTakingIntWithPositive() throws Throwable  {
        // Given a CombinedDomainXYPlot instance with some data
        CombinedDomainXYPlot combinedDomainXYPlot = new CombinedDomainXYPlot();
        
        // When the domain axis location for a specific ID is requested
        AxisLocation domainAxisLocation = combinedDomainXYPlot.getDomainAxisLocation(1234567890);
        
        // Then the correct AxisLocation instance should be returned, and the plot's weight and range crosshair locking status should be as expected
        assertEquals(1, combinedDomainXYPlot.getWeight());
        assertTrue(combinedDomainXYPlot.isRangeCrosshairLockedOnData());
        assertNotNull(domainAxisLocation);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testClearDomainAxes0() throws Throwable  {
        // Given a CombinedRangeXYPlot instance
        CombinedRangeXYPlot combinedRangeXYPlot = new CombinedRangeXYPlot();
        
        // When the plot is cleared of its domain axes
        combinedRangeXYPlot.clearDomainAxes();
        
        // Then the weight should be 1 and the domain crosshair should be locked on data
        assertEquals(1, combinedRangeXYPlot.getWeight());
        assertTrue(combinedRangeXYPlot.isDomainCrosshairLockedOnData());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testClearDomainAxes1() throws Throwable  {
        // Given a CombinedDomainXYPlot object
        CombinedDomainXYPlot combinedDomainXYPlot = new CombinedDomainXYPlot();
        
        // When clearing the domain axes
        combinedDomainXYPlot.clearDomainAxes();
        
        // Then the range crosshair is locked on data and the weight is 1
        assertTrue(combinedDomainXYPlot.isRangeCrosshairLockedOnData());
        assertEquals(1, combinedDomainXYPlot.getWeight());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testGetDomainAxisLocationTakingNoArguments() throws Throwable  {
        // rollbacked to evosuite
        CombinedDomainXYPlot combinedDomainXYPlot = new CombinedDomainXYPlot();
        AxisLocation arg0 = combinedDomainXYPlot.getDomainAxisLocation();
        assertNotNull(arg0);
        
        combinedDomainXYPlot.setDomainAxisLocation(arg0, false);
        assertTrue(combinedDomainXYPlot.isRangeCrosshairLockedOnData());
        assertEquals(1, combinedDomainXYPlot.getWeight());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testSetDomainAxisLocationTaking1And1ThrowsIllegalArgumentException() throws Throwable  {
        // Tests that passing a null 'location' argument throws an IllegalArgumentException.
        CombinedDomainXYPlot combinedDomainXYPlot = new CombinedDomainXYPlot();
        try {
        combinedDomainXYPlot.setDomainAxisLocation(null, true);
        fail("Expecting exception: IllegalArgumentException");
        } catch(IllegalArgumentException e) {
        verifyException("org.jfree.chart.plot.XYPlot", e);}
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testGetRangeAxisTakingInt1() throws Throwable  {
        // No Comments were added
        CombinedRangeXYPlot arg0 = new CombinedRangeXYPlot();
        CombinedDomainXYPlot combinedDomainXYPlot = new CombinedDomainXYPlot();
        combinedDomainXYPlot.add((XYPlot) arg0);
        arg0.getRangeAxis(2);
        assertTrue(arg0.isRangeCrosshairLockedOnData());
        assertEquals(1, arg0.getDomainAxisCount());
        assertTrue(arg0.isDomainCrosshairLockedOnData());
        assertEquals(1, arg0.getWeight());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testSetAxisOffsetThrowsIllegalArgumentException() throws Throwable  {
        // Undeclared exception!
        try {
        CombinedDomainXYPlot combinedDomainXYPlot = new CombinedDomainXYPlot();
        combinedDomainXYPlot.setAxisOffset((RectangleInsets) null);
        fail("Expecting exception: IllegalArgumentException");
        } catch(IllegalArgumentException e) {
        // Null 'offset' argument.
        verifyException("org.jfree.chart.plot.XYPlot", e);}
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testSetAxisOffset() throws Throwable  {
        // Create a new CombinedDomainXYPlot instance
        CombinedDomainXYPlot combinedDomainXYPlot = new CombinedDomainXYPlot();
        
        // Set the axis offset for the plot
        combinedDomainXYPlot.setAxisOffset(combinedDomainXYPlot.DEFAULT_INSETS);
        
        // Check that the range crosshair is locked to the data
        assertTrue(combinedDomainXYPlot.isRangeCrosshairLockedOnData());
        
        // Check the weight of the plot
        assertEquals(1, combinedDomainXYPlot.getWeight());
        
        // Check that the domain crosshair is locked to the data
        assertTrue(combinedDomainXYPlot.isDomainCrosshairLockedOnData());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void test1() throws Throwable  {
        CombinedDomainXYPlot combinedDomainXYPlot = new CombinedDomainXYPlot();
        try {
        combinedDomainXYPlot.setOrientation(null);
        fail("Expected exception: IllegalArgumentException");
        } catch (IllegalArgumentException e) {
        // Null 'orientation' argument.
        verifyException("org.jfree.chart.plot.XYPlot", e);}
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void test2() throws Throwable  {
        // Given a CombinedDomainXYPlot instance with a horizontal orientation
        CombinedDomainXYPlot combinedDomainXYPlot = new CombinedDomainXYPlot();
        combinedDomainXYPlot.setOrientation(PlotOrientation.HORIZONTAL);
        
        // When we set the range crosshair to be locked on data
        combinedDomainXYPlot.setRangeCrosshairLockedOnData(true);
        
        // Then the range crosshair should be locked on data
        assertTrue(combinedDomainXYPlot.isRangeCrosshairLockedOnData());
        
        // When we set the domain crosshair to be locked on data
        combinedDomainXYPlot.setDomainCrosshairLockedOnData(true);
        
        // Then the domain crosshair should be locked on data
        assertTrue(combinedDomainXYPlot.isDomainCrosshairLockedOnData());
        
        // When we set the weight of the plot to 1
        combinedDomainXYPlot.setWeight(1);
        
        // Then the weight of the plot should be 1
        assertEquals(1, combinedDomainXYPlot.getWeight());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testCloneAndCreatesXYPlotTaking4ArgumentsAndSetDatasetTaking2Arguments() throws Throwable  {
        // Test that the XYPlot can set and retrieve a dataset correctly
        
        DateAxis dateAxis = new DateAxis();
        XYErrorRenderer errorRenderer = new XYErrorRenderer();
        DefaultXYZDataset dataset = new DefaultXYZDataset();
        XYPlot xyPlot = new XYPlot(dataset, dateAxis, dateAxis, errorRenderer);
        xyPlot.setDataset(4, (XYDataset) dataset);
        assertEquals(5, xyPlot.getDatasetCount());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testGetDomainCrosshairStroke() throws Throwable  {
        // Given the CombinedDomainXYPlot object is created
        CombinedDomainXYPlot combinedDomainXYPlot = new CombinedDomainXYPlot();
        
        // When certain properties are set on the plot
        BasicStroke domainCrosshairStroke = (BasicStroke)combinedDomainXYPlot.getDomainCrosshairStroke();
        assertEquals(2, domainCrosshairStroke.getLineJoin()); // Then the line join style of the domain crosshair is set to 2
        assertEquals(1, combinedDomainXYPlot.getWeight()); // And the weight of the plot is set to 1
        assertTrue(combinedDomainXYPlot.isDomainCrosshairLockedOnData()); // And the domain crosshair is locked on the data
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testDrawRangeTickBands() throws Throwable  {
        // rollbacked to evosuite
        CombinedDomainXYPlot combinedDomainXYPlot = new CombinedDomainXYPlot();
        combinedDomainXYPlot.drawRangeTickBands((Graphics2D) null, (Rectangle2D) null, (List) null);
        assertTrue(combinedDomainXYPlot.isDomainCrosshairLockedOnData());
        assertEquals(1, combinedDomainXYPlot.getWeight());
        assertTrue(combinedDomainXYPlot.isRangeCrosshairLockedOnData());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testSetDomainTickBandPaint() throws Throwable  {
        // Given a new instance of the DateAxis and CombinedDomainXYPlot classes
        DateAxis dateAxis = new DateAxis();
        CombinedDomainXYPlot combinedDomainXYPlot = new CombinedDomainXYPlot();
        
        // When the domainTickBandPaint property is set to the default value for the DateAxis class
        combinedDomainXYPlot.setDomainTickBandPaint(dateAxis.DEFAULT_AXIS_LINE_PAINT);
        
        // Then the rangeCrosshairLockedOnData property should be true
        assertTrue(combinedDomainXYPlot.isRangeCrosshairLockedOnData());
        
        // And the weight of the plot should be 1
        assertEquals(1, combinedDomainXYPlot.getWeight());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testGetFixedRangeAxisSpace() throws Throwable  {
        // rollbacked to evosuite
        CombinedDomainXYPlot combinedDomainXYPlot = new CombinedDomainXYPlot();
        combinedDomainXYPlot.getFixedRangeAxisSpace();
        assertTrue(combinedDomainXYPlot.isRangeCrosshairLockedOnData());
        assertTrue(combinedDomainXYPlot.isDomainCrosshairLockedOnData());
        assertEquals(1, combinedDomainXYPlot.getWeight());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void test3() throws Throwable  {
        // Given a CombinedRangeXYPlot instance and an XYPlot instance
        CombinedRangeXYPlot combinedRangeXYPlot = new CombinedRangeXYPlot();
        XYPlot xyPlot = new XYPlot();
        
        // When we add the XYPlot to the CombinedRangeXYPlot with a weight of 10
        combinedRangeXYPlot.add(xyPlot, 10);
        
        // Then the CombinedRangeXYPlot should have a weight of 10 and the XYPlot should have a weight of 1
        assertEquals(10, combinedRangeXYPlot.getWeight());
        assertEquals(1, xyPlot.getWeight());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testIsDomainCrosshairLockedOnData() throws Throwable  {
        // Given a CombinedDomainXYPlot instance
        CombinedDomainXYPlot combinedDomainXYPlot = new CombinedDomainXYPlot();
        
        // When the isDomainCrosshairLockedOnData method is called
        boolean domainCrosshairLockedOnData = combinedDomainXYPlot.isDomainCrosshairLockedOnData();
        
        // Then the crosshair should be locked on data
        assertTrue(domainCrosshairLockedOnData);
        
        // And the weight of the plot should be 1
        assertEquals(1, combinedDomainXYPlot.getWeight());
        
        // And the range crosshair should also be locked on data
        assertTrue(combinedDomainXYPlot.isRangeCrosshairLockedOnData());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testSetDomainAxisTakingValueAxis() throws Throwable  {
        // Create a new XYPlot and ThermometerPlot instances
        XYPlot xyPlot = new XYPlot();
        ThermometerPlot thermometerPlot = new ThermometerPlot();
        
        // Get the range axis of the ThermometerPlot
        ValueAxis rangeAxis = thermometerPlot.getRangeAxis();
        
        // Set the domain axis of the XYPlot to the range axis of the ThermometerPlot
        xyPlot.setDomainAxis(rangeAxis);
        
        // Assert that the range crosshair is locked on data for the XYPlot
        assertTrue(xyPlot.isRangeCrosshairLockedOnData());
        
        // Assert that there is only one domain axis for the XYPlot
        assertEquals(1, xyPlot.getDomainAxisCount());
        
        // Assert that the crosshair is locked on data for the XYPlot's domain axis
        assertTrue(xyPlot.isDomainCrosshairLockedOnData());
        
        // Assert that the XYPlot has a weight of 1
        assertEquals(1, xyPlot.getWeight());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testSetDomainAxisLocationTakingAxisLocation() throws Throwable  {
        // No Comments were added
        CombinedDomainXYPlot combinedDomainXYPlot = new CombinedDomainXYPlot();
        AxisLocation arg0 = combinedDomainXYPlot.getRangeAxisLocation(48);
        assertNotNull(arg0);
        
        combinedDomainXYPlot.setDomainAxisLocation(arg0);
        assertTrue(combinedDomainXYPlot.isRangeCrosshairLockedOnData());
        assertTrue(combinedDomainXYPlot.isDomainCrosshairLockedOnData());
        assertEquals(1, combinedDomainXYPlot.getWeight());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testSetRangeCrosshairStroke() throws Throwable  {
        // Given
        CombinedRangeXYPlot combinedRangeXYPlot = new CombinedRangeXYPlot();
        
        // When
        combinedRangeXYPlot.setRangeCrosshairStroke(null);
        
        // Then
        assertTrue(combinedRangeXYPlot.isDomainCrosshairLockedOnData());
        assertEquals(1, combinedRangeXYPlot.getWeight());
        assertTrue(combinedRangeXYPlot.isRangeCrosshairLockedOnData());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testSetRangeTickBandPaint() throws Throwable  {
        // Given a CombinedRangeXYPlot object,
        CombinedRangeXYPlot combinedRangeXYPlot = new CombinedRangeXYPlot();
        
        // When setting the range tick band paint to a specific color,
        Color arg0 = Color.MAGENTA;
        combinedRangeXYPlot.setRangeTickBandPaint(arg0);
        
        // Then the range tick band paint should be set to that color,
        Color rangeTickBandPaint = (Color)combinedRangeXYPlot.getRangeTickBandPaint();
        assertEquals((-65281), rangeTickBandPaint.getRGB());
        
        // And the range crosshair lock should be enabled,
        assertTrue(combinedRangeXYPlot.isRangeCrosshairLockedOnData());
        
        // And the domain crosshair lock should be enabled,
        assertTrue(combinedRangeXYPlot.isDomainCrosshairLockedOnData());
        
        // And the weight of the plot should be set to a specific value,
        assertEquals(1, combinedRangeXYPlot.getWeight());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testIsRangeGridlinesVisible() throws Throwable  {
        // Given a CombinedRangeXYPlot instance with range gridlines visible and crosshair locked on data
        CombinedRangeXYPlot combinedRangeXYPlot = new CombinedRangeXYPlot();
        combinedRangeXYPlot.setRangeGridlinesVisible(true);
        combinedRangeXYPlot.setRangeCrosshairLockedOnData(true);
        
        // When the instance is created
        boolean rangeGridlinesVisible = combinedRangeXYPlot.isRangeGridlinesVisible();
        
        // Then the range gridlines are visible and the crosshair is locked on data
        assertTrue(rangeGridlinesVisible);
        assertTrue(combinedRangeXYPlot.isRangeCrosshairLockedOnData());
        
        // And the weight is set to 1
        assertEquals(1, combinedRangeXYPlot.getWeight());
        
        // When the domain crosshair is locked on data
        combinedRangeXYPlot.setDomainCrosshairLockedOnData(true);
        
        // Then the domain crosshair is also locked on data
        assertTrue(combinedRangeXYPlot.isDomainCrosshairLockedOnData());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testGetWeight() throws Throwable  {
        // Given a CombinedDomainXYPlot object
        CombinedDomainXYPlot combinedDomainXYPlot = new CombinedDomainXYPlot();
        
        // When the weight of the plot is retrieved
        int weight = combinedDomainXYPlot.getWeight();
        
        // Then the weight should be 1
        assertEquals(1, weight);
        
        // And the range crosshair should be locked on data
        assertTrue(combinedDomainXYPlot.isRangeCrosshairLockedOnData());
        
        // And the domain crosshair should be locked on data
        assertTrue(combinedDomainXYPlot.isDomainCrosshairLockedOnData());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testSetFixedRangeAxisSpace() throws Throwable  {
        // Given a CombinedDomainXYPlot instance
        CombinedDomainXYPlot combinedDomainXYPlot = new CombinedDomainXYPlot();
        
        // When the fixedRangeAxisSpace is set to a new AxisSpace instance
        AxisSpace arg0 = new AxisSpace();
        combinedDomainXYPlot.setFixedRangeAxisSpace(arg0);
        
        // Then the domain crosshair should be locked on data
        assertTrue(combinedDomainXYPlot.isDomainCrosshairLockedOnData());
        
        // And the weight should be set to 1
        assertEquals(1, combinedDomainXYPlot.getWeight());
        
        // And the range crosshair should also be locked on data
        assertTrue(combinedDomainXYPlot.isRangeCrosshairLockedOnData());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testDrawZeroRangeBaseline() throws Throwable  {
        // Given a CombinedRangeXYPlot object with a domain crosshair locked on data and a range crosshair locked on data
        CombinedRangeXYPlot combinedRangeXYPlot = new CombinedRangeXYPlot();
        combinedRangeXYPlot.setDomainCrosshairLockedOnData(true);
        combinedRangeXYPlot.setRangeCrosshairLockedOnData(true);
        
        // When the drawZeroRangeBaseline method is called with a null Graphics2D object and a null Rectangle2D object
        combinedRangeXYPlot.drawZeroRangeBaseline((Graphics2D) null, (Rectangle2D) null);
        
        // Then the method should return true and set the weight to 1
        assertTrue(combinedRangeXYPlot.isDomainCrosshairLockedOnData());
        assertEquals(1, combinedRangeXYPlot.getWeight());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testGetPlotTypeThrowsNullPointerException() throws Throwable  {
        // rollbacked to evosuite
        XYPlot xYPlot = new XYPlot();
        xYPlot.getPlotType();
        assertTrue(xYPlot.isRangeCrosshairLockedOnData());
        assertTrue(xYPlot.isDomainCrosshairLockedOnData());
        assertEquals(1, xYPlot.getWeight());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testGetDatasetTakingNoArgumentsReturningNull() throws Throwable  {
        // No Comments were added
        CombinedDomainXYPlot combinedDomainXYPlot = new CombinedDomainXYPlot();
        combinedDomainXYPlot.getDataset();
        assertTrue(combinedDomainXYPlot.isRangeCrosshairLockedOnData());
        assertTrue(combinedDomainXYPlot.isDomainCrosshairLockedOnData());
        assertEquals(1, combinedDomainXYPlot.getWeight());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testGetRangeMarkersTakingLayer() throws Throwable  {
        // rollbacked to evosuite
        CombinedDomainXYPlot combinedDomainXYPlot = new CombinedDomainXYPlot();
        combinedDomainXYPlot.getRangeMarkers((Layer) null);
        assertEquals(1, combinedDomainXYPlot.getWeight());
        assertTrue(combinedDomainXYPlot.isRangeCrosshairLockedOnData());
        assertTrue(combinedDomainXYPlot.isDomainCrosshairLockedOnData());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testGetQuadrantOrigin() throws Throwable  {
        // Given a CombinedDomainXYPlot instance
        CombinedDomainXYPlot combinedDomainXYPlot = new CombinedDomainXYPlot();
        
        // When the quadrant origin is retrieved
        Point2D.Double quadrantOrigin = (Point2D.Double)combinedDomainXYPlot.getQuadrantOrigin();
        
        // Then the domain crosshair should be locked on data
        assertTrue(combinedDomainXYPlot.isDomainCrosshairLockedOnData());
        
        // And the weight should be 1
        assertEquals(1, combinedDomainXYPlot.getWeight());
        
        // And the quadrant origin should have x and y values of 0
        assertEquals(0.0, quadrantOrigin.x, 0.01);
        assertEquals(0.0, quadrantOrigin.y, 0.01);
        
        // And the range crosshair should be locked on data
        assertTrue(combinedDomainXYPlot.isRangeCrosshairLockedOnData());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testGetRangeCrosshairStroke() throws Throwable  {
        // Create a new CombinedDomainXYPlot object
        CombinedDomainXYPlot combinedDomainXYPlot = new CombinedDomainXYPlot();
        
        // Check that the range crosshair is locked on data and the domain crosshair is also locked on data
        assertTrue(combinedDomainXYPlot.isRangeCrosshairLockedOnData());
        assertTrue(combinedDomainXYPlot.isDomainCrosshairLockedOnData());
        
        // Get the range crosshair stroke and check that it is a BasicStroke object
        BasicStroke rangeCrosshairStroke = (BasicStroke) combinedDomainXYPlot.getRangeCrosshairStroke();
        assertTrue(rangeCrosshairStroke instanceof BasicStroke);
        
        // Check the miter limit of the range crosshair stroke
        assertEquals(0.0F, rangeCrosshairStroke.getMiterLimit(), 0.01F);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testGetDomainCrosshairPaint() throws Throwable  {
        // Given: We have an instance of XYPlot and we want to test its properties
        XYPlot xyPlot = new XYPlot();
        
        // When: We call getDomainCrosshairPaint() method on the XYPlot object
        Color domainCrosshairPaint = (Color)xyPlot.getDomainCrosshairPaint();
        
        // Then: The returned value should be a Color with RGB value of -16776961 and weight 1
        assertTrue(xyPlot.isRangeCrosshairLockedOnData());
        assertEquals((-16776961), domainCrosshairPaint.getRGB());
        assertEquals(1, xyPlot.getWeight());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testIsRangeZoomable() throws Throwable  {
        // Given a CombinedDomainXYPlot object, when its range zoomability is checked,
        // Then the range zoomability should be set to true.
        CombinedDomainXYPlot combinedDomainXYPlot = new CombinedDomainXYPlot();
        boolean isRangeZoomable = combinedDomainXYPlot.isRangeZoomable();
        assertTrue(combinedDomainXYPlot.isRangeCrosshairLockedOnData());
        assertTrue(isRangeZoomable);
        assertEquals(1, combinedDomainXYPlot.getWeight());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testGetRangeCrosshairValueReturningZero() throws Throwable  {
        // rollbacked to evosuite
        CombinedRangeXYPlot combinedRangeXYPlot = new CombinedRangeXYPlot();
        double rangeCrosshairValue = combinedRangeXYPlot.getRangeCrosshairValue();
        assertTrue(combinedRangeXYPlot.isRangeCrosshairLockedOnData());
        assertEquals(1, combinedRangeXYPlot.getWeight());
        assertTrue(combinedRangeXYPlot.isDomainCrosshairLockedOnData());
        assertEquals(0.0, rangeCrosshairValue, 0.01);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testIsDomainZoomable() throws Throwable  {
        // rollbacked to evosuite
        CombinedDomainXYPlot combinedDomainXYPlot = new CombinedDomainXYPlot();
        boolean domainZoomable = combinedDomainXYPlot.isDomainZoomable();
        assertEquals(1, combinedDomainXYPlot.getWeight());
        assertTrue(combinedDomainXYPlot.isDomainCrosshairLockedOnData());
        assertTrue(domainZoomable);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testGetDomainAxisCount() throws Throwable  {
        // Set up a new CombinedDomainXYPlot object and retrieve its domain axis count
        CombinedDomainXYPlot combinedDomainXYPlot = new CombinedDomainXYPlot();
        int domainAxisCount = combinedDomainXYPlot.getDomainAxisCount();
        
        // Assert that the weight of the CombinedDomainXYPlot is 1
        assertEquals(1, combinedDomainXYPlot.getWeight());
        
        // Assert that the domain crosshair is locked on data for the CombinedDomainXYPlot
        assertTrue(combinedDomainXYPlot.isDomainCrosshairLockedOnData());
        
        // Assert that the range crosshair is locked on data for the CombinedDomainXYPlot
        assertTrue(combinedDomainXYPlot.isRangeCrosshairLockedOnData());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testGetRangeGridlinePaint() throws Throwable  {
        // Test the properties of a CombinedDomainXYPlot
        CombinedDomainXYPlot combinedDomainXYPlot = new CombinedDomainXYPlot();
        
        // Check the weight property
        assertEquals(1, combinedDomainXYPlot.getWeight());
        
        // Check the domain crosshair locking property
        assertTrue(combinedDomainXYPlot.isDomainCrosshairLockedOnData());
        
        // Check the range crosshair locking property
        assertTrue(combinedDomainXYPlot.isRangeCrosshairLockedOnData());
        
        // Check the range gridline paint property
        Color rangeGridlinePaint = (Color) combinedDomainXYPlot.getRangeGridlinePaint();
        assertEquals((-4144960), rangeGridlinePaint.getRGB());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testSetFixedLegendItems() throws Throwable  {
        // Given a CombinedDomainXYPlot object, we want to test that it has a fixed legend items collection and
        // that its domain crosshair is locked on data.
        CombinedDomainXYPlot combinedDomainXYPlot = new CombinedDomainXYPlot();
        
        // When we set the fixed legend items collection to null.
        combinedDomainXYPlot.setFixedLegendItems(null);
        
        // Then we assert that the domain crosshair is locked on data and that its weight is 1.
        assertTrue(combinedDomainXYPlot.isDomainCrosshairLockedOnData());
        assertEquals(1, combinedDomainXYPlot.getWeight());
        
        // When we check if the range crosshair is also locked on data.
        assertTrue(combinedDomainXYPlot.isRangeCrosshairLockedOnData());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testGetRangeGridlineStroke() throws Throwable  {
        // Given a CombinedRangeXYPlot object with various properties set
        CombinedRangeXYPlot combinedRangeXYPlot = new CombinedRangeXYPlot();
        
        // When the range gridline stroke is retrieved
        BasicStroke rangeGridlineStroke = (BasicStroke) combinedRangeXYPlot.getRangeGridlineStroke();
        
        // Then the range crosshair is locked on data and the weight is 1
        assertTrue(combinedRangeXYPlot.isRangeCrosshairLockedOnData());
        assertEquals(1, combinedRangeXYPlot.getWeight());
        
        // And the domain crosshair is also locked on data
        assertTrue(combinedRangeXYPlot.isDomainCrosshairLockedOnData());
        
        // And the miter limit of the range gridline stroke is 0.0F with a tolerance of 0.01F
        assertEquals(0.0F, rangeGridlineStroke.getMiterLimit(), 0.01F);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testGetIndexOfReturningNegative() throws Throwable  {
        CombinedDomainXYPlot combinedDomainXYPlot = new CombinedDomainXYPlot();
        StackedXYBarRenderer arg0 = new StackedXYBarRenderer();
        
        // Get the index of the specified renderer in the plot
        int rendererIndex = combinedDomainXYPlot.getIndexOf(arg0);
        
        // Check that the crosshair is locked on the data
        assertTrue(combinedDomainXYPlot.isRangeCrosshairLockedOnData());
        assertTrue(combinedDomainXYPlot.isDomainCrosshairLockedOnData());
        
        // Check that the weight of the plot is 1
        assertEquals(1, combinedDomainXYPlot.getWeight());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testSetWeight() throws Throwable  {
        // Given a CombinedDomainXYPlot object with a default weight of 0
        CombinedDomainXYPlot combinedDomainXYPlot = new CombinedDomainXYPlot();
        
        // When the weight is set to 1000
        combinedDomainXYPlot.setWeight(1000);
        
        // Then the getWeight method returns 1000
        assertEquals(1000, combinedDomainXYPlot.getWeight());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testGetRangeCrosshairPaint() throws Throwable  {
        // Given a combined range XY plot
        CombinedRangeXYPlot combinedRangeXYPlot = new CombinedRangeXYPlot();
        
        // When we set the weight of the plot to 1
        combinedRangeXYPlot.setWeight(1);
        
        // Then the weight should be equal to 1
        assertEquals(1, combinedRangeXYPlot.getWeight());
        
        // And when we set the range crosshair lock on data property to true
        combinedRangeXYPlot.setRangeCrosshairLockedOnData(true);
        
        // Then the range crosshair lock on data property should be true
        assertTrue(combinedRangeXYPlot.isRangeCrosshairLockedOnData());
        
        // And when we set the domain crosshair lock on data property to true
        combinedRangeXYPlot.setDomainCrosshairLockedOnData(true);
        
        // Then the domain crosshair lock on data property should be true
        assertTrue(combinedRangeXYPlot.isDomainCrosshairLockedOnData());
        
        // And when we get the range crosshair paint
        Color rangeCrosshairPaint = (Color) combinedRangeXYPlot.getRangeCrosshairPaint();
        
        // Then the green value of the color should be 0
        assertEquals(0, rangeCrosshairPaint.getGreen());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testClearAnnotations() throws Throwable  {
        // Given a CombinedDomainXYPlot object with crosshairs locked on data
        CombinedDomainXYPlot combinedDomainXYPlot = new CombinedDomainXYPlot();
        combinedDomainXYPlot.setDomainCrosshairLockedOnData(true);
        combinedDomainXYPlot.setRangeCrosshairLockedOnData(true);
        
        // When the crosshairs are cleared from the plot
        combinedDomainXYPlot.clearAnnotations();
        
        // Then the crosshairs should be unlocked and the weight should be 1
        assertFalse(combinedDomainXYPlot.isDomainCrosshairLockedOnData());
        assertEquals(1, combinedDomainXYPlot.getWeight());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testSetRangeCrosshairValueTakingDouble() throws Throwable  {
        // Create a new instance of the CombinedRangeXYPlot class
        CombinedRangeXYPlot combinedRangeXYPlot = new CombinedRangeXYPlot();
        
        // Set the range crosshair value to 1.0E-4
        combinedRangeXYPlot.setRangeCrosshairValue(1.0E-4);
        
        // Get the range crosshair value and assert that it is equal to 1.0E-4
        double actualRangeCrosshairValue = combinedRangeXYPlot.getRangeCrosshairValue();
        assertEquals(1.0E-4, actualRangeCrosshairValue, 0.01);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testSetDatasetTakingXYDataset() throws Throwable  {
        // No Comments were added
        CombinedDomainXYPlot combinedDomainXYPlot = new CombinedDomainXYPlot();
        TimeTableXYDataset arg0 = new TimeTableXYDataset();
        combinedDomainXYPlot.setDataset((XYDataset) arg0);
        XYDataset dataset = combinedDomainXYPlot.getDataset();
        assertEquals(1, combinedDomainXYPlot.getWeight());
        assertTrue(combinedDomainXYPlot.isRangeCrosshairLockedOnData());
        assertNotNull(dataset);
        assertTrue(combinedDomainXYPlot.isDomainCrosshairLockedOnData());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testGetRangeZeroBaselinePaint() throws Throwable  {
        // Given a XYPlot object, we want to test that its range crosshair is locked on data
        XYPlot xyPlot = new XYPlot();
        
        // When we get the paint used for the range zero baseline
        Color rangeZeroBaselinePaint = (Color)xyPlot.getRangeZeroBaselinePaint();
        
        // Then we check that the paint has a blue color and that the weight of the plot is 1
        assertTrue(xyPlot.isRangeCrosshairLockedOnData());
        assertEquals(0, rangeZeroBaselinePaint.getBlue());
        assertEquals(1, xyPlot.getWeight());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testGetRangeAxisEdgeTakingNoArguments() throws Throwable  {
        // rollbacked to evosuite
        CombinedRangeXYPlot combinedRangeXYPlot = new CombinedRangeXYPlot();
        combinedRangeXYPlot.getRangeAxisEdge();
        assertTrue(combinedRangeXYPlot.isRangeCrosshairLockedOnData());
        assertTrue(combinedRangeXYPlot.isDomainCrosshairLockedOnData());
        assertEquals(1, combinedRangeXYPlot.getWeight());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testDrawDomainGridlinesThrowsNullPointerException() throws Throwable  {
        CombinedDomainXYPlot combinedDomainXYPlot = new CombinedDomainXYPlot();
        DefaultXYItemRenderer arg0 = new DefaultXYItemRenderer();
        combinedDomainXYPlot.setRenderer((XYItemRenderer) arg0);
        
        // Draw domain gridlines with a null Graphics2D object should throw a NullPointerException
        try {
        combinedDomainXYPlot.drawDomainGridlines(null, null, null);
        fail("Expecting exception: NullPointerException");
        } catch (NullPointerException e) {
        // Verify that the expected exception was thrown
        verifyException("org.jfree.chart.plot.XYPlot", e);}
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testSetRangeCrosshairPaint() throws Throwable  {
        // Setup the plot
        CombinedDomainXYPlot plot = new CombinedDomainXYPlot();
        
        // Test the crosshair paint
        Color yellow = Color.YELLOW;
        plot.setRangeCrosshairPaint(yellow);
        assertTrue(plot.isDomainCrosshairLockedOnData());
        assertTrue(plot.isRangeCrosshairLockedOnData());
        
        // Test the weight
        int weight = 1;
        assertEquals(weight, plot.getWeight());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testGetDomainGridlineStroke() throws Throwable  {
        // Create a new instance of CombinedRangeXYPlot
        CombinedRangeXYPlot combinedRangeXYPlot = new CombinedRangeXYPlot();
        
        // Set the domain gridline stroke to a BasicStroke with a line join style of 2 (BEVEL) and a weight of 1
        BasicStroke domainGridlineStroke = new BasicStroke(1, BasicStroke.CAP_BUTT, BasicStroke.JOIN_BEVEL);
        combinedRangeXYPlot.setDomainGridlineStroke(domainGridlineStroke);
        
        // Verify that the domain crosshair stroke is set to the same BasicStroke instance as the domain gridline stroke
        assertEquals(domainGridlineStroke, combinedRangeXYPlot.getDomainCrosshairStroke());
        
        // Verify that the domain crosshair is locked on data
        assertTrue(combinedRangeXYPlot.isDomainCrosshairLockedOnData());
        
        // Verify that the range gridline stroke is set to a BasicStroke with a line join style of 2 (BEVEL) and a weight of 1
        assertEquals(new BasicStroke(1, BasicStroke.CAP_BUTT, BasicStroke.JOIN_BEVEL), combinedRangeXYPlot.getRangeGridlineStroke());
        
        // Verify that the range crosshair stroke is set to the same BasicStroke instance as the range gridline stroke
        assertEquals(combinedRangeXYPlot.getRangeCrosshairStroke(), combinedRangeXYPlot.getRangeGridlineStroke());
        
        // Verify that the range crosshair is locked on data
        assertTrue(combinedRangeXYPlot.isRangeCrosshairLockedOnData());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testGetAnnotations() throws Throwable  {
        // rollbacked to evosuite
        CombinedRangeXYPlot combinedRangeXYPlot = new CombinedRangeXYPlot();
        combinedRangeXYPlot.getAnnotations();
        assertEquals(1, combinedRangeXYPlot.getWeight());
        assertTrue(combinedRangeXYPlot.isRangeCrosshairLockedOnData());
        assertTrue(combinedRangeXYPlot.isDomainCrosshairLockedOnData());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testGetRangeAxisCount() throws Throwable  {
        // Create a new instance of CombinedDomainXYPlot
        CombinedDomainXYPlot combinedDomainXYPlot = new CombinedDomainXYPlot();
        
        // Verify that the range axis count is 0
        assertEquals(0, combinedDomainXYPlot.getRangeAxisCount());
        
        // Verify that the domain crosshair is locked on data
        assertTrue(combinedDomainXYPlot.isDomainCrosshairLockedOnData());
        
        // Verify that the range crosshair is locked on data
        assertTrue(combinedDomainXYPlot.isRangeCrosshairLockedOnData());
        
        // Verify that the weight of the combined plot is 1
        assertEquals(1, combinedDomainXYPlot.getWeight());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testSetDomainAxisLocationTaking1And1AndSetDomainAxisLocationTaking1And11() throws Throwable  {
        // rollbacked to evosuite
        CombinedDomainXYPlot combinedDomainXYPlot = new CombinedDomainXYPlot((ValueAxis) null);
        AxisLocation arg1 = AxisLocation.BOTTOM_OR_RIGHT;
        combinedDomainXYPlot.setDomainAxisLocation(2001, arg1);
        assertTrue(combinedDomainXYPlot.isDomainCrosshairLockedOnData());
        assertEquals(1, combinedDomainXYPlot.getWeight());
        assertTrue(combinedDomainXYPlot.isRangeCrosshairLockedOnData());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testIsRangeCrosshairLockedOnData() throws Throwable  {
        // Create a new instance of the CombinedDomainXYPlot class
        CombinedDomainXYPlot combinedDomainXYPlot = new CombinedDomainXYPlot();
        
        // Test that the domain crosshair is locked on data
        assertTrue(combinedDomainXYPlot.isDomainCrosshairLockedOnData());
        
        // Test that the range crosshair is locked on data
        assertTrue(combinedDomainXYPlot.isRangeCrosshairLockedOnData());
        
        // Test that the weight of the plot is 1
        assertEquals(1, combinedDomainXYPlot.getWeight());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testSetFixedDomainAxisSpace() throws Throwable  {
        // Given a CombinedRangeXYPlot object
        CombinedRangeXYPlot plot = new CombinedRangeXYPlot();
        
        // When the fixedDomainAxisSpace property is set to null
        plot.setFixedDomainAxisSpace(null);
        
        // Then the rangeCrosshairLockedOnData property should be true
        assertTrue(plot.isRangeCrosshairLockedOnData());
        
        // And the domainCrosshairLockedOnData property should be true
        assertTrue(plot.isDomainCrosshairLockedOnData());
        
        // And the weight property should be 1
        assertEquals(1, plot.getWeight());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testGetSeriesRenderingOrder() throws Throwable  {
        // Given a CombinedRangeXYPlot instance with default settings
        CombinedRangeXYPlot combinedRangeXYPlot = new CombinedRangeXYPlot();
        
        // When the series rendering order is set to a specific value
        SeriesRenderingOrder arg0 = combinedRangeXYPlot.getSeriesRenderingOrder();
        combinedRangeXYPlot.setSeriesRenderingOrder(arg0);
        
        // Then the range crosshair lock state should remain unchanged
        assertTrue(combinedRangeXYPlot.isRangeCrosshairLockedOnData());
        
        // And the weight of the plot should be set to 1
        assertEquals(1, combinedRangeXYPlot.getWeight());
        
        // And the domain crosshair lock state should remain unchanged
        assertTrue(combinedRangeXYPlot.isDomainCrosshairLockedOnData());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testCreatesXYPlotTakingNoArguments() throws Throwable  {
        // rollbacked to evosuite
        XYPlot arg0 = new XYPlot();
        JFreeChart jFreeChart = new JFreeChart(arg0);
        // Undeclared exception!
        try { 
          jFreeChart.createBufferedImage(100, 50);
          fail("Expecting exception: NullPointerException");
        
        } catch(NullPointerException e) {
           //
           // no message in exception (getMessage() returned null)
           //
           verifyException("org.jfree.chart.plot.XYPlot", e);
        }
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testGetAxisOffset() throws Throwable  {
        // Given: A CombinedRangeXYPlot object is created and its properties are set
        CombinedRangeXYPlot combinedRangeXYPlot = new CombinedRangeXYPlot();
        combinedRangeXYPlot.setWeight(1);
        combinedRangeXYPlot.setRangeCrosshairLockedOnData(true);
        
        // When: The axis offset of the plot is retrieved
        RectangleInsets axisOffset = combinedRangeXYPlot.getAxisOffset();
        
        // Then: The range crosshair should be locked on data, and the axis offset should be zero
        assertTrue(combinedRangeXYPlot.isRangeCrosshairLockedOnData());
        assertEquals(0.0, axisOffset.getRight(), 0.01);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testGetRangeZeroBaselineStroke() throws Throwable  {
        // Given a CombinedDomainXYPlot object with some pre-configured settings
        CombinedDomainXYPlot combinedDomainXYPlot = new CombinedDomainXYPlot();
        combinedDomainXYPlot.setRangeZeroBaselineStroke(new BasicStroke());
        combinedDomainXYPlot.setWeight(1);
        combinedDomainXYPlot.setDomainCrosshairLockedOnData(true);
        combinedDomainXYPlot.setRangeCrosshairLockedOnData(true);
        
        // When the CombinedDomainXYPlot object is initialized with some default settings
        BasicStroke rangeZeroBaselineStroke = (BasicStroke) combinedDomainXYPlot.getRangeZeroBaselineStroke();
        
        // Then the CombinedDomainXYPlot object should have certain properties set, including:
        assertTrue(combinedDomainXYPlot.isRangeCrosshairLockedOnData());
        assertTrue(combinedDomainXYPlot.isDomainCrosshairLockedOnData());
        assertEquals(1, combinedDomainXYPlot.getWeight());
        assertEquals(2, rangeZeroBaselineStroke.getEndCap());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testGetDomainTickBandPaint() throws Throwable  {
        // rollbacked to evosuite
        CombinedRangeXYPlot combinedRangeXYPlot = new CombinedRangeXYPlot();
        Paint domainTickBandPaint = combinedRangeXYPlot.getDomainTickBandPaint();
        assertNull(domainTickBandPaint);
        assertTrue(combinedRangeXYPlot.isDomainCrosshairLockedOnData());
        assertTrue(combinedRangeXYPlot.isRangeCrosshairLockedOnData());
        assertEquals(1, combinedRangeXYPlot.getWeight());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testSetRangeZeroBaselineVisible() throws Throwable  {
        // Given a CombinedDomainXYPlot instance with range zero baseline visible set to true
        CombinedDomainXYPlot combinedDomainXYPlot = new CombinedDomainXYPlot();
        combinedDomainXYPlot.setRangeZeroBaselineVisible(true);
        
        // When the range zero baseline visibility is checked
        boolean actualResult = combinedDomainXYPlot.isRangeZeroBaselineVisible();
        
        // Then the result should be true, indicating that the range zero baseline is visible
        assertTrue(actualResult);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testGetRangeAxisLocationTakingNoArguments() throws Throwable  {
        // Arrange
        CombinedDomainXYPlot plot = new CombinedDomainXYPlot();
        
        // Act
        AxisLocation rangeAxisLocation = plot.getRangeAxisLocation();
        
        // Assert
        assertEquals(1, plot.getWeight());
        assertNotNull(rangeAxisLocation);
        assertTrue(plot.isDomainCrosshairLockedOnData());
        assertTrue(plot.isRangeCrosshairLockedOnData());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testGetDomainAxisForDatasetThrowsIllegalArgumentException() throws Throwable  {
        CombinedDomainXYPlot combinedDomainXYPlot = new CombinedDomainXYPlot();
        // Undeclared exception!
        try {
        combinedDomainXYPlot.getDomainAxisForDataset(10);
        fail("Expecting exception: IllegalArgumentException");
        
        } catch(IllegalArgumentException e) {
        // The specified index is out of bounds for the number of datasets in the plot.
        verifyException("org.jfree.chart.plot.XYPlot", e);}
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testSetRangeAxisLocationTaking1And1AndSetRangeAxisLocationTaking1And1AndSetRangeAxisLocationTaking1And1WithZero() throws Throwable  {
        // No Comments were added
        CombinedRangeXYPlot combinedRangeXYPlot = new CombinedRangeXYPlot((ValueAxis) null);
        combinedRangeXYPlot.setRangeAxisLocation(0, (AxisLocation) null);
        assertTrue(combinedRangeXYPlot.isRangeCrosshairLockedOnData());
        assertEquals(1, combinedRangeXYPlot.getWeight());
        assertTrue(combinedRangeXYPlot.isDomainCrosshairLockedOnData());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testGetDatasetRenderingOrder() throws Throwable  {
        // Given a CombinedDomainXYPlot instance
        CombinedDomainXYPlot combinedDomainXYPlot = new CombinedDomainXYPlot();
        
        // When the dataset rendering order is retrieved and set
        DatasetRenderingOrder originalOrder = combinedDomainXYPlot.getDatasetRenderingOrder();
        combinedDomainXYPlot.setDatasetRenderingOrder(originalOrder);
        
        // Then the dataset rendering order should be restored to its original value
        assertEquals(originalOrder, combinedDomainXYPlot.getDatasetRenderingOrder());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testGetDomainCrosshairValueReturningZero() throws Throwable  {
        // Given a CombinedDomainXYPlot object
        CombinedDomainXYPlot combinedDomainXYPlot = new CombinedDomainXYPlot();
        
        // When the domain crosshair value is retrieved
        double domainCrosshairValue = combinedDomainXYPlot.getDomainCrosshairValue();
        
        // Then the domain crosshair value should be equal to 0.0, with a tolerance of 0.01
        assertEquals(0.0, domainCrosshairValue, 0.01);
        
        // And the weight should be equal to 1
        assertEquals(1, combinedDomainXYPlot.getWeight());
        
        // And the range crosshair lock state should be true
        assertTrue(combinedDomainXYPlot.isRangeCrosshairLockedOnData());
        
        // And the domain crosshair lock state should be true
        assertTrue(combinedDomainXYPlot.isDomainCrosshairLockedOnData());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testAddRangeMarkerTakingMarker() throws Throwable  {
        // No Comments were added
        CombinedDomainXYPlot combinedDomainXYPlot = new CombinedDomainXYPlot();
        CategoryMarker arg0 = new CategoryMarker(10.5F, combinedDomainXYPlot.DEFAULT_GRIDLINE_PAINT, combinedDomainXYPlot.DEFAULT_GRIDLINE_STROKE);
        combinedDomainXYPlot.addRangeMarker((Marker) arg0);
        assertTrue(combinedDomainXYPlot.isRangeCrosshairLockedOnData());
        assertEquals(1, combinedDomainXYPlot.getWeight());
    }
  }
  