1 /* =========================================================== 2 * JFreeChart : a free chart library for the Java(tm) platform 3 * =========================================================== 4 * 5 * (C) Copyright 2000-2013, 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 20 * License along with this library; if not, write to the Free Software 21 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, 22 * USA. 23 * 24 * [Oracle and Java are registered trademarks of Oracle and/or its affiliates. 25 * Other names may be trademarks of their respective owners.] 26 * 27 * ------------------------- 28 * DatasetUtilitiesTest.java 29 * ------------------------- 30 * (C) Copyright 2003-2013, by Object Refinery Limited and Contributors. 31 * 32 * Original Author: David Gilbert (for Object Refinery Limited); 33 * Contributor(s): -; 34 * 35 * Changes 36 * ------- 37 * 18-Sep-2003 : Version 1 (DG); 38 * 23-Mar-2004 : Added test for maximumStackedRangeValue() method (DG); 39 * 04-Oct-2004 : Eliminated NumberUtils usage (DG); 40 * 07-Jan-2005 : Updated for method name changes (DG); 41 * 03-Feb-2005 : Added testFindStackedRangeBounds2() method (DG); 42 * 26-Sep-2007 : Added testIsEmptyOrNullXYDataset() method (DG); 43 * 28-Mar-2008 : Added and renamed various tests (DG); 44 * 08-Oct-2008 : New tests to support patch 2131001 and related 45 * changes (DG); 46 * 25-Mar-2009 : Added tests for new iterateToFindRangeBounds() method (DG); 47 * 16-May-2009 : Added 48 * testIterateToFindRangeBounds_MultiValueCategoryDataset() (DG); 49 * 10-Sep-2009 : Added tests for bug 2849731 (DG); 50 * 51 */ 52 53 package org.jfree.data.general; 54 55 import java.util.ArrayList; 56 import java.util.Arrays; 57 import java.util.Date; 58 import java.util.List; 59 60 import org.jfree.data.KeyToGroupMap; 61 import org.jfree.data.Range; 62 import org.jfree.data.category.CategoryDataset; 63 import org.jfree.data.category.DefaultCategoryDataset; 64 import org.jfree.data.category.DefaultIntervalCategoryDataset; 65 import org.jfree.data.function.Function2D; 66 import org.jfree.data.function.LineFunction2D; 67 import org.jfree.data.statistics.BoxAndWhiskerItem; 68 import org.jfree.data.statistics.DefaultBoxAndWhiskerXYDataset; 69 import org.jfree.data.statistics.DefaultMultiValueCategoryDataset; 70 import org.jfree.data.statistics.DefaultStatisticalCategoryDataset; 71 import org.jfree.data.statistics.MultiValueCategoryDataset; 72 import org.jfree.data.xy.DefaultIntervalXYDataset; 73 import org.jfree.data.xy.DefaultTableXYDataset; 74 import org.jfree.data.xy.DefaultXYDataset; 75 import org.jfree.data.xy.IntervalXYDataset; 76 import org.jfree.data.xy.TableXYDataset; 77 import org.jfree.data.xy.XYDataset; 78 import org.jfree.data.xy.XYIntervalSeries; 79 import org.jfree.data.xy.XYIntervalSeriesCollection; 80 import org.jfree.data.xy.XYSeries; 81 import org.jfree.data.xy.XYSeriesCollection; 82 import org.jfree.data.xy.YIntervalSeries; 83 import org.jfree.data.xy.YIntervalSeriesCollection; 84 import org.junit.Test; 85 import static org.junit.Assert.assertTrue; 86 import static org.junit.Assert.assertFalse; 87 import static org.junit.Assert.assertEquals; 88 import static org.junit.Assert.assertNull; 89 90 /** 91 * Tests for the {@link DatasetUtilities} class. 92 */ 93 public class DatasetUtilitiesTest { 94 95 private static final double EPSILON = 0.0000000001; 96 97 /** 98 * Some tests to verify that Java does what I think it does! 99 */ 100 @Test testJava()101 public void testJava() { 102 assertTrue(Double.isNaN(Math.min(1.0, Double.NaN))); 103 assertTrue(Double.isNaN(Math.max(1.0, Double.NaN))); 104 } 105 106 /** 107 * Some tests for the calculatePieDatasetTotal() method. 108 */ 109 @Test testCalculatePieDatasetTotal()110 public void testCalculatePieDatasetTotal() { 111 DefaultPieDataset d = new DefaultPieDataset(); 112 assertEquals(0.0, DatasetUtilities.calculatePieDatasetTotal(d), 113 EPSILON); 114 d.setValue("A", 1.0); 115 assertEquals(1.0, DatasetUtilities.calculatePieDatasetTotal(d), 116 EPSILON); 117 d.setValue("B", 3.0); 118 assertEquals(4.0, DatasetUtilities.calculatePieDatasetTotal(d), 119 EPSILON); 120 } 121 122 /** 123 * Some tests for the findDomainBounds() method. 124 */ 125 @Test testFindDomainBounds()126 public void testFindDomainBounds() { 127 XYDataset dataset = createXYDataset1(); 128 Range r = DatasetUtilities.findDomainBounds(dataset); 129 assertEquals(1.0, r.getLowerBound(), EPSILON); 130 assertEquals(3.0, r.getUpperBound(), EPSILON); 131 } 132 133 /** 134 * This test checks that the standard method has 'includeInterval' 135 * defaulting to true. 136 */ 137 @Test testFindDomainBounds2()138 public void testFindDomainBounds2() { 139 DefaultIntervalXYDataset dataset = new DefaultIntervalXYDataset(); 140 double[] x1 = new double[] {1.0, 2.0, 3.0}; 141 double[] x1Start = new double[] {0.9, 1.9, 2.9}; 142 double[] x1End = new double[] {1.1, 2.1, 3.1}; 143 double[] y1 = new double[] {4.0, 5.0, 6.0}; 144 double[] y1Start = new double[] {1.09, 2.09, 3.09}; 145 double[] y1End = new double[] {1.11, 2.11, 3.11}; 146 double[][] data1 = new double[][] {x1, x1Start, x1End, y1, y1Start, 147 y1End}; 148 dataset.addSeries("S1", data1); 149 Range r = DatasetUtilities.findDomainBounds(dataset); 150 assertEquals(0.9, r.getLowerBound(), EPSILON); 151 assertEquals(3.1, r.getUpperBound(), EPSILON); 152 } 153 154 /** 155 * This test checks that when the 'includeInterval' flag is false, the 156 * bounds come from the regular x-values. 157 */ 158 @Test testFindDomainBounds3()159 public void testFindDomainBounds3() { 160 DefaultIntervalXYDataset dataset = new DefaultIntervalXYDataset(); 161 double[] x1 = new double[] {1.0, 2.0, 3.0}; 162 double[] x1Start = new double[] {0.9, 1.9, 2.9}; 163 double[] x1End = new double[] {1.1, 2.1, 3.1}; 164 double[] y1 = new double[] {4.0, 5.0, 6.0}; 165 double[] y1Start = new double[] {1.09, 2.09, 3.09}; 166 double[] y1End = new double[] {1.11, 2.11, 3.11}; 167 double[][] data1 = new double[][] {x1, x1Start, x1End, y1, y1Start, 168 y1End}; 169 dataset.addSeries("S1", data1); 170 Range r = DatasetUtilities.findDomainBounds(dataset, false); 171 assertEquals(1.0, r.getLowerBound(), EPSILON); 172 assertEquals(3.0, r.getUpperBound(), EPSILON); 173 } 174 175 /** 176 * This test checks that NaN values are ignored. 177 */ 178 @Test testFindDomainBounds_NaN()179 public void testFindDomainBounds_NaN() { 180 DefaultIntervalXYDataset dataset = new DefaultIntervalXYDataset(); 181 double[] x1 = new double[] {1.0, 2.0, Double.NaN}; 182 double[] x1Start = new double[] {0.9, 1.9, Double.NaN}; 183 double[] x1End = new double[] {1.1, 2.1, Double.NaN}; 184 double[] y1 = new double[] {4.0, 5.0, 6.0}; 185 double[] y1Start = new double[] {1.09, 2.09, 3.09}; 186 double[] y1End = new double[] {1.11, 2.11, 3.11}; 187 double[][] data1 = new double[][] {x1, x1Start, x1End, y1, y1Start, 188 y1End}; 189 dataset.addSeries("S1", data1); 190 Range r = DatasetUtilities.findDomainBounds(dataset); 191 assertEquals(0.9, r.getLowerBound(), EPSILON); 192 assertEquals(2.1, r.getUpperBound(), EPSILON); 193 194 r = DatasetUtilities.findDomainBounds(dataset, false); 195 assertEquals(1.0, r.getLowerBound(), EPSILON); 196 assertEquals(2.0, r.getUpperBound(), EPSILON); 197 } 198 199 /** 200 * Some tests for the iterateDomainBounds() method. 201 */ 202 @Test testIterateDomainBounds()203 public void testIterateDomainBounds() { 204 XYDataset dataset = createXYDataset1(); 205 Range r = DatasetUtilities.iterateDomainBounds(dataset); 206 assertEquals(1.0, r.getLowerBound(), EPSILON); 207 assertEquals(3.0, r.getUpperBound(), EPSILON); 208 } 209 210 /** 211 * Check that NaN values in the dataset are ignored. 212 */ 213 @Test testIterateDomainBounds_NaN()214 public void testIterateDomainBounds_NaN() { 215 DefaultXYDataset dataset = new DefaultXYDataset(); 216 double[] x = new double[] {1.0, 2.0, Double.NaN, 3.0}; 217 double[] y = new double[] {9.0, 8.0, 7.0, 6.0}; 218 dataset.addSeries("S1", new double[][] {x, y}); 219 Range r = DatasetUtilities.iterateDomainBounds(dataset); 220 assertEquals(1.0, r.getLowerBound(), EPSILON); 221 assertEquals(3.0, r.getUpperBound(), EPSILON); 222 } 223 224 /** 225 * Check that NaN values in the IntervalXYDataset are ignored. 226 */ 227 @Test testIterateDomainBounds_NaN2()228 public void testIterateDomainBounds_NaN2() { 229 DefaultIntervalXYDataset dataset = new DefaultIntervalXYDataset(); 230 double[] x1 = new double[] {Double.NaN, 2.0, 3.0}; 231 double[] x1Start = new double[] {0.9, Double.NaN, 2.9}; 232 double[] x1End = new double[] {1.1, Double.NaN, 3.1}; 233 double[] y1 = new double[] {4.0, 5.0, 6.0}; 234 double[] y1Start = new double[] {1.09, 2.09, 3.09}; 235 double[] y1End = new double[] {1.11, 2.11, 3.11}; 236 double[][] data1 = new double[][] {x1, x1Start, x1End, y1, y1Start, 237 y1End}; 238 dataset.addSeries("S1", data1); 239 Range r = DatasetUtilities.iterateDomainBounds(dataset, false); 240 assertEquals(2.0, r.getLowerBound(), EPSILON); 241 assertEquals(3.0, r.getUpperBound(), EPSILON); 242 r = DatasetUtilities.iterateDomainBounds(dataset, true); 243 assertEquals(0.9, r.getLowerBound(), EPSILON); 244 assertEquals(3.1, r.getUpperBound(), EPSILON); 245 } 246 247 /** 248 * Some tests for the findRangeBounds() for a CategoryDataset method. 249 */ 250 @Test testFindRangeBounds_CategoryDataset()251 public void testFindRangeBounds_CategoryDataset() { 252 CategoryDataset dataset = createCategoryDataset1(); 253 Range r = DatasetUtilities.findRangeBounds(dataset); 254 assertEquals(1.0, r.getLowerBound(), EPSILON); 255 assertEquals(6.0, r.getUpperBound(), EPSILON); 256 } 257 258 /** 259 * Some tests for the findRangeBounds() method on an XYDataset. 260 */ 261 @Test testFindRangeBounds()262 public void testFindRangeBounds() { 263 XYDataset dataset = createXYDataset1(); 264 Range r = DatasetUtilities.findRangeBounds(dataset); 265 assertEquals(100.0, r.getLowerBound(), EPSILON); 266 assertEquals(105.0, r.getUpperBound(), EPSILON); 267 } 268 269 /** 270 * A test for the findRangeBounds(XYDataset) method using 271 * an IntervalXYDataset. 272 */ 273 @Test testFindRangeBounds2()274 public void testFindRangeBounds2() { 275 YIntervalSeriesCollection dataset = new YIntervalSeriesCollection(); 276 Range r = DatasetUtilities.findRangeBounds(dataset); 277 assertNull(r); 278 YIntervalSeries s1 = new YIntervalSeries("S1"); 279 dataset.addSeries(s1); 280 r = DatasetUtilities.findRangeBounds(dataset); 281 assertNull(r); 282 283 // try a single item 284 s1.add(1.0, 2.0, 1.5, 2.5); 285 r = DatasetUtilities.findRangeBounds(dataset); 286 assertEquals(1.5, r.getLowerBound(), EPSILON); 287 assertEquals(2.5, r.getUpperBound(), EPSILON); 288 289 r = DatasetUtilities.findRangeBounds(dataset, false); 290 assertEquals(2.0, r.getLowerBound(), EPSILON); 291 assertEquals(2.0, r.getUpperBound(), EPSILON); 292 293 // another item 294 s1.add(2.0, 2.0, 1.4, 2.1); 295 r = DatasetUtilities.findRangeBounds(dataset); 296 assertEquals(1.4, r.getLowerBound(), EPSILON); 297 assertEquals(2.5, r.getUpperBound(), EPSILON); 298 299 // another empty series 300 YIntervalSeries s2 = new YIntervalSeries("S2"); 301 dataset.addSeries(s2); 302 r = DatasetUtilities.findRangeBounds(dataset); 303 assertEquals(1.4, r.getLowerBound(), EPSILON); 304 assertEquals(2.5, r.getUpperBound(), EPSILON); 305 306 // an item in series 2 307 s2.add(1.0, 2.0, 1.9, 2.6); 308 r = DatasetUtilities.findRangeBounds(dataset); 309 assertEquals(1.4, r.getLowerBound(), EPSILON); 310 assertEquals(2.6, r.getUpperBound(), EPSILON); 311 312 // what if we don't want the interval? 313 r = DatasetUtilities.findRangeBounds(dataset, false); 314 assertEquals(2.0, r.getLowerBound(), EPSILON); 315 assertEquals(2.0, r.getUpperBound(), EPSILON); 316 } 317 318 /** 319 * Some tests for the iterateRangeBounds() method. 320 */ 321 @Test testIterateRangeBounds_CategoryDataset()322 public void testIterateRangeBounds_CategoryDataset() { 323 CategoryDataset dataset = createCategoryDataset1(); 324 Range r = DatasetUtilities.iterateRangeBounds(dataset, false); 325 assertEquals(1.0, r.getLowerBound(), EPSILON); 326 assertEquals(6.0, r.getUpperBound(), EPSILON); 327 } 328 329 /** 330 * Some checks for the iterateRangeBounds() method. 331 */ 332 @Test testIterateRangeBounds2_CategoryDataset()333 public void testIterateRangeBounds2_CategoryDataset() { 334 // an empty dataset should return a null range 335 DefaultCategoryDataset dataset = new DefaultCategoryDataset(); 336 Range r = DatasetUtilities.iterateRangeBounds(dataset, false); 337 assertNull(r); 338 339 // a dataset with a single value 340 dataset.addValue(1.23, "R1", "C1"); 341 r = DatasetUtilities.iterateRangeBounds(dataset, false); 342 assertEquals(1.23, r.getLowerBound(), EPSILON); 343 assertEquals(1.23, r.getUpperBound(), EPSILON); 344 345 // null is ignored 346 dataset.addValue(null, "R2", "C1"); 347 r = DatasetUtilities.iterateRangeBounds(dataset, false); 348 assertEquals(1.23, r.getLowerBound(), EPSILON); 349 assertEquals(1.23, r.getUpperBound(), EPSILON); 350 351 // a Double.NaN should be ignored 352 dataset.addValue(Double.NaN, "R2", "C1"); 353 r = DatasetUtilities.iterateRangeBounds(dataset, false); 354 assertEquals(1.23, r.getLowerBound(), EPSILON); 355 assertEquals(1.23, r.getUpperBound(), EPSILON); 356 } 357 358 /** 359 * Some checks for the iterateRangeBounds() method using an 360 * IntervalCategoryDataset. 361 */ 362 @Test testIterateRangeBounds3_CategoryDataset()363 public void testIterateRangeBounds3_CategoryDataset() { 364 Number[][] starts = new Double[2][3]; 365 Number[][] ends = new Double[2][3]; 366 starts[0][0] = new Double(1.0); 367 starts[0][1] = new Double(2.0); 368 starts[0][2] = new Double(3.0); 369 starts[1][0] = new Double(11.0); 370 starts[1][1] = new Double(12.0); 371 starts[1][2] = new Double(13.0); 372 ends[0][0] = new Double(4.0); 373 ends[0][1] = new Double(5.0); 374 ends[0][2] = new Double(6.0); 375 ends[1][0] = new Double(16.0); 376 ends[1][1] = new Double(15.0); 377 ends[1][2] = new Double(14.0); 378 379 DefaultIntervalCategoryDataset d = new DefaultIntervalCategoryDataset( 380 starts, ends); 381 Range r = DatasetUtilities.iterateRangeBounds(d, false); 382 assertEquals(4.0, r.getLowerBound(), EPSILON); 383 assertEquals(16.0, r.getUpperBound(), EPSILON); 384 r = DatasetUtilities.iterateRangeBounds(d, true); 385 assertEquals(1.0, r.getLowerBound(), EPSILON); 386 assertEquals(16.0, r.getUpperBound(), EPSILON); 387 } 388 389 /** 390 * Some tests for the iterateRangeBounds() method. 391 */ 392 @Test testIterateRangeBounds()393 public void testIterateRangeBounds() { 394 XYDataset dataset = createXYDataset1(); 395 Range r = DatasetUtilities.iterateRangeBounds(dataset); 396 assertEquals(100.0, r.getLowerBound(), EPSILON); 397 assertEquals(105.0, r.getUpperBound(), EPSILON); 398 } 399 400 /** 401 * Check the range returned when a series contains a null value. 402 */ 403 @Test testIterateRangeBounds2()404 public void testIterateRangeBounds2() { 405 XYSeries s1 = new XYSeries("S1"); 406 s1.add(1.0, 1.1); 407 s1.add(2.0, null); 408 s1.add(3.0, 3.3); 409 XYSeriesCollection dataset = new XYSeriesCollection(s1); 410 Range r = DatasetUtilities.iterateRangeBounds(dataset); 411 assertEquals(1.1, r.getLowerBound(), EPSILON); 412 assertEquals(3.3, r.getUpperBound(), EPSILON); 413 } 414 415 /** 416 * Some checks for the iterateRangeBounds() method. 417 */ 418 @Test testIterateRangeBounds3()419 public void testIterateRangeBounds3() { 420 // an empty dataset should return a null range 421 XYSeriesCollection dataset = new XYSeriesCollection(); 422 Range r = DatasetUtilities.iterateRangeBounds(dataset); 423 assertNull(r); 424 XYSeries s1 = new XYSeries("S1"); 425 dataset.addSeries(s1); 426 r = DatasetUtilities.iterateRangeBounds(dataset); 427 assertNull(r); 428 429 // a dataset with a single value 430 s1.add(1.0, 1.23); 431 r = DatasetUtilities.iterateRangeBounds(dataset); 432 assertEquals(1.23, r.getLowerBound(), EPSILON); 433 assertEquals(1.23, r.getUpperBound(), EPSILON); 434 435 // null is ignored 436 s1.add(2.0, null); 437 r = DatasetUtilities.iterateRangeBounds(dataset); 438 assertEquals(1.23, r.getLowerBound(), EPSILON); 439 assertEquals(1.23, r.getUpperBound(), EPSILON); 440 441 // Double.NaN DOESN'T mess things up 442 s1.add(3.0, Double.NaN); 443 r = DatasetUtilities.iterateRangeBounds(dataset); 444 assertEquals(1.23, r.getLowerBound(), EPSILON); 445 assertEquals(1.23, r.getUpperBound(), EPSILON); 446 } 447 448 /** 449 * Some checks for the range bounds of a dataset that implements the 450 * {@link IntervalXYDataset} interface. 451 */ 452 @Test testIterateRangeBounds4()453 public void testIterateRangeBounds4() { 454 YIntervalSeriesCollection dataset = new YIntervalSeriesCollection(); 455 Range r = DatasetUtilities.iterateRangeBounds(dataset); 456 assertNull(r); 457 YIntervalSeries s1 = new YIntervalSeries("S1"); 458 dataset.addSeries(s1); 459 r = DatasetUtilities.iterateRangeBounds(dataset); 460 assertNull(r); 461 462 // try a single item 463 s1.add(1.0, 2.0, 1.5, 2.5); 464 r = DatasetUtilities.iterateRangeBounds(dataset); 465 assertEquals(1.5, r.getLowerBound(), EPSILON); 466 assertEquals(2.5, r.getUpperBound(), EPSILON); 467 468 // another item 469 s1.add(2.0, 2.0, 1.4, 2.1); 470 r = DatasetUtilities.iterateRangeBounds(dataset); 471 assertEquals(1.4, r.getLowerBound(), EPSILON); 472 assertEquals(2.5, r.getUpperBound(), EPSILON); 473 474 // another empty series 475 YIntervalSeries s2 = new YIntervalSeries("S2"); 476 dataset.addSeries(s2); 477 r = DatasetUtilities.iterateRangeBounds(dataset); 478 assertEquals(1.4, r.getLowerBound(), EPSILON); 479 assertEquals(2.5, r.getUpperBound(), EPSILON); 480 481 // an item in series 2 482 s2.add(1.0, 2.0, 1.9, 2.6); 483 r = DatasetUtilities.iterateRangeBounds(dataset); 484 assertEquals(1.4, r.getLowerBound(), EPSILON); 485 assertEquals(2.6, r.getUpperBound(), EPSILON); 486 } 487 488 /** 489 * Some tests for the findMinimumDomainValue() method. 490 */ 491 @Test testFindMinimumDomainValue()492 public void testFindMinimumDomainValue() { 493 XYDataset dataset = createXYDataset1(); 494 Number minimum = DatasetUtilities.findMinimumDomainValue(dataset); 495 assertEquals(new Double(1.0), minimum); 496 } 497 498 /** 499 * Some tests for the findMaximumDomainValue() method. 500 */ 501 @Test testFindMaximumDomainValue()502 public void testFindMaximumDomainValue() { 503 XYDataset dataset = createXYDataset1(); 504 Number maximum = DatasetUtilities.findMaximumDomainValue(dataset); 505 assertEquals(new Double(3.0), maximum); 506 } 507 508 /** 509 * Some tests for the findMinimumRangeValue() method. 510 */ 511 @Test testFindMinimumRangeValue()512 public void testFindMinimumRangeValue() { 513 CategoryDataset d1 = createCategoryDataset1(); 514 Number min1 = DatasetUtilities.findMinimumRangeValue(d1); 515 assertEquals(new Double(1.0), min1); 516 517 XYDataset d2 = createXYDataset1(); 518 Number min2 = DatasetUtilities.findMinimumRangeValue(d2); 519 assertEquals(new Double(100.0), min2); 520 } 521 522 /** 523 * Some tests for the findMaximumRangeValue() method. 524 */ 525 @Test testFindMaximumRangeValue()526 public void testFindMaximumRangeValue() { 527 CategoryDataset d1 = createCategoryDataset1(); 528 Number max1 = DatasetUtilities.findMaximumRangeValue(d1); 529 assertEquals(new Double(6.0), max1); 530 531 XYDataset dataset = createXYDataset1(); 532 Number maximum = DatasetUtilities.findMaximumRangeValue(dataset); 533 assertEquals(new Double(105.0), maximum); 534 } 535 536 /** 537 * A quick test of the min and max range value methods. 538 */ 539 @Test testMinMaxRange()540 public void testMinMaxRange() { 541 DefaultCategoryDataset dataset = new DefaultCategoryDataset(); 542 dataset.addValue(100.0, "Series 1", "Type 1"); 543 dataset.addValue(101.1, "Series 1", "Type 2"); 544 Number min = DatasetUtilities.findMinimumRangeValue(dataset); 545 assertTrue(min.doubleValue() < 100.1); 546 Number max = DatasetUtilities.findMaximumRangeValue(dataset); 547 assertTrue(max.doubleValue() > 101.0); 548 } 549 550 /** 551 * A test to reproduce bug report 803660. 552 */ 553 @Test test803660()554 public void test803660() { 555 DefaultCategoryDataset dataset = new DefaultCategoryDataset(); 556 dataset.addValue(100.0, "Series 1", "Type 1"); 557 dataset.addValue(101.1, "Series 1", "Type 2"); 558 Number n = DatasetUtilities.findMaximumRangeValue(dataset); 559 assertTrue(n.doubleValue() > 101.0); 560 } 561 562 /** 563 * A simple test for the cumulative range calculation. The sequence of 564 * "cumulative" values are considered to be { 0.0, 10.0, 25.0, 18.0 } so 565 * the range should be 0.0 -> 25.0. 566 */ 567 @Test testCumulativeRange1()568 public void testCumulativeRange1() { 569 DefaultCategoryDataset dataset = new DefaultCategoryDataset(); 570 dataset.addValue(10.0, "Series 1", "Start"); 571 dataset.addValue(15.0, "Series 1", "Delta 1"); 572 dataset.addValue(-7.0, "Series 1", "Delta 2"); 573 Range range = DatasetUtilities.findCumulativeRangeBounds(dataset); 574 assertEquals(0.0, range.getLowerBound(), 0.00000001); 575 assertEquals(25.0, range.getUpperBound(), 0.00000001); 576 } 577 578 /** 579 * A further test for the cumulative range calculation. 580 */ 581 @Test testCumulativeRange2()582 public void testCumulativeRange2() { 583 DefaultCategoryDataset dataset = new DefaultCategoryDataset(); 584 dataset.addValue(-21.4, "Series 1", "Start Value"); 585 dataset.addValue(11.57, "Series 1", "Delta 1"); 586 dataset.addValue(3.51, "Series 1", "Delta 2"); 587 dataset.addValue(-12.36, "Series 1", "Delta 3"); 588 dataset.addValue(3.39, "Series 1", "Delta 4"); 589 dataset.addValue(38.68, "Series 1", "Delta 5"); 590 dataset.addValue(-43.31, "Series 1", "Delta 6"); 591 dataset.addValue(-29.59, "Series 1", "Delta 7"); 592 dataset.addValue(35.30, "Series 1", "Delta 8"); 593 dataset.addValue(5.0, "Series 1", "Delta 9"); 594 Range range = DatasetUtilities.findCumulativeRangeBounds(dataset); 595 assertEquals(-49.51, range.getLowerBound(), 0.00000001); 596 assertEquals(23.39, range.getUpperBound(), 0.00000001); 597 } 598 599 /** 600 * A further test for the cumulative range calculation. 601 */ 602 @Test testCumulativeRange3()603 public void testCumulativeRange3() { 604 DefaultCategoryDataset dataset = new DefaultCategoryDataset(); 605 dataset.addValue(15.76, "Product 1", "Labour"); 606 dataset.addValue(8.66, "Product 1", "Administration"); 607 dataset.addValue(4.71, "Product 1", "Marketing"); 608 dataset.addValue(3.51, "Product 1", "Distribution"); 609 dataset.addValue(32.64, "Product 1", "Total Expense"); 610 Range range = DatasetUtilities.findCumulativeRangeBounds(dataset); 611 assertEquals(0.0, range.getLowerBound(), EPSILON); 612 assertEquals(65.28, range.getUpperBound(), EPSILON); 613 } 614 615 /** 616 * Check that the findCumulativeRangeBounds() method ignores Double.NaN 617 * values. 618 */ 619 @Test testCumulativeRange_NaN()620 public void testCumulativeRange_NaN() { 621 DefaultCategoryDataset dataset = new DefaultCategoryDataset(); 622 dataset.addValue(10.0, "Series 1", "Start"); 623 dataset.addValue(15.0, "Series 1", "Delta 1"); 624 dataset.addValue(Double.NaN, "Series 1", "Delta 2"); 625 Range range = DatasetUtilities.findCumulativeRangeBounds(dataset); 626 assertEquals(0.0, range.getLowerBound(), EPSILON); 627 assertEquals(25.0, range.getUpperBound(), EPSILON); 628 } 629 630 /** 631 * Test the creation of a dataset from an array. 632 */ 633 @Test testCreateCategoryDataset1()634 public void testCreateCategoryDataset1() { 635 String[] rowKeys = {"R1", "R2", "R3"}; 636 String[] columnKeys = {"C1", "C2"}; 637 double[][] data = new double[3][]; 638 data[0] = new double[] {1.1, 1.2}; 639 data[1] = new double[] {2.1, 2.2}; 640 data[2] = new double[] {3.1, 3.2}; 641 CategoryDataset dataset = DatasetUtilities.createCategoryDataset( 642 rowKeys, columnKeys, data); 643 assertTrue(dataset.getRowCount() == 3); 644 assertTrue(dataset.getColumnCount() == 2); 645 } 646 647 /** 648 * Test the creation of a dataset from an array. This time is should fail 649 * because the array dimensions are around the wrong way. 650 */ 651 @Test testCreateCategoryDataset2()652 public void testCreateCategoryDataset2() { 653 boolean pass = false; 654 String[] rowKeys = {"R1", "R2", "R3"}; 655 String[] columnKeys = {"C1", "C2"}; 656 double[][] data = new double[2][]; 657 data[0] = new double[] {1.1, 1.2, 1.3}; 658 data[1] = new double[] {2.1, 2.2, 2.3}; 659 CategoryDataset dataset = null; 660 try { 661 dataset = DatasetUtilities.createCategoryDataset(rowKeys, 662 columnKeys, data); 663 } 664 catch (IllegalArgumentException e) { 665 pass = true; // got it! 666 } 667 assertTrue(pass); 668 assertTrue(dataset == null); 669 } 670 671 /** 672 * Test for a bug reported in the forum: 673 * 674 * http://www.jfree.org/phpBB2/viewtopic.php?t=7903 675 */ 676 @Test testMaximumStackedRangeValue()677 public void testMaximumStackedRangeValue() { 678 double v1 = 24.3; 679 double v2 = 14.2; 680 double v3 = 33.2; 681 double v4 = 32.4; 682 double v5 = 26.3; 683 double v6 = 22.6; 684 Number answer = new Double(Math.max(v1 + v2 + v3, v4 + v5 + v6)); 685 DefaultCategoryDataset d = new DefaultCategoryDataset(); 686 d.addValue(v1, "Row 0", "Column 0"); 687 d.addValue(v2, "Row 1", "Column 0"); 688 d.addValue(v3, "Row 2", "Column 0"); 689 d.addValue(v4, "Row 0", "Column 1"); 690 d.addValue(v5, "Row 1", "Column 1"); 691 d.addValue(v6, "Row 2", "Column 1"); 692 Number max = DatasetUtilities.findMaximumStackedRangeValue(d); 693 assertTrue(max.equals(answer)); 694 } 695 696 /** 697 * Some checks for the findStackedRangeBounds() method. 698 */ 699 @Test testFindStackedRangeBounds_CategoryDataset1()700 public void testFindStackedRangeBounds_CategoryDataset1() { 701 CategoryDataset d1 = createCategoryDataset1(); 702 Range r = DatasetUtilities.findStackedRangeBounds(d1); 703 assertEquals(0.0, r.getLowerBound(), EPSILON); 704 assertEquals(15.0, r.getUpperBound(), EPSILON); 705 706 d1 = createCategoryDataset2(); 707 r = DatasetUtilities.findStackedRangeBounds(d1); 708 assertEquals(-2.0, r.getLowerBound(), EPSILON); 709 assertEquals(2.0, r.getUpperBound(), EPSILON); 710 } 711 712 /** 713 * Some checks for the findStackedRangeBounds() method. 714 */ 715 @Test testFindStackedRangeBounds_CategoryDataset2()716 public void testFindStackedRangeBounds_CategoryDataset2() { 717 DefaultCategoryDataset dataset = new DefaultCategoryDataset(); 718 Range r = DatasetUtilities.findStackedRangeBounds(dataset); 719 assertTrue(r == null); 720 721 dataset.addValue(5.0, "R1", "C1"); 722 r = DatasetUtilities.findStackedRangeBounds(dataset, 3.0); 723 assertEquals(3.0, r.getLowerBound(), EPSILON); 724 assertEquals(8.0, r.getUpperBound(), EPSILON); 725 726 dataset.addValue(-1.0, "R2", "C1"); 727 r = DatasetUtilities.findStackedRangeBounds(dataset, 3.0); 728 assertEquals(2.0, r.getLowerBound(), EPSILON); 729 assertEquals(8.0, r.getUpperBound(), EPSILON); 730 731 dataset.addValue(null, "R3", "C1"); 732 r = DatasetUtilities.findStackedRangeBounds(dataset, 3.0); 733 assertEquals(2.0, r.getLowerBound(), EPSILON); 734 assertEquals(8.0, r.getUpperBound(), EPSILON); 735 736 dataset.addValue(Double.NaN, "R4", "C1"); 737 r = DatasetUtilities.findStackedRangeBounds(dataset, 3.0); 738 assertEquals(2.0, r.getLowerBound(), EPSILON); 739 assertEquals(8.0, r.getUpperBound(), EPSILON); 740 } 741 742 /** 743 * Some checks for the findStackedRangeBounds(CategoryDataset, 744 * KeyToGroupMap) method. 745 */ 746 @Test testFindStackedRangeBounds_CategoryDataset3()747 public void testFindStackedRangeBounds_CategoryDataset3() { 748 DefaultCategoryDataset dataset = new DefaultCategoryDataset(); 749 KeyToGroupMap map = new KeyToGroupMap("Group A"); 750 Range r = DatasetUtilities.findStackedRangeBounds(dataset, map); 751 assertTrue(r == null); 752 753 dataset.addValue(1.0, "R1", "C1"); 754 dataset.addValue(2.0, "R2", "C1"); 755 dataset.addValue(3.0, "R3", "C1"); 756 dataset.addValue(4.0, "R4", "C1"); 757 758 map.mapKeyToGroup("R1", "Group A"); 759 map.mapKeyToGroup("R2", "Group A"); 760 map.mapKeyToGroup("R3", "Group B"); 761 map.mapKeyToGroup("R4", "Group B"); 762 763 r = DatasetUtilities.findStackedRangeBounds(dataset, map); 764 assertEquals(0.0, r.getLowerBound(), EPSILON); 765 assertEquals(7.0, r.getUpperBound(), EPSILON); 766 767 dataset.addValue(null, "R5", "C1"); 768 r = DatasetUtilities.findStackedRangeBounds(dataset, map); 769 assertEquals(0.0, r.getLowerBound(), EPSILON); 770 assertEquals(7.0, r.getUpperBound(), EPSILON); 771 772 dataset.addValue(Double.NaN, "R6", "C1"); 773 r = DatasetUtilities.findStackedRangeBounds(dataset, map); 774 assertEquals(0.0, r.getLowerBound(), EPSILON); 775 assertEquals(7.0, r.getUpperBound(), EPSILON); 776 } 777 778 /** 779 * Some checks for the findStackedRangeBounds() method. 780 */ 781 @Test testFindStackedRangeBoundsForTableXYDataset1()782 public void testFindStackedRangeBoundsForTableXYDataset1() { 783 TableXYDataset d2 = createTableXYDataset1(); 784 Range r = DatasetUtilities.findStackedRangeBounds(d2); 785 assertEquals(-2.0, r.getLowerBound(), EPSILON); 786 assertEquals(2.0, r.getUpperBound(), EPSILON); 787 } 788 789 /** 790 * Some checks for the findStackedRangeBounds() method. 791 */ 792 @Test testFindStackedRangeBoundsForTableXYDataset2()793 public void testFindStackedRangeBoundsForTableXYDataset2() { 794 DefaultTableXYDataset d = new DefaultTableXYDataset(); 795 Range r = DatasetUtilities.findStackedRangeBounds(d); 796 assertEquals(r, new Range(0.0, 0.0)); 797 } 798 799 /** 800 * Tests the stacked range extent calculation. 801 */ 802 @Test testStackedRangeWithMap()803 public void testStackedRangeWithMap() { 804 CategoryDataset d = createCategoryDataset1(); 805 KeyToGroupMap map = new KeyToGroupMap("G0"); 806 map.mapKeyToGroup("R2", "G1"); 807 Range r = DatasetUtilities.findStackedRangeBounds(d, map); 808 assertEquals(0.0, r.getLowerBound(), EPSILON); 809 assertEquals(9.0, r.getUpperBound(), EPSILON); 810 } 811 812 /** 813 * Some checks for the isEmptyOrNull(XYDataset) method. 814 */ 815 @Test testIsEmptyOrNullXYDataset()816 public void testIsEmptyOrNullXYDataset() { 817 XYSeriesCollection dataset = null; 818 assertTrue(DatasetUtilities.isEmptyOrNull(dataset)); 819 dataset = new XYSeriesCollection(); 820 assertTrue(DatasetUtilities.isEmptyOrNull(dataset)); 821 XYSeries s1 = new XYSeries("S1"); 822 dataset.addSeries(s1); 823 assertTrue(DatasetUtilities.isEmptyOrNull(dataset)); 824 s1.add(1.0, 2.0); 825 assertFalse(DatasetUtilities.isEmptyOrNull(dataset)); 826 s1.clear(); 827 assertTrue(DatasetUtilities.isEmptyOrNull(dataset)); 828 } 829 830 /** 831 * Some checks for the limitPieDataset() methods. 832 */ 833 @Test testLimitPieDataset()834 public void testLimitPieDataset() { 835 836 // check that empty dataset is handled OK 837 DefaultPieDataset d1 = new DefaultPieDataset(); 838 PieDataset d2 = DatasetUtilities.createConsolidatedPieDataset(d1, 839 "Other", 0.05); 840 assertEquals(0, d2.getItemCount()); 841 842 // check that minItem limit is observed 843 d1.setValue("Item 1", 1.0); 844 d1.setValue("Item 2", 49.50); 845 d1.setValue("Item 3", 49.50); 846 d2 = DatasetUtilities.createConsolidatedPieDataset(d1, "Other", 0.05); 847 assertEquals(3, d2.getItemCount()); 848 assertEquals("Item 1", d2.getKey(0)); 849 assertEquals("Item 2", d2.getKey(1)); 850 assertEquals("Item 3", d2.getKey(2)); 851 852 // check that minItem limit is observed 853 d1.setValue("Item 4", 1.0); 854 d2 = DatasetUtilities.createConsolidatedPieDataset(d1, "Other", 0.05, 855 2); 856 857 // and that simple aggregation works 858 assertEquals(3, d2.getItemCount()); 859 assertEquals("Item 2", d2.getKey(0)); 860 assertEquals("Item 3", d2.getKey(1)); 861 assertEquals("Other", d2.getKey(2)); 862 assertEquals(new Double(2.0), d2.getValue("Other")); 863 864 } 865 866 /** 867 * Some checks for the sampleFunction2D() method. 868 */ 869 @Test testSampleFunction2D()870 public void testSampleFunction2D() { 871 Function2D f = new LineFunction2D(0, 1); 872 XYDataset dataset = DatasetUtilities.sampleFunction2D(f, 0.0, 1.0, 2, 873 "S1"); 874 assertEquals(1, dataset.getSeriesCount()); 875 assertEquals("S1", dataset.getSeriesKey(0)); 876 assertEquals(2, dataset.getItemCount(0)); 877 assertEquals(0.0, dataset.getXValue(0, 0), EPSILON); 878 assertEquals(0.0, dataset.getYValue(0, 0), EPSILON); 879 assertEquals(1.0, dataset.getXValue(0, 1), EPSILON); 880 assertEquals(1.0, dataset.getYValue(0, 1), EPSILON); 881 } 882 883 /** 884 * A simple check for the findMinimumStackedRangeValue() method. 885 */ 886 @Test testFindMinimumStackedRangeValue()887 public void testFindMinimumStackedRangeValue() { 888 DefaultCategoryDataset dataset = new DefaultCategoryDataset(); 889 890 // an empty dataset should return a null max 891 Number min = DatasetUtilities.findMinimumStackedRangeValue(dataset); 892 assertNull(min); 893 894 dataset.addValue(1.0, "R1", "C1"); 895 min = DatasetUtilities.findMinimumStackedRangeValue(dataset); 896 assertEquals(0.0, min.doubleValue(), EPSILON); 897 898 dataset.addValue(2.0, "R2", "C1"); 899 min = DatasetUtilities.findMinimumStackedRangeValue(dataset); 900 assertEquals(0.0, min.doubleValue(), EPSILON); 901 902 dataset.addValue(-3.0, "R3", "C1"); 903 min = DatasetUtilities.findMinimumStackedRangeValue(dataset); 904 assertEquals(-3.0, min.doubleValue(), EPSILON); 905 906 dataset.addValue(Double.NaN, "R4", "C1"); 907 min = DatasetUtilities.findMinimumStackedRangeValue(dataset); 908 assertEquals(-3.0, min.doubleValue(), EPSILON); 909 } 910 911 /** 912 * A simple check for the findMaximumStackedRangeValue() method. 913 */ 914 @Test testFindMinimumStackedRangeValue2()915 public void testFindMinimumStackedRangeValue2() { 916 DefaultCategoryDataset dataset = new DefaultCategoryDataset(); 917 dataset.addValue(-1.0, "R1", "C1"); 918 Number min = DatasetUtilities.findMinimumStackedRangeValue(dataset); 919 assertEquals(-1.0, min.doubleValue(), EPSILON); 920 921 dataset.addValue(-2.0, "R2", "C1"); 922 min = DatasetUtilities.findMinimumStackedRangeValue(dataset); 923 assertEquals(-3.0, min.doubleValue(), EPSILON); 924 } 925 926 /** 927 * A simple check for the findMaximumStackedRangeValue() method. 928 */ 929 @Test testFindMaximumStackedRangeValue()930 public void testFindMaximumStackedRangeValue() { 931 DefaultCategoryDataset dataset = new DefaultCategoryDataset(); 932 933 // an empty dataset should return a null max 934 Number max = DatasetUtilities.findMaximumStackedRangeValue(dataset); 935 assertNull(max); 936 937 dataset.addValue(1.0, "R1", "C1"); 938 max = DatasetUtilities.findMaximumStackedRangeValue(dataset); 939 assertEquals(1.0, max.doubleValue(), EPSILON); 940 941 dataset.addValue(2.0, "R2", "C1"); 942 max = DatasetUtilities.findMaximumStackedRangeValue(dataset); 943 assertEquals(3.0, max.doubleValue(), EPSILON); 944 945 dataset.addValue(-3.0, "R3", "C1"); 946 max = DatasetUtilities.findMaximumStackedRangeValue(dataset); 947 assertEquals(3.0, max.doubleValue(), EPSILON); 948 949 dataset.addValue(Double.NaN, "R4", "C1"); 950 max = DatasetUtilities.findMaximumStackedRangeValue(dataset); 951 assertEquals(3.0, max.doubleValue(), EPSILON); 952 } 953 954 /** 955 * A simple check for the findMaximumStackedRangeValue() method. 956 */ 957 @Test testFindMaximumStackedRangeValue2()958 public void testFindMaximumStackedRangeValue2() { 959 DefaultCategoryDataset dataset = new DefaultCategoryDataset(); 960 dataset.addValue(-1.0, "R1", "C1"); 961 Number max = DatasetUtilities.findMaximumStackedRangeValue(dataset); 962 assertEquals(0.0, max.doubleValue(), EPSILON); 963 964 dataset.addValue(-2.0, "R2", "C1"); 965 max = DatasetUtilities.findMaximumStackedRangeValue(dataset); 966 assertEquals(0.0, max.doubleValue(), EPSILON); 967 } 968 969 /** 970 * Creates a dataset for testing. 971 * 972 * @return A dataset. 973 */ createCategoryDataset1()974 private CategoryDataset createCategoryDataset1() { 975 DefaultCategoryDataset result = new DefaultCategoryDataset(); 976 result.addValue(1.0, "R0", "C0"); 977 result.addValue(1.0, "R1", "C0"); 978 result.addValue(1.0, "R2", "C0"); 979 result.addValue(4.0, "R0", "C1"); 980 result.addValue(5.0, "R1", "C1"); 981 result.addValue(6.0, "R2", "C1"); 982 return result; 983 } 984 985 /** 986 * Creates a dataset for testing. 987 * 988 * @return A dataset. 989 */ createCategoryDataset2()990 private CategoryDataset createCategoryDataset2() { 991 DefaultCategoryDataset result = new DefaultCategoryDataset(); 992 result.addValue(1.0, "R0", "C0"); 993 result.addValue(-2.0, "R1", "C0"); 994 result.addValue(2.0, "R0", "C1"); 995 result.addValue(-1.0, "R1", "C1"); 996 return result; 997 } 998 999 1000 /** 1001 * Creates a dataset for testing. 1002 * 1003 * @return A dataset. 1004 */ createXYDataset1()1005 private XYDataset createXYDataset1() { 1006 XYSeries series1 = new XYSeries("S1"); 1007 series1.add(1.0, 100.0); 1008 series1.add(2.0, 101.0); 1009 series1.add(3.0, 102.0); 1010 XYSeries series2 = new XYSeries("S2"); 1011 series2.add(1.0, 103.0); 1012 series2.add(2.0, null); 1013 series2.add(3.0, 105.0); 1014 XYSeriesCollection result = new XYSeriesCollection(); 1015 result.addSeries(series1); 1016 result.addSeries(series2); 1017 result.setIntervalWidth(0.0); 1018 return result; 1019 } 1020 1021 /** 1022 * Creates a sample dataset for testing purposes. 1023 * 1024 * @return A sample dataset. 1025 */ createTableXYDataset1()1026 private TableXYDataset createTableXYDataset1() { 1027 DefaultTableXYDataset dataset = new DefaultTableXYDataset(); 1028 1029 XYSeries s1 = new XYSeries("Series 1", true, false); 1030 s1.add(1.0, 1.0); 1031 s1.add(2.0, 2.0); 1032 dataset.addSeries(s1); 1033 1034 XYSeries s2 = new XYSeries("Series 2", true, false); 1035 s2.add(1.0, -2.0); 1036 s2.add(2.0, -1.0); 1037 dataset.addSeries(s2); 1038 1039 return dataset; 1040 } 1041 1042 /** 1043 * Some checks for the iteratorToFindRangeBounds(XYDataset...) method. 1044 */ 1045 @Test testIterateToFindRangeBounds1_XYDataset()1046 public void testIterateToFindRangeBounds1_XYDataset() { 1047 // null dataset throws IllegalArgumentException 1048 boolean pass = false; 1049 try { 1050 DatasetUtilities.iterateToFindRangeBounds(null, new ArrayList(), 1051 new Range(0.0, 1.0), true); 1052 } 1053 catch (IllegalArgumentException e) { 1054 pass = true; 1055 } 1056 assertTrue(pass); 1057 1058 // null list throws IllegalArgumentException 1059 pass = false; 1060 try { 1061 DatasetUtilities.iterateToFindRangeBounds(new XYSeriesCollection(), 1062 null, new Range(0.0, 1.0), true); 1063 } 1064 catch (IllegalArgumentException e) { 1065 pass = true; 1066 } 1067 assertTrue(pass); 1068 1069 // null range throws IllegalArgumentException 1070 pass = false; 1071 try { 1072 DatasetUtilities.iterateToFindRangeBounds(new XYSeriesCollection(), 1073 new ArrayList(), null, true); 1074 } 1075 catch (IllegalArgumentException e) { 1076 pass = true; 1077 } 1078 assertTrue(pass); 1079 } 1080 1081 /** 1082 * Some tests for the iterateToFindRangeBounds() method. 1083 */ 1084 @Test testIterateToFindRangeBounds2_XYDataset()1085 public void testIterateToFindRangeBounds2_XYDataset() { 1086 List visibleSeriesKeys = new ArrayList(); 1087 Range xRange = new Range(0.0, 10.0); 1088 1089 // empty dataset returns null 1090 XYSeriesCollection dataset = new XYSeriesCollection(); 1091 Range r = DatasetUtilities.iterateToFindRangeBounds(dataset, 1092 visibleSeriesKeys, xRange, false); 1093 assertNull(r); 1094 1095 // add an empty series 1096 XYSeries s1 = new XYSeries("A"); 1097 dataset.addSeries(s1); 1098 visibleSeriesKeys.add("A"); 1099 r = DatasetUtilities.iterateToFindRangeBounds(dataset, 1100 visibleSeriesKeys, xRange, false); 1101 assertNull(r); 1102 1103 // check a null value 1104 s1.add(1.0, null); 1105 r = DatasetUtilities.iterateToFindRangeBounds(dataset, 1106 visibleSeriesKeys, xRange, false); 1107 assertNull(r); 1108 1109 // check a NaN 1110 s1.add(2.0, Double.NaN); 1111 r = DatasetUtilities.iterateToFindRangeBounds(dataset, 1112 visibleSeriesKeys, xRange, false); 1113 assertNull(r); 1114 1115 // check a regular value 1116 s1.add(3.0, 5.0); 1117 r = DatasetUtilities.iterateToFindRangeBounds(dataset, 1118 visibleSeriesKeys, xRange, false); 1119 assertEquals(new Range(5.0, 5.0), r); 1120 1121 // check another regular value 1122 s1.add(4.0, 6.0); 1123 r = DatasetUtilities.iterateToFindRangeBounds(dataset, 1124 visibleSeriesKeys, xRange, false); 1125 assertEquals(new Range(5.0, 6.0), r); 1126 1127 // add a second series 1128 XYSeries s2 = new XYSeries("B"); 1129 dataset.addSeries(s2); 1130 r = DatasetUtilities.iterateToFindRangeBounds(dataset, 1131 visibleSeriesKeys, xRange, false); 1132 assertEquals(new Range(5.0, 6.0), r); 1133 visibleSeriesKeys.add("B"); 1134 r = DatasetUtilities.iterateToFindRangeBounds(dataset, 1135 visibleSeriesKeys, xRange, false); 1136 assertEquals(new Range(5.0, 6.0), r); 1137 1138 // add a value to the second series 1139 s2.add(5.0, 15.0); 1140 r = DatasetUtilities.iterateToFindRangeBounds(dataset, 1141 visibleSeriesKeys, xRange, false); 1142 assertEquals(new Range(5.0, 15.0), r); 1143 1144 // add a value that isn't in the xRange 1145 s2.add(15.0, 150.0); 1146 r = DatasetUtilities.iterateToFindRangeBounds(dataset, 1147 visibleSeriesKeys, xRange, false); 1148 assertEquals(new Range(5.0, 15.0), r); 1149 1150 r = DatasetUtilities.iterateToFindRangeBounds(dataset, 1151 visibleSeriesKeys, new Range(0.0, 20.0), false); 1152 assertEquals(new Range(5.0, 150.0), r); 1153 } 1154 1155 /** 1156 * Some checks for the iterateToFindRangeBounds() method when applied to 1157 * a BoxAndWhiskerXYDataset. 1158 */ 1159 @Test testIterateToFindRangeBounds_BoxAndWhiskerXYDataset()1160 public void testIterateToFindRangeBounds_BoxAndWhiskerXYDataset() { 1161 DefaultBoxAndWhiskerXYDataset dataset 1162 = new DefaultBoxAndWhiskerXYDataset("Series 1"); 1163 List visibleSeriesKeys = new ArrayList(); 1164 visibleSeriesKeys.add("Series 1"); 1165 Range xRange = new Range(Double.NEGATIVE_INFINITY, 1166 Double.POSITIVE_INFINITY); 1167 assertNull(DatasetUtilities.iterateToFindRangeBounds(dataset, 1168 visibleSeriesKeys, xRange, false)); 1169 1170 dataset.add(new Date(50L), new BoxAndWhiskerItem(5.0, 4.9, 2.0, 8.0, 1171 1.0, 9.0, 0.0, 10.0, new ArrayList())); 1172 assertEquals(new Range(5.0, 5.0), 1173 DatasetUtilities.iterateToFindRangeBounds(dataset, 1174 visibleSeriesKeys, xRange, false)); 1175 assertEquals(new Range(1.0, 9.0), 1176 DatasetUtilities.iterateToFindRangeBounds(dataset, 1177 visibleSeriesKeys, xRange, true)); 1178 } 1179 1180 /** 1181 * Some checks for the iterateToFindRangeBounds(CategoryDataset...) 1182 * method. 1183 */ 1184 @Test testIterateToFindRangeBounds_StatisticalCategoryDataset()1185 public void testIterateToFindRangeBounds_StatisticalCategoryDataset() { 1186 DefaultStatisticalCategoryDataset dataset 1187 = new DefaultStatisticalCategoryDataset(); 1188 List visibleSeriesKeys = new ArrayList(); 1189 assertNull(DatasetUtilities.iterateToFindRangeBounds(dataset, 1190 visibleSeriesKeys, false)); 1191 dataset.add(1.0, 0.5, "R1", "C1"); 1192 visibleSeriesKeys.add("R1"); 1193 assertEquals(new Range(1.0, 1.0), 1194 DatasetUtilities.iterateToFindRangeBounds(dataset, 1195 visibleSeriesKeys, false)); 1196 assertEquals(new Range(0.5, 1.5), 1197 DatasetUtilities.iterateToFindRangeBounds(dataset, 1198 visibleSeriesKeys, true)); 1199 } 1200 1201 /** 1202 * Some checks for the iterateToFindRangeBounds(CategoryDataset...) method 1203 * with a {@link MultiValueCategoryDataset}. 1204 */ 1205 @Test testIterateToFindRangeBounds_MultiValueCategoryDataset()1206 public void testIterateToFindRangeBounds_MultiValueCategoryDataset() { 1207 DefaultMultiValueCategoryDataset dataset 1208 = new DefaultMultiValueCategoryDataset(); 1209 List visibleSeriesKeys = new ArrayList(); 1210 assertNull(DatasetUtilities.iterateToFindRangeBounds(dataset, 1211 visibleSeriesKeys, true)); 1212 List values = Arrays.asList(new Double[] {new Double(1.0)}); 1213 dataset.add(values, "R1", "C1"); 1214 visibleSeriesKeys.add("R1"); 1215 assertEquals(new Range(1.0, 1.0), 1216 DatasetUtilities.iterateToFindRangeBounds(dataset, 1217 visibleSeriesKeys, true)); 1218 1219 values = Arrays.asList(new Double[] {new Double(2.0), new Double(3.0)}); 1220 dataset.add(values, "R1", "C2"); 1221 assertEquals(new Range(1.0, 3.0), 1222 DatasetUtilities.iterateToFindRangeBounds(dataset, 1223 visibleSeriesKeys, true)); 1224 1225 values = Arrays.asList(new Double[] {new Double(-1.0), 1226 new Double(-2.0)}); 1227 dataset.add(values, "R2", "C1"); 1228 assertEquals(new Range(1.0, 3.0), 1229 DatasetUtilities.iterateToFindRangeBounds(dataset, 1230 visibleSeriesKeys, true)); 1231 visibleSeriesKeys.add("R2"); 1232 assertEquals(new Range(-2.0, 3.0), 1233 DatasetUtilities.iterateToFindRangeBounds(dataset, 1234 visibleSeriesKeys, true)); 1235 } 1236 1237 /** 1238 * Some checks for the iterateRangeBounds() method when passed an 1239 * IntervalCategoryDataset. 1240 */ 1241 @Test testIterateRangeBounds_IntervalCategoryDataset()1242 public void testIterateRangeBounds_IntervalCategoryDataset() { 1243 TestIntervalCategoryDataset d = new TestIntervalCategoryDataset(); 1244 d.addItem(1.0, 2.0, 3.0, "R1", "C1"); 1245 assertEquals(new Range(1.0, 3.0), 1246 DatasetUtilities.iterateRangeBounds(d)); 1247 1248 d = new TestIntervalCategoryDataset(); 1249 d.addItem(2.5, 2.0, 3.0, "R1", "C1"); 1250 assertEquals(new Range(2.0, 3.0), 1251 DatasetUtilities.iterateRangeBounds(d)); 1252 1253 d = new TestIntervalCategoryDataset(); 1254 d.addItem(4.0, 2.0, 3.0, "R1", "C1"); 1255 assertEquals(new Range(2.0, 4.0), 1256 DatasetUtilities.iterateRangeBounds(d)); 1257 1258 d = new TestIntervalCategoryDataset(); 1259 d.addItem(null, new Double(2.0), new Double(3.0), "R1", "C1"); 1260 assertEquals(new Range(2.0, 3.0), 1261 DatasetUtilities.iterateRangeBounds(d)); 1262 1263 // try some nulls 1264 d = new TestIntervalCategoryDataset(); 1265 d.addItem(null, null, null, "R1", "C1"); 1266 assertNull(DatasetUtilities.iterateRangeBounds(d)); 1267 1268 d = new TestIntervalCategoryDataset(); 1269 d.addItem(new Double(1.0), null, null, "R1", "C1"); 1270 assertEquals(new Range(1.0, 1.0), 1271 DatasetUtilities.iterateRangeBounds(d)); 1272 1273 d = new TestIntervalCategoryDataset(); 1274 d.addItem(null, new Double(1.0), null, "R1", "C1"); 1275 assertEquals(new Range(1.0, 1.0), 1276 DatasetUtilities.iterateRangeBounds(d)); 1277 1278 d = new TestIntervalCategoryDataset(); 1279 d.addItem(null, null, new Double(1.0), "R1", "C1"); 1280 assertEquals(new Range(1.0, 1.0), 1281 DatasetUtilities.iterateRangeBounds(d)); 1282 } 1283 1284 /** 1285 * A test for bug 2849731. 1286 */ 1287 @Test testBug2849731()1288 public void testBug2849731() { 1289 TestIntervalCategoryDataset d = new TestIntervalCategoryDataset(); 1290 d.addItem(2.5, 2.0, 3.0, "R1", "C1"); 1291 d.addItem(new Double(4.0), null, null, "R2", "C1"); 1292 assertEquals(new Range(2.0, 4.0), 1293 DatasetUtilities.iterateRangeBounds(d)); 1294 } 1295 1296 /** 1297 * Another test for bug 2849731. 1298 */ 1299 @Test testBug2849731_2()1300 public void testBug2849731_2() { 1301 XYIntervalSeriesCollection d = new XYIntervalSeriesCollection(); 1302 XYIntervalSeries s = new XYIntervalSeries("S1"); 1303 s.add(1.0, Double.NaN, Double.NaN, Double.NaN, 1.5, Double.NaN); 1304 d.addSeries(s); 1305 Range r = DatasetUtilities.iterateDomainBounds(d); 1306 assertEquals(1.0, r.getLowerBound(), EPSILON); 1307 assertEquals(1.0, r.getUpperBound(), EPSILON); 1308 1309 s.add(1.0, 1.5, Double.NaN, Double.NaN, 1.5, Double.NaN); 1310 r = DatasetUtilities.iterateDomainBounds(d); 1311 assertEquals(1.0, r.getLowerBound(), EPSILON); 1312 assertEquals(1.5, r.getUpperBound(), EPSILON); 1313 1314 s.add(1.0, Double.NaN, 0.5, Double.NaN, 1.5, Double.NaN); 1315 r = DatasetUtilities.iterateDomainBounds(d); 1316 assertEquals(0.5, r.getLowerBound(), EPSILON); 1317 assertEquals(1.5, r.getUpperBound(), EPSILON); 1318 } 1319 /** 1320 * Yet another test for bug 2849731. 1321 */ 1322 @Test testBug2849731_3()1323 public void testBug2849731_3() { 1324 XYIntervalSeriesCollection d = new XYIntervalSeriesCollection(); 1325 XYIntervalSeries s = new XYIntervalSeries("S1"); 1326 s.add(1.0, Double.NaN, Double.NaN, 1.5, Double.NaN, Double.NaN); 1327 d.addSeries(s); 1328 Range r = DatasetUtilities.iterateRangeBounds(d); 1329 assertEquals(1.5, r.getLowerBound(), EPSILON); 1330 assertEquals(1.5, r.getUpperBound(), EPSILON); 1331 1332 s.add(1.0, 1.5, Double.NaN, Double.NaN, Double.NaN, 2.5); 1333 r = DatasetUtilities.iterateRangeBounds(d); 1334 assertEquals(1.5, r.getLowerBound(), EPSILON); 1335 assertEquals(2.5, r.getUpperBound(), EPSILON); 1336 1337 s.add(1.0, Double.NaN, 0.5, Double.NaN, 3.5, Double.NaN); 1338 r = DatasetUtilities.iterateRangeBounds(d); 1339 assertEquals(1.5, r.getLowerBound(), EPSILON); 1340 assertEquals(3.5, r.getUpperBound(), EPSILON); 1341 } 1342 1343 /** 1344 * Check the findYValue() method with a dataset that is in ascending order 1345 * of x-values. 1346 */ 1347 @Test testFindYValue()1348 public void testFindYValue() { 1349 XYSeries series = new XYSeries("S1"); 1350 XYSeriesCollection dataset = new XYSeriesCollection(series); 1351 assertTrue(Double.isNaN(DatasetUtilities.findYValue(dataset, 0, 100.0))); 1352 1353 series.add(1.0, 5.0); 1354 assertTrue(Double.isNaN(DatasetUtilities.findYValue(dataset, 0, 0.0))); 1355 assertEquals(5.0, DatasetUtilities.findYValue(dataset, 0, 1.0), EPSILON); 1356 assertTrue(Double.isNaN(DatasetUtilities.findYValue(dataset, 0, 2.0))); 1357 1358 series.add(2.0, 10.0); 1359 assertTrue(Double.isNaN(DatasetUtilities.findYValue(dataset, 0, 0.0))); 1360 assertEquals(5.0, DatasetUtilities.findYValue(dataset, 0, 1.0), EPSILON); 1361 assertEquals(6.25, DatasetUtilities.findYValue(dataset, 0, 1.25), EPSILON); 1362 assertEquals(7.5, DatasetUtilities.findYValue(dataset, 0, 1.5), EPSILON); 1363 assertEquals(10.0, DatasetUtilities.findYValue(dataset, 0, 2.0), EPSILON); 1364 assertTrue(Double.isNaN(DatasetUtilities.findYValue(dataset, 0, 3.0))); 1365 } 1366 1367 /** 1368 * Check the findYValue() method with a dataset that is not sorted. 1369 */ 1370 @Test testFindYValueNonSorted()1371 public void testFindYValueNonSorted() { 1372 XYSeries series = new XYSeries("S1", false); 1373 XYSeriesCollection dataset = new XYSeriesCollection(series); 1374 assertTrue(Double.isNaN(DatasetUtilities.findYValue(dataset, 0, 100.0))); 1375 1376 series.add(1.0, 5.0); 1377 assertTrue(Double.isNaN(DatasetUtilities.findYValue(dataset, 0, 0.0))); 1378 assertEquals(5.0, DatasetUtilities.findYValue(dataset, 0, 1.0), EPSILON); 1379 assertTrue(Double.isNaN(DatasetUtilities.findYValue(dataset, 0, 2.0))); 1380 1381 series.add(0.0, 10.0); 1382 series.add(4.0, 20.0); 1383 assertTrue(Double.isNaN(DatasetUtilities.findYValue(dataset, 0, -0.5))); 1384 assertEquals(10.0, DatasetUtilities.findYValue(dataset, 0, 0.0), EPSILON); 1385 assertEquals(5.0, DatasetUtilities.findYValue(dataset, 0, 1.0), EPSILON); 1386 assertEquals(15.0, DatasetUtilities.findYValue(dataset, 0, 2.0), EPSILON); 1387 assertEquals(20.0, DatasetUtilities.findYValue(dataset, 0, 4.0), EPSILON); 1388 assertEquals(17.5, DatasetUtilities.findYValue(dataset, 0, 3.0), EPSILON); 1389 assertTrue(Double.isNaN(DatasetUtilities.findYValue(dataset, 0, 5.0))); 1390 } 1391 1392 /** 1393 * Check the findYValue() method with a dataset that allows duplicate 1394 * values. 1395 */ 1396 @Test testFindYValueWithDuplicates()1397 public void testFindYValueWithDuplicates() { 1398 XYSeries series = new XYSeries("S1", true, true); 1399 XYSeriesCollection dataset = new XYSeriesCollection(series); 1400 assertTrue(Double.isNaN(DatasetUtilities.findYValue(dataset, 0, 100.0))); 1401 1402 series.add(1.0, 5.0); 1403 assertTrue(Double.isNaN(DatasetUtilities.findYValue(dataset, 0, 0.0))); 1404 assertEquals(5.0, DatasetUtilities.findYValue(dataset, 0, 1.0), EPSILON); 1405 assertTrue(Double.isNaN(DatasetUtilities.findYValue(dataset, 0, 2.0))); 1406 1407 series.add(1.0, 10.0); 1408 assertTrue(Double.isNaN(DatasetUtilities.findYValue(dataset, 0, 0.0))); 1409 assertEquals(5.0, DatasetUtilities.findYValue(dataset, 0, 1.0), EPSILON); 1410 assertTrue(Double.isNaN(DatasetUtilities.findYValue(dataset, 0, 2.0))); 1411 1412 series.add(2.0, 10.0); 1413 assertTrue(Double.isNaN(DatasetUtilities.findYValue(dataset, 0, 0.0))); 1414 assertEquals(5.0, DatasetUtilities.findYValue(dataset, 0, 1.0), EPSILON); 1415 assertEquals(10.0, DatasetUtilities.findYValue(dataset, 0, 1.25), EPSILON); 1416 assertEquals(10.0, DatasetUtilities.findYValue(dataset, 0, 1.5), EPSILON); 1417 assertEquals(10.0, DatasetUtilities.findYValue(dataset, 0, 2.0), EPSILON); 1418 assertTrue(Double.isNaN(DatasetUtilities.findYValue(dataset, 0, 3.0))); 1419 } 1420 1421 } 1422