1 /*******************************************************************************
2 * Copyright (c) 2011, 2013 Ericsson
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
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 *******************************************************************************/
16 package org
.eclipse
.linuxtools
.tmf
.ui
.tests
.histogram
;
18 import static org
.junit
.Assert
.assertArrayEquals
;
19 import static org
.junit
.Assert
.assertEquals
;
20 import static org
.junit
.Assert
.fail
;
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
;
33 * Unit tests for the HistogramDataModel class.
35 public class HistogramDataModelTest
{
37 private static final double DELTA
= 1e-15;
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});
48 * Test method for {@link HistogramDataModel#HistogramDataModel()}.
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
);
57 * Test method for {@link HistogramDataModel#HistogramDataModel(HistogramDataModel)}.
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
);
67 * Test method for {@link HistogramDataModel#HistogramDataModel(int)}.
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
);
77 * Test methods for {@link HistogramDataModel#countEvent(long,long, ITmfTrace)}.
80 public void testClear() {
81 final int nbBuckets
= 100;
82 HistogramDataModel model
= new HistogramDataModel(nbBuckets
);
83 model
.countEvent(0, -1, null);
85 testModelConsistency(model
, nbBuckets
, 0, 1, 0, 0, 0, nbBuckets
);
89 * Test methods for {@link HistogramDataModel#countEvent(long,long, ITmfTrace)}.
92 public void testCountEvent_0() {
93 final int nbBuckets
= 100;
94 HistogramDataModel model
= new HistogramDataModel(nbBuckets
);
95 model
.countEvent(0, -1, null);
97 testModelConsistency(model
, nbBuckets
, 0, 1, 0, 0, 0, nbBuckets
);
101 * Test methods for {@link HistogramDataModel#countEvent(long,long, ITmfTrace)} and
102 * {@link HistogramDataModel#scaleTo(int,int,int)}.
105 public void testCountEvent_1() {
106 final int nbBuckets
= 100;
107 final int maxHeight
= 10;
109 HistogramDataModel model
= new HistogramDataModel(nbBuckets
);
111 HistogramScaledData result
= model
.scaleTo(nbBuckets
, maxHeight
, 1);
113 for (int i
= 0; i
< result
.fData
.length
; i
++) {
114 assertEquals(_0
, result
.fData
[i
]);
117 testModelConsistency(model
, nbBuckets
, 0, 1, 0, 0, 0, nbBuckets
);
121 * Test methods for {@link HistogramDataModel#countEvent(long,long, ITmfTrace)} and
122 * {@link HistogramDataModel#scaleTo(int,int,int)}.
125 public void testCountEvent_2() {
126 final int nbBuckets
= 100;
127 final int maxHeight
= 10;
129 HistogramDataModel model
= new HistogramDataModel(nbBuckets
);
130 model
.countEvent(0, 1, null);
132 HistogramScaledData result
= model
.scaleTo(nbBuckets
, maxHeight
, 1);
133 assertEquals(_1
, result
.fData
[0]);
135 assertArrayEqualsInt(0, result
.fData
,1);
137 testModelConsistency(model
, nbBuckets
, 1, 1, 1, 1, 1, nbBuckets
+ 1);
141 * Test methods for {@link HistogramDataModel#countEvent(long,long, ITmfTrace)} and
142 * {@link HistogramDataModel#scaleTo(int,int,int)}.
145 public void testCountEvent_3() {
146 final int nbBuckets
= 100;
147 final int maxHeight
= 10;
149 HistogramDataModel model
= new HistogramDataModel(nbBuckets
);
150 countEventsInModel(nbBuckets
, model
);
152 HistogramScaledData result
= model
.scaleTo(nbBuckets
, maxHeight
, 1);
154 assertArrayEqualsInt(1, result
.fData
);
156 testModelConsistency(model
, nbBuckets
, nbBuckets
, 1, 0, 0, nbBuckets
- 1, nbBuckets
);
160 * Test methods for {@link HistogramDataModel#countEvent(long,long,ITmfTrace)} and
161 * {@link HistogramDataModel#scaleTo(int,int,int)}.
164 public void testCountEvent_4() {
165 final int nbBuckets
= 100;
166 final int maxHeight
= 10;
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);
175 HistogramScaledData result
= model
.scaleTo(nbBuckets
, maxHeight
, 1);
177 assertArrayEqualsInt(2, result
.fData
);
179 testModelConsistency(model
, nbBuckets
, 2 * nbBuckets
, 1, 0, 0, nbBuckets
- 1, nbBuckets
);
184 * Test methods for {@link HistogramDataModel#countEvent(long,long,ITmfTrace)} and
185 * {@link HistogramDataModel#scaleTo(int,int,int)}.
188 public void testCountEvent_5() {
189 final int nbBuckets
= 100;
190 final int startTime
= 25;
191 final int maxHeight
= 10;
193 HistogramDataModel model
= new HistogramDataModel(nbBuckets
);
194 for (int i
= startTime
; i
< startTime
+ nbBuckets
; i
++) {
195 model
.countEvent(i
, i
, null);
198 HistogramScaledData result
= model
.scaleTo(nbBuckets
, maxHeight
, 1);
200 assertArrayEqualsInt(1, result
.fData
);
202 testModelConsistency(model
, nbBuckets
, nbBuckets
, 1, startTime
, startTime
, startTime
+ nbBuckets
- 1, startTime
+ nbBuckets
);
206 * Test method for {@link HistogramDataModel#scaleTo(int,int,int)}.
209 public void testScaleTo_0() {
210 HistogramDataModel model
= new HistogramDataModel(10);
212 model
.scaleTo(10, 0, 1);
213 } catch (AssertionError e1
) {
215 model
.scaleTo(0, 10, 1);
216 } catch (AssertionError e2
) {
218 model
.scaleTo(0, 0, 1);
219 } catch (AssertionError e3
) {
224 fail("Uncaught assertion error");
228 * Test method for {@link HistogramDataModel#scaleTo(int,int,int)}.
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
};
237 HistogramDataModel model
= new HistogramDataModel(nbBuckets
);
238 countEventsInModel(nbEvents
, model
);
240 HistogramScaledData result
= model
.scaleTo(nbBuckets
, maxHeight
, 1);
242 assertArrayEquals( expectedResult
, result
.fData
);
244 testModelConsistency(model
, nbBuckets
, nbEvents
, 1, 0, 0, nbEvents
- 1, nbBuckets
);
248 * Test method for {@link HistogramDataModel#scaleTo(int,int,int)}.
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
};
257 HistogramDataModel model
= new HistogramDataModel(nbBuckets
);
258 countEventsInModel(nbEvents
, model
);
260 HistogramScaledData result
= model
.scaleTo(nbBuckets
, maxHeight
, 1);
262 assertArrayEquals(expectedResult
, result
.fData
);
264 testModelConsistency(model
, nbBuckets
, nbEvents
, 1, 0, 0, nbEvents
- 1, nbBuckets
);
268 * Test method for {@link HistogramDataModel#scaleTo(int,int,int)}.
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
};
277 HistogramDataModel model
= new HistogramDataModel(nbBuckets
);
278 countEventsInModel(nbEvents
, model
);
280 HistogramScaledData result
= model
.scaleTo(nbBuckets
, maxHeight
, 1);
282 assertArrayEquals(expectedResult
, result
.fData
);
284 testModelConsistency(model
, nbBuckets
, nbEvents
, 2, 0, 0, nbEvents
- 1, 2 * nbBuckets
);
288 * Test method for {@link HistogramDataModel#scaleTo(int,int,int)}.
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
};
297 HistogramDataModel model
= new HistogramDataModel(nbBuckets
);
298 countEventsInModel(nbEvents
, model
);
300 HistogramScaledData result
= model
.scaleTo(nbBuckets
, maxHeight
, 1);
302 assertArrayEquals(expectedResult
, result
.fData
);
304 testModelConsistency(model
, nbBuckets
, nbEvents
, 4, 0, 0, nbEvents
- 1, 4 * nbBuckets
);
308 * Test method for {@link HistogramDataModel#scaleTo(int,int,int)}.
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
};
317 HistogramDataModel model
= new HistogramDataModel(nbBuckets
);
318 countEventsInModel(nbEvents
, model
);
320 HistogramScaledData result
= model
.scaleTo(10, maxHeight
, 1);
322 assertArrayEquals(expectedResult
, result
.fData
);
324 testModelConsistency(model
, nbBuckets
, nbEvents
, 2, 0, 0, nbEvents
- 1, 2 * nbBuckets
);
328 * Test method for {@link HistogramDataModel#scaleTo(int,int,int)}.
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
};
337 HistogramDataModel model
= new HistogramDataModel(nbBuckets
);
338 countEventsInModel(nbEvents
, model
);
340 HistogramScaledData result
= model
.scaleTo(10, maxHeight
, 1);
342 assertArrayEquals(expectedResult
, result
.fData
);
344 testModelConsistency(model
, nbBuckets
, nbEvents
, 4, 0, 0, nbEvents
- 1, 4 * nbBuckets
);
348 * Test method for {@link HistogramDataModel#scaleTo(int,int,int)}.
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;
359 // (int)(width / barWith) = 2
360 // -> 2 bars -> expected result needs two buckets (scaled data)
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}) };
369 HistogramDataModel model
= new HistogramDataModel(nbBuckets
);
370 countEventsInModel(nbEvents
, model
);
372 // verify scaled data
373 HistogramScaledData result
= model
.scaleTo(width
, maxHeight
, barWidth
);
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
);
387 assertArrayEquals(expectedResult
, result
.fData
);
390 testModelConsistency(model
, nbBuckets
, nbEvents
, 4, 0, 0, nbEvents
- 1, 4 * nbBuckets
);
394 * Test method for {@link HistogramDataModel#scaleTo(int,int,int)}.
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;
404 // (int)(width / barWith) = 10
405 // -> 10 bars -> expected result needs 10 buckets (scaled data)
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
};
412 HistogramDataModel model
= new HistogramDataModel(nbBuckets
);
413 countInvertedEvents(nbEvents
, model
);
415 // verify scaled data
416 HistogramScaledData result
= model
.scaleTo(width
, maxHeight
, barWidth
);
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
);
431 assertArrayEquals(expectedResult
, result
.fData
);
434 testModelConsistency(model
, nbBuckets
, nbEvents
, 4, -3, 0, nbEvents
- 1, -3 + 4 * nbBuckets
);
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);
444 * Test method for {@link HistogramDataModel#scaleTo(int,int,int)}.
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;
453 final int nbEvents
= 2 * nbBuckets
;
455 HistogramDataModel model
= new HistogramDataModel(nbBuckets
);
456 countEventsInModel(nbEvents
, model
);
458 HistogramScaledData result
= model
.scaleTo(width
, maxHeight
, barWidth
);
462 countInvertedEvents(nbEvents
, model
);
464 HistogramScaledData revResult
= model
.scaleTo(width
, maxHeight
, barWidth
);
466 testModelConsistency(model
, nbBuckets
, nbEvents
, 2, 0, 0, nbEvents
- 1, 2 * nbBuckets
);
468 // For the above number of events, result and revResult are exactly the same.
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));
480 assertArrayEquals(revResult
.fData
, result
.fData
);
484 * Test method for testing model listener.
487 public void testModelListener() {
488 final int nbBuckets
= 2000;
489 final int nbEvents
= 10 * nbBuckets
+ 256;
490 final int[] count
= new int[1];
493 // Test add listener and call of listener
494 IHistogramModelListener listener
= new IHistogramModelListener() {
496 public void modelUpdated() {
501 // Test that the listener interface is called every 16000 events.
502 HistogramDataModel model
= new HistogramDataModel(nbBuckets
);
503 model
.addHistogramListener(listener
);
505 countEventsInModel(nbEvents
, model
, 1);
507 assertEquals(1, count
[0]);
509 // Test that the listener interface is called when complete is called.
511 assertEquals(2, count
[0]);
513 // Test that clear triggers call of listener interface
515 assertEquals(3, count
[0]);
517 // Test remove listener
519 model
.removeHistogramListener(listener
);
521 countEventsInModel(nbEvents
, model
);
523 assertEquals(0, count
[0]);
527 * Test method for {@link HistogramDataModel#scaleTo(int,int,int)}.
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 };
540 HistogramDataModel model
= new HistogramDataModel(nbBuckets
);
541 countEventsInModel(nbEvents
, model
);
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);
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);
553 HistogramScaledData result
= model
.scaleTo(nbBuckets
, maxHeight
, 1);
555 assertArrayEquals(expectedResult
, result
.fData
);
557 assertArrayEquals(expectedLostEventsResult
, result
.fLostEventsData
);
559 testModelConsistency(model
, nbBuckets
, nbCombinedEvents
, 4, 0, 0, nbEvents
- 1, 4 * nbBuckets
);
560 assertEquals(7, result
.fMaxCombinedValue
);
564 * Test method for {@link HistogramDataModel#scaleTo(int,int,int)}.
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 };
576 HistogramDataModel model
= new HistogramDataModel(nbBuckets
);
577 countEventsInModel(nbEvents
, model
);
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);
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);
589 HistogramScaledData result
= model
.scaleTo(nbBuckets
, maxHeight
, 1);
591 assertArrayEquals(expectedLostEventsResult
, result
.fLostEventsData
);
593 testModelConsistency(model
, nbBuckets
, nbCombinedEvents
, 4, 0, 0, nbEvents
- 1, 4 * nbBuckets
);
594 assertEquals(9, result
.fMaxCombinedValue
);
598 * Test method for {@link HistogramDataModel#scaleTo(int,int,int)}.
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 };
611 HistogramDataModel model
= new HistogramDataModel(nbBuckets
);
612 countEventsInModel(nbEvents
, model
);
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);
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);
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);
629 HistogramScaledData result
= model
.scaleTo(nbBuckets
, maxHeight
, 1);
631 assertArrayEquals(expectedLostEventsResult
, result
.fLostEventsData
);
633 testModelConsistency(model
, nbBuckets
, nbCombinedEvents
, 4, 0, 0, nbEvents
- 1, 4 * nbBuckets
);
634 assertEquals(10, result
.fMaxCombinedValue
);
638 * Test method for {@link HistogramDataModel#scaleTo(int,int,int)}.
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 };
649 HistogramDataModel model
= new HistogramDataModel(nbBuckets
);
650 countEventsInModel(nbEvents
, model
);
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);
657 HistogramScaledData result
= model
.scaleTo(nbBuckets
, maxHeight
, 1);
659 assertArrayEquals(expectedLostEventsResult
, result
.fLostEventsData
);
661 testModelConsistency(model
, nbBuckets
, nbCombinedEvents
, 4, 0, 0, nbEvents
- 1, 4 * nbBuckets
);
662 assertEquals(9, result
.fMaxCombinedValue
);
669 private static void countEventsInModel(final int nbEvents
, HistogramDataModel model
) {
670 countEventsInModel(nbEvents
, model
, 0);
673 private static void countEventsInModel(final int nbEvents
, HistogramDataModel model
, int offset
) {
674 countEventsInModel(nbEvents
, model
, offset
, 0);
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);
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());
693 private static void assertArrayEqualsInt(final int val
, HistogramBucket
[] result
) {
694 assertArrayEqualsInt(val
, result
, 0);
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());