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

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