org.jfree.data.KeyToGroupMap Java Examples

/**
 * Test that the equals() method distinguishes all fields.
 */
@Test
public void testEquals() {
    GroupedStackedBarRenderer r1 = new GroupedStackedBarRenderer();
    GroupedStackedBarRenderer r2 = new GroupedStackedBarRenderer();
    assertTrue(r1.equals(r2));
    assertTrue(r2.equals(r1));

    // map
    KeyToGroupMap m1 = new KeyToGroupMap("G1");
    m1.mapKeyToGroup("S1", "G2");
    r1.setSeriesToGroupMap(m1);
    assertFalse(r1.equals(r2));
    KeyToGroupMap m2 = new KeyToGroupMap("G1");
    m2.mapKeyToGroup("S1", "G2");
    r2.setSeriesToGroupMap(m2);
    assertTrue(r1.equals(r2));
}
 

/**
 * Tests the getGroup() method.
 */
public void testGetGroup() {
    KeyToGroupMap m1 = new KeyToGroupMap("Default Group");

    // a key that hasn't been mapped should return the default group
    assertEquals("Default Group", m1.getGroup("K1"));

    m1.mapKeyToGroup("K1", "G1");
    assertEquals("G1", m1.getGroup("K1"));
    m1.mapKeyToGroup("K1", "G2");
    assertEquals("G2", m1.getGroup("K1"));
    m1.mapKeyToGroup("K1", null);
    assertEquals("Default Group", m1.getGroup("K1"));

    // a null argument should throw an exception
    boolean pass = false;
    try {
        Comparable g = m1.getGroup(null);
        System.out.println(g);
    }
    catch (IllegalArgumentException e) {
        pass = true;
    }
    assertTrue(pass);
}
 

/**
 * Test that the equals() method distinguishes all fields.
 */
public void testEquals() {
    GroupedStackedBarRenderer r1 = new GroupedStackedBarRenderer();
    GroupedStackedBarRenderer r2 = new GroupedStackedBarRenderer();
    assertTrue(r1.equals(r2));
    assertTrue(r2.equals(r1));
    
    // map
    KeyToGroupMap m1 = new KeyToGroupMap("G1");
    m1.mapKeyToGroup("S1", "G2");
    r1.setSeriesToGroupMap(m1);
    assertFalse(r1.equals(r2));
    KeyToGroupMap m2 = new KeyToGroupMap("G1");
    m2.mapKeyToGroup("S1", "G2");
    r2.setSeriesToGroupMap(m2);
    assertTrue(r1.equals(r2));
}
 

/**
 * Tests the getGroupIndex() method.
 */
public void testGetGroupIndex() {
    KeyToGroupMap m1 = new KeyToGroupMap("Default Group");

    // the default group is always at index 0
    assertEquals(0, m1.getGroupIndex("Default Group"));

    // a non-existent group should return -1
    assertEquals(-1, m1.getGroupIndex("G3"));

    // indices are assigned in the order that groups are originally mapped
    m1.mapKeyToGroup("K3", "G3");
    m1.mapKeyToGroup("K1", "G1");
    m1.mapKeyToGroup("K2", "G2");
    assertEquals(1, m1.getGroupIndex("G3"));
    assertEquals(2, m1.getGroupIndex("G1"));
    assertEquals(3, m1.getGroupIndex("G2"));
}
 

/**
 * Test that the equals() method distinguishes all fields.
 */
@Test
public void testEquals() {
    GroupedStackedBarRenderer r1 = new GroupedStackedBarRenderer();
    GroupedStackedBarRenderer r2 = new GroupedStackedBarRenderer();
    assertTrue(r1.equals(r2));
    assertTrue(r2.equals(r1));

    // map
    KeyToGroupMap m1 = new KeyToGroupMap("G1");
    m1.mapKeyToGroup("S1", "G2");
    r1.setSeriesToGroupMap(m1);
    assertFalse(r1.equals(r2));
    KeyToGroupMap m2 = new KeyToGroupMap("G1");
    m2.mapKeyToGroup("S1", "G2");
    r2.setSeriesToGroupMap(m2);
    assertTrue(r1.equals(r2));
}
 

/**
 * Tests the getGroupIndex() method.
 */
