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