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