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