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

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