org.eclipse.linuxtools.tmf.ui.tests/src/org/eclipse/linuxtools/tmf/ui/tests/histogram/HistogramDataModelTest.java

   1 /*******************************************************************************
   2  * Copyright (c) 2011, 2013 Ericsson
   3  *
   4  * All rights reserved. This program and the accompanying materials are
   5  * made available under the terms of the Eclipse Public License v1.0 which
   6  * accompanies this distribution, and is available at
   7  * http://www.eclipse.org/legal/epl-v10.html
   8  *
   9  * Contributors:
  10  *   Francois Chouinard - Initial API and implementation
  11  *   Bernd Hufmann - Adapt to junit.framework.TestCase
  12  *   Alexandre Montplaisir - Port to JUnit4
  13  *   Patrick Tasse - Support selection range
  14  *******************************************************************************/
  15
  16 package org.eclipse.linuxtools.tmf.ui.tests.histogram;
  17
  18 import static org.junit.Assert.assertEquals;
  19 import static org.junit.Assert.assertTrue;
  20 import static org.junit.Assert.fail;
  21
  22 import org.eclipse.linuxtools.tmf.ui.views.histogram.HistogramDataModel;
  23 import org.eclipse.linuxtools.tmf.ui.views.histogram.HistogramScaledData;
  24 import org.eclipse.linuxtools.tmf.ui.views.histogram.IHistogramModelListener;
  25 import org.junit.Test;
  26
  27 /**
  28  * Unit tests for the HistogramDataModel class.
  29  */
  30 public class HistogramDataModelTest {
  31
  32     private static final double DELTA = 1e-15;
  33
  34     /**
  35      * Test method for {@link HistogramDataModel#HistogramDataModel()}.
  36      */
  37     @Test
  38     public void testHistogramDataModel() {
  39         HistogramDataModel model = new HistogramDataModel();
  40         assertTrue(model.getNbBuckets() == HistogramDataModel.DEFAULT_NUMBER_OF_BUCKETS);
  41         assertTrue(model.getNbEvents() == 0);
  42         assertTrue(model.getBucketDuration() == 1);
  43         assertTrue(model.getFirstBucketTime() == 0);
  44         assertTrue(model.getStartTime() == 0);
  45         assertTrue(model.getEndTime() == 0);
  46         assertTrue(model.getTimeLimit() == HistogramDataModel.DEFAULT_NUMBER_OF_BUCKETS);
  47     }
  48
  49     /**
  50      * Test method for {@link HistogramDataModel#HistogramDataModel(int)}.
  51      */
  52     @Test
  53     public void testHistogramDataModelInt() {
  54         final int nbBuckets = 5 * 1000;
  55         HistogramDataModel model = new HistogramDataModel(nbBuckets);
  56         assertTrue(model.getNbEvents() == 0);
  57         assertTrue(model.getNbBuckets() == nbBuckets);
  58         assertTrue(model.getBucketDuration() == 1);
  59         assertTrue(model.getFirstBucketTime() == 0);
  60         assertTrue(model.getStartTime() == 0);
  61         assertTrue(model.getEndTime() == 0);
  62         assertTrue(model.getTimeLimit() == nbBuckets);
  63     }
  64
  65     /**
  66      * Test methods for {@link HistogramDataModel#countEvent(long,long)}.
  67      */
  68     @Test
  69     public void testClear() {
  70         final int nbBuckets = 100;
  71         HistogramDataModel model = new HistogramDataModel(nbBuckets);
  72         model.countEvent(0, -1);
  73
  74         assertTrue(model.getNbEvents() == 0);
  75         assertTrue(model.getNbBuckets() == nbBuckets);
  76         assertTrue(model.getBucketDuration() == 1);
  77         assertTrue(model.getFirstBucketTime() == 0);
  78         assertTrue(model.getStartTime() == 0);
  79         assertTrue(model.getEndTime() == 0);
  80         assertTrue(model.getTimeLimit() == nbBuckets);
  81     }
  82
  83     /**
  84      * Test methods for {@link HistogramDataModel#countEvent(long,long)}.
  85      */
  86     @Test
  87     public void testCountEvent_0() {
  88         final int nbBuckets = 100;
  89         HistogramDataModel model = new HistogramDataModel(nbBuckets);
  90         model.countEvent(0, -1);
  91
  92         assertTrue(model.getNbEvents() == 0);
  93         assertTrue(model.getNbBuckets() == nbBuckets);
  94         assertTrue(model.getBucketDuration() == 1);
  95         assertTrue(model.getFirstBucketTime() == 0);
  96         assertTrue(model.getStartTime() == 0);
  97         assertTrue(model.getEndTime() == 0);
  98         assertTrue(model.getTimeLimit() == nbBuckets);
  99     }
 100
 101     /**
 102      * Test methods for {@link HistogramDataModel#countEvent(long,long)} and
 103      * {@link HistogramDataModel#scaleTo(int,int,int)}.
 104      */
 105     @Test
 106     public void testCountEvent_1() {
 107         final int nbBuckets = 100;
 108         final int maxHeight = 10;
 109
 110         HistogramDataModel model = new HistogramDataModel(nbBuckets);
 111
 112         HistogramScaledData result = model.scaleTo(nbBuckets, maxHeight, 1);
 113         for (int i = 0; i < result.fData.length; i++) {
 114             assertTrue(result.fData[i] == 0);
 115         }
 116
 117         assertTrue(model.getNbEvents() == 0);
 118         assertTrue(model.getNbBuckets() == nbBuckets);
 119         assertTrue(model.getBucketDuration() == 1);
 120         assertTrue(model.getFirstBucketTime() == 0);
 121         assertTrue(model.getStartTime() == 0);
 122         assertTrue(model.getEndTime() == 0);
 123         assertTrue(model.getTimeLimit() == nbBuckets);
 124     }
 125
 126     /**
 127      * Test methods for {@link HistogramDataModel#countEvent(long,long)} and
 128      * {@link HistogramDataModel#scaleTo(int,int,int)}.
 129      */
 130     @Test
 131     public void testCountEvent_2() {
 132         final int nbBuckets = 100;
 133         final int maxHeight = 10;
 134
 135         HistogramDataModel model = new HistogramDataModel(nbBuckets);
 136         model.countEvent(0, 1);
 137
 138         HistogramScaledData result = model.scaleTo(nbBuckets, maxHeight, 1);
 139         assertTrue(result.fData[0] == 1);
 140         for (int i = 1; i < result.fData.length; i++) {
 141             assertTrue(result.fData[i] == 0);
 142         }
 143
 144         assertTrue(model.getNbEvents() == 1);
 145         assertTrue(model.getNbBuckets() == nbBuckets);
 146         assertTrue(model.getBucketDuration() == 1);
 147         assertTrue(model.getFirstBucketTime() == 1);
 148         assertTrue(model.getStartTime() == 1);
 149         assertTrue(model.getEndTime() == 1);
 150         assertTrue(model.getTimeLimit() == nbBuckets + 1);
 151     }
 152
 153     /**
 154      * Test methods for {@link HistogramDataModel#countEvent(long,long)} and
 155      * {@link HistogramDataModel#scaleTo(int,int,int)}.
 156      */
 157     @Test
 158     public void testCountEvent_3() {
 159         final int nbBuckets = 100;
 160         final int maxHeight = 10;
 161
 162         HistogramDataModel model = new HistogramDataModel(nbBuckets);
 163         for (int i = 0; i < nbBuckets; i++) {
 164             model.countEvent(i, i);
 165         }
 166
 167         HistogramScaledData result = model.scaleTo(nbBuckets, maxHeight, 1);
 168         for (int i = 0; i < result.fData.length; i++) {
 169             assertTrue(result.fData[i] == 1);
 170         }
 171
 172         assertTrue(model.getNbEvents() == nbBuckets);
 173         assertTrue(model.getNbBuckets() == nbBuckets);
 174         assertTrue(model.getBucketDuration() == 1);
 175         assertTrue(model.getFirstBucketTime() == 0);
 176         assertTrue(model.getStartTime() == 0);
 177         assertTrue(model.getEndTime() == nbBuckets - 1);
 178         assertTrue(model.getTimeLimit() == nbBuckets);
 179     }
 180
 181     /**
 182      * Test methods for {@link HistogramDataModel#countEvent(long,long)} and
 183      * {@link HistogramDataModel#scaleTo(int,int,int)}.
 184      */
 185     @Test
 186     public void testCountEvent_4() {
 187         final int nbBuckets = 100;
 188         final int maxHeight = 10;
 189
 190         HistogramDataModel model = new HistogramDataModel(nbBuckets);
 191         for (int i = 0; i < nbBuckets; i++) {
 192             model.countEvent(i, i);
 193             model.countEvent(i+1, i);
 194         }
 195
 196         HistogramScaledData result = model.scaleTo(nbBuckets, maxHeight, 1);
 197         for (int i = 0; i < result.fData.length; i++) {
 198             assertTrue(result.fData[i] == 2);
 199         }
 200
 201         assertTrue(model.getNbEvents() == 2 * nbBuckets);
 202         assertTrue(model.getNbBuckets() == nbBuckets);
 203         assertTrue(model.getBucketDuration() == 1);
 204         assertTrue(model.getFirstBucketTime() == 0);
 205         assertTrue(model.getStartTime() == 0);
 206         assertTrue(model.getEndTime() == nbBuckets - 1);
 207         assertTrue(model.getTimeLimit() == nbBuckets);
 208     }
 209
 210     /**
 211      * Test methods for {@link HistogramDataModel#countEvent(long,long)} and
 212      * {@link HistogramDataModel#scaleTo(int,int,int)}.
 213      */
 214     @Test
 215     public void testCountEvent_5() {
 216         final int nbBuckets = 100;
 217         final int startTime = 25;
 218         final int maxHeight = 10;
 219
 220         HistogramDataModel model = new HistogramDataModel(nbBuckets);
 221         for (int i = startTime; i < startTime + nbBuckets; i++) {
 222             model.countEvent(i, i);
 223         }
 224
 225         HistogramScaledData result = model.scaleTo(nbBuckets, maxHeight, 1);
 226         for (int i = 0; i < result.fData.length; i++) {
 227             assertTrue(result.fData[i] == 1);
 228         }
 229
 230         assertTrue(model.getNbEvents() == nbBuckets);
 231         assertTrue(model.getNbBuckets() == nbBuckets);
 232         assertTrue(model.getBucketDuration() == 1);
 233         assertTrue(model.getFirstBucketTime() == startTime);
 234         assertTrue(model.getStartTime() == startTime);
 235         assertTrue(model.getEndTime() == startTime + nbBuckets - 1);
 236         assertTrue(model.getTimeLimit() == startTime + nbBuckets);
 237     }
 238
 239     /**
 240      * Test method for {@link HistogramDataModel#scaleTo(int,int,int)}.
 241      */
 242     @Test
 243     public void testScaleTo_0() {
 244         HistogramDataModel model = new HistogramDataModel(10);
 245         try {
 246             model.scaleTo(10, 0, 1);
 247         }
 248         catch (AssertionError e1) {
 249             try {
 250                 model.scaleTo(0, 10, 1);
 251             }
 252             catch (AssertionError e2) {
 253                 try {
 254                     model.scaleTo(0, 0, 1);
 255                 }
 256                 catch (AssertionError e3) {
 257                     return;
 258                 }
 259             }
 260         }
 261         fail("Uncaught assertion error");
 262     }
 263
 264     /**
 265      * Test method for {@link HistogramDataModel#scaleTo(int,int,int)}.
 266      */
 267     @Test
 268     public void testScaleTo_1() {
 269         final int nbBuckets = 10;
 270         final int maxHeight = 10;
 271         final int nbEvents = nbBuckets / 2;
 272         final int[] expectedResult = new int[] { 1, 1, 1, 1, 1, 0, 0, 0, 0, 0 };
 273
 274         HistogramDataModel model = new HistogramDataModel(nbBuckets);
 275         for (int i = 0; i < nbEvents; i++) {
 276             model.countEvent(i, i);
 277         }
 278
 279         HistogramScaledData result = model.scaleTo(nbBuckets, maxHeight, 1);
 280         for (int i = 0; i < result.fData.length; i++) {
 281             assertTrue(result.fData[i] == expectedResult[i]);
 282         }
 283
 284         assertTrue(model.getNbEvents() == nbEvents);
 285         assertTrue(model.getNbBuckets() == nbBuckets);
 286         assertTrue(model.getBucketDuration() == 1);
 287         assertTrue(model.getFirstBucketTime() == 0);
 288         assertTrue(model.getStartTime() == 0);
 289         assertTrue(model.getEndTime() == nbEvents - 1);
 290         assertTrue(model.getTimeLimit() == nbBuckets);
 291     }
 292
 293     /**
 294      * Test method for {@link HistogramDataModel#scaleTo(int,int,int)}.
 295      */
 296     @Test
 297     public void testScaleTo_2() {
 298         final int nbBuckets = 10;
 299         final int maxHeight = 10;
 300         final int nbEvents = nbBuckets;
 301         final int[] expectedResult = new int[] { 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 };
 302
 303         HistogramDataModel model = new HistogramDataModel(nbBuckets);
 304         for (int i = 0; i < nbEvents; i++) {
 305             model.countEvent(i, i);
 306         }
 307
 308         HistogramScaledData result = model.scaleTo(nbBuckets, maxHeight, 1);
 309         for (int i = 0; i < result.fData.length; i++) {
 310             assertTrue(result.fData[i] == expectedResult[i]);
 311         }
 312
 313         assertTrue(model.getNbEvents() == nbEvents);
 314         assertTrue(model.getNbBuckets() == nbBuckets);
 315         assertTrue(model.getBucketDuration() == 1);
 316         assertTrue(model.getFirstBucketTime() == 0);
 317         assertTrue(model.getStartTime() == 0);
 318         assertTrue(model.getEndTime() == nbEvents - 1);
 319         assertTrue(model.getTimeLimit() == nbBuckets);
 320     }
 321
 322     /**
 323      * Test method for {@link HistogramDataModel#scaleTo(int,int,int)}.
 324      */
 325     @Test
 326     public void testScaleTo_3() {
 327         final int nbBuckets = 10;
 328         final int maxHeight = 10;
 329         final int nbEvents = 2 * nbBuckets;
 330         final int[] expectedResult = new int[] { 2, 2, 2, 2, 2, 2, 2, 2, 2, 2 };
 331
 332         HistogramDataModel model = new HistogramDataModel(nbBuckets);
 333         for (int i = 0; i < nbEvents; i++) {
 334             model.countEvent(i, i);
 335         }
 336
 337         HistogramScaledData result = model.scaleTo(nbBuckets, maxHeight, 1);
 338         for (int i = 0; i < result.fData.length; i++) {
 339             assertTrue(result.fData[i] == expectedResult[i]);
 340         }
 341
 342         assertTrue(model.getNbEvents() == nbEvents);
 343         assertTrue(model.getNbBuckets() == nbBuckets);
 344         assertTrue(model.getBucketDuration() == 2);
 345         assertTrue(model.getFirstBucketTime() == 0);
 346         assertTrue(model.getStartTime() == 0);
 347         assertTrue(model.getEndTime() == nbEvents - 1);
 348         assertTrue(model.getTimeLimit() == 2 * nbBuckets);
 349     }
 350
 351     /**
 352      * Test method for {@link HistogramDataModel#scaleTo(int,int,int)}.
 353      */
 354     @Test
 355     public void testScaleTo_4() {
 356         final int nbBuckets = 10;
 357         final int maxHeight = 10;
 358         final int nbEvents = 3 * nbBuckets;
 359         final int[] expectedResult = new int[] { 4, 4, 4, 4, 4, 4, 4, 2, 0, 0 };
 360
 361         HistogramDataModel model = new HistogramDataModel(nbBuckets);
 362         for (int i = 0; i < nbEvents; i++) {
 363             model.countEvent(i, i);
 364         }
 365
 366         HistogramScaledData result = model.scaleTo(nbBuckets, maxHeight, 1);
 367         for (int i = 0; i < result.fData.length; i++) {
 368             assertTrue(result.fData[i] == expectedResult[i]);
 369         }
 370
 371         assertTrue(model.getNbEvents() == nbEvents);
 372         assertTrue(model.getNbBuckets() == nbBuckets);
 373         assertTrue(model.getBucketDuration() == 4);
 374         assertTrue(model.getFirstBucketTime() == 0);
 375         assertTrue(model.getStartTime() == 0);
 376         assertTrue(model.getEndTime() == nbEvents - 1);
 377         assertTrue(model.getTimeLimit() == 4 * nbBuckets);
 378     }
 379
 380     /**
 381      * Test method for {@link HistogramDataModel#scaleTo(int,int,int)}.
 382      */
 383     @Test
 384     public void testScaleTo_5() {
 385         final int nbBuckets = 100;
 386         final int maxHeight = 20;
 387         final int nbEvents = 2 * nbBuckets;
 388         final int[] expectedResult = new int[] { 20, 20, 20, 20, 20, 20, 20, 20, 20, 20 };
 389
 390         HistogramDataModel model = new HistogramDataModel(nbBuckets);
 391         for (int i = 0; i < nbEvents; i++) {
 392             model.countEvent(i, i);
 393         }
 394
 395         HistogramScaledData result = model.scaleTo(10, maxHeight, 1);
 396         for (int i = 0; i < result.fData.length; i++) {
 397             assertTrue(result.fData[i] == expectedResult[i]);
 398         }
 399
 400         assertTrue(model.getNbEvents() == nbEvents);
 401         assertTrue(model.getNbBuckets() == nbBuckets);
 402         assertTrue(model.getBucketDuration() == 2);
 403         assertTrue(model.getFirstBucketTime() == 0);
 404         assertTrue(model.getEndTime() == nbEvents - 1);
 405         assertTrue(model.getTimeLimit() == 2 * nbBuckets);
 406     }
 407
 408     /**
 409      * Test method for {@link HistogramDataModel#scaleTo(int,int,int)}.
 410      */
 411     @Test
 412     public void testScaleTo_6() {
 413         final int nbBuckets = 100;
 414         final int maxHeight = 24;
 415         final int nbEvents = 2 * nbBuckets + 1;
 416         final int[] expectedResult = new int[] { 24, 24, 24, 24, 24, 24, 24, 24, 9, 0 };
 417
 418         HistogramDataModel model = new HistogramDataModel(nbBuckets);
 419         for (int i = 0; i < nbEvents; i++) {
 420             model.countEvent(i, i);
 421         }
 422
 423         HistogramScaledData result = model.scaleTo(10, maxHeight, 1);
 424         for (int i = 0; i < result.fData.length; i++) {
 425             assertTrue(result.fData[i] == expectedResult[i]);
 426         }
 427
 428         assertTrue(model.getNbEvents() == nbEvents);
 429         assertTrue(model.getNbBuckets() == nbBuckets);
 430         assertTrue(model.getBucketDuration() == 4);
 431         assertTrue(model.getFirstBucketTime() == 0);
 432         assertTrue(model.getStartTime() == 0);
 433         assertTrue(model.getEndTime() == nbEvents - 1);
 434         assertTrue(model.getTimeLimit() == 4 * nbBuckets);
 435     }
 436
 437     /**
 438      * Test method for {@link HistogramDataModel#scaleTo(int,int,int)}.
 439      */
 440     @Test
 441     public void testScaleTo_7() {
 442         // verify scaleTo with barWidth > 1
 443         final int nbBuckets = 100;
 444         final int maxHeight = 24;
 445         final int width = 10;
 446         final int barWidth = 4;
 447         final int nbEvents = 2 * nbBuckets + 1;
 448
 449         // (int)(width / barWith) = 2
 450         // -> 2 bars -> expected result needs two buckets (scaled data)
 451         //
 452         // buckets (in model) per bar = last bucket id / nbBars + 1 (plus 1 to cover all used buckets)
 453         // -> buckets per bar = 50 / 2 + 1 = 26
 454         // -> first entry in expected result is 26 * 4 = 104
 455         // -> second entry in expected result is 22 * 4 + 9 = 97
 456         final int[] expectedResult = new int[] { 104, 97 };
 457
 458         HistogramDataModel model = new HistogramDataModel(nbBuckets);
 459         for (int i = 0; i < nbEvents; i++) {
 460             model.countEvent(i, i);
 461         }
 462
 463         // verify scaled data
 464         HistogramScaledData result = model.scaleTo(width, maxHeight, barWidth);
 465
 466         assertEquals(4 * 26, result.fBucketDuration);
 467         assertEquals(0, result.fSelectionBeginBucket);
 468         assertEquals(0, result.fSelectionEndBucket);
 469         assertEquals(0, result.fFirstBucketTime);
 470         assertEquals(0, result.fFirstEventTime);
 471         assertEquals(1, result.fLastBucket);
 472         assertEquals(104, result.fMaxValue);
 473         assertEquals((double)maxHeight/104, result.fScalingFactor, DELTA);
 474         assertEquals(maxHeight, result.fHeight);
 475         assertEquals(width, result.fWidth);
 476         assertEquals(barWidth, result.fBarWidth);
 477
 478         for (int i = 0; i < result.fData.length; i++) {
 479             assertEquals(expectedResult[i], result.fData[i]);
 480         }
 481
 482         // verify model
 483         assertEquals(nbEvents, model.getNbEvents());
 484         assertEquals(nbBuckets, model.getNbBuckets());
 485         assertEquals(4, model.getBucketDuration());
 486         assertEquals(0, model.getFirstBucketTime());
 487         assertEquals(0, model.getStartTime());
 488         assertEquals(nbEvents - 1, model.getEndTime());
 489         assertEquals(4 * nbBuckets, model.getTimeLimit());
 490     }
 491
 492     /**
 493      * Test method for {@link HistogramDataModel#scaleTo(int,int,int)}.
 494      */
 495     @Test
 496     public void testScaleToReverse_1() {
 497         final int nbBuckets = 100;
 498         final int maxHeight = 24;
 499         final int width = 10;
 500         final int barWidth = 1;
 501         final int nbEvents = 2 * nbBuckets + 1;
 502
 503         // (int)(width / barWith) = 10
 504         // -> 10 bars -> expected result needs 10 buckets (scaled data)
 505         //
 506         // buckets in (model) per bar = last bucket id / nbBars + 1 (plus 1 to cover all used buckets)
 507         // -> buckets per bar = 50 / 10 + 1 = 6
 508         final int[] expectedResult = new int[] { 21, 24, 24, 24, 24, 24, 24, 24, 12, 0 };
 509
 510         HistogramDataModel model = new HistogramDataModel(nbBuckets);
 511         for (int i = nbEvents - 1; i >= 0; i--) {
 512             model.countEvent(i, i);
 513         }
 514
 515         // verify scaled data
 516         HistogramScaledData result = model.scaleTo(width, maxHeight, barWidth);
 517
 518         assertEquals(4 * 6, result.fBucketDuration);
 519         assertEquals(0, result.fSelectionBeginBucket);
 520         assertEquals(0, result.fSelectionEndBucket);
 521         assertEquals(-3, result.fFirstBucketTime); // negative is correct, can happen when reverse
 522         assertEquals(0, result.fFirstEventTime);
 523         assertEquals(9, result.fLastBucket);
 524         assertEquals(24, result.fMaxValue);
 525         assertEquals((double)maxHeight/24, result.fScalingFactor, DELTA);
 526         assertEquals(maxHeight, result.fHeight);
 527         assertEquals(width, result.fWidth);
 528         assertEquals(barWidth, result.fBarWidth);
 529
 530         for (int i = 0; i < result.fData.length; i++) {
 531             assertEquals(expectedResult[i], result.fData[i]);
 532         }
 533
 534         // verify model
 535         assertEquals(nbEvents, model.getNbEvents());
 536         assertEquals(nbBuckets, model.getNbBuckets());
 537         assertEquals(4, model.getBucketDuration());
 538         assertEquals(-3, model.getFirstBucketTime());
 539         assertEquals(0, model.getStartTime());
 540         assertEquals(nbEvents - 1, model.getEndTime());
 541         assertEquals(-3 + 4 * nbBuckets, model.getTimeLimit());
 542     }
 543
 544     /**
 545      * Test method for {@link HistogramDataModel#scaleTo(int,int,int)}.
 546      */
 547     @Test
 548     public void testScaleToReverse_2() {
 549         final int nbBuckets = 100;
 550         final int maxHeight = 24;
 551         final int width = 10;
 552         final int barWidth = 1;
 553
 554         final int nbEvents = 2 * nbBuckets;
 555
 556         HistogramDataModel model = new HistogramDataModel(nbBuckets);
 557         for (int i = 0; i < nbEvents; i++) {
 558             model.countEvent(i, i);
 559         }
 560
 561         HistogramScaledData result = model.scaleTo(width, maxHeight, barWidth);
 562
 563         model.clear();
 564
 565         for (int i = nbEvents -1; i >= 0; i--) {
 566             model.countEvent(i, i);
 567         }
 568
 569         HistogramScaledData revResult = model.scaleTo(width, maxHeight, barWidth);
 570
 571         assertEquals(nbEvents, model.getNbEvents());
 572         assertEquals(nbBuckets, model.getNbBuckets());
 573         assertEquals(2, model.getBucketDuration());
 574         assertEquals(0, model.getFirstBucketTime());
 575         assertEquals(0, model.getStartTime());
 576         assertEquals(nbEvents - 1, model.getEndTime());
 577         assertEquals(2 * nbBuckets, model.getTimeLimit());
 578
 579         // For the above number of events, result and revResult are exactly the same.
 580         assertEquals(result.fBucketDuration, revResult.fBucketDuration);
 581         assertEquals(result.fSelectionBeginBucket, revResult.fSelectionBeginBucket);
 582         assertEquals(result.fSelectionEndBucket, revResult.fSelectionEndBucket);
 583         assertEquals(result.fFirstBucketTime, revResult.fFirstBucketTime);
 584         assertEquals(result.fMaxValue, revResult.fMaxValue);
 585         assertEquals(result.fScalingFactor, revResult.fScalingFactor, DELTA);
 586         assertEquals(result.fLastBucket, revResult.fLastBucket);
 587         assertEquals(result.getBucketEndTime(0), revResult.getBucketEndTime(0));
 588         assertEquals(result.getBucketStartTime(0), revResult.getBucketStartTime(0));
 589
 590         for (int i = 0; i < result.fData.length; i++) {
 591             assertTrue(result.fData[i] == revResult.fData[i]);
 592         }
 593     }
 594
 595     /**
 596      * Test method for testing model listener.
 597      */
 598     @Test
 599     public void testModelListener() {
 600         final int nbBuckets = 2000;
 601         final int nbEvents = 10 * nbBuckets + 256;
 602         final int[] count = new int[1];
 603         count [0] = 0;
 604
 605         // Test add listener and call of listener
 606         IHistogramModelListener listener = new IHistogramModelListener() {
 607             @Override
 608             public void modelUpdated() {
 609                 count[0]++;
 610             }
 611         };
 612
 613         // Test that the listener interface is called every 16000 events.
 614         HistogramDataModel model = new HistogramDataModel(nbBuckets);
 615         model.addHistogramListener(listener);
 616         for (int i = 0; i < nbEvents; i++) {
 617             model.countEvent(i+1, i);
 618         }
 619
 620         assertTrue(count[0] == 1);
 621
 622         // Test that the listener interface is called when complete is called.
 623         model.complete();
 624         assertTrue(count[0] == 2);
 625
 626         // Test that clear triggers call of listener interface
 627         model.clear();
 628         assertTrue(count[0] == 3);
 629
 630         // Test remove listener
 631         count[0] = 0;
 632         model.removeHistogramListener(listener);
 633
 634         for (int i = 0; i < nbEvents; i++) {
 635             model.countEvent(i, i);
 636         }
 637         model.complete();
 638         assertTrue(count[0] == 0);
 639     }
 640 }