1 /*******************************************************************************
2 * Copyright (c) 2009, 2013 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
.assertNull
;
20 import static org
.junit
.Assert
.assertTrue
;
21 import static org
.junit
.Assert
.fail
;
24 import java
.io
.IOException
;
25 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
.component
.ITmfDataProvider
;
34 import org
.eclipse
.linuxtools
.tmf
.core
.event
.ITmfEvent
;
35 import org
.eclipse
.linuxtools
.tmf
.core
.exceptions
.TmfTraceException
;
36 import org
.eclipse
.linuxtools
.tmf
.core
.request
.TmfDataRequest
;
37 import org
.eclipse
.linuxtools
.tmf
.core
.request
.TmfEventRequest
;
38 import org
.eclipse
.linuxtools
.tmf
.core
.statesystem
.ITmfStateSystem
;
39 import org
.eclipse
.linuxtools
.tmf
.core
.statistics
.ITmfStatistics
;
40 import org
.eclipse
.linuxtools
.tmf
.core
.tests
.TmfCoreTestPlugin
;
41 import org
.eclipse
.linuxtools
.tmf
.core
.timestamp
.ITmfTimestamp
;
42 import org
.eclipse
.linuxtools
.tmf
.core
.timestamp
.TmfTimeRange
;
43 import org
.eclipse
.linuxtools
.tmf
.core
.timestamp
.TmfTimestamp
;
44 import org
.eclipse
.linuxtools
.tmf
.core
.trace
.ITmfContext
;
45 import org
.eclipse
.linuxtools
.tmf
.core
.trace
.ITmfLocation
;
46 import org
.eclipse
.linuxtools
.tmf
.core
.trace
.ITmfTrace
;
47 import org
.eclipse
.linuxtools
.tmf
.core
.trace
.TmfCheckpointIndexer
;
48 import org
.eclipse
.linuxtools
.tmf
.core
.trace
.TmfContext
;
49 import org
.eclipse
.linuxtools
.tmf
.tests
.stubs
.trace
.TmfTraceStub
;
50 import org
.junit
.After
;
51 import org
.junit
.Before
;
52 import org
.junit
.Test
;
55 * Test suite for the TmfTrace class.
57 @SuppressWarnings("javadoc")
58 public class TmfTraceTest
{
60 // ------------------------------------------------------------------------
62 // ------------------------------------------------------------------------
64 private static final long DEFAULT_INITIAL_OFFSET_VALUE
= (1L * 100 * 1000 * 1000); // .1sec
65 private static final String DIRECTORY
= "testfiles";
66 private static final String TEST_STREAM
= "A-Test-10K";
67 private static final int BLOCK_SIZE
= 500;
68 private static final int NB_EVENTS
= 10000;
69 private static TmfTraceStub fTrace
= null;
71 private static int SCALE
= -3;
73 // ------------------------------------------------------------------------
75 // ------------------------------------------------------------------------
79 fTrace
= setupTrace(DIRECTORY
+ File
.separator
+ TEST_STREAM
);
83 public void tearDown() {
88 // ------------------------------------------------------------------------
90 // ------------------------------------------------------------------------
92 private static TmfTraceStub
setupTrace(final String path
) {
95 final URL location
= FileLocator
.find(TmfCoreTestPlugin
.getDefault().getBundle(), new Path(path
), null);
96 final File test
= new File(FileLocator
.toFileURL(location
).toURI());
97 fTrace
= new TmfTraceStub(test
.toURI().getPath(), BLOCK_SIZE
);
99 } catch (final TmfTraceException e
) {
101 } catch (final URISyntaxException e
) {
103 } catch (final IOException e
) {
110 // ------------------------------------------------------------------------
112 // ------------------------------------------------------------------------
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", ITmfEvent
.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());
146 @SuppressWarnings("null")
147 public void testStandardConstructorCacheSize() throws TmfTraceException
{
148 TmfTraceStub trace
= null;
149 File testfile
= null;
151 final URL location
= FileLocator
.find(TmfCoreTestPlugin
.getDefault().getBundle(), new Path(DIRECTORY
+ File
.separator
+ TEST_STREAM
), null);
152 testfile
= new File(FileLocator
.toFileURL(location
).toURI());
153 trace
= new TmfTraceStub(testfile
.toURI().getPath(), 0);
155 } catch (final URISyntaxException e
) {
156 fail("URISyntaxException");
157 } catch (final IOException e
) {
161 assertFalse ("Open trace", trace
== null);
162 assertEquals("getType", ITmfEvent
.class, trace
.getType());
163 assertNull ("getResource", trace
.getResource());
164 assertEquals("getPath", testfile
.toURI().getPath(), trace
.getPath());
165 assertEquals("getCacheSize", ITmfTrace
.DEFAULT_TRACE_CACHE_SIZE
, trace
.getCacheSize());
166 assertEquals("getStreamingInterval", 0, trace
.getStreamingInterval());
167 assertEquals("getName", TEST_STREAM
, trace
.getName());
169 assertEquals("getNbEvents", NB_EVENTS
, trace
.getNbEvents());
170 assertEquals("getRange-start", 1, trace
.getTimeRange().getStartTime().getValue());
171 assertEquals("getRange-end", NB_EVENTS
, trace
.getTimeRange().getEndTime().getValue());
172 assertEquals("getStartTime", 1, trace
.getStartTime().getValue());
173 assertEquals("getEndTime", NB_EVENTS
, trace
.getEndTime().getValue());
176 final URL location
= FileLocator
.find(TmfCoreTestPlugin
.getDefault().getBundle(), new Path(DIRECTORY
+ File
.separator
+ TEST_STREAM
), null);
177 testfile
= new File(FileLocator
.toFileURL(location
).toURI());
178 trace
= new TmfTraceStub(testfile
.toURI().getPath(), BLOCK_SIZE
);
180 } catch (final URISyntaxException e
) {
181 fail("URISyntaxException");
182 } catch (final IOException e
) {
186 assertEquals("getType", ITmfEvent
.class, trace
.getType());
187 assertNull ("getResource", trace
.getResource());
188 assertEquals("getPath", testfile
.toURI().getPath(), trace
.getPath());
189 assertEquals("getCacheSize", BLOCK_SIZE
, trace
.getCacheSize());
190 assertEquals("getStreamingInterval", 0, trace
.getStreamingInterval());
191 assertEquals("getName", TEST_STREAM
, trace
.getName());
193 assertEquals("getNbEvents", NB_EVENTS
, trace
.getNbEvents());
194 assertEquals("getRange-start", 1, trace
.getTimeRange().getStartTime().getValue());
195 assertEquals("getRange-end", NB_EVENTS
, trace
.getTimeRange().getEndTime().getValue());
196 assertEquals("getStartTime", 1, trace
.getStartTime().getValue());
197 assertEquals("getEndTime", NB_EVENTS
, trace
.getEndTime().getValue());
201 @SuppressWarnings("null")
202 public void testFullConstructor() throws TmfTraceException
{
203 TmfTraceStub trace
= null;
204 File testfile
= null;
206 final URL location
= FileLocator
.find(TmfCoreTestPlugin
.getDefault().getBundle(), new Path(DIRECTORY
+ File
.separator
+ TEST_STREAM
), null);
207 testfile
= new File(FileLocator
.toFileURL(location
).toURI());
208 trace
= new TmfTraceStub(testfile
.toURI().getPath(), BLOCK_SIZE
, null);
210 } catch (final URISyntaxException e
) {
211 fail("URISyntaxException");
212 } catch (final IOException e
) {
216 assertFalse ("Open trace", trace
== null);
217 assertEquals("getType", ITmfEvent
.class, trace
.getType());
218 assertNull ("getResource", trace
.getResource());
219 assertEquals("getPath", testfile
.toURI().getPath(), trace
.getPath());
220 assertEquals("getCacheSize", BLOCK_SIZE
, trace
.getCacheSize());
221 assertEquals("getStreamingInterval", 0, trace
.getStreamingInterval());
222 assertEquals("getName", TEST_STREAM
, trace
.getName());
224 assertEquals("getNbEvents", NB_EVENTS
, trace
.getNbEvents());
225 assertEquals("getRange-start", 1, trace
.getTimeRange().getStartTime().getValue());
226 assertEquals("getRange-end", NB_EVENTS
, trace
.getTimeRange().getEndTime().getValue());
227 assertEquals("getStartTime", 1, trace
.getStartTime().getValue());
228 assertEquals("getEndTime", NB_EVENTS
, trace
.getEndTime().getValue());
232 @SuppressWarnings("null")
233 public void testLiveTraceConstructor() throws TmfTraceException
{
234 TmfTraceStub trace
= null;
235 File testfile
= null;
236 final long interval
= 100;
238 final URL location
= FileLocator
.find(TmfCoreTestPlugin
.getDefault().getBundle(), new Path(DIRECTORY
+ File
.separator
+ TEST_STREAM
), null);
239 testfile
= new File(FileLocator
.toFileURL(location
).toURI());
240 trace
= new TmfTraceStub(testfile
.toURI().getPath(), BLOCK_SIZE
, interval
);
242 } catch (final URISyntaxException e
) {
243 fail("URISyntaxException");
244 } catch (final IOException e
) {
248 assertFalse ("Open trace", trace
== null);
249 assertEquals("getType", ITmfEvent
.class, trace
.getType());
250 assertNull ("getResource", trace
.getResource());
251 assertEquals("getPath", testfile
.toURI().getPath(), trace
.getPath());
252 assertEquals("getCacheSize", BLOCK_SIZE
, trace
.getCacheSize());
253 assertEquals("getStreamingInterval", interval
, trace
.getStreamingInterval());
254 assertEquals("getName", TEST_STREAM
, trace
.getName());
256 assertEquals("getNbEvents", NB_EVENTS
, trace
.getNbEvents());
257 assertEquals("getRange-start", 1, trace
.getTimeRange().getStartTime().getValue());
258 assertEquals("getRange-end", NB_EVENTS
, trace
.getTimeRange().getEndTime().getValue());
259 assertEquals("getStartTime", 1, trace
.getStartTime().getValue());
260 assertEquals("getEndTime", NB_EVENTS
, trace
.getEndTime().getValue());
264 @SuppressWarnings("null")
265 public void testCopyConstructor() throws TmfTraceException
{
266 TmfTraceStub original
= null;
267 TmfTraceStub trace
= null;
268 File testfile
= null;
270 final URL location
= FileLocator
.find(TmfCoreTestPlugin
.getDefault().getBundle(), new Path(DIRECTORY
+ File
.separator
+ TEST_STREAM
), null);
271 testfile
= new File(FileLocator
.toFileURL(location
).toURI());
272 original
= new TmfTraceStub(testfile
.toURI().getPath(), BLOCK_SIZE
, new TmfCheckpointIndexer(null));
273 trace
= new TmfTraceStub(original
);
275 } catch (final URISyntaxException e
) {
276 fail("URISyntaxException");
277 } catch (final IOException e
) {
281 assertFalse ("Open trace", trace
== null);
282 assertEquals("getType", ITmfEvent
.class, trace
.getType());
283 assertNull ("getResource", trace
.getResource());
284 assertEquals("getPath", testfile
.toURI().getPath(), trace
.getPath());
285 assertEquals("getCacheSize", BLOCK_SIZE
, trace
.getCacheSize());
286 assertEquals("getStreamingInterval", 0, trace
.getStreamingInterval());
287 assertEquals("getName", TEST_STREAM
, trace
.getName());
289 assertEquals("getNbEvents", NB_EVENTS
, trace
.getNbEvents());
290 assertEquals("getRange-start", 1, trace
.getTimeRange().getStartTime().getValue());
291 assertEquals("getRange-end", NB_EVENTS
, trace
.getTimeRange().getEndTime().getValue());
292 assertEquals("getStartTime", 1, trace
.getStartTime().getValue());
293 assertEquals("getEndTime", NB_EVENTS
, trace
.getEndTime().getValue());
295 // Test the copy of a null trace
297 new TmfTraceStub((TmfTraceStub
) null);
298 fail("Missing exception");
299 } catch (final IllegalArgumentException e
) {
301 } catch (final Exception e
) {
302 fail("Unexpected exception");
306 // ------------------------------------------------------------------------
307 // Trace initialization
308 // ------------------------------------------------------------------------
311 public void testInitializeNullPath() {
312 // Instantiate an "empty" trace
313 final TmfTraceStub trace
= new TmfTraceStub();
316 trace
.initialize(null, null, ITmfEvent
.class);
317 fail("TmfTrace.initialize() - no exception thrown");
318 } catch (TmfTraceException e
) {
320 } catch (Exception e
) {
321 fail("TmfTrace.initialize() - wrong exception thrown");
326 public void testInitializeSimplePath() {
327 // Instantiate an "empty" trace
328 final TmfTraceStub trace
= new TmfTraceStub();
330 // Path == trace name
331 String path
= "TraceName";
333 trace
.initialize(null, path
, ITmfEvent
.class);
334 } catch (Exception e
) {
335 fail("TmfTrace.initialize() - Exception thrown");
338 assertEquals("getType", ITmfEvent
.class, trace
.getType());
339 assertNull ("getResource", trace
.getResource());
340 assertEquals("getPath", path
, trace
.getPath());
341 assertEquals("getCacheSize", ITmfTrace
.DEFAULT_TRACE_CACHE_SIZE
, trace
.getCacheSize());
342 assertEquals("getStreamingInterval", 0, trace
.getStreamingInterval());
343 assertEquals("getName", path
, trace
.getName());
345 assertEquals("getNbEvents", 0, trace
.getNbEvents());
346 assertEquals("getRange-start", Long
.MIN_VALUE
, trace
.getTimeRange().getStartTime().getValue());
347 assertEquals("getRange-end", Long
.MIN_VALUE
, trace
.getTimeRange().getEndTime().getValue());
348 assertEquals("getStartTime", Long
.MIN_VALUE
, trace
.getStartTime().getValue());
349 assertEquals("getEndTime", Long
.MIN_VALUE
, trace
.getEndTime().getValue());
353 public void testInitializeNormalPath() {
354 // Instantiate an "empty" trace
355 final TmfTraceStub trace
= new TmfTraceStub();
357 // Path == trace name
358 String name
= "TraceName";
359 String path
= "/my/trace/path/" + name
;
361 trace
.initialize(null, path
, ITmfEvent
.class);
362 } catch (Exception e
) {
363 fail("TmfTrace.initialize() - Exception thrown");
366 assertEquals("getType", ITmfEvent
.class, trace
.getType());
367 assertNull ("getResource", trace
.getResource());
368 assertEquals("getPath", path
, trace
.getPath());
369 assertEquals("getCacheSize", ITmfTrace
.DEFAULT_TRACE_CACHE_SIZE
, trace
.getCacheSize());
370 assertEquals("getStreamingInterval", 0, trace
.getStreamingInterval());
371 assertEquals("getName", name
, trace
.getName());
373 assertEquals("getNbEvents", 0, trace
.getNbEvents());
374 assertEquals("getRange-start", Long
.MIN_VALUE
, trace
.getTimeRange().getStartTime().getValue());
375 assertEquals("getRange-end", Long
.MIN_VALUE
, trace
.getTimeRange().getEndTime().getValue());
376 assertEquals("getStartTime", Long
.MIN_VALUE
, trace
.getStartTime().getValue());
377 assertEquals("getEndTime", Long
.MIN_VALUE
, trace
.getEndTime().getValue());
381 public void testInitTrace() throws URISyntaxException
, IOException
, TmfTraceException
, InterruptedException
{
382 // Instantiate an "empty" trace
383 final TmfTraceStub trace
= new TmfTraceStub();
385 assertNull ("getType", trace
.getType());
386 assertNull ("getResource", trace
.getResource());
387 assertEquals("getCacheSize", ITmfTrace
.DEFAULT_TRACE_CACHE_SIZE
, trace
.getCacheSize());
388 assertEquals("getStreamingInterval", 0, trace
.getStreamingInterval());
389 assertEquals("getName", "", trace
.getName());
391 assertEquals("getNbEvents", 0, trace
.getNbEvents());
392 assertEquals("getRange-start", Long
.MIN_VALUE
, trace
.getTimeRange().getStartTime().getValue());
393 assertEquals("getRange-end", Long
.MIN_VALUE
, trace
.getTimeRange().getEndTime().getValue());
394 assertEquals("getStartTime", Long
.MIN_VALUE
, trace
.getStartTime().getValue());
395 assertEquals("getEndTime", Long
.MIN_VALUE
, trace
.getEndTime().getValue());
398 final URL location
= FileLocator
.find(TmfCoreTestPlugin
.getDefault().getBundle(), new Path(DIRECTORY
+ File
.separator
+ TEST_STREAM
), null);
399 final File testfile
= new File(FileLocator
.toFileURL(location
).toURI());
400 assertTrue("validate", trace
.validate(null, testfile
.getPath()));
402 // InitTrace and wait for indexing completion...
403 trace
.initTrace(null, testfile
.toURI().getPath(), ITmfEvent
.class);
406 while (trace
.getNbEvents() < NB_EVENTS
&& nbSecs
< 10) {
410 if (trace
.getNbEvents() < NB_EVENTS
) {
414 assertEquals("getType", ITmfEvent
.class, trace
.getType());
415 assertNull ("getResource", trace
.getResource());
416 assertEquals("getCacheSize", ITmfTrace
.DEFAULT_TRACE_CACHE_SIZE
, trace
.getCacheSize());
417 assertEquals("getStreamingInterval", 0, trace
.getStreamingInterval());
418 assertEquals("getName", TEST_STREAM
, trace
.getName());
420 assertEquals("getNbEvents", NB_EVENTS
, trace
.getNbEvents());
421 assertEquals("getRange-start", 1, trace
.getTimeRange().getStartTime().getValue());
422 assertEquals("getRange-end", NB_EVENTS
, trace
.getTimeRange().getEndTime().getValue());
423 assertEquals("getStartTime", 1, trace
.getStartTime().getValue());
424 assertEquals("getEndTime", NB_EVENTS
, trace
.getEndTime().getValue());
427 // ------------------------------------------------------------------------
428 // Set/Get streaming interval
429 // ------------------------------------------------------------------------
432 public void testSetStreamingInterval() throws TmfTraceException
{
433 final TmfTraceStub trace
= new TmfTraceStub(fTrace
);
436 assertEquals("getStreamingInterval", interval
, trace
.getStreamingInterval());
439 trace
.setStreamingInterval(interval
);
440 assertEquals("getStreamingInterval", interval
, trace
.getStreamingInterval());
443 trace
.setStreamingInterval(interval
);
444 assertEquals("getStreamingInterval", 0, trace
.getStreamingInterval());
447 trace
.setStreamingInterval(interval
);
448 assertEquals("getStreamingInterval", interval
, trace
.getStreamingInterval());
453 // ------------------------------------------------------------------------
454 // Set/Get time range
455 // ------------------------------------------------------------------------
458 public void testSetTimeRange() throws TmfTraceException
{
459 final TmfTraceStub trace
= new TmfTraceStub(fTrace
);
462 assertEquals("getRange-start", 1, trace
.getTimeRange().getStartTime().getValue());
463 assertEquals("getRange-end", NB_EVENTS
, trace
.getTimeRange().getEndTime().getValue());
464 assertEquals("getStartTime", 1, trace
.getStartTime().getValue());
465 assertEquals("getEndTime", NB_EVENTS
, trace
.getEndTime().getValue());
467 trace
.setTimeRange(new TmfTimeRange(new TmfTimestamp(100), new TmfTimestamp(200)));
468 assertEquals("setTimeRange", 100, trace
.getTimeRange().getStartTime().getValue());
469 assertEquals("setTimeRange", 200, trace
.getTimeRange().getEndTime().getValue());
470 assertEquals("setTimeRange", 100, trace
.getStartTime().getValue());
471 assertEquals("setTimeRange", 200, trace
.getEndTime().getValue());
477 public void testSetStartTime() throws TmfTraceException
{
478 final TmfTraceStub trace
= new TmfTraceStub(fTrace
);
481 assertEquals("getRange-start", 1, trace
.getTimeRange().getStartTime().getValue());
482 assertEquals("getRange-end", NB_EVENTS
, trace
.getTimeRange().getEndTime().getValue());
483 assertEquals("getStartTime", 1, trace
.getStartTime().getValue());
484 assertEquals("getEndTime", NB_EVENTS
, trace
.getEndTime().getValue());
486 trace
.setStartTime(new TmfTimestamp(100));
487 assertEquals("setStartTime", 100, trace
.getTimeRange().getStartTime().getValue());
488 assertEquals("setStartTime", NB_EVENTS
, trace
.getTimeRange().getEndTime().getValue());
489 assertEquals("setStartTime", 100, trace
.getStartTime().getValue());
490 assertEquals("setStartTime", NB_EVENTS
, trace
.getEndTime().getValue());
496 public void testSetEndTime() throws TmfTraceException
{
497 final TmfTraceStub trace
= new TmfTraceStub(fTrace
);
500 assertEquals("getRange-start", 1, trace
.getTimeRange().getStartTime().getValue());
501 assertEquals("getRange-end", NB_EVENTS
, trace
.getTimeRange().getEndTime().getValue());
502 assertEquals("getStartTime", 1, trace
.getStartTime().getValue());
503 assertEquals("getEndTime", NB_EVENTS
, trace
.getEndTime().getValue());
505 trace
.setEndTime(new TmfTimestamp(100));
506 assertEquals("setEndTime", 1, trace
.getTimeRange().getStartTime().getValue());
507 assertEquals("setEndTime", 100, trace
.getTimeRange().getEndTime().getValue());
508 assertEquals("setEndTime", 1, trace
.getStartTime().getValue());
509 assertEquals("setEndTime", 100, trace
.getEndTime().getValue());
515 public void testSetNbEvents() throws TmfTraceException
{
516 final TmfTraceStub trace
= new TmfTraceStub(fTrace
);
519 assertEquals("getNbEvents", NB_EVENTS
, trace
.getNbEvents());
521 trace
.setNbEvents(0);
522 assertEquals("getNbEvents", 0, trace
.getNbEvents());
524 trace
.setNbEvents(-1);
525 assertEquals("getNbEvents", 0, trace
.getNbEvents());
527 trace
.setNbEvents(NB_EVENTS
+ 1);
528 assertEquals("getNbEvents", NB_EVENTS
+ 1, trace
.getNbEvents());
530 trace
.setNbEvents(NB_EVENTS
);
531 assertEquals("getNbEvents", NB_EVENTS
, trace
.getNbEvents());
536 // ------------------------------------------------------------------------
537 // State system and statistics methods
538 // ------------------------------------------------------------------------
541 public void testGetStatistics() {
542 /* Should be null in unit tests */
543 ITmfStatistics stats
= fTrace
.getStatistics();
548 public void testGetStateSystem() {
549 /* There should be no state system registered so far */
550 ITmfStateSystem ss
= fTrace
.getStateSystems().get("something");
555 * Make sure the returned map is unmodifiable.
557 @Test(expected
=UnsupportedOperationException
.class)
558 public void testGetStateSystem_readOnly() {
559 Map
<String
, ITmfStateSystem
> sss
= fTrace
.getStateSystems();
560 sss
.put("something", null);
563 // ------------------------------------------------------------------------
564 // seekEvent on location (note: does not reliably set the rank)
565 // ------------------------------------------------------------------------
568 public void testSeekEventOnCacheBoundary() {
569 // Position trace at event rank 0
570 ITmfContext context
= fTrace
.seekEvent(0);
571 ITmfEvent event
= fTrace
.parseEvent(context
);
572 assertEquals("Event timestamp", 1, event
.getTimestamp().getValue());
573 assertEquals("Event rank", 0, context
.getRank());
575 context
= fTrace
.seekEvent(context
.getLocation());
576 assertEquals("Event rank", ITmfContext
.UNKNOWN_RANK
, context
.getRank());
578 event
= fTrace
.parseEvent(context
);
579 assertEquals("Event timestamp", 1, event
.getTimestamp().getValue());
580 assertEquals("Event rank", ITmfContext
.UNKNOWN_RANK
, context
.getRank());
582 event
= fTrace
.getNext(context
);
583 assertEquals("Event timestamp", 1, event
.getTimestamp().getValue());
584 assertEquals("Event rank", ITmfContext
.UNKNOWN_RANK
, context
.getRank());
586 // Position trace at event rank 1000
587 ITmfContext tmpContext
= fTrace
.seekEvent(new TmfTimestamp(1001, SCALE
, 0));
588 context
= fTrace
.seekEvent(tmpContext
.getLocation());
589 assertEquals("Event rank", ITmfContext
.UNKNOWN_RANK
, context
.getRank());
591 event
= fTrace
.parseEvent(context
);
592 assertEquals("Event timestamp", 1001, event
.getTimestamp().getValue());
593 assertEquals("Event rank", ITmfContext
.UNKNOWN_RANK
, context
.getRank());
595 event
= fTrace
.getNext(context
);
596 assertEquals("Event timestamp", 1001, event
.getTimestamp().getValue());
597 assertEquals("Event rank", ITmfContext
.UNKNOWN_RANK
, context
.getRank());
599 // Position trace at event rank 4000
600 tmpContext
= fTrace
.seekEvent(new TmfTimestamp(4001, SCALE
, 0));
601 context
= fTrace
.seekEvent(tmpContext
.getLocation());
602 assertEquals("Event rank", ITmfContext
.UNKNOWN_RANK
, context
.getRank());
604 event
= fTrace
.parseEvent(context
);
605 assertEquals("Event timestamp", 4001, event
.getTimestamp().getValue());
606 assertEquals("Event rank", ITmfContext
.UNKNOWN_RANK
, context
.getRank());
608 event
= fTrace
.getNext(context
);
609 assertEquals("Event timestamp", 4001, event
.getTimestamp().getValue());
610 assertEquals("Event rank", ITmfContext
.UNKNOWN_RANK
, context
.getRank());
614 public void testSeekEventNotOnCacheBoundary() {
615 // Position trace at event rank 9
616 ITmfContext tmpContext
= fTrace
.seekEvent(new TmfTimestamp(10, SCALE
, 0));
617 TmfContext context
= fTrace
.seekEvent(tmpContext
.getLocation());
618 assertEquals("Event rank", ITmfContext
.UNKNOWN_RANK
, context
.getRank());
620 ITmfEvent event
= fTrace
.parseEvent(context
);
621 assertEquals("Event timestamp", 10, event
.getTimestamp().getValue());
622 assertEquals("Event rank", ITmfContext
.UNKNOWN_RANK
, context
.getRank());
624 event
= fTrace
.getNext(context
);
625 assertEquals("Event timestamp", 10, event
.getTimestamp().getValue());
626 assertEquals("Event rank", ITmfContext
.UNKNOWN_RANK
, context
.getRank());
628 // Position trace at event rank 999
629 tmpContext
= fTrace
.seekEvent(new TmfTimestamp(1000, SCALE
, 0));
630 context
= fTrace
.seekEvent(tmpContext
.getLocation());
631 assertEquals("Event rank", ITmfContext
.UNKNOWN_RANK
, context
.getRank());
633 event
= fTrace
.parseEvent(context
);
634 assertEquals("Event timestamp", 1000, event
.getTimestamp().getValue());
635 assertEquals("Event rank", ITmfContext
.UNKNOWN_RANK
, context
.getRank());
637 event
= fTrace
.getNext(context
);
638 assertEquals("Event timestamp", 1000, event
.getTimestamp().getValue());
639 assertEquals("Event rank", ITmfContext
.UNKNOWN_RANK
, context
.getRank());
641 // Position trace at event rank 1001
642 tmpContext
= fTrace
.seekEvent(new TmfTimestamp(1002, SCALE
, 0));
643 context
= fTrace
.seekEvent(tmpContext
.getLocation());
644 assertEquals("Event rank", ITmfContext
.UNKNOWN_RANK
, context
.getRank());
646 event
= fTrace
.parseEvent(context
);
647 assertEquals("Event timestamp", 1002, event
.getTimestamp().getValue());
648 assertEquals("Event rank", ITmfContext
.UNKNOWN_RANK
, context
.getRank());
650 event
= fTrace
.getNext(context
);
651 assertEquals("Event timestamp", 1002, event
.getTimestamp().getValue());
652 assertEquals("Event rank", ITmfContext
.UNKNOWN_RANK
, context
.getRank());
654 // Position trace at event rank 4500
655 tmpContext
= fTrace
.seekEvent(new TmfTimestamp(4501, SCALE
, 0));
656 context
= fTrace
.seekEvent(tmpContext
.getLocation());
657 assertEquals("Event rank", ITmfContext
.UNKNOWN_RANK
, context
.getRank());
659 event
= fTrace
.parseEvent(context
);
660 assertEquals("Event timestamp", 4501, event
.getTimestamp().getValue());
661 assertEquals("Event rank", ITmfContext
.UNKNOWN_RANK
, context
.getRank());
663 event
= fTrace
.getNext(context
);
664 assertEquals("Event timestamp", 4501, event
.getTimestamp().getValue());
665 assertEquals("Event rank", ITmfContext
.UNKNOWN_RANK
, context
.getRank());
669 public void testSeekEventOutOfScope() {
670 // Position trace at beginning
671 ITmfContext tmpContext
= fTrace
.seekEvent(0);
672 ITmfContext context
= fTrace
.seekEvent(tmpContext
.getLocation());
673 assertEquals("Event rank", ITmfContext
.UNKNOWN_RANK
, context
.getRank());
675 ITmfEvent event
= fTrace
.parseEvent(context
);
676 assertEquals("Event timestamp", 1, event
.getTimestamp().getValue());
677 assertEquals("Event rank", ITmfContext
.UNKNOWN_RANK
, context
.getRank());
679 event
= fTrace
.getNext(context
);
680 assertEquals("Event timestamp", 1, event
.getTimestamp().getValue());
681 assertEquals("Event rank", ITmfContext
.UNKNOWN_RANK
, context
.getRank());
683 // Position trace at event passed the end
684 context
= fTrace
.seekEvent(new TmfTimestamp(NB_EVENTS
+ 1, SCALE
, 0));
685 assertNull("Event timestamp", context
.getLocation());
686 assertEquals("Event rank", ITmfContext
.UNKNOWN_RANK
, context
.getRank());
688 event
= fTrace
.getNext(context
);
689 assertNull("Event", event
);
692 // ------------------------------------------------------------------------
693 // seekEvent on timestamp (note: does not reliably set the rank)
694 // ------------------------------------------------------------------------
697 public void testSeekEventOnNullTimestamp() {
698 // Position trace at event rank 0
699 ITmfContext context
= fTrace
.seekEvent((ITmfTimestamp
) null);
700 assertEquals("Event rank", 0, context
.getRank());
702 ITmfEvent event
= fTrace
.parseEvent(context
);
703 assertEquals("Event timestamp", 1, event
.getTimestamp().getValue());
704 assertEquals("Event rank", 0, context
.getRank());
708 public void testSeekEventOnTimestampOnCacheBoundary() {
709 // Position trace at event rank 0
710 ITmfContext context
= fTrace
.seekEvent(new TmfTimestamp(1, SCALE
, 0));
711 assertEquals("Event rank", 0, context
.getRank());
713 ITmfEvent event
= fTrace
.parseEvent(context
);
714 assertEquals("Event timestamp", 1, event
.getTimestamp().getValue());
715 assertEquals("Event rank", 0, context
.getRank());
717 event
= fTrace
.getNext(context
);
718 assertEquals("Event timestamp", 1, event
.getTimestamp().getValue());
719 assertEquals("Event rank", 1, context
.getRank());
721 // Position trace at event rank 1000
722 context
= fTrace
.seekEvent(new TmfTimestamp(1001, SCALE
, 0));
723 assertEquals("Event rank", 1000, context
.getRank());
725 event
= fTrace
.parseEvent(context
);
726 assertEquals("Event timestamp", 1001, event
.getTimestamp().getValue());
727 assertEquals("Event rank", 1000, context
.getRank());
729 event
= fTrace
.getNext(context
);
730 assertEquals("Event timestamp", 1001, event
.getTimestamp().getValue());
731 assertEquals("Event rank", 1001, context
.getRank());
733 // Position trace at event rank 4000
734 context
= fTrace
.seekEvent(new TmfTimestamp(4001, SCALE
, 0));
735 assertEquals("Event rank", 4000, context
.getRank());
737 event
= fTrace
.parseEvent(context
);
738 assertEquals("Event timestamp", 4001, event
.getTimestamp().getValue());
739 assertEquals("Event rank", 4000, context
.getRank());
741 event
= fTrace
.getNext(context
);
742 assertEquals("Event timestamp", 4001, event
.getTimestamp().getValue());
743 assertEquals("Event rank", 4001, context
.getRank());
747 public void testSeekEventOnTimestampNotOnCacheBoundary() {
748 // Position trace at event rank 1
749 ITmfContext context
= fTrace
.seekEvent(new TmfTimestamp(2, SCALE
, 0));
750 assertEquals("Event rank", 1, context
.getRank());
752 ITmfEvent event
= fTrace
.parseEvent(context
);
753 assertEquals("Event timestamp", 2, event
.getTimestamp().getValue());
754 assertEquals("Event rank", 1, context
.getRank());
756 event
= fTrace
.getNext(context
);
757 assertEquals("Event timestamp", 2, event
.getTimestamp().getValue());
758 assertEquals("Event rank", 2, context
.getRank());
760 // Position trace at event rank 9
761 context
= fTrace
.seekEvent(new TmfTimestamp(10, SCALE
, 0));
762 assertEquals("Event rank", 9, context
.getRank());
764 event
= fTrace
.parseEvent(context
);
765 assertEquals("Event timestamp", 10, event
.getTimestamp().getValue());
766 assertEquals("Event rank", 9, context
.getRank());
768 event
= fTrace
.getNext(context
);
769 assertEquals("Event timestamp", 10, event
.getTimestamp().getValue());
770 assertEquals("Event rank", 10, context
.getRank());
772 // Position trace at event rank 999
773 context
= fTrace
.seekEvent(new TmfTimestamp(1000, SCALE
, 0));
774 assertEquals("Event rank", 999, context
.getRank());
776 event
= fTrace
.parseEvent(context
);
777 assertEquals("Event timestamp", 1000, event
.getTimestamp().getValue());
778 assertEquals("Event rank", 999, context
.getRank());
780 event
= fTrace
.getNext(context
);
781 assertEquals("Event timestamp", 1000, event
.getTimestamp().getValue());
782 assertEquals("Event rank", 1000, context
.getRank());
784 // Position trace at event rank 1001
785 context
= fTrace
.seekEvent(new TmfTimestamp(1002, SCALE
, 0));
786 assertEquals("Event rank", 1001, context
.getRank());
788 event
= fTrace
.parseEvent(context
);
789 assertEquals("Event timestamp", 1002, event
.getTimestamp().getValue());
790 assertEquals("Event rank", 1001, context
.getRank());
792 event
= fTrace
.getNext(context
);
793 assertEquals("Event timestamp", 1002, event
.getTimestamp().getValue());
794 assertEquals("Event rank", 1002, context
.getRank());
796 // Position trace at event rank 4500
797 context
= fTrace
.seekEvent(new TmfTimestamp(4501, SCALE
, 0));
798 assertEquals("Event rank", 4500, context
.getRank());
800 event
= fTrace
.parseEvent(context
);
801 assertEquals("Event timestamp", 4501, event
.getTimestamp().getValue());
802 assertEquals("Event rank", 4500, context
.getRank());
804 event
= fTrace
.getNext(context
);
805 assertEquals("Event timestamp", 4501, event
.getTimestamp().getValue());
806 assertEquals("Event rank", 4501, context
.getRank());
810 public void testSeekEventOnTimestampOutOfScope() {
811 // Position trace at beginning
812 ITmfContext context
= fTrace
.seekEvent(new TmfTimestamp(-1, SCALE
, 0));
813 assertEquals("Event rank", 0, context
.getRank());
815 ITmfEvent event
= fTrace
.parseEvent(context
);
816 assertEquals("Event timestamp", 1, event
.getTimestamp().getValue());
817 assertEquals("Event rank", 0, context
.getRank());
819 event
= fTrace
.getNext(context
);
820 assertEquals("Event timestamp", 1, event
.getTimestamp().getValue());
821 assertEquals("Event rank", 1, context
.getRank());
823 // Position trace at event passed the end
824 context
= fTrace
.seekEvent(new TmfTimestamp(NB_EVENTS
+ 1, SCALE
, 0));
825 assertEquals("Event rank", ITmfContext
.UNKNOWN_RANK
, context
.getRank());
827 event
= fTrace
.parseEvent(context
);
828 assertEquals("Event timestamp", null, event
);
829 assertEquals("Event rank", ITmfContext
.UNKNOWN_RANK
, context
.getRank());
831 event
= fTrace
.getNext(context
);
832 assertEquals("Event timestamp", null, event
);
833 assertEquals("Event rank", ITmfContext
.UNKNOWN_RANK
, context
.getRank());
836 // ------------------------------------------------------------------------
838 // ------------------------------------------------------------------------
841 public void testSeekEventOnNegativeRank() {
842 // Position trace at event rank 0
843 ITmfContext context
= fTrace
.seekEvent(-1);
844 assertEquals("Event rank", 0, context
.getRank());
846 ITmfEvent event
= fTrace
.parseEvent(context
);
847 assertEquals("Event timestamp", 1, event
.getTimestamp().getValue());
848 assertEquals("Event rank", 0, context
.getRank());
852 public void testSeekOnRankOnCacheBoundary() {
853 // On lower bound, returns the first event (ts = 1)
854 ITmfContext context
= fTrace
.seekEvent(0);
855 assertEquals("Event rank", 0, context
.getRank());
857 ITmfEvent event
= fTrace
.parseEvent(context
);
858 assertEquals("Event timestamp", 1, event
.getTimestamp().getValue());
859 assertEquals("Event rank", 0, context
.getRank());
861 event
= fTrace
.getNext(context
);
862 assertEquals("Event timestamp", 1, event
.getTimestamp().getValue());
863 assertEquals("Event rank", 1, context
.getRank());
865 // Position trace at event rank 1000
866 context
= fTrace
.seekEvent(1000);
867 assertEquals("Event rank", 1000, context
.getRank());
869 event
= fTrace
.parseEvent(context
);
870 assertEquals("Event timestamp", 1001, event
.getTimestamp().getValue());
871 assertEquals("Event rank", 1000, context
.getRank());
873 event
= fTrace
.getNext(context
);
874 assertEquals("Event timestamp", 1001, event
.getTimestamp().getValue());
875 assertEquals("Event rank", 1001, context
.getRank());
877 // Position trace at event rank 4000
878 context
= fTrace
.seekEvent(4000);
879 assertEquals("Event rank", 4000, context
.getRank());
881 event
= fTrace
.parseEvent(context
);
882 assertEquals("Event timestamp", 4001, event
.getTimestamp().getValue());
883 assertEquals("Event rank", 4000, context
.getRank());
885 event
= fTrace
.getNext(context
);
886 assertEquals("Event timestamp", 4001, event
.getTimestamp().getValue());
887 assertEquals("Event rank", 4001, context
.getRank());
891 public void testSeekOnRankNotOnCacheBoundary() {
892 // Position trace at event rank 9
893 ITmfContext context
= fTrace
.seekEvent(9);
894 assertEquals("Event rank", 9, context
.getRank());
896 ITmfEvent event
= fTrace
.parseEvent(context
);
897 assertEquals("Event timestamp", 10, event
.getTimestamp().getValue());
898 assertEquals("Event rank", 9, context
.getRank());
900 event
= fTrace
.getNext(context
);
901 assertEquals("Event timestamp", 10, event
.getTimestamp().getValue());
902 assertEquals("Event rank", 10, context
.getRank());
904 // Position trace at event rank 999
905 context
= fTrace
.seekEvent(999);
906 assertEquals("Event rank", 999, context
.getRank());
908 event
= fTrace
.parseEvent(context
);
909 assertEquals("Event timestamp", 1000, event
.getTimestamp().getValue());
910 assertEquals("Event rank", 999, context
.getRank());
912 event
= fTrace
.getNext(context
);
913 assertEquals("Event timestamp", 1000, event
.getTimestamp().getValue());
914 assertEquals("Event rank", 1000, context
.getRank());
916 // Position trace at event rank 1001
917 context
= fTrace
.seekEvent(1001);
918 assertEquals("Event rank", 1001, context
.getRank());
920 event
= fTrace
.parseEvent(context
);
921 assertEquals("Event timestamp", 1002, event
.getTimestamp().getValue());
922 assertEquals("Event rank", 1001, context
.getRank());
924 event
= fTrace
.getNext(context
);
925 assertEquals("Event timestamp", 1002, event
.getTimestamp().getValue());
926 assertEquals("Event rank", 1002, context
.getRank());
928 // Position trace at event rank 4500
929 context
= fTrace
.seekEvent(4500);
930 assertEquals("Event rank", 4500, context
.getRank());
932 event
= fTrace
.parseEvent(context
);
933 assertEquals("Event timestamp", 4501, event
.getTimestamp().getValue());
934 assertEquals("Event rank", 4500, context
.getRank());
936 event
= fTrace
.getNext(context
);
937 assertEquals("Event timestamp", 4501, event
.getTimestamp().getValue());
938 assertEquals("Event rank", 4501, context
.getRank());
942 public void testSeekEventOnRankOutOfScope() {
943 // Position trace at beginning
944 ITmfContext context
= fTrace
.seekEvent(-1);
945 assertEquals("Event rank", 0, context
.getRank());
947 ITmfEvent event
= fTrace
.parseEvent(context
);
948 assertEquals("Event timestamp", 1, event
.getTimestamp().getValue());
949 assertEquals("Event rank", 0, context
.getRank());
951 event
= fTrace
.getNext(context
);
952 assertEquals("Event timestamp", 1, event
.getTimestamp().getValue());
953 assertEquals("Event rank", 1, context
.getRank());
955 // Position trace at event passed the end
956 context
= fTrace
.seekEvent(NB_EVENTS
);
957 assertEquals("Event rank", NB_EVENTS
, context
.getRank());
959 event
= fTrace
.parseEvent(context
);
960 assertNull("Event", event
);
961 assertEquals("Event rank", NB_EVENTS
, context
.getRank());
963 event
= fTrace
.getNext(context
);
964 assertNull("Event", event
);
965 assertEquals("Event rank", NB_EVENTS
, context
.getRank());
968 // ------------------------------------------------------------------------
969 // parseEvent - make sure parseEvent doesn't update the context
970 // ------------------------------------------------------------------------
973 public void testParseEvent() {
974 final int NB_READS
= 20;
976 // On lower bound, returns the first event (ts = 0)
977 final TmfContext context
= (TmfContext
) fTrace
.seekEvent(new TmfTimestamp(0, SCALE
, 0));
978 TmfContext svContext
= new TmfContext(context
);
980 ITmfEvent event
= fTrace
.parseEvent(context
);
981 assertEquals("Event timestamp", 1, event
.getTimestamp().getValue());
982 assertEquals("Event rank", 0, context
.getRank());
983 assertTrue("parseEvent", context
.equals(svContext
));
985 event
= fTrace
.parseEvent(context
);
986 assertEquals("Event timestamp", 1, event
.getTimestamp().getValue());
987 assertEquals("Event rank", 0, context
.getRank());
988 assertTrue("parseEvent", context
.equals(svContext
));
990 event
= fTrace
.parseEvent(context
);
991 assertEquals("Event timestamp", 1, event
.getTimestamp().getValue());
992 assertEquals("Event rank", 0, context
.getRank());
993 assertTrue("parseEvent", context
.equals(svContext
));
995 // Position the trace at event NB_READS
996 for (int i
= 1; i
< NB_READS
; i
++) {
997 event
= fTrace
.getNext(context
);
998 assertEquals("Event timestamp", i
, event
.getTimestamp().getValue());
1001 svContext
= new TmfContext(context
);
1002 event
= fTrace
.parseEvent(context
);
1003 assertEquals("Event timestamp", NB_READS
, event
.getTimestamp().getValue());
1004 assertEquals("Event rank", NB_READS
-1 , context
.getRank());
1005 assertTrue("parseEvent", context
.equals(svContext
));
1007 event
= fTrace
.parseEvent(context
);
1008 assertEquals("Event timestamp", NB_READS
, event
.getTimestamp().getValue());
1009 assertEquals("Event rank", NB_READS
- 1, context
.getRank());
1010 assertTrue("parseEvent", context
.equals(svContext
));
1013 // ------------------------------------------------------------------------
1014 // getNext - updates the context
1015 // ------------------------------------------------------------------------
1018 public void testGetNextAfteSeekingOnTS_1() {
1019 final long INITIAL_TS
= 1;
1020 final int NB_READS
= 20;
1022 // On lower bound, returns the first event (ts = 1)
1023 final ITmfContext context
= fTrace
.seekEvent(new TmfTimestamp(INITIAL_TS
, SCALE
, 0));
1027 for (int i
= 0; i
< NB_READS
; i
++) {
1028 event
= fTrace
.getNext(context
);
1029 assertEquals("Event timestamp", INITIAL_TS
+ i
, event
.getTimestamp().getValue());
1030 assertEquals("Event rank", INITIAL_TS
+ i
, context
.getRank());
1033 // Make sure we stay positioned
1034 event
= fTrace
.parseEvent(context
);
1035 assertEquals("Event timestamp", INITIAL_TS
+ NB_READS
, event
.getTimestamp().getValue());
1036 assertEquals("Event rank", INITIAL_TS
+ NB_READS
- 1, context
.getRank());
1040 public void testGetNextAfteSeekingOnTS_2() {
1041 final long INITIAL_TS
= 2;
1042 final int NB_READS
= 20;
1044 // On lower bound, returns the first event (ts = 500)
1045 final ITmfContext context
= fTrace
.seekEvent(new TmfTimestamp(INITIAL_TS
, SCALE
, 0));
1049 for (int i
= 0; i
< NB_READS
; i
++) {
1050 event
= fTrace
.getNext(context
);
1051 assertEquals("Event timestamp", INITIAL_TS
+ i
, event
.getTimestamp().getValue());
1052 assertEquals("Event rank", INITIAL_TS
+ i
, context
.getRank());
1055 // Make sure we stay positioned
1056 event
= fTrace
.parseEvent(context
);
1057 assertEquals("Event timestamp", INITIAL_TS
+ NB_READS
, event
.getTimestamp().getValue());
1058 assertEquals("Event rank", INITIAL_TS
+ NB_READS
- 1, context
.getRank());
1062 public void testGetNextAfteSeekingOnTS_3() {
1063 final long INITIAL_TS
= 500;
1064 final int NB_READS
= 20;
1066 // On lower bound, returns the first event (ts = 500)
1067 final ITmfContext context
= fTrace
.seekEvent(new TmfTimestamp(INITIAL_TS
, SCALE
, 0));
1071 for (int i
= 0; i
< NB_READS
; i
++) {
1072 event
= fTrace
.getNext(context
);
1073 assertEquals("Event timestamp", INITIAL_TS
+ i
, event
.getTimestamp().getValue());
1074 assertEquals("Event rank", INITIAL_TS
+ i
, context
.getRank());
1077 // Make sure we stay positioned
1078 event
= fTrace
.parseEvent(context
);
1079 assertEquals("Event timestamp", INITIAL_TS
+ NB_READS
, event
.getTimestamp().getValue());
1080 assertEquals("Event rank", INITIAL_TS
+ NB_READS
- 1, context
.getRank());
1084 public void testGetNextAfterSeekingOnRank_1() {
1085 final long INITIAL_RANK
= 0L;
1086 final int NB_READS
= 20;
1088 // On lower bound, returns the first event (rank = 0)
1089 final ITmfContext context
= fTrace
.seekEvent(INITIAL_RANK
);
1093 for (int i
= 0; i
< NB_READS
; i
++) {
1094 event
= fTrace
.getNext(context
);
1095 assertEquals("Event timestamp", INITIAL_RANK
+ i
+ 1, event
.getTimestamp().getValue());
1096 assertEquals("Event rank", INITIAL_RANK
+ i
+ 1, context
.getRank());
1099 // Make sure we stay positioned
1100 event
= fTrace
.parseEvent(context
);
1101 assertEquals("Event timestamp", INITIAL_RANK
+ NB_READS
+ 1, event
.getTimestamp().getValue());
1102 assertEquals("Event rank", INITIAL_RANK
+ NB_READS
, context
.getRank());
1106 public void testGetNextAfterSeekingOnRank_2() {
1107 final long INITIAL_RANK
= 1L;
1108 final int NB_READS
= 20;
1110 // On lower bound, returns the first event (rank = 0)
1111 final ITmfContext context
= fTrace
.seekEvent(INITIAL_RANK
);
1115 for (int i
= 0; i
< NB_READS
; i
++) {
1116 event
= fTrace
.getNext(context
);
1117 assertEquals("Event timestamp", INITIAL_RANK
+ i
+ 1, event
.getTimestamp().getValue());
1118 assertEquals("Event rank", INITIAL_RANK
+ i
+ 1, context
.getRank());
1121 // Make sure we stay positioned
1122 event
= fTrace
.parseEvent(context
);
1123 assertEquals("Event timestamp", INITIAL_RANK
+ NB_READS
+ 1, event
.getTimestamp().getValue());
1124 assertEquals("Event rank", INITIAL_RANK
+ NB_READS
, context
.getRank());
1128 public void testGetNextAfterSeekingOnRank_3() {
1129 final long INITIAL_RANK
= 500L;
1130 final int NB_READS
= 20;
1132 // On lower bound, returns the first event (rank = 0)
1133 final ITmfContext context
= fTrace
.seekEvent(INITIAL_RANK
);
1137 for (int i
= 0; i
< NB_READS
; i
++) {
1138 event
= fTrace
.getNext(context
);
1139 assertEquals("Event timestamp", INITIAL_RANK
+ i
+ 1, event
.getTimestamp().getValue());
1140 assertEquals("Event rank", INITIAL_RANK
+ i
+ 1, context
.getRank());
1143 // Make sure we stay positioned
1144 event
= fTrace
.parseEvent(context
);
1145 assertEquals("Event timestamp", INITIAL_RANK
+ NB_READS
+ 1, event
.getTimestamp().getValue());
1146 assertEquals("Event rank", INITIAL_RANK
+ NB_READS
, context
.getRank());
1150 public void testGetNextAfterSeekingOnLocation_1() {
1151 final ITmfLocation INITIAL_LOC
= null;
1152 final long INITIAL_TS
= 1;
1153 final int NB_READS
= 20;
1155 // On lower bound, returns the first event (ts = 1)
1156 final ITmfContext context
= fTrace
.seekEvent(INITIAL_LOC
);
1160 for (int i
= 0; i
< NB_READS
; i
++) {
1161 event
= fTrace
.getNext(context
);
1162 assertEquals("Event timestamp", INITIAL_TS
+ i
, event
.getTimestamp().getValue());
1163 assertEquals("Event rank", INITIAL_TS
+ i
, context
.getRank());
1166 // Make sure we stay positioned
1167 event
= fTrace
.parseEvent(context
);
1168 assertEquals("Event timestamp", INITIAL_TS
+ NB_READS
, event
.getTimestamp().getValue());
1169 assertEquals("Event rank", INITIAL_TS
+ NB_READS
- 1, context
.getRank());
1173 public void testGetNextAfterSeekingOnLocation_2() {
1174 final ITmfLocation INITIAL_LOC
= fTrace
.seekEvent(1L).getLocation();
1175 final long INITIAL_TS
= 2;
1176 final int NB_READS
= 20;
1178 // On lower bound, returns the first event (ts = 501)
1179 final ITmfContext context
= fTrace
.seekEvent(INITIAL_LOC
);
1183 for (int i
= 0; i
< NB_READS
; i
++) {
1184 event
= fTrace
.getNext(context
);
1185 assertEquals("Event timestamp", INITIAL_TS
+ i
, event
.getTimestamp().getValue());
1188 // Make sure we stay positioned
1189 event
= fTrace
.parseEvent(context
);
1190 assertEquals("Event timestamp", INITIAL_TS
+ NB_READS
, event
.getTimestamp().getValue());
1194 public void testGetNextAfterSeekingOnLocation_3() {
1195 final ITmfLocation INITIAL_LOC
= fTrace
.seekEvent(500L).getLocation();
1196 final long INITIAL_TS
= 501;
1197 final int NB_READS
= 20;
1199 // On lower bound, returns the first event (ts = 501)
1200 final ITmfContext context
= fTrace
.seekEvent(INITIAL_LOC
);
1204 for (int i
= 0; i
< NB_READS
; i
++) {
1205 event
= fTrace
.getNext(context
);
1206 assertEquals("Event timestamp", INITIAL_TS
+ i
, event
.getTimestamp().getValue());
1209 // Make sure we stay positioned
1210 event
= fTrace
.parseEvent(context
);
1211 assertEquals("Event timestamp", INITIAL_TS
+ NB_READS
, event
.getTimestamp().getValue());
1215 public void testGetNextLocation() {
1216 ITmfContext context1
= fTrace
.seekEvent(0);
1217 fTrace
.getNext(context1
);
1218 ITmfLocation location
= context1
.getLocation();
1219 ITmfEvent event1
= fTrace
.getNext(context1
);
1220 ITmfContext context2
= fTrace
.seekEvent(location
);
1221 ITmfEvent event2
= fTrace
.getNext(context2
);
1222 assertEquals("Event timestamp", event1
.getTimestamp().getValue(), event2
.getTimestamp().getValue());
1226 public void testGetNextEndLocation() {
1227 ITmfContext context1
= fTrace
.seekEvent(fTrace
.getNbEvents() - 1);
1228 fTrace
.getNext(context1
);
1229 ITmfLocation location
= context1
.getLocation();
1230 ITmfContext context2
= fTrace
.seekEvent(location
);
1231 ITmfEvent event
= fTrace
.getNext(context2
);
1232 assertNull("Event", event
);
1235 // ------------------------------------------------------------------------
1237 // ------------------------------------------------------------------------
1240 public void testProcessEventRequestForAllEvents() throws InterruptedException
{
1241 final int blockSize
= 1;
1242 final Vector
<ITmfEvent
> requestedEvents
= new Vector
<ITmfEvent
>();
1244 final TmfTimeRange range
= new TmfTimeRange(TmfTimestamp
.BIG_BANG
, TmfTimestamp
.BIG_CRUNCH
);
1245 final TmfEventRequest request
= new TmfEventRequest(ITmfEvent
.class, range
, NB_EVENTS
, blockSize
) {
1247 public void handleData(final ITmfEvent event
) {
1248 super.handleData(event
);
1249 requestedEvents
.add(event
);
1252 final ITmfDataProvider
[] providers
= TmfProviderManager
.getProviders(ITmfEvent
.class, TmfTraceStub
.class);
1253 providers
[0].sendRequest(request
);
1254 request
.waitForCompletion();
1256 assertEquals("nbEvents", NB_EVENTS
, requestedEvents
.size());
1257 assertTrue("isCompleted", request
.isCompleted());
1258 assertFalse("isCancelled", request
.isCancelled());
1260 // Ensure that we have distinct events.
1261 // Don't go overboard: we are not validating the stub!
1262 for (int i
= 0; i
< NB_EVENTS
; i
++) {
1263 assertEquals("Distinct events", i
+ 1, requestedEvents
.get(i
).getTimestamp().getValue());
1268 public void testProcessEventRequestForNbEvents() throws InterruptedException
{
1269 final int blockSize
= 100;
1270 final int nbEvents
= 1000;
1271 final Vector
<ITmfEvent
> requestedEvents
= new Vector
<ITmfEvent
>();
1273 final TmfTimeRange range
= new TmfTimeRange(TmfTimestamp
.BIG_BANG
, TmfTimestamp
.BIG_CRUNCH
);
1274 final TmfEventRequest request
= new TmfEventRequest(ITmfEvent
.class, range
, nbEvents
, blockSize
) {
1276 public void handleData(final ITmfEvent event
) {
1277 super.handleData(event
);
1278 requestedEvents
.add(event
);
1281 final ITmfDataProvider
[] providers
= TmfProviderManager
.getProviders(ITmfEvent
.class, TmfTraceStub
.class);
1282 providers
[0].sendRequest(request
);
1283 request
.waitForCompletion();
1285 assertEquals("nbEvents", nbEvents
, requestedEvents
.size());
1286 assertTrue("isCompleted", request
.isCompleted());
1287 assertFalse("isCancelled", request
.isCancelled());
1289 // Ensure that we have distinct events.
1290 // Don't go overboard: we are not validating the stub!
1291 for (int i
= 0; i
< nbEvents
; i
++) {
1292 assertEquals("Distinct events", i
+ 1, requestedEvents
.get(i
).getTimestamp().getValue());
1297 public void testProcessEventRequestForSomeEvents() throws InterruptedException
{
1298 final int blockSize
= 1;
1299 final long startTime
= 100;
1300 final int nbEvents
= 1000;
1301 final Vector
<ITmfEvent
> requestedEvents
= new Vector
<ITmfEvent
>();
1303 final TmfTimeRange range
= new TmfTimeRange(new TmfTimestamp(startTime
, SCALE
), TmfTimestamp
.BIG_CRUNCH
);
1304 final TmfEventRequest request
= new TmfEventRequest(ITmfEvent
.class, range
, nbEvents
, blockSize
) {
1306 public void handleData(final ITmfEvent event
) {
1307 super.handleData(event
);
1308 requestedEvents
.add(event
);
1311 final ITmfDataProvider
[] providers
= TmfProviderManager
.getProviders(ITmfEvent
.class, TmfTraceStub
.class);
1312 providers
[0].sendRequest(request
);
1313 request
.waitForCompletion();
1315 assertEquals("nbEvents", nbEvents
, requestedEvents
.size());
1316 assertTrue("isCompleted", request
.isCompleted());
1317 assertFalse("isCancelled", request
.isCancelled());
1319 // Ensure that we have distinct events.
1320 // Don't go overboard: we are not validating the stub!
1321 for (int i
= 0; i
< nbEvents
; i
++) {
1322 assertEquals("Distinct events", startTime
+ i
, requestedEvents
.get(i
).getTimestamp().getValue());
1327 public void testProcessEventRequestForOtherEvents() throws InterruptedException
{
1328 final int blockSize
= 1;
1329 final int startIndex
= 99;
1330 final long startTime
= 100;
1331 final int nbEvents
= 1000;
1332 final Vector
<ITmfEvent
> requestedEvents
= new Vector
<ITmfEvent
>();
1334 final TmfTimeRange range
= new TmfTimeRange(new TmfTimestamp(startTime
, SCALE
), TmfTimestamp
.BIG_CRUNCH
);
1335 final TmfEventRequest request
= new TmfEventRequest(ITmfEvent
.class, range
, startIndex
, nbEvents
, blockSize
) {
1337 public void handleData(final ITmfEvent event
) {
1338 super.handleData(event
);
1339 requestedEvents
.add(event
);
1342 final ITmfDataProvider
[] providers
= TmfProviderManager
.getProviders(ITmfEvent
.class, TmfTraceStub
.class);
1343 providers
[0].sendRequest(request
);
1344 request
.waitForCompletion();
1346 assertEquals("nbEvents", nbEvents
, requestedEvents
.size());
1347 assertTrue("isCompleted", request
.isCompleted());
1348 assertFalse("isCancelled", request
.isCancelled());
1350 // Ensure that we have distinct events.
1351 // Don't go overboard: we are not validating the stub!
1352 for (int i
= 0; i
< nbEvents
; i
++) {
1353 assertEquals("Distinct events", startTime
+ i
, requestedEvents
.get(i
).getTimestamp().getValue());
1358 public void testProcessDataRequestForSomeEvents() throws InterruptedException
{
1359 final int startIndex
= 100;
1360 final int nbEvents
= 1000;
1361 final Vector
<ITmfEvent
> requestedEvents
= new Vector
<ITmfEvent
>();
1363 final TmfDataRequest request
= new TmfDataRequest(ITmfEvent
.class, startIndex
, nbEvents
) {
1365 public void handleData(final ITmfEvent event
) {
1366 super.handleData(event
);
1367 requestedEvents
.add(event
);
1370 final ITmfDataProvider
[] providers
= TmfProviderManager
.getProviders(ITmfEvent
.class, TmfTraceStub
.class);
1371 providers
[0].sendRequest(request
);
1372 request
.waitForCompletion();
1374 assertEquals("nbEvents", nbEvents
, requestedEvents
.size());
1375 assertTrue("isCompleted", request
.isCompleted());
1376 assertFalse("isCancelled", request
.isCancelled());
1378 // Ensure that we have distinct events.
1379 // Don't go overboard: we are not validating the stub!
1380 for (int i
= 0; i
< nbEvents
; i
++) {
1381 assertEquals("Distinct events", startIndex
+ 1 + i
, requestedEvents
.get(i
).getTimestamp().getValue());
1385 // ------------------------------------------------------------------------
1387 // ------------------------------------------------------------------------
1390 public void testCancel() throws InterruptedException
{
1391 final Vector
<ITmfEvent
> requestedEvents
= new Vector
<ITmfEvent
>();
1393 final TmfTimeRange range
= new TmfTimeRange(TmfTimestamp
.BIG_BANG
, TmfTimestamp
.BIG_CRUNCH
);
1394 final TmfEventRequest request
= new TmfEventRequest(ITmfEvent
.class, range
, NB_EVENTS
, BLOCK_SIZE
) {
1397 public void handleData(final ITmfEvent event
) {
1398 super.handleData(event
);
1399 requestedEvents
.add(event
);
1400 if (++nbRead
== BLOCK_SIZE
) {
1405 final ITmfDataProvider
[] providers
= TmfProviderManager
.getProviders(ITmfEvent
.class, TmfTraceStub
.class);
1406 providers
[0].sendRequest(request
);
1407 request
.waitForCompletion();
1409 assertEquals("nbEvents", BLOCK_SIZE
, requestedEvents
.size());
1410 assertTrue("isCompleted", request
.isCompleted());
1411 assertTrue("isCancelled", request
.isCancelled());
1414 // ------------------------------------------------------------------------
1416 // ------------------------------------------------------------------------
1419 public void testDefaultTmfTraceStub() {
1420 assertFalse ("Open trace", fTrace
== null);
1421 assertEquals("getType", ITmfEvent
.class, fTrace
.getType());
1422 assertNull ("getResource", fTrace
.getResource());
1423 assertEquals("getCacheSize", BLOCK_SIZE
, fTrace
.getCacheSize());
1424 assertEquals("getStreamingInterval", 0, fTrace
.getStreamingInterval());
1425 assertEquals("getName", TEST_STREAM
, fTrace
.getName());
1427 assertEquals("getNbEvents", NB_EVENTS
, fTrace
.getNbEvents());
1428 assertEquals("getRange-start", 1, fTrace
.getTimeRange().getStartTime().getValue());
1429 assertEquals("getRange-end", NB_EVENTS
, fTrace
.getTimeRange().getEndTime().getValue());
1430 assertEquals("getStartTime", 1, fTrace
.getStartTime().getValue());
1431 assertEquals("getEndTime", NB_EVENTS
, fTrace
.getEndTime().getValue());
1433 String expected
= "TmfTrace [fPath=" + fTrace
.getPath() + ", fCacheSize=" + fTrace
.getCacheSize() +
1434 ", fNbEvents=" + fTrace
.getNbEvents() + ", fStartTime=" + fTrace
.getStartTime() +
1435 ", fEndTime=" + fTrace
.getEndTime() + ", fStreamingInterval=" + fTrace
.getStreamingInterval() +
1437 assertEquals("toString", expected
, fTrace
.toString());
1440 // ------------------------------------------------------------------------
1441 // getInitialRangeOffset, getCurrentRange, getCurrentTime
1442 // ------------------------------------------------------------------------
1445 public void testCurrentTimeValues() throws TmfTraceException
{
1447 TmfTraceStub trace
= null;
1448 File testfile
= null;
1450 final URL location
= FileLocator
.find(TmfCoreTestPlugin
.getDefault().getBundle(), new Path(DIRECTORY
+ File
.separator
+ TEST_STREAM
), null);
1451 testfile
= new File(FileLocator
.toFileURL(location
).toURI());
1452 trace
= new TmfTraceStub(testfile
.toURI().getPath());
1453 // verify initial values
1454 TmfTimestamp defaultInitRange
= new TmfTimestamp(DEFAULT_INITIAL_OFFSET_VALUE
, ITmfTimestamp
.NANOSECOND_SCALE
);
1455 assertEquals("getInitialRangeOffset", defaultInitRange
, trace
.getInitialRangeOffset());
1456 assertEquals("getCurrentTime", TmfTimestamp
.ZERO
, trace
.getCurrentTime());
1457 assertEquals("getCurrentRange", TmfTimeRange
.NULL_RANGE
, trace
.getCurrentRange());
1458 trace
.setInitialRangeOffset(new TmfTimestamp(5, ITmfTimestamp
.MILLISECOND_SCALE
));
1460 } catch (final URISyntaxException e
) {
1461 fail("URISyntaxException");
1462 } catch (final IOException e
) {
1463 fail("IOException");
1465 assertFalse ("Open trace", trace
== null);
1467 TmfTimestamp initRange
= new TmfTimestamp(5, ITmfTimestamp
.MILLISECOND_SCALE
);
1468 assertEquals("getInitialRangeOffset", initRange
, trace
.getInitialRangeOffset());
1469 assertEquals("getCurrentTime", trace
.getTimeRange().getStartTime(), trace
.getCurrentTime());
1471 ITmfTimestamp startTimestamp
= trace
.getTimeRange().getStartTime();
1472 long endValue
= startTimestamp
.getValue() + initRange
.normalize(0, startTimestamp
.getScale()).getValue();
1473 ITmfTimestamp endTimestamp
= new TmfTimestamp(endValue
, startTimestamp
.getScale());
1474 TmfTimeRange expectedRange
= new TmfTimeRange(startTimestamp
, endTimestamp
);
1475 assertEquals("getCurrentRange", expectedRange
, trace
.getCurrentRange());