org.eclipse.linuxtools.tmf.core.tests/src/org/eclipse/linuxtools/tmf/core/tests/trace/TmfMultiTraceExperimentTest.java

   1 /*******************************************************************************
   2  * Copyright (c) 2009, 2010, 2012 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  *   Francois Chouinard - Adjusted for new Trace Model
  12  *******************************************************************************/
  13
  14 package org.eclipse.linuxtools.tmf.core.tests.trace;
  15
  16 import java.io.File;
  17 import java.io.IOException;
  18 import java.net.URISyntaxException;
  19 import java.net.URL;
  20 import java.util.Vector;
  21
  22 import junit.framework.TestCase;
  23
  24 import org.eclipse.core.runtime.FileLocator;
  25 import org.eclipse.core.runtime.Path;
  26 import org.eclipse.linuxtools.tmf.core.event.ITmfEvent;
  27 import org.eclipse.linuxtools.tmf.core.event.TmfEvent;
  28 import org.eclipse.linuxtools.tmf.core.event.TmfTimeRange;
  29 import org.eclipse.linuxtools.tmf.core.event.TmfTimestamp;
  30 import org.eclipse.linuxtools.tmf.core.exceptions.TmfTraceException;
  31 import org.eclipse.linuxtools.tmf.core.request.TmfDataRequest;
  32 import org.eclipse.linuxtools.tmf.core.request.TmfEventRequest;
  33 import org.eclipse.linuxtools.tmf.core.tests.TmfCoreTestPlugin;
  34 import org.eclipse.linuxtools.tmf.core.trace.ITmfContext;
  35 import org.eclipse.linuxtools.tmf.core.trace.ITmfLocation;
  36 import org.eclipse.linuxtools.tmf.core.trace.ITmfTrace;
  37 import org.eclipse.linuxtools.tmf.tests.stubs.trace.TmfExperimentStub;
  38 import org.eclipse.linuxtools.tmf.tests.stubs.trace.TmfTraceStub;
  39
  40 /**
  41  * Test suite for the TmfExperiment class (multiple traces).
  42  */
  43 @SuppressWarnings("nls")
  44 public class TmfMultiTraceExperimentTest extends TestCase {
  45
  46     // ------------------------------------------------------------------------
  47     // Attributes
  48     // ------------------------------------------------------------------------
  49
  50     private static final String DIRECTORY    = "testfiles";
  51     private static final String TEST_STREAM1 = "O-Test-10K";
  52     private static final String TEST_STREAM2 = "E-Test-10K";
  53     private static final String EXPERIMENT   = "MyExperiment";
  54     private static int          NB_EVENTS    = 20000;
  55     private static int          BLOCK_SIZE   = 1000;
  56
  57     private static ITmfTrace<TmfEvent>[] fTraces;
  58     private static TmfExperimentStub<TmfEvent> fExperiment;
  59
  60     private static byte SCALE = (byte) -3;
  61
  62     // ------------------------------------------------------------------------
  63     // Housekeeping
  64     // ------------------------------------------------------------------------
  65
  66     @SuppressWarnings("unchecked")
  67     private synchronized static ITmfTrace<?>[] setupTrace(final String path1, final String path2) {
  68         if (fTraces == null) {
  69             fTraces = new ITmfTrace[2];
  70             try {
  71                 URL location = FileLocator.find(TmfCoreTestPlugin.getDefault().getBundle(), new Path(path1), null);
  72                 File test = new File(FileLocator.toFileURL(location).toURI());
  73                 final TmfTraceStub trace1 = new TmfTraceStub(test.getPath(), 0, true);
  74                 fTraces[0] = trace1;
  75                 location = FileLocator.find(TmfCoreTestPlugin.getDefault().getBundle(), new Path(path2), null);
  76                 test = new File(FileLocator.toFileURL(location).toURI());
  77                 final TmfTraceStub trace2 = new TmfTraceStub(test.getPath(), 0, true);
  78                 fTraces[1] = trace2;
  79             } catch (final TmfTraceException e) {
  80                 e.printStackTrace();
  81             } catch (final URISyntaxException e) {
  82                 e.printStackTrace();
  83             } catch (final IOException e) {
  84                 e.printStackTrace();
  85             }
  86         }
  87         return fTraces;
  88     }
  89
  90     public TmfMultiTraceExperimentTest(final String name) throws Exception {
  91         super(name);
  92     }
  93
  94     @Override
  95     protected synchronized void setUp() throws Exception {
  96         super.setUp();
  97         setupTrace(DIRECTORY + File.separator + TEST_STREAM1, DIRECTORY + File.separator + TEST_STREAM2);
  98         if (fExperiment == null) {
  99             fExperiment = new TmfExperimentStub<TmfEvent>(EXPERIMENT, fTraces, BLOCK_SIZE);
 100             fExperiment.getIndexer().buildIndex(0, TmfTimeRange.ETERNITY, true);
 101         }
 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("GetNbEvents", NB_EVENTS, fExperiment.getNbEvents());
 117
 118         final TmfTimeRange timeRange = fExperiment.getTimeRange();
 119         assertEquals("getStartTime", 1, timeRange.getStartTime().getValue());
 120         assertEquals("getEndTime", NB_EVENTS, timeRange.getEndTime().getValue());
 121     }
 122
 123     // ------------------------------------------------------------------------
 124     // seekEvent on rank
 125     // ------------------------------------------------------------------------
 126
 127     public void testSeekRankOnCacheBoundary() throws Exception {
 128
 129         long cacheSize = fExperiment.getCacheSize();
 130
 131         // On lower bound, returns the first event (TS = 1)
 132         ITmfContext context = fExperiment.seekEvent(0);
 133         assertEquals("Context rank", 0, context.getRank());
 134
 135         ITmfEvent event = fExperiment.getNext(context);
 136         assertEquals("Event timestamp", 1, event.getTimestamp().getValue());
 137         assertEquals("Context rank", 1, context.getRank());
 138
 139         // Position trace at event rank [cacheSize]
 140         context = fExperiment.seekEvent(cacheSize);
 141         assertEquals("Context rank", cacheSize, context.getRank());
 142
 143         event = fExperiment.getNext(context);
 144         assertEquals("Event timestamp", cacheSize + 1, event.getTimestamp().getValue());
 145         assertEquals("Context rank", cacheSize + 1, context.getRank());
 146
 147         // Position trace at event rank [4 * cacheSize]
 148         context = fExperiment.seekEvent(4 * cacheSize);
 149         assertEquals("Context rank", 4 * cacheSize, context.getRank());
 150
 151         event = fExperiment.getNext(context);
 152         assertEquals("Event timestamp", 4 * cacheSize + 1, event.getTimestamp().getValue());
 153         assertEquals("Context rank", 4 * cacheSize + 1, context.getRank());
 154     }
 155
 156     public void testSeekRankNotOnCacheBoundary() throws Exception {
 157
 158         long cacheSize = fExperiment.getCacheSize();
 159
 160         // Position trace at event rank 9
 161         ITmfContext context = fExperiment.seekEvent(9);
 162         assertEquals("Context rank", 9, context.getRank());
 163
 164         ITmfEvent event = fExperiment.getNext(context);
 165         assertEquals("Event timestamp", 10, event.getTimestamp().getValue());
 166         assertEquals("Context rank", 10, context.getRank());
 167
 168         // Position trace at event rank [cacheSize - 1]
 169         context = fExperiment.seekEvent(cacheSize - 1);
 170         assertEquals("Context rank", cacheSize - 1, context.getRank());
 171
 172         event = fExperiment.getNext(context);
 173         assertEquals("Event timestamp", cacheSize, event.getTimestamp().getValue());
 174         assertEquals("Context rank", cacheSize, context.getRank());
 175
 176         // Position trace at event rank [cacheSize + 1]
 177         context = fExperiment.seekEvent(cacheSize + 1);
 178         assertEquals("Context rank", cacheSize + 1, context.getRank());
 179
 180         event = fExperiment.getNext(context);
 181         assertEquals("Event timestamp", cacheSize + 2, event.getTimestamp().getValue());
 182         assertEquals("Context rank", cacheSize + 2, context.getRank());
 183
 184         // Position trace at event rank 4500
 185         context = fExperiment.seekEvent(4500);
 186         assertEquals("Context rank", 4500, context.getRank());
 187
 188         event = fExperiment.getNext(context);
 189         assertEquals("Event timestamp", 4501, event.getTimestamp().getValue());
 190         assertEquals("Context rank", 4501, context.getRank());
 191     }
 192
 193     public void testSeekRankOutOfScope() throws Exception {
 194
 195         // Position trace at beginning
 196         ITmfContext context = fExperiment.seekEvent(-1);
 197         assertEquals("Event rank", 0, context.getRank());
 198
 199         ITmfEvent event = fExperiment.getNext(context);
 200         assertEquals("Event timestamp", 1, event.getTimestamp().getValue());
 201         assertEquals("Context rank", 1, context.getRank());
 202
 203         // Position trace at event passed the end
 204         context = fExperiment.seekEvent(NB_EVENTS);
 205         assertEquals("Context rank", NB_EVENTS, context.getRank());
 206
 207         event = fExperiment.getNext(context);
 208         assertNull("Event", event);
 209         assertEquals("Context rank", NB_EVENTS, context.getRank());
 210     }
 211
 212     // ------------------------------------------------------------------------
 213     // seekEvent on timestamp
 214     // ------------------------------------------------------------------------
 215
 216     public void testSeekTimestampOnCacheBoundary() throws Exception {
 217
 218         long cacheSize = fExperiment.getCacheSize();
 219
 220         // Position trace at event rank 0
 221         ITmfContext context = fExperiment.seekEvent(new TmfTimestamp(1, SCALE, 0));
 222         assertEquals("Context rank", 0, context.getRank());
 223
 224         ITmfEvent event = fExperiment.getNext(context);
 225         assertEquals("Event timestamp", 1, event.getTimestamp().getValue());
 226         assertEquals("Context rank", 1, context.getRank());
 227
 228         // Position trace at event rank [cacheSize]
 229         context = fExperiment.seekEvent(new TmfTimestamp(cacheSize + 1, SCALE, 0));
 230         assertEquals("Event rank", cacheSize, context.getRank());
 231
 232         event = fExperiment.getNext(context);
 233         assertEquals("Event timestamp", cacheSize + 1, event.getTimestamp().getValue());
 234         assertEquals("Context rank", cacheSize + 1, context.getRank());
 235
 236         // Position trace at event rank [4 * cacheSize]
 237         context = fExperiment.seekEvent(new TmfTimestamp(4 * cacheSize + 1, SCALE, 0));
 238         assertEquals("Context rank", 4 * cacheSize, context.getRank());
 239
 240         event = fExperiment.getNext(context);
 241         assertEquals("Event timestamp", 4 * cacheSize + 1, event.getTimestamp().getValue());
 242         assertEquals("Context rank", 4 * cacheSize + 1, context.getRank());
 243     }
 244
 245     public void testSeekTimestampNotOnCacheBoundary() throws Exception {
 246
 247         // Position trace at event rank 1 (TS = 2)
 248         ITmfContext context = fExperiment.seekEvent(new TmfTimestamp(2, SCALE, 0));
 249         assertEquals("Context rank", 1, context.getRank());
 250
 251         ITmfEvent event = fExperiment.getNext(context);
 252         assertEquals("Event timestamp", 2, event.getTimestamp().getValue());
 253         assertEquals("Context rank", 2, context.getRank());
 254
 255         // Position trace at event rank 9 (TS = 10)
 256         context = fExperiment.seekEvent(new TmfTimestamp(10, SCALE, 0));
 257         assertEquals("Context rank", 9, context.getRank());
 258
 259         event = fExperiment.getNext(context);
 260         assertEquals("Event timestamp", 10, event.getTimestamp().getValue());
 261         assertEquals("Context rank", 10, context.getRank());
 262
 263         // Position trace at event rank 999 (TS = 1000)
 264         context = fExperiment.seekEvent(new TmfTimestamp(1000, SCALE, 0));
 265         assertEquals("Context rank", 999, context.getRank());
 266
 267         event = fExperiment.getNext(context);
 268         assertEquals("Event timestamp", 1000, event.getTimestamp().getValue());
 269         assertEquals("Context rank", 1000, context.getRank());
 270
 271         // Position trace at event rank 1001 (TS = 1002)
 272         context = fExperiment.seekEvent(new TmfTimestamp(1002, SCALE, 0));
 273         assertEquals("Context rank", 1001, context.getRank());
 274
 275         event = fExperiment.getNext(context);
 276         assertEquals("Event timestamp", 1002, event.getTimestamp().getValue());
 277         assertEquals("Context rank", 1002, context.getRank());
 278
 279         // Position trace at event rank 4500 (TS = 4501)
 280         context = fExperiment.seekEvent(new TmfTimestamp(4501, SCALE, 0));
 281         assertEquals("Context rank", 4500, context.getRank());
 282
 283         event = fExperiment.getNext(context);
 284         assertEquals("Event timestamp", 4501, event.getTimestamp().getValue());
 285         assertEquals("Context rank", 4501, context.getRank());
 286     }
 287
 288     public void testSeekTimestampOutOfScope() throws Exception {
 289
 290         // Position trace at beginning
 291         ITmfContext context = fExperiment.seekEvent(new TmfTimestamp(-1, SCALE, 0));
 292         assertEquals("Event rank", 0, context.getRank());
 293
 294         ITmfEvent event = fExperiment.getNext(context);
 295         assertEquals("Event timestamp", 1, event.getTimestamp().getValue());
 296         assertEquals("Event rank", 1, context.getRank());
 297
 298         // Position trace at event passed the end
 299         context = fExperiment.seekEvent(new TmfTimestamp(NB_EVENTS + 1, SCALE, 0));
 300         event = fExperiment.getNext(context);
 301         assertNull("Event location", event);
 302         assertEquals("Event rank", ITmfContext.UNKNOWN_RANK, context.getRank());
 303     }
 304
 305     // ------------------------------------------------------------------------
 306     // seekEvent by location (context rank is undefined)
 307     // ------------------------------------------------------------------------
 308
 309     public void testSeekLocationOnCacheBoundary() throws Exception {
 310
 311         long cacheSize = fExperiment.getCacheSize();
 312
 313         // Position trace at event rank 0
 314         ITmfContext tmpContext = fExperiment.seekEvent(0);
 315         ITmfContext context = fExperiment.seekEvent(tmpContext.getLocation());
 316
 317         ITmfEvent event = fExperiment.getNext(context);
 318         assertEquals("Event timestamp", 1, event.getTimestamp().getValue());
 319
 320         event = fExperiment.getNext(context);
 321         assertEquals("Event timestamp", 2, event.getTimestamp().getValue());
 322
 323         // Position trace at event rank 'cacheSize'
 324         tmpContext = fExperiment.seekEvent(cacheSize);
 325         context = fExperiment.seekEvent(tmpContext.getLocation());
 326
 327         event = fExperiment.getNext(context);
 328         assertEquals("Event timestamp", cacheSize + 1, event.getTimestamp().getValue());
 329
 330         event = fExperiment.getNext(context);
 331         assertEquals("Event timestamp", cacheSize + 2, event.getTimestamp().getValue());
 332
 333         // Position trace at event rank 4 * 'cacheSize'
 334         tmpContext = fExperiment.seekEvent(4 * cacheSize);
 335         context = fExperiment.seekEvent(tmpContext.getLocation());
 336
 337         event = fExperiment.getNext(context);
 338         assertEquals("Event timestamp", 4 * cacheSize + 1, event.getTimestamp().getValue());
 339
 340         event = fExperiment.getNext(context);
 341         assertEquals("Event timestamp", 4 * cacheSize + 2, event.getTimestamp().getValue());
 342     }
 343
 344     public void testSeekLocationNotOnCacheBoundary() throws Exception {
 345
 346         long cacheSize = fExperiment.getCacheSize();
 347
 348         // Position trace at event 'cacheSize' - 1
 349         ITmfContext tmpContext = fExperiment.seekEvent(cacheSize - 1);
 350         ITmfContext context = fExperiment.seekEvent(tmpContext.getLocation());
 351
 352         ITmfEvent event = fExperiment.getNext(context);
 353         assertEquals("Event timestamp", cacheSize, event.getTimestamp().getValue());
 354
 355         event = fExperiment.getNext(context);
 356         assertEquals("Event timestamp", cacheSize + 1, event.getTimestamp().getValue());
 357
 358         // Position trace at event rank 2 * 'cacheSize' - 1
 359         tmpContext = fExperiment.seekEvent(2 * cacheSize - 1);
 360         context = fExperiment.seekEvent(tmpContext.getLocation());
 361         context = fExperiment.seekEvent(2 * cacheSize - 1);
 362
 363         event = fExperiment.getNext(context);
 364         assertEquals("Event timestamp", 2 * cacheSize, event.getTimestamp().getValue());
 365
 366         event = fExperiment.getNext(context);
 367         assertEquals("Event timestamp", 2 * cacheSize + 1, event.getTimestamp().getValue());
 368
 369         // Position trace at event rank 4500
 370         tmpContext = fExperiment.seekEvent(4500);
 371         context = fExperiment.seekEvent(tmpContext.getLocation());
 372
 373         event = fExperiment.getNext(context);
 374         assertEquals("Event timestamp", 4501, event.getTimestamp().getValue());
 375
 376         event = fExperiment.getNext(context);
 377         assertEquals("Event timestamp", 4502, event.getTimestamp().getValue());
 378     }
 379
 380     public void testSeekLocationOutOfScope() throws Exception {
 381
 382         // Position trace at beginning
 383         ITmfContext context = fExperiment.seekEvent((ITmfLocation<?>) null);
 384
 385         ITmfEvent event = fExperiment.getNext(context);
 386         assertEquals("Event timestamp", 1, event.getTimestamp().getValue());
 387     }
 388
 389     // ------------------------------------------------------------------------
 390     // readtNextEvent - updates the context
 391     // ------------------------------------------------------------------------
 392
 393     public void testReadNextEvent() throws Exception {
 394
 395         // On lower bound, returns the first event (ts = 0)
 396         final ITmfContext context = fExperiment.seekEvent(0);
 397         ITmfEvent event = fExperiment.getNext(context);
 398         assertEquals("Event timestamp", 1, event.getTimestamp().getValue());
 399
 400         for (int i = 2; i < 20; i++) {
 401             event = fExperiment.getNext(context);
 402             assertEquals("Event timestamp", i, event.getTimestamp().getValue());
 403         }
 404     }
 405
 406     // ------------------------------------------------------------------------
 407     // processRequest
 408     // ------------------------------------------------------------------------
 409
 410     public void testProcessRequestForNbEvents() throws Exception {
 411
 412         final int blockSize = 100;
 413         final int nbEvents  = 1000;
 414         final Vector<TmfEvent> requestedEvents = new Vector<TmfEvent>();
 415
 416         final TmfTimeRange range = new TmfTimeRange(TmfTimestamp.BIG_BANG, TmfTimestamp.BIG_CRUNCH);
 417         final TmfEventRequest<TmfEvent> request = new TmfEventRequest<TmfEvent>(TmfEvent.class, range, nbEvents, blockSize) {
 418             @Override
 419             public void handleData(final TmfEvent event) {
 420                 super.handleData(event);
 421                 requestedEvents.add(event);
 422             }
 423         };
 424         fExperiment.sendRequest(request);
 425         request.waitForCompletion();
 426
 427         assertEquals("nbEvents", nbEvents, requestedEvents.size());
 428         assertTrue("isCompleted",  request.isCompleted());
 429         assertFalse("isCancelled", request.isCancelled());
 430
 431         // Ensure that we have distinct events.
 432         // Don't go overboard: we are not validating the stub!
 433         for (int i = 0; i < nbEvents; i++) {
 434             assertEquals("Distinct events", i+1, requestedEvents.get(i).getTimestamp().getValue());
 435         }
 436     }
 437
 438     public void testProcessRequestForNbEvents2() throws Exception {
 439
 440         final int blockSize = 2 * NB_EVENTS;
 441         final int nbEvents = 1000;
 442         final Vector<TmfEvent> requestedEvents = new Vector<TmfEvent>();
 443
 444         final TmfTimeRange range = new TmfTimeRange(TmfTimestamp.BIG_BANG, TmfTimestamp.BIG_CRUNCH);
 445         final TmfEventRequest<TmfEvent> request = new TmfEventRequest<TmfEvent>(TmfEvent.class, range, nbEvents, blockSize) {
 446             @Override
 447             public void handleData(final TmfEvent event) {
 448                 super.handleData(event);
 449                 requestedEvents.add(event);
 450             }
 451         };
 452         fExperiment.sendRequest(request);
 453         request.waitForCompletion();
 454
 455         assertEquals("nbEvents", nbEvents, requestedEvents.size());
 456         assertTrue("isCompleted",  request.isCompleted());
 457         assertFalse("isCancelled", request.isCancelled());
 458
 459         // Ensure that we have distinct events.
 460         // Don't go overboard: we are not validating the stub!
 461         for (int i = 0; i < nbEvents; i++) {
 462             assertEquals("Distinct events", i+1, requestedEvents.get(i).getTimestamp().getValue());
 463         }
 464     }
 465
 466     public void testProcessRequestForAllEvents() throws Exception {
 467
 468         final int nbEvents  = TmfDataRequest.ALL_DATA;
 469         final int blockSize =  1;
 470         final Vector<TmfEvent> requestedEvents = new Vector<TmfEvent>();
 471         final long nbExpectedEvents = NB_EVENTS;
 472
 473         final TmfTimeRange range = new TmfTimeRange(TmfTimestamp.BIG_BANG, TmfTimestamp.BIG_CRUNCH);
 474         final TmfEventRequest<TmfEvent> request = new TmfEventRequest<TmfEvent>(TmfEvent.class, range, nbEvents, blockSize) {
 475             @Override
 476             public void handleData(final TmfEvent event) {
 477                 super.handleData(event);
 478                 requestedEvents.add(event);
 479             }
 480         };
 481         fExperiment.sendRequest(request);
 482         request.waitForCompletion();
 483
 484         assertEquals("nbEvents", nbExpectedEvents, requestedEvents.size());
 485         assertTrue("isCompleted",  request.isCompleted());
 486         assertFalse("isCancelled", request.isCancelled());
 487
 488         // Ensure that we have distinct events.
 489         // Don't go overboard: we are not validating the stub!
 490         for (int i = 0; i < nbExpectedEvents; i++) {
 491             assertEquals("Distinct events", i+1, requestedEvents.get(i).getTimestamp().getValue());
 492         }
 493     }
 494
 495     // ------------------------------------------------------------------------
 496     // cancel
 497     // ------------------------------------------------------------------------
 498
 499     public void testCancel() throws Exception {
 500
 501         final int nbEvents  = NB_EVENTS;
 502         final int blockSize = BLOCK_SIZE;
 503         final Vector<TmfEvent> requestedEvents = new Vector<TmfEvent>();
 504
 505         final TmfTimeRange range = new TmfTimeRange(TmfTimestamp.BIG_BANG, TmfTimestamp.BIG_CRUNCH);
 506         final TmfEventRequest<TmfEvent> request = new TmfEventRequest<TmfEvent>(TmfEvent.class, range, nbEvents, blockSize) {
 507             int nbRead = 0;
 508             @Override
 509             public void handleData(final TmfEvent event) {
 510                 super.handleData(event);
 511                 requestedEvents.add(event);
 512                 if (++nbRead == blockSize) {
 513                     cancel();
 514                 }
 515             }
 516             @Override
 517             public void handleCancel() {
 518                 if (requestedEvents.size() < blockSize) {
 519                     System.out.println("aie");
 520                 }
 521             }
 522         };
 523         fExperiment.sendRequest(request);
 524         request.waitForCompletion();
 525
 526         assertEquals("nbEvents",  blockSize, requestedEvents.size());
 527         assertTrue("isCompleted", request.isCompleted());
 528         assertTrue("isCancelled", request.isCancelled());
 529     }
 530
 531     // ------------------------------------------------------------------------
 532     // getTimestamp
 533     // ------------------------------------------------------------------------
 534
 535     public void testGetTimestamp() throws Exception {
 536
 537         assertTrue("getTimestamp", fExperiment.getTimestamp(   0).equals(new TmfTimestamp(   1, (byte) -3)));
 538         assertTrue("getTimestamp", fExperiment.getTimestamp(  10).equals(new TmfTimestamp(  11, (byte) -3)));
 539         assertTrue("getTimestamp", fExperiment.getTimestamp( 100).equals(new TmfTimestamp( 101, (byte) -3)));
 540         assertTrue("getTimestamp", fExperiment.getTimestamp(1000).equals(new TmfTimestamp(1001, (byte) -3)));
 541         assertTrue("getTimestamp", fExperiment.getTimestamp(2000).equals(new TmfTimestamp(2001, (byte) -3)));
 542         assertTrue("getTimestamp", fExperiment.getTimestamp(2500).equals(new TmfTimestamp(2501, (byte) -3)));
 543     }
 544
 545 }