1 /*******************************************************************************
2 * Copyright (c) 2009, 2014 Ericsson
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
10 * Francois Chouinard - Initial API and implementation
11 * Francois Chouinard - Adjusted for new Trace Model
12 * Alexandre Montplaisir - Port to JUnit4
13 * Patrick Tasse - Updated for rank in experiment location
14 *******************************************************************************/
16 package org
.eclipse
.tracecompass
.tmf
.core
.tests
.trace
;
18 import static org
.junit
.Assert
.assertEquals
;
19 import static org
.junit
.Assert
.assertFalse
;
20 import static org
.junit
.Assert
.assertNotNull
;
21 import static org
.junit
.Assert
.assertNull
;
22 import static org
.junit
.Assert
.assertTrue
;
25 import java
.io
.IOException
;
26 import java
.net
.URISyntaxException
;
28 import java
.util
.Vector
;
30 import org
.eclipse
.core
.runtime
.FileLocator
;
31 import org
.eclipse
.core
.runtime
.Path
;
32 import org
.eclipse
.tracecompass
.internal
.tmf
.core
.component
.TmfProviderManager
;
33 import org
.eclipse
.tracecompass
.internal
.tmf
.core
.trace
.experiment
.TmfExperimentContext
;
34 import org
.eclipse
.tracecompass
.internal
.tmf
.core
.trace
.experiment
.TmfExperimentLocation
;
35 import org
.eclipse
.tracecompass
.tmf
.core
.analysis
.IAnalysisModule
;
36 import org
.eclipse
.tracecompass
.tmf
.core
.event
.ITmfEvent
;
37 import org
.eclipse
.tracecompass
.tmf
.core
.exceptions
.TmfTraceException
;
38 import org
.eclipse
.tracecompass
.tmf
.core
.request
.ITmfEventRequest
;
39 import org
.eclipse
.tracecompass
.tmf
.core
.request
.ITmfEventRequest
.ExecutionType
;
40 import org
.eclipse
.tracecompass
.tmf
.core
.request
.TmfEventRequest
;
41 import org
.eclipse
.tracecompass
.tmf
.core
.signal
.TmfTraceOpenedSignal
;
42 import org
.eclipse
.tracecompass
.tmf
.core
.tests
.TmfCoreTestPlugin
;
43 import org
.eclipse
.tracecompass
.tmf
.core
.tests
.shared
.TmfTestTrace
;
44 import org
.eclipse
.tracecompass
.tmf
.core
.timestamp
.TmfTimeRange
;
45 import org
.eclipse
.tracecompass
.tmf
.core
.timestamp
.TmfTimestamp
;
46 import org
.eclipse
.tracecompass
.tmf
.core
.trace
.ITmfContext
;
47 import org
.eclipse
.tracecompass
.tmf
.core
.trace
.ITmfTrace
;
48 import org
.eclipse
.tracecompass
.tmf
.core
.trace
.TmfTraceUtils
;
49 import org
.eclipse
.tracecompass
.tmf
.core
.trace
.experiment
.TmfExperiment
;
50 import org
.eclipse
.tracecompass
.tmf
.core
.trace
.location
.ITmfLocation
;
51 import org
.eclipse
.tracecompass
.tmf
.core
.trace
.location
.TmfLongLocation
;
52 import org
.eclipse
.tracecompass
.tmf
.tests
.stubs
.analysis
.TestExperimentAnalysis
;
53 import org
.eclipse
.tracecompass
.tmf
.tests
.stubs
.trace
.TmfExperimentStub
;
54 import org
.eclipse
.tracecompass
.tmf
.tests
.stubs
.trace
.TmfTraceStub
;
55 import org
.junit
.After
;
56 import org
.junit
.Before
;
57 import org
.junit
.Test
;
60 * Test suite for the TmfExperiment class (single trace).
62 @SuppressWarnings("javadoc")
63 public class TmfExperimentTest
{
65 // ------------------------------------------------------------------------
67 // ------------------------------------------------------------------------
69 private static final String EXPERIMENT
= "MyExperiment";
70 private static int NB_EVENTS
= 10000;
71 private static int BLOCK_SIZE
= 1000;
73 private static final double DELTA
= 1e-15;
75 private ITmfTrace
[] fTestTraces
;
76 private TmfExperimentStub fExperiment
;
78 private static byte SCALE
= (byte) -3;
80 // ------------------------------------------------------------------------
82 // ------------------------------------------------------------------------
84 private synchronized ITmfTrace
[] setupTrace(final String path
) {
85 if (fTestTraces
== null) {
86 fTestTraces
= new ITmfTrace
[1];
88 final URL location
= FileLocator
.find(TmfCoreTestPlugin
.getDefault().getBundle(), new Path(path
), null);
89 final File test
= new File(FileLocator
.toFileURL(location
).toURI());
90 final TmfTraceStub trace
= new TmfTraceStub(test
.getPath(), 0, true, null);
91 fTestTraces
[0] = trace
;
92 } catch (final TmfTraceException e
) {
94 } catch (final URISyntaxException e
) {
96 } catch (final IOException e
) {
103 private synchronized void setupExperiment() {
104 if (fExperiment
== null) {
105 fExperiment
= new TmfExperimentStub(EXPERIMENT
, fTestTraces
, BLOCK_SIZE
);
106 fExperiment
.getIndexer().buildIndex(0, TmfTimeRange
.ETERNITY
, true);
111 public void setUp() {
112 setupTrace(TmfTestTrace
.A_TEST_10K
.getFullPath());
117 public void tearDown() {
118 if (fExperiment
!= null) {
119 fExperiment
.dispose();
121 assertEquals(0, TmfProviderManager
.getProviders(ITmfEvent
.class).length
);
124 // ------------------------------------------------------------------------
126 // ------------------------------------------------------------------------
129 public void testSimpleTmfExperimentConstructor() {
130 TmfExperiment experiment
= new TmfExperiment(ITmfEvent
.class, EXPERIMENT
,
131 fTestTraces
, TmfExperiment
.DEFAULT_INDEX_PAGE_SIZE
, null);
132 assertEquals("GetId", EXPERIMENT
, experiment
.getName());
133 assertEquals("GetCacheSize", TmfExperiment
.DEFAULT_INDEX_PAGE_SIZE
, experiment
.getCacheSize());
134 experiment
.dispose();
136 experiment
= new TmfExperiment(ITmfEvent
.class, EXPERIMENT
, null,
137 TmfExperiment
.DEFAULT_INDEX_PAGE_SIZE
, null);
138 experiment
.dispose();
142 public void testNormalTmfExperimentConstructor() {
143 assertEquals("GetId", EXPERIMENT
, fExperiment
.getName());
144 assertEquals("GetNbEvents", NB_EVENTS
, fExperiment
.getNbEvents());
146 final long nbExperimentEvents
= fExperiment
.getNbEvents();
147 assertEquals("GetNbEvents", NB_EVENTS
, nbExperimentEvents
);
149 final long nbTraceEvents
= fExperiment
.getTraces().get(0).getNbEvents();
150 assertEquals("GetNbEvents", NB_EVENTS
, nbTraceEvents
);
152 final TmfTimeRange timeRange
= fExperiment
.getTimeRange();
153 assertEquals("getStartTime", 1, timeRange
.getStartTime().getValue());
154 assertEquals("getEndTime", NB_EVENTS
, timeRange
.getEndTime().getValue());
157 // ------------------------------------------------------------------------
159 // ------------------------------------------------------------------------
162 public void testExperimentInitialization() {
164 * Calling default constructor, then init should be equivalent to
165 * calling the full constructor
168 TmfExperimentStub experiment
= new TmfExperimentStub(EXPERIMENT
, fTestTraces
, 5000);
169 experiment
.getIndexer().buildIndex(0, TmfTimeRange
.ETERNITY
, true);
171 assertEquals("GetId", EXPERIMENT
, fExperiment
.getName());
172 assertEquals("GetNbEvents", NB_EVENTS
, fExperiment
.getNbEvents());
174 final long nbExperimentEvents
= fExperiment
.getNbEvents();
175 assertEquals("GetNbEvents", NB_EVENTS
, nbExperimentEvents
);
177 final long nbTraceEvents
= fExperiment
.getTraces().get(0).getNbEvents();
178 assertEquals("GetNbEvents", NB_EVENTS
, nbTraceEvents
);
180 final TmfTimeRange timeRange
= fExperiment
.getTimeRange();
181 assertEquals("getStartTime", 1, timeRange
.getStartTime().getValue());
182 assertEquals("getEndTime", NB_EVENTS
, timeRange
.getEndTime().getValue());
184 experiment
.dispose();
187 // ------------------------------------------------------------------------
189 // ------------------------------------------------------------------------
192 public void testGetTimestamp() {
193 assertEquals("getTimestamp", new TmfTimestamp( 1, (byte) -3), fExperiment
.getTimestamp( 0));
194 assertEquals("getTimestamp", new TmfTimestamp( 2, (byte) -3), fExperiment
.getTimestamp( 1));
195 assertEquals("getTimestamp", new TmfTimestamp( 11, (byte) -3), fExperiment
.getTimestamp( 10));
196 assertEquals("getTimestamp", new TmfTimestamp( 101, (byte) -3), fExperiment
.getTimestamp( 100));
197 assertEquals("getTimestamp", new TmfTimestamp( 1001, (byte) -3), fExperiment
.getTimestamp(1000));
198 assertEquals("getTimestamp", new TmfTimestamp( 2001, (byte) -3), fExperiment
.getTimestamp(2000));
199 assertEquals("getTimestamp", new TmfTimestamp( 2501, (byte) -3), fExperiment
.getTimestamp(2500));
200 assertEquals("getTimestamp", new TmfTimestamp(10000, (byte) -3), fExperiment
.getTimestamp(9999));
201 assertNull("getTimestamp", fExperiment
.getTimestamp(10000));
204 // ------------------------------------------------------------------------
205 // State system, statistics and modules methods
206 // ------------------------------------------------------------------------
209 public void testGetAnalysisModules() {
210 TmfExperiment experiment
= fExperiment
;
211 assertNotNull(experiment
);
213 /* There should not be any modules at this point */
214 Iterable
<IAnalysisModule
> modules
= experiment
.getAnalysisModules();
215 assertFalse(modules
.iterator().hasNext());
217 /* Open the experiment, the modules should be populated */
218 experiment
.traceOpened(new TmfTraceOpenedSignal(this, experiment
, null));
219 modules
= experiment
.getAnalysisModules();
220 Iterable
<TestExperimentAnalysis
> testModules
= TmfTraceUtils
.getAnalysisModulesOfClass(experiment
, TestExperimentAnalysis
.class);
221 assertTrue(modules
.iterator().hasNext());
222 assertTrue(testModules
.iterator().hasNext());
225 // ------------------------------------------------------------------------
226 // seekEvent by location
227 // ------------------------------------------------------------------------
230 public void testSeekBadLocation() {
231 ITmfContext context
= fExperiment
.seekEvent(new TmfLongLocation(0L));
232 assertNull("seekEvent", context
);
236 public void testSeekNoTrace() {
237 TmfExperiment experiment
= new TmfExperiment(ITmfEvent
.class, EXPERIMENT
,
238 null, TmfExperiment
.DEFAULT_INDEX_PAGE_SIZE
, null);
239 ITmfContext context
= experiment
.seekEvent((TmfExperimentLocation
) null);
240 validateContextRanks(context
);
241 experiment
.dispose();
244 // ------------------------------------------------------------------------
245 // seekEvent on ratio
246 // ------------------------------------------------------------------------
249 public void testSeekEventOnRatio() {
251 ITmfContext context
= fExperiment
.seekEvent(0.0);
252 assertEquals("Context rank", 0, context
.getRank());
253 ITmfEvent event
= fExperiment
.parseEvent(context
);
254 assertEquals("Event timestamp", 1, event
.getTimestamp().getValue());
255 assertEquals("Context rank", 0, context
.getRank());
258 int midTrace
= NB_EVENTS
/ 2;
259 context
= fExperiment
.seekEvent(0.5);
260 assertEquals("Context rank", midTrace
, context
.getRank());
261 event
= fExperiment
.parseEvent(context
);
262 assertEquals("Event timestamp", midTrace
+ 1, event
.getTimestamp().getValue());
263 assertEquals("Context rank", midTrace
, context
.getRank());
266 context
= fExperiment
.seekEvent(1.0);
267 assertEquals("Context rank", NB_EVENTS
, context
.getRank());
268 event
= fExperiment
.parseEvent(context
);
269 assertNull("Event timestamp", event
);
270 assertEquals("Context rank", NB_EVENTS
, context
.getRank());
273 context
= fExperiment
.seekEvent(1.1);
274 assertEquals("Context rank", NB_EVENTS
, context
.getRank());
275 event
= fExperiment
.parseEvent(context
);
276 assertNull("Event timestamp", event
);
277 assertEquals("Context rank", NB_EVENTS
, context
.getRank());
280 context
= fExperiment
.seekEvent(-0.5);
281 assertEquals("Context rank", 0, context
.getRank());
282 event
= fExperiment
.parseEvent(context
);
283 assertEquals("Event timestamp", 1, event
.getTimestamp().getValue());
284 assertEquals("Context rank", 0, context
.getRank());
288 public void testGetLocationRatio() {
290 ITmfContext context
= fExperiment
.seekEvent((ITmfLocation
) null);
291 double ratio
= fExperiment
.getLocationRatio(context
.getLocation());
292 assertEquals("getLocationRatio", 0.0, ratio
, DELTA
);
295 context
= fExperiment
.seekEvent(NB_EVENTS
/ 2);
296 ratio
= fExperiment
.getLocationRatio(context
.getLocation());
297 assertEquals("getLocationRatio", (double) (NB_EVENTS
/ 2) / NB_EVENTS
, ratio
, DELTA
);
300 context
= fExperiment
.seekEvent(NB_EVENTS
- 1);
301 ratio
= fExperiment
.getLocationRatio(context
.getLocation());
302 assertEquals("getLocationRatio", (double) (NB_EVENTS
- 1) / NB_EVENTS
, ratio
, DELTA
);
305 // @SuppressWarnings("rawtypes")
306 // public void testGetCurrentLocation() {
307 // ITmfContext context = fExperiment.seekEvent((ITmfLocation) null);
308 // ITmfLocation location = fExperiment.getCurrentLocation();
309 // assertEquals("getCurrentLocation", location, context.getLocation());
312 // ------------------------------------------------------------------------
314 // ------------------------------------------------------------------------
317 public void testSeekRankOnCacheBoundary() {
318 long cacheSize
= fExperiment
.getCacheSize();
320 // On lower bound, returns the first event (TS = 1)
321 ITmfContext context
= fExperiment
.seekEvent(0);
322 assertEquals("Context rank", 0, context
.getRank());
324 ITmfEvent event
= fExperiment
.getNext(context
);
325 assertEquals("Event timestamp", 1, event
.getTimestamp().getValue());
326 assertEquals("Context rank", 1, context
.getRank());
328 // Position trace at event rank [cacheSize]
329 context
= fExperiment
.seekEvent(cacheSize
);
330 assertEquals("Context rank", cacheSize
, context
.getRank());
332 event
= fExperiment
.getNext(context
);
333 assertEquals("Event timestamp", cacheSize
+ 1, event
.getTimestamp().getValue());
334 assertEquals("Context rank", cacheSize
+ 1, context
.getRank());
336 // Position trace at event rank [4 * cacheSize]
337 context
= fExperiment
.seekEvent(4 * cacheSize
);
338 assertEquals("Context rank", 4 * cacheSize
, context
.getRank());
340 event
= fExperiment
.getNext(context
);
341 assertEquals("Event timestamp", 4 * cacheSize
+ 1, event
.getTimestamp().getValue());
342 assertEquals("Context rank", 4 * cacheSize
+ 1, context
.getRank());
346 public void testSeekRankNotOnCacheBoundary() {
347 long cacheSize
= fExperiment
.getCacheSize();
349 // Position trace at event rank 9
350 ITmfContext context
= fExperiment
.seekEvent(9);
351 assertEquals("Context rank", 9, context
.getRank());
353 ITmfEvent event
= fExperiment
.getNext(context
);
354 assertEquals("Event timestamp", 10, event
.getTimestamp().getValue());
355 assertEquals("Context rank", 10, context
.getRank());
357 // Position trace at event rank [cacheSize - 1]
358 context
= fExperiment
.seekEvent(cacheSize
- 1);
359 assertEquals("Context rank", cacheSize
- 1, context
.getRank());
361 event
= fExperiment
.getNext(context
);
362 assertEquals("Event timestamp", cacheSize
, event
.getTimestamp().getValue());
363 assertEquals("Context rank", cacheSize
, context
.getRank());
365 // Position trace at event rank [cacheSize + 1]
366 context
= fExperiment
.seekEvent(cacheSize
+ 1);
367 assertEquals("Context rank", cacheSize
+ 1, context
.getRank());
369 event
= fExperiment
.getNext(context
);
370 assertEquals("Event timestamp", cacheSize
+ 2, event
.getTimestamp().getValue());
371 assertEquals("Context rank", cacheSize
+ 2, context
.getRank());
373 // Position trace at event rank 4500
374 context
= fExperiment
.seekEvent(4500);
375 assertEquals("Context rank", 4500, context
.getRank());
377 event
= fExperiment
.getNext(context
);
378 assertEquals("Event timestamp", 4501, event
.getTimestamp().getValue());
379 assertEquals("Context rank", 4501, context
.getRank());
383 public void testSeekRankOutOfScope() {
384 // Position trace at beginning
385 ITmfContext context
= fExperiment
.seekEvent(-1);
386 assertEquals("Event rank", 0, context
.getRank());
388 ITmfEvent event
= fExperiment
.getNext(context
);
389 assertEquals("Event timestamp", 1, event
.getTimestamp().getValue());
390 assertEquals("Context rank", 1, context
.getRank());
392 // Position trace at event passed the end
393 context
= fExperiment
.seekEvent(NB_EVENTS
);
394 assertEquals("Context rank", NB_EVENTS
, context
.getRank());
396 event
= fExperiment
.getNext(context
);
397 assertNull("Event", event
);
398 assertEquals("Context rank", NB_EVENTS
, context
.getRank());
401 // ------------------------------------------------------------------------
402 // seekEvent on timestamp
403 // ------------------------------------------------------------------------
406 public void testSeekTimestampOnCacheBoundary() {
407 long cacheSize
= fExperiment
.getCacheSize();
409 // Position trace at event rank 0
410 ITmfContext context
= fExperiment
.seekEvent(new TmfTimestamp(1, SCALE
));
411 assertEquals("Context rank", 0, context
.getRank());
413 ITmfEvent event
= fExperiment
.getNext(context
);
414 assertEquals("Event timestamp", 1, event
.getTimestamp().getValue());
415 assertEquals("Context rank", 1, context
.getRank());
417 // Position trace at event rank [cacheSize]
418 context
= fExperiment
.seekEvent(new TmfTimestamp(cacheSize
+ 1, SCALE
));
419 assertEquals("Event rank", cacheSize
, context
.getRank());
421 event
= fExperiment
.getNext(context
);
422 assertEquals("Event timestamp", cacheSize
+ 1, event
.getTimestamp().getValue());
423 assertEquals("Context rank", cacheSize
+ 1, context
.getRank());
425 // Position trace at event rank [4 * cacheSize]
426 context
= fExperiment
.seekEvent(new TmfTimestamp(4 * cacheSize
+ 1, SCALE
));
427 assertEquals("Context rank", 4 * cacheSize
, context
.getRank());
429 event
= fExperiment
.getNext(context
);
430 assertEquals("Event timestamp", 4 * cacheSize
+ 1, event
.getTimestamp().getValue());
431 assertEquals("Context rank", 4 * cacheSize
+ 1, context
.getRank());
435 public void testSeekTimestampNotOnCacheBoundary() {
436 // Position trace at event rank 1 (TS = 2)
437 ITmfContext context
= fExperiment
.seekEvent(new TmfTimestamp(2, SCALE
));
438 assertEquals("Context rank", 1, context
.getRank());
440 ITmfEvent event
= fExperiment
.getNext(context
);
441 assertEquals("Event timestamp", 2, event
.getTimestamp().getValue());
442 assertEquals("Context rank", 2, context
.getRank());
444 // Position trace at event rank 9 (TS = 10)
445 context
= fExperiment
.seekEvent(new TmfTimestamp(10, SCALE
));
446 assertEquals("Context rank", 9, context
.getRank());
448 event
= fExperiment
.getNext(context
);
449 assertEquals("Event timestamp", 10, event
.getTimestamp().getValue());
450 assertEquals("Context rank", 10, context
.getRank());
452 // Position trace at event rank 999 (TS = 1000)
453 context
= fExperiment
.seekEvent(new TmfTimestamp(1000, SCALE
));
454 assertEquals("Context rank", 999, context
.getRank());
456 event
= fExperiment
.getNext(context
);
457 assertEquals("Event timestamp", 1000, event
.getTimestamp().getValue());
458 assertEquals("Context rank", 1000, context
.getRank());
460 // Position trace at event rank 1001 (TS = 1002)
461 context
= fExperiment
.seekEvent(new TmfTimestamp(1002, SCALE
));
462 assertEquals("Context rank", 1001, context
.getRank());
464 event
= fExperiment
.getNext(context
);
465 assertEquals("Event timestamp", 1002, event
.getTimestamp().getValue());
466 assertEquals("Context rank", 1002, context
.getRank());
468 // Position trace at event rank 4500 (TS = 4501)
469 context
= fExperiment
.seekEvent(new TmfTimestamp(4501, SCALE
));
470 assertEquals("Context rank", 4500, context
.getRank());
472 event
= fExperiment
.getNext(context
);
473 assertEquals("Event timestamp", 4501, event
.getTimestamp().getValue());
474 assertEquals("Context rank", 4501, context
.getRank());
478 public void testSeekTimestampOutOfScope() {
479 // Position trace at beginning
480 ITmfContext context
= fExperiment
.seekEvent(new TmfTimestamp(-1, SCALE
));
481 assertEquals("Event rank", 0, context
.getRank());
483 ITmfEvent event
= fExperiment
.getNext(context
);
484 assertEquals("Event timestamp", 1, event
.getTimestamp().getValue());
485 assertEquals("Event rank", 1, context
.getRank());
487 // Position trace at event passed the end
488 context
= fExperiment
.seekEvent(new TmfTimestamp(NB_EVENTS
+ 1, SCALE
));
489 event
= fExperiment
.getNext(context
);
490 assertNull("Event location", event
);
491 assertEquals("Event rank", ITmfContext
.UNKNOWN_RANK
, context
.getRank());
494 // ------------------------------------------------------------------------
495 // seekEvent by location (context rank is undefined)
496 // ------------------------------------------------------------------------
499 public void testSeekLocationOnCacheBoundary() {
500 long cacheSize
= fExperiment
.getCacheSize();
502 // Position trace at event rank 0
503 ITmfContext tmpContext
= fExperiment
.seekEvent(0);
504 ITmfContext context
= fExperiment
.seekEvent(tmpContext
.getLocation());
506 ITmfEvent event
= fExperiment
.getNext(context
);
507 assertEquals("Event timestamp", 1, event
.getTimestamp().getValue());
509 event
= fExperiment
.getNext(context
);
510 assertEquals("Event timestamp", 2, event
.getTimestamp().getValue());
512 // Position trace at event rank 'cacheSize'
513 tmpContext
= fExperiment
.seekEvent(cacheSize
);
514 context
= fExperiment
.seekEvent(tmpContext
.getLocation());
516 event
= fExperiment
.getNext(context
);
517 assertEquals("Event timestamp", cacheSize
+ 1, event
.getTimestamp().getValue());
519 event
= fExperiment
.getNext(context
);
520 assertEquals("Event timestamp", cacheSize
+ 2, event
.getTimestamp().getValue());
522 // Position trace at event rank 4 * 'cacheSize'
523 tmpContext
= fExperiment
.seekEvent(4 * cacheSize
);
524 context
= fExperiment
.seekEvent(tmpContext
.getLocation());
526 event
= fExperiment
.getNext(context
);
527 assertEquals("Event timestamp", 4 * cacheSize
+ 1, event
.getTimestamp().getValue());
529 event
= fExperiment
.getNext(context
);
530 assertEquals("Event timestamp", 4 * cacheSize
+ 2, event
.getTimestamp().getValue());
534 public void testSeekLocationNotOnCacheBoundary() {
535 long cacheSize
= fExperiment
.getCacheSize();
537 // Position trace at event 'cacheSize' - 1
538 ITmfContext tmpContext
= fExperiment
.seekEvent(cacheSize
- 1);
539 ITmfContext context
= fExperiment
.seekEvent(tmpContext
.getLocation());
541 ITmfEvent event
= fExperiment
.getNext(context
);
542 assertEquals("Event timestamp", cacheSize
, event
.getTimestamp().getValue());
544 event
= fExperiment
.getNext(context
);
545 assertEquals("Event timestamp", cacheSize
+ 1, event
.getTimestamp().getValue());
547 // Position trace at event rank 2 * 'cacheSize' - 1
548 tmpContext
= fExperiment
.seekEvent(2 * cacheSize
- 1);
549 context
= fExperiment
.seekEvent(tmpContext
.getLocation());
550 context
= fExperiment
.seekEvent(2 * cacheSize
- 1);
552 event
= fExperiment
.getNext(context
);
553 assertEquals("Event timestamp", 2 * cacheSize
, event
.getTimestamp().getValue());
555 event
= fExperiment
.getNext(context
);
556 assertEquals("Event timestamp", 2 * cacheSize
+ 1, event
.getTimestamp().getValue());
558 // Position trace at event rank 4500
559 tmpContext
= fExperiment
.seekEvent(4500);
560 context
= fExperiment
.seekEvent(tmpContext
.getLocation());
562 event
= fExperiment
.getNext(context
);
563 assertEquals("Event timestamp", 4501, event
.getTimestamp().getValue());
565 event
= fExperiment
.getNext(context
);
566 assertEquals("Event timestamp", 4502, event
.getTimestamp().getValue());
570 public void testSeekLocationOutOfScope() {
571 // Position trace at beginning
572 ITmfContext context
= fExperiment
.seekEvent((ITmfLocation
) null);
574 ITmfEvent event
= fExperiment
.getNext(context
);
575 assertEquals("Event timestamp", 1, event
.getTimestamp().getValue());
578 // ------------------------------------------------------------------------
579 // getNext - updates the context
580 // ------------------------------------------------------------------------
582 private static void validateContextRanks(ITmfContext context
) {
583 assertTrue("Experiment context type", context
instanceof TmfExperimentContext
);
584 TmfExperimentContext ctx
= (TmfExperimentContext
) context
;
586 int nbTraces
= ctx
.getNbTraces();
588 // expRank = sum(trace ranks) - nbTraces + 1 (if lastTraceRead != NO_TRACE)
589 long expRank
= -nbTraces
+ ((ctx
.getLastTrace() != TmfExperimentContext
.NO_TRACE
) ?
1 : 0);
590 for (int i
= 0; i
< nbTraces
; i
++) {
591 ITmfContext subContext
= ctx
.getContext(i
);
592 assertNotNull(subContext
);
593 long rank
= subContext
.getRank();
600 assertEquals("Experiment context rank", expRank
, ctx
.getRank());
604 public void testGetNextAfteSeekingOnTS_1() {
606 final long INITIAL_TS
= 1;
607 final int NB_READS
= 20;
609 // On lower bound, returns the first event (ts = 1)
610 final ITmfContext context
= fExperiment
.seekEvent(new TmfTimestamp(INITIAL_TS
, SCALE
));
612 validateContextRanks(context
);
616 for (int i
= 0; i
< NB_READS
; i
++) {
617 event
= fExperiment
.getNext(context
);
618 assertEquals("Event timestamp", INITIAL_TS
+ i
, event
.getTimestamp().getValue());
619 assertEquals("Event rank", INITIAL_TS
+ i
, context
.getRank());
622 // Make sure we stay positioned
623 event
= fExperiment
.parseEvent(context
);
624 assertEquals("Event timestamp", INITIAL_TS
+ NB_READS
, event
.getTimestamp().getValue());
625 assertEquals("Event rank", INITIAL_TS
+ NB_READS
- 1, context
.getRank());
627 validateContextRanks(context
);
631 public void testGetNextAfteSeekingOnTS_2() {
632 final long INITIAL_TS
= 2;
633 final int NB_READS
= 20;
635 // On lower bound, returns the first event (ts = 2)
636 final ITmfContext context
= fExperiment
.seekEvent(new TmfTimestamp(INITIAL_TS
, SCALE
));
638 validateContextRanks(context
);
642 for (int i
= 0; i
< NB_READS
; i
++) {
643 event
= fExperiment
.getNext(context
);
644 assertEquals("Event timestamp", INITIAL_TS
+ i
, event
.getTimestamp().getValue());
645 assertEquals("Event rank", INITIAL_TS
+ i
, context
.getRank());
648 // Make sure we stay positioned
649 event
= fExperiment
.parseEvent(context
);
650 assertEquals("Event timestamp", INITIAL_TS
+ NB_READS
, event
.getTimestamp().getValue());
651 assertEquals("Event rank", INITIAL_TS
+ NB_READS
- 1, context
.getRank());
653 validateContextRanks(context
);
657 public void testGetNextAfteSeekingOnTS_3() {
659 final long INITIAL_TS
= 500;
660 final int NB_READS
= 20;
662 // On lower bound, returns the first event (ts = 500)
663 final ITmfContext context
= fExperiment
.seekEvent(new TmfTimestamp(INITIAL_TS
, SCALE
));
665 validateContextRanks(context
);
669 for (int i
= 0; i
< NB_READS
; i
++) {
670 event
= fExperiment
.getNext(context
);
671 assertEquals("Event timestamp", INITIAL_TS
+ i
, event
.getTimestamp().getValue());
672 assertEquals("Event rank", INITIAL_TS
+ i
, context
.getRank());
675 // Make sure we stay positioned
676 event
= fExperiment
.parseEvent(context
);
677 assertEquals("Event timestamp", INITIAL_TS
+ NB_READS
, event
.getTimestamp().getValue());
678 assertEquals("Event rank", INITIAL_TS
+ NB_READS
- 1, context
.getRank());
680 validateContextRanks(context
);
684 public void testGetNextAfterSeekingOnRank_1() {
685 final long INITIAL_RANK
= 0L;
686 final int NB_READS
= 20;
688 // On lower bound, returns the first event (rank = 0)
689 final ITmfContext context
= fExperiment
.seekEvent(INITIAL_RANK
);
691 validateContextRanks(context
);
695 for (int i
= 0; i
< NB_READS
; i
++) {
696 event
= fExperiment
.getNext(context
);
697 assertEquals("Event timestamp", INITIAL_RANK
+ i
+ 1, event
.getTimestamp().getValue());
698 assertEquals("Event rank", INITIAL_RANK
+ i
+ 1, context
.getRank());
701 // Make sure we stay positioned
702 event
= fExperiment
.parseEvent(context
);
703 assertEquals("Event timestamp", INITIAL_RANK
+ NB_READS
+ 1, event
.getTimestamp().getValue());
704 assertEquals("Event rank", INITIAL_RANK
+ NB_READS
, context
.getRank());
706 validateContextRanks(context
);
710 public void testGetNextAfterSeekingOnRank_2() {
711 final long INITIAL_RANK
= 1L;
712 final int NB_READS
= 20;
714 // On lower bound, returns the first event (rank = 0)
715 final ITmfContext context
= fExperiment
.seekEvent(INITIAL_RANK
);
717 validateContextRanks(context
);
721 for (int i
= 0; i
< NB_READS
; i
++) {
722 event
= fExperiment
.getNext(context
);
723 assertEquals("Event timestamp", INITIAL_RANK
+ i
+ 1, event
.getTimestamp().getValue());
724 assertEquals("Event rank", INITIAL_RANK
+ i
+ 1, context
.getRank());
727 // Make sure we stay positioned
728 event
= fExperiment
.parseEvent(context
);
729 assertEquals("Event timestamp", INITIAL_RANK
+ NB_READS
+ 1, event
.getTimestamp().getValue());
730 assertEquals("Event rank", INITIAL_RANK
+ NB_READS
, context
.getRank());
732 validateContextRanks(context
);
736 public void testGetNextAfterSeekingOnRank_3() {
737 final long INITIAL_RANK
= 500L;
738 final int NB_READS
= 20;
740 // On lower bound, returns the first event (rank = 0)
741 final ITmfContext context
= fExperiment
.seekEvent(INITIAL_RANK
);
743 validateContextRanks(context
);
747 for (int i
= 0; i
< NB_READS
; i
++) {
748 event
= fExperiment
.getNext(context
);
749 assertEquals("Event timestamp", INITIAL_RANK
+ i
+ 1, event
.getTimestamp().getValue());
750 assertEquals("Event rank", INITIAL_RANK
+ i
+ 1, context
.getRank());
753 // Make sure we stay positioned
754 event
= fExperiment
.parseEvent(context
);
755 assertEquals("Event timestamp", INITIAL_RANK
+ NB_READS
+ 1, event
.getTimestamp().getValue());
756 assertEquals("Event rank", INITIAL_RANK
+ NB_READS
, context
.getRank());
758 validateContextRanks(context
);
762 public void testGetNextAfterSeekingOnLocation_1() {
763 final ITmfLocation INITIAL_LOC
= null;
764 final long INITIAL_TS
= 1;
765 final int NB_READS
= 20;
767 // On lower bound, returns the first event (ts = 1)
768 final ITmfContext context
= fExperiment
.seekEvent(INITIAL_LOC
);
770 validateContextRanks(context
);
774 for (int i
= 0; i
< NB_READS
; i
++) {
775 event
= fExperiment
.getNext(context
);
776 assertEquals("Event timestamp", INITIAL_TS
+ i
, event
.getTimestamp().getValue());
777 assertEquals("Event rank", INITIAL_TS
+ i
, context
.getRank());
780 // Make sure we stay positioned
781 event
= fExperiment
.parseEvent(context
);
782 assertEquals("Event timestamp", INITIAL_TS
+ NB_READS
, event
.getTimestamp().getValue());
783 assertEquals("Event rank", INITIAL_TS
+ NB_READS
- 1, context
.getRank());
785 validateContextRanks(context
);
789 public void testGetNextAfterSeekingOnLocation_2() {
790 final ITmfLocation INITIAL_LOC
= fExperiment
.seekEvent(1L).getLocation();
791 final long INITIAL_TS
= 2;
792 final int NB_READS
= 20;
794 // On lower bound, returns the first event (ts = 2)
795 final ITmfContext context
= fExperiment
.seekEvent(INITIAL_LOC
);
797 validateContextRanks(context
);
801 for (int i
= 0; i
< NB_READS
; i
++) {
802 event
= fExperiment
.getNext(context
);
803 assertEquals("Event timestamp", INITIAL_TS
+ i
, event
.getTimestamp().getValue());
806 // Make sure we stay positioned
807 event
= fExperiment
.parseEvent(context
);
808 assertEquals("Event timestamp", INITIAL_TS
+ NB_READS
, event
.getTimestamp().getValue());
810 validateContextRanks(context
);
814 public void testGetNextAfterSeekingOnLocation_3() {
815 final ITmfLocation INITIAL_LOC
= fExperiment
.seekEvent(500L).getLocation();
816 final long INITIAL_TS
= 501;
817 final int NB_READS
= 20;
819 // On lower bound, returns the first event (ts = 501)
820 final ITmfContext context
= fExperiment
.seekEvent(INITIAL_LOC
);
822 validateContextRanks(context
);
826 for (int i
= 0; i
< NB_READS
; i
++) {
827 event
= fExperiment
.getNext(context
);
828 assertEquals("Event timestamp", INITIAL_TS
+ i
, event
.getTimestamp().getValue());
831 // Make sure we stay positioned
832 event
= fExperiment
.parseEvent(context
);
833 assertEquals("Event timestamp", INITIAL_TS
+ NB_READS
, event
.getTimestamp().getValue());
835 validateContextRanks(context
);
839 public void testGetNextLocation() {
840 ITmfContext context1
= fExperiment
.seekEvent(0);
841 fExperiment
.getNext(context1
);
842 ITmfLocation location
= context1
.getLocation();
843 ITmfEvent event1
= fExperiment
.getNext(context1
);
844 ITmfContext context2
= fExperiment
.seekEvent(location
);
845 ITmfEvent event2
= fExperiment
.getNext(context2
);
846 assertEquals("Event timestamp", event1
.getTimestamp().getValue(), event2
.getTimestamp().getValue());
850 public void testGetNextEndLocation() {
851 ITmfContext context1
= fExperiment
.seekEvent(fExperiment
.getNbEvents() - 1);
852 fExperiment
.getNext(context1
);
853 ITmfLocation location
= context1
.getLocation();
854 ITmfContext context2
= fExperiment
.seekEvent(location
);
855 ITmfEvent event
= fExperiment
.getNext(context2
);
856 assertNull("Event", event
);
859 // ------------------------------------------------------------------------
861 // ------------------------------------------------------------------------
864 public void testProcessRequestForNbEvents() throws InterruptedException
{
865 final int nbEvents
= 1000;
866 final Vector
<ITmfEvent
> requestedEvents
= new Vector
<>();
868 final TmfTimeRange range
= new TmfTimeRange(TmfTimestamp
.BIG_BANG
, TmfTimestamp
.BIG_CRUNCH
);
869 final TmfEventRequest request
= new TmfEventRequest(ITmfEvent
.class,
870 range
, 0, nbEvents
, ExecutionType
.FOREGROUND
) {
872 public void handleData(final ITmfEvent event
) {
873 super.handleData(event
);
874 requestedEvents
.add(event
);
877 fExperiment
.sendRequest(request
);
878 request
.waitForCompletion();
880 assertEquals("nbEvents", nbEvents
, requestedEvents
.size());
881 assertTrue("isCompleted", request
.isCompleted());
882 assertFalse("isCancelled", request
.isCancelled());
884 // Ensure that we have distinct events.
885 // Don't go overboard: we are not validating the stub!
886 for (int i
= 0; i
< nbEvents
; i
++) {
887 assertEquals("Distinct events", i
+1, requestedEvents
.get(i
).getTimestamp().getValue());
892 public void testProcessRequestForAllEvents() throws InterruptedException
{
893 final int nbEvents
= ITmfEventRequest
.ALL_DATA
;
894 final Vector
<ITmfEvent
> requestedEvents
= new Vector
<>();
895 final long nbExpectedEvents
= NB_EVENTS
;
897 final TmfTimeRange range
= new TmfTimeRange(TmfTimestamp
.BIG_BANG
, TmfTimestamp
.BIG_CRUNCH
);
898 final TmfEventRequest request
= new TmfEventRequest(ITmfEvent
.class,
899 range
, 0, nbEvents
, ExecutionType
.FOREGROUND
) {
901 public void handleData(final ITmfEvent event
) {
902 super.handleData(event
);
903 requestedEvents
.add(event
);
906 fExperiment
.sendRequest(request
);
907 request
.waitForCompletion();
909 assertEquals("nbEvents", nbExpectedEvents
, requestedEvents
.size());
910 assertTrue("isCompleted", request
.isCompleted());
911 assertFalse("isCancelled", request
.isCancelled());
913 // Ensure that we have distinct events.
914 // Don't go overboard: we are not validating the stub!
915 for (int i
= 0; i
< nbExpectedEvents
; i
++) {
916 assertEquals("Distinct events", i
+1, requestedEvents
.get(i
).getTimestamp().getValue());
920 // ------------------------------------------------------------------------
922 // ------------------------------------------------------------------------
925 public void testCancel() throws InterruptedException
{
926 final int nbEvents
= NB_EVENTS
;
927 final int limit
= BLOCK_SIZE
;
928 final Vector
<ITmfEvent
> requestedEvents
= new Vector
<>();
930 final TmfTimeRange range
= new TmfTimeRange(TmfTimestamp
.BIG_BANG
, TmfTimestamp
.BIG_CRUNCH
);
931 final TmfEventRequest request
= new TmfEventRequest(ITmfEvent
.class,
932 range
, 0, nbEvents
, ExecutionType
.FOREGROUND
) {
936 public void handleData(final ITmfEvent event
) {
937 super.handleData(event
);
938 requestedEvents
.add(event
);
939 if (++nbRead
== limit
) {
945 public void handleCancel() {
946 if (requestedEvents
.size() < limit
) {
947 System
.out
.println("aie");
951 fExperiment
.sendRequest(request
);
952 request
.waitForCompletion();
954 assertEquals("nbEvents", limit
, requestedEvents
.size());
955 assertTrue("isCompleted", request
.isCompleted());
956 assertTrue("isCancelled", request
.isCancelled());