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

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