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