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

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

  29.  * (C) Copyright 2004, 2005, by Object Refinery Limited.

  30.  *

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

  32.  * Contributor(s):   -;

  33.  *

  34.  * $Id: TaskSeriesCollectionTests.java,v 1.4 2005/03/04 11:46:46 mungady Exp $

  35.  *

  36.  * Changes

  37.  * -------

  38.  * 30-Jul-2004 : Version 1 (DG);

  39.  * 12-Jan-2005 : Added tests from TaskSeriesCollectionTests2.java (DG);

  40.  *

  41.  */

  42. 

  43. package org.jfree.data.gantt.junit;

  44. 

  45. import java.io.ByteArrayInputStream;

  46. import java.io.ByteArrayOutputStream;

  47. import java.io.ObjectInput;

  48. import java.io.ObjectInputStream;

  49. import java.io.ObjectOutput;

  50. import java.io.ObjectOutputStream;

  51. import java.util.Date;

  52. 

  53. import junit.framework.Test;

  54. import junit.framework.TestCase;

  55. import junit.framework.TestSuite;

  56. 

  57. import org.jfree.data.gantt.Task;

  58. import org.jfree.data.gantt.TaskSeries;

  59. import org.jfree.data.gantt.TaskSeriesCollection;

  60. import org.jfree.data.time.SimpleTimePeriod;

  61. 

  62. /**

  63.  * Tests for the {@link TaskSeriesCollection} class.

  64.  */

  65. public class TaskSeriesCollectionTests extends TestCase {

  66. 

  67.     /**

  68.      * Returns the tests as a test suite.

  69.      *

  70.      * @return The test suite.

  71.      */

  72.     public static Test suite() {

  73.         return new TestSuite(TaskSeriesCollectionTests.class);

  74.     }

  75. 

  76.     /**

  77.      * Constructs a new set of tests.

  78.      *

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

  80.      */

  81.     public TaskSeriesCollectionTests(String name) {

  82.         super(name);

  83.     }

  84. 

  85.     /**

  86.      * Creates a sample collection for testing purposes.

  87.      * 

  88.      * @return A sample collection.

  89.      */

  90.     private TaskSeriesCollection createCollection1() {

  91.         TaskSeriesCollection result = new TaskSeriesCollection();

  92.         TaskSeries s1 = new TaskSeries("S1");

  93.         s1.add(new Task("Task 1", new Date(1), new Date(2)));

  94.         s1.add(new Task("Task 2", new Date(3), new Date(4)));

  95.         result.add(s1);

  96.         TaskSeries s2 = new TaskSeries("S2");

  97.         s2.add(new Task("Task 3", new Date(5), new Date(6)));

  98.         result.add(s2);

  99.         return result;

  100.     }

  101.     

  102.     /**

  103.      * Creates a sample collection for testing purposes.

  104.      * 

  105.      * @return A sample collection.

  106.      */

  107.     private TaskSeriesCollection createCollection2() {

  108.         TaskSeriesCollection result = new TaskSeriesCollection();

  109.         TaskSeries s1 = new TaskSeries("S1");

  110.         Task t1 = new Task("Task 1", new Date(10), new Date(20));

  111.         t1.addSubtask(new Task("Task 1A", new Date(10), new Date(15)));

  112.         t1.addSubtask(new Task("Task 1B", new Date(16), new Date(20)));

  113.         t1.setPercentComplete(0.10);

  114.         s1.add(t1);

  115.         Task t2 = new Task("Task 2", new Date(30), new Date(40));

  116.         t2.addSubtask(new Task("Task 2A", new Date(30), new Date(35)));

  117.         t2.addSubtask(new Task("Task 2B", new Date(36), new Date(40)));

  118.         t2.setPercentComplete(0.20);

  119.         s1.add(t2);

  120.         result.add(s1);

  121.         TaskSeries s2 = new TaskSeries("S2");

  122.         Task t3 = new Task("Task 3", new Date(50), new Date(60));

  123.         t3.addSubtask(new Task("Task 3A", new Date(50), new Date(55)));

  124.         t3.addSubtask(new Task("Task 3B", new Date(56), new Date(60)));

  125.         t3.setPercentComplete(0.30);

  126.         s2.add(t3);

  127.         result.add(s2);

  128.         return result;

  129.     }

  130.     

  131.     /**

  132.      * Creates a sample collection for testing purposes.

  133.      * 

  134.      * @return A sample collection.

  135.      */

  136.     private TaskSeriesCollection createCollection3() {

  137.         

  138.         // define subtasks

  139.         Task sub1 = new Task("Sub1", new Date(11), new Date(111));

  140.         Task sub2 = new Task("Sub2", new Date(22), new Date(222));

  141.         Task sub3 = new Task("Sub3", new Date(33), new Date(333));

  142.         Task sub4 = new Task("Sub4", new Date(44), new Date(444));

  143.         Task sub5 = new Task("Sub5", new Date(55), new Date(555));

  144.         Task sub6 = new Task("Sub6", new Date(66), new Date(666));

  145.         sub1.setPercentComplete(0.111);

  146.         sub2.setPercentComplete(0.222);

  147.         sub3.setPercentComplete(0.333);

  148.         sub4.setPercentComplete(0.444);

  149.         sub5.setPercentComplete(0.555);

  150.         sub6.setPercentComplete(0.666);

  151.         

  152.         TaskSeries seriesA = new TaskSeries("Series A");

  153.         Task taskA1 = new Task(

  154.             "Task 1", new SimpleTimePeriod(new Date(100), new Date(200))

  155.         );

  156.         taskA1.setPercentComplete(0.1);

  157.         taskA1.addSubtask(sub1);

  158.         Task taskA2 = new Task(

  159.             "Task 2", new SimpleTimePeriod(new Date(220), new Date(350))

  160.         );

  161.         taskA2.setPercentComplete(0.2);

  162.         taskA2.addSubtask(sub2);

  163.         taskA2.addSubtask(sub3);

  164.         seriesA.add(taskA1);

  165.         seriesA.add(taskA2);

  166.          

  167.         TaskSeries seriesB = new TaskSeries("Series B");

  168.         // note that we don't define taskB1

  169.         Task taskB2 = new Task(

  170.             "Task 2", new SimpleTimePeriod(new Date(2220), new Date(3350))

  171.         );

  172.         taskB2.setPercentComplete(0.3);

  173.         taskB2.addSubtask(sub4);

  174.         taskB2.addSubtask(sub5);

  175.         taskB2.addSubtask(sub6);

  176.         seriesB.add(taskB2);

  177. 

  178.         TaskSeriesCollection tsc = new TaskSeriesCollection();

  179.         tsc.add(seriesA);

  180.         tsc.add(seriesB);        

  181.         

  182.         return tsc;

  183.     }

  184.     

  185.     /**

  186.      * A test for the getSeriesCount() method.

  187.      */

  188.     public void testGetSeriesCount() {

  189.         TaskSeriesCollection c = createCollection1();

  190.         assertEquals(2, c.getSeriesCount());

  191.     }

  192.     

  193.     /**

  194.      * Some tests for the getSeriesName() method.

  195.      */

  196.     public void testGetSeriesName() {

  197.         TaskSeriesCollection c = createCollection1();

  198.         assertEquals("S1", c.getSeriesName(0));

  199.         assertEquals("S2", c.getSeriesName(1));

  200.     }

  201.     

  202.     /**

  203.      * A test for the getRowCount() method.

  204.      */

  205.     public void testGetRowCount() {

  206.         TaskSeriesCollection c = createCollection1();

  207.         assertEquals(2, c.getRowCount());

  208.     }

  209.     

  210.     /**

  211.      * Some tests for the getRowKey() method.

  212.      */

  213.     public void testGetRowKey() {

  214.         TaskSeriesCollection c = createCollection1();

  215.         assertEquals("S1", c.getRowKey(0));

  216.         assertEquals("S2", c.getRowKey(1));

  217.     }

  218.     

  219.     /**

  220.      * Some tests for the getRowIndex() method.

  221.      */

  222.     public void testGetRowIndex() {

  223.         TaskSeriesCollection c = createCollection1();

  224.         assertEquals(0, c.getRowIndex("S1"));

  225.         assertEquals(1, c.getRowIndex("S2"));

  226.     }

  227.     

  228.     /**

  229.      * Some tests for the getValue() method.

  230.      */

  231.     public void testGetValue() {

  232.         TaskSeriesCollection c = createCollection1();

  233.         assertEquals(new Long(1L), c.getValue("S1", "Task 1"));

  234.         assertEquals(new Long(3L), c.getValue("S1", "Task 2"));

  235.         assertEquals(new Long(5L), c.getValue("S2", "Task 3"));

  236.         

  237.         assertEquals(new Long(1L), c.getValue(0, 0));

  238.         assertEquals(new Long(3L), c.getValue(0, 1));

  239.         assertEquals(null, c.getValue(0, 2));

  240.         assertEquals(null, c.getValue(1, 0));

  241.         assertEquals(null, c.getValue(1, 1));

  242.         assertEquals(new Long(5L), c.getValue(1, 2));

  243.     }

  244.     

  245.     /**

  246.      * Some tests for the getStartValue() method.

  247.      */

  248.     public void testGetStartValue() {

  249.         TaskSeriesCollection c = createCollection1();

  250.         assertEquals(new Long(1L), c.getStartValue("S1", "Task 1"));

  251.         assertEquals(new Long(3L), c.getStartValue("S1", "Task 2"));

  252.         assertEquals(new Long(5L), c.getStartValue("S2", "Task 3"));

  253.         

  254.         assertEquals(new Long(1L), c.getStartValue(0, 0));

  255.         assertEquals(new Long(3L), c.getStartValue(0, 1));

  256.         assertEquals(null, c.getStartValue(0, 2));

  257.         assertEquals(null, c.getStartValue(1, 0));

  258.         assertEquals(null, c.getStartValue(1, 1));

  259.         assertEquals(new Long(5L), c.getStartValue(1, 2));

  260.         

  261.         // test collection 3, which doesn't define all tasks in all series

  262.         TaskSeriesCollection c3 = createCollection3();

  263.         assertEquals(new Long(100), c3.getStartValue(0, 0));

  264.         assertEquals(new Long(220), c3.getStartValue(0, 1));

  265.         assertTrue(c3.getStartValue(1, 0) == null);

  266.         assertEquals(new Long(2220), c3.getStartValue(1, 1));

  267.     }

  268.     

  269.     /**

  270.      * Some tests for the getStartValue() method for sub-intervals.

  271.      */

  272.     public void testGetStartValue2() {

  273.         TaskSeriesCollection c = createCollection2();

  274.         assertEquals(new Long(10L), c.getStartValue("S1", "Task 1", 0));

  275.         assertEquals(new Long(16L), c.getStartValue("S1", "Task 1", 1));

  276.         assertEquals(new Long(30L), c.getStartValue("S1", "Task 2", 0));

  277.         assertEquals(new Long(36L), c.getStartValue("S1", "Task 2", 1));

  278.         assertEquals(new Long(50L), c.getStartValue("S2", "Task 3", 0));

  279.         assertEquals(new Long(56L), c.getStartValue("S2", "Task 3", 1));

  280.         

  281.         assertEquals(new Long(10L), c.getStartValue(0, 0, 0));

  282.         assertEquals(new Long(16L), c.getStartValue(0, 0, 1));

  283.         assertEquals(new Long(30L), c.getStartValue(0, 1, 0));

  284.         assertEquals(new Long(36L), c.getStartValue(0, 1, 1));

  285.         assertEquals(new Long(50L), c.getStartValue(1, 2, 0));

  286.         assertEquals(new Long(56L), c.getStartValue(1, 2, 1));

  287. 

  288.         TaskSeriesCollection c3 = createCollection3();

  289.         assertEquals(new Long(11), c3.getStartValue(0, 0, 0));

  290.         assertEquals(new Long(22), c3.getStartValue(0, 1, 0));

  291.         assertEquals(new Long(33), c3.getStartValue(0, 1, 1));

  292.         assertTrue(c3.getStartValue(1, 0, 0) == null);

  293.         assertEquals(new Long(44), c3.getStartValue(1, 1, 0));

  294.         assertEquals(new Long(55), c3.getStartValue(1, 1, 1));

  295.         assertEquals(new Long(66), c3.getStartValue(1, 1, 2));

  296. }

  297.     

  298.     /**

  299.      * Some tests for the getEndValue() method.

  300.      */

  301.     public void testGetEndValue() {

  302.         TaskSeriesCollection c = createCollection1();

  303.         assertEquals(new Long(2L), c.getEndValue("S1", "Task 1"));

  304.         assertEquals(new Long(4L), c.getEndValue("S1", "Task 2"));

  305.         assertEquals(new Long(6L), c.getEndValue("S2", "Task 3"));

  306.         

  307.         assertEquals(new Long(2L), c.getEndValue(0, 0));

  308.         assertEquals(new Long(4L), c.getEndValue(0, 1));

  309.         assertEquals(null, c.getEndValue(0, 2));

  310.         assertEquals(null, c.getEndValue(1, 0));

  311.         assertEquals(null, c.getEndValue(1, 1));

  312.         assertEquals(new Long(6L), c.getEndValue(1, 2));

  313.         

  314.         // test collection 3, which doesn't define all tasks in all series

  315.         TaskSeriesCollection c3 = createCollection3();

  316.         assertEquals(new Long(200), c3.getEndValue(0, 0));

  317.         assertEquals(new Long(350), c3.getEndValue(0, 1));

  318.         assertTrue(c3.getEndValue(1, 0) == null);

  319.         assertEquals(new Long(3350), c3.getEndValue(1, 1));

  320.     }

  321.     

  322.     /**

  323.      * Some tests for the getEndValue() method for sub-intervals.

  324.      */

  325.     public void testGetEndValue2() {

  326.         TaskSeriesCollection c = createCollection2();

  327.         assertEquals(new Long(15L), c.getEndValue("S1", "Task 1", 0));

  328.         assertEquals(new Long(20L), c.getEndValue("S1", "Task 1", 1));

  329.         assertEquals(new Long(35L), c.getEndValue("S1", "Task 2", 0));

  330.         assertEquals(new Long(40L), c.getEndValue("S1", "Task 2", 1));

  331.         assertEquals(new Long(55L), c.getEndValue("S2", "Task 3", 0));

  332.         assertEquals(new Long(60L), c.getEndValue("S2", "Task 3", 1));

  333.         

  334.         assertEquals(new Long(15L), c.getEndValue(0, 0, 0));

  335.         assertEquals(new Long(20L), c.getEndValue(0, 0, 1));

  336.         assertEquals(new Long(35L), c.getEndValue(0, 1, 0));

  337.         assertEquals(new Long(40L), c.getEndValue(0, 1, 1));

  338.         assertEquals(new Long(55L), c.getEndValue(1, 2, 0));

  339.         assertEquals(new Long(60L), c.getEndValue(1, 2, 1));

  340.         

  341.         TaskSeriesCollection c3 = createCollection3();

  342.         assertEquals(new Long(111), c3.getEndValue(0, 0, 0));

  343.         assertEquals(new Long(222), c3.getEndValue(0, 1, 0));

  344.         assertEquals(new Long(333), c3.getEndValue(0, 1, 1));

  345.         assertTrue(c3.getEndValue(1, 0, 0) == null);

  346.         assertEquals(new Long(444), c3.getEndValue(1, 1, 0));

  347.         assertEquals(new Long(555), c3.getEndValue(1, 1, 1));

  348.         assertEquals(new Long(666), c3.getEndValue(1, 1, 2));

  349.     }

  350.     

  351.     /**

  352.      * Some tests for the getPercentComplete() method.

  353.      */

  354.     public void testGetPercentComplete() {

  355.         TaskSeriesCollection c = createCollection2();

  356.         assertEquals(new Double(0.10), c.getPercentComplete("S1", "Task 1"));

  357.         assertEquals(new Double(0.20), c.getPercentComplete("S1", "Task 2"));

  358.         assertEquals(new Double(0.30), c.getPercentComplete("S2", "Task 3"));

  359.         

  360.         assertEquals(new Double(0.10), c.getPercentComplete(0, 0));

  361.         assertEquals(new Double(0.20), c.getPercentComplete(0, 1));

  362.         assertEquals(null, c.getPercentComplete(0, 2));

  363.         assertEquals(null, c.getPercentComplete(1, 0));

  364.         assertEquals(null, c.getPercentComplete(1, 1));

  365.         assertEquals(new Double(0.30), c.getPercentComplete(1, 2));

  366.         

  367.         // test collection 3, which doesn't define all tasks in all series

  368.         TaskSeriesCollection c3 = createCollection3();

  369.         assertEquals(new Double(0.1), c3.getPercentComplete(0, 0));

  370.         assertEquals(new Double(0.2), c3.getPercentComplete(0, 1));

  371.         assertTrue(c3.getPercentComplete(1, 0) == null);

  372.         assertEquals(new Double(0.3), c3.getPercentComplete(1, 1));

  373.         

  374.         assertEquals(new Double(0.111), c3.getPercentComplete(0, 0, 0));

  375.  

  376.         assertEquals(new Double(0.222), c3.getPercentComplete(0, 1, 0));

  377.         assertEquals(new Double(0.333), c3.getPercentComplete(0, 1, 1));

  378. 

  379.         assertEquals(new Double(0.444), c3.getPercentComplete(1, 1, 0));

  380.         assertEquals(new Double(0.555), c3.getPercentComplete(1, 1, 1));

  381.         assertEquals(new Double(0.666), c3.getPercentComplete(1, 1, 2));

  382.     }

  383. 

  384.     /**

  385.      * A test for the getColumnCount() method.

  386.      */

  387.     public void testGetColumnCount() {

  388.         TaskSeriesCollection c = createCollection1();

  389.         assertEquals(3, c.getColumnCount());

  390.     }  

  391. 

  392.     /**

  393.      * Some tests for the getColumnKey() method.

  394.      */

  395.     public void testGetColumnKey() {

  396.         TaskSeriesCollection c = createCollection1();

  397.         assertEquals("Task 1", c.getColumnKey(0));

  398.         assertEquals("Task 2", c.getColumnKey(1));

  399.         assertEquals("Task 3", c.getColumnKey(2));

  400.     }

  401.     

  402.     /**

  403.      * Some tests for the getColumnIndex() method.

  404.      */

  405.     public void testGetColumnIndex() {

  406.         TaskSeriesCollection c = createCollection1();

  407.         assertEquals(0, c.getColumnIndex("Task 1"));

  408.         assertEquals(1, c.getColumnIndex("Task 2"));

  409.         assertEquals(2, c.getColumnIndex("Task 3"));

  410.     }

  411.     

  412.     /**

  413.      * Confirm that the equals method can distinguish all the required fields.

  414.      */

  415.     public void testEquals() {

  416.         

  417.         TaskSeries s1 = new TaskSeries("S");

  418.         s1.add(new Task("T1", new Date(1), new Date(2)));

  419.         s1.add(new Task("T2", new Date(11), new Date(22)));

  420.         TaskSeries s2 = new TaskSeries("S");

  421.         s2.add(new Task("T1", new Date(1), new Date(2)));

  422.         s2.add(new Task("T2", new Date(11), new Date(22)));

  423.         TaskSeriesCollection c1 = new TaskSeriesCollection();

  424.         c1.add(s1);

  425.         c1.add(s2);

  426.         

  427.         TaskSeries s1b = new TaskSeries("S");

  428.         s1b.add(new Task("T1", new Date(1), new Date(2)));

  429.         s1b.add(new Task("T2", new Date(11), new Date(22)));

  430.         TaskSeries s2b = new TaskSeries("S");

  431.         s2b.add(new Task("T1", new Date(1), new Date(2)));

  432.         s2b.add(new Task("T2", new Date(11), new Date(22)));

  433.         TaskSeriesCollection c2 = new TaskSeriesCollection();

  434.         c2.add(s1b);

  435.         c2.add(s2b);

  436.         

  437.         assertTrue(c1.equals(c2));

  438.         assertTrue(c2.equals(c1));

  439. 

  440.     }

  441. 

  442.     /**

  443.      * Confirm that cloning works.

  444.      */

  445.     public void testCloning() {

  446.         TaskSeries s1 = new TaskSeries("S");

  447.         s1.add(new Task("T1", new Date(1), new Date(2)));

  448.         s1.add(new Task("T2", new Date(11), new Date(22)));

  449.         TaskSeries s2 = new TaskSeries("S");

  450.         s2.add(new Task("T1", new Date(1), new Date(2)));

  451.         s2.add(new Task("T2", new Date(11), new Date(22)));

  452.         TaskSeriesCollection c1 = new TaskSeriesCollection();

  453.         c1.add(s1);

  454.         c1.add(s2);

  455. 

  456.         TaskSeriesCollection c2 = null;

  457.         try {

  458.             c2 = (TaskSeriesCollection) c1.clone();

  459.         }

  460.         catch (CloneNotSupportedException e) {

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

  462.         }

  463.         assertTrue(c1 != c2);

  464.         assertTrue(c1.getClass() == c2.getClass());

  465.         assertTrue(c1.equals(c2));

  466.     }

  467. 

  468.     /**

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

  470.      */

  471.     public void testSerialization() {

  472. 

  473.         TaskSeries s1 = new TaskSeries("S");

  474.         s1.add(new Task("T1", new Date(1), new Date(2)));

  475.         s1.add(new Task("T2", new Date(11), new Date(22)));

  476.         TaskSeries s2 = new TaskSeries("S");

  477.         s2.add(new Task("T1", new Date(1), new Date(2)));

  478.         s2.add(new Task("T2", new Date(11), new Date(22)));

  479.         TaskSeriesCollection c1 = new TaskSeriesCollection();

  480.         c1.add(s1);

  481.         c1.add(s2);

  482.         TaskSeriesCollection c2 = null;

  483. 

  484.         try {

  485.             ByteArrayOutputStream buffer = new ByteArrayOutputStream();

  486.             ObjectOutput out = new ObjectOutputStream(buffer);

  487.             out.writeObject(c1);

  488.             out.close();

  489. 

  490.             ObjectInput in = new ObjectInputStream(

  491.                 new ByteArrayInputStream(buffer.toByteArray())

  492.             );

  493.             c2 = (TaskSeriesCollection) in.readObject();

  494.             in.close();

  495.         }

  496.         catch (Exception e) {

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

  498.         }

  499.         assertEquals(c1, c2);

  500. 

  501.     }

  502. 

  503.     /**

  504.      * A test for bug report 697153.

  505.      */

  506.     public void test697153() {

  507. 

  508.         TaskSeries s1 = new TaskSeries("S1");

  509.         s1.add(

  510.             new Task("Task 1", new SimpleTimePeriod(new Date(), new Date()))

  511.         );

  512.         s1.add(

  513.             new Task("Task 2", new SimpleTimePeriod(new Date(), new Date()))

  514.         );

  515.         s1.add(

  516.             new Task("Task 3", new SimpleTimePeriod(new Date(), new Date()))

  517.         );

  518. 

  519.         TaskSeries s2 = new TaskSeries("S2");

  520.         s2.add(

  521.             new Task("Task 2", new SimpleTimePeriod(new Date(), new Date()))

  522.         );

  523.         s2.add(

  524.             new Task("Task 3", new SimpleTimePeriod(new Date(), new Date()))

  525.         );

  526.         s2.add(

  527.             new Task("Task 4", new SimpleTimePeriod(new Date(), new Date()))

  528.         );

  529. 

  530.         TaskSeriesCollection tsc = new TaskSeriesCollection();

  531.         tsc.add(s1);

  532.         tsc.add(s2);

  533. 

  534.         s1.removeAll();

  535. 

  536.         int taskCount = tsc.getColumnCount();

  537. 

  538.         assertEquals(3, taskCount);

  539. 

  540.     }

  541. 

  542.     /**

  543.      * A test for bug report 800324.

  544.      */

  545.     public void test800324() {

  546.         TaskSeries s1 = new TaskSeries("S1");

  547.         s1.add(

  548.             new Task("Task 1", new SimpleTimePeriod(new Date(), new Date()))

  549.         );

  550.         s1.add(

  551.             new Task("Task 2", new SimpleTimePeriod(new Date(), new Date()))

  552.         );

  553.         s1.add(

  554.             new Task("Task 3", new SimpleTimePeriod(new Date(), new Date()))

  555.         );

  556.                 

  557.         TaskSeriesCollection tsc = new TaskSeriesCollection();

  558.         tsc.add(s1);

  559. 

  560.         // these methods should throw an IndexOutOfBoundsException since the 

  561.         // column is too high...

  562.         try {

  563.             /* Number start = */ tsc.getStartValue(0, 3);

  564.             assertTrue(false);

  565.         }

  566.         catch (IndexOutOfBoundsException e) {

  567.             // expected 

  568.         }

  569.         try {

  570.             /* Number end = */ tsc.getEndValue(0, 3);

  571.             assertTrue(false);

  572.         }

  573.         catch (IndexOutOfBoundsException e) {

  574.             // expected 

  575.         }

  576.         try {

  577.             /* int count = */ tsc.getSubIntervalCount(0, 3);

  578.             assertTrue(false);

  579.         }

  580.         catch (IndexOutOfBoundsException e) {

  581.             // expected 

  582.         }

  583.     }

  584.     

  585.     /**

  586.      * Some tests for the bug report 1099331.  We create a TaskSeriesCollection 

  587.      * with two series - the first series has two tasks, but the second has 

  588.      * only one.  The key is to ensure that the methods in TaskSeriesCollection 

  589.      * translate the index values to key values *before* accessing the tasks 

  590.      * in the series.

  591.      */

  592.     public void testGetSubIntervalCount() {

  593.         TaskSeriesCollection tsc = createCollection3();

  594.         assertEquals(1, tsc.getSubIntervalCount(0, 0));

  595.         assertEquals(2, tsc.getSubIntervalCount(0, 1));

  596.         assertEquals(0, tsc.getSubIntervalCount(1, 0));

  597.         assertEquals(3, tsc.getSubIntervalCount(1, 1));

  598.     }

  599.     

  600. }