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
.TmfEvent
;
30 import org
.eclipse
.linuxtools
.tmf
.core
.event
.TmfTimeRange
;
31 import org
.eclipse
.linuxtools
.tmf
.core
.event
.TmfTimestamp
;
32 import org
.eclipse
.linuxtools
.tmf
.core
.exceptions
.TmfTraceException
;
33 import org
.eclipse
.linuxtools
.tmf
.core
.request
.ITmfDataRequest
.ExecutionType
;
34 import org
.eclipse
.linuxtools
.tmf
.core
.request
.TmfEventRequest
;
35 import org
.eclipse
.linuxtools
.tmf
.core
.signal
.TmfSignal
;
36 import org
.eclipse
.linuxtools
.tmf
.core
.signal
.TmfSignalHandler
;
37 import org
.eclipse
.linuxtools
.tmf
.core
.signal
.TmfSignalManager
;
38 import org
.eclipse
.linuxtools
.tmf
.core
.tests
.TmfCoreTestPlugin
;
39 import org
.eclipse
.linuxtools
.tmf
.tests
.stubs
.request
.TmfEventRequestStub
;
40 import org
.eclipse
.linuxtools
.tmf
.tests
.stubs
.trace
.TmfTraceStub
;
43 * <b><u>TmfCoalescedEventRequestTest</u></b>
45 * Test suite for the TmfCoalescedEventRequest class.
47 @SuppressWarnings({ "nls" })
48 public class TmfCoalescedEventRequestTest
extends TestCase
{
50 // ------------------------------------------------------------------------
52 // ------------------------------------------------------------------------
54 private TmfTimeRange range1
= new TmfTimeRange(TmfTimeRange
.ETERNITY
);
55 private TmfTimeRange range2
= new TmfTimeRange(new TmfTimestamp(), TmfTimestamp
.BIG_CRUNCH
);
57 private TmfCoalescedEventRequest
<TmfEvent
> fRequest1
;
58 private TmfCoalescedEventRequest
<TmfEvent
> fRequest2
;
59 private TmfCoalescedEventRequest
<TmfEvent
> fRequest3
;
60 private TmfCoalescedEventRequest
<TmfEvent
> fRequest4
;
62 private TmfCoalescedEventRequest
<TmfEvent
> fRequest1b
;
63 private TmfCoalescedEventRequest
<TmfEvent
> fRequest1c
;
65 private int fRequestCount
;
67 // ------------------------------------------------------------------------
69 // ------------------------------------------------------------------------
71 public TmfCoalescedEventRequestTest(String name
) {
76 public void setUp() throws Exception
{
78 TmfEventRequest
.reset();
79 fRequest1
= new TmfCoalescedEventRequest
<TmfEvent
>(TmfEvent
.class, range1
, 100, 200);
80 fRequest2
= new TmfCoalescedEventRequest
<TmfEvent
>(TmfEvent
.class, range2
, 100, 200);
81 fRequest3
= new TmfCoalescedEventRequest
<TmfEvent
>(TmfEvent
.class, range2
, 200, 200);
82 fRequest4
= new TmfCoalescedEventRequest
<TmfEvent
>(TmfEvent
.class, range2
, 200, 300);
84 fRequest1b
= new TmfCoalescedEventRequest
<TmfEvent
>(TmfEvent
.class, range1
, 100, 200);
85 fRequest1c
= new TmfCoalescedEventRequest
<TmfEvent
>(TmfEvent
.class, range1
, 100, 200);
87 fRequestCount
= fRequest1c
.getRequestId() + 1;
91 public void tearDown() throws Exception
{
95 private TmfCoalescedEventRequest
<TmfEvent
> setupTestRequest(final boolean[] flags
) {
97 TmfCoalescedEventRequest
<TmfEvent
> request
= new TmfCoalescedEventRequest
<TmfEvent
>(TmfEvent
.class, range1
, 100, 200) {
99 public void handleCompleted() {
100 super.handleCompleted();
104 public void handleSuccess() {
105 super.handleSuccess();
109 public void handleFailure() {
110 super.handleFailure();
114 public void handleCancel() {
115 super.handleCancel();
122 // ------------------------------------------------------------------------
124 // ------------------------------------------------------------------------
126 public void testTmfCoalescedEventRequest() {
127 TmfCoalescedEventRequest
<TmfEvent
> request
= new TmfCoalescedEventRequest
<TmfEvent
>(TmfEvent
.class);
129 assertEquals("getRequestId", fRequestCount
++, request
.getRequestId());
130 assertEquals("getDataType", TmfEvent
.class, request
.getDataType());
132 assertEquals("getRange", range1
, request
.getRange());
133 assertEquals("getNbRequestedEvents", TmfEventRequest
.ALL_DATA
, request
.getNbRequested());
135 assertFalse("isCompleted", request
.isCompleted());
136 assertFalse("isFailed", request
.isFailed());
137 assertFalse("isCancelled", request
.isCancelled());
139 assertEquals("getNbRead", 0, request
.getNbRead());
142 public void testTmfCoalescedEventRequestIndex() {
143 TmfCoalescedEventRequest
<TmfEvent
> request
= new TmfCoalescedEventRequest
<TmfEvent
>(TmfEvent
.class, range1
);
145 assertEquals("getRequestId", fRequestCount
++, request
.getRequestId());
146 assertEquals("getDataType", TmfEvent
.class, request
.getDataType());
148 assertEquals("getRange", range1
, request
.getRange());
149 assertEquals("getNbRequestedEvents", TmfEventRequest
.ALL_DATA
, request
.getNbRequested());
151 assertFalse("isCompleted", request
.isCompleted());
152 assertFalse("isFailed", request
.isFailed());
153 assertFalse("isCancelled", request
.isCancelled());
155 assertEquals("getNbRead", 0, request
.getNbRead());
158 public void testTmfCoalescedEventRequestIndexNbRequested() {
159 TmfCoalescedEventRequest
<TmfEvent
> request
= new TmfCoalescedEventRequest
<TmfEvent
>(TmfEvent
.class, range1
, 100);
161 assertEquals("getRequestId", fRequestCount
++, request
.getRequestId());
162 assertEquals("getDataType", TmfEvent
.class, request
.getDataType());
164 assertEquals("getRange", range1
, request
.getRange());
165 assertEquals("getNbRequestedEvents", 100, request
.getNbRequested());
167 assertFalse("isCompleted", request
.isCompleted());
168 assertFalse("isFailed", request
.isFailed());
169 assertFalse("isCancelled", request
.isCancelled());
171 assertEquals("getNbRead", 0, request
.getNbRead());
174 public void testTmfCoalescedEventRequestIndexNbEventsBlocksize() {
175 TmfCoalescedEventRequest
<TmfEvent
> request
= new TmfCoalescedEventRequest
<TmfEvent
>(TmfEvent
.class, range1
, 100, 200);
177 assertEquals("getRequestId", fRequestCount
++, request
.getRequestId());
178 assertEquals("getDataType", TmfEvent
.class, request
.getDataType());
180 assertEquals("getRange", range1
, request
.getRange());
181 assertEquals("getNbRequestedEvents", 100, request
.getNbRequested());
183 assertFalse("isCompleted", request
.isCompleted());
184 assertFalse("isFailed", request
.isFailed());
185 assertFalse("isCancelled", request
.isCancelled());
187 assertEquals("getNbRead", 0, request
.getNbRead());
190 // ------------------------------------------------------------------------
192 // ------------------------------------------------------------------------
194 public void testEqualsReflexivity() throws Exception
{
195 assertTrue("equals", fRequest1
.equals(fRequest1
));
196 assertTrue("equals", fRequest2
.equals(fRequest2
));
198 assertFalse("equals", fRequest1
.equals(fRequest2
));
199 assertFalse("equals", fRequest2
.equals(fRequest1
));
202 public void testEqualsSymmetry() throws Exception
{
203 assertTrue("equals", fRequest1
.equals(fRequest1b
));
204 assertTrue("equals", fRequest1b
.equals(fRequest1
));
206 assertFalse("equals", fRequest1
.equals(fRequest3
));
207 assertFalse("equals", fRequest2
.equals(fRequest3
));
208 assertFalse("equals", fRequest3
.equals(fRequest1
));
209 assertFalse("equals", fRequest3
.equals(fRequest2
));
212 public void testEqualsTransivity() throws Exception
{
213 assertTrue("equals", fRequest1
.equals(fRequest1b
));
214 assertTrue("equals", fRequest1b
.equals(fRequest1c
));
215 assertTrue("equals", fRequest1
.equals(fRequest1c
));
218 public void testEqualsNull() throws Exception
{
219 assertFalse("equals", fRequest1
.equals(null));
220 assertFalse("equals", fRequest2
.equals(null));
223 public void testEqualsSuper() throws Exception
{
224 TmfCoalescedDataRequest
<TmfEvent
> dataRequest1
= new TmfCoalescedDataRequest
<TmfEvent
>(
225 fRequest1
.getDataType(), fRequest1
.getIndex(), fRequest1
.getNbRequested());
226 TmfCoalescedDataRequest
<TmfEvent
> dataRequest2
= new TmfCoalescedDataRequest
<TmfEvent
>(
227 fRequest1
.getDataType(), fRequest1
.getIndex(), fRequest1
.getNbRequested());
228 TmfCoalescedDataRequest
<TmfEvent
> dataRequest3
= new TmfCoalescedDataRequest
<TmfEvent
>(
229 fRequest3
.getDataType(), fRequest3
.getIndex(), fRequest3
.getNbRequested());
231 assertTrue("equals", fRequest1
.equals(dataRequest2
));
232 assertTrue("equals", fRequest2
.equals(dataRequest1
));
233 assertFalse("equals", fRequest1
.equals(dataRequest3
));
234 assertFalse("equals", fRequest3
.equals(dataRequest1
));
237 // ------------------------------------------------------------------------
239 // ------------------------------------------------------------------------
241 public void testHashCode() throws Exception
{
242 assertTrue("hashCode", fRequest1
.hashCode() == fRequest1
.hashCode());
243 assertTrue("hashCode", fRequest2
.hashCode() == fRequest2
.hashCode());
244 assertTrue("hashCode", fRequest1
.hashCode() != fRequest2
.hashCode());
247 // ------------------------------------------------------------------------
249 // ------------------------------------------------------------------------
251 public void testToString() {
252 String expected1
= "[TmfCoalescedEventRequest(0,TmfEvent," + range1
+ ",0,100,200)]";
253 String expected2
= "[TmfCoalescedEventRequest(1,TmfEvent," + range2
+ ",0,100,200)]";
254 String expected3
= "[TmfCoalescedEventRequest(2,TmfEvent," + range2
+ ",0,200,200)]";
255 String expected4
= "[TmfCoalescedEventRequest(3,TmfEvent," + range2
+ ",0,200,300)]";
257 assertEquals("toString", expected1
, fRequest1
.toString());
258 assertEquals("toString", expected2
, fRequest2
.toString());
259 assertEquals("toString", expected3
, fRequest3
.toString());
260 assertEquals("toString", expected4
, fRequest4
.toString());
263 // ------------------------------------------------------------------------
265 // ------------------------------------------------------------------------
267 public void testIsCompatible() {
268 TmfCoalescedEventRequest
<TmfEvent
> coalescedRequest
= new TmfCoalescedEventRequest
<TmfEvent
>(TmfEvent
.class, range1
, 100, 200);
269 TmfEventRequest
<TmfEvent
> request1
= new TmfEventRequestStub
<TmfEvent
>(TmfEvent
.class, range1
, 100, 200);
270 TmfEventRequest
<TmfEvent
> request2
= new TmfEventRequestStub
<TmfEvent
>(TmfEvent
.class, range2
, 100, 200);
271 TmfEventRequest
<TmfEvent
> request3
= new TmfEventRequestStub
<TmfEvent
>(TmfEvent
.class, range1
, 101, 200);
273 assertTrue("isCompatible", coalescedRequest
.isCompatible(request1
));
274 assertTrue("isCompatible", coalescedRequest
.isCompatible(request2
));
275 assertTrue("isCompatible", coalescedRequest
.isCompatible(request3
));
278 // ------------------------------------------------------------------------
280 // ------------------------------------------------------------------------
282 public void testAddEvent1() {
283 TmfCoalescedEventRequest
<TmfEvent
> coalescedRequest
= new TmfCoalescedEventRequest
<TmfEvent
>(TmfEvent
.class, range1
, 0, 2147483647, 200, ExecutionType
.FOREGROUND
);
284 TmfEventRequest
<TmfEvent
> request1
= new TmfEventRequestStub
<TmfEvent
>(TmfEvent
.class, range1
, 0, 2147483647, 200);
285 TmfEventRequest
<TmfEvent
> request2
= new TmfEventRequestStub
<TmfEvent
>(TmfEvent
.class, range1
, 1, 2147483647, 200);
287 assertTrue("isCompatible", coalescedRequest
.isCompatible(request1
));
288 assertTrue("isCompatible", coalescedRequest
.isCompatible(request2
));
290 coalescedRequest
.addRequest(request1
);
291 coalescedRequest
.addRequest(request2
);
293 assertEquals("addRequest", 0, coalescedRequest
.getIndex());
294 assertEquals("addRequest", 2147483647, coalescedRequest
.getNbRequested());
295 assertEquals("addRequest", 200, coalescedRequest
.getBlockSize());
299 public void testAddEvent2() {
300 TmfCoalescedEventRequest
<TmfEvent
> coalescedRequest
= new TmfCoalescedEventRequest
<TmfEvent
>(TmfEvent
.class, range1
, 1, 2147483647, 200, ExecutionType
.FOREGROUND
);
301 TmfEventRequest
<TmfEvent
> request1
= new TmfEventRequestStub
<TmfEvent
>(TmfEvent
.class, range1
, 1, 2147483647, 200);
302 TmfEventRequest
<TmfEvent
> request2
= new TmfEventRequestStub
<TmfEvent
>(TmfEvent
.class, range1
, 0, 2147483647, 200);
304 assertTrue("isCompatible", coalescedRequest
.isCompatible(request1
));
305 assertTrue("isCompatible", coalescedRequest
.isCompatible(request2
));
307 coalescedRequest
.addRequest(request1
);
308 coalescedRequest
.addRequest(request2
);
310 assertEquals("addRequest", 0, coalescedRequest
.getIndex());
311 assertEquals("addRequest", 2147483647, coalescedRequest
.getNbRequested());
312 assertEquals("addRequest", 200, coalescedRequest
.getBlockSize());
316 // ------------------------------------------------------------------------
318 // ------------------------------------------------------------------------
320 public void testDone() {
323 final boolean[] crFlags
= new boolean[4];
324 TmfCoalescedEventRequest
<TmfEvent
> request
= setupTestRequest(crFlags
);
325 TmfEventRequest
<TmfEvent
> subRequest1
= new TmfEventRequestStub
<TmfEvent
>(TmfEvent
.class, range1
, 100, 200);
326 TmfEventRequest
<TmfEvent
> subRequest2
= new TmfEventRequestStub
<TmfEvent
>(TmfEvent
.class, range1
, 100, 200);
327 request
.addRequest(subRequest1
);
328 request
.addRequest(subRequest2
);
332 // Validate the coalescing request
333 assertTrue ("isCompleted", request
.isCompleted());
334 assertFalse("isFailed", request
.isFailed());
335 assertFalse("isCancelled", request
.isCancelled());
337 assertTrue ("handleCompleted", crFlags
[0]);
338 assertTrue ("handleSuccess", crFlags
[1]);
339 assertFalse("handleFailure", crFlags
[2]);
340 assertFalse("handleCancel", crFlags
[3]);
342 // Validate the first coalesced request
343 assertTrue ("isCompleted", subRequest1
.isCompleted());
344 assertFalse("isFailed", subRequest1
.isFailed());
345 assertFalse("isCancelled", subRequest1
.isCancelled());
347 // Validate the second coalesced request
348 assertTrue ("isCompleted", subRequest2
.isCompleted());
349 assertFalse("isFailed", subRequest2
.isFailed());
350 assertFalse("isCancelled", subRequest2
.isCancelled());
353 // ------------------------------------------------------------------------
355 // ------------------------------------------------------------------------
357 public void testFail() {
359 final boolean[] crFlags
= new boolean[4];
360 TmfCoalescedEventRequest
<TmfEvent
> request
= setupTestRequest(crFlags
);
361 TmfEventRequest
<TmfEvent
> subRequest1
= new TmfEventRequestStub
<TmfEvent
>(TmfEvent
.class, range1
, 100, 200);
362 TmfEventRequest
<TmfEvent
> subRequest2
= new TmfEventRequestStub
<TmfEvent
>(TmfEvent
.class, range1
, 100, 200);
363 request
.addRequest(subRequest1
);
364 request
.addRequest(subRequest2
);
368 // Validate the coalescing request
369 assertTrue ("isCompleted", request
.isCompleted());
370 assertTrue ("isFailed", request
.isFailed());
371 assertFalse("isCancelled", request
.isCancelled());
373 assertTrue ("handleCompleted", crFlags
[0]);
374 assertFalse("handleSuccess", crFlags
[1]);
375 assertTrue ("handleFailure", crFlags
[2]);
376 assertFalse("handleCancel", crFlags
[3]);
378 // Validate the first coalesced request
379 assertTrue ("isCompleted", subRequest1
.isCompleted());
380 assertTrue ("isFailed", subRequest1
.isFailed());
381 assertFalse("isCancelled", subRequest1
.isCancelled());
383 // Validate the second coalesced request
384 assertTrue ("isCompleted", subRequest2
.isCompleted());
385 assertTrue ("isFailed", subRequest2
.isFailed());
386 assertFalse("isCancelled", subRequest2
.isCancelled());
389 // ------------------------------------------------------------------------
391 // ------------------------------------------------------------------------
393 public void testCancel() {
395 final boolean[] crFlags
= new boolean[4];
396 TmfCoalescedEventRequest
<TmfEvent
> request
= setupTestRequest(crFlags
);
397 TmfEventRequest
<TmfEvent
> subRequest1
= new TmfEventRequestStub
<TmfEvent
>(TmfEvent
.class, range1
, 100, 200);
398 TmfEventRequest
<TmfEvent
> subRequest2
= new TmfEventRequestStub
<TmfEvent
>(TmfEvent
.class, range1
, 100, 200);
399 request
.addRequest(subRequest1
);
400 request
.addRequest(subRequest2
);
404 // Validate the coalescing request
405 assertTrue ("isCompleted", request
.isCompleted());
406 assertFalse("isFailed", request
.isFailed());
407 assertTrue ("isCancelled", request
.isCancelled());
409 assertTrue ("handleCompleted", crFlags
[0]);
410 assertFalse("handleSuccess", crFlags
[1]);
411 assertFalse("handleFailure", crFlags
[2]);
412 assertTrue ("handleCancel", crFlags
[3]);
414 // Validate the first coalesced request
415 assertTrue ("isCompleted", subRequest1
.isCompleted());
416 assertFalse("isFailed", subRequest1
.isFailed());
417 assertTrue ("isCancelled", subRequest1
.isCancelled());
419 // Validate the second coalesced request
420 assertTrue ("isCompleted", subRequest2
.isCompleted());
421 assertFalse("isFailed", subRequest2
.isFailed());
422 assertTrue ("isCancelled", subRequest2
.isCancelled());
425 // ------------------------------------------------------------------------
427 // ------------------------------------------------------------------------
429 // ------------------------------------------------------------------------
431 // ------------------------------------------------------------------------
433 private static final String DIRECTORY
= "testfiles";
434 private static final String TEST_STREAM
= "A-Test-10K";
435 private static final int NB_EVENTS
= 10000;
436 private static final int BLOCK_SIZE
= 100;
438 // Initialize the test trace
439 private TmfTraceStub fTrace
= null;
440 private synchronized TmfTraceStub
setupTrace(String path
) {
441 if (fTrace
== null) {
443 URL location
= FileLocator
.find(TmfCoreTestPlugin
.getDefault().getBundle(), new Path(path
), null);
444 File test
= new File(FileLocator
.toFileURL(location
).toURI());
445 fTrace
= new TmfTraceStub(test
.getPath(), 500);
446 } catch (TmfTraceException e
) {
448 } catch (URISyntaxException e
) {
450 } catch (IOException e
) {
457 Vector
<TmfEvent
> requestedEvents1
;
458 Vector
<TmfEvent
> requestedEvents2
;
459 Vector
<TmfEvent
> requestedEvents3
;
461 TmfEventRequest
<TmfEvent
> request1
;
462 TmfEventRequest
<TmfEvent
> request2
;
463 TmfEventRequest
<TmfEvent
> request3
;
465 ITmfDataProvider
<TmfEvent
>[] providers
;
467 private static class TmfTestTriggerSignal
extends TmfSignal
{
468 public final boolean forceCancel
;
469 public TmfTestTriggerSignal(Object source
, boolean cancel
) {
471 forceCancel
= cancel
;
476 @SuppressWarnings("unchecked")
478 public void trigger(final TmfTestTriggerSignal signal
) {
480 TmfTimeRange range
= new TmfTimeRange(TmfTimestamp
.BIG_BANG
, TmfTimestamp
.BIG_CRUNCH
);
482 requestedEvents1
= new Vector
<TmfEvent
>();
483 request1
= new TmfEventRequest
<TmfEvent
>(TmfEvent
.class, range
, NB_EVENTS
, BLOCK_SIZE
) {
486 public void handleData(TmfEvent event
) {
487 super.handleData(event
);
488 if (!isCompleted()) {
489 requestedEvents1
.add(event
);
490 if (++nbRead
>= BLOCK_SIZE
&& signal
.forceCancel
)
496 requestedEvents2
= new Vector
<TmfEvent
>();
497 request2
= new TmfEventRequest
<TmfEvent
>(TmfEvent
.class, range
, NB_EVENTS
, BLOCK_SIZE
) {
499 public void handleData(TmfEvent event
) {
500 super.handleData(event
);
501 if (!isCompleted()) {
502 requestedEvents2
.add(event
);
507 requestedEvents3
= new Vector
<TmfEvent
>();
508 request3
= new TmfEventRequest
<TmfEvent
>(TmfEvent
.class, range
, NB_EVENTS
, BLOCK_SIZE
) {
510 public void handleData(TmfEvent event
) {
511 super.handleData(event
);
512 if (!isCompleted()) {
513 requestedEvents3
.add(event
);
518 providers
= (ITmfDataProvider
<TmfEvent
>[]) TmfProviderManager
.getProviders(TmfEvent
.class, TmfTraceStub
.class);
519 providers
[0].sendRequest(request1
);
520 providers
[0].sendRequest(request2
);
521 providers
[0].sendRequest(request3
);
524 public void testCoalescedRequest() throws Exception
{
526 fTrace
= setupTrace(DIRECTORY
+ File
.separator
+ TEST_STREAM
);
528 TmfSignalManager
.register(this);
529 TmfTestTriggerSignal signal
= new TmfTestTriggerSignal(this, false);
530 TmfSignalManager
.dispatchSignal(signal
);
532 request1
.waitForCompletion();
533 request2
.waitForCompletion();
534 request3
.waitForCompletion();
536 assertEquals("Request1: nbEvents", NB_EVENTS
, requestedEvents1
.size());
537 assertTrue ("Request1: isCompleted", request1
.isCompleted());
538 assertFalse ("Request1: isCancelled", request1
.isCancelled());
540 assertEquals("Request2: nbEvents", NB_EVENTS
, requestedEvents2
.size());
541 assertTrue ("Request2: isCompleted", request2
.isCompleted());
542 assertFalse ("Request2: isCancelled", request2
.isCancelled());
544 assertEquals("Request3: nbEvents", NB_EVENTS
, requestedEvents3
.size());
545 assertTrue ("Request3: isCompleted", request3
.isCompleted());
546 assertFalse ("Request3: isCancelled", request3
.isCancelled());
548 // Ensure that we have distinct events.
549 // Don't go overboard: we are not validating the stub!
550 for (int i
= 0; i
< NB_EVENTS
; i
++) {
551 assertEquals("Distinct events", i
+1, requestedEvents1
.get(i
).getTimestamp().getValue());
552 assertEquals("Distinct events", i
+1, requestedEvents2
.get(i
).getTimestamp().getValue());
553 assertEquals("Distinct events", i
+1, requestedEvents3
.get(i
).getTimestamp().getValue());
556 TmfSignalManager
.deregister(this);
561 public void testCancelCoalescedRequest() throws Exception
{
563 fTrace
= setupTrace(DIRECTORY
+ File
.separator
+ TEST_STREAM
);
565 TmfSignalManager
.register(this);
566 TmfTestTriggerSignal signal
= new TmfTestTriggerSignal(this, true);
567 TmfSignalManager
.dispatchSignal(signal
);
569 request1
.waitForCompletion();
570 request2
.waitForCompletion();
571 request3
.waitForCompletion();
573 assertEquals("Request1: nbEvents", BLOCK_SIZE
, requestedEvents1
.size());
574 assertTrue ("Request1: isCompleted", request1
.isCompleted());
575 assertTrue ("Request1: isCancelled", request1
.isCancelled());
577 assertEquals("Request2: nbEvents", NB_EVENTS
, requestedEvents2
.size());
578 assertTrue ("Request2: isCompleted", request2
.isCompleted());
579 assertFalse ("Request2: isCancelled", request2
.isCancelled());
581 assertEquals("Request3: nbEvents", NB_EVENTS
, requestedEvents3
.size());
582 assertTrue ("Request3: isCompleted", request3
.isCompleted());
583 assertFalse ("Request3: isCancelled", request3
.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
< NB_EVENTS
; i
++) {
588 assertEquals("Distinct events", i
+1, requestedEvents2
.get(i
).getTimestamp().getValue());
589 assertEquals("Distinct events", i
+1, requestedEvents3
.get(i
).getTimestamp().getValue());
592 TmfSignalManager
.deregister(this);