content: /*
   * This file was automatically generated by UTestGen and EvoSuite
   * Wed Mar 20 05:49:17 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.Second;
  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_Original_ESTest extends XYPlot_Original_ESTest_scaffolding {
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testSetDomainAxisTakingValueAxis() throws Throwable  {
        XYPlot xYPlot = new XYPlot();
        ThermometerPlot thermometerPlot = new ThermometerPlot();
        ValueAxis arg0 = thermometerPlot.getRangeAxis();
        xYPlot.setDomainAxis(arg0);
        assertTrue(xYPlot.isDomainCrosshairLockedOnData());
        assertEquals(1, xYPlot.getDomainAxisCount());
        assertEquals(1, xYPlot.getWeight());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testDrawQuadrantsThrowsNullPointerException() throws Throwable  {
        Rectangle arg1 = new Rectangle();
        CombinedDomainXYPlot combinedDomainXYPlot = new CombinedDomainXYPlot((ValueAxis) null);
        // Undeclared exception!
        try { 
          combinedDomainXYPlot.drawQuadrants((Graphics2D) null, arg1);
          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 testDrawThrowsNullPointerException() throws Throwable  {
        CombinedDomainXYPlot combinedDomainXYPlot = new CombinedDomainXYPlot();
        Rectangle arg1 = new Rectangle();
        JViewport jViewport = new JViewport();
        Point arg2 = jViewport.getViewPosition();
        PlotState arg3 = new PlotState();
        StandardEntityCollection arg0 = new StandardEntityCollection();
        ChartRenderingInfo chartRenderingInfo = new ChartRenderingInfo(arg0);
        PlotRenderingInfo arg4 = chartRenderingInfo.getPlotInfo();
        // Undeclared exception!
        try { 
          combinedDomainXYPlot.draw((Graphics2D) null, arg1, arg2, arg3, arg4);
          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 testIsDomainCrosshairVisibleReturningTrue() throws Throwable  {
        CombinedDomainXYPlot combinedDomainXYPlot = new CombinedDomainXYPlot();
        combinedDomainXYPlot.setDomainCrosshairVisible(true);
        boolean domainCrosshairVisible = combinedDomainXYPlot.isDomainCrosshairVisible();
        assertTrue(domainCrosshairVisible);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testGetRendererTakingNoArgumentsReturningXYItemRendererWhereGetPassCountIsPositive() throws Throwable  {
        XYSeriesCollection arg0 = new XYSeriesCollection();
        SimpleTimeZone arg1 = (SimpleTimeZone)SegmentedTimeline.NO_DST_TIME_ZONE;
        DateAxis arg2 = new DateAxis(">MO]ds", arg1);
        XYErrorRenderer arg3 = new XYErrorRenderer();
        XYPlot xYPlot = new XYPlot(arg0, arg2, arg2, arg3);
        XYErrorRenderer renderer = (XYErrorRenderer)xYPlot.getRenderer();
        assertTrue(renderer.getDrawOutlines());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testGetRangeAxisForDatasetReturningValueAxisWhereIsNegativeArrowVisibleIsTrue() throws Throwable  {
        DateAxis arg0 = new DateAxis();
        CombinedRangeXYPlot combinedRangeXYPlot = new CombinedRangeXYPlot(arg0);
        arg0.setNegativeArrowVisible(true);
        ValueAxis rangeAxisForDataset = combinedRangeXYPlot.getRangeAxisForDataset(0);
        assertTrue(combinedRangeXYPlot.isRangeCrosshairLockedOnData());
        assertTrue(combinedRangeXYPlot.isDomainCrosshairLockedOnData());
        assertNotNull(rangeAxisForDataset);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testGetRangeAxisForDatasetReturningValueAxisWhereIsNegativeArrowVisibleIsFalse() throws Throwable  {
        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);
        assertEquals(1, xYPlot.getWeight());
        assertNotNull(rangeAxisForDataset);
        assertTrue(xYPlot.isRangeCrosshairLockedOnData());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testGetRangeAxisTakingNoArgumentsReturningNull() throws Throwable  {
        CombinedRangeXYPlot combinedRangeXYPlot = new CombinedRangeXYPlot((ValueAxis) null);
        combinedRangeXYPlot.getRangeAxis();
        assertTrue(combinedRangeXYPlot.isDomainCrosshairLockedOnData());
        assertEquals(1, combinedRangeXYPlot.getWeight());
        assertTrue(combinedRangeXYPlot.isRangeCrosshairLockedOnData());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testGetRangeAxisTakingNoArgumentsReturningValueAxisWhereGetLowerBoundIsPositive() throws Throwable  {
        CyclicNumberAxis arg0 = new CyclicNumberAxis(Double.POSITIVE_INFINITY, 1642.1550779831);
        arg0.setRange(1642.1550779831, Double.POSITIVE_INFINITY);
        CombinedRangeXYPlot combinedRangeXYPlot = new CombinedRangeXYPlot(arg0);
        combinedRangeXYPlot.getRangeAxis();
        assertTrue(combinedRangeXYPlot.isRangeCrosshairLockedOnData());
        assertTrue(combinedRangeXYPlot.isDomainCrosshairLockedOnData());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testGetRangeAxisTakingNoArgumentsReturningValueAxisWhereGetLowerBoundIsNegative() throws Throwable  {
        CyclicNumberAxis arg0 = new CyclicNumberAxis(931.2362932587);
        CombinedRangeXYPlot combinedRangeXYPlot = new CombinedRangeXYPlot(arg0);
        combinedRangeXYPlot.getRangeAxis();
        assertEquals(1, combinedRangeXYPlot.getWeight());
        assertTrue(combinedRangeXYPlot.isDomainCrosshairLockedOnData());
        assertTrue(combinedRangeXYPlot.isRangeCrosshairLockedOnData());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testGetPlotTypeReturningNonEmptyString() throws Throwable  {
        CombinedDomainXYPlot combinedDomainXYPlot = new CombinedDomainXYPlot();
        combinedDomainXYPlot.getPlotType();
        assertEquals(1, combinedDomainXYPlot.getWeight());
        assertTrue(combinedDomainXYPlot.isDomainCrosshairLockedOnData());
        assertTrue(combinedDomainXYPlot.isRangeCrosshairLockedOnData());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testGetIndexOfReturningPositive() throws Throwable  {
        CombinedDomainXYPlot combinedDomainXYPlot = new CombinedDomainXYPlot();
        XYBarRenderer arg0 = new XYBarRenderer(1.0F);
        combinedDomainXYPlot.setRenderer(10, (XYItemRenderer) arg0, false);
        int indexOf = combinedDomainXYPlot.getIndexOf(arg0);
        assertEquals(1, combinedDomainXYPlot.getWeight());
        assertTrue(combinedDomainXYPlot.isRangeCrosshairLockedOnData());
        assertEquals(10, indexOf);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testGetIndexOfReturningNegative() throws Throwable  {
        CombinedDomainXYPlot combinedDomainXYPlot = new CombinedDomainXYPlot();
        StackedXYBarRenderer arg0 = new StackedXYBarRenderer();
        combinedDomainXYPlot.getIndexOf(arg0);
        assertTrue(combinedDomainXYPlot.isRangeCrosshairLockedOnData());
        assertTrue(combinedDomainXYPlot.isDomainCrosshairLockedOnData());
        assertEquals(1, combinedDomainXYPlot.getWeight());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testGetDomainAxisEdgeTakingNoArguments() throws Throwable  {
        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  {
        String[] arg1 = new String[0];
        SymbolAxis arg0 = new SymbolAxis((String) null, arg1);
        CombinedDomainXYPlot combinedDomainXYPlot = new CombinedDomainXYPlot(arg0);
        combinedDomainXYPlot.getDomainAxis(0);
        assertEquals(1, combinedDomainXYPlot.getWeight());
        assertTrue(combinedDomainXYPlot.isDomainCrosshairLockedOnData());
        assertTrue(combinedDomainXYPlot.isRangeCrosshairLockedOnData());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testGetDomainAxisTakingNoArgumentsReturningNull() throws Throwable  {
        CombinedRangeXYPlot combinedRangeXYPlot = new CombinedRangeXYPlot();
        combinedRangeXYPlot.getDomainAxis();
        assertTrue(combinedRangeXYPlot.isDomainCrosshairLockedOnData());
        assertEquals(1, combinedRangeXYPlot.getWeight());
        assertTrue(combinedRangeXYPlot.isRangeCrosshairLockedOnData());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testGetDomainAxisTakingNoArgumentsReturningValueAxisWhereGetUpperBoundIsZero() throws Throwable  {
        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);
        combinedDomainXYPlot.getDomainAxis();
        assertEquals(1, combinedDomainXYPlot.getWeight());
        assertTrue(combinedDomainXYPlot.isDomainCrosshairLockedOnData());
        assertTrue(combinedDomainXYPlot.isRangeCrosshairLockedOnData());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testGetDomainAxisTakingNoArgumentsReturningValueAxisWhereGetTickMarkInsideLengthIsNegative() throws Throwable  {
        NumberAxis3D arg0 = new NumberAxis3D("");
        arg0.setTickMarkInsideLength((-1790.2037F));
        CombinedDomainXYPlot combinedDomainXYPlot = new CombinedDomainXYPlot(arg0);
        combinedDomainXYPlot.getDomainAxis();
        assertEquals(1, combinedDomainXYPlot.getWeight());
        assertTrue(combinedDomainXYPlot.isRangeCrosshairLockedOnData());
        assertTrue(combinedDomainXYPlot.isDomainCrosshairLockedOnData());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testGetDomainAxisTakingNoArgumentsReturningValueAxisWhereGetFixedAutoRangeIsPositive() throws Throwable  {
        CyclicNumberAxis arg0 = new CyclicNumberAxis(2177.19695424425, 10);
        CombinedDomainXYPlot combinedDomainXYPlot = new CombinedDomainXYPlot(arg0);
        combinedDomainXYPlot.getDomainAxis();
        assertTrue(combinedDomainXYPlot.isDomainCrosshairLockedOnData());
        assertTrue(combinedDomainXYPlot.isRangeCrosshairLockedOnData());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testEquals() throws Throwable  {
        CombinedDomainXYPlot arg0 = new CombinedDomainXYPlot();
        arg0.equals(arg0);
        assertEquals(1, arg0.getWeight());
        assertTrue(arg0.isRangeCrosshairLockedOnData());
        assertTrue(arg0.isDomainCrosshairLockedOnData());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testGetRangeCrosshairValueReturningNegative() throws Throwable  {
        CombinedDomainXYPlot combinedDomainXYPlot = new CombinedDomainXYPlot();
        combinedDomainXYPlot.setRangeCrosshairValue((-930.18689359599), false);
        double rangeCrosshairValue = combinedDomainXYPlot.getRangeCrosshairValue();
        assertEquals((-930.18689359599), rangeCrosshairValue, 0.01);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testGetDomainCrosshairValueReturningNegative() throws Throwable  {
        CombinedDomainXYPlot combinedDomainXYPlot = new CombinedDomainXYPlot();
        combinedDomainXYPlot.setDomainCrosshairValue((-1029.0), false);
        double domainCrosshairValue = combinedDomainXYPlot.getDomainCrosshairValue();
        assertEquals((-1029.0), domainCrosshairValue, 0.01);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testGetRangeAxisIndexReturningNegative() throws Throwable  {
        DateAxis arg0 = new DateAxis();
        CombinedDomainXYPlot combinedDomainXYPlot = new CombinedDomainXYPlot();
        int rangeAxisIndex = combinedDomainXYPlot.getRangeAxisIndex(arg0);
        assertEquals(1, combinedDomainXYPlot.getWeight());
        assertTrue(combinedDomainXYPlot.isRangeCrosshairLockedOnData());
        assertEquals((-1), rangeAxisIndex);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testGetRangeAxisIndexReturningZero() throws Throwable  {
        CombinedDomainXYPlot combinedDomainXYPlot = new CombinedDomainXYPlot();
        int rangeAxisIndex = combinedDomainXYPlot.getRangeAxisIndex((ValueAxis) null);
        assertEquals(1, combinedDomainXYPlot.getWeight());
        assertTrue(combinedDomainXYPlot.isRangeCrosshairLockedOnData());
        assertEquals(0, rangeAxisIndex);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testGetDomainAxisIndexReturningNegative() throws Throwable  {
        DateAxis arg0 = new DateAxis();
        CombinedRangeXYPlot combinedRangeXYPlot = new CombinedRangeXYPlot();
        int domainAxisIndex = combinedRangeXYPlot.getDomainAxisIndex(arg0);
        assertEquals((-1), domainAxisIndex);
        assertTrue(combinedRangeXYPlot.isRangeCrosshairLockedOnData());
        assertEquals(1, combinedRangeXYPlot.getWeight());
        assertTrue(combinedRangeXYPlot.isDomainCrosshairLockedOnData());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testGetDomainAxisIndexReturningZero() throws Throwable  {
        CombinedRangeXYPlot combinedRangeXYPlot = new CombinedRangeXYPlot();
        int domainAxisIndex = combinedRangeXYPlot.getDomainAxisIndex((ValueAxis) null);
        assertTrue(combinedRangeXYPlot.isDomainCrosshairLockedOnData());
        assertEquals(1, combinedRangeXYPlot.getWeight());
        assertEquals(0, domainAxisIndex);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testGetRangeMarkersTaking2ArgumentsWithNull() throws Throwable  {
        CombinedRangeXYPlot combinedRangeXYPlot = new CombinedRangeXYPlot();
        combinedRangeXYPlot.getRangeMarkers(10, (Layer) null);
        assertTrue(combinedRangeXYPlot.isDomainCrosshairLockedOnData());
        assertTrue(combinedRangeXYPlot.isRangeCrosshairLockedOnData());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testGetDomainMarkersTaking2ArgumentsWithPositive() throws Throwable  {
        CombinedRangeXYPlot combinedRangeXYPlot = new CombinedRangeXYPlot();
        Layer arg1 = Layer.BACKGROUND;
        combinedRangeXYPlot.getDomainMarkers(10, arg1);
        assertEquals(1, combinedRangeXYPlot.getWeight());
        assertTrue(combinedRangeXYPlot.isRangeCrosshairLockedOnData());
        assertTrue(combinedRangeXYPlot.isDomainCrosshairLockedOnData());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testGetDomainMarkersTaking2ArgumentsWithNull() throws Throwable  {
        DateAxis arg0 = new DateAxis();
        CombinedRangeXYPlot combinedRangeXYPlot = new CombinedRangeXYPlot(arg0);
        combinedRangeXYPlot.getDomainMarkers((-1936946035), (Layer) null);
        assertEquals(1, combinedRangeXYPlot.getWeight());
        assertTrue(combinedRangeXYPlot.isDomainCrosshairLockedOnData());
        assertTrue(combinedRangeXYPlot.isRangeCrosshairLockedOnData());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testClearRangeMarkersTakingInt() throws Throwable  {
        CombinedDomainXYPlot combinedDomainXYPlot = new CombinedDomainXYPlot();
        combinedDomainXYPlot.clearRangeMarkers(10);
        assertTrue(combinedDomainXYPlot.isRangeCrosshairLockedOnData());
        assertEquals(1, combinedDomainXYPlot.getWeight());
        assertTrue(combinedDomainXYPlot.isDomainCrosshairLockedOnData());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testAddRangeMarkerTaking3ArgumentsAndClearRangeMarkersTakingInt() throws Throwable  {
        CombinedRangeXYPlot combinedRangeXYPlot = new CombinedRangeXYPlot();
        CategoryMarker arg1 = new CategoryMarker(10);
        Layer arg2 = Layer.FOREGROUND;
        combinedRangeXYPlot.addRangeMarker(649, (Marker) arg1, arg2);
        combinedRangeXYPlot.clearRangeMarkers(649);
        assertEquals(1, combinedRangeXYPlot.getWeight());
        assertTrue(combinedRangeXYPlot.isRangeCrosshairLockedOnData());
        assertTrue(combinedRangeXYPlot.isDomainCrosshairLockedOnData());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testClearDomainMarkersTakingInt() throws Throwable  {
        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  {
        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);
        assertNotNull(rendererForDataset);
        assertTrue(xYPlot.isDomainCrosshairLockedOnData());
        assertEquals(1, xYPlot.getWeight());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testGetRendererForDatasetWithNull() throws Throwable  {
        CombinedRangeXYPlot combinedRangeXYPlot = new CombinedRangeXYPlot();
        combinedRangeXYPlot.getRendererForDataset((XYDataset) null);
        assertTrue(combinedRangeXYPlot.isDomainCrosshairLockedOnData());
        assertEquals(1, combinedRangeXYPlot.getWeight());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testGetRendererTakingIntWithNegative() throws Throwable  {
        CyclicNumberAxis arg0 = new CyclicNumberAxis(0.0);
        CombinedDomainXYPlot combinedDomainXYPlot = new CombinedDomainXYPlot(arg0);
        combinedDomainXYPlot.getRenderer((-1));
        assertTrue(combinedDomainXYPlot.isDomainCrosshairLockedOnData());
        assertEquals(1, combinedDomainXYPlot.getWeight());
        assertTrue(combinedDomainXYPlot.isRangeCrosshairLockedOnData());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testGetRendererTakingIntWithPositive() throws Throwable  {
        CombinedDomainXYPlot combinedDomainXYPlot = new CombinedDomainXYPlot();
        combinedDomainXYPlot.getRenderer(106);
        assertTrue(combinedDomainXYPlot.isDomainCrosshairLockedOnData());
        assertTrue(combinedDomainXYPlot.isRangeCrosshairLockedOnData());
        assertEquals(1, combinedDomainXYPlot.getWeight());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testConfigureRangeAxes() throws Throwable  {
        CombinedDomainXYPlot combinedDomainXYPlot = new CombinedDomainXYPlot();
        combinedDomainXYPlot.configureRangeAxes();
        assertTrue(combinedDomainXYPlot.isDomainCrosshairLockedOnData());
        assertEquals(1, combinedDomainXYPlot.getWeight());
        assertTrue(combinedDomainXYPlot.isRangeCrosshairLockedOnData());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testGetRangeAxisTakingInt0() throws Throwable  {
        CombinedRangeXYPlot combinedRangeXYPlot = new CombinedRangeXYPlot();
        combinedRangeXYPlot.getRangeAxis(10);
        assertEquals(1, combinedRangeXYPlot.getWeight());
        assertTrue(combinedRangeXYPlot.isDomainCrosshairLockedOnData());
        assertTrue(combinedRangeXYPlot.isRangeCrosshairLockedOnData());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testGetRangeAxisTakingIntReturningValueAxisWhereIsVisibleIsTrue() throws Throwable  {
        DateAxis arg0 = new DateAxis();
        CombinedRangeXYPlot combinedRangeXYPlot = new CombinedRangeXYPlot(arg0);
        combinedRangeXYPlot.getRangeAxis(0);
        assertEquals(1, combinedRangeXYPlot.getWeight());
        assertTrue(combinedRangeXYPlot.isRangeCrosshairLockedOnData());
        assertTrue(combinedRangeXYPlot.isDomainCrosshairLockedOnData());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testSetRangeAxisLocationTaking1And1WithTrue() throws Throwable  {
        AxisLocation arg0 = AxisLocation.BOTTOM_OR_LEFT;
        CombinedDomainXYPlot combinedDomainXYPlot = new CombinedDomainXYPlot();
        combinedDomainXYPlot.setRangeAxisLocation(arg0, true);
        assertTrue(combinedDomainXYPlot.isRangeCrosshairLockedOnData());
        assertTrue(combinedDomainXYPlot.isDomainCrosshairLockedOnData());
        assertEquals(1, combinedDomainXYPlot.getWeight());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testGetDomainAxisLocationTakingIntWithZero() throws Throwable  {
        CombinedDomainXYPlot combinedDomainXYPlot = new CombinedDomainXYPlot();
        AxisLocation domainAxisLocation = combinedDomainXYPlot.getDomainAxisLocation(0);
        assertEquals("AxisLocation.BOTTOM_OR_LEFT", domainAxisLocation.toString());
        assertTrue(combinedDomainXYPlot.isRangeCrosshairLockedOnData());
        assertEquals(1, combinedDomainXYPlot.getWeight());
        assertTrue(combinedDomainXYPlot.isDomainCrosshairLockedOnData());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testConfigureDomainAxes() throws Throwable  {
        TimeZone arg1 = TimeZone.getTimeZone("|");
        DateAxis arg0 = new DateAxis("", arg1);
        CombinedRangeXYPlot combinedRangeXYPlot = new CombinedRangeXYPlot(arg0);
        combinedRangeXYPlot.configureDomainAxes();
        assertTrue(combinedRangeXYPlot.isDomainCrosshairLockedOnData());
        assertEquals(1, combinedRangeXYPlot.getWeight());
        assertTrue(combinedRangeXYPlot.isRangeCrosshairLockedOnData());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testSetDomainAxisLocationTaking1And1AndSetDomainAxisLocationTaking1And10() throws Throwable  {
        CombinedDomainXYPlot combinedDomainXYPlot = new CombinedDomainXYPlot();
        CombinedRangeCategoryPlot combinedRangeCategoryPlot = new CombinedRangeCategoryPlot();
        AxisLocation arg0 = combinedRangeCategoryPlot.getDomainAxisLocation(10);
        combinedDomainXYPlot.setDomainAxisLocation(arg0, true);
        assertTrue(combinedDomainXYPlot.isDomainCrosshairLockedOnData());
        assertEquals(1, combinedDomainXYPlot.getWeight());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testGetDomainAxisTakingIntReturningValueAxisWhereIsAutoTickUnitSelectionIsTrue() throws Throwable  {
        ColorBar colorBar = new ColorBar("te991t''28");
        ValueAxis arg0 = colorBar.getAxis();
        CombinedDomainXYPlot combinedDomainXYPlot = new CombinedDomainXYPlot(arg0);
        combinedDomainXYPlot.getDomainAxis(0);
        assertEquals(1, combinedDomainXYPlot.getWeight());
        assertTrue(combinedDomainXYPlot.isRangeCrosshairLockedOnData());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testGetDomainAxisTakingIntWithNegative() throws Throwable  {
        CombinedDomainXYPlot combinedDomainXYPlot = new CombinedDomainXYPlot();
        combinedDomainXYPlot.getDomainAxis((-1952257850));
        assertEquals(1, combinedDomainXYPlot.getWeight());
        assertTrue(combinedDomainXYPlot.isRangeCrosshairLockedOnData());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testMapDatasetToRangeAxis() throws Throwable  {
        CombinedRangeXYPlot combinedRangeXYPlot = new CombinedRangeXYPlot();
        combinedRangeXYPlot.mapDatasetToRangeAxis(10, 10);
        assertTrue(combinedRangeXYPlot.isRangeCrosshairLockedOnData());
        assertEquals(1, combinedRangeXYPlot.getWeight());
        assertTrue(combinedRangeXYPlot.isDomainCrosshairLockedOnData());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testIsDomainCrosshairVisibleReturningFalse() throws Throwable  {
        CombinedRangeXYPlot combinedRangeXYPlot = new CombinedRangeXYPlot();
        combinedRangeXYPlot.isDomainCrosshairVisible();
        assertTrue(combinedRangeXYPlot.isRangeCrosshairLockedOnData());
        assertTrue(combinedRangeXYPlot.isDomainCrosshairLockedOnData());
        assertEquals(1, combinedRangeXYPlot.getWeight());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testMapDatasetToDomainAxis() throws Throwable  {
        Range arg1 = ValueAxis.DEFAULT_RANGE;
        ModuloAxis arg0 = new ModuloAxis("", arg1);
        CombinedRangeXYPlot combinedRangeXYPlot = new CombinedRangeXYPlot(arg0);
        combinedRangeXYPlot.mapDatasetToDomainAxis(15, 2);
        assertTrue(combinedRangeXYPlot.isRangeCrosshairLockedOnData());
        assertEquals(1, combinedRangeXYPlot.getWeight());
        assertTrue(combinedRangeXYPlot.isDomainCrosshairLockedOnData());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testSetDomainAxisTaking2Arguments() throws Throwable  {
        CombinedDomainXYPlot combinedDomainXYPlot = new CombinedDomainXYPlot();
        NumberAxis arg1 = new NumberAxis();
        combinedDomainXYPlot.setDomainAxis(211, (ValueAxis) arg1);
        assertEquals(212, combinedDomainXYPlot.getDomainAxisCount());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testGetDatasetCount() throws Throwable  {
        XYPlot xYPlot = new XYPlot();
        xYPlot.getDatasetCount();
        assertTrue(xYPlot.isRangeCrosshairLockedOnData());
        assertTrue(xYPlot.isDomainCrosshairLockedOnData());
        assertEquals(1, xYPlot.getWeight());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testIsRangeCrosshairVisible() throws Throwable  {
        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  {
        DateAxis arg2 = new DateAxis();
        XYErrorRenderer arg3 = new XYErrorRenderer();
        DefaultXYZDataset arg0 = new DefaultXYZDataset();
        XYPlot xYPlot = new XYPlot(arg0, arg2, arg2, arg3);
        XYPlot clone = (XYPlot)xYPlot.clone();
        assertTrue(clone.isDomainCrosshairLockedOnData());
        assertTrue(clone.equals((Object)xYPlot));
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testCloneAndSetDatasetTaking2Arguments() throws Throwable  {
        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  {
        CombinedDomainXYPlot combinedDomainXYPlot = new CombinedDomainXYPlot();
        CombinedDomainXYPlot arg0 = (CombinedDomainXYPlot)combinedDomainXYPlot.clone();
        boolean equals = combinedDomainXYPlot.equals(arg0);
        assertEquals(1, arg0.getWeight());
        assertTrue(arg0.isDomainCrosshairLockedOnData());
        assertTrue(equals);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testGetSeriesCount() throws Throwable  {
        CombinedRangeXYPlot combinedRangeXYPlot = new CombinedRangeXYPlot();
        int seriesCount = combinedRangeXYPlot.getSeriesCount();
        assertEquals(1, combinedRangeXYPlot.getWeight());
        assertTrue(combinedRangeXYPlot.isDomainCrosshairLockedOnData());
        assertEquals(0, seriesCount);
        assertTrue(combinedRangeXYPlot.isRangeCrosshairLockedOnData());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void test0() throws Throwable  {
        CombinedRangeXYPlot combinedRangeXYPlot = new CombinedRangeXYPlot();
        StandardEntityCollection arg0 = new StandardEntityCollection();
        ChartRenderingInfo chartRenderingInfo = new ChartRenderingInfo(arg0);
        PlotRenderingInfo arg2 = chartRenderingInfo.getPlotInfo();
        GridBagLayout gridBagLayout = new GridBagLayout();
        Point arg3 = gridBagLayout.getLayoutOrigin();
        combinedRangeXYPlot.zoomRangeAxes(1321.0, 1321.0, arg2, (Point2D) arg3);
        assertTrue(combinedRangeXYPlot.isDomainCrosshairLockedOnData());
        assertEquals(1, combinedRangeXYPlot.getWeight());
        assertTrue(combinedRangeXYPlot.isRangeCrosshairLockedOnData());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testZoomRangeAxesTaking4Arguments() throws Throwable  {
        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  {
        CombinedRangeXYPlot combinedRangeXYPlot = new CombinedRangeXYPlot();
        ChartRenderingInfo chartRenderingInfo = new ChartRenderingInfo();
        PlotRenderingInfo arg1 = chartRenderingInfo.getPlotInfo();
        GridBagLayout gridBagLayout = new GridBagLayout();
        Point arg2 = gridBagLayout.getLayoutOrigin();
        combinedRangeXYPlot.zoomRangeAxes(0.05, arg1, (Point2D) arg2);
        assertTrue(combinedRangeXYPlot.isDomainCrosshairLockedOnData());
        assertTrue(combinedRangeXYPlot.isRangeCrosshairLockedOnData());
        assertEquals(1, combinedRangeXYPlot.getWeight());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testZoomRangeAxesTaking3Arguments1() throws Throwable  {
        CombinedRangeXYPlot combinedRangeXYPlot = new CombinedRangeXYPlot((ValueAxis) null);
        ChartRenderingInfo chartRenderingInfo = new ChartRenderingInfo();
        PlotRenderingInfo arg1 = chartRenderingInfo.getPlotInfo();
        GridBagLayout gridBagLayout = new GridBagLayout();
        Point arg2 = gridBagLayout.getLayoutOrigin();
        combinedRangeXYPlot.zoomRangeAxes(0.05, arg1, (Point2D) arg2);
        assertEquals(1, combinedRangeXYPlot.getWeight());
        assertTrue(combinedRangeXYPlot.isDomainCrosshairLockedOnData());
        assertTrue(combinedRangeXYPlot.isRangeCrosshairLockedOnData());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testZoomDomainAxesTaking4ArgumentsWithNonNull() throws Throwable  {
        ChartRenderingInfo chartRenderingInfo = new ChartRenderingInfo();
        PlotRenderingInfo arg2 = chartRenderingInfo.getPlotInfo();
        Point2D.Float arg3 = new Point2D.Float();
        CombinedDomainXYPlot combinedDomainXYPlot = new CombinedDomainXYPlot((ValueAxis) null);
        combinedDomainXYPlot.zoomDomainAxes((double) 10, (double) 10, arg2, (Point2D) arg3);
        assertTrue(combinedDomainXYPlot.isDomainCrosshairLockedOnData());
        assertTrue(combinedDomainXYPlot.isRangeCrosshairLockedOnData());
        assertEquals(1, combinedDomainXYPlot.getWeight());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testZoomDomainAxesTaking4ArgumentsWithNull() throws Throwable  {
        CombinedDomainXYPlot combinedDomainXYPlot = new CombinedDomainXYPlot();
        ChartRenderingInfo chartRenderingInfo = new ChartRenderingInfo();
        PlotRenderingInfo arg2 = chartRenderingInfo.getPlotInfo();
        combinedDomainXYPlot.zoomDomainAxes(448.75, 448.75, arg2, (Point2D) null);
        assertEquals(1, combinedDomainXYPlot.getWeight());
        assertTrue(combinedDomainXYPlot.isDomainCrosshairLockedOnData());
        assertTrue(combinedDomainXYPlot.isRangeCrosshairLockedOnData());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testZoomDomainAxesTaking3Arguments0() throws Throwable  {
        CombinedDomainXYPlot combinedDomainXYPlot = new CombinedDomainXYPlot();
        ChartRenderingInfo chartRenderingInfo = new ChartRenderingInfo();
        PlotRenderingInfo arg1 = chartRenderingInfo.getPlotInfo();
        Point2D.Double arg2 = new Point2D.Double();
        combinedDomainXYPlot.zoomDomainAxes((double) 1.0F, arg1, (Point2D) arg2);
        assertTrue(combinedDomainXYPlot.isRangeCrosshairLockedOnData());
        assertTrue(combinedDomainXYPlot.isDomainCrosshairLockedOnData());
        assertEquals(1, combinedDomainXYPlot.getWeight());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testZoomDomainAxesTaking3Arguments1() throws Throwable  {
        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);
        assertTrue(combinedDomainXYPlot.isRangeCrosshairLockedOnData());
        assertEquals(1, combinedDomainXYPlot.getWeight());
        assertTrue(combinedDomainXYPlot.isDomainCrosshairLockedOnData());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testSetRangeCrosshairValueTaking2ArgumentsWithTrue() throws Throwable  {
        CombinedDomainXYPlot combinedDomainXYPlot = new CombinedDomainXYPlot();
        combinedDomainXYPlot.setRangeCrosshairVisible(true);
        combinedDomainXYPlot.setRangeCrosshairValue((double) 1.0F, true);
        assertTrue(combinedDomainXYPlot.isRangeCrosshairVisible());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testSetRangeCrosshairLockedOnDataWithFalse() throws Throwable  {
        CombinedDomainXYPlot combinedDomainXYPlot = new CombinedDomainXYPlot();
        assertTrue(combinedDomainXYPlot.isRangeCrosshairLockedOnData());
        
        combinedDomainXYPlot.setRangeCrosshairLockedOnData(false);
        assertFalse(combinedDomainXYPlot.isRangeCrosshairLockedOnData());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testSetRangeCrosshairLockedOnDataWithTrue() throws Throwable  {
        CombinedDomainXYPlot combinedDomainXYPlot = new CombinedDomainXYPlot();
        assertTrue(combinedDomainXYPlot.isRangeCrosshairLockedOnData());
        
        combinedDomainXYPlot.setRangeCrosshairLockedOnData(true);
        assertEquals(1, combinedDomainXYPlot.getWeight());
        assertTrue(combinedDomainXYPlot.isDomainCrosshairLockedOnData());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testSetRangeCrosshairValueTaking2ArgumentsAndSetRangeCrosshairVisible() throws Throwable  {
        CombinedDomainXYPlot combinedDomainXYPlot = new CombinedDomainXYPlot();
        combinedDomainXYPlot.setRangeCrosshairVisible(true);
        combinedDomainXYPlot.setRangeCrosshairValue((double) 1.0F, false);
        assertTrue(combinedDomainXYPlot.isRangeCrosshairVisible());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testSetRangeCrosshairVisibleWithFalse() throws Throwable  {
        CombinedRangeXYPlot combinedRangeXYPlot = new CombinedRangeXYPlot();
        combinedRangeXYPlot.setRangeCrosshairVisible(false);
        assertEquals(1, combinedRangeXYPlot.getWeight());
        assertTrue(combinedRangeXYPlot.isDomainCrosshairLockedOnData());
        assertTrue(combinedRangeXYPlot.isRangeCrosshairLockedOnData());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testSetDomainCrosshairPaintThrowsIllegalArgumentException() throws Throwable  {
        CombinedDomainXYPlot combinedDomainXYPlot = new CombinedDomainXYPlot();
        // Undeclared exception!
        try { 
          combinedDomainXYPlot.setDomainCrosshairPaint((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 testSetDomainCrosshairPaint() throws Throwable  {
        CombinedDomainXYPlot combinedDomainXYPlot = new CombinedDomainXYPlot();
        Color arg0 = Color.darkGray;
        combinedDomainXYPlot.setDomainCrosshairPaint(arg0);
        assertTrue(combinedDomainXYPlot.isDomainCrosshairLockedOnData());
        assertEquals(1, combinedDomainXYPlot.getWeight());
        assertTrue(combinedDomainXYPlot.isRangeCrosshairLockedOnData());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testSetDomainCrosshairStrokeThrowsIllegalArgumentException() throws Throwable  {
        CombinedDomainXYPlot combinedDomainXYPlot = new CombinedDomainXYPlot((ValueAxis) null);
        // Undeclared exception!
        try { 
          combinedDomainXYPlot.setDomainCrosshairStroke((Stroke) 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 testSetDomainCrosshairLockedOnDataWithFalse() throws Throwable  {
        CombinedDomainXYPlot combinedDomainXYPlot = new CombinedDomainXYPlot();
        combinedDomainXYPlot.setDomainCrosshairLockedOnData(false);
        assertFalse(combinedDomainXYPlot.isDomainCrosshairLockedOnData());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testSetDomainCrosshairLockedOnDataWithTrue() throws Throwable  {
        CombinedRangeXYPlot combinedRangeXYPlot = new CombinedRangeXYPlot();
        assertTrue(combinedRangeXYPlot.isDomainCrosshairLockedOnData());
        
        combinedRangeXYPlot.setDomainCrosshairLockedOnData(true);
        assertEquals(1, combinedRangeXYPlot.getWeight());
        assertTrue(combinedRangeXYPlot.isRangeCrosshairLockedOnData());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testSetDomainCrosshairValueTaking2ArgumentsWithPositiveAndTrue() throws Throwable  {
        CombinedDomainXYPlot combinedDomainXYPlot = new CombinedDomainXYPlot();
        combinedDomainXYPlot.setDomainCrosshairVisible(true);
        combinedDomainXYPlot.setDomainCrosshairValue(1321.0, true);
        assertEquals(1321.0, combinedDomainXYPlot.getDomainCrosshairValue(), 0.01);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testSetDomainCrosshairVisibleWithFalse() throws Throwable  {
        CombinedDomainXYPlot combinedDomainXYPlot = new CombinedDomainXYPlot();
        combinedDomainXYPlot.setDomainCrosshairVisible(false);
        assertTrue(combinedDomainXYPlot.isRangeCrosshairLockedOnData());
        assertEquals(1, combinedDomainXYPlot.getWeight());
        assertTrue(combinedDomainXYPlot.isDomainCrosshairLockedOnData());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testSetRangeAxisTaking3Arguments() throws Throwable  {
        DateAxis arg1 = new DateAxis();
        XYPlot xYPlot = new XYPlot();
        xYPlot.setRangeAxis(3, (ValueAxis) arg1, true);
        assertEquals(4, xYPlot.getRangeAxisCount());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testSetDomainAxisTaking3ArgumentsWithTrue() throws Throwable  {
        XYPlot xYPlot = new XYPlot();
        CyclicNumberAxis arg1 = new CyclicNumberAxis(10, 1.0F);
        xYPlot.setDomainAxis(10, (ValueAxis) arg1, true);
        assertEquals(11, xYPlot.getDomainAxisCount());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testCloneAndCreatesXYPlotTaking4ArgumentsAndSetDatasetTaking2Arguments() throws Throwable  {
        DateAxis arg2 = new DateAxis();
        XYErrorRenderer arg3 = new XYErrorRenderer();
        DefaultXYZDataset arg1 = new DefaultXYZDataset();
        XYPlot xYPlot = new XYPlot(arg1, arg2, arg2, arg3);
        xYPlot.setDataset(4, (XYDataset) arg1);
        xYPlot.clone();
        assertEquals(5, xYPlot.getDatasetCount());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testHandleClick() throws Throwable  {
        XYPlot xYPlot = new XYPlot();
        ChartRenderingInfo arg0 = new ChartRenderingInfo();
        PlotRenderingInfo arg2 = new PlotRenderingInfo(arg0);
        xYPlot.handleClick(10, 10, arg2);
        assertTrue(xYPlot.isDomainCrosshairLockedOnData());
        assertEquals(1, xYPlot.getWeight());
        assertTrue(xYPlot.isRangeCrosshairLockedOnData());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testDrawRangeCrosshairThrowsNullPointerException() throws Throwable  {
        CombinedRangeXYPlot combinedRangeXYPlot = new CombinedRangeXYPlot();
        Rectangle arg1 = new Rectangle(10, 10, 10, 10);
        CyclicNumberAxis arg4 = new CyclicNumberAxis(10, "org.jfree.chart.entity.XYAnnotationEntity");
        PolarPlot polarPlot = new PolarPlot();
        PlotOrientation arg2 = polarPlot.getOrientation();
        // Undeclared exception!
        try { 
          combinedRangeXYPlot.drawRangeCrosshair((Graphics2D) null, arg1, arg2, 1.0F, arg4, arg4.DEFAULT_ADVANCE_LINE_STROKE, arg4.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  {
        CombinedRangeXYPlot combinedRangeXYPlot = new CombinedRangeXYPlot();
        Rectangle arg1 = new Rectangle(10, 10, 10, 10);
        PlotOrientation arg2 = combinedRangeXYPlot.getOrientation();
        NumberAxis arg4 = new NumberAxis();
        combinedRangeXYPlot.drawRangeCrosshair((Graphics2D) null, arg1, arg2, 10, arg4, arg4.DEFAULT_AXIS_LINE_STROKE, arg4.DEFAULT_TICK_MARK_PAINT);
        assertEquals(1, combinedRangeXYPlot.getWeight());
        assertTrue(combinedRangeXYPlot.isDomainCrosshairLockedOnData());
        assertTrue(combinedRangeXYPlot.isRangeCrosshairLockedOnData());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testDrawVerticalLineWithNonNullAndZero() throws Throwable  {
        CombinedDomainXYPlot arg2 = new CombinedDomainXYPlot();
        CyclicNumberAxis cyclicNumberAxis = new CyclicNumberAxis((-167.808697), 10);
        JFreeChart jFreeChart = new JFreeChart("u@", cyclicNumberAxis.DEFAULT_TICK_LABEL_FONT, arg2, false);
        ChartRenderingInfo arg4 = new ChartRenderingInfo();
        BufferedImage createBufferedImage = jFreeChart.createBufferedImage(805, 500, 1.0, 0.0, arg4);
        Graphics2D arg0 = createBufferedImage.createGraphics();
        Rectangle2D.Double arg1 = new Rectangle2D.Double();
        arg2.drawVerticalLine(arg0, arg1, 0.0, cyclicNumberAxis.DEFAULT_TICK_MARK_STROKE, arg2.DEFAULT_GRIDLINE_PAINT);
        assertEquals(1, arg2.getWeight());
        assertTrue(arg2.isDomainCrosshairLockedOnData());
        assertTrue(arg2.isRangeCrosshairLockedOnData());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testDrawVerticalLineWithNullAndPositive() throws Throwable  {
        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  {
        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 testGetRangeMarkersTaking2Arguments0() throws Throwable  {
        CombinedRangeXYPlot combinedRangeXYPlot = new CombinedRangeXYPlot();
        Layer arg1 = Layer.BACKGROUND;
        combinedRangeXYPlot.getRangeMarkers((int) (byte)61, arg1);
        assertEquals(1, combinedRangeXYPlot.getWeight());
        assertTrue(combinedRangeXYPlot.isRangeCrosshairLockedOnData());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testGetRangeMarkersTaking2Arguments1() throws Throwable  {
        CombinedDomainXYPlot combinedDomainXYPlot = new CombinedDomainXYPlot();
        Layer arg1 = Layer.FOREGROUND;
        combinedDomainXYPlot.getRangeMarkers(3, arg1);
        assertTrue(combinedDomainXYPlot.isRangeCrosshairLockedOnData());
        assertEquals(1, combinedDomainXYPlot.getWeight());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testGetDomainMarkersTakingLayer() throws Throwable  {
        CombinedRangeXYPlot combinedRangeXYPlot = new CombinedRangeXYPlot();
        Layer arg0 = Layer.BACKGROUND;
        combinedRangeXYPlot.getDomainMarkers(arg0);
        assertTrue(combinedRangeXYPlot.isDomainCrosshairLockedOnData());
        assertEquals(1, combinedRangeXYPlot.getWeight());
        assertTrue(combinedRangeXYPlot.isRangeCrosshairLockedOnData());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testGetDomainMarkersTaking2Arguments() throws Throwable  {
        CombinedRangeXYPlot combinedRangeXYPlot = new CombinedRangeXYPlot();
        Layer arg1 = Layer.FOREGROUND;
        combinedRangeXYPlot.getDomainMarkers((-1377), arg1);
        assertTrue(combinedRangeXYPlot.isRangeCrosshairLockedOnData());
        assertEquals(1, combinedRangeXYPlot.getWeight());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testDrawRangeMarkers() throws Throwable  {
        Rectangle2D.Double arg1 = new Rectangle2D.Double();
        Layer arg3 = Layer.BACKGROUND;
        CombinedRangeXYPlot combinedRangeXYPlot = new CombinedRangeXYPlot();
        combinedRangeXYPlot.drawRangeMarkers((Graphics2D) null, arg1, 10, arg3);
        assertTrue(combinedRangeXYPlot.isDomainCrosshairLockedOnData());
        assertTrue(combinedRangeXYPlot.isRangeCrosshairLockedOnData());
        assertEquals(1, combinedRangeXYPlot.getWeight());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testDrawDomainMarkers() throws Throwable  {
        Rectangle2D.Double arg1 = new Rectangle2D.Double();
        Layer arg3 = Layer.FOREGROUND;
        CombinedRangeXYPlot combinedRangeXYPlot = new CombinedRangeXYPlot();
        combinedRangeXYPlot.drawDomainMarkers((Graphics2D) null, arg1, 10, arg3);
        assertTrue(combinedRangeXYPlot.isRangeCrosshairLockedOnData());
        assertTrue(combinedRangeXYPlot.isDomainCrosshairLockedOnData());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testDrawAnnotations() throws Throwable  {
        CombinedRangeXYPlot combinedRangeXYPlot = new CombinedRangeXYPlot();
        ChartRenderingInfo chartRenderingInfo = new ChartRenderingInfo();
        PlotRenderingInfo arg2 = chartRenderingInfo.getPlotInfo();
        Rectangle2D.Double arg1 = new Rectangle2D.Double();
        combinedRangeXYPlot.drawAnnotations((Graphics2D) null, arg1, arg2);
        assertEquals(1, combinedRangeXYPlot.getWeight());
        assertTrue(combinedRangeXYPlot.isRangeCrosshairLockedOnData());
        assertTrue(combinedRangeXYPlot.isDomainCrosshairLockedOnData());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testDrawZeroRangeBaseline() throws Throwable  {
        CombinedRangeXYPlot combinedRangeXYPlot = new CombinedRangeXYPlot();
        combinedRangeXYPlot.drawZeroRangeBaseline((Graphics2D) null, (Rectangle2D) null);
        assertEquals(1, combinedRangeXYPlot.getWeight());
        assertTrue(combinedRangeXYPlot.isDomainCrosshairLockedOnData());
        assertTrue(combinedRangeXYPlot.isRangeCrosshairLockedOnData());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testDrawRangeGridlinesThrowsNullPointerException() throws Throwable  {
        Rectangle2D.Double arg1 = new Rectangle2D.Double();
        Vector<XYTextAnnotation> arg2 = new Vector<XYTextAnnotation>();
        arg2.add((XYTextAnnotation) null);
        CombinedRangeXYPlot combinedRangeXYPlot = new CombinedRangeXYPlot();
        // Undeclared exception!
        try { 
          combinedRangeXYPlot.drawRangeGridlines((Graphics2D) null, arg1, arg2);
          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 testDrawRangeGridlines0() throws Throwable  {
        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.isRangeCrosshairLockedOnData());
        assertTrue(combinedRangeXYPlot.isRangeGridlinesVisible());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testDrawRangeGridlines1() throws Throwable  {
        ArrayList<XYTextAnnotation> arg2 = new ArrayList<XYTextAnnotation>();
        Rectangle2D.Float arg1 = new Rectangle2D.Float();
        CombinedRangeXYPlot combinedRangeXYPlot = new CombinedRangeXYPlot();
        combinedRangeXYPlot.drawRangeGridlines((Graphics2D) null, arg1, arg2);
        assertEquals(1, combinedRangeXYPlot.getWeight());
        assertTrue(combinedRangeXYPlot.isDomainCrosshairLockedOnData());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testDrawDomainGridlines() throws Throwable  {
        CombinedDomainXYPlot combinedDomainXYPlot = new CombinedDomainXYPlot();
        Rectangle arg1 = new Rectangle();
        combinedDomainXYPlot.drawDomainGridlines((Graphics2D) null, arg1, (List) null);
        assertTrue(combinedDomainXYPlot.isDomainCrosshairLockedOnData());
        assertTrue(combinedDomainXYPlot.isRangeCrosshairLockedOnData());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testDrawDomainGridlinesThrowsNullPointerException() throws Throwable  {
        CombinedDomainXYPlot combinedDomainXYPlot = new CombinedDomainXYPlot();
        DefaultXYItemRenderer arg0 = new DefaultXYItemRenderer();
        combinedDomainXYPlot.setRenderer((XYItemRenderer) arg0);
        Rectangle arg1 = new Rectangle();
        // Undeclared exception!
        try { 
          combinedDomainXYPlot.drawDomainGridlines((Graphics2D) null, arg1, (List) null);
          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 testGetRangeAxisForDatasetWithPositive() throws Throwable  {
        CombinedRangeXYPlot combinedRangeXYPlot = new CombinedRangeXYPlot();
        // Undeclared exception!
        try { 
          combinedRangeXYPlot.getRangeAxisForDataset(10);
          fail("Expecting exception: IllegalArgumentException");
        
        } catch(IllegalArgumentException e) {
           //
           // Index 'index' out of bounds.
           //
           verifyException("org.jfree.chart.plot.XYPlot", e);
        }
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testGetRangeAxisForDatasetReturningNull() throws Throwable  {
        CombinedDomainXYPlot combinedDomainXYPlot = new CombinedDomainXYPlot();
        combinedDomainXYPlot.getRangeAxisForDataset(0);
        assertTrue(combinedDomainXYPlot.isRangeCrosshairLockedOnData());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testGetRangeAxisForDatasetWithNegative() throws Throwable  {
        XYPlot xYPlot = new XYPlot();
        // Undeclared exception!
        try { 
          xYPlot.getRangeAxisForDataset((-1314));
          fail("Expecting exception: IllegalArgumentException");
        
        } catch(IllegalArgumentException e) {
           //
           // Index 'index' out of bounds.
           //
           verifyException("org.jfree.chart.plot.XYPlot", e);
        }
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testGetDomainAxisForDatasetReturningNull() throws Throwable  {
        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 testGetDomainAxisForDatasetThrowsIllegalArgumentException() throws Throwable  {
        CombinedRangeXYPlot combinedRangeXYPlot = new CombinedRangeXYPlot();
        // Undeclared exception!
        try { 
          combinedRangeXYPlot.getDomainAxisForDataset(500);
          fail("Expecting exception: IllegalArgumentException");
        
        } catch(IllegalArgumentException e) {
           //
           // Index 'index' out of bounds.
           //
           verifyException("org.jfree.chart.plot.XYPlot", e);
        }
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testGetDomainAxisForDatasetWithNegative() throws Throwable  {
        CombinedRangeXYPlot combinedRangeXYPlot = new CombinedRangeXYPlot();
        // Undeclared exception!
        try { 
          combinedRangeXYPlot.getDomainAxisForDataset((-2866));
          fail("Expecting exception: IllegalArgumentException");
        
        } catch(IllegalArgumentException e) {
           //
           // Index 'index' out of bounds.
           //
           verifyException("org.jfree.chart.plot.XYPlot", e);
        }
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testRender() throws Throwable  {
        CombinedRangeXYPlot combinedRangeXYPlot = new CombinedRangeXYPlot();
        ChartRenderingInfo chartRenderingInfo = new ChartRenderingInfo();
        PlotRenderingInfo arg3 = chartRenderingInfo.getPlotInfo();
        CrosshairState arg4 = new CrosshairState(false);
        Rectangle arg1 = new Rectangle(10, 10);
        boolean render = combinedRangeXYPlot.render((Graphics2D) null, arg1, 0, arg3, arg4);
        assertTrue(combinedRangeXYPlot.isDomainCrosshairLockedOnData());
        assertEquals(1, combinedRangeXYPlot.getWeight());
        assertTrue(combinedRangeXYPlot.isRangeCrosshairLockedOnData());
        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();
        // Undeclared exception!
        try { 
          combinedRangeXYPlot.drawAxes((Graphics2D) null, arg2, arg2, arg3);
          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 testDrawRangeTickBands() throws Throwable  {
        CombinedDomainXYPlot combinedDomainXYPlot = new CombinedDomainXYPlot();
        Rectangle arg1 = new Rectangle();
        combinedDomainXYPlot.drawRangeTickBands((Graphics2D) null, arg1, (List) null);
        assertTrue(combinedDomainXYPlot.isRangeCrosshairLockedOnData());
        assertEquals(1, combinedDomainXYPlot.getWeight());
        assertTrue(combinedDomainXYPlot.isDomainCrosshairLockedOnData());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testDrawDomainTickBands() throws Throwable  {
        CombinedRangeXYPlot combinedRangeXYPlot = new CombinedRangeXYPlot();
        ArrayList<XYTextAnnotation> arg2 = new ArrayList<XYTextAnnotation>();
        combinedRangeXYPlot.drawDomainTickBands((Graphics2D) null, (Rectangle2D) null, arg2);
        assertTrue(combinedRangeXYPlot.isDomainCrosshairLockedOnData());
        assertEquals(1, combinedRangeXYPlot.getWeight());
        assertTrue(combinedRangeXYPlot.isRangeCrosshairLockedOnData());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testCalculateRangeAxisSpace() throws Throwable  {
        DefaultCaret arg1 = new DefaultCaret();
        CombinedDomainXYPlot combinedDomainXYPlot = new CombinedDomainXYPlot();
        AxisSpace calculateRangeAxisSpace = combinedDomainXYPlot.calculateRangeAxisSpace((Graphics2D) null, arg1, (AxisSpace) null);
        assertTrue(combinedDomainXYPlot.isRangeCrosshairLockedOnData());
        assertEquals(1, combinedDomainXYPlot.getWeight());
        assertNotNull(calculateRangeAxisSpace);
        assertTrue(combinedDomainXYPlot.isDomainCrosshairLockedOnData());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testCalculateDomainAxisSpace() throws Throwable  {
        Rectangle2D.Double arg1 = new Rectangle2D.Double();
        CombinedRangeXYPlot combinedRangeXYPlot = new CombinedRangeXYPlot();
        AxisSpace calculateDomainAxisSpace = combinedRangeXYPlot.calculateDomainAxisSpace((Graphics2D) null, arg1, (AxisSpace) null);
        assertEquals(1, combinedRangeXYPlot.getWeight());
        assertNotNull(calculateDomainAxisSpace);
        assertTrue(combinedRangeXYPlot.isDomainCrosshairLockedOnData());
        assertTrue(combinedRangeXYPlot.isRangeCrosshairLockedOnData());
    }
  
    @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  {
        CombinedDomainXYPlot combinedDomainXYPlot = new CombinedDomainXYPlot();
        XYShapeAnnotation arg0 = new XYShapeAnnotation(combinedDomainXYPlot.DEFAULT_LEGEND_ITEM_BOX);
        combinedDomainXYPlot.removeAnnotation(arg0);
        assertTrue(combinedDomainXYPlot.isRangeCrosshairLockedOnData());
        assertTrue(combinedDomainXYPlot.isDomainCrosshairLockedOnData());
        assertEquals(1, combinedDomainXYPlot.getWeight());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testAddAnnotationThrowsIllegalArgumentException() throws Throwable  {
        CombinedRangeXYPlot combinedRangeXYPlot = new CombinedRangeXYPlot();
        // Undeclared exception!
        try { 
          combinedRangeXYPlot.addAnnotation((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 testAddAnnotation() throws Throwable  {
        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.isDomainCrosshairLockedOnData());
        assertEquals(1, combinedRangeXYPlot.getWeight());
        assertTrue(combinedRangeXYPlot.isRangeCrosshairLockedOnData());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testAddRangeMarkerTaking3Arguments() throws Throwable  {
        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);
        assertTrue(combinedDomainXYPlot.isDomainCrosshairLockedOnData());
        assertEquals(1, combinedDomainXYPlot.getWeight());
        assertTrue(combinedDomainXYPlot.isRangeCrosshairLockedOnData());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testAddRangeMarkerTaking3ArgumentsWithNull() throws Throwable  {
        CombinedDomainXYPlot combinedDomainXYPlot = new CombinedDomainXYPlot();
        CategoryMarker arg1 = new CategoryMarker(1.0F, combinedDomainXYPlot.DEFAULT_CROSSHAIR_PAINT, combinedDomainXYPlot.DEFAULT_CROSSHAIR_STROKE);
        combinedDomainXYPlot.addRangeMarker(10, (Marker) arg1, (Layer) null);
        assertTrue(combinedDomainXYPlot.isRangeCrosshairLockedOnData());
        assertEquals(1, combinedDomainXYPlot.getWeight());
        assertTrue(combinedDomainXYPlot.isDomainCrosshairLockedOnData());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testAddRangeMarkerTaking2Arguments() throws Throwable  {
        CombinedDomainXYPlot combinedDomainXYPlot = new CombinedDomainXYPlot();
        ValueMarker arg0 = new ValueMarker(1.0F, combinedDomainXYPlot.DEFAULT_GRIDLINE_PAINT, combinedDomainXYPlot.DEFAULT_GRIDLINE_STROKE);
        Layer arg1 = Layer.FOREGROUND;
        combinedDomainXYPlot.addRangeMarker((Marker) arg0, arg1);
        combinedDomainXYPlot.clearRangeMarkers();
        assertTrue(combinedDomainXYPlot.isDomainCrosshairLockedOnData());
        assertEquals(1, combinedDomainXYPlot.getWeight());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testClearRangeMarkersTakingNoArguments() throws Throwable  {
        XYPlot xYPlot = new XYPlot();
        IntervalMarker arg1 = new IntervalMarker(10, 500.0);
        Layer arg2 = Layer.BACKGROUND;
        xYPlot.addRangeMarker(500, (Marker) arg1, arg2);
        xYPlot.clearRangeMarkers();
        assertTrue(xYPlot.isRangeCrosshairLockedOnData());
        assertTrue(xYPlot.isDomainCrosshairLockedOnData());
        assertEquals(1, xYPlot.getWeight());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testAddDomainMarkerTaking3Arguments() throws Throwable  {
        CombinedRangeXYPlot combinedRangeXYPlot = new CombinedRangeXYPlot();
        ValueMarker arg1 = new ValueMarker(10);
        Layer arg2 = Layer.BACKGROUND;
        combinedRangeXYPlot.addDomainMarker(10, (Marker) arg1, arg2);
        combinedRangeXYPlot.addDomainMarker(10, (Marker) arg1, arg2);
        assertEquals(1, combinedRangeXYPlot.getWeight());
        assertTrue(combinedRangeXYPlot.isDomainCrosshairLockedOnData());
        assertTrue(combinedRangeXYPlot.isRangeCrosshairLockedOnData());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testAddDomainMarkerTaking3ArgumentsWithNullAndMarkerWhereGetAlphaIsPositive() throws Throwable  {
        CombinedRangeXYPlot combinedRangeXYPlot = new CombinedRangeXYPlot();
        ValueMarker arg1 = new ValueMarker(10);
        // Undeclared exception!
        try { 
          combinedRangeXYPlot.addDomainMarker(10, (Marker) arg1, (Layer) null);
          fail("Expecting exception: IllegalArgumentException");
        
        } catch(IllegalArgumentException e) {
           //
           // Null 'layer' not permitted.
           //
           verifyException("org.jfree.chart.plot.XYPlot", e);
        }
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testAddDomainMarkerTaking3ArgumentsWithNull() throws Throwable  {
        CombinedDomainXYPlot combinedDomainXYPlot = new CombinedDomainXYPlot();
        Layer arg2 = Layer.FOREGROUND;
        // Undeclared exception!
        try { 
          combinedDomainXYPlot.addDomainMarker(500, (Marker) null, arg2);
          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  {
        CombinedRangeXYPlot combinedRangeXYPlot = new CombinedRangeXYPlot();
        ValueMarker arg1 = new ValueMarker(10);
        Layer arg2 = Layer.FOREGROUND;
        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 testAddDomainMarkerTaking3ArgumentsAndClearDomainMarkersTakingNoArguments1() throws Throwable  {
        CombinedRangeXYPlot combinedRangeXYPlot = new CombinedRangeXYPlot();
        ValueMarker arg1 = new ValueMarker(10);
        Layer arg2 = Layer.BACKGROUND;
        combinedRangeXYPlot.addDomainMarker(10, (Marker) arg1, arg2);
        combinedRangeXYPlot.clearDomainMarkers();
        assertEquals(1, combinedRangeXYPlot.getWeight());
        assertTrue(combinedRangeXYPlot.isRangeCrosshairLockedOnData());
        assertTrue(combinedRangeXYPlot.isDomainCrosshairLockedOnData());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testSetQuadrantPaintWithPositive() throws Throwable  {
        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  {
        CombinedDomainXYPlot combinedDomainXYPlot = new CombinedDomainXYPlot();
        combinedDomainXYPlot.setQuadrantPaint(0, (Paint) null);
        assertEquals(1, combinedDomainXYPlot.getWeight());
        assertTrue(combinedDomainXYPlot.isDomainCrosshairLockedOnData());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testSetQuadrantPaintWithNegative() throws Throwable  {
        CombinedDomainXYPlot combinedDomainXYPlot = new CombinedDomainXYPlot();
        // Undeclared exception!
        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  {
        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  {
        CombinedRangeXYPlot combinedRangeXYPlot = new CombinedRangeXYPlot();
        combinedRangeXYPlot.getQuadrantPaint(1);
        assertTrue(combinedRangeXYPlot.isDomainCrosshairLockedOnData());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testGetQuadrantPaintWithNegative() throws Throwable  {
        CombinedRangeXYPlot combinedRangeXYPlot = new CombinedRangeXYPlot();
        // Undeclared exception!
        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();
        // Undeclared exception!
        try { 
          combinedDomainXYPlot.setQuadrantOrigin((Point2D) null);
          fail("Expecting exception: IllegalArgumentException");
        
        } catch(IllegalArgumentException e) {
           //
           // Null 'origin' argument.
           //
           verifyException("org.jfree.chart.plot.XYPlot", e);
        }
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testSetQuadrantOrigin() throws Throwable  {
        CombinedDomainXYPlot combinedDomainXYPlot = new CombinedDomainXYPlot();
        Point2D.Double arg0 = new Point2D.Double();
        combinedDomainXYPlot.setQuadrantOrigin(arg0);
        assertEquals(1, combinedDomainXYPlot.getWeight());
        assertTrue(combinedDomainXYPlot.isRangeCrosshairLockedOnData());
        assertTrue(combinedDomainXYPlot.isDomainCrosshairLockedOnData());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testSetRangeZeroBaselinePaintThrowsIllegalArgumentException() throws Throwable  {
        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  {
        DateAxis arg0 = new DateAxis();
        CombinedDomainXYPlot combinedDomainXYPlot = new CombinedDomainXYPlot(arg0);
        combinedDomainXYPlot.setRangeZeroBaselinePaint(arg0.DEFAULT_TICK_MARK_PAINT);
        assertTrue(combinedDomainXYPlot.isRangeCrosshairLockedOnData());
        assertEquals(1, combinedDomainXYPlot.getWeight());
        assertTrue(combinedDomainXYPlot.isDomainCrosshairLockedOnData());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testSetRangeZeroBaselineStrokeThrowsIllegalArgumentException() throws Throwable  {
        XYPlot xYPlot = new XYPlot();
        // Undeclared exception!
        try { 
          xYPlot.setRangeZeroBaselineStroke((Stroke) 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 testSetRangeZeroBaselineStroke() throws Throwable  {
        CombinedDomainXYPlot combinedDomainXYPlot = new CombinedDomainXYPlot();
        PolarPlot polarPlot = new PolarPlot();
        Stroke arg0 = polarPlot.getRadiusGridlineStroke();
        combinedDomainXYPlot.setRangeZeroBaselineStroke(arg0);
        assertTrue(combinedDomainXYPlot.isRangeCrosshairLockedOnData());
        assertTrue(combinedDomainXYPlot.isDomainCrosshairLockedOnData());
        assertEquals(1, combinedDomainXYPlot.getWeight());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testSetRangeGridlinePaintThrowsIllegalArgumentException() throws Throwable  {
        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  {
        CombinedRangeXYPlot combinedRangeXYPlot = new CombinedRangeXYPlot();
        combinedRangeXYPlot.setRangeGridlinePaint(combinedRangeXYPlot.DEFAULT_OUTLINE_PAINT);
        assertEquals(1, combinedRangeXYPlot.getWeight());
        assertTrue(combinedRangeXYPlot.isRangeCrosshairLockedOnData());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testSetRangeGridlineStrokeThrowsIllegalArgumentException() throws Throwable  {
        CombinedDomainXYPlot combinedDomainXYPlot = new CombinedDomainXYPlot();
        // Undeclared exception!
        try { 
          combinedDomainXYPlot.setRangeGridlineStroke((Stroke) 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 testSetRangeGridlineStroke() throws Throwable  {
        CombinedDomainXYPlot combinedDomainXYPlot = new CombinedDomainXYPlot();
        combinedDomainXYPlot.setRangeGridlineStroke(combinedDomainXYPlot.DEFAULT_OUTLINE_STROKE);
        assertEquals(1, combinedDomainXYPlot.getWeight());
        assertTrue(combinedDomainXYPlot.isDomainCrosshairLockedOnData());
        assertTrue(combinedDomainXYPlot.isRangeCrosshairLockedOnData());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testSetRangeGridlinesVisibleWithFalse() throws Throwable  {
        CombinedDomainXYPlot combinedDomainXYPlot = new CombinedDomainXYPlot();
        combinedDomainXYPlot.setRangeGridlinesVisible(false);
        assertFalse(combinedDomainXYPlot.isRangeGridlinesVisible());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testSetRangeGridlinesVisibleWithTrue() throws Throwable  {
        DateAxis arg0 = new DateAxis();
        CombinedRangeXYPlot combinedRangeXYPlot = new CombinedRangeXYPlot(arg0);
        combinedRangeXYPlot.setRangeGridlinesVisible(true);
        assertTrue(combinedRangeXYPlot.isDomainCrosshairLockedOnData());
        assertEquals(1, combinedRangeXYPlot.getWeight());
        assertTrue(combinedRangeXYPlot.isRangeCrosshairLockedOnData());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testSetDomainGridlinePaintThrowsIllegalArgumentException() throws Throwable  {
        CombinedRangeXYPlot combinedRangeXYPlot = new CombinedRangeXYPlot();
        // Undeclared exception!
        try { 
          combinedRangeXYPlot.setDomainGridlinePaint((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 testSetDomainGridlinePaint() throws Throwable  {
        CombinedDomainXYPlot combinedDomainXYPlot = new CombinedDomainXYPlot();
        Color arg0 = (Color)AbstractRenderer.DEFAULT_OUTLINE_PAINT;
        combinedDomainXYPlot.setDomainGridlinePaint(arg0);
        assertEquals(1, combinedDomainXYPlot.getWeight());
        assertTrue(combinedDomainXYPlot.isRangeCrosshairLockedOnData());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testSetDomainGridlineStrokeThrowsIllegalArgumentException() throws Throwable  {
        CombinedRangeXYPlot combinedRangeXYPlot = new CombinedRangeXYPlot();
        // Undeclared exception!
        try { 
          combinedRangeXYPlot.setDomainGridlineStroke((Stroke) 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  {
        DateAxis dateAxis = new DateAxis();
        CombinedRangeXYPlot combinedRangeXYPlot = new CombinedRangeXYPlot();
        combinedRangeXYPlot.setDomainGridlineStroke(dateAxis.DEFAULT_TICK_MARK_STROKE);
        assertTrue(combinedRangeXYPlot.isDomainCrosshairLockedOnData());
        assertEquals(1, combinedRangeXYPlot.getWeight());
        assertTrue(combinedRangeXYPlot.isRangeCrosshairLockedOnData());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testIsDomainGridlinesVisibleReturningFalse() throws Throwable  {
        DateAxis arg0 = new DateAxis();
        CombinedRangeXYPlot combinedRangeXYPlot = new CombinedRangeXYPlot(arg0);
        assertTrue(combinedRangeXYPlot.isDomainGridlinesVisible());
        
        combinedRangeXYPlot.setDomainGridlinesVisible(false);
        boolean domainGridlinesVisible = combinedRangeXYPlot.isDomainGridlinesVisible();
        assertFalse(domainGridlinesVisible);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testSetDomainGridlinesVisibleWithTrue() throws Throwable  {
        CombinedDomainXYPlot combinedDomainXYPlot = new CombinedDomainXYPlot();
        combinedDomainXYPlot.setDomainGridlinesVisible(true);
        assertTrue(combinedDomainXYPlot.isRangeCrosshairLockedOnData());
        assertTrue(combinedDomainXYPlot.isDomainCrosshairLockedOnData());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testGetRendererForDataset() throws Throwable  {
        CombinedDomainXYPlot combinedDomainXYPlot = new CombinedDomainXYPlot();
        YIntervalSeriesCollection arg0 = new YIntervalSeriesCollection();
        combinedDomainXYPlot.getRendererForDataset(arg0);
        assertTrue(combinedDomainXYPlot.isDomainCrosshairLockedOnData());
        assertTrue(combinedDomainXYPlot.isRangeCrosshairLockedOnData());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testSetSeriesRenderingOrderThrowsIllegalArgumentException() throws Throwable  {
        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();
        // Undeclared exception!
        try { 
          combinedDomainXYPlot.setDatasetRenderingOrder((DatasetRenderingOrder) 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 testSetRendererTaking3ArgumentsWithNull() throws Throwable  {
        CombinedDomainXYPlot combinedDomainXYPlot = new CombinedDomainXYPlot();
        combinedDomainXYPlot.setRenderer(989, (XYItemRenderer) null, false);
        assertTrue(combinedDomainXYPlot.isRangeCrosshairLockedOnData());
        assertTrue(combinedDomainXYPlot.isDomainCrosshairLockedOnData());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testSetRendererTaking3ArgumentsWithTrue() throws Throwable  {
        CombinedDomainXYPlot combinedDomainXYPlot = new CombinedDomainXYPlot();
        ClusteredXYBarRenderer arg1 = new ClusteredXYBarRenderer();
        combinedDomainXYPlot.setRenderer(10, (XYItemRenderer) arg1, false);
        combinedDomainXYPlot.setRenderer(10, (XYItemRenderer) arg1, true);
        assertTrue(combinedDomainXYPlot.isDomainCrosshairLockedOnData());
        assertTrue(combinedDomainXYPlot.isRangeCrosshairLockedOnData());
        assertEquals(1, combinedDomainXYPlot.getWeight());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testIndexOfReturningZero() throws Throwable  {
        CombinedRangeXYPlot combinedRangeXYPlot = new CombinedRangeXYPlot();
        int indexOf = combinedRangeXYPlot.indexOf((XYDataset) null);
        assertEquals(0, indexOf);
        assertTrue(combinedRangeXYPlot.isDomainCrosshairLockedOnData());
        assertEquals(1, combinedRangeXYPlot.getWeight());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testIndexOfReturningNegative() throws Throwable  {
        CombinedDomainXYPlot combinedDomainXYPlot = new CombinedDomainXYPlot();
        MatrixSeriesCollection arg0 = new MatrixSeriesCollection();
        int indexOf = combinedDomainXYPlot.indexOf(arg0);
        assertEquals((-1), indexOf);
        assertTrue(combinedDomainXYPlot.isRangeCrosshairLockedOnData());
        assertTrue(combinedDomainXYPlot.isDomainCrosshairLockedOnData());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testSetDatasetTaking2ArgumentsWithNull() throws Throwable  {
        CombinedDomainXYPlot combinedDomainXYPlot = new CombinedDomainXYPlot();
        combinedDomainXYPlot.setDataset(1198, (XYDataset) null);
        assertEquals(1199, combinedDomainXYPlot.getDatasetCount());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testSetDatasetTaking2ArgumentsWithZero() throws Throwable  {
        DateAxis arg2 = new DateAxis();
        XYErrorRenderer arg3 = new XYErrorRenderer();
        DefaultXYZDataset arg1 = new DefaultXYZDataset();
        XYPlot xYPlot = new XYPlot(arg1, arg2, arg2, arg3);
        xYPlot.setDataset(0, (XYDataset) arg1);
        assertEquals(1, xYPlot.getDatasetCount());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testGetDatasetTakingInt() throws Throwable  {
        CombinedDomainXYPlot combinedDomainXYPlot = new CombinedDomainXYPlot();
        combinedDomainXYPlot.getDataset(500);
        assertTrue(combinedDomainXYPlot.isRangeCrosshairLockedOnData());
        assertEquals(1, combinedDomainXYPlot.getWeight());
        assertTrue(combinedDomainXYPlot.isDomainCrosshairLockedOnData());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testGetRangeAxisEdgeTakingInt() throws Throwable  {
        DateAxis arg0 = new DateAxis();
        CombinedRangeXYPlot combinedRangeXYPlot = new CombinedRangeXYPlot(arg0);
        combinedRangeXYPlot.getRangeAxisEdge((-1845));
        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);
        assertEquals("AxisLocation.BOTTOM_OR_LEFT", rangeAxisLocation.toString());
        assertTrue(combinedDomainXYPlot.isDomainCrosshairLockedOnData());
        assertEquals(1, combinedDomainXYPlot.getWeight());
        assertTrue(combinedDomainXYPlot.isRangeCrosshairLockedOnData());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testClearRangeAxes() throws Throwable  {
        CombinedDomainXYPlot combinedDomainXYPlot = new CombinedDomainXYPlot();
        combinedDomainXYPlot.clearRangeAxes();
        assertTrue(combinedDomainXYPlot.isRangeCrosshairLockedOnData());
        assertEquals(1, combinedDomainXYPlot.getWeight());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testSetRangeAxisTaking3ArgumentsWithFalse() throws Throwable  {
        CombinedDomainXYPlot combinedDomainXYPlot = new CombinedDomainXYPlot();
        PeriodAxis arg1 = new PeriodAxis("DR\"M4G578p7B?rvN");
        combinedDomainXYPlot.setRangeAxis(10, (ValueAxis) arg1, false);
        assertEquals(11, combinedDomainXYPlot.getRangeAxisCount());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testSetRangeAxisTaking3ArgumentsWithNull() throws Throwable  {
        CombinedRangeXYPlot combinedRangeXYPlot = new CombinedRangeXYPlot();
        combinedRangeXYPlot.setRangeAxis(253, (ValueAxis) null, true);
        assertEquals(254, combinedRangeXYPlot.getRangeAxisCount());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testSetRangeAxisTaking3ArgumentsWithZero() throws Throwable  {
        Second arg2 = new Second();
        PeriodAxis arg1 = new PeriodAxis("sjTE>'\"Q?`xY0", arg2, arg2);
        CombinedRangeXYPlot combinedRangeXYPlot = new CombinedRangeXYPlot(arg1);
        combinedRangeXYPlot.setRangeAxis(0, (ValueAxis) arg1, true);
        assertEquals(1, combinedRangeXYPlot.getRangeAxisCount());
        assertEquals(1, combinedRangeXYPlot.getWeight());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testSetRangeAxisLocationTaking1And1AndSetRangeAxisLocationTaking1And1AndSetRangeAxisLocationTaking1And1WithFalse() throws Throwable  {
        CombinedDomainXYPlot combinedDomainXYPlot = new CombinedDomainXYPlot();
        AxisLocation arg0 = AxisLocation.BOTTOM_OR_LEFT;
        combinedDomainXYPlot.setRangeAxisLocation(arg0, false);
        assertTrue(combinedDomainXYPlot.isRangeCrosshairLockedOnData());
        assertEquals(1, combinedDomainXYPlot.getWeight());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testSetRangeAxisLocationTaking1And1ThrowsIllegalArgumentException() throws Throwable  {
        CombinedDomainXYPlot combinedDomainXYPlot = new CombinedDomainXYPlot();
        // Undeclared exception!
        try { 
          combinedDomainXYPlot.setRangeAxisLocation((AxisLocation) null, false);
          fail("Expecting exception: IllegalArgumentException");
        
        } catch(IllegalArgumentException e) {
           //
           // Null 'location' argument.
           //
           verifyException("org.jfree.chart.plot.XYPlot", e);
        }
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testSetRangeAxisTakingValueAxis() throws Throwable  {
        DateAxis arg0 = new DateAxis();
        CombinedDomainXYPlot combinedDomainXYPlot = new CombinedDomainXYPlot(arg0);
        combinedDomainXYPlot.setRangeAxis((ValueAxis) arg0);
        assertTrue(combinedDomainXYPlot.isDomainCrosshairLockedOnData());
        assertEquals(1, combinedDomainXYPlot.getRangeAxisCount());
        assertEquals(1, combinedDomainXYPlot.getWeight());
        assertTrue(combinedDomainXYPlot.isRangeCrosshairLockedOnData());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void test1() throws Throwable  {
        CombinedRangeXYPlot combinedRangeXYPlot = new CombinedRangeXYPlot();
        CombinedDomainXYPlot arg0 = new CombinedDomainXYPlot();
        combinedRangeXYPlot.add((XYPlot) arg0, 10);
        assertEquals(10, arg0.getWeight());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testGetDomainAxisEdgeTakingInt() throws Throwable  {
        CombinedDomainXYPlot combinedDomainXYPlot = new CombinedDomainXYPlot();
        RectangleEdge domainAxisEdge = combinedDomainXYPlot.getDomainAxisEdge(0);
        assertTrue(combinedDomainXYPlot.isDomainCrosshairLockedOnData());
        assertEquals(1, combinedDomainXYPlot.getWeight());
        assertEquals("RectangleEdge.BOTTOM", domainAxisEdge.toString());
        assertTrue(combinedDomainXYPlot.isRangeCrosshairLockedOnData());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testGetDomainAxisLocationTakingIntWithPositive() throws Throwable  {
        CombinedDomainXYPlot combinedDomainXYPlot = new CombinedDomainXYPlot();
        AxisLocation domainAxisLocation = combinedDomainXYPlot.getDomainAxisLocation(1238);
        assertEquals(1, combinedDomainXYPlot.getWeight());
        assertTrue(combinedDomainXYPlot.isDomainCrosshairLockedOnData());
        assertNotNull(domainAxisLocation);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testClearDomainAxes0() throws Throwable  {
        CombinedRangeXYPlot combinedRangeXYPlot = new CombinedRangeXYPlot();
        combinedRangeXYPlot.clearDomainAxes();
        assertTrue(combinedRangeXYPlot.isDomainCrosshairLockedOnData());
        assertEquals(1, combinedRangeXYPlot.getWeight());
        assertTrue(combinedRangeXYPlot.isRangeCrosshairLockedOnData());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testClearDomainAxes1() throws Throwable  {
        CombinedDomainXYPlot combinedDomainXYPlot = new CombinedDomainXYPlot();
        combinedDomainXYPlot.clearDomainAxes();
        assertTrue(combinedDomainXYPlot.isDomainCrosshairLockedOnData());
        assertEquals(1, combinedDomainXYPlot.getWeight());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testGetDomainAxisLocationTakingNoArguments() throws Throwable  {
        CombinedDomainXYPlot combinedDomainXYPlot = new CombinedDomainXYPlot();
        AxisLocation arg0 = combinedDomainXYPlot.getDomainAxisLocation();
        assertNotNull(arg0);
        
        combinedDomainXYPlot.setDomainAxisLocation(arg0, false);
        assertTrue(combinedDomainXYPlot.isRangeCrosshairLockedOnData());
        assertTrue(combinedDomainXYPlot.isDomainCrosshairLockedOnData());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testSetDomainAxisLocationTaking1And1ThrowsIllegalArgumentException() throws Throwable  {
        CombinedDomainXYPlot combinedDomainXYPlot = new CombinedDomainXYPlot();
        // Undeclared exception!
        try { 
          combinedDomainXYPlot.setDomainAxisLocation((AxisLocation) null, true);
          fail("Expecting exception: IllegalArgumentException");
        
        } catch(IllegalArgumentException e) {
           //
           // Null 'location' argument.
           //
           verifyException("org.jfree.chart.plot.XYPlot", e);
        }
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testSetDomainAxisTaking3Arguments() throws Throwable  {
        CombinedDomainXYPlot combinedDomainXYPlot = new CombinedDomainXYPlot();
        NumberAxis arg1 = new NumberAxis();
        combinedDomainXYPlot.setDomainAxis(0, (ValueAxis) arg1, false);
        assertEquals(1.05, arg1.getUpperBound(), 0.01);
        assertTrue(combinedDomainXYPlot.isRangeCrosshairLockedOnData());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testSetDomainAxisTaking3ArgumentsWithNull() throws Throwable  {
        CombinedRangeXYPlot combinedRangeXYPlot = new CombinedRangeXYPlot();
        combinedRangeXYPlot.setDomainAxis(0, (ValueAxis) null, false);
        assertTrue(combinedRangeXYPlot.isDomainCrosshairLockedOnData());
        assertEquals(1, combinedRangeXYPlot.getWeight());
        assertEquals(1, combinedRangeXYPlot.getDomainAxisCount());
        assertTrue(combinedRangeXYPlot.isRangeCrosshairLockedOnData());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testGetDomainAxisTakingIntWithPositive() throws Throwable  {
        CombinedDomainXYPlot combinedDomainXYPlot = new CombinedDomainXYPlot();
        combinedDomainXYPlot.getDomainAxis(10);
        assertEquals(1, combinedDomainXYPlot.getWeight());
        assertTrue(combinedDomainXYPlot.isRangeCrosshairLockedOnData());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testSetAxisOffsetThrowsIllegalArgumentException() throws Throwable  {
        CombinedDomainXYPlot combinedDomainXYPlot = new CombinedDomainXYPlot();
        // Undeclared exception!
        try { 
          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  {
        CombinedDomainXYPlot combinedDomainXYPlot = new CombinedDomainXYPlot();
        combinedDomainXYPlot.setAxisOffset(combinedDomainXYPlot.DEFAULT_INSETS);
        assertTrue(combinedDomainXYPlot.isRangeCrosshairLockedOnData());
        assertTrue(combinedDomainXYPlot.isDomainCrosshairLockedOnData());
        assertEquals(1, combinedDomainXYPlot.getWeight());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void test2() throws Throwable  {
        CombinedDomainXYPlot combinedDomainXYPlot = new CombinedDomainXYPlot();
        // Undeclared exception!
        try { 
          combinedDomainXYPlot.setOrientation((PlotOrientation) null);
          fail("Expecting exception: IllegalArgumentException");
        
        } catch(IllegalArgumentException e) {
           //
           // Null 'orientation' argument.
           //
           verifyException("org.jfree.chart.plot.XYPlot", e);
        }
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void test3() throws Throwable  {
        CombinedDomainXYPlot combinedDomainXYPlot = new CombinedDomainXYPlot();
        PlotOrientation arg0 = PlotOrientation.HORIZONTAL;
        combinedDomainXYPlot.setOrientation(arg0);
        assertTrue(combinedDomainXYPlot.isRangeCrosshairLockedOnData());
        assertTrue(combinedDomainXYPlot.isDomainCrosshairLockedOnData());
        assertEquals(1, combinedDomainXYPlot.getWeight());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testGetDataRange() throws Throwable  {
        PeriodAxis arg0 = new PeriodAxis("Null 'stroke' argument.");
        XYBarRenderer arg3 = new XYBarRenderer(0.0);
        XYPlot xYPlot = new XYPlot((XYDataset) null, arg0, arg0, arg3);
        Range dataRange = xYPlot.getDataRange(arg0);
        assertNull(dataRange);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testGetLegendItems() throws Throwable  {
        TimeTableXYDataset arg0 = new TimeTableXYDataset();
        NumberAxis arg2 = new NumberAxis();
        XYPlot xYPlot = new XYPlot(arg0, arg2, arg2, (XYItemRenderer) null);
        xYPlot.getLegendItems();
        assertTrue(xYPlot.isDomainCrosshairLockedOnData());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testGetDomainCrosshairStroke() throws Throwable  {
        CombinedDomainXYPlot combinedDomainXYPlot = new CombinedDomainXYPlot();
        BasicStroke domainCrosshairStroke = (BasicStroke)combinedDomainXYPlot.getDomainCrosshairStroke();
        assertTrue(combinedDomainXYPlot.isDomainCrosshairLockedOnData());
        assertTrue(combinedDomainXYPlot.isRangeCrosshairLockedOnData());
        assertEquals(0, domainCrosshairStroke.getEndCap());
        assertEquals(1, combinedDomainXYPlot.getWeight());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testGetRangeTickBandPaintReturningNull() throws Throwable  {
        CombinedDomainXYPlot combinedDomainXYPlot = new CombinedDomainXYPlot();
        Paint rangeTickBandPaint = combinedDomainXYPlot.getRangeTickBandPaint();
        assertNull(rangeTickBandPaint);
        assertTrue(combinedDomainXYPlot.isRangeCrosshairLockedOnData());
        assertTrue(combinedDomainXYPlot.isDomainCrosshairLockedOnData());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testSetDomainTickBandPaint() throws Throwable  {
        DateAxis dateAxis = new DateAxis();
        CombinedDomainXYPlot combinedDomainXYPlot = new CombinedDomainXYPlot();
        combinedDomainXYPlot.setDomainTickBandPaint(dateAxis.DEFAULT_AXIS_LINE_PAINT);
        assertTrue(combinedDomainXYPlot.isRangeCrosshairLockedOnData());
        assertEquals(1, combinedDomainXYPlot.getWeight());
        assertTrue(combinedDomainXYPlot.isDomainCrosshairLockedOnData());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testGetFixedRangeAxisSpace() throws Throwable  {
        CombinedDomainXYPlot combinedDomainXYPlot = new CombinedDomainXYPlot();
        combinedDomainXYPlot.getFixedRangeAxisSpace();
        assertEquals(1, combinedDomainXYPlot.getWeight());
        assertTrue(combinedDomainXYPlot.isRangeCrosshairLockedOnData());
        assertTrue(combinedDomainXYPlot.isDomainCrosshairLockedOnData());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testIsDomainCrosshairLockedOnData() throws Throwable  {
        CombinedDomainXYPlot combinedDomainXYPlot = new CombinedDomainXYPlot();
        boolean domainCrosshairLockedOnData = combinedDomainXYPlot.isDomainCrosshairLockedOnData();
        assertTrue(combinedDomainXYPlot.isRangeCrosshairLockedOnData());
        assertTrue(domainCrosshairLockedOnData);
        assertEquals(1, combinedDomainXYPlot.getWeight());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testGetRangeAxisTakingInt1() throws Throwable  {
        CombinedRangeXYPlot arg0 = new CombinedRangeXYPlot();
        CombinedDomainXYPlot combinedDomainXYPlot = new CombinedDomainXYPlot();
        combinedDomainXYPlot.add((XYPlot) arg0);
        arg0.getRangeAxis(2);
        assertEquals(1, arg0.getWeight());
        assertEquals(1, arg0.getDomainAxisCount());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testSetDomainAxisLocationTakingAxisLocation() throws Throwable  {
        CombinedDomainXYPlot combinedDomainXYPlot = new CombinedDomainXYPlot();
        AxisLocation arg0 = combinedDomainXYPlot.getRangeAxisLocation(48);
        combinedDomainXYPlot.setDomainAxisLocation(arg0);
        assertTrue(combinedDomainXYPlot.isRangeCrosshairLockedOnData());
        assertEquals(1, combinedDomainXYPlot.getWeight());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testGetFixedDomainAxisSpace() throws Throwable  {
        CombinedRangeXYPlot combinedRangeXYPlot = new CombinedRangeXYPlot();
        combinedRangeXYPlot.getFixedDomainAxisSpace();
        assertTrue(combinedRangeXYPlot.isRangeCrosshairLockedOnData());
        assertTrue(combinedRangeXYPlot.isDomainCrosshairLockedOnData());
        assertEquals(1, combinedRangeXYPlot.getWeight());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testSetRangeCrosshairStroke() throws Throwable  {
        CombinedRangeXYPlot combinedRangeXYPlot = new CombinedRangeXYPlot();
        combinedRangeXYPlot.setRangeCrosshairStroke((Stroke) null);
        assertTrue(combinedRangeXYPlot.isDomainCrosshairLockedOnData());
        assertTrue(combinedRangeXYPlot.isRangeCrosshairLockedOnData());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testSetRangeTickBandPaint() throws Throwable  {
        CombinedRangeXYPlot combinedRangeXYPlot = new CombinedRangeXYPlot();
        Color arg0 = Color.MAGENTA;
        combinedRangeXYPlot.setRangeTickBandPaint(arg0);
        Color rangeTickBandPaint = (Color)combinedRangeXYPlot.getRangeTickBandPaint();
        assertEquals((-65281), rangeTickBandPaint.getRGB());
        assertTrue(combinedRangeXYPlot.isRangeCrosshairLockedOnData());
        assertTrue(combinedRangeXYPlot.isDomainCrosshairLockedOnData());
        assertEquals(1, combinedRangeXYPlot.getWeight());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testIsRangeGridlinesVisible() throws Throwable  {
        CombinedRangeXYPlot combinedRangeXYPlot = new CombinedRangeXYPlot();
        boolean rangeGridlinesVisible = combinedRangeXYPlot.isRangeGridlinesVisible();
        assertTrue(rangeGridlinesVisible);
        assertTrue(combinedRangeXYPlot.isDomainCrosshairLockedOnData());
        assertEquals(1, combinedRangeXYPlot.getWeight());
        assertTrue(combinedRangeXYPlot.isRangeCrosshairLockedOnData());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testGetWeight() throws Throwable  {
        CombinedDomainXYPlot combinedDomainXYPlot = new CombinedDomainXYPlot();
        int weight = combinedDomainXYPlot.getWeight();
        assertEquals(1, weight);
        assertTrue(combinedDomainXYPlot.isDomainCrosshairLockedOnData());
        assertTrue(combinedDomainXYPlot.isRangeCrosshairLockedOnData());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testGetFixedLegendItems() throws Throwable  {
        CombinedDomainXYPlot combinedDomainXYPlot = new CombinedDomainXYPlot();
        combinedDomainXYPlot.getFixedLegendItems();
        assertTrue(combinedDomainXYPlot.isRangeCrosshairLockedOnData());
        assertTrue(combinedDomainXYPlot.isDomainCrosshairLockedOnData());
        assertEquals(1, combinedDomainXYPlot.getWeight());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testSetFixedRangeAxisSpace() throws Throwable  {
        CombinedDomainXYPlot combinedDomainXYPlot = new CombinedDomainXYPlot();
        AxisSpace arg0 = new AxisSpace();
        combinedDomainXYPlot.setFixedRangeAxisSpace(arg0);
        assertTrue(combinedDomainXYPlot.isDomainCrosshairLockedOnData());
        assertEquals(1, combinedDomainXYPlot.getWeight());
        assertTrue(combinedDomainXYPlot.isRangeCrosshairLockedOnData());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testGetRendererTakingNoArgumentsReturningNull() throws Throwable  {
        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 testIsRangeZeroBaselineVisible() throws Throwable  {
        CombinedDomainXYPlot combinedDomainXYPlot = new CombinedDomainXYPlot();
        combinedDomainXYPlot.isRangeZeroBaselineVisible();
        assertTrue(combinedDomainXYPlot.isRangeCrosshairLockedOnData());
        assertEquals(1, combinedDomainXYPlot.getWeight());
        assertTrue(combinedDomainXYPlot.isDomainCrosshairLockedOnData());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testGetPlotType() throws Throwable  {
        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  {
        CombinedDomainXYPlot combinedDomainXYPlot = new CombinedDomainXYPlot();
        combinedDomainXYPlot.getDataset();
        assertTrue(combinedDomainXYPlot.isRangeCrosshairLockedOnData());
        assertEquals(1, combinedDomainXYPlot.getWeight());
        assertTrue(combinedDomainXYPlot.isDomainCrosshairLockedOnData());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testGetRangeMarkersTakingLayer() throws Throwable  {
        CombinedDomainXYPlot combinedDomainXYPlot = new CombinedDomainXYPlot();
        combinedDomainXYPlot.getRangeMarkers((Layer) null);
        assertTrue(combinedDomainXYPlot.isRangeCrosshairLockedOnData());
        assertTrue(combinedDomainXYPlot.isDomainCrosshairLockedOnData());
        assertEquals(1, combinedDomainXYPlot.getWeight());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testGetQuadrantOrigin() throws Throwable  {
        CombinedDomainXYPlot combinedDomainXYPlot = new CombinedDomainXYPlot();
        Point2D.Double quadrantOrigin = (Point2D.Double)combinedDomainXYPlot.getQuadrantOrigin();
        assertEquals(0.0, quadrantOrigin.x, 0.01);
        assertEquals(0.0, quadrantOrigin.y, 0.01);
        assertTrue(combinedDomainXYPlot.isDomainCrosshairLockedOnData());
        assertEquals(1, combinedDomainXYPlot.getWeight());
        assertTrue(combinedDomainXYPlot.isRangeCrosshairLockedOnData());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testIsDomainGridlinesVisibleReturningTrue() throws Throwable  {
        CombinedRangeXYPlot combinedRangeXYPlot = new CombinedRangeXYPlot();
        boolean domainGridlinesVisible = combinedRangeXYPlot.isDomainGridlinesVisible();
        assertTrue(domainGridlinesVisible);
        assertTrue(combinedRangeXYPlot.isRangeCrosshairLockedOnData());
        assertEquals(1, combinedRangeXYPlot.getWeight());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testGetRangeCrosshairStroke() throws Throwable  {
        CombinedDomainXYPlot combinedDomainXYPlot = new CombinedDomainXYPlot();
        BasicStroke rangeCrosshairStroke = (BasicStroke)combinedDomainXYPlot.getRangeCrosshairStroke();
        assertTrue(combinedDomainXYPlot.isRangeCrosshairLockedOnData());
        assertEquals(1, combinedDomainXYPlot.getWeight());
        assertTrue(combinedDomainXYPlot.isDomainCrosshairLockedOnData());
        assertEquals(2, rangeCrosshairStroke.getLineJoin());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testGetDomainCrosshairPaint() throws Throwable  {
        XYPlot xYPlot = new XYPlot();
        Color domainCrosshairPaint = (Color)xYPlot.getDomainCrosshairPaint();
        assertEquals(1, xYPlot.getWeight());
        assertTrue(xYPlot.isDomainCrosshairLockedOnData());
        assertTrue(xYPlot.isRangeCrosshairLockedOnData());
        assertEquals((-16776961), domainCrosshairPaint.getRGB());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testIsRangeZoomable() throws Throwable  {
        CombinedDomainXYPlot combinedDomainXYPlot = new CombinedDomainXYPlot();
        boolean rangeZoomable = combinedDomainXYPlot.isRangeZoomable();
        assertTrue(combinedDomainXYPlot.isRangeCrosshairLockedOnData());
        assertTrue(rangeZoomable);
        assertEquals(1, combinedDomainXYPlot.getWeight());
        assertTrue(combinedDomainXYPlot.isDomainCrosshairLockedOnData());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testGetRangeCrosshairValueReturningZero() throws Throwable  {
        CombinedRangeXYPlot combinedRangeXYPlot = new CombinedRangeXYPlot();
        double rangeCrosshairValue = combinedRangeXYPlot.getRangeCrosshairValue();
        assertEquals(1, combinedRangeXYPlot.getWeight());
        assertTrue(combinedRangeXYPlot.isDomainCrosshairLockedOnData());
        assertEquals(0.0, rangeCrosshairValue, 0.01);
        assertTrue(combinedRangeXYPlot.isRangeCrosshairLockedOnData());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testIsDomainZoomable() throws Throwable  {
        CombinedDomainXYPlot combinedDomainXYPlot = new CombinedDomainXYPlot();
        boolean domainZoomable = combinedDomainXYPlot.isDomainZoomable();
        assertTrue(combinedDomainXYPlot.isRangeCrosshairLockedOnData());
        assertEquals(1, combinedDomainXYPlot.getWeight());
        assertTrue(combinedDomainXYPlot.isDomainCrosshairLockedOnData());
        assertTrue(domainZoomable);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testGetDomainGridlinePaint() throws Throwable  {
        CombinedDomainXYPlot combinedDomainXYPlot = new CombinedDomainXYPlot();
        Color domainGridlinePaint = (Color)combinedDomainXYPlot.getDomainGridlinePaint();
        assertTrue(combinedDomainXYPlot.isRangeCrosshairLockedOnData());
        assertEquals(192, domainGridlinePaint.getRed());
        assertTrue(combinedDomainXYPlot.isDomainCrosshairLockedOnData());
        assertEquals(1, combinedDomainXYPlot.getWeight());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testGetDomainAxisCount() throws Throwable  {
        CombinedDomainXYPlot combinedDomainXYPlot = new CombinedDomainXYPlot();
        combinedDomainXYPlot.getDomainAxisCount();
        assertEquals(1, combinedDomainXYPlot.getWeight());
        assertTrue(combinedDomainXYPlot.isRangeCrosshairLockedOnData());
        assertTrue(combinedDomainXYPlot.isDomainCrosshairLockedOnData());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testGetRangeGridlinePaint() throws Throwable  {
        CombinedDomainXYPlot combinedDomainXYPlot = new CombinedDomainXYPlot();
        Color rangeGridlinePaint = (Color)combinedDomainXYPlot.getRangeGridlinePaint();
        assertEquals(1, combinedDomainXYPlot.getWeight());
        assertTrue(combinedDomainXYPlot.isRangeCrosshairLockedOnData());
        assertEquals((-4144960), rangeGridlinePaint.getRGB());
        assertTrue(combinedDomainXYPlot.isDomainCrosshairLockedOnData());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testSetFixedLegendItems() throws Throwable  {
        CombinedDomainXYPlot combinedDomainXYPlot = new CombinedDomainXYPlot();
        combinedDomainXYPlot.setFixedLegendItems((LegendItemCollection) null);
        assertTrue(combinedDomainXYPlot.isRangeCrosshairLockedOnData());
        assertTrue(combinedDomainXYPlot.isDomainCrosshairLockedOnData());
        assertEquals(1, combinedDomainXYPlot.getWeight());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testGetRangeGridlineStroke() throws Throwable  {
        CombinedRangeXYPlot combinedRangeXYPlot = new CombinedRangeXYPlot();
        BasicStroke rangeGridlineStroke = (BasicStroke)combinedRangeXYPlot.getRangeGridlineStroke();
        assertEquals(1, combinedRangeXYPlot.getWeight());
        assertTrue(combinedRangeXYPlot.isDomainCrosshairLockedOnData());
        assertTrue(combinedRangeXYPlot.isRangeCrosshairLockedOnData());
        assertEquals(0, rangeGridlineStroke.getEndCap());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testSetRendererTakingXYItemRenderer() throws Throwable  {
        XYPlot xYPlot = new XYPlot();
        XYBarRenderer arg0 = new XYBarRenderer(1.0F);
        xYPlot.setRenderer((XYItemRenderer) arg0);
        assertTrue(xYPlot.isDomainCrosshairLockedOnData());
        assertEquals(1, xYPlot.getWeight());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testAddDomainMarkerTakingMarker() throws Throwable  {
        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 testGetIndexOfReturningZero() throws Throwable  {
        CombinedDomainXYPlot combinedDomainXYPlot = new CombinedDomainXYPlot();
        combinedDomainXYPlot.getIndexOf((XYItemRenderer) null);
        assertEquals(1, combinedDomainXYPlot.getWeight());
        assertTrue(combinedDomainXYPlot.isDomainCrosshairLockedOnData());
        assertTrue(combinedDomainXYPlot.isRangeCrosshairLockedOnData());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testSetWeight() throws Throwable  {
        CombinedDomainXYPlot combinedDomainXYPlot = new CombinedDomainXYPlot();
        combinedDomainXYPlot.setWeight((-2703));
        assertEquals((-2703), combinedDomainXYPlot.getWeight());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testGetRangeCrosshairPaint() throws Throwable  {
        CombinedRangeXYPlot combinedRangeXYPlot = new CombinedRangeXYPlot();
        Color rangeCrosshairPaint = (Color)combinedRangeXYPlot.getRangeCrosshairPaint();
        assertTrue(combinedRangeXYPlot.isRangeCrosshairLockedOnData());
        assertEquals(1, combinedRangeXYPlot.getWeight());
        assertEquals(0, rangeCrosshairPaint.getRed());
        assertTrue(combinedRangeXYPlot.isDomainCrosshairLockedOnData());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testClearAnnotations() throws Throwable  {
        CombinedDomainXYPlot combinedDomainXYPlot = new CombinedDomainXYPlot();
        combinedDomainXYPlot.clearAnnotations();
        assertTrue(combinedDomainXYPlot.isDomainCrosshairLockedOnData());
        assertTrue(combinedDomainXYPlot.isRangeCrosshairLockedOnData());
        assertEquals(1, combinedDomainXYPlot.getWeight());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testSetRangeCrosshairValueTakingDouble() throws Throwable  {
        CombinedRangeXYPlot combinedRangeXYPlot = new CombinedRangeXYPlot();
        combinedRangeXYPlot.setRangeCrosshairValue(1.0E-8);
        double rangeCrosshairValue = combinedRangeXYPlot.getRangeCrosshairValue();
        assertEquals(1.0E-8, rangeCrosshairValue, 0.01);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testSetDatasetTakingXYDataset() throws Throwable  {
        CombinedDomainXYPlot combinedDomainXYPlot = new CombinedDomainXYPlot();
        TimeTableXYDataset arg0 = new TimeTableXYDataset();
        combinedDomainXYPlot.setDataset((XYDataset) arg0);
        XYDataset dataset = combinedDomainXYPlot.getDataset();
        assertEquals(1, combinedDomainXYPlot.getWeight());
        assertNotNull(dataset);
        assertTrue(combinedDomainXYPlot.isDomainCrosshairLockedOnData());
        assertTrue(combinedDomainXYPlot.isRangeCrosshairLockedOnData());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testGetRangeZeroBaselinePaint() throws Throwable  {
        XYPlot xYPlot = new XYPlot();
        Color rangeZeroBaselinePaint = (Color)xYPlot.getRangeZeroBaselinePaint();
        assertTrue(xYPlot.isDomainCrosshairLockedOnData());
        assertTrue(xYPlot.isRangeCrosshairLockedOnData());
        assertEquals(1, xYPlot.getWeight());
        assertEquals(0, rangeZeroBaselinePaint.getBlue());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testGetRangeAxisEdgeTakingNoArguments() throws Throwable  {
        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 testSetRendererTaking2Arguments() throws Throwable  {
        CombinedDomainXYPlot combinedDomainXYPlot = new CombinedDomainXYPlot();
        StackedXYBarRenderer arg1 = new StackedXYBarRenderer();
        combinedDomainXYPlot.setRenderer(10, (XYItemRenderer) arg1);
        assertEquals(1, combinedDomainXYPlot.getWeight());
        assertTrue(combinedDomainXYPlot.isRangeCrosshairLockedOnData());
        assertTrue(combinedDomainXYPlot.isDomainCrosshairLockedOnData());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testSetRangeCrosshairPaint() throws Throwable  {
        CombinedDomainXYPlot combinedDomainXYPlot = new CombinedDomainXYPlot();
        Color arg0 = Color.YELLOW;
        combinedDomainXYPlot.setRangeCrosshairPaint(arg0);
        assertEquals(1, combinedDomainXYPlot.getWeight());
        assertTrue(combinedDomainXYPlot.isRangeCrosshairLockedOnData());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testGetDomainGridlineStroke() throws Throwable  {
        CombinedRangeXYPlot combinedRangeXYPlot = new CombinedRangeXYPlot();
        BasicStroke arg0 = (BasicStroke)combinedRangeXYPlot.getDomainGridlineStroke();
        combinedRangeXYPlot.setDomainCrosshairStroke(arg0);
        assertTrue(combinedRangeXYPlot.isRangeCrosshairLockedOnData());
        assertTrue(combinedRangeXYPlot.isDomainCrosshairLockedOnData());
        assertEquals(1, combinedRangeXYPlot.getWeight());
        assertEquals(2, arg0.getLineJoin());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testGetAnnotations() throws Throwable  {
        CombinedRangeXYPlot combinedRangeXYPlot = new CombinedRangeXYPlot();
        combinedRangeXYPlot.getAnnotations();
        assertTrue(combinedRangeXYPlot.isRangeCrosshairLockedOnData());
        assertTrue(combinedRangeXYPlot.isDomainCrosshairLockedOnData());
        assertEquals(1, combinedRangeXYPlot.getWeight());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testGetRangeAxisCount() throws Throwable  {
        CombinedDomainXYPlot combinedDomainXYPlot = new CombinedDomainXYPlot();
        combinedDomainXYPlot.getRangeAxisCount();
        assertEquals(1, combinedDomainXYPlot.getWeight());
        assertTrue(combinedDomainXYPlot.isDomainCrosshairLockedOnData());
        assertTrue(combinedDomainXYPlot.isRangeCrosshairLockedOnData());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testSetDomainAxisLocationTaking1And1AndSetDomainAxisLocationTaking1And11() throws Throwable  {
        CombinedDomainXYPlot combinedDomainXYPlot = new CombinedDomainXYPlot((ValueAxis) null);
        AxisLocation arg1 = AxisLocation.BOTTOM_OR_RIGHT;
        combinedDomainXYPlot.setDomainAxisLocation(2000, arg1);
        assertEquals(1, combinedDomainXYPlot.getWeight());
        assertTrue(combinedDomainXYPlot.isRangeCrosshairLockedOnData());
        assertTrue(combinedDomainXYPlot.isDomainCrosshairLockedOnData());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testIsRangeCrosshairLockedOnData() throws Throwable  {
        CombinedDomainXYPlot combinedDomainXYPlot = new CombinedDomainXYPlot();
        boolean rangeCrosshairLockedOnData = combinedDomainXYPlot.isRangeCrosshairLockedOnData();
        assertEquals(1, combinedDomainXYPlot.getWeight());
        assertTrue(rangeCrosshairLockedOnData);
        assertTrue(combinedDomainXYPlot.isDomainCrosshairLockedOnData());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testSetDomainCrosshairValueTakingDouble() throws Throwable  {
        CombinedDomainXYPlot combinedDomainXYPlot = new CombinedDomainXYPlot();
        combinedDomainXYPlot.setDomainCrosshairValue(0.05);
        double domainCrosshairValue = combinedDomainXYPlot.getDomainCrosshairValue();
        assertEquals(0.05, domainCrosshairValue, 0.01);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testSetFixedDomainAxisSpace() throws Throwable  {
        CombinedRangeXYPlot combinedRangeXYPlot = new CombinedRangeXYPlot();
        combinedRangeXYPlot.setFixedDomainAxisSpace((AxisSpace) null);
        assertTrue(combinedRangeXYPlot.isDomainCrosshairLockedOnData());
        assertEquals(1, combinedRangeXYPlot.getWeight());
        assertTrue(combinedRangeXYPlot.isRangeCrosshairLockedOnData());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testSetRangeAxisLocationTakingAxisLocation() throws Throwable  {
        CombinedDomainXYPlot combinedDomainXYPlot = new CombinedDomainXYPlot();
        CategoryPlot categoryPlot = new CategoryPlot();
        AxisLocation arg0 = categoryPlot.getDomainAxisLocation(10);
        combinedDomainXYPlot.setRangeAxisLocation(arg0);
        assertEquals(1, combinedDomainXYPlot.getWeight());
        assertTrue(combinedDomainXYPlot.isDomainCrosshairLockedOnData());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testGetSeriesRenderingOrder() throws Throwable  {
        CombinedRangeXYPlot combinedRangeXYPlot = new CombinedRangeXYPlot();
        SeriesRenderingOrder arg0 = combinedRangeXYPlot.getSeriesRenderingOrder();
        combinedRangeXYPlot.setSeriesRenderingOrder(arg0);
        assertTrue(combinedRangeXYPlot.isRangeCrosshairLockedOnData());
        assertTrue(combinedRangeXYPlot.isDomainCrosshairLockedOnData());
        assertEquals(1, combinedRangeXYPlot.getWeight());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testCreatesXYPlotTakingNoArguments() throws Throwable  {
        XYPlot arg1 = new XYPlot();
        JFreeChart jFreeChart = new JFreeChart((String) null, arg1);
        // Undeclared exception!
        try { 
          jFreeChart.createBufferedImage(1321, 1321);
          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  {
        CombinedRangeXYPlot combinedRangeXYPlot = new CombinedRangeXYPlot();
        RectangleInsets axisOffset = combinedRangeXYPlot.getAxisOffset();
        assertTrue(combinedRangeXYPlot.isRangeCrosshairLockedOnData());
        assertTrue(combinedRangeXYPlot.isDomainCrosshairLockedOnData());
        assertEquals(1, combinedRangeXYPlot.getWeight());
        assertEquals(0.0, axisOffset.getBottom(), 0.01);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testGetRangeZeroBaselineStroke() throws Throwable  {
        CombinedDomainXYPlot combinedDomainXYPlot = new CombinedDomainXYPlot();
        BasicStroke rangeZeroBaselineStroke = (BasicStroke)combinedDomainXYPlot.getRangeZeroBaselineStroke();
        assertEquals(1, combinedDomainXYPlot.getWeight());
        assertTrue(combinedDomainXYPlot.isDomainCrosshairLockedOnData());
        assertTrue(combinedDomainXYPlot.isRangeCrosshairLockedOnData());
        assertEquals(10.0F, rangeZeroBaselineStroke.getMiterLimit(), 0.01F);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testGetDomainTickBandPaint() throws Throwable  {
        CombinedRangeXYPlot combinedRangeXYPlot = new CombinedRangeXYPlot();
        Paint domainTickBandPaint = combinedRangeXYPlot.getDomainTickBandPaint();
        assertNull(domainTickBandPaint);
        assertTrue(combinedRangeXYPlot.isRangeCrosshairLockedOnData());
        assertTrue(combinedRangeXYPlot.isDomainCrosshairLockedOnData());
        assertEquals(1, combinedRangeXYPlot.getWeight());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testSetRangeZeroBaselineVisible() throws Throwable  {
        CombinedDomainXYPlot combinedDomainXYPlot = new CombinedDomainXYPlot();
        combinedDomainXYPlot.setRangeZeroBaselineVisible(false);
        assertTrue(combinedDomainXYPlot.isRangeCrosshairLockedOnData());
        assertEquals(1, combinedDomainXYPlot.getWeight());
        assertTrue(combinedDomainXYPlot.isDomainCrosshairLockedOnData());
        assertFalse(combinedDomainXYPlot.isRangeZeroBaselineVisible());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testGetRangeAxisLocationTakingNoArguments() throws Throwable  {
        CombinedDomainXYPlot combinedDomainXYPlot = new CombinedDomainXYPlot();
        combinedDomainXYPlot.getRangeAxisLocation();
        assertTrue(combinedDomainXYPlot.isDomainCrosshairLockedOnData());
        assertTrue(combinedDomainXYPlot.isRangeCrosshairLockedOnData());
        assertEquals(1, combinedDomainXYPlot.getWeight());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testGetDomainAxisForDatasetReturningValueAxisWhereIsVisibleIsTrue() throws Throwable  {
        CombinedDomainXYPlot combinedDomainXYPlot = new CombinedDomainXYPlot();
        ValueAxis domainAxisForDataset = combinedDomainXYPlot.getDomainAxisForDataset(0);
        assertEquals(1, combinedDomainXYPlot.getWeight());
        assertTrue(combinedDomainXYPlot.isDomainCrosshairLockedOnData());
        assertNotNull(domainAxisForDataset);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testSetRangeAxisLocationTaking1And1AndSetRangeAxisLocationTaking1And1AndSetRangeAxisLocationTaking1And1WithZero() throws Throwable  {
        CombinedRangeXYPlot combinedRangeXYPlot = new CombinedRangeXYPlot((ValueAxis) null);
        combinedRangeXYPlot.setRangeAxisLocation(0, (AxisLocation) null);
        assertTrue(combinedRangeXYPlot.isRangeCrosshairLockedOnData());
        assertTrue(combinedRangeXYPlot.isDomainCrosshairLockedOnData());
        assertEquals(1, combinedRangeXYPlot.getWeight());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testGetDatasetRenderingOrder() throws Throwable  {
        CombinedDomainXYPlot combinedDomainXYPlot = new CombinedDomainXYPlot();
        DatasetRenderingOrder arg0 = combinedDomainXYPlot.getDatasetRenderingOrder();
        combinedDomainXYPlot.setDatasetRenderingOrder(arg0);
        assertTrue(combinedDomainXYPlot.isDomainCrosshairLockedOnData());
        assertEquals(1, combinedDomainXYPlot.getWeight());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testDrawHorizontalLine() throws Throwable  {
        CombinedRangeXYPlot combinedRangeXYPlot = new CombinedRangeXYPlot();
        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);
        assertEquals(1, combinedRangeXYPlot.getWeight());
        assertTrue(combinedRangeXYPlot.isDomainCrosshairLockedOnData());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testGetDomainCrosshairValueReturningZero() throws Throwable  {
        CombinedDomainXYPlot combinedDomainXYPlot = new CombinedDomainXYPlot();
        double domainCrosshairValue = combinedDomainXYPlot.getDomainCrosshairValue();
        assertTrue(combinedDomainXYPlot.isRangeCrosshairLockedOnData());
        assertEquals(0.0, domainCrosshairValue, 0.01);
        assertEquals(1, combinedDomainXYPlot.getWeight());
        assertTrue(combinedDomainXYPlot.isDomainCrosshairLockedOnData());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testAddRangeMarkerTakingMarker() throws Throwable  {
        CombinedDomainXYPlot combinedDomainXYPlot = new CombinedDomainXYPlot();
        CategoryMarker arg0 = new CategoryMarker(1.0F, combinedDomainXYPlot.DEFAULT_GRIDLINE_PAINT, combinedDomainXYPlot.DEFAULT_GRIDLINE_STROKE);
        combinedDomainXYPlot.addRangeMarker((Marker) arg0);
        assertTrue(combinedDomainXYPlot.isRangeCrosshairLockedOnData());
        assertEquals(1, combinedDomainXYPlot.getWeight());
        assertTrue(combinedDomainXYPlot.isDomainCrosshairLockedOnData());
    }
  }
  