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