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

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