1 /*******************************************************************************
2 * Copyright (c) 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 * Alexandre Montplaisir - Initial API and implementation
11 * Patrick Tasse - Support selection range
12 *******************************************************************************/
14 package org
.eclipse
.tracecompass
.tmf
.ctf
.core
.tests
.temp
.tracemanager
;
16 import static org
.junit
.Assert
.assertEquals
;
17 import static org
.junit
.Assert
.assertNotNull
;
18 import static org
.junit
.Assert
.assertSame
;
19 import static org
.junit
.Assume
.assumeTrue
;
22 import java
.util
.Collection
;
23 import java
.util
.Collections
;
25 import org
.eclipse
.tracecompass
.tmf
.core
.event
.ITmfEvent
;
26 import org
.eclipse
.tracecompass
.tmf
.core
.signal
.TmfRangeSynchSignal
;
27 import org
.eclipse
.tracecompass
.tmf
.core
.signal
.TmfSignalManager
;
28 import org
.eclipse
.tracecompass
.tmf
.core
.signal
.TmfTimeSynchSignal
;
29 import org
.eclipse
.tracecompass
.tmf
.core
.signal
.TmfTraceClosedSignal
;
30 import org
.eclipse
.tracecompass
.tmf
.core
.signal
.TmfTraceOpenedSignal
;
31 import org
.eclipse
.tracecompass
.tmf
.core
.signal
.TmfTraceSelectedSignal
;
32 import org
.eclipse
.tracecompass
.tmf
.core
.timestamp
.ITmfTimestamp
;
33 import org
.eclipse
.tracecompass
.tmf
.core
.timestamp
.TmfTimeRange
;
34 import org
.eclipse
.tracecompass
.tmf
.core
.timestamp
.TmfTimestamp
;
35 import org
.eclipse
.tracecompass
.tmf
.core
.trace
.ITmfTrace
;
36 import org
.eclipse
.tracecompass
.tmf
.core
.trace
.TmfTraceManager
;
37 import org
.eclipse
.tracecompass
.tmf
.core
.trace
.experiment
.TmfExperiment
;
38 import org
.eclipse
.tracecompass
.tmf
.ctf
.core
.tests
.shared
.CtfTmfTestTrace
;
39 import org
.junit
.After
;
40 import org
.junit
.AfterClass
;
41 import org
.junit
.Before
;
42 import org
.junit
.BeforeClass
;
43 import org
.junit
.Test
;
45 import com
.google
.common
.collect
.ImmutableSet
;
48 * Test suite for the {@link TmfTraceManager}.
50 * @author Alexandre Montplaisir
52 public class TmfTraceManagerTest
{
54 private static final int SCALE
= ITmfTimestamp
.NANOSECOND_SCALE
;
56 private static ITmfTrace trace1
;
57 private static final long t1start
= 1331668247314038062L;
58 private static final long t1end
= 1331668259054285979L;
60 private static ITmfTrace trace2
;
61 private static final long t2start
= 1332170682440133097L;
62 private static final long t2end
= 1332170692664579801L;
64 private static final long ONE_SECOND
= 1000000000L;
66 private TmfTraceManager tm
;
70 * Test class initialization
73 public static void setUpClass() {
74 assumeTrue(CtfTmfTestTrace
.TRACE2
.exists());
75 assumeTrue(CtfTmfTestTrace
.KERNEL
.exists());
76 trace1
= CtfTmfTestTrace
.TRACE2
.getTrace();
77 trace2
= CtfTmfTestTrace
.KERNEL
.getTrace();
79 trace1
.indexTrace(true);
80 trace2
.indexTrace(true);
82 // Deregister traces from signal manager so that they don't
83 // interfere with the TmfTraceManager tests
84 TmfSignalManager
.deregister(trace1
);
85 TmfSignalManager
.deregister(trace2
);
93 tm
= TmfTraceManager
.getInstance();
100 public void tearDown() {
101 while (tm
.getActiveTrace() != null) {
102 closeTrace(tm
.getActiveTrace());
107 * Test class clean-up
110 public static void tearDownClass() {
111 CtfTmfTestTrace
.TRACE2
.dispose();
112 CtfTmfTestTrace
.KERNEL
.dispose();
115 // ------------------------------------------------------------------------
116 // Dummy actions (fake signals)
117 // ------------------------------------------------------------------------
119 private void openTrace(ITmfTrace trace
) {
121 throw new IllegalArgumentException();
123 TmfSignalManager
.dispatchSignal(new TmfTraceOpenedSignal(this, trace
, null));
127 private void closeTrace(ITmfTrace trace
) {
129 throw new IllegalArgumentException();
131 TmfSignalManager
.dispatchSignal(new TmfTraceClosedSignal(this, trace
));
133 * In TMF, the next tab would now be selected (if there are some), which
134 * would select another trace automatically.
136 if (tm
.getOpenedTraces().size() > 0) {
137 selectTrace(tm
.getOpenedTraces().toArray(new ITmfTrace
[0])[0]);
141 private void selectTrace(ITmfTrace trace
) {
142 TmfSignalManager
.dispatchSignal(new TmfTraceSelectedSignal(this, trace
));
145 private void selectTimestamp(ITmfTimestamp ts
) {
146 TmfSignalManager
.dispatchSignal(new TmfTimeSynchSignal(this, ts
));
149 private void selectTimeRange(TmfTimeRange tr
) {
150 TmfSignalManager
.dispatchSignal(new TmfRangeSynchSignal(this, tr
));
153 // ------------------------------------------------------------------------
155 // ------------------------------------------------------------------------
158 * Test that the manager is correctly initialized
161 public void testInitialize() {
162 TmfTraceManager mgr
= TmfTraceManager
.getInstance();
168 * Test the contents of a trace set with one trace.
171 public void testTraceSet() {
176 Collection
<ITmfTrace
> expected
= Collections
.singleton(trace2
);
177 Collection
<ITmfTrace
> actual
= tm
.getActiveTraceSet();
179 assertEquals(1, actual
.size());
180 assertEquals(expected
, actual
);
184 * Test the contents of a trace set with an experiment.
187 public void testTraceSetExperiment() {
188 TmfExperiment exp
= createExperiment(trace1
, trace2
);
192 Collection
<ITmfTrace
> expected
= ImmutableSet
.of(trace1
, trace2
);
193 Collection
<ITmfTrace
> actual
= tm
.getActiveTraceSet();
195 assertEquals(2, actual
.size());
196 assertEquals(expected
, actual
);
200 * Test the contents of the complete trace set.
203 public void testTraceSetWithExperiment() {
204 /* Test with a trace */
205 Collection
<ITmfTrace
> expected
= Collections
.singleton(trace1
);
206 Collection
<ITmfTrace
> actual
= TmfTraceManager
.getTraceSetWithExperiment(trace1
);
207 assertEquals(1, actual
.size());
208 assertEquals(expected
, actual
);
210 /* Test with an experiment */
211 TmfExperiment exp
= createExperiment(trace1
, trace2
);
212 expected
= ImmutableSet
.of(trace1
, trace2
, exp
);
213 actual
= TmfTraceManager
.getTraceSetWithExperiment(exp
);
214 assertEquals(3, actual
.size());
215 assertEquals(expected
, actual
);
219 * Test the {@link TmfTraceManager#getSupplementaryFileDir} method.
222 public void testSupplementaryFileDir() {
223 String name1
= trace1
.getName();
224 String name2
= trace2
.getName();
225 String basePath
= TmfTraceManager
.getTemporaryDirPath() + File
.separator
;
227 String expected1
= basePath
+ name1
+ File
.separator
;
228 String expected2
= basePath
+ name2
+ File
.separator
;
230 assertEquals(expected1
, TmfTraceManager
.getSupplementaryFileDir(trace1
));
231 assertEquals(expected2
, TmfTraceManager
.getSupplementaryFileDir(trace2
));
234 // ------------------------------------------------------------------------
235 // Test a single trace
236 // ------------------------------------------------------------------------
239 * Test the initial range of a single trace.
242 public void testTraceInitialRange() {
244 final TmfTimeRange expectedRange
= new TmfTimeRange(
245 trace2
.getStartTime(),
246 calculateOffset(trace2
.getStartTime(), trace2
.getInitialRangeOffset()));
247 TmfTimeRange actualRange
= tm
.getCurrentRange();
248 assertEquals(expectedRange
, actualRange
);
252 * Try selecting a timestamp contained inside the trace's range. The trace's
253 * current time should get updated correctly.
256 public void testNewTimestamp() {
258 ITmfTimestamp ts
= new TmfTimestamp(t2start
+ ONE_SECOND
, SCALE
);
261 ITmfTimestamp afterTs
= tm
.getSelectionBeginTime();
262 assertEquals(ts
, afterTs
);
263 afterTs
= tm
.getSelectionEndTime();
264 assertEquals(ts
, afterTs
);
268 * Try selecting a timestamp happening before the trace's start. The change
272 public void testTimestampBefore() {
274 ITmfTimestamp beforeTs
= tm
.getSelectionBeginTime();
275 ITmfTimestamp ts
= new TmfTimestamp(t2start
- ONE_SECOND
, SCALE
);
278 ITmfTimestamp curTs
= tm
.getSelectionBeginTime();
279 assertEquals(beforeTs
, curTs
);
280 curTs
= tm
.getSelectionEndTime();
281 assertEquals(beforeTs
, curTs
);
285 * Try selecting a timestamp happening after the trace's end. The change
289 public void testTimestampAfter() {
291 ITmfTimestamp beforeTs
= tm
.getSelectionBeginTime();
292 ITmfTimestamp ts
= new TmfTimestamp(t2end
+ ONE_SECOND
, SCALE
);
295 ITmfTimestamp curTs
= tm
.getSelectionBeginTime();
296 assertEquals(beforeTs
, curTs
);
297 curTs
= tm
.getSelectionEndTime();
298 assertEquals(beforeTs
, curTs
);
302 * Test selecting a normal sub-range of a single trace.
305 public void testTraceNewTimeRange() {
307 TmfTimeRange range
= new TmfTimeRange(
308 new TmfTimestamp(t2start
+ ONE_SECOND
, SCALE
),
309 new TmfTimestamp(t2end
- ONE_SECOND
, SCALE
));
310 selectTimeRange(range
);
312 TmfTimeRange curRange
= tm
.getCurrentRange();
313 assertEquals(range
.getStartTime(), curRange
.getStartTime());
314 assertEquals(range
.getEndTime(), curRange
.getEndTime());
318 * Test selecting a range whose start time is before the trace's start time.
319 * The selected range should get clamped to the trace's range.
322 public void testTraceTimeRangeClampingStart() {
324 TmfTimeRange range
= new TmfTimeRange(
325 new TmfTimestamp(t2start
- ONE_SECOND
, SCALE
), // minus here
326 new TmfTimestamp(t2end
- ONE_SECOND
, SCALE
));
327 selectTimeRange(range
);
329 TmfTimeRange curRange
= tm
.getCurrentRange();
330 assertEquals(t2start
, curRange
.getStartTime().getValue());
331 assertEquals(range
.getEndTime(), curRange
.getEndTime());
335 * Test selecting a range whose end time is after the trace's end time.
336 * The selected range should get clamped to the trace's range.
339 public void testTraceTimeRangeClampingEnd() {
341 TmfTimeRange range
= new TmfTimeRange(
342 new TmfTimestamp(t2start
+ ONE_SECOND
, SCALE
),
343 new TmfTimestamp(t2end
+ ONE_SECOND
, SCALE
)); // plus here
344 selectTimeRange(range
);
346 TmfTimeRange curRange
= tm
.getCurrentRange();
347 assertEquals(range
.getStartTime(), curRange
.getStartTime());
348 assertEquals(t2end
, curRange
.getEndTime().getValue());
352 * Test selecting a range whose both start and end times are outside of the
353 * trace's range. The selected range should get clamped to the trace's
357 public void testTraceTimeRangeClampingBoth() {
359 TmfTimeRange range
= new TmfTimeRange(
360 new TmfTimestamp(t2start
- ONE_SECOND
, SCALE
), // minus here
361 new TmfTimestamp(t2end
+ ONE_SECOND
, SCALE
)); // plus here
362 selectTimeRange(range
);
364 TmfTimeRange curRange
= tm
.getCurrentRange();
365 assertEquals(t2start
, curRange
.getStartTime().getValue());
366 assertEquals(t2end
, curRange
.getEndTime().getValue());
369 // ------------------------------------------------------------------------
370 // Test multiple, non-overlapping traces in parallel
371 // ------------------------------------------------------------------------
374 * Test, with two traces in parallel, when we select a timestamp that is
375 * part of the first trace.
377 * The first trace's timestamp should be updated, but the second trace's one
381 public void testTwoTracesTimestampValid() {
385 TmfTimestamp ts
= new TmfTimestamp(t1start
+ ONE_SECOND
, SCALE
);
388 /* Timestamp of trace1 should have been updated */
389 assertEquals(ts
, tm
.getSelectionBeginTime());
390 assertEquals(ts
, tm
.getSelectionEndTime());
392 /* Timestamp of trace2 should not have changed */
394 assertEquals(trace2
.getStartTime(), tm
.getSelectionBeginTime());
395 assertEquals(trace2
.getStartTime(), tm
.getSelectionEndTime());
399 * Test, with two traces in parallel, when we select a timestamp that is
400 * between two traces.
402 * None of the trace's timestamps should be updated (we are not in an
406 public void testTwoTracesTimestampInBetween() {
410 TmfTimestamp ts
= new TmfTimestamp(t1end
+ ONE_SECOND
, SCALE
);
413 /* Timestamp of trace1 should not have changed */
414 assertEquals(trace1
.getStartTime(), tm
.getSelectionBeginTime());
415 assertEquals(trace1
.getStartTime(), tm
.getSelectionEndTime());
417 /* Timestamp of trace2 should not have changed */
419 assertEquals(trace2
.getStartTime(), tm
.getSelectionBeginTime());
420 assertEquals(trace2
.getStartTime(), tm
.getSelectionEndTime());
424 * Test, with two traces in parallel, when we select a timestamp that is
425 * completely out of the trace's range.
427 * None of the trace's timestamps should be updated.
430 public void testTwoTracesTimestampInvalid() {
434 TmfTimestamp ts
= new TmfTimestamp(t2end
+ ONE_SECOND
, SCALE
);
437 /* Timestamp of trace1 should not have changed */
438 assertEquals(trace1
.getStartTime(), tm
.getSelectionBeginTime());
439 assertEquals(trace1
.getStartTime(), tm
.getSelectionEndTime());
441 /* Timestamp of trace2 should not have changed */
443 assertEquals(trace2
.getStartTime(), tm
.getSelectionBeginTime());
444 assertEquals(trace2
.getStartTime(), tm
.getSelectionEndTime());
448 * Test, with two traces opened in parallel (not in an experiment), if we
449 * select a time range valid in one of them. That trace's time range should
450 * be updated, but not the other one.
453 public void testTwoTracesTimeRangeAllInOne() {
457 TmfTimeRange range
= new TmfTimeRange(
458 new TmfTimestamp(t1start
+ ONE_SECOND
, SCALE
),
459 new TmfTimestamp(t1end
- ONE_SECOND
, SCALE
));
460 selectTimeRange(range
);
462 /* Range of trace1 should be equal to the requested one */
463 assertEquals(range
, tm
.getCurrentRange());
465 /* The range of trace 2 should not have changed */
467 assertEquals(getInitialRange(trace2
), tm
.getCurrentRange());
471 * Test, with two traces in parallel, when we select a time range that is
472 * only partially valid for one of the traces.
474 * The first trace's time range should be clamped to a valid range, and the
475 * second one's should not change.
478 public void testTwoTracesTimeRangePartiallyInOne() {
482 TmfTimeRange range
= new TmfTimeRange(
483 new TmfTimestamp(t1start
+ ONE_SECOND
, SCALE
),
484 new TmfTimestamp(t1end
+ ONE_SECOND
, SCALE
));
485 selectTimeRange(range
);
487 /* Range of trace1 should get clamped to its end time */
488 TmfTimeRange expectedRange
= new TmfTimeRange(
489 new TmfTimestamp(t1start
+ ONE_SECOND
, SCALE
),
490 new TmfTimestamp(t1end
, SCALE
));
491 assertEquals(expectedRange
, tm
.getCurrentRange());
493 /* Range of trace2 should not have changed */
495 assertEquals(getInitialRange(trace2
), tm
.getCurrentRange());
499 * Test, with two traces in parallel, when we select a time range that is
500 * only partially valid for both traces.
502 * Each trace's time range should get clamped to respectively valid ranges.
505 public void testTwoTracesTimeRangeInBoth() {
509 TmfTimeRange range
= new TmfTimeRange(
510 new TmfTimestamp(t1end
- ONE_SECOND
, SCALE
),
511 new TmfTimestamp(t2start
+ ONE_SECOND
, SCALE
));
512 selectTimeRange(range
);
514 /* Range of trace1 should be clamped to its end time */
515 TmfTimeRange expectedRange
= new TmfTimeRange(
516 new TmfTimestamp(t1end
- ONE_SECOND
, SCALE
),
517 new TmfTimestamp(t1end
, SCALE
));
518 assertEquals(expectedRange
, tm
.getCurrentRange());
520 /* Range of trace2 should be clamped to its start time */
522 expectedRange
= new TmfTimeRange(
523 new TmfTimestamp(t2start
, SCALE
),
524 new TmfTimestamp(t2start
+ ONE_SECOND
, SCALE
));
525 assertEquals(expectedRange
, tm
.getCurrentRange());
529 * Test, with two traces in parallel, when we select a time range that is
530 * not valid for any trace.
532 * Each trace's time range should not be modified.
535 public void testTwoTracesTimeRangeInBetween() {
539 TmfTimeRange range
= new TmfTimeRange(
540 new TmfTimestamp(t1end
+ ONE_SECOND
, SCALE
),
541 new TmfTimestamp(t1end
- ONE_SECOND
, SCALE
));
542 selectTimeRange(range
);
544 /* Range of trace1 should not have changed */
545 TmfTimeRange expectedRange
= getInitialRange(trace1
);
546 TmfTimeRange curRange
= tm
.getCurrentRange();
547 assertEquals(expectedRange
.getStartTime(), curRange
.getStartTime());
548 assertEquals(expectedRange
.getEndTime(), curRange
.getEndTime());
550 /* Range of trace2 should not have changed */
552 expectedRange
= getInitialRange(trace2
);
553 curRange
= tm
.getCurrentRange();
554 assertEquals(expectedRange
.getStartTime(), curRange
.getStartTime());
555 assertEquals(expectedRange
.getEndTime(), curRange
.getEndTime());
558 // ------------------------------------------------------------------------
559 // Test an experiment
560 // ------------------------------------------------------------------------
563 * Test in an experiment when we select a timestamp that is part of one of
564 * the experiment's traces.
566 * The experiment's current time should be correctly updated.
569 public void testExperimentTimestampInTrace() {
570 TmfExperiment exp
= createExperiment(trace1
, trace2
);
572 TmfTimestamp ts
= new TmfTimestamp(t1start
+ ONE_SECOND
, SCALE
);
575 /* The experiment's current time should be updated. */
576 assertEquals(ts
, tm
.getSelectionBeginTime());
577 assertEquals(ts
, tm
.getSelectionEndTime());
581 * Test in an experiment when we select a timestamp that is between two
582 * traces in the experiment.
584 * The experiment's current time should still be updated, since the
585 * timestamp is valid in the experiment itself.
588 public void testExperimentTimestampInBetween() {
589 TmfExperiment exp
= createExperiment(trace1
, trace2
);
591 TmfTimestamp ts
= new TmfTimestamp(t1end
+ ONE_SECOND
, SCALE
);
594 /* The experiment's current time should be updated. */
595 assertEquals(ts
, tm
.getSelectionBeginTime());
596 assertEquals(ts
, tm
.getSelectionEndTime());
600 * Test in an experiment when we select a timestamp that is outside of the
601 * total range of the experiment.
603 * The experiment's current time should not be updated.
606 public void testExperimentTimestampInvalid() {
607 TmfExperiment exp
= createExperiment(trace1
, trace2
);
609 TmfTimestamp ts
= new TmfTimestamp(t2end
+ ONE_SECOND
, SCALE
);
612 /* The experiment's current time should NOT be updated. */
613 assertEquals(trace1
.getStartTime(), tm
.getSelectionBeginTime());
614 assertEquals(trace1
.getStartTime(), tm
.getSelectionEndTime());
618 * Test the initial range of an experiment.
621 public void testExperimentInitialRange() {
622 TmfExperiment exp
= createExperiment(trace1
, trace2
);
625 * The initial range should be == to the initial range of the earliest
626 * trace (here trace1).
628 final TmfTimeRange actualRange
= tm
.getCurrentRange();
630 assertEquals(getInitialRange(trace1
), actualRange
);
631 assertEquals(getInitialRange(exp
), actualRange
);
635 * Test the range clamping with the start time of the range outside of the
636 * earliest trace's range. Only that start time should get clamped.
639 public void testExperimentRangeClampingOne() {
640 TmfExperiment exp
= createExperiment(trace1
, trace2
);
643 final TmfTimeRange range
= new TmfTimeRange(
644 new TmfTimestamp(t1start
- ONE_SECOND
, SCALE
),
645 new TmfTimestamp(t1end
- ONE_SECOND
, SCALE
));
646 selectTimeRange(range
);
648 TmfTimeRange actualRange
= tm
.getCurrentRange();
649 assertEquals(t1start
, actualRange
.getStartTime().getValue());
650 assertEquals(t1end
- ONE_SECOND
, actualRange
.getEndTime().getValue());
654 * Test the range clamping when both the start and end times of the signal's
655 * range are outside of the trace's range. The range should clamp to the
656 * experiment's range.
659 public void testExperimentRangeClampingBoth() {
660 TmfExperiment exp
= createExperiment(trace1
, trace2
);
663 final TmfTimeRange range
= new TmfTimeRange(
664 new TmfTimestamp(t1start
- ONE_SECOND
, SCALE
),
665 new TmfTimestamp(t2end
+ ONE_SECOND
, SCALE
));
666 selectTimeRange(range
);
668 TmfTimeRange actualRange
= tm
.getCurrentRange();
669 assertEquals(t1start
, actualRange
.getStartTime().getValue());
670 assertEquals(t2end
, actualRange
.getEndTime().getValue());
674 * Test selecting a range in-between two disjoint traces in an experiment.
675 * The range should still get correctly selected, even if no trace has any
676 * events in that range.
679 public void testExperimentRangeInBetween() {
680 TmfExperiment exp
= createExperiment(trace1
, trace2
);
683 final TmfTimeRange range
= new TmfTimeRange(
684 new TmfTimestamp(t1end
+ ONE_SECOND
, SCALE
),
685 new TmfTimestamp(t2start
- ONE_SECOND
, SCALE
));
686 selectTimeRange(range
);
688 TmfTimeRange actualRange
= tm
.getCurrentRange();
689 assertEquals(range
, actualRange
);
692 // ------------------------------------------------------------------------
694 // ------------------------------------------------------------------------
696 private static TmfExperiment
createExperiment(ITmfTrace t1
, ITmfTrace t2
) {
697 ITmfTrace
[] traces
= new ITmfTrace
[] { t1
, t2
};
698 TmfExperiment exp
= new TmfExperiment(ITmfEvent
.class, "test-exp", traces
,
699 TmfExperiment
.DEFAULT_INDEX_PAGE_SIZE
, null);
700 exp
.indexTrace(true);
701 // Deregister experiment from signal manager so that it doesn't
702 // interfere with the TmfTraceManager tests
703 TmfSignalManager
.deregister(exp
);
707 private static TmfTimeRange
getInitialRange(ITmfTrace trace
) {
708 return new TmfTimeRange(
709 trace
.getStartTime(),
710 calculateOffset(trace
.getStartTime(), trace
.getInitialRangeOffset()));
714 * Basically a "initial + offset" operation, but for ITmfTimetamp objects.
716 private static ITmfTimestamp
calculateOffset(ITmfTimestamp initialTs
, ITmfTimestamp offsetTs
) {
717 long start
= initialTs
.normalize(0, SCALE
).getValue();
718 long offset
= offsetTs
.normalize(0, SCALE
).getValue();
719 return new TmfTimestamp(start
+ offset
, SCALE
);