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