public class VectorSeriesTests extends TestCase implements SeriesChangeListener { SeriesChangeEvent lastEvent; public void seriesChanged(SeriesChangeEvent event) { this.lastEvent = event; } /** * Returns the tests as a test suite. * * @return The test suite. */ public static Test suite() { return new TestSuite(VectorSeriesTests.class); } /** * Constructs a new set of tests. * * @param name the name of the tests. */ public VectorSeriesTests(String name) { super(name); } /** * Confirm that the equals method can distinguish all the required fields. */ public void testEquals() { VectorSeries s1 = new VectorSeries("s1"); VectorSeries s2 = new VectorSeries("s1"); assertTrue(s1.equals(s2)); // seriesKey s1 = new VectorSeries("s2"); assertFalse(s1.equals(s2)); s2 = new VectorSeries("s2"); assertTrue(s1.equals(s2)); // autoSort s1 = new VectorSeries("s2", true, true); assertFalse(s1.equals(s2)); s2 = new VectorSeries("s2", true, true); assertTrue(s1.equals(s2)); // allowDuplicateValues s1 = new VectorSeries("s2", false, false); assertFalse(s1.equals(s2)); s2 = new VectorSeries("s2", false, false); assertTrue(s1.equals(s2)); // add a value s1.add(1.0, 0.5, 1.5, 2.0); assertFalse(s1.equals(s2)); s2.add(1.0, 0.5, 1.5, 2.0); assertTrue(s2.equals(s1)); // add another value s1.add(2.0, 0.5, 1.5, 2.0); assertFalse(s1.equals(s2)); s2.add(2.0, 0.5, 1.5, 2.0); assertTrue(s2.equals(s1)); // remove a value s1.remove(new XYCoordinate(1.0, 0.5)); assertFalse(s1.equals(s2)); s2.remove(new XYCoordinate(1.0, 0.5)); assertTrue(s2.equals(s1)); } /** * Confirm that cloning works. */ public void testCloning() { VectorSeries s1 = new VectorSeries("s1"); s1.add(1.0, 0.5, 1.5, 2.0); VectorSeries s2 = null; try { s2 = (VectorSeries) s1.clone(); } catch (CloneNotSupportedException e) { e.printStackTrace(); } assertTrue(s1 != s2); assertTrue(s1.getClass() == s2.getClass()); assertTrue(s1.equals(s2)); } /** * Serialize an instance, restore it, and check for equality. */ public void testSerialization() { VectorSeries s1 = new VectorSeries("s1"); s1.add(1.0, 0.5, 1.5, 2.0); VectorSeries s2 = null; try { ByteArrayOutputStream buffer = new ByteArrayOutputStream(); ObjectOutput out = new ObjectOutputStream(buffer); out.writeObject(s1); out.close(); ObjectInput in = new ObjectInputStream( new ByteArrayInputStream(buffer.toByteArray())); s2 = (VectorSeries) in.readObject(); in.close(); } catch (Exception e) { e.printStackTrace(); } assertEquals(s1, s2); } /** * Simple test for the indexOf() method. */ public void testIndexOf() { VectorSeries s1 = new VectorSeries("Series 1"); s1.add(1.0, 1.0, 1.0, 2.0); s1.add(2.0, 2.0, 2.0, 3.0); s1.add(3.0, 3.0, 3.0, 4.0); assertEquals(0, s1.indexOf(new XYCoordinate(1.0, 1.0))); } /** * A check for the indexOf() method for an unsorted series. */ public void testIndexOf2() { VectorSeries s1 = new VectorSeries("Series 1"); s1.add(1.0, 1.0, 1.0, 2.0); s1.add(3.0, 3.0, 3.0, 3.0); s1.add(2.0, 2.0, 2.0, 2.0); assertEquals(0, s1.indexOf(new XYCoordinate(1.0, 1.0))); assertEquals(1, s1.indexOf(new XYCoordinate(3.0, 3.0))); assertEquals(2, s1.indexOf(new XYCoordinate(2.0, 2.0))); } /** * Simple test for the remove() method. */ public void testRemove() { VectorSeries s1 = new VectorSeries("Series 1"); s1.add(1.0, 1.0, 1.0, 2.0); s1.add(3.0, 3.0, 3.0, 3.0); s1.add(2.0, 2.0, 2.0, 2.0); assertEquals(3, s1.getItemCount()); s1.remove(new XYCoordinate(2.0, 2.0)); assertEquals(3.0, s1.getXValue(1), EPSILON); s1.remove(new XYCoordinate(1.0, 1.0)); assertEquals(3.0, s1.getXValue(0), EPSILON); } private static final double EPSILON = 0.0000000001; /** * When items are added with duplicate x-values, we expect them to remain * in the order they were added. */ public void testAdditionOfDuplicateXValues() { VectorSeries s1 = new VectorSeries("Series 1"); s1.add(1.0, 1.0, 1.0, 1.0); s1.add(2.0, 2.0, 2.0, 2.0); s1.add(2.0, 2.0, 3.0, 3.0); s1.add(2.0, 3.0, 4.0, 4.0); s1.add(3.0, 5.0, 5.0, 5.0); assertEquals(1.0, s1.getVectorXValue(0), EPSILON); assertEquals(2.0, s1.getVectorXValue(1), EPSILON); assertEquals(3.0, s1.getVectorXValue(2), EPSILON); assertEquals(4.0, s1.getVectorXValue(3), EPSILON); assertEquals(5.0, s1.getVectorXValue(4), EPSILON); } /** * Some checks for the add() method for an UNSORTED series. */ public void testAdd() { VectorSeries series = new VectorSeries("Series", false, true); series.add(5.0, 5.50, 5.50, 5.50); series.add(5.1, 5.51, 5.51, 5.51); series.add(6.0, 6.6, 6.6, 6.6); series.add(3.0, 3.3, 3.3, 3.3); series.add(4.0, 4.4, 4.4, 4.4); series.add(2.0, 2.2, 2.2, 2.2); series.add(1.0, 1.1, 1.1, 1.1); assertEquals(5.5, series.getVectorXValue(0), EPSILON); assertEquals(5.51, series.getVectorXValue(1), EPSILON); assertEquals(6.6, series.getVectorXValue(2), EPSILON); assertEquals(3.3, series.getVectorXValue(3), EPSILON); assertEquals(4.4, series.getVectorXValue(4), EPSILON); assertEquals(2.2, series.getVectorXValue(5), EPSILON); assertEquals(1.1, series.getVectorXValue(6), EPSILON); } /** * A simple check that the maximumItemCount attribute is working. */ public void testSetMaximumItemCount() { VectorSeries s1 = new VectorSeries("S1"); assertEquals(Integer.MAX_VALUE, s1.getMaximumItemCount()); s1.setMaximumItemCount(2); assertEquals(2, s1.getMaximumItemCount()); s1.add(1.0, 1.1, 1.1, 1.1); s1.add(2.0, 2.2, 2.2, 2.2); s1.add(3.0, 3.3, 3.3, 3.3); assertEquals(2.0, s1.getXValue(0), EPSILON); assertEquals(3.0, s1.getXValue(1), EPSILON); } /** * Check that the maximum item count can be applied retrospectively. */ public void testSetMaximumItemCount2() { VectorSeries s1 = new VectorSeries("S1"); s1.add(1.0, 1.1, 1.1, 1.1); s1.add(2.0, 2.2, 2.2, 2.2); s1.add(3.0, 3.3, 3.3, 3.3); s1.setMaximumItemCount(2); assertEquals(2.0, s1.getXValue(0), EPSILON); assertEquals(3.0, s1.getXValue(1), EPSILON); } /** * Some checks for the clear() method. */ public void testClear() { VectorSeries s1 = new VectorSeries("S1"); s1.addChangeListener(this); s1.clear(); assertNull(this.lastEvent); assertTrue(s1.isEmpty()); s1.add(1.0, 2.0, 3.0, 4.0); assertFalse(s1.isEmpty()); s1.clear(); assertNotNull(this.lastEvent); assertTrue(s1.isEmpty())
public class YIntervalSeriesTests extends TestCase implements SeriesChangeListener { SeriesChangeEvent lastEvent; public void seriesChanged(SeriesChangeEvent event) { this.lastEvent = event; } /** * Returns the tests as a test suite. * * @return The test suite. */ public static Test suite() { return new TestSuite(YIntervalSeriesTests.class); } /** * Constructs a new set of tests. * * @param name the name of the tests. */ public YIntervalSeriesTests(String name) { super(name); } /** * Confirm that the equals method can distinguish all the required fields. */ public void testEquals() { YIntervalSeries s1 = new YIntervalSeries("s1"); YIntervalSeries s2 = new YIntervalSeries("s1"); assertTrue(s1.equals(s2)); // seriesKey s1 = new YIntervalSeries("s2"); assertFalse(s1.equals(s2)); s2 = new YIntervalSeries("s2"); assertTrue(s1.equals(s2)); // autoSort s1 = new YIntervalSeries("s2", false, true); assertFalse(s1.equals(s2)); s2 = new YIntervalSeries("s2", false, true); assertTrue(s1.equals(s2)); // allowDuplicateValues s1 = new YIntervalSeries("s2", false, false); assertFalse(s1.equals(s2)); s2 = new YIntervalSeries("s2", false, false); assertTrue(s1.equals(s2)); // add a value s1.add(1.0, 0.5, 1.5, 2.0); assertFalse(s1.equals(s2)); s2.add(1.0, 0.5, 1.5, 2.0); assertTrue(s2.equals(s1)); // add another value s1.add(2.0, 0.5, 1.5, 2.0); assertFalse(s1.equals(s2)); s2.add(2.0, 0.5, 1.5, 2.0); assertTrue(s2.equals(s1)); // remove a value s1.remove(new Double(1.0)); assertFalse(s1.equals(s2)); s2.remove(new Double(1.0)); assertTrue(s2.equals(s1)); } /** * Confirm that cloning works. */ public void testCloning() { YIntervalSeries s1 = new YIntervalSeries("s1"); s1.add(1.0, 0.5, 1.5, 2.0); YIntervalSeries s2 = null; try { s2 = (YIntervalSeries) s1.clone(); } catch (CloneNotSupportedException e) { e.printStackTrace(); } assertTrue(s1 != s2); assertTrue(s1.getClass() == s2.getClass()); assertTrue(s1.equals(s2)); } /** * Serialize an instance, restore it, and check for equality. */ public void testSerialization() { YIntervalSeries s1 = new YIntervalSeries("s1"); s1.add(1.0, 0.5, 1.5, 2.0); YIntervalSeries s2 = null; try { ByteArrayOutputStream buffer = new ByteArrayOutputStream(); ObjectOutput out = new ObjectOutputStream(buffer); out.writeObject(s1); out.close(); ObjectInput in = new ObjectInputStream( new ByteArrayInputStream(buffer.toByteArray())); s2 = (YIntervalSeries) in.readObject(); in.close(); } catch (Exception e) { e.printStackTrace(); } assertEquals(s1, s2); } /** * Simple test for the indexOf() method. */ public void testIndexOf() { YIntervalSeries s1 = new YIntervalSeries("Series 1"); s1.add(1.0, 1.0, 1.0, 2.0); s1.add(2.0, 2.0, 2.0, 3.0); s1.add(3.0, 3.0, 3.0, 4.0); assertEquals(0, s1.indexOf(new Double(1.0))); } /** * A check for the indexOf() method for an unsorted series. */ public void testIndexOf2() { YIntervalSeries s1 = new YIntervalSeries("Series 1", false, true); s1.add(1.0, 1.0, 1.0, 2.0); s1.add(3.0, 3.0, 3.0, 3.0); s1.add(2.0, 2.0, 2.0, 2.0); assertEquals(0, s1.indexOf(new Double(1.0))); assertEquals(1, s1.indexOf(new Double(3.0))); assertEquals(2, s1.indexOf(new Double(2.0))); } /** * Simple test for the remove() method. */ public void testRemove() { YIntervalSeries s1 = new YIntervalSeries("Series 1"); s1.add(1.0, 1.0, 1.0, 2.0); s1.add(2.0, 2.0, 2.0, 2.0); s1.add(3.0, 3.0, 3.0, 3.0); assertEquals(3, s1.getItemCount()); s1.remove(new Double(2.0)); assertEquals(new Double(3.0), s1.getX(1)); s1.remove(new Double(1.0)); assertEquals(new Double(3.0), s1.getX(0)); } private static final double EPSILON = 0.0000000001; /** * When items are added with duplicate x-values, we expect them to remain * in the order they were added. */ public void testAdditionOfDuplicateXValues() { YIntervalSeries s1 = new YIntervalSeries("Series 1"); s1.add(1.0, 1.0, 1.0, 1.0); s1.add(2.0, 2.0, 2.0, 2.0); s1.add(2.0, 3.0, 3.0, 3.0); s1.add(2.0, 4.0, 4.0, 4.0); s1.add(3.0, 5.0, 5.0, 5.0); assertEquals(1.0, s1.getYValue(0), EPSILON); assertEquals(2.0, s1.getYValue(1), EPSILON); assertEquals(3.0, s1.getYValue(2), EPSILON); assertEquals(4.0, s1.getYValue(3), EPSILON); assertEquals(5.0, s1.getYValue(4), EPSILON); } /** * Some checks for the add() method for an UNSORTED series. */ public void testAdd() { YIntervalSeries series = new YIntervalSeries("Series", false, true); series.add(5.0, 5.50, 5.50, 5.50); series.add(5.1, 5.51, 5.51, 5.51); series.add(6.0, 6.6, 6.6, 6.6); series.add(3.0, 3.3, 3.3, 3.3); series.add(4.0, 4.4, 4.4, 4.4); series.add(2.0, 2.2, 2.2, 2.2); series.add(1.0, 1.1, 1.1, 1.1); assertEquals(5.5, series.getYValue(0), EPSILON); assertEquals(5.51, series.getYValue(1), EPSILON); assertEquals(6.6, series.getYValue(2), EPSILON); assertEquals(3.3, series.getYValue(3), EPSILON); assertEquals(4.4, series.getYValue(4), EPSILON); assertEquals(2.2, series.getYValue(5), EPSILON); assertEquals(1.1, series.getYValue(6), EPSILON); } /** * A simple check that the maximumItemCount attribute is working. */ public void testSetMaximumItemCount() { YIntervalSeries s1 = new YIntervalSeries("S1"); assertEquals(Integer.MAX_VALUE, s1.getMaximumItemCount()); s1.setMaximumItemCount(2); assertEquals(2, s1.getMaximumItemCount()); s1.add(1.0, 1.1, 1.1, 1.1); s1.add(2.0, 2.2, 2.2, 2.2); s1.add(3.0, 3.3, 3.3, 3.3); assertEquals(2.0, s1.getX(0).doubleValue(), EPSILON); assertEquals(3.0, s1.getX(1).doubleValue(), EPSILON); } /** * Check that the maximum item count can be applied retrospectively. */ public void testSetMaximumItemCount2() { YIntervalSeries s1 = new YIntervalSeries("S1"); s1.add(1.0, 1.1, 1.1, 1.1); s1.add(2.0, 2.2, 2.2, 2.2); s1.add(3.0, 3.3, 3.3, 3.3); s1.setMaximumItemCount(2); assertEquals(2.0, s1.getX(0).doubleValue(), EPSILON); assertEquals(3.0, s1.getX(1).doubleValue(), EPSILON); } /** * Some checks for the clear() method. */ public void testClear() { YIntervalSeries s1 = new YIntervalSeries("S1"); s1.addChangeListener(this); s1.clear(); assertNull(this.lastEvent); assertTrue(s1.isEmpty()); s1.add(1.0, 2.0, 3.0, 4.0); assertFalse(s1.isEmpty()); s1.clear(); assertNotNull(this.lastEvent); assertTrue(s1.isEmpty())
Clone fragments detected by clone detection tool
File path: /jfreechart-1.0.10/tests/org/jfree/data/xy/junit/VectorSeriesTests.java File path: /jfreechart-1.0.10/tests/org/jfree/data/xy/junit/YIntervalSeriesTests.java
Method name: Method name:
Number of AST nodes: 0 Number of AST nodes: 0
1
public class VectorSeriesTests extends TestCase 
1
public class YIntervalSeriesTests extends TestCase   
2
        implements SeriesChangeListener {
2
        implements SeriesChangeListener {
3
    SeriesChangeEvent lastEvent;
3
    SeriesChangeEvent lastEvent;
4
    
4
    
5
    public void seriesChanged(SeriesChangeEvent event) {
5
    public void seriesChanged(SeriesChangeEvent event) {
6
        this.lastEvent = event;
6
        this.lastEvent = event;
7
    }
7
    }
8
    /**
8
    /**
9
     * Returns the tests as a test suite.
9
     * Returns the tests as a test suite.
10
     *
10
     *
11
     * @return The test suite.
11
     * @return The test suite.
12
     */
12
     */
13
    public static Test suite() {
13
    public static Test suite() {
14
        return new TestSuite(VectorSeriesTests.class);
14
        return new TestSuite(YIntervalSeriesTests.class);
15
    }
15
    }
16
    /**
16
    /**
17
     * Constructs a new set of tests.
17
     * Constructs a new set of tests.
18
     *
18
     *
19
     * @param name  the name of the tests.
19
     * @param name  the name of the tests.
20
     */
20
     */
21
    public VectorSeriesTests(String name) {
21
    public YIntervalSeriesTests(String name) {
22
        super(name);
22
        super(name);
23
    }
23
    }
24
    /**
24
    /**
25
     * Confirm that the equals method can distinguish all the required fields.
25
     * Confirm that the equals method can distinguish all the required fields.
26
     */
26
     */
27
    public void testEquals() {
27
    public void testEquals() {
28
        
28
        
29
        VectorSeries s1 = new VectorSeries("s1");
29
        YIntervalSeries s1 = new YIntervalSeries("s1");
30
        VectorSeries s2 = new VectorSeries("s1");
30
        YIntervalSeries s2 = new YIntervalSeries("s1");
31
        assertTrue(s1.equals(s2));
31
        assertTrue(s1.equals(s2));
32
        
32
        
33
        // seriesKey
33
        // seriesKey
34
        s1 = new VectorSeries("s2");
34
        s1 = new YIntervalSeries("s2");
35
        assertFalse(s1.equals(s2));
35
        assertFalse(s1.equals(s2));
36
        s2 = new VectorSeries("s2");
36
        s2 = new YIntervalSeries("s2");
37
        assertTrue(s1.equals(s2));
37
        assertTrue(s1.equals(s2));
38
        
38
        
39
        // autoSort
39
        // autoSort
40
        s1 = new VectorSeries("s2", true, true);
40
        s1 = new YIntervalSeries("s2", false, true);
41
        assertFalse(s1.equals(s2));
41
        assertFalse(s1.equals(s2));
42
        s2 = new VectorSeries("s2", true, true);
42
        s2 = new YIntervalSeries("s2", false, true);
43
        assertTrue(s1.equals(s2));
43
        assertTrue(s1.equals(s2));
44
        
44
        
45
        // allowDuplicateValues
45
        // allowDuplicateValues
46
        s1 = new VectorSeries("s2", false, false);
46
        s1 = new YIntervalSeries("s2", false, false);
47
        assertFalse(s1.equals(s2));
47
        assertFalse(s1.equals(s2));
48
        s2 = new VectorSeries("s2", false, false);
48
        s2 = new YIntervalSeries("s2", false, false);
49
        assertTrue(s1.equals(s2));
49
        assertTrue(s1.equals(s2));
50
        
50
        
51
        // add a value
51
        // add a value
52
        s1.add(1.0, 0.5, 1.5, 2.0);
52
        s1.add(1.0, 0.5, 1.5, 2.0);
53
        assertFalse(s1.equals(s2));
53
        assertFalse(s1.equals(s2));
54
        s2.add(1.0, 0.5, 1.5, 2.0);
54
        s2.add(1.0, 0.5, 1.5, 2.0);
55
        assertTrue(s2.equals(s1));
55
        assertTrue(s2.equals(s1));
56
        // add another value
56
        // add another value
57
        s1.add(2.0, 0.5, 1.5, 2.0);
57
        s1.add(2.0, 0.5, 1.5, 2.0);
58
        assertFalse(s1.equals(s2));
58
        assertFalse(s1.equals(s2));
59
        s2.add(2.0, 0.5, 1.5, 2.0);
59
        s2.add(2.0, 0.5, 1.5, 2.0);
60
        assertTrue(s2.equals(s1));
60
        assertTrue(s2.equals(s1));
61
        // remove a value
61
        // remove a value
62
        s1.remove(new XYCoordinate(1.0, 0.5));
62
        s1.remove(new Double(1.0));
63
        assertFalse(s1.equals(s2));
63
        assertFalse(s1.equals(s2));
64
        s2.remove(new XYCoordinate(1.0, 0.5));
64
        s2.remove(new Double(1.0));
65
        assertTrue(s2.equals(s1));
65
        assertTrue(s2.equals(s1));
66
        
66
        
67
    }
67
    }
68
    /**
68
    /**
69
     * Confirm that cloning works.
69
     * Confirm that cloning works.
70
     */
70
     */
71
    public void testCloning() {
71
    public void testCloning() {
72
        VectorSeries s1 = new VectorSeries("s1");
72
        YIntervalSeries s1 = new YIntervalSeries("s1");
73
        s1.add(1.0, 0.5, 1.5, 2.0);
73
        s1.add(1.0, 0.5, 1.5, 2.0);
74
        VectorSeries s2 = null;
74
        YIntervalSeries s2 = null;
75
        try {
75
        try {
76
            s2 = (VectorSeries) s1.clone();
76
            s2 = (YIntervalSeries) s1.clone();
77
        }
77
        }
78
        catch (CloneNotSupportedException e) {
78
        catch (CloneNotSupportedException e) {
79
            e.printStackTrace();
79
            e.printStackTrace();
80
        }
80
        }
81
        assertTrue(s1 != s2);
81
        assertTrue(s1 != s2);
82
        assertTrue(s1.getClass() == s2.getClass());
82
        assertTrue(s1.getClass() == s2.getClass());
83
        assertTrue(s1.equals(s2));
83
        assertTrue(s1.equals(s2));
84
    }
84
    }
85
    /**
85
    /**
86
     * Serialize an instance, restore it, and check for equality.
86
     * Serialize an instance, restore it, and check for equality.
87
     */
87
     */
88
    public void testSerialization() {
88
    public void testSerialization() {
89
        VectorSeries s1 = new VectorSeries("s1");
89
        YIntervalSeries s1 = new YIntervalSeries("s1");
90
        s1.add(1.0, 0.5, 1.5, 2.0);
90
        s1.add(1.0, 0.5, 1.5, 2.0);
91
        VectorSeries s2 = null;
91
        YIntervalSeries s2 = null;
92
        
92
        
93
        try {
93
        try {
94
            ByteArrayOutputStream buffer = new ByteArrayOutputStream();
94
            ByteArrayOutputStream buffer = new ByteArrayOutputStream();
95
            ObjectOutput out = new ObjectOutputStream(buffer);
95
            ObjectOutput out = new ObjectOutputStream(buffer);
96
            out.writeObject(s1);
96
            out.writeObject(s1);
97
            out.close();
97
            out.close();
98
            ObjectInput in = new ObjectInputStream(
98
            ObjectInput in = new ObjectInputStream(
99
                    new ByteArrayInputStream(buffer.toByteArray()));
99
                    new ByteArrayInputStream(buffer.toByteArray()));
100
            s2 = (VectorSeries) in.readObject();
100
            s2 = (YIntervalSeries) in.readObject();
101
            in.close();
101
            in.close();
102
        }
102
        }
103
        catch (Exception e) {
103
        catch (Exception e) {
104
            e.printStackTrace();
104
            e.printStackTrace();
105
        }
105
        }
106
        assertEquals(s1, s2);
106
        assertEquals(s1, s2);
107
    }
107
    }
108
    
108
    
109
    /**
109
    /**
110
     * Simple test for the indexOf() method.
110
     * Simple test for the indexOf() method.
111
     */
111
     */
112
    public void testIndexOf() {
112
    public void testIndexOf() {
113
        VectorSeries s1 = new VectorSeries("Series 1");
113
        YIntervalSeries s1 = new YIntervalSeries("Series 1");
114
        s1.add(1.0, 1.0, 1.0, 2.0);
114
        s1.add(1.0, 1.0, 1.0, 2.0);
115
        s1.add(2.0, 2.0, 2.0, 3.0);
115
        s1.add(2.0, 2.0, 2.0, 3.0);
116
        s1.add(3.0, 3.0, 3.0, 4.0);
116
        s1.add(3.0, 3.0, 3.0, 4.0);
117
        assertEquals(0, s1.indexOf(new XYCoordinate(1.0, 1.0)));
117
        assertEquals(0, s1.indexOf(new Double(1.0)));
118
    }
118
    }
119
    
119
    
120
    /**
120
    /**
121
     * A check for the indexOf() method for an unsorted series.
121
     * A check for the indexOf() method for an unsorted series.
122
     */
122
     */
123
    public void testIndexOf2() {
123
    public void testIndexOf2() {
124
        VectorSeries s1 = new VectorSeries("Series 1");
124
        YIntervalSeries s1 = new YIntervalSeries("Series 1", false, true);
125
        s1.add(1.0, 1.0, 1.0, 2.0);
125
        s1.add(1.0, 1.0, 1.0, 2.0);
126
        s1.add(3.0, 3.0, 3.0, 3.0);
126
        s1.add(3.0, 3.0, 3.0, 3.0);
127
        s1.add(2.0, 2.0, 2.0, 2.0);
127
        s1.add(2.0, 2.0, 2.0, 2.0);
128
        assertEquals(0, s1.indexOf(new XYCoordinate(1.0, 1.0)));        
128
        assertEquals(0, s1.indexOf(new Double(1.0)));        
129
        assertEquals(1, s1.indexOf(new XYCoordinate(3.0, 3.0)));        
129
        assertEquals(1, s1.indexOf(new Double(3.0)));        
130
        assertEquals(2, s1.indexOf(new XYCoordinate(2.0, 2.0)));        
130
        assertEquals(2, s1.indexOf(new Double(2.0)));        
131
    }
131
    }
132
    /**
132
    /**
133
     * Simple test for the remove() method.
133
     * Simple test for the remove() method.
134
     */
134
     */
135
    public void testRemove() {
135
    public void testRemove() {
136
        VectorSeries s1 = new VectorSeries("Series 1");
136
        YIntervalSeries s1 = new YIntervalSeries("Series 1");
137
        s1.add(1.0, 1.0, 1.0, 2.0);
137
        s1.add(1.0, 1.0, 1.0, 2.0);
138
        s1.add(3.0, 3.0, 3.0, 3.0);
138
        s1.add(2.0, 2.0, 2.0, 2.0);
139
        s1.add(2.0, 2.0, 2.0, 2.0);
139
        s1.add(3.0, 3.0, 3.0, 3.0);
140
        assertEquals(3, s1.getItemCount());
140
        assertEquals(3, s1.getItemCount());
141
        
141
        
142
        s1.remove(new XYCoordinate(2.0, 2.0));
142
        s1.remove(new Double(2.0));
143
        assertEquals(3.0, s1.getXValue(1), EPSILON);
143
        assertEquals(new Double(3.0), s1.getX(1));
144
        
144
        
145
        s1.remove(new XYCoordinate(1.0, 1.0));
145
        s1.remove(new Double(1.0));
146
        assertEquals(3.0, s1.getXValue(0), EPSILON);    
146
        assertEquals(new Double(3.0), s1.getX(0));    
147
    }
147
    }
148
    private static final double EPSILON = 0.0000000001;
148
    private static final double EPSILON = 0.0000000001;
149
    
149
    
150
    /**
150
    /**
151
     * When items are added with duplicate x-values, we expect them to remain 
151
     * When items are added with duplicate x-values, we expect them to remain 
152
     * in the order they were added.
152
     * in the order they were added.
153
     */
153
     */
154
    public void testAdditionOfDuplicateXValues() {
154
    public void testAdditionOfDuplicateXValues() {
155
        VectorSeries s1 = new VectorSeries("Series 1");
155
        YIntervalSeries s1 = new YIntervalSeries("Series 1");
156
        s1.add(1.0, 1.0, 1.0, 1.0);
156
        s1.add(1.0, 1.0, 1.0, 1.0);
157
        s1.add(2.0, 2.0, 2.0, 2.0);
157
        s1.add(2.0, 2.0, 2.0, 2.0);
158
        s1.add(2.0, 2.0, 3.0, 3.0);
158
        s1.add(2.0, 3.0, 3.0, 3.0);
159
        s1.add(2.0, 3.0, 4.0, 4.0);
159
        s1.add(2.0, 4.0, 4.0, 4.0);
160
        s1.add(3.0, 5.0, 5.0, 5.0);
160
        s1.add(3.0, 5.0, 5.0, 5.0);
161
        assertEquals(1.0, s1.getVectorXValue(0), EPSILON);
161
        assertEquals(1.0, s1.getYValue(0), EPSILON);
162
        assertEquals(2.0, s1.getVectorXValue(1), EPSILON);
162
        assertEquals(2.0, s1.getYValue(1), EPSILON);
163
        assertEquals(3.0, s1.getVectorXValue(2), EPSILON);
163
        assertEquals(3.0, s1.getYValue(2), EPSILON);
164
        assertEquals(4.0, s1.getVectorXValue(3), EPSILON);
164
        assertEquals(4.0, s1.getYValue(3), EPSILON);
165
        assertEquals(5.0, s1.getVectorXValue(4), EPSILON);
165
        assertEquals(5.0, s1.getYValue(4), EPSILON);
166
    }
166
    }
167
    
167
    
168
    /**
168
    /**
169
     * Some checks for the add() method for an UNSORTED series.
169
     * Some checks for the add() method for an UNSORTED series.
170
     */
170
     */
171
    public void testAdd() {
171
    public void testAdd() {
172
        VectorSeries series = new VectorSeries("Series", false, true);
172
        YIntervalSeries series = new YIntervalSeries("Series", false, true);
173
        series.add(5.0, 5.50, 5.50, 5.50);
173
        series.add(5.0, 5.50, 5.50, 5.50);
174
        series.add(5.1, 5.51, 5.51, 5.51);
174
        series.add(5.1, 5.51, 5.51, 5.51);
175
        series.add(6.0, 6.6, 6.6, 6.6);
175
        series.add(6.0, 6.6, 6.6, 6.6);
176
        series.add(3.0, 3.3, 3.3, 3.3);
176
        series.add(3.0, 3.3, 3.3, 3.3);
177
        series.add(4.0, 4.4, 4.4, 4.4);
177
        series.add(4.0, 4.4, 4.4, 4.4);
178
        series.add(2.0, 2.2, 2.2, 2.2);
178
        series.add(2.0, 2.2, 2.2, 2.2);
179
        series.add(1.0, 1.1, 1.1, 1.1);
179
        series.add(1.0, 1.1, 1.1, 1.1);
180
        assertEquals(5.5, series.getVectorXValue(0), EPSILON);
180
        assertEquals(5.5, series.getYValue(0), EPSILON);
181
        assertEquals(5.51, series.getVectorXValue(1), EPSILON);
181
        assertEquals(5.51, series.getYValue(1), EPSILON);
182
        assertEquals(6.6, series.getVectorXValue(2), EPSILON);
182
        assertEquals(6.6, series.getYValue(2), EPSILON);
183
        assertEquals(3.3, series.getVectorXValue(3), EPSILON);
183
        assertEquals(3.3, series.getYValue(3), EPSILON);
184
        assertEquals(4.4, series.getVectorXValue(4), EPSILON);
184
        assertEquals(4.4, series.getYValue(4), EPSILON);
185
        assertEquals(2.2, series.getVectorXValue(5), EPSILON);
185
        assertEquals(2.2, series.getYValue(5), EPSILON);
186
        assertEquals(1.1, series.getVectorXValue(6), EPSILON);
186
        assertEquals(1.1, series.getYValue(6), EPSILON);
187
    }
187
    }
188
    
188
    
189
    /**
189
    /**
190
     * A simple check that the maximumItemCount attribute is working.
190
     * A simple check that the maximumItemCount attribute is working.
191
     */
191
     */
192
    public void testSetMaximumItemCount() {
192
    public void testSetMaximumItemCount() {
193
        VectorSeries s1 = new VectorSeries("S1");
193
        YIntervalSeries s1 = new YIntervalSeries("S1");
194
        assertEquals(Integer.MAX_VALUE, s1.getMaximumItemCount());
194
        assertEquals(Integer.MAX_VALUE, s1.getMaximumItemCount());
195
        s1.setMaximumItemCount(2);
195
        s1.setMaximumItemCount(2);
196
        assertEquals(2, s1.getMaximumItemCount());
196
        assertEquals(2, s1.getMaximumItemCount());
197
        s1.add(1.0, 1.1, 1.1, 1.1);
197
        s1.add(1.0, 1.1, 1.1, 1.1);
198
        s1.add(2.0, 2.2, 2.2, 2.2);
198
        s1.add(2.0, 2.2, 2.2, 2.2);
199
        s1.add(3.0, 3.3, 3.3, 3.3);
199
        s1.add(3.0, 3.3, 3.3, 3.3);
200
        assertEquals(2.0, s1.getXValue(0), EPSILON);
200
        assertEquals(2.0, s1.getX(0).doubleValue(), EPSILON);
201
        assertEquals(3.0, s1.getXValue(1), EPSILON);
201
        assertEquals(3.0, s1.getX(1).doubleValue(), EPSILON);
202
    }
202
    }
203
    
203
    
204
    /**
204
    /**
205
     * Check that the maximum item count can be applied retrospectively.
205
     * Check that the maximum item count can be applied retrospectively.
206
     */
206
     */
207
    public void testSetMaximumItemCount2() {
207
    public void testSetMaximumItemCount2() {
208
        VectorSeries s1 = new VectorSeries("S1");
208
        YIntervalSeries s1 = new YIntervalSeries("S1");
209
        s1.add(1.0, 1.1, 1.1, 1.1);
209
        s1.add(1.0, 1.1, 1.1, 1.1);
210
        s1.add(2.0, 2.2, 2.2, 2.2);
210
        s1.add(2.0, 2.2, 2.2, 2.2);
211
        s1.add(3.0, 3.3, 3.3, 3.3);
211
        s1.add(3.0, 3.3, 3.3, 3.3);
212
        s1.setMaximumItemCount(2);
212
        s1.setMaximumItemCount(2);
213
        assertEquals(2.0, s1.getXValue(0), EPSILON);
213
        assertEquals(2.0, s1.getX(0).doubleValue(), EPSILON);
214
        assertEquals(3.0, s1.getXValue(1), EPSILON);
214
        assertEquals(3.0, s1.getX(1).doubleValue(), EPSILON);
215
    }
215
    }
216
    
216
    
217
    /**
217
    /**
218
     * Some checks for the clear() method.
218
     * Some checks for the clear() method.
219
     */
219
     */
220
    public void testClear() {
220
    public void testClear() {
221
        VectorSeries s1 = new VectorSeries("S1");
221
        YIntervalSeries s1 = new YIntervalSeries("S1");
222
        s1.addChangeListener(this);
222
        s1.addChangeListener(this);
223
        s1.clear();
223
        s1.clear();
224
        assertNull(this.lastEvent);
224
        assertNull(this.lastEvent);
225
        assertTrue(s1.isEmpty());
225
        assertTrue(s1.isEmpty());
226
        s1.add(1.0, 2.0, 3.0, 4.0);
226
        s1.add(1.0, 2.0, 3.0, 4.0);
227
        assertFalse(s1.isEmpty());
227
        assertFalse(s1.isEmpty());
228
        s1.clear();
228
        s1.clear();
229
        assertNotNull(this.lastEvent);
229
        assertNotNull(this.lastEvent);
230
        assertTrue(s1.isEmpty())
230
        assertTrue(s1.isEmpty())
Summary
Number of common nesting structure subtrees0
Number of refactorable cases0
Number of non-refactorable cases0
Time elapsed for finding largest common nesting structure subtrees (ms)0.0
Clones location
Number of node comparisons0