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