public void testGetGroupIndex() {
    KeyToGroupMap m1 = new KeyToGroupMap("Default Group");
   
    // the default group is always at index 0
    assertEquals(0, m1.getGroupIndex("Default Group"));
    
    // a non-existent group should return -1
    assertEquals(-1, m1.getGroupIndex("G3"));
    
    // indices are assigned in the order that groups are originally mapped
    m1.mapKeyToGroup("K3", "G3");
    m1.mapKeyToGroup("K1", "G1");
    m1.mapKeyToGroup("K2", "G2");
    assertEquals(1, m1.getGroupIndex("G3"));
    assertEquals(2, m1.getGroupIndex("G1"));
    assertEquals(3, m1.getGroupIndex("G2"));
}
 

/**
 * Tests the getGroup() method.
 */
public void testGetGroup() {
    KeyToGroupMap m1 = new KeyToGroupMap("Default Group");
    
    // a key that hasn't been mapped should return the default group
    assertEquals("Default Group", m1.getGroup("K1"));
    
    m1.mapKeyToGroup("K1", "G1");
    assertEquals("G1", m1.getGroup("K1"));
    m1.mapKeyToGroup("K1", "G2");
    assertEquals("G2", m1.getGroup("K1"));
    m1.mapKeyToGroup("K1", null);
    assertEquals("Default Group", m1.getGroup("K1"));
    
    // a null argument should throw an exception
    boolean pass = false;
    try {
        Comparable g = m1.getGroup(null); 
        System.out.println(g);
    }
    catch (IllegalArgumentException e) {
        pass = true;   
    }
    assertTrue(pass);
}
 

/**
 * Test that the equals() method distinguishes all fields.
 */
@Test
public void testEquals() {
    GroupedStackedBarRenderer r1 = new GroupedStackedBarRenderer();
    GroupedStackedBarRenderer r2 = new GroupedStackedBarRenderer();
    assertTrue(r1.equals(r2));
    assertTrue(r2.equals(r1));

    // map
    KeyToGroupMap m1 = new KeyToGroupMap("G1");
    m1.mapKeyToGroup("S1", "G2");
    r1.setSeriesToGroupMap(m1);
    assertFalse(r1.equals(r2));
    KeyToGroupMap m2 = new KeyToGroupMap("G1");
    m2.mapKeyToGroup("S1", "G2");
    r2.setSeriesToGroupMap(m2);
    assertTrue(r1.equals(r2));
}
 

/**
 * Test that the equals() method distinguishes all fields.
 */
@Test
public void testEquals() {
    GroupedStackedBarRenderer r1 = new GroupedStackedBarRenderer();
    GroupedStackedBarRenderer r2 = new GroupedStackedBarRenderer();
    assertTrue(r1.equals(r2));
    assertTrue(r2.equals(r1));

    // map
    KeyToGroupMap m1 = new KeyToGroupMap("G1");
    m1.mapKeyToGroup("S1", "G2");
    r1.setSeriesToGroupMap(m1);
    assertFalse(r1.equals(r2));
    KeyToGroupMap m2 = new KeyToGroupMap("G1");
    m2.mapKeyToGroup("S1", "G2");
    r2.setSeriesToGroupMap(m2);
    assertTrue(r1.equals(r2));
}
 

/**
 * Test that the equals() method distinguishes all fields.
 */
public void testEquals() {
    GroupedStackedBarRenderer r1 = new GroupedStackedBarRenderer();
    GroupedStackedBarRenderer r2 = new GroupedStackedBarRenderer();
    assertTrue(r1.equals(r2));
    assertTrue(r2.equals(r1));

    // map
    KeyToGroupMap m1 = new KeyToGroupMap("G1");
    m1.mapKeyToGroup("S1", "G2");
    r1.setSeriesToGroupMap(m1);
    assertFalse(r1.equals(r2));
    KeyToGroupMap m2 = new KeyToGroupMap("G1");
    m2.mapKeyToGroup("S1", "G2");
    r2.setSeriesToGroupMap(m2);
    assertTrue(r1.equals(r2));
}
 

/**
 * Test that the equals() method distinguishes all fields.
 */
@Test
public void testEquals() {
    GroupedStackedBarRenderer r1 = new GroupedStackedBarRenderer();
    GroupedStackedBarRenderer r2 = new GroupedStackedBarRenderer();
    assertTrue(r1.equals(r2));
    assertTrue(r2.equals(r1));

    // map
    KeyToGroupMap m1 = new KeyToGroupMap("G1");
    m1.mapKeyToGroup("S1", "G2");
    r1.setSeriesToGroupMap(m1);
    assertFalse(r1.equals(r2));
    KeyToGroupMap m2 = new KeyToGroupMap("G1");
    m2.mapKeyToGroup("S1", "G2");
    r2.setSeriesToGroupMap(m2);
    assertTrue(r1.equals(r2));
}
 

