tmf/org.eclipse.tracecompass.tmf.core.tests/src/org/eclipse/tracecompass/tmf/core/tests/trace/TmfTraceTest.java

   1 /*******************************************************************************
   2  * Copyright (c) 2009, 2014 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 - Adapted for TMF Trace Model 1.0
  12  *   Alexandre Montplaisir - Port to JUnit4
  13  *******************************************************************************/
  14
  15 package org.eclipse.tracecompass.tmf.core.tests.trace;
  16
  17 import static org.junit.Assert.assertEquals;
  18 import static org.junit.Assert.assertFalse;
  19 import static org.junit.Assert.assertNotNull;
  20 import static org.junit.Assert.assertNull;
  21 import static org.junit.Assert.assertTrue;
  22 import static org.junit.Assert.fail;
  23
  24 import java.io.File;
  25 import java.io.IOException;
  26 import java.net.URISyntaxException;
  27 import java.net.URL;
  28 import java.util.Vector;
  29 import java.util.concurrent.TimeUnit;
  30
  31 import org.eclipse.core.runtime.FileLocator;
  32 import org.eclipse.core.runtime.Path;
  33 import org.eclipse.tracecompass.internal.tmf.core.component.TmfProviderManager;
  34 import org.eclipse.tracecompass.tmf.core.analysis.IAnalysisModule;
  35 import org.eclipse.tracecompass.tmf.core.component.ITmfEventProvider;
  36 import org.eclipse.tracecompass.tmf.core.event.ITmfEvent;
  37 import org.eclipse.tracecompass.tmf.core.event.aspect.ITmfEventAspect;
  38 import org.eclipse.tracecompass.tmf.core.exceptions.TmfTraceException;
  39 import org.eclipse.tracecompass.tmf.core.request.ITmfEventRequest.ExecutionType;
  40 import org.eclipse.tracecompass.tmf.core.request.TmfEventRequest;
  41 import org.eclipse.tracecompass.tmf.core.signal.TmfSignalManager;
  42 import org.eclipse.tracecompass.tmf.core.signal.TmfTraceOpenedSignal;
  43 import org.eclipse.tracecompass.tmf.core.tests.TmfCoreTestPlugin;
  44 import org.eclipse.tracecompass.tmf.core.tests.shared.TmfTestTrace;
  45 import org.eclipse.tracecompass.tmf.core.timestamp.ITmfTimestamp;
  46 import org.eclipse.tracecompass.tmf.core.timestamp.TmfTimeRange;
  47 import org.eclipse.tracecompass.tmf.core.timestamp.TmfTimestamp;
  48 import org.eclipse.tracecompass.tmf.core.trace.ITmfContext;
  49 import org.eclipse.tracecompass.tmf.core.trace.ITmfTrace;
  50 import org.eclipse.tracecompass.tmf.core.trace.TmfContext;
  51 import org.eclipse.tracecompass.tmf.core.trace.TmfTrace;
  52 import org.eclipse.tracecompass.tmf.core.trace.location.ITmfLocation;
  53 import org.eclipse.tracecompass.tmf.tests.stubs.analysis.TestAnalysis;
  54 import org.eclipse.tracecompass.tmf.tests.stubs.trace.TmfTraceStub;
  55 import org.junit.After;
  56 import org.junit.Before;
  57 import org.junit.Rule;
  58 import org.junit.Test;
  59 import org.junit.rules.TestRule;
  60 import org.junit.rules.Timeout;
  61
  62 /**
  63  * Test suite for the TmfTrace class.
  64  */
  65 @SuppressWarnings("javadoc")
  66 public class TmfTraceTest {
  67
  68     /** Time-out tests after 20 seconds */
  69     @Rule
  70     public TestRule globalTimeout= new Timeout(20, TimeUnit.SECONDS);
  71
  72     // ------------------------------------------------------------------------
  73     // Variables
  74     // ------------------------------------------------------------------------
  75
  76     private static final TmfTestTrace TEST_TRACE = TmfTestTrace.A_TEST_10K;
  77     private static final long   DEFAULT_INITIAL_OFFSET_VALUE = (1L * 100 * 1000 * 1000); // .1sec
  78     private static final int    NB_EVENTS   = 10000;
  79     private TmfTraceStub fTrace      = null;
  80
  81     private static int SCALE = -3;
  82
  83     // ------------------------------------------------------------------------
  84     // Housekeeping
  85     // ------------------------------------------------------------------------
  86
  87     @Before
  88     public void setUp() {
  89         try {
  90             final URL location = FileLocator.find(TmfCoreTestPlugin.getDefault().getBundle(), new Path(TEST_TRACE.getFullPath()), null);
  91             final File test = new File(FileLocator.toFileURL(location).toURI());
  92             fTrace = new TmfTraceStub(test.toURI().getPath(), ITmfTrace.DEFAULT_TRACE_CACHE_SIZE, false, null);
  93             TmfSignalManager.deregister(fTrace);
  94             fTrace.indexTrace(true);
  95         } catch (final TmfTraceException e) {
  96             e.printStackTrace();
  97         } catch (final URISyntaxException e) {
  98             e.printStackTrace();
  99         } catch (final IOException e) {
 100             e.printStackTrace();
 101         }
 102     }
 103
 104     @After
 105     public void tearDown() {
 106         fTrace.dispose();
 107         fTrace = null;
 108     }
 109
 110     // ------------------------------------------------------------------------
 111     // Constructors
 112     // ------------------------------------------------------------------------
 113
 114     @Test
 115     public void testFullConstructor() throws TmfTraceException {
 116         try {
 117             final URL location = FileLocator.find(TmfCoreTestPlugin.getDefault().getBundle(), new Path(TEST_TRACE.getFullPath()), null);
 118             File testfile = new File(FileLocator.toFileURL(location).toURI());
 119             TmfTraceStub trace = new TmfTraceStub(testfile.toURI().getPath(), ITmfTrace.DEFAULT_TRACE_CACHE_SIZE, false, null);
 120             trace.indexTrace(true);
 121
 122             assertEquals("getType", ITmfEvent.class, trace.getType());
 123             assertNull("getResource", trace.getResource());
 124             assertEquals("getPath", testfile.toURI().getPath(), trace.getPath());
 125             assertEquals("getCacheSize", ITmfTrace.DEFAULT_TRACE_CACHE_SIZE, trace.getCacheSize());
 126             assertEquals("getStreamingInterval", 0, trace.getStreamingInterval());
 127             assertEquals("getName", TEST_TRACE.getPath(), trace.getName());
 128
 129             assertEquals("getNbEvents", NB_EVENTS, trace.getNbEvents());
 130             assertEquals("getRange-start", 1, trace.getTimeRange().getStartTime().getValue());
 131             assertEquals("getRange-end", NB_EVENTS, trace.getTimeRange().getEndTime().getValue());
 132             assertEquals("getStartTime", 1, trace.getStartTime().getValue());
 133             assertEquals("getEndTime", NB_EVENTS, trace.getEndTime().getValue());
 134
 135         } catch (final URISyntaxException e) {
 136             fail("URISyntaxException");
 137         } catch (final IOException e) {
 138             fail("IOException");
 139         }
 140     }
 141
 142     @Test
 143     public void testLiveTraceConstructor() throws TmfTraceException {
 144         final long interval = 100;
 145         try {
 146             final URL location = FileLocator.find(TmfCoreTestPlugin.getDefault().getBundle(), new Path(TEST_TRACE.getFullPath()), null);
 147             File testfile = new File(FileLocator.toFileURL(location).toURI());
 148             TmfTraceStub trace = new TmfTraceStub(testfile.toURI().getPath(), ITmfTrace.DEFAULT_TRACE_CACHE_SIZE, interval);
 149             trace.indexTrace(true);
 150
 151             assertEquals("getType", ITmfEvent.class, trace.getType());
 152             assertNull("getResource", trace.getResource());
 153             assertEquals("getPath", testfile.toURI().getPath(), trace.getPath());
 154             assertEquals("getCacheSize", ITmfTrace.DEFAULT_TRACE_CACHE_SIZE, trace.getCacheSize());
 155             assertEquals("getStreamingInterval", interval, trace.getStreamingInterval());
 156             assertEquals("getName", TEST_TRACE.getPath(), trace.getName());
 157
 158             assertEquals("getNbEvents", NB_EVENTS, trace.getNbEvents());
 159             assertEquals("getRange-start", 1, trace.getTimeRange().getStartTime().getValue());
 160             assertEquals("getRange-end", NB_EVENTS, trace.getTimeRange().getEndTime().getValue());
 161             assertEquals("getStartTime", 1, trace.getStartTime().getValue());
 162             assertEquals("getEndTime", NB_EVENTS, trace.getEndTime().getValue());
 163
 164         } catch (final URISyntaxException e) {
 165             fail("URISyntaxException");
 166         } catch (final IOException e) {
 167             fail("IOException");
 168         }
 169     }
 170
 171     @Test
 172     public void testCopyConstructor() throws TmfTraceException {
 173         try {
 174             final URL location = FileLocator.find(TmfCoreTestPlugin.getDefault().getBundle(), new Path(TEST_TRACE.getFullPath()), null);
 175             File testfile = new File(FileLocator.toFileURL(location).toURI());
 176             TmfTraceStub original = new TmfTraceStub(testfile.toURI().getPath(), ITmfTrace.DEFAULT_TRACE_CACHE_SIZE, false, null);
 177             TmfTraceStub trace = new TmfTraceStub(original);
 178             trace.indexTrace(true);
 179
 180             assertEquals("getType", ITmfEvent.class, trace.getType());
 181             assertNull("getResource", trace.getResource());
 182             assertEquals("getPath", testfile.toURI().getPath(), trace.getPath());
 183             assertEquals("getCacheSize", ITmfTrace.DEFAULT_TRACE_CACHE_SIZE, trace.getCacheSize());
 184             assertEquals("getStreamingInterval", 0, trace.getStreamingInterval());
 185             assertEquals("getName", TEST_TRACE.getPath(), trace.getName());
 186
 187             assertEquals("getNbEvents", NB_EVENTS, trace.getNbEvents());
 188             assertEquals("getRange-start", 1, trace.getTimeRange().getStartTime().getValue());
 189             assertEquals("getRange-end", NB_EVENTS, trace.getTimeRange().getEndTime().getValue());
 190             assertEquals("getStartTime", 1, trace.getStartTime().getValue());
 191             assertEquals("getEndTime", NB_EVENTS, trace.getEndTime().getValue());
 192
 193         } catch (final URISyntaxException e) {
 194             fail("URISyntaxException");
 195         } catch (final IOException e) {
 196             fail("IOException");
 197         }
 198
 199         // Test the copy of a null trace
 200         try {
 201             new TmfTraceStub((TmfTraceStub) null);
 202             fail("Missing exception");
 203         } catch (final IllegalArgumentException e) {
 204             // test passed
 205         } catch (final Exception e) {
 206             fail("Unexpected exception");
 207         }
 208     }
 209
 210     // ------------------------------------------------------------------------
 211     // Trace initialization
 212     // ------------------------------------------------------------------------
 213
 214     @Test
 215     public void testInitializeNullPath() {
 216         // Instantiate an "empty" trace
 217         final TmfTraceStub trace = new TmfTraceStub();
 218
 219         try {
 220             trace.initialize(null, null, ITmfEvent.class);
 221             fail("TmfTrace.initialize() - no exception thrown");
 222         } catch (TmfTraceException e) {
 223             // Success
 224         } catch (Exception e) {
 225             fail("TmfTrace.initialize() - wrong exception thrown");
 226         }
 227     }
 228
 229     @Test
 230     public void testInitializeSimplePath() {
 231         // Instantiate an "empty" trace
 232         final TmfTraceStub trace = new TmfTraceStub();
 233
 234         // Path == trace name
 235         String path = "TraceName";
 236         try {
 237             trace.initialize(null, path, ITmfEvent.class);
 238         } catch (Exception e) {
 239             fail("TmfTrace.initialize() - Exception thrown");
 240         }
 241
 242         assertEquals("getType", ITmfEvent.class, trace.getType());
 243         assertNull  ("getResource", trace.getResource());
 244         assertEquals("getPath", path, trace.getPath());
 245         assertEquals("getCacheSize", ITmfTrace.DEFAULT_TRACE_CACHE_SIZE, trace.getCacheSize());
 246         assertEquals("getStreamingInterval", 0, trace.getStreamingInterval());
 247         assertEquals("getName", path, trace.getName());
 248
 249         assertEquals("getNbEvents",    0, trace.getNbEvents());
 250         assertEquals("getRange-start", Long.MIN_VALUE, trace.getTimeRange().getStartTime().getValue());
 251         assertEquals("getRange-end",   Long.MIN_VALUE, trace.getTimeRange().getEndTime().getValue());
 252         assertEquals("getStartTime",   Long.MIN_VALUE, trace.getStartTime().getValue());
 253         assertEquals("getEndTime",     Long.MIN_VALUE, trace.getEndTime().getValue());
 254     }
 255
 256     @Test
 257     public void testInitializeNormalPath() {
 258         // Instantiate an "empty" trace
 259         final TmfTraceStub trace = new TmfTraceStub();
 260
 261         // Path == trace name
 262         String name = "TraceName";
 263         String path = "/my/trace/path/" + name;
 264         try {
 265             trace.initialize(null, path, ITmfEvent.class);
 266         } catch (Exception e) {
 267             fail("TmfTrace.initialize() - Exception thrown");
 268         }
 269
 270         assertEquals("getType", ITmfEvent.class, trace.getType());
 271         assertNull  ("getResource", trace.getResource());
 272         assertEquals("getPath", path, trace.getPath());
 273         assertEquals("getCacheSize", ITmfTrace.DEFAULT_TRACE_CACHE_SIZE, trace.getCacheSize());
 274         assertEquals("getStreamingInterval", 0, trace.getStreamingInterval());
 275         assertEquals("getName", name, trace.getName());
 276
 277         assertEquals("getNbEvents",    0, trace.getNbEvents());
 278         assertEquals("getRange-start", Long.MIN_VALUE, trace.getTimeRange().getStartTime().getValue());
 279         assertEquals("getRange-end",   Long.MIN_VALUE, trace.getTimeRange().getEndTime().getValue());
 280         assertEquals("getStartTime",   Long.MIN_VALUE, trace.getStartTime().getValue());
 281         assertEquals("getEndTime",     Long.MIN_VALUE, trace.getEndTime().getValue());
 282     }
 283
 284     @Test
 285     public void testInitTrace() throws URISyntaxException, IOException, TmfTraceException, InterruptedException {
 286         // Instantiate an "empty" trace
 287         final TmfTraceStub trace = new TmfTraceStub();
 288
 289         assertNull  ("getType",  trace.getType());
 290         assertNull  ("getResource", trace.getResource());
 291         assertEquals("getCacheSize", ITmfTrace.DEFAULT_TRACE_CACHE_SIZE, trace.getCacheSize());
 292         assertEquals("getStreamingInterval", 0, trace.getStreamingInterval());
 293         assertEquals("getName", "", trace.getName());
 294
 295         assertEquals("getNbEvents",    0, trace.getNbEvents());
 296         assertEquals("getRange-start", Long.MIN_VALUE, trace.getTimeRange().getStartTime().getValue());
 297         assertEquals("getRange-end",   Long.MIN_VALUE, trace.getTimeRange().getEndTime().getValue());
 298         assertEquals("getStartTime",   Long.MIN_VALUE, trace.getStartTime().getValue());
 299         assertEquals("getEndTime",     Long.MIN_VALUE, trace.getEndTime().getValue());
 300
 301         // Validate
 302         final URL location = FileLocator.find(TmfCoreTestPlugin.getDefault().getBundle(), new Path(TEST_TRACE.getFullPath()), null);
 303         final File testfile = new File(FileLocator.toFileURL(location).toURI());
 304         assertTrue("validate", trace.validate(null, testfile.getPath()).isOK());
 305
 306         // InitTrace and wait for indexing completion...
 307         trace.initTrace(null, testfile.toURI().getPath(), ITmfEvent.class);
 308         trace.indexTrace(true);
 309         int nbSecs = 0;
 310         while (trace.getNbEvents() < NB_EVENTS && nbSecs < 10) {
 311             Thread.sleep(1000);
 312             nbSecs++;
 313         }
 314         if (trace.getNbEvents() < NB_EVENTS) {
 315             fail("indexing");
 316         }
 317
 318         assertEquals("getType", ITmfEvent.class, trace.getType());
 319         assertNull  ("getResource", trace.getResource());
 320         assertEquals("getCacheSize", ITmfTrace.DEFAULT_TRACE_CACHE_SIZE, trace.getCacheSize());
 321         assertEquals("getStreamingInterval", 0, trace.getStreamingInterval());
 322         assertEquals("getName", TEST_TRACE.getPath(), trace.getName());
 323
 324         assertEquals("getNbEvents",    NB_EVENTS, trace.getNbEvents());
 325         assertEquals("getRange-start", 1,         trace.getTimeRange().getStartTime().getValue());
 326         assertEquals("getRange-end",   NB_EVENTS, trace.getTimeRange().getEndTime().getValue());
 327         assertEquals("getStartTime",   1,         trace.getStartTime().getValue());
 328         assertEquals("getEndTime",     NB_EVENTS, trace.getEndTime().getValue());
 329     }
 330
 331     // ------------------------------------------------------------------------
 332     // Set/Get streaming interval
 333     // ------------------------------------------------------------------------
 334
 335     @Test
 336     public void testSetStreamingInterval() throws TmfTraceException {
 337         final TmfTraceStub trace = new TmfTraceStub(fTrace);
 338
 339         long interval = 0;
 340         assertEquals("getStreamingInterval", interval, trace.getStreamingInterval());
 341
 342         interval = 100;
 343         trace.setStreamingInterval(interval);
 344         assertEquals("getStreamingInterval", interval, trace.getStreamingInterval());
 345
 346         interval = -1;
 347         trace.setStreamingInterval(interval);
 348         assertEquals("getStreamingInterval", 0, trace.getStreamingInterval());
 349
 350         interval = 0;
 351         trace.setStreamingInterval(interval);
 352         assertEquals("getStreamingInterval", interval, trace.getStreamingInterval());
 353
 354         trace.dispose();
 355     }
 356
 357     // ------------------------------------------------------------------------
 358     // Set/Get time range
 359     // ------------------------------------------------------------------------
 360
 361     @Test
 362     public void testSetTimeRange() throws TmfTraceException {
 363         final TmfTraceStub trace = new TmfTraceStub(fTrace);
 364         trace.indexTrace(true);
 365
 366         assertEquals("getRange-start", 1,         trace.getTimeRange().getStartTime().getValue());
 367         assertEquals("getRange-end",   NB_EVENTS, trace.getTimeRange().getEndTime().getValue());
 368         assertEquals("getStartTime",   1,         trace.getStartTime().getValue());
 369         assertEquals("getEndTime",     NB_EVENTS, trace.getEndTime().getValue());
 370
 371         trace.setTimeRange(new TmfTimeRange(new TmfTimestamp(100), new TmfTimestamp(200)));
 372         assertEquals("setTimeRange",   100, trace.getTimeRange().getStartTime().getValue());
 373         assertEquals("setTimeRange",   200, trace.getTimeRange().getEndTime().getValue());
 374         assertEquals("setTimeRange",   100, trace.getStartTime().getValue());
 375         assertEquals("setTimeRange",   200, trace.getEndTime().getValue());
 376
 377         trace.dispose();
 378     }
 379
 380     @Test
 381     public void testSetStartTime() throws TmfTraceException {
 382         final TmfTraceStub trace = new TmfTraceStub(fTrace);
 383         trace.indexTrace(true);
 384
 385         assertEquals("getRange-start", 1,         trace.getTimeRange().getStartTime().getValue());
 386         assertEquals("getRange-end",   NB_EVENTS, trace.getTimeRange().getEndTime().getValue());
 387         assertEquals("getStartTime",   1,         trace.getStartTime().getValue());
 388         assertEquals("getEndTime",     NB_EVENTS, trace.getEndTime().getValue());
 389
 390         trace.setStartTime(new TmfTimestamp(100));
 391         assertEquals("setStartTime",   100,       trace.getTimeRange().getStartTime().getValue());
 392         assertEquals("setStartTime",   NB_EVENTS, trace.getTimeRange().getEndTime().getValue());
 393         assertEquals("setStartTime",   100,       trace.getStartTime().getValue());
 394         assertEquals("setStartTime",   NB_EVENTS, trace.getEndTime().getValue());
 395
 396         trace.dispose();
 397     }
 398
 399     @Test
 400     public void testSetEndTime() throws TmfTraceException {
 401         final TmfTraceStub trace = new TmfTraceStub(fTrace);
 402         trace.indexTrace(true);
 403
 404         assertEquals("getRange-start", 1,         trace.getTimeRange().getStartTime().getValue());
 405         assertEquals("getRange-end",   NB_EVENTS, trace.getTimeRange().getEndTime().getValue());
 406         assertEquals("getStartTime",   1,         trace.getStartTime().getValue());
 407         assertEquals("getEndTime",     NB_EVENTS, trace.getEndTime().getValue());
 408
 409         trace.setEndTime(new TmfTimestamp(100));
 410         assertEquals("setEndTime",     1,   trace.getTimeRange().getStartTime().getValue());
 411         assertEquals("setEndTime",     100, trace.getTimeRange().getEndTime().getValue());
 412         assertEquals("setEndTime",     1,   trace.getStartTime().getValue());
 413         assertEquals("setEndTime",     100, trace.getEndTime().getValue());
 414
 415         trace.dispose();
 416     }
 417
 418     @Test
 419     public void testSetNbEvents() throws TmfTraceException {
 420         final TmfTraceStub trace = new TmfTraceStub(fTrace);
 421         trace.indexTrace(true);
 422
 423         assertEquals("getNbEvents", NB_EVENTS, trace.getNbEvents());
 424
 425         trace.setNbEvents(0);
 426         assertEquals("getNbEvents", 0, trace.getNbEvents());
 427
 428         trace.setNbEvents(-1);
 429         assertEquals("getNbEvents", 0, trace.getNbEvents());
 430
 431         trace.setNbEvents(NB_EVENTS + 1);
 432         assertEquals("getNbEvents", NB_EVENTS + 1, trace.getNbEvents());
 433
 434         trace.setNbEvents(NB_EVENTS);
 435         assertEquals("getNbEvents", NB_EVENTS, trace.getNbEvents());
 436
 437         trace.dispose();
 438     }
 439
 440     // ------------------------------------------------------------------------
 441     // State system, statistics and modules methods
 442     // ------------------------------------------------------------------------
 443
 444     @Test
 445     public void testGetModules() {
 446         /* There should not be any modules at this point */
 447         Iterable<IAnalysisModule> modules = fTrace.getAnalysisModules();
 448         assertFalse(modules.iterator().hasNext());
 449
 450         /* Open the trace, the modules should be populated */
 451         fTrace.traceOpened(new TmfTraceOpenedSignal(this, fTrace, null));
 452
 453         modules = fTrace.getAnalysisModules();
 454         assertTrue(modules.iterator().hasNext());
 455
 456         /*
 457          * Make sure all modules of type TestAnalysis are returned in the second
 458          * call
 459          */
 460         int count = 0;
 461         for (IAnalysisModule module : modules) {
 462             if (module instanceof TestAnalysis) {
 463                 count++;
 464                 IAnalysisModule otherModule = fTrace.getAnalysisModule(module.getId());
 465                 assertNotNull(otherModule);
 466                 assertEquals(otherModule, module);
 467             }
 468         }
 469         /*
 470          * FIXME: The exact count depends on the context the test is run (full
 471          * test suite or this file only), but there must be at least 2 modules
 472          */
 473         assertTrue(count >= 2);
 474     }
 475
 476     // ------------------------------------------------------------------------
 477     // seekEvent on location (note: does not reliably set the rank)
 478     // ------------------------------------------------------------------------
 479
 480     @Test
 481     public void testSeekEventOnCacheBoundary() {
 482         // Position trace at event rank 0
 483         ITmfContext context = fTrace.seekEvent(0);
 484         ITmfEvent event = fTrace.parseEvent(context);
 485         assertEquals("Event timestamp", 1, event.getTimestamp().getValue());
 486         assertEquals("Event rank", 0, context.getRank());
 487
 488         context = fTrace.seekEvent(context.getLocation());
 489         assertEquals("Event rank", ITmfContext.UNKNOWN_RANK, context.getRank());
 490
 491         event = fTrace.parseEvent(context);
 492         assertEquals("Event timestamp", 1, event.getTimestamp().getValue());
 493         assertEquals("Event rank", ITmfContext.UNKNOWN_RANK, context.getRank());
 494
 495         event = fTrace.getNext(context);
 496         assertEquals("Event timestamp", 1, event.getTimestamp().getValue());
 497         assertEquals("Event rank", ITmfContext.UNKNOWN_RANK, context.getRank());
 498
 499         // Position trace at event rank 1000
 500         ITmfContext tmpContext = fTrace.seekEvent(new TmfTimestamp(1001, SCALE));
 501         context = fTrace.seekEvent(tmpContext.getLocation());
 502         assertEquals("Event rank", ITmfContext.UNKNOWN_RANK, context.getRank());
 503
 504         event = fTrace.parseEvent(context);
 505         assertEquals("Event timestamp", 1001, event.getTimestamp().getValue());
 506         assertEquals("Event rank", ITmfContext.UNKNOWN_RANK, context.getRank());
 507
 508         event = fTrace.getNext(context);
 509         assertEquals("Event timestamp", 1001, event.getTimestamp().getValue());
 510         assertEquals("Event rank", ITmfContext.UNKNOWN_RANK, context.getRank());
 511
 512         // Position trace at event rank 4000
 513         tmpContext = fTrace.seekEvent(new TmfTimestamp(4001, SCALE));
 514         context = fTrace.seekEvent(tmpContext.getLocation());
 515         assertEquals("Event rank", ITmfContext.UNKNOWN_RANK, context.getRank());
 516
 517         event = fTrace.parseEvent(context);
 518         assertEquals("Event timestamp", 4001, event.getTimestamp().getValue());
 519         assertEquals("Event rank", ITmfContext.UNKNOWN_RANK, context.getRank());
 520
 521         event = fTrace.getNext(context);
 522         assertEquals("Event timestamp", 4001, event.getTimestamp().getValue());
 523         assertEquals("Event rank", ITmfContext.UNKNOWN_RANK, context.getRank());
 524     }
 525
 526     @Test
 527     public void testSeekEventNotOnCacheBoundary() {
 528         // Position trace at event rank 9
 529         ITmfContext tmpContext = fTrace.seekEvent(new TmfTimestamp(10, SCALE));
 530         TmfContext context = fTrace.seekEvent(tmpContext.getLocation());
 531         assertEquals("Event rank", ITmfContext.UNKNOWN_RANK, context.getRank());
 532
 533         ITmfEvent event = fTrace.parseEvent(context);
 534         assertEquals("Event timestamp", 10, event.getTimestamp().getValue());
 535         assertEquals("Event rank", ITmfContext.UNKNOWN_RANK, context.getRank());
 536
 537         event = fTrace.getNext(context);
 538         assertEquals("Event timestamp", 10, event.getTimestamp().getValue());
 539         assertEquals("Event rank", ITmfContext.UNKNOWN_RANK, context.getRank());
 540
 541         // Position trace at event rank 999
 542         tmpContext = fTrace.seekEvent(new TmfTimestamp(1000, SCALE));
 543         context = fTrace.seekEvent(tmpContext.getLocation());
 544         assertEquals("Event rank", ITmfContext.UNKNOWN_RANK, context.getRank());
 545
 546         event = fTrace.parseEvent(context);
 547         assertEquals("Event timestamp", 1000, event.getTimestamp().getValue());
 548         assertEquals("Event rank", ITmfContext.UNKNOWN_RANK, context.getRank());
 549
 550         event = fTrace.getNext(context);
 551         assertEquals("Event timestamp", 1000, event.getTimestamp().getValue());
 552         assertEquals("Event rank", ITmfContext.UNKNOWN_RANK, context.getRank());
 553
 554         // Position trace at event rank 1001
 555         tmpContext = fTrace.seekEvent(new TmfTimestamp(1002, SCALE));
 556         context = fTrace.seekEvent(tmpContext.getLocation());
 557         assertEquals("Event rank", ITmfContext.UNKNOWN_RANK, context.getRank());
 558
 559         event = fTrace.parseEvent(context);
 560         assertEquals("Event timestamp", 1002, event.getTimestamp().getValue());
 561         assertEquals("Event rank", ITmfContext.UNKNOWN_RANK, context.getRank());
 562
 563         event = fTrace.getNext(context);
 564         assertEquals("Event timestamp", 1002, event.getTimestamp().getValue());
 565         assertEquals("Event rank", ITmfContext.UNKNOWN_RANK, context.getRank());
 566
 567         // Position trace at event rank 4500
 568         tmpContext = fTrace.seekEvent(new TmfTimestamp(4501, SCALE));
 569         context = fTrace.seekEvent(tmpContext.getLocation());
 570         assertEquals("Event rank", ITmfContext.UNKNOWN_RANK, context.getRank());
 571
 572         event = fTrace.parseEvent(context);
 573         assertEquals("Event timestamp", 4501, event.getTimestamp().getValue());
 574         assertEquals("Event rank", ITmfContext.UNKNOWN_RANK, context.getRank());
 575
 576         event = fTrace.getNext(context);
 577         assertEquals("Event timestamp", 4501, event.getTimestamp().getValue());
 578         assertEquals("Event rank", ITmfContext.UNKNOWN_RANK, context.getRank());
 579     }
 580
 581     @Test
 582     public void testSeekEventOutOfScope() {
 583         // Position trace at beginning
 584         ITmfContext tmpContext = fTrace.seekEvent(0);
 585         ITmfContext context = fTrace.seekEvent(tmpContext.getLocation());
 586         assertEquals("Event rank", ITmfContext.UNKNOWN_RANK, context.getRank());
 587
 588         ITmfEvent event = fTrace.parseEvent(context);
 589         assertEquals("Event timestamp", 1, event.getTimestamp().getValue());
 590         assertEquals("Event rank", ITmfContext.UNKNOWN_RANK, context.getRank());
 591
 592         event = fTrace.getNext(context);
 593         assertEquals("Event timestamp", 1, event.getTimestamp().getValue());
 594         assertEquals("Event rank", ITmfContext.UNKNOWN_RANK, context.getRank());
 595
 596         // Position trace at event passed the end
 597         context = fTrace.seekEvent(new TmfTimestamp(NB_EVENTS + 1, SCALE));
 598         assertNull("Event timestamp", context.getLocation());
 599         assertEquals("Event rank", ITmfContext.UNKNOWN_RANK, context.getRank());
 600
 601         event = fTrace.getNext(context);
 602         assertNull("Event", event);
 603     }
 604
 605     // ------------------------------------------------------------------------
 606     // seekEvent on timestamp (note: does not reliably set the rank)
 607     // ------------------------------------------------------------------------
 608
 609     @Test
 610     public void testSeekEventOnNullTimestamp() {
 611         // Position trace at event rank 0
 612         ITmfContext context = fTrace.seekEvent((ITmfTimestamp) null);
 613         assertEquals("Event rank", 0, context.getRank());
 614
 615         ITmfEvent event = fTrace.parseEvent(context);
 616         assertEquals("Event timestamp", 1, event.getTimestamp().getValue());
 617         assertEquals("Event rank", 0, context.getRank());
 618     }
 619
 620     @Test
 621     public void testSeekEventOnTimestampOnCacheBoundary() {
 622         // Position trace at event rank 0
 623         ITmfContext context = fTrace.seekEvent(new TmfTimestamp(1, SCALE));
 624         assertEquals("Event rank", 0, context.getRank());
 625
 626         ITmfEvent event = fTrace.parseEvent(context);
 627         assertEquals("Event timestamp", 1, event.getTimestamp().getValue());
 628         assertEquals("Event rank", 0, context.getRank());
 629
 630         event = fTrace.getNext(context);
 631         assertEquals("Event timestamp", 1, event.getTimestamp().getValue());
 632         assertEquals("Event rank", 1, context.getRank());
 633
 634         // Position trace at event rank 1000
 635         context = fTrace.seekEvent(new TmfTimestamp(1001, SCALE));
 636         assertEquals("Event rank", 1000, context.getRank());
 637
 638         event = fTrace.parseEvent(context);
 639         assertEquals("Event timestamp", 1001, event.getTimestamp().getValue());
 640         assertEquals("Event rank", 1000, context.getRank());
 641
 642         event = fTrace.getNext(context);
 643         assertEquals("Event timestamp", 1001, event.getTimestamp().getValue());
 644         assertEquals("Event rank", 1001, context.getRank());
 645
 646         // Position trace at event rank 4000
 647         context = fTrace.seekEvent(new TmfTimestamp(4001, SCALE));
 648         assertEquals("Event rank", 4000, context.getRank());
 649
 650         event = fTrace.parseEvent(context);
 651         assertEquals("Event timestamp", 4001, event.getTimestamp().getValue());
 652         assertEquals("Event rank", 4000, context.getRank());
 653
 654         event = fTrace.getNext(context);
 655         assertEquals("Event timestamp", 4001, event.getTimestamp().getValue());
 656         assertEquals("Event rank", 4001, context.getRank());
 657     }
 658
 659     @Test
 660     public void testSeekEventOnTimestampNotOnCacheBoundary() {
 661         // Position trace at event rank 1
 662         ITmfContext context = fTrace.seekEvent(new TmfTimestamp(2, SCALE));
 663         assertEquals("Event rank", 1, context.getRank());
 664
 665         ITmfEvent event = fTrace.parseEvent(context);
 666         assertEquals("Event timestamp", 2, event.getTimestamp().getValue());
 667         assertEquals("Event rank", 1, context.getRank());
 668
 669         event = fTrace.getNext(context);
 670         assertEquals("Event timestamp", 2, event.getTimestamp().getValue());
 671         assertEquals("Event rank", 2, context.getRank());
 672
 673         // Position trace at event rank 9
 674         context = fTrace.seekEvent(new TmfTimestamp(10, SCALE));
 675         assertEquals("Event rank", 9, context.getRank());
 676
 677         event = fTrace.parseEvent(context);
 678         assertEquals("Event timestamp", 10, event.getTimestamp().getValue());
 679         assertEquals("Event rank", 9, context.getRank());
 680
 681         event = fTrace.getNext(context);
 682         assertEquals("Event timestamp", 10, event.getTimestamp().getValue());
 683         assertEquals("Event rank", 10, context.getRank());
 684
 685         // Position trace at event rank 999
 686         context = fTrace.seekEvent(new TmfTimestamp(1000, SCALE));
 687         assertEquals("Event rank", 999, context.getRank());
 688
 689         event = fTrace.parseEvent(context);
 690         assertEquals("Event timestamp", 1000, event.getTimestamp().getValue());
 691         assertEquals("Event rank", 999, context.getRank());
 692
 693         event = fTrace.getNext(context);
 694         assertEquals("Event timestamp", 1000, event.getTimestamp().getValue());
 695         assertEquals("Event rank", 1000, context.getRank());
 696
 697         // Position trace at event rank 1001
 698         context = fTrace.seekEvent(new TmfTimestamp(1002, SCALE));
 699         assertEquals("Event rank", 1001, context.getRank());
 700
 701         event = fTrace.parseEvent(context);
 702         assertEquals("Event timestamp", 1002, event.getTimestamp().getValue());
 703         assertEquals("Event rank", 1001, context.getRank());
 704
 705         event = fTrace.getNext(context);
 706         assertEquals("Event timestamp", 1002, event.getTimestamp().getValue());
 707         assertEquals("Event rank", 1002, context.getRank());
 708
 709         // Position trace at event rank 4500
 710         context = fTrace.seekEvent(new TmfTimestamp(4501, SCALE));
 711         assertEquals("Event rank", 4500, context.getRank());
 712
 713         event = fTrace.parseEvent(context);
 714         assertEquals("Event timestamp", 4501, event.getTimestamp().getValue());
 715         assertEquals("Event rank", 4500, context.getRank());
 716
 717         event = fTrace.getNext(context);
 718         assertEquals("Event timestamp", 4501, event.getTimestamp().getValue());
 719         assertEquals("Event rank", 4501, context.getRank());
 720     }
 721
 722     @Test
 723     public void testSeekEventOnTimestampOutOfScope() {
 724         // Position trace at beginning
 725         ITmfContext context = fTrace.seekEvent(new TmfTimestamp(-1, SCALE));
 726         assertEquals("Event rank", 0, context.getRank());
 727
 728         ITmfEvent event = fTrace.parseEvent(context);
 729         assertEquals("Event timestamp", 1, event.getTimestamp().getValue());
 730         assertEquals("Event rank", 0, context.getRank());
 731
 732         event = fTrace.getNext(context);
 733         assertEquals("Event timestamp", 1, event.getTimestamp().getValue());
 734         assertEquals("Event rank", 1, context.getRank());
 735
 736         // Position trace at event passed the end
 737         context = fTrace.seekEvent(new TmfTimestamp(NB_EVENTS + 1, SCALE));
 738         assertEquals("Event rank", ITmfContext.UNKNOWN_RANK, context.getRank());
 739
 740         event = fTrace.parseEvent(context);
 741         assertEquals("Event timestamp", null, event);
 742         assertEquals("Event rank", ITmfContext.UNKNOWN_RANK, context.getRank());
 743
 744         event = fTrace.getNext(context);
 745         assertEquals("Event timestamp", null, event);
 746         assertEquals("Event rank", ITmfContext.UNKNOWN_RANK, context.getRank());
 747     }
 748
 749     // ------------------------------------------------------------------------
 750     // seekEvent on rank
 751     // ------------------------------------------------------------------------
 752
 753     @Test
 754     public void testSeekEventOnNegativeRank() {
 755         // Position trace at event rank 0
 756         ITmfContext context = fTrace.seekEvent(-1);
 757         assertEquals("Event rank", 0, context.getRank());
 758
 759         ITmfEvent event = fTrace.parseEvent(context);
 760         assertEquals("Event timestamp", 1, event.getTimestamp().getValue());
 761         assertEquals("Event rank", 0, context.getRank());
 762     }
 763
 764     @Test
 765     public void testSeekOnRankOnCacheBoundary() {
 766         // On lower bound, returns the first event (ts = 1)
 767         ITmfContext context = fTrace.seekEvent(0);
 768         assertEquals("Event rank", 0, context.getRank());
 769
 770         ITmfEvent event = fTrace.parseEvent(context);
 771         assertEquals("Event timestamp", 1, event.getTimestamp().getValue());
 772         assertEquals("Event rank", 0, context.getRank());
 773
 774         event = fTrace.getNext(context);
 775         assertEquals("Event timestamp", 1, event.getTimestamp().getValue());
 776         assertEquals("Event rank", 1, context.getRank());
 777
 778         // Position trace at event rank 1000
 779         context = fTrace.seekEvent(1000);
 780         assertEquals("Event rank", 1000, context.getRank());
 781
 782         event = fTrace.parseEvent(context);
 783         assertEquals("Event timestamp", 1001, event.getTimestamp().getValue());
 784         assertEquals("Event rank", 1000, context.getRank());
 785
 786         event = fTrace.getNext(context);
 787         assertEquals("Event timestamp", 1001, event.getTimestamp().getValue());
 788         assertEquals("Event rank", 1001, context.getRank());
 789
 790         // Position trace at event rank 4000
 791         context = fTrace.seekEvent(4000);
 792         assertEquals("Event rank", 4000, context.getRank());
 793
 794         event = fTrace.parseEvent(context);
 795         assertEquals("Event timestamp", 4001, event.getTimestamp().getValue());
 796         assertEquals("Event rank", 4000, context.getRank());
 797
 798         event = fTrace.getNext(context);
 799         assertEquals("Event timestamp", 4001, event.getTimestamp().getValue());
 800         assertEquals("Event rank", 4001, context.getRank());
 801     }
 802
 803     @Test
 804     public void testSeekOnRankNotOnCacheBoundary() {
 805         // Position trace at event rank 9
 806         ITmfContext context = fTrace.seekEvent(9);
 807         assertEquals("Event rank", 9, context.getRank());
 808
 809         ITmfEvent event = fTrace.parseEvent(context);
 810         assertEquals("Event timestamp", 10, event.getTimestamp().getValue());
 811         assertEquals("Event rank", 9, context.getRank());
 812
 813         event = fTrace.getNext(context);
 814         assertEquals("Event timestamp", 10, event.getTimestamp().getValue());
 815         assertEquals("Event rank", 10, context.getRank());
 816
 817         // Position trace at event rank 999
 818         context = fTrace.seekEvent(999);
 819         assertEquals("Event rank", 999, context.getRank());
 820
 821         event = fTrace.parseEvent(context);
 822         assertEquals("Event timestamp", 1000, event.getTimestamp().getValue());
 823         assertEquals("Event rank", 999, context.getRank());
 824
 825         event = fTrace.getNext(context);
 826         assertEquals("Event timestamp", 1000, event.getTimestamp().getValue());
 827         assertEquals("Event rank", 1000, context.getRank());
 828
 829         // Position trace at event rank 1001
 830         context = fTrace.seekEvent(1001);
 831         assertEquals("Event rank", 1001, context.getRank());
 832
 833         event = fTrace.parseEvent(context);
 834         assertEquals("Event timestamp", 1002, event.getTimestamp().getValue());
 835         assertEquals("Event rank", 1001, context.getRank());
 836
 837         event = fTrace.getNext(context);
 838         assertEquals("Event timestamp", 1002, event.getTimestamp().getValue());
 839         assertEquals("Event rank", 1002, context.getRank());
 840
 841         // Position trace at event rank 4500
 842         context = fTrace.seekEvent(4500);
 843         assertEquals("Event rank", 4500, context.getRank());
 844
 845         event = fTrace.parseEvent(context);
 846         assertEquals("Event timestamp", 4501, event.getTimestamp().getValue());
 847         assertEquals("Event rank", 4500, context.getRank());
 848
 849         event = fTrace.getNext(context);
 850         assertEquals("Event timestamp", 4501, event.getTimestamp().getValue());
 851         assertEquals("Event rank", 4501, context.getRank());
 852     }
 853
 854     @Test
 855     public void testSeekEventOnRankOutOfScope() {
 856         // Position trace at beginning
 857         ITmfContext context = fTrace.seekEvent(-1);
 858         assertEquals("Event rank", 0, context.getRank());
 859
 860         ITmfEvent event = fTrace.parseEvent(context);
 861         assertEquals("Event timestamp", 1, event.getTimestamp().getValue());
 862         assertEquals("Event rank", 0, context.getRank());
 863
 864         event = fTrace.getNext(context);
 865         assertEquals("Event timestamp", 1, event.getTimestamp().getValue());
 866         assertEquals("Event rank", 1, context.getRank());
 867
 868         // Position trace at event passed the end
 869         context = fTrace.seekEvent(NB_EVENTS);
 870         assertEquals("Event rank", NB_EVENTS, context.getRank());
 871
 872         event = fTrace.parseEvent(context);
 873         assertNull("Event", event);
 874         assertEquals("Event rank", NB_EVENTS, context.getRank());
 875
 876         event = fTrace.getNext(context);
 877         assertNull("Event", event);
 878         assertEquals("Event rank", NB_EVENTS, context.getRank());
 879     }
 880
 881     // ------------------------------------------------------------------------
 882     // parseEvent - make sure parseEvent doesn't update the context
 883     // ------------------------------------------------------------------------
 884
 885     @Test
 886     public void testParseEvent() {
 887         final int NB_READS = 20;
 888
 889         // On lower bound, returns the first event (ts = 0)
 890         final TmfContext context = (TmfContext) fTrace.seekEvent(new TmfTimestamp(0, SCALE));
 891         TmfContext svContext = new TmfContext(context);
 892
 893         ITmfEvent event = fTrace.parseEvent(context);
 894         assertEquals("Event timestamp", 1, event.getTimestamp().getValue());
 895         assertEquals("Event rank", 0, context.getRank());
 896         assertTrue("parseEvent", context.equals(svContext));
 897
 898         event = fTrace.parseEvent(context);
 899         assertEquals("Event timestamp", 1, event.getTimestamp().getValue());
 900         assertEquals("Event rank", 0, context.getRank());
 901         assertTrue("parseEvent", context.equals(svContext));
 902
 903         event = fTrace.parseEvent(context);
 904         assertEquals("Event timestamp", 1, event.getTimestamp().getValue());
 905         assertEquals("Event rank", 0, context.getRank());
 906         assertTrue("parseEvent", context.equals(svContext));
 907
 908         // Position the trace at event NB_READS
 909         for (int i = 1; i < NB_READS; i++) {
 910             event = fTrace.getNext(context);
 911             assertEquals("Event timestamp", i, event.getTimestamp().getValue());
 912         }
 913
 914         svContext = new TmfContext(context);
 915         event = fTrace.parseEvent(context);
 916         assertEquals("Event timestamp", NB_READS, event.getTimestamp().getValue());
 917         assertEquals("Event rank", NB_READS -1 , context.getRank());
 918         assertTrue("parseEvent", context.equals(svContext));
 919
 920         event = fTrace.parseEvent(context);
 921         assertEquals("Event timestamp", NB_READS, event.getTimestamp().getValue());
 922         assertEquals("Event rank", NB_READS - 1, context.getRank());
 923         assertTrue("parseEvent", context.equals(svContext));
 924     }
 925
 926     // ------------------------------------------------------------------------
 927     // getNext - updates the context
 928     // ------------------------------------------------------------------------
 929
 930     @Test
 931     public void testGetNextAfteSeekingOnTS_1() {
 932         final long INITIAL_TS = 1;
 933         final int NB_READS = 20;
 934
 935         // On lower bound, returns the first event (ts = 1)
 936         final ITmfContext context = fTrace.seekEvent(new TmfTimestamp(INITIAL_TS, SCALE));
 937
 938         // Read NB_EVENTS
 939         ITmfEvent event;
 940         for (int i = 0; i < NB_READS; i++) {
 941             event = fTrace.getNext(context);
 942             assertEquals("Event timestamp", INITIAL_TS + i, event.getTimestamp().getValue());
 943             assertEquals("Event rank", INITIAL_TS + i, context.getRank());
 944         }
 945
 946         // Make sure we stay positioned
 947         event = fTrace.parseEvent(context);
 948         assertEquals("Event timestamp", INITIAL_TS + NB_READS, event.getTimestamp().getValue());
 949         assertEquals("Event rank", INITIAL_TS + NB_READS - 1, context.getRank());
 950     }
 951
 952     @Test
 953     public void testGetNextAfteSeekingOnTS_2() {
 954         final long INITIAL_TS = 2;
 955         final int NB_READS = 20;
 956
 957         // On lower bound, returns the first event (ts = 500)
 958         final ITmfContext context = fTrace.seekEvent(new TmfTimestamp(INITIAL_TS, SCALE));
 959
 960         // Read NB_EVENTS
 961         ITmfEvent event;
 962         for (int i = 0; i < NB_READS; i++) {
 963             event = fTrace.getNext(context);
 964             assertEquals("Event timestamp", INITIAL_TS + i, event.getTimestamp().getValue());
 965             assertEquals("Event rank", INITIAL_TS + i, context.getRank());
 966         }
 967
 968         // Make sure we stay positioned
 969         event = fTrace.parseEvent(context);
 970         assertEquals("Event timestamp", INITIAL_TS + NB_READS, event.getTimestamp().getValue());
 971         assertEquals("Event rank", INITIAL_TS + NB_READS - 1, context.getRank());
 972     }
 973
 974     @Test
 975     public void testGetNextAfteSeekingOnTS_3() {
 976         final long INITIAL_TS = 500;
 977         final int NB_READS = 20;
 978
 979         // On lower bound, returns the first event (ts = 500)
 980         final ITmfContext context = fTrace.seekEvent(new TmfTimestamp(INITIAL_TS, SCALE));
 981
 982         // Read NB_EVENTS
 983         ITmfEvent event;
 984         for (int i = 0; i < NB_READS; i++) {
 985             event = fTrace.getNext(context);
 986             assertEquals("Event timestamp", INITIAL_TS + i, event.getTimestamp().getValue());
 987             assertEquals("Event rank", INITIAL_TS + i, context.getRank());
 988         }
 989
 990         // Make sure we stay positioned
 991         event = fTrace.parseEvent(context);
 992         assertEquals("Event timestamp", INITIAL_TS + NB_READS, event.getTimestamp().getValue());
 993         assertEquals("Event rank", INITIAL_TS + NB_READS - 1, context.getRank());
 994     }
 995
 996     @Test
 997     public void testGetNextAfterSeekingOnRank_1() {
 998         final long INITIAL_RANK = 0L;
 999         final int NB_READS = 20;
1000
1001         // On lower bound, returns the first event (rank = 0)
1002         final ITmfContext context = fTrace.seekEvent(INITIAL_RANK);
1003
1004         // Read NB_EVENTS
1005         ITmfEvent event;
1006         for (int i = 0; i < NB_READS; i++) {
1007             event = fTrace.getNext(context);
1008             assertEquals("Event timestamp", INITIAL_RANK + i + 1, event.getTimestamp().getValue());
1009             assertEquals("Event rank", INITIAL_RANK + i + 1, context.getRank());
1010         }
1011
1012         // Make sure we stay positioned
1013         event = fTrace.parseEvent(context);
1014         assertEquals("Event timestamp", INITIAL_RANK + NB_READS + 1, event.getTimestamp().getValue());
1015         assertEquals("Event rank", INITIAL_RANK + NB_READS, context.getRank());
1016     }
1017
1018     @Test
1019     public void testGetNextAfterSeekingOnRank_2() {
1020         final long INITIAL_RANK = 1L;
1021         final int NB_READS = 20;
1022
1023         // On lower bound, returns the first event (rank = 0)
1024         final ITmfContext context = fTrace.seekEvent(INITIAL_RANK);
1025
1026         // Read NB_EVENTS
1027         ITmfEvent event;
1028         for (int i = 0; i < NB_READS; i++) {
1029             event = fTrace.getNext(context);
1030             assertEquals("Event timestamp", INITIAL_RANK + i + 1, event.getTimestamp().getValue());
1031             assertEquals("Event rank", INITIAL_RANK + i + 1, context.getRank());
1032         }
1033
1034         // Make sure we stay positioned
1035         event = fTrace.parseEvent(context);
1036         assertEquals("Event timestamp", INITIAL_RANK + NB_READS + 1, event.getTimestamp().getValue());
1037         assertEquals("Event rank", INITIAL_RANK + NB_READS, context.getRank());
1038     }
1039
1040     @Test
1041     public void testGetNextAfterSeekingOnRank_3() {
1042         final long INITIAL_RANK = 500L;
1043         final int NB_READS = 20;
1044
1045         // On lower bound, returns the first event (rank = 0)
1046         final ITmfContext context = fTrace.seekEvent(INITIAL_RANK);
1047
1048         // Read NB_EVENTS
1049         ITmfEvent event;
1050         for (int i = 0; i < NB_READS; i++) {
1051             event = fTrace.getNext(context);
1052             assertEquals("Event timestamp", INITIAL_RANK + i + 1, event.getTimestamp().getValue());
1053             assertEquals("Event rank", INITIAL_RANK + i + 1, context.getRank());
1054         }
1055
1056         // Make sure we stay positioned
1057         event = fTrace.parseEvent(context);
1058         assertEquals("Event timestamp", INITIAL_RANK + NB_READS + 1, event.getTimestamp().getValue());
1059         assertEquals("Event rank", INITIAL_RANK + NB_READS, context.getRank());
1060     }
1061
1062     @Test
1063     public void testGetNextAfterSeekingOnLocation_1() {
1064         final ITmfLocation INITIAL_LOC = null;
1065         final long INITIAL_TS = 1;
1066         final int NB_READS = 20;
1067
1068         // On lower bound, returns the first event (ts = 1)
1069         final ITmfContext context = fTrace.seekEvent(INITIAL_LOC);
1070
1071         // Read NB_EVENTS
1072         ITmfEvent event;
1073         for (int i = 0; i < NB_READS; i++) {
1074             event = fTrace.getNext(context);
1075             assertEquals("Event timestamp", INITIAL_TS + i, event.getTimestamp().getValue());
1076             assertEquals("Event rank", INITIAL_TS + i, context.getRank());
1077         }
1078
1079         // Make sure we stay positioned
1080         event = fTrace.parseEvent(context);
1081         assertEquals("Event timestamp", INITIAL_TS + NB_READS, event.getTimestamp().getValue());
1082         assertEquals("Event rank", INITIAL_TS + NB_READS - 1, context.getRank());
1083     }
1084
1085     @Test
1086     public void testGetNextAfterSeekingOnLocation_2() {
1087         final ITmfLocation INITIAL_LOC = fTrace.seekEvent(1L).getLocation();
1088         final long INITIAL_TS = 2;
1089         final int NB_READS = 20;
1090
1091         // On lower bound, returns the first event (ts = 501)
1092         final ITmfContext context = fTrace.seekEvent(INITIAL_LOC);
1093
1094         // Read NB_EVENTS
1095         ITmfEvent event;
1096         for (int i = 0; i < NB_READS; i++) {
1097             event = fTrace.getNext(context);
1098             assertEquals("Event timestamp", INITIAL_TS + i, event.getTimestamp().getValue());
1099         }
1100
1101         // Make sure we stay positioned
1102         event = fTrace.parseEvent(context);
1103         assertEquals("Event timestamp", INITIAL_TS + NB_READS, event.getTimestamp().getValue());
1104     }
1105
1106     @Test
1107     public void testGetNextAfterSeekingOnLocation_3() {
1108         final ITmfLocation INITIAL_LOC = fTrace.seekEvent(500L).getLocation();
1109         final long INITIAL_TS = 501;
1110         final int NB_READS = 20;
1111
1112         // On lower bound, returns the first event (ts = 501)
1113         final ITmfContext context = fTrace.seekEvent(INITIAL_LOC);
1114
1115         // Read NB_EVENTS
1116         ITmfEvent event;
1117         for (int i = 0; i < NB_READS; i++) {
1118             event = fTrace.getNext(context);
1119             assertEquals("Event timestamp", INITIAL_TS + i, event.getTimestamp().getValue());
1120         }
1121
1122         // Make sure we stay positioned
1123         event = fTrace.parseEvent(context);
1124         assertEquals("Event timestamp", INITIAL_TS + NB_READS, event.getTimestamp().getValue());
1125     }
1126
1127     @Test
1128     public void testGetNextLocation() {
1129         ITmfContext context1 = fTrace.seekEvent(0);
1130         fTrace.getNext(context1);
1131         ITmfLocation location = context1.getLocation();
1132         ITmfEvent event1 = fTrace.getNext(context1);
1133         ITmfContext context2 = fTrace.seekEvent(location);
1134         ITmfEvent event2 = fTrace.getNext(context2);
1135         assertEquals("Event timestamp", event1.getTimestamp().getValue(), event2.getTimestamp().getValue());
1136     }
1137
1138     @Test
1139     public void testGetNextEndLocation() {
1140         ITmfContext context1 = fTrace.seekEvent(fTrace.getNbEvents() - 1);
1141         fTrace.getNext(context1);
1142         ITmfLocation location = context1.getLocation();
1143         ITmfContext context2 = fTrace.seekEvent(location);
1144         ITmfEvent event = fTrace.getNext(context2);
1145         assertNull("Event", event);
1146     }
1147
1148     // ------------------------------------------------------------------------
1149     // processRequest
1150     // ------------------------------------------------------------------------
1151
1152     @Test
1153     public void testProcessEventRequestForAllEvents() throws InterruptedException {
1154         final Vector<ITmfEvent> requestedEvents = new Vector<>();
1155
1156         final TmfTimeRange range = new TmfTimeRange(TmfTimestamp.BIG_BANG, TmfTimestamp.BIG_CRUNCH);
1157         final TmfEventRequest request = new TmfEventRequest(ITmfEvent.class,
1158                 range, 0, NB_EVENTS, ExecutionType.FOREGROUND) {
1159             @Override
1160             public void handleData(final ITmfEvent event) {
1161                 super.handleData(event);
1162                 requestedEvents.add(event);
1163             }
1164         };
1165         final ITmfEventProvider[] providers = TmfProviderManager.getProviders(ITmfEvent.class, TmfTraceStub.class);
1166         providers[0].sendRequest(request);
1167         request.waitForCompletion();
1168
1169         assertEquals("nbEvents", NB_EVENTS, requestedEvents.size());
1170         assertTrue("isCompleted",  request.isCompleted());
1171         assertFalse("isCancelled", request.isCancelled());
1172
1173         // Ensure that we have distinct events.
1174         // Don't go overboard: we are not validating the stub!
1175         for (int i = 0; i < NB_EVENTS; i++) {
1176             assertEquals("Distinct events", i + 1, requestedEvents.get(i).getTimestamp().getValue());
1177         }
1178     }
1179
1180     @Test
1181     public void testProcessEventRequestForNbEvents() throws InterruptedException {
1182         final int nbEvents  = 1000;
1183         final Vector<ITmfEvent> requestedEvents = new Vector<>();
1184
1185         final TmfTimeRange range = new TmfTimeRange(TmfTimestamp.BIG_BANG, TmfTimestamp.BIG_CRUNCH);
1186         final TmfEventRequest request = new TmfEventRequest(ITmfEvent.class,
1187                 range, 0, nbEvents, ExecutionType.FOREGROUND) {
1188             @Override
1189             public void handleData(final ITmfEvent event) {
1190                 super.handleData(event);
1191                 requestedEvents.add(event);
1192             }
1193         };
1194         final ITmfEventProvider[] providers = TmfProviderManager.getProviders(ITmfEvent.class, TmfTraceStub.class);
1195         providers[0].sendRequest(request);
1196         request.waitForCompletion();
1197
1198         assertEquals("nbEvents", nbEvents, requestedEvents.size());
1199         assertTrue("isCompleted",  request.isCompleted());
1200         assertFalse("isCancelled", request.isCancelled());
1201
1202         // Ensure that we have distinct events.
1203         // Don't go overboard: we are not validating the stub!
1204         for (int i = 0; i < nbEvents; i++) {
1205             assertEquals("Distinct events", i + 1, requestedEvents.get(i).getTimestamp().getValue());
1206         }
1207     }
1208
1209     @Test
1210     public void testProcessEventRequestForSomeEvents() throws InterruptedException {
1211         final long startTime = 100;
1212         final int nbEvents  = 1000;
1213         final Vector<ITmfEvent> requestedEvents = new Vector<>();
1214
1215         final TmfTimeRange range = new TmfTimeRange(new TmfTimestamp(startTime, SCALE), TmfTimestamp.BIG_CRUNCH);
1216         final TmfEventRequest request = new TmfEventRequest(ITmfEvent.class,
1217                 range, 0, nbEvents, ExecutionType.FOREGROUND) {
1218             @Override
1219             public void handleData(final ITmfEvent event) {
1220                 super.handleData(event);
1221                 requestedEvents.add(event);
1222             }
1223         };
1224         final ITmfEventProvider[] providers = TmfProviderManager.getProviders(ITmfEvent.class, TmfTraceStub.class);
1225         providers[0].sendRequest(request);
1226         request.waitForCompletion();
1227
1228         assertEquals("nbEvents", nbEvents, requestedEvents.size());
1229         assertTrue("isCompleted",  request.isCompleted());
1230         assertFalse("isCancelled", request.isCancelled());
1231
1232         // Ensure that we have distinct events.
1233         // Don't go overboard: we are not validating the stub!
1234         for (int i = 0; i < nbEvents; i++) {
1235             assertEquals("Distinct events", startTime + i, requestedEvents.get(i).getTimestamp().getValue());
1236         }
1237     }
1238
1239     @Test
1240     public void testProcessEventRequestForOtherEvents() throws InterruptedException {
1241         final int startIndex = 99;
1242         final long startTime = 100;
1243         final int nbEvents  = 1000;
1244         final Vector<ITmfEvent> requestedEvents = new Vector<>();
1245
1246         final TmfTimeRange range = new TmfTimeRange(new TmfTimestamp(startTime, SCALE), TmfTimestamp.BIG_CRUNCH);
1247         final TmfEventRequest request = new TmfEventRequest(ITmfEvent.class,
1248                 range, startIndex, nbEvents, ExecutionType.FOREGROUND) {
1249             @Override
1250             public void handleData(final ITmfEvent event) {
1251                 super.handleData(event);
1252                 requestedEvents.add(event);
1253             }
1254         };
1255         final ITmfEventProvider[] providers = TmfProviderManager.getProviders(ITmfEvent.class, TmfTraceStub.class);
1256         providers[0].sendRequest(request);
1257         request.waitForCompletion();
1258
1259         assertEquals("nbEvents", nbEvents, requestedEvents.size());
1260         assertTrue("isCompleted",  request.isCompleted());
1261         assertFalse("isCancelled", request.isCancelled());
1262
1263         // Ensure that we have distinct events.
1264         // Don't go overboard: we are not validating the stub!
1265         for (int i = 0; i < nbEvents; i++) {
1266             assertEquals("Distinct events", startTime + i, requestedEvents.get(i).getTimestamp().getValue());
1267         }
1268     }
1269
1270     @Test
1271     public void testProcessDataRequestForSomeEvents() throws InterruptedException {
1272         final int startIndex = 100;
1273         final int nbEvents  = 1000;
1274         final Vector<ITmfEvent> requestedEvents = new Vector<>();
1275
1276         final TmfEventRequest request = new TmfEventRequest(ITmfEvent.class,
1277                 TmfTimeRange.ETERNITY,
1278                 startIndex,
1279                 nbEvents,
1280                 TmfEventRequest.ExecutionType.FOREGROUND) {
1281             @Override
1282             public void handleData(final ITmfEvent event) {
1283                 super.handleData(event);
1284                 requestedEvents.add(event);
1285             }
1286         };
1287         final ITmfEventProvider[] providers = TmfProviderManager.getProviders(ITmfEvent.class, TmfTraceStub.class);
1288         providers[0].sendRequest(request);
1289         request.waitForCompletion();
1290
1291         assertEquals("nbEvents", nbEvents, requestedEvents.size());
1292         assertTrue("isCompleted",  request.isCompleted());
1293         assertFalse("isCancelled", request.isCancelled());
1294
1295         // Ensure that we have distinct events.
1296         // Don't go overboard: we are not validating the stub!
1297         for (int i = 0; i < nbEvents; i++) {
1298             assertEquals("Distinct events", startIndex + 1 + i, requestedEvents.get(i).getTimestamp().getValue());
1299         }
1300     }
1301
1302     // ------------------------------------------------------------------------
1303     // cancel
1304     // ------------------------------------------------------------------------
1305
1306     @Test
1307     public void testCancel() throws InterruptedException {
1308         final int limit = 500;
1309         final Vector<ITmfEvent> requestedEvents = new Vector<>();
1310
1311         final TmfTimeRange range = new TmfTimeRange(TmfTimestamp.BIG_BANG, TmfTimestamp.BIG_CRUNCH);
1312         final TmfEventRequest request = new TmfEventRequest(ITmfEvent.class,
1313                 range, 0, NB_EVENTS, ExecutionType.FOREGROUND) {
1314             int nbRead = 0;
1315
1316             @Override
1317             public void handleData(final ITmfEvent event) {
1318                 super.handleData(event);
1319                 requestedEvents.add(event);
1320                 if (++nbRead == limit) {
1321                     cancel();
1322                 }
1323             }
1324         };
1325         final ITmfEventProvider[] providers = TmfProviderManager.getProviders(ITmfEvent.class, TmfTraceStub.class);
1326         providers[0].sendRequest(request);
1327         request.waitForCompletion();
1328
1329         assertEquals("nbEvents",  limit, requestedEvents.size());
1330         assertTrue("isCompleted", request.isCompleted());
1331         assertTrue("isCancelled", request.isCancelled());
1332     }
1333
1334     // ------------------------------------------------------------------------
1335     // toString
1336     // ------------------------------------------------------------------------
1337
1338     @Test
1339     public void testDefaultTmfTraceStub() {
1340         assertFalse ("Open trace", fTrace == null);
1341         assertEquals("getType",  ITmfEvent.class, fTrace.getType());
1342         assertNull  ("getResource", fTrace.getResource());
1343         assertEquals("getStreamingInterval", 0, fTrace.getStreamingInterval());
1344         assertEquals("getName", TEST_TRACE.getPath(), fTrace.getName());
1345
1346         assertEquals("getNbEvents",    NB_EVENTS, fTrace.getNbEvents());
1347         assertEquals("getRange-start", 1,         fTrace.getTimeRange().getStartTime().getValue());
1348         assertEquals("getRange-end",   NB_EVENTS, fTrace.getTimeRange().getEndTime().getValue());
1349         assertEquals("getStartTime",   1,         fTrace.getStartTime().getValue());
1350         assertEquals("getEndTime",     NB_EVENTS, fTrace.getEndTime().getValue());
1351
1352         String expected = "TmfTrace [fPath=" + fTrace.getPath() + ", fCacheSize=" + fTrace.getCacheSize() +
1353                 ", fNbEvents=" + fTrace.getNbEvents() + ", fStartTime=" + fTrace.getStartTime() +
1354                 ", fEndTime=" + fTrace.getEndTime() + ", fStreamingInterval=" + fTrace.getStreamingInterval() +
1355                 "]";
1356         assertEquals("toString", expected, fTrace.toString());
1357     }
1358
1359     // ------------------------------------------------------------------------
1360     // getInitialRangeOffset, getCurrentRange, getCurrentTime
1361     // ------------------------------------------------------------------------
1362
1363     @Test
1364     public void testCurrentTimeValues() throws TmfTraceException {
1365
1366         TmfTraceStub trace = null;
1367         File testfile = null;
1368         try {
1369             final URL location = FileLocator.find(TmfCoreTestPlugin.getDefault().getBundle(), new Path(TEST_TRACE.getFullPath()), null);
1370             testfile = new File(FileLocator.toFileURL(location).toURI());
1371             trace = new TmfTraceStub(testfile.toURI().getPath(), ITmfTrace.DEFAULT_TRACE_CACHE_SIZE, false, null);
1372             // verify initial values
1373             TmfTimestamp defaultInitRange = new TmfTimestamp(DEFAULT_INITIAL_OFFSET_VALUE, ITmfTimestamp.NANOSECOND_SCALE);
1374             assertEquals("getInitialRangeOffset", defaultInitRange, trace.getInitialRangeOffset());
1375             trace.setInitialRangeOffset(new TmfTimestamp(5, ITmfTimestamp.MILLISECOND_SCALE));
1376             trace.indexTrace(true);
1377
1378             TmfTimestamp initRange = new TmfTimestamp(5, ITmfTimestamp.MILLISECOND_SCALE);
1379             assertEquals("getInitialRangeOffset", initRange, trace.getInitialRangeOffset());
1380
1381         } catch (final URISyntaxException e) {
1382             fail("URISyntaxException");
1383         } catch (final IOException e) {
1384             fail("IOException");
1385         }
1386     }
1387
1388     // ------------------------------------------------------------------------
1389     // Other getters
1390     // ------------------------------------------------------------------------
1391
1392     /**
1393      * Run the String getHostId() method test
1394      */
1395     @Test
1396     public void testTraceHostId() {
1397         String a = fTrace.getHostId();
1398         assertEquals("A-Test-10K", a);
1399     }
1400
1401     /**
1402      * Test the {@link TmfTrace#getEventAspects} method.
1403      */
1404     @Test
1405     public void testGetEventAspects() {
1406         Iterable<ITmfEventAspect> aspects = fTrace.getEventAspects();
1407         for (ITmfEventAspect aspect : aspects) {
1408             assertTrue(TmfTrace.BASE_ASPECTS.contains(aspect));
1409         }
1410     }
1411 }