1 /*******************************************************************************
2 * Copyright (c) 2009, 2013 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 - Fix for concurrency
14 *******************************************************************************/
16 package org
.eclipse
.linuxtools
.tmf
.core
.tests
.trace
;
18 import static org
.junit
.Assert
.assertEquals
;
19 import static org
.junit
.Assert
.assertFalse
;
20 import static org
.junit
.Assert
.assertNull
;
21 import static org
.junit
.Assert
.assertTrue
;
24 import java
.io
.IOException
;
25 import java
.net
.URISyntaxException
;
27 import java
.util
.Vector
;
29 import org
.eclipse
.core
.runtime
.FileLocator
;
30 import org
.eclipse
.core
.runtime
.Path
;
31 import org
.eclipse
.linuxtools
.internal
.tmf
.core
.trace
.TmfExperimentContext
;
32 import org
.eclipse
.linuxtools
.tmf
.core
.event
.ITmfEvent
;
33 import org
.eclipse
.linuxtools
.tmf
.core
.exceptions
.TmfTraceException
;
34 import org
.eclipse
.linuxtools
.tmf
.core
.request
.ITmfEventRequest
;
35 import org
.eclipse
.linuxtools
.tmf
.core
.request
.ITmfEventRequest
.ExecutionType
;
36 import org
.eclipse
.linuxtools
.tmf
.core
.request
.TmfEventRequest
;
37 import org
.eclipse
.linuxtools
.tmf
.core
.tests
.TmfCoreTestPlugin
;
38 import org
.eclipse
.linuxtools
.tmf
.core
.tests
.shared
.TmfTestTrace
;
39 import org
.eclipse
.linuxtools
.tmf
.core
.timestamp
.ITmfTimestamp
;
40 import org
.eclipse
.linuxtools
.tmf
.core
.timestamp
.TmfTimeRange
;
41 import org
.eclipse
.linuxtools
.tmf
.core
.timestamp
.TmfTimestamp
;
42 import org
.eclipse
.linuxtools
.tmf
.core
.trace
.ITmfContext
;
43 import org
.eclipse
.linuxtools
.tmf
.core
.trace
.ITmfTrace
;
44 import org
.eclipse
.linuxtools
.tmf
.core
.trace
.location
.ITmfLocation
;
45 import org
.eclipse
.linuxtools
.tmf
.tests
.stubs
.trace
.TmfExperimentStub
;
46 import org
.eclipse
.linuxtools
.tmf
.tests
.stubs
.trace
.TmfTraceStub
;
47 import org
.junit
.AfterClass
;
48 import org
.junit
.BeforeClass
;
49 import org
.junit
.Test
;
52 * Test suite for the TmfExperiment class (multiple traces).
54 @SuppressWarnings("javadoc")
55 public class TmfMultiTraceExperimentTest
{
57 // ------------------------------------------------------------------------
59 // ------------------------------------------------------------------------
61 private static final long DEFAULT_INITIAL_OFFSET_VALUE
= (1L * 100 * 1000 * 1000); // .1sec
62 private static final String EXPERIMENT
= "MyExperiment";
63 private static int NB_EVENTS
= 20000;
64 private static int BLOCK_SIZE
= 1000;
66 private static TmfExperimentStub fExperiment
;
68 private static byte SCALE
= (byte) -3;
70 // ------------------------------------------------------------------------
72 // ------------------------------------------------------------------------
75 public static void setUp() {
76 ITmfTrace
[] traces
= setupTraces();
77 fExperiment
= new TmfExperimentStub(EXPERIMENT
, traces
, BLOCK_SIZE
);
78 fExperiment
.getIndexer().buildIndex(0, TmfTimeRange
.ETERNITY
, true);
82 public static void tearDown() {
83 fExperiment
.dispose();
86 private static ITmfTrace
[] setupTraces() {
88 ITmfTrace
[] traces
= new ITmfTrace
[2];
90 URL location
= FileLocator
.find(TmfCoreTestPlugin
.getDefault().getBundle(), new Path(TmfTestTrace
.O_TEST_10K
.getFullPath()), null);
91 File test
= new File(FileLocator
.toFileURL(location
).toURI());
92 final TmfTraceStub trace1
= new TmfTraceStub(test
.getPath(), 0, true, null);
95 location
= FileLocator
.find(TmfCoreTestPlugin
.getDefault().getBundle(), new Path(TmfTestTrace
.E_TEST_10K
.getFullPath()), null);
96 test
= new File(FileLocator
.toFileURL(location
).toURI());
97 final TmfTraceStub trace2
= new TmfTraceStub(test
.getPath(), 0, true, null);
101 } catch (final TmfTraceException e
) {
103 } catch (final URISyntaxException e
) {
105 } catch (final IOException e
) {
108 return new ITmfTrace
[0];
111 // ------------------------------------------------------------------------
113 // ------------------------------------------------------------------------
116 public void testBasicTmfExperimentConstructor() {
117 assertEquals("GetId", EXPERIMENT
, fExperiment
.getName());
118 assertEquals("GetNbEvents", NB_EVENTS
, fExperiment
.getNbEvents());
120 final TmfTimeRange timeRange
= fExperiment
.getTimeRange();
121 assertEquals("getStartTime", 1, timeRange
.getStartTime().getValue());
122 assertEquals("getEndTime", NB_EVENTS
, timeRange
.getEndTime().getValue());
124 TmfTimestamp initRange
= new TmfTimestamp(DEFAULT_INITIAL_OFFSET_VALUE
, ITmfTimestamp
.NANOSECOND_SCALE
);
125 assertEquals("getInitialRangeOffset", initRange
, fExperiment
.getInitialRangeOffset());
128 // ------------------------------------------------------------------------
130 // ------------------------------------------------------------------------
133 public void testSeekRankOnCacheBoundary() {
134 long cacheSize
= fExperiment
.getCacheSize();
136 // On lower bound, returns the first event (TS = 1)
137 ITmfContext context
= fExperiment
.seekEvent(0);
138 assertEquals("Context rank", 0, context
.getRank());
140 ITmfEvent event
= fExperiment
.getNext(context
);
141 assertEquals("Event timestamp", 1, event
.getTimestamp().getValue());
142 assertEquals("Context rank", 1, context
.getRank());
144 // Position trace at event rank [cacheSize]
145 context
= fExperiment
.seekEvent(cacheSize
);
146 assertEquals("Context rank", cacheSize
, context
.getRank());
148 event
= fExperiment
.getNext(context
);
149 assertEquals("Event timestamp", cacheSize
+ 1, event
.getTimestamp().getValue());
150 assertEquals("Context rank", cacheSize
+ 1, context
.getRank());
152 // Position trace at event rank [4 * cacheSize]
153 context
= fExperiment
.seekEvent(4 * cacheSize
);
154 assertEquals("Context rank", 4 * cacheSize
, context
.getRank());
156 event
= fExperiment
.getNext(context
);
157 assertEquals("Event timestamp", 4 * cacheSize
+ 1, event
.getTimestamp().getValue());
158 assertEquals("Context rank", 4 * cacheSize
+ 1, context
.getRank());
162 public void testSeekRankNotOnCacheBoundary() {
163 long cacheSize
= fExperiment
.getCacheSize();
165 // Position trace at event rank 9
166 ITmfContext context
= fExperiment
.seekEvent(9);
167 assertEquals("Context rank", 9, context
.getRank());
169 ITmfEvent event
= fExperiment
.getNext(context
);
170 assertEquals("Event timestamp", 10, event
.getTimestamp().getValue());
171 assertEquals("Context rank", 10, context
.getRank());
173 // Position trace at event rank [cacheSize - 1]
174 context
= fExperiment
.seekEvent(cacheSize
- 1);
175 assertEquals("Context rank", cacheSize
- 1, context
.getRank());
177 event
= fExperiment
.getNext(context
);
178 assertEquals("Event timestamp", cacheSize
, event
.getTimestamp().getValue());
179 assertEquals("Context rank", cacheSize
, context
.getRank());
181 // Position trace at event rank [cacheSize + 1]
182 context
= fExperiment
.seekEvent(cacheSize
+ 1);
183 assertEquals("Context rank", cacheSize
+ 1, context
.getRank());
185 event
= fExperiment
.getNext(context
);
186 assertEquals("Event timestamp", cacheSize
+ 2, event
.getTimestamp().getValue());
187 assertEquals("Context rank", cacheSize
+ 2, context
.getRank());
189 // Position trace at event rank 4500
190 context
= fExperiment
.seekEvent(4500);
191 assertEquals("Context rank", 4500, context
.getRank());
193 event
= fExperiment
.getNext(context
);
194 assertEquals("Event timestamp", 4501, event
.getTimestamp().getValue());
195 assertEquals("Context rank", 4501, context
.getRank());
199 public void testSeekRankOutOfScope() {
200 // Position trace at beginning
201 ITmfContext context
= fExperiment
.seekEvent(-1);
202 assertEquals("Event rank", 0, context
.getRank());
204 ITmfEvent event
= fExperiment
.getNext(context
);
205 assertEquals("Event timestamp", 1, event
.getTimestamp().getValue());
206 assertEquals("Context rank", 1, context
.getRank());
208 // Position trace at event passed the end
209 context
= fExperiment
.seekEvent(NB_EVENTS
);
210 assertEquals("Context rank", NB_EVENTS
, context
.getRank());
212 event
= fExperiment
.getNext(context
);
213 assertNull("Event", event
);
214 assertEquals("Context rank", NB_EVENTS
, context
.getRank());
217 // ------------------------------------------------------------------------
218 // seekEvent on timestamp
219 // ------------------------------------------------------------------------
222 public void testSeekTimestampOnCacheBoundary() {
223 long cacheSize
= fExperiment
.getCacheSize();
225 // Position trace at event rank 0
226 ITmfContext context
= fExperiment
.seekEvent(new TmfTimestamp(1, SCALE
, 0));
227 assertEquals("Context rank", 0, context
.getRank());
229 ITmfEvent event
= fExperiment
.getNext(context
);
230 assertEquals("Event timestamp", 1, event
.getTimestamp().getValue());
231 assertEquals("Context rank", 1, context
.getRank());
233 // Position trace at event rank [cacheSize]
234 context
= fExperiment
.seekEvent(new TmfTimestamp(cacheSize
+ 1, SCALE
, 0));
235 assertEquals("Event rank", cacheSize
, context
.getRank());
237 event
= fExperiment
.getNext(context
);
238 assertEquals("Event timestamp", cacheSize
+ 1, event
.getTimestamp().getValue());
239 assertEquals("Context rank", cacheSize
+ 1, context
.getRank());
241 // Position trace at event rank [4 * cacheSize]
242 context
= fExperiment
.seekEvent(new TmfTimestamp(4 * cacheSize
+ 1, SCALE
, 0));
243 assertEquals("Context rank", 4 * cacheSize
, context
.getRank());
245 event
= fExperiment
.getNext(context
);
246 assertEquals("Event timestamp", 4 * cacheSize
+ 1, event
.getTimestamp().getValue());
247 assertEquals("Context rank", 4 * cacheSize
+ 1, context
.getRank());
251 public void testSeekTimestampNotOnCacheBoundary() {
252 // Position trace at event rank 1 (TS = 2)
253 ITmfContext context
= fExperiment
.seekEvent(new TmfTimestamp(2, SCALE
, 0));
254 assertEquals("Context rank", 1, context
.getRank());
256 ITmfEvent event
= fExperiment
.getNext(context
);
257 assertEquals("Event timestamp", 2, event
.getTimestamp().getValue());
258 assertEquals("Context rank", 2, context
.getRank());
260 // Position trace at event rank 9 (TS = 10)
261 context
= fExperiment
.seekEvent(new TmfTimestamp(10, SCALE
, 0));
262 assertEquals("Context rank", 9, context
.getRank());
264 event
= fExperiment
.getNext(context
);
265 assertEquals("Event timestamp", 10, event
.getTimestamp().getValue());
266 assertEquals("Context rank", 10, context
.getRank());
268 // Position trace at event rank 999 (TS = 1000)
269 context
= fExperiment
.seekEvent(new TmfTimestamp(1000, SCALE
, 0));
270 assertEquals("Context rank", 999, context
.getRank());
272 event
= fExperiment
.getNext(context
);
273 assertEquals("Event timestamp", 1000, event
.getTimestamp().getValue());
274 assertEquals("Context rank", 1000, context
.getRank());
276 // Position trace at event rank 1001 (TS = 1002)
277 context
= fExperiment
.seekEvent(new TmfTimestamp(1002, SCALE
, 0));
278 assertEquals("Context rank", 1001, context
.getRank());
280 event
= fExperiment
.getNext(context
);
281 assertEquals("Event timestamp", 1002, event
.getTimestamp().getValue());
282 assertEquals("Context rank", 1002, context
.getRank());
284 // Position trace at event rank 4500 (TS = 4501)
285 context
= fExperiment
.seekEvent(new TmfTimestamp(4501, SCALE
, 0));
286 assertEquals("Context rank", 4500, context
.getRank());
288 event
= fExperiment
.getNext(context
);
289 assertEquals("Event timestamp", 4501, event
.getTimestamp().getValue());
290 assertEquals("Context rank", 4501, context
.getRank());
294 public void testSeekTimestampOutOfScope() {
295 // Position trace at beginning
296 ITmfContext context
= fExperiment
.seekEvent(new TmfTimestamp(-1, SCALE
, 0));
297 assertEquals("Event rank", 0, context
.getRank());
299 ITmfEvent event
= fExperiment
.getNext(context
);
300 assertEquals("Event timestamp", 1, event
.getTimestamp().getValue());
301 assertEquals("Event rank", 1, context
.getRank());
303 // Position trace at event passed the end
304 context
= fExperiment
.seekEvent(new TmfTimestamp(NB_EVENTS
+ 1, SCALE
, 0));
305 event
= fExperiment
.getNext(context
);
306 assertNull("Event location", event
);
307 assertEquals("Event rank", ITmfContext
.UNKNOWN_RANK
, context
.getRank());
310 // ------------------------------------------------------------------------
311 // seekEvent by location (context rank is undefined)
312 // ------------------------------------------------------------------------
315 public void testSeekLocationOnCacheBoundary() {
316 long cacheSize
= fExperiment
.getCacheSize();
318 // Position trace at event rank 0
319 ITmfContext tmpContext
= fExperiment
.seekEvent(0);
320 ITmfContext context
= fExperiment
.seekEvent(tmpContext
.getLocation());
322 ITmfEvent event
= fExperiment
.getNext(context
);
323 assertEquals("Event timestamp", 1, event
.getTimestamp().getValue());
325 event
= fExperiment
.getNext(context
);
326 assertEquals("Event timestamp", 2, event
.getTimestamp().getValue());
328 // Position trace at event rank 'cacheSize'
329 tmpContext
= fExperiment
.seekEvent(cacheSize
);
330 context
= fExperiment
.seekEvent(tmpContext
.getLocation());
332 event
= fExperiment
.getNext(context
);
333 assertEquals("Event timestamp", cacheSize
+ 1, event
.getTimestamp().getValue());
335 event
= fExperiment
.getNext(context
);
336 assertEquals("Event timestamp", cacheSize
+ 2, event
.getTimestamp().getValue());
338 // Position trace at event rank 4 * 'cacheSize'
339 tmpContext
= fExperiment
.seekEvent(4 * cacheSize
);
340 context
= fExperiment
.seekEvent(tmpContext
.getLocation());
342 event
= fExperiment
.getNext(context
);
343 assertEquals("Event timestamp", 4 * cacheSize
+ 1, event
.getTimestamp().getValue());
345 event
= fExperiment
.getNext(context
);
346 assertEquals("Event timestamp", 4 * cacheSize
+ 2, event
.getTimestamp().getValue());
350 public void testSeekLocationNotOnCacheBoundary() {
351 long cacheSize
= fExperiment
.getCacheSize();
353 // Position trace at event 'cacheSize' - 1
354 ITmfContext tmpContext
= fExperiment
.seekEvent(cacheSize
- 1);
355 ITmfContext context
= fExperiment
.seekEvent(tmpContext
.getLocation());
357 ITmfEvent event
= fExperiment
.getNext(context
);
358 assertEquals("Event timestamp", cacheSize
, event
.getTimestamp().getValue());
360 event
= fExperiment
.getNext(context
);
361 assertEquals("Event timestamp", cacheSize
+ 1, event
.getTimestamp().getValue());
363 // Position trace at event rank 2 * 'cacheSize' - 1
364 tmpContext
= fExperiment
.seekEvent(2 * cacheSize
- 1);
365 context
= fExperiment
.seekEvent(tmpContext
.getLocation());
366 context
= fExperiment
.seekEvent(2 * cacheSize
- 1);
368 event
= fExperiment
.getNext(context
);
369 assertEquals("Event timestamp", 2 * cacheSize
, event
.getTimestamp().getValue());
371 event
= fExperiment
.getNext(context
);
372 assertEquals("Event timestamp", 2 * cacheSize
+ 1, event
.getTimestamp().getValue());
374 // Position trace at event rank 4500
375 tmpContext
= fExperiment
.seekEvent(4500);
376 context
= fExperiment
.seekEvent(tmpContext
.getLocation());
378 event
= fExperiment
.getNext(context
);
379 assertEquals("Event timestamp", 4501, event
.getTimestamp().getValue());
381 event
= fExperiment
.getNext(context
);
382 assertEquals("Event timestamp", 4502, event
.getTimestamp().getValue());
386 public void testSeekLocationOutOfScope() {
387 // Position trace at beginning
388 ITmfContext context
= fExperiment
.seekEvent((ITmfLocation
) null);
390 ITmfEvent event
= fExperiment
.getNext(context
);
391 assertEquals("Event timestamp", 1, event
.getTimestamp().getValue());
394 // ------------------------------------------------------------------------
395 // getNext - updates the context
396 // ------------------------------------------------------------------------
398 private static void validateContextRanks(ITmfContext context
) {
399 assertTrue("Experiment context type", context
instanceof TmfExperimentContext
);
400 TmfExperimentContext ctx
= (TmfExperimentContext
) context
;
402 int nbTraces
= ctx
.getContexts().length
;
404 // expRank = sum(trace ranks) - nbTraces + 1 (if lastTraceRead != NO_TRACE)
405 long expRank
= -nbTraces
+ ((ctx
.getLastTrace() != TmfExperimentContext
.NO_TRACE
) ?
1 : 0);
406 for (int i
= 0; i
< nbTraces
; i
++) {
407 long rank
= ctx
.getContexts()[i
].getRank();
414 assertEquals("Experiment context rank", expRank
, ctx
.getRank());
418 public void testGetNextAfteSeekingOnTS_1() {
419 final long INITIAL_TS
= 1;
420 final int NB_READS
= 20;
422 // On lower bound, returns the first event (ts = 1)
423 final ITmfContext context
= fExperiment
.seekEvent(new TmfTimestamp(INITIAL_TS
, SCALE
, 0));
425 validateContextRanks(context
);
429 for (int i
= 0; i
< NB_READS
; i
++) {
430 event
= fExperiment
.getNext(context
);
431 assertEquals("Event timestamp", INITIAL_TS
+ i
, event
.getTimestamp().getValue());
432 assertEquals("Event rank", INITIAL_TS
+ i
, context
.getRank());
435 // Make sure we stay positioned
436 event
= fExperiment
.parseEvent(context
);
437 assertEquals("Event timestamp", INITIAL_TS
+ NB_READS
, event
.getTimestamp().getValue());
438 assertEquals("Event rank", INITIAL_TS
+ NB_READS
- 1, context
.getRank());
440 validateContextRanks(context
);
444 public void testGetNextAfteSeekingOnTS_2() {
445 final long INITIAL_TS
= 2;
446 final int NB_READS
= 20;
448 // On lower bound, returns the first event (ts = 2)
449 final ITmfContext context
= fExperiment
.seekEvent(new TmfTimestamp(INITIAL_TS
, SCALE
, 0));
451 validateContextRanks(context
);
455 for (int i
= 0; i
< NB_READS
; i
++) {
456 event
= fExperiment
.getNext(context
);
457 assertEquals("Event timestamp", INITIAL_TS
+ i
, event
.getTimestamp().getValue());
458 assertEquals("Event rank", INITIAL_TS
+ i
, context
.getRank());
461 // Make sure we stay positioned
462 event
= fExperiment
.parseEvent(context
);
463 assertEquals("Event timestamp", INITIAL_TS
+ NB_READS
, event
.getTimestamp().getValue());
464 assertEquals("Event rank", INITIAL_TS
+ NB_READS
- 1, context
.getRank());
466 validateContextRanks(context
);
470 public void testGetNextAfteSeekingOnTS_3() {
471 final long INITIAL_TS
= 500;
472 final int NB_READS
= 20;
474 // On lower bound, returns the first event (ts = 500)
475 final ITmfContext context
= fExperiment
.seekEvent(new TmfTimestamp(INITIAL_TS
, SCALE
, 0));
477 validateContextRanks(context
);
481 for (int i
= 0; i
< NB_READS
; i
++) {
482 event
= fExperiment
.getNext(context
);
483 assertEquals("Event timestamp", INITIAL_TS
+ i
, event
.getTimestamp().getValue());
484 assertEquals("Event rank", INITIAL_TS
+ i
, context
.getRank());
487 // Make sure we stay positioned
488 event
= fExperiment
.parseEvent(context
);
489 assertEquals("Event timestamp", INITIAL_TS
+ NB_READS
, event
.getTimestamp().getValue());
490 assertEquals("Event rank", INITIAL_TS
+ NB_READS
- 1, context
.getRank());
492 validateContextRanks(context
);
496 public void testGetNextAfterSeekingOnRank_1() {
497 final long INITIAL_RANK
= 0L;
498 final int NB_READS
= 20;
500 // On lower bound, returns the first event (rank = 0)
501 final ITmfContext context
= fExperiment
.seekEvent(INITIAL_RANK
);
503 validateContextRanks(context
);
507 for (int i
= 0; i
< NB_READS
; i
++) {
508 event
= fExperiment
.getNext(context
);
509 assertEquals("Event timestamp", INITIAL_RANK
+ i
+ 1, event
.getTimestamp().getValue());
510 assertEquals("Event rank", INITIAL_RANK
+ i
+ 1, context
.getRank());
513 // Make sure we stay positioned
514 event
= fExperiment
.parseEvent(context
);
515 assertEquals("Event timestamp", INITIAL_RANK
+ NB_READS
+ 1, event
.getTimestamp().getValue());
516 assertEquals("Event rank", INITIAL_RANK
+ NB_READS
, context
.getRank());
518 validateContextRanks(context
);
522 public void testGetNextAfterSeekingOnRank_2() {
523 final long INITIAL_RANK
= 1L;
524 final int NB_READS
= 20;
526 // On lower bound, returns the first event (rank = 0)
527 final ITmfContext context
= fExperiment
.seekEvent(INITIAL_RANK
);
529 validateContextRanks(context
);
533 for (int i
= 0; i
< NB_READS
; i
++) {
534 event
= fExperiment
.getNext(context
);
535 assertEquals("Event timestamp", INITIAL_RANK
+ i
+ 1, event
.getTimestamp().getValue());
536 assertEquals("Event rank", INITIAL_RANK
+ i
+ 1, context
.getRank());
539 // Make sure we stay positioned
540 event
= fExperiment
.parseEvent(context
);
541 assertEquals("Event timestamp", INITIAL_RANK
+ NB_READS
+ 1, event
.getTimestamp().getValue());
542 assertEquals("Event rank", INITIAL_RANK
+ NB_READS
, context
.getRank());
544 validateContextRanks(context
);
548 public void testGetNextAfterSeekingOnRank_3() {
549 final long INITIAL_RANK
= 500L;
550 final int NB_READS
= 20;
552 // On lower bound, returns the first event (rank = 0)
553 final ITmfContext context
= fExperiment
.seekEvent(INITIAL_RANK
);
555 validateContextRanks(context
);
559 for (int i
= 0; i
< NB_READS
; i
++) {
560 event
= fExperiment
.getNext(context
);
561 assertEquals("Event timestamp", INITIAL_RANK
+ i
+ 1, event
.getTimestamp().getValue());
562 assertEquals("Event rank", INITIAL_RANK
+ i
+ 1, context
.getRank());
565 // Make sure we stay positioned
566 event
= fExperiment
.parseEvent(context
);
567 assertEquals("Event timestamp", INITIAL_RANK
+ NB_READS
+ 1, event
.getTimestamp().getValue());
568 assertEquals("Event rank", INITIAL_RANK
+ NB_READS
, context
.getRank());
570 validateContextRanks(context
);
574 public void testGetNextAfterSeekingOnLocation_1() {
575 final ITmfLocation INITIAL_LOC
= null;
576 final long INITIAL_TS
= 1;
577 final int NB_READS
= 20;
579 // On lower bound, returns the first event (ts = 1)
580 final ITmfContext context
= fExperiment
.seekEvent(INITIAL_LOC
);
582 validateContextRanks(context
);
586 for (int i
= 0; i
< NB_READS
; i
++) {
587 event
= fExperiment
.getNext(context
);
588 assertEquals("Event timestamp", INITIAL_TS
+ i
, event
.getTimestamp().getValue());
589 assertEquals("Event rank", INITIAL_TS
+ i
, context
.getRank());
592 // Make sure we stay positioned
593 event
= fExperiment
.parseEvent(context
);
594 assertEquals("Event timestamp", INITIAL_TS
+ NB_READS
, event
.getTimestamp().getValue());
595 assertEquals("Event rank", INITIAL_TS
+ NB_READS
- 1, context
.getRank());
597 validateContextRanks(context
);
601 public void testGetNextAfterSeekingOnLocation_2() {
602 final ITmfLocation INITIAL_LOC
= fExperiment
.seekEvent(1L).getLocation();
603 final long INITIAL_TS
= 2;
604 final int NB_READS
= 20;
606 // On lower bound, returns the first event (ts = 2)
607 final ITmfContext context
= fExperiment
.seekEvent(INITIAL_LOC
);
609 validateContextRanks(context
);
613 for (int i
= 0; i
< NB_READS
; i
++) {
614 event
= fExperiment
.getNext(context
);
615 assertEquals("Event timestamp", INITIAL_TS
+ i
, event
.getTimestamp().getValue());
618 // Make sure we stay positioned
619 event
= fExperiment
.parseEvent(context
);
620 assertEquals("Event timestamp", INITIAL_TS
+ NB_READS
, event
.getTimestamp().getValue());
622 validateContextRanks(context
);
626 public void testGetNextAfterSeekingOnLocation_3() {
627 final ITmfLocation INITIAL_LOC
= fExperiment
.seekEvent(500L).getLocation();
628 final long INITIAL_TS
= 501;
629 final int NB_READS
= 20;
631 // On lower bound, returns the first event (ts = 501)
632 final ITmfContext context
= fExperiment
.seekEvent(INITIAL_LOC
);
634 validateContextRanks(context
);
638 for (int i
= 0; i
< NB_READS
; i
++) {
639 event
= fExperiment
.getNext(context
);
640 assertEquals("Event timestamp", INITIAL_TS
+ i
, event
.getTimestamp().getValue());
643 // Make sure we stay positioned
644 event
= fExperiment
.parseEvent(context
);
645 assertEquals("Event timestamp", INITIAL_TS
+ NB_READS
, event
.getTimestamp().getValue());
647 validateContextRanks(context
);
651 public void testGetNextLocation() {
652 ITmfContext context1
= fExperiment
.seekEvent(0);
653 fExperiment
.getNext(context1
);
654 ITmfLocation location
= context1
.getLocation();
655 ITmfEvent event1
= fExperiment
.getNext(context1
);
656 ITmfContext context2
= fExperiment
.seekEvent(location
);
657 ITmfEvent event2
= fExperiment
.getNext(context2
);
658 assertEquals("Event timestamp", event1
.getTimestamp().getValue(), event2
.getTimestamp().getValue());
662 public void testGetNextEndLocation() {
663 ITmfContext context1
= fExperiment
.seekEvent(fExperiment
.getNbEvents() - 1);
664 fExperiment
.getNext(context1
);
665 ITmfLocation location
= context1
.getLocation();
666 ITmfContext context2
= fExperiment
.seekEvent(location
);
667 ITmfEvent event
= fExperiment
.getNext(context2
);
668 assertNull("Event", event
);
671 // ------------------------------------------------------------------------
673 // ------------------------------------------------------------------------
676 public void testProcessRequestForNbEvents() throws InterruptedException
{
677 final int nbEvents
= 1000;
678 final Vector
<ITmfEvent
> requestedEvents
= new Vector
<ITmfEvent
>();
680 final TmfTimeRange range
= new TmfTimeRange(TmfTimestamp
.BIG_BANG
, TmfTimestamp
.BIG_CRUNCH
);
681 final TmfEventRequest request
= new TmfEventRequest(ITmfEvent
.class,
682 range
, 0, nbEvents
, ExecutionType
.FOREGROUND
) {
684 public void handleData(final ITmfEvent event
) {
685 super.handleData(event
);
686 requestedEvents
.add(event
);
689 fExperiment
.sendRequest(request
);
690 request
.waitForCompletion();
692 assertEquals("nbEvents", nbEvents
, requestedEvents
.size());
693 assertTrue("isCompleted", request
.isCompleted());
694 assertFalse("isCancelled", request
.isCancelled());
696 // Ensure that we have distinct events.
697 // Don't go overboard: we are not validating the stub!
698 for (int i
= 0; i
< nbEvents
; i
++) {
699 assertEquals("Distinct events", i
+1, requestedEvents
.get(i
).getTimestamp().getValue());
704 public void testProcessRequestForAllEvents() throws InterruptedException
{
705 final int nbEvents
= ITmfEventRequest
.ALL_DATA
;
706 final Vector
<ITmfEvent
> requestedEvents
= new Vector
<ITmfEvent
>();
707 final long nbExpectedEvents
= NB_EVENTS
;
709 final TmfTimeRange range
= new TmfTimeRange(TmfTimestamp
.BIG_BANG
, TmfTimestamp
.BIG_CRUNCH
);
710 final TmfEventRequest request
= new TmfEventRequest(ITmfEvent
.class,
711 range
, 0, nbEvents
, ExecutionType
.FOREGROUND
) {
713 public void handleData(final ITmfEvent event
) {
714 super.handleData(event
);
715 requestedEvents
.add(event
);
718 fExperiment
.sendRequest(request
);
719 request
.waitForCompletion();
721 assertEquals("nbEvents", nbExpectedEvents
, requestedEvents
.size());
722 assertTrue("isCompleted", request
.isCompleted());
723 assertFalse("isCancelled", request
.isCancelled());
725 // Ensure that we have distinct events.
726 // Don't go overboard: we are not validating the stub!
727 for (int i
= 0; i
< nbExpectedEvents
; i
++) {
728 assertEquals("Distinct events", i
+1, requestedEvents
.get(i
).getTimestamp().getValue());
732 // ------------------------------------------------------------------------
734 // ------------------------------------------------------------------------
737 public void testCancel() throws InterruptedException
{
738 final int nbEvents
= NB_EVENTS
;
739 final int limit
= BLOCK_SIZE
;
740 final Vector
<ITmfEvent
> requestedEvents
= new Vector
<ITmfEvent
>();
742 final TmfTimeRange range
= new TmfTimeRange(TmfTimestamp
.BIG_BANG
, TmfTimestamp
.BIG_CRUNCH
);
743 final TmfEventRequest request
= new TmfEventRequest(ITmfEvent
.class,
744 range
, 0, nbEvents
, ExecutionType
.FOREGROUND
) {
748 public void handleData(final ITmfEvent event
) {
749 super.handleData(event
);
750 requestedEvents
.add(event
);
751 if (++nbRead
== limit
) {
756 fExperiment
.sendRequest(request
);
757 request
.waitForCompletion();
759 assertEquals("nbEvents", limit
, requestedEvents
.size());
760 assertTrue("isCompleted", request
.isCompleted());
761 assertTrue("isCancelled", request
.isCancelled());
764 // ------------------------------------------------------------------------
766 // ------------------------------------------------------------------------
769 public void testGetTimestamp() {
770 assertEquals("getTimestamp", new TmfTimestamp( 1, (byte) -3), fExperiment
.getTimestamp( 0));
771 assertEquals("getTimestamp", new TmfTimestamp( 2, (byte) -3), fExperiment
.getTimestamp( 1));
772 assertEquals("getTimestamp", new TmfTimestamp( 11, (byte) -3), fExperiment
.getTimestamp( 10));
773 assertEquals("getTimestamp", new TmfTimestamp( 101, (byte) -3), fExperiment
.getTimestamp( 100));
774 assertEquals("getTimestamp", new TmfTimestamp( 1001, (byte) -3), fExperiment
.getTimestamp( 1000));
775 assertEquals("getTimestamp", new TmfTimestamp( 2001, (byte) -3), fExperiment
.getTimestamp( 2000));
776 assertEquals("getTimestamp", new TmfTimestamp( 2501, (byte) -3), fExperiment
.getTimestamp( 2500));
777 assertEquals("getTimestamp", new TmfTimestamp(10000, (byte) -3), fExperiment
.getTimestamp( 9999));
778 assertEquals("getTimestamp", new TmfTimestamp(20000, (byte) -3), fExperiment
.getTimestamp(19999));
779 assertNull("getTimestamp", fExperiment
.getTimestamp(20000));
782 // ------------------------------------------------------------------------
783 // getInitialRangeOffset, getCurrentRange, getCurrentTime
784 // ------------------------------------------------------------------------
787 public void testDefaultCurrentTimeValues() {
788 ITmfTrace
[] traces
= setupTraces();
789 TmfExperimentStub exp
= new TmfExperimentStub(EXPERIMENT
, traces
, BLOCK_SIZE
);
791 // verify initial values
792 TmfTimestamp initRange
= new TmfTimestamp(DEFAULT_INITIAL_OFFSET_VALUE
, ITmfTimestamp
.NANOSECOND_SCALE
);
793 assertEquals("getInitialRangeOffset", initRange
, exp
.getInitialRangeOffset());
799 public void testInitialRangeOffset() {
800 ITmfTrace
[] traces
= setupTraces();
801 ((TmfTraceStub
) traces
[0]).setInitialRangeOffset(new TmfTimestamp(5, ITmfTimestamp
.MILLISECOND_SCALE
));
802 ((TmfTraceStub
) traces
[1]).setInitialRangeOffset(new TmfTimestamp(2, ITmfTimestamp
.MILLISECOND_SCALE
));
803 TmfExperimentStub exp
= new TmfExperimentStub(EXPERIMENT
, traces
, BLOCK_SIZE
);
805 TmfTimestamp initRange
= new TmfTimestamp(2, ITmfTimestamp
.MILLISECOND_SCALE
);
806 assertEquals("getInitialRangeOffset", initRange
, exp
.getInitialRangeOffset());