1 /*******************************************************************************
2 * Copyright (c) 2009, 2010, 2012 Ericsson
4 * All rights reserved. This program and the accompanying materials are
5 * made available under the terms of the Eclipse Public License v1.0 which
6 * accompanies this distribution, and is available at
7 * http://www.eclipse.org/legal/epl-v10.html
10 * Francois Chouinard - Initial API and implementation
11 * Francois Chouinard - Adapted for TMF Trace Model 1.0
12 *******************************************************************************/
14 package org
.eclipse
.linuxtools
.tmf
.core
.tests
.trace
;
17 import java
.io
.IOException
;
18 import java
.net
.URISyntaxException
;
20 import java
.util
.Vector
;
22 import junit
.framework
.TestCase
;
24 import org
.eclipse
.core
.runtime
.FileLocator
;
25 import org
.eclipse
.core
.runtime
.Path
;
26 import org
.eclipse
.linuxtools
.internal
.tmf
.core
.component
.TmfProviderManager
;
27 import org
.eclipse
.linuxtools
.tmf
.core
.component
.ITmfDataProvider
;
28 import org
.eclipse
.linuxtools
.tmf
.core
.event
.ITmfEvent
;
29 import org
.eclipse
.linuxtools
.tmf
.core
.event
.ITmfTimestamp
;
30 import org
.eclipse
.linuxtools
.tmf
.core
.event
.TmfEvent
;
31 import org
.eclipse
.linuxtools
.tmf
.core
.event
.TmfTimeRange
;
32 import org
.eclipse
.linuxtools
.tmf
.core
.event
.TmfTimestamp
;
33 import org
.eclipse
.linuxtools
.tmf
.core
.exceptions
.TmfTraceException
;
34 import org
.eclipse
.linuxtools
.tmf
.core
.request
.TmfDataRequest
;
35 import org
.eclipse
.linuxtools
.tmf
.core
.request
.TmfEventRequest
;
36 import org
.eclipse
.linuxtools
.tmf
.core
.tests
.TmfCoreTestPlugin
;
37 import org
.eclipse
.linuxtools
.tmf
.core
.trace
.ITmfContext
;
38 import org
.eclipse
.linuxtools
.tmf
.core
.trace
.ITmfLocation
;
39 import org
.eclipse
.linuxtools
.tmf
.core
.trace
.ITmfTrace
;
40 import org
.eclipse
.linuxtools
.tmf
.core
.trace
.TmfCheckpointIndexer
;
41 import org
.eclipse
.linuxtools
.tmf
.core
.trace
.TmfContext
;
42 import org
.eclipse
.linuxtools
.tmf
.tests
.stubs
.trace
.TmfTraceStub
;
45 * Test suite for the TmfTrace class.
47 @SuppressWarnings({ "nls" })
48 public class TmfTraceTest
extends TestCase
{
50 // ------------------------------------------------------------------------
52 // ------------------------------------------------------------------------
54 private static final String DIRECTORY
= "testfiles";
55 private static final String TEST_STREAM
= "A-Test-10K";
56 private static final int BLOCK_SIZE
= 500;
57 private static final int NB_EVENTS
= 10000;
58 private static TmfTraceStub fTrace
= null;
60 private static int SCALE
= -3;
62 // ------------------------------------------------------------------------
64 // ------------------------------------------------------------------------
66 public TmfTraceTest(final String name
) throws Exception
{
71 protected void setUp() throws Exception
{
73 fTrace
= setupTrace(DIRECTORY
+ File
.separator
+ TEST_STREAM
);
77 protected void tearDown() throws Exception
{
83 // ------------------------------------------------------------------------
85 // ------------------------------------------------------------------------
87 private static TmfTraceStub
setupTrace(final String path
) {
90 final URL location
= FileLocator
.find(TmfCoreTestPlugin
.getDefault().getBundle(), new Path(path
), null);
91 final File test
= new File(FileLocator
.toFileURL(location
).toURI());
92 fTrace
= new TmfTraceStub(test
.toURI().getPath(), BLOCK_SIZE
);
94 } catch (final TmfTraceException e
) {
96 } catch (final URISyntaxException e
) {
98 } catch (final IOException e
) {
105 // ------------------------------------------------------------------------
107 // ------------------------------------------------------------------------
109 public void testStandardConstructor() throws Exception
{
110 TmfTraceStub trace
= null;
111 File testfile
= null;
113 final URL location
= FileLocator
.find(TmfCoreTestPlugin
.getDefault().getBundle(), new Path(DIRECTORY
+ File
.separator
+ TEST_STREAM
), null);
114 testfile
= new File(FileLocator
.toFileURL(location
).toURI());
115 trace
= new TmfTraceStub(testfile
.toURI().getPath());
117 } catch (final URISyntaxException e
) {
118 fail("URISyntaxException");
119 } catch (final IOException e
) {
123 assertFalse ("Open trace", trace
== null);
124 assertEquals("getType", TmfEvent
.class, trace
.getType());
125 assertNull ("getResource", trace
.getResource());
126 assertEquals("getPath", testfile
.toURI().getPath(), trace
.getPath());
127 assertEquals("getCacheSize", ITmfTrace
.DEFAULT_TRACE_CACHE_SIZE
, trace
.getCacheSize());
128 assertEquals("getStreamingInterval", 0, trace
.getStreamingInterval());
129 assertEquals("getName", TEST_STREAM
, trace
.getName());
131 assertEquals("getNbEvents", NB_EVENTS
, trace
.getNbEvents());
132 assertEquals("getRange-start", 1, trace
.getTimeRange().getStartTime().getValue());
133 assertEquals("getRange-end", NB_EVENTS
, trace
.getTimeRange().getEndTime().getValue());
134 assertEquals("getStartTime", 1, trace
.getStartTime().getValue());
135 assertEquals("getEndTime", NB_EVENTS
, trace
.getEndTime().getValue());
138 public void testStandardConstructorCacheSize() throws Exception
{
139 TmfTraceStub trace
= null;
140 File testfile
= null;
142 final URL location
= FileLocator
.find(TmfCoreTestPlugin
.getDefault().getBundle(), new Path(DIRECTORY
+ File
.separator
+ TEST_STREAM
), null);
143 testfile
= new File(FileLocator
.toFileURL(location
).toURI());
144 trace
= new TmfTraceStub(testfile
.toURI().getPath(), 0);
146 } catch (final URISyntaxException e
) {
147 fail("URISyntaxException");
148 } catch (final IOException e
) {
152 assertFalse ("Open trace", trace
== null);
153 assertEquals("getType", TmfEvent
.class, trace
.getType());
154 assertNull ("getResource", trace
.getResource());
155 assertEquals("getPath", testfile
.toURI().getPath(), trace
.getPath());
156 assertEquals("getCacheSize", ITmfTrace
.DEFAULT_TRACE_CACHE_SIZE
, trace
.getCacheSize());
157 assertEquals("getStreamingInterval", 0, trace
.getStreamingInterval());
158 assertEquals("getName", TEST_STREAM
, trace
.getName());
160 assertEquals("getNbEvents", NB_EVENTS
, trace
.getNbEvents());
161 assertEquals("getRange-start", 1, trace
.getTimeRange().getStartTime().getValue());
162 assertEquals("getRange-end", NB_EVENTS
, trace
.getTimeRange().getEndTime().getValue());
163 assertEquals("getStartTime", 1, trace
.getStartTime().getValue());
164 assertEquals("getEndTime", NB_EVENTS
, trace
.getEndTime().getValue());
167 final URL location
= FileLocator
.find(TmfCoreTestPlugin
.getDefault().getBundle(), new Path(DIRECTORY
+ File
.separator
+ TEST_STREAM
), null);
168 testfile
= new File(FileLocator
.toFileURL(location
).toURI());
169 trace
= new TmfTraceStub(testfile
.toURI().getPath(), BLOCK_SIZE
);
171 } catch (final URISyntaxException e
) {
172 fail("URISyntaxException");
173 } catch (final IOException e
) {
177 assertEquals("getType", TmfEvent
.class, trace
.getType());
178 assertNull ("getResource", trace
.getResource());
179 assertEquals("getPath", testfile
.toURI().getPath(), trace
.getPath());
180 assertEquals("getCacheSize", BLOCK_SIZE
, trace
.getCacheSize());
181 assertEquals("getStreamingInterval", 0, trace
.getStreamingInterval());
182 assertEquals("getName", TEST_STREAM
, trace
.getName());
184 assertEquals("getNbEvents", NB_EVENTS
, trace
.getNbEvents());
185 assertEquals("getRange-start", 1, trace
.getTimeRange().getStartTime().getValue());
186 assertEquals("getRange-end", NB_EVENTS
, trace
.getTimeRange().getEndTime().getValue());
187 assertEquals("getStartTime", 1, trace
.getStartTime().getValue());
188 assertEquals("getEndTime", NB_EVENTS
, trace
.getEndTime().getValue());
191 public void testFullConstructor() throws Exception
{
192 TmfTraceStub trace
= null;
193 File testfile
= null;
195 final URL location
= FileLocator
.find(TmfCoreTestPlugin
.getDefault().getBundle(), new Path(DIRECTORY
+ File
.separator
+ TEST_STREAM
), null);
196 testfile
= new File(FileLocator
.toFileURL(location
).toURI());
197 trace
= new TmfTraceStub(testfile
.toURI().getPath(), BLOCK_SIZE
, null);
199 } catch (final URISyntaxException e
) {
200 fail("URISyntaxException");
201 } catch (final IOException e
) {
205 assertFalse ("Open trace", trace
== null);
206 assertEquals("getType", TmfEvent
.class, trace
.getType());
207 assertNull ("getResource", trace
.getResource());
208 assertEquals("getPath", testfile
.toURI().getPath(), trace
.getPath());
209 assertEquals("getCacheSize", BLOCK_SIZE
, trace
.getCacheSize());
210 assertEquals("getStreamingInterval", 0, trace
.getStreamingInterval());
211 assertEquals("getName", TEST_STREAM
, trace
.getName());
213 assertEquals("getNbEvents", NB_EVENTS
, trace
.getNbEvents());
214 assertEquals("getRange-start", 1, trace
.getTimeRange().getStartTime().getValue());
215 assertEquals("getRange-end", NB_EVENTS
, trace
.getTimeRange().getEndTime().getValue());
216 assertEquals("getStartTime", 1, trace
.getStartTime().getValue());
217 assertEquals("getEndTime", NB_EVENTS
, trace
.getEndTime().getValue());
220 public void testLiveTraceConstructor() throws Exception
{
221 TmfTraceStub trace
= null;
222 File testfile
= null;
223 final long interval
= 100;
225 final URL location
= FileLocator
.find(TmfCoreTestPlugin
.getDefault().getBundle(), new Path(DIRECTORY
+ File
.separator
+ TEST_STREAM
), null);
226 testfile
= new File(FileLocator
.toFileURL(location
).toURI());
227 trace
= new TmfTraceStub(testfile
.toURI().getPath(), BLOCK_SIZE
, interval
);
229 } catch (final URISyntaxException e
) {
230 fail("URISyntaxException");
231 } catch (final IOException e
) {
235 assertFalse ("Open trace", trace
== null);
236 assertEquals("getType", TmfEvent
.class, trace
.getType());
237 assertNull ("getResource", trace
.getResource());
238 assertEquals("getPath", testfile
.toURI().getPath(), trace
.getPath());
239 assertEquals("getCacheSize", BLOCK_SIZE
, trace
.getCacheSize());
240 assertEquals("getStreamingInterval", interval
, trace
.getStreamingInterval());
241 assertEquals("getName", TEST_STREAM
, trace
.getName());
243 assertEquals("getNbEvents", NB_EVENTS
, trace
.getNbEvents());
244 assertEquals("getRange-start", 1, trace
.getTimeRange().getStartTime().getValue());
245 assertEquals("getRange-end", NB_EVENTS
, trace
.getTimeRange().getEndTime().getValue());
246 assertEquals("getStartTime", 1, trace
.getStartTime().getValue());
247 assertEquals("getEndTime", NB_EVENTS
, trace
.getEndTime().getValue());
250 @SuppressWarnings({ "unchecked", "rawtypes" })
251 public void testCopyConstructor() throws Exception
{
252 TmfTraceStub original
= null;
253 TmfTraceStub trace
= null;
254 File testfile
= null;
256 final URL location
= FileLocator
.find(TmfCoreTestPlugin
.getDefault().getBundle(), new Path(DIRECTORY
+ File
.separator
+ TEST_STREAM
), null);
257 testfile
= new File(FileLocator
.toFileURL(location
).toURI());
258 original
= new TmfTraceStub(testfile
.toURI().getPath(), BLOCK_SIZE
, new TmfCheckpointIndexer(null));
259 trace
= new TmfTraceStub(original
);
261 } catch (final URISyntaxException e
) {
262 fail("URISyntaxException");
263 } catch (final IOException e
) {
267 assertFalse ("Open trace", trace
== null);
268 assertEquals("getType", TmfEvent
.class, trace
.getType());
269 assertNull ("getResource", trace
.getResource());
270 assertEquals("getPath", testfile
.toURI().getPath(), trace
.getPath());
271 assertEquals("getCacheSize", BLOCK_SIZE
, trace
.getCacheSize());
272 assertEquals("getStreamingInterval", 0, trace
.getStreamingInterval());
273 assertEquals("getName", TEST_STREAM
, trace
.getName());
275 assertEquals("getNbEvents", NB_EVENTS
, trace
.getNbEvents());
276 assertEquals("getRange-start", 1, trace
.getTimeRange().getStartTime().getValue());
277 assertEquals("getRange-end", NB_EVENTS
, trace
.getTimeRange().getEndTime().getValue());
278 assertEquals("getStartTime", 1, trace
.getStartTime().getValue());
279 assertEquals("getEndTime", NB_EVENTS
, trace
.getEndTime().getValue());
281 // Test the copy of a null trace
283 new TmfTraceStub((TmfTraceStub
) null);
284 fail("Missing exception");
285 } catch (final IllegalArgumentException e
) {
287 } catch (final Exception e
) {
288 fail("Unexpected exception");
292 // ------------------------------------------------------------------------
293 // Trace initialization
294 // ------------------------------------------------------------------------
296 public void testInitializeNullPath() throws Exception
{
298 // Instantiate an "empty" trace
299 final TmfTraceStub trace
= new TmfTraceStub();
302 trace
.initialize(null, null, TmfEvent
.class);
303 fail("TmfTrace.initialize() - no exception thrown");
304 } catch (TmfTraceException e
) {
306 } catch (Exception e
) {
307 fail("TmfTrace.initialize() - wrong exception thrown");
311 public void testInitializeSimplePath() throws Exception
{
313 // Instantiate an "empty" trace
314 final TmfTraceStub trace
= new TmfTraceStub();
316 // Path == trace name
317 String path
= "TraceName";
319 trace
.initialize(null, path
, TmfEvent
.class);
320 } catch (Exception e
) {
321 fail("TmfTrace.initialize() - Exception thrown");
324 assertEquals("getType", TmfEvent
.class, trace
.getType());
325 assertNull ("getResource", trace
.getResource());
326 assertEquals("getPath", path
, trace
.getPath());
327 assertEquals("getCacheSize", ITmfTrace
.DEFAULT_TRACE_CACHE_SIZE
, trace
.getCacheSize());
328 assertEquals("getStreamingInterval", 0, trace
.getStreamingInterval());
329 assertEquals("getName", path
, trace
.getName());
331 assertEquals("getNbEvents", 0, trace
.getNbEvents());
332 assertEquals("getRange-start", Long
.MAX_VALUE
, trace
.getTimeRange().getStartTime().getValue());
333 assertEquals("getRange-end", Long
.MIN_VALUE
, trace
.getTimeRange().getEndTime().getValue());
334 assertEquals("getStartTime", Long
.MAX_VALUE
, trace
.getStartTime().getValue());
335 assertEquals("getEndTime", Long
.MIN_VALUE
, trace
.getEndTime().getValue());
338 public void testInitializeNormalPath() throws Exception
{
340 // Instantiate an "empty" trace
341 final TmfTraceStub trace
= new TmfTraceStub();
343 // Path == trace name
344 String name
= "TraceName";
345 String path
= "/my/trace/path/" + name
;
347 trace
.initialize(null, path
, TmfEvent
.class);
348 } catch (Exception e
) {
349 fail("TmfTrace.initialize() - Exception thrown");
352 assertEquals("getType", TmfEvent
.class, trace
.getType());
353 assertNull ("getResource", trace
.getResource());
354 assertEquals("getPath", path
, trace
.getPath());
355 assertEquals("getCacheSize", ITmfTrace
.DEFAULT_TRACE_CACHE_SIZE
, trace
.getCacheSize());
356 assertEquals("getStreamingInterval", 0, trace
.getStreamingInterval());
357 assertEquals("getName", name
, trace
.getName());
359 assertEquals("getNbEvents", 0, trace
.getNbEvents());
360 assertEquals("getRange-start", Long
.MAX_VALUE
, trace
.getTimeRange().getStartTime().getValue());
361 assertEquals("getRange-end", Long
.MIN_VALUE
, trace
.getTimeRange().getEndTime().getValue());
362 assertEquals("getStartTime", Long
.MAX_VALUE
, trace
.getStartTime().getValue());
363 assertEquals("getEndTime", Long
.MIN_VALUE
, trace
.getEndTime().getValue());
366 public void testInitTrace() throws Exception
{
368 // Instantiate an "empty" trace
369 final TmfTraceStub trace
= new TmfTraceStub();
371 assertNull ("getType", trace
.getType());
372 assertNull ("getResource", trace
.getResource());
373 assertEquals("getCacheSize", ITmfTrace
.DEFAULT_TRACE_CACHE_SIZE
, trace
.getCacheSize());
374 assertEquals("getStreamingInterval", 0, trace
.getStreamingInterval());
375 assertEquals("getName", "", trace
.getName());
377 assertEquals("getNbEvents", 0, trace
.getNbEvents());
378 assertEquals("getRange-start", Long
.MAX_VALUE
, trace
.getTimeRange().getStartTime().getValue());
379 assertEquals("getRange-end", Long
.MIN_VALUE
, trace
.getTimeRange().getEndTime().getValue());
380 assertEquals("getStartTime", Long
.MAX_VALUE
, trace
.getStartTime().getValue());
381 assertEquals("getEndTime", Long
.MIN_VALUE
, trace
.getEndTime().getValue());
384 final URL location
= FileLocator
.find(TmfCoreTestPlugin
.getDefault().getBundle(), new Path(DIRECTORY
+ File
.separator
+ TEST_STREAM
), null);
385 final File testfile
= new File(FileLocator
.toFileURL(location
).toURI());
386 assertTrue("validate", trace
.validate(null, testfile
.getPath()));
388 // InitTrace and wait for indexing completion...
389 trace
.initTrace(null, testfile
.toURI().getPath(), TmfEvent
.class);
392 while (trace
.getNbEvents() < NB_EVENTS
&& nbSecs
< 10) {
396 if (trace
.getNbEvents() < NB_EVENTS
) {
400 assertEquals("getType", TmfEvent
.class, trace
.getType());
401 assertNull ("getResource", trace
.getResource());
402 assertEquals("getCacheSize", ITmfTrace
.DEFAULT_TRACE_CACHE_SIZE
, trace
.getCacheSize());
403 assertEquals("getStreamingInterval", 0, trace
.getStreamingInterval());
404 assertEquals("getName", TEST_STREAM
, trace
.getName());
406 assertEquals("getNbEvents", NB_EVENTS
, trace
.getNbEvents());
407 assertEquals("getRange-start", 1, trace
.getTimeRange().getStartTime().getValue());
408 assertEquals("getRange-end", NB_EVENTS
, trace
.getTimeRange().getEndTime().getValue());
409 assertEquals("getStartTime", 1, trace
.getStartTime().getValue());
410 assertEquals("getEndTime", NB_EVENTS
, trace
.getEndTime().getValue());
413 // ------------------------------------------------------------------------
414 // Set/Get streaming interval
415 // ------------------------------------------------------------------------
417 public void testSetStreamingInterval() throws Exception
{
418 final TmfTraceStub trace
= new TmfTraceStub(fTrace
);
421 assertEquals("getStreamingInterval", interval
, trace
.getStreamingInterval());
424 trace
.setStreamingInterval(interval
);
425 assertEquals("getStreamingInterval", interval
, trace
.getStreamingInterval());
428 trace
.setStreamingInterval(interval
);
429 assertEquals("getStreamingInterval", 0, trace
.getStreamingInterval());
432 trace
.setStreamingInterval(interval
);
433 assertEquals("getStreamingInterval", interval
, trace
.getStreamingInterval());
438 // ------------------------------------------------------------------------
439 // Set/Get time range
440 // ------------------------------------------------------------------------
442 public void testSetTimeRange() throws Exception
{
443 final TmfTraceStub trace
= new TmfTraceStub(fTrace
);
446 assertEquals("getRange-start", 1, trace
.getTimeRange().getStartTime().getValue());
447 assertEquals("getRange-end", NB_EVENTS
, trace
.getTimeRange().getEndTime().getValue());
448 assertEquals("getStartTime", 1, trace
.getStartTime().getValue());
449 assertEquals("getEndTime", NB_EVENTS
, trace
.getEndTime().getValue());
451 trace
.setTimeRange(new TmfTimeRange(new TmfTimestamp(100), new TmfTimestamp(200)));
452 assertEquals("setTimeRange", 100, trace
.getTimeRange().getStartTime().getValue());
453 assertEquals("setTimeRange", 200, trace
.getTimeRange().getEndTime().getValue());
454 assertEquals("setTimeRange", 100, trace
.getStartTime().getValue());
455 assertEquals("setTimeRange", 200, trace
.getEndTime().getValue());
460 public void testSetStartTime() throws Exception
{
461 final TmfTraceStub trace
= new TmfTraceStub(fTrace
);
464 assertEquals("getRange-start", 1, trace
.getTimeRange().getStartTime().getValue());
465 assertEquals("getRange-end", NB_EVENTS
, trace
.getTimeRange().getEndTime().getValue());
466 assertEquals("getStartTime", 1, trace
.getStartTime().getValue());
467 assertEquals("getEndTime", NB_EVENTS
, trace
.getEndTime().getValue());
469 trace
.setStartTime(new TmfTimestamp(100));
470 assertEquals("setStartTime", 100, trace
.getTimeRange().getStartTime().getValue());
471 assertEquals("setStartTime", NB_EVENTS
, trace
.getTimeRange().getEndTime().getValue());
472 assertEquals("setStartTime", 100, trace
.getStartTime().getValue());
473 assertEquals("setStartTime", NB_EVENTS
, trace
.getEndTime().getValue());
478 public void testSetEndTime() throws Exception
{
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
.setEndTime(new TmfTimestamp(100));
488 assertEquals("setEndTime", 1, trace
.getTimeRange().getStartTime().getValue());
489 assertEquals("setEndTime", 100, trace
.getTimeRange().getEndTime().getValue());
490 assertEquals("setEndTime", 1, trace
.getStartTime().getValue());
491 assertEquals("setEndTime", 100, trace
.getEndTime().getValue());
496 public void testSetNbEvents() throws Exception
{
497 final TmfTraceStub trace
= new TmfTraceStub(fTrace
);
500 assertEquals("getNbEvents", NB_EVENTS
, trace
.getNbEvents());
502 trace
.setNbEvents(0);
503 assertEquals("getNbEvents", 0, trace
.getNbEvents());
505 trace
.setNbEvents(-1);
506 assertEquals("getNbEvents", 0, trace
.getNbEvents());
508 trace
.setNbEvents(NB_EVENTS
+ 1);
509 assertEquals("getNbEvents", NB_EVENTS
+ 1, trace
.getNbEvents());
511 trace
.setNbEvents(NB_EVENTS
);
512 assertEquals("getNbEvents", NB_EVENTS
, trace
.getNbEvents());
517 // ------------------------------------------------------------------------
518 // seekEvent on location (note: does not reliably set the rank)
519 // ------------------------------------------------------------------------
521 public void testSeekEventOnCacheBoundary() throws Exception
{
523 // Position trace at event rank 0
524 ITmfContext context
= fTrace
.seekEvent(0);
525 ITmfEvent event
= fTrace
.parseEvent(context
);
526 assertEquals("Event timestamp", 1, event
.getTimestamp().getValue());
527 assertEquals("Event rank", 0, context
.getRank());
529 context
= fTrace
.seekEvent(context
.getLocation());
530 assertEquals("Event rank", ITmfContext
.UNKNOWN_RANK
, context
.getRank());
532 event
= fTrace
.parseEvent(context
);
533 assertEquals("Event timestamp", 1, event
.getTimestamp().getValue());
534 assertEquals("Event rank", ITmfContext
.UNKNOWN_RANK
, context
.getRank());
536 event
= fTrace
.getNext(context
);
537 assertEquals("Event timestamp", 1, event
.getTimestamp().getValue());
538 assertEquals("Event rank", ITmfContext
.UNKNOWN_RANK
, context
.getRank());
540 // Position trace at event rank 1000
541 ITmfContext tmpContext
= fTrace
.seekEvent(new TmfTimestamp(1001, SCALE
, 0));
542 context
= fTrace
.seekEvent(tmpContext
.getLocation());
543 assertEquals("Event rank", ITmfContext
.UNKNOWN_RANK
, context
.getRank());
545 event
= fTrace
.parseEvent(context
);
546 assertEquals("Event timestamp", 1001, event
.getTimestamp().getValue());
547 assertEquals("Event rank", ITmfContext
.UNKNOWN_RANK
, context
.getRank());
549 event
= fTrace
.getNext(context
);
550 assertEquals("Event timestamp", 1001, event
.getTimestamp().getValue());
551 assertEquals("Event rank", ITmfContext
.UNKNOWN_RANK
, context
.getRank());
553 // Position trace at event rank 4000
554 tmpContext
= fTrace
.seekEvent(new TmfTimestamp(4001, SCALE
, 0));
555 context
= fTrace
.seekEvent(tmpContext
.getLocation());
556 assertEquals("Event rank", ITmfContext
.UNKNOWN_RANK
, context
.getRank());
558 event
= fTrace
.parseEvent(context
);
559 assertEquals("Event timestamp", 4001, event
.getTimestamp().getValue());
560 assertEquals("Event rank", ITmfContext
.UNKNOWN_RANK
, context
.getRank());
562 event
= fTrace
.getNext(context
);
563 assertEquals("Event timestamp", 4001, event
.getTimestamp().getValue());
564 assertEquals("Event rank", ITmfContext
.UNKNOWN_RANK
, context
.getRank());
567 public void testSeekEventNotOnCacheBoundary() throws Exception
{
569 // Position trace at event rank 9
570 ITmfContext tmpContext
= fTrace
.seekEvent(new TmfTimestamp(10, SCALE
, 0));
571 TmfContext context
= fTrace
.seekEvent(tmpContext
.getLocation());
572 assertEquals("Event rank", ITmfContext
.UNKNOWN_RANK
, context
.getRank());
574 ITmfEvent event
= fTrace
.parseEvent(context
);
575 assertEquals("Event timestamp", 10, event
.getTimestamp().getValue());
576 assertEquals("Event rank", ITmfContext
.UNKNOWN_RANK
, context
.getRank());
578 event
= fTrace
.getNext(context
);
579 assertEquals("Event timestamp", 10, event
.getTimestamp().getValue());
580 assertEquals("Event rank", ITmfContext
.UNKNOWN_RANK
, context
.getRank());
582 // Position trace at event rank 999
583 tmpContext
= fTrace
.seekEvent(new TmfTimestamp(1000, SCALE
, 0));
584 context
= fTrace
.seekEvent(tmpContext
.getLocation());
585 assertEquals("Event rank", ITmfContext
.UNKNOWN_RANK
, context
.getRank());
587 event
= fTrace
.parseEvent(context
);
588 assertEquals("Event timestamp", 1000, event
.getTimestamp().getValue());
589 assertEquals("Event rank", ITmfContext
.UNKNOWN_RANK
, context
.getRank());
591 event
= fTrace
.getNext(context
);
592 assertEquals("Event timestamp", 1000, event
.getTimestamp().getValue());
593 assertEquals("Event rank", ITmfContext
.UNKNOWN_RANK
, context
.getRank());
595 // Position trace at event rank 1001
596 tmpContext
= fTrace
.seekEvent(new TmfTimestamp(1002, SCALE
, 0));
597 context
= fTrace
.seekEvent(tmpContext
.getLocation());
598 assertEquals("Event rank", ITmfContext
.UNKNOWN_RANK
, context
.getRank());
600 event
= fTrace
.parseEvent(context
);
601 assertEquals("Event timestamp", 1002, event
.getTimestamp().getValue());
602 assertEquals("Event rank", ITmfContext
.UNKNOWN_RANK
, context
.getRank());
604 event
= fTrace
.getNext(context
);
605 assertEquals("Event timestamp", 1002, event
.getTimestamp().getValue());
606 assertEquals("Event rank", ITmfContext
.UNKNOWN_RANK
, context
.getRank());
608 // Position trace at event rank 4500
609 tmpContext
= fTrace
.seekEvent(new TmfTimestamp(4501, SCALE
, 0));
610 context
= fTrace
.seekEvent(tmpContext
.getLocation());
611 assertEquals("Event rank", ITmfContext
.UNKNOWN_RANK
, context
.getRank());
613 event
= fTrace
.parseEvent(context
);
614 assertEquals("Event timestamp", 4501, event
.getTimestamp().getValue());
615 assertEquals("Event rank", ITmfContext
.UNKNOWN_RANK
, context
.getRank());
617 event
= fTrace
.getNext(context
);
618 assertEquals("Event timestamp", 4501, event
.getTimestamp().getValue());
619 assertEquals("Event rank", ITmfContext
.UNKNOWN_RANK
, context
.getRank());
622 public void testSeekEventOutOfScope() throws Exception
{
624 // Position trace at beginning
625 ITmfContext tmpContext
= fTrace
.seekEvent(0);
626 ITmfContext context
= fTrace
.seekEvent(tmpContext
.getLocation());
627 assertEquals("Event rank", ITmfContext
.UNKNOWN_RANK
, context
.getRank());
629 ITmfEvent event
= fTrace
.parseEvent(context
);
630 assertEquals("Event timestamp", 1, event
.getTimestamp().getValue());
631 assertEquals("Event rank", ITmfContext
.UNKNOWN_RANK
, context
.getRank());
633 event
= fTrace
.getNext(context
);
634 assertEquals("Event timestamp", 1, event
.getTimestamp().getValue());
635 assertEquals("Event rank", ITmfContext
.UNKNOWN_RANK
, context
.getRank());
637 // Position trace at event passed the end
638 context
= fTrace
.seekEvent(new TmfTimestamp(NB_EVENTS
+ 1, SCALE
, 0));
639 assertNull("Event timestamp", context
.getLocation());
640 assertEquals("Event rank", ITmfContext
.UNKNOWN_RANK
, context
.getRank());
642 event
= fTrace
.getNext(context
);
643 assertNull("Event", event
);
646 // ------------------------------------------------------------------------
647 // seekEvent on timestamp (note: does not reliably set the rank)
648 // ------------------------------------------------------------------------
650 public void testSeekEventOnNullTimestamp() throws Exception
{
652 // Position trace at event rank 0
653 ITmfContext context
= fTrace
.seekEvent((ITmfTimestamp
) null);
654 assertEquals("Event rank", 0, context
.getRank());
656 ITmfEvent event
= fTrace
.parseEvent(context
);
657 assertEquals("Event timestamp", 1, event
.getTimestamp().getValue());
658 assertEquals("Event rank", 0, context
.getRank());
661 public void testSeekEventOnTimestampOnCacheBoundary() throws Exception
{
663 // Position trace at event rank 0
664 ITmfContext context
= fTrace
.seekEvent(new TmfTimestamp(1, SCALE
, 0));
665 assertEquals("Event rank", 0, context
.getRank());
667 ITmfEvent event
= fTrace
.parseEvent(context
);
668 assertEquals("Event timestamp", 1, event
.getTimestamp().getValue());
669 assertEquals("Event rank", 0, context
.getRank());
671 event
= fTrace
.getNext(context
);
672 assertEquals("Event timestamp", 1, event
.getTimestamp().getValue());
673 assertEquals("Event rank", 1, context
.getRank());
675 // Position trace at event rank 1000
676 context
= fTrace
.seekEvent(new TmfTimestamp(1001, SCALE
, 0));
677 assertEquals("Event rank", 1000, context
.getRank());
679 event
= fTrace
.parseEvent(context
);
680 assertEquals("Event timestamp", 1001, event
.getTimestamp().getValue());
681 assertEquals("Event rank", 1000, context
.getRank());
683 event
= fTrace
.getNext(context
);
684 assertEquals("Event timestamp", 1001, event
.getTimestamp().getValue());
685 assertEquals("Event rank", 1001, context
.getRank());
687 // Position trace at event rank 4000
688 context
= fTrace
.seekEvent(new TmfTimestamp(4001, SCALE
, 0));
689 assertEquals("Event rank", 4000, context
.getRank());
691 event
= fTrace
.parseEvent(context
);
692 assertEquals("Event timestamp", 4001, event
.getTimestamp().getValue());
693 assertEquals("Event rank", 4000, context
.getRank());
695 event
= fTrace
.getNext(context
);
696 assertEquals("Event timestamp", 4001, event
.getTimestamp().getValue());
697 assertEquals("Event rank", 4001, context
.getRank());
700 public void testSeekEventOnTimestampNotOnCacheBoundary() throws Exception
{
702 // Position trace at event rank 1
703 ITmfContext context
= fTrace
.seekEvent(new TmfTimestamp(2, SCALE
, 0));
704 assertEquals("Event rank", 1, context
.getRank());
706 ITmfEvent event
= fTrace
.parseEvent(context
);
707 assertEquals("Event timestamp", 2, event
.getTimestamp().getValue());
708 assertEquals("Event rank", 1, context
.getRank());
710 event
= fTrace
.getNext(context
);
711 assertEquals("Event timestamp", 2, event
.getTimestamp().getValue());
712 assertEquals("Event rank", 2, context
.getRank());
714 // Position trace at event rank 9
715 context
= fTrace
.seekEvent(new TmfTimestamp(10, SCALE
, 0));
716 assertEquals("Event rank", 9, context
.getRank());
718 event
= fTrace
.parseEvent(context
);
719 assertEquals("Event timestamp", 10, event
.getTimestamp().getValue());
720 assertEquals("Event rank", 9, context
.getRank());
722 event
= fTrace
.getNext(context
);
723 assertEquals("Event timestamp", 10, event
.getTimestamp().getValue());
724 assertEquals("Event rank", 10, context
.getRank());
726 // Position trace at event rank 999
727 context
= fTrace
.seekEvent(new TmfTimestamp(1000, SCALE
, 0));
728 assertEquals("Event rank", 999, context
.getRank());
730 event
= fTrace
.parseEvent(context
);
731 assertEquals("Event timestamp", 1000, event
.getTimestamp().getValue());
732 assertEquals("Event rank", 999, context
.getRank());
734 event
= fTrace
.getNext(context
);
735 assertEquals("Event timestamp", 1000, event
.getTimestamp().getValue());
736 assertEquals("Event rank", 1000, context
.getRank());
738 // Position trace at event rank 1001
739 context
= fTrace
.seekEvent(new TmfTimestamp(1002, SCALE
, 0));
740 assertEquals("Event rank", 1001, context
.getRank());
742 event
= fTrace
.parseEvent(context
);
743 assertEquals("Event timestamp", 1002, event
.getTimestamp().getValue());
744 assertEquals("Event rank", 1001, context
.getRank());
746 event
= fTrace
.getNext(context
);
747 assertEquals("Event timestamp", 1002, event
.getTimestamp().getValue());
748 assertEquals("Event rank", 1002, context
.getRank());
750 // Position trace at event rank 4500
751 context
= fTrace
.seekEvent(new TmfTimestamp(4501, SCALE
, 0));
752 assertEquals("Event rank", 4500, context
.getRank());
754 event
= fTrace
.parseEvent(context
);
755 assertEquals("Event timestamp", 4501, event
.getTimestamp().getValue());
756 assertEquals("Event rank", 4500, context
.getRank());
758 event
= fTrace
.getNext(context
);
759 assertEquals("Event timestamp", 4501, event
.getTimestamp().getValue());
760 assertEquals("Event rank", 4501, context
.getRank());
763 public void testSeekEventOnTimestampOutOfScope() throws Exception
{
765 // Position trace at beginning
766 ITmfContext context
= fTrace
.seekEvent(new TmfTimestamp(-1, SCALE
, 0));
767 assertEquals("Event rank", 0, context
.getRank());
769 ITmfEvent event
= fTrace
.parseEvent(context
);
770 assertEquals("Event timestamp", 1, event
.getTimestamp().getValue());
771 assertEquals("Event rank", 0, context
.getRank());
773 event
= fTrace
.getNext(context
);
774 assertEquals("Event timestamp", 1, event
.getTimestamp().getValue());
775 assertEquals("Event rank", 1, context
.getRank());
777 // Position trace at event passed the end
778 context
= fTrace
.seekEvent(new TmfTimestamp(NB_EVENTS
+ 1, SCALE
, 0));
779 assertEquals("Event rank", ITmfContext
.UNKNOWN_RANK
, context
.getRank());
781 event
= fTrace
.parseEvent(context
);
782 assertEquals("Event timestamp", null, event
);
783 assertEquals("Event rank", ITmfContext
.UNKNOWN_RANK
, context
.getRank());
785 event
= fTrace
.getNext(context
);
786 assertEquals("Event timestamp", null, event
);
787 assertEquals("Event rank", ITmfContext
.UNKNOWN_RANK
, context
.getRank());
790 // ------------------------------------------------------------------------
792 // ------------------------------------------------------------------------
794 public void testSeekEventOnNegativeRank() throws Exception
{
796 // Position trace at event rank 0
797 ITmfContext context
= fTrace
.seekEvent(-1);
798 assertEquals("Event rank", 0, context
.getRank());
800 ITmfEvent event
= fTrace
.parseEvent(context
);
801 assertEquals("Event timestamp", 1, event
.getTimestamp().getValue());
802 assertEquals("Event rank", 0, context
.getRank());
805 public void testSeekOnRankOnCacheBoundary() throws Exception
{
807 // On lower bound, returns the first event (ts = 1)
808 ITmfContext context
= fTrace
.seekEvent(0);
809 assertEquals("Event rank", 0, context
.getRank());
811 ITmfEvent event
= fTrace
.parseEvent(context
);
812 assertEquals("Event timestamp", 1, event
.getTimestamp().getValue());
813 assertEquals("Event rank", 0, context
.getRank());
815 event
= fTrace
.getNext(context
);
816 assertEquals("Event timestamp", 1, event
.getTimestamp().getValue());
817 assertEquals("Event rank", 1, context
.getRank());
819 // Position trace at event rank 1000
820 context
= fTrace
.seekEvent(1000);
821 assertEquals("Event rank", 1000, context
.getRank());
823 event
= fTrace
.parseEvent(context
);
824 assertEquals("Event timestamp", 1001, event
.getTimestamp().getValue());
825 assertEquals("Event rank", 1000, context
.getRank());
827 event
= fTrace
.getNext(context
);
828 assertEquals("Event timestamp", 1001, event
.getTimestamp().getValue());
829 assertEquals("Event rank", 1001, context
.getRank());
831 // Position trace at event rank 4000
832 context
= fTrace
.seekEvent(4000);
833 assertEquals("Event rank", 4000, context
.getRank());
835 event
= fTrace
.parseEvent(context
);
836 assertEquals("Event timestamp", 4001, event
.getTimestamp().getValue());
837 assertEquals("Event rank", 4000, context
.getRank());
839 event
= fTrace
.getNext(context
);
840 assertEquals("Event timestamp", 4001, event
.getTimestamp().getValue());
841 assertEquals("Event rank", 4001, context
.getRank());
844 public void testSeekOnRankNotOnCacheBoundary() throws Exception
{
846 // Position trace at event rank 9
847 ITmfContext context
= fTrace
.seekEvent(9);
848 assertEquals("Event rank", 9, context
.getRank());
850 ITmfEvent event
= fTrace
.parseEvent(context
);
851 assertEquals("Event timestamp", 10, event
.getTimestamp().getValue());
852 assertEquals("Event rank", 9, context
.getRank());
854 event
= fTrace
.getNext(context
);
855 assertEquals("Event timestamp", 10, event
.getTimestamp().getValue());
856 assertEquals("Event rank", 10, context
.getRank());
858 // Position trace at event rank 999
859 context
= fTrace
.seekEvent(999);
860 assertEquals("Event rank", 999, context
.getRank());
862 event
= fTrace
.parseEvent(context
);
863 assertEquals("Event timestamp", 1000, event
.getTimestamp().getValue());
864 assertEquals("Event rank", 999, context
.getRank());
866 event
= fTrace
.getNext(context
);
867 assertEquals("Event timestamp", 1000, event
.getTimestamp().getValue());
868 assertEquals("Event rank", 1000, context
.getRank());
870 // Position trace at event rank 1001
871 context
= fTrace
.seekEvent(1001);
872 assertEquals("Event rank", 1001, context
.getRank());
874 event
= fTrace
.parseEvent(context
);
875 assertEquals("Event timestamp", 1002, event
.getTimestamp().getValue());
876 assertEquals("Event rank", 1001, context
.getRank());
878 event
= fTrace
.getNext(context
);
879 assertEquals("Event timestamp", 1002, event
.getTimestamp().getValue());
880 assertEquals("Event rank", 1002, context
.getRank());
882 // Position trace at event rank 4500
883 context
= fTrace
.seekEvent(4500);
884 assertEquals("Event rank", 4500, context
.getRank());
886 event
= fTrace
.parseEvent(context
);
887 assertEquals("Event timestamp", 4501, event
.getTimestamp().getValue());
888 assertEquals("Event rank", 4500, context
.getRank());
890 event
= fTrace
.getNext(context
);
891 assertEquals("Event timestamp", 4501, event
.getTimestamp().getValue());
892 assertEquals("Event rank", 4501, context
.getRank());
895 public void testSeekEventOnRankOutOfScope() throws Exception
{
897 // Position trace at beginning
898 ITmfContext context
= fTrace
.seekEvent(-1);
899 assertEquals("Event rank", 0, context
.getRank());
901 ITmfEvent event
= fTrace
.parseEvent(context
);
902 assertEquals("Event timestamp", 1, event
.getTimestamp().getValue());
903 assertEquals("Event rank", 0, context
.getRank());
905 event
= fTrace
.getNext(context
);
906 assertEquals("Event timestamp", 1, event
.getTimestamp().getValue());
907 assertEquals("Event rank", 1, context
.getRank());
909 // Position trace at event passed the end
910 context
= fTrace
.seekEvent(NB_EVENTS
);
911 assertEquals("Event rank", NB_EVENTS
, context
.getRank());
913 event
= fTrace
.parseEvent(context
);
914 assertNull("Event", event
);
915 assertEquals("Event rank", NB_EVENTS
, context
.getRank());
917 event
= fTrace
.getNext(context
);
918 assertNull("Event", event
);
919 assertEquals("Event rank", NB_EVENTS
, context
.getRank());
922 // ------------------------------------------------------------------------
923 // parseEvent - make sure parseEvent doesn't update the context
924 // ------------------------------------------------------------------------
926 public void testParseEvent() throws Exception
{
928 final int NB_READS
= 20;
930 // On lower bound, returns the first event (ts = 0)
931 final TmfContext context
= (TmfContext
) fTrace
.seekEvent(new TmfTimestamp(0, SCALE
, 0));
932 TmfContext svContext
= new TmfContext(context
);
934 ITmfEvent event
= fTrace
.parseEvent(context
);
935 assertEquals("Event timestamp", 1, event
.getTimestamp().getValue());
936 assertEquals("Event rank", 0, context
.getRank());
937 assertTrue("parseEvent", context
.equals(svContext
));
939 event
= fTrace
.parseEvent(context
);
940 assertEquals("Event timestamp", 1, event
.getTimestamp().getValue());
941 assertEquals("Event rank", 0, context
.getRank());
942 assertTrue("parseEvent", context
.equals(svContext
));
944 event
= fTrace
.parseEvent(context
);
945 assertEquals("Event timestamp", 1, event
.getTimestamp().getValue());
946 assertEquals("Event rank", 0, context
.getRank());
947 assertTrue("parseEvent", context
.equals(svContext
));
949 // Position the trace at event NB_READS
950 for (int i
= 1; i
< NB_READS
; i
++) {
951 event
= fTrace
.getNext(context
);
952 assertEquals("Event timestamp", i
, event
.getTimestamp().getValue());
955 svContext
= new TmfContext(context
);
956 event
= fTrace
.parseEvent(context
);
957 assertEquals("Event timestamp", NB_READS
, event
.getTimestamp().getValue());
958 assertEquals("Event rank", NB_READS
-1 , context
.getRank());
959 assertTrue("parseEvent", context
.equals(svContext
));
961 event
= fTrace
.parseEvent(context
);
962 assertEquals("Event timestamp", NB_READS
, event
.getTimestamp().getValue());
963 assertEquals("Event rank", NB_READS
- 1, context
.getRank());
964 assertTrue("parseEvent", context
.equals(svContext
));
967 // ------------------------------------------------------------------------
968 // getNext - updates the context
969 // ------------------------------------------------------------------------
971 public void testGetNextAfteSeekingOnTS_1() throws Exception
{
973 final long INITIAL_TS
= 1;
974 final int NB_READS
= 20;
976 // On lower bound, returns the first event (ts = 1)
977 final ITmfContext context
= fTrace
.seekEvent(new TmfTimestamp(INITIAL_TS
, SCALE
, 0));
981 for (int i
= 0; i
< NB_READS
; i
++) {
982 event
= fTrace
.getNext(context
);
983 assertEquals("Event timestamp", INITIAL_TS
+ i
, event
.getTimestamp().getValue());
984 assertEquals("Event rank", INITIAL_TS
+ i
, context
.getRank());
987 // Make sure we stay positioned
988 event
= fTrace
.parseEvent(context
);
989 assertEquals("Event timestamp", INITIAL_TS
+ NB_READS
, event
.getTimestamp().getValue());
990 assertEquals("Event rank", INITIAL_TS
+ NB_READS
- 1, context
.getRank());
993 public void testGetNextAfteSeekingOnTS_2() throws Exception
{
995 final long INITIAL_TS
= 2;
996 final int NB_READS
= 20;
998 // On lower bound, returns the first event (ts = 500)
999 final ITmfContext context
= fTrace
.seekEvent(new TmfTimestamp(INITIAL_TS
, SCALE
, 0));
1003 for (int i
= 0; i
< NB_READS
; i
++) {
1004 event
= fTrace
.getNext(context
);
1005 assertEquals("Event timestamp", INITIAL_TS
+ i
, event
.getTimestamp().getValue());
1006 assertEquals("Event rank", INITIAL_TS
+ i
, context
.getRank());
1009 // Make sure we stay positioned
1010 event
= fTrace
.parseEvent(context
);
1011 assertEquals("Event timestamp", INITIAL_TS
+ NB_READS
, event
.getTimestamp().getValue());
1012 assertEquals("Event rank", INITIAL_TS
+ NB_READS
- 1, context
.getRank());
1015 public void testGetNextAfteSeekingOnTS_3() throws Exception
{
1017 final long INITIAL_TS
= 500;
1018 final int NB_READS
= 20;
1020 // On lower bound, returns the first event (ts = 500)
1021 final ITmfContext context
= fTrace
.seekEvent(new TmfTimestamp(INITIAL_TS
, SCALE
, 0));
1025 for (int i
= 0; i
< NB_READS
; i
++) {
1026 event
= fTrace
.getNext(context
);
1027 assertEquals("Event timestamp", INITIAL_TS
+ i
, event
.getTimestamp().getValue());
1028 assertEquals("Event rank", INITIAL_TS
+ i
, context
.getRank());
1031 // Make sure we stay positioned
1032 event
= fTrace
.parseEvent(context
);
1033 assertEquals("Event timestamp", INITIAL_TS
+ NB_READS
, event
.getTimestamp().getValue());
1034 assertEquals("Event rank", INITIAL_TS
+ NB_READS
- 1, context
.getRank());
1037 public void testGetNextAfterSeekingOnRank_1() throws Exception
{
1039 final long INITIAL_RANK
= 0L;
1040 final int NB_READS
= 20;
1042 // On lower bound, returns the first event (rank = 0)
1043 final ITmfContext context
= fTrace
.seekEvent(INITIAL_RANK
);
1047 for (int i
= 0; i
< NB_READS
; i
++) {
1048 event
= fTrace
.getNext(context
);
1049 assertEquals("Event timestamp", INITIAL_RANK
+ i
+ 1, event
.getTimestamp().getValue());
1050 assertEquals("Event rank", INITIAL_RANK
+ i
+ 1, context
.getRank());
1053 // Make sure we stay positioned
1054 event
= fTrace
.parseEvent(context
);
1055 assertEquals("Event timestamp", INITIAL_RANK
+ NB_READS
+ 1, event
.getTimestamp().getValue());
1056 assertEquals("Event rank", INITIAL_RANK
+ NB_READS
, context
.getRank());
1059 public void testGetNextAfterSeekingOnRank_2() throws Exception
{
1061 final long INITIAL_RANK
= 1L;
1062 final int NB_READS
= 20;
1064 // On lower bound, returns the first event (rank = 0)
1065 final ITmfContext context
= fTrace
.seekEvent(INITIAL_RANK
);
1069 for (int i
= 0; i
< NB_READS
; i
++) {
1070 event
= fTrace
.getNext(context
);
1071 assertEquals("Event timestamp", INITIAL_RANK
+ i
+ 1, event
.getTimestamp().getValue());
1072 assertEquals("Event rank", INITIAL_RANK
+ i
+ 1, context
.getRank());
1075 // Make sure we stay positioned
1076 event
= fTrace
.parseEvent(context
);
1077 assertEquals("Event timestamp", INITIAL_RANK
+ NB_READS
+ 1, event
.getTimestamp().getValue());
1078 assertEquals("Event rank", INITIAL_RANK
+ NB_READS
, context
.getRank());
1081 public void testGetNextAfterSeekingOnRank_3() throws Exception
{
1083 final long INITIAL_RANK
= 500L;
1084 final int NB_READS
= 20;
1086 // On lower bound, returns the first event (rank = 0)
1087 final ITmfContext context
= fTrace
.seekEvent(INITIAL_RANK
);
1091 for (int i
= 0; i
< NB_READS
; i
++) {
1092 event
= fTrace
.getNext(context
);
1093 assertEquals("Event timestamp", INITIAL_RANK
+ i
+ 1, event
.getTimestamp().getValue());
1094 assertEquals("Event rank", INITIAL_RANK
+ i
+ 1, context
.getRank());
1097 // Make sure we stay positioned
1098 event
= fTrace
.parseEvent(context
);
1099 assertEquals("Event timestamp", INITIAL_RANK
+ NB_READS
+ 1, event
.getTimestamp().getValue());
1100 assertEquals("Event rank", INITIAL_RANK
+ NB_READS
, context
.getRank());
1103 public void testGetNextAfterSeekingOnLocation_1() throws Exception
{
1105 final ITmfLocation
<?
> INITIAL_LOC
= null;
1106 final long INITIAL_TS
= 1;
1107 final int NB_READS
= 20;
1109 // On lower bound, returns the first event (ts = 1)
1110 final ITmfContext context
= fTrace
.seekEvent(INITIAL_LOC
);
1114 for (int i
= 0; i
< NB_READS
; i
++) {
1115 event
= fTrace
.getNext(context
);
1116 assertEquals("Event timestamp", INITIAL_TS
+ i
, event
.getTimestamp().getValue());
1117 assertEquals("Event rank", INITIAL_TS
+ i
, context
.getRank());
1120 // Make sure we stay positioned
1121 event
= fTrace
.parseEvent(context
);
1122 assertEquals("Event timestamp", INITIAL_TS
+ NB_READS
, event
.getTimestamp().getValue());
1123 assertEquals("Event rank", INITIAL_TS
+ NB_READS
- 1, context
.getRank());
1126 public void testGetNextAfterSeekingOnLocation_2() throws Exception
{
1128 final ITmfLocation
<?
> INITIAL_LOC
= fTrace
.seekEvent(1L).getLocation();
1129 final long INITIAL_TS
= 2;
1130 final int NB_READS
= 20;
1132 // On lower bound, returns the first event (ts = 501)
1133 final ITmfContext context
= fTrace
.seekEvent(INITIAL_LOC
);
1137 for (int i
= 0; i
< NB_READS
; i
++) {
1138 event
= fTrace
.getNext(context
);
1139 assertEquals("Event timestamp", INITIAL_TS
+ i
, event
.getTimestamp().getValue());
1142 // Make sure we stay positioned
1143 event
= fTrace
.parseEvent(context
);
1144 assertEquals("Event timestamp", INITIAL_TS
+ NB_READS
, event
.getTimestamp().getValue());
1147 public void testGetNextAfterSeekingOnLocation_3() throws Exception
{
1149 final ITmfLocation
<?
> INITIAL_LOC
= fTrace
.seekEvent(500L).getLocation();
1150 final long INITIAL_TS
= 501;
1151 final int NB_READS
= 20;
1153 // On lower bound, returns the first event (ts = 501)
1154 final ITmfContext context
= fTrace
.seekEvent(INITIAL_LOC
);
1158 for (int i
= 0; i
< NB_READS
; i
++) {
1159 event
= fTrace
.getNext(context
);
1160 assertEquals("Event timestamp", INITIAL_TS
+ i
, event
.getTimestamp().getValue());
1163 // Make sure we stay positioned
1164 event
= fTrace
.parseEvent(context
);
1165 assertEquals("Event timestamp", INITIAL_TS
+ NB_READS
, event
.getTimestamp().getValue());
1168 public void testGetNextLocation() throws Exception
{
1169 ITmfContext context1
= fTrace
.seekEvent(0);
1170 fTrace
.getNext(context1
);
1171 ITmfLocation
<?
> location
= context1
.getLocation().clone();
1172 ITmfEvent event1
= fTrace
.getNext(context1
);
1173 ITmfContext context2
= fTrace
.seekEvent(location
);
1174 ITmfEvent event2
= fTrace
.getNext(context2
);
1175 assertEquals("Event timestamp", event1
.getTimestamp().getValue(), event2
.getTimestamp().getValue());
1178 public void testGetNextEndLocation() throws Exception
{
1179 ITmfContext context1
= fTrace
.seekEvent(fTrace
.getNbEvents() - 1);
1180 fTrace
.getNext(context1
);
1181 ITmfLocation
<?
> location
= context1
.getLocation().clone();
1182 ITmfContext context2
= fTrace
.seekEvent(location
);
1183 ITmfEvent event
= fTrace
.getNext(context2
);
1184 assertNull("Event", event
);
1187 // ------------------------------------------------------------------------
1189 // ------------------------------------------------------------------------
1191 @SuppressWarnings("unchecked")
1192 public void testProcessEventRequestForAllEvents() throws Exception
{
1193 final int BLOCK_SIZE
= 1;
1194 final Vector
<TmfEvent
> requestedEvents
= new Vector
<TmfEvent
>();
1196 final TmfTimeRange range
= new TmfTimeRange(TmfTimestamp
.BIG_BANG
, TmfTimestamp
.BIG_CRUNCH
);
1197 final TmfEventRequest
<TmfEvent
> request
= new TmfEventRequest
<TmfEvent
>(TmfEvent
.class, range
, NB_EVENTS
, BLOCK_SIZE
) {
1199 public void handleData(final TmfEvent event
) {
1200 super.handleData(event
);
1201 requestedEvents
.add(event
);
1204 final ITmfDataProvider
<TmfEvent
>[] providers
= (ITmfDataProvider
<TmfEvent
>[]) TmfProviderManager
.getProviders(TmfEvent
.class, TmfTraceStub
.class);
1205 providers
[0].sendRequest(request
);
1206 request
.waitForCompletion();
1208 assertEquals("nbEvents", NB_EVENTS
, requestedEvents
.size());
1209 assertTrue("isCompleted", request
.isCompleted());
1210 assertFalse("isCancelled", request
.isCancelled());
1212 // Ensure that we have distinct events.
1213 // Don't go overboard: we are not validating the stub!
1214 for (int i
= 0; i
< NB_EVENTS
; i
++) {
1215 assertEquals("Distinct events", i
+ 1, requestedEvents
.get(i
).getTimestamp().getValue());
1219 @SuppressWarnings("unchecked")
1220 public void testProcessEventRequestForNbEvents() throws Exception
{
1221 final int BLOCK_SIZE
= 100;
1222 final int NB_EVENTS
= 1000;
1223 final Vector
<TmfEvent
> requestedEvents
= new Vector
<TmfEvent
>();
1225 final TmfTimeRange range
= new TmfTimeRange(TmfTimestamp
.BIG_BANG
, TmfTimestamp
.BIG_CRUNCH
);
1226 final TmfEventRequest
<TmfEvent
> request
= new TmfEventRequest
<TmfEvent
>(TmfEvent
.class, range
, NB_EVENTS
, BLOCK_SIZE
) {
1228 public void handleData(final TmfEvent event
) {
1229 super.handleData(event
);
1230 requestedEvents
.add(event
);
1233 final ITmfDataProvider
<TmfEvent
>[] providers
= (ITmfDataProvider
<TmfEvent
>[]) TmfProviderManager
.getProviders(TmfEvent
.class, TmfTraceStub
.class);
1234 providers
[0].sendRequest(request
);
1235 request
.waitForCompletion();
1237 assertEquals("nbEvents", NB_EVENTS
, requestedEvents
.size());
1238 assertTrue("isCompleted", request
.isCompleted());
1239 assertFalse("isCancelled", request
.isCancelled());
1241 // Ensure that we have distinct events.
1242 // Don't go overboard: we are not validating the stub!
1243 for (int i
= 0; i
< NB_EVENTS
; i
++) {
1244 assertEquals("Distinct events", i
+ 1, requestedEvents
.get(i
).getTimestamp().getValue());
1248 @SuppressWarnings("unchecked")
1249 public void testProcessEventRequestForSomeEvents() throws Exception
{
1250 final int BLOCK_SIZE
= 1;
1251 final long startTime
= 100;
1252 final int NB_EVENTS
= 1000;
1253 final Vector
<TmfEvent
> requestedEvents
= new Vector
<TmfEvent
>();
1255 final TmfTimeRange range
= new TmfTimeRange(new TmfTimestamp(startTime
, SCALE
), TmfTimestamp
.BIG_CRUNCH
);
1256 final TmfEventRequest
<TmfEvent
> request
= new TmfEventRequest
<TmfEvent
>(TmfEvent
.class, range
, NB_EVENTS
, BLOCK_SIZE
) {
1258 public void handleData(final TmfEvent event
) {
1259 super.handleData(event
);
1260 requestedEvents
.add(event
);
1263 final ITmfDataProvider
<TmfEvent
>[] providers
= (ITmfDataProvider
<TmfEvent
>[]) TmfProviderManager
.getProviders(TmfEvent
.class, TmfTraceStub
.class);
1264 providers
[0].sendRequest(request
);
1265 request
.waitForCompletion();
1267 assertEquals("nbEvents", NB_EVENTS
, requestedEvents
.size());
1268 assertTrue("isCompleted", request
.isCompleted());
1269 assertFalse("isCancelled", request
.isCancelled());
1271 // Ensure that we have distinct events.
1272 // Don't go overboard: we are not validating the stub!
1273 for (int i
= 0; i
< NB_EVENTS
; i
++) {
1274 assertEquals("Distinct events", startTime
+ i
, requestedEvents
.get(i
).getTimestamp().getValue());
1278 @SuppressWarnings("unchecked")
1279 public void testProcessEventRequestForOtherEvents() throws Exception
{
1280 final int BLOCK_SIZE
= 1;
1281 final int startIndex
= 99;
1282 final long startTime
= 100;
1283 final int NB_EVENTS
= 1000;
1284 final Vector
<TmfEvent
> requestedEvents
= new Vector
<TmfEvent
>();
1286 final TmfTimeRange range
= new TmfTimeRange(new TmfTimestamp(startTime
, SCALE
), TmfTimestamp
.BIG_CRUNCH
);
1287 final TmfEventRequest
<TmfEvent
> request
= new TmfEventRequest
<TmfEvent
>(TmfEvent
.class, range
, startIndex
, NB_EVENTS
, BLOCK_SIZE
) {
1289 public void handleData(final TmfEvent event
) {
1290 super.handleData(event
);
1291 requestedEvents
.add(event
);
1294 final ITmfDataProvider
<TmfEvent
>[] providers
= (ITmfDataProvider
<TmfEvent
>[]) TmfProviderManager
.getProviders(TmfEvent
.class, TmfTraceStub
.class);
1295 providers
[0].sendRequest(request
);
1296 request
.waitForCompletion();
1298 assertEquals("nbEvents", NB_EVENTS
, requestedEvents
.size());
1299 assertTrue("isCompleted", request
.isCompleted());
1300 assertFalse("isCancelled", request
.isCancelled());
1302 // Ensure that we have distinct events.
1303 // Don't go overboard: we are not validating the stub!
1304 for (int i
= 0; i
< NB_EVENTS
; i
++) {
1305 assertEquals("Distinct events", startTime
+ i
, requestedEvents
.get(i
).getTimestamp().getValue());
1309 @SuppressWarnings("unchecked")
1310 public void testProcessDataRequestForSomeEvents() throws Exception
{
1311 final int startIndex
= 100;
1312 final int NB_EVENTS
= 1000;
1313 final Vector
<TmfEvent
> requestedEvents
= new Vector
<TmfEvent
>();
1315 final TmfDataRequest
<TmfEvent
> request
= new TmfDataRequest
<TmfEvent
>(TmfEvent
.class, startIndex
, NB_EVENTS
) {
1317 public void handleData(final TmfEvent event
) {
1318 super.handleData(event
);
1319 requestedEvents
.add(event
);
1322 final ITmfDataProvider
<TmfEvent
>[] providers
= (ITmfDataProvider
<TmfEvent
>[]) TmfProviderManager
.getProviders(TmfEvent
.class, TmfTraceStub
.class);
1323 providers
[0].sendRequest(request
);
1324 request
.waitForCompletion();
1326 assertEquals("nbEvents", NB_EVENTS
, requestedEvents
.size());
1327 assertTrue("isCompleted", request
.isCompleted());
1328 assertFalse("isCancelled", request
.isCancelled());
1330 // Ensure that we have distinct events.
1331 // Don't go overboard: we are not validating the stub!
1332 for (int i
= 0; i
< NB_EVENTS
; i
++) {
1333 assertEquals("Distinct events", startIndex
+ 1 + i
, requestedEvents
.get(i
).getTimestamp().getValue());
1337 // ------------------------------------------------------------------------
1339 // ------------------------------------------------------------------------
1341 @SuppressWarnings("unchecked")
1342 public void testCancel() throws Exception
{
1343 final Vector
<TmfEvent
> requestedEvents
= new Vector
<TmfEvent
>();
1345 final TmfTimeRange range
= new TmfTimeRange(TmfTimestamp
.BIG_BANG
, TmfTimestamp
.BIG_CRUNCH
);
1346 final TmfEventRequest
<TmfEvent
> request
= new TmfEventRequest
<TmfEvent
>(TmfEvent
.class, range
, NB_EVENTS
, BLOCK_SIZE
) {
1349 public void handleData(final TmfEvent event
) {
1350 super.handleData(event
);
1351 requestedEvents
.add(event
);
1352 if (++nbRead
== BLOCK_SIZE
) {
1357 final ITmfDataProvider
<TmfEvent
>[] providers
= (ITmfDataProvider
<TmfEvent
>[]) TmfProviderManager
.getProviders(TmfEvent
.class, TmfTraceStub
.class);
1358 providers
[0].sendRequest(request
);
1359 request
.waitForCompletion();
1361 assertEquals("nbEvents", BLOCK_SIZE
, requestedEvents
.size());
1362 assertTrue("isCompleted", request
.isCompleted());
1363 assertTrue("isCancelled", request
.isCancelled());
1366 // ------------------------------------------------------------------------
1368 // ------------------------------------------------------------------------
1370 public void testDefaultTmfTraceStub() throws Exception
{
1371 assertFalse ("Open trace", fTrace
== null);
1372 assertEquals("getType", TmfEvent
.class, fTrace
.getType());
1373 assertNull ("getResource", fTrace
.getResource());
1374 assertEquals("getCacheSize", BLOCK_SIZE
, fTrace
.getCacheSize());
1375 assertEquals("getStreamingInterval", 0, fTrace
.getStreamingInterval());
1376 assertEquals("getName", TEST_STREAM
, fTrace
.getName());
1378 assertEquals("getNbEvents", NB_EVENTS
, fTrace
.getNbEvents());
1379 assertEquals("getRange-start", 1, fTrace
.getTimeRange().getStartTime().getValue());
1380 assertEquals("getRange-end", NB_EVENTS
, fTrace
.getTimeRange().getEndTime().getValue());
1381 assertEquals("getStartTime", 1, fTrace
.getStartTime().getValue());
1382 assertEquals("getEndTime", NB_EVENTS
, fTrace
.getEndTime().getValue());
1384 String expected
= "TmfTrace [fPath=" + fTrace
.getPath() + ", fCacheSize=" + fTrace
.getCacheSize() +
1385 ", fNbEvents=" + fTrace
.getNbEvents() + ", fStartTime=" + fTrace
.getStartTime() +
1386 ", fEndTime=" + fTrace
.getEndTime() + ", fStreamingInterval=" + fTrace
.getStreamingInterval() +
1388 assertEquals("toString", expected
, fTrace
.toString());