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
.assertNotNull
;
20 import static org
.junit
.Assert
.assertNull
;
21 import static org
.junit
.Assert
.assertTrue
;
22 import static org
.junit
.Assert
.fail
;
25 import java
.io
.IOException
;
26 import java
.net
.URISyntaxException
;
28 import java
.util
.Collection
;
29 import java
.util
.Vector
;
31 import org
.eclipse
.core
.runtime
.FileLocator
;
32 import org
.eclipse
.core
.runtime
.Path
;
33 import org
.eclipse
.linuxtools
.internal
.tmf
.core
.component
.TmfProviderManager
;
34 import org
.eclipse
.linuxtools
.tmf
.core
.component
.ITmfDataProvider
;
35 import org
.eclipse
.linuxtools
.tmf
.core
.event
.ITmfEvent
;
36 import org
.eclipse
.linuxtools
.tmf
.core
.exceptions
.TmfTraceException
;
37 import org
.eclipse
.linuxtools
.tmf
.core
.request
.TmfDataRequest
;
38 import org
.eclipse
.linuxtools
.tmf
.core
.request
.TmfEventRequest
;
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
.ITmfLocation
;
47 import org
.eclipse
.linuxtools
.tmf
.core
.trace
.ITmfTrace
;
48 import org
.eclipse
.linuxtools
.tmf
.core
.trace
.TmfCheckpointIndexer
;
49 import org
.eclipse
.linuxtools
.tmf
.core
.trace
.TmfContext
;
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(), BLOCK_SIZE
);
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());
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);
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(), BLOCK_SIZE
);
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("getCacheSize", BLOCK_SIZE
, trace
.getCacheSize());
191 assertEquals("getStreamingInterval", 0, trace
.getStreamingInterval());
192 assertEquals("getName", TEST_STREAM
, trace
.getName());
194 assertEquals("getNbEvents", NB_EVENTS
, trace
.getNbEvents());
195 assertEquals("getRange-start", 1, trace
.getTimeRange().getStartTime().getValue());
196 assertEquals("getRange-end", NB_EVENTS
, trace
.getTimeRange().getEndTime().getValue());
197 assertEquals("getStartTime", 1, trace
.getStartTime().getValue());
198 assertEquals("getEndTime", NB_EVENTS
, trace
.getEndTime().getValue());
202 @SuppressWarnings("null")
203 public void testFullConstructor() throws TmfTraceException
{
204 TmfTraceStub trace
= null;
205 File testfile
= null;
207 final URL location
= FileLocator
.find(TmfCoreTestPlugin
.getDefault().getBundle(), new Path(DIRECTORY
+ File
.separator
+ TEST_STREAM
), null);
208 testfile
= new File(FileLocator
.toFileURL(location
).toURI());
209 trace
= new TmfTraceStub(testfile
.toURI().getPath(), BLOCK_SIZE
, null);
211 } catch (final URISyntaxException e
) {
212 fail("URISyntaxException");
213 } catch (final IOException e
) {
217 assertFalse ("Open trace", trace
== null);
218 assertEquals("getType", ITmfEvent
.class, trace
.getType());
219 assertNull ("getResource", trace
.getResource());
220 assertEquals("getPath", testfile
.toURI().getPath(), trace
.getPath());
221 assertEquals("getCacheSize", BLOCK_SIZE
, trace
.getCacheSize());
222 assertEquals("getStreamingInterval", 0, trace
.getStreamingInterval());
223 assertEquals("getName", TEST_STREAM
, trace
.getName());
225 assertEquals("getNbEvents", NB_EVENTS
, trace
.getNbEvents());
226 assertEquals("getRange-start", 1, trace
.getTimeRange().getStartTime().getValue());
227 assertEquals("getRange-end", NB_EVENTS
, trace
.getTimeRange().getEndTime().getValue());
228 assertEquals("getStartTime", 1, trace
.getStartTime().getValue());
229 assertEquals("getEndTime", NB_EVENTS
, trace
.getEndTime().getValue());
233 @SuppressWarnings("null")
234 public void testLiveTraceConstructor() throws TmfTraceException
{
235 TmfTraceStub trace
= null;
236 File testfile
= null;
237 final long interval
= 100;
239 final URL location
= FileLocator
.find(TmfCoreTestPlugin
.getDefault().getBundle(), new Path(DIRECTORY
+ File
.separator
+ TEST_STREAM
), null);
240 testfile
= new File(FileLocator
.toFileURL(location
).toURI());
241 trace
= new TmfTraceStub(testfile
.toURI().getPath(), BLOCK_SIZE
, interval
);
243 } catch (final URISyntaxException e
) {
244 fail("URISyntaxException");
245 } catch (final IOException e
) {
249 assertFalse ("Open trace", trace
== null);
250 assertEquals("getType", ITmfEvent
.class, trace
.getType());
251 assertNull ("getResource", trace
.getResource());
252 assertEquals("getPath", testfile
.toURI().getPath(), trace
.getPath());
253 assertEquals("getCacheSize", BLOCK_SIZE
, trace
.getCacheSize());
254 assertEquals("getStreamingInterval", interval
, trace
.getStreamingInterval());
255 assertEquals("getName", TEST_STREAM
, trace
.getName());
257 assertEquals("getNbEvents", NB_EVENTS
, trace
.getNbEvents());
258 assertEquals("getRange-start", 1, trace
.getTimeRange().getStartTime().getValue());
259 assertEquals("getRange-end", NB_EVENTS
, trace
.getTimeRange().getEndTime().getValue());
260 assertEquals("getStartTime", 1, trace
.getStartTime().getValue());
261 assertEquals("getEndTime", NB_EVENTS
, trace
.getEndTime().getValue());
265 @SuppressWarnings("null")
266 public void testCopyConstructor() throws TmfTraceException
{
267 TmfTraceStub original
= null;
268 TmfTraceStub trace
= null;
269 File testfile
= null;
271 final URL location
= FileLocator
.find(TmfCoreTestPlugin
.getDefault().getBundle(), new Path(DIRECTORY
+ File
.separator
+ TEST_STREAM
), null);
272 testfile
= new File(FileLocator
.toFileURL(location
).toURI());
273 original
= new TmfTraceStub(testfile
.toURI().getPath(), BLOCK_SIZE
, new TmfCheckpointIndexer(null));
274 trace
= new TmfTraceStub(original
);
276 } catch (final URISyntaxException e
) {
277 fail("URISyntaxException");
278 } catch (final IOException e
) {
282 assertFalse ("Open trace", trace
== null);
283 assertEquals("getType", ITmfEvent
.class, trace
.getType());
284 assertNull ("getResource", trace
.getResource());
285 assertEquals("getPath", testfile
.toURI().getPath(), trace
.getPath());
286 assertEquals("getCacheSize", BLOCK_SIZE
, trace
.getCacheSize());
287 assertEquals("getStreamingInterval", 0, trace
.getStreamingInterval());
288 assertEquals("getName", TEST_STREAM
, trace
.getName());
290 assertEquals("getNbEvents", NB_EVENTS
, trace
.getNbEvents());
291 assertEquals("getRange-start", 1, trace
.getTimeRange().getStartTime().getValue());
292 assertEquals("getRange-end", NB_EVENTS
, trace
.getTimeRange().getEndTime().getValue());
293 assertEquals("getStartTime", 1, trace
.getStartTime().getValue());
294 assertEquals("getEndTime", NB_EVENTS
, trace
.getEndTime().getValue());
296 // Test the copy of a null trace
298 new TmfTraceStub((TmfTraceStub
) null);
299 fail("Missing exception");
300 } catch (final IllegalArgumentException e
) {
302 } catch (final Exception e
) {
303 fail("Unexpected exception");
307 // ------------------------------------------------------------------------
308 // Trace initialization
309 // ------------------------------------------------------------------------
312 public void testInitializeNullPath() {
313 // Instantiate an "empty" trace
314 final TmfTraceStub trace
= new TmfTraceStub();
317 trace
.initialize(null, null, ITmfEvent
.class);
318 fail("TmfTrace.initialize() - no exception thrown");
319 } catch (TmfTraceException e
) {
321 } catch (Exception e
) {
322 fail("TmfTrace.initialize() - wrong exception thrown");
327 public void testInitializeSimplePath() {
328 // Instantiate an "empty" trace
329 final TmfTraceStub trace
= new TmfTraceStub();
331 // Path == trace name
332 String path
= "TraceName";
334 trace
.initialize(null, path
, ITmfEvent
.class);
335 } catch (Exception e
) {
336 fail("TmfTrace.initialize() - Exception thrown");
339 assertEquals("getType", ITmfEvent
.class, trace
.getType());
340 assertNull ("getResource", trace
.getResource());
341 assertEquals("getPath", path
, trace
.getPath());
342 assertEquals("getCacheSize", ITmfTrace
.DEFAULT_TRACE_CACHE_SIZE
, trace
.getCacheSize());
343 assertEquals("getStreamingInterval", 0, trace
.getStreamingInterval());
344 assertEquals("getName", path
, trace
.getName());
346 assertEquals("getNbEvents", 0, trace
.getNbEvents());
347 assertEquals("getRange-start", Long
.MIN_VALUE
, trace
.getTimeRange().getStartTime().getValue());
348 assertEquals("getRange-end", Long
.MIN_VALUE
, trace
.getTimeRange().getEndTime().getValue());
349 assertEquals("getStartTime", Long
.MIN_VALUE
, trace
.getStartTime().getValue());
350 assertEquals("getEndTime", Long
.MIN_VALUE
, trace
.getEndTime().getValue());
354 public void testInitializeNormalPath() {
355 // Instantiate an "empty" trace
356 final TmfTraceStub trace
= new TmfTraceStub();
358 // Path == trace name
359 String name
= "TraceName";
360 String path
= "/my/trace/path/" + name
;
362 trace
.initialize(null, path
, ITmfEvent
.class);
363 } catch (Exception e
) {
364 fail("TmfTrace.initialize() - Exception thrown");
367 assertEquals("getType", ITmfEvent
.class, trace
.getType());
368 assertNull ("getResource", trace
.getResource());
369 assertEquals("getPath", path
, trace
.getPath());
370 assertEquals("getCacheSize", ITmfTrace
.DEFAULT_TRACE_CACHE_SIZE
, trace
.getCacheSize());
371 assertEquals("getStreamingInterval", 0, trace
.getStreamingInterval());
372 assertEquals("getName", name
, trace
.getName());
374 assertEquals("getNbEvents", 0, trace
.getNbEvents());
375 assertEquals("getRange-start", Long
.MIN_VALUE
, trace
.getTimeRange().getStartTime().getValue());
376 assertEquals("getRange-end", Long
.MIN_VALUE
, trace
.getTimeRange().getEndTime().getValue());
377 assertEquals("getStartTime", Long
.MIN_VALUE
, trace
.getStartTime().getValue());
378 assertEquals("getEndTime", Long
.MIN_VALUE
, trace
.getEndTime().getValue());
382 public void testInitTrace() throws URISyntaxException
, IOException
, TmfTraceException
, InterruptedException
{
383 // Instantiate an "empty" trace
384 final TmfTraceStub trace
= new TmfTraceStub();
386 assertNull ("getType", trace
.getType());
387 assertNull ("getResource", trace
.getResource());
388 assertEquals("getCacheSize", ITmfTrace
.DEFAULT_TRACE_CACHE_SIZE
, trace
.getCacheSize());
389 assertEquals("getStreamingInterval", 0, trace
.getStreamingInterval());
390 assertEquals("getName", "", trace
.getName());
392 assertEquals("getNbEvents", 0, trace
.getNbEvents());
393 assertEquals("getRange-start", Long
.MIN_VALUE
, trace
.getTimeRange().getStartTime().getValue());
394 assertEquals("getRange-end", Long
.MIN_VALUE
, trace
.getTimeRange().getEndTime().getValue());
395 assertEquals("getStartTime", Long
.MIN_VALUE
, trace
.getStartTime().getValue());
396 assertEquals("getEndTime", Long
.MIN_VALUE
, trace
.getEndTime().getValue());
399 final URL location
= FileLocator
.find(TmfCoreTestPlugin
.getDefault().getBundle(), new Path(DIRECTORY
+ File
.separator
+ TEST_STREAM
), null);
400 final File testfile
= new File(FileLocator
.toFileURL(location
).toURI());
401 assertTrue("validate", trace
.validate(null, testfile
.getPath()));
403 // InitTrace and wait for indexing completion...
404 trace
.initTrace(null, testfile
.toURI().getPath(), ITmfEvent
.class);
407 while (trace
.getNbEvents() < NB_EVENTS
&& nbSecs
< 10) {
411 if (trace
.getNbEvents() < NB_EVENTS
) {
415 assertEquals("getType", ITmfEvent
.class, trace
.getType());
416 assertNull ("getResource", trace
.getResource());
417 assertEquals("getCacheSize", ITmfTrace
.DEFAULT_TRACE_CACHE_SIZE
, trace
.getCacheSize());
418 assertEquals("getStreamingInterval", 0, trace
.getStreamingInterval());
419 assertEquals("getName", TEST_STREAM
, trace
.getName());
421 assertEquals("getNbEvents", NB_EVENTS
, trace
.getNbEvents());
422 assertEquals("getRange-start", 1, trace
.getTimeRange().getStartTime().getValue());
423 assertEquals("getRange-end", NB_EVENTS
, trace
.getTimeRange().getEndTime().getValue());
424 assertEquals("getStartTime", 1, trace
.getStartTime().getValue());
425 assertEquals("getEndTime", NB_EVENTS
, trace
.getEndTime().getValue());
428 // ------------------------------------------------------------------------
429 // Set/Get streaming interval
430 // ------------------------------------------------------------------------
433 public void testSetStreamingInterval() throws TmfTraceException
{
434 final TmfTraceStub trace
= new TmfTraceStub(fTrace
);
437 assertEquals("getStreamingInterval", interval
, trace
.getStreamingInterval());
440 trace
.setStreamingInterval(interval
);
441 assertEquals("getStreamingInterval", interval
, trace
.getStreamingInterval());
444 trace
.setStreamingInterval(interval
);
445 assertEquals("getStreamingInterval", 0, trace
.getStreamingInterval());
448 trace
.setStreamingInterval(interval
);
449 assertEquals("getStreamingInterval", interval
, trace
.getStreamingInterval());
454 // ------------------------------------------------------------------------
455 // Set/Get time range
456 // ------------------------------------------------------------------------
459 public void testSetTimeRange() throws TmfTraceException
{
460 final TmfTraceStub trace
= new TmfTraceStub(fTrace
);
463 assertEquals("getRange-start", 1, trace
.getTimeRange().getStartTime().getValue());
464 assertEquals("getRange-end", NB_EVENTS
, trace
.getTimeRange().getEndTime().getValue());
465 assertEquals("getStartTime", 1, trace
.getStartTime().getValue());
466 assertEquals("getEndTime", NB_EVENTS
, trace
.getEndTime().getValue());
468 trace
.setTimeRange(new TmfTimeRange(new TmfTimestamp(100), new TmfTimestamp(200)));
469 assertEquals("setTimeRange", 100, trace
.getTimeRange().getStartTime().getValue());
470 assertEquals("setTimeRange", 200, trace
.getTimeRange().getEndTime().getValue());
471 assertEquals("setTimeRange", 100, trace
.getStartTime().getValue());
472 assertEquals("setTimeRange", 200, trace
.getEndTime().getValue());
478 public void testSetStartTime() throws TmfTraceException
{
479 final TmfTraceStub trace
= new TmfTraceStub(fTrace
);
482 assertEquals("getRange-start", 1, trace
.getTimeRange().getStartTime().getValue());
483 assertEquals("getRange-end", NB_EVENTS
, trace
.getTimeRange().getEndTime().getValue());
484 assertEquals("getStartTime", 1, trace
.getStartTime().getValue());
485 assertEquals("getEndTime", NB_EVENTS
, trace
.getEndTime().getValue());
487 trace
.setStartTime(new TmfTimestamp(100));
488 assertEquals("setStartTime", 100, trace
.getTimeRange().getStartTime().getValue());
489 assertEquals("setStartTime", NB_EVENTS
, trace
.getTimeRange().getEndTime().getValue());
490 assertEquals("setStartTime", 100, trace
.getStartTime().getValue());
491 assertEquals("setStartTime", NB_EVENTS
, trace
.getEndTime().getValue());
497 public void testSetEndTime() throws TmfTraceException
{
498 final TmfTraceStub trace
= new TmfTraceStub(fTrace
);
501 assertEquals("getRange-start", 1, trace
.getTimeRange().getStartTime().getValue());
502 assertEquals("getRange-end", NB_EVENTS
, trace
.getTimeRange().getEndTime().getValue());
503 assertEquals("getStartTime", 1, trace
.getStartTime().getValue());
504 assertEquals("getEndTime", NB_EVENTS
, trace
.getEndTime().getValue());
506 trace
.setEndTime(new TmfTimestamp(100));
507 assertEquals("setEndTime", 1, trace
.getTimeRange().getStartTime().getValue());
508 assertEquals("setEndTime", 100, trace
.getTimeRange().getEndTime().getValue());
509 assertEquals("setEndTime", 1, trace
.getStartTime().getValue());
510 assertEquals("setEndTime", 100, trace
.getEndTime().getValue());
516 public void testSetNbEvents() throws TmfTraceException
{
517 final TmfTraceStub trace
= new TmfTraceStub(fTrace
);
520 assertEquals("getNbEvents", NB_EVENTS
, trace
.getNbEvents());
522 trace
.setNbEvents(0);
523 assertEquals("getNbEvents", 0, trace
.getNbEvents());
525 trace
.setNbEvents(-1);
526 assertEquals("getNbEvents", 0, trace
.getNbEvents());
528 trace
.setNbEvents(NB_EVENTS
+ 1);
529 assertEquals("getNbEvents", NB_EVENTS
+ 1, trace
.getNbEvents());
531 trace
.setNbEvents(NB_EVENTS
);
532 assertEquals("getNbEvents", NB_EVENTS
, trace
.getNbEvents());
537 // ------------------------------------------------------------------------
538 // State system and statistics methods
539 // ------------------------------------------------------------------------
542 public void testGetStatistics() {
543 /* Should be null in unit tests */
544 ITmfStatistics stats
= fTrace
.getStatistics();
549 public void testGetStateSystem() {
550 /* There should be no state system registered so far */
551 ITmfStateSystem ss
= fTrace
.getStateSystem("something");
556 public void testListStateSystem() {
557 Collection
<String
> sss
= fTrace
.listStateSystems();
559 assertEquals(0, sss
.size());
562 // ------------------------------------------------------------------------
563 // seekEvent on location (note: does not reliably set the rank)
564 // ------------------------------------------------------------------------
567 public void testSeekEventOnCacheBoundary() {
568 // Position trace at event rank 0
569 ITmfContext context
= fTrace
.seekEvent(0);
570 ITmfEvent event
= fTrace
.parseEvent(context
);
571 assertEquals("Event timestamp", 1, event
.getTimestamp().getValue());
572 assertEquals("Event rank", 0, context
.getRank());
574 context
= fTrace
.seekEvent(context
.getLocation());
575 assertEquals("Event rank", ITmfContext
.UNKNOWN_RANK
, context
.getRank());
577 event
= fTrace
.parseEvent(context
);
578 assertEquals("Event timestamp", 1, event
.getTimestamp().getValue());
579 assertEquals("Event rank", ITmfContext
.UNKNOWN_RANK
, context
.getRank());
581 event
= fTrace
.getNext(context
);
582 assertEquals("Event timestamp", 1, event
.getTimestamp().getValue());
583 assertEquals("Event rank", ITmfContext
.UNKNOWN_RANK
, context
.getRank());
585 // Position trace at event rank 1000
586 ITmfContext tmpContext
= fTrace
.seekEvent(new TmfTimestamp(1001, SCALE
, 0));
587 context
= fTrace
.seekEvent(tmpContext
.getLocation());
588 assertEquals("Event rank", ITmfContext
.UNKNOWN_RANK
, context
.getRank());
590 event
= fTrace
.parseEvent(context
);
591 assertEquals("Event timestamp", 1001, event
.getTimestamp().getValue());
592 assertEquals("Event rank", ITmfContext
.UNKNOWN_RANK
, context
.getRank());
594 event
= fTrace
.getNext(context
);
595 assertEquals("Event timestamp", 1001, event
.getTimestamp().getValue());
596 assertEquals("Event rank", ITmfContext
.UNKNOWN_RANK
, context
.getRank());
598 // Position trace at event rank 4000
599 tmpContext
= fTrace
.seekEvent(new TmfTimestamp(4001, SCALE
, 0));
600 context
= fTrace
.seekEvent(tmpContext
.getLocation());
601 assertEquals("Event rank", ITmfContext
.UNKNOWN_RANK
, context
.getRank());
603 event
= fTrace
.parseEvent(context
);
604 assertEquals("Event timestamp", 4001, event
.getTimestamp().getValue());
605 assertEquals("Event rank", ITmfContext
.UNKNOWN_RANK
, context
.getRank());
607 event
= fTrace
.getNext(context
);
608 assertEquals("Event timestamp", 4001, event
.getTimestamp().getValue());
609 assertEquals("Event rank", ITmfContext
.UNKNOWN_RANK
, context
.getRank());
613 public void testSeekEventNotOnCacheBoundary() {
614 // Position trace at event rank 9
615 ITmfContext tmpContext
= fTrace
.seekEvent(new TmfTimestamp(10, SCALE
, 0));
616 TmfContext context
= fTrace
.seekEvent(tmpContext
.getLocation());
617 assertEquals("Event rank", ITmfContext
.UNKNOWN_RANK
, context
.getRank());
619 ITmfEvent event
= fTrace
.parseEvent(context
);
620 assertEquals("Event timestamp", 10, event
.getTimestamp().getValue());
621 assertEquals("Event rank", ITmfContext
.UNKNOWN_RANK
, context
.getRank());
623 event
= fTrace
.getNext(context
);
624 assertEquals("Event timestamp", 10, event
.getTimestamp().getValue());
625 assertEquals("Event rank", ITmfContext
.UNKNOWN_RANK
, context
.getRank());
627 // Position trace at event rank 999
628 tmpContext
= fTrace
.seekEvent(new TmfTimestamp(1000, SCALE
, 0));
629 context
= fTrace
.seekEvent(tmpContext
.getLocation());
630 assertEquals("Event rank", ITmfContext
.UNKNOWN_RANK
, context
.getRank());
632 event
= fTrace
.parseEvent(context
);
633 assertEquals("Event timestamp", 1000, event
.getTimestamp().getValue());
634 assertEquals("Event rank", ITmfContext
.UNKNOWN_RANK
, context
.getRank());
636 event
= fTrace
.getNext(context
);
637 assertEquals("Event timestamp", 1000, event
.getTimestamp().getValue());
638 assertEquals("Event rank", ITmfContext
.UNKNOWN_RANK
, context
.getRank());
640 // Position trace at event rank 1001
641 tmpContext
= fTrace
.seekEvent(new TmfTimestamp(1002, SCALE
, 0));
642 context
= fTrace
.seekEvent(tmpContext
.getLocation());
643 assertEquals("Event rank", ITmfContext
.UNKNOWN_RANK
, context
.getRank());
645 event
= fTrace
.parseEvent(context
);
646 assertEquals("Event timestamp", 1002, event
.getTimestamp().getValue());
647 assertEquals("Event rank", ITmfContext
.UNKNOWN_RANK
, context
.getRank());
649 event
= fTrace
.getNext(context
);
650 assertEquals("Event timestamp", 1002, event
.getTimestamp().getValue());
651 assertEquals("Event rank", ITmfContext
.UNKNOWN_RANK
, context
.getRank());
653 // Position trace at event rank 4500
654 tmpContext
= fTrace
.seekEvent(new TmfTimestamp(4501, SCALE
, 0));
655 context
= fTrace
.seekEvent(tmpContext
.getLocation());
656 assertEquals("Event rank", ITmfContext
.UNKNOWN_RANK
, context
.getRank());
658 event
= fTrace
.parseEvent(context
);
659 assertEquals("Event timestamp", 4501, event
.getTimestamp().getValue());
660 assertEquals("Event rank", ITmfContext
.UNKNOWN_RANK
, context
.getRank());
662 event
= fTrace
.getNext(context
);
663 assertEquals("Event timestamp", 4501, event
.getTimestamp().getValue());
664 assertEquals("Event rank", ITmfContext
.UNKNOWN_RANK
, context
.getRank());
668 public void testSeekEventOutOfScope() {
669 // Position trace at beginning
670 ITmfContext tmpContext
= fTrace
.seekEvent(0);
671 ITmfContext context
= fTrace
.seekEvent(tmpContext
.getLocation());
672 assertEquals("Event rank", ITmfContext
.UNKNOWN_RANK
, context
.getRank());
674 ITmfEvent event
= fTrace
.parseEvent(context
);
675 assertEquals("Event timestamp", 1, event
.getTimestamp().getValue());
676 assertEquals("Event rank", ITmfContext
.UNKNOWN_RANK
, context
.getRank());
678 event
= fTrace
.getNext(context
);
679 assertEquals("Event timestamp", 1, event
.getTimestamp().getValue());
680 assertEquals("Event rank", ITmfContext
.UNKNOWN_RANK
, context
.getRank());
682 // Position trace at event passed the end
683 context
= fTrace
.seekEvent(new TmfTimestamp(NB_EVENTS
+ 1, SCALE
, 0));
684 assertNull("Event timestamp", context
.getLocation());
685 assertEquals("Event rank", ITmfContext
.UNKNOWN_RANK
, context
.getRank());
687 event
= fTrace
.getNext(context
);
688 assertNull("Event", event
);
691 // ------------------------------------------------------------------------
692 // seekEvent on timestamp (note: does not reliably set the rank)
693 // ------------------------------------------------------------------------
696 public void testSeekEventOnNullTimestamp() {
697 // Position trace at event rank 0
698 ITmfContext context
= fTrace
.seekEvent((ITmfTimestamp
) null);
699 assertEquals("Event rank", 0, context
.getRank());
701 ITmfEvent event
= fTrace
.parseEvent(context
);
702 assertEquals("Event timestamp", 1, event
.getTimestamp().getValue());
703 assertEquals("Event rank", 0, context
.getRank());
707 public void testSeekEventOnTimestampOnCacheBoundary() {
708 // Position trace at event rank 0
709 ITmfContext context
= fTrace
.seekEvent(new TmfTimestamp(1, SCALE
, 0));
710 assertEquals("Event rank", 0, context
.getRank());
712 ITmfEvent event
= fTrace
.parseEvent(context
);
713 assertEquals("Event timestamp", 1, event
.getTimestamp().getValue());
714 assertEquals("Event rank", 0, context
.getRank());
716 event
= fTrace
.getNext(context
);
717 assertEquals("Event timestamp", 1, event
.getTimestamp().getValue());
718 assertEquals("Event rank", 1, context
.getRank());
720 // Position trace at event rank 1000
721 context
= fTrace
.seekEvent(new TmfTimestamp(1001, SCALE
, 0));
722 assertEquals("Event rank", 1000, context
.getRank());
724 event
= fTrace
.parseEvent(context
);
725 assertEquals("Event timestamp", 1001, event
.getTimestamp().getValue());
726 assertEquals("Event rank", 1000, context
.getRank());
728 event
= fTrace
.getNext(context
);
729 assertEquals("Event timestamp", 1001, event
.getTimestamp().getValue());
730 assertEquals("Event rank", 1001, context
.getRank());
732 // Position trace at event rank 4000
733 context
= fTrace
.seekEvent(new TmfTimestamp(4001, SCALE
, 0));
734 assertEquals("Event rank", 4000, context
.getRank());
736 event
= fTrace
.parseEvent(context
);
737 assertEquals("Event timestamp", 4001, event
.getTimestamp().getValue());
738 assertEquals("Event rank", 4000, context
.getRank());
740 event
= fTrace
.getNext(context
);
741 assertEquals("Event timestamp", 4001, event
.getTimestamp().getValue());
742 assertEquals("Event rank", 4001, context
.getRank());
746 public void testSeekEventOnTimestampNotOnCacheBoundary() {
747 // Position trace at event rank 1
748 ITmfContext context
= fTrace
.seekEvent(new TmfTimestamp(2, SCALE
, 0));
749 assertEquals("Event rank", 1, context
.getRank());
751 ITmfEvent event
= fTrace
.parseEvent(context
);
752 assertEquals("Event timestamp", 2, event
.getTimestamp().getValue());
753 assertEquals("Event rank", 1, context
.getRank());
755 event
= fTrace
.getNext(context
);
756 assertEquals("Event timestamp", 2, event
.getTimestamp().getValue());
757 assertEquals("Event rank", 2, context
.getRank());
759 // Position trace at event rank 9
760 context
= fTrace
.seekEvent(new TmfTimestamp(10, SCALE
, 0));
761 assertEquals("Event rank", 9, context
.getRank());
763 event
= fTrace
.parseEvent(context
);
764 assertEquals("Event timestamp", 10, event
.getTimestamp().getValue());
765 assertEquals("Event rank", 9, context
.getRank());
767 event
= fTrace
.getNext(context
);
768 assertEquals("Event timestamp", 10, event
.getTimestamp().getValue());
769 assertEquals("Event rank", 10, context
.getRank());
771 // Position trace at event rank 999
772 context
= fTrace
.seekEvent(new TmfTimestamp(1000, SCALE
, 0));
773 assertEquals("Event rank", 999, context
.getRank());
775 event
= fTrace
.parseEvent(context
);
776 assertEquals("Event timestamp", 1000, event
.getTimestamp().getValue());
777 assertEquals("Event rank", 999, context
.getRank());
779 event
= fTrace
.getNext(context
);
780 assertEquals("Event timestamp", 1000, event
.getTimestamp().getValue());
781 assertEquals("Event rank", 1000, context
.getRank());
783 // Position trace at event rank 1001
784 context
= fTrace
.seekEvent(new TmfTimestamp(1002, SCALE
, 0));
785 assertEquals("Event rank", 1001, context
.getRank());
787 event
= fTrace
.parseEvent(context
);
788 assertEquals("Event timestamp", 1002, event
.getTimestamp().getValue());
789 assertEquals("Event rank", 1001, context
.getRank());
791 event
= fTrace
.getNext(context
);
792 assertEquals("Event timestamp", 1002, event
.getTimestamp().getValue());
793 assertEquals("Event rank", 1002, context
.getRank());
795 // Position trace at event rank 4500
796 context
= fTrace
.seekEvent(new TmfTimestamp(4501, SCALE
, 0));
797 assertEquals("Event rank", 4500, context
.getRank());
799 event
= fTrace
.parseEvent(context
);
800 assertEquals("Event timestamp", 4501, event
.getTimestamp().getValue());
801 assertEquals("Event rank", 4500, context
.getRank());
803 event
= fTrace
.getNext(context
);
804 assertEquals("Event timestamp", 4501, event
.getTimestamp().getValue());
805 assertEquals("Event rank", 4501, context
.getRank());
809 public void testSeekEventOnTimestampOutOfScope() {
810 // Position trace at beginning
811 ITmfContext context
= fTrace
.seekEvent(new TmfTimestamp(-1, SCALE
, 0));
812 assertEquals("Event rank", 0, context
.getRank());
814 ITmfEvent event
= fTrace
.parseEvent(context
);
815 assertEquals("Event timestamp", 1, event
.getTimestamp().getValue());
816 assertEquals("Event rank", 0, context
.getRank());
818 event
= fTrace
.getNext(context
);
819 assertEquals("Event timestamp", 1, event
.getTimestamp().getValue());
820 assertEquals("Event rank", 1, context
.getRank());
822 // Position trace at event passed the end
823 context
= fTrace
.seekEvent(new TmfTimestamp(NB_EVENTS
+ 1, SCALE
, 0));
824 assertEquals("Event rank", ITmfContext
.UNKNOWN_RANK
, context
.getRank());
826 event
= fTrace
.parseEvent(context
);
827 assertEquals("Event timestamp", null, event
);
828 assertEquals("Event rank", ITmfContext
.UNKNOWN_RANK
, context
.getRank());
830 event
= fTrace
.getNext(context
);
831 assertEquals("Event timestamp", null, event
);
832 assertEquals("Event rank", ITmfContext
.UNKNOWN_RANK
, context
.getRank());
835 // ------------------------------------------------------------------------
837 // ------------------------------------------------------------------------
840 public void testSeekEventOnNegativeRank() {
841 // Position trace at event rank 0
842 ITmfContext context
= fTrace
.seekEvent(-1);
843 assertEquals("Event rank", 0, context
.getRank());
845 ITmfEvent event
= fTrace
.parseEvent(context
);
846 assertEquals("Event timestamp", 1, event
.getTimestamp().getValue());
847 assertEquals("Event rank", 0, context
.getRank());
851 public void testSeekOnRankOnCacheBoundary() {
852 // On lower bound, returns the first event (ts = 1)
853 ITmfContext context
= fTrace
.seekEvent(0);
854 assertEquals("Event rank", 0, context
.getRank());
856 ITmfEvent event
= fTrace
.parseEvent(context
);
857 assertEquals("Event timestamp", 1, event
.getTimestamp().getValue());
858 assertEquals("Event rank", 0, context
.getRank());
860 event
= fTrace
.getNext(context
);
861 assertEquals("Event timestamp", 1, event
.getTimestamp().getValue());
862 assertEquals("Event rank", 1, context
.getRank());
864 // Position trace at event rank 1000
865 context
= fTrace
.seekEvent(1000);
866 assertEquals("Event rank", 1000, context
.getRank());
868 event
= fTrace
.parseEvent(context
);
869 assertEquals("Event timestamp", 1001, event
.getTimestamp().getValue());
870 assertEquals("Event rank", 1000, context
.getRank());
872 event
= fTrace
.getNext(context
);
873 assertEquals("Event timestamp", 1001, event
.getTimestamp().getValue());
874 assertEquals("Event rank", 1001, context
.getRank());
876 // Position trace at event rank 4000
877 context
= fTrace
.seekEvent(4000);
878 assertEquals("Event rank", 4000, context
.getRank());
880 event
= fTrace
.parseEvent(context
);
881 assertEquals("Event timestamp", 4001, event
.getTimestamp().getValue());
882 assertEquals("Event rank", 4000, context
.getRank());
884 event
= fTrace
.getNext(context
);
885 assertEquals("Event timestamp", 4001, event
.getTimestamp().getValue());
886 assertEquals("Event rank", 4001, context
.getRank());
890 public void testSeekOnRankNotOnCacheBoundary() {
891 // Position trace at event rank 9
892 ITmfContext context
= fTrace
.seekEvent(9);
893 assertEquals("Event rank", 9, context
.getRank());
895 ITmfEvent event
= fTrace
.parseEvent(context
);
896 assertEquals("Event timestamp", 10, event
.getTimestamp().getValue());
897 assertEquals("Event rank", 9, context
.getRank());
899 event
= fTrace
.getNext(context
);
900 assertEquals("Event timestamp", 10, event
.getTimestamp().getValue());
901 assertEquals("Event rank", 10, context
.getRank());
903 // Position trace at event rank 999
904 context
= fTrace
.seekEvent(999);
905 assertEquals("Event rank", 999, context
.getRank());
907 event
= fTrace
.parseEvent(context
);
908 assertEquals("Event timestamp", 1000, event
.getTimestamp().getValue());
909 assertEquals("Event rank", 999, context
.getRank());
911 event
= fTrace
.getNext(context
);
912 assertEquals("Event timestamp", 1000, event
.getTimestamp().getValue());
913 assertEquals("Event rank", 1000, context
.getRank());
915 // Position trace at event rank 1001
916 context
= fTrace
.seekEvent(1001);
917 assertEquals("Event rank", 1001, context
.getRank());
919 event
= fTrace
.parseEvent(context
);
920 assertEquals("Event timestamp", 1002, event
.getTimestamp().getValue());
921 assertEquals("Event rank", 1001, context
.getRank());
923 event
= fTrace
.getNext(context
);
924 assertEquals("Event timestamp", 1002, event
.getTimestamp().getValue());
925 assertEquals("Event rank", 1002, context
.getRank());
927 // Position trace at event rank 4500
928 context
= fTrace
.seekEvent(4500);
929 assertEquals("Event rank", 4500, context
.getRank());
931 event
= fTrace
.parseEvent(context
);
932 assertEquals("Event timestamp", 4501, event
.getTimestamp().getValue());
933 assertEquals("Event rank", 4500, context
.getRank());
935 event
= fTrace
.getNext(context
);
936 assertEquals("Event timestamp", 4501, event
.getTimestamp().getValue());
937 assertEquals("Event rank", 4501, context
.getRank());
941 public void testSeekEventOnRankOutOfScope() {
942 // Position trace at beginning
943 ITmfContext context
= fTrace
.seekEvent(-1);
944 assertEquals("Event rank", 0, context
.getRank());
946 ITmfEvent event
= fTrace
.parseEvent(context
);
947 assertEquals("Event timestamp", 1, event
.getTimestamp().getValue());
948 assertEquals("Event rank", 0, context
.getRank());
950 event
= fTrace
.getNext(context
);
951 assertEquals("Event timestamp", 1, event
.getTimestamp().getValue());
952 assertEquals("Event rank", 1, context
.getRank());
954 // Position trace at event passed the end
955 context
= fTrace
.seekEvent(NB_EVENTS
);
956 assertEquals("Event rank", NB_EVENTS
, context
.getRank());
958 event
= fTrace
.parseEvent(context
);
959 assertNull("Event", event
);
960 assertEquals("Event rank", NB_EVENTS
, context
.getRank());
962 event
= fTrace
.getNext(context
);
963 assertNull("Event", event
);
964 assertEquals("Event rank", NB_EVENTS
, context
.getRank());
967 // ------------------------------------------------------------------------
968 // parseEvent - make sure parseEvent doesn't update the context
969 // ------------------------------------------------------------------------
972 public void testParseEvent() {
973 final int NB_READS
= 20;
975 // On lower bound, returns the first event (ts = 0)
976 final TmfContext context
= (TmfContext
) fTrace
.seekEvent(new TmfTimestamp(0, SCALE
, 0));
977 TmfContext svContext
= new TmfContext(context
);
979 ITmfEvent event
= fTrace
.parseEvent(context
);
980 assertEquals("Event timestamp", 1, event
.getTimestamp().getValue());
981 assertEquals("Event rank", 0, context
.getRank());
982 assertTrue("parseEvent", context
.equals(svContext
));
984 event
= fTrace
.parseEvent(context
);
985 assertEquals("Event timestamp", 1, event
.getTimestamp().getValue());
986 assertEquals("Event rank", 0, context
.getRank());
987 assertTrue("parseEvent", context
.equals(svContext
));
989 event
= fTrace
.parseEvent(context
);
990 assertEquals("Event timestamp", 1, event
.getTimestamp().getValue());
991 assertEquals("Event rank", 0, context
.getRank());
992 assertTrue("parseEvent", context
.equals(svContext
));
994 // Position the trace at event NB_READS
995 for (int i
= 1; i
< NB_READS
; i
++) {
996 event
= fTrace
.getNext(context
);
997 assertEquals("Event timestamp", i
, event
.getTimestamp().getValue());
1000 svContext
= new TmfContext(context
);
1001 event
= fTrace
.parseEvent(context
);
1002 assertEquals("Event timestamp", NB_READS
, event
.getTimestamp().getValue());
1003 assertEquals("Event rank", NB_READS
-1 , context
.getRank());
1004 assertTrue("parseEvent", context
.equals(svContext
));
1006 event
= fTrace
.parseEvent(context
);
1007 assertEquals("Event timestamp", NB_READS
, event
.getTimestamp().getValue());
1008 assertEquals("Event rank", NB_READS
- 1, context
.getRank());
1009 assertTrue("parseEvent", context
.equals(svContext
));
1012 // ------------------------------------------------------------------------
1013 // getNext - updates the context
1014 // ------------------------------------------------------------------------
1017 public void testGetNextAfteSeekingOnTS_1() {
1018 final long INITIAL_TS
= 1;
1019 final int NB_READS
= 20;
1021 // On lower bound, returns the first event (ts = 1)
1022 final ITmfContext context
= fTrace
.seekEvent(new TmfTimestamp(INITIAL_TS
, SCALE
, 0));
1026 for (int i
= 0; i
< NB_READS
; i
++) {
1027 event
= fTrace
.getNext(context
);
1028 assertEquals("Event timestamp", INITIAL_TS
+ i
, event
.getTimestamp().getValue());
1029 assertEquals("Event rank", INITIAL_TS
+ i
, context
.getRank());
1032 // Make sure we stay positioned
1033 event
= fTrace
.parseEvent(context
);
1034 assertEquals("Event timestamp", INITIAL_TS
+ NB_READS
, event
.getTimestamp().getValue());
1035 assertEquals("Event rank", INITIAL_TS
+ NB_READS
- 1, context
.getRank());
1039 public void testGetNextAfteSeekingOnTS_2() {
1040 final long INITIAL_TS
= 2;
1041 final int NB_READS
= 20;
1043 // On lower bound, returns the first event (ts = 500)
1044 final ITmfContext context
= fTrace
.seekEvent(new TmfTimestamp(INITIAL_TS
, SCALE
, 0));
1048 for (int i
= 0; i
< NB_READS
; i
++) {
1049 event
= fTrace
.getNext(context
);
1050 assertEquals("Event timestamp", INITIAL_TS
+ i
, event
.getTimestamp().getValue());
1051 assertEquals("Event rank", INITIAL_TS
+ i
, context
.getRank());
1054 // Make sure we stay positioned
1055 event
= fTrace
.parseEvent(context
);
1056 assertEquals("Event timestamp", INITIAL_TS
+ NB_READS
, event
.getTimestamp().getValue());
1057 assertEquals("Event rank", INITIAL_TS
+ NB_READS
- 1, context
.getRank());
1061 public void testGetNextAfteSeekingOnTS_3() {
1062 final long INITIAL_TS
= 500;
1063 final int NB_READS
= 20;
1065 // On lower bound, returns the first event (ts = 500)
1066 final ITmfContext context
= fTrace
.seekEvent(new TmfTimestamp(INITIAL_TS
, SCALE
, 0));
1070 for (int i
= 0; i
< NB_READS
; i
++) {
1071 event
= fTrace
.getNext(context
);
1072 assertEquals("Event timestamp", INITIAL_TS
+ i
, event
.getTimestamp().getValue());
1073 assertEquals("Event rank", INITIAL_TS
+ i
, context
.getRank());
1076 // Make sure we stay positioned
1077 event
= fTrace
.parseEvent(context
);
1078 assertEquals("Event timestamp", INITIAL_TS
+ NB_READS
, event
.getTimestamp().getValue());
1079 assertEquals("Event rank", INITIAL_TS
+ NB_READS
- 1, context
.getRank());
1083 public void testGetNextAfterSeekingOnRank_1() {
1084 final long INITIAL_RANK
= 0L;
1085 final int NB_READS
= 20;
1087 // On lower bound, returns the first event (rank = 0)
1088 final ITmfContext context
= fTrace
.seekEvent(INITIAL_RANK
);
1092 for (int i
= 0; i
< NB_READS
; i
++) {
1093 event
= fTrace
.getNext(context
);
1094 assertEquals("Event timestamp", INITIAL_RANK
+ i
+ 1, event
.getTimestamp().getValue());
1095 assertEquals("Event rank", INITIAL_RANK
+ i
+ 1, context
.getRank());
1098 // Make sure we stay positioned
1099 event
= fTrace
.parseEvent(context
);
1100 assertEquals("Event timestamp", INITIAL_RANK
+ NB_READS
+ 1, event
.getTimestamp().getValue());
1101 assertEquals("Event rank", INITIAL_RANK
+ NB_READS
, context
.getRank());
1105 public void testGetNextAfterSeekingOnRank_2() {
1106 final long INITIAL_RANK
= 1L;
1107 final int NB_READS
= 20;
1109 // On lower bound, returns the first event (rank = 0)
1110 final ITmfContext context
= fTrace
.seekEvent(INITIAL_RANK
);
1114 for (int i
= 0; i
< NB_READS
; i
++) {
1115 event
= fTrace
.getNext(context
);
1116 assertEquals("Event timestamp", INITIAL_RANK
+ i
+ 1, event
.getTimestamp().getValue());
1117 assertEquals("Event rank", INITIAL_RANK
+ i
+ 1, context
.getRank());
1120 // Make sure we stay positioned
1121 event
= fTrace
.parseEvent(context
);
1122 assertEquals("Event timestamp", INITIAL_RANK
+ NB_READS
+ 1, event
.getTimestamp().getValue());
1123 assertEquals("Event rank", INITIAL_RANK
+ NB_READS
, context
.getRank());
1127 public void testGetNextAfterSeekingOnRank_3() {
1128 final long INITIAL_RANK
= 500L;
1129 final int NB_READS
= 20;
1131 // On lower bound, returns the first event (rank = 0)
1132 final ITmfContext context
= fTrace
.seekEvent(INITIAL_RANK
);
1136 for (int i
= 0; i
< NB_READS
; i
++) {
1137 event
= fTrace
.getNext(context
);
1138 assertEquals("Event timestamp", INITIAL_RANK
+ i
+ 1, event
.getTimestamp().getValue());
1139 assertEquals("Event rank", INITIAL_RANK
+ i
+ 1, context
.getRank());
1142 // Make sure we stay positioned
1143 event
= fTrace
.parseEvent(context
);
1144 assertEquals("Event timestamp", INITIAL_RANK
+ NB_READS
+ 1, event
.getTimestamp().getValue());
1145 assertEquals("Event rank", INITIAL_RANK
+ NB_READS
, context
.getRank());
1149 public void testGetNextAfterSeekingOnLocation_1() {
1150 final ITmfLocation INITIAL_LOC
= null;
1151 final long INITIAL_TS
= 1;
1152 final int NB_READS
= 20;
1154 // On lower bound, returns the first event (ts = 1)
1155 final ITmfContext context
= fTrace
.seekEvent(INITIAL_LOC
);
1159 for (int i
= 0; i
< NB_READS
; i
++) {
1160 event
= fTrace
.getNext(context
);
1161 assertEquals("Event timestamp", INITIAL_TS
+ i
, event
.getTimestamp().getValue());
1162 assertEquals("Event rank", INITIAL_TS
+ i
, context
.getRank());
1165 // Make sure we stay positioned
1166 event
= fTrace
.parseEvent(context
);
1167 assertEquals("Event timestamp", INITIAL_TS
+ NB_READS
, event
.getTimestamp().getValue());
1168 assertEquals("Event rank", INITIAL_TS
+ NB_READS
- 1, context
.getRank());
1172 public void testGetNextAfterSeekingOnLocation_2() {
1173 final ITmfLocation INITIAL_LOC
= fTrace
.seekEvent(1L).getLocation();
1174 final long INITIAL_TS
= 2;
1175 final int NB_READS
= 20;
1177 // On lower bound, returns the first event (ts = 501)
1178 final ITmfContext context
= fTrace
.seekEvent(INITIAL_LOC
);
1182 for (int i
= 0; i
< NB_READS
; i
++) {
1183 event
= fTrace
.getNext(context
);
1184 assertEquals("Event timestamp", INITIAL_TS
+ i
, event
.getTimestamp().getValue());
1187 // Make sure we stay positioned
1188 event
= fTrace
.parseEvent(context
);
1189 assertEquals("Event timestamp", INITIAL_TS
+ NB_READS
, event
.getTimestamp().getValue());
1193 public void testGetNextAfterSeekingOnLocation_3() {
1194 final ITmfLocation INITIAL_LOC
= fTrace
.seekEvent(500L).getLocation();
1195 final long INITIAL_TS
= 501;
1196 final int NB_READS
= 20;
1198 // On lower bound, returns the first event (ts = 501)
1199 final ITmfContext context
= fTrace
.seekEvent(INITIAL_LOC
);
1203 for (int i
= 0; i
< NB_READS
; i
++) {
1204 event
= fTrace
.getNext(context
);
1205 assertEquals("Event timestamp", INITIAL_TS
+ i
, event
.getTimestamp().getValue());
1208 // Make sure we stay positioned
1209 event
= fTrace
.parseEvent(context
);
1210 assertEquals("Event timestamp", INITIAL_TS
+ NB_READS
, event
.getTimestamp().getValue());
1214 public void testGetNextLocation() {
1215 ITmfContext context1
= fTrace
.seekEvent(0);
1216 fTrace
.getNext(context1
);
1217 ITmfLocation location
= context1
.getLocation();
1218 ITmfEvent event1
= fTrace
.getNext(context1
);
1219 ITmfContext context2
= fTrace
.seekEvent(location
);
1220 ITmfEvent event2
= fTrace
.getNext(context2
);
1221 assertEquals("Event timestamp", event1
.getTimestamp().getValue(), event2
.getTimestamp().getValue());
1225 public void testGetNextEndLocation() {
1226 ITmfContext context1
= fTrace
.seekEvent(fTrace
.getNbEvents() - 1);
1227 fTrace
.getNext(context1
);
1228 ITmfLocation location
= context1
.getLocation();
1229 ITmfContext context2
= fTrace
.seekEvent(location
);
1230 ITmfEvent event
= fTrace
.getNext(context2
);
1231 assertNull("Event", event
);
1234 // ------------------------------------------------------------------------
1236 // ------------------------------------------------------------------------
1239 public void testProcessEventRequestForAllEvents() throws InterruptedException
{
1240 final int blockSize
= 1;
1241 final Vector
<ITmfEvent
> requestedEvents
= new Vector
<ITmfEvent
>();
1243 final TmfTimeRange range
= new TmfTimeRange(TmfTimestamp
.BIG_BANG
, TmfTimestamp
.BIG_CRUNCH
);
1244 final TmfEventRequest request
= new TmfEventRequest(ITmfEvent
.class, range
, NB_EVENTS
, blockSize
) {
1246 public void handleData(final ITmfEvent event
) {
1247 super.handleData(event
);
1248 requestedEvents
.add(event
);
1251 final ITmfDataProvider
[] providers
= TmfProviderManager
.getProviders(ITmfEvent
.class, TmfTraceStub
.class);
1252 providers
[0].sendRequest(request
);
1253 request
.waitForCompletion();
1255 assertEquals("nbEvents", NB_EVENTS
, requestedEvents
.size());
1256 assertTrue("isCompleted", request
.isCompleted());
1257 assertFalse("isCancelled", request
.isCancelled());
1259 // Ensure that we have distinct events.
1260 // Don't go overboard: we are not validating the stub!
1261 for (int i
= 0; i
< NB_EVENTS
; i
++) {
1262 assertEquals("Distinct events", i
+ 1, requestedEvents
.get(i
).getTimestamp().getValue());
1267 public void testProcessEventRequestForNbEvents() throws InterruptedException
{
1268 final int blockSize
= 100;
1269 final int nbEvents
= 1000;
1270 final Vector
<ITmfEvent
> requestedEvents
= new Vector
<ITmfEvent
>();
1272 final TmfTimeRange range
= new TmfTimeRange(TmfTimestamp
.BIG_BANG
, TmfTimestamp
.BIG_CRUNCH
);
1273 final TmfEventRequest request
= new TmfEventRequest(ITmfEvent
.class, range
, nbEvents
, blockSize
) {
1275 public void handleData(final ITmfEvent event
) {
1276 super.handleData(event
);
1277 requestedEvents
.add(event
);
1280 final ITmfDataProvider
[] providers
= TmfProviderManager
.getProviders(ITmfEvent
.class, TmfTraceStub
.class);
1281 providers
[0].sendRequest(request
);
1282 request
.waitForCompletion();
1284 assertEquals("nbEvents", nbEvents
, requestedEvents
.size());
1285 assertTrue("isCompleted", request
.isCompleted());
1286 assertFalse("isCancelled", request
.isCancelled());
1288 // Ensure that we have distinct events.
1289 // Don't go overboard: we are not validating the stub!
1290 for (int i
= 0; i
< nbEvents
; i
++) {
1291 assertEquals("Distinct events", i
+ 1, requestedEvents
.get(i
).getTimestamp().getValue());
1296 public void testProcessEventRequestForSomeEvents() throws InterruptedException
{
1297 final int blockSize
= 1;
1298 final long startTime
= 100;
1299 final int nbEvents
= 1000;
1300 final Vector
<ITmfEvent
> requestedEvents
= new Vector
<ITmfEvent
>();
1302 final TmfTimeRange range
= new TmfTimeRange(new TmfTimestamp(startTime
, SCALE
), TmfTimestamp
.BIG_CRUNCH
);
1303 final TmfEventRequest request
= new TmfEventRequest(ITmfEvent
.class, range
, nbEvents
, blockSize
) {
1305 public void handleData(final ITmfEvent event
) {
1306 super.handleData(event
);
1307 requestedEvents
.add(event
);
1310 final ITmfDataProvider
[] providers
= TmfProviderManager
.getProviders(ITmfEvent
.class, TmfTraceStub
.class);
1311 providers
[0].sendRequest(request
);
1312 request
.waitForCompletion();
1314 assertEquals("nbEvents", nbEvents
, requestedEvents
.size());
1315 assertTrue("isCompleted", request
.isCompleted());
1316 assertFalse("isCancelled", request
.isCancelled());
1318 // Ensure that we have distinct events.
1319 // Don't go overboard: we are not validating the stub!
1320 for (int i
= 0; i
< nbEvents
; i
++) {
1321 assertEquals("Distinct events", startTime
+ i
, requestedEvents
.get(i
).getTimestamp().getValue());
1326 public void testProcessEventRequestForOtherEvents() throws InterruptedException
{
1327 final int blockSize
= 1;
1328 final int startIndex
= 99;
1329 final long startTime
= 100;
1330 final int nbEvents
= 1000;
1331 final Vector
<ITmfEvent
> requestedEvents
= new Vector
<ITmfEvent
>();
1333 final TmfTimeRange range
= new TmfTimeRange(new TmfTimestamp(startTime
, SCALE
), TmfTimestamp
.BIG_CRUNCH
);
1334 final TmfEventRequest request
= new TmfEventRequest(ITmfEvent
.class, range
, startIndex
, nbEvents
, blockSize
) {
1336 public void handleData(final ITmfEvent event
) {
1337 super.handleData(event
);
1338 requestedEvents
.add(event
);
1341 final ITmfDataProvider
[] providers
= TmfProviderManager
.getProviders(ITmfEvent
.class, TmfTraceStub
.class);
1342 providers
[0].sendRequest(request
);
1343 request
.waitForCompletion();
1345 assertEquals("nbEvents", nbEvents
, requestedEvents
.size());
1346 assertTrue("isCompleted", request
.isCompleted());
1347 assertFalse("isCancelled", request
.isCancelled());
1349 // Ensure that we have distinct events.
1350 // Don't go overboard: we are not validating the stub!
1351 for (int i
= 0; i
< nbEvents
; i
++) {
1352 assertEquals("Distinct events", startTime
+ i
, requestedEvents
.get(i
).getTimestamp().getValue());
1357 public void testProcessDataRequestForSomeEvents() throws InterruptedException
{
1358 final int startIndex
= 100;
1359 final int nbEvents
= 1000;
1360 final Vector
<ITmfEvent
> requestedEvents
= new Vector
<ITmfEvent
>();
1362 final TmfDataRequest request
= new TmfDataRequest(ITmfEvent
.class, startIndex
, nbEvents
) {
1364 public void handleData(final ITmfEvent event
) {
1365 super.handleData(event
);
1366 requestedEvents
.add(event
);
1369 final ITmfDataProvider
[] providers
= TmfProviderManager
.getProviders(ITmfEvent
.class, TmfTraceStub
.class);
1370 providers
[0].sendRequest(request
);
1371 request
.waitForCompletion();
1373 assertEquals("nbEvents", nbEvents
, requestedEvents
.size());
1374 assertTrue("isCompleted", request
.isCompleted());
1375 assertFalse("isCancelled", request
.isCancelled());
1377 // Ensure that we have distinct events.
1378 // Don't go overboard: we are not validating the stub!
1379 for (int i
= 0; i
< nbEvents
; i
++) {
1380 assertEquals("Distinct events", startIndex
+ 1 + i
, requestedEvents
.get(i
).getTimestamp().getValue());
1384 // ------------------------------------------------------------------------
1386 // ------------------------------------------------------------------------
1389 public void testCancel() throws InterruptedException
{
1390 final Vector
<ITmfEvent
> requestedEvents
= new Vector
<ITmfEvent
>();
1392 final TmfTimeRange range
= new TmfTimeRange(TmfTimestamp
.BIG_BANG
, TmfTimestamp
.BIG_CRUNCH
);
1393 final TmfEventRequest request
= new TmfEventRequest(ITmfEvent
.class, range
, NB_EVENTS
, BLOCK_SIZE
) {
1396 public void handleData(final ITmfEvent event
) {
1397 super.handleData(event
);
1398 requestedEvents
.add(event
);
1399 if (++nbRead
== BLOCK_SIZE
) {
1404 final ITmfDataProvider
[] providers
= TmfProviderManager
.getProviders(ITmfEvent
.class, TmfTraceStub
.class);
1405 providers
[0].sendRequest(request
);
1406 request
.waitForCompletion();
1408 assertEquals("nbEvents", BLOCK_SIZE
, requestedEvents
.size());
1409 assertTrue("isCompleted", request
.isCompleted());
1410 assertTrue("isCancelled", request
.isCancelled());
1413 // ------------------------------------------------------------------------
1415 // ------------------------------------------------------------------------
1418 public void testDefaultTmfTraceStub() {
1419 assertFalse ("Open trace", fTrace
== null);
1420 assertEquals("getType", ITmfEvent
.class, fTrace
.getType());
1421 assertNull ("getResource", fTrace
.getResource());
1422 assertEquals("getCacheSize", BLOCK_SIZE
, fTrace
.getCacheSize());
1423 assertEquals("getStreamingInterval", 0, fTrace
.getStreamingInterval());
1424 assertEquals("getName", TEST_STREAM
, fTrace
.getName());
1426 assertEquals("getNbEvents", NB_EVENTS
, fTrace
.getNbEvents());
1427 assertEquals("getRange-start", 1, fTrace
.getTimeRange().getStartTime().getValue());
1428 assertEquals("getRange-end", NB_EVENTS
, fTrace
.getTimeRange().getEndTime().getValue());
1429 assertEquals("getStartTime", 1, fTrace
.getStartTime().getValue());
1430 assertEquals("getEndTime", NB_EVENTS
, fTrace
.getEndTime().getValue());
1432 String expected
= "TmfTrace [fPath=" + fTrace
.getPath() + ", fCacheSize=" + fTrace
.getCacheSize() +
1433 ", fNbEvents=" + fTrace
.getNbEvents() + ", fStartTime=" + fTrace
.getStartTime() +
1434 ", fEndTime=" + fTrace
.getEndTime() + ", fStreamingInterval=" + fTrace
.getStreamingInterval() +
1436 assertEquals("toString", expected
, fTrace
.toString());
1439 // ------------------------------------------------------------------------
1440 // getInitialRangeOffset, getCurrentRange, getCurrentTime
1441 // ------------------------------------------------------------------------
1444 public void testCurrentTimeValues() throws TmfTraceException
{
1446 TmfTraceStub trace
= null;
1447 File testfile
= null;
1449 final URL location
= FileLocator
.find(TmfCoreTestPlugin
.getDefault().getBundle(), new Path(DIRECTORY
+ File
.separator
+ TEST_STREAM
), null);
1450 testfile
= new File(FileLocator
.toFileURL(location
).toURI());
1451 trace
= new TmfTraceStub(testfile
.toURI().getPath());
1452 // verify initial values
1453 TmfTimestamp defaultInitRange
= new TmfTimestamp(DEFAULT_INITIAL_OFFSET_VALUE
, ITmfTimestamp
.NANOSECOND_SCALE
);
1454 assertEquals("getInitialRangeOffset", defaultInitRange
, trace
.getInitialRangeOffset());
1455 assertEquals("getCurrentTime", TmfTimestamp
.ZERO
, trace
.getCurrentTime());
1456 assertEquals("getCurrentRange", TmfTimeRange
.NULL_RANGE
, trace
.getCurrentRange());
1457 trace
.setInitialRangeOffset(new TmfTimestamp(5, ITmfTimestamp
.MILLISECOND_SCALE
));
1459 } catch (final URISyntaxException e
) {
1460 fail("URISyntaxException");
1461 } catch (final IOException e
) {
1462 fail("IOException");
1464 assertFalse ("Open trace", trace
== null);
1466 TmfTimestamp initRange
= new TmfTimestamp(5, ITmfTimestamp
.MILLISECOND_SCALE
);
1467 assertEquals("getInitialRangeOffset", initRange
, trace
.getInitialRangeOffset());
1468 assertEquals("getCurrentTime", trace
.getTimeRange().getStartTime(), trace
.getCurrentTime());
1470 ITmfTimestamp startTimestamp
= trace
.getTimeRange().getStartTime();
1471 long endValue
= startTimestamp
.getValue() + initRange
.normalize(0, startTimestamp
.getScale()).getValue();
1472 ITmfTimestamp endTimestamp
= new TmfTimestamp(endValue
, startTimestamp
.getScale());
1473 TmfTimeRange expectedRange
= new TmfTimeRange(startTimestamp
, endTimestamp
);
1474 assertEquals("getCurrentRange", expectedRange
, trace
.getCurrentRange());