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.ITmfDataRequest.ExecutionType;
  37 import org.eclipse.linuxtools.tmf.core.request.TmfDataRequest;
  38 import org.eclipse.linuxtools.tmf.core.request.TmfEventRequest;
  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.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.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 TmfTestTrace TEST_TRACE = TmfTestTrace.A_TEST_10K;
  66     private static final long   DEFAULT_INITIAL_OFFSET_VALUE = (1L * 100 * 1000 * 1000); // .1sec
  67     private static final int    NB_EVENTS   = 10000;
  68     private static TmfTraceStub fTrace      = null;
  69
  70     private static int SCALE = -3;
  71
  72     // ------------------------------------------------------------------------
  73     // Housekeeping
  74     // ------------------------------------------------------------------------
  75
  76     @Before
  77     public void setUp() {
  78         fTrace = setupTrace(TEST_TRACE.getFullPath());
  79     }
  80
  81     @After
  82     public void tearDown() {
  83         fTrace.dispose();
  84         fTrace = null;
  85     }
  86
  87     // ------------------------------------------------------------------------
  88     // Helper functions
  89     // ------------------------------------------------------------------------
  90
  91     private static TmfTraceStub setupTrace(final String path) {
  92         if (fTrace == null) {
  93             try {
  94                 final URL location = FileLocator.find(TmfCoreTestPlugin.getDefault().getBundle(), new Path(path), null);
  95                 final File test = new File(FileLocator.toFileURL(location).toURI());
  96                 fTrace = new TmfTraceStub(test.toURI().getPath(), ITmfTrace.DEFAULT_TRACE_CACHE_SIZE, false, null);
  97                 fTrace.indexTrace(true);
  98             } catch (final TmfTraceException e) {
  99                 e.printStackTrace();
 100             } catch (final URISyntaxException e) {
 101                 e.printStackTrace();
 102             } catch (final IOException e) {
 103                 e.printStackTrace();
 104             }
 105         }
 106         return fTrace;
 107     }
 108
 109     // ------------------------------------------------------------------------
 110     // Constructors
 111     // ------------------------------------------------------------------------
 112
 113     @Test
 114     public void testFullConstructor() throws TmfTraceException {
 115         try {
 116             final URL location = FileLocator.find(TmfCoreTestPlugin.getDefault().getBundle(), new Path(TEST_TRACE.getFullPath()), null);
 117             File testfile = new File(FileLocator.toFileURL(location).toURI());
 118             TmfTraceStub trace = new TmfTraceStub(testfile.toURI().getPath(), ITmfTrace.DEFAULT_TRACE_CACHE_SIZE, false, null);
 119             trace.indexTrace(true);
 120
 121             assertEquals("getType", ITmfEvent.class, trace.getType());
 122             assertNull("getResource", trace.getResource());
 123             assertEquals("getPath", testfile.toURI().getPath(), trace.getPath());
 124             assertEquals("getCacheSize", ITmfTrace.DEFAULT_TRACE_CACHE_SIZE, trace.getCacheSize());
 125             assertEquals("getStreamingInterval", 0, trace.getStreamingInterval());
 126             assertEquals("getName", TEST_TRACE.getPath(), trace.getName());
 127
 128             assertEquals("getNbEvents", NB_EVENTS, trace.getNbEvents());
 129             assertEquals("getRange-start", 1, trace.getTimeRange().getStartTime().getValue());
 130             assertEquals("getRange-end", NB_EVENTS, trace.getTimeRange().getEndTime().getValue());
 131             assertEquals("getStartTime", 1, trace.getStartTime().getValue());
 132             assertEquals("getEndTime", NB_EVENTS, trace.getEndTime().getValue());
 133
 134         } catch (final URISyntaxException e) {
 135             fail("URISyntaxException");
 136         } catch (final IOException e) {
 137             fail("IOException");
 138         }
 139     }
 140
 141     @Test
 142     public void testLiveTraceConstructor() throws TmfTraceException {
 143         final long interval = 100;
 144         try {
 145             final URL location = FileLocator.find(TmfCoreTestPlugin.getDefault().getBundle(), new Path(TEST_TRACE.getFullPath()), null);
 146             File testfile = new File(FileLocator.toFileURL(location).toURI());
 147             TmfTraceStub trace = new TmfTraceStub(testfile.toURI().getPath(), ITmfTrace.DEFAULT_TRACE_CACHE_SIZE, interval);
 148             trace.indexTrace(true);
 149
 150             assertEquals("getType", ITmfEvent.class, trace.getType());
 151             assertNull("getResource", trace.getResource());
 152             assertEquals("getPath", testfile.toURI().getPath(), trace.getPath());
 153             assertEquals("getCacheSize", ITmfTrace.DEFAULT_TRACE_CACHE_SIZE, trace.getCacheSize());
 154             assertEquals("getStreamingInterval", interval, trace.getStreamingInterval());
 155             assertEquals("getName", TEST_TRACE.getPath(), trace.getName());
 156
 157             assertEquals("getNbEvents", NB_EVENTS, trace.getNbEvents());
 158             assertEquals("getRange-start", 1, trace.getTimeRange().getStartTime().getValue());
 159             assertEquals("getRange-end", NB_EVENTS, trace.getTimeRange().getEndTime().getValue());
 160             assertEquals("getStartTime", 1, trace.getStartTime().getValue());
 161             assertEquals("getEndTime", NB_EVENTS, trace.getEndTime().getValue());
 162
 163         } catch (final URISyntaxException e) {
 164             fail("URISyntaxException");
 165         } catch (final IOException e) {
 166             fail("IOException");
 167         }
 168     }
 169
 170     @Test
 171     public void testCopyConstructor() throws TmfTraceException {
 172         try {
 173             final URL location = FileLocator.find(TmfCoreTestPlugin.getDefault().getBundle(), new Path(TEST_TRACE.getFullPath()), null);
 174             File testfile = new File(FileLocator.toFileURL(location).toURI());
 175             TmfTraceStub original = new TmfTraceStub(testfile.toURI().getPath(), ITmfTrace.DEFAULT_TRACE_CACHE_SIZE, false, null);
 176             TmfTraceStub trace = new TmfTraceStub(original);
 177             trace.indexTrace(true);
 178
 179             assertEquals("getType", ITmfEvent.class, trace.getType());
 180             assertNull("getResource", trace.getResource());
 181             assertEquals("getPath", testfile.toURI().getPath(), trace.getPath());
 182             assertEquals("getCacheSize", ITmfTrace.DEFAULT_TRACE_CACHE_SIZE, trace.getCacheSize());
 183             assertEquals("getStreamingInterval", 0, trace.getStreamingInterval());
 184             assertEquals("getName", TEST_TRACE.getPath(), trace.getName());
 185
 186             assertEquals("getNbEvents", NB_EVENTS, trace.getNbEvents());
 187             assertEquals("getRange-start", 1, trace.getTimeRange().getStartTime().getValue());
 188             assertEquals("getRange-end", NB_EVENTS, trace.getTimeRange().getEndTime().getValue());
 189             assertEquals("getStartTime", 1, trace.getStartTime().getValue());
 190             assertEquals("getEndTime", NB_EVENTS, trace.getEndTime().getValue());
 191
 192         } catch (final URISyntaxException e) {
 193             fail("URISyntaxException");
 194         } catch (final IOException e) {
 195             fail("IOException");
 196         }
 197
 198         // Test the copy of a null trace
 199         try {
 200             new TmfTraceStub((TmfTraceStub) null);
 201             fail("Missing exception");
 202         } catch (final IllegalArgumentException e) {
 203             // test passed
 204         } catch (final Exception e) {
 205             fail("Unexpected exception");
 206         }
 207     }
 208
 209     // ------------------------------------------------------------------------
 210     // Trace initialization
 211     // ------------------------------------------------------------------------
 212
 213     @Test
 214     public void testInitializeNullPath() {
 215         // Instantiate an "empty" trace
 216         final TmfTraceStub trace = new TmfTraceStub();
 217
 218         try {
 219             trace.initialize(null, null, ITmfEvent.class);
 220             fail("TmfTrace.initialize() - no exception thrown");
 221         } catch (TmfTraceException e) {
 222             // Success
 223         } catch (Exception e) {
 224             fail("TmfTrace.initialize() - wrong exception thrown");
 225         }
 226     }
 227
 228     @Test
 229     public void testInitializeSimplePath() {
 230         // Instantiate an "empty" trace
 231         final TmfTraceStub trace = new TmfTraceStub();
 232
 233         // Path == trace name
 234         String path = "TraceName";
 235         try {
 236             trace.initialize(null, path, ITmfEvent.class);
 237         } catch (Exception e) {
 238             fail("TmfTrace.initialize() - Exception thrown");
 239         }
 240
 241         assertEquals("getType", ITmfEvent.class, trace.getType());
 242         assertNull  ("getResource", trace.getResource());
 243         assertEquals("getPath", path, trace.getPath());
 244         assertEquals("getCacheSize", ITmfTrace.DEFAULT_TRACE_CACHE_SIZE, trace.getCacheSize());
 245         assertEquals("getStreamingInterval", 0, trace.getStreamingInterval());
 246         assertEquals("getName", path, trace.getName());
 247
 248         assertEquals("getNbEvents",    0, trace.getNbEvents());
 249         assertEquals("getRange-start", Long.MIN_VALUE, trace.getTimeRange().getStartTime().getValue());
 250         assertEquals("getRange-end",   Long.MIN_VALUE, trace.getTimeRange().getEndTime().getValue());
 251         assertEquals("getStartTime",   Long.MIN_VALUE, trace.getStartTime().getValue());
 252         assertEquals("getEndTime",     Long.MIN_VALUE, trace.getEndTime().getValue());
 253     }
 254
 255     @Test
 256     public void testInitializeNormalPath() {
 257         // Instantiate an "empty" trace
 258         final TmfTraceStub trace = new TmfTraceStub();
 259
 260         // Path == trace name
 261         String name = "TraceName";
 262         String path = "/my/trace/path/" + name;
 263         try {
 264             trace.initialize(null, path, ITmfEvent.class);
 265         } catch (Exception e) {
 266             fail("TmfTrace.initialize() - Exception thrown");
 267         }
 268
 269         assertEquals("getType", ITmfEvent.class, trace.getType());
 270         assertNull  ("getResource", trace.getResource());
 271         assertEquals("getPath", path, trace.getPath());
 272         assertEquals("getCacheSize", ITmfTrace.DEFAULT_TRACE_CACHE_SIZE, trace.getCacheSize());
 273         assertEquals("getStreamingInterval", 0, trace.getStreamingInterval());
 274         assertEquals("getName", name, trace.getName());
 275
 276         assertEquals("getNbEvents",    0, trace.getNbEvents());
 277         assertEquals("getRange-start", Long.MIN_VALUE, trace.getTimeRange().getStartTime().getValue());
 278         assertEquals("getRange-end",   Long.MIN_VALUE, trace.getTimeRange().getEndTime().getValue());
 279         assertEquals("getStartTime",   Long.MIN_VALUE, trace.getStartTime().getValue());
 280         assertEquals("getEndTime",     Long.MIN_VALUE, trace.getEndTime().getValue());
 281     }
 282
 283     @Test
 284     public void testInitTrace() throws URISyntaxException, IOException, TmfTraceException, InterruptedException {
 285         // Instantiate an "empty" trace
 286         final TmfTraceStub trace = new TmfTraceStub();
 287
 288         assertNull  ("getType",  trace.getType());
 289         assertNull  ("getResource", trace.getResource());
 290         assertEquals("getCacheSize", ITmfTrace.DEFAULT_TRACE_CACHE_SIZE, trace.getCacheSize());
 291         assertEquals("getStreamingInterval", 0, trace.getStreamingInterval());
 292         assertEquals("getName", "", trace.getName());
 293
 294         assertEquals("getNbEvents",    0, trace.getNbEvents());
 295         assertEquals("getRange-start", Long.MIN_VALUE, trace.getTimeRange().getStartTime().getValue());
 296         assertEquals("getRange-end",   Long.MIN_VALUE, trace.getTimeRange().getEndTime().getValue());
 297         assertEquals("getStartTime",   Long.MIN_VALUE, trace.getStartTime().getValue());
 298         assertEquals("getEndTime",     Long.MIN_VALUE, trace.getEndTime().getValue());
 299
 300         // Validate
 301         final URL location = FileLocator.find(TmfCoreTestPlugin.getDefault().getBundle(), new Path(TEST_TRACE.getFullPath()), null);
 302         final File testfile = new File(FileLocator.toFileURL(location).toURI());
 303         assertTrue("validate", trace.validate(null, testfile.getPath()).isOK());
 304
 305         // InitTrace and wait for indexing completion...
 306         trace.initTrace(null, testfile.toURI().getPath(), ITmfEvent.class);
 307         trace.indexTrace(true);
 308         int nbSecs = 0;
 309         while (trace.getNbEvents() < NB_EVENTS && nbSecs < 10) {
 310             Thread.sleep(1000);
 311             nbSecs++;
 312         }
 313         if (trace.getNbEvents() < NB_EVENTS) {
 314             fail("indexing");
 315         }
 316
 317         assertEquals("getType", ITmfEvent.class, trace.getType());
 318         assertNull  ("getResource", trace.getResource());
 319         assertEquals("getCacheSize", ITmfTrace.DEFAULT_TRACE_CACHE_SIZE, trace.getCacheSize());
 320         assertEquals("getStreamingInterval", 0, trace.getStreamingInterval());
 321         assertEquals("getName", TEST_TRACE.getPath(), trace.getName());
 322
 323         assertEquals("getNbEvents",    NB_EVENTS, trace.getNbEvents());
 324         assertEquals("getRange-start", 1,         trace.getTimeRange().getStartTime().getValue());
 325         assertEquals("getRange-end",   NB_EVENTS, trace.getTimeRange().getEndTime().getValue());
 326         assertEquals("getStartTime",   1,         trace.getStartTime().getValue());
 327         assertEquals("getEndTime",     NB_EVENTS, trace.getEndTime().getValue());
 328     }
 329
 330     // ------------------------------------------------------------------------
 331     // Set/Get streaming interval
 332     // ------------------------------------------------------------------------
 333
 334     @Test
 335     public void testSetStreamingInterval() throws TmfTraceException {
 336         final TmfTraceStub trace = new TmfTraceStub(fTrace);
 337
 338         long interval = 0;
 339         assertEquals("getStreamingInterval", interval, trace.getStreamingInterval());
 340
 341         interval = 100;
 342         trace.setStreamingInterval(interval);
 343         assertEquals("getStreamingInterval", interval, trace.getStreamingInterval());
 344
 345         interval = -1;
 346         trace.setStreamingInterval(interval);
 347         assertEquals("getStreamingInterval", 0, trace.getStreamingInterval());
 348
 349         interval = 0;
 350         trace.setStreamingInterval(interval);
 351         assertEquals("getStreamingInterval", interval, trace.getStreamingInterval());
 352
 353         trace.dispose();
 354     }
 355
 356     // ------------------------------------------------------------------------
 357     // Set/Get time range
 358     // ------------------------------------------------------------------------
 359
 360     @Test
 361     public void testSetTimeRange() throws TmfTraceException {
 362         final TmfTraceStub trace = new TmfTraceStub(fTrace);
 363         trace.indexTrace(true);
 364
 365         assertEquals("getRange-start", 1,         trace.getTimeRange().getStartTime().getValue());
 366         assertEquals("getRange-end",   NB_EVENTS, trace.getTimeRange().getEndTime().getValue());
 367         assertEquals("getStartTime",   1,         trace.getStartTime().getValue());
 368         assertEquals("getEndTime",     NB_EVENTS, trace.getEndTime().getValue());
 369
 370         trace.setTimeRange(new TmfTimeRange(new TmfTimestamp(100), new TmfTimestamp(200)));
 371         assertEquals("setTimeRange",   100, trace.getTimeRange().getStartTime().getValue());
 372         assertEquals("setTimeRange",   200, trace.getTimeRange().getEndTime().getValue());
 373         assertEquals("setTimeRange",   100, trace.getStartTime().getValue());
 374         assertEquals("setTimeRange",   200, trace.getEndTime().getValue());
 375
 376         trace.dispose();
 377     }
 378
 379     @Test
 380     public void testSetStartTime() throws TmfTraceException {
 381         final TmfTraceStub trace = new TmfTraceStub(fTrace);
 382         trace.indexTrace(true);
 383
 384         assertEquals("getRange-start", 1,         trace.getTimeRange().getStartTime().getValue());
 385         assertEquals("getRange-end",   NB_EVENTS, trace.getTimeRange().getEndTime().getValue());
 386         assertEquals("getStartTime",   1,         trace.getStartTime().getValue());
 387         assertEquals("getEndTime",     NB_EVENTS, trace.getEndTime().getValue());
 388
 389         trace.setStartTime(new TmfTimestamp(100));
 390         assertEquals("setStartTime",   100,       trace.getTimeRange().getStartTime().getValue());
 391         assertEquals("setStartTime",   NB_EVENTS, trace.getTimeRange().getEndTime().getValue());
 392         assertEquals("setStartTime",   100,       trace.getStartTime().getValue());
 393         assertEquals("setStartTime",   NB_EVENTS, trace.getEndTime().getValue());
 394
 395         trace.dispose();
 396     }
 397
 398     @Test
 399     public void testSetEndTime() throws TmfTraceException {
 400         final TmfTraceStub trace = new TmfTraceStub(fTrace);
 401         trace.indexTrace(true);
 402
 403         assertEquals("getRange-start", 1,         trace.getTimeRange().getStartTime().getValue());
 404         assertEquals("getRange-end",   NB_EVENTS, trace.getTimeRange().getEndTime().getValue());
 405         assertEquals("getStartTime",   1,         trace.getStartTime().getValue());
 406         assertEquals("getEndTime",     NB_EVENTS, trace.getEndTime().getValue());
 407
 408         trace.setEndTime(new TmfTimestamp(100));
 409         assertEquals("setEndTime",     1,   trace.getTimeRange().getStartTime().getValue());
 410         assertEquals("setEndTime",     100, trace.getTimeRange().getEndTime().getValue());
 411         assertEquals("setEndTime",     1,   trace.getStartTime().getValue());
 412         assertEquals("setEndTime",     100, trace.getEndTime().getValue());
 413
 414         trace.dispose();
 415     }
 416
 417     @Test
 418     public void testSetNbEvents() throws TmfTraceException {
 419         final TmfTraceStub trace = new TmfTraceStub(fTrace);
 420         trace.indexTrace(true);
 421
 422         assertEquals("getNbEvents", NB_EVENTS, trace.getNbEvents());
 423
 424         trace.setNbEvents(0);
 425         assertEquals("getNbEvents", 0, trace.getNbEvents());
 426
 427         trace.setNbEvents(-1);
 428         assertEquals("getNbEvents", 0, trace.getNbEvents());
 429
 430         trace.setNbEvents(NB_EVENTS + 1);
 431         assertEquals("getNbEvents", NB_EVENTS + 1, trace.getNbEvents());
 432
 433         trace.setNbEvents(NB_EVENTS);
 434         assertEquals("getNbEvents", NB_EVENTS, trace.getNbEvents());
 435
 436         trace.dispose();
 437     }
 438
 439     // ------------------------------------------------------------------------
 440     // State system and statistics methods
 441     // ------------------------------------------------------------------------
 442
 443     @Test
 444     public void testGetStatistics() {
 445         /* Should be null in unit tests */
 446         ITmfStatistics stats = fTrace.getStatistics();
 447         assertNull(stats);
 448     }
 449
 450     @Test
 451     public void testGetStateSystem() {
 452         /* There should be no state system registered so far */
 453         ITmfStateSystem ss = fTrace.getStateSystems().get("something");
 454         assertNull(ss);
 455     }
 456
 457     /**
 458      * Make sure the returned map is unmodifiable.
 459      */
 460     @Test(expected=UnsupportedOperationException.class)
 461     public void testGetStateSystem_readOnly() {
 462         Map<String, ITmfStateSystem> sss = fTrace.getStateSystems();
 463         sss.put("something", null);
 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<ITmfEvent>();
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 ITmfDataProvider[] 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<ITmfEvent>();
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 ITmfDataProvider[] 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<ITmfEvent>();
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 ITmfDataProvider[] 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<ITmfEvent>();
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 ITmfDataProvider[] 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<ITmfEvent>();
1265
1266         final TmfDataRequest request = new TmfDataRequest(ITmfEvent.class,
1267                 startIndex,
1268                 nbEvents,
1269                 TmfDataRequest.ExecutionType.FOREGROUND) {
1270             @Override
1271             public void handleData(final ITmfEvent event) {
1272                 super.handleData(event);
1273                 requestedEvents.add(event);
1274             }
1275         };
1276         final ITmfDataProvider[] providers = TmfProviderManager.getProviders(ITmfEvent.class, TmfTraceStub.class);
1277         providers[0].sendRequest(request);
1278         request.waitForCompletion();
1279
1280         assertEquals("nbEvents", nbEvents, requestedEvents.size());
1281         assertTrue("isCompleted",  request.isCompleted());
1282         assertFalse("isCancelled", request.isCancelled());
1283
1284         // Ensure that we have distinct events.
1285         // Don't go overboard: we are not validating the stub!
1286         for (int i = 0; i < nbEvents; i++) {
1287             assertEquals("Distinct events", startIndex + 1 + i, requestedEvents.get(i).getTimestamp().getValue());
1288         }
1289     }
1290
1291     // ------------------------------------------------------------------------
1292     // cancel
1293     // ------------------------------------------------------------------------
1294
1295     @Test
1296     public void testCancel() throws InterruptedException {
1297         final int limit = 500;
1298         final Vector<ITmfEvent> requestedEvents = new Vector<ITmfEvent>();
1299
1300         final TmfTimeRange range = new TmfTimeRange(TmfTimestamp.BIG_BANG, TmfTimestamp.BIG_CRUNCH);
1301         final TmfEventRequest request = new TmfEventRequest(ITmfEvent.class,
1302                 range, 0, NB_EVENTS, ExecutionType.FOREGROUND) {
1303             int nbRead = 0;
1304
1305             @Override
1306             public void handleData(final ITmfEvent event) {
1307                 super.handleData(event);
1308                 requestedEvents.add(event);
1309                 if (++nbRead == limit) {
1310                     cancel();
1311                 }
1312             }
1313         };
1314         final ITmfDataProvider[] providers = TmfProviderManager.getProviders(ITmfEvent.class, TmfTraceStub.class);
1315         providers[0].sendRequest(request);
1316         request.waitForCompletion();
1317
1318         assertEquals("nbEvents",  limit, requestedEvents.size());
1319         assertTrue("isCompleted", request.isCompleted());
1320         assertTrue("isCancelled", request.isCancelled());
1321     }
1322
1323     // ------------------------------------------------------------------------
1324     // toString
1325     // ------------------------------------------------------------------------
1326
1327     @Test
1328     public void testDefaultTmfTraceStub() {
1329         assertFalse ("Open trace", fTrace == null);
1330         assertEquals("getType",  ITmfEvent.class, fTrace.getType());
1331         assertNull  ("getResource", fTrace.getResource());
1332         assertEquals("getStreamingInterval", 0, fTrace.getStreamingInterval());
1333         assertEquals("getName", TEST_TRACE.getPath(), fTrace.getName());
1334
1335         assertEquals("getNbEvents",    NB_EVENTS, fTrace.getNbEvents());
1336         assertEquals("getRange-start", 1,         fTrace.getTimeRange().getStartTime().getValue());
1337         assertEquals("getRange-end",   NB_EVENTS, fTrace.getTimeRange().getEndTime().getValue());
1338         assertEquals("getStartTime",   1,         fTrace.getStartTime().getValue());
1339         assertEquals("getEndTime",     NB_EVENTS, fTrace.getEndTime().getValue());
1340
1341         String expected = "TmfTrace [fPath=" + fTrace.getPath() + ", fCacheSize=" + fTrace.getCacheSize() +
1342                 ", fNbEvents=" + fTrace.getNbEvents() + ", fStartTime=" + fTrace.getStartTime() +
1343                 ", fEndTime=" + fTrace.getEndTime() + ", fStreamingInterval=" + fTrace.getStreamingInterval() +
1344                 "]";
1345         assertEquals("toString", expected, fTrace.toString());
1346     }
1347
1348     // ------------------------------------------------------------------------
1349     // getInitialRangeOffset, getCurrentRange, getCurrentTime
1350     // ------------------------------------------------------------------------
1351
1352     @Test
1353     public void testCurrentTimeValues() throws TmfTraceException {
1354
1355         TmfTraceStub trace = null;
1356         File testfile = null;
1357         try {
1358             final URL location = FileLocator.find(TmfCoreTestPlugin.getDefault().getBundle(), new Path(TEST_TRACE.getFullPath()), null);
1359             testfile = new File(FileLocator.toFileURL(location).toURI());
1360             trace = new TmfTraceStub(testfile.toURI().getPath(), ITmfTrace.DEFAULT_TRACE_CACHE_SIZE, false, null);
1361             // verify initial values
1362             TmfTimestamp defaultInitRange = new TmfTimestamp(DEFAULT_INITIAL_OFFSET_VALUE, ITmfTimestamp.NANOSECOND_SCALE);
1363             assertEquals("getInitialRangeOffset", defaultInitRange, trace.getInitialRangeOffset());
1364             trace.setInitialRangeOffset(new TmfTimestamp(5, ITmfTimestamp.MILLISECOND_SCALE));
1365             trace.indexTrace(true);
1366
1367             TmfTimestamp initRange = new TmfTimestamp(5, ITmfTimestamp.MILLISECOND_SCALE);
1368             assertEquals("getInitialRangeOffset", initRange, trace.getInitialRangeOffset());
1369
1370         } catch (final URISyntaxException e) {
1371             fail("URISyntaxException");
1372         } catch (final IOException e) {
1373             fail("IOException");
1374         }
1375     }
1376
1377     /**
1378      * Run the String getHostId() method test
1379      */
1380     @Test
1381     public void testTraceHostId() {
1382         String a = fTrace.getHostId();
1383         assertEquals("A-Test-10K", a);
1384     }
1385 }