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