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