1 /*******************************************************************************
2 * Copyright (c) 2009, 2014 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 - Adapted for TMF Trace Model 1.0
12 * Alexandre Montplaisir - Port to JUnit4
13 *******************************************************************************/
15 package org
.eclipse
.tracecompass
.tmf
.core
.tests
.trace
;
17 import static org
.junit
.Assert
.assertEquals
;
18 import static org
.junit
.Assert
.assertFalse
;
19 import static org
.junit
.Assert
.assertNotNull
;
20 import static org
.junit
.Assert
.assertNull
;
21 import static org
.junit
.Assert
.assertTrue
;
22 import static org
.junit
.Assert
.fail
;
25 import java
.io
.IOException
;
26 import java
.net
.URISyntaxException
;
28 import java
.util
.Vector
;
29 import java
.util
.concurrent
.TimeUnit
;
31 import org
.eclipse
.core
.runtime
.FileLocator
;
32 import org
.eclipse
.core
.runtime
.Path
;
33 import org
.eclipse
.tracecompass
.internal
.tmf
.core
.component
.TmfProviderManager
;
34 import org
.eclipse
.tracecompass
.tmf
.core
.analysis
.IAnalysisModule
;
35 import org
.eclipse
.tracecompass
.tmf
.core
.component
.ITmfEventProvider
;
36 import org
.eclipse
.tracecompass
.tmf
.core
.event
.ITmfEvent
;
37 import org
.eclipse
.tracecompass
.tmf
.core
.event
.aspect
.ITmfEventAspect
;
38 import org
.eclipse
.tracecompass
.tmf
.core
.exceptions
.TmfTraceException
;
39 import org
.eclipse
.tracecompass
.tmf
.core
.request
.ITmfEventRequest
.ExecutionType
;
40 import org
.eclipse
.tracecompass
.tmf
.core
.request
.TmfEventRequest
;
41 import org
.eclipse
.tracecompass
.tmf
.core
.signal
.TmfSignalManager
;
42 import org
.eclipse
.tracecompass
.tmf
.core
.signal
.TmfTraceOpenedSignal
;
43 import org
.eclipse
.tracecompass
.tmf
.core
.tests
.TmfCoreTestPlugin
;
44 import org
.eclipse
.tracecompass
.tmf
.core
.tests
.shared
.TmfTestTrace
;
45 import org
.eclipse
.tracecompass
.tmf
.core
.timestamp
.ITmfTimestamp
;
46 import org
.eclipse
.tracecompass
.tmf
.core
.timestamp
.TmfTimeRange
;
47 import org
.eclipse
.tracecompass
.tmf
.core
.timestamp
.TmfTimestamp
;
48 import org
.eclipse
.tracecompass
.tmf
.core
.trace
.ITmfContext
;
49 import org
.eclipse
.tracecompass
.tmf
.core
.trace
.ITmfTrace
;
50 import org
.eclipse
.tracecompass
.tmf
.core
.trace
.TmfContext
;
51 import org
.eclipse
.tracecompass
.tmf
.core
.trace
.TmfTrace
;
52 import org
.eclipse
.tracecompass
.tmf
.core
.trace
.location
.ITmfLocation
;
53 import org
.eclipse
.tracecompass
.tmf
.tests
.stubs
.analysis
.TestAnalysis
;
54 import org
.eclipse
.tracecompass
.tmf
.tests
.stubs
.trace
.TmfTraceStub
;
55 import org
.junit
.After
;
56 import org
.junit
.Before
;
57 import org
.junit
.Rule
;
58 import org
.junit
.Test
;
59 import org
.junit
.rules
.TestRule
;
60 import org
.junit
.rules
.Timeout
;
63 * Test suite for the TmfTrace class.
65 @SuppressWarnings("javadoc")
66 public class TmfTraceTest
{
68 /** Time-out tests after 20 seconds */
70 public TestRule globalTimeout
= new Timeout(20, TimeUnit
.SECONDS
);
72 // ------------------------------------------------------------------------
74 // ------------------------------------------------------------------------
76 private static final TmfTestTrace TEST_TRACE
= TmfTestTrace
.A_TEST_10K
;
77 private static final long DEFAULT_INITIAL_OFFSET_VALUE
= (1L * 100 * 1000 * 1000); // .1sec
78 private static final int NB_EVENTS
= 10000;
79 private TmfTraceStub fTrace
= null;
81 private static int SCALE
= -3;
83 // ------------------------------------------------------------------------
85 // ------------------------------------------------------------------------
90 final URL location
= FileLocator
.find(TmfCoreTestPlugin
.getDefault().getBundle(), new Path(TEST_TRACE
.getFullPath()), null);
91 final File test
= new File(FileLocator
.toFileURL(location
).toURI());
92 fTrace
= new TmfTraceStub(test
.toURI().getPath(), ITmfTrace
.DEFAULT_TRACE_CACHE_SIZE
, false, null);
93 TmfSignalManager
.deregister(fTrace
);
94 fTrace
.indexTrace(true);
95 } catch (final TmfTraceException e
) {
97 } catch (final URISyntaxException e
) {
99 } catch (final IOException e
) {
105 public void tearDown() {
110 // ------------------------------------------------------------------------
112 // ------------------------------------------------------------------------
115 public void testFullConstructor() throws TmfTraceException
{
117 final URL location
= FileLocator
.find(TmfCoreTestPlugin
.getDefault().getBundle(), new Path(TEST_TRACE
.getFullPath()), null);
118 File testfile
= new File(FileLocator
.toFileURL(location
).toURI());
119 TmfTraceStub trace
= new TmfTraceStub(testfile
.toURI().getPath(), ITmfTrace
.DEFAULT_TRACE_CACHE_SIZE
, false, null);
120 trace
.indexTrace(true);
122 assertEquals("getEventType", ITmfEvent
.class, trace
.getEventType());
123 assertNull("getResource", trace
.getResource());
124 assertEquals("getPath", testfile
.toURI().getPath(), trace
.getPath());
125 assertEquals("getCacheSize", ITmfTrace
.DEFAULT_TRACE_CACHE_SIZE
, trace
.getCacheSize());
126 assertEquals("getStreamingInterval", 0, trace
.getStreamingInterval());
127 assertEquals("getName", TEST_TRACE
.getPath(), trace
.getName());
129 assertEquals("getNbEvents", NB_EVENTS
, trace
.getNbEvents());
130 assertEquals("getRange-start", 1, trace
.getTimeRange().getStartTime().getValue());
131 assertEquals("getRange-end", NB_EVENTS
, trace
.getTimeRange().getEndTime().getValue());
132 assertEquals("getStartTime", 1, trace
.getStartTime().getValue());
133 assertEquals("getEndTime", NB_EVENTS
, trace
.getEndTime().getValue());
135 } catch (final URISyntaxException e
) {
136 fail("URISyntaxException");
137 } catch (final IOException e
) {
143 public void testLiveTraceConstructor() throws TmfTraceException
{
144 final long interval
= 100;
146 final URL location
= FileLocator
.find(TmfCoreTestPlugin
.getDefault().getBundle(), new Path(TEST_TRACE
.getFullPath()), null);
147 File testfile
= new File(FileLocator
.toFileURL(location
).toURI());
148 TmfTraceStub trace
= new TmfTraceStub(testfile
.toURI().getPath(), ITmfTrace
.DEFAULT_TRACE_CACHE_SIZE
, interval
);
149 trace
.indexTrace(true);
151 assertEquals("getEventType", ITmfEvent
.class, trace
.getEventType());
152 assertNull("getResource", trace
.getResource());
153 assertEquals("getPath", testfile
.toURI().getPath(), trace
.getPath());
154 assertEquals("getCacheSize", ITmfTrace
.DEFAULT_TRACE_CACHE_SIZE
, trace
.getCacheSize());
155 assertEquals("getStreamingInterval", interval
, trace
.getStreamingInterval());
156 assertEquals("getName", TEST_TRACE
.getPath(), trace
.getName());
158 assertEquals("getNbEvents", NB_EVENTS
, trace
.getNbEvents());
159 assertEquals("getRange-start", 1, trace
.getTimeRange().getStartTime().getValue());
160 assertEquals("getRange-end", NB_EVENTS
, trace
.getTimeRange().getEndTime().getValue());
161 assertEquals("getStartTime", 1, trace
.getStartTime().getValue());
162 assertEquals("getEndTime", NB_EVENTS
, trace
.getEndTime().getValue());
164 } catch (final URISyntaxException e
) {
165 fail("URISyntaxException");
166 } catch (final IOException e
) {
172 public void testCopyConstructor() throws TmfTraceException
{
174 final URL location
= FileLocator
.find(TmfCoreTestPlugin
.getDefault().getBundle(), new Path(TEST_TRACE
.getFullPath()), null);
175 File testfile
= new File(FileLocator
.toFileURL(location
).toURI());
176 TmfTraceStub original
= new TmfTraceStub(testfile
.toURI().getPath(), ITmfTrace
.DEFAULT_TRACE_CACHE_SIZE
, false, null);
177 TmfTraceStub trace
= new TmfTraceStub(original
);
178 trace
.indexTrace(true);
180 assertEquals("getEventType", ITmfEvent
.class, trace
.getEventType());
181 assertNull("getResource", trace
.getResource());
182 assertEquals("getPath", testfile
.toURI().getPath(), trace
.getPath());
183 assertEquals("getCacheSize", ITmfTrace
.DEFAULT_TRACE_CACHE_SIZE
, trace
.getCacheSize());
184 assertEquals("getStreamingInterval", 0, trace
.getStreamingInterval());
185 assertEquals("getName", TEST_TRACE
.getPath(), trace
.getName());
187 assertEquals("getNbEvents", NB_EVENTS
, trace
.getNbEvents());
188 assertEquals("getRange-start", 1, trace
.getTimeRange().getStartTime().getValue());
189 assertEquals("getRange-end", NB_EVENTS
, trace
.getTimeRange().getEndTime().getValue());
190 assertEquals("getStartTime", 1, trace
.getStartTime().getValue());
191 assertEquals("getEndTime", NB_EVENTS
, trace
.getEndTime().getValue());
193 } catch (final URISyntaxException e
) {
194 fail("URISyntaxException");
195 } catch (final IOException e
) {
199 // Test the copy of a null trace
201 new TmfTraceStub((TmfTraceStub
) null);
202 fail("Missing exception");
203 } catch (final IllegalArgumentException e
) {
205 } catch (final Exception e
) {
206 fail("Unexpected exception");
210 // ------------------------------------------------------------------------
211 // Trace initialization
212 // ------------------------------------------------------------------------
215 public void testInitializeNullPath() {
216 // Instantiate an "empty" trace
217 final TmfTraceStub trace
= new TmfTraceStub();
220 trace
.initialize(null, null, ITmfEvent
.class);
221 fail("TmfTrace.initialize() - no exception thrown");
222 } catch (TmfTraceException e
) {
224 } catch (Exception e
) {
225 fail("TmfTrace.initialize() - wrong exception thrown");
230 public void testInitializeSimplePath() {
231 // Instantiate an "empty" trace
232 final TmfTraceStub trace
= new TmfTraceStub();
234 // Path == trace name
235 String path
= "TraceName";
237 trace
.initialize(null, path
, ITmfEvent
.class);
238 } catch (Exception e
) {
239 fail("TmfTrace.initialize() - Exception thrown");
242 assertEquals("getEventType", ITmfEvent
.class, trace
.getEventType());
243 assertNull ("getResource", trace
.getResource());
244 assertEquals("getPath", path
, trace
.getPath());
245 assertEquals("getCacheSize", ITmfTrace
.DEFAULT_TRACE_CACHE_SIZE
, trace
.getCacheSize());
246 assertEquals("getStreamingInterval", 0, trace
.getStreamingInterval());
247 assertEquals("getName", path
, trace
.getName());
249 assertEquals("getNbEvents", 0, trace
.getNbEvents());
250 assertEquals("getRange-start", Long
.MIN_VALUE
, trace
.getTimeRange().getStartTime().getValue());
251 assertEquals("getRange-end", Long
.MIN_VALUE
, trace
.getTimeRange().getEndTime().getValue());
252 assertEquals("getStartTime", Long
.MIN_VALUE
, trace
.getStartTime().getValue());
253 assertEquals("getEndTime", Long
.MIN_VALUE
, trace
.getEndTime().getValue());
257 public void testInitializeNormalPath() {
258 // Instantiate an "empty" trace
259 final TmfTraceStub trace
= new TmfTraceStub();
261 // Path == trace name
262 String name
= "TraceName";
263 String path
= "/my/trace/path/" + name
;
265 trace
.initialize(null, path
, ITmfEvent
.class);
266 } catch (Exception e
) {
267 fail("TmfTrace.initialize() - Exception thrown");
270 assertEquals("getEventType", ITmfEvent
.class, trace
.getEventType());
271 assertNull ("getResource", trace
.getResource());
272 assertEquals("getPath", path
, trace
.getPath());
273 assertEquals("getCacheSize", ITmfTrace
.DEFAULT_TRACE_CACHE_SIZE
, trace
.getCacheSize());
274 assertEquals("getStreamingInterval", 0, trace
.getStreamingInterval());
275 assertEquals("getName", name
, trace
.getName());
277 assertEquals("getNbEvents", 0, trace
.getNbEvents());
278 assertEquals("getRange-start", Long
.MIN_VALUE
, trace
.getTimeRange().getStartTime().getValue());
279 assertEquals("getRange-end", Long
.MIN_VALUE
, trace
.getTimeRange().getEndTime().getValue());
280 assertEquals("getStartTime", Long
.MIN_VALUE
, trace
.getStartTime().getValue());
281 assertEquals("getEndTime", Long
.MIN_VALUE
, trace
.getEndTime().getValue());
285 public void testInitTrace() throws URISyntaxException
, IOException
, TmfTraceException
, InterruptedException
{
286 // Instantiate an "empty" trace
287 final TmfTraceStub trace
= new TmfTraceStub();
289 assertNull ("getEventType", trace
.getEventType());
290 assertNull ("getResource", trace
.getResource());
291 assertEquals("getCacheSize", ITmfTrace
.DEFAULT_TRACE_CACHE_SIZE
, trace
.getCacheSize());
292 assertEquals("getStreamingInterval", 0, trace
.getStreamingInterval());
293 assertEquals("getName", "", trace
.getName());
295 assertEquals("getNbEvents", 0, trace
.getNbEvents());
296 assertEquals("getRange-start", Long
.MIN_VALUE
, trace
.getTimeRange().getStartTime().getValue());
297 assertEquals("getRange-end", Long
.MIN_VALUE
, trace
.getTimeRange().getEndTime().getValue());
298 assertEquals("getStartTime", Long
.MIN_VALUE
, trace
.getStartTime().getValue());
299 assertEquals("getEndTime", Long
.MIN_VALUE
, trace
.getEndTime().getValue());
302 final URL location
= FileLocator
.find(TmfCoreTestPlugin
.getDefault().getBundle(), new Path(TEST_TRACE
.getFullPath()), null);
303 final File testfile
= new File(FileLocator
.toFileURL(location
).toURI());
304 assertTrue("validate", trace
.validate(null, testfile
.getPath()).isOK());
306 // InitTrace and wait for indexing completion...
307 trace
.initTrace(null, testfile
.toURI().getPath(), ITmfEvent
.class);
308 trace
.indexTrace(true);
310 while (trace
.getNbEvents() < NB_EVENTS
&& nbSecs
< 10) {
314 if (trace
.getNbEvents() < NB_EVENTS
) {
318 assertEquals("getEventType", ITmfEvent
.class, trace
.getEventType());
319 assertNull ("getResource", trace
.getResource());
320 assertEquals("getCacheSize", ITmfTrace
.DEFAULT_TRACE_CACHE_SIZE
, trace
.getCacheSize());
321 assertEquals("getStreamingInterval", 0, trace
.getStreamingInterval());
322 assertEquals("getName", TEST_TRACE
.getPath(), trace
.getName());
324 assertEquals("getNbEvents", NB_EVENTS
, trace
.getNbEvents());
325 assertEquals("getRange-start", 1, trace
.getTimeRange().getStartTime().getValue());
326 assertEquals("getRange-end", NB_EVENTS
, trace
.getTimeRange().getEndTime().getValue());
327 assertEquals("getStartTime", 1, trace
.getStartTime().getValue());
328 assertEquals("getEndTime", NB_EVENTS
, trace
.getEndTime().getValue());
331 // ------------------------------------------------------------------------
332 // Set/Get streaming interval
333 // ------------------------------------------------------------------------
336 public void testSetStreamingInterval() throws TmfTraceException
{
337 final TmfTraceStub trace
= new TmfTraceStub(fTrace
);
340 assertEquals("getStreamingInterval", interval
, trace
.getStreamingInterval());
343 trace
.setStreamingInterval(interval
);
344 assertEquals("getStreamingInterval", interval
, trace
.getStreamingInterval());
347 trace
.setStreamingInterval(interval
);
348 assertEquals("getStreamingInterval", 0, trace
.getStreamingInterval());
351 trace
.setStreamingInterval(interval
);
352 assertEquals("getStreamingInterval", interval
, trace
.getStreamingInterval());
357 // ------------------------------------------------------------------------
358 // Set/Get time range
359 // ------------------------------------------------------------------------
362 public void testSetTimeRange() throws TmfTraceException
{
363 final TmfTraceStub trace
= new TmfTraceStub(fTrace
);
364 trace
.indexTrace(true);
366 assertEquals("getRange-start", 1, trace
.getTimeRange().getStartTime().getValue());
367 assertEquals("getRange-end", NB_EVENTS
, trace
.getTimeRange().getEndTime().getValue());
368 assertEquals("getStartTime", 1, trace
.getStartTime().getValue());
369 assertEquals("getEndTime", NB_EVENTS
, trace
.getEndTime().getValue());
371 trace
.setTimeRange(new TmfTimeRange(new TmfTimestamp(100), new TmfTimestamp(200)));
372 assertEquals("setTimeRange", 100, trace
.getTimeRange().getStartTime().getValue());
373 assertEquals("setTimeRange", 200, trace
.getTimeRange().getEndTime().getValue());
374 assertEquals("setTimeRange", 100, trace
.getStartTime().getValue());
375 assertEquals("setTimeRange", 200, trace
.getEndTime().getValue());
381 public void testSetStartTime() throws TmfTraceException
{
382 final TmfTraceStub trace
= new TmfTraceStub(fTrace
);
383 trace
.indexTrace(true);
385 assertEquals("getRange-start", 1, trace
.getTimeRange().getStartTime().getValue());
386 assertEquals("getRange-end", NB_EVENTS
, trace
.getTimeRange().getEndTime().getValue());
387 assertEquals("getStartTime", 1, trace
.getStartTime().getValue());
388 assertEquals("getEndTime", NB_EVENTS
, trace
.getEndTime().getValue());
390 trace
.setStartTime(new TmfTimestamp(100));
391 assertEquals("setStartTime", 100, trace
.getTimeRange().getStartTime().getValue());
392 assertEquals("setStartTime", NB_EVENTS
, trace
.getTimeRange().getEndTime().getValue());
393 assertEquals("setStartTime", 100, trace
.getStartTime().getValue());
394 assertEquals("setStartTime", NB_EVENTS
, trace
.getEndTime().getValue());
400 public void testSetEndTime() throws TmfTraceException
{
401 final TmfTraceStub trace
= new TmfTraceStub(fTrace
);
402 trace
.indexTrace(true);
404 assertEquals("getRange-start", 1, trace
.getTimeRange().getStartTime().getValue());
405 assertEquals("getRange-end", NB_EVENTS
, trace
.getTimeRange().getEndTime().getValue());
406 assertEquals("getStartTime", 1, trace
.getStartTime().getValue());
407 assertEquals("getEndTime", NB_EVENTS
, trace
.getEndTime().getValue());
409 trace
.setEndTime(new TmfTimestamp(100));
410 assertEquals("setEndTime", 1, trace
.getTimeRange().getStartTime().getValue());
411 assertEquals("setEndTime", 100, trace
.getTimeRange().getEndTime().getValue());
412 assertEquals("setEndTime", 1, trace
.getStartTime().getValue());
413 assertEquals("setEndTime", 100, trace
.getEndTime().getValue());
419 public void testSetNbEvents() throws TmfTraceException
{
420 final TmfTraceStub trace
= new TmfTraceStub(fTrace
);
421 trace
.indexTrace(true);
423 assertEquals("getNbEvents", NB_EVENTS
, trace
.getNbEvents());
425 trace
.setNbEvents(0);
426 assertEquals("getNbEvents", 0, trace
.getNbEvents());
428 trace
.setNbEvents(-1);
429 assertEquals("getNbEvents", 0, trace
.getNbEvents());
431 trace
.setNbEvents(NB_EVENTS
+ 1);
432 assertEquals("getNbEvents", NB_EVENTS
+ 1, trace
.getNbEvents());
434 trace
.setNbEvents(NB_EVENTS
);
435 assertEquals("getNbEvents", NB_EVENTS
, trace
.getNbEvents());
440 // ------------------------------------------------------------------------
441 // State system, statistics and modules methods
442 // ------------------------------------------------------------------------
445 public void testGetModules() {
446 /* There should not be any modules at this point */
447 Iterable
<IAnalysisModule
> modules
= fTrace
.getAnalysisModules();
448 assertFalse(modules
.iterator().hasNext());
450 /* Open the trace, the modules should be populated */
451 fTrace
.traceOpened(new TmfTraceOpenedSignal(this, fTrace
, null));
453 modules
= fTrace
.getAnalysisModules();
454 assertTrue(modules
.iterator().hasNext());
457 * Make sure all modules of type TestAnalysis are returned in the second
461 for (IAnalysisModule module
: modules
) {
462 if (module
instanceof TestAnalysis
) {
464 IAnalysisModule otherModule
= fTrace
.getAnalysisModule(module
.getId());
465 assertNotNull(otherModule
);
466 assertEquals(otherModule
, module
);
470 * FIXME: The exact count depends on the context the test is run (full
471 * test suite or this file only), but there must be at least 2 modules
473 assertTrue(count
>= 2);
476 // ------------------------------------------------------------------------
477 // seekEvent on location (note: does not reliably set the rank)
478 // ------------------------------------------------------------------------
481 public void testSeekEventOnCacheBoundary() {
482 // Position trace at event rank 0
483 ITmfContext context
= fTrace
.seekEvent(0);
484 ITmfEvent event
= fTrace
.parseEvent(context
);
485 assertEquals("Event timestamp", 1, event
.getTimestamp().getValue());
486 assertEquals("Event rank", 0, context
.getRank());
488 context
= fTrace
.seekEvent(context
.getLocation());
489 assertEquals("Event rank", ITmfContext
.UNKNOWN_RANK
, context
.getRank());
491 event
= fTrace
.parseEvent(context
);
492 assertEquals("Event timestamp", 1, event
.getTimestamp().getValue());
493 assertEquals("Event rank", ITmfContext
.UNKNOWN_RANK
, context
.getRank());
495 event
= fTrace
.getNext(context
);
496 assertEquals("Event timestamp", 1, event
.getTimestamp().getValue());
497 assertEquals("Event rank", ITmfContext
.UNKNOWN_RANK
, context
.getRank());
499 // Position trace at event rank 1000
500 ITmfContext tmpContext
= fTrace
.seekEvent(new TmfTimestamp(1001, SCALE
));
501 context
= fTrace
.seekEvent(tmpContext
.getLocation());
502 assertEquals("Event rank", ITmfContext
.UNKNOWN_RANK
, context
.getRank());
504 event
= fTrace
.parseEvent(context
);
505 assertEquals("Event timestamp", 1001, event
.getTimestamp().getValue());
506 assertEquals("Event rank", ITmfContext
.UNKNOWN_RANK
, context
.getRank());
508 event
= fTrace
.getNext(context
);
509 assertEquals("Event timestamp", 1001, event
.getTimestamp().getValue());
510 assertEquals("Event rank", ITmfContext
.UNKNOWN_RANK
, context
.getRank());
512 // Position trace at event rank 4000
513 tmpContext
= fTrace
.seekEvent(new TmfTimestamp(4001, SCALE
));
514 context
= fTrace
.seekEvent(tmpContext
.getLocation());
515 assertEquals("Event rank", ITmfContext
.UNKNOWN_RANK
, context
.getRank());
517 event
= fTrace
.parseEvent(context
);
518 assertEquals("Event timestamp", 4001, event
.getTimestamp().getValue());
519 assertEquals("Event rank", ITmfContext
.UNKNOWN_RANK
, context
.getRank());
521 event
= fTrace
.getNext(context
);
522 assertEquals("Event timestamp", 4001, event
.getTimestamp().getValue());
523 assertEquals("Event rank", ITmfContext
.UNKNOWN_RANK
, context
.getRank());
527 public void testSeekEventNotOnCacheBoundary() {
528 // Position trace at event rank 9
529 ITmfContext tmpContext
= fTrace
.seekEvent(new TmfTimestamp(10, SCALE
));
530 TmfContext context
= fTrace
.seekEvent(tmpContext
.getLocation());
531 assertEquals("Event rank", ITmfContext
.UNKNOWN_RANK
, context
.getRank());
533 ITmfEvent event
= fTrace
.parseEvent(context
);
534 assertEquals("Event timestamp", 10, event
.getTimestamp().getValue());
535 assertEquals("Event rank", ITmfContext
.UNKNOWN_RANK
, context
.getRank());
537 event
= fTrace
.getNext(context
);
538 assertEquals("Event timestamp", 10, event
.getTimestamp().getValue());
539 assertEquals("Event rank", ITmfContext
.UNKNOWN_RANK
, context
.getRank());
541 // Position trace at event rank 999
542 tmpContext
= fTrace
.seekEvent(new TmfTimestamp(1000, SCALE
));
543 context
= fTrace
.seekEvent(tmpContext
.getLocation());
544 assertEquals("Event rank", ITmfContext
.UNKNOWN_RANK
, context
.getRank());
546 event
= fTrace
.parseEvent(context
);
547 assertEquals("Event timestamp", 1000, event
.getTimestamp().getValue());
548 assertEquals("Event rank", ITmfContext
.UNKNOWN_RANK
, context
.getRank());
550 event
= fTrace
.getNext(context
);
551 assertEquals("Event timestamp", 1000, event
.getTimestamp().getValue());
552 assertEquals("Event rank", ITmfContext
.UNKNOWN_RANK
, context
.getRank());
554 // Position trace at event rank 1001
555 tmpContext
= fTrace
.seekEvent(new TmfTimestamp(1002, SCALE
));
556 context
= fTrace
.seekEvent(tmpContext
.getLocation());
557 assertEquals("Event rank", ITmfContext
.UNKNOWN_RANK
, context
.getRank());
559 event
= fTrace
.parseEvent(context
);
560 assertEquals("Event timestamp", 1002, event
.getTimestamp().getValue());
561 assertEquals("Event rank", ITmfContext
.UNKNOWN_RANK
, context
.getRank());
563 event
= fTrace
.getNext(context
);
564 assertEquals("Event timestamp", 1002, event
.getTimestamp().getValue());
565 assertEquals("Event rank", ITmfContext
.UNKNOWN_RANK
, context
.getRank());
567 // Position trace at event rank 4500
568 tmpContext
= fTrace
.seekEvent(new TmfTimestamp(4501, SCALE
));
569 context
= fTrace
.seekEvent(tmpContext
.getLocation());
570 assertEquals("Event rank", ITmfContext
.UNKNOWN_RANK
, context
.getRank());
572 event
= fTrace
.parseEvent(context
);
573 assertEquals("Event timestamp", 4501, event
.getTimestamp().getValue());
574 assertEquals("Event rank", ITmfContext
.UNKNOWN_RANK
, context
.getRank());
576 event
= fTrace
.getNext(context
);
577 assertEquals("Event timestamp", 4501, event
.getTimestamp().getValue());
578 assertEquals("Event rank", ITmfContext
.UNKNOWN_RANK
, context
.getRank());
582 public void testSeekEventOutOfScope() {
583 // Position trace at beginning
584 ITmfContext tmpContext
= fTrace
.seekEvent(0);
585 ITmfContext context
= fTrace
.seekEvent(tmpContext
.getLocation());
586 assertEquals("Event rank", ITmfContext
.UNKNOWN_RANK
, context
.getRank());
588 ITmfEvent event
= fTrace
.parseEvent(context
);
589 assertEquals("Event timestamp", 1, event
.getTimestamp().getValue());
590 assertEquals("Event rank", ITmfContext
.UNKNOWN_RANK
, context
.getRank());
592 event
= fTrace
.getNext(context
);
593 assertEquals("Event timestamp", 1, event
.getTimestamp().getValue());
594 assertEquals("Event rank", ITmfContext
.UNKNOWN_RANK
, context
.getRank());
596 // Position trace at event passed the end
597 context
= fTrace
.seekEvent(new TmfTimestamp(NB_EVENTS
+ 1, SCALE
));
598 assertNull("Event timestamp", context
.getLocation());
599 assertEquals("Event rank", ITmfContext
.UNKNOWN_RANK
, context
.getRank());
601 event
= fTrace
.getNext(context
);
602 assertNull("Event", event
);
605 // ------------------------------------------------------------------------
606 // seekEvent on timestamp (note: does not reliably set the rank)
607 // ------------------------------------------------------------------------
610 public void testSeekEventOnNullTimestamp() {
611 // Position trace at event rank 0
612 ITmfContext context
= fTrace
.seekEvent((ITmfTimestamp
) null);
613 assertEquals("Event rank", 0, context
.getRank());
615 ITmfEvent event
= fTrace
.parseEvent(context
);
616 assertEquals("Event timestamp", 1, event
.getTimestamp().getValue());
617 assertEquals("Event rank", 0, context
.getRank());
621 public void testSeekEventOnTimestampOnCacheBoundary() {
622 // Position trace at event rank 0
623 ITmfContext context
= fTrace
.seekEvent(new TmfTimestamp(1, SCALE
));
624 assertEquals("Event rank", 0, context
.getRank());
626 ITmfEvent event
= fTrace
.parseEvent(context
);
627 assertEquals("Event timestamp", 1, event
.getTimestamp().getValue());
628 assertEquals("Event rank", 0, context
.getRank());
630 event
= fTrace
.getNext(context
);
631 assertEquals("Event timestamp", 1, event
.getTimestamp().getValue());
632 assertEquals("Event rank", 1, context
.getRank());
634 // Position trace at event rank 1000
635 context
= fTrace
.seekEvent(new TmfTimestamp(1001, SCALE
));
636 assertEquals("Event rank", 1000, context
.getRank());
638 event
= fTrace
.parseEvent(context
);
639 assertEquals("Event timestamp", 1001, event
.getTimestamp().getValue());
640 assertEquals("Event rank", 1000, context
.getRank());
642 event
= fTrace
.getNext(context
);
643 assertEquals("Event timestamp", 1001, event
.getTimestamp().getValue());
644 assertEquals("Event rank", 1001, context
.getRank());
646 // Position trace at event rank 4000
647 context
= fTrace
.seekEvent(new TmfTimestamp(4001, SCALE
));
648 assertEquals("Event rank", 4000, context
.getRank());
650 event
= fTrace
.parseEvent(context
);
651 assertEquals("Event timestamp", 4001, event
.getTimestamp().getValue());
652 assertEquals("Event rank", 4000, context
.getRank());
654 event
= fTrace
.getNext(context
);
655 assertEquals("Event timestamp", 4001, event
.getTimestamp().getValue());
656 assertEquals("Event rank", 4001, context
.getRank());
660 public void testSeekEventOnTimestampNotOnCacheBoundary() {
661 // Position trace at event rank 1
662 ITmfContext context
= fTrace
.seekEvent(new TmfTimestamp(2, SCALE
));
663 assertEquals("Event rank", 1, context
.getRank());
665 ITmfEvent event
= fTrace
.parseEvent(context
);
666 assertEquals("Event timestamp", 2, event
.getTimestamp().getValue());
667 assertEquals("Event rank", 1, context
.getRank());
669 event
= fTrace
.getNext(context
);
670 assertEquals("Event timestamp", 2, event
.getTimestamp().getValue());
671 assertEquals("Event rank", 2, context
.getRank());
673 // Position trace at event rank 9
674 context
= fTrace
.seekEvent(new TmfTimestamp(10, SCALE
));
675 assertEquals("Event rank", 9, context
.getRank());
677 event
= fTrace
.parseEvent(context
);
678 assertEquals("Event timestamp", 10, event
.getTimestamp().getValue());
679 assertEquals("Event rank", 9, context
.getRank());
681 event
= fTrace
.getNext(context
);
682 assertEquals("Event timestamp", 10, event
.getTimestamp().getValue());
683 assertEquals("Event rank", 10, context
.getRank());
685 // Position trace at event rank 999
686 context
= fTrace
.seekEvent(new TmfTimestamp(1000, SCALE
));
687 assertEquals("Event rank", 999, context
.getRank());
689 event
= fTrace
.parseEvent(context
);
690 assertEquals("Event timestamp", 1000, event
.getTimestamp().getValue());
691 assertEquals("Event rank", 999, context
.getRank());
693 event
= fTrace
.getNext(context
);
694 assertEquals("Event timestamp", 1000, event
.getTimestamp().getValue());
695 assertEquals("Event rank", 1000, context
.getRank());
697 // Position trace at event rank 1001
698 context
= fTrace
.seekEvent(new TmfTimestamp(1002, SCALE
));
699 assertEquals("Event rank", 1001, context
.getRank());
701 event
= fTrace
.parseEvent(context
);
702 assertEquals("Event timestamp", 1002, event
.getTimestamp().getValue());
703 assertEquals("Event rank", 1001, context
.getRank());
705 event
= fTrace
.getNext(context
);
706 assertEquals("Event timestamp", 1002, event
.getTimestamp().getValue());
707 assertEquals("Event rank", 1002, context
.getRank());
709 // Position trace at event rank 4500
710 context
= fTrace
.seekEvent(new TmfTimestamp(4501, SCALE
));
711 assertEquals("Event rank", 4500, context
.getRank());
713 event
= fTrace
.parseEvent(context
);
714 assertEquals("Event timestamp", 4501, event
.getTimestamp().getValue());
715 assertEquals("Event rank", 4500, context
.getRank());
717 event
= fTrace
.getNext(context
);
718 assertEquals("Event timestamp", 4501, event
.getTimestamp().getValue());
719 assertEquals("Event rank", 4501, context
.getRank());
723 public void testSeekEventOnTimestampOutOfScope() {
724 // Position trace at beginning
725 ITmfContext context
= fTrace
.seekEvent(new TmfTimestamp(-1, SCALE
));
726 assertEquals("Event rank", 0, context
.getRank());
728 ITmfEvent event
= fTrace
.parseEvent(context
);
729 assertEquals("Event timestamp", 1, event
.getTimestamp().getValue());
730 assertEquals("Event rank", 0, context
.getRank());
732 event
= fTrace
.getNext(context
);
733 assertEquals("Event timestamp", 1, event
.getTimestamp().getValue());
734 assertEquals("Event rank", 1, context
.getRank());
736 // Position trace at event passed the end
737 context
= fTrace
.seekEvent(new TmfTimestamp(NB_EVENTS
+ 1, SCALE
));
738 assertEquals("Event rank", ITmfContext
.UNKNOWN_RANK
, context
.getRank());
740 event
= fTrace
.parseEvent(context
);
741 assertEquals("Event timestamp", null, event
);
742 assertEquals("Event rank", ITmfContext
.UNKNOWN_RANK
, context
.getRank());
744 event
= fTrace
.getNext(context
);
745 assertEquals("Event timestamp", null, event
);
746 assertEquals("Event rank", ITmfContext
.UNKNOWN_RANK
, context
.getRank());
749 // ------------------------------------------------------------------------
751 // ------------------------------------------------------------------------
754 public void testSeekEventOnNegativeRank() {
755 // Position trace at event rank 0
756 ITmfContext context
= fTrace
.seekEvent(-1);
757 assertEquals("Event rank", 0, context
.getRank());
759 ITmfEvent event
= fTrace
.parseEvent(context
);
760 assertEquals("Event timestamp", 1, event
.getTimestamp().getValue());
761 assertEquals("Event rank", 0, context
.getRank());
765 public void testSeekOnRankOnCacheBoundary() {
766 // On lower bound, returns the first event (ts = 1)
767 ITmfContext context
= fTrace
.seekEvent(0);
768 assertEquals("Event rank", 0, context
.getRank());
770 ITmfEvent event
= fTrace
.parseEvent(context
);
771 assertEquals("Event timestamp", 1, event
.getTimestamp().getValue());
772 assertEquals("Event rank", 0, context
.getRank());
774 event
= fTrace
.getNext(context
);
775 assertEquals("Event timestamp", 1, event
.getTimestamp().getValue());
776 assertEquals("Event rank", 1, context
.getRank());
778 // Position trace at event rank 1000
779 context
= fTrace
.seekEvent(1000);
780 assertEquals("Event rank", 1000, context
.getRank());
782 event
= fTrace
.parseEvent(context
);
783 assertEquals("Event timestamp", 1001, event
.getTimestamp().getValue());
784 assertEquals("Event rank", 1000, context
.getRank());
786 event
= fTrace
.getNext(context
);
787 assertEquals("Event timestamp", 1001, event
.getTimestamp().getValue());
788 assertEquals("Event rank", 1001, context
.getRank());
790 // Position trace at event rank 4000
791 context
= fTrace
.seekEvent(4000);
792 assertEquals("Event rank", 4000, context
.getRank());
794 event
= fTrace
.parseEvent(context
);
795 assertEquals("Event timestamp", 4001, event
.getTimestamp().getValue());
796 assertEquals("Event rank", 4000, context
.getRank());
798 event
= fTrace
.getNext(context
);
799 assertEquals("Event timestamp", 4001, event
.getTimestamp().getValue());
800 assertEquals("Event rank", 4001, context
.getRank());
804 public void testSeekOnRankNotOnCacheBoundary() {
805 // Position trace at event rank 9
806 ITmfContext context
= fTrace
.seekEvent(9);
807 assertEquals("Event rank", 9, context
.getRank());
809 ITmfEvent event
= fTrace
.parseEvent(context
);
810 assertEquals("Event timestamp", 10, event
.getTimestamp().getValue());
811 assertEquals("Event rank", 9, context
.getRank());
813 event
= fTrace
.getNext(context
);
814 assertEquals("Event timestamp", 10, event
.getTimestamp().getValue());
815 assertEquals("Event rank", 10, context
.getRank());
817 // Position trace at event rank 999
818 context
= fTrace
.seekEvent(999);
819 assertEquals("Event rank", 999, context
.getRank());
821 event
= fTrace
.parseEvent(context
);
822 assertEquals("Event timestamp", 1000, event
.getTimestamp().getValue());
823 assertEquals("Event rank", 999, context
.getRank());
825 event
= fTrace
.getNext(context
);
826 assertEquals("Event timestamp", 1000, event
.getTimestamp().getValue());
827 assertEquals("Event rank", 1000, context
.getRank());
829 // Position trace at event rank 1001
830 context
= fTrace
.seekEvent(1001);
831 assertEquals("Event rank", 1001, context
.getRank());
833 event
= fTrace
.parseEvent(context
);
834 assertEquals("Event timestamp", 1002, event
.getTimestamp().getValue());
835 assertEquals("Event rank", 1001, context
.getRank());
837 event
= fTrace
.getNext(context
);
838 assertEquals("Event timestamp", 1002, event
.getTimestamp().getValue());
839 assertEquals("Event rank", 1002, context
.getRank());
841 // Position trace at event rank 4500
842 context
= fTrace
.seekEvent(4500);
843 assertEquals("Event rank", 4500, context
.getRank());
845 event
= fTrace
.parseEvent(context
);
846 assertEquals("Event timestamp", 4501, event
.getTimestamp().getValue());
847 assertEquals("Event rank", 4500, context
.getRank());
849 event
= fTrace
.getNext(context
);
850 assertEquals("Event timestamp", 4501, event
.getTimestamp().getValue());
851 assertEquals("Event rank", 4501, context
.getRank());
855 public void testSeekEventOnRankOutOfScope() {
856 // Position trace at beginning
857 ITmfContext context
= fTrace
.seekEvent(-1);
858 assertEquals("Event rank", 0, context
.getRank());
860 ITmfEvent event
= fTrace
.parseEvent(context
);
861 assertEquals("Event timestamp", 1, event
.getTimestamp().getValue());
862 assertEquals("Event rank", 0, context
.getRank());
864 event
= fTrace
.getNext(context
);
865 assertEquals("Event timestamp", 1, event
.getTimestamp().getValue());
866 assertEquals("Event rank", 1, context
.getRank());
868 // Position trace at event passed the end
869 context
= fTrace
.seekEvent(NB_EVENTS
);
870 assertEquals("Event rank", NB_EVENTS
, context
.getRank());
872 event
= fTrace
.parseEvent(context
);
873 assertNull("Event", event
);
874 assertEquals("Event rank", NB_EVENTS
, context
.getRank());
876 event
= fTrace
.getNext(context
);
877 assertNull("Event", event
);
878 assertEquals("Event rank", NB_EVENTS
, context
.getRank());
881 // ------------------------------------------------------------------------
882 // parseEvent - make sure parseEvent doesn't update the context
883 // ------------------------------------------------------------------------
886 public void testParseEvent() {
887 final int NB_READS
= 20;
889 // On lower bound, returns the first event (ts = 0)
890 final TmfContext context
= (TmfContext
) fTrace
.seekEvent(new TmfTimestamp(0, SCALE
));
891 TmfContext svContext
= new TmfContext(context
);
893 ITmfEvent event
= fTrace
.parseEvent(context
);
894 assertEquals("Event timestamp", 1, event
.getTimestamp().getValue());
895 assertEquals("Event rank", 0, context
.getRank());
896 assertTrue("parseEvent", context
.equals(svContext
));
898 event
= fTrace
.parseEvent(context
);
899 assertEquals("Event timestamp", 1, event
.getTimestamp().getValue());
900 assertEquals("Event rank", 0, context
.getRank());
901 assertTrue("parseEvent", context
.equals(svContext
));
903 event
= fTrace
.parseEvent(context
);
904 assertEquals("Event timestamp", 1, event
.getTimestamp().getValue());
905 assertEquals("Event rank", 0, context
.getRank());
906 assertTrue("parseEvent", context
.equals(svContext
));
908 // Position the trace at event NB_READS
909 for (int i
= 1; i
< NB_READS
; i
++) {
910 event
= fTrace
.getNext(context
);
911 assertEquals("Event timestamp", i
, event
.getTimestamp().getValue());
914 svContext
= new TmfContext(context
);
915 event
= fTrace
.parseEvent(context
);
916 assertEquals("Event timestamp", NB_READS
, event
.getTimestamp().getValue());
917 assertEquals("Event rank", NB_READS
-1 , context
.getRank());
918 assertTrue("parseEvent", context
.equals(svContext
));
920 event
= fTrace
.parseEvent(context
);
921 assertEquals("Event timestamp", NB_READS
, event
.getTimestamp().getValue());
922 assertEquals("Event rank", NB_READS
- 1, context
.getRank());
923 assertTrue("parseEvent", context
.equals(svContext
));
926 // ------------------------------------------------------------------------
927 // getNext - updates the context
928 // ------------------------------------------------------------------------
931 public void testGetNextAfteSeekingOnTS_1() {
932 final long INITIAL_TS
= 1;
933 final int NB_READS
= 20;
935 // On lower bound, returns the first event (ts = 1)
936 final ITmfContext context
= fTrace
.seekEvent(new TmfTimestamp(INITIAL_TS
, SCALE
));
940 for (int i
= 0; i
< NB_READS
; i
++) {
941 event
= fTrace
.getNext(context
);
942 assertEquals("Event timestamp", INITIAL_TS
+ i
, event
.getTimestamp().getValue());
943 assertEquals("Event rank", INITIAL_TS
+ i
, context
.getRank());
946 // Make sure we stay positioned
947 event
= fTrace
.parseEvent(context
);
948 assertEquals("Event timestamp", INITIAL_TS
+ NB_READS
, event
.getTimestamp().getValue());
949 assertEquals("Event rank", INITIAL_TS
+ NB_READS
- 1, context
.getRank());
953 public void testGetNextAfteSeekingOnTS_2() {
954 final long INITIAL_TS
= 2;
955 final int NB_READS
= 20;
957 // On lower bound, returns the first event (ts = 500)
958 final ITmfContext context
= fTrace
.seekEvent(new TmfTimestamp(INITIAL_TS
, SCALE
));
962 for (int i
= 0; i
< NB_READS
; i
++) {
963 event
= fTrace
.getNext(context
);
964 assertEquals("Event timestamp", INITIAL_TS
+ i
, event
.getTimestamp().getValue());
965 assertEquals("Event rank", INITIAL_TS
+ i
, context
.getRank());
968 // Make sure we stay positioned
969 event
= fTrace
.parseEvent(context
);
970 assertEquals("Event timestamp", INITIAL_TS
+ NB_READS
, event
.getTimestamp().getValue());
971 assertEquals("Event rank", INITIAL_TS
+ NB_READS
- 1, context
.getRank());
975 public void testGetNextAfteSeekingOnTS_3() {
976 final long INITIAL_TS
= 500;
977 final int NB_READS
= 20;
979 // On lower bound, returns the first event (ts = 500)
980 final ITmfContext context
= fTrace
.seekEvent(new TmfTimestamp(INITIAL_TS
, SCALE
));
984 for (int i
= 0; i
< NB_READS
; i
++) {
985 event
= fTrace
.getNext(context
);
986 assertEquals("Event timestamp", INITIAL_TS
+ i
, event
.getTimestamp().getValue());
987 assertEquals("Event rank", INITIAL_TS
+ i
, context
.getRank());
990 // Make sure we stay positioned
991 event
= fTrace
.parseEvent(context
);
992 assertEquals("Event timestamp", INITIAL_TS
+ NB_READS
, event
.getTimestamp().getValue());
993 assertEquals("Event rank", INITIAL_TS
+ NB_READS
- 1, context
.getRank());
997 public void testGetNextAfterSeekingOnRank_1() {
998 final long INITIAL_RANK
= 0L;
999 final int NB_READS
= 20;
1001 // On lower bound, returns the first event (rank = 0)
1002 final ITmfContext context
= fTrace
.seekEvent(INITIAL_RANK
);
1006 for (int i
= 0; i
< NB_READS
; i
++) {
1007 event
= fTrace
.getNext(context
);
1008 assertEquals("Event timestamp", INITIAL_RANK
+ i
+ 1, event
.getTimestamp().getValue());
1009 assertEquals("Event rank", INITIAL_RANK
+ i
+ 1, context
.getRank());
1012 // Make sure we stay positioned
1013 event
= fTrace
.parseEvent(context
);
1014 assertEquals("Event timestamp", INITIAL_RANK
+ NB_READS
+ 1, event
.getTimestamp().getValue());
1015 assertEquals("Event rank", INITIAL_RANK
+ NB_READS
, context
.getRank());
1019 public void testGetNextAfterSeekingOnRank_2() {
1020 final long INITIAL_RANK
= 1L;
1021 final int NB_READS
= 20;
1023 // On lower bound, returns the first event (rank = 0)
1024 final ITmfContext context
= fTrace
.seekEvent(INITIAL_RANK
);
1028 for (int i
= 0; i
< NB_READS
; i
++) {
1029 event
= fTrace
.getNext(context
);
1030 assertEquals("Event timestamp", INITIAL_RANK
+ i
+ 1, event
.getTimestamp().getValue());
1031 assertEquals("Event rank", INITIAL_RANK
+ i
+ 1, context
.getRank());
1034 // Make sure we stay positioned
1035 event
= fTrace
.parseEvent(context
);
1036 assertEquals("Event timestamp", INITIAL_RANK
+ NB_READS
+ 1, event
.getTimestamp().getValue());
1037 assertEquals("Event rank", INITIAL_RANK
+ NB_READS
, context
.getRank());
1041 public void testGetNextAfterSeekingOnRank_3() {
1042 final long INITIAL_RANK
= 500L;
1043 final int NB_READS
= 20;
1045 // On lower bound, returns the first event (rank = 0)
1046 final ITmfContext context
= fTrace
.seekEvent(INITIAL_RANK
);
1050 for (int i
= 0; i
< NB_READS
; i
++) {
1051 event
= fTrace
.getNext(context
);
1052 assertEquals("Event timestamp", INITIAL_RANK
+ i
+ 1, event
.getTimestamp().getValue());
1053 assertEquals("Event rank", INITIAL_RANK
+ i
+ 1, context
.getRank());
1056 // Make sure we stay positioned
1057 event
= fTrace
.parseEvent(context
);
1058 assertEquals("Event timestamp", INITIAL_RANK
+ NB_READS
+ 1, event
.getTimestamp().getValue());
1059 assertEquals("Event rank", INITIAL_RANK
+ NB_READS
, context
.getRank());
1063 public void testGetNextAfterSeekingOnLocation_1() {
1064 final ITmfLocation INITIAL_LOC
= null;
1065 final long INITIAL_TS
= 1;
1066 final int NB_READS
= 20;
1068 // On lower bound, returns the first event (ts = 1)
1069 final ITmfContext context
= fTrace
.seekEvent(INITIAL_LOC
);
1073 for (int i
= 0; i
< NB_READS
; i
++) {
1074 event
= fTrace
.getNext(context
);
1075 assertEquals("Event timestamp", INITIAL_TS
+ i
, event
.getTimestamp().getValue());
1076 assertEquals("Event rank", INITIAL_TS
+ i
, context
.getRank());
1079 // Make sure we stay positioned
1080 event
= fTrace
.parseEvent(context
);
1081 assertEquals("Event timestamp", INITIAL_TS
+ NB_READS
, event
.getTimestamp().getValue());
1082 assertEquals("Event rank", INITIAL_TS
+ NB_READS
- 1, context
.getRank());
1086 public void testGetNextAfterSeekingOnLocation_2() {
1087 final ITmfLocation INITIAL_LOC
= fTrace
.seekEvent(1L).getLocation();
1088 final long INITIAL_TS
= 2;
1089 final int NB_READS
= 20;
1091 // On lower bound, returns the first event (ts = 501)
1092 final ITmfContext context
= fTrace
.seekEvent(INITIAL_LOC
);
1096 for (int i
= 0; i
< NB_READS
; i
++) {
1097 event
= fTrace
.getNext(context
);
1098 assertEquals("Event timestamp", INITIAL_TS
+ i
, event
.getTimestamp().getValue());
1101 // Make sure we stay positioned
1102 event
= fTrace
.parseEvent(context
);
1103 assertEquals("Event timestamp", INITIAL_TS
+ NB_READS
, event
.getTimestamp().getValue());
1107 public void testGetNextAfterSeekingOnLocation_3() {
1108 final ITmfLocation INITIAL_LOC
= fTrace
.seekEvent(500L).getLocation();
1109 final long INITIAL_TS
= 501;
1110 final int NB_READS
= 20;
1112 // On lower bound, returns the first event (ts = 501)
1113 final ITmfContext context
= fTrace
.seekEvent(INITIAL_LOC
);
1117 for (int i
= 0; i
< NB_READS
; i
++) {
1118 event
= fTrace
.getNext(context
);
1119 assertEquals("Event timestamp", INITIAL_TS
+ i
, event
.getTimestamp().getValue());
1122 // Make sure we stay positioned
1123 event
= fTrace
.parseEvent(context
);
1124 assertEquals("Event timestamp", INITIAL_TS
+ NB_READS
, event
.getTimestamp().getValue());
1128 public void testGetNextLocation() {
1129 ITmfContext context1
= fTrace
.seekEvent(0);
1130 fTrace
.getNext(context1
);
1131 ITmfLocation location
= context1
.getLocation();
1132 ITmfEvent event1
= fTrace
.getNext(context1
);
1133 ITmfContext context2
= fTrace
.seekEvent(location
);
1134 ITmfEvent event2
= fTrace
.getNext(context2
);
1135 assertEquals("Event timestamp", event1
.getTimestamp().getValue(), event2
.getTimestamp().getValue());
1139 public void testGetNextEndLocation() {
1140 ITmfContext context1
= fTrace
.seekEvent(fTrace
.getNbEvents() - 1);
1141 fTrace
.getNext(context1
);
1142 ITmfLocation location
= context1
.getLocation();
1143 ITmfContext context2
= fTrace
.seekEvent(location
);
1144 ITmfEvent event
= fTrace
.getNext(context2
);
1145 assertNull("Event", event
);
1148 // ------------------------------------------------------------------------
1150 // ------------------------------------------------------------------------
1153 public void testProcessEventRequestForAllEvents() throws InterruptedException
{
1154 final Vector
<ITmfEvent
> requestedEvents
= new Vector
<>();
1156 final TmfTimeRange range
= new TmfTimeRange(TmfTimestamp
.BIG_BANG
, TmfTimestamp
.BIG_CRUNCH
);
1157 final TmfEventRequest request
= new TmfEventRequest(ITmfEvent
.class,
1158 range
, 0, NB_EVENTS
, ExecutionType
.FOREGROUND
) {
1160 public void handleData(final ITmfEvent event
) {
1161 super.handleData(event
);
1162 requestedEvents
.add(event
);
1165 final ITmfEventProvider
[] providers
= TmfProviderManager
.getProviders(ITmfEvent
.class, TmfTraceStub
.class);
1166 providers
[0].sendRequest(request
);
1167 request
.waitForCompletion();
1169 assertEquals("nbEvents", NB_EVENTS
, requestedEvents
.size());
1170 assertTrue("isCompleted", request
.isCompleted());
1171 assertFalse("isCancelled", request
.isCancelled());
1173 // Ensure that we have distinct events.
1174 // Don't go overboard: we are not validating the stub!
1175 for (int i
= 0; i
< NB_EVENTS
; i
++) {
1176 assertEquals("Distinct events", i
+ 1, requestedEvents
.get(i
).getTimestamp().getValue());
1181 public void testProcessEventRequestForNbEvents() throws InterruptedException
{
1182 final int nbEvents
= 1000;
1183 final Vector
<ITmfEvent
> requestedEvents
= new Vector
<>();
1185 final TmfTimeRange range
= new TmfTimeRange(TmfTimestamp
.BIG_BANG
, TmfTimestamp
.BIG_CRUNCH
);
1186 final TmfEventRequest request
= new TmfEventRequest(ITmfEvent
.class,
1187 range
, 0, nbEvents
, ExecutionType
.FOREGROUND
) {
1189 public void handleData(final ITmfEvent event
) {
1190 super.handleData(event
);
1191 requestedEvents
.add(event
);
1194 final ITmfEventProvider
[] providers
= TmfProviderManager
.getProviders(ITmfEvent
.class, TmfTraceStub
.class);
1195 providers
[0].sendRequest(request
);
1196 request
.waitForCompletion();
1198 assertEquals("nbEvents", nbEvents
, requestedEvents
.size());
1199 assertTrue("isCompleted", request
.isCompleted());
1200 assertFalse("isCancelled", request
.isCancelled());
1202 // Ensure that we have distinct events.
1203 // Don't go overboard: we are not validating the stub!
1204 for (int i
= 0; i
< nbEvents
; i
++) {
1205 assertEquals("Distinct events", i
+ 1, requestedEvents
.get(i
).getTimestamp().getValue());
1210 public void testProcessEventRequestForSomeEvents() throws InterruptedException
{
1211 final long startTime
= 100;
1212 final int nbEvents
= 1000;
1213 final Vector
<ITmfEvent
> requestedEvents
= new Vector
<>();
1215 final TmfTimeRange range
= new TmfTimeRange(new TmfTimestamp(startTime
, SCALE
), TmfTimestamp
.BIG_CRUNCH
);
1216 final TmfEventRequest request
= new TmfEventRequest(ITmfEvent
.class,
1217 range
, 0, nbEvents
, ExecutionType
.FOREGROUND
) {
1219 public void handleData(final ITmfEvent event
) {
1220 super.handleData(event
);
1221 requestedEvents
.add(event
);
1224 final ITmfEventProvider
[] providers
= TmfProviderManager
.getProviders(ITmfEvent
.class, TmfTraceStub
.class);
1225 providers
[0].sendRequest(request
);
1226 request
.waitForCompletion();
1228 assertEquals("nbEvents", nbEvents
, requestedEvents
.size());
1229 assertTrue("isCompleted", request
.isCompleted());
1230 assertFalse("isCancelled", request
.isCancelled());
1232 // Ensure that we have distinct events.
1233 // Don't go overboard: we are not validating the stub!
1234 for (int i
= 0; i
< nbEvents
; i
++) {
1235 assertEquals("Distinct events", startTime
+ i
, requestedEvents
.get(i
).getTimestamp().getValue());
1240 public void testProcessEventRequestForOtherEvents() throws InterruptedException
{
1241 final int startIndex
= 99;
1242 final long startTime
= 100;
1243 final int nbEvents
= 1000;
1244 final Vector
<ITmfEvent
> requestedEvents
= new Vector
<>();
1246 final TmfTimeRange range
= new TmfTimeRange(new TmfTimestamp(startTime
, SCALE
), TmfTimestamp
.BIG_CRUNCH
);
1247 final TmfEventRequest request
= new TmfEventRequest(ITmfEvent
.class,
1248 range
, startIndex
, nbEvents
, ExecutionType
.FOREGROUND
) {
1250 public void handleData(final ITmfEvent event
) {
1251 super.handleData(event
);
1252 requestedEvents
.add(event
);
1255 final ITmfEventProvider
[] providers
= TmfProviderManager
.getProviders(ITmfEvent
.class, TmfTraceStub
.class);
1256 providers
[0].sendRequest(request
);
1257 request
.waitForCompletion();
1259 assertEquals("nbEvents", nbEvents
, requestedEvents
.size());
1260 assertTrue("isCompleted", request
.isCompleted());
1261 assertFalse("isCancelled", request
.isCancelled());
1263 // Ensure that we have distinct events.
1264 // Don't go overboard: we are not validating the stub!
1265 for (int i
= 0; i
< nbEvents
; i
++) {
1266 assertEquals("Distinct events", startTime
+ i
, requestedEvents
.get(i
).getTimestamp().getValue());
1271 public void testProcessDataRequestForSomeEvents() throws InterruptedException
{
1272 final int startIndex
= 100;
1273 final int nbEvents
= 1000;
1274 final Vector
<ITmfEvent
> requestedEvents
= new Vector
<>();
1276 final TmfEventRequest request
= new TmfEventRequest(ITmfEvent
.class,
1277 TmfTimeRange
.ETERNITY
,
1280 TmfEventRequest
.ExecutionType
.FOREGROUND
) {
1282 public void handleData(final ITmfEvent event
) {
1283 super.handleData(event
);
1284 requestedEvents
.add(event
);
1287 final ITmfEventProvider
[] providers
= TmfProviderManager
.getProviders(ITmfEvent
.class, TmfTraceStub
.class);
1288 providers
[0].sendRequest(request
);
1289 request
.waitForCompletion();
1291 assertEquals("nbEvents", nbEvents
, requestedEvents
.size());
1292 assertTrue("isCompleted", request
.isCompleted());
1293 assertFalse("isCancelled", request
.isCancelled());
1295 // Ensure that we have distinct events.
1296 // Don't go overboard: we are not validating the stub!
1297 for (int i
= 0; i
< nbEvents
; i
++) {
1298 assertEquals("Distinct events", startIndex
+ 1 + i
, requestedEvents
.get(i
).getTimestamp().getValue());
1302 // ------------------------------------------------------------------------
1304 // ------------------------------------------------------------------------
1307 public void testCancel() throws InterruptedException
{
1308 final int limit
= 500;
1309 final Vector
<ITmfEvent
> requestedEvents
= new Vector
<>();
1311 final TmfTimeRange range
= new TmfTimeRange(TmfTimestamp
.BIG_BANG
, TmfTimestamp
.BIG_CRUNCH
);
1312 final TmfEventRequest request
= new TmfEventRequest(ITmfEvent
.class,
1313 range
, 0, NB_EVENTS
, ExecutionType
.FOREGROUND
) {
1317 public void handleData(final ITmfEvent event
) {
1318 super.handleData(event
);
1319 requestedEvents
.add(event
);
1320 if (++nbRead
== limit
) {
1325 final ITmfEventProvider
[] providers
= TmfProviderManager
.getProviders(ITmfEvent
.class, TmfTraceStub
.class);
1326 providers
[0].sendRequest(request
);
1327 request
.waitForCompletion();
1329 assertEquals("nbEvents", limit
, requestedEvents
.size());
1330 assertTrue("isCompleted", request
.isCompleted());
1331 assertTrue("isCancelled", request
.isCancelled());
1334 // ------------------------------------------------------------------------
1336 // ------------------------------------------------------------------------
1339 public void testDefaultTmfTraceStub() {
1340 assertFalse ("Open trace", fTrace
== null);
1341 assertEquals("getEventType", ITmfEvent
.class, fTrace
.getEventType());
1342 assertNull ("getResource", fTrace
.getResource());
1343 assertEquals("getStreamingInterval", 0, fTrace
.getStreamingInterval());
1344 assertEquals("getName", TEST_TRACE
.getPath(), fTrace
.getName());
1346 assertEquals("getNbEvents", NB_EVENTS
, fTrace
.getNbEvents());
1347 assertEquals("getRange-start", 1, fTrace
.getTimeRange().getStartTime().getValue());
1348 assertEquals("getRange-end", NB_EVENTS
, fTrace
.getTimeRange().getEndTime().getValue());
1349 assertEquals("getStartTime", 1, fTrace
.getStartTime().getValue());
1350 assertEquals("getEndTime", NB_EVENTS
, fTrace
.getEndTime().getValue());
1352 String expected
= "TmfTrace [fPath=" + fTrace
.getPath() + ", fCacheSize=" + fTrace
.getCacheSize() +
1353 ", fNbEvents=" + fTrace
.getNbEvents() + ", fStartTime=" + fTrace
.getStartTime() +
1354 ", fEndTime=" + fTrace
.getEndTime() + ", fStreamingInterval=" + fTrace
.getStreamingInterval() +
1356 assertEquals("toString", expected
, fTrace
.toString());
1359 // ------------------------------------------------------------------------
1360 // getInitialRangeOffset, getCurrentRange, getCurrentTime
1361 // ------------------------------------------------------------------------
1364 public void testCurrentTimeValues() throws TmfTraceException
{
1366 TmfTraceStub trace
= null;
1367 File testfile
= null;
1369 final URL location
= FileLocator
.find(TmfCoreTestPlugin
.getDefault().getBundle(), new Path(TEST_TRACE
.getFullPath()), null);
1370 testfile
= new File(FileLocator
.toFileURL(location
).toURI());
1371 trace
= new TmfTraceStub(testfile
.toURI().getPath(), ITmfTrace
.DEFAULT_TRACE_CACHE_SIZE
, false, null);
1372 // verify initial values
1373 TmfTimestamp defaultInitRange
= new TmfTimestamp(DEFAULT_INITIAL_OFFSET_VALUE
, ITmfTimestamp
.NANOSECOND_SCALE
);
1374 assertEquals("getInitialRangeOffset", defaultInitRange
, trace
.getInitialRangeOffset());
1375 trace
.setInitialRangeOffset(new TmfTimestamp(5, ITmfTimestamp
.MILLISECOND_SCALE
));
1376 trace
.indexTrace(true);
1378 TmfTimestamp initRange
= new TmfTimestamp(5, ITmfTimestamp
.MILLISECOND_SCALE
);
1379 assertEquals("getInitialRangeOffset", initRange
, trace
.getInitialRangeOffset());
1381 } catch (final URISyntaxException e
) {
1382 fail("URISyntaxException");
1383 } catch (final IOException e
) {
1384 fail("IOException");
1388 // ------------------------------------------------------------------------
1390 // ------------------------------------------------------------------------
1393 * Run the String getHostId() method test
1396 public void testTraceHostId() {
1397 String a
= fTrace
.getHostId();
1398 assertEquals("A-Test-10K", a
);
1402 * Test the {@link TmfTrace#getEventAspects} method.
1405 public void testGetEventAspects() {
1406 Iterable
<ITmfEventAspect
> aspects
= fTrace
.getEventAspects();
1407 for (ITmfEventAspect aspect
: aspects
) {
1408 assertTrue(TmfTrace
.BASE_ASPECTS
.contains(aspect
));