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
.TmfCoalescedEventRequest
;
30 import org
.eclipse
.linuxtools
.tmf
.core
.component
.ITmfEventProvider
;
31 import org
.eclipse
.linuxtools
.tmf
.core
.event
.ITmfEvent
;
32 import org
.eclipse
.linuxtools
.tmf
.core
.exceptions
.TmfTraceException
;
33 import org
.eclipse
.linuxtools
.tmf
.core
.request
.ITmfEventRequest
.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
.core
.tests
.shared
.TmfTestTrace
;
40 import org
.eclipse
.linuxtools
.tmf
.core
.timestamp
.TmfTimeRange
;
41 import org
.eclipse
.linuxtools
.tmf
.core
.timestamp
.TmfTimestamp
;
42 import org
.eclipse
.linuxtools
.tmf
.tests
.stubs
.request
.TmfEventRequestStub
;
43 import org
.eclipse
.linuxtools
.tmf
.tests
.stubs
.trace
.TmfTraceStub
;
44 import org
.junit
.Before
;
45 import org
.junit
.Test
;
48 * Test suite for the TmfCoalescedEventRequest class.
50 @SuppressWarnings("javadoc")
51 public class TmfCoalescedEventRequestTest
{
53 // ------------------------------------------------------------------------
55 // ------------------------------------------------------------------------
57 private final TmfTimeRange range1
= new TmfTimeRange(TmfTimeRange
.ETERNITY
);
58 private final TmfTimeRange range2
= new TmfTimeRange(new TmfTimestamp(), TmfTimestamp
.BIG_CRUNCH
);
60 private TmfCoalescedEventRequest fRequest1
;
61 private TmfCoalescedEventRequest fRequest2
;
62 private TmfCoalescedEventRequest fRequest3
;
63 private TmfCoalescedEventRequest fRequest4
;
65 private TmfCoalescedEventRequest fRequest1b
;
66 private TmfCoalescedEventRequest fRequest1c
;
68 private int fRequestCount
;
70 // ------------------------------------------------------------------------
72 // ------------------------------------------------------------------------
76 TmfEventRequest
.reset();
77 fRequest1
= new TmfCoalescedEventRequest(ITmfEvent
.class, range1
, 0, 100, ExecutionType
.FOREGROUND
);
78 fRequest2
= new TmfCoalescedEventRequest(ITmfEvent
.class, range2
, 0, 100, ExecutionType
.FOREGROUND
);
79 fRequest3
= new TmfCoalescedEventRequest(ITmfEvent
.class, range2
, 0, 200, ExecutionType
.FOREGROUND
);
80 fRequest4
= new TmfCoalescedEventRequest(ITmfEvent
.class, range2
, 0, 200, ExecutionType
.FOREGROUND
);
82 fRequest1b
= new TmfCoalescedEventRequest(ITmfEvent
.class, range1
, 0, 100, ExecutionType
.FOREGROUND
);
83 fRequest1c
= new TmfCoalescedEventRequest(ITmfEvent
.class, range1
, 0, 100, ExecutionType
.FOREGROUND
);
85 fRequestCount
= fRequest1c
.getRequestId() + 1;
88 private TmfCoalescedEventRequest
setupTestRequest(final boolean[] flags
) {
90 TmfCoalescedEventRequest request
= new TmfCoalescedEventRequest(ITmfEvent
.class, range1
, 0, 100, ExecutionType
.FOREGROUND
) {
92 public void handleCompleted() {
93 super.handleCompleted();
98 public void handleSuccess() {
99 super.handleSuccess();
104 public void handleFailure() {
105 super.handleFailure();
110 public void handleCancel() {
111 super.handleCancel();
118 // ------------------------------------------------------------------------
120 // ------------------------------------------------------------------------
123 public void testTmfCoalescedEventRequestIndexNbEventsBlocksize() {
124 TmfCoalescedEventRequest request
= new TmfCoalescedEventRequest(ITmfEvent
.class, range1
, 0, 100, ExecutionType
.FOREGROUND
);
126 assertEquals("getRequestId", fRequestCount
++, request
.getRequestId());
127 assertEquals("getDataType", ITmfEvent
.class, request
.getDataType());
129 assertEquals("getRange", range1
, request
.getRange());
130 assertEquals("getNbRequestedEvents", 100, request
.getNbRequested());
132 assertFalse("isCompleted", request
.isCompleted());
133 assertFalse("isFailed", request
.isFailed());
134 assertFalse("isCancelled", request
.isCancelled());
136 assertEquals("getNbRead", 0, request
.getNbRead());
139 // ------------------------------------------------------------------------
141 // ------------------------------------------------------------------------
144 public void testEqualsReflexivity() {
145 assertTrue("equals", fRequest1
.equals(fRequest1
));
146 assertTrue("equals", fRequest2
.equals(fRequest2
));
148 assertFalse("equals", fRequest1
.equals(fRequest2
));
149 assertFalse("equals", fRequest2
.equals(fRequest1
));
153 public void testEqualsSymmetry() {
154 assertTrue("equals", fRequest1
.equals(fRequest1b
));
155 assertTrue("equals", fRequest1b
.equals(fRequest1
));
157 assertFalse("equals", fRequest1
.equals(fRequest3
));
158 assertFalse("equals", fRequest2
.equals(fRequest3
));
159 assertFalse("equals", fRequest3
.equals(fRequest1
));
160 assertFalse("equals", fRequest3
.equals(fRequest2
));
164 public void testEqualsTransivity() {
165 assertTrue("equals", fRequest1
.equals(fRequest1b
));
166 assertTrue("equals", fRequest1b
.equals(fRequest1c
));
167 assertTrue("equals", fRequest1
.equals(fRequest1c
));
171 public void testEqualsNull() {
172 assertFalse("equals", fRequest1
.equals(null));
173 assertFalse("equals", fRequest2
.equals(null));
176 // ------------------------------------------------------------------------
178 // ------------------------------------------------------------------------
181 public void testHashCode() {
182 assertTrue("hashCode", fRequest1
.hashCode() == fRequest1
.hashCode());
183 assertTrue("hashCode", fRequest2
.hashCode() == fRequest2
.hashCode());
184 assertTrue("hashCode", fRequest1
.hashCode() != fRequest2
.hashCode());
187 // ------------------------------------------------------------------------
189 // ------------------------------------------------------------------------
192 public void testToString() {
193 String expected1
= "[TmfCoalescedEventRequest(0,ITmfEvent,FOREGROUND," + range1
+ ",0,100, [])]";
194 String expected2
= "[TmfCoalescedEventRequest(1,ITmfEvent,FOREGROUND," + range2
+ ",0,100, [])]";
195 String expected3
= "[TmfCoalescedEventRequest(2,ITmfEvent,FOREGROUND," + range2
+ ",0,200, [])]";
196 String expected4
= "[TmfCoalescedEventRequest(3,ITmfEvent,FOREGROUND," + range2
+ ",0,200, [])]";
198 assertEquals("toString", expected1
, fRequest1
.toString());
199 assertEquals("toString", expected2
, fRequest2
.toString());
200 assertEquals("toString", expected3
, fRequest3
.toString());
201 assertEquals("toString", expected4
, fRequest4
.toString());
204 // ------------------------------------------------------------------------
206 // ------------------------------------------------------------------------
209 public void testIsCompatible() {
210 TmfCoalescedEventRequest coalescedRequest
= new TmfCoalescedEventRequest(ITmfEvent
.class, range1
, 0, 100, ExecutionType
.FOREGROUND
);
211 TmfEventRequest req1
= new TmfEventRequestStub(ITmfEvent
.class, range1
, 100, 200);
212 TmfEventRequest req2
= new TmfEventRequestStub(ITmfEvent
.class, range2
, 100, 200);
213 TmfEventRequest req3
= new TmfEventRequestStub(ITmfEvent
.class, range1
, 101, 200);
215 assertTrue("isCompatible", coalescedRequest
.isCompatible(req1
));
216 assertTrue("isCompatible", coalescedRequest
.isCompatible(req2
));
217 assertTrue("isCompatible", coalescedRequest
.isCompatible(req3
));
220 // ------------------------------------------------------------------------
222 // ------------------------------------------------------------------------
225 public void testAddEvent1() {
226 TmfCoalescedEventRequest coalescedRequest
= new TmfCoalescedEventRequest(ITmfEvent
.class, range1
, 0, 2147483647, ExecutionType
.FOREGROUND
);
227 TmfEventRequest req1
= new TmfEventRequestStub(ITmfEvent
.class, range1
, 0, 2147483647, 200);
228 TmfEventRequest req2
= new TmfEventRequestStub(ITmfEvent
.class, range1
, 1, 2147483647, 200);
230 assertTrue("isCompatible", coalescedRequest
.isCompatible(req1
));
231 assertTrue("isCompatible", coalescedRequest
.isCompatible(req2
));
233 coalescedRequest
.addRequest(req1
);
234 coalescedRequest
.addRequest(req2
);
236 assertEquals("addRequest", 0, coalescedRequest
.getIndex());
237 assertEquals("addRequest", 2147483647, coalescedRequest
.getNbRequested());
241 public void testAddEvent2() {
242 TmfCoalescedEventRequest coalescedRequest
= new TmfCoalescedEventRequest(ITmfEvent
.class, range1
, 1, 2147483647, ExecutionType
.FOREGROUND
);
243 TmfEventRequest req1
= new TmfEventRequestStub(ITmfEvent
.class, range1
, 1, 2147483647, 200);
244 TmfEventRequest req2
= new TmfEventRequestStub(ITmfEvent
.class, range1
, 0, 2147483647, 200);
246 assertTrue("isCompatible", coalescedRequest
.isCompatible(req1
));
247 assertTrue("isCompatible", coalescedRequest
.isCompatible(req2
));
249 coalescedRequest
.addRequest(req1
);
250 coalescedRequest
.addRequest(req2
);
252 assertEquals("addRequest", 0, coalescedRequest
.getIndex());
253 assertEquals("addRequest", 2147483647, coalescedRequest
.getNbRequested());
256 // ------------------------------------------------------------------------
258 // ------------------------------------------------------------------------
261 public void testDone() {
263 final boolean[] crFlags
= new boolean[4];
264 TmfCoalescedEventRequest request
= setupTestRequest(crFlags
);
265 TmfEventRequest subRequest1
= new TmfEventRequestStub(ITmfEvent
.class, range1
, 100, 200);
266 TmfEventRequest subRequest2
= new TmfEventRequestStub(ITmfEvent
.class, range1
, 100, 200);
267 request
.addRequest(subRequest1
);
268 request
.addRequest(subRequest2
);
272 // Validate the coalescing request
273 assertTrue("isCompleted", request
.isCompleted());
274 assertFalse("isFailed", request
.isFailed());
275 assertFalse("isCancelled", request
.isCancelled());
277 assertTrue("handleCompleted", crFlags
[0]);
278 assertTrue("handleSuccess", crFlags
[1]);
279 assertFalse("handleFailure", crFlags
[2]);
280 assertFalse("handleCancel", crFlags
[3]);
282 // Validate the first coalesced request
283 assertTrue("isCompleted", subRequest1
.isCompleted());
284 assertFalse("isFailed", subRequest1
.isFailed());
285 assertFalse("isCancelled", subRequest1
.isCancelled());
287 // Validate the second coalesced request
288 assertTrue("isCompleted", subRequest2
.isCompleted());
289 assertFalse("isFailed", subRequest2
.isFailed());
290 assertFalse("isCancelled", subRequest2
.isCancelled());
293 // ------------------------------------------------------------------------
295 // ------------------------------------------------------------------------
298 public void testFail() {
299 final boolean[] crFlags
= new boolean[4];
300 TmfCoalescedEventRequest request
= setupTestRequest(crFlags
);
301 TmfEventRequest subRequest1
= new TmfEventRequestStub(ITmfEvent
.class, range1
, 100, 200);
302 TmfEventRequest subRequest2
= new TmfEventRequestStub(ITmfEvent
.class, range1
, 100, 200);
303 request
.addRequest(subRequest1
);
304 request
.addRequest(subRequest2
);
308 // Validate the coalescing request
309 assertTrue("isCompleted", request
.isCompleted());
310 assertTrue("isFailed", request
.isFailed());
311 assertFalse("isCancelled", request
.isCancelled());
313 assertTrue("handleCompleted", crFlags
[0]);
314 assertFalse("handleSuccess", crFlags
[1]);
315 assertTrue("handleFailure", crFlags
[2]);
316 assertFalse("handleCancel", crFlags
[3]);
318 // Validate the first coalesced request
319 assertTrue("isCompleted", subRequest1
.isCompleted());
320 assertTrue("isFailed", subRequest1
.isFailed());
321 assertFalse("isCancelled", subRequest1
.isCancelled());
323 // Validate the second coalesced request
324 assertTrue("isCompleted", subRequest2
.isCompleted());
325 assertTrue("isFailed", subRequest2
.isFailed());
326 assertFalse("isCancelled", subRequest2
.isCancelled());
329 // ------------------------------------------------------------------------
331 // ------------------------------------------------------------------------
334 public void testCancel() {
335 final boolean[] crFlags
= new boolean[4];
336 TmfCoalescedEventRequest request
= setupTestRequest(crFlags
);
337 TmfEventRequest subRequest1
= new TmfEventRequestStub(ITmfEvent
.class, range1
, 100, 200);
338 TmfEventRequest subRequest2
= new TmfEventRequestStub(ITmfEvent
.class, range1
, 100, 200);
339 request
.addRequest(subRequest1
);
340 request
.addRequest(subRequest2
);
344 // Validate the coalescing request
345 assertTrue("isCompleted", request
.isCompleted());
346 assertFalse("isFailed", request
.isFailed());
347 assertTrue("isCancelled", request
.isCancelled());
349 assertTrue("handleCompleted", crFlags
[0]);
350 assertFalse("handleSuccess", crFlags
[1]);
351 assertFalse("handleFailure", crFlags
[2]);
352 assertTrue("handleCancel", crFlags
[3]);
354 // Validate the first coalesced request
355 assertTrue("isCompleted", subRequest1
.isCompleted());
356 assertFalse("isFailed", subRequest1
.isFailed());
357 assertTrue("isCancelled", subRequest1
.isCancelled());
359 // Validate the second coalesced request
360 assertTrue("isCompleted", subRequest2
.isCompleted());
361 assertFalse("isFailed", subRequest2
.isFailed());
362 assertTrue("isCancelled", subRequest2
.isCancelled());
365 // ------------------------------------------------------------------------
367 // ------------------------------------------------------------------------
369 private static final TmfTestTrace TEST_TRACE
= TmfTestTrace
.A_TEST_10K
;
370 private static final int NB_EVENTS
= 5000;
372 // Initialize the test trace
373 private TmfTraceStub fTrace
= null;
375 private synchronized TmfTraceStub
setupTrace(String path
) {
376 if (fTrace
== null) {
378 URL location
= FileLocator
.find(TmfCoreTestPlugin
.getDefault().getBundle(), new Path(path
), null);
379 File test
= new File(FileLocator
.toFileURL(location
).toURI());
380 fTrace
= new TmfTraceStub(test
.getPath(), 500, false, null);
381 } catch (TmfTraceException e
) {
383 } catch (URISyntaxException e
) {
385 } catch (IOException e
) {
392 Vector
<ITmfEvent
> requestedEvents1
;
393 Vector
<ITmfEvent
> requestedEvents2
;
394 Vector
<ITmfEvent
> requestedEvents3
;
396 TmfEventRequest request1
;
397 TmfEventRequest request2
;
398 TmfEventRequest request3
;
400 ITmfEventProvider
[] providers
;
402 private static class TmfTestTriggerSignal
extends TmfSignal
{
403 public final boolean forceCancel
;
404 public final long fIndex
;
406 public TmfTestTriggerSignal(Object source
, long index
, boolean cancel
) {
408 forceCancel
= cancel
;
414 public void trigger(final TmfTestTriggerSignal signal
) {
416 TmfTimeRange range
= new TmfTimeRange(TmfTimestamp
.BIG_BANG
, TmfTimestamp
.BIG_CRUNCH
);
417 final long REQUEST_OFFSET
= 1000;
419 requestedEvents1
= new Vector
<>();
420 request1
= new TmfEventRequest(ITmfEvent
.class, range
, signal
.fIndex
,
421 NB_EVENTS
, ExecutionType
.FOREGROUND
) {
423 public void handleData(ITmfEvent event
) {
424 super.handleData(event
);
425 if (!isCompleted()) {
426 requestedEvents1
.add(event
);
427 if (signal
.forceCancel
) {
434 requestedEvents2
= new Vector
<>();
435 request2
= new TmfEventRequest(ITmfEvent
.class, range
,
436 signal
.fIndex
+ REQUEST_OFFSET
, NB_EVENTS
, ExecutionType
.FOREGROUND
) {
438 public void handleData(ITmfEvent event
) {
439 super.handleData(event
);
440 if (!isCompleted()) {
441 requestedEvents2
.add(event
);
446 requestedEvents3
= new Vector
<>();
447 request3
= new TmfEventRequest(ITmfEvent
.class, range
,
448 signal
.fIndex
+ 2 * REQUEST_OFFSET
, NB_EVENTS
, ExecutionType
.FOREGROUND
) {
450 public void handleData(ITmfEvent event
) {
451 super.handleData(event
);
452 if (!isCompleted()) {
453 requestedEvents3
.add(event
);
458 providers
= TmfProviderManager
.getProviders(ITmfEvent
.class, TmfTraceStub
.class);
459 providers
[0].sendRequest(request1
);
460 providers
[0].sendRequest(request2
);
461 providers
[0].sendRequest(request3
);
464 public void runCoalescedRequest(long startIndex
) throws InterruptedException
{
466 fTrace
= setupTrace(TEST_TRACE
.getFullPath());
468 TmfSignalManager
.register(this);
469 TmfTestTriggerSignal signal
= new TmfTestTriggerSignal(this, startIndex
, false);
470 TmfSignalManager
.dispatchSignal(signal
);
472 request1
.waitForCompletion();
473 request2
.waitForCompletion();
474 request3
.waitForCompletion();
477 assertEquals("Request1: nbEvents", NB_EVENTS
, requestedEvents1
.size());
478 assertTrue("Request1: isCompleted", request1
.isCompleted());
479 assertFalse("Request1: isCancelled", request1
.isCancelled());
481 assertEquals("Request2: nbEvents", NB_EVENTS
, requestedEvents2
.size());
482 assertTrue("Request2: isCompleted", request2
.isCompleted());
483 assertFalse("Request2: isCancelled", request2
.isCancelled());
485 assertEquals("Request3: nbEvents", NB_EVENTS
, requestedEvents3
.size());
486 assertTrue("Request3: isCompleted", request3
.isCompleted());
487 assertFalse("Request3: isCancelled", request3
.isCancelled());
489 // Ensure that we have distinct events.
490 // Don't go overboard: we are not validating the stub!
491 for (int i
= 0; i
< NB_EVENTS
; i
++) {
492 assertEquals("Distinct events", i
+ 1 + request1
.getIndex(), requestedEvents1
.get(i
).getTimestamp().getValue());
493 assertEquals("Distinct events", i
+ 1 + request2
.getIndex(), requestedEvents2
.get(i
).getTimestamp().getValue());
494 assertEquals("Distinct events", i
+ 1 + request3
.getIndex(), requestedEvents3
.get(i
).getTimestamp().getValue());
497 TmfSignalManager
.deregister(this);
504 public void testCoalescedRequest() throws InterruptedException
{
505 runCoalescedRequest(0);
506 runCoalescedRequest(1);
507 runCoalescedRequest(5);
511 public void testCancelCoalescedRequest() throws InterruptedException
{
513 fTrace
= setupTrace(TEST_TRACE
.getFullPath());
515 TmfSignalManager
.register(this);
516 TmfTestTriggerSignal signal
= new TmfTestTriggerSignal(this, 0, true);
517 TmfSignalManager
.dispatchSignal(signal
);
519 request1
.waitForCompletion();
520 request2
.waitForCompletion();
521 request3
.waitForCompletion();
523 assertTrue("Request1: isCompleted", request1
.isCompleted());
524 assertTrue("Request1: isCancelled", request1
.isCancelled());
526 assertEquals("Request2: nbEvents", NB_EVENTS
, requestedEvents2
.size());
527 assertTrue("Request2: isCompleted", request2
.isCompleted());
528 assertFalse("Request2: isCancelled", request2
.isCancelled());
530 assertEquals("Request3: nbEvents", NB_EVENTS
, requestedEvents3
.size());
531 assertTrue("Request3: isCompleted", request3
.isCompleted());
532 assertFalse("Request3: isCancelled", request3
.isCancelled());
534 // Ensure that we have distinct events.
535 // Don't go overboard: we are not validating the stub!
536 for (int i
= 0; i
< NB_EVENTS
; i
++) {
537 assertEquals("Distinct events", i
+ 1 + request2
.getIndex(), requestedEvents2
.get(i
).getTimestamp().getValue());
538 assertEquals("Distinct events", i
+ 1 + request3
.getIndex(), requestedEvents3
.get(i
).getTimestamp().getValue());
541 TmfSignalManager
.deregister(this);