/**
 * Tests the stacked range extent calculation.
 */
public void testStackedRangeWithMap() {
    CategoryDataset d = createCategoryDataset1();
    KeyToGroupMap map = new KeyToGroupMap("G0");
    map.mapKeyToGroup("R2", "G1");
    Range r = DatasetUtilities.findStackedRangeBounds(d, map);
    assertEquals(0.0, r.getLowerBound(), EPSILON);
    assertEquals(9.0, r.getUpperBound(), EPSILON);        
}
 

/**
 * Updates the map used to assign each series to a group, and sends a
 * {@link RendererChangeEvent} to all registered listeners.
 *
 * @param map  the map (<code>null</code> not permitted).
 */
public void setSeriesToGroupMap(KeyToGroupMap map) {
    if (map == null) {
        throw new IllegalArgumentException("Null 'map' argument.");
    }
    this.seriesToGroupMap = map;
    fireChangeEvent();
}
 

/**
 * Confirm that the equals method can distinguish all the required fields.
 */
public void testEquals() {
    KeyToGroupMap m1 = new KeyToGroupMap("Default Group");
    KeyToGroupMap m2 = new KeyToGroupMap("Default Group");
    assertTrue(m1.equals(m2));
    assertTrue(m2.equals(m1));

    m1.mapKeyToGroup("K1", "G1");
    assertFalse(m1.equals(m2));
    m2.mapKeyToGroup("K1", "G1");
    assertTrue(m1.equals(m2));
}
 

/**
 * Tests the mapKeyToGroup() method.
 */
public void testMapKeyToGroup() {
    KeyToGroupMap m1 = new KeyToGroupMap("G1");
    
    // map a key to the default group
    m1.mapKeyToGroup("K1", "G1");
    assertEquals("G1", m1.getGroup("K1"));
    
    // map a key to a new group
    m1.mapKeyToGroup("K2", "G2");
    assertEquals("G2", m1.getGroup("K2"));
    
    // clear a mapping
    m1.mapKeyToGroup("K2", null);
    assertEquals("G1", m1.getGroup("K2"));  // after clearing, reverts to 
                                            // default group
    
    // check handling of null key
    boolean pass = false;
    try {
        m1.mapKeyToGroup(null, "G1");   
    }
    catch (IllegalArgumentException e) {
        pass = true;   
    }
    assertTrue(pass);
}
 

/**
 * Updates the map used to assign each series to a group, and sends a 
 * {@link RendererChangeEvent} to all registered listeners.
 * 
 * @param map  the map (<code>null</code> not permitted).
 */
public void setSeriesToGroupMap(KeyToGroupMap map) {
    if (map == null) {
        throw new IllegalArgumentException("Null 'map' argument.");   
    }
    this.seriesToGroupMap = map;   
    fireChangeEvent();
}
 

/**
 * Updates the map used to assign each series to a group.
 * 
 * @param map  the map (<code>null</code> not permitted).
 */
public void setSeriesToGroupMap(KeyToGroupMap map) {
    if (map == null) {
        throw new IllegalArgumentException("Null 'map' argument.");   
    }
    this.seriesToGroupMap = map;   
    notifyListeners(new RendererChangeEvent(this));
}
 

/**
 * Tests the stacked range extent calculation.
 */
@Test
public void testStackedRangeWithMap() {
    CategoryDataset d = createCategoryDataset1();
    KeyToGroupMap map = new KeyToGroupMap("G0");
    map.mapKeyToGroup("R2", "G1");
    Range r = DatasetUtilities.findStackedRangeBounds(d, map);
    assertEquals(0.0, r.getLowerBound(), EPSILON);
    assertEquals(9.0, r.getUpperBound(), EPSILON);
}
 

/**
 * Tests that the getGroupCount() method returns the correct values under 
 * various circumstances.
 */
