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