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 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.  * TimeSeriesTests.java

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

  27.  * (C) Copyright 2001-2005, by Object Refinery Limited.

  28.  *

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

  30.  * Contributor(s):   -;

  31.  *

  32.  * $Id: TimeSeriesTests.java,v 1.5 2005/02/10 10:05:07 mungady Exp $

  33.  *

  34.  * Changes

  35.  * -------

  36.  * 16-Nov-2001 : Version 1 (DG);

  37.  * 17-Oct-2002 : Fixed errors reported by Checkstyle (DG);

  38.  * 13-Mar-2003 : Added serialization test (DG);

  39.  * 15-Oct-2003 : Added test for setMaximumItemCount method (DG);

  40.  * 23-Aug-2004 : Added test that highlights a bug where the addOrUpdate() method can

  41.  *               lead to more than maximumItemCount items in the dataset (DG);

  42.  *

  43.  */

  44. 

  45. package org.jfree.data.time.junit;

  46. 

  47. import java.io.ByteArrayInputStream;

  48. import java.io.ByteArrayOutputStream;

  49. import java.io.ObjectInput;

  50. import java.io.ObjectInputStream;

  51. import java.io.ObjectOutput;

  52. import java.io.ObjectOutputStream;

  53. 

  54. import junit.framework.Test;

  55. import junit.framework.TestCase;

  56. import junit.framework.TestSuite;

  57. 

  58. import org.jfree.data.general.SeriesChangeEvent;

  59. import org.jfree.data.general.SeriesChangeListener;

  60. import org.jfree.data.general.SeriesException;

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

  62. import org.jfree.data.time.FixedMillisecond;

  63. import org.jfree.data.time.Month;

  64. import org.jfree.data.time.RegularTimePeriod;

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

  66. import org.jfree.data.time.TimeSeriesDataItem;

  67. import org.jfree.data.time.Year;

  68. import org.jfree.date.MonthConstants;

  69. 

  70. /**

  71.  * A collection of test cases for the {@link TimeSeries} class.

  72.  */

  73. public class TimeSeriesTests extends TestCase implements SeriesChangeListener {

  74. 

  75.     /** A time series. */

  76.     private TimeSeries seriesA;

  77. 

  78.     /** A time series. */

  79.     private TimeSeries seriesB;

  80. 

  81.     /** A time series. */

  82.     private TimeSeries seriesC;

  83. 

  84.     /** A flag that indicates whether or not a change event was fired. */

  85.     private boolean gotSeriesChangeEvent = false;

  86.     

  87.     /**

  88.      * Returns the tests as a test suite.

  89.      *

  90.      * @return The test suite.

  91.      */

  92.     public static Test suite() {

  93.         return new TestSuite(TimeSeriesTests.class);

  94.     }

  95. 

  96.     /**

  97.      * Constructs a new set of tests.

  98.      *

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

  100.      */

  101.     public TimeSeriesTests(String name) {

  102.         super(name);

  103.     }

  104. 

  105.     /**

  106.      * Common test setup.

  107.      */

  108.     protected void setUp() {

  109. 

  110.         this.seriesA = new TimeSeries("Series A", Year.class);

  111.         try {

  112.             this.seriesA.add(new Year(2000), new Integer(102000));

  113.             this.seriesA.add(new Year(2001), new Integer(102001));

  114.             this.seriesA.add(new Year(2002), new Integer(102002));

  115.             this.seriesA.add(new Year(2003), new Integer(102003));

  116.             this.seriesA.add(new Year(2004), new Integer(102004));

  117.             this.seriesA.add(new Year(2005), new Integer(102005));

  118.         }

  119.         catch (SeriesException e) {

  120.             System.err.println("TimeSeriesTests.setUp(): problem creating series.");

  121.         }

  122. 

  123.         this.seriesB = new TimeSeries("Series B", Year.class);

  124.         try {

  125.             this.seriesB.add(new Year(2006), new Integer(202006));

  126.             this.seriesB.add(new Year(2007), new Integer(202007));

  127.             this.seriesB.add(new Year(2008), new Integer(202008));

  128.         }

  129.         catch (SeriesException e) {

  130.             System.err.println("TimeSeriesTests.setUp(): problem creating series.");

  131.         }

  132. 

  133.         this.seriesC = new TimeSeries("Series C", Year.class);

  134.         try {

  135.             this.seriesC.add(new Year(1999), new Integer(301999));

  136.             this.seriesC.add(new Year(2000), new Integer(302000));

  137.             this.seriesC.add(new Year(2002), new Integer(302002));

  138.         }

  139.         catch (SeriesException e) {

  140.             System.err.println("TimeSeriesTests.setUp(): problem creating series.");

  141.         }

  142. 

  143.     }

  144.     

  145.     /**

  146.      * Sets the flag to indicate that a {@link SeriesChangeEvent} has been received.

  147.      * 

  148.      * @param event  the event.

  149.      */

  150.     public void seriesChanged(SeriesChangeEvent event) {

  151.         this.gotSeriesChangeEvent = true;   

  152.     }

  153. 

  154.     /**

  155.      * Check that cloning works.

  156.      */

  157.     public void testClone() {

  158. 

  159.         TimeSeries series = new TimeSeries("Test Series");

  160. 

  161.         RegularTimePeriod jan1st2002 = new Day(1, MonthConstants.JANUARY, 2002);

  162.         try {

  163.             series.add(jan1st2002, new Integer(42));

  164.         }

  165.         catch (SeriesException e) {

  166.             System.err.println("TimeSeriesTests.testClone: problem adding to series.");

  167.         }

  168. 

  169.         TimeSeries clone = null;

  170.         try {

  171.             clone = (TimeSeries) series.clone();

  172.             clone.setName("Clone Series");

  173.             try {

  174.                 clone.update(jan1st2002, new Integer(10));

  175.             }

  176.             catch (SeriesException e) {

  177.                 System.err.println("TimeSeriesTests.testClone: problem updating series.");

  178.             }

  179.         }

  180.         catch (CloneNotSupportedException e) {

  181.             assertTrue(false);  

  182.         }

  183. 

  184.         int seriesValue = series.getValue(jan1st2002).intValue();

  185.         int cloneValue = clone.getValue(jan1st2002).intValue();

  186. 

  187.         assertEquals(42, seriesValue);

  188.         assertEquals(10, cloneValue);

  189.         assertEquals("Test Series", series.getName());

  190.         assertEquals("Clone Series", clone.getName());

  191. 

  192.     }

  193. 

  194.     /**

  195.      * Add a value to series A for 1999.  It should be added at index 0.

  196.      */

  197.     public void testAddValue() {

  198. 

  199.         try {

  200.             this.seriesA.add(new Year(1999), new Integer(1));

  201.         }

  202.         catch (SeriesException e) {

  203.             System.err.println("TimeSeriesTests.testAddValue: problem adding to series.");

  204.         }

  205. 

  206.         int value = this.seriesA.getValue(0).intValue();

  207.         assertEquals(1, value);

  208. 

  209.     }

  210. 

  211.     /**

  212.      * Tests the retrieval of values.

  213.      */

  214.     public void testGetValue() {

  215. 

  216.         Number value1 = this.seriesA.getValue(new Year(1999));

  217.         assertNull(value1);

  218.         int value2 = this.seriesA.getValue(new Year(2000)).intValue();

  219.         assertEquals(102000, value2);

  220. 

  221.     }

  222. 

  223.     /**

  224.      * Tests the deletion of values.

  225.      */

  226.     public void testDelete() {

  227.         this.seriesA.delete(0, 0);

  228.         assertEquals(5, this.seriesA.getItemCount());

  229.         Number value = this.seriesA.getValue(new Year(2000));

  230.         assertNull(value);

  231.     }

  232. 

  233.     /**

  234.      * Basic tests for the delete() method.

  235.      */

  236.     public void testDelete2() {

  237.         TimeSeries s1 = new TimeSeries("Series", Year.class);    

  238.         s1.add(new Year(2000), 13.75);

  239.         s1.add(new Year(2001), 11.90);

  240.         s1.add(new Year(2002), null);

  241.         s1.addChangeListener(this);

  242.         this.gotSeriesChangeEvent = false;

  243.         s1.delete(new Year(2001));

  244.         assertTrue(this.gotSeriesChangeEvent);

  245.         assertEquals(2, s1.getItemCount());

  246.         assertEquals(null, s1.getValue(new Year(2001)));

  247.     }

  248.     

  249.     /**

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

  251.      */

  252.     public void testSerialization() {

  253. 

  254.         TimeSeries s1 = new TimeSeries("A test", Year.class);

  255.         s1.add(new Year(2000), 13.75);

  256.         s1.add(new Year(2001), 11.90);

  257.         s1.add(new Year(2002), null);

  258.         s1.add(new Year(2005), 19.32);

  259.         s1.add(new Year(2007), 16.89);

  260.         TimeSeries s2 = null;

  261. 

  262.         try {

  263.             ByteArrayOutputStream buffer = new ByteArrayOutputStream();

  264.             ObjectOutput out = new ObjectOutputStream(buffer);

  265.             out.writeObject(s1);

  266.             out.close();

  267. 

  268.             ObjectInput in = new ObjectInputStream(

  269.                 new ByteArrayInputStream(buffer.toByteArray())

  270.             );

  271.             s2 = (TimeSeries) in.readObject();

  272.             in.close();

  273.         }

  274.         catch (Exception e) {

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

  276.         }

  277.         assertTrue(s1.equals(s2));

  278. 

  279.     }

  280. 

  281.     /**

  282.      * Tests the equals method.

  283.      */

  284.     public void testEquals() {

  285.         TimeSeries s1 = new TimeSeries("Time Series 1");

  286.         TimeSeries s2 = new TimeSeries("Time Series 2");

  287.         boolean b1 = s1.equals(s2);

  288.         assertFalse("b1", b1);

  289. 

  290.         s2.setName("Time Series 1");

  291.         boolean b2 = s1.equals(s2);

  292.         assertTrue("b2", b2);

  293. 

  294.         RegularTimePeriod p1 = new Day();

  295.         RegularTimePeriod p2 = p1.next();

  296.         s1.add(p1, 100.0);

  297.         s1.add(p2, 200.0);

  298.         boolean b3 = s1.equals(s2);

  299.         assertFalse("b3", b3);

  300. 

  301.         s2.add(p1, 100.0);

  302.         s2.add(p2, 200.0);

  303.         boolean b4 = s1.equals(s2);

  304.         assertTrue("b4", b4);

  305. 

  306.         s1.setMaximumItemCount(100);

  307.         boolean b5 = s1.equals(s2);

  308.         assertFalse("b5", b5);

  309. 

  310.         s2.setMaximumItemCount(100);

  311.         boolean b6 = s1.equals(s2);

  312.         assertTrue("b6", b6);

  313. 

  314.         s1.setHistoryCount(100);

  315.         boolean b7 = s1.equals(s2);

  316.         assertFalse("b7", b7);

  317. 

  318.         s2.setHistoryCount(100);

  319.         boolean b8 = s1.equals(s2);

  320.         assertTrue("b8", b8);

  321.     }

  322.     

  323.     /**

  324.      * Tests a specific bug report where null arguments in the constructor cause the 

  325.      * equals() method to fail.  Fixed for 0.9.21.

  326.      */

  327.     public void testEquals2() {

  328.         TimeSeries s1 = new TimeSeries("Series", null, null, Day.class);

  329.         TimeSeries s2 = new TimeSeries("Series", null, null, Day.class);

  330.         assertTrue(s1.equals(s2));

  331.     }

  332.     

  333.     /**

  334.      * Some tests to ensure that the createCopy(RegularTimePeriod, RegularTimePeriod) method

  335.      * is functioning correctly.

  336.      */

  337.     public void testCreateCopy1() {

  338.         

  339.         TimeSeries series = new TimeSeries("Series", Month.class);

  340.         series.add(new Month(MonthConstants.JANUARY, 2003), 45.0);

  341.         series.add(new Month(MonthConstants.FEBRUARY, 2003), 55.0);

  342.         series.add(new Month(MonthConstants.JUNE, 2003), 35.0);

  343.         series.add(new Month(MonthConstants.NOVEMBER, 2003), 85.0);

  344.         series.add(new Month(MonthConstants.DECEMBER, 2003), 75.0);

  345.         

  346.         try {

  347.             // copy a range before the start of the series data...

  348.             TimeSeries result1 = series.createCopy(new Month(MonthConstants.NOVEMBER, 2002),

  349.                                                    new Month(MonthConstants.DECEMBER, 2002));

  350.             assertEquals(0, result1.getItemCount());

  351.         

  352.             // copy a range that includes only the first item in the series...

  353.             TimeSeries result2 = series.createCopy(new Month(MonthConstants.NOVEMBER, 2002),

  354.                                                    new Month(MonthConstants.JANUARY, 2003));

  355.             assertEquals(1, result2.getItemCount());

  356.         

  357.             // copy a range that begins before and ends in the middle of the series...

  358.             TimeSeries result3 = series.createCopy(new Month(MonthConstants.NOVEMBER, 2002),

  359.                                                    new Month(MonthConstants.APRIL, 2003));

  360.             assertEquals(2, result3.getItemCount());

  361.         

  362.             TimeSeries result4 = series.createCopy(new Month(MonthConstants.NOVEMBER, 2002),

  363.                                                    new Month(MonthConstants.DECEMBER, 2003));

  364.             assertEquals(5, result4.getItemCount());

  365.                                                                                         

  366.             TimeSeries result5 = series.createCopy(new Month(MonthConstants.NOVEMBER, 2002),

  367.                                                    new Month(MonthConstants.MARCH, 2004));

  368.             assertEquals(5, result5.getItemCount());

  369.         

  370.             TimeSeries result6 = series.createCopy(new Month(MonthConstants.JANUARY, 2003),

  371.                                                    new Month(MonthConstants.JANUARY, 2003));

  372.             assertEquals(1, result6.getItemCount());

  373. 

  374.             TimeSeries result7 = series.createCopy(new Month(MonthConstants.JANUARY, 2003),

  375.                                                    new Month(MonthConstants.APRIL, 2003));

  376.             assertEquals(2, result7.getItemCount());

  377. 

  378.             TimeSeries result8 = series.createCopy(new Month(MonthConstants.JANUARY, 2003),

  379.                                                    new Month(MonthConstants.DECEMBER, 2003));

  380.             assertEquals(5, result8.getItemCount());

  381. 

  382.             TimeSeries result9 = series.createCopy(new Month(MonthConstants.JANUARY, 2003),

  383.                                                    new Month(MonthConstants.MARCH, 2004));

  384.             assertEquals(5, result9.getItemCount());

  385.         

  386.             TimeSeries result10 = series.createCopy(new Month(MonthConstants.MAY, 2003),

  387.                                                     new Month(MonthConstants.DECEMBER, 2003));

  388.             assertEquals(3, result10.getItemCount());

  389. 

  390.             TimeSeries result11 = series.createCopy(new Month(MonthConstants.MAY, 2003),

  391.                                                     new Month(MonthConstants.MARCH, 2004));

  392.             assertEquals(3, result11.getItemCount());

  393. 

  394.             TimeSeries result12 = series.createCopy(new Month(MonthConstants.DECEMBER, 2003),

  395.                                                     new Month(MonthConstants.DECEMBER, 2003));

  396.             assertEquals(1, result12.getItemCount());

  397.     

  398.             TimeSeries result13 = series.createCopy(new Month(MonthConstants.DECEMBER, 2003),

  399.                                                     new Month(MonthConstants.MARCH, 2004));

  400.             assertEquals(1, result13.getItemCount());

  401. 

  402.             TimeSeries result14 = series.createCopy(new Month(MonthConstants.JANUARY, 2004),

  403.                                                     new Month(MonthConstants.MARCH, 2004));

  404.             assertEquals(0, result14.getItemCount());

  405.         }

  406.         catch (CloneNotSupportedException e) {

  407.             assertTrue(false);

  408.         }

  409. 

  410.     }

  411.     

  412.     /**

  413.      * Test the setMaximumItemCount() method to ensure that it removes items from the series

  414.      * if necessary.

  415.      */

  416.     public void testSetMaximumItemCount() {

  417. 

  418.         TimeSeries s1 = new TimeSeries("S1", Year.class);

  419.         s1.add(new Year(2000), 13.75);

  420.         s1.add(new Year(2001), 11.90);

  421.         s1.add(new Year(2002), null);

  422.         s1.add(new Year(2005), 19.32);

  423.         s1.add(new Year(2007), 16.89);

  424. 

  425.         assertTrue(s1.getItemCount() == 5);

  426.         s1.setMaximumItemCount(3);

  427.         assertTrue(s1.getItemCount() == 3);

  428.         TimeSeriesDataItem item = s1.getDataItem(0);

  429.         assertTrue(item.getPeriod().equals(new Year(2002)));

  430. 

  431.     }

  432. 

  433.     /**

  434.      * Some checks for the addOrUpdate() method.

  435.      */

  436.     public void testAddOrUpdate() {

  437.         TimeSeries s1 = new TimeSeries("S1", Year.class);

  438.         s1.setMaximumItemCount(2);

  439.         s1.addOrUpdate(new Year(2000), 100.0);

  440.         assertEquals(1, s1.getItemCount());

  441.         s1.addOrUpdate(new Year(2001), 101.0);

  442.         assertEquals(2, s1.getItemCount());

  443.         s1.addOrUpdate(new Year(2001), 102.0);

  444.         assertEquals(2, s1.getItemCount());

  445.         s1.addOrUpdate(new Year(2002), 103.0);

  446.         assertEquals(2, s1.getItemCount());

  447.     }

  448. 

  449.     /**

  450.      * A test for the bug report 1075255.

  451.      */

  452.     public void testBug1075255() {

  453.         TimeSeries ts = new TimeSeries("dummy", FixedMillisecond.class);

  454.         ts.add(new FixedMillisecond(0L), 0.0);

  455.         TimeSeries ts2 = new TimeSeries("dummy2", FixedMillisecond.class);

  456.         ts2.add(new FixedMillisecond(0L), 1.0);

  457.         try {

  458.             ts.addAndOrUpdate(ts2);

  459.         }

  460.         catch (Exception e) {

  461.             e.printStackTrace();

  462.             assertTrue(false);

  463.         }

  464.         assertEquals(1, ts.getItemCount());

  465.     }

  466. }