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

   1 /*******************************************************************************
   2  * Copyright (c) 2009, 2010 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  *******************************************************************************/
  12
  13 package org.eclipse.linuxtools.tmf.core.tests.trace;
  14
  15 import java.io.File;
  16 import java.io.IOException;
  17 import java.net.URISyntaxException;
  18 import java.net.URL;
  19 import java.util.Vector;
  20
  21 import junit.framework.TestCase;
  22
  23 import org.eclipse.core.runtime.FileLocator;
  24 import org.eclipse.core.runtime.Path;
  25 import org.eclipse.linuxtools.tmf.core.component.ITmfDataProvider;
  26 import org.eclipse.linuxtools.tmf.core.component.TmfProviderManager;
  27 import org.eclipse.linuxtools.tmf.core.event.ITmfEvent;
  28 import org.eclipse.linuxtools.tmf.core.event.TmfEvent;
  29 import org.eclipse.linuxtools.tmf.core.event.TmfTimeRange;
  30 import org.eclipse.linuxtools.tmf.core.event.TmfTimestamp;
  31 import org.eclipse.linuxtools.tmf.core.request.TmfEventRequest;
  32 import org.eclipse.linuxtools.tmf.core.tests.TmfCoreTestPlugin;
  33 import org.eclipse.linuxtools.tmf.core.trace.ITmfContext;
  34 import org.eclipse.linuxtools.tmf.core.trace.TmfCheckpoint;
  35 import org.eclipse.linuxtools.tmf.core.trace.TmfContext;
  36 import org.eclipse.linuxtools.tmf.core.trace.TmfTrace;
  37 import org.eclipse.linuxtools.tmf.tests.stubs.trace.TmfTraceStub;
  38
  39 /**
  40  * <b><u>TmfTraceTest</u></b>
  41  * <p>
  42  * Test suite for the TmfTrace class.
  43  */
  44 @SuppressWarnings("nls")
  45 public class TmfTraceTest extends TestCase {
  46
  47     // ------------------------------------------------------------------------
  48     // Variables
  49     // ------------------------------------------------------------------------
  50
  51     private static final String DIRECTORY   = "testfiles";
  52     private static final String TEST_STREAM = "A-Test-10K";
  53     private static final int    BLOCK_SIZE  = 500;
  54     private static final int    NB_EVENTS   = 10000;
  55     private static TmfTraceStub fTrace      = null;
  56
  57     private static byte SCALE = (byte) -3;
  58
  59     // ------------------------------------------------------------------------
  60     // Housekeeping
  61     // ------------------------------------------------------------------------
  62
  63     public TmfTraceTest(final String name) throws Exception {
  64         super(name);
  65     }
  66
  67     @Override
  68     protected void setUp() throws Exception {
  69         super.setUp();
  70         fTrace = setupTrace(DIRECTORY + File.separator + TEST_STREAM);
  71         // Dummy request to force the trace indexing
  72         final TmfEventRequest<TmfEvent> request = new TmfEventRequest<TmfEvent>(TmfEvent.class) {
  73             @Override
  74             public void handleData(final TmfEvent event) {
  75                 super.handleData(event);
  76             }
  77         };
  78         fTrace.sendRequest(request);
  79         request.waitForCompletion();
  80     }
  81
  82     @Override
  83     protected void tearDown() throws Exception {
  84         super.tearDown();
  85         fTrace.dispose();
  86         fTrace = null;
  87     }
  88
  89     // ------------------------------------------------------------------------
  90     // Helper functions
  91     // ------------------------------------------------------------------------
  92
  93     private TmfTraceStub setupTrace(final String path) {
  94         if (fTrace == null)
  95             try {
  96                 final URL location = FileLocator.find(TmfCoreTestPlugin.getDefault().getBundle(), new Path(path), null);
  97                 final File test = new File(FileLocator.toFileURL(location).toURI());
  98                 fTrace = new TmfTraceStub(test.toURI().getPath(), BLOCK_SIZE, false);
  99             } catch (final URISyntaxException e) {
 100                 e.printStackTrace();
 101             } catch (final IOException e) {
 102                 e.printStackTrace();
 103             }
 104         return fTrace;
 105     }
 106
 107     // ------------------------------------------------------------------------
 108     // Constructors
 109     // ------------------------------------------------------------------------
 110
 111     public void testTmfTraceDefault() throws Exception {
 112         TmfTraceStub trace = null;
 113         File testfile = null;
 114         try {
 115             final URL location = FileLocator.find(TmfCoreTestPlugin.getDefault().getBundle(), new Path(DIRECTORY + File.separator + TEST_STREAM), null);
 116             testfile = new File(FileLocator.toFileURL(location).toURI());
 117             trace = new TmfTraceStub(testfile.toURI().getPath());
 118         } catch (final URISyntaxException e) {
 119             fail("URISyntaxException");
 120         } catch (final IOException e) {
 121             fail("IOException");
 122         }
 123         assertTrue  ("Open trace",   trace != null);
 124         assertEquals("getType",      TmfEvent.class, trace.getType());
 125         assertEquals("getPath",      testfile.toURI().getPath(), trace.getPath());
 126         assertEquals("getName",      TEST_STREAM, trace.getName());
 127         assertEquals("getCacheSize", TmfTrace.DEFAULT_INDEX_PAGE_SIZE, trace.getIndexPageSize());
 128     }
 129
 130     public void testTmfTraceDefaultCacheSize() throws Exception {
 131         TmfTraceStub trace = null;
 132         File testfile = null;
 133         try {
 134             final URL location = FileLocator.find(TmfCoreTestPlugin.getDefault().getBundle(), new Path(DIRECTORY + File.separator + TEST_STREAM), null);
 135             testfile = new File(FileLocator.toFileURL(location).toURI());
 136             trace = new TmfTraceStub(testfile.toURI().getPath(), 0);
 137         } catch (final URISyntaxException e) {
 138             fail("URISyntaxException");
 139         } catch (final IOException e) {
 140             fail("IOException");
 141         }
 142         assertTrue  ("Open trace",   trace != null);
 143         assertEquals("getType",      TmfEvent.class, trace.getType());
 144         assertEquals("getPath",      testfile.toURI().getPath(), trace.getPath());
 145         assertEquals("getName",      TEST_STREAM, trace.getName());
 146         assertEquals("getCacheSize", TmfTrace.DEFAULT_INDEX_PAGE_SIZE, trace.getIndexPageSize());
 147     }
 148
 149     public void testTmfTrace() throws Exception {
 150         assertEquals("getType",      TmfEvent.class, fTrace.getType());
 151         assertEquals("getName",      TEST_STREAM,    fTrace.getName());
 152         assertEquals("getCacheSize", BLOCK_SIZE,     fTrace.getIndexPageSize());
 153     }
 154
 155     //    public void testClone() throws Exception {
 156     //          TmfTraceStub trace = fTrace.clone();
 157     //          assertEquals("getType",      TmfEvent.class,        trace.getType());
 158     //          assertEquals("getPath",      fTrace.getPath(),      trace.getPath());
 159     //          assertEquals("getName",      TEST_STREAM,           trace.getName());
 160     //          assertEquals("getCacheSize", BLOCK_SIZE,            trace.getIndexPageSize());
 161     //          assertEquals("getTimeRange", fTrace.getTimeRange(), trace.getTimeRange());
 162     //    }
 163
 164     // ------------------------------------------------------------------------
 165     // Get/Set time range
 166     // ------------------------------------------------------------------------
 167
 168     public void testSetTimeRange() throws Exception {
 169         final TmfTraceStub trace = new TmfTraceStub(fTrace);
 170
 171         assertEquals("getRange-start", 1,         trace.getTimeRange().getStartTime().getValue());
 172         assertEquals("getRange-end",   NB_EVENTS, trace.getTimeRange().getEndTime().getValue());
 173         assertEquals("getStartTime",   1,         trace.getStartTime().getValue());
 174         assertEquals("getEndTime",     NB_EVENTS, trace.getEndTime().getValue());
 175
 176         trace.setTimeRange(new TmfTimeRange(new TmfTimestamp(100), new TmfTimestamp(200)));
 177         assertEquals("setTimeRange",   100, trace.getTimeRange().getStartTime().getValue());
 178         assertEquals("setTimeRange",   200, trace.getTimeRange().getEndTime().getValue());
 179         assertEquals("setTimeRange",   100, trace.getStartTime().getValue());
 180         assertEquals("setTimeRange",   200, trace.getEndTime().getValue());
 181
 182         trace.dispose();
 183     }
 184
 185     public void testSetStartTime() throws Exception {
 186         final TmfTraceStub trace = new TmfTraceStub(fTrace);
 187
 188         assertEquals("getRange-start", 1,         trace.getTimeRange().getStartTime().getValue());
 189         assertEquals("getRange-end",   NB_EVENTS, trace.getTimeRange().getEndTime().getValue());
 190         assertEquals("getStartTime",   1,         trace.getStartTime().getValue());
 191         assertEquals("getEndTime",     NB_EVENTS, trace.getEndTime().getValue());
 192
 193         trace.setStartTime(new TmfTimestamp(100));
 194         assertEquals("setStartTime",   100,       trace.getTimeRange().getStartTime().getValue());
 195         assertEquals("setStartTime",   NB_EVENTS, trace.getTimeRange().getEndTime().getValue());
 196         assertEquals("setStartTime",   100,       trace.getStartTime().getValue());
 197         assertEquals("setStartTime",   NB_EVENTS, trace.getEndTime().getValue());
 198
 199         trace.dispose();
 200     }
 201
 202     public void testSetEndTime() throws Exception {
 203         final TmfTraceStub trace = new TmfTraceStub(fTrace);
 204
 205         assertEquals("getRange-start", 1,         trace.getTimeRange().getStartTime().getValue());
 206         assertEquals("getRange-end",   NB_EVENTS, trace.getTimeRange().getEndTime().getValue());
 207         assertEquals("getStartTime",   1,         trace.getStartTime().getValue());
 208         assertEquals("getEndTime",     NB_EVENTS, trace.getEndTime().getValue());
 209
 210         trace.setEndTime(new TmfTimestamp(100));
 211         assertEquals("setEndTime",     1,   trace.getTimeRange().getStartTime().getValue());
 212         assertEquals("setEndTime",     100, trace.getTimeRange().getEndTime().getValue());
 213         assertEquals("setEndTime",     1,   trace.getStartTime().getValue());
 214         assertEquals("setEndTime",     100, trace.getEndTime().getValue());
 215
 216         trace.dispose();
 217     }
 218
 219     // ------------------------------------------------------------------------
 220     // Verify checkpoints
 221     // ------------------------------------------------------------------------
 222
 223     public void testTmfTraceIndexing() throws Exception {
 224         assertEquals("getCacheSize",   BLOCK_SIZE, fTrace.getIndexPageSize());
 225         assertEquals("getTraceSize",   NB_EVENTS,  fTrace.getNbEvents());
 226         assertEquals("getRange-start", 1,          fTrace.getTimeRange().getStartTime().getValue());
 227         assertEquals("getRange-end",   NB_EVENTS,  fTrace.getTimeRange().getEndTime().getValue());
 228         assertEquals("getStartTime",   1,          fTrace.getStartTime().getValue());
 229         assertEquals("getEndTime",     NB_EVENTS,  fTrace.getEndTime().getValue());
 230
 231         final Vector<TmfCheckpoint> checkpoints = fTrace.getCheckpoints();
 232         final int pageSize = fTrace.getIndexPageSize();
 233         assertTrue("Checkpoints exist",  checkpoints != null);
 234
 235         // Validate that each checkpoint points to the right event
 236         for (int i = 0; i < checkpoints.size(); i++) {
 237             final TmfCheckpoint checkpoint = checkpoints.get(i);
 238             final TmfContext context = new TmfContext(checkpoint.getLocation(), i * pageSize);
 239             final ITmfEvent event = fTrace.parseEvent(context);
 240             assertTrue(context.getRank() == i * pageSize);
 241             assertTrue((checkpoint.getTimestamp().compareTo(event.getTimestamp(), false) == 0));
 242         }
 243     }
 244
 245     // ------------------------------------------------------------------------
 246     // parseEvent - make sure parseEvent doesn't update the context
 247     // ------------------------------------------------------------------------
 248
 249     public void testParseEvent() throws Exception {
 250
 251         final int NB_READS = 20;
 252
 253         // On lower bound, returns the first event (ts = 0)
 254         final TmfContext context = (TmfContext) fTrace.seekEvent(new TmfTimestamp(0, SCALE, 0));
 255         TmfContext svContext = new TmfContext(context);
 256
 257         ITmfEvent event = fTrace.parseEvent(context);
 258         assertEquals("Event timestamp", 1, event.getTimestamp().getValue());
 259         assertEquals("Event rank", 0, context.getRank());
 260         assertTrue("parseEvent", context.equals(svContext));
 261
 262         event = fTrace.parseEvent(context);
 263         assertEquals("Event timestamp", 1, event.getTimestamp().getValue());
 264         assertEquals("Event rank", 0, context.getRank());
 265         assertTrue("parseEvent", context.equals(svContext));
 266
 267         event = fTrace.parseEvent(context);
 268         assertEquals("Event timestamp", 1, event.getTimestamp().getValue());
 269         assertEquals("Event rank", 0, context.getRank());
 270         assertTrue("parseEvent", context.equals(svContext));
 271
 272         // Position the trace at event NB_READS
 273         for (int i = 1; i < NB_READS; i++) {
 274             event = fTrace.getNextEvent(context);
 275             assertEquals("Event timestamp", i, event.getTimestamp().getValue());
 276         }
 277
 278         svContext = new TmfContext(context);
 279         event = fTrace.parseEvent(context);
 280         assertEquals("Event timestamp", NB_READS, event.getTimestamp().getValue());
 281         assertEquals("Event rank", NB_READS -1 , context.getRank());
 282         assertTrue("parseEvent", context.equals(svContext));
 283
 284         event = fTrace.parseEvent(context);
 285         assertEquals("Event timestamp", NB_READS, event.getTimestamp().getValue());
 286         assertEquals("Event rank", NB_READS - 1, context.getRank());
 287         assertTrue("parseEvent", context.equals(svContext));
 288     }
 289
 290     // ------------------------------------------------------------------------
 291     // getNextEvent - updates the context
 292     // ------------------------------------------------------------------------
 293
 294     public void testGetNextEvent() throws Exception {
 295
 296         final int NB_READS = 20;
 297
 298         // On lower bound, returns the first event (ts = 1)
 299         final ITmfContext context = fTrace.seekEvent(new TmfTimestamp(0, SCALE, 0));
 300
 301         // Read NB_EVENTS
 302         ITmfEvent event;
 303         for (int i = 0; i < NB_READS; i++) {
 304             event = fTrace.getNextEvent(context);
 305             assertEquals("Event timestamp", i + 1, event.getTimestamp().getValue());
 306             assertEquals("Event rank", i + 1, context.getRank());
 307         }
 308
 309         // Make sure we stay positioned
 310         event = fTrace.parseEvent(context);
 311         assertEquals("Event timestamp", NB_READS + 1, event.getTimestamp().getValue());
 312         assertEquals("Event rank", NB_READS, context.getRank());
 313     }
 314
 315     // ------------------------------------------------------------------------
 316     // seekLocation
 317     // Note: seekLocation() does not reliably set the rank
 318     // ------------------------------------------------------------------------
 319
 320     public void testSeekLocationOnCacheBoundary() throws Exception {
 321
 322         // Position trace at event rank 0
 323         TmfContext context = fTrace.seekLocation(null);
 324         ITmfEvent event = fTrace.parseEvent(context);
 325         assertEquals("Event timestamp", 1, event.getTimestamp().getValue());
 326         assertEquals("Event rank", 0, context.getRank());
 327
 328         context = fTrace.seekLocation(context.getLocation());
 329         assertEquals("Event rank", ITmfContext.UNKNOWN_RANK, context.getRank());
 330
 331         event = fTrace.parseEvent(context);
 332         assertEquals("Event timestamp", 1, event.getTimestamp().getValue());
 333         assertEquals("Event rank", ITmfContext.UNKNOWN_RANK, context.getRank());
 334
 335         event = fTrace.getNextEvent(context);
 336         assertEquals("Event timestamp", 1, event.getTimestamp().getValue());
 337         assertEquals("Event rank", ITmfContext.UNKNOWN_RANK, context.getRank());
 338
 339         // Position trace at event rank 1000
 340         ITmfContext tmpContext = fTrace.seekEvent(new TmfTimestamp(1001, SCALE, 0));
 341         context = fTrace.seekLocation(tmpContext.getLocation());
 342         assertEquals("Event rank", ITmfContext.UNKNOWN_RANK, context.getRank());
 343
 344         event = fTrace.parseEvent(context);
 345         assertEquals("Event timestamp", 1001, event.getTimestamp().getValue());
 346         assertEquals("Event rank", ITmfContext.UNKNOWN_RANK, context.getRank());
 347
 348         event = fTrace.getNextEvent(context);
 349         assertEquals("Event timestamp", 1001, event.getTimestamp().getValue());
 350         assertEquals("Event rank", ITmfContext.UNKNOWN_RANK, context.getRank());
 351
 352         // Position trace at event rank 4000
 353         tmpContext = fTrace.seekEvent(new TmfTimestamp(4001, SCALE, 0));
 354         context = fTrace.seekLocation(tmpContext.getLocation());
 355         assertEquals("Event rank", ITmfContext.UNKNOWN_RANK, context.getRank());
 356
 357         event = fTrace.parseEvent(context);
 358         assertEquals("Event timestamp", 4001, event.getTimestamp().getValue());
 359         assertEquals("Event rank", ITmfContext.UNKNOWN_RANK, context.getRank());
 360
 361         event = fTrace.getNextEvent(context);
 362         assertEquals("Event timestamp", 4001, event.getTimestamp().getValue());
 363         assertEquals("Event rank", ITmfContext.UNKNOWN_RANK, context.getRank());
 364     }
 365
 366     public void testSeekLocationNotOnCacheBoundary() throws Exception {
 367
 368         // Position trace at event rank 9
 369         ITmfContext tmpContext = fTrace.seekEvent(new TmfTimestamp(10, SCALE, 0));
 370         TmfContext context = fTrace.seekLocation(tmpContext.getLocation());
 371         assertEquals("Event rank", ITmfContext.UNKNOWN_RANK, context.getRank());
 372
 373         ITmfEvent event = fTrace.parseEvent(context);
 374         assertEquals("Event timestamp", 10, event.getTimestamp().getValue());
 375         assertEquals("Event rank", ITmfContext.UNKNOWN_RANK, context.getRank());
 376
 377         event = fTrace.getNextEvent(context);
 378         assertEquals("Event timestamp", 10, event.getTimestamp().getValue());
 379         assertEquals("Event rank", ITmfContext.UNKNOWN_RANK, context.getRank());
 380
 381         // Position trace at event rank 999
 382         tmpContext = fTrace.seekEvent(new TmfTimestamp(1000, SCALE, 0));
 383         context = fTrace.seekLocation(tmpContext.getLocation());
 384         assertEquals("Event rank", ITmfContext.UNKNOWN_RANK, context.getRank());
 385
 386         event = fTrace.parseEvent(context);
 387         assertEquals("Event timestamp", 1000, event.getTimestamp().getValue());
 388         assertEquals("Event rank", ITmfContext.UNKNOWN_RANK, context.getRank());
 389
 390         event = fTrace.getNextEvent(context);
 391         assertEquals("Event timestamp", 1000, event.getTimestamp().getValue());
 392         assertEquals("Event rank", ITmfContext.UNKNOWN_RANK, context.getRank());
 393
 394         // Position trace at event rank 1001
 395         tmpContext = fTrace.seekEvent(new TmfTimestamp(1002, SCALE, 0));
 396         context = fTrace.seekLocation(tmpContext.getLocation());
 397         assertEquals("Event rank", ITmfContext.UNKNOWN_RANK, context.getRank());
 398
 399         event = fTrace.parseEvent(context);
 400         assertEquals("Event timestamp", 1002, event.getTimestamp().getValue());
 401         assertEquals("Event rank", ITmfContext.UNKNOWN_RANK, context.getRank());
 402
 403         event = fTrace.getNextEvent(context);
 404         assertEquals("Event timestamp", 1002, event.getTimestamp().getValue());
 405         assertEquals("Event rank", ITmfContext.UNKNOWN_RANK, context.getRank());
 406
 407         // Position trace at event rank 4500
 408         tmpContext = fTrace.seekEvent(new TmfTimestamp(4501, SCALE, 0));
 409         context = fTrace.seekLocation(tmpContext.getLocation());
 410         assertEquals("Event rank", ITmfContext.UNKNOWN_RANK, context.getRank());
 411
 412         event = fTrace.parseEvent(context);
 413         assertEquals("Event timestamp", 4501, event.getTimestamp().getValue());
 414         assertEquals("Event rank", ITmfContext.UNKNOWN_RANK, context.getRank());
 415
 416         event = fTrace.getNextEvent(context);
 417         assertEquals("Event timestamp", 4501, event.getTimestamp().getValue());
 418         assertEquals("Event rank", ITmfContext.UNKNOWN_RANK, context.getRank());
 419     }
 420
 421     public void testSeekLocationOutOfScope() throws Exception {
 422
 423         // Position trace at beginning
 424         ITmfContext tmpContext = fTrace.seekLocation(null);
 425         ITmfContext context = fTrace.seekLocation(tmpContext.getLocation());
 426         assertEquals("Event rank", ITmfContext.UNKNOWN_RANK, context.getRank());
 427
 428         ITmfEvent event = fTrace.parseEvent(context);
 429         assertEquals("Event timestamp", 1, event.getTimestamp().getValue());
 430         assertEquals("Event rank", ITmfContext.UNKNOWN_RANK, context.getRank());
 431
 432         event = fTrace.getNextEvent(context);
 433         assertEquals("Event timestamp", 1, event.getTimestamp().getValue());
 434         assertEquals("Event rank", ITmfContext.UNKNOWN_RANK, context.getRank());
 435
 436         // Position trace at event passed the end
 437         tmpContext = fTrace.seekEvent(new TmfTimestamp(NB_EVENTS + 1, SCALE, 0));
 438         context = fTrace.seekLocation(tmpContext.getLocation());
 439         assertEquals("Event rank", ITmfContext.UNKNOWN_RANK, context.getRank());
 440
 441         event = fTrace.parseEvent(context);
 442         assertEquals("Event timestamp", null, event);
 443         assertEquals("Event rank", ITmfContext.UNKNOWN_RANK, context.getRank());
 444
 445         event = fTrace.getNextEvent(context);
 446         assertEquals("Event timestamp", null, event);
 447         assertEquals("Event rank", ITmfContext.UNKNOWN_RANK, context.getRank());
 448     }
 449
 450     // ------------------------------------------------------------------------
 451     // seekEvent on timestamp
 452     // ------------------------------------------------------------------------
 453
 454     public void testSeekEventOnTimestampOnCacheBoundary() throws Exception {
 455
 456         // Position trace at event rank 0
 457         ITmfContext context = fTrace.seekEvent(new TmfTimestamp(1, SCALE, 0));
 458         assertEquals("Event rank", 0, context.getRank());
 459
 460         ITmfEvent event = fTrace.parseEvent(context);
 461         assertEquals("Event timestamp", 1, event.getTimestamp().getValue());
 462         assertEquals("Event rank", 0, context.getRank());
 463
 464         event = fTrace.getNextEvent(context);
 465         assertEquals("Event timestamp", 1, event.getTimestamp().getValue());
 466         assertEquals("Event rank", 1, context.getRank());
 467
 468         // Position trace at event rank 1000
 469         context = fTrace.seekEvent(new TmfTimestamp(1001, SCALE, 0));
 470         assertEquals("Event rank", 1000, context.getRank());
 471
 472         event = fTrace.parseEvent(context);
 473         assertEquals("Event timestamp", 1001, event.getTimestamp().getValue());
 474         assertEquals("Event rank", 1000, context.getRank());
 475
 476         event = fTrace.getNextEvent(context);
 477         assertEquals("Event timestamp", 1001, event.getTimestamp().getValue());
 478         assertEquals("Event rank", 1001, context.getRank());
 479
 480         // Position trace at event rank 4000
 481         context = fTrace.seekEvent(new TmfTimestamp(4001, SCALE, 0));
 482         assertEquals("Event rank", 4000, context.getRank());
 483
 484         event = fTrace.parseEvent(context);
 485         assertEquals("Event timestamp", 4001, event.getTimestamp().getValue());
 486         assertEquals("Event rank", 4000, context.getRank());
 487
 488         event = fTrace.getNextEvent(context);
 489         assertEquals("Event timestamp", 4001, event.getTimestamp().getValue());
 490         assertEquals("Event rank", 4001, context.getRank());
 491     }
 492
 493     public void testSeekEventOnTimestampNotOnCacheBoundary() throws Exception {
 494
 495         // Position trace at event rank 1
 496         ITmfContext context = fTrace.seekEvent(new TmfTimestamp(2, SCALE, 0));
 497         assertEquals("Event rank", 1, context.getRank());
 498
 499         ITmfEvent event = fTrace.parseEvent(context);
 500         assertEquals("Event timestamp", 2, event.getTimestamp().getValue());
 501         assertEquals("Event rank", 1, context.getRank());
 502
 503         event = fTrace.getNextEvent(context);
 504         assertEquals("Event timestamp", 2, event.getTimestamp().getValue());
 505         assertEquals("Event rank", 2, context.getRank());
 506
 507         // Position trace at event rank 9
 508         context = fTrace.seekEvent(new TmfTimestamp(10, SCALE, 0));
 509         assertEquals("Event rank", 9, context.getRank());
 510
 511         event = fTrace.parseEvent(context);
 512         assertEquals("Event timestamp", 10, event.getTimestamp().getValue());
 513         assertEquals("Event rank", 9, context.getRank());
 514
 515         event = fTrace.getNextEvent(context);
 516         assertEquals("Event timestamp", 10, event.getTimestamp().getValue());
 517         assertEquals("Event rank", 10, context.getRank());
 518
 519         // Position trace at event rank 999
 520         context = fTrace.seekEvent(new TmfTimestamp(1000, SCALE, 0));
 521         assertEquals("Event rank", 999, context.getRank());
 522
 523         event = fTrace.parseEvent(context);
 524         assertEquals("Event timestamp", 1000, event.getTimestamp().getValue());
 525         assertEquals("Event rank", 999, context.getRank());
 526
 527         event = fTrace.getNextEvent(context);
 528         assertEquals("Event timestamp", 1000, event.getTimestamp().getValue());
 529         assertEquals("Event rank", 1000, context.getRank());
 530
 531         // Position trace at event rank 1001
 532         context = fTrace.seekEvent(new TmfTimestamp(1002, SCALE, 0));
 533         assertEquals("Event rank", 1001, context.getRank());
 534
 535         event = fTrace.parseEvent(context);
 536         assertEquals("Event timestamp", 1002, event.getTimestamp().getValue());
 537         assertEquals("Event rank", 1001, context.getRank());
 538
 539         event = fTrace.getNextEvent(context);
 540         assertEquals("Event timestamp", 1002, event.getTimestamp().getValue());
 541         assertEquals("Event rank", 1002, context.getRank());
 542
 543         // Position trace at event rank 4500
 544         context = fTrace.seekEvent(new TmfTimestamp(4501, SCALE, 0));
 545         assertEquals("Event rank", 4500, context.getRank());
 546
 547         event = fTrace.parseEvent(context);
 548         assertEquals("Event timestamp", 4501, event.getTimestamp().getValue());
 549         assertEquals("Event rank", 4500, context.getRank());
 550
 551         event = fTrace.getNextEvent(context);
 552         assertEquals("Event timestamp", 4501, event.getTimestamp().getValue());
 553         assertEquals("Event rank", 4501, context.getRank());
 554     }
 555
 556     public void testSeekEventOnTimestampOutOfScope() throws Exception {
 557
 558         // Position trace at beginning
 559         ITmfContext context = fTrace.seekEvent(new TmfTimestamp(-1, SCALE, 0));
 560         assertEquals("Event rank", 0, context.getRank());
 561
 562         ITmfEvent event = fTrace.parseEvent(context);
 563         assertEquals("Event timestamp", 1, event.getTimestamp().getValue());
 564         assertEquals("Event rank", 0, context.getRank());
 565
 566         event = fTrace.getNextEvent(context);
 567         assertEquals("Event timestamp", 1, event.getTimestamp().getValue());
 568         assertEquals("Event rank", 1, context.getRank());
 569
 570         // Position trace at event passed the end
 571         context = fTrace.seekEvent(new TmfTimestamp(NB_EVENTS + 1, SCALE, 0));
 572         assertEquals("Event rank", NB_EVENTS, context.getRank());
 573
 574         event = fTrace.parseEvent(context);
 575         assertEquals("Event timestamp", null, event);
 576         assertEquals("Event rank", NB_EVENTS, context.getRank());
 577
 578         event = fTrace.getNextEvent(context);
 579         assertEquals("Event timestamp", null, event);
 580         assertEquals("Event rank", NB_EVENTS, context.getRank());
 581     }
 582
 583     // ------------------------------------------------------------------------
 584     // seekEvent on rank
 585     // ------------------------------------------------------------------------
 586
 587     public void testSeekOnRankOnCacheBoundary() throws Exception {
 588
 589         // On lower bound, returns the first event (ts = 1)
 590         ITmfContext context = fTrace.seekEvent(0);
 591         assertEquals("Event rank", 0, context.getRank());
 592
 593         ITmfEvent event = fTrace.parseEvent(context);
 594         assertEquals("Event timestamp", 1, event.getTimestamp().getValue());
 595         assertEquals("Event rank", 0, context.getRank());
 596
 597         event = fTrace.getNextEvent(context);
 598         assertEquals("Event timestamp", 1, event.getTimestamp().getValue());
 599         assertEquals("Event rank", 1, context.getRank());
 600
 601         // Position trace at event rank 1000
 602         context = fTrace.seekEvent(1000);
 603         assertEquals("Event rank", 1000, context.getRank());
 604
 605         event = fTrace.parseEvent(context);
 606         assertEquals("Event timestamp", 1001, event.getTimestamp().getValue());
 607         assertEquals("Event rank", 1000, context.getRank());
 608
 609         event = fTrace.getNextEvent(context);
 610         assertEquals("Event timestamp", 1001, event.getTimestamp().getValue());
 611         assertEquals("Event rank", 1001, context.getRank());
 612
 613         // Position trace at event rank 4000
 614         context = fTrace.seekEvent(4000);
 615         assertEquals("Event rank", 4000, context.getRank());
 616
 617         event = fTrace.parseEvent(context);
 618         assertEquals("Event timestamp", 4001, event.getTimestamp().getValue());
 619         assertEquals("Event rank", 4000, context.getRank());
 620
 621         event = fTrace.getNextEvent(context);
 622         assertEquals("Event timestamp", 4001, event.getTimestamp().getValue());
 623         assertEquals("Event rank", 4001, context.getRank());
 624     }
 625
 626     public void testSeekOnRankNotOnCacheBoundary() throws Exception {
 627
 628         // Position trace at event rank 9
 629         ITmfContext context = fTrace.seekEvent(9);
 630         assertEquals("Event rank", 9, context.getRank());
 631
 632         ITmfEvent event = fTrace.parseEvent(context);
 633         assertEquals("Event timestamp", 10, event.getTimestamp().getValue());
 634         assertEquals("Event rank", 9, context.getRank());
 635
 636         event = fTrace.getNextEvent(context);
 637         assertEquals("Event timestamp", 10, event.getTimestamp().getValue());
 638         assertEquals("Event rank", 10, context.getRank());
 639
 640         // Position trace at event rank 999
 641         context = fTrace.seekEvent(999);
 642         assertEquals("Event rank", 999, context.getRank());
 643
 644         event = fTrace.parseEvent(context);
 645         assertEquals("Event timestamp", 1000, event.getTimestamp().getValue());
 646         assertEquals("Event rank", 999, context.getRank());
 647
 648         event = fTrace.getNextEvent(context);
 649         assertEquals("Event timestamp", 1000, event.getTimestamp().getValue());
 650         assertEquals("Event rank", 1000, context.getRank());
 651
 652         // Position trace at event rank 1001
 653         context = fTrace.seekEvent(1001);
 654         assertEquals("Event rank", 1001, context.getRank());
 655
 656         event = fTrace.parseEvent(context);
 657         assertEquals("Event timestamp", 1002, event.getTimestamp().getValue());
 658         assertEquals("Event rank", 1001, context.getRank());
 659
 660         event = fTrace.getNextEvent(context);
 661         assertEquals("Event timestamp", 1002, event.getTimestamp().getValue());
 662         assertEquals("Event rank", 1002, context.getRank());
 663
 664         // Position trace at event rank 4500
 665         context = fTrace.seekEvent(4500);
 666         assertEquals("Event rank", 4500, context.getRank());
 667
 668         event = fTrace.parseEvent(context);
 669         assertEquals("Event timestamp", 4501, event.getTimestamp().getValue());
 670         assertEquals("Event rank", 4500, context.getRank());
 671
 672         event = fTrace.getNextEvent(context);
 673         assertEquals("Event timestamp", 4501, event.getTimestamp().getValue());
 674         assertEquals("Event rank", 4501, context.getRank());
 675     }
 676
 677     public void testSeekEventOnRankOfScope() throws Exception {
 678
 679         // Position trace at beginning
 680         ITmfContext context = fTrace.seekEvent(-1);
 681         assertEquals("Event rank", 0, context.getRank());
 682
 683         ITmfEvent event = fTrace.parseEvent(context);
 684         assertEquals("Event timestamp", 1, event.getTimestamp().getValue());
 685         assertEquals("Event rank", 0, context.getRank());
 686
 687         event = fTrace.getNextEvent(context);
 688         assertEquals("Event timestamp", 1, event.getTimestamp().getValue());
 689         assertEquals("Event rank", 1, context.getRank());
 690
 691         // Position trace at event passed the end
 692         context = fTrace.seekEvent(NB_EVENTS);
 693         assertEquals("Event rank", NB_EVENTS, context.getRank());
 694
 695         event = fTrace.parseEvent(context);
 696         assertEquals("Event timestamp", null, event);
 697         assertEquals("Event rank", NB_EVENTS, context.getRank());
 698
 699         event = fTrace.getNextEvent(context);
 700         assertEquals("Event timestamp", null, event);
 701         assertEquals("Event rank", NB_EVENTS, context.getRank());
 702     }
 703
 704     // ------------------------------------------------------------------------
 705     // processRequest
 706     // ------------------------------------------------------------------------
 707
 708     @SuppressWarnings("unchecked")
 709     public void testProcessRequestForNbEvents() throws Exception {
 710         final int BLOCK_SIZE = 100;
 711         final int NB_EVENTS  = 1000;
 712         final Vector<TmfEvent> requestedEvents = new Vector<TmfEvent>();
 713
 714         final TmfTimeRange range = new TmfTimeRange(TmfTimestamp.BIG_BANG, TmfTimestamp.BIG_CRUNCH);
 715         final TmfEventRequest<TmfEvent> request = new TmfEventRequest<TmfEvent>(TmfEvent.class, range, NB_EVENTS, BLOCK_SIZE) {
 716             @Override
 717             public void handleData(final TmfEvent event) {
 718                 super.handleData(event);
 719                 requestedEvents.add(event);
 720             }
 721         };
 722         final ITmfDataProvider<TmfEvent>[] providers = (ITmfDataProvider<TmfEvent>[]) TmfProviderManager.getProviders(TmfEvent.class, TmfTraceStub.class);
 723         providers[0].sendRequest(request);
 724         request.waitForCompletion();
 725
 726         assertEquals("nbEvents", NB_EVENTS, requestedEvents.size());
 727         assertTrue("isCompleted",  request.isCompleted());
 728         assertFalse("isCancelled", request.isCancelled());
 729
 730         // Ensure that we have distinct events.
 731         // Don't go overboard: we are not validating the stub!
 732         for (int i = 0; i < NB_EVENTS; i++)
 733             assertEquals("Distinct events", i+1, requestedEvents.get(i).getTimestamp().getValue());
 734     }
 735
 736     @SuppressWarnings("unchecked")
 737     public void testProcessRequestForAllEvents() throws Exception {
 738         final int BLOCK_SIZE =  1;
 739         final Vector<TmfEvent> requestedEvents = new Vector<TmfEvent>();
 740
 741         final TmfTimeRange range = new TmfTimeRange(TmfTimestamp.BIG_BANG, TmfTimestamp.BIG_CRUNCH);
 742         final TmfEventRequest<TmfEvent> request = new TmfEventRequest<TmfEvent>(TmfEvent.class, range, NB_EVENTS, BLOCK_SIZE) {
 743             @Override
 744             public void handleData(final TmfEvent event) {
 745                 super.handleData(event);
 746                 requestedEvents.add(event);
 747             }
 748         };
 749         final ITmfDataProvider<TmfEvent>[] providers = (ITmfDataProvider<TmfEvent>[]) TmfProviderManager.getProviders(TmfEvent.class, TmfTraceStub.class);
 750         providers[0].sendRequest(request);
 751         request.waitForCompletion();
 752
 753         assertEquals("nbEvents", NB_EVENTS, requestedEvents.size());
 754         assertTrue("isCompleted",  request.isCompleted());
 755         assertFalse("isCancelled", request.isCancelled());
 756
 757         // Ensure that we have distinct events.
 758         // Don't go overboard: we are not validating the stub!
 759         for (int i = 0; i < NB_EVENTS; i++)
 760             assertEquals("Distinct events", i+1, requestedEvents.get(i).getTimestamp().getValue());
 761     }
 762
 763     // ------------------------------------------------------------------------
 764     // cancel
 765     // ------------------------------------------------------------------------
 766
 767     @SuppressWarnings("unchecked")
 768     public void testCancel() throws Exception {
 769         final Vector<TmfEvent> requestedEvents = new Vector<TmfEvent>();
 770
 771         final TmfTimeRange range = new TmfTimeRange(TmfTimestamp.BIG_BANG, TmfTimestamp.BIG_CRUNCH);
 772         final TmfEventRequest<TmfEvent> request = new TmfEventRequest<TmfEvent>(TmfEvent.class, range, NB_EVENTS, BLOCK_SIZE) {
 773             int nbRead = 0;
 774             @Override
 775             public void handleData(final TmfEvent event) {
 776                 super.handleData(event);
 777                 requestedEvents.add(event);
 778                 if (++nbRead == BLOCK_SIZE)
 779                     cancel();
 780             }
 781         };
 782         final ITmfDataProvider<TmfEvent>[] providers = (ITmfDataProvider<TmfEvent>[]) TmfProviderManager.getProviders(TmfEvent.class, TmfTraceStub.class);
 783         providers[0].sendRequest(request);
 784         request.waitForCompletion();
 785
 786         assertEquals("nbEvents",  BLOCK_SIZE, requestedEvents.size());
 787         assertTrue("isCompleted", request.isCompleted());
 788         assertTrue("isCancelled", request.isCancelled());
 789     }
 790
 791 }