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
.tmf
.core
.component
.ITmfDataProvider
;
27 import org
.eclipse
.linuxtools
.tmf
.core
.component
.TmfProviderManager
;
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
.ITmfTrace
;
39 import org
.eclipse
.linuxtools
.tmf
.core
.trace
.TmfCheckpointIndexer
;
40 import org
.eclipse
.linuxtools
.tmf
.core
.trace
.TmfContext
;
41 import org
.eclipse
.linuxtools
.tmf
.tests
.stubs
.trace
.TmfTraceStub
;
44 * Test suite for the TmfTrace class.
46 @SuppressWarnings("nls")
47 public class TmfTraceTest
extends TestCase
{
49 // ------------------------------------------------------------------------
51 // ------------------------------------------------------------------------
53 private static final String DIRECTORY
= "testfiles";
54 private static final String TEST_STREAM
= "A-Test-10K";
55 private static final int BLOCK_SIZE
= 500;
56 private static final int NB_EVENTS
= 10000;
57 private static TmfTraceStub fTrace
= null;
59 private static int SCALE
= -3;
61 // ------------------------------------------------------------------------
63 // ------------------------------------------------------------------------
65 public TmfTraceTest(final String name
) throws Exception
{
70 protected void setUp() throws Exception
{
72 fTrace
= setupTrace(DIRECTORY
+ File
.separator
+ TEST_STREAM
);
76 protected void tearDown() throws Exception
{
82 // ------------------------------------------------------------------------
84 // ------------------------------------------------------------------------
86 private TmfTraceStub
setupTrace(final String path
) {
89 final URL location
= FileLocator
.find(TmfCoreTestPlugin
.getDefault().getBundle(), new Path(path
), null);
90 final File test
= new File(FileLocator
.toFileURL(location
).toURI());
91 fTrace
= new TmfTraceStub(test
.toURI().getPath(), BLOCK_SIZE
);
93 } catch (final TmfTraceException e
) {
95 } catch (final URISyntaxException e
) {
97 } catch (final IOException e
) {
104 // ------------------------------------------------------------------------
106 // ------------------------------------------------------------------------
108 public void testStandardConstructor() throws Exception
{
109 TmfTraceStub trace
= null;
110 File testfile
= null;
112 final URL location
= FileLocator
.find(TmfCoreTestPlugin
.getDefault().getBundle(), new Path(DIRECTORY
+ File
.separator
+ TEST_STREAM
), null);
113 testfile
= new File(FileLocator
.toFileURL(location
).toURI());
114 trace
= new TmfTraceStub(testfile
.toURI().getPath());
116 } catch (final URISyntaxException e
) {
117 fail("URISyntaxException");
118 } catch (final IOException e
) {
122 assertFalse ("Open trace", trace
== null);
123 assertEquals("getType", TmfEvent
.class, trace
.getType());
124 assertNull ("getResource", trace
.getResource());
125 assertEquals("getPath", testfile
.toURI().getPath(), trace
.getPath());
126 assertEquals("getCacheSize", ITmfTrace
.DEFAULT_TRACE_CACHE_SIZE
, trace
.getCacheSize());
127 assertEquals("getStreamingInterval", 0, trace
.getStreamingInterval());
128 assertEquals("getName", TEST_STREAM
, trace
.getName());
130 assertEquals("getNbEvents", NB_EVENTS
, trace
.getNbEvents());
131 assertEquals("getRange-start", 1, trace
.getTimeRange().getStartTime().getValue());
132 assertEquals("getRange-end", NB_EVENTS
, trace
.getTimeRange().getEndTime().getValue());
133 assertEquals("getStartTime", 1, trace
.getStartTime().getValue());
134 assertEquals("getEndTime", NB_EVENTS
, trace
.getEndTime().getValue());
137 public void testStandardConstructorCacheSize() throws Exception
{
138 TmfTraceStub trace
= null;
139 File testfile
= null;
141 final URL location
= FileLocator
.find(TmfCoreTestPlugin
.getDefault().getBundle(), new Path(DIRECTORY
+ File
.separator
+ TEST_STREAM
), null);
142 testfile
= new File(FileLocator
.toFileURL(location
).toURI());
143 trace
= new TmfTraceStub(testfile
.toURI().getPath(), 0);
145 } catch (final URISyntaxException e
) {
146 fail("URISyntaxException");
147 } catch (final IOException e
) {
151 assertFalse ("Open trace", trace
== null);
152 assertEquals("getType", TmfEvent
.class, trace
.getType());
153 assertNull ("getResource", trace
.getResource());
154 assertEquals("getPath", testfile
.toURI().getPath(), trace
.getPath());
155 assertEquals("getCacheSize", ITmfTrace
.DEFAULT_TRACE_CACHE_SIZE
, trace
.getCacheSize());
156 assertEquals("getStreamingInterval", 0, trace
.getStreamingInterval());
157 assertEquals("getName", TEST_STREAM
, trace
.getName());
159 assertEquals("getNbEvents", NB_EVENTS
, trace
.getNbEvents());
160 assertEquals("getRange-start", 1, trace
.getTimeRange().getStartTime().getValue());
161 assertEquals("getRange-end", NB_EVENTS
, trace
.getTimeRange().getEndTime().getValue());
162 assertEquals("getStartTime", 1, trace
.getStartTime().getValue());
163 assertEquals("getEndTime", NB_EVENTS
, trace
.getEndTime().getValue());
166 final URL location
= FileLocator
.find(TmfCoreTestPlugin
.getDefault().getBundle(), new Path(DIRECTORY
+ File
.separator
+ TEST_STREAM
), null);
167 testfile
= new File(FileLocator
.toFileURL(location
).toURI());
168 trace
= new TmfTraceStub(testfile
.toURI().getPath(), BLOCK_SIZE
);
170 } catch (final URISyntaxException e
) {
171 fail("URISyntaxException");
172 } catch (final IOException e
) {
176 assertFalse ("Open trace", trace
== null);
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({ "rawtypes", "unchecked" })
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 assertFalse ("Open trace", trace
== null);
325 assertEquals("getType", TmfEvent
.class, trace
.getType());
326 assertNull ("getResource", trace
.getResource());
327 assertEquals("getPath", path
, trace
.getPath());
328 assertEquals("getCacheSize", ITmfTrace
.DEFAULT_TRACE_CACHE_SIZE
, trace
.getCacheSize());
329 assertEquals("getStreamingInterval", 0, trace
.getStreamingInterval());
330 assertEquals("getName", path
, trace
.getName());
332 assertEquals("getNbEvents", 0, trace
.getNbEvents());
333 assertEquals("getRange-start", Long
.MAX_VALUE
, trace
.getTimeRange().getStartTime().getValue());
334 assertEquals("getRange-end", Long
.MIN_VALUE
, trace
.getTimeRange().getEndTime().getValue());
335 assertEquals("getStartTime", Long
.MAX_VALUE
, trace
.getStartTime().getValue());
336 assertEquals("getEndTime", Long
.MIN_VALUE
, trace
.getEndTime().getValue());
339 public void testInitializeNormalPath() throws Exception
{
341 // Instantiate an "empty" trace
342 final TmfTraceStub trace
= new TmfTraceStub();
344 // Path == trace name
345 String name
= "TraceName";
346 String path
= "/my/trace/path/" + name
;
348 trace
.initialize(null, path
, TmfEvent
.class);
349 } catch (Exception e
) {
350 fail("TmfTrace.initialize() - Exception thrown");
353 assertFalse ("Open trace", trace
== null);
354 assertEquals("getType", TmfEvent
.class, trace
.getType());
355 assertNull ("getResource", trace
.getResource());
356 assertEquals("getPath", path
, trace
.getPath());
357 assertEquals("getCacheSize", ITmfTrace
.DEFAULT_TRACE_CACHE_SIZE
, trace
.getCacheSize());
358 assertEquals("getStreamingInterval", 0, trace
.getStreamingInterval());
359 assertEquals("getName", name
, trace
.getName());
361 assertEquals("getNbEvents", 0, trace
.getNbEvents());
362 assertEquals("getRange-start", Long
.MAX_VALUE
, trace
.getTimeRange().getStartTime().getValue());
363 assertEquals("getRange-end", Long
.MIN_VALUE
, trace
.getTimeRange().getEndTime().getValue());
364 assertEquals("getStartTime", Long
.MAX_VALUE
, trace
.getStartTime().getValue());
365 assertEquals("getEndTime", Long
.MIN_VALUE
, trace
.getEndTime().getValue());
368 public void testInitTrace() throws Exception
{
370 // Instantiate an "empty" trace
371 final TmfTraceStub trace
= new TmfTraceStub();
373 assertFalse ("Open trace", trace
== null);
374 assertNull ("getType", trace
.getType());
375 assertNull ("getResource", trace
.getResource());
376 assertEquals("getCacheSize", ITmfTrace
.DEFAULT_TRACE_CACHE_SIZE
, trace
.getCacheSize());
377 assertEquals("getStreamingInterval", 0, trace
.getStreamingInterval());
378 assertEquals("getName", "", trace
.getName());
380 assertEquals("getNbEvents", 0, trace
.getNbEvents());
381 assertEquals("getRange-start", Long
.MAX_VALUE
, trace
.getTimeRange().getStartTime().getValue());
382 assertEquals("getRange-end", Long
.MIN_VALUE
, trace
.getTimeRange().getEndTime().getValue());
383 assertEquals("getStartTime", Long
.MAX_VALUE
, trace
.getStartTime().getValue());
384 assertEquals("getEndTime", Long
.MIN_VALUE
, trace
.getEndTime().getValue());
387 final URL location
= FileLocator
.find(TmfCoreTestPlugin
.getDefault().getBundle(), new Path(DIRECTORY
+ File
.separator
+ TEST_STREAM
), null);
388 final File testfile
= new File(FileLocator
.toFileURL(location
).toURI());
389 assertTrue("validate", trace
.validate(null, testfile
.getPath()));
391 // InitTrace and wait for indexing completion...
392 trace
.initTrace(null, testfile
.getPath(), TmfEvent
.class);
395 while (trace
.getNbEvents() < NB_EVENTS
&& nbSecs
< 10) {
399 if (trace
.getNbEvents() < NB_EVENTS
) {
403 assertFalse ("Open trace", trace
== null);
404 assertEquals("getType", TmfEvent
.class, trace
.getType());
405 assertNull ("getResource", trace
.getResource());
406 assertEquals("getCacheSize", ITmfTrace
.DEFAULT_TRACE_CACHE_SIZE
, trace
.getCacheSize());
407 assertEquals("getStreamingInterval", 0, trace
.getStreamingInterval());
408 assertEquals("getName", TEST_STREAM
, trace
.getName());
410 assertEquals("getNbEvents", NB_EVENTS
, trace
.getNbEvents());
411 assertEquals("getRange-start", 1, trace
.getTimeRange().getStartTime().getValue());
412 assertEquals("getRange-end", NB_EVENTS
, trace
.getTimeRange().getEndTime().getValue());
413 assertEquals("getStartTime", 1, trace
.getStartTime().getValue());
414 assertEquals("getEndTime", NB_EVENTS
, trace
.getEndTime().getValue());
417 // ------------------------------------------------------------------------
418 // Set/Get streaming interval
419 // ------------------------------------------------------------------------
421 public void testSetStreamingInterval() throws Exception
{
422 final TmfTraceStub trace
= new TmfTraceStub(fTrace
);
425 assertEquals("getStreamingInterval", interval
, trace
.getStreamingInterval());
428 trace
.setStreamingInterval(interval
);
429 assertEquals("getStreamingInterval", interval
, trace
.getStreamingInterval());
432 trace
.setStreamingInterval(interval
);
433 assertEquals("getStreamingInterval", 0, trace
.getStreamingInterval());
436 trace
.setStreamingInterval(interval
);
437 assertEquals("getStreamingInterval", interval
, trace
.getStreamingInterval());
442 // ------------------------------------------------------------------------
443 // Set/Get time range
444 // ------------------------------------------------------------------------
446 public void testSetTimeRange() throws Exception
{
447 final TmfTraceStub trace
= new TmfTraceStub(fTrace
);
450 assertEquals("getRange-start", 1, trace
.getTimeRange().getStartTime().getValue());
451 assertEquals("getRange-end", NB_EVENTS
, trace
.getTimeRange().getEndTime().getValue());
452 assertEquals("getStartTime", 1, trace
.getStartTime().getValue());
453 assertEquals("getEndTime", NB_EVENTS
, trace
.getEndTime().getValue());
455 trace
.setTimeRange(new TmfTimeRange(new TmfTimestamp(100), new TmfTimestamp(200)));
456 assertEquals("setTimeRange", 100, trace
.getTimeRange().getStartTime().getValue());
457 assertEquals("setTimeRange", 200, trace
.getTimeRange().getEndTime().getValue());
458 assertEquals("setTimeRange", 100, trace
.getStartTime().getValue());
459 assertEquals("setTimeRange", 200, trace
.getEndTime().getValue());
464 public void testSetStartTime() throws Exception
{
465 final TmfTraceStub trace
= new TmfTraceStub(fTrace
);
468 assertEquals("getRange-start", 1, trace
.getTimeRange().getStartTime().getValue());
469 assertEquals("getRange-end", NB_EVENTS
, trace
.getTimeRange().getEndTime().getValue());
470 assertEquals("getStartTime", 1, trace
.getStartTime().getValue());
471 assertEquals("getEndTime", NB_EVENTS
, trace
.getEndTime().getValue());
473 trace
.setStartTime(new TmfTimestamp(100));
474 assertEquals("setStartTime", 100, trace
.getTimeRange().getStartTime().getValue());
475 assertEquals("setStartTime", NB_EVENTS
, trace
.getTimeRange().getEndTime().getValue());
476 assertEquals("setStartTime", 100, trace
.getStartTime().getValue());
477 assertEquals("setStartTime", NB_EVENTS
, trace
.getEndTime().getValue());
482 public void testSetEndTime() throws Exception
{
483 final TmfTraceStub trace
= new TmfTraceStub(fTrace
);
486 assertEquals("getRange-start", 1, trace
.getTimeRange().getStartTime().getValue());
487 assertEquals("getRange-end", NB_EVENTS
, trace
.getTimeRange().getEndTime().getValue());
488 assertEquals("getStartTime", 1, trace
.getStartTime().getValue());
489 assertEquals("getEndTime", NB_EVENTS
, trace
.getEndTime().getValue());
491 trace
.setEndTime(new TmfTimestamp(100));
492 assertEquals("setEndTime", 1, trace
.getTimeRange().getStartTime().getValue());
493 assertEquals("setEndTime", 100, trace
.getTimeRange().getEndTime().getValue());
494 assertEquals("setEndTime", 1, trace
.getStartTime().getValue());
495 assertEquals("setEndTime", 100, trace
.getEndTime().getValue());
500 public void testSetNbEvents() throws Exception
{
501 final TmfTraceStub trace
= new TmfTraceStub(fTrace
);
504 assertEquals("getNbEvents", NB_EVENTS
, trace
.getNbEvents());
506 trace
.setNbEvents(0);
507 assertEquals("getNbEvents", 0, trace
.getNbEvents());
509 trace
.setNbEvents(-1);
510 assertEquals("getNbEvents", 0, trace
.getNbEvents());
512 trace
.setNbEvents(NB_EVENTS
+ 1);
513 assertEquals("getNbEvents", NB_EVENTS
+ 1, trace
.getNbEvents());
515 trace
.setNbEvents(NB_EVENTS
);
516 assertEquals("getNbEvents", NB_EVENTS
, trace
.getNbEvents());
521 // ------------------------------------------------------------------------
522 // seekEvent on location (note: does not reliably set the rank)
523 // ------------------------------------------------------------------------
525 public void testSeekEventOnCacheBoundary() throws Exception
{
527 // Position trace at event rank 0
528 ITmfContext context
= fTrace
.seekEvent(0);
529 ITmfEvent event
= fTrace
.parseEvent(context
);
530 assertEquals("Event timestamp", 1, event
.getTimestamp().getValue());
531 assertEquals("Event rank", 0, context
.getRank());
533 context
= fTrace
.seekEvent(context
.getLocation());
534 assertEquals("Event rank", ITmfContext
.UNKNOWN_RANK
, context
.getRank());
536 event
= fTrace
.parseEvent(context
);
537 assertEquals("Event timestamp", 1, event
.getTimestamp().getValue());
538 assertEquals("Event rank", ITmfContext
.UNKNOWN_RANK
, context
.getRank());
540 event
= fTrace
.getNext(context
);
541 assertEquals("Event timestamp", 1, event
.getTimestamp().getValue());
542 assertEquals("Event rank", ITmfContext
.UNKNOWN_RANK
, context
.getRank());
544 // Position trace at event rank 1000
545 ITmfContext tmpContext
= fTrace
.seekEvent(new TmfTimestamp(1001, SCALE
, 0));
546 context
= fTrace
.seekEvent(tmpContext
.getLocation());
547 assertEquals("Event rank", ITmfContext
.UNKNOWN_RANK
, context
.getRank());
549 event
= fTrace
.parseEvent(context
);
550 assertEquals("Event timestamp", 1001, event
.getTimestamp().getValue());
551 assertEquals("Event rank", ITmfContext
.UNKNOWN_RANK
, context
.getRank());
553 event
= fTrace
.getNext(context
);
554 assertEquals("Event timestamp", 1001, event
.getTimestamp().getValue());
555 assertEquals("Event rank", ITmfContext
.UNKNOWN_RANK
, context
.getRank());
557 // Position trace at event rank 4000
558 tmpContext
= fTrace
.seekEvent(new TmfTimestamp(4001, SCALE
, 0));
559 context
= fTrace
.seekEvent(tmpContext
.getLocation());
560 assertEquals("Event rank", ITmfContext
.UNKNOWN_RANK
, context
.getRank());
562 event
= fTrace
.parseEvent(context
);
563 assertEquals("Event timestamp", 4001, event
.getTimestamp().getValue());
564 assertEquals("Event rank", ITmfContext
.UNKNOWN_RANK
, context
.getRank());
566 event
= fTrace
.getNext(context
);
567 assertEquals("Event timestamp", 4001, event
.getTimestamp().getValue());
568 assertEquals("Event rank", ITmfContext
.UNKNOWN_RANK
, context
.getRank());
571 public void testSeekEventNotOnCacheBoundary() throws Exception
{
573 // Position trace at event rank 9
574 ITmfContext tmpContext
= fTrace
.seekEvent(new TmfTimestamp(10, SCALE
, 0));
575 TmfContext context
= fTrace
.seekEvent(tmpContext
.getLocation());
576 assertEquals("Event rank", ITmfContext
.UNKNOWN_RANK
, context
.getRank());
578 ITmfEvent event
= fTrace
.parseEvent(context
);
579 assertEquals("Event timestamp", 10, event
.getTimestamp().getValue());
580 assertEquals("Event rank", ITmfContext
.UNKNOWN_RANK
, context
.getRank());
582 event
= fTrace
.getNext(context
);
583 assertEquals("Event timestamp", 10, event
.getTimestamp().getValue());
584 assertEquals("Event rank", ITmfContext
.UNKNOWN_RANK
, context
.getRank());
586 // Position trace at event rank 999
587 tmpContext
= fTrace
.seekEvent(new TmfTimestamp(1000, SCALE
, 0));
588 context
= fTrace
.seekEvent(tmpContext
.getLocation());
589 assertEquals("Event rank", ITmfContext
.UNKNOWN_RANK
, context
.getRank());
591 event
= fTrace
.parseEvent(context
);
592 assertEquals("Event timestamp", 1000, event
.getTimestamp().getValue());
593 assertEquals("Event rank", ITmfContext
.UNKNOWN_RANK
, context
.getRank());
595 event
= fTrace
.getNext(context
);
596 assertEquals("Event timestamp", 1000, event
.getTimestamp().getValue());
597 assertEquals("Event rank", ITmfContext
.UNKNOWN_RANK
, context
.getRank());
599 // Position trace at event rank 1001
600 tmpContext
= fTrace
.seekEvent(new TmfTimestamp(1002, SCALE
, 0));
601 context
= fTrace
.seekEvent(tmpContext
.getLocation());
602 assertEquals("Event rank", ITmfContext
.UNKNOWN_RANK
, context
.getRank());
604 event
= fTrace
.parseEvent(context
);
605 assertEquals("Event timestamp", 1002, event
.getTimestamp().getValue());
606 assertEquals("Event rank", ITmfContext
.UNKNOWN_RANK
, context
.getRank());
608 event
= fTrace
.getNext(context
);
609 assertEquals("Event timestamp", 1002, event
.getTimestamp().getValue());
610 assertEquals("Event rank", ITmfContext
.UNKNOWN_RANK
, context
.getRank());
612 // Position trace at event rank 4500
613 tmpContext
= fTrace
.seekEvent(new TmfTimestamp(4501, SCALE
, 0));
614 context
= fTrace
.seekEvent(tmpContext
.getLocation());
615 assertEquals("Event rank", ITmfContext
.UNKNOWN_RANK
, context
.getRank());
617 event
= fTrace
.parseEvent(context
);
618 assertEquals("Event timestamp", 4501, event
.getTimestamp().getValue());
619 assertEquals("Event rank", ITmfContext
.UNKNOWN_RANK
, context
.getRank());
621 event
= fTrace
.getNext(context
);
622 assertEquals("Event timestamp", 4501, event
.getTimestamp().getValue());
623 assertEquals("Event rank", ITmfContext
.UNKNOWN_RANK
, context
.getRank());
626 public void testSeekEventOutOfScope() throws Exception
{
628 // Position trace at beginning
629 ITmfContext tmpContext
= fTrace
.seekEvent(0);
630 ITmfContext context
= fTrace
.seekEvent(tmpContext
.getLocation());
631 assertEquals("Event rank", ITmfContext
.UNKNOWN_RANK
, context
.getRank());
633 ITmfEvent event
= fTrace
.parseEvent(context
);
634 assertEquals("Event timestamp", 1, event
.getTimestamp().getValue());
635 assertEquals("Event rank", ITmfContext
.UNKNOWN_RANK
, context
.getRank());
637 event
= fTrace
.getNext(context
);
638 assertEquals("Event timestamp", 1, event
.getTimestamp().getValue());
639 assertEquals("Event rank", ITmfContext
.UNKNOWN_RANK
, context
.getRank());
641 // Position trace at event passed the end
642 context
= fTrace
.seekEvent(new TmfTimestamp(NB_EVENTS
+ 1, SCALE
, 0));
643 assertNull("Event timestamp", context
.getLocation());
644 assertEquals("Event rank", ITmfContext
.UNKNOWN_RANK
, context
.getRank());
646 event
= fTrace
.getNext(context
);
647 assertNull("Event", event
);
650 // ------------------------------------------------------------------------
651 // seekEvent on timestamp (note: does not reliably set the rank)
652 // ------------------------------------------------------------------------
654 public void testSeekEventOnNullTimestamp() throws Exception
{
656 // Position trace at event rank 0
657 ITmfContext context
= fTrace
.seekEvent((ITmfTimestamp
) null);
658 assertEquals("Event rank", 0, context
.getRank());
660 ITmfEvent event
= fTrace
.parseEvent(context
);
661 assertEquals("Event timestamp", 1, event
.getTimestamp().getValue());
662 assertEquals("Event rank", 0, context
.getRank());
665 public void testSeekEventOnTimestampOnCacheBoundary() throws Exception
{
667 // Position trace at event rank 0
668 ITmfContext context
= fTrace
.seekEvent(new TmfTimestamp(1, SCALE
, 0));
669 assertEquals("Event rank", 0, context
.getRank());
671 ITmfEvent event
= fTrace
.parseEvent(context
);
672 assertEquals("Event timestamp", 1, event
.getTimestamp().getValue());
673 assertEquals("Event rank", 0, context
.getRank());
675 event
= fTrace
.getNext(context
);
676 assertEquals("Event timestamp", 1, event
.getTimestamp().getValue());
677 assertEquals("Event rank", 1, context
.getRank());
679 // Position trace at event rank 1000
680 context
= fTrace
.seekEvent(new TmfTimestamp(1001, SCALE
, 0));
681 assertEquals("Event rank", 1000, context
.getRank());
683 event
= fTrace
.parseEvent(context
);
684 assertEquals("Event timestamp", 1001, event
.getTimestamp().getValue());
685 assertEquals("Event rank", 1000, context
.getRank());
687 event
= fTrace
.getNext(context
);
688 assertEquals("Event timestamp", 1001, event
.getTimestamp().getValue());
689 assertEquals("Event rank", 1001, context
.getRank());
691 // Position trace at event rank 4000
692 context
= fTrace
.seekEvent(new TmfTimestamp(4001, SCALE
, 0));
693 assertEquals("Event rank", 4000, context
.getRank());
695 event
= fTrace
.parseEvent(context
);
696 assertEquals("Event timestamp", 4001, event
.getTimestamp().getValue());
697 assertEquals("Event rank", 4000, context
.getRank());
699 event
= fTrace
.getNext(context
);
700 assertEquals("Event timestamp", 4001, event
.getTimestamp().getValue());
701 assertEquals("Event rank", 4001, context
.getRank());
704 public void testSeekEventOnTimestampNotOnCacheBoundary() throws Exception
{
706 // Position trace at event rank 1
707 ITmfContext context
= fTrace
.seekEvent(new TmfTimestamp(2, SCALE
, 0));
708 assertEquals("Event rank", 1, context
.getRank());
710 ITmfEvent event
= fTrace
.parseEvent(context
);
711 assertEquals("Event timestamp", 2, event
.getTimestamp().getValue());
712 assertEquals("Event rank", 1, context
.getRank());
714 event
= fTrace
.getNext(context
);
715 assertEquals("Event timestamp", 2, event
.getTimestamp().getValue());
716 assertEquals("Event rank", 2, context
.getRank());
718 // Position trace at event rank 9
719 context
= fTrace
.seekEvent(new TmfTimestamp(10, SCALE
, 0));
720 assertEquals("Event rank", 9, context
.getRank());
722 event
= fTrace
.parseEvent(context
);
723 assertEquals("Event timestamp", 10, event
.getTimestamp().getValue());
724 assertEquals("Event rank", 9, context
.getRank());
726 event
= fTrace
.getNext(context
);
727 assertEquals("Event timestamp", 10, event
.getTimestamp().getValue());
728 assertEquals("Event rank", 10, context
.getRank());
730 // Position trace at event rank 999
731 context
= fTrace
.seekEvent(new TmfTimestamp(1000, SCALE
, 0));
732 assertEquals("Event rank", 999, context
.getRank());
734 event
= fTrace
.parseEvent(context
);
735 assertEquals("Event timestamp", 1000, event
.getTimestamp().getValue());
736 assertEquals("Event rank", 999, context
.getRank());
738 event
= fTrace
.getNext(context
);
739 assertEquals("Event timestamp", 1000, event
.getTimestamp().getValue());
740 assertEquals("Event rank", 1000, context
.getRank());
742 // Position trace at event rank 1001
743 context
= fTrace
.seekEvent(new TmfTimestamp(1002, SCALE
, 0));
744 assertEquals("Event rank", 1001, context
.getRank());
746 event
= fTrace
.parseEvent(context
);
747 assertEquals("Event timestamp", 1002, event
.getTimestamp().getValue());
748 assertEquals("Event rank", 1001, context
.getRank());
750 event
= fTrace
.getNext(context
);
751 assertEquals("Event timestamp", 1002, event
.getTimestamp().getValue());
752 assertEquals("Event rank", 1002, context
.getRank());
754 // Position trace at event rank 4500
755 context
= fTrace
.seekEvent(new TmfTimestamp(4501, SCALE
, 0));
756 assertEquals("Event rank", 4500, context
.getRank());
758 event
= fTrace
.parseEvent(context
);
759 assertEquals("Event timestamp", 4501, event
.getTimestamp().getValue());
760 assertEquals("Event rank", 4500, context
.getRank());
762 event
= fTrace
.getNext(context
);
763 assertEquals("Event timestamp", 4501, event
.getTimestamp().getValue());
764 assertEquals("Event rank", 4501, context
.getRank());
767 public void testSeekEventOnTimestampOutOfScope() throws Exception
{
769 // Position trace at beginning
770 ITmfContext context
= fTrace
.seekEvent(new TmfTimestamp(-1, SCALE
, 0));
771 assertEquals("Event rank", 0, context
.getRank());
773 ITmfEvent event
= fTrace
.parseEvent(context
);
774 assertEquals("Event timestamp", 1, event
.getTimestamp().getValue());
775 assertEquals("Event rank", 0, context
.getRank());
777 event
= fTrace
.getNext(context
);
778 assertEquals("Event timestamp", 1, event
.getTimestamp().getValue());
779 assertEquals("Event rank", 1, context
.getRank());
781 // Position trace at event passed the end
782 context
= fTrace
.seekEvent(new TmfTimestamp(NB_EVENTS
+ 1, SCALE
, 0));
783 assertEquals("Event rank", ITmfContext
.UNKNOWN_RANK
, context
.getRank());
785 event
= fTrace
.parseEvent(context
);
786 assertEquals("Event timestamp", null, event
);
787 assertEquals("Event rank", ITmfContext
.UNKNOWN_RANK
, context
.getRank());
789 event
= fTrace
.getNext(context
);
790 assertEquals("Event timestamp", null, event
);
791 assertEquals("Event rank", ITmfContext
.UNKNOWN_RANK
, context
.getRank());
794 // ------------------------------------------------------------------------
796 // ------------------------------------------------------------------------
798 public void testSeekEventOnNegativeRank() throws Exception
{
800 // Position trace at event rank 0
801 ITmfContext context
= fTrace
.seekEvent(-1);
802 assertEquals("Event rank", 0, context
.getRank());
804 ITmfEvent event
= fTrace
.parseEvent(context
);
805 assertEquals("Event timestamp", 1, event
.getTimestamp().getValue());
806 assertEquals("Event rank", 0, context
.getRank());
809 public void testSeekOnRankOnCacheBoundary() throws Exception
{
811 // On lower bound, returns the first event (ts = 1)
812 ITmfContext context
= fTrace
.seekEvent(0);
813 assertEquals("Event rank", 0, context
.getRank());
815 ITmfEvent event
= fTrace
.parseEvent(context
);
816 assertEquals("Event timestamp", 1, event
.getTimestamp().getValue());
817 assertEquals("Event rank", 0, context
.getRank());
819 event
= fTrace
.getNext(context
);
820 assertEquals("Event timestamp", 1, event
.getTimestamp().getValue());
821 assertEquals("Event rank", 1, context
.getRank());
823 // Position trace at event rank 1000
824 context
= fTrace
.seekEvent(1000);
825 assertEquals("Event rank", 1000, context
.getRank());
827 event
= fTrace
.parseEvent(context
);
828 assertEquals("Event timestamp", 1001, event
.getTimestamp().getValue());
829 assertEquals("Event rank", 1000, context
.getRank());
831 event
= fTrace
.getNext(context
);
832 assertEquals("Event timestamp", 1001, event
.getTimestamp().getValue());
833 assertEquals("Event rank", 1001, context
.getRank());
835 // Position trace at event rank 4000
836 context
= fTrace
.seekEvent(4000);
837 assertEquals("Event rank", 4000, context
.getRank());
839 event
= fTrace
.parseEvent(context
);
840 assertEquals("Event timestamp", 4001, event
.getTimestamp().getValue());
841 assertEquals("Event rank", 4000, context
.getRank());
843 event
= fTrace
.getNext(context
);
844 assertEquals("Event timestamp", 4001, event
.getTimestamp().getValue());
845 assertEquals("Event rank", 4001, context
.getRank());
848 public void testSeekOnRankNotOnCacheBoundary() throws Exception
{
850 // Position trace at event rank 9
851 ITmfContext context
= fTrace
.seekEvent(9);
852 assertEquals("Event rank", 9, context
.getRank());
854 ITmfEvent event
= fTrace
.parseEvent(context
);
855 assertEquals("Event timestamp", 10, event
.getTimestamp().getValue());
856 assertEquals("Event rank", 9, context
.getRank());
858 event
= fTrace
.getNext(context
);
859 assertEquals("Event timestamp", 10, event
.getTimestamp().getValue());
860 assertEquals("Event rank", 10, context
.getRank());
862 // Position trace at event rank 999
863 context
= fTrace
.seekEvent(999);
864 assertEquals("Event rank", 999, context
.getRank());
866 event
= fTrace
.parseEvent(context
);
867 assertEquals("Event timestamp", 1000, event
.getTimestamp().getValue());
868 assertEquals("Event rank", 999, context
.getRank());
870 event
= fTrace
.getNext(context
);
871 assertEquals("Event timestamp", 1000, event
.getTimestamp().getValue());
872 assertEquals("Event rank", 1000, context
.getRank());
874 // Position trace at event rank 1001
875 context
= fTrace
.seekEvent(1001);
876 assertEquals("Event rank", 1001, context
.getRank());
878 event
= fTrace
.parseEvent(context
);
879 assertEquals("Event timestamp", 1002, event
.getTimestamp().getValue());
880 assertEquals("Event rank", 1001, context
.getRank());
882 event
= fTrace
.getNext(context
);
883 assertEquals("Event timestamp", 1002, event
.getTimestamp().getValue());
884 assertEquals("Event rank", 1002, context
.getRank());
886 // Position trace at event rank 4500
887 context
= fTrace
.seekEvent(4500);
888 assertEquals("Event rank", 4500, context
.getRank());
890 event
= fTrace
.parseEvent(context
);
891 assertEquals("Event timestamp", 4501, event
.getTimestamp().getValue());
892 assertEquals("Event rank", 4500, context
.getRank());
894 event
= fTrace
.getNext(context
);
895 assertEquals("Event timestamp", 4501, event
.getTimestamp().getValue());
896 assertEquals("Event rank", 4501, context
.getRank());
899 public void testSeekEventOnRankOutOfScope() throws Exception
{
901 // Position trace at beginning
902 ITmfContext context
= fTrace
.seekEvent(-1);
903 assertEquals("Event rank", 0, context
.getRank());
905 ITmfEvent event
= fTrace
.parseEvent(context
);
906 assertEquals("Event timestamp", 1, event
.getTimestamp().getValue());
907 assertEquals("Event rank", 0, context
.getRank());
909 event
= fTrace
.getNext(context
);
910 assertEquals("Event timestamp", 1, event
.getTimestamp().getValue());
911 assertEquals("Event rank", 1, context
.getRank());
913 // Position trace at event passed the end
914 context
= fTrace
.seekEvent(NB_EVENTS
);
915 assertEquals("Event rank", NB_EVENTS
, context
.getRank());
917 event
= fTrace
.parseEvent(context
);
918 assertNull("Event", event
);
919 assertEquals("Event rank", NB_EVENTS
, context
.getRank());
921 event
= fTrace
.getNext(context
);
922 assertNull("Event", event
);
923 assertEquals("Event rank", NB_EVENTS
, context
.getRank());
926 // ------------------------------------------------------------------------
927 // parseEvent - make sure parseEvent doesn't update the context
928 // ------------------------------------------------------------------------
930 public void testParseEvent() throws Exception
{
932 final int NB_READS
= 20;
934 // On lower bound, returns the first event (ts = 0)
935 final TmfContext context
= (TmfContext
) fTrace
.seekEvent(new TmfTimestamp(0, SCALE
, 0));
936 TmfContext svContext
= new TmfContext(context
);
938 ITmfEvent event
= fTrace
.parseEvent(context
);
939 assertEquals("Event timestamp", 1, event
.getTimestamp().getValue());
940 assertEquals("Event rank", 0, context
.getRank());
941 assertTrue("parseEvent", context
.equals(svContext
));
943 event
= fTrace
.parseEvent(context
);
944 assertEquals("Event timestamp", 1, event
.getTimestamp().getValue());
945 assertEquals("Event rank", 0, context
.getRank());
946 assertTrue("parseEvent", context
.equals(svContext
));
948 event
= fTrace
.parseEvent(context
);
949 assertEquals("Event timestamp", 1, event
.getTimestamp().getValue());
950 assertEquals("Event rank", 0, context
.getRank());
951 assertTrue("parseEvent", context
.equals(svContext
));
953 // Position the trace at event NB_READS
954 for (int i
= 1; i
< NB_READS
; i
++) {
955 event
= fTrace
.getNext(context
);
956 assertEquals("Event timestamp", i
, event
.getTimestamp().getValue());
959 svContext
= new TmfContext(context
);
960 event
= fTrace
.parseEvent(context
);
961 assertEquals("Event timestamp", NB_READS
, event
.getTimestamp().getValue());
962 assertEquals("Event rank", NB_READS
-1 , context
.getRank());
963 assertTrue("parseEvent", context
.equals(svContext
));
965 event
= fTrace
.parseEvent(context
);
966 assertEquals("Event timestamp", NB_READS
, event
.getTimestamp().getValue());
967 assertEquals("Event rank", NB_READS
- 1, context
.getRank());
968 assertTrue("parseEvent", context
.equals(svContext
));
971 // ------------------------------------------------------------------------
972 // readNextEvent - updates the context
973 // ------------------------------------------------------------------------
975 public void testReadNextEvent() throws Exception
{
977 final int NB_READS
= 20;
979 // On lower bound, returns the first event (ts = 1)
980 final ITmfContext context
= fTrace
.seekEvent(new TmfTimestamp(0, SCALE
, 0));
984 for (int i
= 0; i
< NB_READS
; i
++) {
985 event
= fTrace
.getNext(context
);
986 assertEquals("Event timestamp", i
+ 1, event
.getTimestamp().getValue());
987 assertEquals("Event rank", i
+ 1, context
.getRank());
990 // Make sure we stay positioned
991 event
= fTrace
.parseEvent(context
);
992 assertEquals("Event timestamp", NB_READS
+ 1, event
.getTimestamp().getValue());
993 assertEquals("Event rank", NB_READS
, context
.getRank());
996 // ------------------------------------------------------------------------
998 // ------------------------------------------------------------------------
1000 @SuppressWarnings("unchecked")
1001 public void testProcessEventRequestForAllEvents() throws Exception
{
1002 final int BLOCK_SIZE
= 1;
1003 final Vector
<TmfEvent
> requestedEvents
= new Vector
<TmfEvent
>();
1005 final TmfTimeRange range
= new TmfTimeRange(TmfTimestamp
.BIG_BANG
, TmfTimestamp
.BIG_CRUNCH
);
1006 final TmfEventRequest
<TmfEvent
> request
= new TmfEventRequest
<TmfEvent
>(TmfEvent
.class, range
, NB_EVENTS
, BLOCK_SIZE
) {
1008 public void handleData(final TmfEvent event
) {
1009 super.handleData(event
);
1010 requestedEvents
.add(event
);
1013 final ITmfDataProvider
<TmfEvent
>[] providers
= (ITmfDataProvider
<TmfEvent
>[]) TmfProviderManager
.getProviders(TmfEvent
.class, TmfTraceStub
.class);
1014 providers
[0].sendRequest(request
);
1015 request
.waitForCompletion();
1017 assertEquals("nbEvents", NB_EVENTS
, requestedEvents
.size());
1018 assertTrue("isCompleted", request
.isCompleted());
1019 assertFalse("isCancelled", request
.isCancelled());
1021 // Ensure that we have distinct events.
1022 // Don't go overboard: we are not validating the stub!
1023 for (int i
= 0; i
< NB_EVENTS
; i
++) {
1024 assertEquals("Distinct events", i
+ 1, requestedEvents
.get(i
).getTimestamp().getValue());
1028 @SuppressWarnings("unchecked")
1029 public void testProcessEventRequestForNbEvents() throws Exception
{
1030 final int BLOCK_SIZE
= 100;
1031 final int NB_EVENTS
= 1000;
1032 final Vector
<TmfEvent
> requestedEvents
= new Vector
<TmfEvent
>();
1034 final TmfTimeRange range
= new TmfTimeRange(TmfTimestamp
.BIG_BANG
, TmfTimestamp
.BIG_CRUNCH
);
1035 final TmfEventRequest
<TmfEvent
> request
= new TmfEventRequest
<TmfEvent
>(TmfEvent
.class, range
, NB_EVENTS
, BLOCK_SIZE
) {
1037 public void handleData(final TmfEvent event
) {
1038 super.handleData(event
);
1039 requestedEvents
.add(event
);
1042 final ITmfDataProvider
<TmfEvent
>[] providers
= (ITmfDataProvider
<TmfEvent
>[]) TmfProviderManager
.getProviders(TmfEvent
.class, TmfTraceStub
.class);
1043 providers
[0].sendRequest(request
);
1044 request
.waitForCompletion();
1046 assertEquals("nbEvents", NB_EVENTS
, requestedEvents
.size());
1047 assertTrue("isCompleted", request
.isCompleted());
1048 assertFalse("isCancelled", request
.isCancelled());
1050 // Ensure that we have distinct events.
1051 // Don't go overboard: we are not validating the stub!
1052 for (int i
= 0; i
< NB_EVENTS
; i
++) {
1053 assertEquals("Distinct events", i
+ 1, requestedEvents
.get(i
).getTimestamp().getValue());
1057 @SuppressWarnings("unchecked")
1058 public void testProcessEventRequestForSomeEvents() throws Exception
{
1059 final int BLOCK_SIZE
= 1;
1060 final long startTime
= 100;
1061 final int NB_EVENTS
= 1000;
1062 final Vector
<TmfEvent
> requestedEvents
= new Vector
<TmfEvent
>();
1064 final TmfTimeRange range
= new TmfTimeRange(new TmfTimestamp(startTime
, SCALE
), TmfTimestamp
.BIG_CRUNCH
);
1065 final TmfEventRequest
<TmfEvent
> request
= new TmfEventRequest
<TmfEvent
>(TmfEvent
.class, range
, NB_EVENTS
, BLOCK_SIZE
) {
1067 public void handleData(final TmfEvent event
) {
1068 super.handleData(event
);
1069 requestedEvents
.add(event
);
1072 final ITmfDataProvider
<TmfEvent
>[] providers
= (ITmfDataProvider
<TmfEvent
>[]) TmfProviderManager
.getProviders(TmfEvent
.class, TmfTraceStub
.class);
1073 providers
[0].sendRequest(request
);
1074 request
.waitForCompletion();
1076 assertEquals("nbEvents", NB_EVENTS
, requestedEvents
.size());
1077 assertTrue("isCompleted", request
.isCompleted());
1078 assertFalse("isCancelled", request
.isCancelled());
1080 // Ensure that we have distinct events.
1081 // Don't go overboard: we are not validating the stub!
1082 for (int i
= 0; i
< NB_EVENTS
; i
++) {
1083 assertEquals("Distinct events", startTime
+ i
, requestedEvents
.get(i
).getTimestamp().getValue());
1087 @SuppressWarnings("unchecked")
1088 public void testProcessEventRequestForOtherEvents() throws Exception
{
1089 final int BLOCK_SIZE
= 1;
1090 final int startIndex
= 99;
1091 final long startTime
= 100;
1092 final int NB_EVENTS
= 1000;
1093 final Vector
<TmfEvent
> requestedEvents
= new Vector
<TmfEvent
>();
1095 final TmfTimeRange range
= new TmfTimeRange(new TmfTimestamp(startTime
, SCALE
), TmfTimestamp
.BIG_CRUNCH
);
1096 final TmfEventRequest
<TmfEvent
> request
= new TmfEventRequest
<TmfEvent
>(TmfEvent
.class, range
, startIndex
, NB_EVENTS
, BLOCK_SIZE
) {
1098 public void handleData(final TmfEvent event
) {
1099 super.handleData(event
);
1100 requestedEvents
.add(event
);
1103 final ITmfDataProvider
<TmfEvent
>[] providers
= (ITmfDataProvider
<TmfEvent
>[]) TmfProviderManager
.getProviders(TmfEvent
.class, TmfTraceStub
.class);
1104 providers
[0].sendRequest(request
);
1105 request
.waitForCompletion();
1107 assertEquals("nbEvents", NB_EVENTS
, requestedEvents
.size());
1108 assertTrue("isCompleted", request
.isCompleted());
1109 assertFalse("isCancelled", request
.isCancelled());
1111 // Ensure that we have distinct events.
1112 // Don't go overboard: we are not validating the stub!
1113 for (int i
= 0; i
< NB_EVENTS
; i
++) {
1114 assertEquals("Distinct events", startTime
+ i
, requestedEvents
.get(i
).getTimestamp().getValue());
1118 @SuppressWarnings("unchecked")
1119 public void testProcessDataRequestForSomeEvents() throws Exception
{
1120 final int startIndex
= 100;
1121 final int NB_EVENTS
= 1000;
1122 final Vector
<TmfEvent
> requestedEvents
= new Vector
<TmfEvent
>();
1124 final TmfDataRequest
<TmfEvent
> request
= new TmfDataRequest
<TmfEvent
>(TmfEvent
.class, startIndex
, NB_EVENTS
) {
1126 public void handleData(final TmfEvent event
) {
1127 super.handleData(event
);
1128 requestedEvents
.add(event
);
1131 final ITmfDataProvider
<TmfEvent
>[] providers
= (ITmfDataProvider
<TmfEvent
>[]) TmfProviderManager
.getProviders(TmfEvent
.class, TmfTraceStub
.class);
1132 providers
[0].sendRequest(request
);
1133 request
.waitForCompletion();
1135 assertEquals("nbEvents", NB_EVENTS
, requestedEvents
.size());
1136 assertTrue("isCompleted", request
.isCompleted());
1137 assertFalse("isCancelled", request
.isCancelled());
1139 // Ensure that we have distinct events.
1140 // Don't go overboard: we are not validating the stub!
1141 for (int i
= 0; i
< NB_EVENTS
; i
++) {
1142 assertEquals("Distinct events", startIndex
+ 1 + i
, requestedEvents
.get(i
).getTimestamp().getValue());
1146 // ------------------------------------------------------------------------
1148 // ------------------------------------------------------------------------
1150 @SuppressWarnings("unchecked")
1151 public void testCancel() throws Exception
{
1152 final Vector
<TmfEvent
> requestedEvents
= new Vector
<TmfEvent
>();
1154 final TmfTimeRange range
= new TmfTimeRange(TmfTimestamp
.BIG_BANG
, TmfTimestamp
.BIG_CRUNCH
);
1155 final TmfEventRequest
<TmfEvent
> request
= new TmfEventRequest
<TmfEvent
>(TmfEvent
.class, range
, NB_EVENTS
, BLOCK_SIZE
) {
1158 public void handleData(final TmfEvent event
) {
1159 super.handleData(event
);
1160 requestedEvents
.add(event
);
1161 if (++nbRead
== BLOCK_SIZE
) {
1166 final ITmfDataProvider
<TmfEvent
>[] providers
= (ITmfDataProvider
<TmfEvent
>[]) TmfProviderManager
.getProviders(TmfEvent
.class, TmfTraceStub
.class);
1167 providers
[0].sendRequest(request
);
1168 request
.waitForCompletion();
1170 assertEquals("nbEvents", BLOCK_SIZE
, requestedEvents
.size());
1171 assertTrue("isCompleted", request
.isCompleted());
1172 assertTrue("isCancelled", request
.isCancelled());
1175 // ------------------------------------------------------------------------
1177 // ------------------------------------------------------------------------
1179 public void testDefaultTmfTraceStub() throws Exception
{
1180 assertFalse ("Open trace", fTrace
== null);
1181 assertEquals("getType", TmfEvent
.class, fTrace
.getType());
1182 assertNull ("getResource", fTrace
.getResource());
1183 assertEquals("getCacheSize", BLOCK_SIZE
, fTrace
.getCacheSize());
1184 assertEquals("getStreamingInterval", 0, fTrace
.getStreamingInterval());
1185 assertEquals("getName", TEST_STREAM
, fTrace
.getName());
1187 assertEquals("getNbEvents", NB_EVENTS
, fTrace
.getNbEvents());
1188 assertEquals("getRange-start", 1, fTrace
.getTimeRange().getStartTime().getValue());
1189 assertEquals("getRange-end", NB_EVENTS
, fTrace
.getTimeRange().getEndTime().getValue());
1190 assertEquals("getStartTime", 1, fTrace
.getStartTime().getValue());
1191 assertEquals("getEndTime", NB_EVENTS
, fTrace
.getEndTime().getValue());
1193 String expected
= "TmfTrace [fPath=" + fTrace
.getPath() + ", fCacheSize=" + fTrace
.getCacheSize() +
1194 ", fNbEvents=" + fTrace
.getNbEvents() + ", fStartTime=" + fTrace
.getStartTime() +
1195 ", fEndTime=" + fTrace
.getEndTime() + ", fStreamingInterval=" + fTrace
.getStreamingInterval() +
1197 assertEquals("toString", expected
, fTrace
.toString());