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
.tests
.shared
.TmfTestTrace
;
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
.ITmfLocation
;
43 import org
.eclipse
.linuxtools
.tmf
.core
.trace
.ITmfTrace
;
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 EXPERIMENT
= "MyExperiment";
62 private static int NB_EVENTS
= 20000;
63 private static int BLOCK_SIZE
= 1000;
65 private static TmfExperimentStub fExperiment
;
67 private static byte SCALE
= (byte) -3;
69 // ------------------------------------------------------------------------
71 // ------------------------------------------------------------------------
74 public static void setUp() {
75 ITmfTrace
[] traces
= setupTraces();
76 fExperiment
= new TmfExperimentStub(EXPERIMENT
, traces
, BLOCK_SIZE
);
77 fExperiment
.getIndexer().buildIndex(0, TmfTimeRange
.ETERNITY
, true);
81 public static void tearDown() {
82 fExperiment
.dispose();
85 private static ITmfTrace
[] setupTraces() {
87 ITmfTrace
[] traces
= new ITmfTrace
[2];
89 URL location
= FileLocator
.find(TmfCoreTestPlugin
.getDefault().getBundle(), new Path(TmfTestTrace
.O_TEST_10K
.getFullPath()), null);
90 File test
= new File(FileLocator
.toFileURL(location
).toURI());
91 final TmfTraceStub trace1
= new TmfTraceStub(test
.getPath(), 0, true);
94 location
= FileLocator
.find(TmfCoreTestPlugin
.getDefault().getBundle(), new Path(TmfTestTrace
.E_TEST_10K
.getFullPath()), null);
95 test
= new File(FileLocator
.toFileURL(location
).toURI());
96 final TmfTraceStub trace2
= new TmfTraceStub(test
.getPath(), 0, true);
100 } catch (final TmfTraceException e
) {
102 } catch (final URISyntaxException e
) {
104 } catch (final IOException e
) {
107 return new ITmfTrace
[0];
110 // ------------------------------------------------------------------------
112 // ------------------------------------------------------------------------
115 public void testBasicTmfExperimentConstructor() {
116 assertEquals("GetId", EXPERIMENT
, fExperiment
.getName());
117 assertEquals("GetNbEvents", NB_EVENTS
, fExperiment
.getNbEvents());
119 final TmfTimeRange timeRange
= fExperiment
.getTimeRange();
120 assertEquals("getStartTime", 1, timeRange
.getStartTime().getValue());
121 assertEquals("getEndTime", NB_EVENTS
, timeRange
.getEndTime().getValue());
123 TmfTimestamp initRange
= new TmfTimestamp(DEFAULT_INITIAL_OFFSET_VALUE
, ITmfTimestamp
.NANOSECOND_SCALE
);
124 assertEquals("getInitialRangeOffset", initRange
, fExperiment
.getInitialRangeOffset());
127 // ------------------------------------------------------------------------
129 // ------------------------------------------------------------------------
132 public void testSeekRankOnCacheBoundary() {
133 long cacheSize
= fExperiment
.getCacheSize();
135 // On lower bound, returns the first event (TS = 1)
136 ITmfContext context
= fExperiment
.seekEvent(0);
137 assertEquals("Context rank", 0, context
.getRank());
139 ITmfEvent event
= fExperiment
.getNext(context
);
140 assertEquals("Event timestamp", 1, event
.getTimestamp().getValue());
141 assertEquals("Context rank", 1, context
.getRank());
143 // Position trace at event rank [cacheSize]
144 context
= fExperiment
.seekEvent(cacheSize
);
145 assertEquals("Context rank", cacheSize
, context
.getRank());
147 event
= fExperiment
.getNext(context
);
148 assertEquals("Event timestamp", cacheSize
+ 1, event
.getTimestamp().getValue());
149 assertEquals("Context rank", cacheSize
+ 1, context
.getRank());
151 // Position trace at event rank [4 * cacheSize]
152 context
= fExperiment
.seekEvent(4 * cacheSize
);
153 assertEquals("Context rank", 4 * cacheSize
, context
.getRank());
155 event
= fExperiment
.getNext(context
);
156 assertEquals("Event timestamp", 4 * cacheSize
+ 1, event
.getTimestamp().getValue());
157 assertEquals("Context rank", 4 * cacheSize
+ 1, context
.getRank());
161 public void testSeekRankNotOnCacheBoundary() {
162 long cacheSize
= fExperiment
.getCacheSize();
164 // Position trace at event rank 9
165 ITmfContext context
= fExperiment
.seekEvent(9);
166 assertEquals("Context rank", 9, context
.getRank());
168 ITmfEvent event
= fExperiment
.getNext(context
);
169 assertEquals("Event timestamp", 10, event
.getTimestamp().getValue());
170 assertEquals("Context rank", 10, context
.getRank());
172 // Position trace at event rank [cacheSize - 1]
173 context
= fExperiment
.seekEvent(cacheSize
- 1);
174 assertEquals("Context rank", cacheSize
- 1, context
.getRank());
176 event
= fExperiment
.getNext(context
);
177 assertEquals("Event timestamp", cacheSize
, event
.getTimestamp().getValue());
178 assertEquals("Context rank", cacheSize
, context
.getRank());
180 // Position trace at event rank [cacheSize + 1]
181 context
= fExperiment
.seekEvent(cacheSize
+ 1);
182 assertEquals("Context rank", cacheSize
+ 1, context
.getRank());
184 event
= fExperiment
.getNext(context
);
185 assertEquals("Event timestamp", cacheSize
+ 2, event
.getTimestamp().getValue());
186 assertEquals("Context rank", cacheSize
+ 2, context
.getRank());
188 // Position trace at event rank 4500
189 context
= fExperiment
.seekEvent(4500);
190 assertEquals("Context rank", 4500, context
.getRank());
192 event
= fExperiment
.getNext(context
);
193 assertEquals("Event timestamp", 4501, event
.getTimestamp().getValue());
194 assertEquals("Context rank", 4501, context
.getRank());
198 public void testSeekRankOutOfScope() {
199 // Position trace at beginning
200 ITmfContext context
= fExperiment
.seekEvent(-1);
201 assertEquals("Event rank", 0, context
.getRank());
203 ITmfEvent event
= fExperiment
.getNext(context
);
204 assertEquals("Event timestamp", 1, event
.getTimestamp().getValue());
205 assertEquals("Context rank", 1, context
.getRank());
207 // Position trace at event passed the end
208 context
= fExperiment
.seekEvent(NB_EVENTS
);
209 assertEquals("Context rank", NB_EVENTS
, context
.getRank());
211 event
= fExperiment
.getNext(context
);
212 assertNull("Event", event
);
213 assertEquals("Context rank", NB_EVENTS
, context
.getRank());
216 // ------------------------------------------------------------------------
217 // seekEvent on timestamp
218 // ------------------------------------------------------------------------
221 public void testSeekTimestampOnCacheBoundary() {
222 long cacheSize
= fExperiment
.getCacheSize();
224 // Position trace at event rank 0
225 ITmfContext context
= fExperiment
.seekEvent(new TmfTimestamp(1, SCALE
, 0));
226 assertEquals("Context rank", 0, context
.getRank());
228 ITmfEvent event
= fExperiment
.getNext(context
);
229 assertEquals("Event timestamp", 1, event
.getTimestamp().getValue());
230 assertEquals("Context rank", 1, context
.getRank());
232 // Position trace at event rank [cacheSize]
233 context
= fExperiment
.seekEvent(new TmfTimestamp(cacheSize
+ 1, SCALE
, 0));
234 assertEquals("Event rank", cacheSize
, context
.getRank());
236 event
= fExperiment
.getNext(context
);
237 assertEquals("Event timestamp", cacheSize
+ 1, event
.getTimestamp().getValue());
238 assertEquals("Context rank", cacheSize
+ 1, context
.getRank());
240 // Position trace at event rank [4 * cacheSize]
241 context
= fExperiment
.seekEvent(new TmfTimestamp(4 * cacheSize
+ 1, SCALE
, 0));
242 assertEquals("Context rank", 4 * cacheSize
, context
.getRank());
244 event
= fExperiment
.getNext(context
);
245 assertEquals("Event timestamp", 4 * cacheSize
+ 1, event
.getTimestamp().getValue());
246 assertEquals("Context rank", 4 * cacheSize
+ 1, context
.getRank());
250 public void testSeekTimestampNotOnCacheBoundary() {
251 // Position trace at event rank 1 (TS = 2)
252 ITmfContext context
= fExperiment
.seekEvent(new TmfTimestamp(2, SCALE
, 0));
253 assertEquals("Context rank", 1, context
.getRank());
255 ITmfEvent event
= fExperiment
.getNext(context
);
256 assertEquals("Event timestamp", 2, event
.getTimestamp().getValue());
257 assertEquals("Context rank", 2, context
.getRank());
259 // Position trace at event rank 9 (TS = 10)
260 context
= fExperiment
.seekEvent(new TmfTimestamp(10, SCALE
, 0));
261 assertEquals("Context rank", 9, context
.getRank());
263 event
= fExperiment
.getNext(context
);
264 assertEquals("Event timestamp", 10, event
.getTimestamp().getValue());
265 assertEquals("Context rank", 10, context
.getRank());
267 // Position trace at event rank 999 (TS = 1000)
268 context
= fExperiment
.seekEvent(new TmfTimestamp(1000, SCALE
, 0));
269 assertEquals("Context rank", 999, context
.getRank());
271 event
= fExperiment
.getNext(context
);
272 assertEquals("Event timestamp", 1000, event
.getTimestamp().getValue());
273 assertEquals("Context rank", 1000, context
.getRank());
275 // Position trace at event rank 1001 (TS = 1002)
276 context
= fExperiment
.seekEvent(new TmfTimestamp(1002, SCALE
, 0));
277 assertEquals("Context rank", 1001, context
.getRank());
279 event
= fExperiment
.getNext(context
);
280 assertEquals("Event timestamp", 1002, event
.getTimestamp().getValue());
281 assertEquals("Context rank", 1002, context
.getRank());
283 // Position trace at event rank 4500 (TS = 4501)
284 context
= fExperiment
.seekEvent(new TmfTimestamp(4501, SCALE
, 0));
285 assertEquals("Context rank", 4500, context
.getRank());
287 event
= fExperiment
.getNext(context
);
288 assertEquals("Event timestamp", 4501, event
.getTimestamp().getValue());
289 assertEquals("Context rank", 4501, context
.getRank());
293 public void testSeekTimestampOutOfScope() {
294 // Position trace at beginning
295 ITmfContext context
= fExperiment
.seekEvent(new TmfTimestamp(-1, SCALE
, 0));
296 assertEquals("Event rank", 0, context
.getRank());
298 ITmfEvent event
= fExperiment
.getNext(context
);
299 assertEquals("Event timestamp", 1, event
.getTimestamp().getValue());
300 assertEquals("Event rank", 1, context
.getRank());
302 // Position trace at event passed the end
303 context
= fExperiment
.seekEvent(new TmfTimestamp(NB_EVENTS
+ 1, SCALE
, 0));
304 event
= fExperiment
.getNext(context
);
305 assertNull("Event location", event
);
306 assertEquals("Event rank", ITmfContext
.UNKNOWN_RANK
, context
.getRank());
309 // ------------------------------------------------------------------------
310 // seekEvent by location (context rank is undefined)
311 // ------------------------------------------------------------------------
314 public void testSeekLocationOnCacheBoundary() {
315 long cacheSize
= fExperiment
.getCacheSize();
317 // Position trace at event rank 0
318 ITmfContext tmpContext
= fExperiment
.seekEvent(0);
319 ITmfContext context
= fExperiment
.seekEvent(tmpContext
.getLocation());
321 ITmfEvent event
= fExperiment
.getNext(context
);
322 assertEquals("Event timestamp", 1, event
.getTimestamp().getValue());
324 event
= fExperiment
.getNext(context
);
325 assertEquals("Event timestamp", 2, event
.getTimestamp().getValue());
327 // Position trace at event rank 'cacheSize'
328 tmpContext
= fExperiment
.seekEvent(cacheSize
);
329 context
= fExperiment
.seekEvent(tmpContext
.getLocation());
331 event
= fExperiment
.getNext(context
);
332 assertEquals("Event timestamp", cacheSize
+ 1, event
.getTimestamp().getValue());
334 event
= fExperiment
.getNext(context
);
335 assertEquals("Event timestamp", cacheSize
+ 2, event
.getTimestamp().getValue());
337 // Position trace at event rank 4 * 'cacheSize'
338 tmpContext
= fExperiment
.seekEvent(4 * cacheSize
);
339 context
= fExperiment
.seekEvent(tmpContext
.getLocation());
341 event
= fExperiment
.getNext(context
);
342 assertEquals("Event timestamp", 4 * cacheSize
+ 1, event
.getTimestamp().getValue());
344 event
= fExperiment
.getNext(context
);
345 assertEquals("Event timestamp", 4 * cacheSize
+ 2, event
.getTimestamp().getValue());
349 public void testSeekLocationNotOnCacheBoundary() {
350 long cacheSize
= fExperiment
.getCacheSize();
352 // Position trace at event 'cacheSize' - 1
353 ITmfContext tmpContext
= fExperiment
.seekEvent(cacheSize
- 1);
354 ITmfContext context
= fExperiment
.seekEvent(tmpContext
.getLocation());
356 ITmfEvent event
= fExperiment
.getNext(context
);
357 assertEquals("Event timestamp", cacheSize
, event
.getTimestamp().getValue());
359 event
= fExperiment
.getNext(context
);
360 assertEquals("Event timestamp", cacheSize
+ 1, event
.getTimestamp().getValue());
362 // Position trace at event rank 2 * 'cacheSize' - 1
363 tmpContext
= fExperiment
.seekEvent(2 * cacheSize
- 1);
364 context
= fExperiment
.seekEvent(tmpContext
.getLocation());
365 context
= fExperiment
.seekEvent(2 * cacheSize
- 1);
367 event
= fExperiment
.getNext(context
);
368 assertEquals("Event timestamp", 2 * cacheSize
, event
.getTimestamp().getValue());
370 event
= fExperiment
.getNext(context
);
371 assertEquals("Event timestamp", 2 * cacheSize
+ 1, event
.getTimestamp().getValue());
373 // Position trace at event rank 4500
374 tmpContext
= fExperiment
.seekEvent(4500);
375 context
= fExperiment
.seekEvent(tmpContext
.getLocation());
377 event
= fExperiment
.getNext(context
);
378 assertEquals("Event timestamp", 4501, event
.getTimestamp().getValue());
380 event
= fExperiment
.getNext(context
);
381 assertEquals("Event timestamp", 4502, event
.getTimestamp().getValue());
385 public void testSeekLocationOutOfScope() {
386 // Position trace at beginning
387 ITmfContext context
= fExperiment
.seekEvent((ITmfLocation
) null);
389 ITmfEvent event
= fExperiment
.getNext(context
);
390 assertEquals("Event timestamp", 1, event
.getTimestamp().getValue());
393 // ------------------------------------------------------------------------
394 // getNext - updates the context
395 // ------------------------------------------------------------------------
397 private static void validateContextRanks(ITmfContext context
) {
398 assertTrue("Experiment context type", context
instanceof TmfExperimentContext
);
399 TmfExperimentContext ctx
= (TmfExperimentContext
) context
;
401 int nbTraces
= ctx
.getContexts().length
;
403 // expRank = sum(trace ranks) - nbTraces + 1 (if lastTraceRead != NO_TRACE)
404 long expRank
= -nbTraces
+ ((ctx
.getLastTrace() != TmfExperimentContext
.NO_TRACE
) ?
1 : 0);
405 for (int i
= 0; i
< nbTraces
; i
++) {
406 long rank
= ctx
.getContexts()[i
].getRank();
413 assertEquals("Experiment context rank", expRank
, ctx
.getRank());
417 public void testGetNextAfteSeekingOnTS_1() {
418 final long INITIAL_TS
= 1;
419 final int NB_READS
= 20;
421 // On lower bound, returns the first event (ts = 1)
422 final ITmfContext context
= fExperiment
.seekEvent(new TmfTimestamp(INITIAL_TS
, SCALE
, 0));
424 validateContextRanks(context
);
428 for (int i
= 0; i
< NB_READS
; i
++) {
429 event
= fExperiment
.getNext(context
);
430 assertEquals("Event timestamp", INITIAL_TS
+ i
, event
.getTimestamp().getValue());
431 assertEquals("Event rank", INITIAL_TS
+ i
, context
.getRank());
434 // Make sure we stay positioned
435 event
= fExperiment
.parseEvent(context
);
436 assertEquals("Event timestamp", INITIAL_TS
+ NB_READS
, event
.getTimestamp().getValue());
437 assertEquals("Event rank", INITIAL_TS
+ NB_READS
- 1, context
.getRank());
439 validateContextRanks(context
);
443 public void testGetNextAfteSeekingOnTS_2() {
444 final long INITIAL_TS
= 2;
445 final int NB_READS
= 20;
447 // On lower bound, returns the first event (ts = 2)
448 final ITmfContext context
= fExperiment
.seekEvent(new TmfTimestamp(INITIAL_TS
, SCALE
, 0));
450 validateContextRanks(context
);
454 for (int i
= 0; i
< NB_READS
; i
++) {
455 event
= fExperiment
.getNext(context
);
456 assertEquals("Event timestamp", INITIAL_TS
+ i
, event
.getTimestamp().getValue());
457 assertEquals("Event rank", INITIAL_TS
+ i
, context
.getRank());
460 // Make sure we stay positioned
461 event
= fExperiment
.parseEvent(context
);
462 assertEquals("Event timestamp", INITIAL_TS
+ NB_READS
, event
.getTimestamp().getValue());
463 assertEquals("Event rank", INITIAL_TS
+ NB_READS
- 1, context
.getRank());
465 validateContextRanks(context
);
469 public void testGetNextAfteSeekingOnTS_3() {
470 final long INITIAL_TS
= 500;
471 final int NB_READS
= 20;
473 // On lower bound, returns the first event (ts = 500)
474 final ITmfContext context
= fExperiment
.seekEvent(new TmfTimestamp(INITIAL_TS
, SCALE
, 0));
476 validateContextRanks(context
);
480 for (int i
= 0; i
< NB_READS
; i
++) {
481 event
= fExperiment
.getNext(context
);
482 assertEquals("Event timestamp", INITIAL_TS
+ i
, event
.getTimestamp().getValue());
483 assertEquals("Event rank", INITIAL_TS
+ i
, context
.getRank());
486 // Make sure we stay positioned
487 event
= fExperiment
.parseEvent(context
);
488 assertEquals("Event timestamp", INITIAL_TS
+ NB_READS
, event
.getTimestamp().getValue());
489 assertEquals("Event rank", INITIAL_TS
+ NB_READS
- 1, context
.getRank());
491 validateContextRanks(context
);
495 public void testGetNextAfterSeekingOnRank_1() {
496 final long INITIAL_RANK
= 0L;
497 final int NB_READS
= 20;
499 // On lower bound, returns the first event (rank = 0)
500 final ITmfContext context
= fExperiment
.seekEvent(INITIAL_RANK
);
502 validateContextRanks(context
);
506 for (int i
= 0; i
< NB_READS
; i
++) {
507 event
= fExperiment
.getNext(context
);
508 assertEquals("Event timestamp", INITIAL_RANK
+ i
+ 1, event
.getTimestamp().getValue());
509 assertEquals("Event rank", INITIAL_RANK
+ i
+ 1, context
.getRank());
512 // Make sure we stay positioned
513 event
= fExperiment
.parseEvent(context
);
514 assertEquals("Event timestamp", INITIAL_RANK
+ NB_READS
+ 1, event
.getTimestamp().getValue());
515 assertEquals("Event rank", INITIAL_RANK
+ NB_READS
, context
.getRank());
517 validateContextRanks(context
);
521 public void testGetNextAfterSeekingOnRank_2() {
522 final long INITIAL_RANK
= 1L;
523 final int NB_READS
= 20;
525 // On lower bound, returns the first event (rank = 0)
526 final ITmfContext context
= fExperiment
.seekEvent(INITIAL_RANK
);
528 validateContextRanks(context
);
532 for (int i
= 0; i
< NB_READS
; i
++) {
533 event
= fExperiment
.getNext(context
);
534 assertEquals("Event timestamp", INITIAL_RANK
+ i
+ 1, event
.getTimestamp().getValue());
535 assertEquals("Event rank", INITIAL_RANK
+ i
+ 1, context
.getRank());
538 // Make sure we stay positioned
539 event
= fExperiment
.parseEvent(context
);
540 assertEquals("Event timestamp", INITIAL_RANK
+ NB_READS
+ 1, event
.getTimestamp().getValue());
541 assertEquals("Event rank", INITIAL_RANK
+ NB_READS
, context
.getRank());
543 validateContextRanks(context
);
547 public void testGetNextAfterSeekingOnRank_3() {
548 final long INITIAL_RANK
= 500L;
549 final int NB_READS
= 20;
551 // On lower bound, returns the first event (rank = 0)
552 final ITmfContext context
= fExperiment
.seekEvent(INITIAL_RANK
);
554 validateContextRanks(context
);
558 for (int i
= 0; i
< NB_READS
; i
++) {
559 event
= fExperiment
.getNext(context
);
560 assertEquals("Event timestamp", INITIAL_RANK
+ i
+ 1, event
.getTimestamp().getValue());
561 assertEquals("Event rank", INITIAL_RANK
+ i
+ 1, context
.getRank());
564 // Make sure we stay positioned
565 event
= fExperiment
.parseEvent(context
);
566 assertEquals("Event timestamp", INITIAL_RANK
+ NB_READS
+ 1, event
.getTimestamp().getValue());
567 assertEquals("Event rank", INITIAL_RANK
+ NB_READS
, context
.getRank());
569 validateContextRanks(context
);
573 public void testGetNextAfterSeekingOnLocation_1() {
574 final ITmfLocation INITIAL_LOC
= null;
575 final long INITIAL_TS
= 1;
576 final int NB_READS
= 20;
578 // On lower bound, returns the first event (ts = 1)
579 final ITmfContext context
= fExperiment
.seekEvent(INITIAL_LOC
);
581 validateContextRanks(context
);
585 for (int i
= 0; i
< NB_READS
; i
++) {
586 event
= fExperiment
.getNext(context
);
587 assertEquals("Event timestamp", INITIAL_TS
+ i
, event
.getTimestamp().getValue());
588 assertEquals("Event rank", INITIAL_TS
+ i
, context
.getRank());
591 // Make sure we stay positioned
592 event
= fExperiment
.parseEvent(context
);
593 assertEquals("Event timestamp", INITIAL_TS
+ NB_READS
, event
.getTimestamp().getValue());
594 assertEquals("Event rank", INITIAL_TS
+ NB_READS
- 1, context
.getRank());
596 validateContextRanks(context
);
600 public void testGetNextAfterSeekingOnLocation_2() {
601 final ITmfLocation INITIAL_LOC
= fExperiment
.seekEvent(1L).getLocation();
602 final long INITIAL_TS
= 2;
603 final int NB_READS
= 20;
605 // On lower bound, returns the first event (ts = 2)
606 final ITmfContext context
= fExperiment
.seekEvent(INITIAL_LOC
);
608 validateContextRanks(context
);
612 for (int i
= 0; i
< NB_READS
; i
++) {
613 event
= fExperiment
.getNext(context
);
614 assertEquals("Event timestamp", INITIAL_TS
+ i
, event
.getTimestamp().getValue());
617 // Make sure we stay positioned
618 event
= fExperiment
.parseEvent(context
);
619 assertEquals("Event timestamp", INITIAL_TS
+ NB_READS
, event
.getTimestamp().getValue());
621 validateContextRanks(context
);
625 public void testGetNextAfterSeekingOnLocation_3() {
626 final ITmfLocation INITIAL_LOC
= fExperiment
.seekEvent(500L).getLocation();
627 final long INITIAL_TS
= 501;
628 final int NB_READS
= 20;
630 // On lower bound, returns the first event (ts = 501)
631 final ITmfContext context
= fExperiment
.seekEvent(INITIAL_LOC
);
633 validateContextRanks(context
);
637 for (int i
= 0; i
< NB_READS
; i
++) {
638 event
= fExperiment
.getNext(context
);
639 assertEquals("Event timestamp", INITIAL_TS
+ i
, event
.getTimestamp().getValue());
642 // Make sure we stay positioned
643 event
= fExperiment
.parseEvent(context
);
644 assertEquals("Event timestamp", INITIAL_TS
+ NB_READS
, event
.getTimestamp().getValue());
646 validateContextRanks(context
);
650 public void testGetNextLocation() {
651 ITmfContext context1
= fExperiment
.seekEvent(0);
652 fExperiment
.getNext(context1
);
653 ITmfLocation location
= context1
.getLocation();
654 ITmfEvent event1
= fExperiment
.getNext(context1
);
655 ITmfContext context2
= fExperiment
.seekEvent(location
);
656 ITmfEvent event2
= fExperiment
.getNext(context2
);
657 assertEquals("Event timestamp", event1
.getTimestamp().getValue(), event2
.getTimestamp().getValue());
661 public void testGetNextEndLocation() {
662 ITmfContext context1
= fExperiment
.seekEvent(fExperiment
.getNbEvents() - 1);
663 fExperiment
.getNext(context1
);
664 ITmfLocation location
= context1
.getLocation();
665 ITmfContext context2
= fExperiment
.seekEvent(location
);
666 ITmfEvent event
= fExperiment
.getNext(context2
);
667 assertNull("Event", event
);
670 // ------------------------------------------------------------------------
672 // ------------------------------------------------------------------------
675 public void testProcessRequestForNbEvents() throws InterruptedException
{
676 final int blockSize
= 100;
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, range
, nbEvents
, blockSize
) {
683 public void handleData(final ITmfEvent event
) {
684 super.handleData(event
);
685 requestedEvents
.add(event
);
688 fExperiment
.sendRequest(request
);
689 request
.waitForCompletion();
691 assertEquals("nbEvents", nbEvents
, requestedEvents
.size());
692 assertTrue("isCompleted", request
.isCompleted());
693 assertFalse("isCancelled", request
.isCancelled());
695 // Ensure that we have distinct events.
696 // Don't go overboard: we are not validating the stub!
697 for (int i
= 0; i
< nbEvents
; i
++) {
698 assertEquals("Distinct events", i
+1, requestedEvents
.get(i
).getTimestamp().getValue());
703 public void testProcessRequestForNbEvents2() throws InterruptedException
{
704 final int blockSize
= 2 * NB_EVENTS
;
705 final int nbEvents
= 1000;
706 final Vector
<ITmfEvent
> requestedEvents
= new Vector
<ITmfEvent
>();
708 final TmfTimeRange range
= new TmfTimeRange(TmfTimestamp
.BIG_BANG
, TmfTimestamp
.BIG_CRUNCH
);
709 final TmfEventRequest request
= new TmfEventRequest(ITmfEvent
.class, range
, nbEvents
, blockSize
) {
711 public void handleData(final ITmfEvent event
) {
712 super.handleData(event
);
713 requestedEvents
.add(event
);
716 fExperiment
.sendRequest(request
);
717 request
.waitForCompletion();
719 assertEquals("nbEvents", nbEvents
, requestedEvents
.size());
720 assertTrue("isCompleted", request
.isCompleted());
721 assertFalse("isCancelled", request
.isCancelled());
723 // Ensure that we have distinct events.
724 // Don't go overboard: we are not validating the stub!
725 for (int i
= 0; i
< nbEvents
; i
++) {
726 assertEquals("Distinct events", i
+1, requestedEvents
.get(i
).getTimestamp().getValue());
731 public void testProcessRequestForAllEvents() throws InterruptedException
{
732 final int nbEvents
= TmfDataRequest
.ALL_DATA
;
733 final int blockSize
= 1;
734 final Vector
<ITmfEvent
> requestedEvents
= new Vector
<ITmfEvent
>();
735 final long nbExpectedEvents
= NB_EVENTS
;
737 final TmfTimeRange range
= new TmfTimeRange(TmfTimestamp
.BIG_BANG
, TmfTimestamp
.BIG_CRUNCH
);
738 final TmfEventRequest request
= new TmfEventRequest(ITmfEvent
.class, range
, nbEvents
, blockSize
) {
740 public void handleData(final ITmfEvent event
) {
741 super.handleData(event
);
742 requestedEvents
.add(event
);
745 fExperiment
.sendRequest(request
);
746 request
.waitForCompletion();
748 assertEquals("nbEvents", nbExpectedEvents
, requestedEvents
.size());
749 assertTrue("isCompleted", request
.isCompleted());
750 assertFalse("isCancelled", request
.isCancelled());
752 // Ensure that we have distinct events.
753 // Don't go overboard: we are not validating the stub!
754 for (int i
= 0; i
< nbExpectedEvents
; i
++) {
755 assertEquals("Distinct events", i
+1, requestedEvents
.get(i
).getTimestamp().getValue());
759 // ------------------------------------------------------------------------
761 // ------------------------------------------------------------------------
764 public void testCancel() throws InterruptedException
{
765 final int nbEvents
= NB_EVENTS
;
766 final int blockSize
= BLOCK_SIZE
;
767 final Vector
<ITmfEvent
> requestedEvents
= new Vector
<ITmfEvent
>();
769 final TmfTimeRange range
= new TmfTimeRange(TmfTimestamp
.BIG_BANG
, TmfTimestamp
.BIG_CRUNCH
);
770 final TmfEventRequest request
= new TmfEventRequest(ITmfEvent
.class, range
, nbEvents
, blockSize
) {
773 public void handleData(final ITmfEvent event
) {
774 super.handleData(event
);
775 requestedEvents
.add(event
);
776 if (++nbRead
== blockSize
) {
781 public void handleCancel() {
782 if (requestedEvents
.size() < blockSize
) {
783 System
.out
.println("aie");
787 fExperiment
.sendRequest(request
);
788 request
.waitForCompletion();
790 assertEquals("nbEvents", blockSize
, requestedEvents
.size());
791 assertTrue("isCompleted", request
.isCompleted());
792 assertTrue("isCancelled", request
.isCancelled());
795 // ------------------------------------------------------------------------
797 // ------------------------------------------------------------------------
800 public void testGetTimestamp() {
801 assertEquals("getTimestamp", new TmfTimestamp( 1, (byte) -3), fExperiment
.getTimestamp( 0));
802 assertEquals("getTimestamp", new TmfTimestamp( 2, (byte) -3), fExperiment
.getTimestamp( 1));
803 assertEquals("getTimestamp", new TmfTimestamp( 11, (byte) -3), fExperiment
.getTimestamp( 10));
804 assertEquals("getTimestamp", new TmfTimestamp( 101, (byte) -3), fExperiment
.getTimestamp( 100));
805 assertEquals("getTimestamp", new TmfTimestamp( 1001, (byte) -3), fExperiment
.getTimestamp( 1000));
806 assertEquals("getTimestamp", new TmfTimestamp( 2001, (byte) -3), fExperiment
.getTimestamp( 2000));
807 assertEquals("getTimestamp", new TmfTimestamp( 2501, (byte) -3), fExperiment
.getTimestamp( 2500));
808 assertEquals("getTimestamp", new TmfTimestamp(10000, (byte) -3), fExperiment
.getTimestamp( 9999));
809 assertEquals("getTimestamp", new TmfTimestamp(20000, (byte) -3), fExperiment
.getTimestamp(19999));
810 assertNull("getTimestamp", fExperiment
.getTimestamp(20000));
813 // ------------------------------------------------------------------------
814 // getInitialRangeOffset, getCurrentRange, getCurrentTime
815 // ------------------------------------------------------------------------
818 public void testDefaultCurrentTimeValues() {
819 ITmfTrace
[] traces
= setupTraces();
820 TmfExperimentStub exp
= new TmfExperimentStub(EXPERIMENT
, traces
, BLOCK_SIZE
);
822 // verify initial values
823 TmfTimestamp initRange
= new TmfTimestamp(DEFAULT_INITIAL_OFFSET_VALUE
, ITmfTimestamp
.NANOSECOND_SCALE
);
824 assertEquals("getInitialRangeOffset", initRange
, exp
.getInitialRangeOffset());
830 public void testInitialRangeOffset() {
831 ITmfTrace
[] traces
= setupTraces();
832 ((TmfTraceStub
) traces
[0]).setInitialRangeOffset(new TmfTimestamp(5, ITmfTimestamp
.MILLISECOND_SCALE
));
833 ((TmfTraceStub
) traces
[1]).setInitialRangeOffset(new TmfTimestamp(2, ITmfTimestamp
.MILLISECOND_SCALE
));
834 TmfExperimentStub exp
= new TmfExperimentStub(EXPERIMENT
, traces
, BLOCK_SIZE
);
836 TmfTimestamp initRange
= new TmfTimestamp(2, ITmfTimestamp
.MILLISECOND_SCALE
);
837 assertEquals("getInitialRangeOffset", initRange
, exp
.getInitialRangeOffset());