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