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

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