public void testGroupCount() {
    KeyToGroupMap m1 = new KeyToGroupMap("Default Group");
    
    // a new map always has 1 group (the default group)
    assertEquals(1, m1.getGroupCount());
    
    // if the default group is not mapped to, it should still count towards
    // the group count...
    m1.mapKeyToGroup("C1", "G1");
    assertEquals(2, m1.getGroupCount());
    
    // now when the default group is mapped to, it shouldn't increase the
    // group count...
    m1.mapKeyToGroup("C2", "Default Group");
    assertEquals(2, m1.getGroupCount());

    // complicate things a little...
    m1.mapKeyToGroup("C3", "Default Group");
    m1.mapKeyToGroup("C4", "G2");
    m1.mapKeyToGroup("C5", "G2");
    m1.mapKeyToGroup("C6", "Default Group");
    assertEquals(3, m1.getGroupCount());
    
    // now overwrite group "G2"...
    m1.mapKeyToGroup("C4", "G1");
    m1.mapKeyToGroup("C5", "G1");
    assertEquals(2, m1.getGroupCount()); 
}
 

/**
 * Some checks for the findRangeBounds() method.
 */
@Test
public void testFindRangeBounds() {
    GroupedStackedBarRenderer r = new GroupedStackedBarRenderer();
    assertNull(r.findRangeBounds(null));

    // an empty dataset should return a null range
    DefaultCategoryDataset dataset = new DefaultCategoryDataset();
    assertNull(r.findRangeBounds(dataset));

    dataset.addValue(1.0, "R1", "C1");
    assertEquals(new Range(0.0, 1.0), r.findRangeBounds(dataset));

    dataset.addValue(-2.0, "R1", "C2");
    assertEquals(new Range(-2.0, 1.0), r.findRangeBounds(dataset));

    dataset.addValue(null, "R1", "C3");
    assertEquals(new Range(-2.0, 1.0), r.findRangeBounds(dataset));

    KeyToGroupMap m = new KeyToGroupMap("G1");
    m.mapKeyToGroup("R1", "G1");
    m.mapKeyToGroup("R2", "G1");
    m.mapKeyToGroup("R3", "G2");
    r.setSeriesToGroupMap(m);

    dataset.addValue(0.5, "R3", "C1");
    assertEquals(new Range(-2.0, 1.0), r.findRangeBounds(dataset));

    dataset.addValue(5.0, "R3", "C2");
    assertEquals(new Range(-2.0, 5.0), r.findRangeBounds(dataset));
}
 

/**
 * Some checks for the findStackedRangeBounds(CategoryDataset,
 * KeyToGroupMap) method.
 */
@Test
public void testFindStackedRangeBounds_CategoryDataset3() {
    DefaultCategoryDataset dataset = new DefaultCategoryDataset();
    KeyToGroupMap map = new KeyToGroupMap("Group A");
    Range r = DatasetUtilities.findStackedRangeBounds(dataset, map);
    assertTrue(r == null);

    dataset.addValue(1.0, "R1", "C1");
    dataset.addValue(2.0, "R2", "C1");
    dataset.addValue(3.0, "R3", "C1");
    dataset.addValue(4.0, "R4", "C1");

    map.mapKeyToGroup("R1", "Group A");
    map.mapKeyToGroup("R2", "Group A");
    map.mapKeyToGroup("R3", "Group B");
    map.mapKeyToGroup("R4", "Group B");

    r = DatasetUtilities.findStackedRangeBounds(dataset, map);
    assertEquals(0.0, r.getLowerBound(), EPSILON);
    assertEquals(7.0, r.getUpperBound(), EPSILON);

    dataset.addValue(null, "R5", "C1");
    r = DatasetUtilities.findStackedRangeBounds(dataset, map);
    assertEquals(0.0, r.getLowerBound(), EPSILON);
    assertEquals(7.0, r.getUpperBound(), EPSILON);

    dataset.addValue(Double.NaN, "R6", "C1");
    r = DatasetUtilities.findStackedRangeBounds(dataset, map);
    assertEquals(0.0, r.getLowerBound(), EPSILON);
    assertEquals(7.0, r.getUpperBound(), EPSILON);
}
 

/**
 * Tests the stacked range extent calculation.
 */
@Test
public void testStackedRangeWithMap() {
    CategoryDataset d = createCategoryDataset1();
    KeyToGroupMap map = new KeyToGroupMap("G0");
    map.mapKeyToGroup("R2", "G1");
    Range r = DatasetUtilities.findStackedRangeBounds(d, map);
    assertEquals(0.0, r.getLowerBound(), EPSILON);
    assertEquals(9.0, r.getUpperBound(), EPSILON);
}
 

/**
 * Confirm that the equals method can distinguish all the required fields.
 */
