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