1. /* ===========================================================

  2.  * JFreeChart : a free chart library for the Java(tm) platform

  3.  * ===========================================================

  4.  *

  5.  * (C) Copyright 2000-2005, by Object Refinery Limited and Contributors.

  6.  *

  7.  * Project Info:  http://www.jfree.org/jfreechart/index.html

  8.  *

  9.  * This library is free software; you can redistribute it and/or modify it 

  10.  * under the terms of the GNU Lesser General Public License as published by 

  11.  * the Free Software Foundation; either version 2.1 of the License, or 

  12.  * (at your option) any later version.

  13.  *

  14.  * This library is distributed in the hope that it will be useful, but 

  15.  * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY 

  16.  * or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public 

  17.  * License for more details.

  18.  *

  19.  * You should have received a copy of the GNU Lesser General Public License 

  20.  * along with this library; if not, write to the Free Software Foundation, 

  21.  * Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307, USA.

  22.  *

  23.  * [Java is a trademark or registered trademark of Sun Microsystems, Inc. 

  24.  * in the United States and other countries.]

  25.  *

  26.  * ----------------

  27.  * XYPlotTests.java

  28.  * ----------------

  29.  * (C) Copyright 2003-2005, by Object Refinery Limited and Contributors.

  30.  *

  31.  * Original Author:  David Gilbert (for Object Refinery Limited);

  32.  * Contributor(s):   -;

  33.  *

  34.  * $Id: XYPlotTests.java,v 1.6 2005/02/25 09:40:36 mungady Exp $

  35.  *

  36.  * Changes

  37.  * -------

  38.  * 26-Mar-2003 : Version 1 (DG);

  39.  * 22-Mar-2004 : Added new cloning test (DG);

  40.  * 05-Oct-2004 : Strengthened test for clone independence (DG);

  41.  */

  42. 

  43. package org.jfree.chart.plot.junit;

  44. 

  45. import java.awt.BasicStroke;

  46. import java.awt.Color;

  47. import java.awt.Stroke;

  48. import java.io.ByteArrayInputStream;

  49. import java.io.ByteArrayOutputStream;

  50. import java.io.ObjectInput;

  51. import java.io.ObjectInputStream;

  52. import java.io.ObjectOutput;

  53. import java.io.ObjectOutputStream;

  54. 

  55. import junit.framework.Test;

  56. import junit.framework.TestCase;

  57. import junit.framework.TestSuite;

  58. 

  59. import org.jfree.chart.ChartFactory;

  60. import org.jfree.chart.JFreeChart;

  61. import org.jfree.chart.LegendItemCollection;

  62. import org.jfree.chart.axis.AxisLocation;

  63. import org.jfree.chart.axis.DateAxis;

  64. import org.jfree.chart.axis.NumberAxis;

  65. import org.jfree.chart.labels.StandardXYToolTipGenerator;

  66. import org.jfree.chart.plot.PlotOrientation;

  67. import org.jfree.chart.plot.ValueMarker;

  68. import org.jfree.chart.plot.XYPlot;

  69. import org.jfree.chart.renderer.xy.DefaultXYItemRenderer;

  70. import org.jfree.chart.renderer.xy.StandardXYItemRenderer;

  71. import org.jfree.chart.renderer.xy.XYBarRenderer;

  72. import org.jfree.chart.renderer.xy.XYItemRenderer;

  73. import org.jfree.chart.renderer.xy.XYLineAndShapeRenderer;

  74. import org.jfree.data.time.Day;

  75. import org.jfree.data.time.TimeSeries;

  76. import org.jfree.data.time.TimeSeriesCollection;

  77. import org.jfree.data.xy.IntervalXYDataset;

  78. import org.jfree.data.xy.XYDataset;

  79. import org.jfree.data.xy.XYSeries;

  80. import org.jfree.data.xy.XYSeriesCollection;

  81. import org.jfree.date.MonthConstants;

  82. import org.jfree.ui.Layer;

  83. import org.jfree.ui.RectangleInsets;

  84. 

  85. /**

  86.  * Tests for the {@link XYPlot} class.

  87.  */

  88. public class XYPlotTests extends TestCase {

  89. 

  90.     /**

  91.      * Returns the tests as a test suite.

  92.      *

  93.      * @return The test suite.

  94.      */

  95.     public static Test suite() {

  96.         return new TestSuite(XYPlotTests.class);

  97.     }

  98. 

  99.     /**

  100.      * Constructs a new set of tests.

  101.      *

  102.      * @param name  the name of the tests.

  103.      */

  104.     public XYPlotTests(String name) {

  105.         super(name);

  106.     }

  107.     

  108.     /**

  109.      * Added this test in response to a bug report.

  110.      */

  111.     public void testGetDatasetCount() {

  112.         XYPlot plot = new XYPlot();

  113.         assertEquals(0, plot.getDatasetCount());

  114.     }

  115. 

  116.     /**

  117.      * Test the equals() method.

  118.      */

  119.     public void testEquals() {

  120.         

  121.         XYPlot plot1 = new XYPlot();

  122.         XYPlot plot2 = new XYPlot();

  123.         assertTrue(plot1.equals(plot2));    

  124.         

  125.         // orientation...

  126.         plot1.setOrientation(PlotOrientation.HORIZONTAL);

  127.         assertFalse(plot1.equals(plot2));

  128.         plot2.setOrientation(PlotOrientation.HORIZONTAL);

  129.         assertTrue(plot1.equals(plot2));

  130.         

  131.         // axisOffset...

  132.         plot1.setAxisOffset(new RectangleInsets(0.05, 0.05, 0.05, 0.05));

  133.         assertFalse(plot1.equals(plot2));

  134.         plot2.setAxisOffset(new RectangleInsets(0.05, 0.05, 0.05, 0.05));

  135.         assertTrue(plot1.equals(plot2));

  136. 

  137.         // domainAxis...

  138.         plot1.setDomainAxis(new NumberAxis("Domain Axis"));

  139.         assertFalse(plot1.equals(plot2));

  140.         plot2.setDomainAxis(new NumberAxis("Domain Axis"));

  141.         assertTrue(plot1.equals(plot2));

  142. 

  143.         // domainAxisLocation...

  144.         plot1.setDomainAxisLocation(AxisLocation.TOP_OR_RIGHT);

  145.         assertFalse(plot1.equals(plot2));

  146.         plot2.setDomainAxisLocation(AxisLocation.TOP_OR_RIGHT);

  147.         assertTrue(plot1.equals(plot2));

  148. 

  149.         // secondary DomainAxes...

  150.         plot1.setDomainAxis(11, new NumberAxis("Secondary Domain Axis"));

  151.         assertFalse(plot1.equals(plot2));

  152.         plot2.setDomainAxis(11, new NumberAxis("Secondary Domain Axis"));

  153.         assertTrue(plot1.equals(plot2));

  154. 

  155.         // secondary DomainAxisLocations...

  156.         plot1.setDomainAxisLocation(11, AxisLocation.TOP_OR_RIGHT);

  157.         assertFalse(plot1.equals(plot2));

  158.         plot2.setDomainAxisLocation(11, AxisLocation.TOP_OR_RIGHT);

  159.         assertTrue(plot1.equals(plot2));

  160. 

  161.         // rangeAxis...

  162.         plot1.setRangeAxis(new NumberAxis("Range Axis"));

  163.         assertFalse(plot1.equals(plot2));

  164.         plot2.setRangeAxis(new NumberAxis("Range Axis"));

  165.         assertTrue(plot1.equals(plot2));

  166. 

  167.         // rangeAxisLocation...

  168.         plot1.setRangeAxisLocation(AxisLocation.TOP_OR_RIGHT);

  169.         assertFalse(plot1.equals(plot2));

  170.         plot2.setRangeAxisLocation(AxisLocation.TOP_OR_RIGHT);

  171.         assertTrue(plot1.equals(plot2));

  172. 

  173.         // secondary RangeAxes...

  174.         plot1.setRangeAxis(11, new NumberAxis("Secondary Range Axis"));

  175.         assertFalse(plot1.equals(plot2));

  176.         plot2.setRangeAxis(11, new NumberAxis("Secondary Range Axis"));

  177.         assertTrue(plot1.equals(plot2));

  178. 

  179.         // secondary RangeAxisLocations...

  180.         plot1.setRangeAxisLocation(11, AxisLocation.TOP_OR_RIGHT);

  181.         assertFalse(plot1.equals(plot2));

  182.         plot2.setRangeAxisLocation(11, AxisLocation.TOP_OR_RIGHT);

  183.         assertTrue(plot1.equals(plot2));

  184.         

  185.         // secondary DatasetDomainAxisMap...

  186.         plot1.mapDatasetToDomainAxis(11, 11);

  187.         assertFalse(plot1.equals(plot2));

  188.         plot2.mapDatasetToDomainAxis(11, 11);

  189.         assertTrue(plot1.equals(plot2));

  190. 

  191.         // secondaryDatasetRangeAxisMap...

  192.         plot1.mapDatasetToRangeAxis(11, 11);

  193.         assertFalse(plot1.equals(plot2));

  194.         plot2.mapDatasetToRangeAxis(11, 11);

  195.         assertTrue(plot1.equals(plot2));

  196.         

  197.         // renderer

  198.         plot1.setRenderer(new DefaultXYItemRenderer());

  199.         assertFalse(plot1.equals(plot2));

  200.         plot2.setRenderer(new DefaultXYItemRenderer());

  201.         assertTrue(plot1.equals(plot2));

  202.         

  203.         // secondary renderers

  204.         plot1.setRenderer(11, new DefaultXYItemRenderer());

  205.         assertFalse(plot1.equals(plot2));

  206.         plot2.setRenderer(11, new DefaultXYItemRenderer());

  207.         assertTrue(plot1.equals(plot2));

  208.         

  209.         // domainGridlinesVisible

  210.         plot1.setDomainGridlinesVisible(false);

  211.         assertFalse(plot1.equals(plot2));

  212.         plot2.setDomainGridlinesVisible(false);

  213.         assertTrue(plot1.equals(plot2));

  214. 

  215.         // domainGridlineStroke

  216.         Stroke stroke = new BasicStroke(2.0f);

  217.         plot1.setDomainGridlineStroke(stroke);

  218.         assertFalse(plot1.equals(plot2));

  219.         plot2.setDomainGridlineStroke(stroke);

  220.         assertTrue(plot1.equals(plot2));

  221.         

  222.         // domainGridlinePaint

  223.         plot1.setDomainGridlinePaint(Color.blue);

  224.         assertFalse(plot1.equals(plot2));

  225.         plot2.setDomainGridlinePaint(Color.blue);

  226.         assertTrue(plot1.equals(plot2));

  227.         

  228.         // rangeGridlinesVisible

  229.         plot1.setRangeGridlinesVisible(false);

  230.         assertFalse(plot1.equals(plot2));

  231.         plot2.setRangeGridlinesVisible(false);

  232.         assertTrue(plot1.equals(plot2));

  233. 

  234.         // rangeGridlineStroke

  235.         plot1.setRangeGridlineStroke(stroke);

  236.         assertFalse(plot1.equals(plot2));

  237.         plot2.setRangeGridlineStroke(stroke);

  238.         assertTrue(plot1.equals(plot2));

  239.         

  240.         // rangeGridlinePaint

  241.         plot1.setRangeGridlinePaint(Color.blue);

  242.         assertFalse(plot1.equals(plot2));

  243.         plot2.setRangeGridlinePaint(Color.blue);

  244.         assertTrue(plot1.equals(plot2));

  245.                 

  246.         // zeroRangeBaselineVisible

  247.         plot1.setZeroRangeBaselineVisible(true);

  248.         assertFalse(plot1.equals(plot2));

  249.         plot2.setZeroRangeBaselineVisible(true);

  250.         assertTrue(plot1.equals(plot2));

  251. 

  252.         // zeroRangeBaselineStroke

  253.         plot1.setZeroRangeBaselineStroke(stroke);

  254.         assertFalse(plot1.equals(plot2));

  255.         plot2.setZeroRangeBaselineStroke(stroke);

  256.         assertTrue(plot1.equals(plot2));

  257.         

  258.         // zeroRangeBaselinePaint

  259.         plot1.setZeroRangeBaselinePaint(Color.blue);

  260.         assertFalse(plot1.equals(plot2));

  261.         plot2.setZeroRangeBaselinePaint(Color.blue);

  262.         assertTrue(plot1.equals(plot2));

  263. 

  264.         // rangeCrosshairVisible

  265.         plot1.setRangeCrosshairVisible(true);

  266.         assertFalse(plot1.equals(plot2));

  267.         plot2.setRangeCrosshairVisible(true);

  268.         assertTrue(plot1.equals(plot2));

  269.         

  270.         // rangeCrosshairValue

  271.         plot1.setRangeCrosshairValue(100.0);

  272.         assertFalse(plot1.equals(plot2));

  273.         plot2.setRangeCrosshairValue(100.0);

  274.         assertTrue(plot1.equals(plot2));

  275.         

  276.         // rangeCrosshairStroke

  277.         plot1.setRangeCrosshairStroke(stroke);

  278.         assertFalse(plot1.equals(plot2));

  279.         plot2.setRangeCrosshairStroke(stroke);

  280.         assertTrue(plot1.equals(plot2));

  281.         

  282.         // rangeCrosshairPaint

  283.         plot1.setRangeCrosshairPaint(Color.red);

  284.         assertFalse(plot1.equals(plot2));

  285.         plot2.setRangeCrosshairPaint(Color.red);

  286.         assertTrue(plot1.equals(plot2));

  287.         

  288.         // rangeCrosshairLockedOnData

  289.         plot1.setRangeCrosshairLockedOnData(false);

  290.         assertFalse(plot1.equals(plot2));

  291.         plot2.setRangeCrosshairLockedOnData(false);

  292.         assertTrue(plot1.equals(plot2));

  293.         

  294.         // range markers

  295.         plot1.addRangeMarker(new ValueMarker(4.0));

  296.         assertFalse(plot1.equals(plot2));

  297.         plot2.addRangeMarker(new ValueMarker(4.0));

  298.         assertTrue(plot1.equals(plot2));

  299.         

  300.         // secondary range markers

  301.         plot1.addRangeMarker(1, new ValueMarker(4.0), Layer.FOREGROUND);

  302.         assertFalse(plot1.equals(plot2));

  303.         plot2.addRangeMarker(1, new ValueMarker(4.0), Layer.FOREGROUND);

  304.         assertTrue(plot1.equals(plot2));

  305.                 

  306.         // weight

  307.         plot1.setWeight(3);

  308.         assertFalse(plot1.equals(plot2));

  309.         plot2.setWeight(3);

  310.         assertTrue(plot1.equals(plot2));

  311.         

  312.     }

  313. 

  314.     /**

  315.      * Confirm that basic cloning works.

  316.      */

  317.     public void testCloning() {

  318.         XYPlot p1 = new XYPlot();

  319.         XYPlot p2 = null;

  320.         try {

  321.             p2 = (XYPlot) p1.clone();

  322.         }

  323.         catch (CloneNotSupportedException e) {

  324.             e.printStackTrace();

  325.             System.err.println("XYPlotTests.testCloning: failed to clone.");

  326.         }

  327.         assertTrue(p1 != p2);

  328.         assertTrue(p1.getClass() == p2.getClass());

  329.         assertTrue(p1.equals(p2));

  330.     }

  331.     

  332.     /**

  333.      * Tests cloning for a more complex plot.

  334.      */

  335.     public void testCloning2() {

  336.         XYPlot p1 = new XYPlot(

  337.             null, new NumberAxis("Domain Axis"), new NumberAxis("Range Axis"),

  338.             new StandardXYItemRenderer()

  339.         );   

  340.         p1.setRangeAxis(1, new NumberAxis("Range Axis 2"));

  341.         p1.setRenderer(1, new XYBarRenderer());

  342.         XYPlot p2 = null;

  343.         try {

  344.             p2 = (XYPlot) p1.clone();

  345.         }

  346.         catch (CloneNotSupportedException e) {

  347.             e.printStackTrace();

  348.             System.err.println("Failed to clone.");

  349.         }

  350.         assertTrue(p1 != p2);

  351.         assertTrue(p1.getClass() == p2.getClass());

  352.         assertTrue(p1.equals(p2));

  353.     }

  354.     

  355.     /**

  356.      * Tests the independence of the clones.

  357.      */

  358.     public void testCloneIndependence() {

  359.         XYPlot p1 = new XYPlot(

  360.             null, new NumberAxis("Domain Axis"), new NumberAxis("Range Axis"),

  361.             new StandardXYItemRenderer()

  362.         );

  363.         p1.setDomainAxis(1, new NumberAxis("Domain Axis 2"));

  364.         p1.setDomainAxisLocation(1, AxisLocation.BOTTOM_OR_LEFT);

  365.         p1.setRangeAxis(1, new NumberAxis("Range Axis 2"));

  366.         p1.setRangeAxisLocation(1, AxisLocation.TOP_OR_RIGHT);

  367.         p1.setRenderer(1, new XYBarRenderer());

  368.         XYPlot p2 = null;        

  369.         try {

  370.             p2 = (XYPlot) p1.clone();

  371.         }

  372.         catch (CloneNotSupportedException e) {

  373.             e.printStackTrace();

  374.             System.err.println("Failed to clone.");

  375.         }

  376.         assertTrue(p1.equals(p2));

  377.         

  378.         p1.getDomainAxis().setLabel("Label");

  379.         assertFalse(p1.equals(p2));

  380.         p2.getDomainAxis().setLabel("Label");

  381.         assertTrue(p1.equals(p2));

  382.         

  383.         p1.getDomainAxis(1).setLabel("S1");

  384.         assertFalse(p1.equals(p2));

  385.         p2.getDomainAxis(1).setLabel("S1");

  386.         assertTrue(p1.equals(p2));

  387.         

  388.         p1.setDomainAxisLocation(1, AxisLocation.TOP_OR_RIGHT);

  389.         assertFalse(p1.equals(p2));

  390.         p2.setDomainAxisLocation(1, AxisLocation.TOP_OR_RIGHT);

  391.         assertTrue(p1.equals(p2));

  392.         

  393.         p1.mapDatasetToDomainAxis(2, 1);

  394.         assertFalse(p1.equals(p2));

  395.         p2.mapDatasetToDomainAxis(2, 1);

  396.         assertTrue(p1.equals(p2));

  397. 

  398.         p1.getRangeAxis().setLabel("Label");

  399.         assertFalse(p1.equals(p2));

  400.         p2.getRangeAxis().setLabel("Label");

  401.         assertTrue(p1.equals(p2));

  402.         

  403.         p1.getRangeAxis(1).setLabel("S1");

  404.         assertFalse(p1.equals(p2));

  405.         p2.getRangeAxis(1).setLabel("S1");

  406.         assertTrue(p1.equals(p2));

  407.         

  408.         p1.setRangeAxisLocation(1, AxisLocation.TOP_OR_LEFT);

  409.         assertFalse(p1.equals(p2));

  410.         p2.setRangeAxisLocation(1, AxisLocation.TOP_OR_LEFT);

  411.         assertTrue(p1.equals(p2));

  412.         

  413.         p1.mapDatasetToRangeAxis(2, 1);

  414.         assertFalse(p1.equals(p2));

  415.         p2.mapDatasetToRangeAxis(2, 1);

  416.         assertTrue(p1.equals(p2));

  417. 

  418.         p1.getRenderer().setOutlinePaint(Color.cyan);

  419.         assertFalse(p1.equals(p2));

  420.         p2.getRenderer().setOutlinePaint(Color.cyan);

  421.         assertTrue(p1.equals(p2));

  422.         

  423.         p1.getRenderer(1).setOutlinePaint(Color.red);

  424.         assertFalse(p1.equals(p2));

  425.         p2.getRenderer(1).setOutlinePaint(Color.red);

  426.         assertTrue(p1.equals(p2));

  427.         

  428.     }

  429.     

  430.     /**

  431.      * Setting a null renderer should be allowed, but is generating a null 

  432.      * pointer exception in 0.9.7.

  433.      */

  434.     public void testSetNullRenderer() {

  435.         boolean failed = false;

  436.         try {

  437.             XYPlot plot = new XYPlot(

  438.                 null, new NumberAxis("X"), new NumberAxis("Y"), null

  439.             );

  440.             plot.setRenderer(null);

  441.         }

  442.         catch (Exception e) {

  443.             failed = true;

  444.         }

  445.         assertTrue(!failed);

  446.     }

  447. 

  448.     /**

  449.      * Serialize an instance, restore it, and check for equality.

  450.      */

  451.     public void testSerialization1() {

  452. 

  453.         XYDataset data = new XYSeriesCollection();

  454.         NumberAxis domainAxis = new NumberAxis("Domain");

  455.         NumberAxis rangeAxis = new NumberAxis("Range");

  456.         StandardXYItemRenderer renderer = new StandardXYItemRenderer();

  457.         XYPlot p1 = new XYPlot(data, domainAxis, rangeAxis, renderer);

  458.         XYPlot p2 = null;

  459. 

  460.         try {

  461.             ByteArrayOutputStream buffer = new ByteArrayOutputStream();

  462.             ObjectOutput out = new ObjectOutputStream(buffer);

  463.             out.writeObject(p1);

  464.             out.close();

  465. 

  466.             ObjectInput in = new ObjectInputStream(

  467.                 new ByteArrayInputStream(buffer.toByteArray())

  468.             );

  469.             p2 = (XYPlot) in.readObject();

  470.             in.close();

  471.         }

  472.         catch (Exception e) {

  473.             System.out.println(e.toString());

  474.         }

  475.         assertEquals(p1, p2);

  476. 

  477.     }

  478. 

  479.     /**

  480.      * Serialize an instance, restore it, and check for equality.  This test 

  481.      * uses a {@link DateAxis} and a {@link StandardXYToolTipGenerator}.

  482.      */

  483.     public void testSerialization2() {

  484. 

  485.         IntervalXYDataset data1 = createDataset1();

  486.         XYItemRenderer renderer1 = new XYBarRenderer(0.20);

  487.         renderer1.setToolTipGenerator(

  488.             StandardXYToolTipGenerator.getTimeSeriesInstance()

  489.         );

  490.         XYPlot p1 = new XYPlot(data1, new DateAxis("Date"), null, renderer1);

  491.         XYPlot p2 = null;

  492. 

  493.         try {

  494.             ByteArrayOutputStream buffer = new ByteArrayOutputStream();

  495.             ObjectOutput out = new ObjectOutputStream(buffer);

  496.             out.writeObject(p1);

  497.             out.close();

  498. 

  499.             ObjectInput in = new ObjectInputStream(

  500.                 new ByteArrayInputStream(buffer.toByteArray())

  501.             );

  502.             p2 = (XYPlot) in.readObject();

  503.             in.close();

  504.         }

  505.         catch (Exception e) {

  506.             System.out.println(e.toString());

  507.         }

  508.         assertEquals(p1, p2);

  509. 

  510.     }

  511. 

  512.     /**

  513.      * Problem to reproduce a bug in serialization.  The bug (first reported 

  514.      * against the {@link org.jfree.chart.plot.CategoryPlot} class) is a null 

  515.      * pointer exception that occurs when drawing a plot after deserialization.

  516.      * It is caused by four temporary storage structures (axesAtTop, 

  517.      * axesAtBottom, axesAtLeft and axesAtRight - all initialized as empty 

  518.      * lists in the constructor) not being initialized by the readObject() 

  519.      * method following deserialization.  This test has been written to 

  520.      * reproduce the bug (now fixed).

  521.      */

  522.     public void testSerialization3() {

  523.         

  524.         XYSeriesCollection dataset = new XYSeriesCollection();

  525.         JFreeChart chart = ChartFactory.createXYLineChart(

  526.             "Test Chart",

  527.             "Domain Axis",

  528.             "Range Axis",

  529.             dataset,

  530.             PlotOrientation.VERTICAL,

  531.             true,

  532.             true,

  533.             false

  534.         );

  535.         JFreeChart chart2 = null;

  536.         

  537.         // serialize and deserialize the chart....

  538.         try {

  539.             ByteArrayOutputStream buffer = new ByteArrayOutputStream();

  540.             ObjectOutput out = new ObjectOutputStream(buffer);

  541.             out.writeObject(chart);

  542.             out.close();

  543. 

  544.             ObjectInput in = new ObjectInputStream(

  545.                 new ByteArrayInputStream(buffer.toByteArray())

  546.             );

  547.             chart2 = (JFreeChart) in.readObject();

  548.             in.close();

  549.         }

  550.         catch (Exception e) {

  551.             System.out.println(e.toString());

  552.         }

  553. 

  554.         boolean passed = true;

  555.         try {

  556.             chart2.createBufferedImage(300, 200);

  557.         }

  558.         catch (Exception e) {

  559.             passed = false;  

  560.             e.printStackTrace();            

  561.         }

  562.         assertTrue(passed);

  563.     }

  564.     

  565.     /**

  566.      * Some checks for the getRendererForDataset() method.

  567.      */

  568.     public void testGetRendererForDataset() {

  569.         XYDataset d0 = new XYSeriesCollection();

  570.         XYDataset d1 = new XYSeriesCollection();

  571.         XYDataset d2 = new XYSeriesCollection();

  572.         XYDataset d3 = new XYSeriesCollection();  // not used by plot

  573.         XYItemRenderer r0 = new XYLineAndShapeRenderer();

  574.         XYItemRenderer r2 = new XYLineAndShapeRenderer();

  575.         XYPlot plot = new XYPlot();

  576.         plot.setDataset(0, d0);

  577.         plot.setDataset(1, d1);

  578.         plot.setDataset(2, d2);

  579.         plot.setRenderer(0, r0);

  580.         // no renderer 1

  581.         plot.setRenderer(2, r2);

  582.         assertEquals(r0, plot.getRendererForDataset(d0));

  583.         assertEquals(r0, plot.getRendererForDataset(d1));

  584.         assertEquals(r2, plot.getRendererForDataset(d2));

  585.         assertEquals(null, plot.getRendererForDataset(d3));

  586.         assertEquals(null, plot.getRendererForDataset(null));

  587.     }

  588. 

  589.     /**

  590.      * Some checks for the getLegendItems() method.

  591.      */

  592.     public void testGetLegendItems() {

  593.         // check the case where there is a secondary dataset that doesn't 

  594.         // have a renderer (i.e. falls back to renderer 0)

  595.         XYDataset d0 = createDataset1();

  596.         XYDataset d1 = createDataset2();

  597.         XYItemRenderer r0 = new XYLineAndShapeRenderer();

  598.         XYPlot plot = new XYPlot();

  599.         plot.setDataset(0, d0);

  600.         plot.setDataset(1, d1);

  601.         plot.setRenderer(0, r0);

  602.         LegendItemCollection items = plot.getLegendItems();

  603.         assertEquals(2, items.getItemCount());

  604.     }

  605.     

  606.     /**

  607.      * Creates a sample dataset.

  608.      *

  609.      * @return Series 1.

  610.      */

  611.     private IntervalXYDataset createDataset1() {

  612. 

  613.         // create dataset 1...

  614.         TimeSeries series1 = new TimeSeries("Series 1", Day.class);

  615.         series1.add(new Day(1, MonthConstants.MARCH, 2002), 12353.3);

  616.         series1.add(new Day(2, MonthConstants.MARCH, 2002), 13734.4);

  617.         series1.add(new Day(3, MonthConstants.MARCH, 2002), 14525.3);

  618.         series1.add(new Day(4, MonthConstants.MARCH, 2002), 13984.3);

  619.         series1.add(new Day(5, MonthConstants.MARCH, 2002), 12999.4);

  620.         series1.add(new Day(6, MonthConstants.MARCH, 2002), 14274.3);

  621.         series1.add(new Day(7, MonthConstants.MARCH, 2002), 15943.5);

  622.         series1.add(new Day(8, MonthConstants.MARCH, 2002), 14845.3);

  623.         series1.add(new Day(9, MonthConstants.MARCH, 2002), 14645.4);

  624.         series1.add(new Day(10, MonthConstants.MARCH, 2002), 16234.6);

  625.         series1.add(new Day(11, MonthConstants.MARCH, 2002), 17232.3);

  626.         series1.add(new Day(12, MonthConstants.MARCH, 2002), 14232.2);

  627.         series1.add(new Day(13, MonthConstants.MARCH, 2002), 13102.2);

  628.         series1.add(new Day(14, MonthConstants.MARCH, 2002), 14230.2);

  629.         series1.add(new Day(15, MonthConstants.MARCH, 2002), 11235.2);

  630. 

  631.         TimeSeriesCollection collection = new TimeSeriesCollection(series1);

  632.         collection.setDomainIsPointsInTime(false);  

  633.             // this tells the time series collection that

  634.             // we intend the data to represent time periods

  635.             // NOT points in time.  This is required when

  636.             // determining the min/max values in the

  637.             // dataset's domain.

  638.         return collection;

  639. 

  640.     }

  641. 

  642.     /**

  643.      * Creates a sample dataset.

  644.      *

  645.      * @return A sample dataset.

  646.      */

  647.     private XYDataset createDataset2() {

  648.         // create dataset 1...

  649.         XYSeries series = new XYSeries("Series 2");

  650.         XYSeriesCollection collection = new XYSeriesCollection(series);

  651.         return collection;

  652. 

  653.     }

  654. }