1 /*******************************************************************************
2 * Copyright (c) 2009, 2010, 2012 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 *******************************************************************************/
14 package org
.eclipse
.linuxtools
.tmf
.core
.tests
.trace
;
17 import java
.io
.IOException
;
18 import java
.net
.URISyntaxException
;
20 import java
.util
.Vector
;
22 import junit
.framework
.TestCase
;
24 import org
.eclipse
.core
.runtime
.FileLocator
;
25 import org
.eclipse
.core
.runtime
.Path
;
26 import org
.eclipse
.linuxtools
.internal
.tmf
.core
.trace
.TmfExperimentContext
;
27 import org
.eclipse
.linuxtools
.tmf
.core
.event
.ITmfEvent
;
28 import org
.eclipse
.linuxtools
.tmf
.core
.event
.ITmfTimestamp
;
29 import org
.eclipse
.linuxtools
.tmf
.core
.event
.TmfEvent
;
30 import org
.eclipse
.linuxtools
.tmf
.core
.event
.TmfTimeRange
;
31 import org
.eclipse
.linuxtools
.tmf
.core
.event
.TmfTimestamp
;
32 import org
.eclipse
.linuxtools
.tmf
.core
.exceptions
.TmfTraceException
;
33 import org
.eclipse
.linuxtools
.tmf
.core
.request
.TmfDataRequest
;
34 import org
.eclipse
.linuxtools
.tmf
.core
.request
.TmfEventRequest
;
35 import org
.eclipse
.linuxtools
.tmf
.core
.tests
.TmfCoreTestPlugin
;
36 import org
.eclipse
.linuxtools
.tmf
.core
.trace
.ITmfContext
;
37 import org
.eclipse
.linuxtools
.tmf
.core
.trace
.ITmfLocation
;
38 import org
.eclipse
.linuxtools
.tmf
.core
.trace
.ITmfTrace
;
39 import org
.eclipse
.linuxtools
.tmf
.tests
.stubs
.trace
.TmfExperimentStub
;
40 import org
.eclipse
.linuxtools
.tmf
.tests
.stubs
.trace
.TmfTraceStub
;
43 * Test suite for the TmfExperiment class (multiple traces).
45 @SuppressWarnings({"nls","javadoc"})
46 public class TmfMultiTraceExperimentTest
extends TestCase
{
48 // ------------------------------------------------------------------------
50 // ------------------------------------------------------------------------
51 private static final long DEFAULT_INITIAL_OFFSET_VALUE
= (1L * 100 * 1000 * 1000); // .1sec
52 private static final String DIRECTORY
= "testfiles";
53 private static final String TEST_STREAM1
= "O-Test-10K";
54 private static final String TEST_STREAM2
= "E-Test-10K";
55 private static final String EXPERIMENT
= "MyExperiment";
56 private static int NB_EVENTS
= 20000;
57 private static int BLOCK_SIZE
= 1000;
59 private static ITmfTrace
[] fTraces
;
60 private static TmfExperimentStub fExperiment
;
62 private static byte SCALE
= (byte) -3;
64 // ------------------------------------------------------------------------
66 // ------------------------------------------------------------------------
68 private synchronized static ITmfTrace
[] setupTrace(final String path1
, final String path2
) {
69 if (fTraces
== null) {
70 fTraces
= new ITmfTrace
[2];
72 URL location
= FileLocator
.find(TmfCoreTestPlugin
.getDefault().getBundle(), new Path(path1
), null);
73 File test
= new File(FileLocator
.toFileURL(location
).toURI());
74 final TmfTraceStub trace1
= new TmfTraceStub(test
.getPath(), 0, true);
75 trace1
.setInitialRangeOffset(new TmfTimestamp(5, ITmfTimestamp
.MILLISECOND_SCALE
));
78 location
= FileLocator
.find(TmfCoreTestPlugin
.getDefault().getBundle(), new Path(path2
), null);
79 test
= new File(FileLocator
.toFileURL(location
).toURI());
80 final TmfTraceStub trace2
= new TmfTraceStub(test
.getPath(), 0, true);
81 trace2
.setInitialRangeOffset(new TmfTimestamp(2, ITmfTimestamp
.MILLISECOND_SCALE
));
83 } catch (final TmfTraceException e
) {
85 } catch (final URISyntaxException e
) {
87 } catch (final IOException e
) {
95 * @param name the test name
97 public TmfMultiTraceExperimentTest(final String name
) {
102 protected synchronized void setUp() throws Exception
{
104 setupTrace(DIRECTORY
+ File
.separator
+ TEST_STREAM1
, DIRECTORY
+ File
.separator
+ TEST_STREAM2
);
105 if (fExperiment
== null) {
106 fExperiment
= new TmfExperimentStub(EXPERIMENT
, fTraces
, BLOCK_SIZE
);
107 fExperiment
.getIndexer().buildIndex(0, TmfTimeRange
.ETERNITY
, true);
112 protected void tearDown() throws Exception
{
116 // ------------------------------------------------------------------------
118 // ------------------------------------------------------------------------
120 public void testBasicTmfExperimentConstructor() {
122 assertEquals("GetId", EXPERIMENT
, fExperiment
.getName());
123 assertEquals("GetNbEvents", NB_EVENTS
, fExperiment
.getNbEvents());
125 final TmfTimeRange timeRange
= fExperiment
.getTimeRange();
126 assertEquals("getStartTime", 1, timeRange
.getStartTime().getValue());
127 assertEquals("getEndTime", NB_EVENTS
, timeRange
.getEndTime().getValue());
129 TmfTimestamp initRange
= new TmfTimestamp(2, ITmfTimestamp
.MILLISECOND_SCALE
);
130 assertEquals("getInitialRangeOffset", initRange
, fExperiment
.getInitialRangeOffset());
131 assertEquals("getCurrentTime", fExperiment
.getTimeRange().getStartTime(), fExperiment
.getCurrentTime());
133 ITmfTimestamp startTimestamp
= fExperiment
.getTimeRange().getStartTime();
134 long endValue
= startTimestamp
.getValue() + initRange
.normalize(0, startTimestamp
.getScale()).getValue();
135 ITmfTimestamp endTimestamp
= new TmfTimestamp(endValue
, startTimestamp
.getScale());
136 TmfTimeRange expectedRange
= new TmfTimeRange(startTimestamp
, endTimestamp
);
137 assertEquals("getCurrentRange", expectedRange
, fExperiment
.getCurrentRange());
140 // ------------------------------------------------------------------------
142 // ------------------------------------------------------------------------
144 public void testSeekRankOnCacheBoundary() {
146 long cacheSize
= fExperiment
.getCacheSize();
148 // On lower bound, returns the first event (TS = 1)
149 ITmfContext context
= fExperiment
.seekEvent(0);
150 assertEquals("Context rank", 0, context
.getRank());
152 ITmfEvent event
= fExperiment
.getNext(context
);
153 assertEquals("Event timestamp", 1, event
.getTimestamp().getValue());
154 assertEquals("Context rank", 1, context
.getRank());
156 // Position trace at event rank [cacheSize]
157 context
= fExperiment
.seekEvent(cacheSize
);
158 assertEquals("Context rank", cacheSize
, context
.getRank());
160 event
= fExperiment
.getNext(context
);
161 assertEquals("Event timestamp", cacheSize
+ 1, event
.getTimestamp().getValue());
162 assertEquals("Context rank", cacheSize
+ 1, context
.getRank());
164 // Position trace at event rank [4 * cacheSize]
165 context
= fExperiment
.seekEvent(4 * cacheSize
);
166 assertEquals("Context rank", 4 * cacheSize
, context
.getRank());
168 event
= fExperiment
.getNext(context
);
169 assertEquals("Event timestamp", 4 * cacheSize
+ 1, event
.getTimestamp().getValue());
170 assertEquals("Context rank", 4 * cacheSize
+ 1, context
.getRank());
173 public void testSeekRankNotOnCacheBoundary() {
175 long cacheSize
= fExperiment
.getCacheSize();
177 // Position trace at event rank 9
178 ITmfContext context
= fExperiment
.seekEvent(9);
179 assertEquals("Context rank", 9, context
.getRank());
181 ITmfEvent event
= fExperiment
.getNext(context
);
182 assertEquals("Event timestamp", 10, event
.getTimestamp().getValue());
183 assertEquals("Context rank", 10, 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
, event
.getTimestamp().getValue());
191 assertEquals("Context rank", cacheSize
, context
.getRank());
193 // Position trace at event rank [cacheSize + 1]
194 context
= fExperiment
.seekEvent(cacheSize
+ 1);
195 assertEquals("Context rank", cacheSize
+ 1, context
.getRank());
197 event
= fExperiment
.getNext(context
);
198 assertEquals("Event timestamp", cacheSize
+ 2, event
.getTimestamp().getValue());
199 assertEquals("Context rank", cacheSize
+ 2, context
.getRank());
201 // Position trace at event rank 4500
202 context
= fExperiment
.seekEvent(4500);
203 assertEquals("Context rank", 4500, context
.getRank());
205 event
= fExperiment
.getNext(context
);
206 assertEquals("Event timestamp", 4501, event
.getTimestamp().getValue());
207 assertEquals("Context rank", 4501, context
.getRank());
210 public void testSeekRankOutOfScope() {
212 // Position trace at beginning
213 ITmfContext context
= fExperiment
.seekEvent(-1);
214 assertEquals("Event rank", 0, context
.getRank());
216 ITmfEvent event
= fExperiment
.getNext(context
);
217 assertEquals("Event timestamp", 1, event
.getTimestamp().getValue());
218 assertEquals("Context rank", 1, context
.getRank());
220 // Position trace at event passed the end
221 context
= fExperiment
.seekEvent(NB_EVENTS
);
222 assertEquals("Context rank", NB_EVENTS
, context
.getRank());
224 event
= fExperiment
.getNext(context
);
225 assertNull("Event", event
);
226 assertEquals("Context rank", NB_EVENTS
, context
.getRank());
229 // ------------------------------------------------------------------------
230 // seekEvent on timestamp
231 // ------------------------------------------------------------------------
233 public void testSeekTimestampOnCacheBoundary() {
235 long cacheSize
= fExperiment
.getCacheSize();
237 // Position trace at event rank 0
238 ITmfContext context
= fExperiment
.seekEvent(new TmfTimestamp(1, SCALE
, 0));
239 assertEquals("Context rank", 0, context
.getRank());
241 ITmfEvent event
= fExperiment
.getNext(context
);
242 assertEquals("Event timestamp", 1, event
.getTimestamp().getValue());
243 assertEquals("Context rank", 1, context
.getRank());
245 // Position trace at event rank [cacheSize]
246 context
= fExperiment
.seekEvent(new TmfTimestamp(cacheSize
+ 1, SCALE
, 0));
247 assertEquals("Event rank", cacheSize
, context
.getRank());
249 event
= fExperiment
.getNext(context
);
250 assertEquals("Event timestamp", cacheSize
+ 1, event
.getTimestamp().getValue());
251 assertEquals("Context rank", cacheSize
+ 1, context
.getRank());
253 // Position trace at event rank [4 * cacheSize]
254 context
= fExperiment
.seekEvent(new TmfTimestamp(4 * cacheSize
+ 1, SCALE
, 0));
255 assertEquals("Context rank", 4 * cacheSize
, context
.getRank());
257 event
= fExperiment
.getNext(context
);
258 assertEquals("Event timestamp", 4 * cacheSize
+ 1, event
.getTimestamp().getValue());
259 assertEquals("Context rank", 4 * cacheSize
+ 1, context
.getRank());
262 public void testSeekTimestampNotOnCacheBoundary() {
264 // Position trace at event rank 1 (TS = 2)
265 ITmfContext context
= fExperiment
.seekEvent(new TmfTimestamp(2, SCALE
, 0));
266 assertEquals("Context rank", 1, context
.getRank());
268 ITmfEvent event
= fExperiment
.getNext(context
);
269 assertEquals("Event timestamp", 2, event
.getTimestamp().getValue());
270 assertEquals("Context rank", 2, context
.getRank());
272 // Position trace at event rank 9 (TS = 10)
273 context
= fExperiment
.seekEvent(new TmfTimestamp(10, SCALE
, 0));
274 assertEquals("Context rank", 9, context
.getRank());
276 event
= fExperiment
.getNext(context
);
277 assertEquals("Event timestamp", 10, event
.getTimestamp().getValue());
278 assertEquals("Context rank", 10, context
.getRank());
280 // Position trace at event rank 999 (TS = 1000)
281 context
= fExperiment
.seekEvent(new TmfTimestamp(1000, SCALE
, 0));
282 assertEquals("Context rank", 999, context
.getRank());
284 event
= fExperiment
.getNext(context
);
285 assertEquals("Event timestamp", 1000, event
.getTimestamp().getValue());
286 assertEquals("Context rank", 1000, context
.getRank());
288 // Position trace at event rank 1001 (TS = 1002)
289 context
= fExperiment
.seekEvent(new TmfTimestamp(1002, SCALE
, 0));
290 assertEquals("Context rank", 1001, context
.getRank());
292 event
= fExperiment
.getNext(context
);
293 assertEquals("Event timestamp", 1002, event
.getTimestamp().getValue());
294 assertEquals("Context rank", 1002, context
.getRank());
296 // Position trace at event rank 4500 (TS = 4501)
297 context
= fExperiment
.seekEvent(new TmfTimestamp(4501, SCALE
, 0));
298 assertEquals("Context rank", 4500, context
.getRank());
300 event
= fExperiment
.getNext(context
);
301 assertEquals("Event timestamp", 4501, event
.getTimestamp().getValue());
302 assertEquals("Context rank", 4501, context
.getRank());
305 public void testSeekTimestampOutOfScope() {
307 // Position trace at beginning
308 ITmfContext context
= fExperiment
.seekEvent(new TmfTimestamp(-1, SCALE
, 0));
309 assertEquals("Event rank", 0, context
.getRank());
311 ITmfEvent event
= fExperiment
.getNext(context
);
312 assertEquals("Event timestamp", 1, event
.getTimestamp().getValue());
313 assertEquals("Event rank", 1, context
.getRank());
315 // Position trace at event passed the end
316 context
= fExperiment
.seekEvent(new TmfTimestamp(NB_EVENTS
+ 1, SCALE
, 0));
317 event
= fExperiment
.getNext(context
);
318 assertNull("Event location", event
);
319 assertEquals("Event rank", ITmfContext
.UNKNOWN_RANK
, context
.getRank());
322 // ------------------------------------------------------------------------
323 // seekEvent by location (context rank is undefined)
324 // ------------------------------------------------------------------------
326 public void testSeekLocationOnCacheBoundary() {
328 long cacheSize
= fExperiment
.getCacheSize();
330 // Position trace at event rank 0
331 ITmfContext tmpContext
= fExperiment
.seekEvent(0);
332 ITmfContext context
= fExperiment
.seekEvent(tmpContext
.getLocation());
334 ITmfEvent event
= fExperiment
.getNext(context
);
335 assertEquals("Event timestamp", 1, event
.getTimestamp().getValue());
337 event
= fExperiment
.getNext(context
);
338 assertEquals("Event timestamp", 2, event
.getTimestamp().getValue());
340 // Position trace at event rank 'cacheSize'
341 tmpContext
= fExperiment
.seekEvent(cacheSize
);
342 context
= fExperiment
.seekEvent(tmpContext
.getLocation());
344 event
= fExperiment
.getNext(context
);
345 assertEquals("Event timestamp", cacheSize
+ 1, event
.getTimestamp().getValue());
347 event
= fExperiment
.getNext(context
);
348 assertEquals("Event timestamp", cacheSize
+ 2, event
.getTimestamp().getValue());
350 // Position trace at event rank 4 * 'cacheSize'
351 tmpContext
= fExperiment
.seekEvent(4 * cacheSize
);
352 context
= fExperiment
.seekEvent(tmpContext
.getLocation());
354 event
= fExperiment
.getNext(context
);
355 assertEquals("Event timestamp", 4 * cacheSize
+ 1, event
.getTimestamp().getValue());
357 event
= fExperiment
.getNext(context
);
358 assertEquals("Event timestamp", 4 * cacheSize
+ 2, event
.getTimestamp().getValue());
361 public void testSeekLocationNotOnCacheBoundary() {
363 long cacheSize
= fExperiment
.getCacheSize();
365 // Position trace at event 'cacheSize' - 1
366 ITmfContext tmpContext
= fExperiment
.seekEvent(cacheSize
- 1);
367 ITmfContext context
= fExperiment
.seekEvent(tmpContext
.getLocation());
369 ITmfEvent event
= fExperiment
.getNext(context
);
370 assertEquals("Event timestamp", cacheSize
, event
.getTimestamp().getValue());
372 event
= fExperiment
.getNext(context
);
373 assertEquals("Event timestamp", cacheSize
+ 1, event
.getTimestamp().getValue());
375 // Position trace at event rank 2 * 'cacheSize' - 1
376 tmpContext
= fExperiment
.seekEvent(2 * cacheSize
- 1);
377 context
= fExperiment
.seekEvent(tmpContext
.getLocation());
378 context
= fExperiment
.seekEvent(2 * cacheSize
- 1);
380 event
= fExperiment
.getNext(context
);
381 assertEquals("Event timestamp", 2 * cacheSize
, event
.getTimestamp().getValue());
383 event
= fExperiment
.getNext(context
);
384 assertEquals("Event timestamp", 2 * cacheSize
+ 1, event
.getTimestamp().getValue());
386 // Position trace at event rank 4500
387 tmpContext
= fExperiment
.seekEvent(4500);
388 context
= fExperiment
.seekEvent(tmpContext
.getLocation());
390 event
= fExperiment
.getNext(context
);
391 assertEquals("Event timestamp", 4501, event
.getTimestamp().getValue());
393 event
= fExperiment
.getNext(context
);
394 assertEquals("Event timestamp", 4502, event
.getTimestamp().getValue());
397 public void testSeekLocationOutOfScope() {
399 // Position trace at beginning
400 ITmfContext context
= fExperiment
.seekEvent((ITmfLocation
) null);
402 ITmfEvent event
= fExperiment
.getNext(context
);
403 assertEquals("Event timestamp", 1, event
.getTimestamp().getValue());
406 // ------------------------------------------------------------------------
407 // getNext - updates the context
408 // ------------------------------------------------------------------------
410 private static void validateContextRanks(ITmfContext context
) {
411 assertTrue("Experiment context type", context
instanceof TmfExperimentContext
);
412 TmfExperimentContext ctx
= (TmfExperimentContext
) context
;
414 int nbTraces
= ctx
.getContexts().length
;
416 // expRank = sum(trace ranks) - nbTraces + 1 (if lastTraceRead != NO_TRACE)
417 long expRank
= -nbTraces
+ ((ctx
.getLastTrace() != TmfExperimentContext
.NO_TRACE
) ?
1 : 0);
418 for (int i
= 0; i
< nbTraces
; i
++) {
419 long rank
= ctx
.getContexts()[i
].getRank();
426 assertEquals("Experiment context rank", expRank
, ctx
.getRank());
429 public void testGetNextAfteSeekingOnTS_1() {
431 final long INITIAL_TS
= 1;
432 final int NB_READS
= 20;
434 // On lower bound, returns the first event (ts = 1)
435 final ITmfContext context
= fExperiment
.seekEvent(new TmfTimestamp(INITIAL_TS
, SCALE
, 0));
437 validateContextRanks(context
);
441 for (int i
= 0; i
< NB_READS
; i
++) {
442 event
= fExperiment
.getNext(context
);
443 assertEquals("Event timestamp", INITIAL_TS
+ i
, event
.getTimestamp().getValue());
444 assertEquals("Event rank", INITIAL_TS
+ i
, context
.getRank());
447 // Make sure we stay positioned
448 event
= fExperiment
.parseEvent(context
);
449 assertEquals("Event timestamp", INITIAL_TS
+ NB_READS
, event
.getTimestamp().getValue());
450 assertEquals("Event rank", INITIAL_TS
+ NB_READS
- 1, context
.getRank());
452 validateContextRanks(context
);
455 public void testGetNextAfteSeekingOnTS_2() {
457 final long INITIAL_TS
= 2;
458 final int NB_READS
= 20;
460 // On lower bound, returns the first event (ts = 2)
461 final ITmfContext context
= fExperiment
.seekEvent(new TmfTimestamp(INITIAL_TS
, SCALE
, 0));
463 validateContextRanks(context
);
467 for (int i
= 0; i
< NB_READS
; i
++) {
468 event
= fExperiment
.getNext(context
);
469 assertEquals("Event timestamp", INITIAL_TS
+ i
, event
.getTimestamp().getValue());
470 assertEquals("Event rank", INITIAL_TS
+ i
, context
.getRank());
473 // Make sure we stay positioned
474 event
= fExperiment
.parseEvent(context
);
475 assertEquals("Event timestamp", INITIAL_TS
+ NB_READS
, event
.getTimestamp().getValue());
476 assertEquals("Event rank", INITIAL_TS
+ NB_READS
- 1, context
.getRank());
478 validateContextRanks(context
);
481 public void testGetNextAfteSeekingOnTS_3() {
483 final long INITIAL_TS
= 500;
484 final int NB_READS
= 20;
486 // On lower bound, returns the first event (ts = 500)
487 final ITmfContext context
= fExperiment
.seekEvent(new TmfTimestamp(INITIAL_TS
, SCALE
, 0));
489 validateContextRanks(context
);
493 for (int i
= 0; i
< NB_READS
; i
++) {
494 event
= fExperiment
.getNext(context
);
495 assertEquals("Event timestamp", INITIAL_TS
+ i
, event
.getTimestamp().getValue());
496 assertEquals("Event rank", INITIAL_TS
+ i
, context
.getRank());
499 // Make sure we stay positioned
500 event
= fExperiment
.parseEvent(context
);
501 assertEquals("Event timestamp", INITIAL_TS
+ NB_READS
, event
.getTimestamp().getValue());
502 assertEquals("Event rank", INITIAL_TS
+ NB_READS
- 1, context
.getRank());
504 validateContextRanks(context
);
507 public void testGetNextAfterSeekingOnRank_1() {
509 final long INITIAL_RANK
= 0L;
510 final int NB_READS
= 20;
512 // On lower bound, returns the first event (rank = 0)
513 final ITmfContext context
= fExperiment
.seekEvent(INITIAL_RANK
);
515 validateContextRanks(context
);
519 for (int i
= 0; i
< NB_READS
; i
++) {
520 event
= fExperiment
.getNext(context
);
521 assertEquals("Event timestamp", INITIAL_RANK
+ i
+ 1, event
.getTimestamp().getValue());
522 assertEquals("Event rank", INITIAL_RANK
+ i
+ 1, context
.getRank());
525 // Make sure we stay positioned
526 event
= fExperiment
.parseEvent(context
);
527 assertEquals("Event timestamp", INITIAL_RANK
+ NB_READS
+ 1, event
.getTimestamp().getValue());
528 assertEquals("Event rank", INITIAL_RANK
+ NB_READS
, context
.getRank());
530 validateContextRanks(context
);
533 public void testGetNextAfterSeekingOnRank_2() {
535 final long INITIAL_RANK
= 1L;
536 final int NB_READS
= 20;
538 // On lower bound, returns the first event (rank = 0)
539 final ITmfContext context
= fExperiment
.seekEvent(INITIAL_RANK
);
541 validateContextRanks(context
);
545 for (int i
= 0; i
< NB_READS
; i
++) {
546 event
= fExperiment
.getNext(context
);
547 assertEquals("Event timestamp", INITIAL_RANK
+ i
+ 1, event
.getTimestamp().getValue());
548 assertEquals("Event rank", INITIAL_RANK
+ i
+ 1, context
.getRank());
551 // Make sure we stay positioned
552 event
= fExperiment
.parseEvent(context
);
553 assertEquals("Event timestamp", INITIAL_RANK
+ NB_READS
+ 1, event
.getTimestamp().getValue());
554 assertEquals("Event rank", INITIAL_RANK
+ NB_READS
, context
.getRank());
556 validateContextRanks(context
);
559 public void testGetNextAfterSeekingOnRank_3() {
561 final long INITIAL_RANK
= 500L;
562 final int NB_READS
= 20;
564 // On lower bound, returns the first event (rank = 0)
565 final ITmfContext context
= fExperiment
.seekEvent(INITIAL_RANK
);
567 validateContextRanks(context
);
571 for (int i
= 0; i
< NB_READS
; i
++) {
572 event
= fExperiment
.getNext(context
);
573 assertEquals("Event timestamp", INITIAL_RANK
+ i
+ 1, event
.getTimestamp().getValue());
574 assertEquals("Event rank", INITIAL_RANK
+ i
+ 1, context
.getRank());
577 // Make sure we stay positioned
578 event
= fExperiment
.parseEvent(context
);
579 assertEquals("Event timestamp", INITIAL_RANK
+ NB_READS
+ 1, event
.getTimestamp().getValue());
580 assertEquals("Event rank", INITIAL_RANK
+ NB_READS
, context
.getRank());
582 validateContextRanks(context
);
585 public void testGetNextAfterSeekingOnLocation_1() {
587 final ITmfLocation INITIAL_LOC
= null;
588 final long INITIAL_TS
= 1;
589 final int NB_READS
= 20;
591 // On lower bound, returns the first event (ts = 1)
592 final ITmfContext context
= fExperiment
.seekEvent(INITIAL_LOC
);
594 validateContextRanks(context
);
598 for (int i
= 0; i
< NB_READS
; i
++) {
599 event
= fExperiment
.getNext(context
);
600 assertEquals("Event timestamp", INITIAL_TS
+ i
, event
.getTimestamp().getValue());
601 assertEquals("Event rank", INITIAL_TS
+ i
, context
.getRank());
604 // Make sure we stay positioned
605 event
= fExperiment
.parseEvent(context
);
606 assertEquals("Event timestamp", INITIAL_TS
+ NB_READS
, event
.getTimestamp().getValue());
607 assertEquals("Event rank", INITIAL_TS
+ NB_READS
- 1, context
.getRank());
609 validateContextRanks(context
);
612 public void testGetNextAfterSeekingOnLocation_2() {
614 final ITmfLocation INITIAL_LOC
= fExperiment
.seekEvent(1L).getLocation();
615 final long INITIAL_TS
= 2;
616 final int NB_READS
= 20;
618 // On lower bound, returns the first event (ts = 2)
619 final ITmfContext context
= fExperiment
.seekEvent(INITIAL_LOC
);
621 validateContextRanks(context
);
625 for (int i
= 0; i
< NB_READS
; i
++) {
626 event
= fExperiment
.getNext(context
);
627 assertEquals("Event timestamp", INITIAL_TS
+ i
, event
.getTimestamp().getValue());
630 // Make sure we stay positioned
631 event
= fExperiment
.parseEvent(context
);
632 assertEquals("Event timestamp", INITIAL_TS
+ NB_READS
, event
.getTimestamp().getValue());
634 validateContextRanks(context
);
637 public void testGetNextAfterSeekingOnLocation_3() {
639 final ITmfLocation INITIAL_LOC
= fExperiment
.seekEvent(500L).getLocation();
640 final long INITIAL_TS
= 501;
641 final int NB_READS
= 20;
643 // On lower bound, returns the first event (ts = 501)
644 final ITmfContext context
= fExperiment
.seekEvent(INITIAL_LOC
);
646 validateContextRanks(context
);
650 for (int i
= 0; i
< NB_READS
; i
++) {
651 event
= fExperiment
.getNext(context
);
652 assertEquals("Event timestamp", INITIAL_TS
+ i
, event
.getTimestamp().getValue());
655 // Make sure we stay positioned
656 event
= fExperiment
.parseEvent(context
);
657 assertEquals("Event timestamp", INITIAL_TS
+ NB_READS
, event
.getTimestamp().getValue());
659 validateContextRanks(context
);
662 public void testGetNextLocation() {
663 ITmfContext context1
= fExperiment
.seekEvent(0);
664 fExperiment
.getNext(context1
);
665 ITmfLocation location
= context1
.getLocation();
666 ITmfEvent event1
= fExperiment
.getNext(context1
);
667 ITmfContext context2
= fExperiment
.seekEvent(location
);
668 ITmfEvent event2
= fExperiment
.getNext(context2
);
669 assertEquals("Event timestamp", event1
.getTimestamp().getValue(), event2
.getTimestamp().getValue());
672 public void testGetNextEndLocation() {
673 ITmfContext context1
= fExperiment
.seekEvent(fExperiment
.getNbEvents() - 1);
674 fExperiment
.getNext(context1
);
675 ITmfLocation location
= context1
.getLocation();
676 ITmfContext context2
= fExperiment
.seekEvent(location
);
677 ITmfEvent event
= fExperiment
.getNext(context2
);
678 assertNull("Event", event
);
681 // ------------------------------------------------------------------------
683 // ------------------------------------------------------------------------
685 public void testProcessRequestForNbEvents() throws InterruptedException
{
687 final int blockSize
= 100;
688 final int nbEvents
= 1000;
689 final Vector
<ITmfEvent
> requestedEvents
= new Vector
<ITmfEvent
>();
691 final TmfTimeRange range
= new TmfTimeRange(TmfTimestamp
.BIG_BANG
, TmfTimestamp
.BIG_CRUNCH
);
692 final TmfEventRequest request
= new TmfEventRequest(TmfEvent
.class, range
, nbEvents
, blockSize
) {
694 public void handleData(final ITmfEvent event
) {
695 super.handleData(event
);
696 requestedEvents
.add(event
);
699 fExperiment
.sendRequest(request
);
700 request
.waitForCompletion();
702 assertEquals("nbEvents", nbEvents
, requestedEvents
.size());
703 assertTrue("isCompleted", request
.isCompleted());
704 assertFalse("isCancelled", request
.isCancelled());
706 // Ensure that we have distinct events.
707 // Don't go overboard: we are not validating the stub!
708 for (int i
= 0; i
< nbEvents
; i
++) {
709 assertEquals("Distinct events", i
+1, requestedEvents
.get(i
).getTimestamp().getValue());
713 public void testProcessRequestForNbEvents2() throws InterruptedException
{
715 final int blockSize
= 2 * NB_EVENTS
;
716 final int nbEvents
= 1000;
717 final Vector
<ITmfEvent
> requestedEvents
= new Vector
<ITmfEvent
>();
719 final TmfTimeRange range
= new TmfTimeRange(TmfTimestamp
.BIG_BANG
, TmfTimestamp
.BIG_CRUNCH
);
720 final TmfEventRequest request
= new TmfEventRequest(TmfEvent
.class, range
, nbEvents
, blockSize
) {
722 public void handleData(final ITmfEvent event
) {
723 super.handleData(event
);
724 requestedEvents
.add(event
);
727 fExperiment
.sendRequest(request
);
728 request
.waitForCompletion();
730 assertEquals("nbEvents", nbEvents
, requestedEvents
.size());
731 assertTrue("isCompleted", request
.isCompleted());
732 assertFalse("isCancelled", request
.isCancelled());
734 // Ensure that we have distinct events.
735 // Don't go overboard: we are not validating the stub!
736 for (int i
= 0; i
< nbEvents
; i
++) {
737 assertEquals("Distinct events", i
+1, requestedEvents
.get(i
).getTimestamp().getValue());
741 public void testProcessRequestForAllEvents() throws InterruptedException
{
743 final int nbEvents
= TmfDataRequest
.ALL_DATA
;
744 final int blockSize
= 1;
745 final Vector
<ITmfEvent
> requestedEvents
= new Vector
<ITmfEvent
>();
746 final long nbExpectedEvents
= NB_EVENTS
;
748 final TmfTimeRange range
= new TmfTimeRange(TmfTimestamp
.BIG_BANG
, TmfTimestamp
.BIG_CRUNCH
);
749 final TmfEventRequest request
= new TmfEventRequest(TmfEvent
.class, range
, nbEvents
, blockSize
) {
751 public void handleData(final ITmfEvent event
) {
752 super.handleData(event
);
753 requestedEvents
.add(event
);
756 fExperiment
.sendRequest(request
);
757 request
.waitForCompletion();
759 assertEquals("nbEvents", nbExpectedEvents
, requestedEvents
.size());
760 assertTrue("isCompleted", request
.isCompleted());
761 assertFalse("isCancelled", request
.isCancelled());
763 // Ensure that we have distinct events.
764 // Don't go overboard: we are not validating the stub!
765 for (int i
= 0; i
< nbExpectedEvents
; i
++) {
766 assertEquals("Distinct events", i
+1, requestedEvents
.get(i
).getTimestamp().getValue());
770 // ------------------------------------------------------------------------
772 // ------------------------------------------------------------------------
774 public void testCancel() throws InterruptedException
{
776 final int nbEvents
= NB_EVENTS
;
777 final int blockSize
= BLOCK_SIZE
;
778 final Vector
<ITmfEvent
> requestedEvents
= new Vector
<ITmfEvent
>();
780 final TmfTimeRange range
= new TmfTimeRange(TmfTimestamp
.BIG_BANG
, TmfTimestamp
.BIG_CRUNCH
);
781 final TmfEventRequest request
= new TmfEventRequest(TmfEvent
.class, range
, nbEvents
, blockSize
) {
784 public void handleData(final ITmfEvent event
) {
785 super.handleData(event
);
786 requestedEvents
.add(event
);
787 if (++nbRead
== blockSize
) {
792 public void handleCancel() {
793 if (requestedEvents
.size() < blockSize
) {
794 System
.out
.println("aie");
798 fExperiment
.sendRequest(request
);
799 request
.waitForCompletion();
801 assertEquals("nbEvents", blockSize
, requestedEvents
.size());
802 assertTrue("isCompleted", request
.isCompleted());
803 assertTrue("isCancelled", request
.isCancelled());
806 // ------------------------------------------------------------------------
808 // ------------------------------------------------------------------------
810 public void testGetTimestamp() {
811 assertEquals("getTimestamp", new TmfTimestamp( 1, (byte) -3), fExperiment
.getTimestamp( 0));
812 assertEquals("getTimestamp", new TmfTimestamp( 2, (byte) -3), fExperiment
.getTimestamp( 1));
813 assertEquals("getTimestamp", new TmfTimestamp( 11, (byte) -3), fExperiment
.getTimestamp( 10));
814 assertEquals("getTimestamp", new TmfTimestamp( 101, (byte) -3), fExperiment
.getTimestamp( 100));
815 assertEquals("getTimestamp", new TmfTimestamp( 1001, (byte) -3), fExperiment
.getTimestamp( 1000));
816 assertEquals("getTimestamp", new TmfTimestamp( 2001, (byte) -3), fExperiment
.getTimestamp( 2000));
817 assertEquals("getTimestamp", new TmfTimestamp( 2501, (byte) -3), fExperiment
.getTimestamp( 2500));
818 assertEquals("getTimestamp", new TmfTimestamp(10000, (byte) -3), fExperiment
.getTimestamp( 9999));
819 assertEquals("getTimestamp", new TmfTimestamp(20000, (byte) -3), fExperiment
.getTimestamp(19999));
820 assertNull("getTimestamp", fExperiment
.getTimestamp(20000));
823 // ------------------------------------------------------------------------
824 // getInitialRangeOffset, getCurrentRange, getCurrentTime
825 // ------------------------------------------------------------------------
826 public void testDefaultCurrentTimeValues() {
827 // reset to default initial range offset
828 ((TmfTraceStub
)fTraces
[0]).setInitialRangeOffset(null);
829 ((TmfTraceStub
)fTraces
[1]).setInitialRangeOffset(null);
831 TmfExperimentStub exp
= new TmfExperimentStub(EXPERIMENT
, fTraces
, BLOCK_SIZE
);
833 // verify initial values
834 TmfTimestamp initRange
= new TmfTimestamp(DEFAULT_INITIAL_OFFSET_VALUE
, ITmfTimestamp
.NANOSECOND_SCALE
);
835 assertEquals("getInitialRangeOffset", initRange
, exp
.getInitialRangeOffset());
836 assertEquals("getCurrentTime", TmfTimestamp
.ZERO
, exp
.getCurrentTime());
837 assertEquals("getCurrentRange", TmfTimeRange
.NULL_RANGE
, exp
.getCurrentRange());