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

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

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

  4.  *

  5.  * (C) Copyright 2000-2004, 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 under the terms

  10.  * of the GNU Lesser General Public License as published by the Free Software Foundation;

  11.  * either version 2.1 of the License, or (at your option) any later version.

  12.  *

  13.  * This library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY;

  14.  * without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.

  15.  * See the GNU Lesser General Public License for more details.

  16.  *

  17.  * You should have received a copy of the GNU Lesser General Public License along with this

  18.  * library; if not, write to the Free Software Foundation, Inc., 59 Temple Place, Suite 330,

  19.  * Boston, MA 02111-1307, USA.

  20.  *

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

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

  23.  *

  24.  * ----------------------

  25.  * CategoryPlotTests.java

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

  27.  * (C) Copyright 2003, 2004, by Object Refinery Limited and Contributors.

  28.  *

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

  30.  * Contributor(s):   -;

  31.  *

  32.  * $Id: CategoryPlotTests.java,v 1.2 2005/02/22 12:55:35 mungady Exp $

  33.  *

  34.  * Changes

  35.  * -------

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

  37.  * 15-Sep-2003 : Added a unit test to reproduce a bug in serialization (now fixed) (DG);

  38.  *

  39.  */

  40. 

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

  42. 

  43. import java.awt.BasicStroke;

  44. import java.awt.Color;

  45. import java.awt.Stroke;

  46. import java.io.ByteArrayInputStream;

  47. import java.io.ByteArrayOutputStream;

  48. import java.io.ObjectInput;

  49. import java.io.ObjectInputStream;

  50. import java.io.ObjectOutput;

  51. import java.io.ObjectOutputStream;

  52. 

  53. import junit.framework.Test;

  54. import junit.framework.TestCase;

  55. import junit.framework.TestSuite;

  56. 

  57. import org.jfree.chart.ChartFactory;

  58. import org.jfree.chart.JFreeChart;

  59. import org.jfree.chart.annotations.CategoryTextAnnotation;

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

  61. import org.jfree.chart.axis.AxisSpace;

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

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

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

  65. import org.jfree.chart.plot.CategoryPlot;

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

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

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

  69. import org.jfree.chart.renderer.category.AreaRenderer;

  70. import org.jfree.chart.renderer.category.BarRenderer;

  71. import org.jfree.chart.renderer.category.LineAndShapeRenderer;

  72. import org.jfree.data.Range;

  73. import org.jfree.data.category.DefaultCategoryDataset;

  74. import org.jfree.ui.Layer;

  75. import org.jfree.ui.RectangleInsets;

  76. import org.jfree.util.SortOrder;

  77. 

  78. /**

  79.  * Tests for the {@link CategoryPlot} class.

  80.  */

  81. public class CategoryPlotTests extends TestCase {

  82. 

  83.     /**

  84.      * Returns the tests as a test suite.

  85.      *

  86.      * @return The test suite.

  87.      */

  88.     public static Test suite() {

  89.         return new TestSuite(CategoryPlotTests.class);

  90.     }

  91. 

  92.     /**

  93.      * Constructs a new set of tests.

  94.      *

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

  96.      */

  97.     public CategoryPlotTests(String name) {

  98.         super(name);

  99.     }

  100. 

  101.     /**

  102.      * A test for a bug reported in the forum.

  103.      */

  104.     public void testAxisRange() {

  105.         DefaultCategoryDataset datasetA = new DefaultCategoryDataset();

  106.         DefaultCategoryDataset datasetB = new DefaultCategoryDataset();

  107.         datasetB.addValue(50.0, "R1", "C1");

  108.         datasetB.addValue(80.0, "R1", "C1");

  109.         CategoryPlot plot = new CategoryPlot(

  110.             datasetA, new CategoryAxis(null), new NumberAxis(null), new LineAndShapeRenderer()

  111.         );

  112.         plot.setDataset(1, datasetB);

  113.         plot.setRenderer(1, new LineAndShapeRenderer());

  114.         Range r = plot.getRangeAxis().getRange();

  115.         assertEquals(84.0, r.getUpperBound(), 0.00001);

  116.     }

  117.     

  118.     /**

  119.      * Test that the equals() method differentiates all the required fields.

  120.      */

  121.     public void testEquals() {

  122.         

  123.         CategoryPlot plot1 = new CategoryPlot();

  124.         CategoryPlot plot2 = new CategoryPlot();

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

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

  127.         

  128.         // orientation...

  129.         plot1.setOrientation(PlotOrientation.HORIZONTAL);

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

  131.         plot2.setOrientation(PlotOrientation.HORIZONTAL);

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

  133.         

  134.         // axisOffset...

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

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

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

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

  139. 

  140.         // domainAxis - no longer a separate field but test anyway...

  141.         plot1.setDomainAxis(new CategoryAxis("Category Axis"));

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

  143.         plot2.setDomainAxis(new CategoryAxis("Category Axis"));

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

  145. 

  146.         // domainAxes...

  147.         plot1.setDomainAxis(11, new CategoryAxis("Secondary Axis"));

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

  149.         plot2.setDomainAxis(11, new CategoryAxis("Secondary Axis"));

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

  151. 

  152.         // domainAxisLocation - no longer a separate field but test anyway...

  153.         plot1.setDomainAxisLocation(AxisLocation.TOP_OR_RIGHT);

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

  155.         plot2.setDomainAxisLocation(AxisLocation.TOP_OR_RIGHT);

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

  157. 

  158.         // domainAxisLocations...

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

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

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

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

  163. 

  164.         // draw shared domain axis...

  165.         plot1.setDrawSharedDomainAxis(!plot1.getDrawSharedDomainAxis());

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

  167.         plot2.setDrawSharedDomainAxis(!plot2.getDrawSharedDomainAxis());

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

  169.         

  170.         // rangeAxis - no longer a separate field but test anyway...

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

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

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

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

  175. 

  176.         // rangeAxes...

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

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

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

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

  181. 

  182.         // rangeAxisLocation - no longer a separate field but test anyway...

  183.         plot1.setRangeAxisLocation(AxisLocation.TOP_OR_RIGHT);

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

  185.         plot2.setRangeAxisLocation(AxisLocation.TOP_OR_RIGHT);

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

  187. 

  188.         // rangeAxisLocations...

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

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

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

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

  193.         

  194.         // datasetToDomainAxisMap...

  195.         plot1.mapDatasetToDomainAxis(11, 11);

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

  197.         plot2.mapDatasetToDomainAxis(11, 11);

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

  199. 

  200.         // datasetToRangeAxisMap...

  201.         plot1.mapDatasetToRangeAxis(11, 11);

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

  203.         plot2.mapDatasetToRangeAxis(11, 11);

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

  205.         

  206.         // renderer - no longer a separate field but test anyway...

  207.         plot1.setRenderer(new AreaRenderer());

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

  209.         plot2.setRenderer(new AreaRenderer());

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

  211.         

  212.         // renderers...

  213.         plot1.setRenderer(11, new AreaRenderer());

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

  215.         plot2.setRenderer(11, new AreaRenderer());

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

  217.         

  218.         // rendering order...

  219.         plot1.setDatasetRenderingOrder(DatasetRenderingOrder.FORWARD);

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

  221.         plot2.setDatasetRenderingOrder(DatasetRenderingOrder.FORWARD);

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

  223. 

  224.         // columnRenderingOrder...

  225.         plot1.setColumnRenderingOrder(SortOrder.DESCENDING);

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

  227.         plot2.setColumnRenderingOrder(SortOrder.DESCENDING);

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

  229.         

  230.         // rowRenderingOrder...

  231.         plot1.setRowRenderingOrder(SortOrder.DESCENDING);

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

  233.         plot2.setRowRenderingOrder(SortOrder.DESCENDING);

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

  235.         

  236.         // domainGridlinesVisible

  237.         plot1.setDomainGridlinesVisible(true);

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

  239.         plot2.setDomainGridlinesVisible(true);

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

  241. 

  242.         // domainGridlinePosition

  243.         plot1.setDomainGridlinePosition(CategoryAnchor.END);

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

  245.         plot2.setDomainGridlinePosition(CategoryAnchor.END);

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

  247. 

  248.         // domainGridlineStroke

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

  250.         plot1.setDomainGridlineStroke(stroke);

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

  252.         plot2.setDomainGridlineStroke(stroke);

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

  254.         

  255.         // domainGridlinePaint

  256.         plot1.setDomainGridlinePaint(Color.blue);

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

  258.         plot2.setDomainGridlinePaint(Color.blue);

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

  260.         

  261.         // rangeGridlinesVisible

  262.         plot1.setRangeGridlinesVisible(false);

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

  264.         plot2.setRangeGridlinesVisible(false);

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

  266. 

  267.         // rangeGridlineStroke

  268.         plot1.setRangeGridlineStroke(stroke);

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

  270.         plot2.setRangeGridlineStroke(stroke);

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

  272.         

  273.         // rangeGridlinePaint

  274.         plot1.setRangeGridlinePaint(Color.blue);

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

  276.         plot2.setRangeGridlinePaint(Color.blue);

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

  278.         

  279.         // anchorValue

  280.         plot1.setAnchorValue(100.0);

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

  282.         plot2.setAnchorValue(100.0);

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

  284.         

  285.         // rangeCrosshairVisible

  286.         plot1.setRangeCrosshairVisible(true);

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

  288.         plot2.setRangeCrosshairVisible(true);

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

  290.         

  291.         // rangeCrosshairValue

  292.         plot1.setRangeCrosshairValue(100.0);

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

  294.         plot2.setRangeCrosshairValue(100.0);

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

  296.         

  297.         // rangeCrosshairStroke

  298.         plot1.setRangeCrosshairStroke(stroke);

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

  300.         plot2.setRangeCrosshairStroke(stroke);

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

  302.         

  303.         // rangeCrosshairPaint

  304.         plot1.setRangeCrosshairPaint(Color.blue);

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

  306.         plot2.setRangeCrosshairPaint(Color.blue);

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

  308.         

  309.         // rangeCrosshairLockedOnData

  310.         plot1.setRangeCrosshairLockedOnData(false);

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

  312.         plot2.setRangeCrosshairLockedOnData(false);

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

  314.         

  315.         // range markers - no longer separate fields but test anyway...

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

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

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

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

  320.         

  321.         plot1.addRangeMarker(new ValueMarker(5.0), Layer.BACKGROUND);

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

  323.         plot2.addRangeMarker(new ValueMarker(5.0), Layer.BACKGROUND);

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

  325.         

  326.         // foreground range markers...

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

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

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

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

  331.         

  332.         // background range markers...

  333.         plot1.addRangeMarker(1, new ValueMarker(5.0), Layer.BACKGROUND);

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

  335.         plot2.addRangeMarker(1, new ValueMarker(5.0), Layer.BACKGROUND);

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

  337. 

  338.         // annotations

  339.         plot1.addAnnotation(new CategoryTextAnnotation("Text", "Category", 43.0));

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

  341.         plot2.addAnnotation(new CategoryTextAnnotation("Text", "Category", 43.0));

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

  343.         

  344.         // weight

  345.         plot1.setWeight(3);

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

  347.         plot2.setWeight(3);

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

  349.         

  350.         // fixed domain axis space...

  351.         plot1.setFixedDomainAxisSpace(new AxisSpace());

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

  353.         plot2.setFixedDomainAxisSpace(new AxisSpace());

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

  355.         

  356.         // fixed range axis space...

  357.         plot1.setFixedRangeAxisSpace(new AxisSpace());

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

  359.         plot2.setFixedRangeAxisSpace(new AxisSpace());

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

  361.         

  362.         

  363.     }

  364. 

  365.     /**

  366.      * Confirm that cloning works.

  367.      */

  368.     public void testCloning() {

  369.         CategoryPlot p1 = new CategoryPlot();

  370.         CategoryPlot p2 = null;

  371.         try {

  372.             p2 = (CategoryPlot) p1.clone();

  373.         }

  374.         catch (CloneNotSupportedException e) {

  375.             e.printStackTrace();

  376.             System.err.println("CategoryPlotTests.testCloning: failed to clone.");

  377.         }

  378.         assertTrue(p1 != p2);

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

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

  381.     }

  382. 

  383.     /**

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

  385.      */

  386.     public void testSerialization() {

  387. 

  388.         DefaultCategoryDataset data = new DefaultCategoryDataset();

  389.         CategoryAxis domainAxis = new CategoryAxis("Domain");

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

  391.         BarRenderer renderer = new BarRenderer();

  392.         CategoryPlot p1 = new CategoryPlot(data, domainAxis, rangeAxis, renderer);

  393.         p1.setOrientation(PlotOrientation.HORIZONTAL);

  394.         CategoryPlot p2 = null;

  395. 

  396.         try {

  397.             ByteArrayOutputStream buffer = new ByteArrayOutputStream();

  398.             ObjectOutput out = new ObjectOutputStream(buffer);

  399.             out.writeObject(p1);

  400.             out.close();

  401. 

  402.             ObjectInput in = new ObjectInputStream(new ByteArrayInputStream(buffer.toByteArray()));

  403.             p2 = (CategoryPlot) in.readObject();

  404.             in.close();

  405.         }

  406.         catch (Exception e) {

  407.             e.printStackTrace();

  408.         }

  409.         assertEquals(p1, p2);

  410. 

  411.     }

  412. 

  413.     /**

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

  415.      */

  416.     public void testSerialization2() {

  417. 

  418.         DefaultCategoryDataset data = new DefaultCategoryDataset();

  419.         CategoryAxis domainAxis = new CategoryAxis("Domain");

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

  421.         BarRenderer renderer = new BarRenderer();

  422.         CategoryPlot p1 = new CategoryPlot(data, domainAxis, rangeAxis, renderer);

  423.         p1.setOrientation(PlotOrientation.VERTICAL);

  424.         CategoryPlot p2 = null;

  425. 

  426.         try {

  427.             ByteArrayOutputStream buffer = new ByteArrayOutputStream();

  428.             ObjectOutput out = new ObjectOutputStream(buffer);

  429.             out.writeObject(p1);

  430.             out.close();

  431. 

  432.             ObjectInput in = new ObjectInputStream(new ByteArrayInputStream(buffer.toByteArray()));

  433.             p2 = (CategoryPlot) in.readObject();

  434.             in.close();

  435.         }

  436.         catch (Exception e) {

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

  438.         }

  439.         assertEquals(p1, p2);

  440. 

  441.     }

  442. 

  443.     /**

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

  445.      */

  446.     public void testSerialization3() {

  447.         DefaultCategoryDataset dataset = new DefaultCategoryDataset();

  448.         JFreeChart chart = ChartFactory.createBarChart(

  449.             "Test Chart",

  450.             "Category Axis",

  451.             "Value Axis",

  452.             dataset,

  453.             PlotOrientation.VERTICAL,

  454.             true,

  455.             true,

  456.             false

  457.         );

  458.         JFreeChart chart2 = null;

  459.         

  460.         // serialize and deserialize the chart....

  461.         try {

  462.             ByteArrayOutputStream buffer = new ByteArrayOutputStream();

  463.             ObjectOutput out = new ObjectOutputStream(buffer);

  464.             out.writeObject(chart);

  465.             out.close();

  466. 

  467.             ObjectInput in = new ObjectInputStream(new ByteArrayInputStream(buffer.toByteArray()));

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

  469.             in.close();

  470.         }

  471.         catch (Exception e) {

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

  473.         }

  474. 

  475.         // now check that the chart is usable...

  476.         boolean passed = true;

  477.         try {

  478.             chart2.createBufferedImage(300, 200);

  479.         }

  480.         catch (Exception e) {

  481.             passed = false;  

  482.             e.printStackTrace();            

  483.         }

  484.         assertTrue(passed);

  485.     }

  486.     

  487. }