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