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.TmfExperimentLocation;
  28 import org.eclipse.linuxtools.tmf.core.event.ITmfEvent;
  29 import org.eclipse.linuxtools.tmf.core.event.TmfEvent;
  30 import org.eclipse.linuxtools.tmf.core.event.TmfTimeRange;
  31 import org.eclipse.linuxtools.tmf.core.event.TmfTimestamp;
  32 import org.eclipse.linuxtools.tmf.core.exceptions.TmfTraceException;
  33 import org.eclipse.linuxtools.tmf.core.request.TmfEventRequest;
  34 import org.eclipse.linuxtools.tmf.core.tests.TmfCoreTestPlugin;
  35 import org.eclipse.linuxtools.tmf.core.trace.ITmfContext;
  36 import org.eclipse.linuxtools.tmf.core.trace.ITmfLocation;
  37 import org.eclipse.linuxtools.tmf.core.trace.ITmfTrace;
  38 import org.eclipse.linuxtools.tmf.core.trace.TmfExperiment;
  39 import org.eclipse.linuxtools.tmf.core.trace.TmfLocation;
  40 import org.eclipse.linuxtools.tmf.tests.stubs.trace.TmfExperimentStub;
  41 import org.eclipse.linuxtools.tmf.tests.stubs.trace.TmfTraceStub;
  42
  43 /**
  44  * Test suite for the TmfExperiment class (single trace).
  45  */
  46 @SuppressWarnings("nls")
  47 public class TmfExperimentTest extends TestCase {
  48
  49     // ------------------------------------------------------------------------
  50     // Attributes
  51     // ------------------------------------------------------------------------
  52
  53     private static final String DIRECTORY   = "testfiles";
  54     private static final String TEST_STREAM = "A-Test-10K";
  55     private static final String EXPERIMENT  = "MyExperiment";
  56     private static int          NB_EVENTS   = 10000;
  57     private static int          BLOCK_SIZE  = 1000;
  58
  59     private ITmfTrace<TmfEvent>[] fTestTraces;
  60     @SuppressWarnings("rawtypes")
  61     private TmfExperimentStub fExperiment;
  62
  63     private static byte SCALE = (byte) -3;
  64
  65     // ------------------------------------------------------------------------
  66     // Housekeeping
  67     // ------------------------------------------------------------------------
  68
  69     @SuppressWarnings("unchecked")
  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<ITmfEvent>(EXPERIMENT, fTestTraces, BLOCK_SIZE);
  92             fExperiment.getIndexer().buildIndex(0, TmfTimeRange.ETERNITY, true);
  93         }
  94     }
  95
  96     public TmfExperimentTest(final String name) throws Exception {
  97         super(name);
  98     }
  99
 100     @Override
 101     protected void setUp() throws Exception {
 102         super.setUp();
 103         setupTrace(DIRECTORY + File.separator + TEST_STREAM);
 104         setupExperiment();
 105     }
 106
 107     @Override
 108     protected void tearDown() throws Exception {
 109         super.tearDown();
 110     }
 111
 112     // ------------------------------------------------------------------------
 113     // Constructor
 114     // ------------------------------------------------------------------------
 115
 116     public void testSimpleTmfExperimentConstructor() {
 117
 118         TmfExperiment<TmfEvent> experiment = new TmfExperiment<TmfEvent>(TmfEvent.class, EXPERIMENT, fTestTraces);
 119         assertEquals("GetId", EXPERIMENT, experiment.getName());
 120         assertEquals("GetCacheSize", TmfExperiment.DEFAULT_INDEX_PAGE_SIZE, experiment.getCacheSize());
 121         experiment.dispose();
 122
 123         experiment = new TmfExperiment<TmfEvent>(TmfEvent.class, EXPERIMENT, null);
 124         experiment.dispose();
 125     }
 126
 127     public void testNormalTmfExperimentConstructor() {
 128
 129         assertEquals("GetId", EXPERIMENT, fExperiment.getName());
 130         assertEquals("GetNbEvents", NB_EVENTS, fExperiment.getNbEvents());
 131
 132         final long nbExperimentEvents = fExperiment.getNbEvents();
 133         assertEquals("GetNbEvents", NB_EVENTS, nbExperimentEvents);
 134
 135         final long nbTraceEvents = fExperiment.getTraces()[0].getNbEvents();
 136         assertEquals("GetNbEvents", NB_EVENTS, nbTraceEvents);
 137
 138         final TmfTimeRange timeRange = fExperiment.getTimeRange();
 139         assertEquals("getStartTime", 1, timeRange.getStartTime().getValue());
 140         assertEquals("getEndTime", NB_EVENTS, timeRange.getEndTime().getValue());
 141     }
 142
 143     @SuppressWarnings("static-access")
 144     public void testSetCurrentExperiment() {
 145
 146         TmfExperiment<TmfEvent> experiment = new TmfExperiment<TmfEvent>(TmfEvent.class, EXPERIMENT, fTestTraces);
 147         experiment.setCurrentExperiment(experiment);
 148         assertEquals("getCurrentExperiment", experiment, experiment.getCurrentExperiment());
 149
 150         TmfExperiment<TmfEvent> experiment2 = new TmfExperiment<TmfEvent>(TmfEvent.class, EXPERIMENT, null);
 151         experiment.setCurrentExperiment(experiment2);
 152         assertEquals("getCurrentExperiment", experiment2, experiment.getCurrentExperiment());
 153
 154         experiment.dispose();
 155         experiment2.dispose();
 156     }
 157
 158     // ------------------------------------------------------------------------
 159     // getTimestamp
 160     // ------------------------------------------------------------------------
 161
 162     public void testGetTimestamp() throws Exception {
 163         assertTrue("getTimestamp", fExperiment.getTimestamp(    0).equals(new TmfTimestamp(   1, (byte) -3)));
 164         assertTrue("getTimestamp", fExperiment.getTimestamp(   10).equals(new TmfTimestamp(  11, (byte) -3)));
 165         assertTrue("getTimestamp", fExperiment.getTimestamp(  100).equals(new TmfTimestamp( 101, (byte) -3)));
 166         assertTrue("getTimestamp", fExperiment.getTimestamp( 1000).equals(new TmfTimestamp(1001, (byte) -3)));
 167         assertTrue("getTimestamp", fExperiment.getTimestamp( 2000).equals(new TmfTimestamp(2001, (byte) -3)));
 168         assertTrue("getTimestamp", fExperiment.getTimestamp( 2500).equals(new TmfTimestamp(2501, (byte) -3)));
 169         assertNull("getTimestamp", fExperiment.getTimestamp(10000));
 170     }
 171
 172     // ------------------------------------------------------------------------
 173     // Bookmarks file handling
 174     // ------------------------------------------------------------------------
 175
 176     public void testBookmarks() throws Exception {
 177         assertNull("GetBookmarksFile", fExperiment.getBookmarksFile());
 178
 179         IFile bookmarks = (IFile) fTestTraces[0].getResource();
 180         fExperiment.setBookmarksFile(bookmarks);
 181         assertEquals("GetBookmarksFile", bookmarks, fExperiment.getBookmarksFile());
 182     }
 183
 184     // ------------------------------------------------------------------------
 185     // seekEvent by location
 186     // ------------------------------------------------------------------------
 187
 188     @SuppressWarnings("unchecked")
 189     public void testSeekBadLocation() throws Exception {
 190         ITmfContext context = fExperiment.seekEvent((ITmfLocation<?>) new TmfLocation<Long>(0L));
 191         assertNull("seekEvent", context);
 192     }
 193
 194     public void testSeekNoTrace() throws Exception {
 195         TmfExperiment<TmfEvent> experiment = new TmfExperiment<TmfEvent>(TmfEvent.class, EXPERIMENT, null);
 196         @SuppressWarnings("restriction")
 197         ITmfContext context = experiment.seekEvent((TmfExperimentLocation) null);
 198         assertNull("seekEvent", context);
 199         experiment.dispose();
 200     }
 201
 202     // ------------------------------------------------------------------------
 203     // seekEvent on ratio
 204     // ------------------------------------------------------------------------
 205
 206     public void testSeekEventOnRatio() throws Exception {
 207
 208         // First event
 209         ITmfContext context = fExperiment.seekEvent(0.0);
 210         assertEquals("Context rank", 0, context.getRank());
 211         ITmfEvent event = fExperiment.parseEvent(context);
 212         assertEquals("Event timestamp", 1, event.getTimestamp().getValue());
 213         assertEquals("Context rank", 0, context.getRank());
 214
 215         // Middle event
 216         int midTrace = NB_EVENTS / 2;
 217         context = fExperiment.seekEvent(0.5);
 218         assertEquals("Context rank", midTrace, context.getRank());
 219         event = fExperiment.parseEvent(context);
 220         assertEquals("Event timestamp", midTrace + 1, event.getTimestamp().getValue());
 221         assertEquals("Context rank", midTrace, context.getRank());
 222
 223         // Last event
 224         context = fExperiment.seekEvent(1.0);
 225         assertEquals("Context rank", NB_EVENTS, context.getRank());
 226         event = fExperiment.parseEvent(context);
 227         assertNull("Event timestamp", event);
 228         assertEquals("Context rank", NB_EVENTS, context.getRank());
 229
 230         // Beyond last event
 231         context = fExperiment.seekEvent(1.1);
 232         assertEquals("Context rank", NB_EVENTS, context.getRank());
 233         event = fExperiment.parseEvent(context);
 234         assertNull("Event timestamp", event);
 235         assertEquals("Context rank", NB_EVENTS, context.getRank());
 236
 237         // Negative ratio
 238         context = fExperiment.seekEvent(-0.5);
 239         assertEquals("Context rank", 0, context.getRank());
 240         event = fExperiment.parseEvent(context);
 241         assertEquals("Event timestamp", 1, event.getTimestamp().getValue());
 242         assertEquals("Context rank", 0, context.getRank());
 243     }
 244
 245     @SuppressWarnings({ "unchecked", "rawtypes" })
 246     public void testGetLocationRatio() throws Exception {
 247
 248         // First event
 249         ITmfContext context = fExperiment.seekEvent((ITmfLocation) null);
 250         double ratio = fExperiment.getLocationRatio(context.getLocation());
 251         context = fExperiment.seekEvent(ratio);
 252         double ratio2 = fExperiment.getLocationRatio(context.getLocation());
 253         assertEquals("getLocationRatio", ratio, ratio2);
 254
 255         // Middle event
 256         context = fExperiment.seekEvent(NB_EVENTS / 2);
 257         ratio = fExperiment.getLocationRatio(context.getLocation());
 258         context = fExperiment.seekEvent(ratio);
 259         ratio2 = fExperiment.getLocationRatio(context.getLocation());
 260         assertEquals("getLocationRatio", ratio, ratio2);
 261
 262         // Last event
 263         context = fExperiment.seekEvent(NB_EVENTS - 1);
 264         ratio = fExperiment.getLocationRatio(context.getLocation());
 265         context = fExperiment.seekEvent(ratio);
 266         ratio2 = fExperiment.getLocationRatio(context.getLocation());
 267         assertEquals("getLocationRatio", ratio, ratio2);
 268     }
 269
 270 //    @SuppressWarnings({ "unchecked", "rawtypes" })
 271 //    public void testGetCurrentLocation() throws Exception {
 272 //        ITmfContext context = fExperiment.seekEvent((ITmfLocation) null);
 273 //        ITmfLocation location = fExperiment.getCurrentLocation();
 274 //        assertEquals("getCurrentLocation", location, context.getLocation());
 275 //    }
 276
 277     // ------------------------------------------------------------------------
 278     // seekEvent on rank
 279     // ------------------------------------------------------------------------
 280
 281     public void testSeekRankOnCacheBoundary() throws Exception {
 282
 283         long cacheSize = fExperiment.getCacheSize();
 284
 285         // On lower bound, returns the first event (TS = 1)
 286         ITmfContext context = fExperiment.seekEvent(0);
 287         assertEquals("Context rank", 0, context.getRank());
 288
 289         ITmfEvent event = fExperiment.getNext(context);
 290         assertEquals("Event timestamp", 1, event.getTimestamp().getValue());
 291         assertEquals("Context rank", 1, context.getRank());
 292
 293         // Position trace at event rank [cacheSize]
 294         context = fExperiment.seekEvent(cacheSize);
 295         assertEquals("Context rank", cacheSize, context.getRank());
 296
 297         event = fExperiment.getNext(context);
 298         assertEquals("Event timestamp", cacheSize + 1, event.getTimestamp().getValue());
 299         assertEquals("Context rank", cacheSize + 1, context.getRank());
 300
 301         // Position trace at event rank [4 * cacheSize]
 302         context = fExperiment.seekEvent(4 * cacheSize);
 303         assertEquals("Context rank", 4 * cacheSize, context.getRank());
 304
 305         event = fExperiment.getNext(context);
 306         assertEquals("Event timestamp", 4 * cacheSize + 1, event.getTimestamp().getValue());
 307         assertEquals("Context rank", 4 * cacheSize + 1, context.getRank());
 308     }
 309
 310     public void testSeekRankNotOnCacheBoundary() throws Exception {
 311
 312         long cacheSize = fExperiment.getCacheSize();
 313
 314         // Position trace at event rank 9
 315         ITmfContext context = fExperiment.seekEvent(9);
 316         assertEquals("Context rank", 9, context.getRank());
 317
 318         ITmfEvent event = fExperiment.getNext(context);
 319         assertEquals("Event timestamp", 10, event.getTimestamp().getValue());
 320         assertEquals("Context rank", 10, context.getRank());
 321
 322         // Position trace at event rank [cacheSize - 1]
 323         context = fExperiment.seekEvent(cacheSize - 1);
 324         assertEquals("Context rank", cacheSize - 1, context.getRank());
 325
 326         event = fExperiment.getNext(context);
 327         assertEquals("Event timestamp", cacheSize, event.getTimestamp().getValue());
 328         assertEquals("Context rank", cacheSize, context.getRank());
 329
 330         // Position trace at event rank [cacheSize + 1]
 331         context = fExperiment.seekEvent(cacheSize + 1);
 332         assertEquals("Context rank", cacheSize + 1, context.getRank());
 333
 334         event = fExperiment.getNext(context);
 335         assertEquals("Event timestamp", cacheSize + 2, event.getTimestamp().getValue());
 336         assertEquals("Context rank", cacheSize + 2, context.getRank());
 337
 338         // Position trace at event rank 4500
 339         context = fExperiment.seekEvent(4500);
 340         assertEquals("Context rank", 4500, context.getRank());
 341
 342         event = fExperiment.getNext(context);
 343         assertEquals("Event timestamp", 4501, event.getTimestamp().getValue());
 344         assertEquals("Context rank", 4501, context.getRank());
 345     }
 346
 347     public void testSeekRankOutOfScope() throws Exception {
 348
 349         // Position trace at beginning
 350         ITmfContext context = fExperiment.seekEvent(-1);
 351         assertEquals("Event rank", 0, context.getRank());
 352
 353         ITmfEvent event = fExperiment.getNext(context);
 354         assertEquals("Event timestamp", 1, event.getTimestamp().getValue());
 355         assertEquals("Context rank", 1, context.getRank());
 356
 357         // Position trace at event passed the end
 358         context = fExperiment.seekEvent(NB_EVENTS);
 359         assertEquals("Context rank", NB_EVENTS, context.getRank());
 360
 361         event = fExperiment.getNext(context);
 362         assertNull("Event", event);
 363         assertEquals("Context rank", NB_EVENTS, context.getRank());
 364     }
 365
 366     // ------------------------------------------------------------------------
 367     // seekEvent on timestamp
 368     // ------------------------------------------------------------------------
 369
 370     public void testSeekTimestampOnCacheBoundary() throws Exception {
 371
 372         long cacheSize = fExperiment.getCacheSize();
 373
 374         // Position trace at event rank 0
 375         ITmfContext context = fExperiment.seekEvent(new TmfTimestamp(1, SCALE, 0));
 376         assertEquals("Context rank", 0, context.getRank());
 377
 378         ITmfEvent event = fExperiment.getNext(context);
 379         assertEquals("Event timestamp", 1, event.getTimestamp().getValue());
 380         assertEquals("Context rank", 1, context.getRank());
 381
 382         // Position trace at event rank [cacheSize]
 383         context = fExperiment.seekEvent(new TmfTimestamp(cacheSize + 1, SCALE, 0));
 384         assertEquals("Event rank", cacheSize, context.getRank());
 385
 386         event = fExperiment.getNext(context);
 387         assertEquals("Event timestamp", cacheSize + 1, event.getTimestamp().getValue());
 388         assertEquals("Context rank", cacheSize + 1, context.getRank());
 389
 390         // Position trace at event rank [4 * cacheSize]
 391         context = fExperiment.seekEvent(new TmfTimestamp(4 * cacheSize + 1, SCALE, 0));
 392         assertEquals("Context rank", 4 * cacheSize, context.getRank());
 393
 394         event = fExperiment.getNext(context);
 395         assertEquals("Event timestamp", 4 * cacheSize + 1, event.getTimestamp().getValue());
 396         assertEquals("Context rank", 4 * cacheSize + 1, context.getRank());
 397     }
 398
 399     public void testSeekTimestampNotOnCacheBoundary() throws Exception {
 400
 401         // Position trace at event rank 1 (TS = 2)
 402         ITmfContext context = fExperiment.seekEvent(new TmfTimestamp(2, SCALE, 0));
 403         assertEquals("Context rank", 1, context.getRank());
 404
 405         ITmfEvent event = fExperiment.getNext(context);
 406         assertEquals("Event timestamp", 2, event.getTimestamp().getValue());
 407         assertEquals("Context rank", 2, context.getRank());
 408
 409         // Position trace at event rank 9 (TS = 10)
 410         context = fExperiment.seekEvent(new TmfTimestamp(10, SCALE, 0));
 411         assertEquals("Context rank", 9, context.getRank());
 412
 413         event = fExperiment.getNext(context);
 414         assertEquals("Event timestamp", 10, event.getTimestamp().getValue());
 415         assertEquals("Context rank", 10, context.getRank());
 416
 417         // Position trace at event rank 999 (TS = 1000)
 418         context = fExperiment.seekEvent(new TmfTimestamp(1000, SCALE, 0));
 419         assertEquals("Context rank", 999, context.getRank());
 420
 421         event = fExperiment.getNext(context);
 422         assertEquals("Event timestamp", 1000, event.getTimestamp().getValue());
 423         assertEquals("Context rank", 1000, context.getRank());
 424
 425         // Position trace at event rank 1001 (TS = 1002)
 426         context = fExperiment.seekEvent(new TmfTimestamp(1002, SCALE, 0));
 427         assertEquals("Context rank", 1001, context.getRank());
 428
 429         event = fExperiment.getNext(context);
 430         assertEquals("Event timestamp", 1002, event.getTimestamp().getValue());
 431         assertEquals("Context rank", 1002, context.getRank());
 432
 433         // Position trace at event rank 4500 (TS = 4501)
 434         context = fExperiment.seekEvent(new TmfTimestamp(4501, SCALE, 0));
 435         assertEquals("Context rank", 4500, context.getRank());
 436
 437         event = fExperiment.getNext(context);
 438         assertEquals("Event timestamp", 4501, event.getTimestamp().getValue());
 439         assertEquals("Context rank", 4501, context.getRank());
 440     }
 441
 442     public void testSeekTimestampOutOfScope() throws Exception {
 443
 444         // Position trace at beginning
 445         ITmfContext context = fExperiment.seekEvent(new TmfTimestamp(-1, SCALE, 0));
 446         assertEquals("Event rank", 0, context.getRank());
 447
 448         ITmfEvent event = fExperiment.getNext(context);
 449         assertEquals("Event timestamp", 1, event.getTimestamp().getValue());
 450         assertEquals("Event rank", 1, context.getRank());
 451
 452         // Position trace at event passed the end
 453         context = fExperiment.seekEvent(new TmfTimestamp(NB_EVENTS + 1, SCALE, 0));
 454         event = fExperiment.getNext(context);
 455         assertNull("Event location", event);
 456         assertEquals("Event rank", ITmfContext.UNKNOWN_RANK, context.getRank());
 457     }
 458
 459     // ------------------------------------------------------------------------
 460     // seekEvent by location (context rank is undefined)
 461     // ------------------------------------------------------------------------
 462
 463     public void testSeekLocationOnCacheBoundary() throws Exception {
 464
 465         long cacheSize = fExperiment.getCacheSize();
 466
 467         // Position trace at event rank 0
 468         ITmfContext tmpContext = fExperiment.seekEvent(0);
 469         ITmfContext context = fExperiment.seekEvent(tmpContext.getLocation());
 470
 471         ITmfEvent event = fExperiment.getNext(context);
 472         assertEquals("Event timestamp", 1, event.getTimestamp().getValue());
 473
 474         event = fExperiment.getNext(context);
 475         assertEquals("Event timestamp", 2, event.getTimestamp().getValue());
 476
 477         // Position trace at event rank 'cacheSize'
 478         tmpContext = fExperiment.seekEvent(cacheSize);
 479         context = fExperiment.seekEvent(tmpContext.getLocation());
 480
 481         event = fExperiment.getNext(context);
 482         assertEquals("Event timestamp", cacheSize + 1, event.getTimestamp().getValue());
 483
 484         event = fExperiment.getNext(context);
 485         assertEquals("Event timestamp", cacheSize + 2, event.getTimestamp().getValue());
 486
 487         // Position trace at event rank 4 * 'cacheSize'
 488         tmpContext = fExperiment.seekEvent(4 * cacheSize);
 489         context = fExperiment.seekEvent(tmpContext.getLocation());
 490
 491         event = fExperiment.getNext(context);
 492         assertEquals("Event timestamp", 4 * cacheSize + 1, event.getTimestamp().getValue());
 493
 494         event = fExperiment.getNext(context);
 495         assertEquals("Event timestamp", 4 * cacheSize + 2, event.getTimestamp().getValue());
 496     }
 497
 498     public void testSeekLocationNotOnCacheBoundary() throws Exception {
 499
 500         long cacheSize = fExperiment.getCacheSize();
 501
 502         // Position trace at event 'cacheSize' - 1
 503         ITmfContext tmpContext = fExperiment.seekEvent(cacheSize - 1);
 504         ITmfContext context = fExperiment.seekEvent(tmpContext.getLocation());
 505
 506         ITmfEvent event = fExperiment.getNext(context);
 507         assertEquals("Event timestamp", cacheSize, event.getTimestamp().getValue());
 508
 509         event = fExperiment.getNext(context);
 510         assertEquals("Event timestamp", cacheSize + 1, event.getTimestamp().getValue());
 511
 512         // Position trace at event rank 2 * 'cacheSize' - 1
 513         tmpContext = fExperiment.seekEvent(2 * cacheSize - 1);
 514         context = fExperiment.seekEvent(tmpContext.getLocation());
 515         context = fExperiment.seekEvent(2 * cacheSize - 1);
 516
 517         event = fExperiment.getNext(context);
 518         assertEquals("Event timestamp", 2 * cacheSize, event.getTimestamp().getValue());
 519
 520         event = fExperiment.getNext(context);
 521         assertEquals("Event timestamp", 2 * cacheSize + 1, event.getTimestamp().getValue());
 522
 523         // Position trace at event rank 4500
 524         tmpContext = fExperiment.seekEvent(4500);
 525         context = fExperiment.seekEvent(tmpContext.getLocation());
 526
 527         event = fExperiment.getNext(context);
 528         assertEquals("Event timestamp", 4501, event.getTimestamp().getValue());
 529
 530         event = fExperiment.getNext(context);
 531         assertEquals("Event timestamp", 4502, event.getTimestamp().getValue());
 532     }
 533
 534     public void testSeekLocationOutOfScope() throws Exception {
 535
 536         // Position trace at beginning
 537         ITmfContext context = fExperiment.seekEvent((ITmfLocation<?>) null);
 538
 539         ITmfEvent event = fExperiment.getNext(context);
 540         assertEquals("Event timestamp", 1, event.getTimestamp().getValue());
 541     }
 542
 543     // ------------------------------------------------------------------------
 544     // readtNextEvent - updates the context
 545     // ------------------------------------------------------------------------
 546
 547     public void testReadNextEvent() throws Exception {
 548
 549         // On lower bound, returns the first event (ts = 0)
 550         final ITmfContext context = fExperiment.seekEvent(0);
 551         ITmfEvent event = fExperiment.getNext(context);
 552         assertEquals("Event timestamp", 1, event.getTimestamp().getValue());
 553
 554         for (int i = 2; i < 20; i++) {
 555             event = fExperiment.getNext(context);
 556             assertEquals("Event timestamp", i, event.getTimestamp().getValue());
 557         }
 558     }
 559
 560     // ------------------------------------------------------------------------
 561     // processRequest
 562     // ------------------------------------------------------------------------
 563
 564     public void testProcessRequestForNbEvents() throws Exception {
 565
 566         final int blockSize = 100;
 567         final int nbEvents  = 1000;
 568         final Vector<TmfEvent> requestedEvents = new Vector<TmfEvent>();
 569
 570         final TmfTimeRange range = new TmfTimeRange(TmfTimestamp.BIG_BANG, TmfTimestamp.BIG_CRUNCH);
 571         final TmfEventRequest<TmfEvent> request = new TmfEventRequest<TmfEvent>(TmfEvent.class, range, nbEvents, blockSize) {
 572             @Override
 573             public void handleData(final TmfEvent event) {
 574                 super.handleData(event);
 575                 requestedEvents.add(event);
 576             }
 577         };
 578         fExperiment.sendRequest(request);
 579         request.waitForCompletion();
 580
 581         assertEquals("nbEvents", nbEvents, requestedEvents.size());
 582         assertTrue("isCompleted",  request.isCompleted());
 583         assertFalse("isCancelled", request.isCancelled());
 584
 585         // Ensure that we have distinct events.
 586         // Don't go overboard: we are not validating the stub!
 587         for (int i = 0; i < nbEvents; i++) {
 588             assertEquals("Distinct events", i+1, requestedEvents.get(i).getTimestamp().getValue());
 589         }
 590     }
 591
 592     public void testProcessRequestForNbEvents2() throws Exception {
 593
 594         final int blockSize = 2 * NB_EVENTS;
 595         final int nbEvents = 1000;
 596         final Vector<TmfEvent> requestedEvents = new Vector<TmfEvent>();
 597
 598         final TmfTimeRange range = new TmfTimeRange(TmfTimestamp.BIG_BANG, TmfTimestamp.BIG_CRUNCH);
 599         final TmfEventRequest<TmfEvent> request = new TmfEventRequest<TmfEvent>(TmfEvent.class, range, nbEvents, blockSize) {
 600             @Override
 601             public void handleData(final TmfEvent event) {
 602                 super.handleData(event);
 603                 requestedEvents.add(event);
 604             }
 605         };
 606         fExperiment.sendRequest(request);
 607         request.waitForCompletion();
 608
 609         assertEquals("nbEvents", nbEvents, requestedEvents.size());
 610         assertTrue("isCompleted",  request.isCompleted());
 611         assertFalse("isCancelled", request.isCancelled());
 612
 613         // Ensure that we have distinct events.
 614         // Don't go overboard: we are not validating the stub!
 615         for (int i = 0; i < nbEvents; i++) {
 616             assertEquals("Distinct events", i+1, requestedEvents.get(i).getTimestamp().getValue());
 617         }
 618     }
 619
 620     public void testProcessRequestForAllEvents() throws Exception {
 621
 622         final int nbEvents  = TmfEventRequest.ALL_DATA;
 623         final int blockSize =  1;
 624         final Vector<TmfEvent> requestedEvents = new Vector<TmfEvent>();
 625         final long nbExpectedEvents = NB_EVENTS;
 626
 627         final TmfTimeRange range = new TmfTimeRange(TmfTimestamp.BIG_BANG, TmfTimestamp.BIG_CRUNCH);
 628         final TmfEventRequest<TmfEvent> request = new TmfEventRequest<TmfEvent>(TmfEvent.class, range, nbEvents, blockSize) {
 629             @Override
 630             public void handleData(final TmfEvent event) {
 631                 super.handleData(event);
 632                 requestedEvents.add(event);
 633             }
 634         };
 635         fExperiment.sendRequest(request);
 636         request.waitForCompletion();
 637
 638         assertEquals("nbEvents", nbExpectedEvents, requestedEvents.size());
 639         assertTrue("isCompleted",  request.isCompleted());
 640         assertFalse("isCancelled", request.isCancelled());
 641
 642         // Ensure that we have distinct events.
 643         // Don't go overboard: we are not validating the stub!
 644         for (int i = 0; i < nbExpectedEvents; i++) {
 645             assertEquals("Distinct events", i+1, requestedEvents.get(i).getTimestamp().getValue());
 646         }
 647     }
 648
 649     // ------------------------------------------------------------------------
 650     // cancel
 651     // ------------------------------------------------------------------------
 652
 653     public void testCancel() throws Exception {
 654
 655         final int nbEvents  = NB_EVENTS;
 656         final int blockSize = BLOCK_SIZE;
 657         final Vector<TmfEvent> requestedEvents = new Vector<TmfEvent>();
 658
 659         final TmfTimeRange range = new TmfTimeRange(TmfTimestamp.BIG_BANG, TmfTimestamp.BIG_CRUNCH);
 660         final TmfEventRequest<TmfEvent> request = new TmfEventRequest<TmfEvent>(TmfEvent.class, range, nbEvents, blockSize) {
 661             int nbRead = 0;
 662             @Override
 663             public void handleData(final TmfEvent event) {
 664                 super.handleData(event);
 665                 requestedEvents.add(event);
 666                 if (++nbRead == blockSize) {
 667                     cancel();
 668                 }
 669             }
 670             @Override
 671             public void handleCancel() {
 672                 if (requestedEvents.size() < blockSize) {
 673                     System.out.println("aie");
 674                 }
 675             }
 676         };
 677         fExperiment.sendRequest(request);
 678         request.waitForCompletion();
 679
 680         assertEquals("nbEvents",  blockSize, requestedEvents.size());
 681         assertTrue("isCompleted", request.isCompleted());
 682         assertTrue("isCancelled", request.isCancelled());
 683     }
 684
 685 }