1 /*******************************************************************************
2 * Copyright (c) 2009, 2013 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 * Alexandre Montplaisir - Port to JUnit4
12 *******************************************************************************/
14 package org
.eclipse
.linuxtools
.tmf
.core
.tests
.request
;
16 import static org
.junit
.Assert
.assertEquals
;
17 import static org
.junit
.Assert
.assertFalse
;
18 import static org
.junit
.Assert
.assertTrue
;
21 import java
.io
.IOException
;
22 import java
.net
.URISyntaxException
;
24 import java
.util
.Vector
;
26 import org
.eclipse
.core
.runtime
.FileLocator
;
27 import org
.eclipse
.core
.runtime
.Path
;
28 import org
.eclipse
.linuxtools
.internal
.tmf
.core
.component
.TmfProviderManager
;
29 import org
.eclipse
.linuxtools
.internal
.tmf
.core
.request
.TmfCoalescedDataRequest
;
30 import org
.eclipse
.linuxtools
.internal
.tmf
.core
.request
.TmfCoalescedEventRequest
;
31 import org
.eclipse
.linuxtools
.tmf
.core
.component
.ITmfDataProvider
;
32 import org
.eclipse
.linuxtools
.tmf
.core
.event
.ITmfEvent
;
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
.core
.timestamp
.TmfTimeRange
;
42 import org
.eclipse
.linuxtools
.tmf
.core
.timestamp
.TmfTimestamp
;
43 import org
.eclipse
.linuxtools
.tmf
.tests
.stubs
.request
.TmfEventRequestStub
;
44 import org
.eclipse
.linuxtools
.tmf
.tests
.stubs
.trace
.TmfTraceStub
;
45 import org
.junit
.Before
;
46 import org
.junit
.Test
;
49 * Test suite for the TmfCoalescedEventRequest class.
51 @SuppressWarnings("javadoc")
52 public class TmfCoalescedEventRequestTest
{
54 // ------------------------------------------------------------------------
56 // ------------------------------------------------------------------------
58 private final TmfTimeRange range1
= new TmfTimeRange(TmfTimeRange
.ETERNITY
);
59 private final TmfTimeRange range2
= new TmfTimeRange(new TmfTimestamp(), TmfTimestamp
.BIG_CRUNCH
);
61 private TmfCoalescedEventRequest fRequest1
;
62 private TmfCoalescedEventRequest fRequest2
;
63 private TmfCoalescedEventRequest fRequest3
;
64 private TmfCoalescedEventRequest fRequest4
;
66 private TmfCoalescedEventRequest fRequest1b
;
67 private TmfCoalescedEventRequest fRequest1c
;
69 private int fRequestCount
;
71 // ------------------------------------------------------------------------
73 // ------------------------------------------------------------------------
77 TmfDataRequest
.reset();
78 fRequest1
= new TmfCoalescedEventRequest(ITmfEvent
.class, range1
, 0, 100, ExecutionType
.FOREGROUND
);
79 fRequest2
= new TmfCoalescedEventRequest(ITmfEvent
.class, range2
, 0, 100, ExecutionType
.FOREGROUND
);
80 fRequest3
= new TmfCoalescedEventRequest(ITmfEvent
.class, range2
, 0, 200, ExecutionType
.FOREGROUND
);
81 fRequest4
= new TmfCoalescedEventRequest(ITmfEvent
.class, range2
, 0, 200, ExecutionType
.FOREGROUND
);
83 fRequest1b
= new TmfCoalescedEventRequest(ITmfEvent
.class, range1
, 0, 100, ExecutionType
.FOREGROUND
);
84 fRequest1c
= new TmfCoalescedEventRequest(ITmfEvent
.class, range1
, 0, 100, ExecutionType
.FOREGROUND
);
86 fRequestCount
= fRequest1c
.getRequestId() + 1;
89 private TmfCoalescedEventRequest
setupTestRequest(final boolean[] flags
) {
91 TmfCoalescedEventRequest request
= new TmfCoalescedEventRequest(ITmfEvent
.class, range1
, 0, 100, ExecutionType
.FOREGROUND
) {
93 public void handleCompleted() {
94 super.handleCompleted();
99 public void handleSuccess() {
100 super.handleSuccess();
105 public void handleFailure() {
106 super.handleFailure();
111 public void handleCancel() {
112 super.handleCancel();
119 // ------------------------------------------------------------------------
121 // ------------------------------------------------------------------------
124 public void testTmfCoalescedEventRequestIndexNbEventsBlocksize() {
125 TmfCoalescedEventRequest request
= new TmfCoalescedEventRequest(ITmfEvent
.class, range1
, 0, 100, ExecutionType
.FOREGROUND
);
127 assertEquals("getRequestId", fRequestCount
++, request
.getRequestId());
128 assertEquals("getDataType", ITmfEvent
.class, request
.getDataType());
130 assertEquals("getRange", range1
, request
.getRange());
131 assertEquals("getNbRequestedEvents", 100, request
.getNbRequested());
133 assertFalse("isCompleted", request
.isCompleted());
134 assertFalse("isFailed", request
.isFailed());
135 assertFalse("isCancelled", request
.isCancelled());
137 assertEquals("getNbRead", 0, request
.getNbRead());
140 // ------------------------------------------------------------------------
142 // ------------------------------------------------------------------------
145 public void testEqualsReflexivity() {
146 assertTrue("equals", fRequest1
.equals(fRequest1
));
147 assertTrue("equals", fRequest2
.equals(fRequest2
));
149 assertFalse("equals", fRequest1
.equals(fRequest2
));
150 assertFalse("equals", fRequest2
.equals(fRequest1
));
154 public void testEqualsSymmetry() {
155 assertTrue("equals", fRequest1
.equals(fRequest1b
));
156 assertTrue("equals", fRequest1b
.equals(fRequest1
));
158 assertFalse("equals", fRequest1
.equals(fRequest3
));
159 assertFalse("equals", fRequest2
.equals(fRequest3
));
160 assertFalse("equals", fRequest3
.equals(fRequest1
));
161 assertFalse("equals", fRequest3
.equals(fRequest2
));
165 public void testEqualsTransivity() {
166 assertTrue("equals", fRequest1
.equals(fRequest1b
));
167 assertTrue("equals", fRequest1b
.equals(fRequest1c
));
168 assertTrue("equals", fRequest1
.equals(fRequest1c
));
172 public void testEqualsNull() {
173 assertFalse("equals", fRequest1
.equals(null));
174 assertFalse("equals", fRequest2
.equals(null));
178 public void testEqualsSuper() {
179 TmfCoalescedDataRequest dataRequest1
= new TmfCoalescedDataRequest(
180 fRequest1
.getDataType(),
181 fRequest1
.getIndex(),
182 fRequest1
.getNbRequested(),
183 ExecutionType
.FOREGROUND
);
184 TmfCoalescedDataRequest dataRequest2
= new TmfCoalescedDataRequest(
185 fRequest1
.getDataType(),
186 fRequest1
.getIndex(),
187 fRequest1
.getNbRequested(),
188 ExecutionType
.FOREGROUND
);
189 TmfCoalescedDataRequest dataRequest3
= new TmfCoalescedDataRequest(
190 fRequest3
.getDataType(),
191 fRequest3
.getIndex(),
192 fRequest3
.getNbRequested(),
193 ExecutionType
.FOREGROUND
);
195 assertTrue("equals", fRequest1
.equals(dataRequest2
));
196 assertTrue("equals", fRequest2
.equals(dataRequest1
));
197 assertFalse("equals", fRequest1
.equals(dataRequest3
));
198 assertFalse("equals", fRequest3
.equals(dataRequest1
));
201 // ------------------------------------------------------------------------
203 // ------------------------------------------------------------------------
206 public void testHashCode() {
207 assertTrue("hashCode", fRequest1
.hashCode() == fRequest1
.hashCode());
208 assertTrue("hashCode", fRequest2
.hashCode() == fRequest2
.hashCode());
209 assertTrue("hashCode", fRequest1
.hashCode() != fRequest2
.hashCode());
212 // ------------------------------------------------------------------------
214 // ------------------------------------------------------------------------
217 public void testToString() {
218 String expected1
= "[TmfCoalescedEventRequest(0,ITmfEvent,FOREGROUND," + range1
+ ",0,100, [])]";
219 String expected2
= "[TmfCoalescedEventRequest(1,ITmfEvent,FOREGROUND," + range2
+ ",0,100, [])]";
220 String expected3
= "[TmfCoalescedEventRequest(2,ITmfEvent,FOREGROUND," + range2
+ ",0,200, [])]";
221 String expected4
= "[TmfCoalescedEventRequest(3,ITmfEvent,FOREGROUND," + range2
+ ",0,200, [])]";
223 assertEquals("toString", expected1
, fRequest1
.toString());
224 assertEquals("toString", expected2
, fRequest2
.toString());
225 assertEquals("toString", expected3
, fRequest3
.toString());
226 assertEquals("toString", expected4
, fRequest4
.toString());
229 // ------------------------------------------------------------------------
231 // ------------------------------------------------------------------------
234 public void testIsCompatible() {
235 TmfCoalescedEventRequest coalescedRequest
= new TmfCoalescedEventRequest(ITmfEvent
.class, range1
, 0, 100, ExecutionType
.FOREGROUND
);
236 TmfEventRequest req1
= new TmfEventRequestStub(ITmfEvent
.class, range1
, 100, 200);
237 TmfEventRequest req2
= new TmfEventRequestStub(ITmfEvent
.class, range2
, 100, 200);
238 TmfEventRequest req3
= new TmfEventRequestStub(ITmfEvent
.class, range1
, 101, 200);
240 assertTrue("isCompatible", coalescedRequest
.isCompatible(req1
));
241 assertTrue("isCompatible", coalescedRequest
.isCompatible(req2
));
242 assertTrue("isCompatible", coalescedRequest
.isCompatible(req3
));
245 // ------------------------------------------------------------------------
247 // ------------------------------------------------------------------------
250 public void testAddEvent1() {
251 TmfCoalescedEventRequest coalescedRequest
= new TmfCoalescedEventRequest(ITmfEvent
.class, range1
, 0, 2147483647, ExecutionType
.FOREGROUND
);
252 TmfEventRequest req1
= new TmfEventRequestStub(ITmfEvent
.class, range1
, 0, 2147483647, 200);
253 TmfEventRequest req2
= new TmfEventRequestStub(ITmfEvent
.class, range1
, 1, 2147483647, 200);
255 assertTrue("isCompatible", coalescedRequest
.isCompatible(req1
));
256 assertTrue("isCompatible", coalescedRequest
.isCompatible(req2
));
258 coalescedRequest
.addRequest(req1
);
259 coalescedRequest
.addRequest(req2
);
261 assertEquals("addRequest", 0, coalescedRequest
.getIndex());
262 assertEquals("addRequest", 2147483647, coalescedRequest
.getNbRequested());
266 public void testAddEvent2() {
267 TmfCoalescedEventRequest coalescedRequest
= new TmfCoalescedEventRequest(ITmfEvent
.class, range1
, 1, 2147483647, ExecutionType
.FOREGROUND
);
268 TmfEventRequest req1
= new TmfEventRequestStub(ITmfEvent
.class, range1
, 1, 2147483647, 200);
269 TmfEventRequest req2
= new TmfEventRequestStub(ITmfEvent
.class, range1
, 0, 2147483647, 200);
271 assertTrue("isCompatible", coalescedRequest
.isCompatible(req1
));
272 assertTrue("isCompatible", coalescedRequest
.isCompatible(req2
));
274 coalescedRequest
.addRequest(req1
);
275 coalescedRequest
.addRequest(req2
);
277 assertEquals("addRequest", 0, coalescedRequest
.getIndex());
278 assertEquals("addRequest", 2147483647, coalescedRequest
.getNbRequested());
281 // ------------------------------------------------------------------------
283 // ------------------------------------------------------------------------
286 public void testDone() {
288 final boolean[] crFlags
= new boolean[4];
289 TmfCoalescedEventRequest request
= setupTestRequest(crFlags
);
290 TmfEventRequest subRequest1
= new TmfEventRequestStub(ITmfEvent
.class, range1
, 100, 200);
291 TmfEventRequest subRequest2
= new TmfEventRequestStub(ITmfEvent
.class, range1
, 100, 200);
292 request
.addRequest(subRequest1
);
293 request
.addRequest(subRequest2
);
297 // Validate the coalescing request
298 assertTrue("isCompleted", request
.isCompleted());
299 assertFalse("isFailed", request
.isFailed());
300 assertFalse("isCancelled", request
.isCancelled());
302 assertTrue("handleCompleted", crFlags
[0]);
303 assertTrue("handleSuccess", crFlags
[1]);
304 assertFalse("handleFailure", crFlags
[2]);
305 assertFalse("handleCancel", crFlags
[3]);
307 // Validate the first coalesced request
308 assertTrue("isCompleted", subRequest1
.isCompleted());
309 assertFalse("isFailed", subRequest1
.isFailed());
310 assertFalse("isCancelled", subRequest1
.isCancelled());
312 // Validate the second coalesced request
313 assertTrue("isCompleted", subRequest2
.isCompleted());
314 assertFalse("isFailed", subRequest2
.isFailed());
315 assertFalse("isCancelled", subRequest2
.isCancelled());
318 // ------------------------------------------------------------------------
320 // ------------------------------------------------------------------------
323 public void testFail() {
324 final boolean[] crFlags
= new boolean[4];
325 TmfCoalescedEventRequest request
= setupTestRequest(crFlags
);
326 TmfEventRequest subRequest1
= new TmfEventRequestStub(ITmfEvent
.class, range1
, 100, 200);
327 TmfEventRequest subRequest2
= new TmfEventRequestStub(ITmfEvent
.class, range1
, 100, 200);
328 request
.addRequest(subRequest1
);
329 request
.addRequest(subRequest2
);
333 // Validate the coalescing request
334 assertTrue("isCompleted", request
.isCompleted());
335 assertTrue("isFailed", request
.isFailed());
336 assertFalse("isCancelled", request
.isCancelled());
338 assertTrue("handleCompleted", crFlags
[0]);
339 assertFalse("handleSuccess", crFlags
[1]);
340 assertTrue("handleFailure", crFlags
[2]);
341 assertFalse("handleCancel", crFlags
[3]);
343 // Validate the first coalesced request
344 assertTrue("isCompleted", subRequest1
.isCompleted());
345 assertTrue("isFailed", subRequest1
.isFailed());
346 assertFalse("isCancelled", subRequest1
.isCancelled());
348 // Validate the second coalesced request
349 assertTrue("isCompleted", subRequest2
.isCompleted());
350 assertTrue("isFailed", subRequest2
.isFailed());
351 assertFalse("isCancelled", subRequest2
.isCancelled());
354 // ------------------------------------------------------------------------
356 // ------------------------------------------------------------------------
359 public void testCancel() {
360 final boolean[] crFlags
= new boolean[4];
361 TmfCoalescedEventRequest request
= setupTestRequest(crFlags
);
362 TmfEventRequest subRequest1
= new TmfEventRequestStub(ITmfEvent
.class, range1
, 100, 200);
363 TmfEventRequest subRequest2
= new TmfEventRequestStub(ITmfEvent
.class, range1
, 100, 200);
364 request
.addRequest(subRequest1
);
365 request
.addRequest(subRequest2
);
369 // Validate the coalescing request
370 assertTrue("isCompleted", request
.isCompleted());
371 assertFalse("isFailed", request
.isFailed());
372 assertTrue("isCancelled", request
.isCancelled());
374 assertTrue("handleCompleted", crFlags
[0]);
375 assertFalse("handleSuccess", crFlags
[1]);
376 assertFalse("handleFailure", crFlags
[2]);
377 assertTrue("handleCancel", crFlags
[3]);
379 // Validate the first coalesced request
380 assertTrue("isCompleted", subRequest1
.isCompleted());
381 assertFalse("isFailed", subRequest1
.isFailed());
382 assertTrue("isCancelled", subRequest1
.isCancelled());
384 // Validate the second coalesced request
385 assertTrue("isCompleted", subRequest2
.isCompleted());
386 assertFalse("isFailed", subRequest2
.isFailed());
387 assertTrue("isCancelled", subRequest2
.isCancelled());
390 // ------------------------------------------------------------------------
392 // ------------------------------------------------------------------------
394 private static final String DIRECTORY
= "testfiles";
395 private static final String TEST_STREAM
= "A-Test-10K";
396 private static final int NB_EVENTS
= 5000;
398 // Initialize the test trace
399 private TmfTraceStub fTrace
= null;
401 private synchronized TmfTraceStub
setupTrace(String path
) {
402 if (fTrace
== null) {
404 URL location
= FileLocator
.find(TmfCoreTestPlugin
.getDefault().getBundle(), new Path(path
), null);
405 File test
= new File(FileLocator
.toFileURL(location
).toURI());
406 fTrace
= new TmfTraceStub(test
.getPath(), 500, false, null, null);
407 } catch (TmfTraceException e
) {
409 } catch (URISyntaxException e
) {
411 } catch (IOException e
) {
418 Vector
<ITmfEvent
> requestedEvents1
;
419 Vector
<ITmfEvent
> requestedEvents2
;
420 Vector
<ITmfEvent
> requestedEvents3
;
422 TmfEventRequest request1
;
423 TmfEventRequest request2
;
424 TmfEventRequest request3
;
426 ITmfDataProvider
[] providers
;
428 private static class TmfTestTriggerSignal
extends TmfSignal
{
429 public final boolean forceCancel
;
430 public final long fIndex
;
432 public TmfTestTriggerSignal(Object source
, long index
, boolean cancel
) {
434 forceCancel
= cancel
;
440 public void trigger(final TmfTestTriggerSignal signal
) {
442 TmfTimeRange range
= new TmfTimeRange(TmfTimestamp
.BIG_BANG
, TmfTimestamp
.BIG_CRUNCH
);
443 final long REQUEST_OFFSET
= 1000;
445 requestedEvents1
= new Vector
<ITmfEvent
>();
446 request1
= new TmfEventRequest(ITmfEvent
.class, range
, signal
.fIndex
,
447 NB_EVENTS
, ExecutionType
.FOREGROUND
) {
449 public void handleData(ITmfEvent event
) {
450 super.handleData(event
);
451 if (!isCompleted()) {
452 requestedEvents1
.add(event
);
453 if (signal
.forceCancel
) {
460 requestedEvents2
= new Vector
<ITmfEvent
>();
461 request2
= new TmfEventRequest(ITmfEvent
.class, range
,
462 signal
.fIndex
+ REQUEST_OFFSET
, NB_EVENTS
, ExecutionType
.FOREGROUND
) {
464 public void handleData(ITmfEvent event
) {
465 super.handleData(event
);
466 if (!isCompleted()) {
467 requestedEvents2
.add(event
);
472 requestedEvents3
= new Vector
<ITmfEvent
>();
473 request3
= new TmfEventRequest(ITmfEvent
.class, range
,
474 signal
.fIndex
+ 2 * REQUEST_OFFSET
, NB_EVENTS
, ExecutionType
.FOREGROUND
) {
476 public void handleData(ITmfEvent event
) {
477 super.handleData(event
);
478 if (!isCompleted()) {
479 requestedEvents3
.add(event
);
484 providers
= TmfProviderManager
.getProviders(ITmfEvent
.class, TmfTraceStub
.class);
485 providers
[0].sendRequest(request1
);
486 providers
[0].sendRequest(request2
);
487 providers
[0].sendRequest(request3
);
490 public void runCoalescedRequest(long startIndex
) throws InterruptedException
{
492 fTrace
= setupTrace(DIRECTORY
+ File
.separator
+ TEST_STREAM
);
494 TmfSignalManager
.register(this);
495 TmfTestTriggerSignal signal
= new TmfTestTriggerSignal(this, startIndex
, false);
496 TmfSignalManager
.dispatchSignal(signal
);
498 request1
.waitForCompletion();
499 request2
.waitForCompletion();
500 request3
.waitForCompletion();
503 assertEquals("Request1: nbEvents", NB_EVENTS
, requestedEvents1
.size());
504 assertTrue("Request1: isCompleted", request1
.isCompleted());
505 assertFalse("Request1: isCancelled", request1
.isCancelled());
507 assertEquals("Request2: nbEvents", NB_EVENTS
, requestedEvents2
.size());
508 assertTrue("Request2: isCompleted", request2
.isCompleted());
509 assertFalse("Request2: isCancelled", request2
.isCancelled());
511 assertEquals("Request3: nbEvents", NB_EVENTS
, requestedEvents3
.size());
512 assertTrue("Request3: isCompleted", request3
.isCompleted());
513 assertFalse("Request3: isCancelled", request3
.isCancelled());
515 // Ensure that we have distinct events.
516 // Don't go overboard: we are not validating the stub!
517 for (int i
= 0; i
< NB_EVENTS
; i
++) {
518 assertEquals("Distinct events", i
+ 1 + request1
.getIndex(), requestedEvents1
.get(i
).getTimestamp().getValue());
519 assertEquals("Distinct events", i
+ 1 + request2
.getIndex(), requestedEvents2
.get(i
).getTimestamp().getValue());
520 assertEquals("Distinct events", i
+ 1 + request3
.getIndex(), requestedEvents3
.get(i
).getTimestamp().getValue());
523 TmfSignalManager
.deregister(this);
530 public void testCoalescedRequest() throws InterruptedException
{
531 runCoalescedRequest(0);
532 runCoalescedRequest(1);
533 runCoalescedRequest(5);
537 public void testCancelCoalescedRequest() throws InterruptedException
{
539 fTrace
= setupTrace(DIRECTORY
+ File
.separator
+ TEST_STREAM
);
541 TmfSignalManager
.register(this);
542 TmfTestTriggerSignal signal
= new TmfTestTriggerSignal(this, 0, true);
543 TmfSignalManager
.dispatchSignal(signal
);
545 request1
.waitForCompletion();
546 request2
.waitForCompletion();
547 request3
.waitForCompletion();
549 assertTrue("Request1: isCompleted", request1
.isCompleted());
550 assertTrue("Request1: isCancelled", request1
.isCancelled());
552 assertEquals("Request2: nbEvents", NB_EVENTS
, requestedEvents2
.size());
553 assertTrue("Request2: isCompleted", request2
.isCompleted());
554 assertFalse("Request2: isCancelled", request2
.isCancelled());
556 assertEquals("Request3: nbEvents", NB_EVENTS
, requestedEvents3
.size());
557 assertTrue("Request3: isCompleted", request3
.isCompleted());
558 assertFalse("Request3: isCancelled", request3
.isCancelled());
560 // Ensure that we have distinct events.
561 // Don't go overboard: we are not validating the stub!
562 for (int i
= 0; i
< NB_EVENTS
; i
++) {
563 assertEquals("Distinct events", i
+ 1 + request2
.getIndex(), requestedEvents2
.get(i
).getTimestamp().getValue());
564 assertEquals("Distinct events", i
+ 1 + request3
.getIndex(), requestedEvents3
.get(i
).getTimestamp().getValue());
567 TmfSignalManager
.deregister(this);