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