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
.resources
.IFile
;
25 import org
.eclipse
.core
.runtime
.FileLocator
;
26 import org
.eclipse
.core
.runtime
.Path
;
27 import org
.eclipse
.linuxtools
.internal
.tmf
.core
.trace
.TmfExperimentContext
;
28 import org
.eclipse
.linuxtools
.internal
.tmf
.core
.trace
.TmfExperimentLocation
;
29 import org
.eclipse
.linuxtools
.tmf
.core
.event
.ITmfEvent
;
30 import org
.eclipse
.linuxtools
.tmf
.core
.event
.TmfEvent
;
31 import org
.eclipse
.linuxtools
.tmf
.core
.event
.TmfTimeRange
;
32 import org
.eclipse
.linuxtools
.tmf
.core
.event
.TmfTimestamp
;
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
.trace
.ITmfContext
;
38 import org
.eclipse
.linuxtools
.tmf
.core
.trace
.ITmfLocation
;
39 import org
.eclipse
.linuxtools
.tmf
.core
.trace
.ITmfTrace
;
40 import org
.eclipse
.linuxtools
.tmf
.core
.trace
.TmfExperiment
;
41 import org
.eclipse
.linuxtools
.tmf
.core
.trace
.TmfLocation
;
42 import org
.eclipse
.linuxtools
.tmf
.tests
.stubs
.trace
.TmfExperimentStub
;
43 import org
.eclipse
.linuxtools
.tmf
.tests
.stubs
.trace
.TmfTraceStub
;
46 * Test suite for the TmfExperiment class (single trace).
48 @SuppressWarnings({"nls","javadoc"})
49 public class TmfExperimentTest
extends TestCase
{
51 // ------------------------------------------------------------------------
53 // ------------------------------------------------------------------------
55 private static final String DIRECTORY
= "testfiles";
56 private static final String TEST_STREAM
= "A-Test-10K";
57 private static final String EXPERIMENT
= "MyExperiment";
58 private static int NB_EVENTS
= 10000;
59 private static int BLOCK_SIZE
= 1000;
61 private ITmfTrace
[] fTestTraces
;
62 private TmfExperimentStub fExperiment
;
64 private static byte SCALE
= (byte) -3;
66 // ------------------------------------------------------------------------
68 // ------------------------------------------------------------------------
70 private synchronized ITmfTrace
[] setupTrace(final String path
) {
71 if (fTestTraces
== null) {
72 fTestTraces
= new ITmfTrace
[1];
74 final URL location
= FileLocator
.find(TmfCoreTestPlugin
.getDefault().getBundle(), new Path(path
), null);
75 final File test
= new File(FileLocator
.toFileURL(location
).toURI());
76 final TmfTraceStub trace
= new TmfTraceStub(test
.getPath(), 0, true);
77 fTestTraces
[0] = trace
;
78 } catch (final TmfTraceException e
) {
80 } catch (final URISyntaxException e
) {
82 } catch (final IOException e
) {
89 private synchronized void setupExperiment() {
90 if (fExperiment
== null) {
91 fExperiment
= new TmfExperimentStub(EXPERIMENT
, fTestTraces
, BLOCK_SIZE
);
92 fExperiment
.getIndexer().buildIndex(0, TmfTimeRange
.ETERNITY
, true);
97 * @param name the test name
99 public TmfExperimentTest(final String name
) {
104 protected void setUp() throws Exception
{
106 setupTrace(DIRECTORY
+ File
.separator
+ TEST_STREAM
);
111 protected void tearDown() throws Exception
{
115 // ------------------------------------------------------------------------
117 // ------------------------------------------------------------------------
119 public void testSimpleTmfExperimentConstructor() {
121 TmfExperiment experiment
= new TmfExperiment(TmfEvent
.class, EXPERIMENT
, fTestTraces
);
122 assertEquals("GetId", EXPERIMENT
, experiment
.getName());
123 assertEquals("GetCacheSize", TmfExperiment
.DEFAULT_INDEX_PAGE_SIZE
, experiment
.getCacheSize());
124 experiment
.dispose();
126 experiment
= new TmfExperiment(TmfEvent
.class, EXPERIMENT
, null);
127 experiment
.dispose();
130 public void testNormalTmfExperimentConstructor() {
132 assertEquals("GetId", EXPERIMENT
, fExperiment
.getName());
133 assertEquals("GetNbEvents", NB_EVENTS
, fExperiment
.getNbEvents());
135 final long nbExperimentEvents
= fExperiment
.getNbEvents();
136 assertEquals("GetNbEvents", NB_EVENTS
, nbExperimentEvents
);
138 final long nbTraceEvents
= fExperiment
.getTraces()[0].getNbEvents();
139 assertEquals("GetNbEvents", NB_EVENTS
, nbTraceEvents
);
141 final TmfTimeRange timeRange
= fExperiment
.getTimeRange();
142 assertEquals("getStartTime", 1, timeRange
.getStartTime().getValue());
143 assertEquals("getEndTime", NB_EVENTS
, timeRange
.getEndTime().getValue());
146 @SuppressWarnings("static-access")
147 public void testSetCurrentExperiment() {
149 TmfExperiment experiment
= new TmfExperiment(TmfEvent
.class, EXPERIMENT
, fTestTraces
);
150 experiment
.setCurrentExperiment(experiment
);
151 assertEquals("getCurrentExperiment", experiment
, experiment
.getCurrentExperiment());
153 TmfExperiment experiment2
= new TmfExperiment(TmfEvent
.class, EXPERIMENT
, null);
154 experiment
.setCurrentExperiment(experiment2
);
155 assertEquals("getCurrentExperiment", experiment2
, experiment
.getCurrentExperiment());
157 experiment
.dispose();
158 experiment2
.dispose();
161 // ------------------------------------------------------------------------
163 // ------------------------------------------------------------------------
165 public void testGetTimestamp() {
166 assertEquals("getTimestamp", new TmfTimestamp( 1, (byte) -3), fExperiment
.getTimestamp( 0));
167 assertEquals("getTimestamp", new TmfTimestamp( 2, (byte) -3), fExperiment
.getTimestamp( 1));
168 assertEquals("getTimestamp", new TmfTimestamp( 11, (byte) -3), fExperiment
.getTimestamp( 10));
169 assertEquals("getTimestamp", new TmfTimestamp( 101, (byte) -3), fExperiment
.getTimestamp( 100));
170 assertEquals("getTimestamp", new TmfTimestamp( 1001, (byte) -3), fExperiment
.getTimestamp(1000));
171 assertEquals("getTimestamp", new TmfTimestamp( 2001, (byte) -3), fExperiment
.getTimestamp(2000));
172 assertEquals("getTimestamp", new TmfTimestamp( 2501, (byte) -3), fExperiment
.getTimestamp(2500));
173 assertEquals("getTimestamp", new TmfTimestamp(10000, (byte) -3), fExperiment
.getTimestamp(9999));
174 assertNull("getTimestamp", fExperiment
.getTimestamp(10000));
177 // ------------------------------------------------------------------------
178 // Bookmarks file handling
179 // ------------------------------------------------------------------------
181 public void testBookmarks() {
182 assertNull("GetBookmarksFile", fExperiment
.getBookmarksFile());
183 IFile bookmarks
= (IFile
) fTestTraces
[0].getResource();
184 fExperiment
.setBookmarksFile(bookmarks
);
185 assertEquals("GetBookmarksFile", bookmarks
, fExperiment
.getBookmarksFile());
188 // ------------------------------------------------------------------------
189 // seekEvent by location
190 // ------------------------------------------------------------------------
192 public void testSeekBadLocation() {
193 ITmfContext context
= fExperiment
.seekEvent(new TmfLocation
<Long
>(0L));
194 assertNull("seekEvent", context
);
197 public void testSeekNoTrace() {
198 TmfExperiment experiment
= new TmfExperiment(TmfEvent
.class, EXPERIMENT
, null);
199 ITmfContext context
= experiment
.seekEvent((TmfExperimentLocation
) null);
200 assertNull("seekEvent", context
);
201 experiment
.dispose();
204 // ------------------------------------------------------------------------
205 // seekEvent on ratio
206 // ------------------------------------------------------------------------
208 public void testSeekEventOnRatio() {
211 ITmfContext context
= fExperiment
.seekEvent(0.0);
212 assertEquals("Context rank", 0, context
.getRank());
213 ITmfEvent event
= fExperiment
.parseEvent(context
);
214 assertEquals("Event timestamp", 1, event
.getTimestamp().getValue());
215 assertEquals("Context rank", 0, context
.getRank());
218 int midTrace
= NB_EVENTS
/ 2;
219 context
= fExperiment
.seekEvent(0.5);
220 assertEquals("Context rank", midTrace
, context
.getRank());
221 event
= fExperiment
.parseEvent(context
);
222 assertEquals("Event timestamp", midTrace
+ 1, event
.getTimestamp().getValue());
223 assertEquals("Context rank", midTrace
, context
.getRank());
226 context
= fExperiment
.seekEvent(1.0);
227 assertEquals("Context rank", NB_EVENTS
, context
.getRank());
228 event
= fExperiment
.parseEvent(context
);
229 assertNull("Event timestamp", event
);
230 assertEquals("Context rank", NB_EVENTS
, context
.getRank());
233 context
= fExperiment
.seekEvent(1.1);
234 assertEquals("Context rank", NB_EVENTS
, context
.getRank());
235 event
= fExperiment
.parseEvent(context
);
236 assertNull("Event timestamp", event
);
237 assertEquals("Context rank", NB_EVENTS
, context
.getRank());
240 context
= fExperiment
.seekEvent(-0.5);
241 assertEquals("Context rank", 0, context
.getRank());
242 event
= fExperiment
.parseEvent(context
);
243 assertEquals("Event timestamp", 1, event
.getTimestamp().getValue());
244 assertEquals("Context rank", 0, context
.getRank());
247 @SuppressWarnings("rawtypes")
248 public void testGetLocationRatio() {
251 ITmfContext context
= fExperiment
.seekEvent((ITmfLocation
) null);
252 double ratio
= fExperiment
.getLocationRatio(context
.getLocation());
253 context
= fExperiment
.seekEvent(ratio
);
254 double ratio2
= fExperiment
.getLocationRatio(context
.getLocation());
255 assertEquals("getLocationRatio", ratio
, ratio2
);
258 context
= fExperiment
.seekEvent(NB_EVENTS
/ 2);
259 ratio
= fExperiment
.getLocationRatio(context
.getLocation());
260 context
= fExperiment
.seekEvent(ratio
);
261 ratio2
= fExperiment
.getLocationRatio(context
.getLocation());
262 assertEquals("getLocationRatio", ratio
, ratio2
);
265 context
= fExperiment
.seekEvent(NB_EVENTS
- 1);
266 ratio
= fExperiment
.getLocationRatio(context
.getLocation());
267 context
= fExperiment
.seekEvent(ratio
);
268 ratio2
= fExperiment
.getLocationRatio(context
.getLocation());
269 assertEquals("getLocationRatio", ratio
, ratio2
);
272 // @SuppressWarnings("rawtypes")
273 // public void testGetCurrentLocation() {
274 // ITmfContext context = fExperiment.seekEvent((ITmfLocation) null);
275 // ITmfLocation location = fExperiment.getCurrentLocation();
276 // assertEquals("getCurrentLocation", location, context.getLocation());
279 // ------------------------------------------------------------------------
281 // ------------------------------------------------------------------------
283 public void testSeekRankOnCacheBoundary() {
285 long cacheSize
= fExperiment
.getCacheSize();
287 // On lower bound, returns the first event (TS = 1)
288 ITmfContext context
= fExperiment
.seekEvent(0);
289 assertEquals("Context rank", 0, context
.getRank());
291 ITmfEvent event
= fExperiment
.getNext(context
);
292 assertEquals("Event timestamp", 1, event
.getTimestamp().getValue());
293 assertEquals("Context rank", 1, context
.getRank());
295 // Position trace at event rank [cacheSize]
296 context
= fExperiment
.seekEvent(cacheSize
);
297 assertEquals("Context rank", cacheSize
, context
.getRank());
299 event
= fExperiment
.getNext(context
);
300 assertEquals("Event timestamp", cacheSize
+ 1, event
.getTimestamp().getValue());
301 assertEquals("Context rank", cacheSize
+ 1, context
.getRank());
303 // Position trace at event rank [4 * cacheSize]
304 context
= fExperiment
.seekEvent(4 * cacheSize
);
305 assertEquals("Context rank", 4 * cacheSize
, context
.getRank());
307 event
= fExperiment
.getNext(context
);
308 assertEquals("Event timestamp", 4 * cacheSize
+ 1, event
.getTimestamp().getValue());
309 assertEquals("Context rank", 4 * cacheSize
+ 1, context
.getRank());
312 public void testSeekRankNotOnCacheBoundary() {
314 long cacheSize
= fExperiment
.getCacheSize();
316 // Position trace at event rank 9
317 ITmfContext context
= fExperiment
.seekEvent(9);
318 assertEquals("Context rank", 9, context
.getRank());
320 ITmfEvent event
= fExperiment
.getNext(context
);
321 assertEquals("Event timestamp", 10, event
.getTimestamp().getValue());
322 assertEquals("Context rank", 10, context
.getRank());
324 // Position trace at event rank [cacheSize - 1]
325 context
= fExperiment
.seekEvent(cacheSize
- 1);
326 assertEquals("Context rank", cacheSize
- 1, context
.getRank());
328 event
= fExperiment
.getNext(context
);
329 assertEquals("Event timestamp", cacheSize
, event
.getTimestamp().getValue());
330 assertEquals("Context rank", cacheSize
, context
.getRank());
332 // Position trace at event rank [cacheSize + 1]
333 context
= fExperiment
.seekEvent(cacheSize
+ 1);
334 assertEquals("Context rank", cacheSize
+ 1, context
.getRank());
336 event
= fExperiment
.getNext(context
);
337 assertEquals("Event timestamp", cacheSize
+ 2, event
.getTimestamp().getValue());
338 assertEquals("Context rank", cacheSize
+ 2, context
.getRank());
340 // Position trace at event rank 4500
341 context
= fExperiment
.seekEvent(4500);
342 assertEquals("Context rank", 4500, context
.getRank());
344 event
= fExperiment
.getNext(context
);
345 assertEquals("Event timestamp", 4501, event
.getTimestamp().getValue());
346 assertEquals("Context rank", 4501, context
.getRank());
349 public void testSeekRankOutOfScope() {
351 // Position trace at beginning
352 ITmfContext context
= fExperiment
.seekEvent(-1);
353 assertEquals("Event rank", 0, context
.getRank());
355 ITmfEvent event
= fExperiment
.getNext(context
);
356 assertEquals("Event timestamp", 1, event
.getTimestamp().getValue());
357 assertEquals("Context rank", 1, context
.getRank());
359 // Position trace at event passed the end
360 context
= fExperiment
.seekEvent(NB_EVENTS
);
361 assertEquals("Context rank", NB_EVENTS
, context
.getRank());
363 event
= fExperiment
.getNext(context
);
364 assertNull("Event", event
);
365 assertEquals("Context rank", NB_EVENTS
, context
.getRank());
368 // ------------------------------------------------------------------------
369 // seekEvent on timestamp
370 // ------------------------------------------------------------------------
372 public void testSeekTimestampOnCacheBoundary() {
374 long cacheSize
= fExperiment
.getCacheSize();
376 // Position trace at event rank 0
377 ITmfContext context
= fExperiment
.seekEvent(new TmfTimestamp(1, SCALE
, 0));
378 assertEquals("Context rank", 0, context
.getRank());
380 ITmfEvent event
= fExperiment
.getNext(context
);
381 assertEquals("Event timestamp", 1, event
.getTimestamp().getValue());
382 assertEquals("Context rank", 1, context
.getRank());
384 // Position trace at event rank [cacheSize]
385 context
= fExperiment
.seekEvent(new TmfTimestamp(cacheSize
+ 1, SCALE
, 0));
386 assertEquals("Event rank", cacheSize
, context
.getRank());
388 event
= fExperiment
.getNext(context
);
389 assertEquals("Event timestamp", cacheSize
+ 1, event
.getTimestamp().getValue());
390 assertEquals("Context rank", cacheSize
+ 1, context
.getRank());
392 // Position trace at event rank [4 * cacheSize]
393 context
= fExperiment
.seekEvent(new TmfTimestamp(4 * cacheSize
+ 1, SCALE
, 0));
394 assertEquals("Context rank", 4 * cacheSize
, context
.getRank());
396 event
= fExperiment
.getNext(context
);
397 assertEquals("Event timestamp", 4 * cacheSize
+ 1, event
.getTimestamp().getValue());
398 assertEquals("Context rank", 4 * cacheSize
+ 1, context
.getRank());
401 public void testSeekTimestampNotOnCacheBoundary() {
403 // Position trace at event rank 1 (TS = 2)
404 ITmfContext context
= fExperiment
.seekEvent(new TmfTimestamp(2, SCALE
, 0));
405 assertEquals("Context rank", 1, context
.getRank());
407 ITmfEvent event
= fExperiment
.getNext(context
);
408 assertEquals("Event timestamp", 2, event
.getTimestamp().getValue());
409 assertEquals("Context rank", 2, context
.getRank());
411 // Position trace at event rank 9 (TS = 10)
412 context
= fExperiment
.seekEvent(new TmfTimestamp(10, SCALE
, 0));
413 assertEquals("Context rank", 9, context
.getRank());
415 event
= fExperiment
.getNext(context
);
416 assertEquals("Event timestamp", 10, event
.getTimestamp().getValue());
417 assertEquals("Context rank", 10, context
.getRank());
419 // Position trace at event rank 999 (TS = 1000)
420 context
= fExperiment
.seekEvent(new TmfTimestamp(1000, SCALE
, 0));
421 assertEquals("Context rank", 999, context
.getRank());
423 event
= fExperiment
.getNext(context
);
424 assertEquals("Event timestamp", 1000, event
.getTimestamp().getValue());
425 assertEquals("Context rank", 1000, context
.getRank());
427 // Position trace at event rank 1001 (TS = 1002)
428 context
= fExperiment
.seekEvent(new TmfTimestamp(1002, SCALE
, 0));
429 assertEquals("Context rank", 1001, context
.getRank());
431 event
= fExperiment
.getNext(context
);
432 assertEquals("Event timestamp", 1002, event
.getTimestamp().getValue());
433 assertEquals("Context rank", 1002, context
.getRank());
435 // Position trace at event rank 4500 (TS = 4501)
436 context
= fExperiment
.seekEvent(new TmfTimestamp(4501, SCALE
, 0));
437 assertEquals("Context rank", 4500, context
.getRank());
439 event
= fExperiment
.getNext(context
);
440 assertEquals("Event timestamp", 4501, event
.getTimestamp().getValue());
441 assertEquals("Context rank", 4501, context
.getRank());
444 public void testSeekTimestampOutOfScope() {
446 // Position trace at beginning
447 ITmfContext context
= fExperiment
.seekEvent(new TmfTimestamp(-1, SCALE
, 0));
448 assertEquals("Event rank", 0, context
.getRank());
450 ITmfEvent event
= fExperiment
.getNext(context
);
451 assertEquals("Event timestamp", 1, event
.getTimestamp().getValue());
452 assertEquals("Event rank", 1, context
.getRank());
454 // Position trace at event passed the end
455 context
= fExperiment
.seekEvent(new TmfTimestamp(NB_EVENTS
+ 1, SCALE
, 0));
456 event
= fExperiment
.getNext(context
);
457 assertNull("Event location", event
);
458 assertEquals("Event rank", ITmfContext
.UNKNOWN_RANK
, context
.getRank());
461 // ------------------------------------------------------------------------
462 // seekEvent by location (context rank is undefined)
463 // ------------------------------------------------------------------------
465 public void testSeekLocationOnCacheBoundary() {
467 long cacheSize
= fExperiment
.getCacheSize();
469 // Position trace at event rank 0
470 ITmfContext tmpContext
= fExperiment
.seekEvent(0);
471 ITmfContext context
= fExperiment
.seekEvent(tmpContext
.getLocation());
473 ITmfEvent event
= fExperiment
.getNext(context
);
474 assertEquals("Event timestamp", 1, event
.getTimestamp().getValue());
476 event
= fExperiment
.getNext(context
);
477 assertEquals("Event timestamp", 2, event
.getTimestamp().getValue());
479 // Position trace at event rank 'cacheSize'
480 tmpContext
= fExperiment
.seekEvent(cacheSize
);
481 context
= fExperiment
.seekEvent(tmpContext
.getLocation());
483 event
= fExperiment
.getNext(context
);
484 assertEquals("Event timestamp", cacheSize
+ 1, event
.getTimestamp().getValue());
486 event
= fExperiment
.getNext(context
);
487 assertEquals("Event timestamp", cacheSize
+ 2, event
.getTimestamp().getValue());
489 // Position trace at event rank 4 * 'cacheSize'
490 tmpContext
= fExperiment
.seekEvent(4 * cacheSize
);
491 context
= fExperiment
.seekEvent(tmpContext
.getLocation());
493 event
= fExperiment
.getNext(context
);
494 assertEquals("Event timestamp", 4 * cacheSize
+ 1, event
.getTimestamp().getValue());
496 event
= fExperiment
.getNext(context
);
497 assertEquals("Event timestamp", 4 * cacheSize
+ 2, event
.getTimestamp().getValue());
500 public void testSeekLocationNotOnCacheBoundary() {
502 long cacheSize
= fExperiment
.getCacheSize();
504 // Position trace at event 'cacheSize' - 1
505 ITmfContext tmpContext
= fExperiment
.seekEvent(cacheSize
- 1);
506 ITmfContext context
= fExperiment
.seekEvent(tmpContext
.getLocation());
508 ITmfEvent event
= fExperiment
.getNext(context
);
509 assertEquals("Event timestamp", cacheSize
, event
.getTimestamp().getValue());
511 event
= fExperiment
.getNext(context
);
512 assertEquals("Event timestamp", cacheSize
+ 1, event
.getTimestamp().getValue());
514 // Position trace at event rank 2 * 'cacheSize' - 1
515 tmpContext
= fExperiment
.seekEvent(2 * cacheSize
- 1);
516 context
= fExperiment
.seekEvent(tmpContext
.getLocation());
517 context
= fExperiment
.seekEvent(2 * cacheSize
- 1);
519 event
= fExperiment
.getNext(context
);
520 assertEquals("Event timestamp", 2 * cacheSize
, event
.getTimestamp().getValue());
522 event
= fExperiment
.getNext(context
);
523 assertEquals("Event timestamp", 2 * cacheSize
+ 1, event
.getTimestamp().getValue());
525 // Position trace at event rank 4500
526 tmpContext
= fExperiment
.seekEvent(4500);
527 context
= fExperiment
.seekEvent(tmpContext
.getLocation());
529 event
= fExperiment
.getNext(context
);
530 assertEquals("Event timestamp", 4501, event
.getTimestamp().getValue());
532 event
= fExperiment
.getNext(context
);
533 assertEquals("Event timestamp", 4502, event
.getTimestamp().getValue());
536 public void testSeekLocationOutOfScope() {
538 // Position trace at beginning
539 ITmfContext context
= fExperiment
.seekEvent((ITmfLocation
<?
>) null);
541 ITmfEvent event
= fExperiment
.getNext(context
);
542 assertEquals("Event timestamp", 1, event
.getTimestamp().getValue());
545 // ------------------------------------------------------------------------
546 // getNext - updates the context
547 // ------------------------------------------------------------------------
549 private static void validateContextRanks(ITmfContext context
) {
550 assertTrue("Experiment context type", context
instanceof TmfExperimentContext
);
551 TmfExperimentContext ctx
= (TmfExperimentContext
) context
;
553 int nbTraces
= ctx
.getContexts().length
;
555 // expRank = sum(trace ranks) - nbTraces + 1 (if lastTraceRead != NO_TRACE)
556 long expRank
= -nbTraces
+ ((ctx
.getLastTrace() != TmfExperimentContext
.NO_TRACE
) ?
1 : 0);
557 for (int i
= 0; i
< nbTraces
; i
++) {
558 long rank
= ctx
.getContexts()[i
].getRank();
565 assertEquals("Experiment context rank", expRank
, ctx
.getRank());
568 public void testGetNextAfteSeekingOnTS_1() {
570 final long INITIAL_TS
= 1;
571 final int NB_READS
= 20;
573 // On lower bound, returns the first event (ts = 1)
574 final ITmfContext context
= fExperiment
.seekEvent(new TmfTimestamp(INITIAL_TS
, SCALE
, 0));
576 validateContextRanks(context
);
580 for (int i
= 0; i
< NB_READS
; i
++) {
581 event
= fExperiment
.getNext(context
);
582 assertEquals("Event timestamp", INITIAL_TS
+ i
, event
.getTimestamp().getValue());
583 assertEquals("Event rank", INITIAL_TS
+ i
, context
.getRank());
586 // Make sure we stay positioned
587 event
= fExperiment
.parseEvent(context
);
588 assertEquals("Event timestamp", INITIAL_TS
+ NB_READS
, event
.getTimestamp().getValue());
589 assertEquals("Event rank", INITIAL_TS
+ NB_READS
- 1, context
.getRank());
591 validateContextRanks(context
);
594 public void testGetNextAfteSeekingOnTS_2() {
596 final long INITIAL_TS
= 2;
597 final int NB_READS
= 20;
599 // On lower bound, returns the first event (ts = 2)
600 final ITmfContext context
= fExperiment
.seekEvent(new TmfTimestamp(INITIAL_TS
, SCALE
, 0));
602 validateContextRanks(context
);
606 for (int i
= 0; i
< NB_READS
; i
++) {
607 event
= fExperiment
.getNext(context
);
608 assertEquals("Event timestamp", INITIAL_TS
+ i
, event
.getTimestamp().getValue());
609 assertEquals("Event rank", INITIAL_TS
+ i
, context
.getRank());
612 // Make sure we stay positioned
613 event
= fExperiment
.parseEvent(context
);
614 assertEquals("Event timestamp", INITIAL_TS
+ NB_READS
, event
.getTimestamp().getValue());
615 assertEquals("Event rank", INITIAL_TS
+ NB_READS
- 1, context
.getRank());
617 validateContextRanks(context
);
620 public void testGetNextAfteSeekingOnTS_3() {
622 final long INITIAL_TS
= 500;
623 final int NB_READS
= 20;
625 // On lower bound, returns the first event (ts = 500)
626 final ITmfContext context
= fExperiment
.seekEvent(new TmfTimestamp(INITIAL_TS
, SCALE
, 0));
628 validateContextRanks(context
);
632 for (int i
= 0; i
< NB_READS
; i
++) {
633 event
= fExperiment
.getNext(context
);
634 assertEquals("Event timestamp", INITIAL_TS
+ i
, event
.getTimestamp().getValue());
635 assertEquals("Event rank", INITIAL_TS
+ i
, context
.getRank());
638 // Make sure we stay positioned
639 event
= fExperiment
.parseEvent(context
);
640 assertEquals("Event timestamp", INITIAL_TS
+ NB_READS
, event
.getTimestamp().getValue());
641 assertEquals("Event rank", INITIAL_TS
+ NB_READS
- 1, context
.getRank());
643 validateContextRanks(context
);
646 public void testGetNextAfterSeekingOnRank_1() {
648 final long INITIAL_RANK
= 0L;
649 final int NB_READS
= 20;
651 // On lower bound, returns the first event (rank = 0)
652 final ITmfContext context
= fExperiment
.seekEvent(INITIAL_RANK
);
654 validateContextRanks(context
);
658 for (int i
= 0; i
< NB_READS
; i
++) {
659 event
= fExperiment
.getNext(context
);
660 assertEquals("Event timestamp", INITIAL_RANK
+ i
+ 1, event
.getTimestamp().getValue());
661 assertEquals("Event rank", INITIAL_RANK
+ i
+ 1, context
.getRank());
664 // Make sure we stay positioned
665 event
= fExperiment
.parseEvent(context
);
666 assertEquals("Event timestamp", INITIAL_RANK
+ NB_READS
+ 1, event
.getTimestamp().getValue());
667 assertEquals("Event rank", INITIAL_RANK
+ NB_READS
, context
.getRank());
669 validateContextRanks(context
);
672 public void testGetNextAfterSeekingOnRank_2() {
674 final long INITIAL_RANK
= 1L;
675 final int NB_READS
= 20;
677 // On lower bound, returns the first event (rank = 0)
678 final ITmfContext context
= fExperiment
.seekEvent(INITIAL_RANK
);
680 validateContextRanks(context
);
684 for (int i
= 0; i
< NB_READS
; i
++) {
685 event
= fExperiment
.getNext(context
);
686 assertEquals("Event timestamp", INITIAL_RANK
+ i
+ 1, event
.getTimestamp().getValue());
687 assertEquals("Event rank", INITIAL_RANK
+ i
+ 1, context
.getRank());
690 // Make sure we stay positioned
691 event
= fExperiment
.parseEvent(context
);
692 assertEquals("Event timestamp", INITIAL_RANK
+ NB_READS
+ 1, event
.getTimestamp().getValue());
693 assertEquals("Event rank", INITIAL_RANK
+ NB_READS
, context
.getRank());
695 validateContextRanks(context
);
698 public void testGetNextAfterSeekingOnRank_3() {
700 final long INITIAL_RANK
= 500L;
701 final int NB_READS
= 20;
703 // On lower bound, returns the first event (rank = 0)
704 final ITmfContext context
= fExperiment
.seekEvent(INITIAL_RANK
);
706 validateContextRanks(context
);
710 for (int i
= 0; i
< NB_READS
; i
++) {
711 event
= fExperiment
.getNext(context
);
712 assertEquals("Event timestamp", INITIAL_RANK
+ i
+ 1, event
.getTimestamp().getValue());
713 assertEquals("Event rank", INITIAL_RANK
+ i
+ 1, context
.getRank());
716 // Make sure we stay positioned
717 event
= fExperiment
.parseEvent(context
);
718 assertEquals("Event timestamp", INITIAL_RANK
+ NB_READS
+ 1, event
.getTimestamp().getValue());
719 assertEquals("Event rank", INITIAL_RANK
+ NB_READS
, context
.getRank());
721 validateContextRanks(context
);
724 public void testGetNextAfterSeekingOnLocation_1() {
726 final ITmfLocation
<?
> INITIAL_LOC
= null;
727 final long INITIAL_TS
= 1;
728 final int NB_READS
= 20;
730 // On lower bound, returns the first event (ts = 1)
731 final ITmfContext context
= fExperiment
.seekEvent(INITIAL_LOC
);
733 validateContextRanks(context
);
737 for (int i
= 0; i
< NB_READS
; i
++) {
738 event
= fExperiment
.getNext(context
);
739 assertEquals("Event timestamp", INITIAL_TS
+ i
, event
.getTimestamp().getValue());
740 assertEquals("Event rank", INITIAL_TS
+ i
, context
.getRank());
743 // Make sure we stay positioned
744 event
= fExperiment
.parseEvent(context
);
745 assertEquals("Event timestamp", INITIAL_TS
+ NB_READS
, event
.getTimestamp().getValue());
746 assertEquals("Event rank", INITIAL_TS
+ NB_READS
- 1, context
.getRank());
748 validateContextRanks(context
);
751 public void testGetNextAfterSeekingOnLocation_2() {
753 final ITmfLocation
<?
> INITIAL_LOC
= fExperiment
.seekEvent(1L).getLocation();
754 final long INITIAL_TS
= 2;
755 final int NB_READS
= 20;
757 // On lower bound, returns the first event (ts = 2)
758 final ITmfContext context
= fExperiment
.seekEvent(INITIAL_LOC
);
760 validateContextRanks(context
);
764 for (int i
= 0; i
< NB_READS
; i
++) {
765 event
= fExperiment
.getNext(context
);
766 assertEquals("Event timestamp", INITIAL_TS
+ i
, event
.getTimestamp().getValue());
769 // Make sure we stay positioned
770 event
= fExperiment
.parseEvent(context
);
771 assertEquals("Event timestamp", INITIAL_TS
+ NB_READS
, event
.getTimestamp().getValue());
773 validateContextRanks(context
);
776 public void testGetNextAfterSeekingOnLocation_3() {
778 final ITmfLocation
<?
> INITIAL_LOC
= fExperiment
.seekEvent(500L).getLocation();
779 final long INITIAL_TS
= 501;
780 final int NB_READS
= 20;
782 // On lower bound, returns the first event (ts = 501)
783 final ITmfContext context
= fExperiment
.seekEvent(INITIAL_LOC
);
785 validateContextRanks(context
);
789 for (int i
= 0; i
< NB_READS
; i
++) {
790 event
= fExperiment
.getNext(context
);
791 assertEquals("Event timestamp", INITIAL_TS
+ i
, event
.getTimestamp().getValue());
794 // Make sure we stay positioned
795 event
= fExperiment
.parseEvent(context
);
796 assertEquals("Event timestamp", INITIAL_TS
+ NB_READS
, event
.getTimestamp().getValue());
798 validateContextRanks(context
);
801 public void testGetNextLocation() {
802 ITmfContext context1
= fExperiment
.seekEvent(0);
803 fExperiment
.getNext(context1
);
804 ITmfLocation
<?
> location
= context1
.getLocation().clone();
805 ITmfEvent event1
= fExperiment
.getNext(context1
);
806 ITmfContext context2
= fExperiment
.seekEvent(location
);
807 ITmfEvent event2
= fExperiment
.getNext(context2
);
808 assertEquals("Event timestamp", event1
.getTimestamp().getValue(), event2
.getTimestamp().getValue());
811 public void testGetNextEndLocation() {
812 ITmfContext context1
= fExperiment
.seekEvent(fExperiment
.getNbEvents() - 1);
813 fExperiment
.getNext(context1
);
814 ITmfLocation
<?
> location
= context1
.getLocation().clone();
815 ITmfContext context2
= fExperiment
.seekEvent(location
);
816 ITmfEvent event
= fExperiment
.getNext(context2
);
817 assertNull("Event", event
);
820 // ------------------------------------------------------------------------
822 // ------------------------------------------------------------------------
824 public void testProcessRequestForNbEvents() throws InterruptedException
{
826 final int blockSize
= 100;
827 final int nbEvents
= 1000;
828 final Vector
<ITmfEvent
> requestedEvents
= new Vector
<ITmfEvent
>();
830 final TmfTimeRange range
= new TmfTimeRange(TmfTimestamp
.BIG_BANG
, TmfTimestamp
.BIG_CRUNCH
);
831 final TmfEventRequest request
= new TmfEventRequest(TmfEvent
.class, range
, nbEvents
, blockSize
) {
833 public void handleData(final ITmfEvent event
) {
834 super.handleData(event
);
835 requestedEvents
.add(event
);
838 fExperiment
.sendRequest(request
);
839 request
.waitForCompletion();
841 assertEquals("nbEvents", nbEvents
, requestedEvents
.size());
842 assertTrue("isCompleted", request
.isCompleted());
843 assertFalse("isCancelled", request
.isCancelled());
845 // Ensure that we have distinct events.
846 // Don't go overboard: we are not validating the stub!
847 for (int i
= 0; i
< nbEvents
; i
++) {
848 assertEquals("Distinct events", i
+1, requestedEvents
.get(i
).getTimestamp().getValue());
852 public void testProcessRequestForNbEvents2() throws InterruptedException
{
854 final int blockSize
= 2 * NB_EVENTS
;
855 final int nbEvents
= 1000;
856 final Vector
<ITmfEvent
> requestedEvents
= new Vector
<ITmfEvent
>();
858 final TmfTimeRange range
= new TmfTimeRange(TmfTimestamp
.BIG_BANG
, TmfTimestamp
.BIG_CRUNCH
);
859 final TmfEventRequest request
= new TmfEventRequest(TmfEvent
.class, range
, nbEvents
, blockSize
) {
861 public void handleData(final ITmfEvent event
) {
862 super.handleData(event
);
863 requestedEvents
.add(event
);
866 fExperiment
.sendRequest(request
);
867 request
.waitForCompletion();
869 assertEquals("nbEvents", nbEvents
, requestedEvents
.size());
870 assertTrue("isCompleted", request
.isCompleted());
871 assertFalse("isCancelled", request
.isCancelled());
873 // Ensure that we have distinct events.
874 // Don't go overboard: we are not validating the stub!
875 for (int i
= 0; i
< nbEvents
; i
++) {
876 assertEquals("Distinct events", i
+1, requestedEvents
.get(i
).getTimestamp().getValue());
880 public void testProcessRequestForAllEvents() throws InterruptedException
{
882 final int nbEvents
= TmfDataRequest
.ALL_DATA
;
883 final int blockSize
= 1;
884 final Vector
<ITmfEvent
> requestedEvents
= new Vector
<ITmfEvent
>();
885 final long nbExpectedEvents
= NB_EVENTS
;
887 final TmfTimeRange range
= new TmfTimeRange(TmfTimestamp
.BIG_BANG
, TmfTimestamp
.BIG_CRUNCH
);
888 final TmfEventRequest request
= new TmfEventRequest(TmfEvent
.class, range
, nbEvents
, blockSize
) {
890 public void handleData(final ITmfEvent event
) {
891 super.handleData(event
);
892 requestedEvents
.add(event
);
895 fExperiment
.sendRequest(request
);
896 request
.waitForCompletion();
898 assertEquals("nbEvents", nbExpectedEvents
, requestedEvents
.size());
899 assertTrue("isCompleted", request
.isCompleted());
900 assertFalse("isCancelled", request
.isCancelled());
902 // Ensure that we have distinct events.
903 // Don't go overboard: we are not validating the stub!
904 for (int i
= 0; i
< nbExpectedEvents
; i
++) {
905 assertEquals("Distinct events", i
+1, requestedEvents
.get(i
).getTimestamp().getValue());
909 // ------------------------------------------------------------------------
911 // ------------------------------------------------------------------------
913 public void testCancel() throws InterruptedException
{
915 final int nbEvents
= NB_EVENTS
;
916 final int blockSize
= BLOCK_SIZE
;
917 final Vector
<ITmfEvent
> requestedEvents
= new Vector
<ITmfEvent
>();
919 final TmfTimeRange range
= new TmfTimeRange(TmfTimestamp
.BIG_BANG
, TmfTimestamp
.BIG_CRUNCH
);
920 final TmfEventRequest request
= new TmfEventRequest(TmfEvent
.class, range
, nbEvents
, blockSize
) {
923 public void handleData(final ITmfEvent event
) {
924 super.handleData(event
);
925 requestedEvents
.add(event
);
926 if (++nbRead
== blockSize
) {
931 public void handleCancel() {
932 if (requestedEvents
.size() < blockSize
) {
933 System
.out
.println("aie");
937 fExperiment
.sendRequest(request
);
938 request
.waitForCompletion();
940 assertEquals("nbEvents", blockSize
, requestedEvents
.size());
941 assertTrue("isCompleted", request
.isCompleted());
942 assertTrue("isCancelled", request
.isCancelled());