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
.TmfEvent
;
29 import org
.eclipse
.linuxtools
.tmf
.core
.event
.TmfTimeRange
;
30 import org
.eclipse
.linuxtools
.tmf
.core
.event
.TmfTimestamp
;
31 import org
.eclipse
.linuxtools
.tmf
.core
.exceptions
.TmfTraceException
;
32 import org
.eclipse
.linuxtools
.tmf
.core
.request
.TmfDataRequest
;
33 import org
.eclipse
.linuxtools
.tmf
.core
.request
.TmfEventRequest
;
34 import org
.eclipse
.linuxtools
.tmf
.core
.tests
.TmfCoreTestPlugin
;
35 import org
.eclipse
.linuxtools
.tmf
.core
.trace
.ITmfContext
;
36 import org
.eclipse
.linuxtools
.tmf
.core
.trace
.ITmfLocation
;
37 import org
.eclipse
.linuxtools
.tmf
.core
.trace
.ITmfTrace
;
38 import org
.eclipse
.linuxtools
.tmf
.tests
.stubs
.trace
.TmfExperimentStub
;
39 import org
.eclipse
.linuxtools
.tmf
.tests
.stubs
.trace
.TmfTraceStub
;
42 * Test suite for the TmfExperiment class (multiple traces).
44 @SuppressWarnings({"nls","javadoc"})
45 public class TmfMultiTraceExperimentTest
extends TestCase
{
47 // ------------------------------------------------------------------------
49 // ------------------------------------------------------------------------
51 private static final String DIRECTORY
= "testfiles";
52 private static final String TEST_STREAM1
= "O-Test-10K";
53 private static final String TEST_STREAM2
= "E-Test-10K";
54 private static final String EXPERIMENT
= "MyExperiment";
55 private static int NB_EVENTS
= 20000;
56 private static int BLOCK_SIZE
= 1000;
58 private static ITmfTrace
[] fTraces
;
59 private static TmfExperimentStub fExperiment
;
61 private static byte SCALE
= (byte) -3;
63 // ------------------------------------------------------------------------
65 // ------------------------------------------------------------------------
67 private synchronized static ITmfTrace
[] setupTrace(final String path1
, final String path2
) {
68 if (fTraces
== null) {
69 fTraces
= new ITmfTrace
[2];
71 URL location
= FileLocator
.find(TmfCoreTestPlugin
.getDefault().getBundle(), new Path(path1
), null);
72 File test
= new File(FileLocator
.toFileURL(location
).toURI());
73 final TmfTraceStub trace1
= new TmfTraceStub(test
.getPath(), 0, true);
75 location
= FileLocator
.find(TmfCoreTestPlugin
.getDefault().getBundle(), new Path(path2
), null);
76 test
= new File(FileLocator
.toFileURL(location
).toURI());
77 final TmfTraceStub trace2
= new TmfTraceStub(test
.getPath(), 0, true);
79 } catch (final TmfTraceException e
) {
81 } catch (final URISyntaxException e
) {
83 } catch (final IOException e
) {
91 * @param name the test name
93 public TmfMultiTraceExperimentTest(final String name
) {
98 protected synchronized void setUp() throws Exception
{
100 setupTrace(DIRECTORY
+ File
.separator
+ TEST_STREAM1
, DIRECTORY
+ File
.separator
+ TEST_STREAM2
);
101 if (fExperiment
== null) {
102 fExperiment
= new TmfExperimentStub(EXPERIMENT
, fTraces
, BLOCK_SIZE
);
103 fExperiment
.getIndexer().buildIndex(0, TmfTimeRange
.ETERNITY
, true);
108 protected void tearDown() throws Exception
{
112 // ------------------------------------------------------------------------
114 // ------------------------------------------------------------------------
116 public void testBasicTmfExperimentConstructor() {
118 assertEquals("GetId", EXPERIMENT
, fExperiment
.getName());
119 assertEquals("GetNbEvents", NB_EVENTS
, fExperiment
.getNbEvents());
121 final TmfTimeRange timeRange
= fExperiment
.getTimeRange();
122 assertEquals("getStartTime", 1, timeRange
.getStartTime().getValue());
123 assertEquals("getEndTime", NB_EVENTS
, timeRange
.getEndTime().getValue());
126 // ------------------------------------------------------------------------
128 // ------------------------------------------------------------------------
130 public void testSeekRankOnCacheBoundary() {
132 long cacheSize
= fExperiment
.getCacheSize();
134 // On lower bound, returns the first event (TS = 1)
135 ITmfContext context
= fExperiment
.seekEvent(0);
136 assertEquals("Context rank", 0, context
.getRank());
138 ITmfEvent event
= fExperiment
.getNext(context
);
139 assertEquals("Event timestamp", 1, event
.getTimestamp().getValue());
140 assertEquals("Context rank", 1, context
.getRank());
142 // Position trace at event rank [cacheSize]
143 context
= fExperiment
.seekEvent(cacheSize
);
144 assertEquals("Context rank", cacheSize
, context
.getRank());
146 event
= fExperiment
.getNext(context
);
147 assertEquals("Event timestamp", cacheSize
+ 1, event
.getTimestamp().getValue());
148 assertEquals("Context rank", cacheSize
+ 1, context
.getRank());
150 // Position trace at event rank [4 * cacheSize]
151 context
= fExperiment
.seekEvent(4 * cacheSize
);
152 assertEquals("Context rank", 4 * cacheSize
, context
.getRank());
154 event
= fExperiment
.getNext(context
);
155 assertEquals("Event timestamp", 4 * cacheSize
+ 1, event
.getTimestamp().getValue());
156 assertEquals("Context rank", 4 * cacheSize
+ 1, context
.getRank());
159 public void testSeekRankNotOnCacheBoundary() {
161 long cacheSize
= fExperiment
.getCacheSize();
163 // Position trace at event rank 9
164 ITmfContext context
= fExperiment
.seekEvent(9);
165 assertEquals("Context rank", 9, context
.getRank());
167 ITmfEvent event
= fExperiment
.getNext(context
);
168 assertEquals("Event timestamp", 10, event
.getTimestamp().getValue());
169 assertEquals("Context rank", 10, context
.getRank());
171 // Position trace at event rank [cacheSize - 1]
172 context
= fExperiment
.seekEvent(cacheSize
- 1);
173 assertEquals("Context rank", cacheSize
- 1, context
.getRank());
175 event
= fExperiment
.getNext(context
);
176 assertEquals("Event timestamp", cacheSize
, event
.getTimestamp().getValue());
177 assertEquals("Context rank", cacheSize
, context
.getRank());
179 // Position trace at event rank [cacheSize + 1]
180 context
= fExperiment
.seekEvent(cacheSize
+ 1);
181 assertEquals("Context rank", cacheSize
+ 1, context
.getRank());
183 event
= fExperiment
.getNext(context
);
184 assertEquals("Event timestamp", cacheSize
+ 2, event
.getTimestamp().getValue());
185 assertEquals("Context rank", cacheSize
+ 2, context
.getRank());
187 // Position trace at event rank 4500
188 context
= fExperiment
.seekEvent(4500);
189 assertEquals("Context rank", 4500, context
.getRank());
191 event
= fExperiment
.getNext(context
);
192 assertEquals("Event timestamp", 4501, event
.getTimestamp().getValue());
193 assertEquals("Context rank", 4501, context
.getRank());
196 public void testSeekRankOutOfScope() {
198 // Position trace at beginning
199 ITmfContext context
= fExperiment
.seekEvent(-1);
200 assertEquals("Event rank", 0, context
.getRank());
202 ITmfEvent event
= fExperiment
.getNext(context
);
203 assertEquals("Event timestamp", 1, event
.getTimestamp().getValue());
204 assertEquals("Context rank", 1, context
.getRank());
206 // Position trace at event passed the end
207 context
= fExperiment
.seekEvent(NB_EVENTS
);
208 assertEquals("Context rank", NB_EVENTS
, context
.getRank());
210 event
= fExperiment
.getNext(context
);
211 assertNull("Event", event
);
212 assertEquals("Context rank", NB_EVENTS
, context
.getRank());
215 // ------------------------------------------------------------------------
216 // seekEvent on timestamp
217 // ------------------------------------------------------------------------
219 public void testSeekTimestampOnCacheBoundary() {
221 long cacheSize
= fExperiment
.getCacheSize();
223 // Position trace at event rank 0
224 ITmfContext context
= fExperiment
.seekEvent(new TmfTimestamp(1, SCALE
, 0));
225 assertEquals("Context rank", 0, context
.getRank());
227 ITmfEvent event
= fExperiment
.getNext(context
);
228 assertEquals("Event timestamp", 1, event
.getTimestamp().getValue());
229 assertEquals("Context rank", 1, context
.getRank());
231 // Position trace at event rank [cacheSize]
232 context
= fExperiment
.seekEvent(new TmfTimestamp(cacheSize
+ 1, SCALE
, 0));
233 assertEquals("Event rank", cacheSize
, context
.getRank());
235 event
= fExperiment
.getNext(context
);
236 assertEquals("Event timestamp", cacheSize
+ 1, event
.getTimestamp().getValue());
237 assertEquals("Context rank", cacheSize
+ 1, context
.getRank());
239 // Position trace at event rank [4 * cacheSize]
240 context
= fExperiment
.seekEvent(new TmfTimestamp(4 * cacheSize
+ 1, SCALE
, 0));
241 assertEquals("Context rank", 4 * cacheSize
, context
.getRank());
243 event
= fExperiment
.getNext(context
);
244 assertEquals("Event timestamp", 4 * cacheSize
+ 1, event
.getTimestamp().getValue());
245 assertEquals("Context rank", 4 * cacheSize
+ 1, context
.getRank());
248 public void testSeekTimestampNotOnCacheBoundary() {
250 // Position trace at event rank 1 (TS = 2)
251 ITmfContext context
= fExperiment
.seekEvent(new TmfTimestamp(2, SCALE
, 0));
252 assertEquals("Context rank", 1, context
.getRank());
254 ITmfEvent event
= fExperiment
.getNext(context
);
255 assertEquals("Event timestamp", 2, event
.getTimestamp().getValue());
256 assertEquals("Context rank", 2, context
.getRank());
258 // Position trace at event rank 9 (TS = 10)
259 context
= fExperiment
.seekEvent(new TmfTimestamp(10, SCALE
, 0));
260 assertEquals("Context rank", 9, context
.getRank());
262 event
= fExperiment
.getNext(context
);
263 assertEquals("Event timestamp", 10, event
.getTimestamp().getValue());
264 assertEquals("Context rank", 10, context
.getRank());
266 // Position trace at event rank 999 (TS = 1000)
267 context
= fExperiment
.seekEvent(new TmfTimestamp(1000, SCALE
, 0));
268 assertEquals("Context rank", 999, context
.getRank());
270 event
= fExperiment
.getNext(context
);
271 assertEquals("Event timestamp", 1000, event
.getTimestamp().getValue());
272 assertEquals("Context rank", 1000, context
.getRank());
274 // Position trace at event rank 1001 (TS = 1002)
275 context
= fExperiment
.seekEvent(new TmfTimestamp(1002, SCALE
, 0));
276 assertEquals("Context rank", 1001, context
.getRank());
278 event
= fExperiment
.getNext(context
);
279 assertEquals("Event timestamp", 1002, event
.getTimestamp().getValue());
280 assertEquals("Context rank", 1002, context
.getRank());
282 // Position trace at event rank 4500 (TS = 4501)
283 context
= fExperiment
.seekEvent(new TmfTimestamp(4501, SCALE
, 0));
284 assertEquals("Context rank", 4500, context
.getRank());
286 event
= fExperiment
.getNext(context
);
287 assertEquals("Event timestamp", 4501, event
.getTimestamp().getValue());
288 assertEquals("Context rank", 4501, context
.getRank());
291 public void testSeekTimestampOutOfScope() {
293 // Position trace at beginning
294 ITmfContext context
= fExperiment
.seekEvent(new TmfTimestamp(-1, SCALE
, 0));
295 assertEquals("Event rank", 0, context
.getRank());
297 ITmfEvent event
= fExperiment
.getNext(context
);
298 assertEquals("Event timestamp", 1, event
.getTimestamp().getValue());
299 assertEquals("Event rank", 1, context
.getRank());
301 // Position trace at event passed the end
302 context
= fExperiment
.seekEvent(new TmfTimestamp(NB_EVENTS
+ 1, SCALE
, 0));
303 event
= fExperiment
.getNext(context
);
304 assertNull("Event location", event
);
305 assertEquals("Event rank", ITmfContext
.UNKNOWN_RANK
, context
.getRank());
308 // ------------------------------------------------------------------------
309 // seekEvent by location (context rank is undefined)
310 // ------------------------------------------------------------------------
312 public void testSeekLocationOnCacheBoundary() {
314 long cacheSize
= fExperiment
.getCacheSize();
316 // Position trace at event rank 0
317 ITmfContext tmpContext
= fExperiment
.seekEvent(0);
318 ITmfContext context
= fExperiment
.seekEvent(tmpContext
.getLocation());
320 ITmfEvent event
= fExperiment
.getNext(context
);
321 assertEquals("Event timestamp", 1, event
.getTimestamp().getValue());
323 event
= fExperiment
.getNext(context
);
324 assertEquals("Event timestamp", 2, event
.getTimestamp().getValue());
326 // Position trace at event rank 'cacheSize'
327 tmpContext
= fExperiment
.seekEvent(cacheSize
);
328 context
= fExperiment
.seekEvent(tmpContext
.getLocation());
330 event
= fExperiment
.getNext(context
);
331 assertEquals("Event timestamp", cacheSize
+ 1, event
.getTimestamp().getValue());
333 event
= fExperiment
.getNext(context
);
334 assertEquals("Event timestamp", cacheSize
+ 2, event
.getTimestamp().getValue());
336 // Position trace at event rank 4 * 'cacheSize'
337 tmpContext
= fExperiment
.seekEvent(4 * cacheSize
);
338 context
= fExperiment
.seekEvent(tmpContext
.getLocation());
340 event
= fExperiment
.getNext(context
);
341 assertEquals("Event timestamp", 4 * cacheSize
+ 1, event
.getTimestamp().getValue());
343 event
= fExperiment
.getNext(context
);
344 assertEquals("Event timestamp", 4 * cacheSize
+ 2, event
.getTimestamp().getValue());
347 public void testSeekLocationNotOnCacheBoundary() {
349 long cacheSize
= fExperiment
.getCacheSize();
351 // Position trace at event 'cacheSize' - 1
352 ITmfContext tmpContext
= fExperiment
.seekEvent(cacheSize
- 1);
353 ITmfContext context
= fExperiment
.seekEvent(tmpContext
.getLocation());
355 ITmfEvent event
= fExperiment
.getNext(context
);
356 assertEquals("Event timestamp", cacheSize
, event
.getTimestamp().getValue());
358 event
= fExperiment
.getNext(context
);
359 assertEquals("Event timestamp", cacheSize
+ 1, event
.getTimestamp().getValue());
361 // Position trace at event rank 2 * 'cacheSize' - 1
362 tmpContext
= fExperiment
.seekEvent(2 * cacheSize
- 1);
363 context
= fExperiment
.seekEvent(tmpContext
.getLocation());
364 context
= fExperiment
.seekEvent(2 * cacheSize
- 1);
366 event
= fExperiment
.getNext(context
);
367 assertEquals("Event timestamp", 2 * cacheSize
, event
.getTimestamp().getValue());
369 event
= fExperiment
.getNext(context
);
370 assertEquals("Event timestamp", 2 * cacheSize
+ 1, event
.getTimestamp().getValue());
372 // Position trace at event rank 4500
373 tmpContext
= fExperiment
.seekEvent(4500);
374 context
= fExperiment
.seekEvent(tmpContext
.getLocation());
376 event
= fExperiment
.getNext(context
);
377 assertEquals("Event timestamp", 4501, event
.getTimestamp().getValue());
379 event
= fExperiment
.getNext(context
);
380 assertEquals("Event timestamp", 4502, event
.getTimestamp().getValue());
383 public void testSeekLocationOutOfScope() {
385 // Position trace at beginning
386 ITmfContext context
= fExperiment
.seekEvent((ITmfLocation
<?
>) null);
388 ITmfEvent event
= fExperiment
.getNext(context
);
389 assertEquals("Event timestamp", 1, event
.getTimestamp().getValue());
392 // ------------------------------------------------------------------------
393 // getNext - updates the context
394 // ------------------------------------------------------------------------
396 private static void validateContextRanks(ITmfContext context
) {
397 assertTrue("Experiment context type", context
instanceof TmfExperimentContext
);
398 TmfExperimentContext ctx
= (TmfExperimentContext
) context
;
400 int nbTraces
= ctx
.getContexts().length
;
402 // expRank = sum(trace ranks) - nbTraces + 1 (if lastTraceRead != NO_TRACE)
403 long expRank
= -nbTraces
+ ((ctx
.getLastTrace() != TmfExperimentContext
.NO_TRACE
) ?
1 : 0);
404 for (int i
= 0; i
< nbTraces
; i
++) {
405 long rank
= ctx
.getContexts()[i
].getRank();
412 assertEquals("Experiment context rank", expRank
, ctx
.getRank());
415 public void testGetNextAfteSeekingOnTS_1() {
417 final long INITIAL_TS
= 1;
418 final int NB_READS
= 20;
420 // On lower bound, returns the first event (ts = 1)
421 final ITmfContext context
= fExperiment
.seekEvent(new TmfTimestamp(INITIAL_TS
, SCALE
, 0));
423 validateContextRanks(context
);
427 for (int i
= 0; i
< NB_READS
; i
++) {
428 event
= fExperiment
.getNext(context
);
429 assertEquals("Event timestamp", INITIAL_TS
+ i
, event
.getTimestamp().getValue());
430 assertEquals("Event rank", INITIAL_TS
+ i
, context
.getRank());
433 // Make sure we stay positioned
434 event
= fExperiment
.parseEvent(context
);
435 assertEquals("Event timestamp", INITIAL_TS
+ NB_READS
, event
.getTimestamp().getValue());
436 assertEquals("Event rank", INITIAL_TS
+ NB_READS
- 1, context
.getRank());
438 validateContextRanks(context
);
441 public void testGetNextAfteSeekingOnTS_2() {
443 final long INITIAL_TS
= 2;
444 final int NB_READS
= 20;
446 // On lower bound, returns the first event (ts = 2)
447 final ITmfContext context
= fExperiment
.seekEvent(new TmfTimestamp(INITIAL_TS
, SCALE
, 0));
449 validateContextRanks(context
);
453 for (int i
= 0; i
< NB_READS
; i
++) {
454 event
= fExperiment
.getNext(context
);
455 assertEquals("Event timestamp", INITIAL_TS
+ i
, event
.getTimestamp().getValue());
456 assertEquals("Event rank", INITIAL_TS
+ i
, context
.getRank());
459 // Make sure we stay positioned
460 event
= fExperiment
.parseEvent(context
);
461 assertEquals("Event timestamp", INITIAL_TS
+ NB_READS
, event
.getTimestamp().getValue());
462 assertEquals("Event rank", INITIAL_TS
+ NB_READS
- 1, context
.getRank());
464 validateContextRanks(context
);
467 public void testGetNextAfteSeekingOnTS_3() {
469 final long INITIAL_TS
= 500;
470 final int NB_READS
= 20;
472 // On lower bound, returns the first event (ts = 500)
473 final ITmfContext context
= fExperiment
.seekEvent(new TmfTimestamp(INITIAL_TS
, SCALE
, 0));
475 validateContextRanks(context
);
479 for (int i
= 0; i
< NB_READS
; i
++) {
480 event
= fExperiment
.getNext(context
);
481 assertEquals("Event timestamp", INITIAL_TS
+ i
, event
.getTimestamp().getValue());
482 assertEquals("Event rank", INITIAL_TS
+ i
, context
.getRank());
485 // Make sure we stay positioned
486 event
= fExperiment
.parseEvent(context
);
487 assertEquals("Event timestamp", INITIAL_TS
+ NB_READS
, event
.getTimestamp().getValue());
488 assertEquals("Event rank", INITIAL_TS
+ NB_READS
- 1, context
.getRank());
490 validateContextRanks(context
);
493 public void testGetNextAfterSeekingOnRank_1() {
495 final long INITIAL_RANK
= 0L;
496 final int NB_READS
= 20;
498 // On lower bound, returns the first event (rank = 0)
499 final ITmfContext context
= fExperiment
.seekEvent(INITIAL_RANK
);
501 validateContextRanks(context
);
505 for (int i
= 0; i
< NB_READS
; i
++) {
506 event
= fExperiment
.getNext(context
);
507 assertEquals("Event timestamp", INITIAL_RANK
+ i
+ 1, event
.getTimestamp().getValue());
508 assertEquals("Event rank", INITIAL_RANK
+ i
+ 1, context
.getRank());
511 // Make sure we stay positioned
512 event
= fExperiment
.parseEvent(context
);
513 assertEquals("Event timestamp", INITIAL_RANK
+ NB_READS
+ 1, event
.getTimestamp().getValue());
514 assertEquals("Event rank", INITIAL_RANK
+ NB_READS
, context
.getRank());
516 validateContextRanks(context
);
519 public void testGetNextAfterSeekingOnRank_2() {
521 final long INITIAL_RANK
= 1L;
522 final int NB_READS
= 20;
524 // On lower bound, returns the first event (rank = 0)
525 final ITmfContext context
= fExperiment
.seekEvent(INITIAL_RANK
);
527 validateContextRanks(context
);
531 for (int i
= 0; i
< NB_READS
; i
++) {
532 event
= fExperiment
.getNext(context
);
533 assertEquals("Event timestamp", INITIAL_RANK
+ i
+ 1, event
.getTimestamp().getValue());
534 assertEquals("Event rank", INITIAL_RANK
+ i
+ 1, context
.getRank());
537 // Make sure we stay positioned
538 event
= fExperiment
.parseEvent(context
);
539 assertEquals("Event timestamp", INITIAL_RANK
+ NB_READS
+ 1, event
.getTimestamp().getValue());
540 assertEquals("Event rank", INITIAL_RANK
+ NB_READS
, context
.getRank());
542 validateContextRanks(context
);
545 public void testGetNextAfterSeekingOnRank_3() {
547 final long INITIAL_RANK
= 500L;
548 final int NB_READS
= 20;
550 // On lower bound, returns the first event (rank = 0)
551 final ITmfContext context
= fExperiment
.seekEvent(INITIAL_RANK
);
553 validateContextRanks(context
);
557 for (int i
= 0; i
< NB_READS
; i
++) {
558 event
= fExperiment
.getNext(context
);
559 assertEquals("Event timestamp", INITIAL_RANK
+ i
+ 1, event
.getTimestamp().getValue());
560 assertEquals("Event rank", INITIAL_RANK
+ i
+ 1, context
.getRank());
563 // Make sure we stay positioned
564 event
= fExperiment
.parseEvent(context
);
565 assertEquals("Event timestamp", INITIAL_RANK
+ NB_READS
+ 1, event
.getTimestamp().getValue());
566 assertEquals("Event rank", INITIAL_RANK
+ NB_READS
, context
.getRank());
568 validateContextRanks(context
);
571 public void testGetNextAfterSeekingOnLocation_1() {
573 final ITmfLocation
<?
> INITIAL_LOC
= null;
574 final long INITIAL_TS
= 1;
575 final int NB_READS
= 20;
577 // On lower bound, returns the first event (ts = 1)
578 final ITmfContext context
= fExperiment
.seekEvent(INITIAL_LOC
);
580 validateContextRanks(context
);
584 for (int i
= 0; i
< NB_READS
; i
++) {
585 event
= fExperiment
.getNext(context
);
586 assertEquals("Event timestamp", INITIAL_TS
+ i
, event
.getTimestamp().getValue());
587 assertEquals("Event rank", INITIAL_TS
+ i
, context
.getRank());
590 // Make sure we stay positioned
591 event
= fExperiment
.parseEvent(context
);
592 assertEquals("Event timestamp", INITIAL_TS
+ NB_READS
, event
.getTimestamp().getValue());
593 assertEquals("Event rank", INITIAL_TS
+ NB_READS
- 1, context
.getRank());
595 validateContextRanks(context
);
598 public void testGetNextAfterSeekingOnLocation_2() {
600 final ITmfLocation
<?
> INITIAL_LOC
= fExperiment
.seekEvent(1L).getLocation();
601 final long INITIAL_TS
= 2;
602 final int NB_READS
= 20;
604 // On lower bound, returns the first event (ts = 2)
605 final ITmfContext context
= fExperiment
.seekEvent(INITIAL_LOC
);
607 validateContextRanks(context
);
611 for (int i
= 0; i
< NB_READS
; i
++) {
612 event
= fExperiment
.getNext(context
);
613 assertEquals("Event timestamp", INITIAL_TS
+ i
, event
.getTimestamp().getValue());
616 // Make sure we stay positioned
617 event
= fExperiment
.parseEvent(context
);
618 assertEquals("Event timestamp", INITIAL_TS
+ NB_READS
, event
.getTimestamp().getValue());
620 validateContextRanks(context
);
623 public void testGetNextAfterSeekingOnLocation_3() {
625 final ITmfLocation
<?
> INITIAL_LOC
= fExperiment
.seekEvent(500L).getLocation();
626 final long INITIAL_TS
= 501;
627 final int NB_READS
= 20;
629 // On lower bound, returns the first event (ts = 501)
630 final ITmfContext context
= fExperiment
.seekEvent(INITIAL_LOC
);
632 validateContextRanks(context
);
636 for (int i
= 0; i
< NB_READS
; i
++) {
637 event
= fExperiment
.getNext(context
);
638 assertEquals("Event timestamp", INITIAL_TS
+ i
, event
.getTimestamp().getValue());
641 // Make sure we stay positioned
642 event
= fExperiment
.parseEvent(context
);
643 assertEquals("Event timestamp", INITIAL_TS
+ NB_READS
, event
.getTimestamp().getValue());
645 validateContextRanks(context
);
648 public void testGetNextLocation() {
649 ITmfContext context1
= fExperiment
.seekEvent(0);
650 fExperiment
.getNext(context1
);
651 ITmfLocation
<?
> location
= context1
.getLocation().clone();
652 ITmfEvent event1
= fExperiment
.getNext(context1
);
653 ITmfContext context2
= fExperiment
.seekEvent(location
);
654 ITmfEvent event2
= fExperiment
.getNext(context2
);
655 assertEquals("Event timestamp", event1
.getTimestamp().getValue(), event2
.getTimestamp().getValue());
658 public void testGetNextEndLocation() {
659 ITmfContext context1
= fExperiment
.seekEvent(fExperiment
.getNbEvents() - 1);
660 fExperiment
.getNext(context1
);
661 ITmfLocation
<?
> location
= context1
.getLocation().clone();
662 ITmfContext context2
= fExperiment
.seekEvent(location
);
663 ITmfEvent event
= fExperiment
.getNext(context2
);
664 assertNull("Event", event
);
667 // ------------------------------------------------------------------------
669 // ------------------------------------------------------------------------
671 public void testProcessRequestForNbEvents() throws InterruptedException
{
673 final int blockSize
= 100;
674 final int nbEvents
= 1000;
675 final Vector
<ITmfEvent
> requestedEvents
= new Vector
<ITmfEvent
>();
677 final TmfTimeRange range
= new TmfTimeRange(TmfTimestamp
.BIG_BANG
, TmfTimestamp
.BIG_CRUNCH
);
678 final TmfEventRequest request
= new TmfEventRequest(TmfEvent
.class, range
, nbEvents
, blockSize
) {
680 public void handleData(final ITmfEvent event
) {
681 super.handleData(event
);
682 requestedEvents
.add(event
);
685 fExperiment
.sendRequest(request
);
686 request
.waitForCompletion();
688 assertEquals("nbEvents", nbEvents
, requestedEvents
.size());
689 assertTrue("isCompleted", request
.isCompleted());
690 assertFalse("isCancelled", request
.isCancelled());
692 // Ensure that we have distinct events.
693 // Don't go overboard: we are not validating the stub!
694 for (int i
= 0; i
< nbEvents
; i
++) {
695 assertEquals("Distinct events", i
+1, requestedEvents
.get(i
).getTimestamp().getValue());
699 public void testProcessRequestForNbEvents2() throws InterruptedException
{
701 final int blockSize
= 2 * NB_EVENTS
;
702 final int nbEvents
= 1000;
703 final Vector
<ITmfEvent
> requestedEvents
= new Vector
<ITmfEvent
>();
705 final TmfTimeRange range
= new TmfTimeRange(TmfTimestamp
.BIG_BANG
, TmfTimestamp
.BIG_CRUNCH
);
706 final TmfEventRequest request
= new TmfEventRequest(TmfEvent
.class, range
, nbEvents
, blockSize
) {
708 public void handleData(final ITmfEvent event
) {
709 super.handleData(event
);
710 requestedEvents
.add(event
);
713 fExperiment
.sendRequest(request
);
714 request
.waitForCompletion();
716 assertEquals("nbEvents", nbEvents
, requestedEvents
.size());
717 assertTrue("isCompleted", request
.isCompleted());
718 assertFalse("isCancelled", request
.isCancelled());
720 // Ensure that we have distinct events.
721 // Don't go overboard: we are not validating the stub!
722 for (int i
= 0; i
< nbEvents
; i
++) {
723 assertEquals("Distinct events", i
+1, requestedEvents
.get(i
).getTimestamp().getValue());
727 public void testProcessRequestForAllEvents() throws InterruptedException
{
729 final int nbEvents
= TmfDataRequest
.ALL_DATA
;
730 final int blockSize
= 1;
731 final Vector
<ITmfEvent
> requestedEvents
= new Vector
<ITmfEvent
>();
732 final long nbExpectedEvents
= NB_EVENTS
;
734 final TmfTimeRange range
= new TmfTimeRange(TmfTimestamp
.BIG_BANG
, TmfTimestamp
.BIG_CRUNCH
);
735 final TmfEventRequest request
= new TmfEventRequest(TmfEvent
.class, range
, nbEvents
, blockSize
) {
737 public void handleData(final ITmfEvent event
) {
738 super.handleData(event
);
739 requestedEvents
.add(event
);
742 fExperiment
.sendRequest(request
);
743 request
.waitForCompletion();
745 assertEquals("nbEvents", nbExpectedEvents
, requestedEvents
.size());
746 assertTrue("isCompleted", request
.isCompleted());
747 assertFalse("isCancelled", request
.isCancelled());
749 // Ensure that we have distinct events.
750 // Don't go overboard: we are not validating the stub!
751 for (int i
= 0; i
< nbExpectedEvents
; i
++) {
752 assertEquals("Distinct events", i
+1, requestedEvents
.get(i
).getTimestamp().getValue());
756 // ------------------------------------------------------------------------
758 // ------------------------------------------------------------------------
760 public void testCancel() throws InterruptedException
{
762 final int nbEvents
= NB_EVENTS
;
763 final int blockSize
= BLOCK_SIZE
;
764 final Vector
<ITmfEvent
> requestedEvents
= new Vector
<ITmfEvent
>();
766 final TmfTimeRange range
= new TmfTimeRange(TmfTimestamp
.BIG_BANG
, TmfTimestamp
.BIG_CRUNCH
);
767 final TmfEventRequest request
= new TmfEventRequest(TmfEvent
.class, range
, nbEvents
, blockSize
) {
770 public void handleData(final ITmfEvent event
) {
771 super.handleData(event
);
772 requestedEvents
.add(event
);
773 if (++nbRead
== blockSize
) {
778 public void handleCancel() {
779 if (requestedEvents
.size() < blockSize
) {
780 System
.out
.println("aie");
784 fExperiment
.sendRequest(request
);
785 request
.waitForCompletion();
787 assertEquals("nbEvents", blockSize
, requestedEvents
.size());
788 assertTrue("isCompleted", request
.isCompleted());
789 assertTrue("isCancelled", request
.isCancelled());
792 // ------------------------------------------------------------------------
794 // ------------------------------------------------------------------------
796 public void testGetTimestamp() {
797 assertEquals("getTimestamp", new TmfTimestamp( 1, (byte) -3), fExperiment
.getTimestamp( 0));
798 assertEquals("getTimestamp", new TmfTimestamp( 2, (byte) -3), fExperiment
.getTimestamp( 1));
799 assertEquals("getTimestamp", new TmfTimestamp( 11, (byte) -3), fExperiment
.getTimestamp( 10));
800 assertEquals("getTimestamp", new TmfTimestamp( 101, (byte) -3), fExperiment
.getTimestamp( 100));
801 assertEquals("getTimestamp", new TmfTimestamp( 1001, (byte) -3), fExperiment
.getTimestamp( 1000));
802 assertEquals("getTimestamp", new TmfTimestamp( 2001, (byte) -3), fExperiment
.getTimestamp( 2000));
803 assertEquals("getTimestamp", new TmfTimestamp( 2501, (byte) -3), fExperiment
.getTimestamp( 2500));
804 assertEquals("getTimestamp", new TmfTimestamp(10000, (byte) -3), fExperiment
.getTimestamp( 9999));
805 assertEquals("getTimestamp", new TmfTimestamp(20000, (byte) -3), fExperiment
.getTimestamp(19999));
806 assertNull("getTimestamp", fExperiment
.getTimestamp(20000));