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

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