tmf/org.eclipse.tracecompass.tmf.core.tests/src/org/eclipse/tracecompass/tmf/core/tests/trace/TmfExperimentTest.java

   1 /*******************************************************************************
   2  * Copyright (c) 2009, 2014 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  *   Francois Chouinard - Adjusted for new Trace Model
  12  *   Alexandre Montplaisir - Port to JUnit4
  13  *   Patrick Tasse - Updated for rank in experiment location
  14  *******************************************************************************/
  15
  16 package org.eclipse.tracecompass.tmf.core.tests.trace;
  17
  18 import static org.junit.Assert.assertEquals;
  19 import static org.junit.Assert.assertFalse;
  20 import static org.junit.Assert.assertNotNull;
  21 import static org.junit.Assert.assertNull;
  22 import static org.junit.Assert.assertTrue;
  23
  24 import java.io.File;
  25 import java.io.IOException;
  26 import java.net.URISyntaxException;
  27 import java.net.URL;
  28 import java.util.Vector;
  29
  30 import org.eclipse.core.runtime.FileLocator;
  31 import org.eclipse.core.runtime.Path;
  32 import org.eclipse.tracecompass.internal.tmf.core.trace.experiment.TmfExperimentContext;
  33 import org.eclipse.tracecompass.internal.tmf.core.trace.experiment.TmfExperimentLocation;
  34 import org.eclipse.tracecompass.tmf.core.analysis.IAnalysisModule;
  35 import org.eclipse.tracecompass.tmf.core.event.ITmfEvent;
  36 import org.eclipse.tracecompass.tmf.core.exceptions.TmfTraceException;
  37 import org.eclipse.tracecompass.tmf.core.request.ITmfEventRequest;
  38 import org.eclipse.tracecompass.tmf.core.request.ITmfEventRequest.ExecutionType;
  39 import org.eclipse.tracecompass.tmf.core.request.TmfEventRequest;
  40 import org.eclipse.tracecompass.tmf.core.signal.TmfTraceOpenedSignal;
  41 import org.eclipse.tracecompass.tmf.core.tests.TmfCoreTestPlugin;
  42 import org.eclipse.tracecompass.tmf.core.tests.shared.TmfTestTrace;
  43 import org.eclipse.tracecompass.tmf.core.timestamp.TmfTimeRange;
  44 import org.eclipse.tracecompass.tmf.core.timestamp.TmfTimestamp;
  45 import org.eclipse.tracecompass.tmf.core.trace.ITmfContext;
  46 import org.eclipse.tracecompass.tmf.core.trace.ITmfTrace;
  47 import org.eclipse.tracecompass.tmf.core.trace.TmfTraceUtils;
  48 import org.eclipse.tracecompass.tmf.core.trace.experiment.TmfExperiment;
  49 import org.eclipse.tracecompass.tmf.core.trace.location.ITmfLocation;
  50 import org.eclipse.tracecompass.tmf.core.trace.location.TmfLongLocation;
  51 import org.eclipse.tracecompass.tmf.tests.stubs.analysis.TestExperimentAnalysis;
  52 import org.eclipse.tracecompass.tmf.tests.stubs.trace.TmfExperimentStub;
  53 import org.eclipse.tracecompass.tmf.tests.stubs.trace.TmfTraceStub;
  54 import org.junit.Before;
  55 import org.junit.Test;
  56
  57 /**
  58  * Test suite for the TmfExperiment class (single trace).
  59  */
  60 @SuppressWarnings("javadoc")
  61 public class TmfExperimentTest {
  62
  63     // ------------------------------------------------------------------------
  64     // Attributes
  65     // ------------------------------------------------------------------------
  66
  67     private static final String EXPERIMENT  = "MyExperiment";
  68     private static int          NB_EVENTS   = 10000;
  69     private static int          BLOCK_SIZE  = 1000;
  70
  71     private static final double DELTA = 1e-15;
  72
  73     private ITmfTrace[] fTestTraces;
  74     private TmfExperimentStub fExperiment;
  75
  76     private static byte SCALE = (byte) -3;
  77
  78     // ------------------------------------------------------------------------
  79     // Housekeeping
  80     // ------------------------------------------------------------------------
  81
  82     private synchronized ITmfTrace[] setupTrace(final String path) {
  83         if (fTestTraces == null) {
  84             fTestTraces = new ITmfTrace[1];
  85             try {
  86                 final URL location = FileLocator.find(TmfCoreTestPlugin.getDefault().getBundle(), new Path(path), null);
  87                 final File test = new File(FileLocator.toFileURL(location).toURI());
  88                 final TmfTraceStub trace = new TmfTraceStub(test.getPath(), 0, true, null);
  89                 fTestTraces[0] = trace;
  90             } catch (final TmfTraceException e) {
  91                 e.printStackTrace();
  92             } catch (final URISyntaxException e) {
  93                 e.printStackTrace();
  94             } catch (final IOException e) {
  95                 e.printStackTrace();
  96             }
  97         }
  98         return fTestTraces;
  99     }
 100
 101     private synchronized void setupExperiment() {
 102         if (fExperiment == null) {
 103             fExperiment = new TmfExperimentStub(EXPERIMENT, fTestTraces, BLOCK_SIZE);
 104             fExperiment.getIndexer().buildIndex(0, TmfTimeRange.ETERNITY, true);
 105         }
 106     }
 107
 108     @Before
 109     public void setUp() {
 110         setupTrace(TmfTestTrace.A_TEST_10K.getFullPath());
 111         setupExperiment();
 112     }
 113
 114     // ------------------------------------------------------------------------
 115     // Constructor
 116     // ------------------------------------------------------------------------
 117
 118     @Test
 119     public void testSimpleTmfExperimentConstructor() {
 120         TmfExperiment experiment = new TmfExperiment(ITmfEvent.class, EXPERIMENT,
 121                 fTestTraces, TmfExperiment.DEFAULT_INDEX_PAGE_SIZE, null);
 122         assertEquals("GetId", EXPERIMENT, experiment.getName());
 123         assertEquals("GetCacheSize", TmfExperiment.DEFAULT_INDEX_PAGE_SIZE, experiment.getCacheSize());
 124         experiment.dispose();
 125
 126         experiment = new TmfExperiment(ITmfEvent.class, EXPERIMENT, null,
 127                 TmfExperiment.DEFAULT_INDEX_PAGE_SIZE, null);
 128         experiment.dispose();
 129     }
 130
 131     @Test
 132     public void testNormalTmfExperimentConstructor() {
 133         assertEquals("GetId", EXPERIMENT, fExperiment.getName());
 134         assertEquals("GetNbEvents", NB_EVENTS, fExperiment.getNbEvents());
 135
 136         final long nbExperimentEvents = fExperiment.getNbEvents();
 137         assertEquals("GetNbEvents", NB_EVENTS, nbExperimentEvents);
 138
 139         final long nbTraceEvents = fExperiment.getTraces().get(0).getNbEvents();
 140         assertEquals("GetNbEvents", NB_EVENTS, nbTraceEvents);
 141
 142         final TmfTimeRange timeRange = fExperiment.getTimeRange();
 143         assertEquals("getStartTime", 1, timeRange.getStartTime().getValue());
 144         assertEquals("getEndTime", NB_EVENTS, timeRange.getEndTime().getValue());
 145     }
 146
 147     // ------------------------------------------------------------------------
 148     // Experiment setup
 149     // ------------------------------------------------------------------------
 150
 151     @Test
 152     public void testExperimentInitialization() {
 153         /*
 154          * Calling default constructor, then init should be equivalent to
 155          * calling the full constructor
 156          */
 157
 158         TmfExperimentStub experiment = new TmfExperimentStub(EXPERIMENT, fTestTraces, 5000);
 159         experiment.getIndexer().buildIndex(0, TmfTimeRange.ETERNITY, true);
 160
 161         assertEquals("GetId", EXPERIMENT, fExperiment.getName());
 162         assertEquals("GetNbEvents", NB_EVENTS, fExperiment.getNbEvents());
 163
 164         final long nbExperimentEvents = fExperiment.getNbEvents();
 165         assertEquals("GetNbEvents", NB_EVENTS, nbExperimentEvents);
 166
 167         final long nbTraceEvents = fExperiment.getTraces().get(0).getNbEvents();
 168         assertEquals("GetNbEvents", NB_EVENTS, nbTraceEvents);
 169
 170         final TmfTimeRange timeRange = fExperiment.getTimeRange();
 171         assertEquals("getStartTime", 1, timeRange.getStartTime().getValue());
 172         assertEquals("getEndTime", NB_EVENTS, timeRange.getEndTime().getValue());
 173     }
 174
 175     // ------------------------------------------------------------------------
 176     // getTimestamp
 177     // ------------------------------------------------------------------------
 178
 179     @Test
 180     public void testGetTimestamp() {
 181         assertEquals("getTimestamp", new TmfTimestamp(    1, (byte) -3), fExperiment.getTimestamp(   0));
 182         assertEquals("getTimestamp", new TmfTimestamp(    2, (byte) -3), fExperiment.getTimestamp(   1));
 183         assertEquals("getTimestamp", new TmfTimestamp(   11, (byte) -3), fExperiment.getTimestamp(  10));
 184         assertEquals("getTimestamp", new TmfTimestamp(  101, (byte) -3), fExperiment.getTimestamp( 100));
 185         assertEquals("getTimestamp", new TmfTimestamp( 1001, (byte) -3), fExperiment.getTimestamp(1000));
 186         assertEquals("getTimestamp", new TmfTimestamp( 2001, (byte) -3), fExperiment.getTimestamp(2000));
 187         assertEquals("getTimestamp", new TmfTimestamp( 2501, (byte) -3), fExperiment.getTimestamp(2500));
 188         assertEquals("getTimestamp", new TmfTimestamp(10000, (byte) -3), fExperiment.getTimestamp(9999));
 189         assertNull("getTimestamp", fExperiment.getTimestamp(10000));
 190     }
 191
 192     // ------------------------------------------------------------------------
 193     // State system, statistics and modules methods
 194     // ------------------------------------------------------------------------
 195
 196     @Test
 197     public void testGetAnalysisModules() {
 198         TmfExperiment experiment = fExperiment;
 199         assertNotNull(experiment);
 200
 201         /* There should not be any modules at this point */
 202         Iterable<IAnalysisModule> modules = experiment.getAnalysisModules();
 203         assertFalse(modules.iterator().hasNext());
 204
 205         /* Open the experiment, the modules should be populated */
 206         experiment.traceOpened(new TmfTraceOpenedSignal(this, experiment, null));
 207         modules = experiment.getAnalysisModules();
 208         Iterable<TestExperimentAnalysis> testModules = TmfTraceUtils.getAnalysisModulesOfClass(experiment, TestExperimentAnalysis.class);
 209         assertTrue(modules.iterator().hasNext());
 210         assertTrue(testModules.iterator().hasNext());
 211     }
 212
 213     // ------------------------------------------------------------------------
 214     // seekEvent by location
 215     // ------------------------------------------------------------------------
 216
 217     @Test
 218     public void testSeekBadLocation() {
 219         ITmfContext context = fExperiment.seekEvent(new TmfLongLocation(0L));
 220         assertNull("seekEvent", context);
 221     }
 222
 223     @Test
 224     public void testSeekNoTrace() {
 225         TmfExperiment experiment = new TmfExperiment(ITmfEvent.class, EXPERIMENT,
 226                 null, TmfExperiment.DEFAULT_INDEX_PAGE_SIZE, null);
 227         ITmfContext context = experiment.seekEvent((TmfExperimentLocation) null);
 228         validateContextRanks(context);
 229         experiment.dispose();
 230     }
 231
 232     // ------------------------------------------------------------------------
 233     // seekEvent on ratio
 234     // ------------------------------------------------------------------------
 235
 236     @Test
 237     public void testSeekEventOnRatio() {
 238         // First event
 239         ITmfContext context = fExperiment.seekEvent(0.0);
 240         assertEquals("Context rank", 0, context.getRank());
 241         ITmfEvent event = fExperiment.parseEvent(context);
 242         assertEquals("Event timestamp", 1, event.getTimestamp().getValue());
 243         assertEquals("Context rank", 0, context.getRank());
 244
 245         // Middle event
 246         int midTrace = NB_EVENTS / 2;
 247         context = fExperiment.seekEvent(0.5);
 248         assertEquals("Context rank", midTrace, context.getRank());
 249         event = fExperiment.parseEvent(context);
 250         assertEquals("Event timestamp", midTrace + 1, event.getTimestamp().getValue());
 251         assertEquals("Context rank", midTrace, context.getRank());
 252
 253         // Last event
 254         context = fExperiment.seekEvent(1.0);
 255         assertEquals("Context rank", NB_EVENTS, context.getRank());
 256         event = fExperiment.parseEvent(context);
 257         assertNull("Event timestamp", event);
 258         assertEquals("Context rank", NB_EVENTS, context.getRank());
 259
 260         // Beyond last event
 261         context = fExperiment.seekEvent(1.1);
 262         assertEquals("Context rank", NB_EVENTS, context.getRank());
 263         event = fExperiment.parseEvent(context);
 264         assertNull("Event timestamp", event);
 265         assertEquals("Context rank", NB_EVENTS, context.getRank());
 266
 267         // Negative ratio
 268         context = fExperiment.seekEvent(-0.5);
 269         assertEquals("Context rank", 0, context.getRank());
 270         event = fExperiment.parseEvent(context);
 271         assertEquals("Event timestamp", 1, event.getTimestamp().getValue());
 272         assertEquals("Context rank", 0, context.getRank());
 273     }
 274
 275     @Test
 276     public void testGetLocationRatio() {
 277         // First event
 278         ITmfContext context = fExperiment.seekEvent((ITmfLocation) null);
 279         double ratio = fExperiment.getLocationRatio(context.getLocation());
 280         assertEquals("getLocationRatio", 0.0, ratio, DELTA);
 281
 282         // Middle event
 283         context = fExperiment.seekEvent(NB_EVENTS / 2);
 284         ratio = fExperiment.getLocationRatio(context.getLocation());
 285         assertEquals("getLocationRatio", (double) (NB_EVENTS / 2) / NB_EVENTS, ratio, DELTA);
 286
 287         // Last event
 288         context = fExperiment.seekEvent(NB_EVENTS - 1);
 289         ratio = fExperiment.getLocationRatio(context.getLocation());
 290         assertEquals("getLocationRatio", (double) (NB_EVENTS - 1) / NB_EVENTS, ratio, DELTA);
 291     }
 292
 293 //    @SuppressWarnings("rawtypes")
 294 //    public void testGetCurrentLocation() {
 295 //        ITmfContext context = fExperiment.seekEvent((ITmfLocation) null);
 296 //        ITmfLocation location = fExperiment.getCurrentLocation();
 297 //        assertEquals("getCurrentLocation", location, context.getLocation());
 298 //    }
 299
 300     // ------------------------------------------------------------------------
 301     // seekEvent on rank
 302     // ------------------------------------------------------------------------
 303
 304     @Test
 305     public void testSeekRankOnCacheBoundary() {
 306         long cacheSize = fExperiment.getCacheSize();
 307
 308         // On lower bound, returns the first event (TS = 1)
 309         ITmfContext context = fExperiment.seekEvent(0);
 310         assertEquals("Context rank", 0, context.getRank());
 311
 312         ITmfEvent event = fExperiment.getNext(context);
 313         assertEquals("Event timestamp", 1, event.getTimestamp().getValue());
 314         assertEquals("Context rank", 1, context.getRank());
 315
 316         // Position trace at event rank [cacheSize]
 317         context = fExperiment.seekEvent(cacheSize);
 318         assertEquals("Context rank", cacheSize, context.getRank());
 319
 320         event = fExperiment.getNext(context);
 321         assertEquals("Event timestamp", cacheSize + 1, event.getTimestamp().getValue());
 322         assertEquals("Context rank", cacheSize + 1, context.getRank());
 323
 324         // Position trace at event rank [4 * cacheSize]
 325         context = fExperiment.seekEvent(4 * cacheSize);
 326         assertEquals("Context rank", 4 * cacheSize, context.getRank());
 327
 328         event = fExperiment.getNext(context);
 329         assertEquals("Event timestamp", 4 * cacheSize + 1, event.getTimestamp().getValue());
 330         assertEquals("Context rank", 4 * cacheSize + 1, context.getRank());
 331     }
 332
 333     @Test
 334     public void testSeekRankNotOnCacheBoundary() {
 335         long cacheSize = fExperiment.getCacheSize();
 336
 337         // Position trace at event rank 9
 338         ITmfContext context = fExperiment.seekEvent(9);
 339         assertEquals("Context rank", 9, context.getRank());
 340
 341         ITmfEvent event = fExperiment.getNext(context);
 342         assertEquals("Event timestamp", 10, event.getTimestamp().getValue());
 343         assertEquals("Context rank", 10, context.getRank());
 344
 345         // Position trace at event rank [cacheSize - 1]
 346         context = fExperiment.seekEvent(cacheSize - 1);
 347         assertEquals("Context rank", cacheSize - 1, context.getRank());
 348
 349         event = fExperiment.getNext(context);
 350         assertEquals("Event timestamp", cacheSize, event.getTimestamp().getValue());
 351         assertEquals("Context rank", cacheSize, context.getRank());
 352
 353         // Position trace at event rank [cacheSize + 1]
 354         context = fExperiment.seekEvent(cacheSize + 1);
 355         assertEquals("Context rank", cacheSize + 1, context.getRank());
 356
 357         event = fExperiment.getNext(context);
 358         assertEquals("Event timestamp", cacheSize + 2, event.getTimestamp().getValue());
 359         assertEquals("Context rank", cacheSize + 2, context.getRank());
 360
 361         // Position trace at event rank 4500
 362         context = fExperiment.seekEvent(4500);
 363         assertEquals("Context rank", 4500, context.getRank());
 364
 365         event = fExperiment.getNext(context);
 366         assertEquals("Event timestamp", 4501, event.getTimestamp().getValue());
 367         assertEquals("Context rank", 4501, context.getRank());
 368     }
 369
 370     @Test
 371     public void testSeekRankOutOfScope() {
 372         // Position trace at beginning
 373         ITmfContext context = fExperiment.seekEvent(-1);
 374         assertEquals("Event rank", 0, context.getRank());
 375
 376         ITmfEvent event = fExperiment.getNext(context);
 377         assertEquals("Event timestamp", 1, event.getTimestamp().getValue());
 378         assertEquals("Context rank", 1, context.getRank());
 379
 380         // Position trace at event passed the end
 381         context = fExperiment.seekEvent(NB_EVENTS);
 382         assertEquals("Context rank", NB_EVENTS, context.getRank());
 383
 384         event = fExperiment.getNext(context);
 385         assertNull("Event", event);
 386         assertEquals("Context rank", NB_EVENTS, context.getRank());
 387     }
 388
 389     // ------------------------------------------------------------------------
 390     // seekEvent on timestamp
 391     // ------------------------------------------------------------------------
 392
 393     @Test
 394     public void testSeekTimestampOnCacheBoundary() {
 395         long cacheSize = fExperiment.getCacheSize();
 396
 397         // Position trace at event rank 0
 398         ITmfContext context = fExperiment.seekEvent(new TmfTimestamp(1, SCALE));
 399         assertEquals("Context rank", 0, context.getRank());
 400
 401         ITmfEvent event = fExperiment.getNext(context);
 402         assertEquals("Event timestamp", 1, event.getTimestamp().getValue());
 403         assertEquals("Context rank", 1, context.getRank());
 404
 405         // Position trace at event rank [cacheSize]
 406         context = fExperiment.seekEvent(new TmfTimestamp(cacheSize + 1, SCALE));
 407         assertEquals("Event rank", cacheSize, context.getRank());
 408
 409         event = fExperiment.getNext(context);
 410         assertEquals("Event timestamp", cacheSize + 1, event.getTimestamp().getValue());
 411         assertEquals("Context rank", cacheSize + 1, context.getRank());
 412
 413         // Position trace at event rank [4 * cacheSize]
 414         context = fExperiment.seekEvent(new TmfTimestamp(4 * cacheSize + 1, SCALE));
 415         assertEquals("Context rank", 4 * cacheSize, context.getRank());
 416
 417         event = fExperiment.getNext(context);
 418         assertEquals("Event timestamp", 4 * cacheSize + 1, event.getTimestamp().getValue());
 419         assertEquals("Context rank", 4 * cacheSize + 1, context.getRank());
 420     }
 421
 422     @Test
 423     public void testSeekTimestampNotOnCacheBoundary() {
 424         // Position trace at event rank 1 (TS = 2)
 425         ITmfContext context = fExperiment.seekEvent(new TmfTimestamp(2, SCALE));
 426         assertEquals("Context rank", 1, context.getRank());
 427
 428         ITmfEvent event = fExperiment.getNext(context);
 429         assertEquals("Event timestamp", 2, event.getTimestamp().getValue());
 430         assertEquals("Context rank", 2, context.getRank());
 431
 432         // Position trace at event rank 9 (TS = 10)
 433         context = fExperiment.seekEvent(new TmfTimestamp(10, SCALE));
 434         assertEquals("Context rank", 9, context.getRank());
 435
 436         event = fExperiment.getNext(context);
 437         assertEquals("Event timestamp", 10, event.getTimestamp().getValue());
 438         assertEquals("Context rank", 10, context.getRank());
 439
 440         // Position trace at event rank 999 (TS = 1000)
 441         context = fExperiment.seekEvent(new TmfTimestamp(1000, SCALE));
 442         assertEquals("Context rank", 999, context.getRank());
 443
 444         event = fExperiment.getNext(context);
 445         assertEquals("Event timestamp", 1000, event.getTimestamp().getValue());
 446         assertEquals("Context rank", 1000, context.getRank());
 447
 448         // Position trace at event rank 1001 (TS = 1002)
 449         context = fExperiment.seekEvent(new TmfTimestamp(1002, SCALE));
 450         assertEquals("Context rank", 1001, context.getRank());
 451
 452         event = fExperiment.getNext(context);
 453         assertEquals("Event timestamp", 1002, event.getTimestamp().getValue());
 454         assertEquals("Context rank", 1002, context.getRank());
 455
 456         // Position trace at event rank 4500 (TS = 4501)
 457         context = fExperiment.seekEvent(new TmfTimestamp(4501, SCALE));
 458         assertEquals("Context rank", 4500, context.getRank());
 459
 460         event = fExperiment.getNext(context);
 461         assertEquals("Event timestamp", 4501, event.getTimestamp().getValue());
 462         assertEquals("Context rank", 4501, context.getRank());
 463     }
 464
 465     @Test
 466     public void testSeekTimestampOutOfScope() {
 467         // Position trace at beginning
 468         ITmfContext context = fExperiment.seekEvent(new TmfTimestamp(-1, SCALE));
 469         assertEquals("Event rank", 0, context.getRank());
 470
 471         ITmfEvent event = fExperiment.getNext(context);
 472         assertEquals("Event timestamp", 1, event.getTimestamp().getValue());
 473         assertEquals("Event rank", 1, context.getRank());
 474
 475         // Position trace at event passed the end
 476         context = fExperiment.seekEvent(new TmfTimestamp(NB_EVENTS + 1, SCALE));
 477         event = fExperiment.getNext(context);
 478         assertNull("Event location", event);
 479         assertEquals("Event rank", ITmfContext.UNKNOWN_RANK, context.getRank());
 480     }
 481
 482     // ------------------------------------------------------------------------
 483     // seekEvent by location (context rank is undefined)
 484     // ------------------------------------------------------------------------
 485
 486     @Test
 487     public void testSeekLocationOnCacheBoundary() {
 488         long cacheSize = fExperiment.getCacheSize();
 489
 490         // Position trace at event rank 0
 491         ITmfContext tmpContext = fExperiment.seekEvent(0);
 492         ITmfContext context = fExperiment.seekEvent(tmpContext.getLocation());
 493
 494         ITmfEvent event = fExperiment.getNext(context);
 495         assertEquals("Event timestamp", 1, event.getTimestamp().getValue());
 496
 497         event = fExperiment.getNext(context);
 498         assertEquals("Event timestamp", 2, event.getTimestamp().getValue());
 499
 500         // Position trace at event rank 'cacheSize'
 501         tmpContext = fExperiment.seekEvent(cacheSize);
 502         context = fExperiment.seekEvent(tmpContext.getLocation());
 503
 504         event = fExperiment.getNext(context);
 505         assertEquals("Event timestamp", cacheSize + 1, event.getTimestamp().getValue());
 506
 507         event = fExperiment.getNext(context);
 508         assertEquals("Event timestamp", cacheSize + 2, event.getTimestamp().getValue());
 509
 510         // Position trace at event rank 4 * 'cacheSize'
 511         tmpContext = fExperiment.seekEvent(4 * cacheSize);
 512         context = fExperiment.seekEvent(tmpContext.getLocation());
 513
 514         event = fExperiment.getNext(context);
 515         assertEquals("Event timestamp", 4 * cacheSize + 1, event.getTimestamp().getValue());
 516
 517         event = fExperiment.getNext(context);
 518         assertEquals("Event timestamp", 4 * cacheSize + 2, event.getTimestamp().getValue());
 519     }
 520
 521     @Test
 522     public void testSeekLocationNotOnCacheBoundary() {
 523         long cacheSize = fExperiment.getCacheSize();
 524
 525         // Position trace at event 'cacheSize' - 1
 526         ITmfContext tmpContext = fExperiment.seekEvent(cacheSize - 1);
 527         ITmfContext context = fExperiment.seekEvent(tmpContext.getLocation());
 528
 529         ITmfEvent event = fExperiment.getNext(context);
 530         assertEquals("Event timestamp", cacheSize, event.getTimestamp().getValue());
 531
 532         event = fExperiment.getNext(context);
 533         assertEquals("Event timestamp", cacheSize + 1, event.getTimestamp().getValue());
 534
 535         // Position trace at event rank 2 * 'cacheSize' - 1
 536         tmpContext = fExperiment.seekEvent(2 * cacheSize - 1);
 537         context = fExperiment.seekEvent(tmpContext.getLocation());
 538         context = fExperiment.seekEvent(2 * cacheSize - 1);
 539
 540         event = fExperiment.getNext(context);
 541         assertEquals("Event timestamp", 2 * cacheSize, event.getTimestamp().getValue());
 542
 543         event = fExperiment.getNext(context);
 544         assertEquals("Event timestamp", 2 * cacheSize + 1, event.getTimestamp().getValue());
 545
 546         // Position trace at event rank 4500
 547         tmpContext = fExperiment.seekEvent(4500);
 548         context = fExperiment.seekEvent(tmpContext.getLocation());
 549
 550         event = fExperiment.getNext(context);
 551         assertEquals("Event timestamp", 4501, event.getTimestamp().getValue());
 552
 553         event = fExperiment.getNext(context);
 554         assertEquals("Event timestamp", 4502, event.getTimestamp().getValue());
 555     }
 556
 557     @Test
 558     public void testSeekLocationOutOfScope() {
 559         // Position trace at beginning
 560         ITmfContext context = fExperiment.seekEvent((ITmfLocation) null);
 561
 562         ITmfEvent event = fExperiment.getNext(context);
 563         assertEquals("Event timestamp", 1, event.getTimestamp().getValue());
 564     }
 565
 566     // ------------------------------------------------------------------------
 567     // getNext - updates the context
 568     // ------------------------------------------------------------------------
 569
 570     private static void validateContextRanks(ITmfContext context) {
 571         assertTrue("Experiment context type", context instanceof TmfExperimentContext);
 572         TmfExperimentContext ctx = (TmfExperimentContext) context;
 573
 574         int nbTraces = ctx.getNbTraces();
 575
 576         // expRank = sum(trace ranks) - nbTraces + 1 (if lastTraceRead != NO_TRACE)
 577         long expRank = -nbTraces + ((ctx.getLastTrace() != TmfExperimentContext.NO_TRACE) ? 1 : 0);
 578         for (int i = 0; i < nbTraces; i++) {
 579             ITmfContext subContext = ctx.getContext(i);
 580             assertNotNull(subContext);
 581             long rank = subContext.getRank();
 582             if (rank == -1) {
 583                 expRank = -1;
 584                 break;
 585             }
 586             expRank += rank;
 587         }
 588         assertEquals("Experiment context rank", expRank, ctx.getRank());
 589     }
 590
 591     @Test
 592     public void testGetNextAfteSeekingOnTS_1() {
 593
 594         final long INITIAL_TS = 1;
 595         final int NB_READS = 20;
 596
 597         // On lower bound, returns the first event (ts = 1)
 598         final ITmfContext context = fExperiment.seekEvent(new TmfTimestamp(INITIAL_TS, SCALE));
 599
 600         validateContextRanks(context);
 601
 602         // Read NB_EVENTS
 603         ITmfEvent event;
 604         for (int i = 0; i < NB_READS; i++) {
 605             event = fExperiment.getNext(context);
 606             assertEquals("Event timestamp", INITIAL_TS + i, event.getTimestamp().getValue());
 607             assertEquals("Event rank", INITIAL_TS + i, context.getRank());
 608         }
 609
 610         // Make sure we stay positioned
 611         event = fExperiment.parseEvent(context);
 612         assertEquals("Event timestamp", INITIAL_TS + NB_READS, event.getTimestamp().getValue());
 613         assertEquals("Event rank", INITIAL_TS + NB_READS - 1, context.getRank());
 614
 615         validateContextRanks(context);
 616     }
 617
 618     @Test
 619     public void testGetNextAfteSeekingOnTS_2() {
 620         final long INITIAL_TS = 2;
 621         final int NB_READS = 20;
 622
 623         // On lower bound, returns the first event (ts = 2)
 624         final ITmfContext context = fExperiment.seekEvent(new TmfTimestamp(INITIAL_TS, SCALE));
 625
 626         validateContextRanks(context);
 627
 628         // Read NB_EVENTS
 629         ITmfEvent event;
 630         for (int i = 0; i < NB_READS; i++) {
 631             event = fExperiment.getNext(context);
 632             assertEquals("Event timestamp", INITIAL_TS + i, event.getTimestamp().getValue());
 633             assertEquals("Event rank", INITIAL_TS + i, context.getRank());
 634         }
 635
 636         // Make sure we stay positioned
 637         event = fExperiment.parseEvent(context);
 638         assertEquals("Event timestamp", INITIAL_TS + NB_READS, event.getTimestamp().getValue());
 639         assertEquals("Event rank", INITIAL_TS + NB_READS - 1, context.getRank());
 640
 641         validateContextRanks(context);
 642     }
 643
 644     @Test
 645     public void testGetNextAfteSeekingOnTS_3() {
 646
 647         final long INITIAL_TS = 500;
 648         final int NB_READS = 20;
 649
 650         // On lower bound, returns the first event (ts = 500)
 651         final ITmfContext context = fExperiment.seekEvent(new TmfTimestamp(INITIAL_TS, SCALE));
 652
 653         validateContextRanks(context);
 654
 655         // Read NB_EVENTS
 656         ITmfEvent event;
 657         for (int i = 0; i < NB_READS; i++) {
 658             event = fExperiment.getNext(context);
 659             assertEquals("Event timestamp", INITIAL_TS + i, event.getTimestamp().getValue());
 660             assertEquals("Event rank", INITIAL_TS + i, context.getRank());
 661         }
 662
 663         // Make sure we stay positioned
 664         event = fExperiment.parseEvent(context);
 665         assertEquals("Event timestamp", INITIAL_TS + NB_READS, event.getTimestamp().getValue());
 666         assertEquals("Event rank", INITIAL_TS + NB_READS - 1, context.getRank());
 667
 668         validateContextRanks(context);
 669     }
 670
 671     @Test
 672     public void testGetNextAfterSeekingOnRank_1() {
 673         final long INITIAL_RANK = 0L;
 674         final int NB_READS = 20;
 675
 676         // On lower bound, returns the first event (rank = 0)
 677         final ITmfContext context = fExperiment.seekEvent(INITIAL_RANK);
 678
 679         validateContextRanks(context);
 680
 681         // Read NB_EVENTS
 682         ITmfEvent event;
 683         for (int i = 0; i < NB_READS; i++) {
 684             event = fExperiment.getNext(context);
 685             assertEquals("Event timestamp", INITIAL_RANK + i + 1, event.getTimestamp().getValue());
 686             assertEquals("Event rank", INITIAL_RANK + i + 1, context.getRank());
 687         }
 688
 689         // Make sure we stay positioned
 690         event = fExperiment.parseEvent(context);
 691         assertEquals("Event timestamp", INITIAL_RANK + NB_READS + 1, event.getTimestamp().getValue());
 692         assertEquals("Event rank", INITIAL_RANK + NB_READS, context.getRank());
 693
 694         validateContextRanks(context);
 695     }
 696
 697     @Test
 698     public void testGetNextAfterSeekingOnRank_2() {
 699         final long INITIAL_RANK = 1L;
 700         final int NB_READS = 20;
 701
 702         // On lower bound, returns the first event (rank = 0)
 703         final ITmfContext context = fExperiment.seekEvent(INITIAL_RANK);
 704
 705         validateContextRanks(context);
 706
 707         // Read NB_EVENTS
 708         ITmfEvent event;
 709         for (int i = 0; i < NB_READS; i++) {
 710             event = fExperiment.getNext(context);
 711             assertEquals("Event timestamp", INITIAL_RANK + i + 1, event.getTimestamp().getValue());
 712             assertEquals("Event rank", INITIAL_RANK + i + 1, context.getRank());
 713         }
 714
 715         // Make sure we stay positioned
 716         event = fExperiment.parseEvent(context);
 717         assertEquals("Event timestamp", INITIAL_RANK + NB_READS + 1, event.getTimestamp().getValue());
 718         assertEquals("Event rank", INITIAL_RANK + NB_READS, context.getRank());
 719
 720         validateContextRanks(context);
 721     }
 722
 723     @Test
 724     public void testGetNextAfterSeekingOnRank_3() {
 725         final long INITIAL_RANK = 500L;
 726         final int NB_READS = 20;
 727
 728         // On lower bound, returns the first event (rank = 0)
 729         final ITmfContext context = fExperiment.seekEvent(INITIAL_RANK);
 730
 731         validateContextRanks(context);
 732
 733         // Read NB_EVENTS
 734         ITmfEvent event;
 735         for (int i = 0; i < NB_READS; i++) {
 736             event = fExperiment.getNext(context);
 737             assertEquals("Event timestamp", INITIAL_RANK + i + 1, event.getTimestamp().getValue());
 738             assertEquals("Event rank", INITIAL_RANK + i + 1, context.getRank());
 739         }
 740
 741         // Make sure we stay positioned
 742         event = fExperiment.parseEvent(context);
 743         assertEquals("Event timestamp", INITIAL_RANK + NB_READS + 1, event.getTimestamp().getValue());
 744         assertEquals("Event rank", INITIAL_RANK + NB_READS, context.getRank());
 745
 746         validateContextRanks(context);
 747     }
 748
 749     @Test
 750     public void testGetNextAfterSeekingOnLocation_1() {
 751         final ITmfLocation INITIAL_LOC = null;
 752         final long INITIAL_TS = 1;
 753         final int NB_READS = 20;
 754
 755         // On lower bound, returns the first event (ts = 1)
 756         final ITmfContext context = fExperiment.seekEvent(INITIAL_LOC);
 757
 758         validateContextRanks(context);
 759
 760         // Read NB_EVENTS
 761         ITmfEvent event;
 762         for (int i = 0; i < NB_READS; i++) {
 763             event = fExperiment.getNext(context);
 764             assertEquals("Event timestamp", INITIAL_TS + i, event.getTimestamp().getValue());
 765             assertEquals("Event rank", INITIAL_TS + i, context.getRank());
 766         }
 767
 768         // Make sure we stay positioned
 769         event = fExperiment.parseEvent(context);
 770         assertEquals("Event timestamp", INITIAL_TS + NB_READS, event.getTimestamp().getValue());
 771         assertEquals("Event rank", INITIAL_TS + NB_READS - 1, context.getRank());
 772
 773         validateContextRanks(context);
 774     }
 775
 776     @Test
 777     public void testGetNextAfterSeekingOnLocation_2() {
 778         final ITmfLocation INITIAL_LOC = fExperiment.seekEvent(1L).getLocation();
 779         final long INITIAL_TS = 2;
 780         final int NB_READS = 20;
 781
 782         // On lower bound, returns the first event (ts = 2)
 783         final ITmfContext context = fExperiment.seekEvent(INITIAL_LOC);
 784
 785         validateContextRanks(context);
 786
 787         // Read NB_EVENTS
 788         ITmfEvent event;
 789         for (int i = 0; i < NB_READS; i++) {
 790             event = fExperiment.getNext(context);
 791             assertEquals("Event timestamp", INITIAL_TS + i, event.getTimestamp().getValue());
 792         }
 793
 794         // Make sure we stay positioned
 795         event = fExperiment.parseEvent(context);
 796         assertEquals("Event timestamp", INITIAL_TS + NB_READS, event.getTimestamp().getValue());
 797
 798         validateContextRanks(context);
 799     }
 800
 801     @Test
 802     public void testGetNextAfterSeekingOnLocation_3() {
 803         final ITmfLocation INITIAL_LOC = fExperiment.seekEvent(500L).getLocation();
 804         final long INITIAL_TS = 501;
 805         final int NB_READS = 20;
 806
 807         // On lower bound, returns the first event (ts = 501)
 808         final ITmfContext context = fExperiment.seekEvent(INITIAL_LOC);
 809
 810         validateContextRanks(context);
 811
 812         // Read NB_EVENTS
 813         ITmfEvent event;
 814         for (int i = 0; i < NB_READS; i++) {
 815             event = fExperiment.getNext(context);
 816             assertEquals("Event timestamp", INITIAL_TS + i, event.getTimestamp().getValue());
 817         }
 818
 819         // Make sure we stay positioned
 820         event = fExperiment.parseEvent(context);
 821         assertEquals("Event timestamp", INITIAL_TS + NB_READS, event.getTimestamp().getValue());
 822
 823         validateContextRanks(context);
 824     }
 825
 826     @Test
 827     public void testGetNextLocation() {
 828         ITmfContext context1 = fExperiment.seekEvent(0);
 829         fExperiment.getNext(context1);
 830         ITmfLocation location = context1.getLocation();
 831         ITmfEvent event1 = fExperiment.getNext(context1);
 832         ITmfContext context2 = fExperiment.seekEvent(location);
 833         ITmfEvent event2 = fExperiment.getNext(context2);
 834         assertEquals("Event timestamp", event1.getTimestamp().getValue(), event2.getTimestamp().getValue());
 835     }
 836
 837     @Test
 838     public void testGetNextEndLocation() {
 839         ITmfContext context1 = fExperiment.seekEvent(fExperiment.getNbEvents() - 1);
 840         fExperiment.getNext(context1);
 841         ITmfLocation location = context1.getLocation();
 842         ITmfContext context2 = fExperiment.seekEvent(location);
 843         ITmfEvent event = fExperiment.getNext(context2);
 844         assertNull("Event", event);
 845     }
 846
 847     // ------------------------------------------------------------------------
 848     // processRequest
 849     // ------------------------------------------------------------------------
 850
 851     @Test
 852     public void testProcessRequestForNbEvents() throws InterruptedException {
 853         final int nbEvents  = 1000;
 854         final Vector<ITmfEvent> requestedEvents = new Vector<>();
 855
 856         final TmfTimeRange range = new TmfTimeRange(TmfTimestamp.BIG_BANG, TmfTimestamp.BIG_CRUNCH);
 857         final TmfEventRequest request = new TmfEventRequest(ITmfEvent.class,
 858                 range, 0, nbEvents, ExecutionType.FOREGROUND) {
 859             @Override
 860             public void handleData(final ITmfEvent event) {
 861                 super.handleData(event);
 862                 requestedEvents.add(event);
 863             }
 864         };
 865         fExperiment.sendRequest(request);
 866         request.waitForCompletion();
 867
 868         assertEquals("nbEvents", nbEvents, requestedEvents.size());
 869         assertTrue("isCompleted",  request.isCompleted());
 870         assertFalse("isCancelled", request.isCancelled());
 871
 872         // Ensure that we have distinct events.
 873         // Don't go overboard: we are not validating the stub!
 874         for (int i = 0; i < nbEvents; i++) {
 875             assertEquals("Distinct events", i+1, requestedEvents.get(i).getTimestamp().getValue());
 876         }
 877     }
 878
 879     @Test
 880     public void testProcessRequestForAllEvents() throws InterruptedException {
 881         final int nbEvents  = ITmfEventRequest.ALL_DATA;
 882         final Vector<ITmfEvent> requestedEvents = new Vector<>();
 883         final long nbExpectedEvents = NB_EVENTS;
 884
 885         final TmfTimeRange range = new TmfTimeRange(TmfTimestamp.BIG_BANG, TmfTimestamp.BIG_CRUNCH);
 886         final TmfEventRequest request = new TmfEventRequest(ITmfEvent.class,
 887                 range, 0, nbEvents, ExecutionType.FOREGROUND) {
 888             @Override
 889             public void handleData(final ITmfEvent event) {
 890                 super.handleData(event);
 891                 requestedEvents.add(event);
 892             }
 893         };
 894         fExperiment.sendRequest(request);
 895         request.waitForCompletion();
 896
 897         assertEquals("nbEvents", nbExpectedEvents, requestedEvents.size());
 898         assertTrue("isCompleted",  request.isCompleted());
 899         assertFalse("isCancelled", request.isCancelled());
 900
 901         // Ensure that we have distinct events.
 902         // Don't go overboard: we are not validating the stub!
 903         for (int i = 0; i < nbExpectedEvents; i++) {
 904             assertEquals("Distinct events", i+1, requestedEvents.get(i).getTimestamp().getValue());
 905         }
 906     }
 907
 908     // ------------------------------------------------------------------------
 909     // cancel
 910     // ------------------------------------------------------------------------
 911
 912     @Test
 913     public void testCancel() throws InterruptedException {
 914         final int nbEvents = NB_EVENTS;
 915         final int limit = BLOCK_SIZE;
 916         final Vector<ITmfEvent> requestedEvents = new Vector<>();
 917
 918         final TmfTimeRange range = new TmfTimeRange(TmfTimestamp.BIG_BANG, TmfTimestamp.BIG_CRUNCH);
 919         final TmfEventRequest request = new TmfEventRequest(ITmfEvent.class,
 920                 range, 0, nbEvents, ExecutionType.FOREGROUND) {
 921             int nbRead = 0;
 922
 923             @Override
 924             public void handleData(final ITmfEvent event) {
 925                 super.handleData(event);
 926                 requestedEvents.add(event);
 927                 if (++nbRead == limit) {
 928                     cancel();
 929                 }
 930             }
 931
 932             @Override
 933             public void handleCancel() {
 934                 if (requestedEvents.size() < limit) {
 935                     System.out.println("aie");
 936                 }
 937             }
 938         };
 939         fExperiment.sendRequest(request);
 940         request.waitForCompletion();
 941
 942         assertEquals("nbEvents",  limit, requestedEvents.size());
 943         assertTrue("isCompleted", request.isCompleted());
 944         assertTrue("isCancelled", request.isCancelled());
 945     }
 946
 947 }