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