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
.tests
.TmfCoreTestPlugin
;
37 import org
.eclipse
.linuxtools
.tmf
.core
.timestamp
.ITmfTimestamp
;
38 import org
.eclipse
.linuxtools
.tmf
.core
.timestamp
.TmfTimeRange
;
39 import org
.eclipse
.linuxtools
.tmf
.core
.timestamp
.TmfTimestamp
;
40 import org
.eclipse
.linuxtools
.tmf
.core
.trace
.ITmfContext
;
41 import org
.eclipse
.linuxtools
.tmf
.core
.trace
.ITmfLocation
;
42 import org
.eclipse
.linuxtools
.tmf
.core
.trace
.ITmfTrace
;
43 import org
.eclipse
.linuxtools
.tmf
.tests
.stubs
.trace
.TmfExperimentStub
;
44 import org
.eclipse
.linuxtools
.tmf
.tests
.stubs
.trace
.TmfTraceStub
;
45 import org
.junit
.AfterClass
;
46 import org
.junit
.BeforeClass
;
47 import org
.junit
.Test
;
50 * Test suite for the TmfExperiment class (multiple traces).
52 @SuppressWarnings("javadoc")
53 public class TmfMultiTraceExperimentTest
{
55 // ------------------------------------------------------------------------
57 // ------------------------------------------------------------------------
59 private static final long DEFAULT_INITIAL_OFFSET_VALUE
= (1L * 100 * 1000 * 1000); // .1sec
60 private static final String DIRECTORY
= "testfiles";
61 private static final String TEST_STREAM1
= "O-Test-10K";
62 private static final String TEST_STREAM2
= "E-Test-10K";
63 private static final String EXPERIMENT
= "MyExperiment";
64 private static int NB_EVENTS
= 20000;
65 private static int BLOCK_SIZE
= 1000;
67 private static TmfExperimentStub fExperiment
;
69 private static byte SCALE
= (byte) -3;
71 // ------------------------------------------------------------------------
73 // ------------------------------------------------------------------------
76 public static void setUp() {
77 ITmfTrace
[] traces
= setupTraces();
78 fExperiment
= new TmfExperimentStub(EXPERIMENT
, traces
, BLOCK_SIZE
);
79 fExperiment
.getIndexer().buildIndex(0, TmfTimeRange
.ETERNITY
, true);
83 public static void tearDown() {
84 fExperiment
.dispose();
87 private static ITmfTrace
[] setupTraces() {
88 final String path1
= DIRECTORY
+ File
.separator
+ TEST_STREAM1
;
89 final String path2
= DIRECTORY
+ File
.separator
+ TEST_STREAM2
;
91 ITmfTrace
[] traces
= new ITmfTrace
[2];
93 URL location
= FileLocator
.find(TmfCoreTestPlugin
.getDefault().getBundle(), new Path(path1
), null);
94 File test
= new File(FileLocator
.toFileURL(location
).toURI());
95 final TmfTraceStub trace1
= new TmfTraceStub(test
.getPath(), 0, true);
98 location
= FileLocator
.find(TmfCoreTestPlugin
.getDefault().getBundle(), new Path(path2
), null);
99 test
= new File(FileLocator
.toFileURL(location
).toURI());
100 final TmfTraceStub trace2
= new TmfTraceStub(test
.getPath(), 0, true);
104 } catch (final TmfTraceException e
) {
106 } catch (final URISyntaxException e
) {
108 } catch (final IOException e
) {
111 return new ITmfTrace
[0];
114 // ------------------------------------------------------------------------
116 // ------------------------------------------------------------------------
119 public void testBasicTmfExperimentConstructor() {
120 assertEquals("GetId", EXPERIMENT
, fExperiment
.getName());
121 assertEquals("GetNbEvents", NB_EVENTS
, fExperiment
.getNbEvents());
123 final TmfTimeRange timeRange
= fExperiment
.getTimeRange();
124 assertEquals("getStartTime", 1, timeRange
.getStartTime().getValue());
125 assertEquals("getEndTime", NB_EVENTS
, timeRange
.getEndTime().getValue());
127 TmfTimestamp initRange
= new TmfTimestamp(DEFAULT_INITIAL_OFFSET_VALUE
, ITmfTimestamp
.NANOSECOND_SCALE
);
128 assertEquals("getInitialRangeOffset", initRange
, fExperiment
.getInitialRangeOffset());
131 // ------------------------------------------------------------------------
133 // ------------------------------------------------------------------------
136 public void testSeekRankOnCacheBoundary() {
137 long cacheSize
= fExperiment
.getCacheSize();
139 // On lower bound, returns the first event (TS = 1)
140 ITmfContext context
= fExperiment
.seekEvent(0);
141 assertEquals("Context rank", 0, context
.getRank());
143 ITmfEvent event
= fExperiment
.getNext(context
);
144 assertEquals("Event timestamp", 1, event
.getTimestamp().getValue());
145 assertEquals("Context rank", 1, context
.getRank());
147 // Position trace at event rank [cacheSize]
148 context
= fExperiment
.seekEvent(cacheSize
);
149 assertEquals("Context rank", cacheSize
, context
.getRank());
151 event
= fExperiment
.getNext(context
);
152 assertEquals("Event timestamp", cacheSize
+ 1, event
.getTimestamp().getValue());
153 assertEquals("Context rank", cacheSize
+ 1, context
.getRank());
155 // Position trace at event rank [4 * cacheSize]
156 context
= fExperiment
.seekEvent(4 * cacheSize
);
157 assertEquals("Context rank", 4 * cacheSize
, context
.getRank());
159 event
= fExperiment
.getNext(context
);
160 assertEquals("Event timestamp", 4 * cacheSize
+ 1, event
.getTimestamp().getValue());
161 assertEquals("Context rank", 4 * cacheSize
+ 1, context
.getRank());
165 public void testSeekRankNotOnCacheBoundary() {
166 long cacheSize
= fExperiment
.getCacheSize();
168 // Position trace at event rank 9
169 ITmfContext context
= fExperiment
.seekEvent(9);
170 assertEquals("Context rank", 9, context
.getRank());
172 ITmfEvent event
= fExperiment
.getNext(context
);
173 assertEquals("Event timestamp", 10, event
.getTimestamp().getValue());
174 assertEquals("Context rank", 10, context
.getRank());
176 // Position trace at event rank [cacheSize - 1]
177 context
= fExperiment
.seekEvent(cacheSize
- 1);
178 assertEquals("Context rank", cacheSize
- 1, context
.getRank());
180 event
= fExperiment
.getNext(context
);
181 assertEquals("Event timestamp", cacheSize
, event
.getTimestamp().getValue());
182 assertEquals("Context rank", cacheSize
, context
.getRank());
184 // Position trace at event rank [cacheSize + 1]
185 context
= fExperiment
.seekEvent(cacheSize
+ 1);
186 assertEquals("Context rank", cacheSize
+ 1, context
.getRank());
188 event
= fExperiment
.getNext(context
);
189 assertEquals("Event timestamp", cacheSize
+ 2, event
.getTimestamp().getValue());
190 assertEquals("Context rank", cacheSize
+ 2, context
.getRank());
192 // Position trace at event rank 4500
193 context
= fExperiment
.seekEvent(4500);
194 assertEquals("Context rank", 4500, context
.getRank());
196 event
= fExperiment
.getNext(context
);
197 assertEquals("Event timestamp", 4501, event
.getTimestamp().getValue());
198 assertEquals("Context rank", 4501, context
.getRank());
202 public void testSeekRankOutOfScope() {
203 // Position trace at beginning
204 ITmfContext context
= fExperiment
.seekEvent(-1);
205 assertEquals("Event rank", 0, context
.getRank());
207 ITmfEvent event
= fExperiment
.getNext(context
);
208 assertEquals("Event timestamp", 1, event
.getTimestamp().getValue());
209 assertEquals("Context rank", 1, context
.getRank());
211 // Position trace at event passed the end
212 context
= fExperiment
.seekEvent(NB_EVENTS
);
213 assertEquals("Context rank", NB_EVENTS
, context
.getRank());
215 event
= fExperiment
.getNext(context
);
216 assertNull("Event", event
);
217 assertEquals("Context rank", NB_EVENTS
, context
.getRank());
220 // ------------------------------------------------------------------------
221 // seekEvent on timestamp
222 // ------------------------------------------------------------------------
225 public void testSeekTimestampOnCacheBoundary() {
226 long cacheSize
= fExperiment
.getCacheSize();
228 // Position trace at event rank 0
229 ITmfContext context
= fExperiment
.seekEvent(new TmfTimestamp(1, SCALE
, 0));
230 assertEquals("Context rank", 0, context
.getRank());
232 ITmfEvent event
= fExperiment
.getNext(context
);
233 assertEquals("Event timestamp", 1, event
.getTimestamp().getValue());
234 assertEquals("Context rank", 1, context
.getRank());
236 // Position trace at event rank [cacheSize]
237 context
= fExperiment
.seekEvent(new TmfTimestamp(cacheSize
+ 1, SCALE
, 0));
238 assertEquals("Event rank", cacheSize
, context
.getRank());
240 event
= fExperiment
.getNext(context
);
241 assertEquals("Event timestamp", cacheSize
+ 1, event
.getTimestamp().getValue());
242 assertEquals("Context rank", cacheSize
+ 1, context
.getRank());
244 // Position trace at event rank [4 * cacheSize]
245 context
= fExperiment
.seekEvent(new TmfTimestamp(4 * cacheSize
+ 1, SCALE
, 0));
246 assertEquals("Context rank", 4 * cacheSize
, context
.getRank());
248 event
= fExperiment
.getNext(context
);
249 assertEquals("Event timestamp", 4 * cacheSize
+ 1, event
.getTimestamp().getValue());
250 assertEquals("Context rank", 4 * cacheSize
+ 1, context
.getRank());
254 public void testSeekTimestampNotOnCacheBoundary() {
255 // Position trace at event rank 1 (TS = 2)
256 ITmfContext context
= fExperiment
.seekEvent(new TmfTimestamp(2, SCALE
, 0));
257 assertEquals("Context rank", 1, context
.getRank());
259 ITmfEvent event
= fExperiment
.getNext(context
);
260 assertEquals("Event timestamp", 2, event
.getTimestamp().getValue());
261 assertEquals("Context rank", 2, context
.getRank());
263 // Position trace at event rank 9 (TS = 10)
264 context
= fExperiment
.seekEvent(new TmfTimestamp(10, SCALE
, 0));
265 assertEquals("Context rank", 9, context
.getRank());
267 event
= fExperiment
.getNext(context
);
268 assertEquals("Event timestamp", 10, event
.getTimestamp().getValue());
269 assertEquals("Context rank", 10, context
.getRank());
271 // Position trace at event rank 999 (TS = 1000)
272 context
= fExperiment
.seekEvent(new TmfTimestamp(1000, SCALE
, 0));
273 assertEquals("Context rank", 999, context
.getRank());
275 event
= fExperiment
.getNext(context
);
276 assertEquals("Event timestamp", 1000, event
.getTimestamp().getValue());
277 assertEquals("Context rank", 1000, context
.getRank());
279 // Position trace at event rank 1001 (TS = 1002)
280 context
= fExperiment
.seekEvent(new TmfTimestamp(1002, SCALE
, 0));
281 assertEquals("Context rank", 1001, context
.getRank());
283 event
= fExperiment
.getNext(context
);
284 assertEquals("Event timestamp", 1002, event
.getTimestamp().getValue());
285 assertEquals("Context rank", 1002, context
.getRank());
287 // Position trace at event rank 4500 (TS = 4501)
288 context
= fExperiment
.seekEvent(new TmfTimestamp(4501, SCALE
, 0));
289 assertEquals("Context rank", 4500, context
.getRank());
291 event
= fExperiment
.getNext(context
);
292 assertEquals("Event timestamp", 4501, event
.getTimestamp().getValue());
293 assertEquals("Context rank", 4501, context
.getRank());
297 public void testSeekTimestampOutOfScope() {
298 // Position trace at beginning
299 ITmfContext context
= fExperiment
.seekEvent(new TmfTimestamp(-1, SCALE
, 0));
300 assertEquals("Event rank", 0, context
.getRank());
302 ITmfEvent event
= fExperiment
.getNext(context
);
303 assertEquals("Event timestamp", 1, event
.getTimestamp().getValue());
304 assertEquals("Event rank", 1, context
.getRank());
306 // Position trace at event passed the end
307 context
= fExperiment
.seekEvent(new TmfTimestamp(NB_EVENTS
+ 1, SCALE
, 0));
308 event
= fExperiment
.getNext(context
);
309 assertNull("Event location", event
);
310 assertEquals("Event rank", ITmfContext
.UNKNOWN_RANK
, context
.getRank());
313 // ------------------------------------------------------------------------
314 // seekEvent by location (context rank is undefined)
315 // ------------------------------------------------------------------------
318 public void testSeekLocationOnCacheBoundary() {
319 long cacheSize
= fExperiment
.getCacheSize();
321 // Position trace at event rank 0
322 ITmfContext tmpContext
= fExperiment
.seekEvent(0);
323 ITmfContext context
= fExperiment
.seekEvent(tmpContext
.getLocation());
325 ITmfEvent event
= fExperiment
.getNext(context
);
326 assertEquals("Event timestamp", 1, event
.getTimestamp().getValue());
328 event
= fExperiment
.getNext(context
);
329 assertEquals("Event timestamp", 2, event
.getTimestamp().getValue());
331 // Position trace at event rank 'cacheSize'
332 tmpContext
= fExperiment
.seekEvent(cacheSize
);
333 context
= fExperiment
.seekEvent(tmpContext
.getLocation());
335 event
= fExperiment
.getNext(context
);
336 assertEquals("Event timestamp", cacheSize
+ 1, event
.getTimestamp().getValue());
338 event
= fExperiment
.getNext(context
);
339 assertEquals("Event timestamp", cacheSize
+ 2, event
.getTimestamp().getValue());
341 // Position trace at event rank 4 * 'cacheSize'
342 tmpContext
= fExperiment
.seekEvent(4 * cacheSize
);
343 context
= fExperiment
.seekEvent(tmpContext
.getLocation());
345 event
= fExperiment
.getNext(context
);
346 assertEquals("Event timestamp", 4 * cacheSize
+ 1, event
.getTimestamp().getValue());
348 event
= fExperiment
.getNext(context
);
349 assertEquals("Event timestamp", 4 * cacheSize
+ 2, event
.getTimestamp().getValue());
353 public void testSeekLocationNotOnCacheBoundary() {
354 long cacheSize
= fExperiment
.getCacheSize();
356 // Position trace at event 'cacheSize' - 1
357 ITmfContext tmpContext
= fExperiment
.seekEvent(cacheSize
- 1);
358 ITmfContext context
= fExperiment
.seekEvent(tmpContext
.getLocation());
360 ITmfEvent event
= fExperiment
.getNext(context
);
361 assertEquals("Event timestamp", cacheSize
, event
.getTimestamp().getValue());
363 event
= fExperiment
.getNext(context
);
364 assertEquals("Event timestamp", cacheSize
+ 1, event
.getTimestamp().getValue());
366 // Position trace at event rank 2 * 'cacheSize' - 1
367 tmpContext
= fExperiment
.seekEvent(2 * cacheSize
- 1);
368 context
= fExperiment
.seekEvent(tmpContext
.getLocation());
369 context
= fExperiment
.seekEvent(2 * cacheSize
- 1);
371 event
= fExperiment
.getNext(context
);
372 assertEquals("Event timestamp", 2 * cacheSize
, event
.getTimestamp().getValue());
374 event
= fExperiment
.getNext(context
);
375 assertEquals("Event timestamp", 2 * cacheSize
+ 1, event
.getTimestamp().getValue());
377 // Position trace at event rank 4500
378 tmpContext
= fExperiment
.seekEvent(4500);
379 context
= fExperiment
.seekEvent(tmpContext
.getLocation());
381 event
= fExperiment
.getNext(context
);
382 assertEquals("Event timestamp", 4501, event
.getTimestamp().getValue());
384 event
= fExperiment
.getNext(context
);
385 assertEquals("Event timestamp", 4502, event
.getTimestamp().getValue());
389 public void testSeekLocationOutOfScope() {
390 // Position trace at beginning
391 ITmfContext context
= fExperiment
.seekEvent((ITmfLocation
) null);
393 ITmfEvent event
= fExperiment
.getNext(context
);
394 assertEquals("Event timestamp", 1, event
.getTimestamp().getValue());
397 // ------------------------------------------------------------------------
398 // getNext - updates the context
399 // ------------------------------------------------------------------------
401 private static void validateContextRanks(ITmfContext context
) {
402 assertTrue("Experiment context type", context
instanceof TmfExperimentContext
);
403 TmfExperimentContext ctx
= (TmfExperimentContext
) context
;
405 int nbTraces
= ctx
.getContexts().length
;
407 // expRank = sum(trace ranks) - nbTraces + 1 (if lastTraceRead != NO_TRACE)
408 long expRank
= -nbTraces
+ ((ctx
.getLastTrace() != TmfExperimentContext
.NO_TRACE
) ?
1 : 0);
409 for (int i
= 0; i
< nbTraces
; i
++) {
410 long rank
= ctx
.getContexts()[i
].getRank();
417 assertEquals("Experiment context rank", expRank
, ctx
.getRank());
421 public void testGetNextAfteSeekingOnTS_1() {
422 final long INITIAL_TS
= 1;
423 final int NB_READS
= 20;
425 // On lower bound, returns the first event (ts = 1)
426 final ITmfContext context
= fExperiment
.seekEvent(new TmfTimestamp(INITIAL_TS
, SCALE
, 0));
428 validateContextRanks(context
);
432 for (int i
= 0; i
< NB_READS
; i
++) {
433 event
= fExperiment
.getNext(context
);
434 assertEquals("Event timestamp", INITIAL_TS
+ i
, event
.getTimestamp().getValue());
435 assertEquals("Event rank", INITIAL_TS
+ i
, context
.getRank());
438 // Make sure we stay positioned
439 event
= fExperiment
.parseEvent(context
);
440 assertEquals("Event timestamp", INITIAL_TS
+ NB_READS
, event
.getTimestamp().getValue());
441 assertEquals("Event rank", INITIAL_TS
+ NB_READS
- 1, context
.getRank());
443 validateContextRanks(context
);
447 public void testGetNextAfteSeekingOnTS_2() {
448 final long INITIAL_TS
= 2;
449 final int NB_READS
= 20;
451 // On lower bound, returns the first event (ts = 2)
452 final ITmfContext context
= fExperiment
.seekEvent(new TmfTimestamp(INITIAL_TS
, SCALE
, 0));
454 validateContextRanks(context
);
458 for (int i
= 0; i
< NB_READS
; i
++) {
459 event
= fExperiment
.getNext(context
);
460 assertEquals("Event timestamp", INITIAL_TS
+ i
, event
.getTimestamp().getValue());
461 assertEquals("Event rank", INITIAL_TS
+ i
, context
.getRank());
464 // Make sure we stay positioned
465 event
= fExperiment
.parseEvent(context
);
466 assertEquals("Event timestamp", INITIAL_TS
+ NB_READS
, event
.getTimestamp().getValue());
467 assertEquals("Event rank", INITIAL_TS
+ NB_READS
- 1, context
.getRank());
469 validateContextRanks(context
);
473 public void testGetNextAfteSeekingOnTS_3() {
474 final long INITIAL_TS
= 500;
475 final int NB_READS
= 20;
477 // On lower bound, returns the first event (ts = 500)
478 final ITmfContext context
= fExperiment
.seekEvent(new TmfTimestamp(INITIAL_TS
, SCALE
, 0));
480 validateContextRanks(context
);
484 for (int i
= 0; i
< NB_READS
; i
++) {
485 event
= fExperiment
.getNext(context
);
486 assertEquals("Event timestamp", INITIAL_TS
+ i
, event
.getTimestamp().getValue());
487 assertEquals("Event rank", INITIAL_TS
+ i
, context
.getRank());
490 // Make sure we stay positioned
491 event
= fExperiment
.parseEvent(context
);
492 assertEquals("Event timestamp", INITIAL_TS
+ NB_READS
, event
.getTimestamp().getValue());
493 assertEquals("Event rank", INITIAL_TS
+ NB_READS
- 1, context
.getRank());
495 validateContextRanks(context
);
499 public void testGetNextAfterSeekingOnRank_1() {
500 final long INITIAL_RANK
= 0L;
501 final int NB_READS
= 20;
503 // On lower bound, returns the first event (rank = 0)
504 final ITmfContext context
= fExperiment
.seekEvent(INITIAL_RANK
);
506 validateContextRanks(context
);
510 for (int i
= 0; i
< NB_READS
; i
++) {
511 event
= fExperiment
.getNext(context
);
512 assertEquals("Event timestamp", INITIAL_RANK
+ i
+ 1, event
.getTimestamp().getValue());
513 assertEquals("Event rank", INITIAL_RANK
+ i
+ 1, context
.getRank());
516 // Make sure we stay positioned
517 event
= fExperiment
.parseEvent(context
);
518 assertEquals("Event timestamp", INITIAL_RANK
+ NB_READS
+ 1, event
.getTimestamp().getValue());
519 assertEquals("Event rank", INITIAL_RANK
+ NB_READS
, context
.getRank());
521 validateContextRanks(context
);
525 public void testGetNextAfterSeekingOnRank_2() {
526 final long INITIAL_RANK
= 1L;
527 final int NB_READS
= 20;
529 // On lower bound, returns the first event (rank = 0)
530 final ITmfContext context
= fExperiment
.seekEvent(INITIAL_RANK
);
532 validateContextRanks(context
);
536 for (int i
= 0; i
< NB_READS
; i
++) {
537 event
= fExperiment
.getNext(context
);
538 assertEquals("Event timestamp", INITIAL_RANK
+ i
+ 1, event
.getTimestamp().getValue());
539 assertEquals("Event rank", INITIAL_RANK
+ i
+ 1, context
.getRank());
542 // Make sure we stay positioned
543 event
= fExperiment
.parseEvent(context
);
544 assertEquals("Event timestamp", INITIAL_RANK
+ NB_READS
+ 1, event
.getTimestamp().getValue());
545 assertEquals("Event rank", INITIAL_RANK
+ NB_READS
, context
.getRank());
547 validateContextRanks(context
);
551 public void testGetNextAfterSeekingOnRank_3() {
552 final long INITIAL_RANK
= 500L;
553 final int NB_READS
= 20;
555 // On lower bound, returns the first event (rank = 0)
556 final ITmfContext context
= fExperiment
.seekEvent(INITIAL_RANK
);
558 validateContextRanks(context
);
562 for (int i
= 0; i
< NB_READS
; i
++) {
563 event
= fExperiment
.getNext(context
);
564 assertEquals("Event timestamp", INITIAL_RANK
+ i
+ 1, event
.getTimestamp().getValue());
565 assertEquals("Event rank", INITIAL_RANK
+ i
+ 1, context
.getRank());
568 // Make sure we stay positioned
569 event
= fExperiment
.parseEvent(context
);
570 assertEquals("Event timestamp", INITIAL_RANK
+ NB_READS
+ 1, event
.getTimestamp().getValue());
571 assertEquals("Event rank", INITIAL_RANK
+ NB_READS
, context
.getRank());
573 validateContextRanks(context
);
577 public void testGetNextAfterSeekingOnLocation_1() {
578 final ITmfLocation INITIAL_LOC
= null;
579 final long INITIAL_TS
= 1;
580 final int NB_READS
= 20;
582 // On lower bound, returns the first event (ts = 1)
583 final ITmfContext context
= fExperiment
.seekEvent(INITIAL_LOC
);
585 validateContextRanks(context
);
589 for (int i
= 0; i
< NB_READS
; i
++) {
590 event
= fExperiment
.getNext(context
);
591 assertEquals("Event timestamp", INITIAL_TS
+ i
, event
.getTimestamp().getValue());
592 assertEquals("Event rank", INITIAL_TS
+ i
, context
.getRank());
595 // Make sure we stay positioned
596 event
= fExperiment
.parseEvent(context
);
597 assertEquals("Event timestamp", INITIAL_TS
+ NB_READS
, event
.getTimestamp().getValue());
598 assertEquals("Event rank", INITIAL_TS
+ NB_READS
- 1, context
.getRank());
600 validateContextRanks(context
);
604 public void testGetNextAfterSeekingOnLocation_2() {
605 final ITmfLocation INITIAL_LOC
= fExperiment
.seekEvent(1L).getLocation();
606 final long INITIAL_TS
= 2;
607 final int NB_READS
= 20;
609 // On lower bound, returns the first event (ts = 2)
610 final ITmfContext context
= fExperiment
.seekEvent(INITIAL_LOC
);
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());
621 // Make sure we stay positioned
622 event
= fExperiment
.parseEvent(context
);
623 assertEquals("Event timestamp", INITIAL_TS
+ NB_READS
, event
.getTimestamp().getValue());
625 validateContextRanks(context
);
629 public void testGetNextAfterSeekingOnLocation_3() {
630 final ITmfLocation INITIAL_LOC
= fExperiment
.seekEvent(500L).getLocation();
631 final long INITIAL_TS
= 501;
632 final int NB_READS
= 20;
634 // On lower bound, returns the first event (ts = 501)
635 final ITmfContext context
= fExperiment
.seekEvent(INITIAL_LOC
);
637 validateContextRanks(context
);
641 for (int i
= 0; i
< NB_READS
; i
++) {
642 event
= fExperiment
.getNext(context
);
643 assertEquals("Event timestamp", INITIAL_TS
+ i
, event
.getTimestamp().getValue());
646 // Make sure we stay positioned
647 event
= fExperiment
.parseEvent(context
);
648 assertEquals("Event timestamp", INITIAL_TS
+ NB_READS
, event
.getTimestamp().getValue());
650 validateContextRanks(context
);
654 public void testGetNextLocation() {
655 ITmfContext context1
= fExperiment
.seekEvent(0);
656 fExperiment
.getNext(context1
);
657 ITmfLocation location
= context1
.getLocation();
658 ITmfEvent event1
= fExperiment
.getNext(context1
);
659 ITmfContext context2
= fExperiment
.seekEvent(location
);
660 ITmfEvent event2
= fExperiment
.getNext(context2
);
661 assertEquals("Event timestamp", event1
.getTimestamp().getValue(), event2
.getTimestamp().getValue());
665 public void testGetNextEndLocation() {
666 ITmfContext context1
= fExperiment
.seekEvent(fExperiment
.getNbEvents() - 1);
667 fExperiment
.getNext(context1
);
668 ITmfLocation location
= context1
.getLocation();
669 ITmfContext context2
= fExperiment
.seekEvent(location
);
670 ITmfEvent event
= fExperiment
.getNext(context2
);
671 assertNull("Event", event
);
674 // ------------------------------------------------------------------------
676 // ------------------------------------------------------------------------
679 public void testProcessRequestForNbEvents() throws InterruptedException
{
680 final int blockSize
= 100;
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, range
, nbEvents
, blockSize
) {
687 public void handleData(final ITmfEvent event
) {
688 super.handleData(event
);
689 requestedEvents
.add(event
);
692 fExperiment
.sendRequest(request
);
693 request
.waitForCompletion();
695 assertEquals("nbEvents", nbEvents
, requestedEvents
.size());
696 assertTrue("isCompleted", request
.isCompleted());
697 assertFalse("isCancelled", request
.isCancelled());
699 // Ensure that we have distinct events.
700 // Don't go overboard: we are not validating the stub!
701 for (int i
= 0; i
< nbEvents
; i
++) {
702 assertEquals("Distinct events", i
+1, requestedEvents
.get(i
).getTimestamp().getValue());
707 public void testProcessRequestForNbEvents2() throws InterruptedException
{
708 final int blockSize
= 2 * NB_EVENTS
;
709 final int nbEvents
= 1000;
710 final Vector
<ITmfEvent
> requestedEvents
= new Vector
<ITmfEvent
>();
712 final TmfTimeRange range
= new TmfTimeRange(TmfTimestamp
.BIG_BANG
, TmfTimestamp
.BIG_CRUNCH
);
713 final TmfEventRequest request
= new TmfEventRequest(ITmfEvent
.class, range
, nbEvents
, blockSize
) {
715 public void handleData(final ITmfEvent event
) {
716 super.handleData(event
);
717 requestedEvents
.add(event
);
720 fExperiment
.sendRequest(request
);
721 request
.waitForCompletion();
723 assertEquals("nbEvents", nbEvents
, requestedEvents
.size());
724 assertTrue("isCompleted", request
.isCompleted());
725 assertFalse("isCancelled", request
.isCancelled());
727 // Ensure that we have distinct events.
728 // Don't go overboard: we are not validating the stub!
729 for (int i
= 0; i
< nbEvents
; i
++) {
730 assertEquals("Distinct events", i
+1, requestedEvents
.get(i
).getTimestamp().getValue());
735 public void testProcessRequestForAllEvents() throws InterruptedException
{
736 final int nbEvents
= TmfDataRequest
.ALL_DATA
;
737 final int blockSize
= 1;
738 final Vector
<ITmfEvent
> requestedEvents
= new Vector
<ITmfEvent
>();
739 final long nbExpectedEvents
= NB_EVENTS
;
741 final TmfTimeRange range
= new TmfTimeRange(TmfTimestamp
.BIG_BANG
, TmfTimestamp
.BIG_CRUNCH
);
742 final TmfEventRequest request
= new TmfEventRequest(ITmfEvent
.class, range
, nbEvents
, blockSize
) {
744 public void handleData(final ITmfEvent event
) {
745 super.handleData(event
);
746 requestedEvents
.add(event
);
749 fExperiment
.sendRequest(request
);
750 request
.waitForCompletion();
752 assertEquals("nbEvents", nbExpectedEvents
, requestedEvents
.size());
753 assertTrue("isCompleted", request
.isCompleted());
754 assertFalse("isCancelled", request
.isCancelled());
756 // Ensure that we have distinct events.
757 // Don't go overboard: we are not validating the stub!
758 for (int i
= 0; i
< nbExpectedEvents
; i
++) {
759 assertEquals("Distinct events", i
+1, requestedEvents
.get(i
).getTimestamp().getValue());
763 // ------------------------------------------------------------------------
765 // ------------------------------------------------------------------------
768 public void testCancel() throws InterruptedException
{
769 final int nbEvents
= NB_EVENTS
;
770 final int blockSize
= BLOCK_SIZE
;
771 final Vector
<ITmfEvent
> requestedEvents
= new Vector
<ITmfEvent
>();
773 final TmfTimeRange range
= new TmfTimeRange(TmfTimestamp
.BIG_BANG
, TmfTimestamp
.BIG_CRUNCH
);
774 final TmfEventRequest request
= new TmfEventRequest(ITmfEvent
.class, range
, nbEvents
, blockSize
) {
777 public void handleData(final ITmfEvent event
) {
778 super.handleData(event
);
779 requestedEvents
.add(event
);
780 if (++nbRead
== blockSize
) {
785 public void handleCancel() {
786 if (requestedEvents
.size() < blockSize
) {
787 System
.out
.println("aie");
791 fExperiment
.sendRequest(request
);
792 request
.waitForCompletion();
794 assertEquals("nbEvents", blockSize
, requestedEvents
.size());
795 assertTrue("isCompleted", request
.isCompleted());
796 assertTrue("isCancelled", request
.isCancelled());
799 // ------------------------------------------------------------------------
801 // ------------------------------------------------------------------------
804 public void testGetTimestamp() {
805 assertEquals("getTimestamp", new TmfTimestamp( 1, (byte) -3), fExperiment
.getTimestamp( 0));
806 assertEquals("getTimestamp", new TmfTimestamp( 2, (byte) -3), fExperiment
.getTimestamp( 1));
807 assertEquals("getTimestamp", new TmfTimestamp( 11, (byte) -3), fExperiment
.getTimestamp( 10));
808 assertEquals("getTimestamp", new TmfTimestamp( 101, (byte) -3), fExperiment
.getTimestamp( 100));
809 assertEquals("getTimestamp", new TmfTimestamp( 1001, (byte) -3), fExperiment
.getTimestamp( 1000));
810 assertEquals("getTimestamp", new TmfTimestamp( 2001, (byte) -3), fExperiment
.getTimestamp( 2000));
811 assertEquals("getTimestamp", new TmfTimestamp( 2501, (byte) -3), fExperiment
.getTimestamp( 2500));
812 assertEquals("getTimestamp", new TmfTimestamp(10000, (byte) -3), fExperiment
.getTimestamp( 9999));
813 assertEquals("getTimestamp", new TmfTimestamp(20000, (byte) -3), fExperiment
.getTimestamp(19999));
814 assertNull("getTimestamp", fExperiment
.getTimestamp(20000));
817 // ------------------------------------------------------------------------
818 // getInitialRangeOffset, getCurrentRange, getCurrentTime
819 // ------------------------------------------------------------------------
822 public void testDefaultCurrentTimeValues() {
823 ITmfTrace
[] traces
= setupTraces();
824 TmfExperimentStub exp
= new TmfExperimentStub(EXPERIMENT
, traces
, BLOCK_SIZE
);
826 // verify initial values
827 TmfTimestamp initRange
= new TmfTimestamp(DEFAULT_INITIAL_OFFSET_VALUE
, ITmfTimestamp
.NANOSECOND_SCALE
);
828 assertEquals("getInitialRangeOffset", initRange
, exp
.getInitialRangeOffset());
834 public void testInitialRangeOffset() {
835 ITmfTrace
[] traces
= setupTraces();
836 ((TmfTraceStub
) traces
[0]).setInitialRangeOffset(new TmfTimestamp(5, ITmfTimestamp
.MILLISECOND_SCALE
));
837 ((TmfTraceStub
) traces
[1]).setInitialRangeOffset(new TmfTimestamp(2, ITmfTimestamp
.MILLISECOND_SCALE
));
838 TmfExperimentStub exp
= new TmfExperimentStub(EXPERIMENT
, traces
, BLOCK_SIZE
);
840 TmfTimestamp initRange
= new TmfTimestamp(2, ITmfTimestamp
.MILLISECOND_SCALE
);
841 assertEquals("getInitialRangeOffset", initRange
, exp
.getInitialRangeOffset());