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

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