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
.tmf
.core
.component
.ITmfDataProvider
;
26 import org
.eclipse
.linuxtools
.tmf
.core
.component
.TmfProviderManager
;
27 import org
.eclipse
.linuxtools
.tmf
.core
.event
.TmfEvent
;
28 import org
.eclipse
.linuxtools
.tmf
.core
.event
.TmfTimeRange
;
29 import org
.eclipse
.linuxtools
.tmf
.core
.event
.TmfTimestamp
;
30 import org
.eclipse
.linuxtools
.tmf
.core
.exceptions
.TmfTraceException
;
31 import org
.eclipse
.linuxtools
.tmf
.core
.request
.TmfCoalescedDataRequest
;
32 import org
.eclipse
.linuxtools
.tmf
.core
.request
.TmfCoalescedEventRequest
;
33 import org
.eclipse
.linuxtools
.tmf
.core
.request
.TmfEventRequest
;
34 import org
.eclipse
.linuxtools
.tmf
.core
.signal
.TmfSignal
;
35 import org
.eclipse
.linuxtools
.tmf
.core
.signal
.TmfSignalHandler
;
36 import org
.eclipse
.linuxtools
.tmf
.core
.signal
.TmfSignalManager
;
37 import org
.eclipse
.linuxtools
.tmf
.core
.tests
.TmfCoreTestPlugin
;
38 import org
.eclipse
.linuxtools
.tmf
.tests
.stubs
.request
.TmfEventRequestStub
;
39 import org
.eclipse
.linuxtools
.tmf
.tests
.stubs
.trace
.TmfTraceStub
;
42 * <b><u>TmfCoalescedEventRequestTest</u></b>
44 * Test suite for the TmfCoalescedEventRequest class.
46 @SuppressWarnings("nls")
47 public class TmfCoalescedEventRequestTest
extends TestCase
{
49 // ------------------------------------------------------------------------
51 // ------------------------------------------------------------------------
53 private TmfTimeRange range1
= new TmfTimeRange(TmfTimeRange
.ETERNITY
);
54 private TmfTimeRange range2
= new TmfTimeRange(new TmfTimestamp(), TmfTimestamp
.BIG_CRUNCH
);
56 private TmfCoalescedEventRequest
<TmfEvent
> fRequest1
;
57 private TmfCoalescedEventRequest
<TmfEvent
> fRequest2
;
58 private TmfCoalescedEventRequest
<TmfEvent
> fRequest3
;
59 private TmfCoalescedEventRequest
<TmfEvent
> fRequest4
;
61 private TmfCoalescedEventRequest
<TmfEvent
> fRequest1b
;
62 private TmfCoalescedEventRequest
<TmfEvent
> fRequest1c
;
64 private int fRequestCount
;
66 // ------------------------------------------------------------------------
68 // ------------------------------------------------------------------------
70 public TmfCoalescedEventRequestTest(String name
) {
75 public void setUp() throws Exception
{
77 TmfEventRequest
.reset();
78 fRequest1
= new TmfCoalescedEventRequest
<TmfEvent
>(TmfEvent
.class, range1
, 100, 200);
79 fRequest2
= new TmfCoalescedEventRequest
<TmfEvent
>(TmfEvent
.class, range2
, 100, 200);
80 fRequest3
= new TmfCoalescedEventRequest
<TmfEvent
>(TmfEvent
.class, range2
, 200, 200);
81 fRequest4
= new TmfCoalescedEventRequest
<TmfEvent
>(TmfEvent
.class, range2
, 200, 300);
83 fRequest1b
= new TmfCoalescedEventRequest
<TmfEvent
>(TmfEvent
.class, range1
, 100, 200);
84 fRequest1c
= new TmfCoalescedEventRequest
<TmfEvent
>(TmfEvent
.class, range1
, 100, 200);
86 fRequestCount
= fRequest1c
.getRequestId() + 1;
90 public void tearDown() throws Exception
{
94 private TmfCoalescedEventRequest
<TmfEvent
> setupTestRequest(final boolean[] flags
) {
96 TmfCoalescedEventRequest
<TmfEvent
> request
= new TmfCoalescedEventRequest
<TmfEvent
>(TmfEvent
.class, range1
, 100, 200) {
98 public void handleCompleted() {
99 super.handleCompleted();
103 public void handleSuccess() {
104 super.handleSuccess();
108 public void handleFailure() {
109 super.handleFailure();
113 public void handleCancel() {
114 super.handleCancel();
121 // ------------------------------------------------------------------------
123 // ------------------------------------------------------------------------
125 public void testTmfCoalescedEventRequest() {
126 TmfCoalescedEventRequest
<TmfEvent
> request
= new TmfCoalescedEventRequest
<TmfEvent
>(TmfEvent
.class);
128 assertEquals("getRequestId", fRequestCount
++, request
.getRequestId());
129 assertEquals("getDataType", TmfEvent
.class, request
.getDataType());
131 assertEquals("getRange", range1
, request
.getRange());
132 assertEquals("getNbRequestedEvents", TmfEventRequest
.ALL_DATA
, request
.getNbRequested());
134 assertFalse("isCompleted", request
.isCompleted());
135 assertFalse("isFailed", request
.isFailed());
136 assertFalse("isCancelled", request
.isCancelled());
138 assertEquals("getNbRead", 0, request
.getNbRead());
141 public void testTmfCoalescedEventRequestIndex() {
142 TmfCoalescedEventRequest
<TmfEvent
> request
= new TmfCoalescedEventRequest
<TmfEvent
>(TmfEvent
.class, range1
);
144 assertEquals("getRequestId", fRequestCount
++, request
.getRequestId());
145 assertEquals("getDataType", TmfEvent
.class, request
.getDataType());
147 assertEquals("getRange", range1
, request
.getRange());
148 assertEquals("getNbRequestedEvents", TmfEventRequest
.ALL_DATA
, request
.getNbRequested());
150 assertFalse("isCompleted", request
.isCompleted());
151 assertFalse("isFailed", request
.isFailed());
152 assertFalse("isCancelled", request
.isCancelled());
154 assertEquals("getNbRead", 0, request
.getNbRead());
157 public void testTmfCoalescedEventRequestIndexNbRequested() {
158 TmfCoalescedEventRequest
<TmfEvent
> request
= new TmfCoalescedEventRequest
<TmfEvent
>(TmfEvent
.class, range1
, 100);
160 assertEquals("getRequestId", fRequestCount
++, request
.getRequestId());
161 assertEquals("getDataType", TmfEvent
.class, request
.getDataType());
163 assertEquals("getRange", range1
, request
.getRange());
164 assertEquals("getNbRequestedEvents", 100, request
.getNbRequested());
166 assertFalse("isCompleted", request
.isCompleted());
167 assertFalse("isFailed", request
.isFailed());
168 assertFalse("isCancelled", request
.isCancelled());
170 assertEquals("getNbRead", 0, request
.getNbRead());
173 public void testTmfCoalescedEventRequestIndexNbEventsBlocksize() {
174 TmfCoalescedEventRequest
<TmfEvent
> request
= new TmfCoalescedEventRequest
<TmfEvent
>(TmfEvent
.class, range1
, 100, 200);
176 assertEquals("getRequestId", fRequestCount
++, request
.getRequestId());
177 assertEquals("getDataType", TmfEvent
.class, request
.getDataType());
179 assertEquals("getRange", range1
, request
.getRange());
180 assertEquals("getNbRequestedEvents", 100, request
.getNbRequested());
182 assertFalse("isCompleted", request
.isCompleted());
183 assertFalse("isFailed", request
.isFailed());
184 assertFalse("isCancelled", request
.isCancelled());
186 assertEquals("getNbRead", 0, request
.getNbRead());
189 // ------------------------------------------------------------------------
191 // ------------------------------------------------------------------------
193 public void testEqualsReflexivity() throws Exception
{
194 assertTrue("equals", fRequest1
.equals(fRequest1
));
195 assertTrue("equals", fRequest2
.equals(fRequest2
));
197 assertFalse("equals", fRequest1
.equals(fRequest2
));
198 assertFalse("equals", fRequest2
.equals(fRequest1
));
201 public void testEqualsSymmetry() throws Exception
{
202 assertTrue("equals", fRequest1
.equals(fRequest1b
));
203 assertTrue("equals", fRequest1b
.equals(fRequest1
));
205 assertFalse("equals", fRequest1
.equals(fRequest3
));
206 assertFalse("equals", fRequest2
.equals(fRequest3
));
207 assertFalse("equals", fRequest3
.equals(fRequest1
));
208 assertFalse("equals", fRequest3
.equals(fRequest2
));
211 public void testEqualsTransivity() throws Exception
{
212 assertTrue("equals", fRequest1
.equals(fRequest1b
));
213 assertTrue("equals", fRequest1b
.equals(fRequest1c
));
214 assertTrue("equals", fRequest1
.equals(fRequest1c
));
217 public void testEqualsNull() throws Exception
{
218 assertFalse("equals", fRequest1
.equals(null));
219 assertFalse("equals", fRequest2
.equals(null));
222 public void testEqualsSuper() throws Exception
{
223 TmfCoalescedDataRequest
<TmfEvent
> dataRequest1
= new TmfCoalescedDataRequest
<TmfEvent
>(
224 fRequest1
.getDataType(), fRequest1
.getIndex(), fRequest1
.getNbRequested());
225 TmfCoalescedDataRequest
<TmfEvent
> dataRequest2
= new TmfCoalescedDataRequest
<TmfEvent
>(
226 fRequest1
.getDataType(), fRequest1
.getIndex(), fRequest1
.getNbRequested());
227 TmfCoalescedDataRequest
<TmfEvent
> dataRequest3
= new TmfCoalescedDataRequest
<TmfEvent
>(
228 fRequest3
.getDataType(), fRequest3
.getIndex(), fRequest3
.getNbRequested());
230 assertTrue("equals", fRequest1
.equals(dataRequest2
));
231 assertTrue("equals", fRequest2
.equals(dataRequest1
));
232 assertFalse("equals", fRequest1
.equals(dataRequest3
));
233 assertFalse("equals", fRequest3
.equals(dataRequest1
));
236 // ------------------------------------------------------------------------
238 // ------------------------------------------------------------------------
240 public void testHashCode() throws Exception
{
241 assertTrue("hashCode", fRequest1
.hashCode() == fRequest1
.hashCode());
242 assertTrue("hashCode", fRequest2
.hashCode() == fRequest2
.hashCode());
243 assertTrue("hashCode", fRequest1
.hashCode() != fRequest2
.hashCode());
246 // ------------------------------------------------------------------------
248 // ------------------------------------------------------------------------
250 public void testToString() {
251 String expected1
= "[TmfCoalescedEventRequest(0,TmfEvent," + range1
+ ",0,100,200)]";
252 String expected2
= "[TmfCoalescedEventRequest(1,TmfEvent," + range2
+ ",0,100,200)]";
253 String expected3
= "[TmfCoalescedEventRequest(2,TmfEvent," + range2
+ ",0,200,200)]";
254 String expected4
= "[TmfCoalescedEventRequest(3,TmfEvent," + range2
+ ",0,200,300)]";
256 assertEquals("toString", expected1
, fRequest1
.toString());
257 assertEquals("toString", expected2
, fRequest2
.toString());
258 assertEquals("toString", expected3
, fRequest3
.toString());
259 assertEquals("toString", expected4
, fRequest4
.toString());
262 // ------------------------------------------------------------------------
264 // ------------------------------------------------------------------------
266 public void testIsCompatible() {
267 TmfCoalescedEventRequest
<TmfEvent
> coalescedRequest
= new TmfCoalescedEventRequest
<TmfEvent
>(TmfEvent
.class, range1
, 100, 200);
268 TmfEventRequest
<TmfEvent
> request1
= new TmfEventRequestStub
<TmfEvent
>(TmfEvent
.class, range1
, 100, 200);
269 TmfEventRequest
<TmfEvent
> request2
= new TmfEventRequestStub
<TmfEvent
>(TmfEvent
.class, range2
, 100, 200);
270 TmfEventRequest
<TmfEvent
> request3
= new TmfEventRequestStub
<TmfEvent
>(TmfEvent
.class, range1
, 101, 200);
272 assertTrue ("isCompatible", coalescedRequest
.isCompatible(request1
));
273 assertTrue ("isCompatible", coalescedRequest
.isCompatible(request2
));
274 assertFalse("isCompatible", coalescedRequest
.isCompatible(request3
));
277 // ------------------------------------------------------------------------
279 // ------------------------------------------------------------------------
281 public void testDone() {
284 final boolean[] crFlags
= new boolean[4];
285 TmfCoalescedEventRequest
<TmfEvent
> request
= setupTestRequest(crFlags
);
286 TmfEventRequest
<TmfEvent
> subRequest1
= new TmfEventRequestStub
<TmfEvent
>(TmfEvent
.class, range1
, 100, 200);
287 TmfEventRequest
<TmfEvent
> subRequest2
= new TmfEventRequestStub
<TmfEvent
>(TmfEvent
.class, range1
, 100, 200);
288 request
.addRequest(subRequest1
);
289 request
.addRequest(subRequest2
);
293 // Validate the coalescing request
294 assertTrue ("isCompleted", request
.isCompleted());
295 assertFalse("isFailed", request
.isFailed());
296 assertFalse("isCancelled", request
.isCancelled());
298 assertTrue ("handleCompleted", crFlags
[0]);
299 assertTrue ("handleSuccess", crFlags
[1]);
300 assertFalse("handleFailure", crFlags
[2]);
301 assertFalse("handleCancel", crFlags
[3]);
303 // Validate the first coalesced request
304 assertTrue ("isCompleted", subRequest1
.isCompleted());
305 assertFalse("isFailed", subRequest1
.isFailed());
306 assertFalse("isCancelled", subRequest1
.isCancelled());
308 // Validate the second coalesced request
309 assertTrue ("isCompleted", subRequest2
.isCompleted());
310 assertFalse("isFailed", subRequest2
.isFailed());
311 assertFalse("isCancelled", subRequest2
.isCancelled());
314 // ------------------------------------------------------------------------
316 // ------------------------------------------------------------------------
318 public void testFail() {
320 final boolean[] crFlags
= new boolean[4];
321 TmfCoalescedEventRequest
<TmfEvent
> request
= setupTestRequest(crFlags
);
322 TmfEventRequest
<TmfEvent
> subRequest1
= new TmfEventRequestStub
<TmfEvent
>(TmfEvent
.class, range1
, 100, 200);
323 TmfEventRequest
<TmfEvent
> subRequest2
= new TmfEventRequestStub
<TmfEvent
>(TmfEvent
.class, range1
, 100, 200);
324 request
.addRequest(subRequest1
);
325 request
.addRequest(subRequest2
);
329 // Validate the coalescing request
330 assertTrue ("isCompleted", request
.isCompleted());
331 assertTrue ("isFailed", request
.isFailed());
332 assertFalse("isCancelled", request
.isCancelled());
334 assertTrue ("handleCompleted", crFlags
[0]);
335 assertFalse("handleSuccess", crFlags
[1]);
336 assertTrue ("handleFailure", crFlags
[2]);
337 assertFalse("handleCancel", crFlags
[3]);
339 // Validate the first coalesced request
340 assertTrue ("isCompleted", subRequest1
.isCompleted());
341 assertTrue ("isFailed", subRequest1
.isFailed());
342 assertFalse("isCancelled", subRequest1
.isCancelled());
344 // Validate the second coalesced request
345 assertTrue ("isCompleted", subRequest2
.isCompleted());
346 assertTrue ("isFailed", subRequest2
.isFailed());
347 assertFalse("isCancelled", subRequest2
.isCancelled());
350 // ------------------------------------------------------------------------
352 // ------------------------------------------------------------------------
354 public void testCancel() {
356 final boolean[] crFlags
= new boolean[4];
357 TmfCoalescedEventRequest
<TmfEvent
> request
= setupTestRequest(crFlags
);
358 TmfEventRequest
<TmfEvent
> subRequest1
= new TmfEventRequestStub
<TmfEvent
>(TmfEvent
.class, range1
, 100, 200);
359 TmfEventRequest
<TmfEvent
> subRequest2
= new TmfEventRequestStub
<TmfEvent
>(TmfEvent
.class, range1
, 100, 200);
360 request
.addRequest(subRequest1
);
361 request
.addRequest(subRequest2
);
365 // Validate the coalescing request
366 assertTrue ("isCompleted", request
.isCompleted());
367 assertFalse("isFailed", request
.isFailed());
368 assertTrue ("isCancelled", request
.isCancelled());
370 assertTrue ("handleCompleted", crFlags
[0]);
371 assertFalse("handleSuccess", crFlags
[1]);
372 assertFalse("handleFailure", crFlags
[2]);
373 assertTrue ("handleCancel", crFlags
[3]);
375 // Validate the first coalesced request
376 assertTrue ("isCompleted", subRequest1
.isCompleted());
377 assertFalse("isFailed", subRequest1
.isFailed());
378 assertTrue ("isCancelled", subRequest1
.isCancelled());
380 // Validate the second coalesced request
381 assertTrue ("isCompleted", subRequest2
.isCompleted());
382 assertFalse("isFailed", subRequest2
.isFailed());
383 assertTrue ("isCancelled", subRequest2
.isCancelled());
386 // ------------------------------------------------------------------------
388 // ------------------------------------------------------------------------
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
= 10000;
397 private static final int BLOCK_SIZE
= 100;
399 // Initialize the test trace
400 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);
407 } catch (TmfTraceException e
) {
409 } catch (URISyntaxException e
) {
411 } catch (IOException e
) {
418 Vector
<TmfEvent
> requestedEvents1
;
419 Vector
<TmfEvent
> requestedEvents2
;
420 Vector
<TmfEvent
> requestedEvents3
;
422 TmfEventRequest
<TmfEvent
> request1
;
423 TmfEventRequest
<TmfEvent
> request2
;
424 TmfEventRequest
<TmfEvent
> request3
;
426 ITmfDataProvider
<TmfEvent
>[] providers
;
428 private static class TmfTestTriggerSignal
extends TmfSignal
{
429 public final boolean forceCancel
;
430 public TmfTestTriggerSignal(Object source
, boolean cancel
) {
432 forceCancel
= cancel
;
437 @SuppressWarnings("unchecked")
439 public void trigger(final TmfTestTriggerSignal signal
) {
441 TmfTimeRange range
= new TmfTimeRange(TmfTimestamp
.BIG_BANG
, TmfTimestamp
.BIG_CRUNCH
);
443 requestedEvents1
= new Vector
<TmfEvent
>();
444 request1
= new TmfEventRequest
<TmfEvent
>(TmfEvent
.class, range
, NB_EVENTS
, BLOCK_SIZE
) {
447 public void handleData(TmfEvent event
) {
448 super.handleData(event
);
449 if (!isCompleted()) {
450 requestedEvents1
.add(event
);
451 if (++nbRead
>= BLOCK_SIZE
&& signal
.forceCancel
)
457 requestedEvents2
= new Vector
<TmfEvent
>();
458 request2
= new TmfEventRequest
<TmfEvent
>(TmfEvent
.class, range
, NB_EVENTS
, BLOCK_SIZE
) {
460 public void handleData(TmfEvent event
) {
461 super.handleData(event
);
462 if (!isCompleted()) {
463 requestedEvents2
.add(event
);
468 requestedEvents3
= new Vector
<TmfEvent
>();
469 request3
= new TmfEventRequest
<TmfEvent
>(TmfEvent
.class, range
, NB_EVENTS
, BLOCK_SIZE
) {
471 public void handleData(TmfEvent event
) {
472 super.handleData(event
);
473 if (!isCompleted()) {
474 requestedEvents3
.add(event
);
479 providers
= (ITmfDataProvider
<TmfEvent
>[]) TmfProviderManager
.getProviders(TmfEvent
.class, TmfTraceStub
.class);
480 providers
[0].sendRequest(request1
);
481 providers
[0].sendRequest(request2
);
482 providers
[0].sendRequest(request3
);
485 public void testCoalescedRequest() throws Exception
{
487 fTrace
= setupTrace(DIRECTORY
+ File
.separator
+ TEST_STREAM
);
489 TmfSignalManager
.register(this);
490 TmfTestTriggerSignal signal
= new TmfTestTriggerSignal(this, false);
491 TmfSignalManager
.dispatchSignal(signal
);
493 request1
.waitForCompletion();
494 request2
.waitForCompletion();
495 request3
.waitForCompletion();
497 assertEquals("Request1: nbEvents", NB_EVENTS
, requestedEvents1
.size());
498 assertTrue ("Request1: isCompleted", request1
.isCompleted());
499 assertFalse ("Request1: isCancelled", request1
.isCancelled());
501 assertEquals("Request2: nbEvents", NB_EVENTS
, requestedEvents2
.size());
502 assertTrue ("Request2: isCompleted", request2
.isCompleted());
503 assertFalse ("Request2: isCancelled", request2
.isCancelled());
505 assertEquals("Request3: nbEvents", NB_EVENTS
, requestedEvents3
.size());
506 assertTrue ("Request3: isCompleted", request3
.isCompleted());
507 assertFalse ("Request3: isCancelled", request3
.isCancelled());
509 // Ensure that we have distinct events.
510 // Don't go overboard: we are not validating the stub!
511 for (int i
= 0; i
< NB_EVENTS
; i
++) {
512 assertEquals("Distinct events", i
+1, requestedEvents1
.get(i
).getTimestamp().getValue());
513 assertEquals("Distinct events", i
+1, requestedEvents2
.get(i
).getTimestamp().getValue());
514 assertEquals("Distinct events", i
+1, requestedEvents3
.get(i
).getTimestamp().getValue());
517 TmfSignalManager
.deregister(this);
522 public void testCancelCoalescedRequest() throws Exception
{
524 fTrace
= setupTrace(DIRECTORY
+ File
.separator
+ TEST_STREAM
);
526 TmfSignalManager
.register(this);
527 TmfTestTriggerSignal signal
= new TmfTestTriggerSignal(this, true);
528 TmfSignalManager
.dispatchSignal(signal
);
530 request1
.waitForCompletion();
531 request2
.waitForCompletion();
532 request3
.waitForCompletion();
534 assertEquals("Request1: nbEvents", BLOCK_SIZE
, requestedEvents1
.size());
535 assertTrue ("Request1: isCompleted", request1
.isCompleted());
536 assertTrue ("Request1: isCancelled", request1
.isCancelled());
538 assertEquals("Request2: nbEvents", NB_EVENTS
, requestedEvents2
.size());
539 assertTrue ("Request2: isCompleted", request2
.isCompleted());
540 assertFalse ("Request2: isCancelled", request2
.isCancelled());
542 assertEquals("Request3: nbEvents", NB_EVENTS
, requestedEvents3
.size());
543 assertTrue ("Request3: isCompleted", request3
.isCompleted());
544 assertFalse ("Request3: isCancelled", request3
.isCancelled());
546 // Ensure that we have distinct events.
547 // Don't go overboard: we are not validating the stub!
548 for (int i
= 0; i
< NB_EVENTS
; i
++) {
549 assertEquals("Distinct events", i
+1, requestedEvents2
.get(i
).getTimestamp().getValue());
550 assertEquals("Distinct events", i
+1, requestedEvents3
.get(i
).getTimestamp().getValue());
553 TmfSignalManager
.deregister(this);