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
.request
;
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
.internal
.tmf
.core
.component
.TmfProviderManager
;
26 import org
.eclipse
.linuxtools
.internal
.tmf
.core
.request
.TmfCoalescedDataRequest
;
27 import org
.eclipse
.linuxtools
.internal
.tmf
.core
.request
.TmfCoalescedEventRequest
;
28 import org
.eclipse
.linuxtools
.tmf
.core
.component
.ITmfDataProvider
;
29 import org
.eclipse
.linuxtools
.tmf
.core
.event
.ITmfEvent
;
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
.ITmfDataRequest
.ExecutionType
;
35 import org
.eclipse
.linuxtools
.tmf
.core
.request
.TmfDataRequest
;
36 import org
.eclipse
.linuxtools
.tmf
.core
.request
.TmfEventRequest
;
37 import org
.eclipse
.linuxtools
.tmf
.core
.signal
.TmfSignal
;
38 import org
.eclipse
.linuxtools
.tmf
.core
.signal
.TmfSignalHandler
;
39 import org
.eclipse
.linuxtools
.tmf
.core
.signal
.TmfSignalManager
;
40 import org
.eclipse
.linuxtools
.tmf
.core
.tests
.TmfCoreTestPlugin
;
41 import org
.eclipse
.linuxtools
.tmf
.tests
.stubs
.request
.TmfEventRequestStub
;
42 import org
.eclipse
.linuxtools
.tmf
.tests
.stubs
.trace
.TmfTraceStub
;
45 * <b><u>TmfCoalescedEventRequestTest</u></b>
47 * Test suite for the TmfCoalescedEventRequest class.
49 @SuppressWarnings({"nls","javadoc"})
50 public class TmfCoalescedEventRequestTest
extends TestCase
{
52 // ------------------------------------------------------------------------
54 // ------------------------------------------------------------------------
56 private final TmfTimeRange range1
= new TmfTimeRange(TmfTimeRange
.ETERNITY
);
57 private final TmfTimeRange range2
= new TmfTimeRange(new TmfTimestamp(), TmfTimestamp
.BIG_CRUNCH
);
59 private TmfCoalescedEventRequest fRequest1
;
60 private TmfCoalescedEventRequest fRequest2
;
61 private TmfCoalescedEventRequest fRequest3
;
62 private TmfCoalescedEventRequest fRequest4
;
64 private TmfCoalescedEventRequest fRequest1b
;
65 private TmfCoalescedEventRequest fRequest1c
;
67 private int fRequestCount
;
69 // ------------------------------------------------------------------------
71 // ------------------------------------------------------------------------
74 * @param name the test name
76 public TmfCoalescedEventRequestTest(String name
) {
81 public void setUp() throws Exception
{
83 TmfDataRequest
.reset();
84 fRequest1
= new TmfCoalescedEventRequest(TmfEvent
.class, range1
, 100, 200);
85 fRequest2
= new TmfCoalescedEventRequest(TmfEvent
.class, range2
, 100, 200);
86 fRequest3
= new TmfCoalescedEventRequest(TmfEvent
.class, range2
, 200, 200);
87 fRequest4
= new TmfCoalescedEventRequest(TmfEvent
.class, range2
, 200, 300);
89 fRequest1b
= new TmfCoalescedEventRequest(TmfEvent
.class, range1
, 100, 200);
90 fRequest1c
= new TmfCoalescedEventRequest(TmfEvent
.class, range1
, 100, 200);
92 fRequestCount
= fRequest1c
.getRequestId() + 1;
96 public void tearDown() throws Exception
{
100 private TmfCoalescedEventRequest
setupTestRequest(final boolean[] flags
) {
102 TmfCoalescedEventRequest request
= new TmfCoalescedEventRequest(TmfEvent
.class, range1
, 100, 200) {
104 public void handleCompleted() {
105 super.handleCompleted();
109 public void handleSuccess() {
110 super.handleSuccess();
114 public void handleFailure() {
115 super.handleFailure();
119 public void handleCancel() {
120 super.handleCancel();
127 // ------------------------------------------------------------------------
129 // ------------------------------------------------------------------------
131 public void testTmfCoalescedEventRequest() {
132 TmfCoalescedEventRequest request
= new TmfCoalescedEventRequest(TmfEvent
.class);
134 assertEquals("getRequestId", fRequestCount
++, request
.getRequestId());
135 assertEquals("getDataType", ITmfEvent
.class, request
.getDataType());
137 assertEquals("getRange", range1
, request
.getRange());
138 assertEquals("getNbRequestedEvents", TmfDataRequest
.ALL_DATA
, request
.getNbRequested());
140 assertFalse("isCompleted", request
.isCompleted());
141 assertFalse("isFailed", request
.isFailed());
142 assertFalse("isCancelled", request
.isCancelled());
144 assertEquals("getNbRead", 0, request
.getNbRead());
147 public void testTmfCoalescedEventRequestIndex() {
148 TmfCoalescedEventRequest request
= new TmfCoalescedEventRequest(TmfEvent
.class, range1
);
150 assertEquals("getRequestId", fRequestCount
++, request
.getRequestId());
151 assertEquals("getDataType", ITmfEvent
.class, request
.getDataType());
153 assertEquals("getRange", range1
, request
.getRange());
154 assertEquals("getNbRequestedEvents", TmfDataRequest
.ALL_DATA
, request
.getNbRequested());
156 assertFalse("isCompleted", request
.isCompleted());
157 assertFalse("isFailed", request
.isFailed());
158 assertFalse("isCancelled", request
.isCancelled());
160 assertEquals("getNbRead", 0, request
.getNbRead());
163 public void testTmfCoalescedEventRequestIndexNbRequested() {
164 TmfCoalescedEventRequest request
= new TmfCoalescedEventRequest(TmfEvent
.class, range1
, 100);
166 assertEquals("getRequestId", fRequestCount
++, request
.getRequestId());
167 assertEquals("getDataType", ITmfEvent
.class, request
.getDataType());
169 assertEquals("getRange", range1
, request
.getRange());
170 assertEquals("getNbRequestedEvents", 100, request
.getNbRequested());
172 assertFalse("isCompleted", request
.isCompleted());
173 assertFalse("isFailed", request
.isFailed());
174 assertFalse("isCancelled", request
.isCancelled());
176 assertEquals("getNbRead", 0, request
.getNbRead());
179 public void testTmfCoalescedEventRequestIndexNbEventsBlocksize() {
180 TmfCoalescedEventRequest request
= new TmfCoalescedEventRequest(TmfEvent
.class, range1
, 100, 200);
182 assertEquals("getRequestId", fRequestCount
++, request
.getRequestId());
183 assertEquals("getDataType", ITmfEvent
.class, request
.getDataType());
185 assertEquals("getRange", range1
, request
.getRange());
186 assertEquals("getNbRequestedEvents", 100, request
.getNbRequested());
188 assertFalse("isCompleted", request
.isCompleted());
189 assertFalse("isFailed", request
.isFailed());
190 assertFalse("isCancelled", request
.isCancelled());
192 assertEquals("getNbRead", 0, request
.getNbRead());
195 // ------------------------------------------------------------------------
197 // ------------------------------------------------------------------------
199 public void testEqualsReflexivity() {
200 assertTrue("equals", fRequest1
.equals(fRequest1
));
201 assertTrue("equals", fRequest2
.equals(fRequest2
));
203 assertFalse("equals", fRequest1
.equals(fRequest2
));
204 assertFalse("equals", fRequest2
.equals(fRequest1
));
207 public void testEqualsSymmetry() {
208 assertTrue("equals", fRequest1
.equals(fRequest1b
));
209 assertTrue("equals", fRequest1b
.equals(fRequest1
));
211 assertFalse("equals", fRequest1
.equals(fRequest3
));
212 assertFalse("equals", fRequest2
.equals(fRequest3
));
213 assertFalse("equals", fRequest3
.equals(fRequest1
));
214 assertFalse("equals", fRequest3
.equals(fRequest2
));
217 public void testEqualsTransivity() {
218 assertTrue("equals", fRequest1
.equals(fRequest1b
));
219 assertTrue("equals", fRequest1b
.equals(fRequest1c
));
220 assertTrue("equals", fRequest1
.equals(fRequest1c
));
223 public void testEqualsNull() {
224 assertFalse("equals", fRequest1
.equals(null));
225 assertFalse("equals", fRequest2
.equals(null));
228 public void testEqualsSuper() {
229 TmfCoalescedDataRequest dataRequest1
= new TmfCoalescedDataRequest(
230 fRequest1
.getDataType(), fRequest1
.getIndex(), fRequest1
.getNbRequested());
231 TmfCoalescedDataRequest dataRequest2
= new TmfCoalescedDataRequest(
232 fRequest1
.getDataType(), fRequest1
.getIndex(), fRequest1
.getNbRequested());
233 TmfCoalescedDataRequest dataRequest3
= new TmfCoalescedDataRequest(
234 fRequest3
.getDataType(), fRequest3
.getIndex(), fRequest3
.getNbRequested());
236 assertTrue("equals", fRequest1
.equals(dataRequest2
));
237 assertTrue("equals", fRequest2
.equals(dataRequest1
));
238 assertFalse("equals", fRequest1
.equals(dataRequest3
));
239 assertFalse("equals", fRequest3
.equals(dataRequest1
));
242 // ------------------------------------------------------------------------
244 // ------------------------------------------------------------------------
246 public void testHashCode() {
247 assertTrue("hashCode", fRequest1
.hashCode() == fRequest1
.hashCode());
248 assertTrue("hashCode", fRequest2
.hashCode() == fRequest2
.hashCode());
249 assertTrue("hashCode", fRequest1
.hashCode() != fRequest2
.hashCode());
252 // ------------------------------------------------------------------------
254 // ------------------------------------------------------------------------
256 public void testToString() {
257 String expected1
= "[TmfCoalescedEventRequest(0,ITmfEvent," + range1
+ ",0,100,200)]";
258 String expected2
= "[TmfCoalescedEventRequest(1,ITmfEvent," + range2
+ ",0,100,200)]";
259 String expected3
= "[TmfCoalescedEventRequest(2,ITmfEvent," + range2
+ ",0,200,200)]";
260 String expected4
= "[TmfCoalescedEventRequest(3,ITmfEvent," + range2
+ ",0,200,300)]";
262 assertEquals("toString", expected1
, fRequest1
.toString());
263 assertEquals("toString", expected2
, fRequest2
.toString());
264 assertEquals("toString", expected3
, fRequest3
.toString());
265 assertEquals("toString", expected4
, fRequest4
.toString());
268 // ------------------------------------------------------------------------
270 // ------------------------------------------------------------------------
272 @SuppressWarnings("hiding")
273 public void testIsCompatible() {
274 TmfCoalescedEventRequest coalescedRequest
= new TmfCoalescedEventRequest(TmfEvent
.class, range1
, 100, 200);
275 TmfEventRequest request1
= new TmfEventRequestStub(TmfEvent
.class, range1
, 100, 200);
276 TmfEventRequest request2
= new TmfEventRequestStub(TmfEvent
.class, range2
, 100, 200);
277 TmfEventRequest request3
= new TmfEventRequestStub(TmfEvent
.class, range1
, 101, 200);
279 assertTrue("isCompatible", coalescedRequest
.isCompatible(request1
));
280 assertTrue("isCompatible", coalescedRequest
.isCompatible(request2
));
281 assertTrue("isCompatible", coalescedRequest
.isCompatible(request3
));
284 // ------------------------------------------------------------------------
286 // ------------------------------------------------------------------------
288 @SuppressWarnings("hiding")
289 public void testAddEvent1() {
290 TmfCoalescedEventRequest coalescedRequest
= new TmfCoalescedEventRequest(TmfEvent
.class, range1
, 0, 2147483647, 200, ExecutionType
.FOREGROUND
);
291 TmfEventRequest request1
= new TmfEventRequestStub(TmfEvent
.class, range1
, 0, 2147483647, 200);
292 TmfEventRequest request2
= new TmfEventRequestStub(TmfEvent
.class, range1
, 1, 2147483647, 200);
294 assertTrue("isCompatible", coalescedRequest
.isCompatible(request1
));
295 assertTrue("isCompatible", coalescedRequest
.isCompatible(request2
));
297 coalescedRequest
.addRequest(request1
);
298 coalescedRequest
.addRequest(request2
);
300 assertEquals("addRequest", 0, coalescedRequest
.getIndex());
301 assertEquals("addRequest", 2147483647, coalescedRequest
.getNbRequested());
302 assertEquals("addRequest", 200, coalescedRequest
.getBlockSize());
306 @SuppressWarnings("hiding")
307 public void testAddEvent2() {
308 TmfCoalescedEventRequest coalescedRequest
= new TmfCoalescedEventRequest(TmfEvent
.class, range1
, 1, 2147483647, 200, ExecutionType
.FOREGROUND
);
309 TmfEventRequest request1
= new TmfEventRequestStub(TmfEvent
.class, range1
, 1, 2147483647, 200);
310 TmfEventRequest request2
= new TmfEventRequestStub(TmfEvent
.class, range1
, 0, 2147483647, 200);
312 assertTrue("isCompatible", coalescedRequest
.isCompatible(request1
));
313 assertTrue("isCompatible", coalescedRequest
.isCompatible(request2
));
315 coalescedRequest
.addRequest(request1
);
316 coalescedRequest
.addRequest(request2
);
318 assertEquals("addRequest", 0, coalescedRequest
.getIndex());
319 assertEquals("addRequest", 2147483647, coalescedRequest
.getNbRequested());
320 assertEquals("addRequest", 200, coalescedRequest
.getBlockSize());
324 // ------------------------------------------------------------------------
326 // ------------------------------------------------------------------------
328 public void testDone() {
331 final boolean[] crFlags
= new boolean[4];
332 TmfCoalescedEventRequest request
= setupTestRequest(crFlags
);
333 TmfEventRequest subRequest1
= new TmfEventRequestStub(TmfEvent
.class, range1
, 100, 200);
334 TmfEventRequest subRequest2
= new TmfEventRequestStub(TmfEvent
.class, range1
, 100, 200);
335 request
.addRequest(subRequest1
);
336 request
.addRequest(subRequest2
);
340 // Validate the coalescing request
341 assertTrue ("isCompleted", request
.isCompleted());
342 assertFalse("isFailed", request
.isFailed());
343 assertFalse("isCancelled", request
.isCancelled());
345 assertTrue ("handleCompleted", crFlags
[0]);
346 assertTrue ("handleSuccess", crFlags
[1]);
347 assertFalse("handleFailure", crFlags
[2]);
348 assertFalse("handleCancel", crFlags
[3]);
350 // Validate the first coalesced request
351 assertTrue ("isCompleted", subRequest1
.isCompleted());
352 assertFalse("isFailed", subRequest1
.isFailed());
353 assertFalse("isCancelled", subRequest1
.isCancelled());
355 // Validate the second coalesced request
356 assertTrue ("isCompleted", subRequest2
.isCompleted());
357 assertFalse("isFailed", subRequest2
.isFailed());
358 assertFalse("isCancelled", subRequest2
.isCancelled());
361 // ------------------------------------------------------------------------
363 // ------------------------------------------------------------------------
365 public void testFail() {
367 final boolean[] crFlags
= new boolean[4];
368 TmfCoalescedEventRequest request
= setupTestRequest(crFlags
);
369 TmfEventRequest subRequest1
= new TmfEventRequestStub(TmfEvent
.class, range1
, 100, 200);
370 TmfEventRequest subRequest2
= new TmfEventRequestStub(TmfEvent
.class, range1
, 100, 200);
371 request
.addRequest(subRequest1
);
372 request
.addRequest(subRequest2
);
376 // Validate the coalescing request
377 assertTrue ("isCompleted", request
.isCompleted());
378 assertTrue ("isFailed", request
.isFailed());
379 assertFalse("isCancelled", request
.isCancelled());
381 assertTrue ("handleCompleted", crFlags
[0]);
382 assertFalse("handleSuccess", crFlags
[1]);
383 assertTrue ("handleFailure", crFlags
[2]);
384 assertFalse("handleCancel", crFlags
[3]);
386 // Validate the first coalesced request
387 assertTrue ("isCompleted", subRequest1
.isCompleted());
388 assertTrue ("isFailed", subRequest1
.isFailed());
389 assertFalse("isCancelled", subRequest1
.isCancelled());
391 // Validate the second coalesced request
392 assertTrue ("isCompleted", subRequest2
.isCompleted());
393 assertTrue ("isFailed", subRequest2
.isFailed());
394 assertFalse("isCancelled", subRequest2
.isCancelled());
397 // ------------------------------------------------------------------------
399 // ------------------------------------------------------------------------
401 public void testCancel() {
403 final boolean[] crFlags
= new boolean[4];
404 TmfCoalescedEventRequest request
= setupTestRequest(crFlags
);
405 TmfEventRequest subRequest1
= new TmfEventRequestStub(TmfEvent
.class, range1
, 100, 200);
406 TmfEventRequest subRequest2
= new TmfEventRequestStub(TmfEvent
.class, range1
, 100, 200);
407 request
.addRequest(subRequest1
);
408 request
.addRequest(subRequest2
);
412 // Validate the coalescing request
413 assertTrue ("isCompleted", request
.isCompleted());
414 assertFalse("isFailed", request
.isFailed());
415 assertTrue ("isCancelled", request
.isCancelled());
417 assertTrue ("handleCompleted", crFlags
[0]);
418 assertFalse("handleSuccess", crFlags
[1]);
419 assertFalse("handleFailure", crFlags
[2]);
420 assertTrue ("handleCancel", crFlags
[3]);
422 // Validate the first coalesced request
423 assertTrue ("isCompleted", subRequest1
.isCompleted());
424 assertFalse("isFailed", subRequest1
.isFailed());
425 assertTrue ("isCancelled", subRequest1
.isCancelled());
427 // Validate the second coalesced request
428 assertTrue ("isCompleted", subRequest2
.isCompleted());
429 assertFalse("isFailed", subRequest2
.isFailed());
430 assertTrue ("isCancelled", subRequest2
.isCancelled());
433 // ------------------------------------------------------------------------
435 // ------------------------------------------------------------------------
437 private static final String DIRECTORY
= "testfiles";
438 private static final String TEST_STREAM
= "A-Test-10K";
439 private static final int NB_EVENTS
= 5000;
440 private static final int BLOCK_SIZE
= 100;
442 // Initialize the test trace
443 private TmfTraceStub fTrace
= null;
444 private synchronized TmfTraceStub
setupTrace(String path
) {
445 if (fTrace
== null) {
447 URL location
= FileLocator
.find(TmfCoreTestPlugin
.getDefault().getBundle(), new Path(path
), null);
448 File test
= new File(FileLocator
.toFileURL(location
).toURI());
449 fTrace
= new TmfTraceStub(test
.getPath(), 500);
450 } catch (TmfTraceException e
) {
452 } catch (URISyntaxException e
) {
454 } catch (IOException e
) {
461 Vector
<ITmfEvent
> requestedEvents1
;
462 Vector
<ITmfEvent
> requestedEvents2
;
463 Vector
<ITmfEvent
> requestedEvents3
;
465 TmfEventRequest request1
;
466 TmfEventRequest request2
;
467 TmfEventRequest request3
;
469 ITmfDataProvider
[] providers
;
471 private static class TmfTestTriggerSignal
extends TmfSignal
{
472 public final boolean forceCancel
;
473 public final long fIndex
;
474 public TmfTestTriggerSignal(Object source
, long index
, boolean cancel
) {
476 forceCancel
= cancel
;
482 public void trigger(final TmfTestTriggerSignal signal
) {
484 TmfTimeRange range
= new TmfTimeRange(TmfTimestamp
.BIG_BANG
, TmfTimestamp
.BIG_CRUNCH
);
485 final long REQUEST_OFFSET
= 1000;
487 requestedEvents1
= new Vector
<ITmfEvent
>();
488 request1
= new TmfEventRequest(TmfEvent
.class, range
, signal
.fIndex
, NB_EVENTS
, BLOCK_SIZE
) {
491 public void handleData(ITmfEvent event
) {
492 super.handleData(event
);
493 if (!isCompleted()) {
494 requestedEvents1
.add(event
);
495 if (++nbRead
>= BLOCK_SIZE
&& signal
.forceCancel
) {
502 requestedEvents2
= new Vector
<ITmfEvent
>();
503 request2
= new TmfEventRequest(TmfEvent
.class, range
, signal
.fIndex
+ REQUEST_OFFSET
, NB_EVENTS
, BLOCK_SIZE
) {
505 public void handleData(ITmfEvent event
) {
506 super.handleData(event
);
507 if (!isCompleted()) {
508 requestedEvents2
.add(event
);
513 requestedEvents3
= new Vector
<ITmfEvent
>();
514 request3
= new TmfEventRequest(TmfEvent
.class, range
, signal
.fIndex
+ 2 * REQUEST_OFFSET
, NB_EVENTS
, BLOCK_SIZE
) {
516 public void handleData(ITmfEvent event
) {
517 super.handleData(event
);
518 if (!isCompleted()) {
519 requestedEvents3
.add(event
);
524 providers
= TmfProviderManager
.getProviders(TmfEvent
.class, TmfTraceStub
.class);
525 providers
[0].sendRequest(request1
);
526 providers
[0].sendRequest(request2
);
527 providers
[0].sendRequest(request3
);
530 public void runCoalescedRequest(long startIndex
) throws InterruptedException
{
532 fTrace
= setupTrace(DIRECTORY
+ File
.separator
+ TEST_STREAM
);
534 TmfSignalManager
.register(this);
535 TmfTestTriggerSignal signal
= new TmfTestTriggerSignal(this, startIndex
, false);
536 TmfSignalManager
.dispatchSignal(signal
);
538 request1
.waitForCompletion();
539 request2
.waitForCompletion();
540 request3
.waitForCompletion();
543 assertEquals("Request1: nbEvents", NB_EVENTS
, requestedEvents1
.size());
544 assertTrue ("Request1: isCompleted", request1
.isCompleted());
545 assertFalse ("Request1: isCancelled", request1
.isCancelled());
547 assertEquals("Request2: nbEvents", NB_EVENTS
, requestedEvents2
.size());
548 assertTrue ("Request2: isCompleted", request2
.isCompleted());
549 assertFalse ("Request2: isCancelled", request2
.isCancelled());
551 assertEquals("Request3: nbEvents", NB_EVENTS
, requestedEvents3
.size());
552 assertTrue ("Request3: isCompleted", request3
.isCompleted());
553 assertFalse ("Request3: isCancelled", request3
.isCancelled());
555 // Ensure that we have distinct events.
556 // Don't go overboard: we are not validating the stub!
557 for (int i
= 0; i
< NB_EVENTS
; i
++) {
558 assertEquals("Distinct events", i
+ 1 + request1
.getIndex(), requestedEvents1
.get(i
).getTimestamp().getValue());
559 assertEquals("Distinct events", i
+ 1 + request2
.getIndex(), requestedEvents2
.get(i
).getTimestamp().getValue());
560 assertEquals("Distinct events", i
+ 1 + request3
.getIndex(), requestedEvents3
.get(i
).getTimestamp().getValue());
564 TmfSignalManager
.deregister(this);
570 public void testCoalescedRequest() throws InterruptedException
{
571 runCoalescedRequest(0);
572 runCoalescedRequest(1);
573 runCoalescedRequest(5);
576 public void testCancelCoalescedRequest() throws InterruptedException
{
578 fTrace
= setupTrace(DIRECTORY
+ File
.separator
+ TEST_STREAM
);
580 TmfSignalManager
.register(this);
581 TmfTestTriggerSignal signal
= new TmfTestTriggerSignal(this, 0, true);
582 TmfSignalManager
.dispatchSignal(signal
);
584 request1
.waitForCompletion();
585 request2
.waitForCompletion();
586 request3
.waitForCompletion();
588 assertEquals("Request1: nbEvents", BLOCK_SIZE
, requestedEvents1
.size());
589 assertTrue ("Request1: isCompleted", request1
.isCompleted());
590 assertTrue ("Request1: isCancelled", request1
.isCancelled());
592 assertEquals("Request2: nbEvents", NB_EVENTS
, requestedEvents2
.size());
593 assertTrue ("Request2: isCompleted", request2
.isCompleted());
594 assertFalse ("Request2: isCancelled", request2
.isCancelled());
596 assertEquals("Request3: nbEvents", NB_EVENTS
, requestedEvents3
.size());
597 assertTrue ("Request3: isCompleted", request3
.isCompleted());
598 assertFalse ("Request3: isCancelled", request3
.isCancelled());
600 // Ensure that we have distinct events.
601 // Don't go overboard: we are not validating the stub!
602 for (int i
= 0; i
< BLOCK_SIZE
; i
++) {
603 assertEquals("Distinct events", i
+ 1 + request1
.getIndex(), requestedEvents1
.get(i
).getTimestamp().getValue());
605 for (int i
= 0; i
< NB_EVENTS
; i
++) {
606 assertEquals("Distinct events", i
+ 1 + request2
.getIndex(), requestedEvents2
.get(i
).getTimestamp().getValue());
607 assertEquals("Distinct events", i
+ 1 + request3
.getIndex(), requestedEvents3
.get(i
).getTimestamp().getValue());
610 TmfSignalManager
.deregister(this);
615 // ------------------------------------------------------------------------
617 // ------------------------------------------------------------------------