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.tests.shared.TmfTestTrace;
  42 import org.eclipse.linuxtools.tmf.core.timestamp.ITmfTimestamp;
  43 import org.eclipse.linuxtools.tmf.core.timestamp.TmfTimeRange;
  44 import org.eclipse.linuxtools.tmf.core.timestamp.TmfTimestamp;
  45 import org.eclipse.linuxtools.tmf.core.trace.ITmfContext;
  46 import org.eclipse.linuxtools.tmf.core.trace.ITmfLocation;
  47 import org.eclipse.linuxtools.tmf.core.trace.ITmfTrace;
  48 import org.eclipse.linuxtools.tmf.core.trace.TmfCheckpointIndexer;
  49 import org.eclipse.linuxtools.tmf.core.trace.TmfContext;
  50 import org.eclipse.linuxtools.tmf.tests.stubs.trace.TmfTraceStub;
  51 import org.junit.After;
  52 import org.junit.Before;
  53 import org.junit.Test;
  54
  55 /**
  56  * Test suite for the TmfTrace class.
  57  */
  58 @SuppressWarnings("javadoc")
  59 public class TmfTraceTest {
  60
  61     // ------------------------------------------------------------------------
  62     // Variables
  63     // ------------------------------------------------------------------------
  64
  65     private static final TmfTestTrace TEST_TRACE = TmfTestTrace.A_TEST_10K;
  66     private static final long   DEFAULT_INITIAL_OFFSET_VALUE = (1L * 100 * 1000 * 1000); // .1sec
  67     private static final int    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(TEST_TRACE.getFullPath());
  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     public void testStandardConstructor() throws TmfTraceException {
 116         try {
 117             final URL location = FileLocator.find(TmfCoreTestPlugin.getDefault().getBundle(), new Path(TEST_TRACE.getFullPath()), null);
 118             File testfile = new File(FileLocator.toFileURL(location).toURI());
 119             TmfTraceStub trace = new TmfTraceStub(testfile.toURI().getPath());
 120             trace.indexTrace(true);
 121
 122             assertEquals("getType", ITmfEvent.class, trace.getType());
 123             assertNull("getResource", trace.getResource());
 124             assertEquals("getPath", testfile.toURI().getPath(), trace.getPath());
 125             assertEquals("getCacheSize", ITmfTrace.DEFAULT_TRACE_CACHE_SIZE, trace.getCacheSize());
 126             assertEquals("getStreamingInterval", 0, trace.getStreamingInterval());
 127             assertEquals("getName", TEST_TRACE.getPath(), trace.getName());
 128
 129             assertEquals("getNbEvents", NB_EVENTS, trace.getNbEvents());
 130             assertEquals("getRange-start", 1, trace.getTimeRange().getStartTime().getValue());
 131             assertEquals("getRange-end", NB_EVENTS, trace.getTimeRange().getEndTime().getValue());
 132             assertEquals("getStartTime", 1, trace.getStartTime().getValue());
 133             assertEquals("getEndTime", NB_EVENTS, trace.getEndTime().getValue());
 134
 135         } catch (final URISyntaxException e) {
 136             fail("URISyntaxException");
 137         } catch (final IOException e) {
 138             fail("IOException");
 139         }
 140     }
 141
 142     @Test
 143     public void testStandardConstructorCacheSize() throws TmfTraceException {
 144         try {
 145             final URL location = FileLocator.find(TmfCoreTestPlugin.getDefault().getBundle(), new Path(TEST_TRACE.getFullPath()), null);
 146             File testfile = new File(FileLocator.toFileURL(location).toURI());
 147             TmfTraceStub trace = new TmfTraceStub(testfile.toURI().getPath(), 0);
 148             trace.indexTrace(true);
 149
 150             assertEquals("getType", ITmfEvent.class, trace.getType());
 151             assertNull("getResource", trace.getResource());
 152             assertEquals("getPath", testfile.toURI().getPath(), trace.getPath());
 153             assertEquals("getCacheSize", ITmfTrace.DEFAULT_TRACE_CACHE_SIZE, trace.getCacheSize());
 154             assertEquals("getStreamingInterval", 0, trace.getStreamingInterval());
 155             assertEquals("getName", TEST_TRACE.getPath(), trace.getName());
 156
 157             assertEquals("getNbEvents", NB_EVENTS, trace.getNbEvents());
 158             assertEquals("getRange-start", 1, trace.getTimeRange().getStartTime().getValue());
 159             assertEquals("getRange-end", NB_EVENTS, trace.getTimeRange().getEndTime().getValue());
 160             assertEquals("getStartTime", 1, trace.getStartTime().getValue());
 161             assertEquals("getEndTime", NB_EVENTS, trace.getEndTime().getValue());
 162
 163         } catch (final URISyntaxException e) {
 164             fail("URISyntaxException");
 165         } catch (final IOException e) {
 166             fail("IOException");
 167         }
 168
 169         try {
 170             final URL location = FileLocator.find(TmfCoreTestPlugin.getDefault().getBundle(), new Path(TEST_TRACE.getFullPath()), null);
 171             File testfile = new File(FileLocator.toFileURL(location).toURI());
 172             TmfTraceStub trace = new TmfTraceStub(testfile.toURI().getPath(), BLOCK_SIZE);
 173             trace.indexTrace(true);
 174
 175             assertEquals("getType", ITmfEvent.class, trace.getType());
 176             assertNull("getResource", trace.getResource());
 177             assertEquals("getPath", testfile.toURI().getPath(), trace.getPath());
 178             assertEquals("getCacheSize", BLOCK_SIZE, trace.getCacheSize());
 179             assertEquals("getStreamingInterval", 0, trace.getStreamingInterval());
 180             assertEquals("getName", TEST_TRACE.getPath(), trace.getName());
 181
 182             assertEquals("getNbEvents", NB_EVENTS, trace.getNbEvents());
 183             assertEquals("getRange-start", 1, trace.getTimeRange().getStartTime().getValue());
 184             assertEquals("getRange-end", NB_EVENTS, trace.getTimeRange().getEndTime().getValue());
 185             assertEquals("getStartTime", 1, trace.getStartTime().getValue());
 186             assertEquals("getEndTime", NB_EVENTS, trace.getEndTime().getValue());
 187
 188         } catch (final URISyntaxException e) {
 189             fail("URISyntaxException");
 190         } catch (final IOException e) {
 191             fail("IOException");
 192         }
 193     }
 194
 195     @Test
 196     public void testFullConstructor() throws TmfTraceException {
 197         try {
 198             final URL location = FileLocator.find(TmfCoreTestPlugin.getDefault().getBundle(), new Path(TEST_TRACE.getFullPath()), null);
 199             File testfile = new File(FileLocator.toFileURL(location).toURI());
 200             TmfTraceStub trace = new TmfTraceStub(testfile.toURI().getPath(), BLOCK_SIZE, null);
 201             trace.indexTrace(true);
 202
 203             assertEquals("getType", ITmfEvent.class, trace.getType());
 204             assertNull("getResource", trace.getResource());
 205             assertEquals("getPath", testfile.toURI().getPath(), trace.getPath());
 206             assertEquals("getCacheSize", BLOCK_SIZE, trace.getCacheSize());
 207             assertEquals("getStreamingInterval", 0, trace.getStreamingInterval());
 208             assertEquals("getName", TEST_TRACE.getPath(), trace.getName());
 209
 210             assertEquals("getNbEvents", NB_EVENTS, trace.getNbEvents());
 211             assertEquals("getRange-start", 1, trace.getTimeRange().getStartTime().getValue());
 212             assertEquals("getRange-end", NB_EVENTS, trace.getTimeRange().getEndTime().getValue());
 213             assertEquals("getStartTime", 1, trace.getStartTime().getValue());
 214             assertEquals("getEndTime", NB_EVENTS, trace.getEndTime().getValue());
 215
 216         } catch (final URISyntaxException e) {
 217             fail("URISyntaxException");
 218         } catch (final IOException e) {
 219             fail("IOException");
 220         }
 221     }
 222
 223     @Test
 224     public void testLiveTraceConstructor() throws TmfTraceException {
 225         final long interval = 100;
 226         try {
 227             final URL location = FileLocator.find(TmfCoreTestPlugin.getDefault().getBundle(), new Path(TEST_TRACE.getFullPath()), null);
 228             File testfile = new File(FileLocator.toFileURL(location).toURI());
 229             TmfTraceStub trace = new TmfTraceStub(testfile.toURI().getPath(), BLOCK_SIZE, interval);
 230             trace.indexTrace(true);
 231
 232             assertEquals("getType", ITmfEvent.class, trace.getType());
 233             assertNull("getResource", trace.getResource());
 234             assertEquals("getPath", testfile.toURI().getPath(), trace.getPath());
 235             assertEquals("getCacheSize", BLOCK_SIZE, trace.getCacheSize());
 236             assertEquals("getStreamingInterval", interval, trace.getStreamingInterval());
 237             assertEquals("getName", TEST_TRACE.getPath(), trace.getName());
 238
 239             assertEquals("getNbEvents", NB_EVENTS, trace.getNbEvents());
 240             assertEquals("getRange-start", 1, trace.getTimeRange().getStartTime().getValue());
 241             assertEquals("getRange-end", NB_EVENTS, trace.getTimeRange().getEndTime().getValue());
 242             assertEquals("getStartTime", 1, trace.getStartTime().getValue());
 243             assertEquals("getEndTime", NB_EVENTS, trace.getEndTime().getValue());
 244
 245         } catch (final URISyntaxException e) {
 246             fail("URISyntaxException");
 247         } catch (final IOException e) {
 248             fail("IOException");
 249         }
 250     }
 251
 252     @Test
 253     public void testCopyConstructor() throws TmfTraceException {
 254         try {
 255             final URL location = FileLocator.find(TmfCoreTestPlugin.getDefault().getBundle(), new Path(TEST_TRACE.getFullPath()), null);
 256             File testfile = new File(FileLocator.toFileURL(location).toURI());
 257             TmfTraceStub original = new TmfTraceStub(testfile.toURI().getPath(), BLOCK_SIZE, new TmfCheckpointIndexer(null));
 258             TmfTraceStub trace = new TmfTraceStub(original);
 259             trace.indexTrace(true);
 260
 261             assertEquals("getType", ITmfEvent.class, trace.getType());
 262             assertNull("getResource", trace.getResource());
 263             assertEquals("getPath", testfile.toURI().getPath(), trace.getPath());
 264             assertEquals("getCacheSize", BLOCK_SIZE, trace.getCacheSize());
 265             assertEquals("getStreamingInterval", 0, trace.getStreamingInterval());
 266             assertEquals("getName", TEST_TRACE.getPath(), trace.getName());
 267
 268             assertEquals("getNbEvents", NB_EVENTS, trace.getNbEvents());
 269             assertEquals("getRange-start", 1, trace.getTimeRange().getStartTime().getValue());
 270             assertEquals("getRange-end", NB_EVENTS, trace.getTimeRange().getEndTime().getValue());
 271             assertEquals("getStartTime", 1, trace.getStartTime().getValue());
 272             assertEquals("getEndTime", NB_EVENTS, trace.getEndTime().getValue());
 273
 274         } catch (final URISyntaxException e) {
 275             fail("URISyntaxException");
 276         } catch (final IOException e) {
 277             fail("IOException");
 278         }
 279
 280         // Test the copy of a null trace
 281         try {
 282             new TmfTraceStub((TmfTraceStub) null);
 283             fail("Missing exception");
 284         } catch (final IllegalArgumentException e) {
 285             // test passed
 286         } catch (final Exception e) {
 287             fail("Unexpected exception");
 288         }
 289     }
 290
 291     // ------------------------------------------------------------------------
 292     // Trace initialization
 293     // ------------------------------------------------------------------------
 294
 295     @Test
 296     public void testInitializeNullPath() {
 297         // Instantiate an "empty" trace
 298         final TmfTraceStub trace = new TmfTraceStub();
 299
 300         try {
 301             trace.initialize(null, null, ITmfEvent.class);
 302             fail("TmfTrace.initialize() - no exception thrown");
 303         } catch (TmfTraceException e) {
 304             // Success
 305         } catch (Exception e) {
 306             fail("TmfTrace.initialize() - wrong exception thrown");
 307         }
 308     }
 309
 310     @Test
 311     public void testInitializeSimplePath() {
 312         // Instantiate an "empty" trace
 313         final TmfTraceStub trace = new TmfTraceStub();
 314
 315         // Path == trace name
 316         String path = "TraceName";
 317         try {
 318             trace.initialize(null, path, ITmfEvent.class);
 319         } catch (Exception e) {
 320             fail("TmfTrace.initialize() - Exception thrown");
 321         }
 322
 323         assertEquals("getType", ITmfEvent.class, trace.getType());
 324         assertNull  ("getResource", trace.getResource());
 325         assertEquals("getPath", path, trace.getPath());
 326         assertEquals("getCacheSize", ITmfTrace.DEFAULT_TRACE_CACHE_SIZE, trace.getCacheSize());
 327         assertEquals("getStreamingInterval", 0, trace.getStreamingInterval());
 328         assertEquals("getName", path, trace.getName());
 329
 330         assertEquals("getNbEvents",    0, trace.getNbEvents());
 331         assertEquals("getRange-start", Long.MIN_VALUE, trace.getTimeRange().getStartTime().getValue());
 332         assertEquals("getRange-end",   Long.MIN_VALUE, trace.getTimeRange().getEndTime().getValue());
 333         assertEquals("getStartTime",   Long.MIN_VALUE, trace.getStartTime().getValue());
 334         assertEquals("getEndTime",     Long.MIN_VALUE, trace.getEndTime().getValue());
 335     }
 336
 337     @Test
 338     public void testInitializeNormalPath() {
 339         // Instantiate an "empty" trace
 340         final TmfTraceStub trace = new TmfTraceStub();
 341
 342         // Path == trace name
 343         String name = "TraceName";
 344         String path = "/my/trace/path/" + name;
 345         try {
 346             trace.initialize(null, path, ITmfEvent.class);
 347         } catch (Exception e) {
 348             fail("TmfTrace.initialize() - Exception thrown");
 349         }
 350
 351         assertEquals("getType", ITmfEvent.class, trace.getType());
 352         assertNull  ("getResource", trace.getResource());
 353         assertEquals("getPath", path, trace.getPath());
 354         assertEquals("getCacheSize", ITmfTrace.DEFAULT_TRACE_CACHE_SIZE, trace.getCacheSize());
 355         assertEquals("getStreamingInterval", 0, trace.getStreamingInterval());
 356         assertEquals("getName", name, trace.getName());
 357
 358         assertEquals("getNbEvents",    0, trace.getNbEvents());
 359         assertEquals("getRange-start", Long.MIN_VALUE, trace.getTimeRange().getStartTime().getValue());
 360         assertEquals("getRange-end",   Long.MIN_VALUE, trace.getTimeRange().getEndTime().getValue());
 361         assertEquals("getStartTime",   Long.MIN_VALUE, trace.getStartTime().getValue());
 362         assertEquals("getEndTime",     Long.MIN_VALUE, trace.getEndTime().getValue());
 363     }
 364
 365     @Test
 366     public void testInitTrace() throws URISyntaxException, IOException, TmfTraceException, InterruptedException {
 367         // Instantiate an "empty" trace
 368         final TmfTraceStub trace = new TmfTraceStub();
 369
 370         assertNull  ("getType",  trace.getType());
 371         assertNull  ("getResource", trace.getResource());
 372         assertEquals("getCacheSize", ITmfTrace.DEFAULT_TRACE_CACHE_SIZE, trace.getCacheSize());
 373         assertEquals("getStreamingInterval", 0, trace.getStreamingInterval());
 374         assertEquals("getName", "", trace.getName());
 375
 376         assertEquals("getNbEvents",    0, trace.getNbEvents());
 377         assertEquals("getRange-start", Long.MIN_VALUE, trace.getTimeRange().getStartTime().getValue());
 378         assertEquals("getRange-end",   Long.MIN_VALUE, trace.getTimeRange().getEndTime().getValue());
 379         assertEquals("getStartTime",   Long.MIN_VALUE, trace.getStartTime().getValue());
 380         assertEquals("getEndTime",     Long.MIN_VALUE, trace.getEndTime().getValue());
 381
 382         // Validate
 383         final URL location = FileLocator.find(TmfCoreTestPlugin.getDefault().getBundle(), new Path(TEST_TRACE.getFullPath()), null);
 384         final File testfile = new File(FileLocator.toFileURL(location).toURI());
 385         assertTrue("validate", trace.validate(null, testfile.getPath()).isOK());
 386
 387         // InitTrace and wait for indexing completion...
 388         trace.initTrace(null, testfile.toURI().getPath(), ITmfEvent.class);
 389         trace.indexTrace(true);
 390         int nbSecs = 0;
 391         while (trace.getNbEvents() < NB_EVENTS && nbSecs < 10) {
 392             Thread.sleep(1000);
 393             nbSecs++;
 394         }
 395         if (trace.getNbEvents() < NB_EVENTS) {
 396             fail("indexing");
 397         }
 398
 399         assertEquals("getType", ITmfEvent.class, trace.getType());
 400         assertNull  ("getResource", trace.getResource());
 401         assertEquals("getCacheSize", ITmfTrace.DEFAULT_TRACE_CACHE_SIZE, trace.getCacheSize());
 402         assertEquals("getStreamingInterval", 0, trace.getStreamingInterval());
 403         assertEquals("getName", TEST_TRACE.getPath(), trace.getName());
 404
 405         assertEquals("getNbEvents",    NB_EVENTS, trace.getNbEvents());
 406         assertEquals("getRange-start", 1,         trace.getTimeRange().getStartTime().getValue());
 407         assertEquals("getRange-end",   NB_EVENTS, trace.getTimeRange().getEndTime().getValue());
 408         assertEquals("getStartTime",   1,         trace.getStartTime().getValue());
 409         assertEquals("getEndTime",     NB_EVENTS, trace.getEndTime().getValue());
 410     }
 411
 412     // ------------------------------------------------------------------------
 413     // Set/Get streaming interval
 414     // ------------------------------------------------------------------------
 415
 416     @Test
 417     public void testSetStreamingInterval() throws TmfTraceException {
 418         final TmfTraceStub trace = new TmfTraceStub(fTrace);
 419
 420         long interval = 0;
 421         assertEquals("getStreamingInterval", interval, trace.getStreamingInterval());
 422
 423         interval = 100;
 424         trace.setStreamingInterval(interval);
 425         assertEquals("getStreamingInterval", interval, trace.getStreamingInterval());
 426
 427         interval = -1;
 428         trace.setStreamingInterval(interval);
 429         assertEquals("getStreamingInterval", 0, trace.getStreamingInterval());
 430
 431         interval = 0;
 432         trace.setStreamingInterval(interval);
 433         assertEquals("getStreamingInterval", interval, trace.getStreamingInterval());
 434
 435         trace.dispose();
 436     }
 437
 438     // ------------------------------------------------------------------------
 439     // Set/Get time range
 440     // ------------------------------------------------------------------------
 441
 442     @Test
 443     public void testSetTimeRange() throws TmfTraceException {
 444         final TmfTraceStub trace = new TmfTraceStub(fTrace);
 445         trace.indexTrace(true);
 446
 447         assertEquals("getRange-start", 1,         trace.getTimeRange().getStartTime().getValue());
 448         assertEquals("getRange-end",   NB_EVENTS, trace.getTimeRange().getEndTime().getValue());
 449         assertEquals("getStartTime",   1,         trace.getStartTime().getValue());
 450         assertEquals("getEndTime",     NB_EVENTS, trace.getEndTime().getValue());
 451
 452         trace.setTimeRange(new TmfTimeRange(new TmfTimestamp(100), new TmfTimestamp(200)));
 453         assertEquals("setTimeRange",   100, trace.getTimeRange().getStartTime().getValue());
 454         assertEquals("setTimeRange",   200, trace.getTimeRange().getEndTime().getValue());
 455         assertEquals("setTimeRange",   100, trace.getStartTime().getValue());
 456         assertEquals("setTimeRange",   200, trace.getEndTime().getValue());
 457
 458         trace.dispose();
 459     }
 460
 461     @Test
 462     public void testSetStartTime() throws TmfTraceException {
 463         final TmfTraceStub trace = new TmfTraceStub(fTrace);
 464         trace.indexTrace(true);
 465
 466         assertEquals("getRange-start", 1,         trace.getTimeRange().getStartTime().getValue());
 467         assertEquals("getRange-end",   NB_EVENTS, trace.getTimeRange().getEndTime().getValue());
 468         assertEquals("getStartTime",   1,         trace.getStartTime().getValue());
 469         assertEquals("getEndTime",     NB_EVENTS, trace.getEndTime().getValue());
 470
 471         trace.setStartTime(new TmfTimestamp(100));
 472         assertEquals("setStartTime",   100,       trace.getTimeRange().getStartTime().getValue());
 473         assertEquals("setStartTime",   NB_EVENTS, trace.getTimeRange().getEndTime().getValue());
 474         assertEquals("setStartTime",   100,       trace.getStartTime().getValue());
 475         assertEquals("setStartTime",   NB_EVENTS, trace.getEndTime().getValue());
 476
 477         trace.dispose();
 478     }
 479
 480     @Test
 481     public void testSetEndTime() throws TmfTraceException {
 482         final TmfTraceStub trace = new TmfTraceStub(fTrace);
 483         trace.indexTrace(true);
 484
 485         assertEquals("getRange-start", 1,         trace.getTimeRange().getStartTime().getValue());
 486         assertEquals("getRange-end",   NB_EVENTS, trace.getTimeRange().getEndTime().getValue());
 487         assertEquals("getStartTime",   1,         trace.getStartTime().getValue());
 488         assertEquals("getEndTime",     NB_EVENTS, trace.getEndTime().getValue());
 489
 490         trace.setEndTime(new TmfTimestamp(100));
 491         assertEquals("setEndTime",     1,   trace.getTimeRange().getStartTime().getValue());
 492         assertEquals("setEndTime",     100, trace.getTimeRange().getEndTime().getValue());
 493         assertEquals("setEndTime",     1,   trace.getStartTime().getValue());
 494         assertEquals("setEndTime",     100, trace.getEndTime().getValue());
 495
 496         trace.dispose();
 497     }
 498
 499     @Test
 500     public void testSetNbEvents() throws TmfTraceException {
 501         final TmfTraceStub trace = new TmfTraceStub(fTrace);
 502         trace.indexTrace(true);
 503
 504         assertEquals("getNbEvents", NB_EVENTS, trace.getNbEvents());
 505
 506         trace.setNbEvents(0);
 507         assertEquals("getNbEvents", 0, trace.getNbEvents());
 508
 509         trace.setNbEvents(-1);
 510         assertEquals("getNbEvents", 0, trace.getNbEvents());
 511
 512         trace.setNbEvents(NB_EVENTS + 1);
 513         assertEquals("getNbEvents", NB_EVENTS + 1, trace.getNbEvents());
 514
 515         trace.setNbEvents(NB_EVENTS);
 516         assertEquals("getNbEvents", NB_EVENTS, trace.getNbEvents());
 517
 518         trace.dispose();
 519     }
 520
 521     // ------------------------------------------------------------------------
 522     // State system and statistics methods
 523     // ------------------------------------------------------------------------
 524
 525     @Test
 526     public void testGetStatistics() {
 527         /* Should be null in unit tests */
 528         ITmfStatistics stats = fTrace.getStatistics();
 529         assertNull(stats);
 530     }
 531
 532     @Test
 533     public void testGetStateSystem() {
 534         /* There should be no state system registered so far */
 535         ITmfStateSystem ss = fTrace.getStateSystems().get("something");
 536         assertNull(ss);
 537     }
 538
 539     /**
 540      * Make sure the returned map is unmodifiable.
 541      */
 542     @Test(expected=UnsupportedOperationException.class)
 543     public void testGetStateSystem_readOnly() {
 544         Map<String, ITmfStateSystem> sss = fTrace.getStateSystems();
 545         sss.put("something", null);
 546     }
 547
 548     // ------------------------------------------------------------------------
 549     // seekEvent on location (note: does not reliably set the rank)
 550     // ------------------------------------------------------------------------
 551
 552     @Test
 553     public void testSeekEventOnCacheBoundary() {
 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     @Test
 599     public void testSeekEventNotOnCacheBoundary() {
 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     @Test
 654     public void testSeekEventOutOfScope() {
 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     @Test
 682     public void testSeekEventOnNullTimestamp() {
 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     @Test
 693     public void testSeekEventOnTimestampOnCacheBoundary() {
 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     @Test
 732     public void testSeekEventOnTimestampNotOnCacheBoundary() {
 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     @Test
 795     public void testSeekEventOnTimestampOutOfScope() {
 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     @Test
 826     public void testSeekEventOnNegativeRank() {
 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     @Test
 837     public void testSeekOnRankOnCacheBoundary() {
 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     @Test
 876     public void testSeekOnRankNotOnCacheBoundary() {
 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     @Test
 927     public void testSeekEventOnRankOutOfScope() {
 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     @Test
 958     public void testParseEvent() {
 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     @Test
1003     public void testGetNextAfteSeekingOnTS_1() {
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     @Test
1025     public void testGetNextAfteSeekingOnTS_2() {
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     @Test
1047     public void testGetNextAfteSeekingOnTS_3() {
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     @Test
1069     public void testGetNextAfterSeekingOnRank_1() {
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     @Test
1091     public void testGetNextAfterSeekingOnRank_2() {
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     @Test
1113     public void testGetNextAfterSeekingOnRank_3() {
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     @Test
1135     public void testGetNextAfterSeekingOnLocation_1() {
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     @Test
1158     public void testGetNextAfterSeekingOnLocation_2() {
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     @Test
1179     public void testGetNextAfterSeekingOnLocation_3() {
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     @Test
1200     public void testGetNextLocation() {
1201         ITmfContext context1 = fTrace.seekEvent(0);
1202         fTrace.getNext(context1);
1203         ITmfLocation location = context1.getLocation();
1204         ITmfEvent event1 = fTrace.getNext(context1);
1205         ITmfContext context2 = fTrace.seekEvent(location);
1206         ITmfEvent event2 = fTrace.getNext(context2);
1207         assertEquals("Event timestamp", event1.getTimestamp().getValue(), event2.getTimestamp().getValue());
1208     }
1209
1210     @Test
1211     public void testGetNextEndLocation() {
1212         ITmfContext context1 = fTrace.seekEvent(fTrace.getNbEvents() - 1);
1213         fTrace.getNext(context1);
1214         ITmfLocation location = context1.getLocation();
1215         ITmfContext context2 = fTrace.seekEvent(location);
1216         ITmfEvent event = fTrace.getNext(context2);
1217         assertNull("Event", event);
1218     }
1219
1220     // ------------------------------------------------------------------------
1221     // processRequest
1222     // ------------------------------------------------------------------------
1223
1224     @Test
1225     public void testProcessEventRequestForAllEvents() throws InterruptedException {
1226         final int blockSize = 1;
1227         final Vector<ITmfEvent> requestedEvents = new Vector<ITmfEvent>();
1228
1229         final TmfTimeRange range = new TmfTimeRange(TmfTimestamp.BIG_BANG, TmfTimestamp.BIG_CRUNCH);
1230         final TmfEventRequest request = new TmfEventRequest(ITmfEvent.class, range, NB_EVENTS, blockSize) {
1231             @Override
1232             public void handleData(final ITmfEvent event) {
1233                 super.handleData(event);
1234                 requestedEvents.add(event);
1235             }
1236         };
1237         final ITmfDataProvider[] providers = TmfProviderManager.getProviders(ITmfEvent.class, TmfTraceStub.class);
1238         providers[0].sendRequest(request);
1239         request.waitForCompletion();
1240
1241         assertEquals("nbEvents", NB_EVENTS, requestedEvents.size());
1242         assertTrue("isCompleted",  request.isCompleted());
1243         assertFalse("isCancelled", request.isCancelled());
1244
1245         // Ensure that we have distinct events.
1246         // Don't go overboard: we are not validating the stub!
1247         for (int i = 0; i < NB_EVENTS; i++) {
1248             assertEquals("Distinct events", i + 1, requestedEvents.get(i).getTimestamp().getValue());
1249         }
1250     }
1251
1252     @Test
1253     public void testProcessEventRequestForNbEvents() throws InterruptedException {
1254         final int blockSize = 100;
1255         final int nbEvents  = 1000;
1256         final Vector<ITmfEvent> requestedEvents = new Vector<ITmfEvent>();
1257
1258         final TmfTimeRange range = new TmfTimeRange(TmfTimestamp.BIG_BANG, TmfTimestamp.BIG_CRUNCH);
1259         final TmfEventRequest request = new TmfEventRequest(ITmfEvent.class, range, nbEvents, blockSize) {
1260             @Override
1261             public void handleData(final ITmfEvent event) {
1262                 super.handleData(event);
1263                 requestedEvents.add(event);
1264             }
1265         };
1266         final ITmfDataProvider[] providers = TmfProviderManager.getProviders(ITmfEvent.class, TmfTraceStub.class);
1267         providers[0].sendRequest(request);
1268         request.waitForCompletion();
1269
1270         assertEquals("nbEvents", nbEvents, requestedEvents.size());
1271         assertTrue("isCompleted",  request.isCompleted());
1272         assertFalse("isCancelled", request.isCancelled());
1273
1274         // Ensure that we have distinct events.
1275         // Don't go overboard: we are not validating the stub!
1276         for (int i = 0; i < nbEvents; i++) {
1277             assertEquals("Distinct events", i + 1, requestedEvents.get(i).getTimestamp().getValue());
1278         }
1279     }
1280
1281     @Test
1282     public void testProcessEventRequestForSomeEvents() throws InterruptedException {
1283         final int blockSize = 1;
1284         final long startTime = 100;
1285         final int nbEvents  = 1000;
1286         final Vector<ITmfEvent> requestedEvents = new Vector<ITmfEvent>();
1287
1288         final TmfTimeRange range = new TmfTimeRange(new TmfTimestamp(startTime, SCALE), TmfTimestamp.BIG_CRUNCH);
1289         final TmfEventRequest request = new TmfEventRequest(ITmfEvent.class, range, nbEvents, blockSize) {
1290             @Override
1291             public void handleData(final ITmfEvent event) {
1292                 super.handleData(event);
1293                 requestedEvents.add(event);
1294             }
1295         };
1296         final ITmfDataProvider[] providers = TmfProviderManager.getProviders(ITmfEvent.class, TmfTraceStub.class);
1297         providers[0].sendRequest(request);
1298         request.waitForCompletion();
1299
1300         assertEquals("nbEvents", nbEvents, requestedEvents.size());
1301         assertTrue("isCompleted",  request.isCompleted());
1302         assertFalse("isCancelled", request.isCancelled());
1303
1304         // Ensure that we have distinct events.
1305         // Don't go overboard: we are not validating the stub!
1306         for (int i = 0; i < nbEvents; i++) {
1307             assertEquals("Distinct events", startTime + i, requestedEvents.get(i).getTimestamp().getValue());
1308         }
1309     }
1310
1311     @Test
1312     public void testProcessEventRequestForOtherEvents() throws InterruptedException {
1313         final int blockSize =  1;
1314         final int startIndex = 99;
1315         final long startTime = 100;
1316         final int nbEvents  = 1000;
1317         final Vector<ITmfEvent> requestedEvents = new Vector<ITmfEvent>();
1318
1319         final TmfTimeRange range = new TmfTimeRange(new TmfTimestamp(startTime, SCALE), TmfTimestamp.BIG_CRUNCH);
1320         final TmfEventRequest request = new TmfEventRequest(ITmfEvent.class, range, startIndex, nbEvents, blockSize) {
1321             @Override
1322             public void handleData(final ITmfEvent event) {
1323                 super.handleData(event);
1324                 requestedEvents.add(event);
1325             }
1326         };
1327         final ITmfDataProvider[] providers = TmfProviderManager.getProviders(ITmfEvent.class, TmfTraceStub.class);
1328         providers[0].sendRequest(request);
1329         request.waitForCompletion();
1330
1331         assertEquals("nbEvents", nbEvents, requestedEvents.size());
1332         assertTrue("isCompleted",  request.isCompleted());
1333         assertFalse("isCancelled", request.isCancelled());
1334
1335         // Ensure that we have distinct events.
1336         // Don't go overboard: we are not validating the stub!
1337         for (int i = 0; i < nbEvents; i++) {
1338             assertEquals("Distinct events", startTime + i, requestedEvents.get(i).getTimestamp().getValue());
1339         }
1340     }
1341
1342     @Test
1343     public void testProcessDataRequestForSomeEvents() throws InterruptedException {
1344         final int startIndex = 100;
1345         final int nbEvents  = 1000;
1346         final Vector<ITmfEvent> requestedEvents = new Vector<ITmfEvent>();
1347
1348         final TmfDataRequest request = new TmfDataRequest(ITmfEvent.class, startIndex, nbEvents) {
1349             @Override
1350             public void handleData(final ITmfEvent event) {
1351                 super.handleData(event);
1352                 requestedEvents.add(event);
1353             }
1354         };
1355         final ITmfDataProvider[] providers = TmfProviderManager.getProviders(ITmfEvent.class, TmfTraceStub.class);
1356         providers[0].sendRequest(request);
1357         request.waitForCompletion();
1358
1359         assertEquals("nbEvents", nbEvents, requestedEvents.size());
1360         assertTrue("isCompleted",  request.isCompleted());
1361         assertFalse("isCancelled", request.isCancelled());
1362
1363         // Ensure that we have distinct events.
1364         // Don't go overboard: we are not validating the stub!
1365         for (int i = 0; i < nbEvents; i++) {
1366             assertEquals("Distinct events", startIndex + 1 + i, requestedEvents.get(i).getTimestamp().getValue());
1367         }
1368     }
1369
1370     // ------------------------------------------------------------------------
1371     // cancel
1372     // ------------------------------------------------------------------------
1373
1374     @Test
1375     public void testCancel() throws InterruptedException {
1376         final Vector<ITmfEvent> requestedEvents = new Vector<ITmfEvent>();
1377
1378         final TmfTimeRange range = new TmfTimeRange(TmfTimestamp.BIG_BANG, TmfTimestamp.BIG_CRUNCH);
1379         final TmfEventRequest request = new TmfEventRequest(ITmfEvent.class, range, NB_EVENTS, BLOCK_SIZE) {
1380             int nbRead = 0;
1381             @Override
1382             public void handleData(final ITmfEvent event) {
1383                 super.handleData(event);
1384                 requestedEvents.add(event);
1385                 if (++nbRead == BLOCK_SIZE) {
1386                     cancel();
1387                 }
1388             }
1389         };
1390         final ITmfDataProvider[] providers = TmfProviderManager.getProviders(ITmfEvent.class, TmfTraceStub.class);
1391         providers[0].sendRequest(request);
1392         request.waitForCompletion();
1393
1394         assertEquals("nbEvents",  BLOCK_SIZE, requestedEvents.size());
1395         assertTrue("isCompleted", request.isCompleted());
1396         assertTrue("isCancelled", request.isCancelled());
1397     }
1398
1399     // ------------------------------------------------------------------------
1400     // toString
1401     // ------------------------------------------------------------------------
1402
1403     @Test
1404     public void testDefaultTmfTraceStub() {
1405         assertFalse ("Open trace", fTrace == null);
1406         assertEquals("getType",  ITmfEvent.class, fTrace.getType());
1407         assertNull  ("getResource", fTrace.getResource());
1408         assertEquals("getCacheSize", BLOCK_SIZE, fTrace.getCacheSize());
1409         assertEquals("getStreamingInterval", 0, fTrace.getStreamingInterval());
1410         assertEquals("getName", TEST_TRACE.getPath(), fTrace.getName());
1411
1412         assertEquals("getNbEvents",    NB_EVENTS, fTrace.getNbEvents());
1413         assertEquals("getRange-start", 1,         fTrace.getTimeRange().getStartTime().getValue());
1414         assertEquals("getRange-end",   NB_EVENTS, fTrace.getTimeRange().getEndTime().getValue());
1415         assertEquals("getStartTime",   1,         fTrace.getStartTime().getValue());
1416         assertEquals("getEndTime",     NB_EVENTS, fTrace.getEndTime().getValue());
1417
1418         String expected = "TmfTrace [fPath=" + fTrace.getPath() + ", fCacheSize=" + fTrace.getCacheSize() +
1419                 ", fNbEvents=" + fTrace.getNbEvents() + ", fStartTime=" + fTrace.getStartTime() +
1420                 ", fEndTime=" + fTrace.getEndTime() + ", fStreamingInterval=" + fTrace.getStreamingInterval() +
1421                 "]";
1422         assertEquals("toString", expected, fTrace.toString());
1423     }
1424
1425     // ------------------------------------------------------------------------
1426     // getInitialRangeOffset, getCurrentRange, getCurrentTime
1427     // ------------------------------------------------------------------------
1428
1429     @Test
1430     public void testCurrentTimeValues() throws TmfTraceException {
1431
1432         TmfTraceStub trace = null;
1433         File testfile = null;
1434         try {
1435             final URL location = FileLocator.find(TmfCoreTestPlugin.getDefault().getBundle(), new Path(TEST_TRACE.getFullPath()), null);
1436             testfile = new File(FileLocator.toFileURL(location).toURI());
1437             trace = new TmfTraceStub(testfile.toURI().getPath());
1438             // verify initial values
1439             TmfTimestamp defaultInitRange = new TmfTimestamp(DEFAULT_INITIAL_OFFSET_VALUE, ITmfTimestamp.NANOSECOND_SCALE);
1440             assertEquals("getInitialRangeOffset", defaultInitRange, trace.getInitialRangeOffset());
1441             trace.setInitialRangeOffset(new TmfTimestamp(5, ITmfTimestamp.MILLISECOND_SCALE));
1442             trace.indexTrace(true);
1443         } catch (final URISyntaxException e) {
1444             fail("URISyntaxException");
1445         } catch (final IOException e) {
1446             fail("IOException");
1447         }
1448         assertFalse ("Open trace", trace == null);
1449
1450         TmfTimestamp initRange = new TmfTimestamp(5, ITmfTimestamp.MILLISECOND_SCALE);
1451         assertEquals("getInitialRangeOffset", initRange, trace.getInitialRangeOffset());
1452     }
1453 }