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
.request
.ITmfDataRequest
.ExecutionType
;
39 import org
.eclipse
.linuxtools
.tmf
.core
.statesystem
.ITmfStateSystem
;
40 import org
.eclipse
.linuxtools
.tmf
.core
.statistics
.ITmfStatistics
;
41 import org
.eclipse
.linuxtools
.tmf
.core
.tests
.TmfCoreTestPlugin
;
42 import org
.eclipse
.linuxtools
.tmf
.core
.timestamp
.ITmfTimestamp
;
43 import org
.eclipse
.linuxtools
.tmf
.core
.timestamp
.TmfTimeRange
;
44 import org
.eclipse
.linuxtools
.tmf
.core
.timestamp
.TmfTimestamp
;
45 import org
.eclipse
.linuxtools
.tmf
.core
.trace
.ITmfContext
;
46 import org
.eclipse
.linuxtools
.tmf
.core
.trace
.ITmfTrace
;
47 import org
.eclipse
.linuxtools
.tmf
.core
.trace
.TmfContext
;
48 import org
.eclipse
.linuxtools
.tmf
.core
.trace
.indexer
.checkpoint
.TmfCheckpointIndexer
;
49 import org
.eclipse
.linuxtools
.tmf
.core
.trace
.location
.ITmfLocation
;
50 import org
.eclipse
.linuxtools
.tmf
.tests
.stubs
.trace
.TmfTraceStub
;
51 import org
.junit
.After
;
52 import org
.junit
.Before
;
53 import org
.junit
.Test
;
56 * Test suite for the TmfTrace class.
58 @SuppressWarnings("javadoc")
59 public class TmfTraceTest
{
61 // ------------------------------------------------------------------------
63 // ------------------------------------------------------------------------
65 private static final long DEFAULT_INITIAL_OFFSET_VALUE
= (1L * 100 * 1000 * 1000); // .1sec
66 private static final String DIRECTORY
= "testfiles";
67 private static final String TEST_STREAM
= "A-Test-10K";
68 private static final int BLOCK_SIZE
= 500;
69 private static final int NB_EVENTS
= 10000;
70 private static TmfTraceStub fTrace
= null;
72 private static int SCALE
= -3;
74 // ------------------------------------------------------------------------
76 // ------------------------------------------------------------------------
80 fTrace
= setupTrace(DIRECTORY
+ File
.separator
+ TEST_STREAM
);
84 public void tearDown() {
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());
99 fTrace
.indexTrace(true);
100 } catch (final TmfTraceException e
) {
102 } catch (final URISyntaxException e
) {
104 } catch (final IOException e
) {
111 // ------------------------------------------------------------------------
113 // ------------------------------------------------------------------------
116 @SuppressWarnings("null")
117 public void testStandardConstructor() throws TmfTraceException
{
118 TmfTraceStub trace
= null;
119 File testfile
= null;
121 final URL location
= FileLocator
.find(TmfCoreTestPlugin
.getDefault().getBundle(), new Path(DIRECTORY
+ File
.separator
+ TEST_STREAM
), null);
122 testfile
= new File(FileLocator
.toFileURL(location
).toURI());
123 trace
= new TmfTraceStub(testfile
.toURI().getPath());
124 trace
.indexTrace(true);
125 } catch (final URISyntaxException e
) {
126 fail("URISyntaxException");
127 } catch (final IOException e
) {
131 assertFalse ("Open trace", trace
== null);
132 assertEquals("getType", ITmfEvent
.class, trace
.getType());
133 assertNull ("getResource", trace
.getResource());
134 assertEquals("getPath", testfile
.toURI().getPath(), trace
.getPath());
135 assertEquals("getCacheSize", ITmfTrace
.DEFAULT_TRACE_CACHE_SIZE
, trace
.getCacheSize());
136 assertEquals("getStreamingInterval", 0, trace
.getStreamingInterval());
137 assertEquals("getName", TEST_STREAM
, trace
.getName());
139 assertEquals("getNbEvents", NB_EVENTS
, trace
.getNbEvents());
140 assertEquals("getRange-start", 1, trace
.getTimeRange().getStartTime().getValue());
141 assertEquals("getRange-end", NB_EVENTS
, trace
.getTimeRange().getEndTime().getValue());
142 assertEquals("getStartTime", 1, trace
.getStartTime().getValue());
143 assertEquals("getEndTime", NB_EVENTS
, trace
.getEndTime().getValue());
147 @SuppressWarnings("null")
148 public void testStandardConstructorCacheSize() throws TmfTraceException
{
149 TmfTraceStub trace
= null;
150 File testfile
= null;
152 final URL location
= FileLocator
.find(TmfCoreTestPlugin
.getDefault().getBundle(), new Path(DIRECTORY
+ File
.separator
+ TEST_STREAM
), null);
153 testfile
= new File(FileLocator
.toFileURL(location
).toURI());
154 trace
= new TmfTraceStub(testfile
.toURI().getPath(), 0);
155 trace
.indexTrace(true);
156 } catch (final URISyntaxException e
) {
157 fail("URISyntaxException");
158 } catch (final IOException e
) {
162 assertFalse ("Open trace", trace
== null);
163 assertEquals("getType", ITmfEvent
.class, trace
.getType());
164 assertNull ("getResource", trace
.getResource());
165 assertEquals("getPath", testfile
.toURI().getPath(), trace
.getPath());
166 assertEquals("getCacheSize", ITmfTrace
.DEFAULT_TRACE_CACHE_SIZE
, trace
.getCacheSize());
167 assertEquals("getStreamingInterval", 0, trace
.getStreamingInterval());
168 assertEquals("getName", TEST_STREAM
, trace
.getName());
170 assertEquals("getNbEvents", NB_EVENTS
, trace
.getNbEvents());
171 assertEquals("getRange-start", 1, trace
.getTimeRange().getStartTime().getValue());
172 assertEquals("getRange-end", NB_EVENTS
, trace
.getTimeRange().getEndTime().getValue());
173 assertEquals("getStartTime", 1, trace
.getStartTime().getValue());
174 assertEquals("getEndTime", NB_EVENTS
, trace
.getEndTime().getValue());
177 final URL location
= FileLocator
.find(TmfCoreTestPlugin
.getDefault().getBundle(), new Path(DIRECTORY
+ File
.separator
+ TEST_STREAM
), null);
178 testfile
= new File(FileLocator
.toFileURL(location
).toURI());
179 trace
= new TmfTraceStub(testfile
.toURI().getPath());
180 trace
.indexTrace(true);
181 } catch (final URISyntaxException e
) {
182 fail("URISyntaxException");
183 } catch (final IOException e
) {
187 assertEquals("getType", ITmfEvent
.class, trace
.getType());
188 assertNull ("getResource", trace
.getResource());
189 assertEquals("getPath", testfile
.toURI().getPath(), trace
.getPath());
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);
209 trace
.indexTrace(true);
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("getStreamingInterval", 0, trace
.getStreamingInterval());
221 assertEquals("getName", TEST_STREAM
, trace
.getName());
223 assertEquals("getNbEvents", NB_EVENTS
, trace
.getNbEvents());
224 assertEquals("getRange-start", 1, trace
.getTimeRange().getStartTime().getValue());
225 assertEquals("getRange-end", NB_EVENTS
, trace
.getTimeRange().getEndTime().getValue());
226 assertEquals("getStartTime", 1, trace
.getStartTime().getValue());
227 assertEquals("getEndTime", NB_EVENTS
, trace
.getEndTime().getValue());
231 @SuppressWarnings("null")
232 public void testLiveTraceConstructor() throws TmfTraceException
{
233 TmfTraceStub trace
= null;
234 File testfile
= null;
235 final long interval
= 100;
237 final URL location
= FileLocator
.find(TmfCoreTestPlugin
.getDefault().getBundle(), new Path(DIRECTORY
+ File
.separator
+ TEST_STREAM
), null);
238 testfile
= new File(FileLocator
.toFileURL(location
).toURI());
239 trace
= new TmfTraceStub(testfile
.toURI().getPath(), BLOCK_SIZE
, interval
);
240 trace
.indexTrace(true);
241 } catch (final URISyntaxException e
) {
242 fail("URISyntaxException");
243 } catch (final IOException e
) {
247 assertFalse ("Open trace", trace
== null);
248 assertEquals("getType", ITmfEvent
.class, trace
.getType());
249 assertNull ("getResource", trace
.getResource());
250 assertEquals("getPath", testfile
.toURI().getPath(), trace
.getPath());
251 assertEquals("getStreamingInterval", interval
, trace
.getStreamingInterval());
252 assertEquals("getName", TEST_STREAM
, trace
.getName());
254 assertEquals("getNbEvents", NB_EVENTS
, trace
.getNbEvents());
255 assertEquals("getRange-start", 1, trace
.getTimeRange().getStartTime().getValue());
256 assertEquals("getRange-end", NB_EVENTS
, trace
.getTimeRange().getEndTime().getValue());
257 assertEquals("getStartTime", 1, trace
.getStartTime().getValue());
258 assertEquals("getEndTime", NB_EVENTS
, trace
.getEndTime().getValue());
262 @SuppressWarnings("null")
263 public void testCopyConstructor() throws TmfTraceException
{
264 TmfTraceStub original
= null;
265 TmfTraceStub trace
= null;
266 File testfile
= null;
268 final URL location
= FileLocator
.find(TmfCoreTestPlugin
.getDefault().getBundle(), new Path(DIRECTORY
+ File
.separator
+ TEST_STREAM
), null);
269 testfile
= new File(FileLocator
.toFileURL(location
).toURI());
270 original
= new TmfTraceStub(testfile
.toURI().getPath(), BLOCK_SIZE
, new TmfCheckpointIndexer(null));
271 trace
= new TmfTraceStub(original
);
272 trace
.indexTrace(true);
273 } catch (final URISyntaxException e
) {
274 fail("URISyntaxException");
275 } catch (final IOException e
) {
279 assertFalse ("Open trace", trace
== null);
280 assertEquals("getType", ITmfEvent
.class, trace
.getType());
281 assertNull ("getResource", trace
.getResource());
282 assertEquals("getPath", testfile
.toURI().getPath(), trace
.getPath());
283 assertEquals("getStreamingInterval", 0, trace
.getStreamingInterval());
284 assertEquals("getName", TEST_STREAM
, trace
.getName());
286 assertEquals("getNbEvents", NB_EVENTS
, trace
.getNbEvents());
287 assertEquals("getRange-start", 1, trace
.getTimeRange().getStartTime().getValue());
288 assertEquals("getRange-end", NB_EVENTS
, trace
.getTimeRange().getEndTime().getValue());
289 assertEquals("getStartTime", 1, trace
.getStartTime().getValue());
290 assertEquals("getEndTime", NB_EVENTS
, trace
.getEndTime().getValue());
292 // Test the copy of a null trace
294 new TmfTraceStub((TmfTraceStub
) null);
295 fail("Missing exception");
296 } catch (final IllegalArgumentException e
) {
298 } catch (final Exception e
) {
299 fail("Unexpected exception");
303 // ------------------------------------------------------------------------
304 // Trace initialization
305 // ------------------------------------------------------------------------
308 public void testInitializeNullPath() {
309 // Instantiate an "empty" trace
310 final TmfTraceStub trace
= new TmfTraceStub();
313 trace
.initialize(null, null, ITmfEvent
.class);
314 fail("TmfTrace.initialize() - no exception thrown");
315 } catch (TmfTraceException e
) {
317 } catch (Exception e
) {
318 fail("TmfTrace.initialize() - wrong exception thrown");
323 public void testInitializeSimplePath() {
324 // Instantiate an "empty" trace
325 final TmfTraceStub trace
= new TmfTraceStub();
327 // Path == trace name
328 String path
= "TraceName";
330 trace
.initialize(null, path
, ITmfEvent
.class);
331 } catch (Exception e
) {
332 fail("TmfTrace.initialize() - Exception thrown");
335 assertEquals("getType", ITmfEvent
.class, trace
.getType());
336 assertNull ("getResource", trace
.getResource());
337 assertEquals("getPath", path
, trace
.getPath());
338 assertEquals("getCacheSize", ITmfTrace
.DEFAULT_TRACE_CACHE_SIZE
, trace
.getCacheSize());
339 assertEquals("getStreamingInterval", 0, trace
.getStreamingInterval());
340 assertEquals("getName", path
, trace
.getName());
342 assertEquals("getNbEvents", 0, trace
.getNbEvents());
343 assertEquals("getRange-start", Long
.MIN_VALUE
, trace
.getTimeRange().getStartTime().getValue());
344 assertEquals("getRange-end", Long
.MIN_VALUE
, trace
.getTimeRange().getEndTime().getValue());
345 assertEquals("getStartTime", Long
.MIN_VALUE
, trace
.getStartTime().getValue());
346 assertEquals("getEndTime", Long
.MIN_VALUE
, trace
.getEndTime().getValue());
350 public void testInitializeNormalPath() {
351 // Instantiate an "empty" trace
352 final TmfTraceStub trace
= new TmfTraceStub();
354 // Path == trace name
355 String name
= "TraceName";
356 String path
= "/my/trace/path/" + name
;
358 trace
.initialize(null, path
, ITmfEvent
.class);
359 } catch (Exception e
) {
360 fail("TmfTrace.initialize() - Exception thrown");
363 assertEquals("getType", ITmfEvent
.class, trace
.getType());
364 assertNull ("getResource", trace
.getResource());
365 assertEquals("getPath", path
, trace
.getPath());
366 assertEquals("getCacheSize", ITmfTrace
.DEFAULT_TRACE_CACHE_SIZE
, trace
.getCacheSize());
367 assertEquals("getStreamingInterval", 0, trace
.getStreamingInterval());
368 assertEquals("getName", name
, trace
.getName());
370 assertEquals("getNbEvents", 0, trace
.getNbEvents());
371 assertEquals("getRange-start", Long
.MIN_VALUE
, trace
.getTimeRange().getStartTime().getValue());
372 assertEquals("getRange-end", Long
.MIN_VALUE
, trace
.getTimeRange().getEndTime().getValue());
373 assertEquals("getStartTime", Long
.MIN_VALUE
, trace
.getStartTime().getValue());
374 assertEquals("getEndTime", Long
.MIN_VALUE
, trace
.getEndTime().getValue());
378 public void testInitTrace() throws URISyntaxException
, IOException
, TmfTraceException
, InterruptedException
{
379 // Instantiate an "empty" trace
380 final TmfTraceStub trace
= new TmfTraceStub();
382 assertNull ("getType", trace
.getType());
383 assertNull ("getResource", trace
.getResource());
384 assertEquals("getCacheSize", ITmfTrace
.DEFAULT_TRACE_CACHE_SIZE
, trace
.getCacheSize());
385 assertEquals("getStreamingInterval", 0, trace
.getStreamingInterval());
386 assertEquals("getName", "", trace
.getName());
388 assertEquals("getNbEvents", 0, trace
.getNbEvents());
389 assertEquals("getRange-start", Long
.MIN_VALUE
, trace
.getTimeRange().getStartTime().getValue());
390 assertEquals("getRange-end", Long
.MIN_VALUE
, trace
.getTimeRange().getEndTime().getValue());
391 assertEquals("getStartTime", Long
.MIN_VALUE
, trace
.getStartTime().getValue());
392 assertEquals("getEndTime", Long
.MIN_VALUE
, trace
.getEndTime().getValue());
395 final URL location
= FileLocator
.find(TmfCoreTestPlugin
.getDefault().getBundle(), new Path(DIRECTORY
+ File
.separator
+ TEST_STREAM
), null);
396 final File testfile
= new File(FileLocator
.toFileURL(location
).toURI());
397 assertTrue("validate", trace
.validate(null, testfile
.getPath()).isOK());
399 // InitTrace and wait for indexing completion...
400 trace
.initTrace(null, testfile
.toURI().getPath(), ITmfEvent
.class);
401 trace
.indexTrace(true);
403 while (trace
.getNbEvents() < NB_EVENTS
&& nbSecs
< 10) {
407 if (trace
.getNbEvents() < NB_EVENTS
) {
411 assertEquals("getType", ITmfEvent
.class, trace
.getType());
412 assertNull ("getResource", trace
.getResource());
413 assertEquals("getCacheSize", ITmfTrace
.DEFAULT_TRACE_CACHE_SIZE
, trace
.getCacheSize());
414 assertEquals("getStreamingInterval", 0, trace
.getStreamingInterval());
415 assertEquals("getName", TEST_STREAM
, trace
.getName());
417 assertEquals("getNbEvents", NB_EVENTS
, trace
.getNbEvents());
418 assertEquals("getRange-start", 1, trace
.getTimeRange().getStartTime().getValue());
419 assertEquals("getRange-end", NB_EVENTS
, trace
.getTimeRange().getEndTime().getValue());
420 assertEquals("getStartTime", 1, trace
.getStartTime().getValue());
421 assertEquals("getEndTime", NB_EVENTS
, trace
.getEndTime().getValue());
424 // ------------------------------------------------------------------------
425 // Set/Get streaming interval
426 // ------------------------------------------------------------------------
429 public void testSetStreamingInterval() throws TmfTraceException
{
430 final TmfTraceStub trace
= new TmfTraceStub(fTrace
);
433 assertEquals("getStreamingInterval", interval
, trace
.getStreamingInterval());
436 trace
.setStreamingInterval(interval
);
437 assertEquals("getStreamingInterval", interval
, trace
.getStreamingInterval());
440 trace
.setStreamingInterval(interval
);
441 assertEquals("getStreamingInterval", 0, trace
.getStreamingInterval());
444 trace
.setStreamingInterval(interval
);
445 assertEquals("getStreamingInterval", interval
, trace
.getStreamingInterval());
450 // ------------------------------------------------------------------------
451 // Set/Get time range
452 // ------------------------------------------------------------------------
455 public void testSetTimeRange() throws TmfTraceException
{
456 final TmfTraceStub trace
= new TmfTraceStub(fTrace
);
457 trace
.indexTrace(true);
459 assertEquals("getRange-start", 1, trace
.getTimeRange().getStartTime().getValue());
460 assertEquals("getRange-end", NB_EVENTS
, trace
.getTimeRange().getEndTime().getValue());
461 assertEquals("getStartTime", 1, trace
.getStartTime().getValue());
462 assertEquals("getEndTime", NB_EVENTS
, trace
.getEndTime().getValue());
464 trace
.setTimeRange(new TmfTimeRange(new TmfTimestamp(100), new TmfTimestamp(200)));
465 assertEquals("setTimeRange", 100, trace
.getTimeRange().getStartTime().getValue());
466 assertEquals("setTimeRange", 200, trace
.getTimeRange().getEndTime().getValue());
467 assertEquals("setTimeRange", 100, trace
.getStartTime().getValue());
468 assertEquals("setTimeRange", 200, trace
.getEndTime().getValue());
474 public void testSetStartTime() throws TmfTraceException
{
475 final TmfTraceStub trace
= new TmfTraceStub(fTrace
);
476 trace
.indexTrace(true);
478 assertEquals("getRange-start", 1, trace
.getTimeRange().getStartTime().getValue());
479 assertEquals("getRange-end", NB_EVENTS
, trace
.getTimeRange().getEndTime().getValue());
480 assertEquals("getStartTime", 1, trace
.getStartTime().getValue());
481 assertEquals("getEndTime", NB_EVENTS
, trace
.getEndTime().getValue());
483 trace
.setStartTime(new TmfTimestamp(100));
484 assertEquals("setStartTime", 100, trace
.getTimeRange().getStartTime().getValue());
485 assertEquals("setStartTime", NB_EVENTS
, trace
.getTimeRange().getEndTime().getValue());
486 assertEquals("setStartTime", 100, trace
.getStartTime().getValue());
487 assertEquals("setStartTime", NB_EVENTS
, trace
.getEndTime().getValue());
493 public void testSetEndTime() throws TmfTraceException
{
494 final TmfTraceStub trace
= new TmfTraceStub(fTrace
);
495 trace
.indexTrace(true);
497 assertEquals("getRange-start", 1, trace
.getTimeRange().getStartTime().getValue());
498 assertEquals("getRange-end", NB_EVENTS
, trace
.getTimeRange().getEndTime().getValue());
499 assertEquals("getStartTime", 1, trace
.getStartTime().getValue());
500 assertEquals("getEndTime", NB_EVENTS
, trace
.getEndTime().getValue());
502 trace
.setEndTime(new TmfTimestamp(100));
503 assertEquals("setEndTime", 1, trace
.getTimeRange().getStartTime().getValue());
504 assertEquals("setEndTime", 100, trace
.getTimeRange().getEndTime().getValue());
505 assertEquals("setEndTime", 1, trace
.getStartTime().getValue());
506 assertEquals("setEndTime", 100, trace
.getEndTime().getValue());
512 public void testSetNbEvents() throws TmfTraceException
{
513 final TmfTraceStub trace
= new TmfTraceStub(fTrace
);
514 trace
.indexTrace(true);
516 assertEquals("getNbEvents", NB_EVENTS
, trace
.getNbEvents());
518 trace
.setNbEvents(0);
519 assertEquals("getNbEvents", 0, trace
.getNbEvents());
521 trace
.setNbEvents(-1);
522 assertEquals("getNbEvents", 0, trace
.getNbEvents());
524 trace
.setNbEvents(NB_EVENTS
+ 1);
525 assertEquals("getNbEvents", NB_EVENTS
+ 1, trace
.getNbEvents());
527 trace
.setNbEvents(NB_EVENTS
);
528 assertEquals("getNbEvents", NB_EVENTS
, trace
.getNbEvents());
533 // ------------------------------------------------------------------------
534 // State system and statistics methods
535 // ------------------------------------------------------------------------
538 public void testGetStatistics() {
539 /* Should be null in unit tests */
540 ITmfStatistics stats
= fTrace
.getStatistics();
545 public void testGetStateSystem() {
546 /* There should be no state system registered so far */
547 ITmfStateSystem ss
= fTrace
.getStateSystems().get("something");
552 * Make sure the returned map is unmodifiable.
554 @Test(expected
=UnsupportedOperationException
.class)
555 public void testGetStateSystem_readOnly() {
556 Map
<String
, ITmfStateSystem
> sss
= fTrace
.getStateSystems();
557 sss
.put("something", null);
560 // ------------------------------------------------------------------------
561 // seekEvent on location (note: does not reliably set the rank)
562 // ------------------------------------------------------------------------
565 public void testSeekEventOnCacheBoundary() {
566 // Position trace at event rank 0
567 ITmfContext context
= fTrace
.seekEvent(0);
568 ITmfEvent event
= fTrace
.parseEvent(context
);
569 assertEquals("Event timestamp", 1, event
.getTimestamp().getValue());
570 assertEquals("Event rank", 0, context
.getRank());
572 context
= fTrace
.seekEvent(context
.getLocation());
573 assertEquals("Event rank", ITmfContext
.UNKNOWN_RANK
, context
.getRank());
575 event
= fTrace
.parseEvent(context
);
576 assertEquals("Event timestamp", 1, event
.getTimestamp().getValue());
577 assertEquals("Event rank", ITmfContext
.UNKNOWN_RANK
, context
.getRank());
579 event
= fTrace
.getNext(context
);
580 assertEquals("Event timestamp", 1, event
.getTimestamp().getValue());
581 assertEquals("Event rank", ITmfContext
.UNKNOWN_RANK
, context
.getRank());
583 // Position trace at event rank 1000
584 ITmfContext tmpContext
= fTrace
.seekEvent(new TmfTimestamp(1001, SCALE
, 0));
585 context
= fTrace
.seekEvent(tmpContext
.getLocation());
586 assertEquals("Event rank", ITmfContext
.UNKNOWN_RANK
, context
.getRank());
588 event
= fTrace
.parseEvent(context
);
589 assertEquals("Event timestamp", 1001, event
.getTimestamp().getValue());
590 assertEquals("Event rank", ITmfContext
.UNKNOWN_RANK
, context
.getRank());
592 event
= fTrace
.getNext(context
);
593 assertEquals("Event timestamp", 1001, event
.getTimestamp().getValue());
594 assertEquals("Event rank", ITmfContext
.UNKNOWN_RANK
, context
.getRank());
596 // Position trace at event rank 4000
597 tmpContext
= fTrace
.seekEvent(new TmfTimestamp(4001, SCALE
, 0));
598 context
= fTrace
.seekEvent(tmpContext
.getLocation());
599 assertEquals("Event rank", ITmfContext
.UNKNOWN_RANK
, context
.getRank());
601 event
= fTrace
.parseEvent(context
);
602 assertEquals("Event timestamp", 4001, event
.getTimestamp().getValue());
603 assertEquals("Event rank", ITmfContext
.UNKNOWN_RANK
, context
.getRank());
605 event
= fTrace
.getNext(context
);
606 assertEquals("Event timestamp", 4001, event
.getTimestamp().getValue());
607 assertEquals("Event rank", ITmfContext
.UNKNOWN_RANK
, context
.getRank());
611 public void testSeekEventNotOnCacheBoundary() {
612 // Position trace at event rank 9
613 ITmfContext tmpContext
= fTrace
.seekEvent(new TmfTimestamp(10, SCALE
, 0));
614 TmfContext context
= fTrace
.seekEvent(tmpContext
.getLocation());
615 assertEquals("Event rank", ITmfContext
.UNKNOWN_RANK
, context
.getRank());
617 ITmfEvent event
= fTrace
.parseEvent(context
);
618 assertEquals("Event timestamp", 10, event
.getTimestamp().getValue());
619 assertEquals("Event rank", ITmfContext
.UNKNOWN_RANK
, context
.getRank());
621 event
= fTrace
.getNext(context
);
622 assertEquals("Event timestamp", 10, event
.getTimestamp().getValue());
623 assertEquals("Event rank", ITmfContext
.UNKNOWN_RANK
, context
.getRank());
625 // Position trace at event rank 999
626 tmpContext
= fTrace
.seekEvent(new TmfTimestamp(1000, SCALE
, 0));
627 context
= fTrace
.seekEvent(tmpContext
.getLocation());
628 assertEquals("Event rank", ITmfContext
.UNKNOWN_RANK
, context
.getRank());
630 event
= fTrace
.parseEvent(context
);
631 assertEquals("Event timestamp", 1000, event
.getTimestamp().getValue());
632 assertEquals("Event rank", ITmfContext
.UNKNOWN_RANK
, context
.getRank());
634 event
= fTrace
.getNext(context
);
635 assertEquals("Event timestamp", 1000, event
.getTimestamp().getValue());
636 assertEquals("Event rank", ITmfContext
.UNKNOWN_RANK
, context
.getRank());
638 // Position trace at event rank 1001
639 tmpContext
= fTrace
.seekEvent(new TmfTimestamp(1002, SCALE
, 0));
640 context
= fTrace
.seekEvent(tmpContext
.getLocation());
641 assertEquals("Event rank", ITmfContext
.UNKNOWN_RANK
, context
.getRank());
643 event
= fTrace
.parseEvent(context
);
644 assertEquals("Event timestamp", 1002, event
.getTimestamp().getValue());
645 assertEquals("Event rank", ITmfContext
.UNKNOWN_RANK
, context
.getRank());
647 event
= fTrace
.getNext(context
);
648 assertEquals("Event timestamp", 1002, event
.getTimestamp().getValue());
649 assertEquals("Event rank", ITmfContext
.UNKNOWN_RANK
, context
.getRank());
651 // Position trace at event rank 4500
652 tmpContext
= fTrace
.seekEvent(new TmfTimestamp(4501, SCALE
, 0));
653 context
= fTrace
.seekEvent(tmpContext
.getLocation());
654 assertEquals("Event rank", ITmfContext
.UNKNOWN_RANK
, context
.getRank());
656 event
= fTrace
.parseEvent(context
);
657 assertEquals("Event timestamp", 4501, event
.getTimestamp().getValue());
658 assertEquals("Event rank", ITmfContext
.UNKNOWN_RANK
, context
.getRank());
660 event
= fTrace
.getNext(context
);
661 assertEquals("Event timestamp", 4501, event
.getTimestamp().getValue());
662 assertEquals("Event rank", ITmfContext
.UNKNOWN_RANK
, context
.getRank());
666 public void testSeekEventOutOfScope() {
667 // Position trace at beginning
668 ITmfContext tmpContext
= fTrace
.seekEvent(0);
669 ITmfContext context
= fTrace
.seekEvent(tmpContext
.getLocation());
670 assertEquals("Event rank", ITmfContext
.UNKNOWN_RANK
, context
.getRank());
672 ITmfEvent event
= fTrace
.parseEvent(context
);
673 assertEquals("Event timestamp", 1, event
.getTimestamp().getValue());
674 assertEquals("Event rank", ITmfContext
.UNKNOWN_RANK
, context
.getRank());
676 event
= fTrace
.getNext(context
);
677 assertEquals("Event timestamp", 1, event
.getTimestamp().getValue());
678 assertEquals("Event rank", ITmfContext
.UNKNOWN_RANK
, context
.getRank());
680 // Position trace at event passed the end
681 context
= fTrace
.seekEvent(new TmfTimestamp(NB_EVENTS
+ 1, SCALE
, 0));
682 assertNull("Event timestamp", context
.getLocation());
683 assertEquals("Event rank", ITmfContext
.UNKNOWN_RANK
, context
.getRank());
685 event
= fTrace
.getNext(context
);
686 assertNull("Event", event
);
689 // ------------------------------------------------------------------------
690 // seekEvent on timestamp (note: does not reliably set the rank)
691 // ------------------------------------------------------------------------
694 public void testSeekEventOnNullTimestamp() {
695 // Position trace at event rank 0
696 ITmfContext context
= fTrace
.seekEvent((ITmfTimestamp
) null);
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());
705 public void testSeekEventOnTimestampOnCacheBoundary() {
706 // Position trace at event rank 0
707 ITmfContext context
= fTrace
.seekEvent(new TmfTimestamp(1, SCALE
, 0));
708 assertEquals("Event rank", 0, context
.getRank());
710 ITmfEvent event
= fTrace
.parseEvent(context
);
711 assertEquals("Event timestamp", 1, event
.getTimestamp().getValue());
712 assertEquals("Event rank", 0, context
.getRank());
714 event
= fTrace
.getNext(context
);
715 assertEquals("Event timestamp", 1, event
.getTimestamp().getValue());
716 assertEquals("Event rank", 1, context
.getRank());
718 // Position trace at event rank 1000
719 context
= fTrace
.seekEvent(new TmfTimestamp(1001, SCALE
, 0));
720 assertEquals("Event rank", 1000, context
.getRank());
722 event
= fTrace
.parseEvent(context
);
723 assertEquals("Event timestamp", 1001, event
.getTimestamp().getValue());
724 assertEquals("Event rank", 1000, context
.getRank());
726 event
= fTrace
.getNext(context
);
727 assertEquals("Event timestamp", 1001, event
.getTimestamp().getValue());
728 assertEquals("Event rank", 1001, context
.getRank());
730 // Position trace at event rank 4000
731 context
= fTrace
.seekEvent(new TmfTimestamp(4001, SCALE
, 0));
732 assertEquals("Event rank", 4000, context
.getRank());
734 event
= fTrace
.parseEvent(context
);
735 assertEquals("Event timestamp", 4001, event
.getTimestamp().getValue());
736 assertEquals("Event rank", 4000, context
.getRank());
738 event
= fTrace
.getNext(context
);
739 assertEquals("Event timestamp", 4001, event
.getTimestamp().getValue());
740 assertEquals("Event rank", 4001, context
.getRank());
744 public void testSeekEventOnTimestampNotOnCacheBoundary() {
745 // Position trace at event rank 1
746 ITmfContext context
= fTrace
.seekEvent(new TmfTimestamp(2, SCALE
, 0));
747 assertEquals("Event rank", 1, context
.getRank());
749 ITmfEvent event
= fTrace
.parseEvent(context
);
750 assertEquals("Event timestamp", 2, event
.getTimestamp().getValue());
751 assertEquals("Event rank", 1, context
.getRank());
753 event
= fTrace
.getNext(context
);
754 assertEquals("Event timestamp", 2, event
.getTimestamp().getValue());
755 assertEquals("Event rank", 2, context
.getRank());
757 // Position trace at event rank 9
758 context
= fTrace
.seekEvent(new TmfTimestamp(10, SCALE
, 0));
759 assertEquals("Event rank", 9, context
.getRank());
761 event
= fTrace
.parseEvent(context
);
762 assertEquals("Event timestamp", 10, event
.getTimestamp().getValue());
763 assertEquals("Event rank", 9, context
.getRank());
765 event
= fTrace
.getNext(context
);
766 assertEquals("Event timestamp", 10, event
.getTimestamp().getValue());
767 assertEquals("Event rank", 10, context
.getRank());
769 // Position trace at event rank 999
770 context
= fTrace
.seekEvent(new TmfTimestamp(1000, SCALE
, 0));
771 assertEquals("Event rank", 999, context
.getRank());
773 event
= fTrace
.parseEvent(context
);
774 assertEquals("Event timestamp", 1000, event
.getTimestamp().getValue());
775 assertEquals("Event rank", 999, context
.getRank());
777 event
= fTrace
.getNext(context
);
778 assertEquals("Event timestamp", 1000, event
.getTimestamp().getValue());
779 assertEquals("Event rank", 1000, context
.getRank());
781 // Position trace at event rank 1001
782 context
= fTrace
.seekEvent(new TmfTimestamp(1002, SCALE
, 0));
783 assertEquals("Event rank", 1001, context
.getRank());
785 event
= fTrace
.parseEvent(context
);
786 assertEquals("Event timestamp", 1002, event
.getTimestamp().getValue());
787 assertEquals("Event rank", 1001, context
.getRank());
789 event
= fTrace
.getNext(context
);
790 assertEquals("Event timestamp", 1002, event
.getTimestamp().getValue());
791 assertEquals("Event rank", 1002, context
.getRank());
793 // Position trace at event rank 4500
794 context
= fTrace
.seekEvent(new TmfTimestamp(4501, SCALE
, 0));
795 assertEquals("Event rank", 4500, context
.getRank());
797 event
= fTrace
.parseEvent(context
);
798 assertEquals("Event timestamp", 4501, event
.getTimestamp().getValue());
799 assertEquals("Event rank", 4500, context
.getRank());
801 event
= fTrace
.getNext(context
);
802 assertEquals("Event timestamp", 4501, event
.getTimestamp().getValue());
803 assertEquals("Event rank", 4501, context
.getRank());
807 public void testSeekEventOnTimestampOutOfScope() {
808 // Position trace at beginning
809 ITmfContext context
= fTrace
.seekEvent(new TmfTimestamp(-1, SCALE
, 0));
810 assertEquals("Event rank", 0, context
.getRank());
812 ITmfEvent event
= fTrace
.parseEvent(context
);
813 assertEquals("Event timestamp", 1, event
.getTimestamp().getValue());
814 assertEquals("Event rank", 0, context
.getRank());
816 event
= fTrace
.getNext(context
);
817 assertEquals("Event timestamp", 1, event
.getTimestamp().getValue());
818 assertEquals("Event rank", 1, context
.getRank());
820 // Position trace at event passed the end
821 context
= fTrace
.seekEvent(new TmfTimestamp(NB_EVENTS
+ 1, SCALE
, 0));
822 assertEquals("Event rank", ITmfContext
.UNKNOWN_RANK
, context
.getRank());
824 event
= fTrace
.parseEvent(context
);
825 assertEquals("Event timestamp", null, event
);
826 assertEquals("Event rank", ITmfContext
.UNKNOWN_RANK
, context
.getRank());
828 event
= fTrace
.getNext(context
);
829 assertEquals("Event timestamp", null, event
);
830 assertEquals("Event rank", ITmfContext
.UNKNOWN_RANK
, context
.getRank());
833 // ------------------------------------------------------------------------
835 // ------------------------------------------------------------------------
838 public void testSeekEventOnNegativeRank() {
839 // Position trace at event rank 0
840 ITmfContext context
= fTrace
.seekEvent(-1);
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());
849 public void testSeekOnRankOnCacheBoundary() {
850 // On lower bound, returns the first event (ts = 1)
851 ITmfContext context
= fTrace
.seekEvent(0);
852 assertEquals("Event rank", 0, context
.getRank());
854 ITmfEvent event
= fTrace
.parseEvent(context
);
855 assertEquals("Event timestamp", 1, event
.getTimestamp().getValue());
856 assertEquals("Event rank", 0, context
.getRank());
858 event
= fTrace
.getNext(context
);
859 assertEquals("Event timestamp", 1, event
.getTimestamp().getValue());
860 assertEquals("Event rank", 1, context
.getRank());
862 // Position trace at event rank 1000
863 context
= fTrace
.seekEvent(1000);
864 assertEquals("Event rank", 1000, context
.getRank());
866 event
= fTrace
.parseEvent(context
);
867 assertEquals("Event timestamp", 1001, event
.getTimestamp().getValue());
868 assertEquals("Event rank", 1000, context
.getRank());
870 event
= fTrace
.getNext(context
);
871 assertEquals("Event timestamp", 1001, event
.getTimestamp().getValue());
872 assertEquals("Event rank", 1001, context
.getRank());
874 // Position trace at event rank 4000
875 context
= fTrace
.seekEvent(4000);
876 assertEquals("Event rank", 4000, context
.getRank());
878 event
= fTrace
.parseEvent(context
);
879 assertEquals("Event timestamp", 4001, event
.getTimestamp().getValue());
880 assertEquals("Event rank", 4000, context
.getRank());
882 event
= fTrace
.getNext(context
);
883 assertEquals("Event timestamp", 4001, event
.getTimestamp().getValue());
884 assertEquals("Event rank", 4001, context
.getRank());
888 public void testSeekOnRankNotOnCacheBoundary() {
889 // Position trace at event rank 9
890 ITmfContext context
= fTrace
.seekEvent(9);
891 assertEquals("Event rank", 9, context
.getRank());
893 ITmfEvent event
= fTrace
.parseEvent(context
);
894 assertEquals("Event timestamp", 10, event
.getTimestamp().getValue());
895 assertEquals("Event rank", 9, context
.getRank());
897 event
= fTrace
.getNext(context
);
898 assertEquals("Event timestamp", 10, event
.getTimestamp().getValue());
899 assertEquals("Event rank", 10, context
.getRank());
901 // Position trace at event rank 999
902 context
= fTrace
.seekEvent(999);
903 assertEquals("Event rank", 999, context
.getRank());
905 event
= fTrace
.parseEvent(context
);
906 assertEquals("Event timestamp", 1000, event
.getTimestamp().getValue());
907 assertEquals("Event rank", 999, context
.getRank());
909 event
= fTrace
.getNext(context
);
910 assertEquals("Event timestamp", 1000, event
.getTimestamp().getValue());
911 assertEquals("Event rank", 1000, context
.getRank());
913 // Position trace at event rank 1001
914 context
= fTrace
.seekEvent(1001);
915 assertEquals("Event rank", 1001, context
.getRank());
917 event
= fTrace
.parseEvent(context
);
918 assertEquals("Event timestamp", 1002, event
.getTimestamp().getValue());
919 assertEquals("Event rank", 1001, context
.getRank());
921 event
= fTrace
.getNext(context
);
922 assertEquals("Event timestamp", 1002, event
.getTimestamp().getValue());
923 assertEquals("Event rank", 1002, context
.getRank());
925 // Position trace at event rank 4500
926 context
= fTrace
.seekEvent(4500);
927 assertEquals("Event rank", 4500, context
.getRank());
929 event
= fTrace
.parseEvent(context
);
930 assertEquals("Event timestamp", 4501, event
.getTimestamp().getValue());
931 assertEquals("Event rank", 4500, context
.getRank());
933 event
= fTrace
.getNext(context
);
934 assertEquals("Event timestamp", 4501, event
.getTimestamp().getValue());
935 assertEquals("Event rank", 4501, context
.getRank());
939 public void testSeekEventOnRankOutOfScope() {
940 // Position trace at beginning
941 ITmfContext context
= fTrace
.seekEvent(-1);
942 assertEquals("Event rank", 0, context
.getRank());
944 ITmfEvent event
= fTrace
.parseEvent(context
);
945 assertEquals("Event timestamp", 1, event
.getTimestamp().getValue());
946 assertEquals("Event rank", 0, context
.getRank());
948 event
= fTrace
.getNext(context
);
949 assertEquals("Event timestamp", 1, event
.getTimestamp().getValue());
950 assertEquals("Event rank", 1, context
.getRank());
952 // Position trace at event passed the end
953 context
= fTrace
.seekEvent(NB_EVENTS
);
954 assertEquals("Event rank", NB_EVENTS
, context
.getRank());
956 event
= fTrace
.parseEvent(context
);
957 assertNull("Event", event
);
958 assertEquals("Event rank", NB_EVENTS
, context
.getRank());
960 event
= fTrace
.getNext(context
);
961 assertNull("Event", event
);
962 assertEquals("Event rank", NB_EVENTS
, context
.getRank());
965 // ------------------------------------------------------------------------
966 // parseEvent - make sure parseEvent doesn't update the context
967 // ------------------------------------------------------------------------
970 public void testParseEvent() {
971 final int NB_READS
= 20;
973 // On lower bound, returns the first event (ts = 0)
974 final TmfContext context
= (TmfContext
) fTrace
.seekEvent(new TmfTimestamp(0, SCALE
, 0));
975 TmfContext svContext
= new TmfContext(context
);
977 ITmfEvent event
= fTrace
.parseEvent(context
);
978 assertEquals("Event timestamp", 1, event
.getTimestamp().getValue());
979 assertEquals("Event rank", 0, context
.getRank());
980 assertTrue("parseEvent", context
.equals(svContext
));
982 event
= fTrace
.parseEvent(context
);
983 assertEquals("Event timestamp", 1, event
.getTimestamp().getValue());
984 assertEquals("Event rank", 0, context
.getRank());
985 assertTrue("parseEvent", context
.equals(svContext
));
987 event
= fTrace
.parseEvent(context
);
988 assertEquals("Event timestamp", 1, event
.getTimestamp().getValue());
989 assertEquals("Event rank", 0, context
.getRank());
990 assertTrue("parseEvent", context
.equals(svContext
));
992 // Position the trace at event NB_READS
993 for (int i
= 1; i
< NB_READS
; i
++) {
994 event
= fTrace
.getNext(context
);
995 assertEquals("Event timestamp", i
, event
.getTimestamp().getValue());
998 svContext
= new TmfContext(context
);
999 event
= fTrace
.parseEvent(context
);
1000 assertEquals("Event timestamp", NB_READS
, event
.getTimestamp().getValue());
1001 assertEquals("Event rank", NB_READS
-1 , context
.getRank());
1002 assertTrue("parseEvent", context
.equals(svContext
));
1004 event
= fTrace
.parseEvent(context
);
1005 assertEquals("Event timestamp", NB_READS
, event
.getTimestamp().getValue());
1006 assertEquals("Event rank", NB_READS
- 1, context
.getRank());
1007 assertTrue("parseEvent", context
.equals(svContext
));
1010 // ------------------------------------------------------------------------
1011 // getNext - updates the context
1012 // ------------------------------------------------------------------------
1015 public void testGetNextAfteSeekingOnTS_1() {
1016 final long INITIAL_TS
= 1;
1017 final int NB_READS
= 20;
1019 // On lower bound, returns the first event (ts = 1)
1020 final ITmfContext context
= fTrace
.seekEvent(new TmfTimestamp(INITIAL_TS
, SCALE
, 0));
1024 for (int i
= 0; i
< NB_READS
; i
++) {
1025 event
= fTrace
.getNext(context
);
1026 assertEquals("Event timestamp", INITIAL_TS
+ i
, event
.getTimestamp().getValue());
1027 assertEquals("Event rank", INITIAL_TS
+ i
, context
.getRank());
1030 // Make sure we stay positioned
1031 event
= fTrace
.parseEvent(context
);
1032 assertEquals("Event timestamp", INITIAL_TS
+ NB_READS
, event
.getTimestamp().getValue());
1033 assertEquals("Event rank", INITIAL_TS
+ NB_READS
- 1, context
.getRank());
1037 public void testGetNextAfteSeekingOnTS_2() {
1038 final long INITIAL_TS
= 2;
1039 final int NB_READS
= 20;
1041 // On lower bound, returns the first event (ts = 500)
1042 final ITmfContext context
= fTrace
.seekEvent(new TmfTimestamp(INITIAL_TS
, SCALE
, 0));
1046 for (int i
= 0; i
< NB_READS
; i
++) {
1047 event
= fTrace
.getNext(context
);
1048 assertEquals("Event timestamp", INITIAL_TS
+ i
, event
.getTimestamp().getValue());
1049 assertEquals("Event rank", INITIAL_TS
+ i
, context
.getRank());
1052 // Make sure we stay positioned
1053 event
= fTrace
.parseEvent(context
);
1054 assertEquals("Event timestamp", INITIAL_TS
+ NB_READS
, event
.getTimestamp().getValue());
1055 assertEquals("Event rank", INITIAL_TS
+ NB_READS
- 1, context
.getRank());
1059 public void testGetNextAfteSeekingOnTS_3() {
1060 final long INITIAL_TS
= 500;
1061 final int NB_READS
= 20;
1063 // On lower bound, returns the first event (ts = 500)
1064 final ITmfContext context
= fTrace
.seekEvent(new TmfTimestamp(INITIAL_TS
, SCALE
, 0));
1068 for (int i
= 0; i
< NB_READS
; i
++) {
1069 event
= fTrace
.getNext(context
);
1070 assertEquals("Event timestamp", INITIAL_TS
+ i
, event
.getTimestamp().getValue());
1071 assertEquals("Event rank", INITIAL_TS
+ i
, context
.getRank());
1074 // Make sure we stay positioned
1075 event
= fTrace
.parseEvent(context
);
1076 assertEquals("Event timestamp", INITIAL_TS
+ NB_READS
, event
.getTimestamp().getValue());
1077 assertEquals("Event rank", INITIAL_TS
+ NB_READS
- 1, context
.getRank());
1081 public void testGetNextAfterSeekingOnRank_1() {
1082 final long INITIAL_RANK
= 0L;
1083 final int NB_READS
= 20;
1085 // On lower bound, returns the first event (rank = 0)
1086 final ITmfContext context
= fTrace
.seekEvent(INITIAL_RANK
);
1090 for (int i
= 0; i
< NB_READS
; i
++) {
1091 event
= fTrace
.getNext(context
);
1092 assertEquals("Event timestamp", INITIAL_RANK
+ i
+ 1, event
.getTimestamp().getValue());
1093 assertEquals("Event rank", INITIAL_RANK
+ i
+ 1, context
.getRank());
1096 // Make sure we stay positioned
1097 event
= fTrace
.parseEvent(context
);
1098 assertEquals("Event timestamp", INITIAL_RANK
+ NB_READS
+ 1, event
.getTimestamp().getValue());
1099 assertEquals("Event rank", INITIAL_RANK
+ NB_READS
, context
.getRank());
1103 public void testGetNextAfterSeekingOnRank_2() {
1104 final long INITIAL_RANK
= 1L;
1105 final int NB_READS
= 20;
1107 // On lower bound, returns the first event (rank = 0)
1108 final ITmfContext context
= fTrace
.seekEvent(INITIAL_RANK
);
1112 for (int i
= 0; i
< NB_READS
; i
++) {
1113 event
= fTrace
.getNext(context
);
1114 assertEquals("Event timestamp", INITIAL_RANK
+ i
+ 1, event
.getTimestamp().getValue());
1115 assertEquals("Event rank", INITIAL_RANK
+ i
+ 1, context
.getRank());
1118 // Make sure we stay positioned
1119 event
= fTrace
.parseEvent(context
);
1120 assertEquals("Event timestamp", INITIAL_RANK
+ NB_READS
+ 1, event
.getTimestamp().getValue());
1121 assertEquals("Event rank", INITIAL_RANK
+ NB_READS
, context
.getRank());
1125 public void testGetNextAfterSeekingOnRank_3() {
1126 final long INITIAL_RANK
= 500L;
1127 final int NB_READS
= 20;
1129 // On lower bound, returns the first event (rank = 0)
1130 final ITmfContext context
= fTrace
.seekEvent(INITIAL_RANK
);
1134 for (int i
= 0; i
< NB_READS
; i
++) {
1135 event
= fTrace
.getNext(context
);
1136 assertEquals("Event timestamp", INITIAL_RANK
+ i
+ 1, event
.getTimestamp().getValue());
1137 assertEquals("Event rank", INITIAL_RANK
+ i
+ 1, context
.getRank());
1140 // Make sure we stay positioned
1141 event
= fTrace
.parseEvent(context
);
1142 assertEquals("Event timestamp", INITIAL_RANK
+ NB_READS
+ 1, event
.getTimestamp().getValue());
1143 assertEquals("Event rank", INITIAL_RANK
+ NB_READS
, context
.getRank());
1147 public void testGetNextAfterSeekingOnLocation_1() {
1148 final ITmfLocation INITIAL_LOC
= null;
1149 final long INITIAL_TS
= 1;
1150 final int NB_READS
= 20;
1152 // On lower bound, returns the first event (ts = 1)
1153 final ITmfContext context
= fTrace
.seekEvent(INITIAL_LOC
);
1157 for (int i
= 0; i
< NB_READS
; i
++) {
1158 event
= fTrace
.getNext(context
);
1159 assertEquals("Event timestamp", INITIAL_TS
+ i
, event
.getTimestamp().getValue());
1160 assertEquals("Event rank", INITIAL_TS
+ i
, context
.getRank());
1163 // Make sure we stay positioned
1164 event
= fTrace
.parseEvent(context
);
1165 assertEquals("Event timestamp", INITIAL_TS
+ NB_READS
, event
.getTimestamp().getValue());
1166 assertEquals("Event rank", INITIAL_TS
+ NB_READS
- 1, context
.getRank());
1170 public void testGetNextAfterSeekingOnLocation_2() {
1171 final ITmfLocation INITIAL_LOC
= fTrace
.seekEvent(1L).getLocation();
1172 final long INITIAL_TS
= 2;
1173 final int NB_READS
= 20;
1175 // On lower bound, returns the first event (ts = 501)
1176 final ITmfContext context
= fTrace
.seekEvent(INITIAL_LOC
);
1180 for (int i
= 0; i
< NB_READS
; i
++) {
1181 event
= fTrace
.getNext(context
);
1182 assertEquals("Event timestamp", INITIAL_TS
+ i
, event
.getTimestamp().getValue());
1185 // Make sure we stay positioned
1186 event
= fTrace
.parseEvent(context
);
1187 assertEquals("Event timestamp", INITIAL_TS
+ NB_READS
, event
.getTimestamp().getValue());
1191 public void testGetNextAfterSeekingOnLocation_3() {
1192 final ITmfLocation INITIAL_LOC
= fTrace
.seekEvent(500L).getLocation();
1193 final long INITIAL_TS
= 501;
1194 final int NB_READS
= 20;
1196 // On lower bound, returns the first event (ts = 501)
1197 final ITmfContext context
= fTrace
.seekEvent(INITIAL_LOC
);
1201 for (int i
= 0; i
< NB_READS
; i
++) {
1202 event
= fTrace
.getNext(context
);
1203 assertEquals("Event timestamp", INITIAL_TS
+ i
, event
.getTimestamp().getValue());
1206 // Make sure we stay positioned
1207 event
= fTrace
.parseEvent(context
);
1208 assertEquals("Event timestamp", INITIAL_TS
+ NB_READS
, event
.getTimestamp().getValue());
1212 public void testGetNextLocation() {
1213 ITmfContext context1
= fTrace
.seekEvent(0);
1214 fTrace
.getNext(context1
);
1215 ITmfLocation location
= context1
.getLocation();
1216 ITmfEvent event1
= fTrace
.getNext(context1
);
1217 ITmfContext context2
= fTrace
.seekEvent(location
);
1218 ITmfEvent event2
= fTrace
.getNext(context2
);
1219 assertEquals("Event timestamp", event1
.getTimestamp().getValue(), event2
.getTimestamp().getValue());
1223 public void testGetNextEndLocation() {
1224 ITmfContext context1
= fTrace
.seekEvent(fTrace
.getNbEvents() - 1);
1225 fTrace
.getNext(context1
);
1226 ITmfLocation location
= context1
.getLocation();
1227 ITmfContext context2
= fTrace
.seekEvent(location
);
1228 ITmfEvent event
= fTrace
.getNext(context2
);
1229 assertNull("Event", event
);
1232 // ------------------------------------------------------------------------
1234 // ------------------------------------------------------------------------
1237 public void testProcessEventRequestForAllEvents() throws InterruptedException
{
1238 final Vector
<ITmfEvent
> requestedEvents
= new Vector
<ITmfEvent
>();
1240 final TmfTimeRange range
= new TmfTimeRange(TmfTimestamp
.BIG_BANG
, TmfTimestamp
.BIG_CRUNCH
);
1241 final TmfEventRequest request
= new TmfEventRequest(ITmfEvent
.class,
1242 range
, 0, NB_EVENTS
, ExecutionType
.FOREGROUND
) {
1244 public void handleData(final ITmfEvent event
) {
1245 super.handleData(event
);
1246 requestedEvents
.add(event
);
1249 final ITmfDataProvider
[] providers
= TmfProviderManager
.getProviders(ITmfEvent
.class, TmfTraceStub
.class);
1250 providers
[0].sendRequest(request
);
1251 request
.waitForCompletion();
1253 assertEquals("nbEvents", NB_EVENTS
, requestedEvents
.size());
1254 assertTrue("isCompleted", request
.isCompleted());
1255 assertFalse("isCancelled", request
.isCancelled());
1257 // Ensure that we have distinct events.
1258 // Don't go overboard: we are not validating the stub!
1259 for (int i
= 0; i
< NB_EVENTS
; i
++) {
1260 assertEquals("Distinct events", i
+ 1, requestedEvents
.get(i
).getTimestamp().getValue());
1265 public void testProcessEventRequestForNbEvents() throws InterruptedException
{
1266 final int nbEvents
= 1000;
1267 final Vector
<ITmfEvent
> requestedEvents
= new Vector
<ITmfEvent
>();
1269 final TmfTimeRange range
= new TmfTimeRange(TmfTimestamp
.BIG_BANG
, TmfTimestamp
.BIG_CRUNCH
);
1270 final TmfEventRequest request
= new TmfEventRequest(ITmfEvent
.class,
1271 range
, 0, nbEvents
, ExecutionType
.FOREGROUND
) {
1273 public void handleData(final ITmfEvent event
) {
1274 super.handleData(event
);
1275 requestedEvents
.add(event
);
1278 final ITmfDataProvider
[] providers
= TmfProviderManager
.getProviders(ITmfEvent
.class, TmfTraceStub
.class);
1279 providers
[0].sendRequest(request
);
1280 request
.waitForCompletion();
1282 assertEquals("nbEvents", nbEvents
, requestedEvents
.size());
1283 assertTrue("isCompleted", request
.isCompleted());
1284 assertFalse("isCancelled", request
.isCancelled());
1286 // Ensure that we have distinct events.
1287 // Don't go overboard: we are not validating the stub!
1288 for (int i
= 0; i
< nbEvents
; i
++) {
1289 assertEquals("Distinct events", i
+ 1, requestedEvents
.get(i
).getTimestamp().getValue());
1294 public void testProcessEventRequestForSomeEvents() throws InterruptedException
{
1295 final long startTime
= 100;
1296 final int nbEvents
= 1000;
1297 final Vector
<ITmfEvent
> requestedEvents
= new Vector
<ITmfEvent
>();
1299 final TmfTimeRange range
= new TmfTimeRange(new TmfTimestamp(startTime
, SCALE
), TmfTimestamp
.BIG_CRUNCH
);
1300 final TmfEventRequest request
= new TmfEventRequest(ITmfEvent
.class,
1301 range
, 0, nbEvents
, ExecutionType
.FOREGROUND
) {
1303 public void handleData(final ITmfEvent event
) {
1304 super.handleData(event
);
1305 requestedEvents
.add(event
);
1308 final ITmfDataProvider
[] providers
= TmfProviderManager
.getProviders(ITmfEvent
.class, TmfTraceStub
.class);
1309 providers
[0].sendRequest(request
);
1310 request
.waitForCompletion();
1312 assertEquals("nbEvents", nbEvents
, requestedEvents
.size());
1313 assertTrue("isCompleted", request
.isCompleted());
1314 assertFalse("isCancelled", request
.isCancelled());
1316 // Ensure that we have distinct events.
1317 // Don't go overboard: we are not validating the stub!
1318 for (int i
= 0; i
< nbEvents
; i
++) {
1319 assertEquals("Distinct events", startTime
+ i
, requestedEvents
.get(i
).getTimestamp().getValue());
1324 public void testProcessEventRequestForOtherEvents() throws InterruptedException
{
1325 final int startIndex
= 99;
1326 final long startTime
= 100;
1327 final int nbEvents
= 1000;
1328 final Vector
<ITmfEvent
> requestedEvents
= new Vector
<ITmfEvent
>();
1330 final TmfTimeRange range
= new TmfTimeRange(new TmfTimestamp(startTime
, SCALE
), TmfTimestamp
.BIG_CRUNCH
);
1331 final TmfEventRequest request
= new TmfEventRequest(ITmfEvent
.class,
1332 range
, startIndex
, nbEvents
, ExecutionType
.FOREGROUND
) {
1334 public void handleData(final ITmfEvent event
) {
1335 super.handleData(event
);
1336 requestedEvents
.add(event
);
1339 final ITmfDataProvider
[] providers
= TmfProviderManager
.getProviders(ITmfEvent
.class, TmfTraceStub
.class);
1340 providers
[0].sendRequest(request
);
1341 request
.waitForCompletion();
1343 assertEquals("nbEvents", nbEvents
, requestedEvents
.size());
1344 assertTrue("isCompleted", request
.isCompleted());
1345 assertFalse("isCancelled", request
.isCancelled());
1347 // Ensure that we have distinct events.
1348 // Don't go overboard: we are not validating the stub!
1349 for (int i
= 0; i
< nbEvents
; i
++) {
1350 assertEquals("Distinct events", startTime
+ i
, requestedEvents
.get(i
).getTimestamp().getValue());
1355 public void testProcessDataRequestForSomeEvents() throws InterruptedException
{
1356 final int startIndex
= 100;
1357 final int nbEvents
= 1000;
1358 final Vector
<ITmfEvent
> requestedEvents
= new Vector
<ITmfEvent
>();
1360 final TmfDataRequest request
= new TmfDataRequest(ITmfEvent
.class,
1363 TmfDataRequest
.ExecutionType
.FOREGROUND
) {
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 int limit
= BLOCK_SIZE
;
1392 final Vector
<ITmfEvent
> requestedEvents
= new Vector
<ITmfEvent
>();
1394 final TmfTimeRange range
= new TmfTimeRange(TmfTimestamp
.BIG_BANG
, TmfTimestamp
.BIG_CRUNCH
);
1395 final TmfEventRequest request
= new TmfEventRequest(ITmfEvent
.class,
1396 range
, 0, NB_EVENTS
, ExecutionType
.FOREGROUND
) {
1400 public void handleData(final ITmfEvent event
) {
1401 super.handleData(event
);
1402 requestedEvents
.add(event
);
1403 if (++nbRead
== limit
) {
1408 final ITmfDataProvider
[] providers
= TmfProviderManager
.getProviders(ITmfEvent
.class, TmfTraceStub
.class);
1409 providers
[0].sendRequest(request
);
1410 request
.waitForCompletion();
1412 assertEquals("nbEvents", limit
, requestedEvents
.size());
1413 assertTrue("isCompleted", request
.isCompleted());
1414 assertTrue("isCancelled", request
.isCancelled());
1417 // ------------------------------------------------------------------------
1419 // ------------------------------------------------------------------------
1422 public void testDefaultTmfTraceStub() {
1423 assertFalse ("Open trace", fTrace
== null);
1424 assertEquals("getType", ITmfEvent
.class, fTrace
.getType());
1425 assertNull ("getResource", fTrace
.getResource());
1426 assertEquals("getStreamingInterval", 0, fTrace
.getStreamingInterval());
1427 assertEquals("getName", TEST_STREAM
, fTrace
.getName());
1429 assertEquals("getNbEvents", NB_EVENTS
, fTrace
.getNbEvents());
1430 assertEquals("getRange-start", 1, fTrace
.getTimeRange().getStartTime().getValue());
1431 assertEquals("getRange-end", NB_EVENTS
, fTrace
.getTimeRange().getEndTime().getValue());
1432 assertEquals("getStartTime", 1, fTrace
.getStartTime().getValue());
1433 assertEquals("getEndTime", NB_EVENTS
, fTrace
.getEndTime().getValue());
1435 String expected
= "TmfTrace [fPath=" + fTrace
.getPath() + ", fCacheSize=" + fTrace
.getCacheSize() +
1436 ", fNbEvents=" + fTrace
.getNbEvents() + ", fStartTime=" + fTrace
.getStartTime() +
1437 ", fEndTime=" + fTrace
.getEndTime() + ", fStreamingInterval=" + fTrace
.getStreamingInterval() +
1439 assertEquals("toString", expected
, fTrace
.toString());
1442 // ------------------------------------------------------------------------
1443 // getInitialRangeOffset, getCurrentRange, getCurrentTime
1444 // ------------------------------------------------------------------------
1447 public void testCurrentTimeValues() throws TmfTraceException
{
1449 TmfTraceStub trace
= null;
1450 File testfile
= null;
1452 final URL location
= FileLocator
.find(TmfCoreTestPlugin
.getDefault().getBundle(), new Path(DIRECTORY
+ File
.separator
+ TEST_STREAM
), null);
1453 testfile
= new File(FileLocator
.toFileURL(location
).toURI());
1454 trace
= new TmfTraceStub(testfile
.toURI().getPath());
1455 // verify initial values
1456 TmfTimestamp defaultInitRange
= new TmfTimestamp(DEFAULT_INITIAL_OFFSET_VALUE
, ITmfTimestamp
.NANOSECOND_SCALE
);
1457 assertEquals("getInitialRangeOffset", defaultInitRange
, trace
.getInitialRangeOffset());
1458 trace
.setInitialRangeOffset(new TmfTimestamp(5, ITmfTimestamp
.MILLISECOND_SCALE
));
1459 trace
.indexTrace(true);
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());
1472 * Run the String getHostId() method test
1475 public void testTraceHostId() {
1476 String a
= fTrace
.getHostId();
1477 assertEquals("A-Test-10K", a
);