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.Vector;
  21
  22 import junit.framework.TestCase;
  23
  24 import org.eclipse.core.runtime.FileLocator;
  25 import org.eclipse.core.runtime.Path;
  26 import org.eclipse.linuxtools.tmf.core.component.ITmfDataProvider;
  27 import org.eclipse.linuxtools.tmf.core.component.TmfProviderManager;
  28 import org.eclipse.linuxtools.tmf.core.event.ITmfEvent;
  29 import org.eclipse.linuxtools.tmf.core.event.ITmfTimestamp;
  30 import org.eclipse.linuxtools.tmf.core.event.TmfEvent;
  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.tests.TmfCoreTestPlugin;
  37 import org.eclipse.linuxtools.tmf.core.trace.ITmfContext;
  38 import org.eclipse.linuxtools.tmf.core.trace.ITmfTrace;
  39 import org.eclipse.linuxtools.tmf.core.trace.TmfCheckpointIndexer;
  40 import org.eclipse.linuxtools.tmf.core.trace.TmfContext;
  41 import org.eclipse.linuxtools.tmf.tests.stubs.trace.TmfTraceStub;
  42
  43 /**
  44  * Test suite for the TmfTrace class.
  45  */
  46 @SuppressWarnings("nls")
  47 public class TmfTraceTest extends TestCase {
  48
  49     // ------------------------------------------------------------------------
  50     // Variables
  51     // ------------------------------------------------------------------------
  52
  53     private static final String DIRECTORY   = "testfiles";
  54     private static final String TEST_STREAM = "A-Test-10K";
  55     private static final int    BLOCK_SIZE  = 500;
  56     private static final int    NB_EVENTS   = 10000;
  57     private static TmfTraceStub fTrace      = null;
  58
  59     private static int SCALE = -3;
  60
  61     // ------------------------------------------------------------------------
  62     // Housekeeping
  63     // ------------------------------------------------------------------------
  64
  65     public TmfTraceTest(final String name) throws Exception {
  66         super(name);
  67     }
  68
  69     @Override
  70     protected void setUp() throws Exception {
  71         super.setUp();
  72         fTrace = setupTrace(DIRECTORY + File.separator + TEST_STREAM);
  73     }
  74
  75     @Override
  76     protected void tearDown() throws Exception {
  77         super.tearDown();
  78         fTrace.dispose();
  79         fTrace = null;
  80     }
  81
  82     // ------------------------------------------------------------------------
  83     // Helper functions
  84     // ------------------------------------------------------------------------
  85
  86     private TmfTraceStub setupTrace(final String path) {
  87         if (fTrace == null) {
  88             try {
  89                 final URL location = FileLocator.find(TmfCoreTestPlugin.getDefault().getBundle(), new Path(path), null);
  90                 final File test = new File(FileLocator.toFileURL(location).toURI());
  91                 fTrace = new TmfTraceStub(test.toURI().getPath(), BLOCK_SIZE);
  92                 fTrace.indexTrace();
  93             } catch (final TmfTraceException e) {
  94                 e.printStackTrace();
  95             } catch (final URISyntaxException e) {
  96                 e.printStackTrace();
  97             } catch (final IOException e) {
  98                 e.printStackTrace();
  99             }
 100         }
 101         return fTrace;
 102     }
 103
 104     // ------------------------------------------------------------------------
 105     // Constructors
 106     // ------------------------------------------------------------------------
 107
 108     public void testStandardConstructor() throws Exception {
 109         TmfTraceStub trace = null;
 110         File testfile = null;
 111         try {
 112             final URL location = FileLocator.find(TmfCoreTestPlugin.getDefault().getBundle(), new Path(DIRECTORY + File.separator + TEST_STREAM), null);
 113             testfile = new File(FileLocator.toFileURL(location).toURI());
 114             trace = new TmfTraceStub(testfile.toURI().getPath());
 115             trace.indexTrace();
 116         } catch (final URISyntaxException e) {
 117             fail("URISyntaxException");
 118         } catch (final IOException e) {
 119             fail("IOException");
 120         }
 121
 122         assertFalse ("Open trace", trace == null);
 123         assertEquals("getType",  TmfEvent.class, trace.getType());
 124         assertNull  ("getResource", trace.getResource());
 125         assertEquals("getPath", testfile.toURI().getPath(), trace.getPath());
 126         assertEquals("getCacheSize", ITmfTrace.DEFAULT_TRACE_CACHE_SIZE, trace.getCacheSize());
 127         assertEquals("getStreamingInterval", 0, trace.getStreamingInterval());
 128         assertEquals("getName", TEST_STREAM, trace.getName());
 129
 130         assertEquals("getNbEvents",    NB_EVENTS, trace.getNbEvents());
 131         assertEquals("getRange-start", 1,         trace.getTimeRange().getStartTime().getValue());
 132         assertEquals("getRange-end",   NB_EVENTS, trace.getTimeRange().getEndTime().getValue());
 133         assertEquals("getStartTime",   1,         trace.getStartTime().getValue());
 134         assertEquals("getEndTime",     NB_EVENTS, trace.getEndTime().getValue());
 135     }
 136
 137     public void testStandardConstructorCacheSize() throws Exception {
 138         TmfTraceStub trace = null;
 139         File testfile = null;
 140         try {
 141             final URL location = FileLocator.find(TmfCoreTestPlugin.getDefault().getBundle(), new Path(DIRECTORY + File.separator + TEST_STREAM), null);
 142             testfile = new File(FileLocator.toFileURL(location).toURI());
 143             trace = new TmfTraceStub(testfile.toURI().getPath(), 0);
 144             trace.indexTrace();
 145         } catch (final URISyntaxException e) {
 146             fail("URISyntaxException");
 147         } catch (final IOException e) {
 148             fail("IOException");
 149         }
 150
 151         assertFalse ("Open trace", trace == null);
 152         assertEquals("getType",  TmfEvent.class, trace.getType());
 153         assertNull  ("getResource", trace.getResource());
 154         assertEquals("getPath", testfile.toURI().getPath(), trace.getPath());
 155         assertEquals("getCacheSize", ITmfTrace.DEFAULT_TRACE_CACHE_SIZE, trace.getCacheSize());
 156         assertEquals("getStreamingInterval", 0, trace.getStreamingInterval());
 157         assertEquals("getName", TEST_STREAM, trace.getName());
 158
 159         assertEquals("getNbEvents",    NB_EVENTS, trace.getNbEvents());
 160         assertEquals("getRange-start", 1,         trace.getTimeRange().getStartTime().getValue());
 161         assertEquals("getRange-end",   NB_EVENTS, trace.getTimeRange().getEndTime().getValue());
 162         assertEquals("getStartTime",   1,         trace.getStartTime().getValue());
 163         assertEquals("getEndTime",     NB_EVENTS, trace.getEndTime().getValue());
 164
 165         try {
 166             final URL location = FileLocator.find(TmfCoreTestPlugin.getDefault().getBundle(), new Path(DIRECTORY + File.separator + TEST_STREAM), null);
 167             testfile = new File(FileLocator.toFileURL(location).toURI());
 168             trace = new TmfTraceStub(testfile.toURI().getPath(), BLOCK_SIZE);
 169             trace.indexTrace();
 170         } catch (final URISyntaxException e) {
 171             fail("URISyntaxException");
 172         } catch (final IOException e) {
 173             fail("IOException");
 174         }
 175
 176         assertFalse ("Open trace", trace == null);
 177         assertEquals("getType",  TmfEvent.class, trace.getType());
 178         assertNull  ("getResource", trace.getResource());
 179         assertEquals("getPath", testfile.toURI().getPath(), trace.getPath());
 180         assertEquals("getCacheSize", BLOCK_SIZE, trace.getCacheSize());
 181         assertEquals("getStreamingInterval", 0, trace.getStreamingInterval());
 182         assertEquals("getName", TEST_STREAM, trace.getName());
 183
 184         assertEquals("getNbEvents",    NB_EVENTS, trace.getNbEvents());
 185         assertEquals("getRange-start", 1,         trace.getTimeRange().getStartTime().getValue());
 186         assertEquals("getRange-end",   NB_EVENTS, trace.getTimeRange().getEndTime().getValue());
 187         assertEquals("getStartTime",   1,         trace.getStartTime().getValue());
 188         assertEquals("getEndTime",     NB_EVENTS, trace.getEndTime().getValue());
 189     }
 190
 191     public void testFullConstructor() throws Exception {
 192         TmfTraceStub trace = null;
 193         File testfile = null;
 194         try {
 195             final URL location = FileLocator.find(TmfCoreTestPlugin.getDefault().getBundle(), new Path(DIRECTORY + File.separator + TEST_STREAM), null);
 196             testfile = new File(FileLocator.toFileURL(location).toURI());
 197             trace = new TmfTraceStub(testfile.toURI().getPath(), BLOCK_SIZE, null);
 198             trace.indexTrace();
 199         } catch (final URISyntaxException e) {
 200             fail("URISyntaxException");
 201         } catch (final IOException e) {
 202             fail("IOException");
 203         }
 204
 205         assertFalse ("Open trace", trace == null);
 206         assertEquals("getType",  TmfEvent.class, trace.getType());
 207         assertNull  ("getResource", trace.getResource());
 208         assertEquals("getPath", testfile.toURI().getPath(), trace.getPath());
 209         assertEquals("getCacheSize", BLOCK_SIZE, trace.getCacheSize());
 210         assertEquals("getStreamingInterval", 0, trace.getStreamingInterval());
 211         assertEquals("getName", TEST_STREAM, trace.getName());
 212
 213         assertEquals("getNbEvents",    NB_EVENTS, trace.getNbEvents());
 214         assertEquals("getRange-start", 1,         trace.getTimeRange().getStartTime().getValue());
 215         assertEquals("getRange-end",   NB_EVENTS, trace.getTimeRange().getEndTime().getValue());
 216         assertEquals("getStartTime",   1,         trace.getStartTime().getValue());
 217         assertEquals("getEndTime",     NB_EVENTS, trace.getEndTime().getValue());
 218     }
 219
 220     public void testLiveTraceConstructor() throws Exception {
 221         TmfTraceStub trace = null;
 222         File testfile = null;
 223         final long interval = 100;
 224         try {
 225             final URL location = FileLocator.find(TmfCoreTestPlugin.getDefault().getBundle(), new Path(DIRECTORY + File.separator + TEST_STREAM), null);
 226             testfile = new File(FileLocator.toFileURL(location).toURI());
 227             trace = new TmfTraceStub(testfile.toURI().getPath(), BLOCK_SIZE, interval);
 228             trace.indexTrace();
 229         } catch (final URISyntaxException e) {
 230             fail("URISyntaxException");
 231         } catch (final IOException e) {
 232             fail("IOException");
 233         }
 234
 235         assertFalse ("Open trace", trace == null);
 236         assertEquals("getType",  TmfEvent.class, trace.getType());
 237         assertNull  ("getResource", trace.getResource());
 238         assertEquals("getPath", testfile.toURI().getPath(), trace.getPath());
 239         assertEquals("getCacheSize", BLOCK_SIZE, trace.getCacheSize());
 240         assertEquals("getStreamingInterval", interval, trace.getStreamingInterval());
 241         assertEquals("getName", TEST_STREAM, trace.getName());
 242
 243         assertEquals("getNbEvents",    NB_EVENTS, trace.getNbEvents());
 244         assertEquals("getRange-start", 1,         trace.getTimeRange().getStartTime().getValue());
 245         assertEquals("getRange-end",   NB_EVENTS, trace.getTimeRange().getEndTime().getValue());
 246         assertEquals("getStartTime",   1,         trace.getStartTime().getValue());
 247         assertEquals("getEndTime",     NB_EVENTS, trace.getEndTime().getValue());
 248     }
 249
 250     @SuppressWarnings({ "rawtypes", "unchecked" })
 251     public void testCopyConstructor() throws Exception {
 252         TmfTraceStub original = null;
 253         TmfTraceStub trace = null;
 254         File testfile = null;
 255         try {
 256             final URL location = FileLocator.find(TmfCoreTestPlugin.getDefault().getBundle(), new Path(DIRECTORY + File.separator + TEST_STREAM), null);
 257             testfile = new File(FileLocator.toFileURL(location).toURI());
 258             original = new TmfTraceStub(testfile.toURI().getPath(), BLOCK_SIZE, new TmfCheckpointIndexer(null));
 259             trace = new TmfTraceStub(original);
 260             trace.indexTrace();
 261         } catch (final URISyntaxException e) {
 262             fail("URISyntaxException");
 263         } catch (final IOException e) {
 264             fail("IOException");
 265         }
 266
 267         assertFalse ("Open trace", trace == null);
 268         assertEquals("getType",  TmfEvent.class, trace.getType());
 269         assertNull  ("getResource", trace.getResource());
 270         assertEquals("getPath", testfile.toURI().getPath(), trace.getPath());
 271         assertEquals("getCacheSize", BLOCK_SIZE, trace.getCacheSize());
 272         assertEquals("getStreamingInterval", 0, trace.getStreamingInterval());
 273         assertEquals("getName", TEST_STREAM, trace.getName());
 274
 275         assertEquals("getNbEvents",    NB_EVENTS, trace.getNbEvents());
 276         assertEquals("getRange-start", 1,         trace.getTimeRange().getStartTime().getValue());
 277         assertEquals("getRange-end",   NB_EVENTS, trace.getTimeRange().getEndTime().getValue());
 278         assertEquals("getStartTime",   1,         trace.getStartTime().getValue());
 279         assertEquals("getEndTime",     NB_EVENTS, trace.getEndTime().getValue());
 280
 281         // Test the copy of a null trace
 282         try {
 283             new TmfTraceStub((TmfTraceStub) null);
 284             fail("Missing exception");
 285         } catch (final IllegalArgumentException e) {
 286             // test passed
 287         } catch (final Exception e) {
 288             fail("Unexpected exception");
 289         }
 290     }
 291
 292     // ------------------------------------------------------------------------
 293     // Trace initialization
 294     // ------------------------------------------------------------------------
 295
 296     public void testInitializeNullPath() throws Exception {
 297
 298         // Instantiate an "empty" trace
 299         final TmfTraceStub trace = new TmfTraceStub();
 300
 301         try {
 302             trace.initialize(null, null, TmfEvent.class);
 303             fail("TmfTrace.initialize() - no exception thrown");
 304         } catch (TmfTraceException e) {
 305             // Success
 306         } catch (Exception e) {
 307             fail("TmfTrace.initialize() - wrong exception thrown");
 308         }
 309     }
 310
 311     public void testInitializeSimplePath() throws Exception {
 312
 313         // Instantiate an "empty" trace
 314         final TmfTraceStub trace = new TmfTraceStub();
 315
 316         // Path == trace name
 317         String path = "TraceName";
 318         try {
 319             trace.initialize(null, path, TmfEvent.class);
 320         } catch (Exception e) {
 321             fail("TmfTrace.initialize() - Exception thrown");
 322         }
 323
 324         assertFalse ("Open trace", trace == null);
 325         assertEquals("getType", TmfEvent.class, trace.getType());
 326         assertNull  ("getResource", trace.getResource());
 327         assertEquals("getPath", path, trace.getPath());
 328         assertEquals("getCacheSize", ITmfTrace.DEFAULT_TRACE_CACHE_SIZE, trace.getCacheSize());
 329         assertEquals("getStreamingInterval", 0, trace.getStreamingInterval());
 330         assertEquals("getName", path, trace.getName());
 331
 332         assertEquals("getNbEvents",    0, trace.getNbEvents());
 333         assertEquals("getRange-start", Long.MAX_VALUE, trace.getTimeRange().getStartTime().getValue());
 334         assertEquals("getRange-end",   Long.MIN_VALUE, trace.getTimeRange().getEndTime().getValue());
 335         assertEquals("getStartTime",   Long.MAX_VALUE, trace.getStartTime().getValue());
 336         assertEquals("getEndTime",     Long.MIN_VALUE, trace.getEndTime().getValue());
 337     }
 338
 339     public void testInitializeNormalPath() throws Exception {
 340
 341         // Instantiate an "empty" trace
 342         final TmfTraceStub trace = new TmfTraceStub();
 343
 344         // Path == trace name
 345         String name = "TraceName";
 346         String path = "/my/trace/path/" + name;
 347         try {
 348             trace.initialize(null, path, TmfEvent.class);
 349         } catch (Exception e) {
 350             fail("TmfTrace.initialize() - Exception thrown");
 351         }
 352
 353         assertFalse ("Open trace", trace == null);
 354         assertEquals("getType", TmfEvent.class, trace.getType());
 355         assertNull  ("getResource", trace.getResource());
 356         assertEquals("getPath", path, trace.getPath());
 357         assertEquals("getCacheSize", ITmfTrace.DEFAULT_TRACE_CACHE_SIZE, trace.getCacheSize());
 358         assertEquals("getStreamingInterval", 0, trace.getStreamingInterval());
 359         assertEquals("getName", name, trace.getName());
 360
 361         assertEquals("getNbEvents",    0, trace.getNbEvents());
 362         assertEquals("getRange-start", Long.MAX_VALUE, trace.getTimeRange().getStartTime().getValue());
 363         assertEquals("getRange-end",   Long.MIN_VALUE, trace.getTimeRange().getEndTime().getValue());
 364         assertEquals("getStartTime",   Long.MAX_VALUE, trace.getStartTime().getValue());
 365         assertEquals("getEndTime",     Long.MIN_VALUE, trace.getEndTime().getValue());
 366     }
 367
 368     public void testInitTrace() throws Exception {
 369
 370         // Instantiate an "empty" trace
 371         final TmfTraceStub trace = new TmfTraceStub();
 372
 373         assertFalse ("Open trace", trace == null);
 374         assertNull  ("getType",  trace.getType());
 375         assertNull  ("getResource", trace.getResource());
 376         assertEquals("getCacheSize", ITmfTrace.DEFAULT_TRACE_CACHE_SIZE, trace.getCacheSize());
 377         assertEquals("getStreamingInterval", 0, trace.getStreamingInterval());
 378         assertEquals("getName", "", trace.getName());
 379
 380         assertEquals("getNbEvents",    0, trace.getNbEvents());
 381         assertEquals("getRange-start", Long.MAX_VALUE, trace.getTimeRange().getStartTime().getValue());
 382         assertEquals("getRange-end",   Long.MIN_VALUE, trace.getTimeRange().getEndTime().getValue());
 383         assertEquals("getStartTime",   Long.MAX_VALUE, trace.getStartTime().getValue());
 384         assertEquals("getEndTime",     Long.MIN_VALUE, trace.getEndTime().getValue());
 385
 386         // Validate
 387         final URL location = FileLocator.find(TmfCoreTestPlugin.getDefault().getBundle(), new Path(DIRECTORY + File.separator + TEST_STREAM), null);
 388         final File testfile = new File(FileLocator.toFileURL(location).toURI());
 389         assertTrue("validate", trace.validate(null, testfile.getPath()));
 390
 391         // InitTrace and wait for indexing completion...
 392         trace.initTrace(null, testfile.getPath(), TmfEvent.class);
 393         int nbSecs = 0;
 394         while (trace.getNbEvents() < NB_EVENTS && nbSecs < 10) {
 395             Thread.sleep(1000);
 396             nbSecs++;
 397         }
 398         if (trace.getNbEvents() < NB_EVENTS) {
 399             fail("indexing");
 400         }
 401
 402         assertFalse ("Open trace", trace == null);
 403         assertEquals("getType",  TmfEvent.class, trace.getType());
 404         assertNull  ("getResource", trace.getResource());
 405         assertEquals("getCacheSize", ITmfTrace.DEFAULT_TRACE_CACHE_SIZE, trace.getCacheSize());
 406         assertEquals("getStreamingInterval", 0, trace.getStreamingInterval());
 407         assertEquals("getName", TEST_STREAM, trace.getName());
 408
 409         assertEquals("getNbEvents",    NB_EVENTS, trace.getNbEvents());
 410         assertEquals("getRange-start", 1,         trace.getTimeRange().getStartTime().getValue());
 411         assertEquals("getRange-end",   NB_EVENTS, trace.getTimeRange().getEndTime().getValue());
 412         assertEquals("getStartTime",   1,         trace.getStartTime().getValue());
 413         assertEquals("getEndTime",     NB_EVENTS, trace.getEndTime().getValue());
 414     }
 415
 416     // ------------------------------------------------------------------------
 417     // Set/Get streaming interval
 418     // ------------------------------------------------------------------------
 419
 420     public void testSetStreamingInterval() throws Exception {
 421         final TmfTraceStub trace = new TmfTraceStub(fTrace);
 422
 423         long interval = 0;
 424         assertEquals("getStreamingInterval", interval, trace.getStreamingInterval());
 425
 426         interval = 100;
 427         trace.setStreamingInterval(interval);
 428         assertEquals("getStreamingInterval", interval, trace.getStreamingInterval());
 429
 430         interval = -1;
 431         trace.setStreamingInterval(interval);
 432         assertEquals("getStreamingInterval", 0, trace.getStreamingInterval());
 433
 434         interval = 0;
 435         trace.setStreamingInterval(interval);
 436         assertEquals("getStreamingInterval", interval, trace.getStreamingInterval());
 437
 438         trace.dispose();
 439     }
 440
 441     // ------------------------------------------------------------------------
 442     // Set/Get time range
 443     // ------------------------------------------------------------------------
 444
 445     public void testSetTimeRange() throws Exception {
 446         final TmfTraceStub trace = new TmfTraceStub(fTrace);
 447         trace.indexTrace();
 448
 449         assertEquals("getRange-start", 1,         trace.getTimeRange().getStartTime().getValue());
 450         assertEquals("getRange-end",   NB_EVENTS, trace.getTimeRange().getEndTime().getValue());
 451         assertEquals("getStartTime",   1,         trace.getStartTime().getValue());
 452         assertEquals("getEndTime",     NB_EVENTS, trace.getEndTime().getValue());
 453
 454         trace.setTimeRange(new TmfTimeRange(new TmfTimestamp(100), new TmfTimestamp(200)));
 455         assertEquals("setTimeRange",   100, trace.getTimeRange().getStartTime().getValue());
 456         assertEquals("setTimeRange",   200, trace.getTimeRange().getEndTime().getValue());
 457         assertEquals("setTimeRange",   100, trace.getStartTime().getValue());
 458         assertEquals("setTimeRange",   200, trace.getEndTime().getValue());
 459
 460         trace.dispose();
 461     }
 462
 463     public void testSetStartTime() throws Exception {
 464         final TmfTraceStub trace = new TmfTraceStub(fTrace);
 465         trace.indexTrace();
 466
 467         assertEquals("getRange-start", 1,         trace.getTimeRange().getStartTime().getValue());
 468         assertEquals("getRange-end",   NB_EVENTS, trace.getTimeRange().getEndTime().getValue());
 469         assertEquals("getStartTime",   1,         trace.getStartTime().getValue());
 470         assertEquals("getEndTime",     NB_EVENTS, trace.getEndTime().getValue());
 471
 472         trace.setStartTime(new TmfTimestamp(100));
 473         assertEquals("setStartTime",   100,       trace.getTimeRange().getStartTime().getValue());
 474         assertEquals("setStartTime",   NB_EVENTS, trace.getTimeRange().getEndTime().getValue());
 475         assertEquals("setStartTime",   100,       trace.getStartTime().getValue());
 476         assertEquals("setStartTime",   NB_EVENTS, trace.getEndTime().getValue());
 477
 478         trace.dispose();
 479     }
 480
 481     public void testSetEndTime() throws Exception {
 482         final TmfTraceStub trace = new TmfTraceStub(fTrace);
 483         trace.indexTrace();
 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     // ------------------------------------------------------------------------
 500     // seekEvent on location (note: does not reliably set the rank)
 501     // ------------------------------------------------------------------------
 502
 503     public void testSeekEventOnCacheBoundary() throws Exception {
 504
 505         // Position trace at event rank 0
 506         ITmfContext context = fTrace.seekEvent(0);
 507         ITmfEvent event = fTrace.parseEvent(context);
 508         assertEquals("Event timestamp", 1, event.getTimestamp().getValue());
 509         assertEquals("Event rank", 0, context.getRank());
 510
 511         context = fTrace.seekEvent(context.getLocation());
 512         assertEquals("Event rank", ITmfContext.UNKNOWN_RANK, context.getRank());
 513
 514         event = fTrace.parseEvent(context);
 515         assertEquals("Event timestamp", 1, event.getTimestamp().getValue());
 516         assertEquals("Event rank", ITmfContext.UNKNOWN_RANK, context.getRank());
 517
 518         event = fTrace.readNextEvent(context);
 519         assertEquals("Event timestamp", 1, event.getTimestamp().getValue());
 520         assertEquals("Event rank", ITmfContext.UNKNOWN_RANK, context.getRank());
 521
 522         // Position trace at event rank 1000
 523         ITmfContext tmpContext = fTrace.seekEvent(new TmfTimestamp(1001, SCALE, 0));
 524         context = fTrace.seekEvent(tmpContext.getLocation());
 525         assertEquals("Event rank", ITmfContext.UNKNOWN_RANK, context.getRank());
 526
 527         event = fTrace.parseEvent(context);
 528         assertEquals("Event timestamp", 1001, event.getTimestamp().getValue());
 529         assertEquals("Event rank", ITmfContext.UNKNOWN_RANK, context.getRank());
 530
 531         event = fTrace.readNextEvent(context);
 532         assertEquals("Event timestamp", 1001, event.getTimestamp().getValue());
 533         assertEquals("Event rank", ITmfContext.UNKNOWN_RANK, context.getRank());
 534
 535         // Position trace at event rank 4000
 536         tmpContext = fTrace.seekEvent(new TmfTimestamp(4001, SCALE, 0));
 537         context = fTrace.seekEvent(tmpContext.getLocation());
 538         assertEquals("Event rank", ITmfContext.UNKNOWN_RANK, context.getRank());
 539
 540         event = fTrace.parseEvent(context);
 541         assertEquals("Event timestamp", 4001, event.getTimestamp().getValue());
 542         assertEquals("Event rank", ITmfContext.UNKNOWN_RANK, context.getRank());
 543
 544         event = fTrace.readNextEvent(context);
 545         assertEquals("Event timestamp", 4001, event.getTimestamp().getValue());
 546         assertEquals("Event rank", ITmfContext.UNKNOWN_RANK, context.getRank());
 547     }
 548
 549     public void testSeekEventNotOnCacheBoundary() throws Exception {
 550
 551         // Position trace at event rank 9
 552         ITmfContext tmpContext = fTrace.seekEvent(new TmfTimestamp(10, SCALE, 0));
 553         TmfContext context = fTrace.seekEvent(tmpContext.getLocation());
 554         assertEquals("Event rank", ITmfContext.UNKNOWN_RANK, context.getRank());
 555
 556         ITmfEvent event = fTrace.parseEvent(context);
 557         assertEquals("Event timestamp", 10, event.getTimestamp().getValue());
 558         assertEquals("Event rank", ITmfContext.UNKNOWN_RANK, context.getRank());
 559
 560         event = fTrace.readNextEvent(context);
 561         assertEquals("Event timestamp", 10, event.getTimestamp().getValue());
 562         assertEquals("Event rank", ITmfContext.UNKNOWN_RANK, context.getRank());
 563
 564         // Position trace at event rank 999
 565         tmpContext = fTrace.seekEvent(new TmfTimestamp(1000, SCALE, 0));
 566         context = fTrace.seekEvent(tmpContext.getLocation());
 567         assertEquals("Event rank", ITmfContext.UNKNOWN_RANK, context.getRank());
 568
 569         event = fTrace.parseEvent(context);
 570         assertEquals("Event timestamp", 1000, event.getTimestamp().getValue());
 571         assertEquals("Event rank", ITmfContext.UNKNOWN_RANK, context.getRank());
 572
 573         event = fTrace.readNextEvent(context);
 574         assertEquals("Event timestamp", 1000, event.getTimestamp().getValue());
 575         assertEquals("Event rank", ITmfContext.UNKNOWN_RANK, context.getRank());
 576
 577         // Position trace at event rank 1001
 578         tmpContext = fTrace.seekEvent(new TmfTimestamp(1002, SCALE, 0));
 579         context = fTrace.seekEvent(tmpContext.getLocation());
 580         assertEquals("Event rank", ITmfContext.UNKNOWN_RANK, context.getRank());
 581
 582         event = fTrace.parseEvent(context);
 583         assertEquals("Event timestamp", 1002, event.getTimestamp().getValue());
 584         assertEquals("Event rank", ITmfContext.UNKNOWN_RANK, context.getRank());
 585
 586         event = fTrace.readNextEvent(context);
 587         assertEquals("Event timestamp", 1002, event.getTimestamp().getValue());
 588         assertEquals("Event rank", ITmfContext.UNKNOWN_RANK, context.getRank());
 589
 590         // Position trace at event rank 4500
 591         tmpContext = fTrace.seekEvent(new TmfTimestamp(4501, SCALE, 0));
 592         context = fTrace.seekEvent(tmpContext.getLocation());
 593         assertEquals("Event rank", ITmfContext.UNKNOWN_RANK, context.getRank());
 594
 595         event = fTrace.parseEvent(context);
 596         assertEquals("Event timestamp", 4501, event.getTimestamp().getValue());
 597         assertEquals("Event rank", ITmfContext.UNKNOWN_RANK, context.getRank());
 598
 599         event = fTrace.readNextEvent(context);
 600         assertEquals("Event timestamp", 4501, event.getTimestamp().getValue());
 601         assertEquals("Event rank", ITmfContext.UNKNOWN_RANK, context.getRank());
 602     }
 603
 604     public void testSeekEventOutOfScope() throws Exception {
 605
 606         // Position trace at beginning
 607         ITmfContext tmpContext = fTrace.seekEvent(0);
 608         ITmfContext context = fTrace.seekEvent(tmpContext.getLocation());
 609         assertEquals("Event rank", ITmfContext.UNKNOWN_RANK, context.getRank());
 610
 611         ITmfEvent event = fTrace.parseEvent(context);
 612         assertEquals("Event timestamp", 1, event.getTimestamp().getValue());
 613         assertEquals("Event rank", ITmfContext.UNKNOWN_RANK, context.getRank());
 614
 615         event = fTrace.readNextEvent(context);
 616         assertEquals("Event timestamp", 1, event.getTimestamp().getValue());
 617         assertEquals("Event rank", ITmfContext.UNKNOWN_RANK, context.getRank());
 618
 619         // Position trace at event passed the end
 620         context = fTrace.seekEvent(new TmfTimestamp(NB_EVENTS + 1, SCALE, 0));
 621         assertNull("Event timestamp", context.getLocation());
 622         assertEquals("Event rank", ITmfContext.UNKNOWN_RANK, context.getRank());
 623
 624         event = fTrace.readNextEvent(context);
 625         assertNull("Event", event);
 626     }
 627
 628     // ------------------------------------------------------------------------
 629     // seekEvent on timestamp (note: does not reliably set the rank)
 630     // ------------------------------------------------------------------------
 631
 632     public void testSeekEventOnNullTimestamp() throws Exception {
 633
 634         // Position trace at event rank 0
 635         ITmfContext context = fTrace.seekEvent((ITmfTimestamp) null);
 636         assertEquals("Event rank", 0, context.getRank());
 637
 638         ITmfEvent event = fTrace.parseEvent(context);
 639         assertEquals("Event timestamp", 1, event.getTimestamp().getValue());
 640         assertEquals("Event rank", 0, context.getRank());
 641     }
 642
 643     public void testSeekEventOnTimestampOnCacheBoundary() throws Exception {
 644
 645         // Position trace at event rank 0
 646         ITmfContext context = fTrace.seekEvent(new TmfTimestamp(1, SCALE, 0));
 647         assertEquals("Event rank", 0, context.getRank());
 648
 649         ITmfEvent event = fTrace.parseEvent(context);
 650         assertEquals("Event timestamp", 1, event.getTimestamp().getValue());
 651         assertEquals("Event rank", 0, context.getRank());
 652
 653         event = fTrace.readNextEvent(context);
 654         assertEquals("Event timestamp", 1, event.getTimestamp().getValue());
 655         assertEquals("Event rank", 1, context.getRank());
 656
 657         // Position trace at event rank 1000
 658         context = fTrace.seekEvent(new TmfTimestamp(1001, SCALE, 0));
 659         assertEquals("Event rank", 1000, context.getRank());
 660
 661         event = fTrace.parseEvent(context);
 662         assertEquals("Event timestamp", 1001, event.getTimestamp().getValue());
 663         assertEquals("Event rank", 1000, context.getRank());
 664
 665         event = fTrace.readNextEvent(context);
 666         assertEquals("Event timestamp", 1001, event.getTimestamp().getValue());
 667         assertEquals("Event rank", 1001, context.getRank());
 668
 669         // Position trace at event rank 4000
 670         context = fTrace.seekEvent(new TmfTimestamp(4001, SCALE, 0));
 671         assertEquals("Event rank", 4000, context.getRank());
 672
 673         event = fTrace.parseEvent(context);
 674         assertEquals("Event timestamp", 4001, event.getTimestamp().getValue());
 675         assertEquals("Event rank", 4000, context.getRank());
 676
 677         event = fTrace.readNextEvent(context);
 678         assertEquals("Event timestamp", 4001, event.getTimestamp().getValue());
 679         assertEquals("Event rank", 4001, context.getRank());
 680     }
 681
 682     public void testSeekEventOnTimestampNotOnCacheBoundary() throws Exception {
 683
 684         // Position trace at event rank 1
 685         ITmfContext context = fTrace.seekEvent(new TmfTimestamp(2, SCALE, 0));
 686         assertEquals("Event rank", 1, context.getRank());
 687
 688         ITmfEvent event = fTrace.parseEvent(context);
 689         assertEquals("Event timestamp", 2, event.getTimestamp().getValue());
 690         assertEquals("Event rank", 1, context.getRank());
 691
 692         event = fTrace.readNextEvent(context);
 693         assertEquals("Event timestamp", 2, event.getTimestamp().getValue());
 694         assertEquals("Event rank", 2, context.getRank());
 695
 696         // Position trace at event rank 9
 697         context = fTrace.seekEvent(new TmfTimestamp(10, SCALE, 0));
 698         assertEquals("Event rank", 9, context.getRank());
 699
 700         event = fTrace.parseEvent(context);
 701         assertEquals("Event timestamp", 10, event.getTimestamp().getValue());
 702         assertEquals("Event rank", 9, context.getRank());
 703
 704         event = fTrace.readNextEvent(context);
 705         assertEquals("Event timestamp", 10, event.getTimestamp().getValue());
 706         assertEquals("Event rank", 10, context.getRank());
 707
 708         // Position trace at event rank 999
 709         context = fTrace.seekEvent(new TmfTimestamp(1000, SCALE, 0));
 710         assertEquals("Event rank", 999, context.getRank());
 711
 712         event = fTrace.parseEvent(context);
 713         assertEquals("Event timestamp", 1000, event.getTimestamp().getValue());
 714         assertEquals("Event rank", 999, context.getRank());
 715
 716         event = fTrace.readNextEvent(context);
 717         assertEquals("Event timestamp", 1000, event.getTimestamp().getValue());
 718         assertEquals("Event rank", 1000, context.getRank());
 719
 720         // Position trace at event rank 1001
 721         context = fTrace.seekEvent(new TmfTimestamp(1002, SCALE, 0));
 722         assertEquals("Event rank", 1001, context.getRank());
 723
 724         event = fTrace.parseEvent(context);
 725         assertEquals("Event timestamp", 1002, event.getTimestamp().getValue());
 726         assertEquals("Event rank", 1001, context.getRank());
 727
 728         event = fTrace.readNextEvent(context);
 729         assertEquals("Event timestamp", 1002, event.getTimestamp().getValue());
 730         assertEquals("Event rank", 1002, context.getRank());
 731
 732         // Position trace at event rank 4500
 733         context = fTrace.seekEvent(new TmfTimestamp(4501, SCALE, 0));
 734         assertEquals("Event rank", 4500, context.getRank());
 735
 736         event = fTrace.parseEvent(context);
 737         assertEquals("Event timestamp", 4501, event.getTimestamp().getValue());
 738         assertEquals("Event rank", 4500, context.getRank());
 739
 740         event = fTrace.readNextEvent(context);
 741         assertEquals("Event timestamp", 4501, event.getTimestamp().getValue());
 742         assertEquals("Event rank", 4501, context.getRank());
 743     }
 744
 745     public void testSeekEventOnTimestampOutOfScope() throws Exception {
 746
 747         // Position trace at beginning
 748         ITmfContext context = fTrace.seekEvent(new TmfTimestamp(-1, SCALE, 0));
 749         assertEquals("Event rank", 0, context.getRank());
 750
 751         ITmfEvent event = fTrace.parseEvent(context);
 752         assertEquals("Event timestamp", 1, event.getTimestamp().getValue());
 753         assertEquals("Event rank", 0, context.getRank());
 754
 755         event = fTrace.readNextEvent(context);
 756         assertEquals("Event timestamp", 1, event.getTimestamp().getValue());
 757         assertEquals("Event rank", 1, context.getRank());
 758
 759         // Position trace at event passed the end
 760         context = fTrace.seekEvent(new TmfTimestamp(NB_EVENTS + 1, SCALE, 0));
 761         assertEquals("Event rank", ITmfContext.UNKNOWN_RANK, context.getRank());
 762
 763         event = fTrace.parseEvent(context);
 764         assertEquals("Event timestamp", null, event);
 765         assertEquals("Event rank", ITmfContext.UNKNOWN_RANK, context.getRank());
 766
 767         event = fTrace.readNextEvent(context);
 768         assertEquals("Event timestamp", null, event);
 769         assertEquals("Event rank", ITmfContext.UNKNOWN_RANK, context.getRank());
 770     }
 771
 772     // ------------------------------------------------------------------------
 773     // seekEvent on rank
 774     // ------------------------------------------------------------------------
 775
 776     public void testSeekEventOnNegativeRank() throws Exception {
 777
 778         // Position trace at event rank 0
 779         ITmfContext context = fTrace.seekEvent(-1);
 780         assertEquals("Event rank", 0, context.getRank());
 781
 782         ITmfEvent event = fTrace.parseEvent(context);
 783         assertEquals("Event timestamp", 1, event.getTimestamp().getValue());
 784         assertEquals("Event rank", 0, context.getRank());
 785     }
 786
 787     public void testSeekOnRankOnCacheBoundary() throws Exception {
 788
 789         // On lower bound, returns the first event (ts = 1)
 790         ITmfContext context = fTrace.seekEvent(0);
 791         assertEquals("Event rank", 0, context.getRank());
 792
 793         ITmfEvent event = fTrace.parseEvent(context);
 794         assertEquals("Event timestamp", 1, event.getTimestamp().getValue());
 795         assertEquals("Event rank", 0, context.getRank());
 796
 797         event = fTrace.readNextEvent(context);
 798         assertEquals("Event timestamp", 1, event.getTimestamp().getValue());
 799         assertEquals("Event rank", 1, context.getRank());
 800
 801         // Position trace at event rank 1000
 802         context = fTrace.seekEvent(1000);
 803         assertEquals("Event rank", 1000, context.getRank());
 804
 805         event = fTrace.parseEvent(context);
 806         assertEquals("Event timestamp", 1001, event.getTimestamp().getValue());
 807         assertEquals("Event rank", 1000, context.getRank());
 808
 809         event = fTrace.readNextEvent(context);
 810         assertEquals("Event timestamp", 1001, event.getTimestamp().getValue());
 811         assertEquals("Event rank", 1001, context.getRank());
 812
 813         // Position trace at event rank 4000
 814         context = fTrace.seekEvent(4000);
 815         assertEquals("Event rank", 4000, context.getRank());
 816
 817         event = fTrace.parseEvent(context);
 818         assertEquals("Event timestamp", 4001, event.getTimestamp().getValue());
 819         assertEquals("Event rank", 4000, context.getRank());
 820
 821         event = fTrace.readNextEvent(context);
 822         assertEquals("Event timestamp", 4001, event.getTimestamp().getValue());
 823         assertEquals("Event rank", 4001, context.getRank());
 824     }
 825
 826     public void testSeekOnRankNotOnCacheBoundary() throws Exception {
 827
 828         // Position trace at event rank 9
 829         ITmfContext context = fTrace.seekEvent(9);
 830         assertEquals("Event rank", 9, context.getRank());
 831
 832         ITmfEvent event = fTrace.parseEvent(context);
 833         assertEquals("Event timestamp", 10, event.getTimestamp().getValue());
 834         assertEquals("Event rank", 9, context.getRank());
 835
 836         event = fTrace.readNextEvent(context);
 837         assertEquals("Event timestamp", 10, event.getTimestamp().getValue());
 838         assertEquals("Event rank", 10, context.getRank());
 839
 840         // Position trace at event rank 999
 841         context = fTrace.seekEvent(999);
 842         assertEquals("Event rank", 999, context.getRank());
 843
 844         event = fTrace.parseEvent(context);
 845         assertEquals("Event timestamp", 1000, event.getTimestamp().getValue());
 846         assertEquals("Event rank", 999, context.getRank());
 847
 848         event = fTrace.readNextEvent(context);
 849         assertEquals("Event timestamp", 1000, event.getTimestamp().getValue());
 850         assertEquals("Event rank", 1000, context.getRank());
 851
 852         // Position trace at event rank 1001
 853         context = fTrace.seekEvent(1001);
 854         assertEquals("Event rank", 1001, context.getRank());
 855
 856         event = fTrace.parseEvent(context);
 857         assertEquals("Event timestamp", 1002, event.getTimestamp().getValue());
 858         assertEquals("Event rank", 1001, context.getRank());
 859
 860         event = fTrace.readNextEvent(context);
 861         assertEquals("Event timestamp", 1002, event.getTimestamp().getValue());
 862         assertEquals("Event rank", 1002, context.getRank());
 863
 864         // Position trace at event rank 4500
 865         context = fTrace.seekEvent(4500);
 866         assertEquals("Event rank", 4500, context.getRank());
 867
 868         event = fTrace.parseEvent(context);
 869         assertEquals("Event timestamp", 4501, event.getTimestamp().getValue());
 870         assertEquals("Event rank", 4500, context.getRank());
 871
 872         event = fTrace.readNextEvent(context);
 873         assertEquals("Event timestamp", 4501, event.getTimestamp().getValue());
 874         assertEquals("Event rank", 4501, context.getRank());
 875     }
 876
 877     public void testSeekEventOnRankOutOfScope() throws Exception {
 878
 879         // Position trace at beginning
 880         ITmfContext context = fTrace.seekEvent(-1);
 881         assertEquals("Event rank", 0, context.getRank());
 882
 883         ITmfEvent event = fTrace.parseEvent(context);
 884         assertEquals("Event timestamp", 1, event.getTimestamp().getValue());
 885         assertEquals("Event rank", 0, context.getRank());
 886
 887         event = fTrace.readNextEvent(context);
 888         assertEquals("Event timestamp", 1, event.getTimestamp().getValue());
 889         assertEquals("Event rank", 1, context.getRank());
 890
 891         // Position trace at event passed the end
 892         context = fTrace.seekEvent(NB_EVENTS);
 893         assertEquals("Event rank", NB_EVENTS, context.getRank());
 894
 895         event = fTrace.parseEvent(context);
 896         assertNull("Event", event);
 897         assertEquals("Event rank", NB_EVENTS, context.getRank());
 898
 899         event = fTrace.readNextEvent(context);
 900         assertNull("Event", event);
 901         assertEquals("Event rank", NB_EVENTS, context.getRank());
 902     }
 903
 904     // ------------------------------------------------------------------------
 905     // parseEvent - make sure parseEvent doesn't update the context
 906     // ------------------------------------------------------------------------
 907
 908     public void testParseEvent() throws Exception {
 909
 910         final int NB_READS = 20;
 911
 912         // On lower bound, returns the first event (ts = 0)
 913         final TmfContext context = (TmfContext) fTrace.seekEvent(new TmfTimestamp(0, SCALE, 0));
 914         TmfContext svContext = new TmfContext(context);
 915
 916         ITmfEvent event = fTrace.parseEvent(context);
 917         assertEquals("Event timestamp", 1, event.getTimestamp().getValue());
 918         assertEquals("Event rank", 0, context.getRank());
 919         assertTrue("parseEvent", context.equals(svContext));
 920
 921         event = fTrace.parseEvent(context);
 922         assertEquals("Event timestamp", 1, event.getTimestamp().getValue());
 923         assertEquals("Event rank", 0, context.getRank());
 924         assertTrue("parseEvent", context.equals(svContext));
 925
 926         event = fTrace.parseEvent(context);
 927         assertEquals("Event timestamp", 1, event.getTimestamp().getValue());
 928         assertEquals("Event rank", 0, context.getRank());
 929         assertTrue("parseEvent", context.equals(svContext));
 930
 931         // Position the trace at event NB_READS
 932         for (int i = 1; i < NB_READS; i++) {
 933             event = fTrace.readNextEvent(context);
 934             assertEquals("Event timestamp", i, event.getTimestamp().getValue());
 935         }
 936
 937         svContext = new TmfContext(context);
 938         event = fTrace.parseEvent(context);
 939         assertEquals("Event timestamp", NB_READS, event.getTimestamp().getValue());
 940         assertEquals("Event rank", NB_READS -1 , context.getRank());
 941         assertTrue("parseEvent", context.equals(svContext));
 942
 943         event = fTrace.parseEvent(context);
 944         assertEquals("Event timestamp", NB_READS, event.getTimestamp().getValue());
 945         assertEquals("Event rank", NB_READS - 1, context.getRank());
 946         assertTrue("parseEvent", context.equals(svContext));
 947     }
 948
 949     // ------------------------------------------------------------------------
 950     // readNextEvent - updates the context
 951     // ------------------------------------------------------------------------
 952
 953     public void testReadNextEvent() throws Exception {
 954
 955         final int NB_READS = 20;
 956
 957         // On lower bound, returns the first event (ts = 1)
 958         final ITmfContext context = fTrace.seekEvent(new TmfTimestamp(0, SCALE, 0));
 959
 960         // Read NB_EVENTS
 961         ITmfEvent event;
 962         for (int i = 0; i < NB_READS; i++) {
 963             event = fTrace.readNextEvent(context);
 964             assertEquals("Event timestamp", i + 1, event.getTimestamp().getValue());
 965             assertEquals("Event rank", i + 1, context.getRank());
 966         }
 967
 968         // Make sure we stay positioned
 969         event = fTrace.parseEvent(context);
 970         assertEquals("Event timestamp", NB_READS + 1, event.getTimestamp().getValue());
 971         assertEquals("Event rank", NB_READS, context.getRank());
 972     }
 973
 974     // ------------------------------------------------------------------------
 975     // processRequest
 976     // ------------------------------------------------------------------------
 977
 978     @SuppressWarnings("unchecked")
 979     public void testProcessEventRequestForAllEvents() throws Exception {
 980         final int BLOCK_SIZE =  1;
 981         final Vector<TmfEvent> requestedEvents = new Vector<TmfEvent>();
 982
 983         final TmfTimeRange range = new TmfTimeRange(TmfTimestamp.BIG_BANG, TmfTimestamp.BIG_CRUNCH);
 984         final TmfEventRequest<TmfEvent> request = new TmfEventRequest<TmfEvent>(TmfEvent.class, range, NB_EVENTS, BLOCK_SIZE) {
 985             @Override
 986             public void handleData(final TmfEvent event) {
 987                 super.handleData(event);
 988                 requestedEvents.add(event);
 989             }
 990         };
 991         final ITmfDataProvider<TmfEvent>[] providers = (ITmfDataProvider<TmfEvent>[]) TmfProviderManager.getProviders(TmfEvent.class, TmfTraceStub.class);
 992         providers[0].sendRequest(request);
 993         request.waitForCompletion();
 994
 995         assertEquals("nbEvents", NB_EVENTS, requestedEvents.size());
 996         assertTrue("isCompleted",  request.isCompleted());
 997         assertFalse("isCancelled", request.isCancelled());
 998
 999         // Ensure that we have distinct events.
1000         // Don't go overboard: we are not validating the stub!
1001         for (int i = 0; i < NB_EVENTS; i++) {
1002             assertEquals("Distinct events", i + 1, requestedEvents.get(i).getTimestamp().getValue());
1003         }
1004     }
1005
1006     @SuppressWarnings("unchecked")
1007     public void testProcessEventRequestForNbEvents() throws Exception {
1008         final int BLOCK_SIZE = 100;
1009         final int NB_EVENTS  = 1000;
1010         final Vector<TmfEvent> requestedEvents = new Vector<TmfEvent>();
1011
1012         final TmfTimeRange range = new TmfTimeRange(TmfTimestamp.BIG_BANG, TmfTimestamp.BIG_CRUNCH);
1013         final TmfEventRequest<TmfEvent> request = new TmfEventRequest<TmfEvent>(TmfEvent.class, range, NB_EVENTS, BLOCK_SIZE) {
1014             @Override
1015             public void handleData(final TmfEvent event) {
1016                 super.handleData(event);
1017                 requestedEvents.add(event);
1018             }
1019         };
1020         final ITmfDataProvider<TmfEvent>[] providers = (ITmfDataProvider<TmfEvent>[]) TmfProviderManager.getProviders(TmfEvent.class, TmfTraceStub.class);
1021         providers[0].sendRequest(request);
1022         request.waitForCompletion();
1023
1024         assertEquals("nbEvents", NB_EVENTS, requestedEvents.size());
1025         assertTrue("isCompleted",  request.isCompleted());
1026         assertFalse("isCancelled", request.isCancelled());
1027
1028         // Ensure that we have distinct events.
1029         // Don't go overboard: we are not validating the stub!
1030         for (int i = 0; i < NB_EVENTS; i++) {
1031             assertEquals("Distinct events", i + 1, requestedEvents.get(i).getTimestamp().getValue());
1032         }
1033     }
1034
1035     @SuppressWarnings("unchecked")
1036     public void testProcessEventRequestForSomeEvents() throws Exception {
1037         final int BLOCK_SIZE =  1;
1038         final long startTime = 100;
1039         final int NB_EVENTS  = 1000;
1040         final Vector<TmfEvent> requestedEvents = new Vector<TmfEvent>();
1041
1042         final TmfTimeRange range = new TmfTimeRange(new TmfTimestamp(startTime, SCALE), TmfTimestamp.BIG_CRUNCH);
1043         final TmfEventRequest<TmfEvent> request = new TmfEventRequest<TmfEvent>(TmfEvent.class, range, NB_EVENTS, BLOCK_SIZE) {
1044             @Override
1045             public void handleData(final TmfEvent event) {
1046                 super.handleData(event);
1047                 requestedEvents.add(event);
1048             }
1049         };
1050         final ITmfDataProvider<TmfEvent>[] providers = (ITmfDataProvider<TmfEvent>[]) TmfProviderManager.getProviders(TmfEvent.class, TmfTraceStub.class);
1051         providers[0].sendRequest(request);
1052         request.waitForCompletion();
1053
1054         assertEquals("nbEvents", NB_EVENTS, requestedEvents.size());
1055         assertTrue("isCompleted",  request.isCompleted());
1056         assertFalse("isCancelled", request.isCancelled());
1057
1058         // Ensure that we have distinct events.
1059         // Don't go overboard: we are not validating the stub!
1060         for (int i = 0; i < NB_EVENTS; i++) {
1061             assertEquals("Distinct events", startTime + i, requestedEvents.get(i).getTimestamp().getValue());
1062         }
1063     }
1064
1065     @SuppressWarnings("unchecked")
1066     public void testProcessEventRequestForOtherEvents() throws Exception {
1067         final int BLOCK_SIZE =  1;
1068         final int startIndex = 99;
1069         final long startTime = 100;
1070         final int NB_EVENTS  = 1000;
1071         final Vector<TmfEvent> requestedEvents = new Vector<TmfEvent>();
1072
1073         final TmfTimeRange range = new TmfTimeRange(new TmfTimestamp(startTime, SCALE), TmfTimestamp.BIG_CRUNCH);
1074         final TmfEventRequest<TmfEvent> request = new TmfEventRequest<TmfEvent>(TmfEvent.class, range, startIndex, NB_EVENTS, BLOCK_SIZE) {
1075             @Override
1076             public void handleData(final TmfEvent event) {
1077                 super.handleData(event);
1078                 requestedEvents.add(event);
1079             }
1080         };
1081         final ITmfDataProvider<TmfEvent>[] providers = (ITmfDataProvider<TmfEvent>[]) TmfProviderManager.getProviders(TmfEvent.class, TmfTraceStub.class);
1082         providers[0].sendRequest(request);
1083         request.waitForCompletion();
1084
1085         assertEquals("nbEvents", NB_EVENTS, requestedEvents.size());
1086         assertTrue("isCompleted",  request.isCompleted());
1087         assertFalse("isCancelled", request.isCancelled());
1088
1089         // Ensure that we have distinct events.
1090         // Don't go overboard: we are not validating the stub!
1091         for (int i = 0; i < NB_EVENTS; i++) {
1092             assertEquals("Distinct events", startTime + i, requestedEvents.get(i).getTimestamp().getValue());
1093         }
1094     }
1095
1096     @SuppressWarnings("unchecked")
1097     public void testProcessDataRequestForSomeEvents() throws Exception {
1098         final int startIndex = 100;
1099         final int NB_EVENTS  = 1000;
1100         final Vector<TmfEvent> requestedEvents = new Vector<TmfEvent>();
1101
1102         final TmfDataRequest<TmfEvent> request = new TmfDataRequest<TmfEvent>(TmfEvent.class, startIndex, NB_EVENTS) {
1103             @Override
1104             public void handleData(final TmfEvent event) {
1105                 super.handleData(event);
1106                 requestedEvents.add(event);
1107             }
1108         };
1109         final ITmfDataProvider<TmfEvent>[] providers = (ITmfDataProvider<TmfEvent>[]) TmfProviderManager.getProviders(TmfEvent.class, TmfTraceStub.class);
1110         providers[0].sendRequest(request);
1111         request.waitForCompletion();
1112
1113         assertEquals("nbEvents", NB_EVENTS, requestedEvents.size());
1114         assertTrue("isCompleted",  request.isCompleted());
1115         assertFalse("isCancelled", request.isCancelled());
1116
1117         // Ensure that we have distinct events.
1118         // Don't go overboard: we are not validating the stub!
1119         for (int i = 0; i < NB_EVENTS; i++) {
1120             assertEquals("Distinct events", startIndex + 1 + i, requestedEvents.get(i).getTimestamp().getValue());
1121         }
1122     }
1123
1124     // ------------------------------------------------------------------------
1125     // cancel
1126     // ------------------------------------------------------------------------
1127
1128     @SuppressWarnings("unchecked")
1129     public void testCancel() throws Exception {
1130         final Vector<TmfEvent> requestedEvents = new Vector<TmfEvent>();
1131
1132         final TmfTimeRange range = new TmfTimeRange(TmfTimestamp.BIG_BANG, TmfTimestamp.BIG_CRUNCH);
1133         final TmfEventRequest<TmfEvent> request = new TmfEventRequest<TmfEvent>(TmfEvent.class, range, NB_EVENTS, BLOCK_SIZE) {
1134             int nbRead = 0;
1135             @Override
1136             public void handleData(final TmfEvent event) {
1137                 super.handleData(event);
1138                 requestedEvents.add(event);
1139                 if (++nbRead == BLOCK_SIZE) {
1140                     cancel();
1141                 }
1142             }
1143         };
1144         final ITmfDataProvider<TmfEvent>[] providers = (ITmfDataProvider<TmfEvent>[]) TmfProviderManager.getProviders(TmfEvent.class, TmfTraceStub.class);
1145         providers[0].sendRequest(request);
1146         request.waitForCompletion();
1147
1148         assertEquals("nbEvents",  BLOCK_SIZE, requestedEvents.size());
1149         assertTrue("isCompleted", request.isCompleted());
1150         assertTrue("isCancelled", request.isCancelled());
1151     }
1152
1153     // ------------------------------------------------------------------------
1154     // toString
1155     // ------------------------------------------------------------------------
1156
1157     public void testDefaultTmfTraceStub() throws Exception {
1158         assertFalse ("Open trace", fTrace == null);
1159         assertEquals("getType",  TmfEvent.class, fTrace.getType());
1160         assertNull  ("getResource", fTrace.getResource());
1161         assertEquals("getCacheSize", BLOCK_SIZE, fTrace.getCacheSize());
1162         assertEquals("getStreamingInterval", 0, fTrace.getStreamingInterval());
1163         assertEquals("getName", TEST_STREAM, fTrace.getName());
1164
1165         assertEquals("getNbEvents",    NB_EVENTS, fTrace.getNbEvents());
1166         assertEquals("getRange-start", 1,         fTrace.getTimeRange().getStartTime().getValue());
1167         assertEquals("getRange-end",   NB_EVENTS, fTrace.getTimeRange().getEndTime().getValue());
1168         assertEquals("getStartTime",   1,         fTrace.getStartTime().getValue());
1169         assertEquals("getEndTime",     NB_EVENTS, fTrace.getEndTime().getValue());
1170
1171         String expected = "TmfTrace [fPath=" + fTrace.getPath() + ", fCacheSize=" + fTrace.getCacheSize() +
1172                 ", fNbEvents=" + fTrace.getNbEvents() + ", fStartTime=" + fTrace.getStartTime() +
1173                 ", fEndTime=" + fTrace.getEndTime() + ", fStreamingInterval=" + fTrace.getStreamingInterval() +
1174                 "]";
1175         assertEquals("toString", expected, fTrace.toString());
1176     }
1177
1178 }