1 /*******************************************************************************
2 * Copyright (c) 2009, 2010 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 *******************************************************************************/
13 package org
.eclipse
.linuxtools
.tmf
.core
.tests
.experiment
;
16 import java
.io
.IOException
;
17 import java
.net
.URISyntaxException
;
19 import java
.util
.Vector
;
21 import junit
.framework
.TestCase
;
23 import org
.eclipse
.core
.runtime
.FileLocator
;
24 import org
.eclipse
.core
.runtime
.Path
;
25 import org
.eclipse
.linuxtools
.tmf
.core
.event
.ITmfEvent
;
26 import org
.eclipse
.linuxtools
.tmf
.core
.event
.TmfEvent
;
27 import org
.eclipse
.linuxtools
.tmf
.core
.event
.TmfTimeRange
;
28 import org
.eclipse
.linuxtools
.tmf
.core
.event
.TmfTimestamp
;
29 import org
.eclipse
.linuxtools
.tmf
.core
.experiment
.TmfExperiment
;
30 import org
.eclipse
.linuxtools
.tmf
.core
.experiment
.TmfExperimentContext
;
31 import org
.eclipse
.linuxtools
.tmf
.core
.request
.TmfEventRequest
;
32 import org
.eclipse
.linuxtools
.tmf
.core
.tests
.TmfCoreTestPlugin
;
33 import org
.eclipse
.linuxtools
.tmf
.core
.trace
.ITmfContext
;
34 import org
.eclipse
.linuxtools
.tmf
.core
.trace
.ITmfTrace
;
35 import org
.eclipse
.linuxtools
.tmf
.core
.trace
.TmfCheckpoint
;
36 import org
.eclipse
.linuxtools
.tmf
.core
.trace
.TmfContext
;
37 import org
.eclipse
.linuxtools
.tmf
.tests
.stubs
.trace
.TmfTraceStub
;
40 * <b><u>TmfExperimentTest</u></b>
42 * TODO: Implement me. Please.
44 @SuppressWarnings("nls")
45 public class TmfMultiTraceExperimentTest
extends TestCase
{
47 private static final String DIRECTORY
= "testfiles";
48 private static final String TEST_STREAM1
= "O-Test-10K";
49 private static final String TEST_STREAM2
= "E-Test-10K";
50 private static final String EXPERIMENT
= "MyExperiment";
51 private static int NB_EVENTS
= 20000;
52 private static int BLOCK_SIZE
= 1000;
54 private static ITmfTrace
<?
>[] fTraces
;
55 private static TmfExperiment
<TmfEvent
> fExperiment
;
57 private static byte SCALE
= (byte) -3;
59 // ------------------------------------------------------------------------
61 // ------------------------------------------------------------------------
63 private synchronized static ITmfTrace
<?
>[] setupTrace(final String path1
, final String path2
) {
64 if (fTraces
== null) {
65 fTraces
= new ITmfTrace
[2];
67 URL location
= FileLocator
.find(TmfCoreTestPlugin
.getDefault().getBundle(), new Path(path1
), null);
68 File test
= new File(FileLocator
.toFileURL(location
).toURI());
69 final TmfTraceStub trace1
= new TmfTraceStub(test
.getPath(), 0, true);
71 location
= FileLocator
.find(TmfCoreTestPlugin
.getDefault().getBundle(), new Path(path2
), null);
72 test
= new File(FileLocator
.toFileURL(location
).toURI());
73 final TmfTraceStub trace2
= new TmfTraceStub(test
.getPath(), 0, true);
75 } catch (final URISyntaxException e
) {
77 } catch (final IOException e
) {
84 @SuppressWarnings("unchecked")
85 private synchronized static void setupExperiment() {
86 synchronized (TmfMultiTraceExperimentTest
.class) {
87 if (fExperiment
== null) {
88 fExperiment
= new TmfExperiment
<TmfEvent
>(TmfEvent
.class, EXPERIMENT
, (ITmfTrace
<TmfEvent
>[]) fTraces
, TmfTimestamp
.ZERO
, BLOCK_SIZE
, true);
93 public TmfMultiTraceExperimentTest(final String name
) throws Exception
{
98 protected void setUp() throws Exception
{
100 setupTrace(DIRECTORY
+ File
.separator
+ TEST_STREAM1
, DIRECTORY
+ File
.separator
+ TEST_STREAM2
);
105 protected void tearDown() throws Exception
{
109 // ------------------------------------------------------------------------
111 // ------------------------------------------------------------------------
113 public void testBasicTmfExperimentConstructor() {
115 assertEquals("GetId", EXPERIMENT
, fExperiment
.getName());
116 assertEquals("GetEpoch", TmfTimestamp
.ZERO
, fExperiment
.getEpoch());
117 assertEquals("GetNbEvents", NB_EVENTS
, fExperiment
.getNbEvents());
119 final TmfTimeRange timeRange
= fExperiment
.getTimeRange();
120 assertEquals("getStartTime", 1, timeRange
.getStartTime().getValue());
121 assertEquals("getEndTime", NB_EVENTS
, timeRange
.getEndTime().getValue());
124 // ------------------------------------------------------------------------
125 // Verify checkpoints
126 // ------------------------------------------------------------------------
128 public void testValidateCheckpoints() throws Exception
{
130 final Vector
<TmfCheckpoint
> checkpoints
= fExperiment
.getCheckpoints();
131 final int pageSize
= fExperiment
.getCacheSize();
132 assertTrue("Checkpoints exist", checkpoints
!= null);
134 // Validate that each checkpoint points to the right event
135 for (int i
= 0; i
< checkpoints
.size(); i
++) {
136 final TmfCheckpoint checkpoint
= checkpoints
.get(i
);
137 final TmfExperimentContext context
= fExperiment
.seekLocation(checkpoint
.getLocation());
138 final ITmfEvent event
= fExperiment
.parseEvent(context
);
139 assertEquals("Event rank", context
.getRank(), i
* pageSize
);
140 assertTrue("Timestamp", (checkpoint
.getTimestamp().compareTo(event
.getTimestamp(), false) == 0));
144 // ------------------------------------------------------------------------
146 // ------------------------------------------------------------------------
148 public void testSeekLocationOnCacheBoundary() throws Exception
{
150 // Position trace at event rank 0
151 TmfContext context
= fExperiment
.seekLocation(null);
152 assertEquals("Event rank", 0, context
.getRank());
154 ITmfEvent event
= fExperiment
.parseEvent(context
);
155 assertEquals("Event timestamp", 1, event
.getTimestamp().getValue());
156 assertEquals("Event rank", 0, context
.getRank());
158 event
= fExperiment
.getNextEvent(context
);
159 assertEquals("Event timestamp", 1, event
.getTimestamp().getValue());
160 assertEquals("Event rank", 1, context
.getRank());
162 event
= fExperiment
.getNextEvent(context
);
163 assertEquals("Event timestamp", 2, event
.getTimestamp().getValue());
164 assertEquals("Event rank", 2, context
.getRank());
166 // Position trace at event rank 1000
167 TmfContext tmpContext
= fExperiment
.seekEvent(new TmfTimestamp(1001, SCALE
, 0));
168 context
= fExperiment
.seekLocation(tmpContext
.getLocation());
169 assertEquals("Event rank", 1000, context
.getRank());
171 event
= fExperiment
.parseEvent(context
);
172 assertEquals("Event timestamp", 1001, event
.getTimestamp().getValue());
173 assertEquals("Event rank", 1000, context
.getRank());
175 event
= fExperiment
.getNextEvent(context
);
176 assertEquals("Event timestamp", 1001, event
.getTimestamp().getValue());
177 assertEquals("Event rank", 1001, context
.getRank());
179 event
= fExperiment
.getNextEvent(context
);
180 assertEquals("Event timestamp", 1002, event
.getTimestamp().getValue());
181 assertEquals("Event rank", 1002, context
.getRank());
183 // Position trace at event rank 4000
184 tmpContext
= fExperiment
.seekEvent(new TmfTimestamp(4001, SCALE
, 0));
185 context
= fExperiment
.seekLocation(tmpContext
.getLocation());
186 assertEquals("Event rank", 4000, context
.getRank());
188 event
= fExperiment
.parseEvent(context
);
189 assertEquals("Event timestamp", 4001, event
.getTimestamp().getValue());
190 assertEquals("Event rank", 4000, context
.getRank());
192 event
= fExperiment
.getNextEvent(context
);
193 assertEquals("Event timestamp", 4001, event
.getTimestamp().getValue());
194 assertEquals("Event rank", 4001, context
.getRank());
196 event
= fExperiment
.getNextEvent(context
);
197 assertEquals("Event timestamp", 4002, event
.getTimestamp().getValue());
198 assertEquals("Event rank", 4002, context
.getRank());
201 public void testSeekLocationNotOnCacheBoundary() throws Exception
{
203 // Position trace at event rank 9
204 TmfContext tmpContext
= fExperiment
.seekEvent(new TmfTimestamp(10, SCALE
, 0));
205 TmfContext context
= fExperiment
.seekLocation(tmpContext
.getLocation());
206 assertEquals("Event rank", 9, context
.getRank());
208 ITmfEvent event
= fExperiment
.parseEvent(context
);
209 assertEquals("Event timestamp", 10, event
.getTimestamp().getValue());
210 assertEquals("Event rank", 9, context
.getRank());
212 event
= fExperiment
.getNextEvent(context
);
213 assertEquals("Event timestamp", 10, event
.getTimestamp().getValue());
214 assertEquals("Event rank", 10, context
.getRank());
216 // Position trace at event rank 999
217 tmpContext
= fExperiment
.seekEvent(new TmfTimestamp(1000, SCALE
, 0));
218 context
= fExperiment
.seekLocation(tmpContext
.getLocation());
219 assertEquals("Event rank", 999, context
.getRank());
221 event
= fExperiment
.parseEvent(context
);
222 assertEquals("Event timestamp", 1000, event
.getTimestamp().getValue());
223 assertEquals("Event rank", 999, context
.getRank());
225 event
= fExperiment
.getNextEvent(context
);
226 assertEquals("Event timestamp", 1000, event
.getTimestamp().getValue());
227 assertEquals("Event rank", 1000, context
.getRank());
229 // Position trace at event rank 1001
230 tmpContext
= fExperiment
.seekEvent(new TmfTimestamp(1002, SCALE
, 0));
231 context
= fExperiment
.seekLocation(tmpContext
.getLocation());
232 assertEquals("Event rank", 1001, context
.getRank());
234 event
= fExperiment
.parseEvent(context
);
235 assertEquals("Event timestamp", 1002, event
.getTimestamp().getValue());
236 assertEquals("Event rank", 1001, context
.getRank());
238 event
= fExperiment
.getNextEvent(context
);
239 assertEquals("Event timestamp", 1002, event
.getTimestamp().getValue());
240 assertEquals("Event rank", 1002, context
.getRank());
242 // Position trace at event rank 4500
243 tmpContext
= fExperiment
.seekEvent(new TmfTimestamp(4501, SCALE
, 0));
244 context
= fExperiment
.seekLocation(tmpContext
.getLocation());
245 assertEquals("Event rank", 4500, context
.getRank());
247 event
= fExperiment
.parseEvent(context
);
248 assertEquals("Event timestamp", 4501, event
.getTimestamp().getValue());
249 assertEquals("Event rank", 4500, context
.getRank());
251 event
= fExperiment
.getNextEvent(context
);
252 assertEquals("Event timestamp", 4501, event
.getTimestamp().getValue());
253 assertEquals("Event rank", 4501, context
.getRank());
256 public void testSeekLocationOutOfScope() throws Exception
{
258 // Position trace at beginning
259 TmfContext tmpContext
= fExperiment
.seekLocation(null);
260 final TmfContext context
= fExperiment
.seekLocation(tmpContext
.getLocation());
261 assertEquals("Event rank", 0, context
.getRank());
263 ITmfEvent event
= fExperiment
.parseEvent(context
);
264 assertEquals("Event timestamp", 1, event
.getTimestamp().getValue());
265 assertEquals("Event rank", 0, context
.getRank());
267 event
= fExperiment
.getNextEvent(context
);
268 assertEquals("Event timestamp", 1, event
.getTimestamp().getValue());
269 assertEquals("Event rank", 1, context
.getRank());
271 // Position trace at event passed the end
272 tmpContext
= fExperiment
.seekEvent(new TmfTimestamp(NB_EVENTS
+ 1, SCALE
, 0));
273 assertEquals("Event location", null, tmpContext
.getLocation());
274 assertEquals("Event rank", ITmfContext
.UNKNOWN_RANK
, tmpContext
.getRank());
277 // ------------------------------------------------------------------------
278 // seekEvent on timestamp
279 // ------------------------------------------------------------------------
281 public void testSeekEventOnTimestampOnCacheBoundary() throws Exception
{
283 // Position trace at event rank 0
284 TmfContext context
= fExperiment
.seekEvent(new TmfTimestamp(1, SCALE
, 0));
285 assertEquals("Event rank", 0, context
.getRank());
287 ITmfEvent event
= fExperiment
.parseEvent(context
);
288 assertEquals("Event timestamp", 1, event
.getTimestamp().getValue());
289 assertEquals("Event rank", 0, context
.getRank());
291 event
= fExperiment
.getNextEvent(context
);
292 assertEquals("Event timestamp", 1, event
.getTimestamp().getValue());
293 assertEquals("Event rank", 1, context
.getRank());
295 // Position trace at event rank 1000
296 context
= fExperiment
.seekEvent(new TmfTimestamp(1001, SCALE
, 0));
297 assertEquals("Event rank", 1000, context
.getRank());
299 event
= fExperiment
.parseEvent(context
);
300 assertEquals("Event timestamp", 1001, event
.getTimestamp().getValue());
301 assertEquals("Event rank", 1000, context
.getRank());
303 event
= fExperiment
.getNextEvent(context
);
304 assertEquals("Event timestamp", 1001, event
.getTimestamp().getValue());
305 assertEquals("Event rank", 1001, context
.getRank());
307 // Position trace at event rank 4000
308 context
= fExperiment
.seekEvent(new TmfTimestamp(4001, SCALE
, 0));
309 assertEquals("Event rank", 4000, context
.getRank());
311 event
= fExperiment
.parseEvent(context
);
312 assertEquals("Event timestamp", 4001, event
.getTimestamp().getValue());
313 assertEquals("Event rank", 4000, context
.getRank());
315 event
= fExperiment
.getNextEvent(context
);
316 assertEquals("Event timestamp", 4001, event
.getTimestamp().getValue());
317 assertEquals("Event rank", 4001, context
.getRank());
320 public void testSeekEventOnTimestampNotOnCacheBoundary() throws Exception
{
322 // Position trace at event rank 1
323 TmfContext context
= fExperiment
.seekEvent(new TmfTimestamp(2, SCALE
, 0));
324 assertEquals("Event rank", 1, context
.getRank());
326 ITmfEvent event
= fExperiment
.parseEvent(context
);
327 assertEquals("Event timestamp", 2, event
.getTimestamp().getValue());
328 assertEquals("Event rank", 1, context
.getRank());
330 event
= fExperiment
.getNextEvent(context
);
331 assertEquals("Event timestamp", 2, event
.getTimestamp().getValue());
332 assertEquals("Event rank", 2, context
.getRank());
334 // Position trace at event rank 9
335 context
= fExperiment
.seekEvent(new TmfTimestamp(10, SCALE
, 0));
336 assertEquals("Event rank", 9, context
.getRank());
338 event
= fExperiment
.parseEvent(context
);
339 assertEquals("Event timestamp", 10, event
.getTimestamp().getValue());
340 assertEquals("Event rank", 9, context
.getRank());
342 event
= fExperiment
.getNextEvent(context
);
343 assertEquals("Event timestamp", 10, event
.getTimestamp().getValue());
344 assertEquals("Event rank", 10, context
.getRank());
346 // Position trace at event rank 999
347 context
= fExperiment
.seekEvent(new TmfTimestamp(1000, SCALE
, 0));
348 assertEquals("Event rank", 999, context
.getRank());
350 event
= fExperiment
.parseEvent(context
);
351 assertEquals("Event timestamp", 1000, event
.getTimestamp().getValue());
352 assertEquals("Event rank", 999, context
.getRank());
354 event
= fExperiment
.getNextEvent(context
);
355 assertEquals("Event timestamp", 1000, event
.getTimestamp().getValue());
356 assertEquals("Event rank", 1000, context
.getRank());
358 // Position trace at event rank 1001
359 context
= fExperiment
.seekEvent(new TmfTimestamp(1002, SCALE
, 0));
360 assertEquals("Event rank", 1001, context
.getRank());
362 event
= fExperiment
.parseEvent(context
);
363 assertEquals("Event timestamp", 1002, event
.getTimestamp().getValue());
364 assertEquals("Event rank", 1001, context
.getRank());
366 event
= fExperiment
.getNextEvent(context
);
367 assertEquals("Event timestamp", 1002, event
.getTimestamp().getValue());
368 assertEquals("Event rank", 1002, context
.getRank());
370 // Position trace at event rank 4500
371 context
= fExperiment
.seekEvent(new TmfTimestamp(4501, SCALE
, 0));
372 assertEquals("Event rank", 4500, context
.getRank());
374 event
= fExperiment
.parseEvent(context
);
375 assertEquals("Event timestamp", 4501, event
.getTimestamp().getValue());
376 assertEquals("Event rank", 4500, context
.getRank());
378 event
= fExperiment
.getNextEvent(context
);
379 assertEquals("Event timestamp", 4501, event
.getTimestamp().getValue());
380 assertEquals("Event rank", 4501, context
.getRank());
383 public void testSeekEventOnTimestampOutOfScope() throws Exception
{
385 // Position trace at beginning
386 TmfContext context
= fExperiment
.seekEvent(new TmfTimestamp(-1, SCALE
, 0));
387 assertEquals("Event rank", 0, context
.getRank());
389 ITmfEvent event
= fExperiment
.parseEvent(context
);
390 assertEquals("Event timestamp", 1, event
.getTimestamp().getValue());
391 assertEquals("Event rank", 0, context
.getRank());
393 event
= fExperiment
.getNextEvent(context
);
394 assertEquals("Event timestamp", 1, event
.getTimestamp().getValue());
395 assertEquals("Event rank", 1, context
.getRank());
397 // Position trace at event passed the end
398 context
= fExperiment
.seekEvent(new TmfTimestamp(NB_EVENTS
+ 1, SCALE
, 0));
399 assertEquals("Event location", null, context
.getLocation());
400 assertEquals("Event rank", ITmfContext
.UNKNOWN_RANK
, context
.getRank());
403 // ------------------------------------------------------------------------
405 // ------------------------------------------------------------------------
407 public void testSeekOnRankOnCacheBoundary() throws Exception
{
409 // On lower bound, returns the first event (ts = 1)
410 TmfContext context
= fExperiment
.seekEvent(0);
411 assertEquals("Event rank", 0, context
.getRank());
413 ITmfEvent event
= fExperiment
.parseEvent(context
);
414 assertEquals("Event timestamp", 1, event
.getTimestamp().getValue());
415 assertEquals("Event rank", 0, context
.getRank());
417 event
= fExperiment
.getNextEvent(context
);
418 assertEquals("Event timestamp", 1, event
.getTimestamp().getValue());
419 assertEquals("Event rank", 1, context
.getRank());
421 // Position trace at event rank 1000
422 context
= fExperiment
.seekEvent(1000);
423 assertEquals("Event rank", 1000, context
.getRank());
425 event
= fExperiment
.parseEvent(context
);
426 assertEquals("Event timestamp", 1001, event
.getTimestamp().getValue());
427 assertEquals("Event rank", 1000, context
.getRank());
429 event
= fExperiment
.getNextEvent(context
);
430 assertEquals("Event timestamp", 1001, event
.getTimestamp().getValue());
431 assertEquals("Event rank", 1001, context
.getRank());
433 // Position trace at event rank 4000
434 context
= fExperiment
.seekEvent(4000);
435 assertEquals("Event rank", 4000, context
.getRank());
437 event
= fExperiment
.parseEvent(context
);
438 assertEquals("Event timestamp", 4001, event
.getTimestamp().getValue());
439 assertEquals("Event rank", 4000, context
.getRank());
441 event
= fExperiment
.getNextEvent(context
);
442 assertEquals("Event timestamp", 4001, event
.getTimestamp().getValue());
443 assertEquals("Event rank", 4001, context
.getRank());
446 public void testSeekOnRankNotOnCacheBoundary() throws Exception
{
448 // Position trace at event rank 9
449 TmfContext context
= fExperiment
.seekEvent(9);
450 assertEquals("Event rank", 9, context
.getRank());
452 ITmfEvent event
= fExperiment
.parseEvent(context
);
453 assertEquals("Event timestamp", 10, event
.getTimestamp().getValue());
454 assertEquals("Event rank", 9, context
.getRank());
456 event
= fExperiment
.getNextEvent(context
);
457 assertEquals("Event timestamp", 10, event
.getTimestamp().getValue());
458 assertEquals("Event rank", 10, context
.getRank());
460 // Position trace at event rank 999
461 context
= fExperiment
.seekEvent(999);
462 assertEquals("Event rank", 999, context
.getRank());
464 event
= fExperiment
.parseEvent(context
);
465 assertEquals("Event timestamp", 1000, event
.getTimestamp().getValue());
466 assertEquals("Event rank", 999, context
.getRank());
468 event
= fExperiment
.getNextEvent(context
);
469 assertEquals("Event timestamp", 1000, event
.getTimestamp().getValue());
470 assertEquals("Event rank", 1000, context
.getRank());
472 // Position trace at event rank 1001
473 context
= fExperiment
.seekEvent(1001);
474 assertEquals("Event rank", 1001, context
.getRank());
476 event
= fExperiment
.parseEvent(context
);
477 assertEquals("Event timestamp", 1002, event
.getTimestamp().getValue());
478 assertEquals("Event rank", 1001, context
.getRank());
480 event
= fExperiment
.getNextEvent(context
);
481 assertEquals("Event timestamp", 1002, event
.getTimestamp().getValue());
482 assertEquals("Event rank", 1002, context
.getRank());
484 // Position trace at event rank 4500
485 context
= fExperiment
.seekEvent(4500);
486 assertEquals("Event rank", 4500, context
.getRank());
488 event
= fExperiment
.parseEvent(context
);
489 assertEquals("Event timestamp", 4501, event
.getTimestamp().getValue());
490 assertEquals("Event rank", 4500, context
.getRank());
492 event
= fExperiment
.getNextEvent(context
);
493 assertEquals("Event timestamp", 4501, event
.getTimestamp().getValue());
494 assertEquals("Event rank", 4501, context
.getRank());
497 public void testSeekEventOnRankOutOfScope() throws Exception
{
499 // Position trace at beginning
500 TmfContext context
= fExperiment
.seekEvent(-1);
501 assertEquals("Event rank", 0, context
.getRank());
503 ITmfEvent event
= fExperiment
.parseEvent(context
);
504 assertEquals("Event timestamp", 1, event
.getTimestamp().getValue());
505 assertEquals("Event rank", 0, context
.getRank());
507 event
= fExperiment
.getNextEvent(context
);
508 assertEquals("Event timestamp", 1, event
.getTimestamp().getValue());
509 assertEquals("Event rank", 1, context
.getRank());
511 // Position trace at event passed the end
512 context
= fExperiment
.seekEvent(NB_EVENTS
);
513 assertEquals("Event location", null, context
.getLocation());
514 assertEquals("Event rank", ITmfContext
.UNKNOWN_RANK
, context
.getRank());
517 // ------------------------------------------------------------------------
518 // parseEvent - make sure parseEvent doesn't update the context
519 // Note: This test is essentially the same as the one from TmfTraceTest
520 // ------------------------------------------------------------------------
522 public void testParseEvent() throws Exception
{
524 final int NB_READS
= 20;
526 // On lower bound, returns the first event (ts = 1)
527 final TmfContext context
= fExperiment
.seekEvent(new TmfTimestamp(0, SCALE
, 0));
530 ITmfEvent event
= null;;
531 for (int i
= 0; i
< NB_READS
; i
++) {
532 event
= fExperiment
.getNextEvent(context
);
533 assertEquals("Event timestamp", i
+ 1, event
.getTimestamp().getValue());
534 assertEquals("Event rank", i
+ 1, context
.getRank());
537 // Make sure we stay positioned
538 event
= fExperiment
.parseEvent(context
);
539 assertEquals("Event timestamp", NB_READS
+ 1, event
.getTimestamp().getValue());
540 assertEquals("Event rank", NB_READS
, context
.getRank());
543 // ------------------------------------------------------------------------
544 // getNextEvent - updates the context
545 // ------------------------------------------------------------------------
547 public void testGetNextEvent() throws Exception
{
549 // On lower bound, returns the first event (ts = 0)
550 final TmfContext context
= fExperiment
.seekEvent(new TmfTimestamp(0, SCALE
, 0));
551 ITmfEvent event
= fExperiment
.getNextEvent(context
);
552 assertEquals("Event timestamp", 1, event
.getTimestamp().getValue());
554 for (int i
= 2; i
< 20; i
++) {
555 event
= fExperiment
.getNextEvent(context
);
556 assertEquals("Event timestamp", i
, event
.getTimestamp().getValue());
560 // ------------------------------------------------------------------------
562 // ------------------------------------------------------------------------
564 public void testProcessRequestForNbEvents() throws Exception
{
566 final int blockSize
= 100;
567 final int nbEvents
= 1000;
568 final Vector
<TmfEvent
> requestedEvents
= new Vector
<TmfEvent
>();
570 final TmfTimeRange range
= new TmfTimeRange(TmfTimestamp
.BIG_BANG
, TmfTimestamp
.BIG_CRUNCH
);
571 final TmfEventRequest
<TmfEvent
> request
= new TmfEventRequest
<TmfEvent
>(TmfEvent
.class, range
, nbEvents
, blockSize
) {
573 public void handleData(final TmfEvent event
) {
574 super.handleData(event
);
575 requestedEvents
.add(event
);
578 fExperiment
.sendRequest(request
);
579 request
.waitForCompletion();
581 assertEquals("nbEvents", nbEvents
, requestedEvents
.size());
582 assertTrue("isCompleted", request
.isCompleted());
583 assertFalse("isCancelled", request
.isCancelled());
585 // Ensure that we have distinct events.
586 // Don't go overboard: we are not validating the stub!
587 for (int i
= 0; i
< nbEvents
; i
++) {
588 assertEquals("Distinct events", i
+1, requestedEvents
.get(i
).getTimestamp().getValue());
592 public void testProcessRequestForNbEvents2() throws Exception
{
594 final int blockSize
= 2 * NB_EVENTS
;
595 final int nbEvents
= 1000;
596 final Vector
<TmfEvent
> requestedEvents
= new Vector
<TmfEvent
>();
598 final TmfTimeRange range
= new TmfTimeRange(TmfTimestamp
.BIG_BANG
, TmfTimestamp
.BIG_CRUNCH
);
599 final TmfEventRequest
<TmfEvent
> request
= new TmfEventRequest
<TmfEvent
>(TmfEvent
.class, range
, nbEvents
, blockSize
) {
601 public void handleData(final TmfEvent event
) {
602 super.handleData(event
);
603 requestedEvents
.add(event
);
606 fExperiment
.sendRequest(request
);
607 request
.waitForCompletion();
609 assertEquals("nbEvents", nbEvents
, requestedEvents
.size());
610 assertTrue("isCompleted", request
.isCompleted());
611 assertFalse("isCancelled", request
.isCancelled());
613 // Ensure that we have distinct events.
614 // Don't go overboard: we are not validating the stub!
615 for (int i
= 0; i
< nbEvents
; i
++) {
616 assertEquals("Distinct events", i
+1, requestedEvents
.get(i
).getTimestamp().getValue());
620 public void testProcessRequestForAllEvents() throws Exception
{
622 final int nbEvents
= TmfEventRequest
.ALL_DATA
;
623 final int blockSize
= 1;
624 final Vector
<TmfEvent
> requestedEvents
= new Vector
<TmfEvent
>();
625 final long nbExpectedEvents
= NB_EVENTS
;
627 final TmfTimeRange range
= new TmfTimeRange(TmfTimestamp
.BIG_BANG
, TmfTimestamp
.BIG_CRUNCH
);
628 final TmfEventRequest
<TmfEvent
> request
= new TmfEventRequest
<TmfEvent
>(TmfEvent
.class, range
, nbEvents
, blockSize
) {
630 public void handleData(final TmfEvent event
) {
631 super.handleData(event
);
632 requestedEvents
.add(event
);
635 fExperiment
.sendRequest(request
);
636 request
.waitForCompletion();
638 assertEquals("nbEvents", nbExpectedEvents
, requestedEvents
.size());
639 assertTrue("isCompleted", request
.isCompleted());
640 assertFalse("isCancelled", request
.isCancelled());
642 // Ensure that we have distinct events.
643 // Don't go overboard: we are not validating the stub!
644 for (int i
= 0; i
< nbExpectedEvents
; i
++) {
645 assertEquals("Distinct events", i
+1, requestedEvents
.get(i
).getTimestamp().getValue());
649 // ------------------------------------------------------------------------
651 // ------------------------------------------------------------------------
653 public void testCancel() throws Exception
{
655 final int nbEvents
= NB_EVENTS
;
656 final int blockSize
= BLOCK_SIZE
;
657 final Vector
<TmfEvent
> requestedEvents
= new Vector
<TmfEvent
>();
659 final TmfTimeRange range
= new TmfTimeRange(TmfTimestamp
.BIG_BANG
, TmfTimestamp
.BIG_CRUNCH
);
660 final TmfEventRequest
<TmfEvent
> request
= new TmfEventRequest
<TmfEvent
>(TmfEvent
.class, range
, nbEvents
, blockSize
) {
663 public void handleData(final TmfEvent event
) {
664 super.handleData(event
);
665 requestedEvents
.add(event
);
666 if (++nbRead
== blockSize
) {
671 public void handleCancel() {
672 if (requestedEvents
.size() < blockSize
) {
673 System
.out
.println("aie");
677 fExperiment
.sendRequest(request
);
678 request
.waitForCompletion();
680 assertEquals("nbEvents", blockSize
, requestedEvents
.size());
681 assertTrue("isCompleted", request
.isCompleted());
682 assertTrue("isCancelled", request
.isCancelled());
685 // ------------------------------------------------------------------------
687 // ------------------------------------------------------------------------
689 // public void testGetRank() throws Exception {
691 // assertEquals("getRank", 0, fExperiment.getRank(new TmfTimestamp()));
692 // assertEquals("getRank", 0, fExperiment.getRank(new TmfTimestamp( 1, (byte) -3)));
693 // assertEquals("getRank", 10, fExperiment.getRank(new TmfTimestamp( 11, (byte) -3)));
694 // assertEquals("getRank", 100, fExperiment.getRank(new TmfTimestamp( 101, (byte) -3)));
695 // assertEquals("getRank", 1000, fExperiment.getRank(new TmfTimestamp(1001, (byte) -3)));
696 // assertEquals("getRank", 2000, fExperiment.getRank(new TmfTimestamp(2001, (byte) -3)));
697 // assertEquals("getRank", 2500, fExperiment.getRank(new TmfTimestamp(2501, (byte) -3)));
700 // ------------------------------------------------------------------------
702 // ------------------------------------------------------------------------
704 public void testGetTimestamp() throws Exception
{
706 assertTrue("getTimestamp", fExperiment
.getTimestamp( 0).equals(new TmfTimestamp( 1, (byte) -3)));
707 assertTrue("getTimestamp", fExperiment
.getTimestamp( 10).equals(new TmfTimestamp( 11, (byte) -3)));
708 assertTrue("getTimestamp", fExperiment
.getTimestamp( 100).equals(new TmfTimestamp( 101, (byte) -3)));
709 assertTrue("getTimestamp", fExperiment
.getTimestamp(1000).equals(new TmfTimestamp(1001, (byte) -3)));
710 assertTrue("getTimestamp", fExperiment
.getTimestamp(2000).equals(new TmfTimestamp(2001, (byte) -3)));
711 assertTrue("getTimestamp", fExperiment
.getTimestamp(2500).equals(new TmfTimestamp(2501, (byte) -3)));