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
.trace
;
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
.ITmfTrace
;
34 import org
.eclipse
.linuxtools
.tmf
.core
.trace
.TmfCheckpoint
;
35 import org
.eclipse
.linuxtools
.tmf
.core
.trace
.TmfContext
;
36 import org
.eclipse
.linuxtools
.tmf
.stubs
.trace
.TmfTraceStub
;
39 * <b><u>TmfExperimentTest</u></b>
41 * TODO: Implement me. Please.
43 @SuppressWarnings("nls")
44 public class TmfExperimentTest
extends TestCase
{
46 private static final String DIRECTORY
= "testfiles";
47 private static final String TEST_STREAM
= "A-Test-10K";
48 private static final String EXPERIMENT
= "MyExperiment";
49 private static int NB_EVENTS
= 10000;
50 private static int fDefaultBlockSize
= 1000;
52 private static ITmfTrace
<?
>[] fTraces
;
53 private static TmfExperiment
<TmfEvent
> fExperiment
;
55 private static byte SCALE
= (byte) -3;
57 // ------------------------------------------------------------------------
59 // ------------------------------------------------------------------------
61 private synchronized ITmfTrace
<?
>[] setupTrace(String path
) {
62 if (fTraces
== null) {
63 fTraces
= new ITmfTrace
[1];
65 URL location
= FileLocator
.find(TmfCoreTestPlugin
.getDefault().getBundle(), new Path(path
), null);
66 File test
= new File(FileLocator
.toFileURL(location
).toURI());
67 TmfTraceStub trace
= new TmfTraceStub(test
.getPath(), true);
69 } catch (URISyntaxException e
) {
71 } catch (IOException e
) {
78 @SuppressWarnings("unchecked")
79 private synchronized void setupExperiment() {
80 if (fExperiment
== null) {
81 fExperiment
= new TmfExperiment
<TmfEvent
>(TmfEvent
.class, EXPERIMENT
, (ITmfTrace
<TmfEvent
>[]) fTraces
);
82 // fExperiment.indexExperiment();
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() {
107 assertEquals("GetId", EXPERIMENT
, fExperiment
.getName());
108 assertEquals("GetEpoch", TmfTimestamp
.ZERO
, fExperiment
.getEpoch());
109 assertEquals("GetNbEvents", NB_EVENTS
, fExperiment
.getNbEvents());
111 TmfTimeRange timeRange
= fExperiment
.getTimeRange();
112 assertEquals("getStartTime", 1, timeRange
.getStartTime().getValue());
113 assertEquals("getEndTime", NB_EVENTS
, timeRange
.getEndTime().getValue());
116 // ------------------------------------------------------------------------
117 // Verify checkpoints
118 // Note: seekLocation() does not reliably set the rank
119 // ------------------------------------------------------------------------
121 public void testValidateCheckpoints() throws Exception
{
123 Vector
<TmfCheckpoint
> checkpoints
= fExperiment
.getCheckpoints();
124 // int pageSize = fExperiment.getCacheSize();
125 assertTrue("Checkpoints exist", checkpoints
!= null);
127 // Validate that each checkpoint points to the right event
128 for (int i
= 0; i
< checkpoints
.size(); i
++) {
129 TmfCheckpoint checkpoint
= checkpoints
.get(i
);
130 TmfExperimentContext context
= fExperiment
.seekLocation(checkpoint
.getLocation());
131 ITmfEvent event
= fExperiment
.parseEvent(context
);
132 // assertEquals("Event rank", context.getRank(), i * pageSize);
133 assertTrue("Timestamp", (checkpoint
.getTimestamp().compareTo(event
.getTimestamp(), false) == 0));
137 // ------------------------------------------------------------------------
138 // parseEvent - make sure parseEvent doesn't update the context
139 // ------------------------------------------------------------------------
141 public void testParseEvent() throws Exception
{
143 // On lower bound, returns the first event (ts = 0)
144 TmfContext context
= fExperiment
.seekEvent(new TmfTimestamp(0, SCALE
, 0));
146 ITmfEvent event
= fExperiment
.parseEvent(context
);
147 assertEquals("Event timestamp", 1, event
.getTimestamp().getValue());
149 event
= fExperiment
.parseEvent(context
);
150 assertEquals("Event timestamp", 1, event
.getTimestamp().getValue());
152 event
= fExperiment
.parseEvent(context
);
153 assertEquals("Event timestamp", 1, event
.getTimestamp().getValue());
155 for (int i
= 1; i
< 20; i
++) {
156 event
= fExperiment
.getNextEvent(context
);
157 assertEquals("Event timestamp", i
, event
.getTimestamp().getValue());
160 event
= fExperiment
.parseEvent(context
);
161 assertEquals("Event timestamp", 20, event
.getTimestamp().getValue());
163 event
= fExperiment
.parseEvent(context
);
164 assertEquals("Event timestamp", 20, event
.getTimestamp().getValue());
167 // ------------------------------------------------------------------------
168 // getNextEvent - updates the context
169 // ------------------------------------------------------------------------
171 public void testGetNextEvent() throws Exception
{
173 // On lower bound, returns the first event (ts = 0)
174 TmfContext context
= fExperiment
.seekEvent(new TmfTimestamp(0, SCALE
, 0));
175 ITmfEvent event
= fExperiment
.getNextEvent(context
);
176 assertEquals("Event timestamp", 1, event
.getTimestamp().getValue());
178 for (int i
= 2; i
< 20; i
++) {
179 event
= fExperiment
.getNextEvent(context
);
180 assertEquals("Event timestamp", i
, event
.getTimestamp().getValue());
184 // ------------------------------------------------------------------------
186 // Note: seekLocation() does not reliably set the rank
187 // ------------------------------------------------------------------------
189 public void testSeekLocationOnCacheBoundary() throws Exception
{
191 // Position trace at event rank 0
192 TmfContext context
= fExperiment
.seekLocation(null);
193 // assertEquals("Event rank", 0, context.getRank());
194 ITmfEvent event
= fExperiment
.parseEvent(context
);
195 assertEquals("Event timestamp", 1, event
.getTimestamp().getValue());
196 // assertEquals("Event rank", 0, context.getRank());
197 event
= fExperiment
.getNextEvent(context
);
198 assertEquals("Event timestamp", 1, event
.getTimestamp().getValue());
199 // assertEquals("Event rank", 1, context.getRank());
201 // Position trace at event rank 1000
202 TmfContext tmpContext
= fExperiment
.seekEvent(new TmfTimestamp(1001, SCALE
, 0));
203 context
= fExperiment
.seekLocation(tmpContext
.getLocation().clone());
204 // assertEquals("Event rank", 1000, context.getRank());
205 event
= fExperiment
.parseEvent(context
);
206 assertEquals("Event timestamp", 1001, event
.getTimestamp().getValue());
207 // assertEquals("Event rank", 1000, context.getRank());
208 event
= fExperiment
.getNextEvent(context
);
209 assertEquals("Event timestamp", 1001, event
.getTimestamp().getValue());
210 // assertEquals("Event rank", 1001, context.getRank());
212 // Position trace at event rank 4000
213 tmpContext
= fExperiment
.seekEvent(new TmfTimestamp(4001, SCALE
, 0));
214 context
= fExperiment
.seekLocation(tmpContext
.getLocation().clone());
215 // assertEquals("Event rank", 4000, context.getRank());
216 event
= fExperiment
.parseEvent(context
);
217 assertEquals("Event timestamp", 4001, event
.getTimestamp().getValue());
218 // assertEquals("Event rank", 4000, context.getRank());
219 event
= fExperiment
.getNextEvent(context
);
220 assertEquals("Event timestamp", 4001, event
.getTimestamp().getValue());
221 // assertEquals("Event rank", 4001, context.getRank());
224 public void testSeekLocationNotOnCacheBoundary() throws Exception
{
226 // Position trace at event rank 9
227 TmfContext tmpContext
= fExperiment
.seekEvent(new TmfTimestamp(10, SCALE
, 0));
228 TmfContext context
= fExperiment
.seekLocation(tmpContext
.getLocation().clone());
229 // assertEquals("Event rank", 9, context.getRank());
230 ITmfEvent event
= fExperiment
.parseEvent(context
);
231 assertEquals("Event timestamp", 10, event
.getTimestamp().getValue());
232 // assertEquals("Event rank", 9, context.getRank());
233 event
= fExperiment
.getNextEvent(context
);
234 assertEquals("Event timestamp", 10, event
.getTimestamp().getValue());
235 // assertEquals("Event rank", 10, context.getRank());
237 // Position trace at event rank 999
238 tmpContext
= fExperiment
.seekEvent(new TmfTimestamp(1000, SCALE
, 0));
239 context
= fExperiment
.seekLocation(tmpContext
.getLocation().clone());
240 // assertEquals("Event rank", 999, context.getRank());
241 event
= fExperiment
.parseEvent(context
);
242 assertEquals("Event timestamp", 1000, event
.getTimestamp().getValue());
243 // assertEquals("Event rank", 999, context.getRank());
244 event
= fExperiment
.getNextEvent(context
);
245 assertEquals("Event timestamp", 1000, event
.getTimestamp().getValue());
246 // assertEquals("Event rank", 1000, context.getRank());
248 // Position trace at event rank 1001
249 tmpContext
= fExperiment
.seekEvent(new TmfTimestamp(1002, SCALE
, 0));
250 context
= fExperiment
.seekLocation(tmpContext
.getLocation().clone());
251 // assertEquals("Event rank", 1001, context.getRank());
252 event
= fExperiment
.parseEvent(context
);
253 assertEquals("Event timestamp", 1002, event
.getTimestamp().getValue());
254 // assertEquals("Event rank", 1001, context.getRank());
255 event
= fExperiment
.getNextEvent(context
);
256 assertEquals("Event timestamp", 1002, event
.getTimestamp().getValue());
257 // assertEquals("Event rank", 1002, context.getRank());
259 // Position trace at event rank 4500
260 tmpContext
= fExperiment
.seekEvent(new TmfTimestamp(4501, SCALE
, 0));
261 context
= fExperiment
.seekLocation(tmpContext
.getLocation().clone());
262 // assertEquals("Event rank", 4500, context.getRank());
263 event
= fExperiment
.parseEvent(context
);
264 assertEquals("Event timestamp", 4501, event
.getTimestamp().getValue());
265 // assertEquals("Event rank", 4500, context.getRank());
266 event
= fExperiment
.getNextEvent(context
);
267 assertEquals("Event timestamp", 4501, event
.getTimestamp().getValue());
268 // assertEquals("Event rank", 4501, context.getRank());
271 public void testSeekLocationOutOfScope() throws Exception
{
273 // Position trace at beginning
274 TmfContext tmpContext
= fExperiment
.seekLocation(null);
275 TmfContext context
= fExperiment
.seekLocation(tmpContext
.getLocation().clone());
276 // assertEquals("Event rank", 0, context.getRank());
277 ITmfEvent event
= fExperiment
.parseEvent(context
);
278 assertEquals("Event timestamp", 1, event
.getTimestamp().getValue());
279 // assertEquals("Event rank", 0, context.getRank());
280 event
= fExperiment
.getNextEvent(context
);
281 assertEquals("Event timestamp", 1, event
.getTimestamp().getValue());
282 // assertEquals("Event rank", 1, context.getRank());
284 // Position trace at event passed the end
285 tmpContext
= fExperiment
.seekEvent(new TmfTimestamp(NB_EVENTS
+ 1, SCALE
, 0));
286 context
= fExperiment
.seekLocation(tmpContext
.getLocation().clone());
287 // assertEquals("Event rank", NB_EVENTS, context.getRank());
288 event
= fExperiment
.parseEvent(context
);
289 assertEquals("Event timestamp", null, event
);
290 // assertEquals("Event rank", NB_EVENTS, context.getRank());
291 event
= fExperiment
.getNextEvent(context
);
292 assertEquals("Event timestamp", null, event
);
293 // assertEquals("Event rank", NB_EVENTS, context.getRank());
296 // ------------------------------------------------------------------------
297 // seekEvent on timestamp
298 // ------------------------------------------------------------------------
300 public void testSeekEventOnTimestampOnCacheBoundary() throws Exception
{
302 // Position trace at event rank 0
303 TmfContext context
= fExperiment
.seekEvent(new TmfTimestamp(1, SCALE
, 0));
304 assertEquals("Event rank", 0, context
.getRank());
305 ITmfEvent event
= fExperiment
.parseEvent(context
);
306 assertEquals("Event timestamp", 1, event
.getTimestamp().getValue());
307 assertEquals("Event rank", 0, context
.getRank());
308 event
= fExperiment
.getNextEvent(context
);
309 assertEquals("Event timestamp", 1, event
.getTimestamp().getValue());
310 assertEquals("Event rank", 1, context
.getRank());
312 // Position trace at event rank 1000
313 context
= fExperiment
.seekEvent(new TmfTimestamp(1001, SCALE
, 0));
314 assertEquals("Event rank", 1000, context
.getRank());
315 event
= fExperiment
.parseEvent(context
);
316 assertEquals("Event timestamp", 1001, event
.getTimestamp().getValue());
317 assertEquals("Event rank", 1000, context
.getRank());
318 event
= fExperiment
.getNextEvent(context
);
319 assertEquals("Event timestamp", 1001, event
.getTimestamp().getValue());
320 assertEquals("Event rank", 1001, context
.getRank());
322 // Position trace at event rank 4000
323 context
= fExperiment
.seekEvent(new TmfTimestamp(4001, SCALE
, 0));
324 assertEquals("Event rank", 4000, context
.getRank());
325 event
= fExperiment
.parseEvent(context
);
326 assertEquals("Event timestamp", 4001, event
.getTimestamp().getValue());
327 assertEquals("Event rank", 4000, context
.getRank());
328 event
= fExperiment
.getNextEvent(context
);
329 assertEquals("Event timestamp", 4001, event
.getTimestamp().getValue());
330 assertEquals("Event rank", 4001, context
.getRank());
333 public void testSeekEventOnTimestampNotOnCacheBoundary() throws Exception
{
335 // Position trace at event rank 1
336 TmfContext context
= fExperiment
.seekEvent(new TmfTimestamp(2, SCALE
, 0));
337 assertEquals("Event rank", 1, context
.getRank());
338 ITmfEvent event
= fExperiment
.parseEvent(context
);
339 assertEquals("Event timestamp", 2, event
.getTimestamp().getValue());
340 assertEquals("Event rank", 1, context
.getRank());
341 event
= fExperiment
.getNextEvent(context
);
342 assertEquals("Event timestamp", 2, event
.getTimestamp().getValue());
343 assertEquals("Event rank", 2, context
.getRank());
345 // Position trace at event rank 9
346 context
= fExperiment
.seekEvent(new TmfTimestamp(10, SCALE
, 0));
347 assertEquals("Event rank", 9, context
.getRank());
348 event
= fExperiment
.parseEvent(context
);
349 assertEquals("Event timestamp", 10, event
.getTimestamp().getValue());
350 assertEquals("Event rank", 9, context
.getRank());
351 event
= fExperiment
.getNextEvent(context
);
352 assertEquals("Event timestamp", 10, event
.getTimestamp().getValue());
353 assertEquals("Event rank", 10, context
.getRank());
355 // Position trace at event rank 999
356 context
= fExperiment
.seekEvent(new TmfTimestamp(1000, SCALE
, 0));
357 assertEquals("Event rank", 999, context
.getRank());
358 event
= fExperiment
.parseEvent(context
);
359 assertEquals("Event timestamp", 1000, event
.getTimestamp().getValue());
360 assertEquals("Event rank", 999, context
.getRank());
361 event
= fExperiment
.getNextEvent(context
);
362 assertEquals("Event timestamp", 1000, event
.getTimestamp().getValue());
363 assertEquals("Event rank", 1000, context
.getRank());
365 // Position trace at event rank 1001
366 context
= fExperiment
.seekEvent(new TmfTimestamp(1002, SCALE
, 0));
367 assertEquals("Event rank", 1001, context
.getRank());
368 event
= fExperiment
.parseEvent(context
);
369 assertEquals("Event timestamp", 1002, event
.getTimestamp().getValue());
370 assertEquals("Event rank", 1001, context
.getRank());
371 event
= fExperiment
.getNextEvent(context
);
372 assertEquals("Event timestamp", 1002, event
.getTimestamp().getValue());
373 assertEquals("Event rank", 1002, context
.getRank());
375 // Position trace at event rank 4500
376 context
= fExperiment
.seekEvent(new TmfTimestamp(4501, SCALE
, 0));
377 assertEquals("Event rank", 4500, context
.getRank());
378 event
= fExperiment
.parseEvent(context
);
379 assertEquals("Event timestamp", 4501, event
.getTimestamp().getValue());
380 assertEquals("Event rank", 4500, context
.getRank());
381 event
= fExperiment
.getNextEvent(context
);
382 assertEquals("Event timestamp", 4501, event
.getTimestamp().getValue());
383 assertEquals("Event rank", 4501, context
.getRank());
386 public void testSeekEventOnTimestampoutOfScope() throws Exception
{
388 // Position trace at beginning
389 TmfContext context
= fExperiment
.seekEvent(new TmfTimestamp(-1, SCALE
, 0));
390 assertEquals("Event rank", 0, context
.getRank());
391 ITmfEvent event
= fExperiment
.parseEvent(context
);
392 assertEquals("Event timestamp", 1, event
.getTimestamp().getValue());
393 assertEquals("Event rank", 0, context
.getRank());
394 event
= fExperiment
.getNextEvent(context
);
395 assertEquals("Event timestamp", 1, event
.getTimestamp().getValue());
396 assertEquals("Event rank", 1, context
.getRank());
398 // Position trace at event passed the end
399 context
= fExperiment
.seekEvent(new TmfTimestamp(NB_EVENTS
+ 1, SCALE
, 0));
400 assertEquals("Event rank", NB_EVENTS
, context
.getRank());
401 event
= fExperiment
.parseEvent(context
);
402 assertEquals("Event timestamp", null, event
);
403 assertEquals("Event rank", NB_EVENTS
, context
.getRank());
404 event
= fExperiment
.getNextEvent(context
);
405 assertEquals("Event timestamp", null, event
);
406 assertEquals("Event rank", NB_EVENTS
, context
.getRank());
409 // ------------------------------------------------------------------------
411 // ------------------------------------------------------------------------
413 public void testSeekOnRankOnCacheBoundary() throws Exception
{
415 // On lower bound, returns the first event (ts = 1)
416 TmfContext context
= fExperiment
.seekEvent(0);
417 assertEquals("Event rank", 0, context
.getRank());
418 ITmfEvent event
= fExperiment
.parseEvent(context
);
419 assertEquals("Event timestamp", 1, event
.getTimestamp().getValue());
420 assertEquals("Event rank", 0, context
.getRank());
421 event
= fExperiment
.getNextEvent(context
);
422 assertEquals("Event timestamp", 1, event
.getTimestamp().getValue());
423 assertEquals("Event rank", 1, context
.getRank());
425 // Position trace at event rank 1000
426 context
= fExperiment
.seekEvent(1000);
427 assertEquals("Event rank", 1000, context
.getRank());
428 event
= fExperiment
.parseEvent(context
);
429 assertEquals("Event timestamp", 1001, event
.getTimestamp().getValue());
430 assertEquals("Event rank", 1000, context
.getRank());
431 event
= fExperiment
.getNextEvent(context
);
432 assertEquals("Event timestamp", 1001, event
.getTimestamp().getValue());
433 assertEquals("Event rank", 1001, context
.getRank());
435 // Position trace at event rank 4000
436 context
= fExperiment
.seekEvent(4000);
437 assertEquals("Event rank", 4000, context
.getRank());
438 event
= fExperiment
.parseEvent(context
);
439 assertEquals("Event timestamp", 4001, event
.getTimestamp().getValue());
440 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());
451 ITmfEvent event
= fExperiment
.parseEvent(context
);
452 assertEquals("Event timestamp", 10, event
.getTimestamp().getValue());
453 assertEquals("Event rank", 9, context
.getRank());
454 event
= fExperiment
.getNextEvent(context
);
455 assertEquals("Event timestamp", 10, event
.getTimestamp().getValue());
456 assertEquals("Event rank", 10, context
.getRank());
458 // Position trace at event rank 999
459 context
= fExperiment
.seekEvent(999);
460 assertEquals("Event rank", 999, context
.getRank());
461 event
= fExperiment
.parseEvent(context
);
462 assertEquals("Event timestamp", 1000, event
.getTimestamp().getValue());
463 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());
471 event
= fExperiment
.parseEvent(context
);
472 assertEquals("Event timestamp", 1002, event
.getTimestamp().getValue());
473 assertEquals("Event rank", 1001, context
.getRank());
474 event
= fExperiment
.getNextEvent(context
);
475 assertEquals("Event timestamp", 1002, event
.getTimestamp().getValue());
476 assertEquals("Event rank", 1002, context
.getRank());
478 // Position trace at event rank 4500
479 context
= fExperiment
.seekEvent(4500);
480 assertEquals("Event rank", 4500, context
.getRank());
481 event
= fExperiment
.parseEvent(context
);
482 assertEquals("Event timestamp", 4501, event
.getTimestamp().getValue());
483 assertEquals("Event rank", 4500, context
.getRank());
484 event
= fExperiment
.getNextEvent(context
);
485 assertEquals("Event timestamp", 4501, event
.getTimestamp().getValue());
486 assertEquals("Event rank", 4501, context
.getRank());
489 public void testSeekEventOnRankOfScope() throws Exception
{
491 // Position trace at beginning
492 TmfContext context
= fExperiment
.seekEvent(-1);
493 assertEquals("Event rank", 0, context
.getRank());
494 ITmfEvent event
= fExperiment
.parseEvent(context
);
495 assertEquals("Event timestamp", 1, event
.getTimestamp().getValue());
496 assertEquals("Event rank", 0, context
.getRank());
497 event
= fExperiment
.getNextEvent(context
);
498 assertEquals("Event timestamp", 1, event
.getTimestamp().getValue());
499 assertEquals("Event rank", 1, context
.getRank());
501 // Position trace at event passed the end
502 context
= fExperiment
.seekEvent(NB_EVENTS
);
503 assertEquals("Event rank", NB_EVENTS
, context
.getRank());
504 event
= fExperiment
.parseEvent(context
);
505 assertEquals("Event timestamp", null, event
);
506 assertEquals("Event rank", NB_EVENTS
, context
.getRank());
507 event
= fExperiment
.getNextEvent(context
);
508 assertEquals("Event timestamp", null, event
);
509 assertEquals("Event rank", NB_EVENTS
, context
.getRank());
512 // ------------------------------------------------------------------------
514 // ------------------------------------------------------------------------
516 public void testProcessRequestForNbEvents() throws Exception
{
517 final int blockSize
= 100;
518 final int nbEvents
= 1000;
519 final Vector
<TmfEvent
> requestedEvents
= new Vector
<TmfEvent
>();
521 TmfTimeRange range
= new TmfTimeRange(TmfTimestamp
.BIG_BANG
, TmfTimestamp
.BIG_CRUNCH
);
522 final TmfEventRequest
<TmfEvent
> request
= new TmfEventRequest
<TmfEvent
>(TmfEvent
.class, range
, nbEvents
, blockSize
) {
524 public void handleData(TmfEvent event
) {
525 super.handleData(event
);
526 requestedEvents
.add(event
);
529 fExperiment
.sendRequest(request
);
530 request
.waitForCompletion();
532 assertEquals("nbEvents", nbEvents
, requestedEvents
.size());
533 assertTrue("isCompleted", request
.isCompleted());
534 assertFalse("isCancelled", request
.isCancelled());
536 // Ensure that we have distinct events.
537 // Don't go overboard: we are not validating the stub!
538 for (int i
= 0; i
< nbEvents
; i
++) {
539 assertEquals("Distinct events", i
+1, requestedEvents
.get(i
).getTimestamp().getValue());
543 public void testProcessRequestForNbEvents2() throws Exception
{
544 final int blockSize
= 2 * NB_EVENTS
;
545 final int nbEvents
= 1000;
546 final Vector
<TmfEvent
> requestedEvents
= new Vector
<TmfEvent
>();
548 TmfTimeRange range
= new TmfTimeRange(TmfTimestamp
.BIG_BANG
, TmfTimestamp
.BIG_CRUNCH
);
549 final TmfEventRequest
<TmfEvent
> request
= new TmfEventRequest
<TmfEvent
>(TmfEvent
.class, range
, nbEvents
, blockSize
) {
551 public void handleData(TmfEvent event
) {
552 super.handleData(event
);
553 requestedEvents
.add(event
);
556 fExperiment
.sendRequest(request
);
557 request
.waitForCompletion();
559 assertEquals("nbEvents", nbEvents
, requestedEvents
.size());
560 assertTrue("isCompleted", request
.isCompleted());
561 assertFalse("isCancelled", request
.isCancelled());
563 // Ensure that we have distinct events.
564 // Don't go overboard: we are not validating the stub!
565 for (int i
= 0; i
< nbEvents
; i
++) {
566 assertEquals("Distinct events", i
+1, requestedEvents
.get(i
).getTimestamp().getValue());
570 public void testProcessRequestForAllEvents() throws Exception
{
571 final int nbEvents
= TmfEventRequest
.ALL_DATA
;
572 final int blockSize
= 1;
573 final Vector
<TmfEvent
> requestedEvents
= new Vector
<TmfEvent
>();
574 long nbExpectedEvents
= fExperiment
.getNbEvents();
576 TmfTimeRange range
= new TmfTimeRange(TmfTimestamp
.BIG_BANG
, TmfTimestamp
.BIG_CRUNCH
);
577 final TmfEventRequest
<TmfEvent
> request
= new TmfEventRequest
<TmfEvent
>(TmfEvent
.class, range
, nbEvents
, blockSize
) {
579 public void handleData(TmfEvent event
) {
580 super.handleData(event
);
581 requestedEvents
.add(event
);
584 fExperiment
.sendRequest(request
);
585 request
.waitForCompletion();
587 assertEquals("nbEvents", nbExpectedEvents
, requestedEvents
.size());
588 assertTrue("isCompleted", request
.isCompleted());
589 assertFalse("isCancelled", request
.isCancelled());
591 // Ensure that we have distinct events.
592 // Don't go overboard: we are not validating the stub!
593 for (int i
= 0; i
< nbExpectedEvents
; i
++) {
594 assertEquals("Distinct events", i
+1, requestedEvents
.get(i
).getTimestamp().getValue());
598 // ------------------------------------------------------------------------
600 // ------------------------------------------------------------------------
602 public void testCancel() throws Exception
{
603 final int nbEvents
= NB_EVENTS
;
604 final int blockSize
= fDefaultBlockSize
;
605 final Vector
<TmfEvent
> requestedEvents
= new Vector
<TmfEvent
>();
607 TmfTimeRange range
= new TmfTimeRange(TmfTimestamp
.BIG_BANG
, TmfTimestamp
.BIG_CRUNCH
);
608 final TmfEventRequest
<TmfEvent
> request
= new TmfEventRequest
<TmfEvent
>(TmfEvent
.class, range
, nbEvents
, blockSize
) {
611 public void handleData(TmfEvent event
) {
612 super.handleData(event
);
613 requestedEvents
.add(event
);
614 if (++nbRead
== blockSize
)
618 fExperiment
.sendRequest(request
);
619 request
.waitForCompletion();
621 assertEquals("nbEvents", blockSize
, requestedEvents
.size());
622 assertTrue("isCompleted", request
.isCompleted());
623 assertTrue("isCancelled", request
.isCancelled());
626 // ------------------------------------------------------------------------
628 // ------------------------------------------------------------------------
630 public void testGetRank() throws Exception
{
631 assertEquals("getRank", 0, fExperiment
.getRank(new TmfTimestamp()));
632 assertEquals("getRank", 0, fExperiment
.getRank(new TmfTimestamp( 1, (byte) -3)));
633 assertEquals("getRank", 10, fExperiment
.getRank(new TmfTimestamp( 11, (byte) -3)));
634 assertEquals("getRank", 100, fExperiment
.getRank(new TmfTimestamp( 101, (byte) -3)));
635 assertEquals("getRank", 1000, fExperiment
.getRank(new TmfTimestamp(1001, (byte) -3)));
636 assertEquals("getRank", 2000, fExperiment
.getRank(new TmfTimestamp(2001, (byte) -3)));
637 assertEquals("getRank", 2500, fExperiment
.getRank(new TmfTimestamp(2501, (byte) -3)));
640 // ------------------------------------------------------------------------
642 // ------------------------------------------------------------------------
644 public void testGetTimestamp() throws Exception
{
645 assertTrue("getTimestamp", fExperiment
.getTimestamp( 0).equals(new TmfTimestamp( 1, (byte) -3)));
646 assertTrue("getTimestamp", fExperiment
.getTimestamp( 10).equals(new TmfTimestamp( 11, (byte) -3)));
647 assertTrue("getTimestamp", fExperiment
.getTimestamp( 100).equals(new TmfTimestamp( 101, (byte) -3)));
648 assertTrue("getTimestamp", fExperiment
.getTimestamp(1000).equals(new TmfTimestamp(1001, (byte) -3)));
649 assertTrue("getTimestamp", fExperiment
.getTimestamp(2000).equals(new TmfTimestamp(2001, (byte) -3)));
650 assertTrue("getTimestamp", fExperiment
.getTimestamp(2500).equals(new TmfTimestamp(2501, (byte) -3)));