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
.linuxtools
.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
;
30 import org
.eclipse
.core
.runtime
.FileLocator
;
31 import org
.eclipse
.core
.runtime
.Path
;
32 import org
.eclipse
.linuxtools
.internal
.tmf
.core
.component
.TmfProviderManager
;
33 import org
.eclipse
.linuxtools
.tmf
.core
.analysis
.IAnalysisModule
;
34 import org
.eclipse
.linuxtools
.tmf
.core
.component
.ITmfEventProvider
;
35 import org
.eclipse
.linuxtools
.tmf
.core
.event
.ITmfEvent
;
36 import org
.eclipse
.linuxtools
.tmf
.core
.exceptions
.TmfTraceException
;
37 import org
.eclipse
.linuxtools
.tmf
.core
.request
.ITmfEventRequest
.ExecutionType
;
38 import org
.eclipse
.linuxtools
.tmf
.core
.request
.TmfEventRequest
;
39 import org
.eclipse
.linuxtools
.tmf
.core
.signal
.TmfSignalManager
;
40 import org
.eclipse
.linuxtools
.tmf
.core
.signal
.TmfTraceOpenedSignal
;
41 import org
.eclipse
.linuxtools
.tmf
.core
.tests
.TmfCoreTestPlugin
;
42 import org
.eclipse
.linuxtools
.tmf
.core
.tests
.shared
.TmfTestTrace
;
43 import org
.eclipse
.linuxtools
.tmf
.core
.timestamp
.ITmfTimestamp
;
44 import org
.eclipse
.linuxtools
.tmf
.core
.timestamp
.TmfTimeRange
;
45 import org
.eclipse
.linuxtools
.tmf
.core
.timestamp
.TmfTimestamp
;
46 import org
.eclipse
.linuxtools
.tmf
.core
.trace
.ITmfContext
;
47 import org
.eclipse
.linuxtools
.tmf
.core
.trace
.ITmfTrace
;
48 import org
.eclipse
.linuxtools
.tmf
.core
.trace
.TmfContext
;
49 import org
.eclipse
.linuxtools
.tmf
.core
.trace
.location
.ITmfLocation
;
50 import org
.eclipse
.linuxtools
.tmf
.tests
.stubs
.analysis
.TestAnalysis
;
51 import org
.eclipse
.linuxtools
.tmf
.tests
.stubs
.trace
.TmfTraceStub
;
52 import org
.junit
.After
;
53 import org
.junit
.Before
;
54 import org
.junit
.Rule
;
55 import org
.junit
.Test
;
56 import org
.junit
.rules
.TestRule
;
57 import org
.junit
.rules
.Timeout
;
60 * Test suite for the TmfTrace class.
62 @SuppressWarnings("javadoc")
63 public class TmfTraceTest
{
65 /** Time-out tests after 20 seconds */
67 public TestRule globalTimeout
= new Timeout(20000);
69 // ------------------------------------------------------------------------
71 // ------------------------------------------------------------------------
73 private static final TmfTestTrace TEST_TRACE
= TmfTestTrace
.A_TEST_10K
;
74 private static final long DEFAULT_INITIAL_OFFSET_VALUE
= (1L * 100 * 1000 * 1000); // .1sec
75 private static final int NB_EVENTS
= 10000;
76 private TmfTraceStub fTrace
= null;
78 private static int SCALE
= -3;
80 // ------------------------------------------------------------------------
82 // ------------------------------------------------------------------------
87 final URL location
= FileLocator
.find(TmfCoreTestPlugin
.getDefault().getBundle(), new Path(TEST_TRACE
.getFullPath()), null);
88 final File test
= new File(FileLocator
.toFileURL(location
).toURI());
89 fTrace
= new TmfTraceStub(test
.toURI().getPath(), ITmfTrace
.DEFAULT_TRACE_CACHE_SIZE
, false, null);
90 TmfSignalManager
.deregister(fTrace
);
91 fTrace
.indexTrace(true);
92 } catch (final TmfTraceException e
) {
94 } catch (final URISyntaxException e
) {
96 } catch (final IOException e
) {
102 public void tearDown() {
107 // ------------------------------------------------------------------------
109 // ------------------------------------------------------------------------
112 public void testFullConstructor() throws TmfTraceException
{
114 final URL location
= FileLocator
.find(TmfCoreTestPlugin
.getDefault().getBundle(), new Path(TEST_TRACE
.getFullPath()), null);
115 File testfile
= new File(FileLocator
.toFileURL(location
).toURI());
116 TmfTraceStub trace
= new TmfTraceStub(testfile
.toURI().getPath(), ITmfTrace
.DEFAULT_TRACE_CACHE_SIZE
, false, null);
117 trace
.indexTrace(true);
119 assertEquals("getType", ITmfEvent
.class, trace
.getType());
120 assertNull("getResource", trace
.getResource());
121 assertEquals("getPath", testfile
.toURI().getPath(), trace
.getPath());
122 assertEquals("getCacheSize", ITmfTrace
.DEFAULT_TRACE_CACHE_SIZE
, trace
.getCacheSize());
123 assertEquals("getStreamingInterval", 0, trace
.getStreamingInterval());
124 assertEquals("getName", TEST_TRACE
.getPath(), trace
.getName());
126 assertEquals("getNbEvents", NB_EVENTS
, trace
.getNbEvents());
127 assertEquals("getRange-start", 1, trace
.getTimeRange().getStartTime().getValue());
128 assertEquals("getRange-end", NB_EVENTS
, trace
.getTimeRange().getEndTime().getValue());
129 assertEquals("getStartTime", 1, trace
.getStartTime().getValue());
130 assertEquals("getEndTime", NB_EVENTS
, trace
.getEndTime().getValue());
132 } catch (final URISyntaxException e
) {
133 fail("URISyntaxException");
134 } catch (final IOException e
) {
140 public void testLiveTraceConstructor() throws TmfTraceException
{
141 final long interval
= 100;
143 final URL location
= FileLocator
.find(TmfCoreTestPlugin
.getDefault().getBundle(), new Path(TEST_TRACE
.getFullPath()), null);
144 File testfile
= new File(FileLocator
.toFileURL(location
).toURI());
145 TmfTraceStub trace
= new TmfTraceStub(testfile
.toURI().getPath(), ITmfTrace
.DEFAULT_TRACE_CACHE_SIZE
, interval
);
146 trace
.indexTrace(true);
148 assertEquals("getType", ITmfEvent
.class, trace
.getType());
149 assertNull("getResource", trace
.getResource());
150 assertEquals("getPath", testfile
.toURI().getPath(), trace
.getPath());
151 assertEquals("getCacheSize", ITmfTrace
.DEFAULT_TRACE_CACHE_SIZE
, trace
.getCacheSize());
152 assertEquals("getStreamingInterval", interval
, trace
.getStreamingInterval());
153 assertEquals("getName", TEST_TRACE
.getPath(), trace
.getName());
155 assertEquals("getNbEvents", NB_EVENTS
, trace
.getNbEvents());
156 assertEquals("getRange-start", 1, trace
.getTimeRange().getStartTime().getValue());
157 assertEquals("getRange-end", NB_EVENTS
, trace
.getTimeRange().getEndTime().getValue());
158 assertEquals("getStartTime", 1, trace
.getStartTime().getValue());
159 assertEquals("getEndTime", NB_EVENTS
, trace
.getEndTime().getValue());
161 } catch (final URISyntaxException e
) {
162 fail("URISyntaxException");
163 } catch (final IOException e
) {
169 public void testCopyConstructor() throws TmfTraceException
{
171 final URL location
= FileLocator
.find(TmfCoreTestPlugin
.getDefault().getBundle(), new Path(TEST_TRACE
.getFullPath()), null);
172 File testfile
= new File(FileLocator
.toFileURL(location
).toURI());
173 TmfTraceStub original
= new TmfTraceStub(testfile
.toURI().getPath(), ITmfTrace
.DEFAULT_TRACE_CACHE_SIZE
, false, null);
174 TmfTraceStub trace
= new TmfTraceStub(original
);
175 trace
.indexTrace(true);
177 assertEquals("getType", ITmfEvent
.class, trace
.getType());
178 assertNull("getResource", trace
.getResource());
179 assertEquals("getPath", testfile
.toURI().getPath(), trace
.getPath());
180 assertEquals("getCacheSize", ITmfTrace
.DEFAULT_TRACE_CACHE_SIZE
, trace
.getCacheSize());
181 assertEquals("getStreamingInterval", 0, trace
.getStreamingInterval());
182 assertEquals("getName", TEST_TRACE
.getPath(), trace
.getName());
184 assertEquals("getNbEvents", NB_EVENTS
, trace
.getNbEvents());
185 assertEquals("getRange-start", 1, trace
.getTimeRange().getStartTime().getValue());
186 assertEquals("getRange-end", NB_EVENTS
, trace
.getTimeRange().getEndTime().getValue());
187 assertEquals("getStartTime", 1, trace
.getStartTime().getValue());
188 assertEquals("getEndTime", NB_EVENTS
, trace
.getEndTime().getValue());
190 } catch (final URISyntaxException e
) {
191 fail("URISyntaxException");
192 } catch (final IOException e
) {
196 // Test the copy of a null trace
198 new TmfTraceStub((TmfTraceStub
) null);
199 fail("Missing exception");
200 } catch (final IllegalArgumentException e
) {
202 } catch (final Exception e
) {
203 fail("Unexpected exception");
207 // ------------------------------------------------------------------------
208 // Trace initialization
209 // ------------------------------------------------------------------------
212 public void testInitializeNullPath() {
213 // Instantiate an "empty" trace
214 final TmfTraceStub trace
= new TmfTraceStub();
217 trace
.initialize(null, null, ITmfEvent
.class);
218 fail("TmfTrace.initialize() - no exception thrown");
219 } catch (TmfTraceException e
) {
221 } catch (Exception e
) {
222 fail("TmfTrace.initialize() - wrong exception thrown");
227 public void testInitializeSimplePath() {
228 // Instantiate an "empty" trace
229 final TmfTraceStub trace
= new TmfTraceStub();
231 // Path == trace name
232 String path
= "TraceName";
234 trace
.initialize(null, path
, ITmfEvent
.class);
235 } catch (Exception e
) {
236 fail("TmfTrace.initialize() - Exception thrown");
239 assertEquals("getType", ITmfEvent
.class, trace
.getType());
240 assertNull ("getResource", trace
.getResource());
241 assertEquals("getPath", path
, trace
.getPath());
242 assertEquals("getCacheSize", ITmfTrace
.DEFAULT_TRACE_CACHE_SIZE
, trace
.getCacheSize());
243 assertEquals("getStreamingInterval", 0, trace
.getStreamingInterval());
244 assertEquals("getName", path
, trace
.getName());
246 assertEquals("getNbEvents", 0, trace
.getNbEvents());
247 assertEquals("getRange-start", Long
.MIN_VALUE
, trace
.getTimeRange().getStartTime().getValue());
248 assertEquals("getRange-end", Long
.MIN_VALUE
, trace
.getTimeRange().getEndTime().getValue());
249 assertEquals("getStartTime", Long
.MIN_VALUE
, trace
.getStartTime().getValue());
250 assertEquals("getEndTime", Long
.MIN_VALUE
, trace
.getEndTime().getValue());
254 public void testInitializeNormalPath() {
255 // Instantiate an "empty" trace
256 final TmfTraceStub trace
= new TmfTraceStub();
258 // Path == trace name
259 String name
= "TraceName";
260 String path
= "/my/trace/path/" + name
;
262 trace
.initialize(null, path
, ITmfEvent
.class);
263 } catch (Exception e
) {
264 fail("TmfTrace.initialize() - Exception thrown");
267 assertEquals("getType", ITmfEvent
.class, trace
.getType());
268 assertNull ("getResource", trace
.getResource());
269 assertEquals("getPath", path
, trace
.getPath());
270 assertEquals("getCacheSize", ITmfTrace
.DEFAULT_TRACE_CACHE_SIZE
, trace
.getCacheSize());
271 assertEquals("getStreamingInterval", 0, trace
.getStreamingInterval());
272 assertEquals("getName", name
, trace
.getName());
274 assertEquals("getNbEvents", 0, trace
.getNbEvents());
275 assertEquals("getRange-start", Long
.MIN_VALUE
, trace
.getTimeRange().getStartTime().getValue());
276 assertEquals("getRange-end", Long
.MIN_VALUE
, trace
.getTimeRange().getEndTime().getValue());
277 assertEquals("getStartTime", Long
.MIN_VALUE
, trace
.getStartTime().getValue());
278 assertEquals("getEndTime", Long
.MIN_VALUE
, trace
.getEndTime().getValue());
282 public void testInitTrace() throws URISyntaxException
, IOException
, TmfTraceException
, InterruptedException
{
283 // Instantiate an "empty" trace
284 final TmfTraceStub trace
= new TmfTraceStub();
286 assertNull ("getType", trace
.getType());
287 assertNull ("getResource", trace
.getResource());
288 assertEquals("getCacheSize", ITmfTrace
.DEFAULT_TRACE_CACHE_SIZE
, trace
.getCacheSize());
289 assertEquals("getStreamingInterval", 0, trace
.getStreamingInterval());
290 assertEquals("getName", "", trace
.getName());
292 assertEquals("getNbEvents", 0, trace
.getNbEvents());
293 assertEquals("getRange-start", Long
.MIN_VALUE
, trace
.getTimeRange().getStartTime().getValue());
294 assertEquals("getRange-end", Long
.MIN_VALUE
, trace
.getTimeRange().getEndTime().getValue());
295 assertEquals("getStartTime", Long
.MIN_VALUE
, trace
.getStartTime().getValue());
296 assertEquals("getEndTime", Long
.MIN_VALUE
, trace
.getEndTime().getValue());
299 final URL location
= FileLocator
.find(TmfCoreTestPlugin
.getDefault().getBundle(), new Path(TEST_TRACE
.getFullPath()), null);
300 final File testfile
= new File(FileLocator
.toFileURL(location
).toURI());
301 assertTrue("validate", trace
.validate(null, testfile
.getPath()).isOK());
303 // InitTrace and wait for indexing completion...
304 trace
.initTrace(null, testfile
.toURI().getPath(), ITmfEvent
.class);
305 trace
.indexTrace(true);
307 while (trace
.getNbEvents() < NB_EVENTS
&& nbSecs
< 10) {
311 if (trace
.getNbEvents() < NB_EVENTS
) {
315 assertEquals("getType", ITmfEvent
.class, trace
.getType());
316 assertNull ("getResource", trace
.getResource());
317 assertEquals("getCacheSize", ITmfTrace
.DEFAULT_TRACE_CACHE_SIZE
, trace
.getCacheSize());
318 assertEquals("getStreamingInterval", 0, trace
.getStreamingInterval());
319 assertEquals("getName", TEST_TRACE
.getPath(), trace
.getName());
321 assertEquals("getNbEvents", NB_EVENTS
, trace
.getNbEvents());
322 assertEquals("getRange-start", 1, trace
.getTimeRange().getStartTime().getValue());
323 assertEquals("getRange-end", NB_EVENTS
, trace
.getTimeRange().getEndTime().getValue());
324 assertEquals("getStartTime", 1, trace
.getStartTime().getValue());
325 assertEquals("getEndTime", NB_EVENTS
, trace
.getEndTime().getValue());
328 // ------------------------------------------------------------------------
329 // Set/Get streaming interval
330 // ------------------------------------------------------------------------
333 public void testSetStreamingInterval() throws TmfTraceException
{
334 final TmfTraceStub trace
= new TmfTraceStub(fTrace
);
337 assertEquals("getStreamingInterval", interval
, trace
.getStreamingInterval());
340 trace
.setStreamingInterval(interval
);
341 assertEquals("getStreamingInterval", interval
, trace
.getStreamingInterval());
344 trace
.setStreamingInterval(interval
);
345 assertEquals("getStreamingInterval", 0, trace
.getStreamingInterval());
348 trace
.setStreamingInterval(interval
);
349 assertEquals("getStreamingInterval", interval
, trace
.getStreamingInterval());
354 // ------------------------------------------------------------------------
355 // Set/Get time range
356 // ------------------------------------------------------------------------
359 public void testSetTimeRange() throws TmfTraceException
{
360 final TmfTraceStub trace
= new TmfTraceStub(fTrace
);
361 trace
.indexTrace(true);
363 assertEquals("getRange-start", 1, trace
.getTimeRange().getStartTime().getValue());
364 assertEquals("getRange-end", NB_EVENTS
, trace
.getTimeRange().getEndTime().getValue());
365 assertEquals("getStartTime", 1, trace
.getStartTime().getValue());
366 assertEquals("getEndTime", NB_EVENTS
, trace
.getEndTime().getValue());
368 trace
.setTimeRange(new TmfTimeRange(new TmfTimestamp(100), new TmfTimestamp(200)));
369 assertEquals("setTimeRange", 100, trace
.getTimeRange().getStartTime().getValue());
370 assertEquals("setTimeRange", 200, trace
.getTimeRange().getEndTime().getValue());
371 assertEquals("setTimeRange", 100, trace
.getStartTime().getValue());
372 assertEquals("setTimeRange", 200, trace
.getEndTime().getValue());
378 public void testSetStartTime() throws TmfTraceException
{
379 final TmfTraceStub trace
= new TmfTraceStub(fTrace
);
380 trace
.indexTrace(true);
382 assertEquals("getRange-start", 1, trace
.getTimeRange().getStartTime().getValue());
383 assertEquals("getRange-end", NB_EVENTS
, trace
.getTimeRange().getEndTime().getValue());
384 assertEquals("getStartTime", 1, trace
.getStartTime().getValue());
385 assertEquals("getEndTime", NB_EVENTS
, trace
.getEndTime().getValue());
387 trace
.setStartTime(new TmfTimestamp(100));
388 assertEquals("setStartTime", 100, trace
.getTimeRange().getStartTime().getValue());
389 assertEquals("setStartTime", NB_EVENTS
, trace
.getTimeRange().getEndTime().getValue());
390 assertEquals("setStartTime", 100, trace
.getStartTime().getValue());
391 assertEquals("setStartTime", NB_EVENTS
, trace
.getEndTime().getValue());
397 public void testSetEndTime() throws TmfTraceException
{
398 final TmfTraceStub trace
= new TmfTraceStub(fTrace
);
399 trace
.indexTrace(true);
401 assertEquals("getRange-start", 1, trace
.getTimeRange().getStartTime().getValue());
402 assertEquals("getRange-end", NB_EVENTS
, trace
.getTimeRange().getEndTime().getValue());
403 assertEquals("getStartTime", 1, trace
.getStartTime().getValue());
404 assertEquals("getEndTime", NB_EVENTS
, trace
.getEndTime().getValue());
406 trace
.setEndTime(new TmfTimestamp(100));
407 assertEquals("setEndTime", 1, trace
.getTimeRange().getStartTime().getValue());
408 assertEquals("setEndTime", 100, trace
.getTimeRange().getEndTime().getValue());
409 assertEquals("setEndTime", 1, trace
.getStartTime().getValue());
410 assertEquals("setEndTime", 100, trace
.getEndTime().getValue());
416 public void testSetNbEvents() throws TmfTraceException
{
417 final TmfTraceStub trace
= new TmfTraceStub(fTrace
);
418 trace
.indexTrace(true);
420 assertEquals("getNbEvents", NB_EVENTS
, trace
.getNbEvents());
422 trace
.setNbEvents(0);
423 assertEquals("getNbEvents", 0, trace
.getNbEvents());
425 trace
.setNbEvents(-1);
426 assertEquals("getNbEvents", 0, trace
.getNbEvents());
428 trace
.setNbEvents(NB_EVENTS
+ 1);
429 assertEquals("getNbEvents", NB_EVENTS
+ 1, trace
.getNbEvents());
431 trace
.setNbEvents(NB_EVENTS
);
432 assertEquals("getNbEvents", NB_EVENTS
, trace
.getNbEvents());
437 // ------------------------------------------------------------------------
438 // State system, statistics and modules methods
439 // ------------------------------------------------------------------------
442 public void testGetModulesByClass() {
443 /* There should not be any modules at this point */
444 Iterable
<IAnalysisModule
> modules
= fTrace
.getAnalysisModules();
445 assertFalse(modules
.iterator().hasNext());
447 /* Open the trace, the modules should be populated */
448 fTrace
.traceOpened(new TmfTraceOpenedSignal(this, fTrace
, null));
450 modules
= fTrace
.getAnalysisModules();
451 Iterable
<TestAnalysis
> testModules
= fTrace
.getAnalysisModulesOfClass(TestAnalysis
.class);
452 assertTrue(modules
.iterator().hasNext());
453 assertTrue(testModules
.iterator().hasNext());
456 * Make sure all modules of type TestAnalysis are returned in the second
459 for (IAnalysisModule module
: modules
) {
460 if (module
instanceof TestAnalysis
) {
461 IAnalysisModule otherModule
= fTrace
.getAnalysisModule(module
.getId());
462 assertNotNull(otherModule
);
463 assertTrue(otherModule
.equals(module
));
469 // ------------------------------------------------------------------------
470 // seekEvent on location (note: does not reliably set the rank)
471 // ------------------------------------------------------------------------
474 public void testSeekEventOnCacheBoundary() {
475 // Position trace at event rank 0
476 ITmfContext context
= fTrace
.seekEvent(0);
477 ITmfEvent event
= fTrace
.parseEvent(context
);
478 assertEquals("Event timestamp", 1, event
.getTimestamp().getValue());
479 assertEquals("Event rank", 0, context
.getRank());
481 context
= fTrace
.seekEvent(context
.getLocation());
482 assertEquals("Event rank", ITmfContext
.UNKNOWN_RANK
, context
.getRank());
484 event
= fTrace
.parseEvent(context
);
485 assertEquals("Event timestamp", 1, event
.getTimestamp().getValue());
486 assertEquals("Event rank", ITmfContext
.UNKNOWN_RANK
, context
.getRank());
488 event
= fTrace
.getNext(context
);
489 assertEquals("Event timestamp", 1, event
.getTimestamp().getValue());
490 assertEquals("Event rank", ITmfContext
.UNKNOWN_RANK
, context
.getRank());
492 // Position trace at event rank 1000
493 ITmfContext tmpContext
= fTrace
.seekEvent(new TmfTimestamp(1001, SCALE
, 0));
494 context
= fTrace
.seekEvent(tmpContext
.getLocation());
495 assertEquals("Event rank", ITmfContext
.UNKNOWN_RANK
, context
.getRank());
497 event
= fTrace
.parseEvent(context
);
498 assertEquals("Event timestamp", 1001, event
.getTimestamp().getValue());
499 assertEquals("Event rank", ITmfContext
.UNKNOWN_RANK
, context
.getRank());
501 event
= fTrace
.getNext(context
);
502 assertEquals("Event timestamp", 1001, event
.getTimestamp().getValue());
503 assertEquals("Event rank", ITmfContext
.UNKNOWN_RANK
, context
.getRank());
505 // Position trace at event rank 4000
506 tmpContext
= fTrace
.seekEvent(new TmfTimestamp(4001, SCALE
, 0));
507 context
= fTrace
.seekEvent(tmpContext
.getLocation());
508 assertEquals("Event rank", ITmfContext
.UNKNOWN_RANK
, context
.getRank());
510 event
= fTrace
.parseEvent(context
);
511 assertEquals("Event timestamp", 4001, event
.getTimestamp().getValue());
512 assertEquals("Event rank", ITmfContext
.UNKNOWN_RANK
, context
.getRank());
514 event
= fTrace
.getNext(context
);
515 assertEquals("Event timestamp", 4001, event
.getTimestamp().getValue());
516 assertEquals("Event rank", ITmfContext
.UNKNOWN_RANK
, context
.getRank());
520 public void testSeekEventNotOnCacheBoundary() {
521 // Position trace at event rank 9
522 ITmfContext tmpContext
= fTrace
.seekEvent(new TmfTimestamp(10, SCALE
, 0));
523 TmfContext context
= fTrace
.seekEvent(tmpContext
.getLocation());
524 assertEquals("Event rank", ITmfContext
.UNKNOWN_RANK
, context
.getRank());
526 ITmfEvent event
= fTrace
.parseEvent(context
);
527 assertEquals("Event timestamp", 10, event
.getTimestamp().getValue());
528 assertEquals("Event rank", ITmfContext
.UNKNOWN_RANK
, context
.getRank());
530 event
= fTrace
.getNext(context
);
531 assertEquals("Event timestamp", 10, event
.getTimestamp().getValue());
532 assertEquals("Event rank", ITmfContext
.UNKNOWN_RANK
, context
.getRank());
534 // Position trace at event rank 999
535 tmpContext
= fTrace
.seekEvent(new TmfTimestamp(1000, SCALE
, 0));
536 context
= fTrace
.seekEvent(tmpContext
.getLocation());
537 assertEquals("Event rank", ITmfContext
.UNKNOWN_RANK
, context
.getRank());
539 event
= fTrace
.parseEvent(context
);
540 assertEquals("Event timestamp", 1000, event
.getTimestamp().getValue());
541 assertEquals("Event rank", ITmfContext
.UNKNOWN_RANK
, context
.getRank());
543 event
= fTrace
.getNext(context
);
544 assertEquals("Event timestamp", 1000, event
.getTimestamp().getValue());
545 assertEquals("Event rank", ITmfContext
.UNKNOWN_RANK
, context
.getRank());
547 // Position trace at event rank 1001
548 tmpContext
= fTrace
.seekEvent(new TmfTimestamp(1002, SCALE
, 0));
549 context
= fTrace
.seekEvent(tmpContext
.getLocation());
550 assertEquals("Event rank", ITmfContext
.UNKNOWN_RANK
, context
.getRank());
552 event
= fTrace
.parseEvent(context
);
553 assertEquals("Event timestamp", 1002, event
.getTimestamp().getValue());
554 assertEquals("Event rank", ITmfContext
.UNKNOWN_RANK
, context
.getRank());
556 event
= fTrace
.getNext(context
);
557 assertEquals("Event timestamp", 1002, event
.getTimestamp().getValue());
558 assertEquals("Event rank", ITmfContext
.UNKNOWN_RANK
, context
.getRank());
560 // Position trace at event rank 4500
561 tmpContext
= fTrace
.seekEvent(new TmfTimestamp(4501, SCALE
, 0));
562 context
= fTrace
.seekEvent(tmpContext
.getLocation());
563 assertEquals("Event rank", ITmfContext
.UNKNOWN_RANK
, context
.getRank());
565 event
= fTrace
.parseEvent(context
);
566 assertEquals("Event timestamp", 4501, event
.getTimestamp().getValue());
567 assertEquals("Event rank", ITmfContext
.UNKNOWN_RANK
, context
.getRank());
569 event
= fTrace
.getNext(context
);
570 assertEquals("Event timestamp", 4501, event
.getTimestamp().getValue());
571 assertEquals("Event rank", ITmfContext
.UNKNOWN_RANK
, context
.getRank());
575 public void testSeekEventOutOfScope() {
576 // Position trace at beginning
577 ITmfContext tmpContext
= fTrace
.seekEvent(0);
578 ITmfContext context
= fTrace
.seekEvent(tmpContext
.getLocation());
579 assertEquals("Event rank", ITmfContext
.UNKNOWN_RANK
, context
.getRank());
581 ITmfEvent event
= fTrace
.parseEvent(context
);
582 assertEquals("Event timestamp", 1, event
.getTimestamp().getValue());
583 assertEquals("Event rank", ITmfContext
.UNKNOWN_RANK
, context
.getRank());
585 event
= fTrace
.getNext(context
);
586 assertEquals("Event timestamp", 1, event
.getTimestamp().getValue());
587 assertEquals("Event rank", ITmfContext
.UNKNOWN_RANK
, context
.getRank());
589 // Position trace at event passed the end
590 context
= fTrace
.seekEvent(new TmfTimestamp(NB_EVENTS
+ 1, SCALE
, 0));
591 assertNull("Event timestamp", context
.getLocation());
592 assertEquals("Event rank", ITmfContext
.UNKNOWN_RANK
, context
.getRank());
594 event
= fTrace
.getNext(context
);
595 assertNull("Event", event
);
598 // ------------------------------------------------------------------------
599 // seekEvent on timestamp (note: does not reliably set the rank)
600 // ------------------------------------------------------------------------
603 public void testSeekEventOnNullTimestamp() {
604 // Position trace at event rank 0
605 ITmfContext context
= fTrace
.seekEvent((ITmfTimestamp
) null);
606 assertEquals("Event rank", 0, context
.getRank());
608 ITmfEvent event
= fTrace
.parseEvent(context
);
609 assertEquals("Event timestamp", 1, event
.getTimestamp().getValue());
610 assertEquals("Event rank", 0, context
.getRank());
614 public void testSeekEventOnTimestampOnCacheBoundary() {
615 // Position trace at event rank 0
616 ITmfContext context
= fTrace
.seekEvent(new TmfTimestamp(1, SCALE
, 0));
617 assertEquals("Event rank", 0, context
.getRank());
619 ITmfEvent event
= fTrace
.parseEvent(context
);
620 assertEquals("Event timestamp", 1, event
.getTimestamp().getValue());
621 assertEquals("Event rank", 0, context
.getRank());
623 event
= fTrace
.getNext(context
);
624 assertEquals("Event timestamp", 1, event
.getTimestamp().getValue());
625 assertEquals("Event rank", 1, context
.getRank());
627 // Position trace at event rank 1000
628 context
= fTrace
.seekEvent(new TmfTimestamp(1001, SCALE
, 0));
629 assertEquals("Event rank", 1000, context
.getRank());
631 event
= fTrace
.parseEvent(context
);
632 assertEquals("Event timestamp", 1001, event
.getTimestamp().getValue());
633 assertEquals("Event rank", 1000, context
.getRank());
635 event
= fTrace
.getNext(context
);
636 assertEquals("Event timestamp", 1001, event
.getTimestamp().getValue());
637 assertEquals("Event rank", 1001, context
.getRank());
639 // Position trace at event rank 4000
640 context
= fTrace
.seekEvent(new TmfTimestamp(4001, SCALE
, 0));
641 assertEquals("Event rank", 4000, context
.getRank());
643 event
= fTrace
.parseEvent(context
);
644 assertEquals("Event timestamp", 4001, event
.getTimestamp().getValue());
645 assertEquals("Event rank", 4000, context
.getRank());
647 event
= fTrace
.getNext(context
);
648 assertEquals("Event timestamp", 4001, event
.getTimestamp().getValue());
649 assertEquals("Event rank", 4001, context
.getRank());
653 public void testSeekEventOnTimestampNotOnCacheBoundary() {
654 // Position trace at event rank 1
655 ITmfContext context
= fTrace
.seekEvent(new TmfTimestamp(2, SCALE
, 0));
656 assertEquals("Event rank", 1, context
.getRank());
658 ITmfEvent event
= fTrace
.parseEvent(context
);
659 assertEquals("Event timestamp", 2, event
.getTimestamp().getValue());
660 assertEquals("Event rank", 1, context
.getRank());
662 event
= fTrace
.getNext(context
);
663 assertEquals("Event timestamp", 2, event
.getTimestamp().getValue());
664 assertEquals("Event rank", 2, context
.getRank());
666 // Position trace at event rank 9
667 context
= fTrace
.seekEvent(new TmfTimestamp(10, SCALE
, 0));
668 assertEquals("Event rank", 9, context
.getRank());
670 event
= fTrace
.parseEvent(context
);
671 assertEquals("Event timestamp", 10, event
.getTimestamp().getValue());
672 assertEquals("Event rank", 9, context
.getRank());
674 event
= fTrace
.getNext(context
);
675 assertEquals("Event timestamp", 10, event
.getTimestamp().getValue());
676 assertEquals("Event rank", 10, context
.getRank());
678 // Position trace at event rank 999
679 context
= fTrace
.seekEvent(new TmfTimestamp(1000, SCALE
, 0));
680 assertEquals("Event rank", 999, context
.getRank());
682 event
= fTrace
.parseEvent(context
);
683 assertEquals("Event timestamp", 1000, event
.getTimestamp().getValue());
684 assertEquals("Event rank", 999, context
.getRank());
686 event
= fTrace
.getNext(context
);
687 assertEquals("Event timestamp", 1000, event
.getTimestamp().getValue());
688 assertEquals("Event rank", 1000, context
.getRank());
690 // Position trace at event rank 1001
691 context
= fTrace
.seekEvent(new TmfTimestamp(1002, SCALE
, 0));
692 assertEquals("Event rank", 1001, context
.getRank());
694 event
= fTrace
.parseEvent(context
);
695 assertEquals("Event timestamp", 1002, event
.getTimestamp().getValue());
696 assertEquals("Event rank", 1001, context
.getRank());
698 event
= fTrace
.getNext(context
);
699 assertEquals("Event timestamp", 1002, event
.getTimestamp().getValue());
700 assertEquals("Event rank", 1002, context
.getRank());
702 // Position trace at event rank 4500
703 context
= fTrace
.seekEvent(new TmfTimestamp(4501, SCALE
, 0));
704 assertEquals("Event rank", 4500, context
.getRank());
706 event
= fTrace
.parseEvent(context
);
707 assertEquals("Event timestamp", 4501, event
.getTimestamp().getValue());
708 assertEquals("Event rank", 4500, context
.getRank());
710 event
= fTrace
.getNext(context
);
711 assertEquals("Event timestamp", 4501, event
.getTimestamp().getValue());
712 assertEquals("Event rank", 4501, context
.getRank());
716 public void testSeekEventOnTimestampOutOfScope() {
717 // Position trace at beginning
718 ITmfContext context
= fTrace
.seekEvent(new TmfTimestamp(-1, SCALE
, 0));
719 assertEquals("Event rank", 0, context
.getRank());
721 ITmfEvent event
= fTrace
.parseEvent(context
);
722 assertEquals("Event timestamp", 1, event
.getTimestamp().getValue());
723 assertEquals("Event rank", 0, context
.getRank());
725 event
= fTrace
.getNext(context
);
726 assertEquals("Event timestamp", 1, event
.getTimestamp().getValue());
727 assertEquals("Event rank", 1, context
.getRank());
729 // Position trace at event passed the end
730 context
= fTrace
.seekEvent(new TmfTimestamp(NB_EVENTS
+ 1, SCALE
, 0));
731 assertEquals("Event rank", ITmfContext
.UNKNOWN_RANK
, context
.getRank());
733 event
= fTrace
.parseEvent(context
);
734 assertEquals("Event timestamp", null, event
);
735 assertEquals("Event rank", ITmfContext
.UNKNOWN_RANK
, context
.getRank());
737 event
= fTrace
.getNext(context
);
738 assertEquals("Event timestamp", null, event
);
739 assertEquals("Event rank", ITmfContext
.UNKNOWN_RANK
, context
.getRank());
742 // ------------------------------------------------------------------------
744 // ------------------------------------------------------------------------
747 public void testSeekEventOnNegativeRank() {
748 // Position trace at event rank 0
749 ITmfContext context
= fTrace
.seekEvent(-1);
750 assertEquals("Event rank", 0, context
.getRank());
752 ITmfEvent event
= fTrace
.parseEvent(context
);
753 assertEquals("Event timestamp", 1, event
.getTimestamp().getValue());
754 assertEquals("Event rank", 0, context
.getRank());
758 public void testSeekOnRankOnCacheBoundary() {
759 // On lower bound, returns the first event (ts = 1)
760 ITmfContext context
= fTrace
.seekEvent(0);
761 assertEquals("Event rank", 0, context
.getRank());
763 ITmfEvent event
= fTrace
.parseEvent(context
);
764 assertEquals("Event timestamp", 1, event
.getTimestamp().getValue());
765 assertEquals("Event rank", 0, context
.getRank());
767 event
= fTrace
.getNext(context
);
768 assertEquals("Event timestamp", 1, event
.getTimestamp().getValue());
769 assertEquals("Event rank", 1, context
.getRank());
771 // Position trace at event rank 1000
772 context
= fTrace
.seekEvent(1000);
773 assertEquals("Event rank", 1000, context
.getRank());
775 event
= fTrace
.parseEvent(context
);
776 assertEquals("Event timestamp", 1001, event
.getTimestamp().getValue());
777 assertEquals("Event rank", 1000, context
.getRank());
779 event
= fTrace
.getNext(context
);
780 assertEquals("Event timestamp", 1001, event
.getTimestamp().getValue());
781 assertEquals("Event rank", 1001, context
.getRank());
783 // Position trace at event rank 4000
784 context
= fTrace
.seekEvent(4000);
785 assertEquals("Event rank", 4000, context
.getRank());
787 event
= fTrace
.parseEvent(context
);
788 assertEquals("Event timestamp", 4001, event
.getTimestamp().getValue());
789 assertEquals("Event rank", 4000, context
.getRank());
791 event
= fTrace
.getNext(context
);
792 assertEquals("Event timestamp", 4001, event
.getTimestamp().getValue());
793 assertEquals("Event rank", 4001, context
.getRank());
797 public void testSeekOnRankNotOnCacheBoundary() {
798 // Position trace at event rank 9
799 ITmfContext context
= fTrace
.seekEvent(9);
800 assertEquals("Event rank", 9, context
.getRank());
802 ITmfEvent event
= fTrace
.parseEvent(context
);
803 assertEquals("Event timestamp", 10, event
.getTimestamp().getValue());
804 assertEquals("Event rank", 9, context
.getRank());
806 event
= fTrace
.getNext(context
);
807 assertEquals("Event timestamp", 10, event
.getTimestamp().getValue());
808 assertEquals("Event rank", 10, context
.getRank());
810 // Position trace at event rank 999
811 context
= fTrace
.seekEvent(999);
812 assertEquals("Event rank", 999, context
.getRank());
814 event
= fTrace
.parseEvent(context
);
815 assertEquals("Event timestamp", 1000, event
.getTimestamp().getValue());
816 assertEquals("Event rank", 999, context
.getRank());
818 event
= fTrace
.getNext(context
);
819 assertEquals("Event timestamp", 1000, event
.getTimestamp().getValue());
820 assertEquals("Event rank", 1000, context
.getRank());
822 // Position trace at event rank 1001
823 context
= fTrace
.seekEvent(1001);
824 assertEquals("Event rank", 1001, context
.getRank());
826 event
= fTrace
.parseEvent(context
);
827 assertEquals("Event timestamp", 1002, event
.getTimestamp().getValue());
828 assertEquals("Event rank", 1001, context
.getRank());
830 event
= fTrace
.getNext(context
);
831 assertEquals("Event timestamp", 1002, event
.getTimestamp().getValue());
832 assertEquals("Event rank", 1002, context
.getRank());
834 // Position trace at event rank 4500
835 context
= fTrace
.seekEvent(4500);
836 assertEquals("Event rank", 4500, context
.getRank());
838 event
= fTrace
.parseEvent(context
);
839 assertEquals("Event timestamp", 4501, event
.getTimestamp().getValue());
840 assertEquals("Event rank", 4500, context
.getRank());
842 event
= fTrace
.getNext(context
);
843 assertEquals("Event timestamp", 4501, event
.getTimestamp().getValue());
844 assertEquals("Event rank", 4501, context
.getRank());
848 public void testSeekEventOnRankOutOfScope() {
849 // Position trace at beginning
850 ITmfContext context
= fTrace
.seekEvent(-1);
851 assertEquals("Event rank", 0, context
.getRank());
853 ITmfEvent event
= fTrace
.parseEvent(context
);
854 assertEquals("Event timestamp", 1, event
.getTimestamp().getValue());
855 assertEquals("Event rank", 0, context
.getRank());
857 event
= fTrace
.getNext(context
);
858 assertEquals("Event timestamp", 1, event
.getTimestamp().getValue());
859 assertEquals("Event rank", 1, context
.getRank());
861 // Position trace at event passed the end
862 context
= fTrace
.seekEvent(NB_EVENTS
);
863 assertEquals("Event rank", NB_EVENTS
, context
.getRank());
865 event
= fTrace
.parseEvent(context
);
866 assertNull("Event", event
);
867 assertEquals("Event rank", NB_EVENTS
, context
.getRank());
869 event
= fTrace
.getNext(context
);
870 assertNull("Event", event
);
871 assertEquals("Event rank", NB_EVENTS
, context
.getRank());
874 // ------------------------------------------------------------------------
875 // parseEvent - make sure parseEvent doesn't update the context
876 // ------------------------------------------------------------------------
879 public void testParseEvent() {
880 final int NB_READS
= 20;
882 // On lower bound, returns the first event (ts = 0)
883 final TmfContext context
= (TmfContext
) fTrace
.seekEvent(new TmfTimestamp(0, SCALE
, 0));
884 TmfContext svContext
= new TmfContext(context
);
886 ITmfEvent event
= fTrace
.parseEvent(context
);
887 assertEquals("Event timestamp", 1, event
.getTimestamp().getValue());
888 assertEquals("Event rank", 0, context
.getRank());
889 assertTrue("parseEvent", context
.equals(svContext
));
891 event
= fTrace
.parseEvent(context
);
892 assertEquals("Event timestamp", 1, event
.getTimestamp().getValue());
893 assertEquals("Event rank", 0, context
.getRank());
894 assertTrue("parseEvent", context
.equals(svContext
));
896 event
= fTrace
.parseEvent(context
);
897 assertEquals("Event timestamp", 1, event
.getTimestamp().getValue());
898 assertEquals("Event rank", 0, context
.getRank());
899 assertTrue("parseEvent", context
.equals(svContext
));
901 // Position the trace at event NB_READS
902 for (int i
= 1; i
< NB_READS
; i
++) {
903 event
= fTrace
.getNext(context
);
904 assertEquals("Event timestamp", i
, event
.getTimestamp().getValue());
907 svContext
= new TmfContext(context
);
908 event
= fTrace
.parseEvent(context
);
909 assertEquals("Event timestamp", NB_READS
, event
.getTimestamp().getValue());
910 assertEquals("Event rank", NB_READS
-1 , context
.getRank());
911 assertTrue("parseEvent", context
.equals(svContext
));
913 event
= fTrace
.parseEvent(context
);
914 assertEquals("Event timestamp", NB_READS
, event
.getTimestamp().getValue());
915 assertEquals("Event rank", NB_READS
- 1, context
.getRank());
916 assertTrue("parseEvent", context
.equals(svContext
));
919 // ------------------------------------------------------------------------
920 // getNext - updates the context
921 // ------------------------------------------------------------------------
924 public void testGetNextAfteSeekingOnTS_1() {
925 final long INITIAL_TS
= 1;
926 final int NB_READS
= 20;
928 // On lower bound, returns the first event (ts = 1)
929 final ITmfContext context
= fTrace
.seekEvent(new TmfTimestamp(INITIAL_TS
, SCALE
, 0));
933 for (int i
= 0; i
< NB_READS
; i
++) {
934 event
= fTrace
.getNext(context
);
935 assertEquals("Event timestamp", INITIAL_TS
+ i
, event
.getTimestamp().getValue());
936 assertEquals("Event rank", INITIAL_TS
+ i
, context
.getRank());
939 // Make sure we stay positioned
940 event
= fTrace
.parseEvent(context
);
941 assertEquals("Event timestamp", INITIAL_TS
+ NB_READS
, event
.getTimestamp().getValue());
942 assertEquals("Event rank", INITIAL_TS
+ NB_READS
- 1, context
.getRank());
946 public void testGetNextAfteSeekingOnTS_2() {
947 final long INITIAL_TS
= 2;
948 final int NB_READS
= 20;
950 // On lower bound, returns the first event (ts = 500)
951 final ITmfContext context
= fTrace
.seekEvent(new TmfTimestamp(INITIAL_TS
, SCALE
, 0));
955 for (int i
= 0; i
< NB_READS
; i
++) {
956 event
= fTrace
.getNext(context
);
957 assertEquals("Event timestamp", INITIAL_TS
+ i
, event
.getTimestamp().getValue());
958 assertEquals("Event rank", INITIAL_TS
+ i
, context
.getRank());
961 // Make sure we stay positioned
962 event
= fTrace
.parseEvent(context
);
963 assertEquals("Event timestamp", INITIAL_TS
+ NB_READS
, event
.getTimestamp().getValue());
964 assertEquals("Event rank", INITIAL_TS
+ NB_READS
- 1, context
.getRank());
968 public void testGetNextAfteSeekingOnTS_3() {
969 final long INITIAL_TS
= 500;
970 final int NB_READS
= 20;
972 // On lower bound, returns the first event (ts = 500)
973 final ITmfContext context
= fTrace
.seekEvent(new TmfTimestamp(INITIAL_TS
, SCALE
, 0));
977 for (int i
= 0; i
< NB_READS
; i
++) {
978 event
= fTrace
.getNext(context
);
979 assertEquals("Event timestamp", INITIAL_TS
+ i
, event
.getTimestamp().getValue());
980 assertEquals("Event rank", INITIAL_TS
+ i
, context
.getRank());
983 // Make sure we stay positioned
984 event
= fTrace
.parseEvent(context
);
985 assertEquals("Event timestamp", INITIAL_TS
+ NB_READS
, event
.getTimestamp().getValue());
986 assertEquals("Event rank", INITIAL_TS
+ NB_READS
- 1, context
.getRank());
990 public void testGetNextAfterSeekingOnRank_1() {
991 final long INITIAL_RANK
= 0L;
992 final int NB_READS
= 20;
994 // On lower bound, returns the first event (rank = 0)
995 final ITmfContext context
= fTrace
.seekEvent(INITIAL_RANK
);
999 for (int i
= 0; i
< NB_READS
; i
++) {
1000 event
= fTrace
.getNext(context
);
1001 assertEquals("Event timestamp", INITIAL_RANK
+ i
+ 1, event
.getTimestamp().getValue());
1002 assertEquals("Event rank", INITIAL_RANK
+ i
+ 1, context
.getRank());
1005 // Make sure we stay positioned
1006 event
= fTrace
.parseEvent(context
);
1007 assertEquals("Event timestamp", INITIAL_RANK
+ NB_READS
+ 1, event
.getTimestamp().getValue());
1008 assertEquals("Event rank", INITIAL_RANK
+ NB_READS
, context
.getRank());
1012 public void testGetNextAfterSeekingOnRank_2() {
1013 final long INITIAL_RANK
= 1L;
1014 final int NB_READS
= 20;
1016 // On lower bound, returns the first event (rank = 0)
1017 final ITmfContext context
= fTrace
.seekEvent(INITIAL_RANK
);
1021 for (int i
= 0; i
< NB_READS
; i
++) {
1022 event
= fTrace
.getNext(context
);
1023 assertEquals("Event timestamp", INITIAL_RANK
+ i
+ 1, event
.getTimestamp().getValue());
1024 assertEquals("Event rank", INITIAL_RANK
+ i
+ 1, context
.getRank());
1027 // Make sure we stay positioned
1028 event
= fTrace
.parseEvent(context
);
1029 assertEquals("Event timestamp", INITIAL_RANK
+ NB_READS
+ 1, event
.getTimestamp().getValue());
1030 assertEquals("Event rank", INITIAL_RANK
+ NB_READS
, context
.getRank());
1034 public void testGetNextAfterSeekingOnRank_3() {
1035 final long INITIAL_RANK
= 500L;
1036 final int NB_READS
= 20;
1038 // On lower bound, returns the first event (rank = 0)
1039 final ITmfContext context
= fTrace
.seekEvent(INITIAL_RANK
);
1043 for (int i
= 0; i
< NB_READS
; i
++) {
1044 event
= fTrace
.getNext(context
);
1045 assertEquals("Event timestamp", INITIAL_RANK
+ i
+ 1, event
.getTimestamp().getValue());
1046 assertEquals("Event rank", INITIAL_RANK
+ i
+ 1, context
.getRank());
1049 // Make sure we stay positioned
1050 event
= fTrace
.parseEvent(context
);
1051 assertEquals("Event timestamp", INITIAL_RANK
+ NB_READS
+ 1, event
.getTimestamp().getValue());
1052 assertEquals("Event rank", INITIAL_RANK
+ NB_READS
, context
.getRank());
1056 public void testGetNextAfterSeekingOnLocation_1() {
1057 final ITmfLocation INITIAL_LOC
= null;
1058 final long INITIAL_TS
= 1;
1059 final int NB_READS
= 20;
1061 // On lower bound, returns the first event (ts = 1)
1062 final ITmfContext context
= fTrace
.seekEvent(INITIAL_LOC
);
1066 for (int i
= 0; i
< NB_READS
; i
++) {
1067 event
= fTrace
.getNext(context
);
1068 assertEquals("Event timestamp", INITIAL_TS
+ i
, event
.getTimestamp().getValue());
1069 assertEquals("Event rank", INITIAL_TS
+ i
, context
.getRank());
1072 // Make sure we stay positioned
1073 event
= fTrace
.parseEvent(context
);
1074 assertEquals("Event timestamp", INITIAL_TS
+ NB_READS
, event
.getTimestamp().getValue());
1075 assertEquals("Event rank", INITIAL_TS
+ NB_READS
- 1, context
.getRank());
1079 public void testGetNextAfterSeekingOnLocation_2() {
1080 final ITmfLocation INITIAL_LOC
= fTrace
.seekEvent(1L).getLocation();
1081 final long INITIAL_TS
= 2;
1082 final int NB_READS
= 20;
1084 // On lower bound, returns the first event (ts = 501)
1085 final ITmfContext context
= fTrace
.seekEvent(INITIAL_LOC
);
1089 for (int i
= 0; i
< NB_READS
; i
++) {
1090 event
= fTrace
.getNext(context
);
1091 assertEquals("Event timestamp", INITIAL_TS
+ i
, event
.getTimestamp().getValue());
1094 // Make sure we stay positioned
1095 event
= fTrace
.parseEvent(context
);
1096 assertEquals("Event timestamp", INITIAL_TS
+ NB_READS
, event
.getTimestamp().getValue());
1100 public void testGetNextAfterSeekingOnLocation_3() {
1101 final ITmfLocation INITIAL_LOC
= fTrace
.seekEvent(500L).getLocation();
1102 final long INITIAL_TS
= 501;
1103 final int NB_READS
= 20;
1105 // On lower bound, returns the first event (ts = 501)
1106 final ITmfContext context
= fTrace
.seekEvent(INITIAL_LOC
);
1110 for (int i
= 0; i
< NB_READS
; i
++) {
1111 event
= fTrace
.getNext(context
);
1112 assertEquals("Event timestamp", INITIAL_TS
+ i
, event
.getTimestamp().getValue());
1115 // Make sure we stay positioned
1116 event
= fTrace
.parseEvent(context
);
1117 assertEquals("Event timestamp", INITIAL_TS
+ NB_READS
, event
.getTimestamp().getValue());
1121 public void testGetNextLocation() {
1122 ITmfContext context1
= fTrace
.seekEvent(0);
1123 fTrace
.getNext(context1
);
1124 ITmfLocation location
= context1
.getLocation();
1125 ITmfEvent event1
= fTrace
.getNext(context1
);
1126 ITmfContext context2
= fTrace
.seekEvent(location
);
1127 ITmfEvent event2
= fTrace
.getNext(context2
);
1128 assertEquals("Event timestamp", event1
.getTimestamp().getValue(), event2
.getTimestamp().getValue());
1132 public void testGetNextEndLocation() {
1133 ITmfContext context1
= fTrace
.seekEvent(fTrace
.getNbEvents() - 1);
1134 fTrace
.getNext(context1
);
1135 ITmfLocation location
= context1
.getLocation();
1136 ITmfContext context2
= fTrace
.seekEvent(location
);
1137 ITmfEvent event
= fTrace
.getNext(context2
);
1138 assertNull("Event", event
);
1141 // ------------------------------------------------------------------------
1143 // ------------------------------------------------------------------------
1146 public void testProcessEventRequestForAllEvents() throws InterruptedException
{
1147 final Vector
<ITmfEvent
> requestedEvents
= new Vector
<>();
1149 final TmfTimeRange range
= new TmfTimeRange(TmfTimestamp
.BIG_BANG
, TmfTimestamp
.BIG_CRUNCH
);
1150 final TmfEventRequest request
= new TmfEventRequest(ITmfEvent
.class,
1151 range
, 0, NB_EVENTS
, ExecutionType
.FOREGROUND
) {
1153 public void handleData(final ITmfEvent event
) {
1154 super.handleData(event
);
1155 requestedEvents
.add(event
);
1158 final ITmfEventProvider
[] providers
= TmfProviderManager
.getProviders(ITmfEvent
.class, TmfTraceStub
.class);
1159 providers
[0].sendRequest(request
);
1160 request
.waitForCompletion();
1162 assertEquals("nbEvents", NB_EVENTS
, requestedEvents
.size());
1163 assertTrue("isCompleted", request
.isCompleted());
1164 assertFalse("isCancelled", request
.isCancelled());
1166 // Ensure that we have distinct events.
1167 // Don't go overboard: we are not validating the stub!
1168 for (int i
= 0; i
< NB_EVENTS
; i
++) {
1169 assertEquals("Distinct events", i
+ 1, requestedEvents
.get(i
).getTimestamp().getValue());
1174 public void testProcessEventRequestForNbEvents() throws InterruptedException
{
1175 final int nbEvents
= 1000;
1176 final Vector
<ITmfEvent
> requestedEvents
= new Vector
<>();
1178 final TmfTimeRange range
= new TmfTimeRange(TmfTimestamp
.BIG_BANG
, TmfTimestamp
.BIG_CRUNCH
);
1179 final TmfEventRequest request
= new TmfEventRequest(ITmfEvent
.class,
1180 range
, 0, nbEvents
, ExecutionType
.FOREGROUND
) {
1182 public void handleData(final ITmfEvent event
) {
1183 super.handleData(event
);
1184 requestedEvents
.add(event
);
1187 final ITmfEventProvider
[] providers
= TmfProviderManager
.getProviders(ITmfEvent
.class, TmfTraceStub
.class);
1188 providers
[0].sendRequest(request
);
1189 request
.waitForCompletion();
1191 assertEquals("nbEvents", nbEvents
, requestedEvents
.size());
1192 assertTrue("isCompleted", request
.isCompleted());
1193 assertFalse("isCancelled", request
.isCancelled());
1195 // Ensure that we have distinct events.
1196 // Don't go overboard: we are not validating the stub!
1197 for (int i
= 0; i
< nbEvents
; i
++) {
1198 assertEquals("Distinct events", i
+ 1, requestedEvents
.get(i
).getTimestamp().getValue());
1203 public void testProcessEventRequestForSomeEvents() throws InterruptedException
{
1204 final long startTime
= 100;
1205 final int nbEvents
= 1000;
1206 final Vector
<ITmfEvent
> requestedEvents
= new Vector
<>();
1208 final TmfTimeRange range
= new TmfTimeRange(new TmfTimestamp(startTime
, SCALE
), TmfTimestamp
.BIG_CRUNCH
);
1209 final TmfEventRequest request
= new TmfEventRequest(ITmfEvent
.class,
1210 range
, 0, nbEvents
, ExecutionType
.FOREGROUND
) {
1212 public void handleData(final ITmfEvent event
) {
1213 super.handleData(event
);
1214 requestedEvents
.add(event
);
1217 final ITmfEventProvider
[] providers
= TmfProviderManager
.getProviders(ITmfEvent
.class, TmfTraceStub
.class);
1218 providers
[0].sendRequest(request
);
1219 request
.waitForCompletion();
1221 assertEquals("nbEvents", nbEvents
, requestedEvents
.size());
1222 assertTrue("isCompleted", request
.isCompleted());
1223 assertFalse("isCancelled", request
.isCancelled());
1225 // Ensure that we have distinct events.
1226 // Don't go overboard: we are not validating the stub!
1227 for (int i
= 0; i
< nbEvents
; i
++) {
1228 assertEquals("Distinct events", startTime
+ i
, requestedEvents
.get(i
).getTimestamp().getValue());
1233 public void testProcessEventRequestForOtherEvents() throws InterruptedException
{
1234 final int startIndex
= 99;
1235 final long startTime
= 100;
1236 final int nbEvents
= 1000;
1237 final Vector
<ITmfEvent
> requestedEvents
= new Vector
<>();
1239 final TmfTimeRange range
= new TmfTimeRange(new TmfTimestamp(startTime
, SCALE
), TmfTimestamp
.BIG_CRUNCH
);
1240 final TmfEventRequest request
= new TmfEventRequest(ITmfEvent
.class,
1241 range
, startIndex
, nbEvents
, ExecutionType
.FOREGROUND
) {
1243 public void handleData(final ITmfEvent event
) {
1244 super.handleData(event
);
1245 requestedEvents
.add(event
);
1248 final ITmfEventProvider
[] providers
= TmfProviderManager
.getProviders(ITmfEvent
.class, TmfTraceStub
.class);
1249 providers
[0].sendRequest(request
);
1250 request
.waitForCompletion();
1252 assertEquals("nbEvents", nbEvents
, requestedEvents
.size());
1253 assertTrue("isCompleted", request
.isCompleted());
1254 assertFalse("isCancelled", request
.isCancelled());
1256 // Ensure that we have distinct events.
1257 // Don't go overboard: we are not validating the stub!
1258 for (int i
= 0; i
< nbEvents
; i
++) {
1259 assertEquals("Distinct events", startTime
+ i
, requestedEvents
.get(i
).getTimestamp().getValue());
1264 public void testProcessDataRequestForSomeEvents() throws InterruptedException
{
1265 final int startIndex
= 100;
1266 final int nbEvents
= 1000;
1267 final Vector
<ITmfEvent
> requestedEvents
= new Vector
<>();
1269 final TmfEventRequest request
= new TmfEventRequest(ITmfEvent
.class,
1270 TmfTimeRange
.ETERNITY
,
1273 TmfEventRequest
.ExecutionType
.FOREGROUND
) {
1275 public void handleData(final ITmfEvent event
) {
1276 super.handleData(event
);
1277 requestedEvents
.add(event
);
1280 final ITmfEventProvider
[] providers
= TmfProviderManager
.getProviders(ITmfEvent
.class, TmfTraceStub
.class);
1281 providers
[0].sendRequest(request
);
1282 request
.waitForCompletion();
1284 assertEquals("nbEvents", nbEvents
, requestedEvents
.size());
1285 assertTrue("isCompleted", request
.isCompleted());
1286 assertFalse("isCancelled", request
.isCancelled());
1288 // Ensure that we have distinct events.
1289 // Don't go overboard: we are not validating the stub!
1290 for (int i
= 0; i
< nbEvents
; i
++) {
1291 assertEquals("Distinct events", startIndex
+ 1 + i
, requestedEvents
.get(i
).getTimestamp().getValue());
1295 // ------------------------------------------------------------------------
1297 // ------------------------------------------------------------------------
1300 public void testCancel() throws InterruptedException
{
1301 final int limit
= 500;
1302 final Vector
<ITmfEvent
> requestedEvents
= new Vector
<>();
1304 final TmfTimeRange range
= new TmfTimeRange(TmfTimestamp
.BIG_BANG
, TmfTimestamp
.BIG_CRUNCH
);
1305 final TmfEventRequest request
= new TmfEventRequest(ITmfEvent
.class,
1306 range
, 0, NB_EVENTS
, ExecutionType
.FOREGROUND
) {
1310 public void handleData(final ITmfEvent event
) {
1311 super.handleData(event
);
1312 requestedEvents
.add(event
);
1313 if (++nbRead
== limit
) {
1318 final ITmfEventProvider
[] providers
= TmfProviderManager
.getProviders(ITmfEvent
.class, TmfTraceStub
.class);
1319 providers
[0].sendRequest(request
);
1320 request
.waitForCompletion();
1322 assertEquals("nbEvents", limit
, requestedEvents
.size());
1323 assertTrue("isCompleted", request
.isCompleted());
1324 assertTrue("isCancelled", request
.isCancelled());
1327 // ------------------------------------------------------------------------
1329 // ------------------------------------------------------------------------
1332 public void testDefaultTmfTraceStub() {
1333 assertFalse ("Open trace", fTrace
== null);
1334 assertEquals("getType", ITmfEvent
.class, fTrace
.getType());
1335 assertNull ("getResource", fTrace
.getResource());
1336 assertEquals("getStreamingInterval", 0, fTrace
.getStreamingInterval());
1337 assertEquals("getName", TEST_TRACE
.getPath(), fTrace
.getName());
1339 assertEquals("getNbEvents", NB_EVENTS
, fTrace
.getNbEvents());
1340 assertEquals("getRange-start", 1, fTrace
.getTimeRange().getStartTime().getValue());
1341 assertEquals("getRange-end", NB_EVENTS
, fTrace
.getTimeRange().getEndTime().getValue());
1342 assertEquals("getStartTime", 1, fTrace
.getStartTime().getValue());
1343 assertEquals("getEndTime", NB_EVENTS
, fTrace
.getEndTime().getValue());
1345 String expected
= "TmfTrace [fPath=" + fTrace
.getPath() + ", fCacheSize=" + fTrace
.getCacheSize() +
1346 ", fNbEvents=" + fTrace
.getNbEvents() + ", fStartTime=" + fTrace
.getStartTime() +
1347 ", fEndTime=" + fTrace
.getEndTime() + ", fStreamingInterval=" + fTrace
.getStreamingInterval() +
1349 assertEquals("toString", expected
, fTrace
.toString());
1352 // ------------------------------------------------------------------------
1353 // getInitialRangeOffset, getCurrentRange, getCurrentTime
1354 // ------------------------------------------------------------------------
1357 public void testCurrentTimeValues() throws TmfTraceException
{
1359 TmfTraceStub trace
= null;
1360 File testfile
= null;
1362 final URL location
= FileLocator
.find(TmfCoreTestPlugin
.getDefault().getBundle(), new Path(TEST_TRACE
.getFullPath()), null);
1363 testfile
= new File(FileLocator
.toFileURL(location
).toURI());
1364 trace
= new TmfTraceStub(testfile
.toURI().getPath(), ITmfTrace
.DEFAULT_TRACE_CACHE_SIZE
, false, null);
1365 // verify initial values
1366 TmfTimestamp defaultInitRange
= new TmfTimestamp(DEFAULT_INITIAL_OFFSET_VALUE
, ITmfTimestamp
.NANOSECOND_SCALE
);
1367 assertEquals("getInitialRangeOffset", defaultInitRange
, trace
.getInitialRangeOffset());
1368 trace
.setInitialRangeOffset(new TmfTimestamp(5, ITmfTimestamp
.MILLISECOND_SCALE
));
1369 trace
.indexTrace(true);
1371 TmfTimestamp initRange
= new TmfTimestamp(5, ITmfTimestamp
.MILLISECOND_SCALE
);
1372 assertEquals("getInitialRangeOffset", initRange
, trace
.getInitialRangeOffset());
1374 } catch (final URISyntaxException e
) {
1375 fail("URISyntaxException");
1376 } catch (final IOException e
) {
1377 fail("IOException");
1382 * Run the String getHostId() method test
1385 public void testTraceHostId() {
1386 String a
= fTrace
.getHostId();
1387 assertEquals("A-Test-10K", a
);