1 /*******************************************************************************
2 * Copyright (c) 2009, 2010, 2012 Ericsson
4 * All rights reserved. This program and the accompanying materials are
5 * made available under the terms of the Eclipse Public License v1.0 which
6 * accompanies this distribution, and is available at
7 * http://www.eclipse.org/legal/epl-v10.html
10 * Francois Chouinard - Initial API and implementation
11 * Francois Chouinard - Adapted for TMF Trace Model 1.0
12 *******************************************************************************/
14 package org
.eclipse
.linuxtools
.tmf
.core
.tests
.trace
;
17 import java
.io
.IOException
;
18 import java
.net
.URISyntaxException
;
20 import java
.util
.Collection
;
21 import java
.util
.Vector
;
23 import junit
.framework
.TestCase
;
25 import org
.eclipse
.core
.runtime
.FileLocator
;
26 import org
.eclipse
.core
.runtime
.Path
;
27 import org
.eclipse
.linuxtools
.internal
.tmf
.core
.component
.TmfProviderManager
;
28 import org
.eclipse
.linuxtools
.tmf
.core
.component
.ITmfDataProvider
;
29 import org
.eclipse
.linuxtools
.tmf
.core
.event
.ITmfEvent
;
30 import org
.eclipse
.linuxtools
.tmf
.core
.event
.ITmfTimestamp
;
31 import org
.eclipse
.linuxtools
.tmf
.core
.event
.TmfEvent
;
32 import org
.eclipse
.linuxtools
.tmf
.core
.event
.TmfTimeRange
;
33 import org
.eclipse
.linuxtools
.tmf
.core
.event
.TmfTimestamp
;
34 import org
.eclipse
.linuxtools
.tmf
.core
.exceptions
.TmfTraceException
;
35 import org
.eclipse
.linuxtools
.tmf
.core
.request
.TmfDataRequest
;
36 import org
.eclipse
.linuxtools
.tmf
.core
.request
.TmfEventRequest
;
37 import org
.eclipse
.linuxtools
.tmf
.core
.statesystem
.ITmfStateSystem
;
38 import org
.eclipse
.linuxtools
.tmf
.core
.statistics
.ITmfStatistics
;
39 import org
.eclipse
.linuxtools
.tmf
.core
.tests
.TmfCoreTestPlugin
;
40 import org
.eclipse
.linuxtools
.tmf
.core
.trace
.ITmfContext
;
41 import org
.eclipse
.linuxtools
.tmf
.core
.trace
.ITmfLocation
;
42 import org
.eclipse
.linuxtools
.tmf
.core
.trace
.ITmfTrace
;
43 import org
.eclipse
.linuxtools
.tmf
.core
.trace
.TmfCheckpointIndexer
;
44 import org
.eclipse
.linuxtools
.tmf
.core
.trace
.TmfContext
;
45 import org
.eclipse
.linuxtools
.tmf
.tests
.stubs
.trace
.TmfTraceStub
;
48 * Test suite for the TmfTrace class.
50 @SuppressWarnings({"nls","javadoc"})
51 public class TmfTraceTest
extends TestCase
{
53 // ------------------------------------------------------------------------
55 // ------------------------------------------------------------------------
56 private static final long DEFAULT_INITIAL_OFFSET_VALUE
= (1L * 100 * 1000 * 1000); // .1sec
57 private static final String DIRECTORY
= "testfiles";
58 private static final String TEST_STREAM
= "A-Test-10K";
59 private static final int BLOCK_SIZE
= 500;
60 private static final int NB_EVENTS
= 10000;
61 private static TmfTraceStub fTrace
= null;
63 private static int SCALE
= -3;
65 // ------------------------------------------------------------------------
67 // ------------------------------------------------------------------------
70 * @param name the test name
72 public TmfTraceTest(final String name
) {
77 protected void setUp() throws Exception
{
79 fTrace
= setupTrace(DIRECTORY
+ File
.separator
+ TEST_STREAM
);
83 protected void tearDown() throws Exception
{
89 // ------------------------------------------------------------------------
91 // ------------------------------------------------------------------------
93 private static TmfTraceStub
setupTrace(final String path
) {
96 final URL location
= FileLocator
.find(TmfCoreTestPlugin
.getDefault().getBundle(), new Path(path
), null);
97 final File test
= new File(FileLocator
.toFileURL(location
).toURI());
98 fTrace
= new TmfTraceStub(test
.toURI().getPath(), BLOCK_SIZE
);
100 } catch (final TmfTraceException e
) {
102 } catch (final URISyntaxException e
) {
104 } catch (final IOException e
) {
111 // ------------------------------------------------------------------------
113 // ------------------------------------------------------------------------
115 @SuppressWarnings("null")
116 public void testStandardConstructor() throws TmfTraceException
{
117 TmfTraceStub trace
= null;
118 File testfile
= null;
120 final URL location
= FileLocator
.find(TmfCoreTestPlugin
.getDefault().getBundle(), new Path(DIRECTORY
+ File
.separator
+ TEST_STREAM
), null);
121 testfile
= new File(FileLocator
.toFileURL(location
).toURI());
122 trace
= new TmfTraceStub(testfile
.toURI().getPath());
124 } catch (final URISyntaxException e
) {
125 fail("URISyntaxException");
126 } catch (final IOException e
) {
130 assertFalse ("Open trace", trace
== null);
131 assertEquals("getType", TmfEvent
.class, trace
.getType());
132 assertNull ("getResource", trace
.getResource());
133 assertEquals("getPath", testfile
.toURI().getPath(), trace
.getPath());
134 assertEquals("getCacheSize", ITmfTrace
.DEFAULT_TRACE_CACHE_SIZE
, trace
.getCacheSize());
135 assertEquals("getStreamingInterval", 0, trace
.getStreamingInterval());
136 assertEquals("getName", TEST_STREAM
, trace
.getName());
138 assertEquals("getNbEvents", NB_EVENTS
, trace
.getNbEvents());
139 assertEquals("getRange-start", 1, trace
.getTimeRange().getStartTime().getValue());
140 assertEquals("getRange-end", NB_EVENTS
, trace
.getTimeRange().getEndTime().getValue());
141 assertEquals("getStartTime", 1, trace
.getStartTime().getValue());
142 assertEquals("getEndTime", NB_EVENTS
, trace
.getEndTime().getValue());
145 @SuppressWarnings("null")
146 public void testStandardConstructorCacheSize() throws TmfTraceException
{
147 TmfTraceStub trace
= null;
148 File testfile
= null;
150 final URL location
= FileLocator
.find(TmfCoreTestPlugin
.getDefault().getBundle(), new Path(DIRECTORY
+ File
.separator
+ TEST_STREAM
), null);
151 testfile
= new File(FileLocator
.toFileURL(location
).toURI());
152 trace
= new TmfTraceStub(testfile
.toURI().getPath(), 0);
154 } catch (final URISyntaxException e
) {
155 fail("URISyntaxException");
156 } catch (final IOException e
) {
160 assertFalse ("Open trace", trace
== null);
161 assertEquals("getType", TmfEvent
.class, trace
.getType());
162 assertNull ("getResource", trace
.getResource());
163 assertEquals("getPath", testfile
.toURI().getPath(), trace
.getPath());
164 assertEquals("getCacheSize", ITmfTrace
.DEFAULT_TRACE_CACHE_SIZE
, trace
.getCacheSize());
165 assertEquals("getStreamingInterval", 0, trace
.getStreamingInterval());
166 assertEquals("getName", TEST_STREAM
, trace
.getName());
168 assertEquals("getNbEvents", NB_EVENTS
, trace
.getNbEvents());
169 assertEquals("getRange-start", 1, trace
.getTimeRange().getStartTime().getValue());
170 assertEquals("getRange-end", NB_EVENTS
, trace
.getTimeRange().getEndTime().getValue());
171 assertEquals("getStartTime", 1, trace
.getStartTime().getValue());
172 assertEquals("getEndTime", NB_EVENTS
, trace
.getEndTime().getValue());
175 final URL location
= FileLocator
.find(TmfCoreTestPlugin
.getDefault().getBundle(), new Path(DIRECTORY
+ File
.separator
+ TEST_STREAM
), null);
176 testfile
= new File(FileLocator
.toFileURL(location
).toURI());
177 trace
= new TmfTraceStub(testfile
.toURI().getPath(), BLOCK_SIZE
);
179 } catch (final URISyntaxException e
) {
180 fail("URISyntaxException");
181 } catch (final IOException e
) {
185 assertEquals("getType", TmfEvent
.class, trace
.getType());
186 assertNull ("getResource", trace
.getResource());
187 assertEquals("getPath", testfile
.toURI().getPath(), trace
.getPath());
188 assertEquals("getCacheSize", BLOCK_SIZE
, trace
.getCacheSize());
189 assertEquals("getStreamingInterval", 0, trace
.getStreamingInterval());
190 assertEquals("getName", TEST_STREAM
, trace
.getName());
192 assertEquals("getNbEvents", NB_EVENTS
, trace
.getNbEvents());
193 assertEquals("getRange-start", 1, trace
.getTimeRange().getStartTime().getValue());
194 assertEquals("getRange-end", NB_EVENTS
, trace
.getTimeRange().getEndTime().getValue());
195 assertEquals("getStartTime", 1, trace
.getStartTime().getValue());
196 assertEquals("getEndTime", NB_EVENTS
, trace
.getEndTime().getValue());
199 @SuppressWarnings("null")
200 public void testFullConstructor() throws TmfTraceException
{
201 TmfTraceStub trace
= null;
202 File testfile
= null;
204 final URL location
= FileLocator
.find(TmfCoreTestPlugin
.getDefault().getBundle(), new Path(DIRECTORY
+ File
.separator
+ TEST_STREAM
), null);
205 testfile
= new File(FileLocator
.toFileURL(location
).toURI());
206 trace
= new TmfTraceStub(testfile
.toURI().getPath(), BLOCK_SIZE
, null);
208 } catch (final URISyntaxException e
) {
209 fail("URISyntaxException");
210 } catch (final IOException e
) {
214 assertFalse ("Open trace", trace
== null);
215 assertEquals("getType", TmfEvent
.class, trace
.getType());
216 assertNull ("getResource", trace
.getResource());
217 assertEquals("getPath", testfile
.toURI().getPath(), trace
.getPath());
218 assertEquals("getCacheSize", BLOCK_SIZE
, trace
.getCacheSize());
219 assertEquals("getStreamingInterval", 0, trace
.getStreamingInterval());
220 assertEquals("getName", TEST_STREAM
, trace
.getName());
222 assertEquals("getNbEvents", NB_EVENTS
, trace
.getNbEvents());
223 assertEquals("getRange-start", 1, trace
.getTimeRange().getStartTime().getValue());
224 assertEquals("getRange-end", NB_EVENTS
, trace
.getTimeRange().getEndTime().getValue());
225 assertEquals("getStartTime", 1, trace
.getStartTime().getValue());
226 assertEquals("getEndTime", NB_EVENTS
, trace
.getEndTime().getValue());
229 @SuppressWarnings("null")
230 public void testLiveTraceConstructor() throws TmfTraceException
{
231 TmfTraceStub trace
= null;
232 File testfile
= null;
233 final long interval
= 100;
235 final URL location
= FileLocator
.find(TmfCoreTestPlugin
.getDefault().getBundle(), new Path(DIRECTORY
+ File
.separator
+ TEST_STREAM
), null);
236 testfile
= new File(FileLocator
.toFileURL(location
).toURI());
237 trace
= new TmfTraceStub(testfile
.toURI().getPath(), BLOCK_SIZE
, interval
);
239 } catch (final URISyntaxException e
) {
240 fail("URISyntaxException");
241 } catch (final IOException e
) {
245 assertFalse ("Open trace", trace
== null);
246 assertEquals("getType", TmfEvent
.class, trace
.getType());
247 assertNull ("getResource", trace
.getResource());
248 assertEquals("getPath", testfile
.toURI().getPath(), trace
.getPath());
249 assertEquals("getCacheSize", BLOCK_SIZE
, trace
.getCacheSize());
250 assertEquals("getStreamingInterval", interval
, trace
.getStreamingInterval());
251 assertEquals("getName", TEST_STREAM
, trace
.getName());
253 assertEquals("getNbEvents", NB_EVENTS
, trace
.getNbEvents());
254 assertEquals("getRange-start", 1, trace
.getTimeRange().getStartTime().getValue());
255 assertEquals("getRange-end", NB_EVENTS
, trace
.getTimeRange().getEndTime().getValue());
256 assertEquals("getStartTime", 1, trace
.getStartTime().getValue());
257 assertEquals("getEndTime", NB_EVENTS
, trace
.getEndTime().getValue());
260 @SuppressWarnings("null")
261 public void testCopyConstructor() throws TmfTraceException
{
262 TmfTraceStub original
= null;
263 TmfTraceStub trace
= null;
264 File testfile
= null;
266 final URL location
= FileLocator
.find(TmfCoreTestPlugin
.getDefault().getBundle(), new Path(DIRECTORY
+ File
.separator
+ TEST_STREAM
), null);
267 testfile
= new File(FileLocator
.toFileURL(location
).toURI());
268 original
= new TmfTraceStub(testfile
.toURI().getPath(), BLOCK_SIZE
, new TmfCheckpointIndexer(null));
269 trace
= new TmfTraceStub(original
);
271 } catch (final URISyntaxException e
) {
272 fail("URISyntaxException");
273 } catch (final IOException e
) {
277 assertFalse ("Open trace", trace
== null);
278 assertEquals("getType", TmfEvent
.class, trace
.getType());
279 assertNull ("getResource", trace
.getResource());
280 assertEquals("getPath", testfile
.toURI().getPath(), trace
.getPath());
281 assertEquals("getCacheSize", BLOCK_SIZE
, trace
.getCacheSize());
282 assertEquals("getStreamingInterval", 0, trace
.getStreamingInterval());
283 assertEquals("getName", TEST_STREAM
, trace
.getName());
285 assertEquals("getNbEvents", NB_EVENTS
, trace
.getNbEvents());
286 assertEquals("getRange-start", 1, trace
.getTimeRange().getStartTime().getValue());
287 assertEquals("getRange-end", NB_EVENTS
, trace
.getTimeRange().getEndTime().getValue());
288 assertEquals("getStartTime", 1, trace
.getStartTime().getValue());
289 assertEquals("getEndTime", NB_EVENTS
, trace
.getEndTime().getValue());
291 // Test the copy of a null trace
293 new TmfTraceStub((TmfTraceStub
) null);
294 fail("Missing exception");
295 } catch (final IllegalArgumentException e
) {
297 } catch (final Exception e
) {
298 fail("Unexpected exception");
302 // ------------------------------------------------------------------------
303 // Trace initialization
304 // ------------------------------------------------------------------------
306 public void testInitializeNullPath() {
308 // Instantiate an "empty" trace
309 final TmfTraceStub trace
= new TmfTraceStub();
312 trace
.initialize(null, null, TmfEvent
.class);
313 fail("TmfTrace.initialize() - no exception thrown");
314 } catch (TmfTraceException e
) {
316 } catch (Exception e
) {
317 fail("TmfTrace.initialize() - wrong exception thrown");
321 public void testInitializeSimplePath() {
323 // Instantiate an "empty" trace
324 final TmfTraceStub trace
= new TmfTraceStub();
326 // Path == trace name
327 String path
= "TraceName";
329 trace
.initialize(null, path
, TmfEvent
.class);
330 } catch (Exception e
) {
331 fail("TmfTrace.initialize() - Exception thrown");
334 assertEquals("getType", TmfEvent
.class, trace
.getType());
335 assertNull ("getResource", trace
.getResource());
336 assertEquals("getPath", path
, trace
.getPath());
337 assertEquals("getCacheSize", ITmfTrace
.DEFAULT_TRACE_CACHE_SIZE
, trace
.getCacheSize());
338 assertEquals("getStreamingInterval", 0, trace
.getStreamingInterval());
339 assertEquals("getName", path
, trace
.getName());
341 assertEquals("getNbEvents", 0, trace
.getNbEvents());
342 assertEquals("getRange-start", Long
.MIN_VALUE
, trace
.getTimeRange().getStartTime().getValue());
343 assertEquals("getRange-end", Long
.MIN_VALUE
, trace
.getTimeRange().getEndTime().getValue());
344 assertEquals("getStartTime", Long
.MIN_VALUE
, trace
.getStartTime().getValue());
345 assertEquals("getEndTime", Long
.MIN_VALUE
, trace
.getEndTime().getValue());
348 public void testInitializeNormalPath() {
350 // Instantiate an "empty" trace
351 final TmfTraceStub trace
= new TmfTraceStub();
353 // Path == trace name
354 String name
= "TraceName";
355 String path
= "/my/trace/path/" + name
;
357 trace
.initialize(null, path
, TmfEvent
.class);
358 } catch (Exception e
) {
359 fail("TmfTrace.initialize() - Exception thrown");
362 assertEquals("getType", TmfEvent
.class, trace
.getType());
363 assertNull ("getResource", trace
.getResource());
364 assertEquals("getPath", path
, trace
.getPath());
365 assertEquals("getCacheSize", ITmfTrace
.DEFAULT_TRACE_CACHE_SIZE
, trace
.getCacheSize());
366 assertEquals("getStreamingInterval", 0, trace
.getStreamingInterval());
367 assertEquals("getName", name
, trace
.getName());
369 assertEquals("getNbEvents", 0, trace
.getNbEvents());
370 assertEquals("getRange-start", Long
.MIN_VALUE
, trace
.getTimeRange().getStartTime().getValue());
371 assertEquals("getRange-end", Long
.MIN_VALUE
, trace
.getTimeRange().getEndTime().getValue());
372 assertEquals("getStartTime", Long
.MIN_VALUE
, trace
.getStartTime().getValue());
373 assertEquals("getEndTime", Long
.MIN_VALUE
, trace
.getEndTime().getValue());
376 public void testInitTrace() throws URISyntaxException
, IOException
, TmfTraceException
, InterruptedException
{
378 // Instantiate an "empty" trace
379 final TmfTraceStub trace
= new TmfTraceStub();
381 assertNull ("getType", trace
.getType());
382 assertNull ("getResource", trace
.getResource());
383 assertEquals("getCacheSize", ITmfTrace
.DEFAULT_TRACE_CACHE_SIZE
, trace
.getCacheSize());
384 assertEquals("getStreamingInterval", 0, trace
.getStreamingInterval());
385 assertEquals("getName", "", trace
.getName());
387 assertEquals("getNbEvents", 0, trace
.getNbEvents());
388 assertEquals("getRange-start", Long
.MIN_VALUE
, trace
.getTimeRange().getStartTime().getValue());
389 assertEquals("getRange-end", Long
.MIN_VALUE
, trace
.getTimeRange().getEndTime().getValue());
390 assertEquals("getStartTime", Long
.MIN_VALUE
, trace
.getStartTime().getValue());
391 assertEquals("getEndTime", Long
.MIN_VALUE
, trace
.getEndTime().getValue());
394 final URL location
= FileLocator
.find(TmfCoreTestPlugin
.getDefault().getBundle(), new Path(DIRECTORY
+ File
.separator
+ TEST_STREAM
), null);
395 final File testfile
= new File(FileLocator
.toFileURL(location
).toURI());
396 assertTrue("validate", trace
.validate(null, testfile
.getPath()));
398 // InitTrace and wait for indexing completion...
399 trace
.initTrace(null, testfile
.toURI().getPath(), TmfEvent
.class);
402 while (trace
.getNbEvents() < NB_EVENTS
&& nbSecs
< 10) {
406 if (trace
.getNbEvents() < NB_EVENTS
) {
410 assertEquals("getType", TmfEvent
.class, trace
.getType());
411 assertNull ("getResource", trace
.getResource());
412 assertEquals("getCacheSize", ITmfTrace
.DEFAULT_TRACE_CACHE_SIZE
, trace
.getCacheSize());
413 assertEquals("getStreamingInterval", 0, trace
.getStreamingInterval());
414 assertEquals("getName", TEST_STREAM
, trace
.getName());
416 assertEquals("getNbEvents", NB_EVENTS
, trace
.getNbEvents());
417 assertEquals("getRange-start", 1, trace
.getTimeRange().getStartTime().getValue());
418 assertEquals("getRange-end", NB_EVENTS
, trace
.getTimeRange().getEndTime().getValue());
419 assertEquals("getStartTime", 1, trace
.getStartTime().getValue());
420 assertEquals("getEndTime", NB_EVENTS
, trace
.getEndTime().getValue());
423 // ------------------------------------------------------------------------
424 // Set/Get streaming interval
425 // ------------------------------------------------------------------------
427 public void testSetStreamingInterval() throws TmfTraceException
{
428 final TmfTraceStub trace
= new TmfTraceStub(fTrace
);
431 assertEquals("getStreamingInterval", interval
, trace
.getStreamingInterval());
434 trace
.setStreamingInterval(interval
);
435 assertEquals("getStreamingInterval", interval
, trace
.getStreamingInterval());
438 trace
.setStreamingInterval(interval
);
439 assertEquals("getStreamingInterval", 0, trace
.getStreamingInterval());
442 trace
.setStreamingInterval(interval
);
443 assertEquals("getStreamingInterval", interval
, trace
.getStreamingInterval());
448 // ------------------------------------------------------------------------
449 // Set/Get time range
450 // ------------------------------------------------------------------------
452 public void testSetTimeRange() throws TmfTraceException
{
453 final TmfTraceStub trace
= new TmfTraceStub(fTrace
);
456 assertEquals("getRange-start", 1, trace
.getTimeRange().getStartTime().getValue());
457 assertEquals("getRange-end", NB_EVENTS
, trace
.getTimeRange().getEndTime().getValue());
458 assertEquals("getStartTime", 1, trace
.getStartTime().getValue());
459 assertEquals("getEndTime", NB_EVENTS
, trace
.getEndTime().getValue());
461 trace
.setTimeRange(new TmfTimeRange(new TmfTimestamp(100), new TmfTimestamp(200)));
462 assertEquals("setTimeRange", 100, trace
.getTimeRange().getStartTime().getValue());
463 assertEquals("setTimeRange", 200, trace
.getTimeRange().getEndTime().getValue());
464 assertEquals("setTimeRange", 100, trace
.getStartTime().getValue());
465 assertEquals("setTimeRange", 200, trace
.getEndTime().getValue());
470 public void testSetStartTime() throws TmfTraceException
{
471 final TmfTraceStub trace
= new TmfTraceStub(fTrace
);
474 assertEquals("getRange-start", 1, trace
.getTimeRange().getStartTime().getValue());
475 assertEquals("getRange-end", NB_EVENTS
, trace
.getTimeRange().getEndTime().getValue());
476 assertEquals("getStartTime", 1, trace
.getStartTime().getValue());
477 assertEquals("getEndTime", NB_EVENTS
, trace
.getEndTime().getValue());
479 trace
.setStartTime(new TmfTimestamp(100));
480 assertEquals("setStartTime", 100, trace
.getTimeRange().getStartTime().getValue());
481 assertEquals("setStartTime", NB_EVENTS
, trace
.getTimeRange().getEndTime().getValue());
482 assertEquals("setStartTime", 100, trace
.getStartTime().getValue());
483 assertEquals("setStartTime", NB_EVENTS
, trace
.getEndTime().getValue());
488 public void testSetEndTime() throws TmfTraceException
{
489 final TmfTraceStub trace
= new TmfTraceStub(fTrace
);
492 assertEquals("getRange-start", 1, trace
.getTimeRange().getStartTime().getValue());
493 assertEquals("getRange-end", NB_EVENTS
, trace
.getTimeRange().getEndTime().getValue());
494 assertEquals("getStartTime", 1, trace
.getStartTime().getValue());
495 assertEquals("getEndTime", NB_EVENTS
, trace
.getEndTime().getValue());
497 trace
.setEndTime(new TmfTimestamp(100));
498 assertEquals("setEndTime", 1, trace
.getTimeRange().getStartTime().getValue());
499 assertEquals("setEndTime", 100, trace
.getTimeRange().getEndTime().getValue());
500 assertEquals("setEndTime", 1, trace
.getStartTime().getValue());
501 assertEquals("setEndTime", 100, trace
.getEndTime().getValue());
506 public void testSetNbEvents() throws TmfTraceException
{
507 final TmfTraceStub trace
= new TmfTraceStub(fTrace
);
510 assertEquals("getNbEvents", NB_EVENTS
, trace
.getNbEvents());
512 trace
.setNbEvents(0);
513 assertEquals("getNbEvents", 0, trace
.getNbEvents());
515 trace
.setNbEvents(-1);
516 assertEquals("getNbEvents", 0, trace
.getNbEvents());
518 trace
.setNbEvents(NB_EVENTS
+ 1);
519 assertEquals("getNbEvents", NB_EVENTS
+ 1, trace
.getNbEvents());
521 trace
.setNbEvents(NB_EVENTS
);
522 assertEquals("getNbEvents", NB_EVENTS
, trace
.getNbEvents());
527 // ------------------------------------------------------------------------
528 // State system and statistics methods
529 // ------------------------------------------------------------------------
531 public void testGetStatistics() {
532 /* Should be null in unit tests */
533 ITmfStatistics stats
= fTrace
.getStatistics();
537 public void testGetStateSystem() {
538 /* There should be no state system registered so far */
539 ITmfStateSystem ss
= fTrace
.getStateSystem("something");
543 public void testListStateSystem() {
544 Collection
<String
> sss
= fTrace
.listStateSystems();
546 assertEquals(0, sss
.size());
549 // ------------------------------------------------------------------------
550 // seekEvent on location (note: does not reliably set the rank)
551 // ------------------------------------------------------------------------
553 public void testSeekEventOnCacheBoundary() {
555 // Position trace at event rank 0
556 ITmfContext context
= fTrace
.seekEvent(0);
557 ITmfEvent event
= fTrace
.parseEvent(context
);
558 assertEquals("Event timestamp", 1, event
.getTimestamp().getValue());
559 assertEquals("Event rank", 0, context
.getRank());
561 context
= fTrace
.seekEvent(context
.getLocation());
562 assertEquals("Event rank", ITmfContext
.UNKNOWN_RANK
, context
.getRank());
564 event
= fTrace
.parseEvent(context
);
565 assertEquals("Event timestamp", 1, event
.getTimestamp().getValue());
566 assertEquals("Event rank", ITmfContext
.UNKNOWN_RANK
, context
.getRank());
568 event
= fTrace
.getNext(context
);
569 assertEquals("Event timestamp", 1, event
.getTimestamp().getValue());
570 assertEquals("Event rank", ITmfContext
.UNKNOWN_RANK
, context
.getRank());
572 // Position trace at event rank 1000
573 ITmfContext tmpContext
= fTrace
.seekEvent(new TmfTimestamp(1001, SCALE
, 0));
574 context
= fTrace
.seekEvent(tmpContext
.getLocation());
575 assertEquals("Event rank", ITmfContext
.UNKNOWN_RANK
, context
.getRank());
577 event
= fTrace
.parseEvent(context
);
578 assertEquals("Event timestamp", 1001, event
.getTimestamp().getValue());
579 assertEquals("Event rank", ITmfContext
.UNKNOWN_RANK
, context
.getRank());
581 event
= fTrace
.getNext(context
);
582 assertEquals("Event timestamp", 1001, event
.getTimestamp().getValue());
583 assertEquals("Event rank", ITmfContext
.UNKNOWN_RANK
, context
.getRank());
585 // Position trace at event rank 4000
586 tmpContext
= fTrace
.seekEvent(new TmfTimestamp(4001, SCALE
, 0));
587 context
= fTrace
.seekEvent(tmpContext
.getLocation());
588 assertEquals("Event rank", ITmfContext
.UNKNOWN_RANK
, context
.getRank());
590 event
= fTrace
.parseEvent(context
);
591 assertEquals("Event timestamp", 4001, event
.getTimestamp().getValue());
592 assertEquals("Event rank", ITmfContext
.UNKNOWN_RANK
, context
.getRank());
594 event
= fTrace
.getNext(context
);
595 assertEquals("Event timestamp", 4001, event
.getTimestamp().getValue());
596 assertEquals("Event rank", ITmfContext
.UNKNOWN_RANK
, context
.getRank());
599 public void testSeekEventNotOnCacheBoundary() {
601 // Position trace at event rank 9
602 ITmfContext tmpContext
= fTrace
.seekEvent(new TmfTimestamp(10, SCALE
, 0));
603 TmfContext context
= fTrace
.seekEvent(tmpContext
.getLocation());
604 assertEquals("Event rank", ITmfContext
.UNKNOWN_RANK
, context
.getRank());
606 ITmfEvent event
= fTrace
.parseEvent(context
);
607 assertEquals("Event timestamp", 10, event
.getTimestamp().getValue());
608 assertEquals("Event rank", ITmfContext
.UNKNOWN_RANK
, context
.getRank());
610 event
= fTrace
.getNext(context
);
611 assertEquals("Event timestamp", 10, event
.getTimestamp().getValue());
612 assertEquals("Event rank", ITmfContext
.UNKNOWN_RANK
, context
.getRank());
614 // Position trace at event rank 999
615 tmpContext
= fTrace
.seekEvent(new TmfTimestamp(1000, SCALE
, 0));
616 context
= fTrace
.seekEvent(tmpContext
.getLocation());
617 assertEquals("Event rank", ITmfContext
.UNKNOWN_RANK
, context
.getRank());
619 event
= fTrace
.parseEvent(context
);
620 assertEquals("Event timestamp", 1000, event
.getTimestamp().getValue());
621 assertEquals("Event rank", ITmfContext
.UNKNOWN_RANK
, context
.getRank());
623 event
= fTrace
.getNext(context
);
624 assertEquals("Event timestamp", 1000, event
.getTimestamp().getValue());
625 assertEquals("Event rank", ITmfContext
.UNKNOWN_RANK
, context
.getRank());
627 // Position trace at event rank 1001
628 tmpContext
= fTrace
.seekEvent(new TmfTimestamp(1002, SCALE
, 0));
629 context
= fTrace
.seekEvent(tmpContext
.getLocation());
630 assertEquals("Event rank", ITmfContext
.UNKNOWN_RANK
, context
.getRank());
632 event
= fTrace
.parseEvent(context
);
633 assertEquals("Event timestamp", 1002, event
.getTimestamp().getValue());
634 assertEquals("Event rank", ITmfContext
.UNKNOWN_RANK
, context
.getRank());
636 event
= fTrace
.getNext(context
);
637 assertEquals("Event timestamp", 1002, event
.getTimestamp().getValue());
638 assertEquals("Event rank", ITmfContext
.UNKNOWN_RANK
, context
.getRank());
640 // Position trace at event rank 4500
641 tmpContext
= fTrace
.seekEvent(new TmfTimestamp(4501, SCALE
, 0));
642 context
= fTrace
.seekEvent(tmpContext
.getLocation());
643 assertEquals("Event rank", ITmfContext
.UNKNOWN_RANK
, context
.getRank());
645 event
= fTrace
.parseEvent(context
);
646 assertEquals("Event timestamp", 4501, event
.getTimestamp().getValue());
647 assertEquals("Event rank", ITmfContext
.UNKNOWN_RANK
, context
.getRank());
649 event
= fTrace
.getNext(context
);
650 assertEquals("Event timestamp", 4501, event
.getTimestamp().getValue());
651 assertEquals("Event rank", ITmfContext
.UNKNOWN_RANK
, context
.getRank());
654 public void testSeekEventOutOfScope() {
656 // Position trace at beginning
657 ITmfContext tmpContext
= fTrace
.seekEvent(0);
658 ITmfContext context
= fTrace
.seekEvent(tmpContext
.getLocation());
659 assertEquals("Event rank", ITmfContext
.UNKNOWN_RANK
, context
.getRank());
661 ITmfEvent event
= fTrace
.parseEvent(context
);
662 assertEquals("Event timestamp", 1, event
.getTimestamp().getValue());
663 assertEquals("Event rank", ITmfContext
.UNKNOWN_RANK
, context
.getRank());
665 event
= fTrace
.getNext(context
);
666 assertEquals("Event timestamp", 1, event
.getTimestamp().getValue());
667 assertEquals("Event rank", ITmfContext
.UNKNOWN_RANK
, context
.getRank());
669 // Position trace at event passed the end
670 context
= fTrace
.seekEvent(new TmfTimestamp(NB_EVENTS
+ 1, SCALE
, 0));
671 assertNull("Event timestamp", context
.getLocation());
672 assertEquals("Event rank", ITmfContext
.UNKNOWN_RANK
, context
.getRank());
674 event
= fTrace
.getNext(context
);
675 assertNull("Event", event
);
678 // ------------------------------------------------------------------------
679 // seekEvent on timestamp (note: does not reliably set the rank)
680 // ------------------------------------------------------------------------
682 public void testSeekEventOnNullTimestamp() {
684 // Position trace at event rank 0
685 ITmfContext context
= fTrace
.seekEvent((ITmfTimestamp
) null);
686 assertEquals("Event rank", 0, context
.getRank());
688 ITmfEvent event
= fTrace
.parseEvent(context
);
689 assertEquals("Event timestamp", 1, event
.getTimestamp().getValue());
690 assertEquals("Event rank", 0, context
.getRank());
693 public void testSeekEventOnTimestampOnCacheBoundary() {
695 // Position trace at event rank 0
696 ITmfContext context
= fTrace
.seekEvent(new TmfTimestamp(1, SCALE
, 0));
697 assertEquals("Event rank", 0, context
.getRank());
699 ITmfEvent event
= fTrace
.parseEvent(context
);
700 assertEquals("Event timestamp", 1, event
.getTimestamp().getValue());
701 assertEquals("Event rank", 0, context
.getRank());
703 event
= fTrace
.getNext(context
);
704 assertEquals("Event timestamp", 1, event
.getTimestamp().getValue());
705 assertEquals("Event rank", 1, context
.getRank());
707 // Position trace at event rank 1000
708 context
= fTrace
.seekEvent(new TmfTimestamp(1001, SCALE
, 0));
709 assertEquals("Event rank", 1000, context
.getRank());
711 event
= fTrace
.parseEvent(context
);
712 assertEquals("Event timestamp", 1001, event
.getTimestamp().getValue());
713 assertEquals("Event rank", 1000, context
.getRank());
715 event
= fTrace
.getNext(context
);
716 assertEquals("Event timestamp", 1001, event
.getTimestamp().getValue());
717 assertEquals("Event rank", 1001, context
.getRank());
719 // Position trace at event rank 4000
720 context
= fTrace
.seekEvent(new TmfTimestamp(4001, SCALE
, 0));
721 assertEquals("Event rank", 4000, context
.getRank());
723 event
= fTrace
.parseEvent(context
);
724 assertEquals("Event timestamp", 4001, event
.getTimestamp().getValue());
725 assertEquals("Event rank", 4000, context
.getRank());
727 event
= fTrace
.getNext(context
);
728 assertEquals("Event timestamp", 4001, event
.getTimestamp().getValue());
729 assertEquals("Event rank", 4001, context
.getRank());
732 public void testSeekEventOnTimestampNotOnCacheBoundary() {
734 // Position trace at event rank 1
735 ITmfContext context
= fTrace
.seekEvent(new TmfTimestamp(2, SCALE
, 0));
736 assertEquals("Event rank", 1, context
.getRank());
738 ITmfEvent event
= fTrace
.parseEvent(context
);
739 assertEquals("Event timestamp", 2, event
.getTimestamp().getValue());
740 assertEquals("Event rank", 1, context
.getRank());
742 event
= fTrace
.getNext(context
);
743 assertEquals("Event timestamp", 2, event
.getTimestamp().getValue());
744 assertEquals("Event rank", 2, context
.getRank());
746 // Position trace at event rank 9
747 context
= fTrace
.seekEvent(new TmfTimestamp(10, SCALE
, 0));
748 assertEquals("Event rank", 9, context
.getRank());
750 event
= fTrace
.parseEvent(context
);
751 assertEquals("Event timestamp", 10, event
.getTimestamp().getValue());
752 assertEquals("Event rank", 9, context
.getRank());
754 event
= fTrace
.getNext(context
);
755 assertEquals("Event timestamp", 10, event
.getTimestamp().getValue());
756 assertEquals("Event rank", 10, context
.getRank());
758 // Position trace at event rank 999
759 context
= fTrace
.seekEvent(new TmfTimestamp(1000, SCALE
, 0));
760 assertEquals("Event rank", 999, context
.getRank());
762 event
= fTrace
.parseEvent(context
);
763 assertEquals("Event timestamp", 1000, event
.getTimestamp().getValue());
764 assertEquals("Event rank", 999, context
.getRank());
766 event
= fTrace
.getNext(context
);
767 assertEquals("Event timestamp", 1000, event
.getTimestamp().getValue());
768 assertEquals("Event rank", 1000, context
.getRank());
770 // Position trace at event rank 1001
771 context
= fTrace
.seekEvent(new TmfTimestamp(1002, SCALE
, 0));
772 assertEquals("Event rank", 1001, context
.getRank());
774 event
= fTrace
.parseEvent(context
);
775 assertEquals("Event timestamp", 1002, event
.getTimestamp().getValue());
776 assertEquals("Event rank", 1001, context
.getRank());
778 event
= fTrace
.getNext(context
);
779 assertEquals("Event timestamp", 1002, event
.getTimestamp().getValue());
780 assertEquals("Event rank", 1002, context
.getRank());
782 // Position trace at event rank 4500
783 context
= fTrace
.seekEvent(new TmfTimestamp(4501, SCALE
, 0));
784 assertEquals("Event rank", 4500, context
.getRank());
786 event
= fTrace
.parseEvent(context
);
787 assertEquals("Event timestamp", 4501, event
.getTimestamp().getValue());
788 assertEquals("Event rank", 4500, context
.getRank());
790 event
= fTrace
.getNext(context
);
791 assertEquals("Event timestamp", 4501, event
.getTimestamp().getValue());
792 assertEquals("Event rank", 4501, context
.getRank());
795 public void testSeekEventOnTimestampOutOfScope() {
797 // Position trace at beginning
798 ITmfContext context
= fTrace
.seekEvent(new TmfTimestamp(-1, SCALE
, 0));
799 assertEquals("Event rank", 0, context
.getRank());
801 ITmfEvent event
= fTrace
.parseEvent(context
);
802 assertEquals("Event timestamp", 1, event
.getTimestamp().getValue());
803 assertEquals("Event rank", 0, context
.getRank());
805 event
= fTrace
.getNext(context
);
806 assertEquals("Event timestamp", 1, event
.getTimestamp().getValue());
807 assertEquals("Event rank", 1, context
.getRank());
809 // Position trace at event passed the end
810 context
= fTrace
.seekEvent(new TmfTimestamp(NB_EVENTS
+ 1, SCALE
, 0));
811 assertEquals("Event rank", ITmfContext
.UNKNOWN_RANK
, context
.getRank());
813 event
= fTrace
.parseEvent(context
);
814 assertEquals("Event timestamp", null, event
);
815 assertEquals("Event rank", ITmfContext
.UNKNOWN_RANK
, context
.getRank());
817 event
= fTrace
.getNext(context
);
818 assertEquals("Event timestamp", null, event
);
819 assertEquals("Event rank", ITmfContext
.UNKNOWN_RANK
, context
.getRank());
822 // ------------------------------------------------------------------------
824 // ------------------------------------------------------------------------
826 public void testSeekEventOnNegativeRank() {
828 // Position trace at event rank 0
829 ITmfContext context
= fTrace
.seekEvent(-1);
830 assertEquals("Event rank", 0, context
.getRank());
832 ITmfEvent event
= fTrace
.parseEvent(context
);
833 assertEquals("Event timestamp", 1, event
.getTimestamp().getValue());
834 assertEquals("Event rank", 0, context
.getRank());
837 public void testSeekOnRankOnCacheBoundary() {
839 // On lower bound, returns the first event (ts = 1)
840 ITmfContext context
= fTrace
.seekEvent(0);
841 assertEquals("Event rank", 0, context
.getRank());
843 ITmfEvent event
= fTrace
.parseEvent(context
);
844 assertEquals("Event timestamp", 1, event
.getTimestamp().getValue());
845 assertEquals("Event rank", 0, context
.getRank());
847 event
= fTrace
.getNext(context
);
848 assertEquals("Event timestamp", 1, event
.getTimestamp().getValue());
849 assertEquals("Event rank", 1, context
.getRank());
851 // Position trace at event rank 1000
852 context
= fTrace
.seekEvent(1000);
853 assertEquals("Event rank", 1000, context
.getRank());
855 event
= fTrace
.parseEvent(context
);
856 assertEquals("Event timestamp", 1001, event
.getTimestamp().getValue());
857 assertEquals("Event rank", 1000, context
.getRank());
859 event
= fTrace
.getNext(context
);
860 assertEquals("Event timestamp", 1001, event
.getTimestamp().getValue());
861 assertEquals("Event rank", 1001, context
.getRank());
863 // Position trace at event rank 4000
864 context
= fTrace
.seekEvent(4000);
865 assertEquals("Event rank", 4000, context
.getRank());
867 event
= fTrace
.parseEvent(context
);
868 assertEquals("Event timestamp", 4001, event
.getTimestamp().getValue());
869 assertEquals("Event rank", 4000, context
.getRank());
871 event
= fTrace
.getNext(context
);
872 assertEquals("Event timestamp", 4001, event
.getTimestamp().getValue());
873 assertEquals("Event rank", 4001, context
.getRank());
876 public void testSeekOnRankNotOnCacheBoundary() {
878 // Position trace at event rank 9
879 ITmfContext context
= fTrace
.seekEvent(9);
880 assertEquals("Event rank", 9, context
.getRank());
882 ITmfEvent event
= fTrace
.parseEvent(context
);
883 assertEquals("Event timestamp", 10, event
.getTimestamp().getValue());
884 assertEquals("Event rank", 9, context
.getRank());
886 event
= fTrace
.getNext(context
);
887 assertEquals("Event timestamp", 10, event
.getTimestamp().getValue());
888 assertEquals("Event rank", 10, context
.getRank());
890 // Position trace at event rank 999
891 context
= fTrace
.seekEvent(999);
892 assertEquals("Event rank", 999, context
.getRank());
894 event
= fTrace
.parseEvent(context
);
895 assertEquals("Event timestamp", 1000, event
.getTimestamp().getValue());
896 assertEquals("Event rank", 999, context
.getRank());
898 event
= fTrace
.getNext(context
);
899 assertEquals("Event timestamp", 1000, event
.getTimestamp().getValue());
900 assertEquals("Event rank", 1000, context
.getRank());
902 // Position trace at event rank 1001
903 context
= fTrace
.seekEvent(1001);
904 assertEquals("Event rank", 1001, context
.getRank());
906 event
= fTrace
.parseEvent(context
);
907 assertEquals("Event timestamp", 1002, event
.getTimestamp().getValue());
908 assertEquals("Event rank", 1001, context
.getRank());
910 event
= fTrace
.getNext(context
);
911 assertEquals("Event timestamp", 1002, event
.getTimestamp().getValue());
912 assertEquals("Event rank", 1002, context
.getRank());
914 // Position trace at event rank 4500
915 context
= fTrace
.seekEvent(4500);
916 assertEquals("Event rank", 4500, context
.getRank());
918 event
= fTrace
.parseEvent(context
);
919 assertEquals("Event timestamp", 4501, event
.getTimestamp().getValue());
920 assertEquals("Event rank", 4500, context
.getRank());
922 event
= fTrace
.getNext(context
);
923 assertEquals("Event timestamp", 4501, event
.getTimestamp().getValue());
924 assertEquals("Event rank", 4501, context
.getRank());
927 public void testSeekEventOnRankOutOfScope() {
929 // Position trace at beginning
930 ITmfContext context
= fTrace
.seekEvent(-1);
931 assertEquals("Event rank", 0, context
.getRank());
933 ITmfEvent event
= fTrace
.parseEvent(context
);
934 assertEquals("Event timestamp", 1, event
.getTimestamp().getValue());
935 assertEquals("Event rank", 0, context
.getRank());
937 event
= fTrace
.getNext(context
);
938 assertEquals("Event timestamp", 1, event
.getTimestamp().getValue());
939 assertEquals("Event rank", 1, context
.getRank());
941 // Position trace at event passed the end
942 context
= fTrace
.seekEvent(NB_EVENTS
);
943 assertEquals("Event rank", NB_EVENTS
, context
.getRank());
945 event
= fTrace
.parseEvent(context
);
946 assertNull("Event", event
);
947 assertEquals("Event rank", NB_EVENTS
, context
.getRank());
949 event
= fTrace
.getNext(context
);
950 assertNull("Event", event
);
951 assertEquals("Event rank", NB_EVENTS
, context
.getRank());
954 // ------------------------------------------------------------------------
955 // parseEvent - make sure parseEvent doesn't update the context
956 // ------------------------------------------------------------------------
958 public void testParseEvent() {
960 final int NB_READS
= 20;
962 // On lower bound, returns the first event (ts = 0)
963 final TmfContext context
= (TmfContext
) fTrace
.seekEvent(new TmfTimestamp(0, SCALE
, 0));
964 TmfContext svContext
= new TmfContext(context
);
966 ITmfEvent event
= fTrace
.parseEvent(context
);
967 assertEquals("Event timestamp", 1, event
.getTimestamp().getValue());
968 assertEquals("Event rank", 0, context
.getRank());
969 assertTrue("parseEvent", context
.equals(svContext
));
971 event
= fTrace
.parseEvent(context
);
972 assertEquals("Event timestamp", 1, event
.getTimestamp().getValue());
973 assertEquals("Event rank", 0, context
.getRank());
974 assertTrue("parseEvent", context
.equals(svContext
));
976 event
= fTrace
.parseEvent(context
);
977 assertEquals("Event timestamp", 1, event
.getTimestamp().getValue());
978 assertEquals("Event rank", 0, context
.getRank());
979 assertTrue("parseEvent", context
.equals(svContext
));
981 // Position the trace at event NB_READS
982 for (int i
= 1; i
< NB_READS
; i
++) {
983 event
= fTrace
.getNext(context
);
984 assertEquals("Event timestamp", i
, event
.getTimestamp().getValue());
987 svContext
= new TmfContext(context
);
988 event
= fTrace
.parseEvent(context
);
989 assertEquals("Event timestamp", NB_READS
, event
.getTimestamp().getValue());
990 assertEquals("Event rank", NB_READS
-1 , context
.getRank());
991 assertTrue("parseEvent", context
.equals(svContext
));
993 event
= fTrace
.parseEvent(context
);
994 assertEquals("Event timestamp", NB_READS
, event
.getTimestamp().getValue());
995 assertEquals("Event rank", NB_READS
- 1, context
.getRank());
996 assertTrue("parseEvent", context
.equals(svContext
));
999 // ------------------------------------------------------------------------
1000 // getNext - updates the context
1001 // ------------------------------------------------------------------------
1003 public void testGetNextAfteSeekingOnTS_1() {
1005 final long INITIAL_TS
= 1;
1006 final int NB_READS
= 20;
1008 // On lower bound, returns the first event (ts = 1)
1009 final ITmfContext context
= fTrace
.seekEvent(new TmfTimestamp(INITIAL_TS
, SCALE
, 0));
1013 for (int i
= 0; i
< NB_READS
; i
++) {
1014 event
= fTrace
.getNext(context
);
1015 assertEquals("Event timestamp", INITIAL_TS
+ i
, event
.getTimestamp().getValue());
1016 assertEquals("Event rank", INITIAL_TS
+ i
, context
.getRank());
1019 // Make sure we stay positioned
1020 event
= fTrace
.parseEvent(context
);
1021 assertEquals("Event timestamp", INITIAL_TS
+ NB_READS
, event
.getTimestamp().getValue());
1022 assertEquals("Event rank", INITIAL_TS
+ NB_READS
- 1, context
.getRank());
1025 public void testGetNextAfteSeekingOnTS_2() {
1027 final long INITIAL_TS
= 2;
1028 final int NB_READS
= 20;
1030 // On lower bound, returns the first event (ts = 500)
1031 final ITmfContext context
= fTrace
.seekEvent(new TmfTimestamp(INITIAL_TS
, SCALE
, 0));
1035 for (int i
= 0; i
< NB_READS
; i
++) {
1036 event
= fTrace
.getNext(context
);
1037 assertEquals("Event timestamp", INITIAL_TS
+ i
, event
.getTimestamp().getValue());
1038 assertEquals("Event rank", INITIAL_TS
+ i
, context
.getRank());
1041 // Make sure we stay positioned
1042 event
= fTrace
.parseEvent(context
);
1043 assertEquals("Event timestamp", INITIAL_TS
+ NB_READS
, event
.getTimestamp().getValue());
1044 assertEquals("Event rank", INITIAL_TS
+ NB_READS
- 1, context
.getRank());
1047 public void testGetNextAfteSeekingOnTS_3() {
1049 final long INITIAL_TS
= 500;
1050 final int NB_READS
= 20;
1052 // On lower bound, returns the first event (ts = 500)
1053 final ITmfContext context
= fTrace
.seekEvent(new TmfTimestamp(INITIAL_TS
, SCALE
, 0));
1057 for (int i
= 0; i
< NB_READS
; i
++) {
1058 event
= fTrace
.getNext(context
);
1059 assertEquals("Event timestamp", INITIAL_TS
+ i
, event
.getTimestamp().getValue());
1060 assertEquals("Event rank", INITIAL_TS
+ i
, context
.getRank());
1063 // Make sure we stay positioned
1064 event
= fTrace
.parseEvent(context
);
1065 assertEquals("Event timestamp", INITIAL_TS
+ NB_READS
, event
.getTimestamp().getValue());
1066 assertEquals("Event rank", INITIAL_TS
+ NB_READS
- 1, context
.getRank());
1069 public void testGetNextAfterSeekingOnRank_1() {
1071 final long INITIAL_RANK
= 0L;
1072 final int NB_READS
= 20;
1074 // On lower bound, returns the first event (rank = 0)
1075 final ITmfContext context
= fTrace
.seekEvent(INITIAL_RANK
);
1079 for (int i
= 0; i
< NB_READS
; i
++) {
1080 event
= fTrace
.getNext(context
);
1081 assertEquals("Event timestamp", INITIAL_RANK
+ i
+ 1, event
.getTimestamp().getValue());
1082 assertEquals("Event rank", INITIAL_RANK
+ i
+ 1, context
.getRank());
1085 // Make sure we stay positioned
1086 event
= fTrace
.parseEvent(context
);
1087 assertEquals("Event timestamp", INITIAL_RANK
+ NB_READS
+ 1, event
.getTimestamp().getValue());
1088 assertEquals("Event rank", INITIAL_RANK
+ NB_READS
, context
.getRank());
1091 public void testGetNextAfterSeekingOnRank_2() {
1093 final long INITIAL_RANK
= 1L;
1094 final int NB_READS
= 20;
1096 // On lower bound, returns the first event (rank = 0)
1097 final ITmfContext context
= fTrace
.seekEvent(INITIAL_RANK
);
1101 for (int i
= 0; i
< NB_READS
; i
++) {
1102 event
= fTrace
.getNext(context
);
1103 assertEquals("Event timestamp", INITIAL_RANK
+ i
+ 1, event
.getTimestamp().getValue());
1104 assertEquals("Event rank", INITIAL_RANK
+ i
+ 1, context
.getRank());
1107 // Make sure we stay positioned
1108 event
= fTrace
.parseEvent(context
);
1109 assertEquals("Event timestamp", INITIAL_RANK
+ NB_READS
+ 1, event
.getTimestamp().getValue());
1110 assertEquals("Event rank", INITIAL_RANK
+ NB_READS
, context
.getRank());
1113 public void testGetNextAfterSeekingOnRank_3() {
1115 final long INITIAL_RANK
= 500L;
1116 final int NB_READS
= 20;
1118 // On lower bound, returns the first event (rank = 0)
1119 final ITmfContext context
= fTrace
.seekEvent(INITIAL_RANK
);
1123 for (int i
= 0; i
< NB_READS
; i
++) {
1124 event
= fTrace
.getNext(context
);
1125 assertEquals("Event timestamp", INITIAL_RANK
+ i
+ 1, event
.getTimestamp().getValue());
1126 assertEquals("Event rank", INITIAL_RANK
+ i
+ 1, context
.getRank());
1129 // Make sure we stay positioned
1130 event
= fTrace
.parseEvent(context
);
1131 assertEquals("Event timestamp", INITIAL_RANK
+ NB_READS
+ 1, event
.getTimestamp().getValue());
1132 assertEquals("Event rank", INITIAL_RANK
+ NB_READS
, context
.getRank());
1135 public void testGetNextAfterSeekingOnLocation_1() {
1137 final ITmfLocation INITIAL_LOC
= null;
1138 final long INITIAL_TS
= 1;
1139 final int NB_READS
= 20;
1141 // On lower bound, returns the first event (ts = 1)
1142 final ITmfContext context
= fTrace
.seekEvent(INITIAL_LOC
);
1146 for (int i
= 0; i
< NB_READS
; i
++) {
1147 event
= fTrace
.getNext(context
);
1148 assertEquals("Event timestamp", INITIAL_TS
+ i
, event
.getTimestamp().getValue());
1149 assertEquals("Event rank", INITIAL_TS
+ i
, context
.getRank());
1152 // Make sure we stay positioned
1153 event
= fTrace
.parseEvent(context
);
1154 assertEquals("Event timestamp", INITIAL_TS
+ NB_READS
, event
.getTimestamp().getValue());
1155 assertEquals("Event rank", INITIAL_TS
+ NB_READS
- 1, context
.getRank());
1158 public void testGetNextAfterSeekingOnLocation_2() {
1160 final ITmfLocation INITIAL_LOC
= fTrace
.seekEvent(1L).getLocation();
1161 final long INITIAL_TS
= 2;
1162 final int NB_READS
= 20;
1164 // On lower bound, returns the first event (ts = 501)
1165 final ITmfContext context
= fTrace
.seekEvent(INITIAL_LOC
);
1169 for (int i
= 0; i
< NB_READS
; i
++) {
1170 event
= fTrace
.getNext(context
);
1171 assertEquals("Event timestamp", INITIAL_TS
+ i
, event
.getTimestamp().getValue());
1174 // Make sure we stay positioned
1175 event
= fTrace
.parseEvent(context
);
1176 assertEquals("Event timestamp", INITIAL_TS
+ NB_READS
, event
.getTimestamp().getValue());
1179 public void testGetNextAfterSeekingOnLocation_3() {
1181 final ITmfLocation INITIAL_LOC
= fTrace
.seekEvent(500L).getLocation();
1182 final long INITIAL_TS
= 501;
1183 final int NB_READS
= 20;
1185 // On lower bound, returns the first event (ts = 501)
1186 final ITmfContext context
= fTrace
.seekEvent(INITIAL_LOC
);
1190 for (int i
= 0; i
< NB_READS
; i
++) {
1191 event
= fTrace
.getNext(context
);
1192 assertEquals("Event timestamp", INITIAL_TS
+ i
, event
.getTimestamp().getValue());
1195 // Make sure we stay positioned
1196 event
= fTrace
.parseEvent(context
);
1197 assertEquals("Event timestamp", INITIAL_TS
+ NB_READS
, event
.getTimestamp().getValue());
1200 public void testGetNextLocation() {
1201 ITmfContext context1
= fTrace
.seekEvent(0);
1202 fTrace
.getNext(context1
);
1203 ITmfLocation location
= context1
.getLocation();
1204 ITmfEvent event1
= fTrace
.getNext(context1
);
1205 ITmfContext context2
= fTrace
.seekEvent(location
);
1206 ITmfEvent event2
= fTrace
.getNext(context2
);
1207 assertEquals("Event timestamp", event1
.getTimestamp().getValue(), event2
.getTimestamp().getValue());
1210 public void testGetNextEndLocation() {
1211 ITmfContext context1
= fTrace
.seekEvent(fTrace
.getNbEvents() - 1);
1212 fTrace
.getNext(context1
);
1213 ITmfLocation location
= context1
.getLocation();
1214 ITmfContext context2
= fTrace
.seekEvent(location
);
1215 ITmfEvent event
= fTrace
.getNext(context2
);
1216 assertNull("Event", event
);
1219 // ------------------------------------------------------------------------
1221 // ------------------------------------------------------------------------
1223 @SuppressWarnings("hiding")
1224 public void testProcessEventRequestForAllEvents() throws InterruptedException
{
1225 final int BLOCK_SIZE
= 1;
1226 final Vector
<ITmfEvent
> requestedEvents
= new Vector
<ITmfEvent
>();
1228 final TmfTimeRange range
= new TmfTimeRange(TmfTimestamp
.BIG_BANG
, TmfTimestamp
.BIG_CRUNCH
);
1229 final TmfEventRequest request
= new TmfEventRequest(TmfEvent
.class, range
, NB_EVENTS
, BLOCK_SIZE
) {
1231 public void handleData(final ITmfEvent event
) {
1232 super.handleData(event
);
1233 requestedEvents
.add(event
);
1236 final ITmfDataProvider
[] providers
= TmfProviderManager
.getProviders(TmfEvent
.class, TmfTraceStub
.class);
1237 providers
[0].sendRequest(request
);
1238 request
.waitForCompletion();
1240 assertEquals("nbEvents", NB_EVENTS
, requestedEvents
.size());
1241 assertTrue("isCompleted", request
.isCompleted());
1242 assertFalse("isCancelled", request
.isCancelled());
1244 // Ensure that we have distinct events.
1245 // Don't go overboard: we are not validating the stub!
1246 for (int i
= 0; i
< NB_EVENTS
; i
++) {
1247 assertEquals("Distinct events", i
+ 1, requestedEvents
.get(i
).getTimestamp().getValue());
1251 @SuppressWarnings("hiding")
1252 public void testProcessEventRequestForNbEvents() throws InterruptedException
{
1253 final int BLOCK_SIZE
= 100;
1254 final int NB_EVENTS
= 1000;
1255 final Vector
<ITmfEvent
> requestedEvents
= new Vector
<ITmfEvent
>();
1257 final TmfTimeRange range
= new TmfTimeRange(TmfTimestamp
.BIG_BANG
, TmfTimestamp
.BIG_CRUNCH
);
1258 final TmfEventRequest request
= new TmfEventRequest(TmfEvent
.class, range
, NB_EVENTS
, BLOCK_SIZE
) {
1260 public void handleData(final ITmfEvent event
) {
1261 super.handleData(event
);
1262 requestedEvents
.add(event
);
1265 final ITmfDataProvider
[] providers
= TmfProviderManager
.getProviders(TmfEvent
.class, TmfTraceStub
.class);
1266 providers
[0].sendRequest(request
);
1267 request
.waitForCompletion();
1269 assertEquals("nbEvents", NB_EVENTS
, requestedEvents
.size());
1270 assertTrue("isCompleted", request
.isCompleted());
1271 assertFalse("isCancelled", request
.isCancelled());
1273 // Ensure that we have distinct events.
1274 // Don't go overboard: we are not validating the stub!
1275 for (int i
= 0; i
< NB_EVENTS
; i
++) {
1276 assertEquals("Distinct events", i
+ 1, requestedEvents
.get(i
).getTimestamp().getValue());
1280 @SuppressWarnings("hiding")
1281 public void testProcessEventRequestForSomeEvents() throws InterruptedException
{
1282 final int BLOCK_SIZE
= 1;
1283 final long startTime
= 100;
1284 final int NB_EVENTS
= 1000;
1285 final Vector
<ITmfEvent
> requestedEvents
= new Vector
<ITmfEvent
>();
1287 final TmfTimeRange range
= new TmfTimeRange(new TmfTimestamp(startTime
, SCALE
), TmfTimestamp
.BIG_CRUNCH
);
1288 final TmfEventRequest request
= new TmfEventRequest(TmfEvent
.class, range
, NB_EVENTS
, BLOCK_SIZE
) {
1290 public void handleData(final ITmfEvent event
) {
1291 super.handleData(event
);
1292 requestedEvents
.add(event
);
1295 final ITmfDataProvider
[] providers
= TmfProviderManager
.getProviders(TmfEvent
.class, TmfTraceStub
.class);
1296 providers
[0].sendRequest(request
);
1297 request
.waitForCompletion();
1299 assertEquals("nbEvents", NB_EVENTS
, requestedEvents
.size());
1300 assertTrue("isCompleted", request
.isCompleted());
1301 assertFalse("isCancelled", request
.isCancelled());
1303 // Ensure that we have distinct events.
1304 // Don't go overboard: we are not validating the stub!
1305 for (int i
= 0; i
< NB_EVENTS
; i
++) {
1306 assertEquals("Distinct events", startTime
+ i
, requestedEvents
.get(i
).getTimestamp().getValue());
1310 @SuppressWarnings("hiding")
1311 public void testProcessEventRequestForOtherEvents() throws InterruptedException
{
1312 final int BLOCK_SIZE
= 1;
1313 final int startIndex
= 99;
1314 final long startTime
= 100;
1315 final int NB_EVENTS
= 1000;
1316 final Vector
<ITmfEvent
> requestedEvents
= new Vector
<ITmfEvent
>();
1318 final TmfTimeRange range
= new TmfTimeRange(new TmfTimestamp(startTime
, SCALE
), TmfTimestamp
.BIG_CRUNCH
);
1319 final TmfEventRequest request
= new TmfEventRequest(TmfEvent
.class, range
, startIndex
, NB_EVENTS
, BLOCK_SIZE
) {
1321 public void handleData(final ITmfEvent event
) {
1322 super.handleData(event
);
1323 requestedEvents
.add(event
);
1326 final ITmfDataProvider
[] providers
= TmfProviderManager
.getProviders(TmfEvent
.class, TmfTraceStub
.class);
1327 providers
[0].sendRequest(request
);
1328 request
.waitForCompletion();
1330 assertEquals("nbEvents", NB_EVENTS
, requestedEvents
.size());
1331 assertTrue("isCompleted", request
.isCompleted());
1332 assertFalse("isCancelled", request
.isCancelled());
1334 // Ensure that we have distinct events.
1335 // Don't go overboard: we are not validating the stub!
1336 for (int i
= 0; i
< NB_EVENTS
; i
++) {
1337 assertEquals("Distinct events", startTime
+ i
, requestedEvents
.get(i
).getTimestamp().getValue());
1341 @SuppressWarnings("hiding")
1342 public void testProcessDataRequestForSomeEvents() throws InterruptedException
{
1343 final int startIndex
= 100;
1344 final int NB_EVENTS
= 1000;
1345 final Vector
<ITmfEvent
> requestedEvents
= new Vector
<ITmfEvent
>();
1347 final TmfDataRequest request
= new TmfDataRequest(TmfEvent
.class, startIndex
, NB_EVENTS
) {
1349 public void handleData(final ITmfEvent event
) {
1350 super.handleData(event
);
1351 requestedEvents
.add(event
);
1354 final ITmfDataProvider
[] providers
= TmfProviderManager
.getProviders(TmfEvent
.class, TmfTraceStub
.class);
1355 providers
[0].sendRequest(request
);
1356 request
.waitForCompletion();
1358 assertEquals("nbEvents", NB_EVENTS
, requestedEvents
.size());
1359 assertTrue("isCompleted", request
.isCompleted());
1360 assertFalse("isCancelled", request
.isCancelled());
1362 // Ensure that we have distinct events.
1363 // Don't go overboard: we are not validating the stub!
1364 for (int i
= 0; i
< NB_EVENTS
; i
++) {
1365 assertEquals("Distinct events", startIndex
+ 1 + i
, requestedEvents
.get(i
).getTimestamp().getValue());
1369 // ------------------------------------------------------------------------
1371 // ------------------------------------------------------------------------
1373 public void testCancel() throws InterruptedException
{
1374 final Vector
<ITmfEvent
> requestedEvents
= new Vector
<ITmfEvent
>();
1376 final TmfTimeRange range
= new TmfTimeRange(TmfTimestamp
.BIG_BANG
, TmfTimestamp
.BIG_CRUNCH
);
1377 final TmfEventRequest request
= new TmfEventRequest(TmfEvent
.class, range
, NB_EVENTS
, BLOCK_SIZE
) {
1380 public void handleData(final ITmfEvent event
) {
1381 super.handleData(event
);
1382 requestedEvents
.add(event
);
1383 if (++nbRead
== BLOCK_SIZE
) {
1388 final ITmfDataProvider
[] providers
= TmfProviderManager
.getProviders(TmfEvent
.class, TmfTraceStub
.class);
1389 providers
[0].sendRequest(request
);
1390 request
.waitForCompletion();
1392 assertEquals("nbEvents", BLOCK_SIZE
, requestedEvents
.size());
1393 assertTrue("isCompleted", request
.isCompleted());
1394 assertTrue("isCancelled", request
.isCancelled());
1397 // ------------------------------------------------------------------------
1399 // ------------------------------------------------------------------------
1401 public void testDefaultTmfTraceStub() {
1402 assertFalse ("Open trace", fTrace
== null);
1403 assertEquals("getType", TmfEvent
.class, fTrace
.getType());
1404 assertNull ("getResource", fTrace
.getResource());
1405 assertEquals("getCacheSize", BLOCK_SIZE
, fTrace
.getCacheSize());
1406 assertEquals("getStreamingInterval", 0, fTrace
.getStreamingInterval());
1407 assertEquals("getName", TEST_STREAM
, fTrace
.getName());
1409 assertEquals("getNbEvents", NB_EVENTS
, fTrace
.getNbEvents());
1410 assertEquals("getRange-start", 1, fTrace
.getTimeRange().getStartTime().getValue());
1411 assertEquals("getRange-end", NB_EVENTS
, fTrace
.getTimeRange().getEndTime().getValue());
1412 assertEquals("getStartTime", 1, fTrace
.getStartTime().getValue());
1413 assertEquals("getEndTime", NB_EVENTS
, fTrace
.getEndTime().getValue());
1415 String expected
= "TmfTrace [fPath=" + fTrace
.getPath() + ", fCacheSize=" + fTrace
.getCacheSize() +
1416 ", fNbEvents=" + fTrace
.getNbEvents() + ", fStartTime=" + fTrace
.getStartTime() +
1417 ", fEndTime=" + fTrace
.getEndTime() + ", fStreamingInterval=" + fTrace
.getStreamingInterval() +
1419 assertEquals("toString", expected
, fTrace
.toString());
1422 // ------------------------------------------------------------------------
1423 // getInitialRangeOffset, getCurrentRange, getCurrentTime
1424 // ------------------------------------------------------------------------
1425 @SuppressWarnings("null")
1426 public void testCurrentTimeValues() throws TmfTraceException
{
1428 TmfTraceStub trace
= null;
1429 File testfile
= null;
1431 final URL location
= FileLocator
.find(TmfCoreTestPlugin
.getDefault().getBundle(), new Path(DIRECTORY
+ File
.separator
+ TEST_STREAM
), null);
1432 testfile
= new File(FileLocator
.toFileURL(location
).toURI());
1433 trace
= new TmfTraceStub(testfile
.toURI().getPath());
1434 // verify initial values
1435 TmfTimestamp defaultInitRange
= new TmfTimestamp(DEFAULT_INITIAL_OFFSET_VALUE
, ITmfTimestamp
.NANOSECOND_SCALE
);
1436 assertEquals("getInitialRangeOffset", defaultInitRange
, trace
.getInitialRangeOffset());
1437 assertEquals("getCurrentTime", TmfTimestamp
.ZERO
, trace
.getCurrentTime());
1438 assertEquals("getCurrentRange", TmfTimeRange
.NULL_RANGE
, trace
.getCurrentRange());
1439 trace
.setInitialRangeOffset(new TmfTimestamp(5, ITmfTimestamp
.MILLISECOND_SCALE
));
1441 } catch (final URISyntaxException e
) {
1442 fail("URISyntaxException");
1443 } catch (final IOException e
) {
1444 fail("IOException");
1446 assertFalse ("Open trace", trace
== null);
1448 TmfTimestamp initRange
= new TmfTimestamp(5, ITmfTimestamp
.MILLISECOND_SCALE
);
1449 assertEquals("getInitialRangeOffset", initRange
, trace
.getInitialRangeOffset());
1450 assertEquals("getCurrentTime", trace
.getTimeRange().getStartTime(), trace
.getCurrentTime());
1452 ITmfTimestamp startTimestamp
= trace
.getTimeRange().getStartTime();
1453 long endValue
= startTimestamp
.getValue() + initRange
.normalize(0, startTimestamp
.getScale()).getValue();
1454 ITmfTimestamp endTimestamp
= new TmfTimestamp(endValue
, startTimestamp
.getScale());
1455 TmfTimeRange expectedRange
= new TmfTimeRange(startTimestamp
, endTimestamp
);
1456 assertEquals("getCurrentRange", expectedRange
, trace
.getCurrentRange());