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 NB_EVENTS
= 10000;
69 private static TmfTraceStub fTrace
= null;
71 private static int SCALE
= -3;
73 // ------------------------------------------------------------------------
75 // ------------------------------------------------------------------------
79 fTrace
= setupTrace(DIRECTORY
+ File
.separator
+ TEST_STREAM
);
83 public void tearDown() {
88 // ------------------------------------------------------------------------
90 // ------------------------------------------------------------------------
92 private static TmfTraceStub
setupTrace(final String path
) {
95 final URL location
= FileLocator
.find(TmfCoreTestPlugin
.getDefault().getBundle(), new Path(path
), null);
96 final File test
= new File(FileLocator
.toFileURL(location
).toURI());
97 fTrace
= new TmfTraceStub(test
.toURI().getPath(), ITmfTrace
.DEFAULT_TRACE_CACHE_SIZE
, false, null, null);
98 fTrace
.indexTrace(true);
99 } catch (final TmfTraceException e
) {
101 } catch (final URISyntaxException e
) {
103 } catch (final IOException e
) {
110 // ------------------------------------------------------------------------
112 // ------------------------------------------------------------------------
115 public void testFullConstructor() throws TmfTraceException
{
117 final URL location
= FileLocator
.find(TmfCoreTestPlugin
.getDefault().getBundle(), new Path(DIRECTORY
+ File
.separator
+ TEST_STREAM
), null);
118 File testfile
= new File(FileLocator
.toFileURL(location
).toURI());
119 TmfTraceStub trace
= new TmfTraceStub(testfile
.toURI().getPath(), ITmfTrace
.DEFAULT_TRACE_CACHE_SIZE
, false, null, null);
120 trace
.indexTrace(true);
122 assertEquals("getType", ITmfEvent
.class, trace
.getType());
123 assertNull("getResource", trace
.getResource());
124 assertEquals("getPath", testfile
.toURI().getPath(), trace
.getPath());
125 assertEquals("getCacheSize", ITmfTrace
.DEFAULT_TRACE_CACHE_SIZE
, trace
.getCacheSize());
126 assertEquals("getStreamingInterval", 0, trace
.getStreamingInterval());
127 assertEquals("getName", TEST_STREAM
, trace
.getName());
129 assertEquals("getNbEvents", NB_EVENTS
, trace
.getNbEvents());
130 assertEquals("getRange-start", 1, trace
.getTimeRange().getStartTime().getValue());
131 assertEquals("getRange-end", NB_EVENTS
, trace
.getTimeRange().getEndTime().getValue());
132 assertEquals("getStartTime", 1, trace
.getStartTime().getValue());
133 assertEquals("getEndTime", NB_EVENTS
, trace
.getEndTime().getValue());
135 } catch (final URISyntaxException e
) {
136 fail("URISyntaxException");
137 } catch (final IOException e
) {
143 public void testLiveTraceConstructor() throws TmfTraceException
{
144 final long interval
= 100;
146 final URL location
= FileLocator
.find(TmfCoreTestPlugin
.getDefault().getBundle(), new Path(DIRECTORY
+ File
.separator
+ TEST_STREAM
), null);
147 File testfile
= new File(FileLocator
.toFileURL(location
).toURI());
148 TmfTraceStub trace
= new TmfTraceStub(testfile
.toURI().getPath(), ITmfTrace
.DEFAULT_TRACE_CACHE_SIZE
, interval
);
149 trace
.indexTrace(true);
151 assertEquals("getType", ITmfEvent
.class, trace
.getType());
152 assertNull("getResource", trace
.getResource());
153 assertEquals("getPath", testfile
.toURI().getPath(), trace
.getPath());
154 assertEquals("getCacheSize", ITmfTrace
.DEFAULT_TRACE_CACHE_SIZE
, trace
.getCacheSize());
155 assertEquals("getStreamingInterval", interval
, trace
.getStreamingInterval());
156 assertEquals("getName", TEST_STREAM
, trace
.getName());
158 assertEquals("getNbEvents", NB_EVENTS
, trace
.getNbEvents());
159 assertEquals("getRange-start", 1, trace
.getTimeRange().getStartTime().getValue());
160 assertEquals("getRange-end", NB_EVENTS
, trace
.getTimeRange().getEndTime().getValue());
161 assertEquals("getStartTime", 1, trace
.getStartTime().getValue());
162 assertEquals("getEndTime", NB_EVENTS
, trace
.getEndTime().getValue());
164 } catch (final URISyntaxException e
) {
165 fail("URISyntaxException");
166 } catch (final IOException e
) {
172 public void testCopyConstructor() throws TmfTraceException
{
174 final URL location
= FileLocator
.find(TmfCoreTestPlugin
.getDefault().getBundle(), new Path(DIRECTORY
+ File
.separator
+ TEST_STREAM
), null);
175 File testfile
= new File(FileLocator
.toFileURL(location
).toURI());
176 TmfTraceStub original
= new TmfTraceStub(testfile
.toURI().getPath(), ITmfTrace
.DEFAULT_TRACE_CACHE_SIZE
, false, new TmfCheckpointIndexer(null), null);
177 TmfTraceStub trace
= new TmfTraceStub(original
);
178 trace
.indexTrace(true);
180 assertEquals("getType", ITmfEvent
.class, trace
.getType());
181 assertNull("getResource", trace
.getResource());
182 assertEquals("getPath", testfile
.toURI().getPath(), trace
.getPath());
183 assertEquals("getCacheSize", ITmfTrace
.DEFAULT_TRACE_CACHE_SIZE
, trace
.getCacheSize());
184 assertEquals("getStreamingInterval", 0, trace
.getStreamingInterval());
185 assertEquals("getName", TEST_STREAM
, trace
.getName());
187 assertEquals("getNbEvents", NB_EVENTS
, trace
.getNbEvents());
188 assertEquals("getRange-start", 1, trace
.getTimeRange().getStartTime().getValue());
189 assertEquals("getRange-end", NB_EVENTS
, trace
.getTimeRange().getEndTime().getValue());
190 assertEquals("getStartTime", 1, trace
.getStartTime().getValue());
191 assertEquals("getEndTime", NB_EVENTS
, trace
.getEndTime().getValue());
193 } catch (final URISyntaxException e
) {
194 fail("URISyntaxException");
195 } catch (final IOException e
) {
199 // Test the copy of a null trace
201 new TmfTraceStub((TmfTraceStub
) null);
202 fail("Missing exception");
203 } catch (final IllegalArgumentException e
) {
205 } catch (final Exception e
) {
206 fail("Unexpected exception");
210 // ------------------------------------------------------------------------
211 // Trace initialization
212 // ------------------------------------------------------------------------
215 public void testInitializeNullPath() {
216 // Instantiate an "empty" trace
217 final TmfTraceStub trace
= new TmfTraceStub();
220 trace
.initialize(null, null, ITmfEvent
.class);
221 fail("TmfTrace.initialize() - no exception thrown");
222 } catch (TmfTraceException e
) {
224 } catch (Exception e
) {
225 fail("TmfTrace.initialize() - wrong exception thrown");
230 public void testInitializeSimplePath() {
231 // Instantiate an "empty" trace
232 final TmfTraceStub trace
= new TmfTraceStub();
234 // Path == trace name
235 String path
= "TraceName";
237 trace
.initialize(null, path
, ITmfEvent
.class);
238 } catch (Exception e
) {
239 fail("TmfTrace.initialize() - Exception thrown");
242 assertEquals("getType", ITmfEvent
.class, trace
.getType());
243 assertNull ("getResource", trace
.getResource());
244 assertEquals("getPath", path
, trace
.getPath());
245 assertEquals("getCacheSize", ITmfTrace
.DEFAULT_TRACE_CACHE_SIZE
, trace
.getCacheSize());
246 assertEquals("getStreamingInterval", 0, trace
.getStreamingInterval());
247 assertEquals("getName", path
, trace
.getName());
249 assertEquals("getNbEvents", 0, trace
.getNbEvents());
250 assertEquals("getRange-start", Long
.MIN_VALUE
, trace
.getTimeRange().getStartTime().getValue());
251 assertEquals("getRange-end", Long
.MIN_VALUE
, trace
.getTimeRange().getEndTime().getValue());
252 assertEquals("getStartTime", Long
.MIN_VALUE
, trace
.getStartTime().getValue());
253 assertEquals("getEndTime", Long
.MIN_VALUE
, trace
.getEndTime().getValue());
257 public void testInitializeNormalPath() {
258 // Instantiate an "empty" trace
259 final TmfTraceStub trace
= new TmfTraceStub();
261 // Path == trace name
262 String name
= "TraceName";
263 String path
= "/my/trace/path/" + name
;
265 trace
.initialize(null, path
, ITmfEvent
.class);
266 } catch (Exception e
) {
267 fail("TmfTrace.initialize() - Exception thrown");
270 assertEquals("getType", ITmfEvent
.class, trace
.getType());
271 assertNull ("getResource", trace
.getResource());
272 assertEquals("getPath", path
, trace
.getPath());
273 assertEquals("getCacheSize", ITmfTrace
.DEFAULT_TRACE_CACHE_SIZE
, trace
.getCacheSize());
274 assertEquals("getStreamingInterval", 0, trace
.getStreamingInterval());
275 assertEquals("getName", name
, trace
.getName());
277 assertEquals("getNbEvents", 0, trace
.getNbEvents());
278 assertEquals("getRange-start", Long
.MIN_VALUE
, trace
.getTimeRange().getStartTime().getValue());
279 assertEquals("getRange-end", Long
.MIN_VALUE
, trace
.getTimeRange().getEndTime().getValue());
280 assertEquals("getStartTime", Long
.MIN_VALUE
, trace
.getStartTime().getValue());
281 assertEquals("getEndTime", Long
.MIN_VALUE
, trace
.getEndTime().getValue());
285 public void testInitTrace() throws URISyntaxException
, IOException
, TmfTraceException
, InterruptedException
{
286 // Instantiate an "empty" trace
287 final TmfTraceStub trace
= new TmfTraceStub();
289 assertNull ("getType", trace
.getType());
290 assertNull ("getResource", trace
.getResource());
291 assertEquals("getCacheSize", ITmfTrace
.DEFAULT_TRACE_CACHE_SIZE
, trace
.getCacheSize());
292 assertEquals("getStreamingInterval", 0, trace
.getStreamingInterval());
293 assertEquals("getName", "", trace
.getName());
295 assertEquals("getNbEvents", 0, trace
.getNbEvents());
296 assertEquals("getRange-start", Long
.MIN_VALUE
, trace
.getTimeRange().getStartTime().getValue());
297 assertEquals("getRange-end", Long
.MIN_VALUE
, trace
.getTimeRange().getEndTime().getValue());
298 assertEquals("getStartTime", Long
.MIN_VALUE
, trace
.getStartTime().getValue());
299 assertEquals("getEndTime", Long
.MIN_VALUE
, trace
.getEndTime().getValue());
302 final URL location
= FileLocator
.find(TmfCoreTestPlugin
.getDefault().getBundle(), new Path(DIRECTORY
+ File
.separator
+ TEST_STREAM
), null);
303 final File testfile
= new File(FileLocator
.toFileURL(location
).toURI());
304 assertTrue("validate", trace
.validate(null, testfile
.getPath()).isOK());
306 // InitTrace and wait for indexing completion...
307 trace
.initTrace(null, testfile
.toURI().getPath(), ITmfEvent
.class);
308 trace
.indexTrace(true);
310 while (trace
.getNbEvents() < NB_EVENTS
&& nbSecs
< 10) {
314 if (trace
.getNbEvents() < NB_EVENTS
) {
318 assertEquals("getType", ITmfEvent
.class, trace
.getType());
319 assertNull ("getResource", trace
.getResource());
320 assertEquals("getCacheSize", ITmfTrace
.DEFAULT_TRACE_CACHE_SIZE
, trace
.getCacheSize());
321 assertEquals("getStreamingInterval", 0, trace
.getStreamingInterval());
322 assertEquals("getName", TEST_STREAM
, trace
.getName());
324 assertEquals("getNbEvents", NB_EVENTS
, trace
.getNbEvents());
325 assertEquals("getRange-start", 1, trace
.getTimeRange().getStartTime().getValue());
326 assertEquals("getRange-end", NB_EVENTS
, trace
.getTimeRange().getEndTime().getValue());
327 assertEquals("getStartTime", 1, trace
.getStartTime().getValue());
328 assertEquals("getEndTime", NB_EVENTS
, trace
.getEndTime().getValue());
331 // ------------------------------------------------------------------------
332 // Set/Get streaming interval
333 // ------------------------------------------------------------------------
336 public void testSetStreamingInterval() throws TmfTraceException
{
337 final TmfTraceStub trace
= new TmfTraceStub(fTrace
);
340 assertEquals("getStreamingInterval", interval
, trace
.getStreamingInterval());
343 trace
.setStreamingInterval(interval
);
344 assertEquals("getStreamingInterval", interval
, trace
.getStreamingInterval());
347 trace
.setStreamingInterval(interval
);
348 assertEquals("getStreamingInterval", 0, trace
.getStreamingInterval());
351 trace
.setStreamingInterval(interval
);
352 assertEquals("getStreamingInterval", interval
, trace
.getStreamingInterval());
357 // ------------------------------------------------------------------------
358 // Set/Get time range
359 // ------------------------------------------------------------------------
362 public void testSetTimeRange() throws TmfTraceException
{
363 final TmfTraceStub trace
= new TmfTraceStub(fTrace
);
364 trace
.indexTrace(true);
366 assertEquals("getRange-start", 1, trace
.getTimeRange().getStartTime().getValue());
367 assertEquals("getRange-end", NB_EVENTS
, trace
.getTimeRange().getEndTime().getValue());
368 assertEquals("getStartTime", 1, trace
.getStartTime().getValue());
369 assertEquals("getEndTime", NB_EVENTS
, trace
.getEndTime().getValue());
371 trace
.setTimeRange(new TmfTimeRange(new TmfTimestamp(100), new TmfTimestamp(200)));
372 assertEquals("setTimeRange", 100, trace
.getTimeRange().getStartTime().getValue());
373 assertEquals("setTimeRange", 200, trace
.getTimeRange().getEndTime().getValue());
374 assertEquals("setTimeRange", 100, trace
.getStartTime().getValue());
375 assertEquals("setTimeRange", 200, trace
.getEndTime().getValue());
381 public void testSetStartTime() throws TmfTraceException
{
382 final TmfTraceStub trace
= new TmfTraceStub(fTrace
);
383 trace
.indexTrace(true);
385 assertEquals("getRange-start", 1, trace
.getTimeRange().getStartTime().getValue());
386 assertEquals("getRange-end", NB_EVENTS
, trace
.getTimeRange().getEndTime().getValue());
387 assertEquals("getStartTime", 1, trace
.getStartTime().getValue());
388 assertEquals("getEndTime", NB_EVENTS
, trace
.getEndTime().getValue());
390 trace
.setStartTime(new TmfTimestamp(100));
391 assertEquals("setStartTime", 100, trace
.getTimeRange().getStartTime().getValue());
392 assertEquals("setStartTime", NB_EVENTS
, trace
.getTimeRange().getEndTime().getValue());
393 assertEquals("setStartTime", 100, trace
.getStartTime().getValue());
394 assertEquals("setStartTime", NB_EVENTS
, trace
.getEndTime().getValue());
400 public void testSetEndTime() throws TmfTraceException
{
401 final TmfTraceStub trace
= new TmfTraceStub(fTrace
);
402 trace
.indexTrace(true);
404 assertEquals("getRange-start", 1, trace
.getTimeRange().getStartTime().getValue());
405 assertEquals("getRange-end", NB_EVENTS
, trace
.getTimeRange().getEndTime().getValue());
406 assertEquals("getStartTime", 1, trace
.getStartTime().getValue());
407 assertEquals("getEndTime", NB_EVENTS
, trace
.getEndTime().getValue());
409 trace
.setEndTime(new TmfTimestamp(100));
410 assertEquals("setEndTime", 1, trace
.getTimeRange().getStartTime().getValue());
411 assertEquals("setEndTime", 100, trace
.getTimeRange().getEndTime().getValue());
412 assertEquals("setEndTime", 1, trace
.getStartTime().getValue());
413 assertEquals("setEndTime", 100, trace
.getEndTime().getValue());
419 public void testSetNbEvents() throws TmfTraceException
{
420 final TmfTraceStub trace
= new TmfTraceStub(fTrace
);
421 trace
.indexTrace(true);
423 assertEquals("getNbEvents", NB_EVENTS
, trace
.getNbEvents());
425 trace
.setNbEvents(0);
426 assertEquals("getNbEvents", 0, trace
.getNbEvents());
428 trace
.setNbEvents(-1);
429 assertEquals("getNbEvents", 0, trace
.getNbEvents());
431 trace
.setNbEvents(NB_EVENTS
+ 1);
432 assertEquals("getNbEvents", NB_EVENTS
+ 1, trace
.getNbEvents());
434 trace
.setNbEvents(NB_EVENTS
);
435 assertEquals("getNbEvents", NB_EVENTS
, trace
.getNbEvents());
440 // ------------------------------------------------------------------------
441 // State system and statistics methods
442 // ------------------------------------------------------------------------
445 public void testGetStatistics() {
446 /* Should be null in unit tests */
447 ITmfStatistics stats
= fTrace
.getStatistics();
452 public void testGetStateSystem() {
453 /* There should be no state system registered so far */
454 ITmfStateSystem ss
= fTrace
.getStateSystems().get("something");
459 * Make sure the returned map is unmodifiable.
461 @Test(expected
=UnsupportedOperationException
.class)
462 public void testGetStateSystem_readOnly() {
463 Map
<String
, ITmfStateSystem
> sss
= fTrace
.getStateSystems();
464 sss
.put("something", null);
467 // ------------------------------------------------------------------------
468 // seekEvent on location (note: does not reliably set the rank)
469 // ------------------------------------------------------------------------
472 public void testSeekEventOnCacheBoundary() {
473 // Position trace at event rank 0
474 ITmfContext context
= fTrace
.seekEvent(0);
475 ITmfEvent event
= fTrace
.parseEvent(context
);
476 assertEquals("Event timestamp", 1, event
.getTimestamp().getValue());
477 assertEquals("Event rank", 0, context
.getRank());
479 context
= fTrace
.seekEvent(context
.getLocation());
480 assertEquals("Event rank", ITmfContext
.UNKNOWN_RANK
, context
.getRank());
482 event
= fTrace
.parseEvent(context
);
483 assertEquals("Event timestamp", 1, event
.getTimestamp().getValue());
484 assertEquals("Event rank", ITmfContext
.UNKNOWN_RANK
, context
.getRank());
486 event
= fTrace
.getNext(context
);
487 assertEquals("Event timestamp", 1, event
.getTimestamp().getValue());
488 assertEquals("Event rank", ITmfContext
.UNKNOWN_RANK
, context
.getRank());
490 // Position trace at event rank 1000
491 ITmfContext tmpContext
= fTrace
.seekEvent(new TmfTimestamp(1001, SCALE
, 0));
492 context
= fTrace
.seekEvent(tmpContext
.getLocation());
493 assertEquals("Event rank", ITmfContext
.UNKNOWN_RANK
, context
.getRank());
495 event
= fTrace
.parseEvent(context
);
496 assertEquals("Event timestamp", 1001, event
.getTimestamp().getValue());
497 assertEquals("Event rank", ITmfContext
.UNKNOWN_RANK
, context
.getRank());
499 event
= fTrace
.getNext(context
);
500 assertEquals("Event timestamp", 1001, event
.getTimestamp().getValue());
501 assertEquals("Event rank", ITmfContext
.UNKNOWN_RANK
, context
.getRank());
503 // Position trace at event rank 4000
504 tmpContext
= fTrace
.seekEvent(new TmfTimestamp(4001, SCALE
, 0));
505 context
= fTrace
.seekEvent(tmpContext
.getLocation());
506 assertEquals("Event rank", ITmfContext
.UNKNOWN_RANK
, context
.getRank());
508 event
= fTrace
.parseEvent(context
);
509 assertEquals("Event timestamp", 4001, event
.getTimestamp().getValue());
510 assertEquals("Event rank", ITmfContext
.UNKNOWN_RANK
, context
.getRank());
512 event
= fTrace
.getNext(context
);
513 assertEquals("Event timestamp", 4001, event
.getTimestamp().getValue());
514 assertEquals("Event rank", ITmfContext
.UNKNOWN_RANK
, context
.getRank());
518 public void testSeekEventNotOnCacheBoundary() {
519 // Position trace at event rank 9
520 ITmfContext tmpContext
= fTrace
.seekEvent(new TmfTimestamp(10, SCALE
, 0));
521 TmfContext context
= fTrace
.seekEvent(tmpContext
.getLocation());
522 assertEquals("Event rank", ITmfContext
.UNKNOWN_RANK
, context
.getRank());
524 ITmfEvent event
= fTrace
.parseEvent(context
);
525 assertEquals("Event timestamp", 10, event
.getTimestamp().getValue());
526 assertEquals("Event rank", ITmfContext
.UNKNOWN_RANK
, context
.getRank());
528 event
= fTrace
.getNext(context
);
529 assertEquals("Event timestamp", 10, event
.getTimestamp().getValue());
530 assertEquals("Event rank", ITmfContext
.UNKNOWN_RANK
, context
.getRank());
532 // Position trace at event rank 999
533 tmpContext
= fTrace
.seekEvent(new TmfTimestamp(1000, SCALE
, 0));
534 context
= fTrace
.seekEvent(tmpContext
.getLocation());
535 assertEquals("Event rank", ITmfContext
.UNKNOWN_RANK
, context
.getRank());
537 event
= fTrace
.parseEvent(context
);
538 assertEquals("Event timestamp", 1000, event
.getTimestamp().getValue());
539 assertEquals("Event rank", ITmfContext
.UNKNOWN_RANK
, context
.getRank());
541 event
= fTrace
.getNext(context
);
542 assertEquals("Event timestamp", 1000, event
.getTimestamp().getValue());
543 assertEquals("Event rank", ITmfContext
.UNKNOWN_RANK
, context
.getRank());
545 // Position trace at event rank 1001
546 tmpContext
= fTrace
.seekEvent(new TmfTimestamp(1002, SCALE
, 0));
547 context
= fTrace
.seekEvent(tmpContext
.getLocation());
548 assertEquals("Event rank", ITmfContext
.UNKNOWN_RANK
, context
.getRank());
550 event
= fTrace
.parseEvent(context
);
551 assertEquals("Event timestamp", 1002, event
.getTimestamp().getValue());
552 assertEquals("Event rank", ITmfContext
.UNKNOWN_RANK
, context
.getRank());
554 event
= fTrace
.getNext(context
);
555 assertEquals("Event timestamp", 1002, event
.getTimestamp().getValue());
556 assertEquals("Event rank", ITmfContext
.UNKNOWN_RANK
, context
.getRank());
558 // Position trace at event rank 4500
559 tmpContext
= fTrace
.seekEvent(new TmfTimestamp(4501, SCALE
, 0));
560 context
= fTrace
.seekEvent(tmpContext
.getLocation());
561 assertEquals("Event rank", ITmfContext
.UNKNOWN_RANK
, context
.getRank());
563 event
= fTrace
.parseEvent(context
);
564 assertEquals("Event timestamp", 4501, event
.getTimestamp().getValue());
565 assertEquals("Event rank", ITmfContext
.UNKNOWN_RANK
, context
.getRank());
567 event
= fTrace
.getNext(context
);
568 assertEquals("Event timestamp", 4501, event
.getTimestamp().getValue());
569 assertEquals("Event rank", ITmfContext
.UNKNOWN_RANK
, context
.getRank());
573 public void testSeekEventOutOfScope() {
574 // Position trace at beginning
575 ITmfContext tmpContext
= fTrace
.seekEvent(0);
576 ITmfContext context
= fTrace
.seekEvent(tmpContext
.getLocation());
577 assertEquals("Event rank", ITmfContext
.UNKNOWN_RANK
, context
.getRank());
579 ITmfEvent event
= fTrace
.parseEvent(context
);
580 assertEquals("Event timestamp", 1, event
.getTimestamp().getValue());
581 assertEquals("Event rank", ITmfContext
.UNKNOWN_RANK
, context
.getRank());
583 event
= fTrace
.getNext(context
);
584 assertEquals("Event timestamp", 1, event
.getTimestamp().getValue());
585 assertEquals("Event rank", ITmfContext
.UNKNOWN_RANK
, context
.getRank());
587 // Position trace at event passed the end
588 context
= fTrace
.seekEvent(new TmfTimestamp(NB_EVENTS
+ 1, SCALE
, 0));
589 assertNull("Event timestamp", context
.getLocation());
590 assertEquals("Event rank", ITmfContext
.UNKNOWN_RANK
, context
.getRank());
592 event
= fTrace
.getNext(context
);
593 assertNull("Event", event
);
596 // ------------------------------------------------------------------------
597 // seekEvent on timestamp (note: does not reliably set the rank)
598 // ------------------------------------------------------------------------
601 public void testSeekEventOnNullTimestamp() {
602 // Position trace at event rank 0
603 ITmfContext context
= fTrace
.seekEvent((ITmfTimestamp
) null);
604 assertEquals("Event rank", 0, context
.getRank());
606 ITmfEvent event
= fTrace
.parseEvent(context
);
607 assertEquals("Event timestamp", 1, event
.getTimestamp().getValue());
608 assertEquals("Event rank", 0, context
.getRank());
612 public void testSeekEventOnTimestampOnCacheBoundary() {
613 // Position trace at event rank 0
614 ITmfContext context
= fTrace
.seekEvent(new TmfTimestamp(1, SCALE
, 0));
615 assertEquals("Event rank", 0, context
.getRank());
617 ITmfEvent event
= fTrace
.parseEvent(context
);
618 assertEquals("Event timestamp", 1, event
.getTimestamp().getValue());
619 assertEquals("Event rank", 0, context
.getRank());
621 event
= fTrace
.getNext(context
);
622 assertEquals("Event timestamp", 1, event
.getTimestamp().getValue());
623 assertEquals("Event rank", 1, context
.getRank());
625 // Position trace at event rank 1000
626 context
= fTrace
.seekEvent(new TmfTimestamp(1001, SCALE
, 0));
627 assertEquals("Event rank", 1000, context
.getRank());
629 event
= fTrace
.parseEvent(context
);
630 assertEquals("Event timestamp", 1001, event
.getTimestamp().getValue());
631 assertEquals("Event rank", 1000, context
.getRank());
633 event
= fTrace
.getNext(context
);
634 assertEquals("Event timestamp", 1001, event
.getTimestamp().getValue());
635 assertEquals("Event rank", 1001, context
.getRank());
637 // Position trace at event rank 4000
638 context
= fTrace
.seekEvent(new TmfTimestamp(4001, SCALE
, 0));
639 assertEquals("Event rank", 4000, context
.getRank());
641 event
= fTrace
.parseEvent(context
);
642 assertEquals("Event timestamp", 4001, event
.getTimestamp().getValue());
643 assertEquals("Event rank", 4000, context
.getRank());
645 event
= fTrace
.getNext(context
);
646 assertEquals("Event timestamp", 4001, event
.getTimestamp().getValue());
647 assertEquals("Event rank", 4001, context
.getRank());
651 public void testSeekEventOnTimestampNotOnCacheBoundary() {
652 // Position trace at event rank 1
653 ITmfContext context
= fTrace
.seekEvent(new TmfTimestamp(2, SCALE
, 0));
654 assertEquals("Event rank", 1, context
.getRank());
656 ITmfEvent event
= fTrace
.parseEvent(context
);
657 assertEquals("Event timestamp", 2, event
.getTimestamp().getValue());
658 assertEquals("Event rank", 1, context
.getRank());
660 event
= fTrace
.getNext(context
);
661 assertEquals("Event timestamp", 2, event
.getTimestamp().getValue());
662 assertEquals("Event rank", 2, context
.getRank());
664 // Position trace at event rank 9
665 context
= fTrace
.seekEvent(new TmfTimestamp(10, SCALE
, 0));
666 assertEquals("Event rank", 9, context
.getRank());
668 event
= fTrace
.parseEvent(context
);
669 assertEquals("Event timestamp", 10, event
.getTimestamp().getValue());
670 assertEquals("Event rank", 9, context
.getRank());
672 event
= fTrace
.getNext(context
);
673 assertEquals("Event timestamp", 10, event
.getTimestamp().getValue());
674 assertEquals("Event rank", 10, context
.getRank());
676 // Position trace at event rank 999
677 context
= fTrace
.seekEvent(new TmfTimestamp(1000, SCALE
, 0));
678 assertEquals("Event rank", 999, context
.getRank());
680 event
= fTrace
.parseEvent(context
);
681 assertEquals("Event timestamp", 1000, event
.getTimestamp().getValue());
682 assertEquals("Event rank", 999, context
.getRank());
684 event
= fTrace
.getNext(context
);
685 assertEquals("Event timestamp", 1000, event
.getTimestamp().getValue());
686 assertEquals("Event rank", 1000, context
.getRank());
688 // Position trace at event rank 1001
689 context
= fTrace
.seekEvent(new TmfTimestamp(1002, SCALE
, 0));
690 assertEquals("Event rank", 1001, context
.getRank());
692 event
= fTrace
.parseEvent(context
);
693 assertEquals("Event timestamp", 1002, event
.getTimestamp().getValue());
694 assertEquals("Event rank", 1001, context
.getRank());
696 event
= fTrace
.getNext(context
);
697 assertEquals("Event timestamp", 1002, event
.getTimestamp().getValue());
698 assertEquals("Event rank", 1002, context
.getRank());
700 // Position trace at event rank 4500
701 context
= fTrace
.seekEvent(new TmfTimestamp(4501, SCALE
, 0));
702 assertEquals("Event rank", 4500, context
.getRank());
704 event
= fTrace
.parseEvent(context
);
705 assertEquals("Event timestamp", 4501, event
.getTimestamp().getValue());
706 assertEquals("Event rank", 4500, context
.getRank());
708 event
= fTrace
.getNext(context
);
709 assertEquals("Event timestamp", 4501, event
.getTimestamp().getValue());
710 assertEquals("Event rank", 4501, context
.getRank());
714 public void testSeekEventOnTimestampOutOfScope() {
715 // Position trace at beginning
716 ITmfContext context
= fTrace
.seekEvent(new TmfTimestamp(-1, SCALE
, 0));
717 assertEquals("Event rank", 0, context
.getRank());
719 ITmfEvent event
= fTrace
.parseEvent(context
);
720 assertEquals("Event timestamp", 1, event
.getTimestamp().getValue());
721 assertEquals("Event rank", 0, context
.getRank());
723 event
= fTrace
.getNext(context
);
724 assertEquals("Event timestamp", 1, event
.getTimestamp().getValue());
725 assertEquals("Event rank", 1, context
.getRank());
727 // Position trace at event passed the end
728 context
= fTrace
.seekEvent(new TmfTimestamp(NB_EVENTS
+ 1, SCALE
, 0));
729 assertEquals("Event rank", ITmfContext
.UNKNOWN_RANK
, context
.getRank());
731 event
= fTrace
.parseEvent(context
);
732 assertEquals("Event timestamp", null, event
);
733 assertEquals("Event rank", ITmfContext
.UNKNOWN_RANK
, context
.getRank());
735 event
= fTrace
.getNext(context
);
736 assertEquals("Event timestamp", null, event
);
737 assertEquals("Event rank", ITmfContext
.UNKNOWN_RANK
, context
.getRank());
740 // ------------------------------------------------------------------------
742 // ------------------------------------------------------------------------
745 public void testSeekEventOnNegativeRank() {
746 // Position trace at event rank 0
747 ITmfContext context
= fTrace
.seekEvent(-1);
748 assertEquals("Event rank", 0, context
.getRank());
750 ITmfEvent event
= fTrace
.parseEvent(context
);
751 assertEquals("Event timestamp", 1, event
.getTimestamp().getValue());
752 assertEquals("Event rank", 0, context
.getRank());
756 public void testSeekOnRankOnCacheBoundary() {
757 // On lower bound, returns the first event (ts = 1)
758 ITmfContext context
= fTrace
.seekEvent(0);
759 assertEquals("Event rank", 0, context
.getRank());
761 ITmfEvent event
= fTrace
.parseEvent(context
);
762 assertEquals("Event timestamp", 1, event
.getTimestamp().getValue());
763 assertEquals("Event rank", 0, context
.getRank());
765 event
= fTrace
.getNext(context
);
766 assertEquals("Event timestamp", 1, event
.getTimestamp().getValue());
767 assertEquals("Event rank", 1, context
.getRank());
769 // Position trace at event rank 1000
770 context
= fTrace
.seekEvent(1000);
771 assertEquals("Event rank", 1000, context
.getRank());
773 event
= fTrace
.parseEvent(context
);
774 assertEquals("Event timestamp", 1001, event
.getTimestamp().getValue());
775 assertEquals("Event rank", 1000, context
.getRank());
777 event
= fTrace
.getNext(context
);
778 assertEquals("Event timestamp", 1001, event
.getTimestamp().getValue());
779 assertEquals("Event rank", 1001, context
.getRank());
781 // Position trace at event rank 4000
782 context
= fTrace
.seekEvent(4000);
783 assertEquals("Event rank", 4000, context
.getRank());
785 event
= fTrace
.parseEvent(context
);
786 assertEquals("Event timestamp", 4001, event
.getTimestamp().getValue());
787 assertEquals("Event rank", 4000, context
.getRank());
789 event
= fTrace
.getNext(context
);
790 assertEquals("Event timestamp", 4001, event
.getTimestamp().getValue());
791 assertEquals("Event rank", 4001, context
.getRank());
795 public void testSeekOnRankNotOnCacheBoundary() {
796 // Position trace at event rank 9
797 ITmfContext context
= fTrace
.seekEvent(9);
798 assertEquals("Event rank", 9, context
.getRank());
800 ITmfEvent event
= fTrace
.parseEvent(context
);
801 assertEquals("Event timestamp", 10, event
.getTimestamp().getValue());
802 assertEquals("Event rank", 9, context
.getRank());
804 event
= fTrace
.getNext(context
);
805 assertEquals("Event timestamp", 10, event
.getTimestamp().getValue());
806 assertEquals("Event rank", 10, context
.getRank());
808 // Position trace at event rank 999
809 context
= fTrace
.seekEvent(999);
810 assertEquals("Event rank", 999, context
.getRank());
812 event
= fTrace
.parseEvent(context
);
813 assertEquals("Event timestamp", 1000, event
.getTimestamp().getValue());
814 assertEquals("Event rank", 999, context
.getRank());
816 event
= fTrace
.getNext(context
);
817 assertEquals("Event timestamp", 1000, event
.getTimestamp().getValue());
818 assertEquals("Event rank", 1000, context
.getRank());
820 // Position trace at event rank 1001
821 context
= fTrace
.seekEvent(1001);
822 assertEquals("Event rank", 1001, context
.getRank());
824 event
= fTrace
.parseEvent(context
);
825 assertEquals("Event timestamp", 1002, event
.getTimestamp().getValue());
826 assertEquals("Event rank", 1001, context
.getRank());
828 event
= fTrace
.getNext(context
);
829 assertEquals("Event timestamp", 1002, event
.getTimestamp().getValue());
830 assertEquals("Event rank", 1002, context
.getRank());
832 // Position trace at event rank 4500
833 context
= fTrace
.seekEvent(4500);
834 assertEquals("Event rank", 4500, context
.getRank());
836 event
= fTrace
.parseEvent(context
);
837 assertEquals("Event timestamp", 4501, event
.getTimestamp().getValue());
838 assertEquals("Event rank", 4500, context
.getRank());
840 event
= fTrace
.getNext(context
);
841 assertEquals("Event timestamp", 4501, event
.getTimestamp().getValue());
842 assertEquals("Event rank", 4501, context
.getRank());
846 public void testSeekEventOnRankOutOfScope() {
847 // Position trace at beginning
848 ITmfContext context
= fTrace
.seekEvent(-1);
849 assertEquals("Event rank", 0, context
.getRank());
851 ITmfEvent event
= fTrace
.parseEvent(context
);
852 assertEquals("Event timestamp", 1, event
.getTimestamp().getValue());
853 assertEquals("Event rank", 0, context
.getRank());
855 event
= fTrace
.getNext(context
);
856 assertEquals("Event timestamp", 1, event
.getTimestamp().getValue());
857 assertEquals("Event rank", 1, context
.getRank());
859 // Position trace at event passed the end
860 context
= fTrace
.seekEvent(NB_EVENTS
);
861 assertEquals("Event rank", NB_EVENTS
, context
.getRank());
863 event
= fTrace
.parseEvent(context
);
864 assertNull("Event", event
);
865 assertEquals("Event rank", NB_EVENTS
, context
.getRank());
867 event
= fTrace
.getNext(context
);
868 assertNull("Event", event
);
869 assertEquals("Event rank", NB_EVENTS
, context
.getRank());
872 // ------------------------------------------------------------------------
873 // parseEvent - make sure parseEvent doesn't update the context
874 // ------------------------------------------------------------------------
877 public void testParseEvent() {
878 final int NB_READS
= 20;
880 // On lower bound, returns the first event (ts = 0)
881 final TmfContext context
= (TmfContext
) fTrace
.seekEvent(new TmfTimestamp(0, SCALE
, 0));
882 TmfContext svContext
= new TmfContext(context
);
884 ITmfEvent event
= fTrace
.parseEvent(context
);
885 assertEquals("Event timestamp", 1, event
.getTimestamp().getValue());
886 assertEquals("Event rank", 0, context
.getRank());
887 assertTrue("parseEvent", context
.equals(svContext
));
889 event
= fTrace
.parseEvent(context
);
890 assertEquals("Event timestamp", 1, event
.getTimestamp().getValue());
891 assertEquals("Event rank", 0, context
.getRank());
892 assertTrue("parseEvent", context
.equals(svContext
));
894 event
= fTrace
.parseEvent(context
);
895 assertEquals("Event timestamp", 1, event
.getTimestamp().getValue());
896 assertEquals("Event rank", 0, context
.getRank());
897 assertTrue("parseEvent", context
.equals(svContext
));
899 // Position the trace at event NB_READS
900 for (int i
= 1; i
< NB_READS
; i
++) {
901 event
= fTrace
.getNext(context
);
902 assertEquals("Event timestamp", i
, event
.getTimestamp().getValue());
905 svContext
= new TmfContext(context
);
906 event
= fTrace
.parseEvent(context
);
907 assertEquals("Event timestamp", NB_READS
, event
.getTimestamp().getValue());
908 assertEquals("Event rank", NB_READS
-1 , context
.getRank());
909 assertTrue("parseEvent", context
.equals(svContext
));
911 event
= fTrace
.parseEvent(context
);
912 assertEquals("Event timestamp", NB_READS
, event
.getTimestamp().getValue());
913 assertEquals("Event rank", NB_READS
- 1, context
.getRank());
914 assertTrue("parseEvent", context
.equals(svContext
));
917 // ------------------------------------------------------------------------
918 // getNext - updates the context
919 // ------------------------------------------------------------------------
922 public void testGetNextAfteSeekingOnTS_1() {
923 final long INITIAL_TS
= 1;
924 final int NB_READS
= 20;
926 // On lower bound, returns the first event (ts = 1)
927 final ITmfContext context
= fTrace
.seekEvent(new TmfTimestamp(INITIAL_TS
, SCALE
, 0));
931 for (int i
= 0; i
< NB_READS
; i
++) {
932 event
= fTrace
.getNext(context
);
933 assertEquals("Event timestamp", INITIAL_TS
+ i
, event
.getTimestamp().getValue());
934 assertEquals("Event rank", INITIAL_TS
+ i
, context
.getRank());
937 // Make sure we stay positioned
938 event
= fTrace
.parseEvent(context
);
939 assertEquals("Event timestamp", INITIAL_TS
+ NB_READS
, event
.getTimestamp().getValue());
940 assertEquals("Event rank", INITIAL_TS
+ NB_READS
- 1, context
.getRank());
944 public void testGetNextAfteSeekingOnTS_2() {
945 final long INITIAL_TS
= 2;
946 final int NB_READS
= 20;
948 // On lower bound, returns the first event (ts = 500)
949 final ITmfContext context
= fTrace
.seekEvent(new TmfTimestamp(INITIAL_TS
, SCALE
, 0));
953 for (int i
= 0; i
< NB_READS
; i
++) {
954 event
= fTrace
.getNext(context
);
955 assertEquals("Event timestamp", INITIAL_TS
+ i
, event
.getTimestamp().getValue());
956 assertEquals("Event rank", INITIAL_TS
+ i
, context
.getRank());
959 // Make sure we stay positioned
960 event
= fTrace
.parseEvent(context
);
961 assertEquals("Event timestamp", INITIAL_TS
+ NB_READS
, event
.getTimestamp().getValue());
962 assertEquals("Event rank", INITIAL_TS
+ NB_READS
- 1, context
.getRank());
966 public void testGetNextAfteSeekingOnTS_3() {
967 final long INITIAL_TS
= 500;
968 final int NB_READS
= 20;
970 // On lower bound, returns the first event (ts = 500)
971 final ITmfContext context
= fTrace
.seekEvent(new TmfTimestamp(INITIAL_TS
, SCALE
, 0));
975 for (int i
= 0; i
< NB_READS
; i
++) {
976 event
= fTrace
.getNext(context
);
977 assertEquals("Event timestamp", INITIAL_TS
+ i
, event
.getTimestamp().getValue());
978 assertEquals("Event rank", INITIAL_TS
+ i
, context
.getRank());
981 // Make sure we stay positioned
982 event
= fTrace
.parseEvent(context
);
983 assertEquals("Event timestamp", INITIAL_TS
+ NB_READS
, event
.getTimestamp().getValue());
984 assertEquals("Event rank", INITIAL_TS
+ NB_READS
- 1, context
.getRank());
988 public void testGetNextAfterSeekingOnRank_1() {
989 final long INITIAL_RANK
= 0L;
990 final int NB_READS
= 20;
992 // On lower bound, returns the first event (rank = 0)
993 final ITmfContext context
= fTrace
.seekEvent(INITIAL_RANK
);
997 for (int i
= 0; i
< NB_READS
; i
++) {
998 event
= fTrace
.getNext(context
);
999 assertEquals("Event timestamp", INITIAL_RANK
+ i
+ 1, event
.getTimestamp().getValue());
1000 assertEquals("Event rank", INITIAL_RANK
+ i
+ 1, context
.getRank());
1003 // Make sure we stay positioned
1004 event
= fTrace
.parseEvent(context
);
1005 assertEquals("Event timestamp", INITIAL_RANK
+ NB_READS
+ 1, event
.getTimestamp().getValue());
1006 assertEquals("Event rank", INITIAL_RANK
+ NB_READS
, context
.getRank());
1010 public void testGetNextAfterSeekingOnRank_2() {
1011 final long INITIAL_RANK
= 1L;
1012 final int NB_READS
= 20;
1014 // On lower bound, returns the first event (rank = 0)
1015 final ITmfContext context
= fTrace
.seekEvent(INITIAL_RANK
);
1019 for (int i
= 0; i
< NB_READS
; i
++) {
1020 event
= fTrace
.getNext(context
);
1021 assertEquals("Event timestamp", INITIAL_RANK
+ i
+ 1, event
.getTimestamp().getValue());
1022 assertEquals("Event rank", INITIAL_RANK
+ i
+ 1, context
.getRank());
1025 // Make sure we stay positioned
1026 event
= fTrace
.parseEvent(context
);
1027 assertEquals("Event timestamp", INITIAL_RANK
+ NB_READS
+ 1, event
.getTimestamp().getValue());
1028 assertEquals("Event rank", INITIAL_RANK
+ NB_READS
, context
.getRank());
1032 public void testGetNextAfterSeekingOnRank_3() {
1033 final long INITIAL_RANK
= 500L;
1034 final int NB_READS
= 20;
1036 // On lower bound, returns the first event (rank = 0)
1037 final ITmfContext context
= fTrace
.seekEvent(INITIAL_RANK
);
1041 for (int i
= 0; i
< NB_READS
; i
++) {
1042 event
= fTrace
.getNext(context
);
1043 assertEquals("Event timestamp", INITIAL_RANK
+ i
+ 1, event
.getTimestamp().getValue());
1044 assertEquals("Event rank", INITIAL_RANK
+ i
+ 1, context
.getRank());
1047 // Make sure we stay positioned
1048 event
= fTrace
.parseEvent(context
);
1049 assertEquals("Event timestamp", INITIAL_RANK
+ NB_READS
+ 1, event
.getTimestamp().getValue());
1050 assertEquals("Event rank", INITIAL_RANK
+ NB_READS
, context
.getRank());
1054 public void testGetNextAfterSeekingOnLocation_1() {
1055 final ITmfLocation INITIAL_LOC
= null;
1056 final long INITIAL_TS
= 1;
1057 final int NB_READS
= 20;
1059 // On lower bound, returns the first event (ts = 1)
1060 final ITmfContext context
= fTrace
.seekEvent(INITIAL_LOC
);
1064 for (int i
= 0; i
< NB_READS
; i
++) {
1065 event
= fTrace
.getNext(context
);
1066 assertEquals("Event timestamp", INITIAL_TS
+ i
, event
.getTimestamp().getValue());
1067 assertEquals("Event rank", INITIAL_TS
+ i
, context
.getRank());
1070 // Make sure we stay positioned
1071 event
= fTrace
.parseEvent(context
);
1072 assertEquals("Event timestamp", INITIAL_TS
+ NB_READS
, event
.getTimestamp().getValue());
1073 assertEquals("Event rank", INITIAL_TS
+ NB_READS
- 1, context
.getRank());
1077 public void testGetNextAfterSeekingOnLocation_2() {
1078 final ITmfLocation INITIAL_LOC
= fTrace
.seekEvent(1L).getLocation();
1079 final long INITIAL_TS
= 2;
1080 final int NB_READS
= 20;
1082 // On lower bound, returns the first event (ts = 501)
1083 final ITmfContext context
= fTrace
.seekEvent(INITIAL_LOC
);
1087 for (int i
= 0; i
< NB_READS
; i
++) {
1088 event
= fTrace
.getNext(context
);
1089 assertEquals("Event timestamp", INITIAL_TS
+ i
, event
.getTimestamp().getValue());
1092 // Make sure we stay positioned
1093 event
= fTrace
.parseEvent(context
);
1094 assertEquals("Event timestamp", INITIAL_TS
+ NB_READS
, event
.getTimestamp().getValue());
1098 public void testGetNextAfterSeekingOnLocation_3() {
1099 final ITmfLocation INITIAL_LOC
= fTrace
.seekEvent(500L).getLocation();
1100 final long INITIAL_TS
= 501;
1101 final int NB_READS
= 20;
1103 // On lower bound, returns the first event (ts = 501)
1104 final ITmfContext context
= fTrace
.seekEvent(INITIAL_LOC
);
1108 for (int i
= 0; i
< NB_READS
; i
++) {
1109 event
= fTrace
.getNext(context
);
1110 assertEquals("Event timestamp", INITIAL_TS
+ i
, event
.getTimestamp().getValue());
1113 // Make sure we stay positioned
1114 event
= fTrace
.parseEvent(context
);
1115 assertEquals("Event timestamp", INITIAL_TS
+ NB_READS
, event
.getTimestamp().getValue());
1119 public void testGetNextLocation() {
1120 ITmfContext context1
= fTrace
.seekEvent(0);
1121 fTrace
.getNext(context1
);
1122 ITmfLocation location
= context1
.getLocation();
1123 ITmfEvent event1
= fTrace
.getNext(context1
);
1124 ITmfContext context2
= fTrace
.seekEvent(location
);
1125 ITmfEvent event2
= fTrace
.getNext(context2
);
1126 assertEquals("Event timestamp", event1
.getTimestamp().getValue(), event2
.getTimestamp().getValue());
1130 public void testGetNextEndLocation() {
1131 ITmfContext context1
= fTrace
.seekEvent(fTrace
.getNbEvents() - 1);
1132 fTrace
.getNext(context1
);
1133 ITmfLocation location
= context1
.getLocation();
1134 ITmfContext context2
= fTrace
.seekEvent(location
);
1135 ITmfEvent event
= fTrace
.getNext(context2
);
1136 assertNull("Event", event
);
1139 // ------------------------------------------------------------------------
1141 // ------------------------------------------------------------------------
1144 public void testProcessEventRequestForAllEvents() throws InterruptedException
{
1145 final Vector
<ITmfEvent
> requestedEvents
= new Vector
<ITmfEvent
>();
1147 final TmfTimeRange range
= new TmfTimeRange(TmfTimestamp
.BIG_BANG
, TmfTimestamp
.BIG_CRUNCH
);
1148 final TmfEventRequest request
= new TmfEventRequest(ITmfEvent
.class,
1149 range
, 0, NB_EVENTS
, ExecutionType
.FOREGROUND
) {
1151 public void handleData(final ITmfEvent event
) {
1152 super.handleData(event
);
1153 requestedEvents
.add(event
);
1156 final ITmfDataProvider
[] providers
= TmfProviderManager
.getProviders(ITmfEvent
.class, TmfTraceStub
.class);
1157 providers
[0].sendRequest(request
);
1158 request
.waitForCompletion();
1160 assertEquals("nbEvents", NB_EVENTS
, requestedEvents
.size());
1161 assertTrue("isCompleted", request
.isCompleted());
1162 assertFalse("isCancelled", request
.isCancelled());
1164 // Ensure that we have distinct events.
1165 // Don't go overboard: we are not validating the stub!
1166 for (int i
= 0; i
< NB_EVENTS
; i
++) {
1167 assertEquals("Distinct events", i
+ 1, requestedEvents
.get(i
).getTimestamp().getValue());
1172 public void testProcessEventRequestForNbEvents() throws InterruptedException
{
1173 final int nbEvents
= 1000;
1174 final Vector
<ITmfEvent
> requestedEvents
= new Vector
<ITmfEvent
>();
1176 final TmfTimeRange range
= new TmfTimeRange(TmfTimestamp
.BIG_BANG
, TmfTimestamp
.BIG_CRUNCH
);
1177 final TmfEventRequest request
= new TmfEventRequest(ITmfEvent
.class,
1178 range
, 0, nbEvents
, ExecutionType
.FOREGROUND
) {
1180 public void handleData(final ITmfEvent event
) {
1181 super.handleData(event
);
1182 requestedEvents
.add(event
);
1185 final ITmfDataProvider
[] providers
= TmfProviderManager
.getProviders(ITmfEvent
.class, TmfTraceStub
.class);
1186 providers
[0].sendRequest(request
);
1187 request
.waitForCompletion();
1189 assertEquals("nbEvents", nbEvents
, requestedEvents
.size());
1190 assertTrue("isCompleted", request
.isCompleted());
1191 assertFalse("isCancelled", request
.isCancelled());
1193 // Ensure that we have distinct events.
1194 // Don't go overboard: we are not validating the stub!
1195 for (int i
= 0; i
< nbEvents
; i
++) {
1196 assertEquals("Distinct events", i
+ 1, requestedEvents
.get(i
).getTimestamp().getValue());
1201 public void testProcessEventRequestForSomeEvents() throws InterruptedException
{
1202 final long startTime
= 100;
1203 final int nbEvents
= 1000;
1204 final Vector
<ITmfEvent
> requestedEvents
= new Vector
<ITmfEvent
>();
1206 final TmfTimeRange range
= new TmfTimeRange(new TmfTimestamp(startTime
, SCALE
), TmfTimestamp
.BIG_CRUNCH
);
1207 final TmfEventRequest request
= new TmfEventRequest(ITmfEvent
.class,
1208 range
, 0, nbEvents
, ExecutionType
.FOREGROUND
) {
1210 public void handleData(final ITmfEvent event
) {
1211 super.handleData(event
);
1212 requestedEvents
.add(event
);
1215 final ITmfDataProvider
[] providers
= TmfProviderManager
.getProviders(ITmfEvent
.class, TmfTraceStub
.class);
1216 providers
[0].sendRequest(request
);
1217 request
.waitForCompletion();
1219 assertEquals("nbEvents", nbEvents
, requestedEvents
.size());
1220 assertTrue("isCompleted", request
.isCompleted());
1221 assertFalse("isCancelled", request
.isCancelled());
1223 // Ensure that we have distinct events.
1224 // Don't go overboard: we are not validating the stub!
1225 for (int i
= 0; i
< nbEvents
; i
++) {
1226 assertEquals("Distinct events", startTime
+ i
, requestedEvents
.get(i
).getTimestamp().getValue());
1231 public void testProcessEventRequestForOtherEvents() throws InterruptedException
{
1232 final int startIndex
= 99;
1233 final long startTime
= 100;
1234 final int nbEvents
= 1000;
1235 final Vector
<ITmfEvent
> requestedEvents
= new Vector
<ITmfEvent
>();
1237 final TmfTimeRange range
= new TmfTimeRange(new TmfTimestamp(startTime
, SCALE
), TmfTimestamp
.BIG_CRUNCH
);
1238 final TmfEventRequest request
= new TmfEventRequest(ITmfEvent
.class,
1239 range
, startIndex
, nbEvents
, ExecutionType
.FOREGROUND
) {
1241 public void handleData(final ITmfEvent event
) {
1242 super.handleData(event
);
1243 requestedEvents
.add(event
);
1246 final ITmfDataProvider
[] providers
= TmfProviderManager
.getProviders(ITmfEvent
.class, TmfTraceStub
.class);
1247 providers
[0].sendRequest(request
);
1248 request
.waitForCompletion();
1250 assertEquals("nbEvents", nbEvents
, requestedEvents
.size());
1251 assertTrue("isCompleted", request
.isCompleted());
1252 assertFalse("isCancelled", request
.isCancelled());
1254 // Ensure that we have distinct events.
1255 // Don't go overboard: we are not validating the stub!
1256 for (int i
= 0; i
< nbEvents
; i
++) {
1257 assertEquals("Distinct events", startTime
+ i
, requestedEvents
.get(i
).getTimestamp().getValue());
1262 public void testProcessDataRequestForSomeEvents() throws InterruptedException
{
1263 final int startIndex
= 100;
1264 final int nbEvents
= 1000;
1265 final Vector
<ITmfEvent
> requestedEvents
= new Vector
<ITmfEvent
>();
1267 final TmfDataRequest request
= new TmfDataRequest(ITmfEvent
.class,
1270 TmfDataRequest
.ExecutionType
.FOREGROUND
) {
1272 public void handleData(final ITmfEvent event
) {
1273 super.handleData(event
);
1274 requestedEvents
.add(event
);
1277 final ITmfDataProvider
[] providers
= TmfProviderManager
.getProviders(ITmfEvent
.class, TmfTraceStub
.class);
1278 providers
[0].sendRequest(request
);
1279 request
.waitForCompletion();
1281 assertEquals("nbEvents", nbEvents
, requestedEvents
.size());
1282 assertTrue("isCompleted", request
.isCompleted());
1283 assertFalse("isCancelled", request
.isCancelled());
1285 // Ensure that we have distinct events.
1286 // Don't go overboard: we are not validating the stub!
1287 for (int i
= 0; i
< nbEvents
; i
++) {
1288 assertEquals("Distinct events", startIndex
+ 1 + i
, requestedEvents
.get(i
).getTimestamp().getValue());
1292 // ------------------------------------------------------------------------
1294 // ------------------------------------------------------------------------
1297 public void testCancel() throws InterruptedException
{
1298 final int limit
= 500;
1299 final Vector
<ITmfEvent
> requestedEvents
= new Vector
<ITmfEvent
>();
1301 final TmfTimeRange range
= new TmfTimeRange(TmfTimestamp
.BIG_BANG
, TmfTimestamp
.BIG_CRUNCH
);
1302 final TmfEventRequest request
= new TmfEventRequest(ITmfEvent
.class,
1303 range
, 0, NB_EVENTS
, ExecutionType
.FOREGROUND
) {
1307 public void handleData(final ITmfEvent event
) {
1308 super.handleData(event
);
1309 requestedEvents
.add(event
);
1310 if (++nbRead
== limit
) {
1315 final ITmfDataProvider
[] providers
= TmfProviderManager
.getProviders(ITmfEvent
.class, TmfTraceStub
.class);
1316 providers
[0].sendRequest(request
);
1317 request
.waitForCompletion();
1319 assertEquals("nbEvents", limit
, requestedEvents
.size());
1320 assertTrue("isCompleted", request
.isCompleted());
1321 assertTrue("isCancelled", request
.isCancelled());
1324 // ------------------------------------------------------------------------
1326 // ------------------------------------------------------------------------
1329 public void testDefaultTmfTraceStub() {
1330 assertFalse ("Open trace", fTrace
== null);
1331 assertEquals("getType", ITmfEvent
.class, fTrace
.getType());
1332 assertNull ("getResource", fTrace
.getResource());
1333 assertEquals("getStreamingInterval", 0, fTrace
.getStreamingInterval());
1334 assertEquals("getName", TEST_STREAM
, fTrace
.getName());
1336 assertEquals("getNbEvents", NB_EVENTS
, fTrace
.getNbEvents());
1337 assertEquals("getRange-start", 1, fTrace
.getTimeRange().getStartTime().getValue());
1338 assertEquals("getRange-end", NB_EVENTS
, fTrace
.getTimeRange().getEndTime().getValue());
1339 assertEquals("getStartTime", 1, fTrace
.getStartTime().getValue());
1340 assertEquals("getEndTime", NB_EVENTS
, fTrace
.getEndTime().getValue());
1342 String expected
= "TmfTrace [fPath=" + fTrace
.getPath() + ", fCacheSize=" + fTrace
.getCacheSize() +
1343 ", fNbEvents=" + fTrace
.getNbEvents() + ", fStartTime=" + fTrace
.getStartTime() +
1344 ", fEndTime=" + fTrace
.getEndTime() + ", fStreamingInterval=" + fTrace
.getStreamingInterval() +
1346 assertEquals("toString", expected
, fTrace
.toString());
1349 // ------------------------------------------------------------------------
1350 // getInitialRangeOffset, getCurrentRange, getCurrentTime
1351 // ------------------------------------------------------------------------
1354 public void testCurrentTimeValues() throws TmfTraceException
{
1356 TmfTraceStub trace
= null;
1357 File testfile
= null;
1359 final URL location
= FileLocator
.find(TmfCoreTestPlugin
.getDefault().getBundle(), new Path(DIRECTORY
+ File
.separator
+ TEST_STREAM
), null);
1360 testfile
= new File(FileLocator
.toFileURL(location
).toURI());
1361 trace
= new TmfTraceStub(testfile
.toURI().getPath(), ITmfTrace
.DEFAULT_TRACE_CACHE_SIZE
, false, null, null);
1362 // verify initial values
1363 TmfTimestamp defaultInitRange
= new TmfTimestamp(DEFAULT_INITIAL_OFFSET_VALUE
, ITmfTimestamp
.NANOSECOND_SCALE
);
1364 assertEquals("getInitialRangeOffset", defaultInitRange
, trace
.getInitialRangeOffset());
1365 trace
.setInitialRangeOffset(new TmfTimestamp(5, ITmfTimestamp
.MILLISECOND_SCALE
));
1366 trace
.indexTrace(true);
1367 } catch (final URISyntaxException e
) {
1368 fail("URISyntaxException");
1369 } catch (final IOException e
) {
1370 fail("IOException");
1372 assertFalse ("Open trace", trace
== null);
1374 TmfTimestamp initRange
= new TmfTimestamp(5, ITmfTimestamp
.MILLISECOND_SCALE
);
1375 assertEquals("getInitialRangeOffset", initRange
, trace
.getInitialRangeOffset());
1379 * Run the String getHostId() method test
1382 public void testTraceHostId() {
1383 String a
= fTrace
.getHostId();
1384 assertEquals("A-Test-10K", a
);