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
.TmfDataRequest
;
35 import org
.eclipse
.linuxtools
.tmf
.core
.request
.TmfEventRequest
;
36 import org
.eclipse
.linuxtools
.tmf
.core
.request
.ITmfDataRequest
.ExecutionType
;
37 import org
.eclipse
.linuxtools
.tmf
.core
.tests
.TmfCoreTestPlugin
;
38 import org
.eclipse
.linuxtools
.tmf
.core
.timestamp
.ITmfTimestamp
;
39 import org
.eclipse
.linuxtools
.tmf
.core
.timestamp
.TmfTimeRange
;
40 import org
.eclipse
.linuxtools
.tmf
.core
.timestamp
.TmfTimestamp
;
41 import org
.eclipse
.linuxtools
.tmf
.core
.trace
.ITmfContext
;
42 import org
.eclipse
.linuxtools
.tmf
.core
.trace
.ITmfTrace
;
43 import org
.eclipse
.linuxtools
.tmf
.core
.trace
.location
.ITmfLocation
;
44 import org
.eclipse
.linuxtools
.tmf
.tests
.stubs
.trace
.TmfExperimentStub
;
45 import org
.eclipse
.linuxtools
.tmf
.tests
.stubs
.trace
.TmfTraceStub
;
46 import org
.junit
.AfterClass
;
47 import org
.junit
.BeforeClass
;
48 import org
.junit
.Test
;
51 * Test suite for the TmfExperiment class (multiple traces).
53 @SuppressWarnings("javadoc")
54 public class TmfMultiTraceExperimentTest
{
56 // ------------------------------------------------------------------------
58 // ------------------------------------------------------------------------
60 private static final long DEFAULT_INITIAL_OFFSET_VALUE
= (1L * 100 * 1000 * 1000); // .1sec
61 private static final String DIRECTORY
= "testfiles";
62 private static final String TEST_STREAM1
= "O-Test-10K";
63 private static final String TEST_STREAM2
= "E-Test-10K";
64 private static final String EXPERIMENT
= "MyExperiment";
65 private static int NB_EVENTS
= 20000;
66 private static int BLOCK_SIZE
= 1000;
68 private static TmfExperimentStub fExperiment
;
70 private static byte SCALE
= (byte) -3;
72 // ------------------------------------------------------------------------
74 // ------------------------------------------------------------------------
77 public static void setUp() {
78 ITmfTrace
[] traces
= setupTraces();
79 fExperiment
= new TmfExperimentStub(EXPERIMENT
, traces
, BLOCK_SIZE
);
80 fExperiment
.getIndexer().buildIndex(0, TmfTimeRange
.ETERNITY
, true);
84 public static void tearDown() {
85 fExperiment
.dispose();
88 private static ITmfTrace
[] setupTraces() {
89 final String path1
= DIRECTORY
+ File
.separator
+ TEST_STREAM1
;
90 final String path2
= DIRECTORY
+ File
.separator
+ TEST_STREAM2
;
92 ITmfTrace
[] traces
= new ITmfTrace
[2];
94 URL location
= FileLocator
.find(TmfCoreTestPlugin
.getDefault().getBundle(), new Path(path1
), null);
95 File test
= new File(FileLocator
.toFileURL(location
).toURI());
96 final TmfTraceStub trace1
= new TmfTraceStub(test
.getPath(), 0, true, null, null);
99 location
= FileLocator
.find(TmfCoreTestPlugin
.getDefault().getBundle(), new Path(path2
), null);
100 test
= new File(FileLocator
.toFileURL(location
).toURI());
101 final TmfTraceStub trace2
= new TmfTraceStub(test
.getPath(), 0, true, null, null);
105 } catch (final TmfTraceException e
) {
107 } catch (final URISyntaxException e
) {
109 } catch (final IOException e
) {
112 return new ITmfTrace
[0];
115 // ------------------------------------------------------------------------
117 // ------------------------------------------------------------------------
120 public void testBasicTmfExperimentConstructor() {
121 assertEquals("GetId", EXPERIMENT
, fExperiment
.getName());
122 assertEquals("GetNbEvents", NB_EVENTS
, fExperiment
.getNbEvents());
124 final TmfTimeRange timeRange
= fExperiment
.getTimeRange();
125 assertEquals("getStartTime", 1, timeRange
.getStartTime().getValue());
126 assertEquals("getEndTime", NB_EVENTS
, timeRange
.getEndTime().getValue());
128 TmfTimestamp initRange
= new TmfTimestamp(DEFAULT_INITIAL_OFFSET_VALUE
, ITmfTimestamp
.NANOSECOND_SCALE
);
129 assertEquals("getInitialRangeOffset", initRange
, fExperiment
.getInitialRangeOffset());
132 // ------------------------------------------------------------------------
134 // ------------------------------------------------------------------------
137 public void testSeekRankOnCacheBoundary() {
138 long cacheSize
= fExperiment
.getCacheSize();
140 // On lower bound, returns the first event (TS = 1)
141 ITmfContext context
= fExperiment
.seekEvent(0);
142 assertEquals("Context rank", 0, context
.getRank());
144 ITmfEvent event
= fExperiment
.getNext(context
);
145 assertEquals("Event timestamp", 1, event
.getTimestamp().getValue());
146 assertEquals("Context rank", 1, context
.getRank());
148 // Position trace at event rank [cacheSize]
149 context
= fExperiment
.seekEvent(cacheSize
);
150 assertEquals("Context rank", cacheSize
, context
.getRank());
152 event
= fExperiment
.getNext(context
);
153 assertEquals("Event timestamp", cacheSize
+ 1, event
.getTimestamp().getValue());
154 assertEquals("Context rank", cacheSize
+ 1, context
.getRank());
156 // Position trace at event rank [4 * cacheSize]
157 context
= fExperiment
.seekEvent(4 * cacheSize
);
158 assertEquals("Context rank", 4 * cacheSize
, context
.getRank());
160 event
= fExperiment
.getNext(context
);
161 assertEquals("Event timestamp", 4 * cacheSize
+ 1, event
.getTimestamp().getValue());
162 assertEquals("Context rank", 4 * cacheSize
+ 1, context
.getRank());
166 public void testSeekRankNotOnCacheBoundary() {
167 long cacheSize
= fExperiment
.getCacheSize();
169 // Position trace at event rank 9
170 ITmfContext context
= fExperiment
.seekEvent(9);
171 assertEquals("Context rank", 9, context
.getRank());
173 ITmfEvent event
= fExperiment
.getNext(context
);
174 assertEquals("Event timestamp", 10, event
.getTimestamp().getValue());
175 assertEquals("Context rank", 10, context
.getRank());
177 // Position trace at event rank [cacheSize - 1]
178 context
= fExperiment
.seekEvent(cacheSize
- 1);
179 assertEquals("Context rank", cacheSize
- 1, context
.getRank());
181 event
= fExperiment
.getNext(context
);
182 assertEquals("Event timestamp", cacheSize
, event
.getTimestamp().getValue());
183 assertEquals("Context rank", cacheSize
, context
.getRank());
185 // Position trace at event rank [cacheSize + 1]
186 context
= fExperiment
.seekEvent(cacheSize
+ 1);
187 assertEquals("Context rank", cacheSize
+ 1, context
.getRank());
189 event
= fExperiment
.getNext(context
);
190 assertEquals("Event timestamp", cacheSize
+ 2, event
.getTimestamp().getValue());
191 assertEquals("Context rank", cacheSize
+ 2, context
.getRank());
193 // Position trace at event rank 4500
194 context
= fExperiment
.seekEvent(4500);
195 assertEquals("Context rank", 4500, context
.getRank());
197 event
= fExperiment
.getNext(context
);
198 assertEquals("Event timestamp", 4501, event
.getTimestamp().getValue());
199 assertEquals("Context rank", 4501, context
.getRank());
203 public void testSeekRankOutOfScope() {
204 // Position trace at beginning
205 ITmfContext context
= fExperiment
.seekEvent(-1);
206 assertEquals("Event rank", 0, context
.getRank());
208 ITmfEvent event
= fExperiment
.getNext(context
);
209 assertEquals("Event timestamp", 1, event
.getTimestamp().getValue());
210 assertEquals("Context rank", 1, context
.getRank());
212 // Position trace at event passed the end
213 context
= fExperiment
.seekEvent(NB_EVENTS
);
214 assertEquals("Context rank", NB_EVENTS
, context
.getRank());
216 event
= fExperiment
.getNext(context
);
217 assertNull("Event", event
);
218 assertEquals("Context rank", NB_EVENTS
, context
.getRank());
221 // ------------------------------------------------------------------------
222 // seekEvent on timestamp
223 // ------------------------------------------------------------------------
226 public void testSeekTimestampOnCacheBoundary() {
227 long cacheSize
= fExperiment
.getCacheSize();
229 // Position trace at event rank 0
230 ITmfContext context
= fExperiment
.seekEvent(new TmfTimestamp(1, SCALE
, 0));
231 assertEquals("Context rank", 0, context
.getRank());
233 ITmfEvent event
= fExperiment
.getNext(context
);
234 assertEquals("Event timestamp", 1, event
.getTimestamp().getValue());
235 assertEquals("Context rank", 1, context
.getRank());
237 // Position trace at event rank [cacheSize]
238 context
= fExperiment
.seekEvent(new TmfTimestamp(cacheSize
+ 1, SCALE
, 0));
239 assertEquals("Event rank", cacheSize
, context
.getRank());
241 event
= fExperiment
.getNext(context
);
242 assertEquals("Event timestamp", cacheSize
+ 1, event
.getTimestamp().getValue());
243 assertEquals("Context rank", cacheSize
+ 1, context
.getRank());
245 // Position trace at event rank [4 * cacheSize]
246 context
= fExperiment
.seekEvent(new TmfTimestamp(4 * cacheSize
+ 1, SCALE
, 0));
247 assertEquals("Context rank", 4 * cacheSize
, context
.getRank());
249 event
= fExperiment
.getNext(context
);
250 assertEquals("Event timestamp", 4 * cacheSize
+ 1, event
.getTimestamp().getValue());
251 assertEquals("Context rank", 4 * cacheSize
+ 1, context
.getRank());
255 public void testSeekTimestampNotOnCacheBoundary() {
256 // Position trace at event rank 1 (TS = 2)
257 ITmfContext context
= fExperiment
.seekEvent(new TmfTimestamp(2, SCALE
, 0));
258 assertEquals("Context rank", 1, context
.getRank());
260 ITmfEvent event
= fExperiment
.getNext(context
);
261 assertEquals("Event timestamp", 2, event
.getTimestamp().getValue());
262 assertEquals("Context rank", 2, context
.getRank());
264 // Position trace at event rank 9 (TS = 10)
265 context
= fExperiment
.seekEvent(new TmfTimestamp(10, SCALE
, 0));
266 assertEquals("Context rank", 9, context
.getRank());
268 event
= fExperiment
.getNext(context
);
269 assertEquals("Event timestamp", 10, event
.getTimestamp().getValue());
270 assertEquals("Context rank", 10, context
.getRank());
272 // Position trace at event rank 999 (TS = 1000)
273 context
= fExperiment
.seekEvent(new TmfTimestamp(1000, SCALE
, 0));
274 assertEquals("Context rank", 999, context
.getRank());
276 event
= fExperiment
.getNext(context
);
277 assertEquals("Event timestamp", 1000, event
.getTimestamp().getValue());
278 assertEquals("Context rank", 1000, context
.getRank());
280 // Position trace at event rank 1001 (TS = 1002)
281 context
= fExperiment
.seekEvent(new TmfTimestamp(1002, SCALE
, 0));
282 assertEquals("Context rank", 1001, context
.getRank());
284 event
= fExperiment
.getNext(context
);
285 assertEquals("Event timestamp", 1002, event
.getTimestamp().getValue());
286 assertEquals("Context rank", 1002, context
.getRank());
288 // Position trace at event rank 4500 (TS = 4501)
289 context
= fExperiment
.seekEvent(new TmfTimestamp(4501, SCALE
, 0));
290 assertEquals("Context rank", 4500, context
.getRank());
292 event
= fExperiment
.getNext(context
);
293 assertEquals("Event timestamp", 4501, event
.getTimestamp().getValue());
294 assertEquals("Context rank", 4501, context
.getRank());
298 public void testSeekTimestampOutOfScope() {
299 // Position trace at beginning
300 ITmfContext context
= fExperiment
.seekEvent(new TmfTimestamp(-1, SCALE
, 0));
301 assertEquals("Event rank", 0, context
.getRank());
303 ITmfEvent event
= fExperiment
.getNext(context
);
304 assertEquals("Event timestamp", 1, event
.getTimestamp().getValue());
305 assertEquals("Event rank", 1, context
.getRank());
307 // Position trace at event passed the end
308 context
= fExperiment
.seekEvent(new TmfTimestamp(NB_EVENTS
+ 1, SCALE
, 0));
309 event
= fExperiment
.getNext(context
);
310 assertNull("Event location", event
);
311 assertEquals("Event rank", ITmfContext
.UNKNOWN_RANK
, context
.getRank());
314 // ------------------------------------------------------------------------
315 // seekEvent by location (context rank is undefined)
316 // ------------------------------------------------------------------------
319 public void testSeekLocationOnCacheBoundary() {
320 long cacheSize
= fExperiment
.getCacheSize();
322 // Position trace at event rank 0
323 ITmfContext tmpContext
= fExperiment
.seekEvent(0);
324 ITmfContext context
= fExperiment
.seekEvent(tmpContext
.getLocation());
326 ITmfEvent event
= fExperiment
.getNext(context
);
327 assertEquals("Event timestamp", 1, event
.getTimestamp().getValue());
329 event
= fExperiment
.getNext(context
);
330 assertEquals("Event timestamp", 2, event
.getTimestamp().getValue());
332 // Position trace at event rank 'cacheSize'
333 tmpContext
= fExperiment
.seekEvent(cacheSize
);
334 context
= fExperiment
.seekEvent(tmpContext
.getLocation());
336 event
= fExperiment
.getNext(context
);
337 assertEquals("Event timestamp", cacheSize
+ 1, event
.getTimestamp().getValue());
339 event
= fExperiment
.getNext(context
);
340 assertEquals("Event timestamp", cacheSize
+ 2, event
.getTimestamp().getValue());
342 // Position trace at event rank 4 * 'cacheSize'
343 tmpContext
= fExperiment
.seekEvent(4 * cacheSize
);
344 context
= fExperiment
.seekEvent(tmpContext
.getLocation());
346 event
= fExperiment
.getNext(context
);
347 assertEquals("Event timestamp", 4 * cacheSize
+ 1, event
.getTimestamp().getValue());
349 event
= fExperiment
.getNext(context
);
350 assertEquals("Event timestamp", 4 * cacheSize
+ 2, event
.getTimestamp().getValue());
354 public void testSeekLocationNotOnCacheBoundary() {
355 long cacheSize
= fExperiment
.getCacheSize();
357 // Position trace at event 'cacheSize' - 1
358 ITmfContext tmpContext
= fExperiment
.seekEvent(cacheSize
- 1);
359 ITmfContext context
= fExperiment
.seekEvent(tmpContext
.getLocation());
361 ITmfEvent event
= fExperiment
.getNext(context
);
362 assertEquals("Event timestamp", cacheSize
, event
.getTimestamp().getValue());
364 event
= fExperiment
.getNext(context
);
365 assertEquals("Event timestamp", cacheSize
+ 1, event
.getTimestamp().getValue());
367 // Position trace at event rank 2 * 'cacheSize' - 1
368 tmpContext
= fExperiment
.seekEvent(2 * cacheSize
- 1);
369 context
= fExperiment
.seekEvent(tmpContext
.getLocation());
370 context
= fExperiment
.seekEvent(2 * cacheSize
- 1);
372 event
= fExperiment
.getNext(context
);
373 assertEquals("Event timestamp", 2 * cacheSize
, event
.getTimestamp().getValue());
375 event
= fExperiment
.getNext(context
);
376 assertEquals("Event timestamp", 2 * cacheSize
+ 1, event
.getTimestamp().getValue());
378 // Position trace at event rank 4500
379 tmpContext
= fExperiment
.seekEvent(4500);
380 context
= fExperiment
.seekEvent(tmpContext
.getLocation());
382 event
= fExperiment
.getNext(context
);
383 assertEquals("Event timestamp", 4501, event
.getTimestamp().getValue());
385 event
= fExperiment
.getNext(context
);
386 assertEquals("Event timestamp", 4502, event
.getTimestamp().getValue());
390 public void testSeekLocationOutOfScope() {
391 // Position trace at beginning
392 ITmfContext context
= fExperiment
.seekEvent((ITmfLocation
) null);
394 ITmfEvent event
= fExperiment
.getNext(context
);
395 assertEquals("Event timestamp", 1, event
.getTimestamp().getValue());
398 // ------------------------------------------------------------------------
399 // getNext - updates the context
400 // ------------------------------------------------------------------------
402 private static void validateContextRanks(ITmfContext context
) {
403 assertTrue("Experiment context type", context
instanceof TmfExperimentContext
);
404 TmfExperimentContext ctx
= (TmfExperimentContext
) context
;
406 int nbTraces
= ctx
.getContexts().length
;
408 // expRank = sum(trace ranks) - nbTraces + 1 (if lastTraceRead != NO_TRACE)
409 long expRank
= -nbTraces
+ ((ctx
.getLastTrace() != TmfExperimentContext
.NO_TRACE
) ?
1 : 0);
410 for (int i
= 0; i
< nbTraces
; i
++) {
411 long rank
= ctx
.getContexts()[i
].getRank();
418 assertEquals("Experiment context rank", expRank
, ctx
.getRank());
422 public void testGetNextAfteSeekingOnTS_1() {
423 final long INITIAL_TS
= 1;
424 final int NB_READS
= 20;
426 // On lower bound, returns the first event (ts = 1)
427 final ITmfContext context
= fExperiment
.seekEvent(new TmfTimestamp(INITIAL_TS
, SCALE
, 0));
429 validateContextRanks(context
);
433 for (int i
= 0; i
< NB_READS
; i
++) {
434 event
= fExperiment
.getNext(context
);
435 assertEquals("Event timestamp", INITIAL_TS
+ i
, event
.getTimestamp().getValue());
436 assertEquals("Event rank", INITIAL_TS
+ i
, context
.getRank());
439 // Make sure we stay positioned
440 event
= fExperiment
.parseEvent(context
);
441 assertEquals("Event timestamp", INITIAL_TS
+ NB_READS
, event
.getTimestamp().getValue());
442 assertEquals("Event rank", INITIAL_TS
+ NB_READS
- 1, context
.getRank());
444 validateContextRanks(context
);
448 public void testGetNextAfteSeekingOnTS_2() {
449 final long INITIAL_TS
= 2;
450 final int NB_READS
= 20;
452 // On lower bound, returns the first event (ts = 2)
453 final ITmfContext context
= fExperiment
.seekEvent(new TmfTimestamp(INITIAL_TS
, SCALE
, 0));
455 validateContextRanks(context
);
459 for (int i
= 0; i
< NB_READS
; i
++) {
460 event
= fExperiment
.getNext(context
);
461 assertEquals("Event timestamp", INITIAL_TS
+ i
, event
.getTimestamp().getValue());
462 assertEquals("Event rank", INITIAL_TS
+ i
, context
.getRank());
465 // Make sure we stay positioned
466 event
= fExperiment
.parseEvent(context
);
467 assertEquals("Event timestamp", INITIAL_TS
+ NB_READS
, event
.getTimestamp().getValue());
468 assertEquals("Event rank", INITIAL_TS
+ NB_READS
- 1, context
.getRank());
470 validateContextRanks(context
);
474 public void testGetNextAfteSeekingOnTS_3() {
475 final long INITIAL_TS
= 500;
476 final int NB_READS
= 20;
478 // On lower bound, returns the first event (ts = 500)
479 final ITmfContext context
= fExperiment
.seekEvent(new TmfTimestamp(INITIAL_TS
, SCALE
, 0));
481 validateContextRanks(context
);
485 for (int i
= 0; i
< NB_READS
; i
++) {
486 event
= fExperiment
.getNext(context
);
487 assertEquals("Event timestamp", INITIAL_TS
+ i
, event
.getTimestamp().getValue());
488 assertEquals("Event rank", INITIAL_TS
+ i
, context
.getRank());
491 // Make sure we stay positioned
492 event
= fExperiment
.parseEvent(context
);
493 assertEquals("Event timestamp", INITIAL_TS
+ NB_READS
, event
.getTimestamp().getValue());
494 assertEquals("Event rank", INITIAL_TS
+ NB_READS
- 1, context
.getRank());
496 validateContextRanks(context
);
500 public void testGetNextAfterSeekingOnRank_1() {
501 final long INITIAL_RANK
= 0L;
502 final int NB_READS
= 20;
504 // On lower bound, returns the first event (rank = 0)
505 final ITmfContext context
= fExperiment
.seekEvent(INITIAL_RANK
);
507 validateContextRanks(context
);
511 for (int i
= 0; i
< NB_READS
; i
++) {
512 event
= fExperiment
.getNext(context
);
513 assertEquals("Event timestamp", INITIAL_RANK
+ i
+ 1, event
.getTimestamp().getValue());
514 assertEquals("Event rank", INITIAL_RANK
+ i
+ 1, context
.getRank());
517 // Make sure we stay positioned
518 event
= fExperiment
.parseEvent(context
);
519 assertEquals("Event timestamp", INITIAL_RANK
+ NB_READS
+ 1, event
.getTimestamp().getValue());
520 assertEquals("Event rank", INITIAL_RANK
+ NB_READS
, context
.getRank());
522 validateContextRanks(context
);
526 public void testGetNextAfterSeekingOnRank_2() {
527 final long INITIAL_RANK
= 1L;
528 final int NB_READS
= 20;
530 // On lower bound, returns the first event (rank = 0)
531 final ITmfContext context
= fExperiment
.seekEvent(INITIAL_RANK
);
533 validateContextRanks(context
);
537 for (int i
= 0; i
< NB_READS
; i
++) {
538 event
= fExperiment
.getNext(context
);
539 assertEquals("Event timestamp", INITIAL_RANK
+ i
+ 1, event
.getTimestamp().getValue());
540 assertEquals("Event rank", INITIAL_RANK
+ i
+ 1, context
.getRank());
543 // Make sure we stay positioned
544 event
= fExperiment
.parseEvent(context
);
545 assertEquals("Event timestamp", INITIAL_RANK
+ NB_READS
+ 1, event
.getTimestamp().getValue());
546 assertEquals("Event rank", INITIAL_RANK
+ NB_READS
, context
.getRank());
548 validateContextRanks(context
);
552 public void testGetNextAfterSeekingOnRank_3() {
553 final long INITIAL_RANK
= 500L;
554 final int NB_READS
= 20;
556 // On lower bound, returns the first event (rank = 0)
557 final ITmfContext context
= fExperiment
.seekEvent(INITIAL_RANK
);
559 validateContextRanks(context
);
563 for (int i
= 0; i
< NB_READS
; i
++) {
564 event
= fExperiment
.getNext(context
);
565 assertEquals("Event timestamp", INITIAL_RANK
+ i
+ 1, event
.getTimestamp().getValue());
566 assertEquals("Event rank", INITIAL_RANK
+ i
+ 1, context
.getRank());
569 // Make sure we stay positioned
570 event
= fExperiment
.parseEvent(context
);
571 assertEquals("Event timestamp", INITIAL_RANK
+ NB_READS
+ 1, event
.getTimestamp().getValue());
572 assertEquals("Event rank", INITIAL_RANK
+ NB_READS
, context
.getRank());
574 validateContextRanks(context
);
578 public void testGetNextAfterSeekingOnLocation_1() {
579 final ITmfLocation INITIAL_LOC
= null;
580 final long INITIAL_TS
= 1;
581 final int NB_READS
= 20;
583 // On lower bound, returns the first event (ts = 1)
584 final ITmfContext context
= fExperiment
.seekEvent(INITIAL_LOC
);
586 validateContextRanks(context
);
590 for (int i
= 0; i
< NB_READS
; i
++) {
591 event
= fExperiment
.getNext(context
);
592 assertEquals("Event timestamp", INITIAL_TS
+ i
, event
.getTimestamp().getValue());
593 assertEquals("Event rank", INITIAL_TS
+ i
, context
.getRank());
596 // Make sure we stay positioned
597 event
= fExperiment
.parseEvent(context
);
598 assertEquals("Event timestamp", INITIAL_TS
+ NB_READS
, event
.getTimestamp().getValue());
599 assertEquals("Event rank", INITIAL_TS
+ NB_READS
- 1, context
.getRank());
601 validateContextRanks(context
);
605 public void testGetNextAfterSeekingOnLocation_2() {
606 final ITmfLocation INITIAL_LOC
= fExperiment
.seekEvent(1L).getLocation();
607 final long INITIAL_TS
= 2;
608 final int NB_READS
= 20;
610 // On lower bound, returns the first event (ts = 2)
611 final ITmfContext context
= fExperiment
.seekEvent(INITIAL_LOC
);
613 validateContextRanks(context
);
617 for (int i
= 0; i
< NB_READS
; i
++) {
618 event
= fExperiment
.getNext(context
);
619 assertEquals("Event timestamp", INITIAL_TS
+ i
, event
.getTimestamp().getValue());
622 // Make sure we stay positioned
623 event
= fExperiment
.parseEvent(context
);
624 assertEquals("Event timestamp", INITIAL_TS
+ NB_READS
, event
.getTimestamp().getValue());
626 validateContextRanks(context
);
630 public void testGetNextAfterSeekingOnLocation_3() {
631 final ITmfLocation INITIAL_LOC
= fExperiment
.seekEvent(500L).getLocation();
632 final long INITIAL_TS
= 501;
633 final int NB_READS
= 20;
635 // On lower bound, returns the first event (ts = 501)
636 final ITmfContext context
= fExperiment
.seekEvent(INITIAL_LOC
);
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());
647 // Make sure we stay positioned
648 event
= fExperiment
.parseEvent(context
);
649 assertEquals("Event timestamp", INITIAL_TS
+ NB_READS
, event
.getTimestamp().getValue());
651 validateContextRanks(context
);
655 public void testGetNextLocation() {
656 ITmfContext context1
= fExperiment
.seekEvent(0);
657 fExperiment
.getNext(context1
);
658 ITmfLocation location
= context1
.getLocation();
659 ITmfEvent event1
= fExperiment
.getNext(context1
);
660 ITmfContext context2
= fExperiment
.seekEvent(location
);
661 ITmfEvent event2
= fExperiment
.getNext(context2
);
662 assertEquals("Event timestamp", event1
.getTimestamp().getValue(), event2
.getTimestamp().getValue());
666 public void testGetNextEndLocation() {
667 ITmfContext context1
= fExperiment
.seekEvent(fExperiment
.getNbEvents() - 1);
668 fExperiment
.getNext(context1
);
669 ITmfLocation location
= context1
.getLocation();
670 ITmfContext context2
= fExperiment
.seekEvent(location
);
671 ITmfEvent event
= fExperiment
.getNext(context2
);
672 assertNull("Event", event
);
675 // ------------------------------------------------------------------------
677 // ------------------------------------------------------------------------
680 public void testProcessRequestForNbEvents() throws InterruptedException
{
681 final int nbEvents
= 1000;
682 final Vector
<ITmfEvent
> requestedEvents
= new Vector
<ITmfEvent
>();
684 final TmfTimeRange range
= new TmfTimeRange(TmfTimestamp
.BIG_BANG
, TmfTimestamp
.BIG_CRUNCH
);
685 final TmfEventRequest request
= new TmfEventRequest(ITmfEvent
.class,
686 range
, 0, nbEvents
, ExecutionType
.FOREGROUND
) {
688 public void handleData(final ITmfEvent event
) {
689 super.handleData(event
);
690 requestedEvents
.add(event
);
693 fExperiment
.sendRequest(request
);
694 request
.waitForCompletion();
696 assertEquals("nbEvents", nbEvents
, requestedEvents
.size());
697 assertTrue("isCompleted", request
.isCompleted());
698 assertFalse("isCancelled", request
.isCancelled());
700 // Ensure that we have distinct events.
701 // Don't go overboard: we are not validating the stub!
702 for (int i
= 0; i
< nbEvents
; i
++) {
703 assertEquals("Distinct events", i
+1, requestedEvents
.get(i
).getTimestamp().getValue());
708 public void testProcessRequestForAllEvents() throws InterruptedException
{
709 final int nbEvents
= TmfDataRequest
.ALL_DATA
;
710 final Vector
<ITmfEvent
> requestedEvents
= new Vector
<ITmfEvent
>();
711 final long nbExpectedEvents
= NB_EVENTS
;
713 final TmfTimeRange range
= new TmfTimeRange(TmfTimestamp
.BIG_BANG
, TmfTimestamp
.BIG_CRUNCH
);
714 final TmfEventRequest request
= new TmfEventRequest(ITmfEvent
.class,
715 range
, 0, nbEvents
, ExecutionType
.FOREGROUND
) {
717 public void handleData(final ITmfEvent event
) {
718 super.handleData(event
);
719 requestedEvents
.add(event
);
722 fExperiment
.sendRequest(request
);
723 request
.waitForCompletion();
725 assertEquals("nbEvents", nbExpectedEvents
, requestedEvents
.size());
726 assertTrue("isCompleted", request
.isCompleted());
727 assertFalse("isCancelled", request
.isCancelled());
729 // Ensure that we have distinct events.
730 // Don't go overboard: we are not validating the stub!
731 for (int i
= 0; i
< nbExpectedEvents
; i
++) {
732 assertEquals("Distinct events", i
+1, requestedEvents
.get(i
).getTimestamp().getValue());
736 // ------------------------------------------------------------------------
738 // ------------------------------------------------------------------------
741 public void testCancel() throws InterruptedException
{
742 final int nbEvents
= NB_EVENTS
;
743 final int limit
= BLOCK_SIZE
;
744 final Vector
<ITmfEvent
> requestedEvents
= new Vector
<ITmfEvent
>();
746 final TmfTimeRange range
= new TmfTimeRange(TmfTimestamp
.BIG_BANG
, TmfTimestamp
.BIG_CRUNCH
);
747 final TmfEventRequest request
= new TmfEventRequest(ITmfEvent
.class,
748 range
, 0, nbEvents
, ExecutionType
.FOREGROUND
) {
752 public void handleData(final ITmfEvent event
) {
753 super.handleData(event
);
754 requestedEvents
.add(event
);
755 if (++nbRead
== limit
) {
760 fExperiment
.sendRequest(request
);
761 request
.waitForCompletion();
763 assertEquals("nbEvents", limit
, requestedEvents
.size());
764 assertTrue("isCompleted", request
.isCompleted());
765 assertTrue("isCancelled", request
.isCancelled());
768 // ------------------------------------------------------------------------
770 // ------------------------------------------------------------------------
773 public void testGetTimestamp() {
774 assertEquals("getTimestamp", new TmfTimestamp( 1, (byte) -3), fExperiment
.getTimestamp( 0));
775 assertEquals("getTimestamp", new TmfTimestamp( 2, (byte) -3), fExperiment
.getTimestamp( 1));
776 assertEquals("getTimestamp", new TmfTimestamp( 11, (byte) -3), fExperiment
.getTimestamp( 10));
777 assertEquals("getTimestamp", new TmfTimestamp( 101, (byte) -3), fExperiment
.getTimestamp( 100));
778 assertEquals("getTimestamp", new TmfTimestamp( 1001, (byte) -3), fExperiment
.getTimestamp( 1000));
779 assertEquals("getTimestamp", new TmfTimestamp( 2001, (byte) -3), fExperiment
.getTimestamp( 2000));
780 assertEquals("getTimestamp", new TmfTimestamp( 2501, (byte) -3), fExperiment
.getTimestamp( 2500));
781 assertEquals("getTimestamp", new TmfTimestamp(10000, (byte) -3), fExperiment
.getTimestamp( 9999));
782 assertEquals("getTimestamp", new TmfTimestamp(20000, (byte) -3), fExperiment
.getTimestamp(19999));
783 assertNull("getTimestamp", fExperiment
.getTimestamp(20000));
786 // ------------------------------------------------------------------------
787 // getInitialRangeOffset, getCurrentRange, getCurrentTime
788 // ------------------------------------------------------------------------
791 public void testDefaultCurrentTimeValues() {
792 ITmfTrace
[] traces
= setupTraces();
793 TmfExperimentStub exp
= new TmfExperimentStub(EXPERIMENT
, traces
, BLOCK_SIZE
);
795 // verify initial values
796 TmfTimestamp initRange
= new TmfTimestamp(DEFAULT_INITIAL_OFFSET_VALUE
, ITmfTimestamp
.NANOSECOND_SCALE
);
797 assertEquals("getInitialRangeOffset", initRange
, exp
.getInitialRangeOffset());
803 public void testInitialRangeOffset() {
804 ITmfTrace
[] traces
= setupTraces();
805 ((TmfTraceStub
) traces
[0]).setInitialRangeOffset(new TmfTimestamp(5, ITmfTimestamp
.MILLISECOND_SCALE
));
806 ((TmfTraceStub
) traces
[1]).setInitialRangeOffset(new TmfTimestamp(2, ITmfTimestamp
.MILLISECOND_SCALE
));
807 TmfExperimentStub exp
= new TmfExperimentStub(EXPERIMENT
, traces
, BLOCK_SIZE
);
809 TmfTimestamp initRange
= new TmfTimestamp(2, ITmfTimestamp
.MILLISECOND_SCALE
);
810 assertEquals("getInitialRangeOffset", initRange
, exp
.getInitialRangeOffset());