public void testEquals() {     
    KeyToGroupMap m1 = new KeyToGroupMap("Default Group");
    KeyToGroupMap m2 = new KeyToGroupMap("Default Group");
    assertTrue(m1.equals(m2));
    assertTrue(m2.equals(m1));
    
    m1.mapKeyToGroup("K1", "G1");
    assertFalse(m1.equals(m2));
    m2.mapKeyToGroup("K1", "G1");
    assertTrue(m1.equals(m2));
}
 

/**
 * Tests that the getKeyCount() method returns the correct values under
 * various circumstances.
 */
public void testKeyCount() {
    KeyToGroupMap m1 = new KeyToGroupMap("Default Group");

    // a new map always has 1 group (the default group)
    assertEquals(0, m1.getKeyCount("Default Group"));

    // simple case
    m1.mapKeyToGroup("K1", "G1");
    assertEquals(1, m1.getKeyCount("G1"));
    m1.mapKeyToGroup("K1", null);
    assertEquals(0, m1.getKeyCount("G1"));

    // if there is an explicit mapping to the default group, it is counted
    m1.mapKeyToGroup("K2", "Default Group");
    assertEquals(1, m1.getKeyCount("Default Group"));

    // complicate things a little...
    m1.mapKeyToGroup("K3", "Default Group");
    m1.mapKeyToGroup("K4", "G2");
    m1.mapKeyToGroup("K5", "G2");
    m1.mapKeyToGroup("K6", "Default Group");
    assertEquals(3, m1.getKeyCount("Default Group"));
    assertEquals(2, m1.getKeyCount("G2"));

    // now overwrite group "G2"...
    m1.mapKeyToGroup("K4", "G1");
    m1.mapKeyToGroup("K5", "G1");
    assertEquals(2, m1.getKeyCount("G1"));
    assertEquals(0, m1.getKeyCount("G2"));
}
 

/**
 * Tests that the getGroupCount() method returns the correct values under
 * various circumstances.
 */
public void testGroupCount() {
    KeyToGroupMap m1 = new KeyToGroupMap("Default Group");

    // a new map always has 1 group (the default group)
    assertEquals(1, m1.getGroupCount());

    // if the default group is not mapped to, it should still count towards
    // the group count...
    m1.mapKeyToGroup("C1", "G1");
    assertEquals(2, m1.getGroupCount());

    // now when the default group is mapped to, it shouldn't increase the
    // group count...
    m1.mapKeyToGroup("C2", "Default Group");
    assertEquals(2, m1.getGroupCount());

    // complicate things a little...
    m1.mapKeyToGroup("C3", "Default Group");
    m1.mapKeyToGroup("C4", "G2");
    m1.mapKeyToGroup("C5", "G2");
    m1.mapKeyToGroup("C6", "Default Group");
    assertEquals(3, m1.getGroupCount());

    // now overwrite group "G2"...
    m1.mapKeyToGroup("C4", "G1");
    m1.mapKeyToGroup("C5", "G1");
    assertEquals(2, m1.getGroupCount());
}
 

/**
 * Tests the mapKeyToGroup() method.
 */
public void testMapKeyToGroup() {
    KeyToGroupMap m1 = new KeyToGroupMap("G1");

    // map a key to the default group
    m1.mapKeyToGroup("K1", "G1");
    assertEquals("G1", m1.getGroup("K1"));

    // map a key to a new group
    m1.mapKeyToGroup("K2", "G2");
    assertEquals("G2", m1.getGroup("K2"));

    // clear a mapping
    m1.mapKeyToGroup("K2", null);
    assertEquals("G1", m1.getGroup("K2"));  // after clearing, reverts to
                                            // default group

    // check handling of null key
    boolean pass = false;
    try {
        m1.mapKeyToGroup(null, "G1");
    }
    catch (IllegalArgumentException e) {
        pass = true;
    }
    assertTrue(pass);
}
 

/**
 * Tests the stacked range extent calculation.
 */
public void testStackedRangeWithMap() {
    CategoryDataset d = createCategoryDataset1();
    KeyToGroupMap map = new KeyToGroupMap("G0");
    map.mapKeyToGroup("R2", "G1");
    Range r = DatasetUtilities.findStackedRangeBounds(d, map);
    assertEquals(0.0, r.getLowerBound(), EPSILON);
    assertEquals(9.0, r.getUpperBound(), EPSILON);
}
 

