org.eclipse.tracecompass.tmf.ctf.core.tests/src/org/eclipse/tracecompass/tmf/ctf/core/tests/temp/tracemanager/TmfTraceManagerTest.java

   1 /*******************************************************************************
   2  * Copyright (c) 2013, 2015 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  *   Alexandre Montplaisir - Initial API and implementation
  11  *   Patrick Tasse - Support selection range
  12  *******************************************************************************/
  13
  14 package org.eclipse.tracecompass.tmf.ctf.core.tests.temp.tracemanager;
  15
  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;
  20
  21 import java.io.File;
  22 import java.util.Collection;
  23 import java.util.Collections;
  24
  25 import org.eclipse.jdt.annotation.NonNull;
  26 import org.eclipse.tracecompass.tmf.core.event.ITmfEvent;
  27 import org.eclipse.tracecompass.tmf.core.signal.TmfRangeSynchSignal;
  28 import org.eclipse.tracecompass.tmf.core.signal.TmfSignalManager;
  29 import org.eclipse.tracecompass.tmf.core.signal.TmfTimeSynchSignal;
  30 import org.eclipse.tracecompass.tmf.core.signal.TmfTraceClosedSignal;
  31 import org.eclipse.tracecompass.tmf.core.signal.TmfTraceOpenedSignal;
  32 import org.eclipse.tracecompass.tmf.core.signal.TmfTraceSelectedSignal;
  33 import org.eclipse.tracecompass.tmf.core.timestamp.ITmfTimestamp;
  34 import org.eclipse.tracecompass.tmf.core.timestamp.TmfTimeRange;
  35 import org.eclipse.tracecompass.tmf.core.timestamp.TmfTimestamp;
  36 import org.eclipse.tracecompass.tmf.core.trace.ITmfTrace;
  37 import org.eclipse.tracecompass.tmf.core.trace.TmfTraceManager;
  38 import org.eclipse.tracecompass.tmf.core.trace.experiment.TmfExperiment;
  39 import org.eclipse.tracecompass.tmf.ctf.core.tests.shared.CtfTmfTestTrace;
  40 import org.junit.After;
  41 import org.junit.AfterClass;
  42 import org.junit.Before;
  43 import org.junit.BeforeClass;
  44 import org.junit.Test;
  45
  46 import com.google.common.collect.ImmutableSet;
  47
  48 /**
  49  * Test suite for the {@link TmfTraceManager}.
  50  *
  51  * @author Alexandre Montplaisir
  52  */
  53 public class TmfTraceManagerTest {
  54
  55     private static final int SCALE = ITmfTimestamp.NANOSECOND_SCALE;
  56
  57     private static ITmfTrace trace1;
  58     private static final long t1start = 1331668247314038062L;
  59     private static final long t1end =   1331668259054285979L;
  60
  61     private static ITmfTrace trace2;
  62     private static final long t2start = 1332170682440133097L;
  63     private static final long t2end =   1332170692664579801L;
  64
  65     private static final long ONE_SECOND = 1000000000L;
  66
  67     private TmfTraceManager tm;
  68
  69
  70     /**
  71      * Test class initialization
  72      */
  73     @BeforeClass
  74     public static void setUpClass() {
  75         assumeTrue(CtfTmfTestTrace.TRACE2.exists());
  76         assumeTrue(CtfTmfTestTrace.KERNEL.exists());
  77         trace1 = CtfTmfTestTrace.TRACE2.getTrace();
  78         trace2 = CtfTmfTestTrace.KERNEL.getTrace();
  79
  80         trace1.indexTrace(true);
  81         trace2.indexTrace(true);
  82
  83         // Deregister traces from signal manager so that they don't
  84         // interfere with the TmfTraceManager tests
  85         TmfSignalManager.deregister(trace1);
  86         TmfSignalManager.deregister(trace2);
  87     }
  88
  89     /**
  90      * Test initialization
  91      */
  92     @Before
  93     public void setUp() {
  94         tm = TmfTraceManager.getInstance();
  95     }
  96
  97     /**
  98      * Test clean-up
  99      */
 100     @After
 101     public void tearDown() {
 102         while (tm.getActiveTrace() != null) {
 103             closeTrace(tm.getActiveTrace());
 104         }
 105     }
 106
 107     /**
 108      * Test class clean-up
 109      */
 110     @AfterClass
 111     public static void tearDownClass() {
 112         CtfTmfTestTrace.TRACE2.dispose();
 113         CtfTmfTestTrace.KERNEL.dispose();
 114     }
 115
 116     // ------------------------------------------------------------------------
 117     // Dummy actions (fake signals)
 118     // ------------------------------------------------------------------------
 119
 120     private void openTrace(ITmfTrace trace) {
 121         if (trace == null) {
 122             throw new IllegalArgumentException();
 123         }
 124         TmfSignalManager.dispatchSignal(new TmfTraceOpenedSignal(this, trace, null));
 125         selectTrace(trace);
 126     }
 127
 128     private void closeTrace(ITmfTrace trace) {
 129         if (trace == null) {
 130             throw new IllegalArgumentException();
 131         }
 132         TmfSignalManager.dispatchSignal(new TmfTraceClosedSignal(this, trace));
 133         /*
 134          * In TMF, the next tab would now be selected (if there are some), which
 135          * would select another trace automatically.
 136          */
 137         if (tm.getOpenedTraces().size() > 0) {
 138             selectTrace(tm.getOpenedTraces().toArray(new ITmfTrace[0])[0]);
 139         }
 140     }
 141
 142     private void selectTrace(ITmfTrace trace) {
 143         TmfSignalManager.dispatchSignal(new TmfTraceSelectedSignal(this, trace));
 144     }
 145
 146     private void selectTimestamp(@NonNull ITmfTimestamp ts) {
 147         TmfSignalManager.dispatchSignal(new TmfTimeSynchSignal(this, ts));
 148     }
 149
 150     private void selectTimeRange(TmfTimeRange tr) {
 151         TmfSignalManager.dispatchSignal(new TmfRangeSynchSignal(this, tr));
 152     }
 153
 154     // ------------------------------------------------------------------------
 155     // General tests
 156     // ------------------------------------------------------------------------
 157
 158     /**
 159      * Test that the manager is correctly initialized
 160      */
 161     @Test
 162     public void testInitialize() {
 163         TmfTraceManager mgr = TmfTraceManager.getInstance();
 164         assertNotNull(mgr);
 165         assertSame(tm, mgr);
 166     }
 167
 168     /**
 169      * Test the contents of a trace set with one trace.
 170      */
 171     @Test
 172     public void testTraceSet() {
 173         openTrace(trace1);
 174         openTrace(trace2);
 175         selectTrace(trace2);
 176
 177         Collection<ITmfTrace> expected = Collections.singleton(trace2);
 178         Collection<ITmfTrace> actual = tm.getActiveTraceSet();
 179
 180         assertEquals(1, actual.size());
 181         assertEquals(expected, actual);
 182     }
 183
 184     /**
 185      * Test the contents of a trace set with an experiment.
 186      */
 187     @Test
 188     public void testTraceSetExperiment() {
 189         TmfExperiment exp = createExperiment(trace1, trace2);
 190         openTrace(trace1);
 191         openTrace(exp);
 192
 193         Collection<ITmfTrace> expected = ImmutableSet.of(trace1, trace2);
 194         Collection<ITmfTrace> actual = tm.getActiveTraceSet();
 195
 196         assertEquals(2, actual.size());
 197         assertEquals(expected, actual);
 198     }
 199
 200     /**
 201      * Test the contents of the complete trace set.
 202      */
 203     @Test
 204     public void testTraceSetWithExperiment() {
 205         /* Test with a trace */
 206         Collection<ITmfTrace> expected = Collections.singleton(trace1);
 207         Collection<ITmfTrace> actual = TmfTraceManager.getTraceSetWithExperiment(trace1);
 208         assertEquals(1, actual.size());
 209         assertEquals(expected, actual);
 210
 211         /* Test with an experiment */
 212         TmfExperiment exp = createExperiment(trace1, trace2);
 213         expected = ImmutableSet.of(trace1, trace2, exp);
 214         actual = TmfTraceManager.getTraceSetWithExperiment(exp);
 215         assertEquals(3, actual.size());
 216         assertEquals(expected, actual);
 217     }
 218
 219     /**
 220      * Test the {@link TmfTraceManager#getSupplementaryFileDir} method.
 221      */
 222     @Test
 223     public void testSupplementaryFileDir() {
 224         String name1 = trace1.getName();
 225         String name2 = trace2.getName();
 226         String basePath = TmfTraceManager.getTemporaryDirPath() + File.separator;
 227
 228         String expected1 = basePath + name1 + File.separator;
 229         String expected2 = basePath + name2 + File.separator;
 230
 231         assertEquals(expected1, TmfTraceManager.getSupplementaryFileDir(trace1));
 232         assertEquals(expected2, TmfTraceManager.getSupplementaryFileDir(trace2));
 233     }
 234
 235     // ------------------------------------------------------------------------
 236     // Test a single trace
 237     // ------------------------------------------------------------------------
 238
 239     /**
 240      * Test the initial range of a single trace.
 241      */
 242     @Test
 243     public void testTraceInitialRange() {
 244         openTrace(trace2);
 245         final TmfTimeRange expectedRange = new TmfTimeRange(
 246                 trace2.getStartTime(),
 247                 calculateOffset(trace2.getStartTime(), trace2.getInitialRangeOffset()));
 248         TmfTimeRange actualRange = tm.getCurrentRange();
 249         assertEquals(expectedRange, actualRange);
 250     }
 251
 252     /**
 253      * Try selecting a timestamp contained inside the trace's range. The trace's
 254      * current time should get updated correctly.
 255      */
 256     @Test
 257     public void testNewTimestamp() {
 258         openTrace(trace2);
 259         ITmfTimestamp ts = new TmfTimestamp(t2start + ONE_SECOND, SCALE);
 260         selectTimestamp(ts);
 261
 262         ITmfTimestamp afterTs = tm.getSelectionBeginTime();
 263         assertEquals(ts, afterTs);
 264         afterTs = tm.getSelectionEndTime();
 265         assertEquals(ts, afterTs);
 266     }
 267
 268     /**
 269      * Try selecting a timestamp happening before the trace's start. The change
 270      * should be ignored.
 271      */
 272     @Test
 273     public void testTimestampBefore() {
 274         openTrace(trace2);
 275         ITmfTimestamp beforeTs = tm.getSelectionBeginTime();
 276         ITmfTimestamp ts = new TmfTimestamp(t2start - ONE_SECOND, SCALE);
 277         selectTimestamp(ts);
 278
 279         ITmfTimestamp curTs = tm.getSelectionBeginTime();
 280         assertEquals(beforeTs, curTs);
 281         curTs = tm.getSelectionEndTime();
 282         assertEquals(beforeTs, curTs);
 283     }
 284
 285     /**
 286      * Try selecting a timestamp happening after the trace's end. The change
 287      * should be ignored.
 288      */
 289     @Test
 290     public void testTimestampAfter() {
 291         openTrace(trace2);
 292         ITmfTimestamp beforeTs = tm.getSelectionBeginTime();
 293         ITmfTimestamp ts = new TmfTimestamp(t2end + ONE_SECOND, SCALE);
 294         selectTimestamp(ts);
 295
 296         ITmfTimestamp curTs = tm.getSelectionBeginTime();
 297         assertEquals(beforeTs, curTs);
 298         curTs = tm.getSelectionEndTime();
 299         assertEquals(beforeTs, curTs);
 300     }
 301
 302     /**
 303      * Test selecting a normal sub-range of a single trace.
 304      */
 305     @Test
 306     public void testTraceNewTimeRange() {
 307         openTrace(trace2);
 308         TmfTimeRange range = new TmfTimeRange(
 309                 new TmfTimestamp(t2start + ONE_SECOND, SCALE),
 310                 new TmfTimestamp(t2end - ONE_SECOND, SCALE));
 311         selectTimeRange(range);
 312
 313         TmfTimeRange curRange = tm.getCurrentRange();
 314         assertEquals(range.getStartTime(), curRange.getStartTime());
 315         assertEquals(range.getEndTime(), curRange.getEndTime());
 316     }
 317
 318     /**
 319      * Test selecting a range whose start time is before the trace's start time.
 320      * The selected range should get clamped to the trace's range.
 321      */
 322     @Test
 323     public void testTraceTimeRangeClampingStart() {
 324         openTrace(trace2);
 325         TmfTimeRange range = new TmfTimeRange(
 326                 new TmfTimestamp(t2start - ONE_SECOND, SCALE), // minus here
 327                 new TmfTimestamp(t2end - ONE_SECOND, SCALE));
 328         selectTimeRange(range);
 329
 330         TmfTimeRange curRange = tm.getCurrentRange();
 331         assertEquals(t2start, curRange.getStartTime().getValue());
 332         assertEquals(range.getEndTime(), curRange.getEndTime());
 333     }
 334
 335     /**
 336      * Test selecting a range whose end time is after the trace's end time.
 337      * The selected range should get clamped to the trace's range.
 338      */
 339     @Test
 340     public void testTraceTimeRangeClampingEnd() {
 341         openTrace(trace2);
 342         TmfTimeRange range = new TmfTimeRange(
 343                 new TmfTimestamp(t2start + ONE_SECOND, SCALE),
 344                 new TmfTimestamp(t2end + ONE_SECOND, SCALE)); // plus here
 345         selectTimeRange(range);
 346
 347         TmfTimeRange curRange = tm.getCurrentRange();
 348         assertEquals(range.getStartTime(), curRange.getStartTime());
 349         assertEquals(t2end, curRange.getEndTime().getValue());
 350     }
 351
 352     /**
 353      * Test selecting a range whose both start and end times are outside of the
 354      * trace's range. The selected range should get clamped to the trace's
 355      * range.
 356      */
 357     @Test
 358     public void testTraceTimeRangeClampingBoth() {
 359         openTrace(trace2);
 360         TmfTimeRange range = new TmfTimeRange(
 361                 new TmfTimestamp(t2start - ONE_SECOND, SCALE), // minus here
 362                 new TmfTimestamp(t2end + ONE_SECOND, SCALE)); // plus here
 363         selectTimeRange(range);
 364
 365         TmfTimeRange curRange = tm.getCurrentRange();
 366         assertEquals(t2start, curRange.getStartTime().getValue());
 367         assertEquals(t2end, curRange.getEndTime().getValue());
 368     }
 369
 370     // ------------------------------------------------------------------------
 371     // Test multiple, non-overlapping traces in parallel
 372     // ------------------------------------------------------------------------
 373
 374     /**
 375      * Test, with two traces in parallel, when we select a timestamp that is
 376      * part of the first trace.
 377      *
 378      * The first trace's timestamp should be updated, but the second trace's one
 379      * should not change.
 380      */
 381     @Test
 382     public void testTwoTracesTimestampValid() {
 383         openTrace(trace1);
 384         openTrace(trace2);
 385         selectTrace(trace1);
 386         TmfTimestamp ts = new TmfTimestamp(t1start + ONE_SECOND, SCALE);
 387         selectTimestamp(ts);
 388
 389         /* Timestamp of trace1 should have been updated */
 390         assertEquals(ts, tm.getSelectionBeginTime());
 391         assertEquals(ts, tm.getSelectionEndTime());
 392
 393         /* Timestamp of trace2 should not have changed */
 394         selectTrace(trace2);
 395         assertEquals(trace2.getStartTime(), tm.getSelectionBeginTime());
 396         assertEquals(trace2.getStartTime(), tm.getSelectionEndTime());
 397     }
 398
 399     /**
 400      * Test, with two traces in parallel, when we select a timestamp that is
 401      * between two traces.
 402      *
 403      * None of the trace's timestamps should be updated (we are not in an
 404      * experiment!)
 405      */
 406     @Test
 407     public void testTwoTracesTimestampInBetween() {
 408         openTrace(trace1);
 409         openTrace(trace2);
 410         selectTrace(trace1);
 411         TmfTimestamp ts = new TmfTimestamp(t1end + ONE_SECOND, SCALE);
 412         selectTimestamp(ts);
 413
 414         /* Timestamp of trace1 should not have changed */
 415         assertEquals(trace1.getStartTime(), tm.getSelectionBeginTime());
 416         assertEquals(trace1.getStartTime(), tm.getSelectionEndTime());
 417
 418         /* Timestamp of trace2 should not have changed */
 419         selectTrace(trace2);
 420         assertEquals(trace2.getStartTime(), tm.getSelectionBeginTime());
 421         assertEquals(trace2.getStartTime(), tm.getSelectionEndTime());
 422     }
 423
 424     /**
 425      * Test, with two traces in parallel, when we select a timestamp that is
 426      * completely out of the trace's range.
 427      *
 428      * None of the trace's timestamps should be updated.
 429      */
 430     @Test
 431     public void testTwoTracesTimestampInvalid() {
 432         openTrace(trace1);
 433         openTrace(trace2);
 434         selectTrace(trace1);
 435         TmfTimestamp ts = new TmfTimestamp(t2end + ONE_SECOND, SCALE);
 436         selectTimestamp(ts);
 437
 438         /* Timestamp of trace1 should not have changed */
 439         assertEquals(trace1.getStartTime(), tm.getSelectionBeginTime());
 440         assertEquals(trace1.getStartTime(), tm.getSelectionEndTime());
 441
 442         /* Timestamp of trace2 should not have changed */
 443         selectTrace(trace2);
 444         assertEquals(trace2.getStartTime(), tm.getSelectionBeginTime());
 445         assertEquals(trace2.getStartTime(), tm.getSelectionEndTime());
 446     }
 447
 448     /**
 449      * Test, with two traces opened in parallel (not in an experiment), if we
 450      * select a time range valid in one of them. That trace's time range should
 451      * be updated, but not the other one.
 452      */
 453     @Test
 454     public void testTwoTracesTimeRangeAllInOne() {
 455         openTrace(trace1);
 456         openTrace(trace2);
 457         selectTrace(trace1);
 458         TmfTimeRange range = new TmfTimeRange(
 459                 new TmfTimestamp(t1start + ONE_SECOND, SCALE),
 460                 new TmfTimestamp(t1end - ONE_SECOND, SCALE));
 461         selectTimeRange(range);
 462
 463         /* Range of trace1 should be equal to the requested one */
 464         assertEquals(range, tm.getCurrentRange());
 465
 466         /* The range of trace 2 should not have changed */
 467         selectTrace(trace2);
 468         assertEquals(getInitialRange(trace2), tm.getCurrentRange());
 469     }
 470
 471     /**
 472      * Test, with two traces in parallel, when we select a time range that is
 473      * only partially valid for one of the traces.
 474      *
 475      * The first trace's time range should be clamped to a valid range, and the
 476      * second one's should not change.
 477      */
 478     @Test
 479     public void testTwoTracesTimeRangePartiallyInOne() {
 480         openTrace(trace1);
 481         openTrace(trace2);
 482         selectTrace(trace1);
 483         TmfTimeRange range = new TmfTimeRange(
 484                 new TmfTimestamp(t1start + ONE_SECOND, SCALE),
 485                 new TmfTimestamp(t1end + ONE_SECOND, SCALE));
 486         selectTimeRange(range);
 487
 488         /* Range of trace1 should get clamped to its end time */
 489         TmfTimeRange expectedRange = new TmfTimeRange(
 490                 new TmfTimestamp(t1start + ONE_SECOND, SCALE),
 491                 new TmfTimestamp(t1end, SCALE));
 492         assertEquals(expectedRange, tm.getCurrentRange());
 493
 494         /* Range of trace2 should not have changed */
 495         selectTrace(trace2);
 496         assertEquals(getInitialRange(trace2), tm.getCurrentRange());
 497     }
 498
 499     /**
 500      * Test, with two traces in parallel, when we select a time range that is
 501      * only partially valid for both traces.
 502      *
 503      * Each trace's time range should get clamped to respectively valid ranges.
 504      */
 505     @Test
 506     public void testTwoTracesTimeRangeInBoth() {
 507         openTrace(trace1);
 508         openTrace(trace2);
 509         selectTrace(trace1);
 510         TmfTimeRange range = new TmfTimeRange(
 511                 new TmfTimestamp(t1end - ONE_SECOND, SCALE),
 512                 new TmfTimestamp(t2start + ONE_SECOND, SCALE));
 513         selectTimeRange(range);
 514
 515         /* Range of trace1 should be clamped to its end time */
 516         TmfTimeRange expectedRange = new TmfTimeRange(
 517                 new TmfTimestamp(t1end - ONE_SECOND, SCALE),
 518                 new TmfTimestamp(t1end, SCALE));
 519         assertEquals(expectedRange, tm.getCurrentRange());
 520
 521         /* Range of trace2 should be clamped to its start time */
 522         selectTrace(trace2);
 523         expectedRange = new TmfTimeRange(
 524                 new TmfTimestamp(t2start, SCALE),
 525                 new TmfTimestamp(t2start + ONE_SECOND, SCALE));
 526         assertEquals(expectedRange, tm.getCurrentRange());
 527     }
 528
 529     /**
 530      * Test, with two traces in parallel, when we select a time range that is
 531      * not valid for any trace.
 532      *
 533      * Each trace's time range should not be modified.
 534      */
 535     @Test
 536     public void testTwoTracesTimeRangeInBetween() {
 537         openTrace(trace1);
 538         openTrace(trace2);
 539         selectTrace(trace1);
 540         TmfTimeRange range = new TmfTimeRange(
 541                 new TmfTimestamp(t1end + ONE_SECOND, SCALE),
 542                 new TmfTimestamp(t1end - ONE_SECOND, SCALE));
 543         selectTimeRange(range);
 544
 545         /* Range of trace1 should not have changed */
 546         TmfTimeRange expectedRange = getInitialRange(trace1);
 547         TmfTimeRange curRange = tm.getCurrentRange();
 548         assertEquals(expectedRange.getStartTime(), curRange.getStartTime());
 549         assertEquals(expectedRange.getEndTime(), curRange.getEndTime());
 550
 551         /* Range of trace2 should not have changed */
 552         selectTrace(trace2);
 553         expectedRange = getInitialRange(trace2);
 554         curRange = tm.getCurrentRange();
 555         assertEquals(expectedRange.getStartTime(), curRange.getStartTime());
 556         assertEquals(expectedRange.getEndTime(), curRange.getEndTime());
 557     }
 558
 559     // ------------------------------------------------------------------------
 560     // Test an experiment
 561     // ------------------------------------------------------------------------
 562
 563     /**
 564      * Test in an experiment when we select a timestamp that is part of one of
 565      * the experiment's traces.
 566      *
 567      * The experiment's current time should be correctly updated.
 568      */
 569     @Test
 570     public void testExperimentTimestampInTrace() {
 571         TmfExperiment exp = createExperiment(trace1, trace2);
 572         openTrace(exp);
 573         TmfTimestamp ts = new TmfTimestamp(t1start + ONE_SECOND, SCALE);
 574         selectTimestamp(ts);
 575
 576         /* The experiment's current time should be updated. */
 577         assertEquals(ts, tm.getSelectionBeginTime());
 578         assertEquals(ts, tm.getSelectionEndTime());
 579     }
 580
 581     /**
 582      * Test in an experiment when we select a timestamp that is between two
 583      * traces in the experiment.
 584      *
 585      * The experiment's current time should still be updated, since the
 586      * timestamp is valid in the experiment itself.
 587      */
 588     @Test
 589     public void testExperimentTimestampInBetween() {
 590         TmfExperiment exp = createExperiment(trace1, trace2);
 591         openTrace(exp);
 592         TmfTimestamp ts = new TmfTimestamp(t1end + ONE_SECOND, SCALE);
 593         selectTimestamp(ts);
 594
 595         /* The experiment's current time should be updated. */
 596         assertEquals(ts, tm.getSelectionBeginTime());
 597         assertEquals(ts, tm.getSelectionEndTime());
 598     }
 599
 600     /**
 601      * Test in an experiment when we select a timestamp that is outside of the
 602      * total range of the experiment.
 603      *
 604      * The experiment's current time should not be updated.
 605      */
 606     @Test
 607     public void testExperimentTimestampInvalid() {
 608         TmfExperiment exp = createExperiment(trace1, trace2);
 609         openTrace(exp);
 610         TmfTimestamp ts = new TmfTimestamp(t2end + ONE_SECOND, SCALE);
 611         selectTimestamp(ts);
 612
 613         /* The experiment's current time should NOT be updated. */
 614         assertEquals(trace1.getStartTime(), tm.getSelectionBeginTime());
 615         assertEquals(trace1.getStartTime(), tm.getSelectionEndTime());
 616     }
 617
 618     /**
 619      * Test the initial range of an experiment.
 620      */
 621     @Test
 622     public void testExperimentInitialRange() {
 623         TmfExperiment exp = createExperiment(trace1, trace2);
 624         openTrace(exp);
 625         /*
 626          * The initial range should be == to the initial range of the earliest
 627          * trace (here trace1).
 628          */
 629         final TmfTimeRange actualRange = tm.getCurrentRange();
 630
 631         assertEquals(getInitialRange(trace1), actualRange);
 632         assertEquals(getInitialRange(exp), actualRange);
 633     }
 634
 635     /**
 636      * Test the range clamping with the start time of the range outside of the
 637      * earliest trace's range. Only that start time should get clamped.
 638      */
 639     @Test
 640     public void testExperimentRangeClampingOne() {
 641         TmfExperiment exp = createExperiment(trace1, trace2);
 642         openTrace(exp);
 643
 644         final TmfTimeRange range = new TmfTimeRange(
 645                 new TmfTimestamp(t1start - ONE_SECOND, SCALE),
 646                 new TmfTimestamp(t1end - ONE_SECOND, SCALE));
 647         selectTimeRange(range);
 648
 649         TmfTimeRange actualRange = tm.getCurrentRange();
 650         assertEquals(t1start, actualRange.getStartTime().getValue());
 651         assertEquals(t1end - ONE_SECOND, actualRange.getEndTime().getValue());
 652     }
 653
 654     /**
 655      * Test the range clamping when both the start and end times of the signal's
 656      * range are outside of the trace's range. The range should clamp to the
 657      * experiment's range.
 658      */
 659     @Test
 660     public void testExperimentRangeClampingBoth() {
 661         TmfExperiment exp = createExperiment(trace1, trace2);
 662         openTrace(exp);
 663
 664         final TmfTimeRange range = new TmfTimeRange(
 665                 new TmfTimestamp(t1start - ONE_SECOND, SCALE),
 666                 new TmfTimestamp(t2end + ONE_SECOND, SCALE));
 667         selectTimeRange(range);
 668
 669         TmfTimeRange actualRange = tm.getCurrentRange();
 670         assertEquals(t1start, actualRange.getStartTime().getValue());
 671         assertEquals(t2end, actualRange.getEndTime().getValue());
 672     }
 673
 674     /**
 675      * Test selecting a range in-between two disjoint traces in an experiment.
 676      * The range should still get correctly selected, even if no trace has any
 677      * events in that range.
 678      */
 679     @Test
 680     public void testExperimentRangeInBetween() {
 681         TmfExperiment exp = createExperiment(trace1, trace2);
 682         openTrace(exp);
 683
 684         final TmfTimeRange range = new TmfTimeRange(
 685                 new TmfTimestamp(t1end + ONE_SECOND, SCALE),
 686                 new TmfTimestamp(t2start - ONE_SECOND, SCALE));
 687         selectTimeRange(range);
 688
 689         TmfTimeRange actualRange = tm.getCurrentRange();
 690         assertEquals(range, actualRange);
 691     }
 692
 693     // ------------------------------------------------------------------------
 694     // Utility methods
 695     // ------------------------------------------------------------------------
 696
 697     private static TmfExperiment createExperiment(ITmfTrace t1, ITmfTrace t2) {
 698         ITmfTrace[] traces = new ITmfTrace[] { t1, t2 };
 699         TmfExperiment exp = new TmfExperiment(ITmfEvent.class, "test-exp", traces,
 700                 TmfExperiment.DEFAULT_INDEX_PAGE_SIZE, null);
 701         exp.indexTrace(true);
 702         // Deregister experiment from signal manager so that it doesn't
 703         // interfere with the TmfTraceManager tests
 704         TmfSignalManager.deregister(exp);
 705         return exp;
 706     }
 707
 708     private static TmfTimeRange getInitialRange(ITmfTrace trace) {
 709         return new TmfTimeRange(
 710                 trace.getStartTime(),
 711                 calculateOffset(trace.getStartTime(), trace.getInitialRangeOffset()));
 712     }
 713
 714     /**
 715      * Basically a "initial + offset" operation, but for ITmfTimetamp objects.
 716      */
 717     private static @NonNull ITmfTimestamp calculateOffset(ITmfTimestamp initialTs, ITmfTimestamp offsetTs) {
 718         long start = initialTs.normalize(0, SCALE).getValue();
 719         long offset = offsetTs.normalize(0, SCALE).getValue();
 720         return new TmfTimestamp(start + offset, SCALE);
 721     }
 722 }