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