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