/**
 * Some checks for the findStackedRangeBounds(CategoryDataset,
 * KeyToGroupMap) method.
 */
public void testFindStackedRangeBounds_CategoryDataset3() {
    DefaultCategoryDataset dataset = new DefaultCategoryDataset();
    KeyToGroupMap map = new KeyToGroupMap("Group A");
    Range r = DatasetUtilities.findStackedRangeBounds(dataset, map);
    assertTrue(r == null);

    dataset.addValue(1.0, "R1", "C1");
    dataset.addValue(2.0, "R2", "C1");
    dataset.addValue(3.0, "R3", "C1");
    dataset.addValue(4.0, "R4", "C1");

    map.mapKeyToGroup("R1", "Group A");
    map.mapKeyToGroup("R2", "Group A");
    map.mapKeyToGroup("R3", "Group B");
    map.mapKeyToGroup("R4", "Group B");

    r = DatasetUtilities.findStackedRangeBounds(dataset, map);
    assertEquals(0.0, r.getLowerBound(), EPSILON);
    assertEquals(7.0, r.getUpperBound(), EPSILON);

    dataset.addValue(null, "R5", "C1");
    r = DatasetUtilities.findStackedRangeBounds(dataset, map);
    assertEquals(0.0, r.getLowerBound(), EPSILON);
    assertEquals(7.0, r.getUpperBound(), EPSILON);

    dataset.addValue(Double.NaN, "R6", "C1");
    r = DatasetUtilities.findStackedRangeBounds(dataset, map);
    assertEquals(0.0, r.getLowerBound(), EPSILON);
    assertEquals(7.0, r.getUpperBound(), EPSILON);
}
 

/**
 * Some checks for the findRangeBounds() method.
 */
public void testFindRangeBounds() {
    GroupedStackedBarRenderer r = new GroupedStackedBarRenderer();
    assertNull(r.findRangeBounds(null));

    // an empty dataset should return a null range
    DefaultCategoryDataset dataset = new DefaultCategoryDataset();
    assertNull(r.findRangeBounds(dataset));

    dataset.addValue(1.0, "R1", "C1");
    assertEquals(new Range(0.0, 1.0), r.findRangeBounds(dataset));

    dataset.addValue(-2.0, "R1", "C2");
    assertEquals(new Range(-2.0, 1.0), r.findRangeBounds(dataset));

    dataset.addValue(null, "R1", "C3");
    assertEquals(new Range(-2.0, 1.0), r.findRangeBounds(dataset));

    KeyToGroupMap m = new KeyToGroupMap("G1");
    m.mapKeyToGroup("R1", "G1");
    m.mapKeyToGroup("R2", "G1");
    m.mapKeyToGroup("R3", "G2");
    r.setSeriesToGroupMap(m);

    dataset.addValue(0.5, "R3", "C1");
    assertEquals(new Range(-2.0, 1.0), r.findRangeBounds(dataset));

    dataset.addValue(5.0, "R3", "C2");
    assertEquals(new Range(-2.0, 5.0), r.findRangeBounds(dataset));
}
 

/**
 * Some checks for the findRangeBounds() method.
 */
@Test
public void testFindRangeBounds() {
    GroupedStackedBarRenderer r = new GroupedStackedBarRenderer();
    assertNull(r.findRangeBounds(null));

    // an empty dataset should return a null range
    DefaultCategoryDataset dataset = new DefaultCategoryDataset();
    assertNull(r.findRangeBounds(dataset));

    dataset.addValue(1.0, "R1", "C1");
    assertEquals(new Range(0.0, 1.0), r.findRangeBounds(dataset));

    dataset.addValue(-2.0, "R1", "C2");
    assertEquals(new Range(-2.0, 1.0), r.findRangeBounds(dataset));

    dataset.addValue(null, "R1", "C3");
    assertEquals(new Range(-2.0, 1.0), r.findRangeBounds(dataset));

    KeyToGroupMap m = new KeyToGroupMap("G1");
    m.mapKeyToGroup("R1", "G1");
    m.mapKeyToGroup("R2", "G1");
    m.mapKeyToGroup("R3", "G2");
    r.setSeriesToGroupMap(m);

    dataset.addValue(0.5, "R3", "C1");
    assertEquals(new Range(-2.0, 1.0), r.findRangeBounds(dataset));

    dataset.addValue(5.0, "R3", "C2");
    assertEquals(new Range(-2.0, 5.0), r.findRangeBounds(dataset));
}