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