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