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