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.TmfLocation;
  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 TmfLocation<Long>(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     @SuppressWarnings("rawtypes")
 248     public void testGetLocationRatio() {
 249
 250         // First event
 251         ITmfContext context = fExperiment.seekEvent((ITmfLocation) null);
 252         double ratio = fExperiment.getLocationRatio(context.getLocation());
 253         context = fExperiment.seekEvent(ratio);
 254         double ratio2 = fExperiment.getLocationRatio(context.getLocation());
 255         assertEquals("getLocationRatio", ratio, ratio2);
 256
 257         // Middle event
 258         context = fExperiment.seekEvent(NB_EVENTS / 2);
 259         ratio = fExperiment.getLocationRatio(context.getLocation());
 260         context = fExperiment.seekEvent(ratio);
 261         ratio2 = fExperiment.getLocationRatio(context.getLocation());
 262         assertEquals("getLocationRatio", ratio, ratio2);
 263
 264         // Last event
 265         context = fExperiment.seekEvent(NB_EVENTS - 1);
 266         ratio = fExperiment.getLocationRatio(context.getLocation());
 267         context = fExperiment.seekEvent(ratio);
 268         ratio2 = fExperiment.getLocationRatio(context.getLocation());
 269         assertEquals("getLocationRatio", ratio, ratio2);
 270     }
 271
 272 //    @SuppressWarnings("rawtypes")
 273 //    public void testGetCurrentLocation() {
 274 //        ITmfContext context = fExperiment.seekEvent((ITmfLocation) null);
 275 //        ITmfLocation location = fExperiment.getCurrentLocation();
 276 //        assertEquals("getCurrentLocation", location, context.getLocation());
 277 //    }
 278
 279     // ------------------------------------------------------------------------
 280     // seekEvent on rank
 281     // ------------------------------------------------------------------------
 282
 283     public void testSeekRankOnCacheBoundary() {
 284
 285         long cacheSize = fExperiment.getCacheSize();
 286
 287         // On lower bound, returns the first event (TS = 1)
 288         ITmfContext context = fExperiment.seekEvent(0);
 289         assertEquals("Context rank", 0, context.getRank());
 290
 291         ITmfEvent event = fExperiment.getNext(context);
 292         assertEquals("Event timestamp", 1, event.getTimestamp().getValue());
 293         assertEquals("Context rank", 1, context.getRank());
 294
 295         // Position trace at event rank [cacheSize]
 296         context = fExperiment.seekEvent(cacheSize);
 297         assertEquals("Context rank", cacheSize, context.getRank());
 298
 299         event = fExperiment.getNext(context);
 300         assertEquals("Event timestamp", cacheSize + 1, event.getTimestamp().getValue());
 301         assertEquals("Context rank", cacheSize + 1, context.getRank());
 302
 303         // Position trace at event rank [4 * cacheSize]
 304         context = fExperiment.seekEvent(4 * cacheSize);
 305         assertEquals("Context rank", 4 * cacheSize, context.getRank());
 306
 307         event = fExperiment.getNext(context);
 308         assertEquals("Event timestamp", 4 * cacheSize + 1, event.getTimestamp().getValue());
 309         assertEquals("Context rank", 4 * cacheSize + 1, context.getRank());
 310     }
 311
 312     public void testSeekRankNotOnCacheBoundary() {
 313
 314         long cacheSize = fExperiment.getCacheSize();
 315
 316         // Position trace at event rank 9
 317         ITmfContext context = fExperiment.seekEvent(9);
 318         assertEquals("Context rank", 9, context.getRank());
 319
 320         ITmfEvent event = fExperiment.getNext(context);
 321         assertEquals("Event timestamp", 10, event.getTimestamp().getValue());
 322         assertEquals("Context rank", 10, context.getRank());
 323
 324         // Position trace at event rank [cacheSize - 1]
 325         context = fExperiment.seekEvent(cacheSize - 1);
 326         assertEquals("Context rank", cacheSize - 1, context.getRank());
 327
 328         event = fExperiment.getNext(context);
 329         assertEquals("Event timestamp", cacheSize, event.getTimestamp().getValue());
 330         assertEquals("Context rank", cacheSize, context.getRank());
 331
 332         // Position trace at event rank [cacheSize + 1]
 333         context = fExperiment.seekEvent(cacheSize + 1);
 334         assertEquals("Context rank", cacheSize + 1, context.getRank());
 335
 336         event = fExperiment.getNext(context);
 337         assertEquals("Event timestamp", cacheSize + 2, event.getTimestamp().getValue());
 338         assertEquals("Context rank", cacheSize + 2, context.getRank());
 339
 340         // Position trace at event rank 4500
 341         context = fExperiment.seekEvent(4500);
 342         assertEquals("Context rank", 4500, context.getRank());
 343
 344         event = fExperiment.getNext(context);
 345         assertEquals("Event timestamp", 4501, event.getTimestamp().getValue());
 346         assertEquals("Context rank", 4501, context.getRank());
 347     }
 348
 349     public void testSeekRankOutOfScope() {
 350
 351         // Position trace at beginning
 352         ITmfContext context = fExperiment.seekEvent(-1);
 353         assertEquals("Event rank", 0, context.getRank());
 354
 355         ITmfEvent event = fExperiment.getNext(context);
 356         assertEquals("Event timestamp", 1, event.getTimestamp().getValue());
 357         assertEquals("Context rank", 1, context.getRank());
 358
 359         // Position trace at event passed the end
 360         context = fExperiment.seekEvent(NB_EVENTS);
 361         assertEquals("Context rank", NB_EVENTS, context.getRank());
 362
 363         event = fExperiment.getNext(context);
 364         assertNull("Event", event);
 365         assertEquals("Context rank", NB_EVENTS, context.getRank());
 366     }
 367
 368     // ------------------------------------------------------------------------
 369     // seekEvent on timestamp
 370     // ------------------------------------------------------------------------
 371
 372     public void testSeekTimestampOnCacheBoundary() {
 373
 374         long cacheSize = fExperiment.getCacheSize();
 375
 376         // Position trace at event rank 0
 377         ITmfContext context = fExperiment.seekEvent(new TmfTimestamp(1, SCALE, 0));
 378         assertEquals("Context rank", 0, context.getRank());
 379
 380         ITmfEvent event = fExperiment.getNext(context);
 381         assertEquals("Event timestamp", 1, event.getTimestamp().getValue());
 382         assertEquals("Context rank", 1, context.getRank());
 383
 384         // Position trace at event rank [cacheSize]
 385         context = fExperiment.seekEvent(new TmfTimestamp(cacheSize + 1, SCALE, 0));
 386         assertEquals("Event rank", cacheSize, context.getRank());
 387
 388         event = fExperiment.getNext(context);
 389         assertEquals("Event timestamp", cacheSize + 1, event.getTimestamp().getValue());
 390         assertEquals("Context rank", cacheSize + 1, context.getRank());
 391
 392         // Position trace at event rank [4 * cacheSize]
 393         context = fExperiment.seekEvent(new TmfTimestamp(4 * cacheSize + 1, SCALE, 0));
 394         assertEquals("Context rank", 4 * cacheSize, context.getRank());
 395
 396         event = fExperiment.getNext(context);
 397         assertEquals("Event timestamp", 4 * cacheSize + 1, event.getTimestamp().getValue());
 398         assertEquals("Context rank", 4 * cacheSize + 1, context.getRank());
 399     }
 400
 401     public void testSeekTimestampNotOnCacheBoundary() {
 402
 403         // Position trace at event rank 1 (TS = 2)
 404         ITmfContext context = fExperiment.seekEvent(new TmfTimestamp(2, SCALE, 0));
 405         assertEquals("Context rank", 1, context.getRank());
 406
 407         ITmfEvent event = fExperiment.getNext(context);
 408         assertEquals("Event timestamp", 2, event.getTimestamp().getValue());
 409         assertEquals("Context rank", 2, context.getRank());
 410
 411         // Position trace at event rank 9 (TS = 10)
 412         context = fExperiment.seekEvent(new TmfTimestamp(10, SCALE, 0));
 413         assertEquals("Context rank", 9, context.getRank());
 414
 415         event = fExperiment.getNext(context);
 416         assertEquals("Event timestamp", 10, event.getTimestamp().getValue());
 417         assertEquals("Context rank", 10, context.getRank());
 418
 419         // Position trace at event rank 999 (TS = 1000)
 420         context = fExperiment.seekEvent(new TmfTimestamp(1000, SCALE, 0));
 421         assertEquals("Context rank", 999, context.getRank());
 422
 423         event = fExperiment.getNext(context);
 424         assertEquals("Event timestamp", 1000, event.getTimestamp().getValue());
 425         assertEquals("Context rank", 1000, context.getRank());
 426
 427         // Position trace at event rank 1001 (TS = 1002)
 428         context = fExperiment.seekEvent(new TmfTimestamp(1002, SCALE, 0));
 429         assertEquals("Context rank", 1001, context.getRank());
 430
 431         event = fExperiment.getNext(context);
 432         assertEquals("Event timestamp", 1002, event.getTimestamp().getValue());
 433         assertEquals("Context rank", 1002, context.getRank());
 434
 435         // Position trace at event rank 4500 (TS = 4501)
 436         context = fExperiment.seekEvent(new TmfTimestamp(4501, SCALE, 0));
 437         assertEquals("Context rank", 4500, context.getRank());
 438
 439         event = fExperiment.getNext(context);
 440         assertEquals("Event timestamp", 4501, event.getTimestamp().getValue());
 441         assertEquals("Context rank", 4501, context.getRank());
 442     }
 443
 444     public void testSeekTimestampOutOfScope() {
 445
 446         // Position trace at beginning
 447         ITmfContext context = fExperiment.seekEvent(new TmfTimestamp(-1, SCALE, 0));
 448         assertEquals("Event rank", 0, context.getRank());
 449
 450         ITmfEvent event = fExperiment.getNext(context);
 451         assertEquals("Event timestamp", 1, event.getTimestamp().getValue());
 452         assertEquals("Event rank", 1, context.getRank());
 453
 454         // Position trace at event passed the end
 455         context = fExperiment.seekEvent(new TmfTimestamp(NB_EVENTS + 1, SCALE, 0));
 456         event = fExperiment.getNext(context);
 457         assertNull("Event location", event);
 458         assertEquals("Event rank", ITmfContext.UNKNOWN_RANK, context.getRank());
 459     }
 460
 461     // ------------------------------------------------------------------------
 462     // seekEvent by location (context rank is undefined)
 463     // ------------------------------------------------------------------------
 464
 465     public void testSeekLocationOnCacheBoundary() {
 466
 467         long cacheSize = fExperiment.getCacheSize();
 468
 469         // Position trace at event rank 0
 470         ITmfContext tmpContext = fExperiment.seekEvent(0);
 471         ITmfContext context = fExperiment.seekEvent(tmpContext.getLocation());
 472
 473         ITmfEvent event = fExperiment.getNext(context);
 474         assertEquals("Event timestamp", 1, event.getTimestamp().getValue());
 475
 476         event = fExperiment.getNext(context);
 477         assertEquals("Event timestamp", 2, event.getTimestamp().getValue());
 478
 479         // Position trace at event rank 'cacheSize'
 480         tmpContext = fExperiment.seekEvent(cacheSize);
 481         context = fExperiment.seekEvent(tmpContext.getLocation());
 482
 483         event = fExperiment.getNext(context);
 484         assertEquals("Event timestamp", cacheSize + 1, event.getTimestamp().getValue());
 485
 486         event = fExperiment.getNext(context);
 487         assertEquals("Event timestamp", cacheSize + 2, event.getTimestamp().getValue());
 488
 489         // Position trace at event rank 4 * 'cacheSize'
 490         tmpContext = fExperiment.seekEvent(4 * cacheSize);
 491         context = fExperiment.seekEvent(tmpContext.getLocation());
 492
 493         event = fExperiment.getNext(context);
 494         assertEquals("Event timestamp", 4 * cacheSize + 1, event.getTimestamp().getValue());
 495
 496         event = fExperiment.getNext(context);
 497         assertEquals("Event timestamp", 4 * cacheSize + 2, event.getTimestamp().getValue());
 498     }
 499
 500     public void testSeekLocationNotOnCacheBoundary() {
 501
 502         long cacheSize = fExperiment.getCacheSize();
 503
 504         // Position trace at event 'cacheSize' - 1
 505         ITmfContext tmpContext = fExperiment.seekEvent(cacheSize - 1);
 506         ITmfContext context = fExperiment.seekEvent(tmpContext.getLocation());
 507
 508         ITmfEvent event = fExperiment.getNext(context);
 509         assertEquals("Event timestamp", cacheSize, event.getTimestamp().getValue());
 510
 511         event = fExperiment.getNext(context);
 512         assertEquals("Event timestamp", cacheSize + 1, event.getTimestamp().getValue());
 513
 514         // Position trace at event rank 2 * 'cacheSize' - 1
 515         tmpContext = fExperiment.seekEvent(2 * cacheSize - 1);
 516         context = fExperiment.seekEvent(tmpContext.getLocation());
 517         context = fExperiment.seekEvent(2 * cacheSize - 1);
 518
 519         event = fExperiment.getNext(context);
 520         assertEquals("Event timestamp", 2 * cacheSize, event.getTimestamp().getValue());
 521
 522         event = fExperiment.getNext(context);
 523         assertEquals("Event timestamp", 2 * cacheSize + 1, event.getTimestamp().getValue());
 524
 525         // Position trace at event rank 4500
 526         tmpContext = fExperiment.seekEvent(4500);
 527         context = fExperiment.seekEvent(tmpContext.getLocation());
 528
 529         event = fExperiment.getNext(context);
 530         assertEquals("Event timestamp", 4501, event.getTimestamp().getValue());
 531
 532         event = fExperiment.getNext(context);
 533         assertEquals("Event timestamp", 4502, event.getTimestamp().getValue());
 534     }
 535
 536     public void testSeekLocationOutOfScope() {
 537
 538         // Position trace at beginning
 539         ITmfContext context = fExperiment.seekEvent((ITmfLocation<?>) null);
 540
 541         ITmfEvent event = fExperiment.getNext(context);
 542         assertEquals("Event timestamp", 1, event.getTimestamp().getValue());
 543     }
 544
 545     // ------------------------------------------------------------------------
 546     // getNext - updates the context
 547     // ------------------------------------------------------------------------
 548
 549     private static void validateContextRanks(ITmfContext context) {
 550         assertTrue("Experiment context type", context instanceof TmfExperimentContext);
 551         TmfExperimentContext ctx = (TmfExperimentContext) context;
 552
 553         int nbTraces = ctx.getContexts().length;
 554
 555         // expRank = sum(trace ranks) - nbTraces + 1 (if lastTraceRead != NO_TRACE)
 556         long expRank = -nbTraces + ((ctx.getLastTrace() != TmfExperimentContext.NO_TRACE) ? 1 : 0);
 557         for (int i = 0; i < nbTraces; i++) {
 558             long rank = ctx.getContexts()[i].getRank();
 559             if (rank == -1) {
 560                 expRank = -1;
 561                 break;
 562             }
 563             expRank += rank;
 564         }
 565         assertEquals("Experiment context rank", expRank, ctx.getRank());
 566     }
 567
 568     public void testGetNextAfteSeekingOnTS_1() {
 569
 570         final long INITIAL_TS = 1;
 571         final int NB_READS = 20;
 572
 573         // On lower bound, returns the first event (ts = 1)
 574         final ITmfContext context = fExperiment.seekEvent(new TmfTimestamp(INITIAL_TS, SCALE, 0));
 575
 576         validateContextRanks(context);
 577
 578         // Read NB_EVENTS
 579         ITmfEvent event;
 580         for (int i = 0; i < NB_READS; i++) {
 581             event = fExperiment.getNext(context);
 582             assertEquals("Event timestamp", INITIAL_TS + i, event.getTimestamp().getValue());
 583             assertEquals("Event rank", INITIAL_TS + i, context.getRank());
 584         }
 585
 586         // Make sure we stay positioned
 587         event = fExperiment.parseEvent(context);
 588         assertEquals("Event timestamp", INITIAL_TS + NB_READS, event.getTimestamp().getValue());
 589         assertEquals("Event rank", INITIAL_TS + NB_READS - 1, context.getRank());
 590
 591         validateContextRanks(context);
 592     }
 593
 594     public void testGetNextAfteSeekingOnTS_2() {
 595
 596         final long INITIAL_TS = 2;
 597         final int NB_READS = 20;
 598
 599         // On lower bound, returns the first event (ts = 2)
 600         final ITmfContext context = fExperiment.seekEvent(new TmfTimestamp(INITIAL_TS, SCALE, 0));
 601
 602         validateContextRanks(context);
 603
 604         // Read NB_EVENTS
 605         ITmfEvent event;
 606         for (int i = 0; i < NB_READS; i++) {
 607             event = fExperiment.getNext(context);
 608             assertEquals("Event timestamp", INITIAL_TS + i, event.getTimestamp().getValue());
 609             assertEquals("Event rank", INITIAL_TS + i, context.getRank());
 610         }
 611
 612         // Make sure we stay positioned
 613         event = fExperiment.parseEvent(context);
 614         assertEquals("Event timestamp", INITIAL_TS + NB_READS, event.getTimestamp().getValue());
 615         assertEquals("Event rank", INITIAL_TS + NB_READS - 1, context.getRank());
 616
 617         validateContextRanks(context);
 618     }
 619
 620     public void testGetNextAfteSeekingOnTS_3() {
 621
 622         final long INITIAL_TS = 500;
 623         final int NB_READS = 20;
 624
 625         // On lower bound, returns the first event (ts = 500)
 626         final ITmfContext context = fExperiment.seekEvent(new TmfTimestamp(INITIAL_TS, SCALE, 0));
 627
 628         validateContextRanks(context);
 629
 630         // Read NB_EVENTS
 631         ITmfEvent event;
 632         for (int i = 0; i < NB_READS; i++) {
 633             event = fExperiment.getNext(context);
 634             assertEquals("Event timestamp", INITIAL_TS + i, event.getTimestamp().getValue());
 635             assertEquals("Event rank", INITIAL_TS + i, context.getRank());
 636         }
 637
 638         // Make sure we stay positioned
 639         event = fExperiment.parseEvent(context);
 640         assertEquals("Event timestamp", INITIAL_TS + NB_READS, event.getTimestamp().getValue());
 641         assertEquals("Event rank", INITIAL_TS + NB_READS - 1, context.getRank());
 642
 643         validateContextRanks(context);
 644     }
 645
 646     public void testGetNextAfterSeekingOnRank_1() {
 647
 648         final long INITIAL_RANK = 0L;
 649         final int NB_READS = 20;
 650
 651         // On lower bound, returns the first event (rank = 0)
 652         final ITmfContext context = fExperiment.seekEvent(INITIAL_RANK);
 653
 654         validateContextRanks(context);
 655
 656         // Read NB_EVENTS
 657         ITmfEvent event;
 658         for (int i = 0; i < NB_READS; i++) {
 659             event = fExperiment.getNext(context);
 660             assertEquals("Event timestamp", INITIAL_RANK + i + 1, event.getTimestamp().getValue());
 661             assertEquals("Event rank", INITIAL_RANK + i + 1, context.getRank());
 662         }
 663
 664         // Make sure we stay positioned
 665         event = fExperiment.parseEvent(context);
 666         assertEquals("Event timestamp", INITIAL_RANK + NB_READS + 1, event.getTimestamp().getValue());
 667         assertEquals("Event rank", INITIAL_RANK + NB_READS, context.getRank());
 668
 669         validateContextRanks(context);
 670     }
 671
 672     public void testGetNextAfterSeekingOnRank_2() {
 673
 674         final long INITIAL_RANK = 1L;
 675         final int NB_READS = 20;
 676
 677         // On lower bound, returns the first event (rank = 0)
 678         final ITmfContext context = fExperiment.seekEvent(INITIAL_RANK);
 679
 680         validateContextRanks(context);
 681
 682         // Read NB_EVENTS
 683         ITmfEvent event;
 684         for (int i = 0; i < NB_READS; i++) {
 685             event = fExperiment.getNext(context);
 686             assertEquals("Event timestamp", INITIAL_RANK + i + 1, event.getTimestamp().getValue());
 687             assertEquals("Event rank", INITIAL_RANK + i + 1, context.getRank());
 688         }
 689
 690         // Make sure we stay positioned
 691         event = fExperiment.parseEvent(context);
 692         assertEquals("Event timestamp", INITIAL_RANK + NB_READS + 1, event.getTimestamp().getValue());
 693         assertEquals("Event rank", INITIAL_RANK + NB_READS, context.getRank());
 694
 695         validateContextRanks(context);
 696     }
 697
 698     public void testGetNextAfterSeekingOnRank_3() {
 699
 700         final long INITIAL_RANK = 500L;
 701         final int NB_READS = 20;
 702
 703         // On lower bound, returns the first event (rank = 0)
 704         final ITmfContext context = fExperiment.seekEvent(INITIAL_RANK);
 705
 706         validateContextRanks(context);
 707
 708         // Read NB_EVENTS
 709         ITmfEvent event;
 710         for (int i = 0; i < NB_READS; i++) {
 711             event = fExperiment.getNext(context);
 712             assertEquals("Event timestamp", INITIAL_RANK + i + 1, event.getTimestamp().getValue());
 713             assertEquals("Event rank", INITIAL_RANK + i + 1, context.getRank());
 714         }
 715
 716         // Make sure we stay positioned
 717         event = fExperiment.parseEvent(context);
 718         assertEquals("Event timestamp", INITIAL_RANK + NB_READS + 1, event.getTimestamp().getValue());
 719         assertEquals("Event rank", INITIAL_RANK + NB_READS, context.getRank());
 720
 721         validateContextRanks(context);
 722     }
 723
 724     public void testGetNextAfterSeekingOnLocation_1() {
 725
 726         final ITmfLocation<?> INITIAL_LOC = null;
 727         final long INITIAL_TS = 1;
 728         final int NB_READS = 20;
 729
 730         // On lower bound, returns the first event (ts = 1)
 731         final ITmfContext context = fExperiment.seekEvent(INITIAL_LOC);
 732
 733         validateContextRanks(context);
 734
 735         // Read NB_EVENTS
 736         ITmfEvent event;
 737         for (int i = 0; i < NB_READS; i++) {
 738             event = fExperiment.getNext(context);
 739             assertEquals("Event timestamp", INITIAL_TS + i, event.getTimestamp().getValue());
 740             assertEquals("Event rank", INITIAL_TS + i, context.getRank());
 741         }
 742
 743         // Make sure we stay positioned
 744         event = fExperiment.parseEvent(context);
 745         assertEquals("Event timestamp", INITIAL_TS + NB_READS, event.getTimestamp().getValue());
 746         assertEquals("Event rank", INITIAL_TS + NB_READS - 1, context.getRank());
 747
 748         validateContextRanks(context);
 749     }
 750
 751     public void testGetNextAfterSeekingOnLocation_2() {
 752
 753         final ITmfLocation<?> INITIAL_LOC = fExperiment.seekEvent(1L).getLocation();
 754         final long INITIAL_TS = 2;
 755         final int NB_READS = 20;
 756
 757         // On lower bound, returns the first event (ts = 2)
 758         final ITmfContext context = fExperiment.seekEvent(INITIAL_LOC);
 759
 760         validateContextRanks(context);
 761
 762         // Read NB_EVENTS
 763         ITmfEvent event;
 764         for (int i = 0; i < NB_READS; i++) {
 765             event = fExperiment.getNext(context);
 766             assertEquals("Event timestamp", INITIAL_TS + i, event.getTimestamp().getValue());
 767         }
 768
 769         // Make sure we stay positioned
 770         event = fExperiment.parseEvent(context);
 771         assertEquals("Event timestamp", INITIAL_TS + NB_READS, event.getTimestamp().getValue());
 772
 773         validateContextRanks(context);
 774     }
 775
 776     public void testGetNextAfterSeekingOnLocation_3() {
 777
 778         final ITmfLocation<?> INITIAL_LOC = fExperiment.seekEvent(500L).getLocation();
 779         final long INITIAL_TS = 501;
 780         final int NB_READS = 20;
 781
 782         // On lower bound, returns the first event (ts = 501)
 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     public void testGetNextLocation() {
 802         ITmfContext context1 = fExperiment.seekEvent(0);
 803         fExperiment.getNext(context1);
 804         ITmfLocation<?> location = context1.getLocation().clone();
 805         ITmfEvent event1 = fExperiment.getNext(context1);
 806         ITmfContext context2 = fExperiment.seekEvent(location);
 807         ITmfEvent event2 = fExperiment.getNext(context2);
 808         assertEquals("Event timestamp", event1.getTimestamp().getValue(), event2.getTimestamp().getValue());
 809     }
 810
 811     public void testGetNextEndLocation() {
 812         ITmfContext context1 = fExperiment.seekEvent(fExperiment.getNbEvents() - 1);
 813         fExperiment.getNext(context1);
 814         ITmfLocation<?> location = context1.getLocation().clone();
 815         ITmfContext context2 = fExperiment.seekEvent(location);
 816         ITmfEvent event = fExperiment.getNext(context2);
 817         assertNull("Event", event);
 818     }
 819
 820     // ------------------------------------------------------------------------
 821     // processRequest
 822     // ------------------------------------------------------------------------
 823
 824     public void testProcessRequestForNbEvents() throws InterruptedException {
 825
 826         final int blockSize = 100;
 827         final int nbEvents  = 1000;
 828         final Vector<ITmfEvent> requestedEvents = new Vector<ITmfEvent>();
 829
 830         final TmfTimeRange range = new TmfTimeRange(TmfTimestamp.BIG_BANG, TmfTimestamp.BIG_CRUNCH);
 831         final TmfEventRequest request = new TmfEventRequest(TmfEvent.class, range, nbEvents, blockSize) {
 832             @Override
 833             public void handleData(final ITmfEvent event) {
 834                 super.handleData(event);
 835                 requestedEvents.add(event);
 836             }
 837         };
 838         fExperiment.sendRequest(request);
 839         request.waitForCompletion();
 840
 841         assertEquals("nbEvents", nbEvents, requestedEvents.size());
 842         assertTrue("isCompleted",  request.isCompleted());
 843         assertFalse("isCancelled", request.isCancelled());
 844
 845         // Ensure that we have distinct events.
 846         // Don't go overboard: we are not validating the stub!
 847         for (int i = 0; i < nbEvents; i++) {
 848             assertEquals("Distinct events", i+1, requestedEvents.get(i).getTimestamp().getValue());
 849         }
 850     }
 851
 852     public void testProcessRequestForNbEvents2() throws InterruptedException {
 853
 854         final int blockSize = 2 * NB_EVENTS;
 855         final int nbEvents = 1000;
 856         final Vector<ITmfEvent> requestedEvents = new Vector<ITmfEvent>();
 857
 858         final TmfTimeRange range = new TmfTimeRange(TmfTimestamp.BIG_BANG, TmfTimestamp.BIG_CRUNCH);
 859         final TmfEventRequest request = new TmfEventRequest(TmfEvent.class, range, nbEvents, blockSize) {
 860             @Override
 861             public void handleData(final ITmfEvent event) {
 862                 super.handleData(event);
 863                 requestedEvents.add(event);
 864             }
 865         };
 866         fExperiment.sendRequest(request);
 867         request.waitForCompletion();
 868
 869         assertEquals("nbEvents", nbEvents, requestedEvents.size());
 870         assertTrue("isCompleted",  request.isCompleted());
 871         assertFalse("isCancelled", request.isCancelled());
 872
 873         // Ensure that we have distinct events.
 874         // Don't go overboard: we are not validating the stub!
 875         for (int i = 0; i < nbEvents; i++) {
 876             assertEquals("Distinct events", i+1, requestedEvents.get(i).getTimestamp().getValue());
 877         }
 878     }
 879
 880     public void testProcessRequestForAllEvents() throws InterruptedException {
 881
 882         final int nbEvents  = TmfDataRequest.ALL_DATA;
 883         final int blockSize =  1;
 884         final Vector<ITmfEvent> requestedEvents = new Vector<ITmfEvent>();
 885         final long nbExpectedEvents = NB_EVENTS;
 886
 887         final TmfTimeRange range = new TmfTimeRange(TmfTimestamp.BIG_BANG, TmfTimestamp.BIG_CRUNCH);
 888         final TmfEventRequest request = new TmfEventRequest(TmfEvent.class, range, nbEvents, blockSize) {
 889             @Override
 890             public void handleData(final ITmfEvent event) {
 891                 super.handleData(event);
 892                 requestedEvents.add(event);
 893             }
 894         };
 895         fExperiment.sendRequest(request);
 896         request.waitForCompletion();
 897
 898         assertEquals("nbEvents", nbExpectedEvents, requestedEvents.size());
 899         assertTrue("isCompleted",  request.isCompleted());
 900         assertFalse("isCancelled", request.isCancelled());
 901
 902         // Ensure that we have distinct events.
 903         // Don't go overboard: we are not validating the stub!
 904         for (int i = 0; i < nbExpectedEvents; i++) {
 905             assertEquals("Distinct events", i+1, requestedEvents.get(i).getTimestamp().getValue());
 906         }
 907     }
 908
 909     // ------------------------------------------------------------------------
 910     // cancel
 911     // ------------------------------------------------------------------------
 912
 913     public void testCancel() throws InterruptedException {
 914
 915         final int nbEvents  = NB_EVENTS;
 916         final int blockSize = BLOCK_SIZE;
 917         final Vector<ITmfEvent> requestedEvents = new Vector<ITmfEvent>();
 918
 919         final TmfTimeRange range = new TmfTimeRange(TmfTimestamp.BIG_BANG, TmfTimestamp.BIG_CRUNCH);
 920         final TmfEventRequest request = new TmfEventRequest(TmfEvent.class, range, nbEvents, blockSize) {
 921             int nbRead = 0;
 922             @Override
 923             public void handleData(final ITmfEvent event) {
 924                 super.handleData(event);
 925                 requestedEvents.add(event);
 926                 if (++nbRead == blockSize) {
 927                     cancel();
 928                 }
 929             }
 930             @Override
 931             public void handleCancel() {
 932                 if (requestedEvents.size() < blockSize) {
 933                     System.out.println("aie");
 934                 }
 935             }
 936         };
 937         fExperiment.sendRequest(request);
 938         request.waitForCompletion();
 939
 940         assertEquals("nbEvents",  blockSize, requestedEvents.size());
 941         assertTrue("isCompleted", request.isCompleted());
 942         assertTrue("isCancelled", request.isCancelled());
 943     }
 944
 945 }