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
.stubs
.trace
.TmfTraceStub
;
40 * <b><u>TmfExperimentTest</u></b>
42 * TODO: Implement me. Please.
44 @SuppressWarnings("nls")
45 public class TmfExperimentTest
extends TestCase
{
47 private static final String DIRECTORY
= "testfiles";
48 private static final String TEST_STREAM
= "A-Test-10K";
49 private static final String EXPERIMENT
= "MyExperiment";
50 private static int NB_EVENTS
= 10000;
51 private static int fDefaultBlockSize
= 1000;
53 private static ITmfTrace
<?
>[] fTraces
;
54 private static TmfExperiment
<TmfEvent
> fExperiment
;
56 private static byte SCALE
= (byte) -3;
58 // ------------------------------------------------------------------------
60 // ------------------------------------------------------------------------
62 private synchronized static ITmfTrace
<?
>[] setupTrace(String path
) {
63 if (fTraces
== null) {
64 fTraces
= new ITmfTrace
[1];
66 URL location
= FileLocator
.find(TmfCoreTestPlugin
.getDefault().getBundle(), new Path(path
), null);
67 File test
= new File(FileLocator
.toFileURL(location
).toURI());
68 TmfTraceStub trace
= new TmfTraceStub(test
.getPath(), true);
70 } catch (URISyntaxException e
) {
72 } catch (IOException e
) {
79 @SuppressWarnings("unchecked")
80 private synchronized static void setupExperiment() {
81 if (fExperiment
== null) {
82 fExperiment
= new TmfExperiment
<TmfEvent
>(TmfEvent
.class, EXPERIMENT
, (ITmfTrace
<TmfEvent
>[]) fTraces
, TmfTimestamp
.Zero
, 1000, true);
86 public TmfExperimentTest(String name
) throws Exception
{
91 protected void setUp() throws Exception
{
93 setupTrace(DIRECTORY
+ File
.separator
+ TEST_STREAM
);
98 protected void tearDown() throws Exception
{
102 // ------------------------------------------------------------------------
104 // ------------------------------------------------------------------------
106 public void testBasicTmfExperimentConstructor() {
108 assertEquals("GetId", EXPERIMENT
, fExperiment
.getName());
109 assertEquals("GetEpoch", TmfTimestamp
.Zero
, fExperiment
.getEpoch());
110 assertEquals("GetNbEvents", NB_EVENTS
, fExperiment
.getNbEvents());
112 long nbTraceEvents
= fExperiment
.getTraces()[0].getNbEvents();
113 assertEquals("GetNbEvents", NB_EVENTS
, nbTraceEvents
);
115 TmfTimeRange timeRange
= fExperiment
.getTimeRange();
116 assertEquals("getStartTime", 1, timeRange
.getStartTime().getValue());
117 assertEquals("getEndTime", NB_EVENTS
, timeRange
.getEndTime().getValue());
120 // ------------------------------------------------------------------------
121 // Verify checkpoints
122 // ------------------------------------------------------------------------
124 public void testValidateCheckpoints() throws Exception
{
126 Vector
<TmfCheckpoint
> checkpoints
= fExperiment
.getCheckpoints();
127 int pageSize
= fExperiment
.getCacheSize();
128 assertTrue("Checkpoints exist", checkpoints
!= null);
130 // Validate that each checkpoint points to the right event
131 for (int i
= 0; i
< checkpoints
.size(); i
++) {
132 TmfCheckpoint checkpoint
= checkpoints
.get(i
);
133 TmfExperimentContext context
= fExperiment
.seekLocation(checkpoint
.getLocation());
134 ITmfEvent event
= fExperiment
.parseEvent(context
);
135 assertEquals("Event rank", i
* pageSize
, context
.getRank());
136 assertTrue("Timestamp", (checkpoint
.getTimestamp().compareTo(event
.getTimestamp(), false) == 0));
140 // ------------------------------------------------------------------------
142 // ------------------------------------------------------------------------
144 public void testSeekLocationOnCacheBoundary() throws Exception
{
146 // Position trace at event rank 0
147 TmfContext context
= fExperiment
.seekLocation(null);
148 assertEquals("Event rank", 0, context
.getRank());
150 ITmfEvent event
= fExperiment
.parseEvent(context
);
151 assertEquals("Event timestamp", 1, event
.getTimestamp().getValue());
152 assertEquals("Event rank", 0, context
.getRank());
154 event
= fExperiment
.getNextEvent(context
);
155 assertEquals("Event timestamp", 1, event
.getTimestamp().getValue());
156 assertEquals("Event rank", 1, context
.getRank());
158 event
= fExperiment
.getNextEvent(context
);
159 assertEquals("Event timestamp", 2, event
.getTimestamp().getValue());
160 assertEquals("Event rank", 2, context
.getRank());
162 // Position trace at event rank 1000
163 TmfContext tmpContext
= fExperiment
.seekEvent(new TmfTimestamp(1001, SCALE
, 0));
164 context
= fExperiment
.seekLocation(tmpContext
.getLocation());
165 assertEquals("Event rank", 1000, context
.getRank());
167 event
= fExperiment
.parseEvent(context
);
168 assertEquals("Event timestamp", 1001, event
.getTimestamp().getValue());
169 assertEquals("Event rank", 1000, context
.getRank());
171 event
= fExperiment
.getNextEvent(context
);
172 assertEquals("Event timestamp", 1001, event
.getTimestamp().getValue());
173 assertEquals("Event rank", 1001, context
.getRank());
175 event
= fExperiment
.getNextEvent(context
);
176 assertEquals("Event timestamp", 1002, event
.getTimestamp().getValue());
177 assertEquals("Event rank", 1002, context
.getRank());
179 // Position trace at event rank 4000
180 tmpContext
= fExperiment
.seekEvent(new TmfTimestamp(4001, SCALE
, 0));
181 context
= fExperiment
.seekLocation(tmpContext
.getLocation());
182 assertEquals("Event rank", 4000, context
.getRank());
184 event
= fExperiment
.parseEvent(context
);
185 assertEquals("Event timestamp", 4001, event
.getTimestamp().getValue());
186 assertEquals("Event rank", 4000, context
.getRank());
188 event
= fExperiment
.getNextEvent(context
);
189 assertEquals("Event timestamp", 4001, event
.getTimestamp().getValue());
190 assertEquals("Event rank", 4001, context
.getRank());
192 event
= fExperiment
.getNextEvent(context
);
193 assertEquals("Event timestamp", 4002, event
.getTimestamp().getValue());
194 assertEquals("Event rank", 4002, context
.getRank());
197 public void testSeekLocationNotOnCacheBoundary() throws Exception
{
199 // Position trace at event rank 9
200 TmfContext tmpContext
= fExperiment
.seekEvent(new TmfTimestamp(10, SCALE
, 0));
201 TmfContext context
= fExperiment
.seekLocation(tmpContext
.getLocation());
202 assertEquals("Event rank", 9, context
.getRank());
204 ITmfEvent event
= fExperiment
.parseEvent(context
);
205 assertEquals("Event timestamp", 10, event
.getTimestamp().getValue());
206 assertEquals("Event rank", 9, context
.getRank());
208 event
= fExperiment
.getNextEvent(context
);
209 assertEquals("Event timestamp", 10, event
.getTimestamp().getValue());
210 assertEquals("Event rank", 10, context
.getRank());
212 // Position trace at event rank 999
213 tmpContext
= fExperiment
.seekEvent(new TmfTimestamp(1000, SCALE
, 0));
214 context
= fExperiment
.seekLocation(tmpContext
.getLocation());
215 assertEquals("Event rank", 999, context
.getRank());
217 event
= fExperiment
.parseEvent(context
);
218 assertEquals("Event timestamp", 1000, event
.getTimestamp().getValue());
219 assertEquals("Event rank", 999, context
.getRank());
221 event
= fExperiment
.getNextEvent(context
);
222 assertEquals("Event timestamp", 1000, event
.getTimestamp().getValue());
223 assertEquals("Event rank", 1000, context
.getRank());
225 // Position trace at event rank 1001
226 tmpContext
= fExperiment
.seekEvent(new TmfTimestamp(1002, SCALE
, 0));
227 context
= fExperiment
.seekLocation(tmpContext
.getLocation());
228 assertEquals("Event rank", 1001, context
.getRank());
230 event
= fExperiment
.parseEvent(context
);
231 assertEquals("Event timestamp", 1002, event
.getTimestamp().getValue());
232 assertEquals("Event rank", 1001, context
.getRank());
234 event
= fExperiment
.getNextEvent(context
);
235 assertEquals("Event timestamp", 1002, event
.getTimestamp().getValue());
236 assertEquals("Event rank", 1002, context
.getRank());
238 // Position trace at event rank 4500
239 tmpContext
= fExperiment
.seekEvent(new TmfTimestamp(4501, SCALE
, 0));
240 context
= fExperiment
.seekLocation(tmpContext
.getLocation());
241 assertEquals("Event rank", 4500, context
.getRank());
243 event
= fExperiment
.parseEvent(context
);
244 assertEquals("Event timestamp", 4501, event
.getTimestamp().getValue());
245 assertEquals("Event rank", 4500, context
.getRank());
247 event
= fExperiment
.getNextEvent(context
);
248 assertEquals("Event timestamp", 4501, event
.getTimestamp().getValue());
249 assertEquals("Event rank", 4501, context
.getRank());
252 public void testSeekLocationOutOfScope() throws Exception
{
254 // Position trace at beginning
255 TmfContext tmpContext
= fExperiment
.seekLocation(null);
256 TmfContext context
= fExperiment
.seekLocation(tmpContext
.getLocation());
257 assertEquals("Event rank", 0, context
.getRank());
259 ITmfEvent event
= fExperiment
.parseEvent(context
);
260 assertEquals("Event timestamp", 1, event
.getTimestamp().getValue());
261 assertEquals("Event rank", 0, context
.getRank());
263 event
= fExperiment
.getNextEvent(context
);
264 assertEquals("Event timestamp", 1, event
.getTimestamp().getValue());
265 assertEquals("Event rank", 1, context
.getRank());
267 // Position trace at event passed the end
268 tmpContext
= fExperiment
.seekEvent(new TmfTimestamp(NB_EVENTS
+ 1, SCALE
, 0));
269 assertEquals("Event location", null, tmpContext
.getLocation());
270 assertEquals("Event rank", ITmfContext
.UNKNOWN_RANK
, tmpContext
.getRank());
273 // ------------------------------------------------------------------------
274 // seekEvent on timestamp
275 // ------------------------------------------------------------------------
277 public void testSeekEventOnTimestampOnCacheBoundary() throws Exception
{
279 // Position trace at event rank 0
280 TmfContext context
= fExperiment
.seekEvent(new TmfTimestamp(1, SCALE
, 0));
281 assertEquals("Event rank", 0, context
.getRank());
283 ITmfEvent event
= fExperiment
.parseEvent(context
);
284 assertEquals("Event timestamp", 1, event
.getTimestamp().getValue());
285 assertEquals("Event rank", 0, context
.getRank());
287 event
= fExperiment
.getNextEvent(context
);
288 assertEquals("Event timestamp", 1, event
.getTimestamp().getValue());
289 assertEquals("Event rank", 1, context
.getRank());
291 // Position trace at event rank 1000
292 context
= fExperiment
.seekEvent(new TmfTimestamp(1001, SCALE
, 0));
293 assertEquals("Event rank", 1000, context
.getRank());
295 event
= fExperiment
.parseEvent(context
);
296 assertEquals("Event timestamp", 1001, event
.getTimestamp().getValue());
297 assertEquals("Event rank", 1000, context
.getRank());
299 event
= fExperiment
.getNextEvent(context
);
300 assertEquals("Event timestamp", 1001, event
.getTimestamp().getValue());
301 assertEquals("Event rank", 1001, context
.getRank());
303 // Position trace at event rank 4000
304 context
= fExperiment
.seekEvent(new TmfTimestamp(4001, SCALE
, 0));
305 assertEquals("Event rank", 4000, context
.getRank());
307 event
= fExperiment
.parseEvent(context
);
308 assertEquals("Event timestamp", 4001, event
.getTimestamp().getValue());
309 assertEquals("Event rank", 4000, context
.getRank());
311 event
= fExperiment
.getNextEvent(context
);
312 assertEquals("Event timestamp", 4001, event
.getTimestamp().getValue());
313 assertEquals("Event rank", 4001, context
.getRank());
316 public void testSeekEventOnTimestampNotOnCacheBoundary() throws Exception
{
318 // Position trace at event rank 1
319 TmfContext context
= fExperiment
.seekEvent(new TmfTimestamp(2, SCALE
, 0));
320 assertEquals("Event rank", 1, context
.getRank());
322 ITmfEvent event
= fExperiment
.parseEvent(context
);
323 assertEquals("Event timestamp", 2, event
.getTimestamp().getValue());
324 assertEquals("Event rank", 1, context
.getRank());
326 event
= fExperiment
.getNextEvent(context
);
327 assertEquals("Event timestamp", 2, event
.getTimestamp().getValue());
328 assertEquals("Event rank", 2, context
.getRank());
330 // Position trace at event rank 9
331 context
= fExperiment
.seekEvent(new TmfTimestamp(10, SCALE
, 0));
332 assertEquals("Event rank", 9, context
.getRank());
334 event
= fExperiment
.parseEvent(context
);
335 assertEquals("Event timestamp", 10, event
.getTimestamp().getValue());
336 assertEquals("Event rank", 9, context
.getRank());
338 event
= fExperiment
.getNextEvent(context
);
339 assertEquals("Event timestamp", 10, event
.getTimestamp().getValue());
340 assertEquals("Event rank", 10, context
.getRank());
342 // Position trace at event rank 999
343 context
= fExperiment
.seekEvent(new TmfTimestamp(1000, SCALE
, 0));
344 assertEquals("Event rank", 999, context
.getRank());
346 event
= fExperiment
.parseEvent(context
);
347 assertEquals("Event timestamp", 1000, event
.getTimestamp().getValue());
348 assertEquals("Event rank", 999, context
.getRank());
350 event
= fExperiment
.getNextEvent(context
);
351 assertEquals("Event timestamp", 1000, event
.getTimestamp().getValue());
352 assertEquals("Event rank", 1000, context
.getRank());
354 // Position trace at event rank 1001
355 context
= fExperiment
.seekEvent(new TmfTimestamp(1002, SCALE
, 0));
356 assertEquals("Event rank", 1001, context
.getRank());
358 event
= fExperiment
.parseEvent(context
);
359 assertEquals("Event timestamp", 1002, event
.getTimestamp().getValue());
360 assertEquals("Event rank", 1001, context
.getRank());
362 event
= fExperiment
.getNextEvent(context
);
363 assertEquals("Event timestamp", 1002, event
.getTimestamp().getValue());
364 assertEquals("Event rank", 1002, context
.getRank());
366 // Position trace at event rank 4500
367 context
= fExperiment
.seekEvent(new TmfTimestamp(4501, SCALE
, 0));
368 assertEquals("Event rank", 4500, context
.getRank());
370 event
= fExperiment
.parseEvent(context
);
371 assertEquals("Event timestamp", 4501, event
.getTimestamp().getValue());
372 assertEquals("Event rank", 4500, context
.getRank());
374 event
= fExperiment
.getNextEvent(context
);
375 assertEquals("Event timestamp", 4501, event
.getTimestamp().getValue());
376 assertEquals("Event rank", 4501, context
.getRank());
379 public void testSeekEventOnTimestampoutOfScope() throws Exception
{
381 // Position trace at beginning
382 TmfContext context
= fExperiment
.seekEvent(new TmfTimestamp(-1, SCALE
, 0));
383 assertEquals("Event rank", 0, context
.getRank());
385 ITmfEvent event
= fExperiment
.parseEvent(context
);
386 assertEquals("Event timestamp", 1, event
.getTimestamp().getValue());
387 assertEquals("Event rank", 0, context
.getRank());
389 event
= fExperiment
.getNextEvent(context
);
390 assertEquals("Event timestamp", 1, event
.getTimestamp().getValue());
391 assertEquals("Event rank", 1, context
.getRank());
393 // Position trace at event passed the end
394 context
= fExperiment
.seekEvent(new TmfTimestamp(NB_EVENTS
+ 1, SCALE
, 0));
395 assertEquals("Event location", null, context
.getLocation());
396 assertEquals("Event rank", ITmfContext
.UNKNOWN_RANK
, context
.getRank());
399 // ------------------------------------------------------------------------
401 // ------------------------------------------------------------------------
403 public void testSeekOnRankOnCacheBoundary() throws Exception
{
405 // On lower bound, returns the first event (ts = 1)
406 TmfContext context
= fExperiment
.seekEvent(0);
407 assertEquals("Event rank", 0, context
.getRank());
409 ITmfEvent event
= fExperiment
.parseEvent(context
);
410 assertEquals("Event timestamp", 1, event
.getTimestamp().getValue());
411 assertEquals("Event rank", 0, context
.getRank());
413 event
= fExperiment
.getNextEvent(context
);
414 assertEquals("Event timestamp", 1, event
.getTimestamp().getValue());
415 assertEquals("Event rank", 1, context
.getRank());
417 // Position trace at event rank 1000
418 context
= fExperiment
.seekEvent(1000);
419 assertEquals("Event rank", 1000, context
.getRank());
421 event
= fExperiment
.parseEvent(context
);
422 assertEquals("Event timestamp", 1001, event
.getTimestamp().getValue());
423 assertEquals("Event rank", 1000, context
.getRank());
425 event
= fExperiment
.getNextEvent(context
);
426 assertEquals("Event timestamp", 1001, event
.getTimestamp().getValue());
427 assertEquals("Event rank", 1001, context
.getRank());
429 // Position trace at event rank 4000
430 context
= fExperiment
.seekEvent(4000);
431 assertEquals("Event rank", 4000, context
.getRank());
433 event
= fExperiment
.parseEvent(context
);
434 assertEquals("Event timestamp", 4001, event
.getTimestamp().getValue());
435 assertEquals("Event rank", 4000, context
.getRank());
437 event
= fExperiment
.getNextEvent(context
);
438 assertEquals("Event timestamp", 4001, event
.getTimestamp().getValue());
439 assertEquals("Event rank", 4001, context
.getRank());
442 public void testSeekOnRankNotOnCacheBoundary() throws Exception
{
444 // Position trace at event rank 9
445 TmfContext context
= fExperiment
.seekEvent(9);
446 assertEquals("Event rank", 9, context
.getRank());
448 ITmfEvent event
= fExperiment
.parseEvent(context
);
449 assertEquals("Event timestamp", 10, event
.getTimestamp().getValue());
450 assertEquals("Event rank", 9, context
.getRank());
452 event
= fExperiment
.getNextEvent(context
);
453 assertEquals("Event timestamp", 10, event
.getTimestamp().getValue());
454 assertEquals("Event rank", 10, context
.getRank());
456 // Position trace at event rank 999
457 context
= fExperiment
.seekEvent(999);
458 assertEquals("Event rank", 999, context
.getRank());
460 event
= fExperiment
.parseEvent(context
);
461 assertEquals("Event timestamp", 1000, event
.getTimestamp().getValue());
462 assertEquals("Event rank", 999, context
.getRank());
464 event
= fExperiment
.getNextEvent(context
);
465 assertEquals("Event timestamp", 1000, event
.getTimestamp().getValue());
466 assertEquals("Event rank", 1000, context
.getRank());
468 // Position trace at event rank 1001
469 context
= fExperiment
.seekEvent(1001);
470 assertEquals("Event rank", 1001, context
.getRank());
472 event
= fExperiment
.parseEvent(context
);
473 assertEquals("Event timestamp", 1002, event
.getTimestamp().getValue());
474 assertEquals("Event rank", 1001, context
.getRank());
476 event
= fExperiment
.getNextEvent(context
);
477 assertEquals("Event timestamp", 1002, event
.getTimestamp().getValue());
478 assertEquals("Event rank", 1002, context
.getRank());
480 // Position trace at event rank 4500
481 context
= fExperiment
.seekEvent(4500);
482 assertEquals("Event rank", 4500, context
.getRank());
484 event
= fExperiment
.parseEvent(context
);
485 assertEquals("Event timestamp", 4501, event
.getTimestamp().getValue());
486 assertEquals("Event rank", 4500, context
.getRank());
488 event
= fExperiment
.getNextEvent(context
);
489 assertEquals("Event timestamp", 4501, event
.getTimestamp().getValue());
490 assertEquals("Event rank", 4501, context
.getRank());
493 public void testSeekEventOnRankOutOfScope() throws Exception
{
495 // Position trace at beginning
496 TmfContext context
= fExperiment
.seekEvent(-1);
497 assertEquals("Event rank", 0, context
.getRank());
499 ITmfEvent event
= fExperiment
.parseEvent(context
);
500 assertEquals("Event timestamp", 1, event
.getTimestamp().getValue());
501 assertEquals("Event rank", 0, context
.getRank());
503 event
= fExperiment
.getNextEvent(context
);
504 assertEquals("Event timestamp", 1, event
.getTimestamp().getValue());
505 assertEquals("Event rank", 1, context
.getRank());
507 // Position trace at event passed the end
508 context
= fExperiment
.seekEvent(NB_EVENTS
);
509 assertEquals("Event location", null, context
.getLocation());
510 assertEquals("Event rank", ITmfContext
.UNKNOWN_RANK
, context
.getRank());
513 // ------------------------------------------------------------------------
514 // parseEvent - make sure parseEvent doesn't update the context
515 // Note: This test is essentially the same as the one from TmfTraceTest
516 // ------------------------------------------------------------------------
518 public void testParseEvent() throws Exception
{
522 // On lower bound, returns the first event (ts = 1)
523 TmfContext context
= fExperiment
.seekEvent(new TmfTimestamp(0, SCALE
, 0));
526 ITmfEvent event
= null;;
527 for (int i
= 0; i
< NB_READS
; i
++) {
528 event
= fExperiment
.getNextEvent(context
);
529 assertEquals("Event timestamp", i
+ 1, event
.getTimestamp().getValue());
530 assertEquals("Event rank", i
+ 1, context
.getRank());
533 // Make sure we stay positioned
534 event
= fExperiment
.parseEvent(context
);
535 assertEquals("Event timestamp", NB_READS
+ 1, event
.getTimestamp().getValue());
536 assertEquals("Event rank", NB_READS
, context
.getRank());
539 // ------------------------------------------------------------------------
540 // getNextEvent - updates the context
541 // ------------------------------------------------------------------------
543 public void testGetNextEvent() throws Exception
{
545 // On lower bound, returns the first event (ts = 0)
546 TmfContext context
= fExperiment
.seekEvent(new TmfTimestamp(0, SCALE
, 0));
547 ITmfEvent event
= fExperiment
.getNextEvent(context
);
548 assertEquals("Event timestamp", 1, event
.getTimestamp().getValue());
550 for (int i
= 2; i
< 20; i
++) {
551 event
= fExperiment
.getNextEvent(context
);
552 assertEquals("Event timestamp", i
, event
.getTimestamp().getValue());
556 // ------------------------------------------------------------------------
558 // ------------------------------------------------------------------------
560 public void testProcessRequestForNbEvents() throws Exception
{
562 final int blockSize
= 100;
563 final int nbEvents
= 1000;
564 final Vector
<TmfEvent
> requestedEvents
= new Vector
<TmfEvent
>();
566 TmfTimeRange range
= new TmfTimeRange(TmfTimestamp
.BigBang
, TmfTimestamp
.BigCrunch
);
567 final TmfEventRequest
<TmfEvent
> request
= new TmfEventRequest
<TmfEvent
>(TmfEvent
.class, range
, nbEvents
, blockSize
) {
569 public void handleData(TmfEvent event
) {
570 super.handleData(event
);
571 requestedEvents
.add(event
);
574 fExperiment
.sendRequest(request
);
575 request
.waitForCompletion();
577 assertEquals("nbEvents", nbEvents
, requestedEvents
.size());
578 assertTrue("isCompleted", request
.isCompleted());
579 assertFalse("isCancelled", request
.isCancelled());
581 // Ensure that we have distinct events.
582 // Don't go overboard: we are not validating the stub!
583 for (int i
= 0; i
< nbEvents
; i
++) {
584 assertEquals("Distinct events", i
+1, requestedEvents
.get(i
).getTimestamp().getValue());
588 public void testProcessRequestForNbEvents2() throws Exception
{
590 final int blockSize
= 2 * NB_EVENTS
;
591 final int nbEvents
= 1000;
592 final Vector
<TmfEvent
> requestedEvents
= new Vector
<TmfEvent
>();
594 TmfTimeRange range
= new TmfTimeRange(TmfTimestamp
.BigBang
, TmfTimestamp
.BigCrunch
);
595 final TmfEventRequest
<TmfEvent
> request
= new TmfEventRequest
<TmfEvent
>(TmfEvent
.class, range
, nbEvents
, blockSize
) {
597 public void handleData(TmfEvent event
) {
598 super.handleData(event
);
599 requestedEvents
.add(event
);
602 fExperiment
.sendRequest(request
);
603 request
.waitForCompletion();
605 assertEquals("nbEvents", nbEvents
, requestedEvents
.size());
606 assertTrue("isCompleted", request
.isCompleted());
607 assertFalse("isCancelled", request
.isCancelled());
609 // Ensure that we have distinct events.
610 // Don't go overboard: we are not validating the stub!
611 for (int i
= 0; i
< nbEvents
; i
++) {
612 assertEquals("Distinct events", i
+1, requestedEvents
.get(i
).getTimestamp().getValue());
616 public void testProcessRequestForAllEvents() throws Exception
{
618 final int nbEvents
= TmfEventRequest
.ALL_DATA
;
619 final int blockSize
= 1;
620 final Vector
<TmfEvent
> requestedEvents
= new Vector
<TmfEvent
>();
621 long nbExpectedEvents
= NB_EVENTS
;
623 TmfTimeRange range
= new TmfTimeRange(TmfTimestamp
.BigBang
, TmfTimestamp
.BigCrunch
);
624 final TmfEventRequest
<TmfEvent
> request
= new TmfEventRequest
<TmfEvent
>(TmfEvent
.class, range
, nbEvents
, blockSize
) {
626 public void handleData(TmfEvent event
) {
627 super.handleData(event
);
628 requestedEvents
.add(event
);
631 fExperiment
.sendRequest(request
);
632 request
.waitForCompletion();
634 assertEquals("nbEvents", nbExpectedEvents
, requestedEvents
.size());
635 assertTrue("isCompleted", request
.isCompleted());
636 assertFalse("isCancelled", request
.isCancelled());
638 // Ensure that we have distinct events.
639 // Don't go overboard: we are not validating the stub!
640 for (int i
= 0; i
< nbExpectedEvents
; i
++) {
641 assertEquals("Distinct events", i
+1, requestedEvents
.get(i
).getTimestamp().getValue());
645 // ------------------------------------------------------------------------
647 // ------------------------------------------------------------------------
649 public void testCancel() throws Exception
{
651 final int nbEvents
= NB_EVENTS
;
652 final int blockSize
= fDefaultBlockSize
;
653 final Vector
<TmfEvent
> requestedEvents
= new Vector
<TmfEvent
>();
655 TmfTimeRange range
= new TmfTimeRange(TmfTimestamp
.BigBang
, TmfTimestamp
.BigCrunch
);
656 final TmfEventRequest
<TmfEvent
> request
= new TmfEventRequest
<TmfEvent
>(TmfEvent
.class, range
, nbEvents
, blockSize
) {
659 public void handleData(TmfEvent event
) {
660 super.handleData(event
);
661 requestedEvents
.add(event
);
662 if (++nbRead
== blockSize
)
666 public void handleCancel() {
667 if (requestedEvents
.size() < blockSize
) {
668 System
.out
.println("aie");
672 fExperiment
.sendRequest(request
);
673 request
.waitForCompletion();
675 assertEquals("nbEvents", blockSize
, requestedEvents
.size());
676 assertTrue("isCompleted", request
.isCompleted());
677 assertTrue("isCancelled", request
.isCancelled());
680 // ------------------------------------------------------------------------
682 // ------------------------------------------------------------------------
684 public void testGetRank() throws Exception
{
686 assertEquals("getRank", 0, fExperiment
.getRank(new TmfTimestamp()));
687 assertEquals("getRank", 0, fExperiment
.getRank(new TmfTimestamp( 1, (byte) -3)));
688 assertEquals("getRank", 10, fExperiment
.getRank(new TmfTimestamp( 11, (byte) -3)));
689 assertEquals("getRank", 100, fExperiment
.getRank(new TmfTimestamp( 101, (byte) -3)));
690 assertEquals("getRank", 1000, fExperiment
.getRank(new TmfTimestamp(1001, (byte) -3)));
691 assertEquals("getRank", 2000, fExperiment
.getRank(new TmfTimestamp(2001, (byte) -3)));
692 assertEquals("getRank", 2500, fExperiment
.getRank(new TmfTimestamp(2501, (byte) -3)));
695 // ------------------------------------------------------------------------
697 // ------------------------------------------------------------------------
699 public void testGetTimestamp() throws Exception
{
701 assertTrue("getTimestamp", fExperiment
.getTimestamp( 0).equals(new TmfTimestamp( 1, (byte) -3)));
702 assertTrue("getTimestamp", fExperiment
.getTimestamp( 10).equals(new TmfTimestamp( 11, (byte) -3)));
703 assertTrue("getTimestamp", fExperiment
.getTimestamp( 100).equals(new TmfTimestamp( 101, (byte) -3)));
704 assertTrue("getTimestamp", fExperiment
.getTimestamp(1000).equals(new TmfTimestamp(1001, (byte) -3)));
705 assertTrue("getTimestamp", fExperiment
.getTimestamp(2000).equals(new TmfTimestamp(2001, (byte) -3)));
706 assertTrue("getTimestamp", fExperiment
.getTimestamp(2500).equals(new TmfTimestamp(2501, (byte) -3)));