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 * Francois Chouinard - Added tests to check offsets
12 * Alexandre Montplaisir - Port to JUnit4
13 *******************************************************************************/
15 package org
.eclipse
.linuxtools
.tmf
.core
.tests
.request
;
17 import static org
.junit
.Assert
.assertEquals
;
18 import static org
.junit
.Assert
.assertFalse
;
19 import static org
.junit
.Assert
.assertTrue
;
21 import org
.eclipse
.linuxtools
.internal
.tmf
.core
.request
.TmfCoalescedDataRequest
;
22 import org
.eclipse
.linuxtools
.tmf
.core
.event
.ITmfEvent
;
23 import org
.eclipse
.linuxtools
.tmf
.core
.request
.TmfDataRequest
;
24 import org
.eclipse
.linuxtools
.tmf
.core
.request
.ITmfDataRequest
.ExecutionType
;
25 import org
.eclipse
.linuxtools
.tmf
.tests
.stubs
.request
.TmfDataRequestStub
;
26 import org
.junit
.Before
;
27 import org
.junit
.Test
;
30 * Test suite for the TmfCoalescedDataRequest class.
32 @SuppressWarnings("javadoc")
33 public class TmfCoalescedDataRequestTest
{
35 // ------------------------------------------------------------------------
37 // ------------------------------------------------------------------------
39 private TmfCoalescedDataRequest fRequest1
;
40 private TmfCoalescedDataRequest fRequest2
;
41 private TmfCoalescedDataRequest fRequest3
;
42 private TmfCoalescedDataRequest fRequest4
;
44 private TmfCoalescedDataRequest fRequest1b
;
45 private TmfCoalescedDataRequest fRequest1c
;
47 private int fRequestCount
;
49 // ------------------------------------------------------------------------
51 // ------------------------------------------------------------------------
55 TmfDataRequest
.reset();
56 fRequest1
= new TmfCoalescedDataRequest(ITmfEvent
.class, 10, 100, ExecutionType
.FOREGROUND
);
57 fRequest2
= new TmfCoalescedDataRequest(ITmfEvent
.class, 20, 100, ExecutionType
.FOREGROUND
);
58 fRequest3
= new TmfCoalescedDataRequest(ITmfEvent
.class, 20, 200, ExecutionType
.FOREGROUND
);
59 fRequest4
= new TmfCoalescedDataRequest(ITmfEvent
.class, 20, 200, ExecutionType
.FOREGROUND
);
61 fRequest1b
= new TmfCoalescedDataRequest(ITmfEvent
.class, 10, 100, ExecutionType
.FOREGROUND
);
62 fRequest1c
= new TmfCoalescedDataRequest(ITmfEvent
.class, 10, 100, ExecutionType
.FOREGROUND
);
64 fRequestCount
= fRequest1c
.getRequestId() + 1;
67 private static TmfCoalescedDataRequest
setupTestRequest(final boolean[] flags
) {
69 TmfCoalescedDataRequest request
= new TmfCoalescedDataRequest(ITmfEvent
.class, 10, 100, ExecutionType
.FOREGROUND
) {
71 public void handleCompleted() {
72 super.handleCompleted();
77 public void handleSuccess() {
78 super.handleSuccess();
83 public void handleFailure() {
84 super.handleFailure();
89 public void handleCancel() {
97 // ------------------------------------------------------------------------
99 // ------------------------------------------------------------------------
102 public void testTmfCoalescedDataRequestIndexNbEventsBlocksize() {
103 TmfCoalescedDataRequest request
= new TmfCoalescedDataRequest(ITmfEvent
.class, 10, 100, ExecutionType
.FOREGROUND
);
105 assertEquals("getRequestId", fRequestCount
++, request
.getRequestId());
106 assertEquals("getDataType", ITmfEvent
.class, request
.getDataType());
108 assertEquals("getIndex", 10, request
.getIndex());
109 assertEquals("getNbRequestedEvents", 100, request
.getNbRequested());
111 assertFalse("isCompleted", request
.isCompleted());
112 assertFalse("isFailed", request
.isFailed());
113 assertFalse("isCancelled", request
.isCancelled());
115 assertEquals("getNbRead", 0, request
.getNbRead());
118 // ------------------------------------------------------------------------
120 // ------------------------------------------------------------------------
123 public void testEqualsReflexivity() {
124 assertTrue("equals", fRequest1
.equals(fRequest1
));
125 assertTrue("equals", fRequest2
.equals(fRequest2
));
127 assertFalse("equals", fRequest1
.equals(fRequest2
));
128 assertFalse("equals", fRequest2
.equals(fRequest1
));
132 public void testEqualsSymmetry() {
133 assertTrue("equals", fRequest1
.equals(fRequest1b
));
134 assertTrue("equals", fRequest1b
.equals(fRequest1
));
136 assertFalse("equals", fRequest1
.equals(fRequest3
));
137 assertFalse("equals", fRequest2
.equals(fRequest3
));
138 assertFalse("equals", fRequest3
.equals(fRequest1
));
139 assertFalse("equals", fRequest3
.equals(fRequest2
));
143 public void testEqualsTransivity() {
144 assertTrue("equals", fRequest1
.equals(fRequest1b
));
145 assertTrue("equals", fRequest1b
.equals(fRequest1c
));
146 assertTrue("equals", fRequest1
.equals(fRequest1c
));
150 public void testEqualsNull() {
151 assertFalse("equals", fRequest1
.equals(null));
152 assertFalse("equals", fRequest2
.equals(null));
155 // ------------------------------------------------------------------------
157 // ------------------------------------------------------------------------
160 public void testHashCode() {
161 assertTrue("hashCode", fRequest1
.hashCode() == fRequest1
.hashCode());
162 assertTrue("hashCode", fRequest2
.hashCode() == fRequest2
.hashCode());
163 assertTrue("hashCode", fRequest1
.hashCode() != fRequest2
.hashCode());
166 // ------------------------------------------------------------------------
168 // ------------------------------------------------------------------------
171 public void testToString() {
172 String expected1
= "[TmfCoalescedDataRequest(0,ITmfEvent,10,100)]";
173 String expected2
= "[TmfCoalescedDataRequest(1,ITmfEvent,20,100)]";
174 String expected3
= "[TmfCoalescedDataRequest(2,ITmfEvent,20,200)]";
175 String expected4
= "[TmfCoalescedDataRequest(3,ITmfEvent,20,200)]";
177 assertEquals("toString", expected1
, fRequest1
.toString());
178 assertEquals("toString", expected2
, fRequest2
.toString());
179 assertEquals("toString", expected3
, fRequest3
.toString());
180 assertEquals("toString", expected4
, fRequest4
.toString());
183 // ------------------------------------------------------------------------
185 // ------------------------------------------------------------------------
188 public void testIsCompatible() {
189 TmfCoalescedDataRequest coalescedRequest
= new TmfCoalescedDataRequest(ITmfEvent
.class, 10, 100, ExecutionType
.FOREGROUND
);
190 TmfDataRequest request1
= new TmfDataRequestStub(ITmfEvent
.class, 10, 100);
191 TmfDataRequest request2
= new TmfDataRequestStub(ITmfEvent
.class, 5, 100);
192 TmfDataRequest request3
= new TmfDataRequestStub(ITmfEvent
.class, 5, 4);
193 TmfDataRequest request4
= new TmfDataRequestStub(ITmfEvent
.class, 5, 5);
194 TmfDataRequest request5
= new TmfDataRequestStub(ITmfEvent
.class, 15, 100);
195 TmfDataRequest request6
= new TmfDataRequestStub(ITmfEvent
.class, 100, 100);
196 TmfDataRequest request7
= new TmfDataRequestStub(ITmfEvent
.class, 110, 100);
197 TmfDataRequest request8
= new TmfDataRequestStub(ITmfEvent
.class, 111, 100);
199 assertTrue("isCompatible", coalescedRequest
.isCompatible(request1
));
200 assertTrue("isCompatible", coalescedRequest
.isCompatible(request2
));
201 assertTrue("isCompatible", coalescedRequest
.isCompatible(request3
));
202 assertTrue("isCompatible", coalescedRequest
.isCompatible(request4
));
203 assertTrue("isCompatible", coalescedRequest
.isCompatible(request5
));
204 assertTrue("isCompatible", coalescedRequest
.isCompatible(request6
));
205 assertTrue("isCompatible", coalescedRequest
.isCompatible(request7
));
206 assertTrue("isCompatible", coalescedRequest
.isCompatible(request8
));
208 TmfDataRequest request9
= new TmfDataRequestStub(ITmfEvent
.class, 5, 3);
209 TmfDataRequest request10
= new TmfDataRequestStub(ITmfEvent
.class, 112, 100);
211 assertFalse("isCompatible", coalescedRequest
.isCompatible(request9
));
212 assertFalse("isCompatible", coalescedRequest
.isCompatible(request10
));
215 // ------------------------------------------------------------------------
217 // ------------------------------------------------------------------------
220 public void testAddRequest1() {
221 TmfCoalescedDataRequest coalescedRequest
= new TmfCoalescedDataRequest(ITmfEvent
.class, 10, 100, ExecutionType
.FOREGROUND
);
222 TmfDataRequest request
= new TmfDataRequestStub(ITmfEvent
.class, 10, 100);
224 assertTrue("isCompatible", coalescedRequest
.isCompatible(request
));
225 coalescedRequest
.addRequest(request
);
226 assertEquals("addRequest", 10, coalescedRequest
.getIndex());
227 assertEquals("addRequest", 100, coalescedRequest
.getNbRequested());
231 public void testAddRequest2() {
232 TmfCoalescedDataRequest coalescedRequest
= new TmfCoalescedDataRequest(ITmfEvent
.class, 10, 100, ExecutionType
.FOREGROUND
);
233 TmfDataRequest request
= new TmfDataRequestStub(ITmfEvent
.class, 5, 100);
235 assertTrue("isCompatible", coalescedRequest
.isCompatible(request
));
236 coalescedRequest
.addRequest(request
);
237 assertEquals("addRequest", 5, coalescedRequest
.getIndex());
238 assertEquals("addRequest", 105, coalescedRequest
.getNbRequested());
242 public void testAddRequest3() {
243 TmfCoalescedDataRequest coalescedRequest
= new TmfCoalescedDataRequest(ITmfEvent
.class, 10, 100, ExecutionType
.FOREGROUND
);
244 TmfDataRequest request
= new TmfDataRequestStub(ITmfEvent
.class, 5, 4);
246 assertTrue("isCompatible", coalescedRequest
.isCompatible(request
));
247 coalescedRequest
.addRequest(request
);
248 assertEquals("addRequest", 5, coalescedRequest
.getIndex());
249 assertEquals("addRequest", 105, coalescedRequest
.getNbRequested());
253 public void testAddRequest4() {
254 TmfCoalescedDataRequest coalescedRequest
= new TmfCoalescedDataRequest(ITmfEvent
.class, 10, 100, ExecutionType
.FOREGROUND
);
255 TmfDataRequest request
= new TmfDataRequestStub(ITmfEvent
.class, 5, 5);
257 assertTrue("isCompatible", coalescedRequest
.isCompatible(request
));
258 coalescedRequest
.addRequest(request
);
259 assertEquals("addRequest", 5, coalescedRequest
.getIndex());
260 assertEquals("addRequest", 105, coalescedRequest
.getNbRequested());
264 public void testAddRequest5() {
265 TmfCoalescedDataRequest coalescedRequest
= new TmfCoalescedDataRequest(ITmfEvent
.class, 10, 100, ExecutionType
.FOREGROUND
);
266 TmfDataRequest request
= new TmfDataRequestStub(ITmfEvent
.class, 15, 100);
268 assertTrue("isCompatible", coalescedRequest
.isCompatible(request
));
269 coalescedRequest
.addRequest(request
);
270 assertEquals("addRequest", 10, coalescedRequest
.getIndex());
271 assertEquals("addRequest", 105, coalescedRequest
.getNbRequested());
275 public void testAddRequest6() {
276 TmfCoalescedDataRequest coalescedRequest
= new TmfCoalescedDataRequest(ITmfEvent
.class, 10, 100, ExecutionType
.FOREGROUND
);
277 TmfDataRequest request
= new TmfDataRequestStub(ITmfEvent
.class, 100, 100);
279 assertTrue("isCompatible", coalescedRequest
.isCompatible(request
));
280 coalescedRequest
.addRequest(request
);
281 assertEquals("addRequest", 10, coalescedRequest
.getIndex());
282 assertEquals("addRequest", 190, coalescedRequest
.getNbRequested());
286 public void testAddRequest7() {
287 TmfCoalescedDataRequest coalescedRequest
= new TmfCoalescedDataRequest(ITmfEvent
.class, 10, 100, ExecutionType
.FOREGROUND
);
288 TmfDataRequest request
= new TmfDataRequestStub(ITmfEvent
.class, 110, 100);
290 assertTrue("isCompatible", coalescedRequest
.isCompatible(request
));
291 coalescedRequest
.addRequest(request
);
292 assertEquals("addRequest", 10, coalescedRequest
.getIndex());
293 assertEquals("addRequest", 200, coalescedRequest
.getNbRequested());
297 public void testAddRequest8() {
298 TmfCoalescedDataRequest coalescedRequest
= new TmfCoalescedDataRequest(ITmfEvent
.class, 10, 100, ExecutionType
.FOREGROUND
);
299 TmfDataRequest request
= new TmfDataRequestStub(ITmfEvent
.class, 111, 100);
301 assertTrue("isCompatible", coalescedRequest
.isCompatible(request
));
302 coalescedRequest
.addRequest(request
);
303 assertEquals("addRequest", 10, coalescedRequest
.getIndex());
304 assertEquals("addRequest", 201, coalescedRequest
.getNbRequested());
307 // ------------------------------------------------------------------------
309 // ------------------------------------------------------------------------
312 public void testDone() {
314 final boolean[] crFlags
= new boolean[4];
315 TmfCoalescedDataRequest request
= setupTestRequest(crFlags
);
316 TmfDataRequest subRequest1
= new TmfDataRequestStub(ITmfEvent
.class, 10, 100);
317 TmfDataRequest subRequest2
= new TmfDataRequestStub(ITmfEvent
.class, 10, 100);
318 request
.addRequest(subRequest1
);
319 request
.addRequest(subRequest2
);
323 // Validate the coalescing request
324 assertTrue("isCompleted", request
.isCompleted());
325 assertFalse("isFailed", request
.isFailed());
326 assertFalse("isCancelled", request
.isCancelled());
328 assertTrue("handleCompleted", crFlags
[0]);
329 assertTrue("handleSuccess", crFlags
[1]);
330 assertFalse("handleFailure", crFlags
[2]);
331 assertFalse("handleCancel", crFlags
[3]);
333 // Validate the first coalesced request
334 assertTrue("isCompleted", subRequest1
.isCompleted());
335 assertFalse("isFailed", subRequest1
.isFailed());
336 assertFalse("isCancelled", subRequest1
.isCancelled());
338 // Validate the second coalesced request
339 assertTrue("isCompleted", subRequest2
.isCompleted());
340 assertFalse("isFailed", subRequest2
.isFailed());
341 assertFalse("isCancelled", subRequest2
.isCancelled());
344 // ------------------------------------------------------------------------
346 // ------------------------------------------------------------------------
349 public void testFail() {
350 final boolean[] crFlags
= new boolean[4];
351 TmfCoalescedDataRequest request
= setupTestRequest(crFlags
);
352 TmfDataRequest subRequest1
= new TmfDataRequestStub(ITmfEvent
.class, 10, 100);
353 TmfDataRequest subRequest2
= new TmfDataRequestStub(ITmfEvent
.class, 10, 100);
354 request
.addRequest(subRequest1
);
355 request
.addRequest(subRequest2
);
359 // Validate the coalescing request
360 assertTrue("isCompleted", request
.isCompleted());
361 assertTrue("isFailed", request
.isFailed());
362 assertFalse("isCancelled", request
.isCancelled());
364 assertTrue("handleCompleted", crFlags
[0]);
365 assertFalse("handleSuccess", crFlags
[1]);
366 assertTrue("handleFailure", crFlags
[2]);
367 assertFalse("handleCancel", crFlags
[3]);
369 // Validate the first coalesced request
370 assertTrue("isCompleted", subRequest1
.isCompleted());
371 assertTrue("isFailed", subRequest1
.isFailed());
372 assertFalse("isCancelled", subRequest1
.isCancelled());
374 // Validate the second coalesced request
375 assertTrue("isCompleted", subRequest2
.isCompleted());
376 assertTrue("isFailed", subRequest2
.isFailed());
377 assertFalse("isCancelled", subRequest2
.isCancelled());
380 // ------------------------------------------------------------------------
382 // ------------------------------------------------------------------------
385 public void testCancel() {
386 final boolean[] crFlags
= new boolean[4];
387 TmfCoalescedDataRequest request
= setupTestRequest(crFlags
);
388 TmfDataRequest subRequest1
= new TmfDataRequestStub(ITmfEvent
.class, 10, 100);
389 TmfDataRequest subRequest2
= new TmfDataRequestStub(ITmfEvent
.class, 10, 100);
390 request
.addRequest(subRequest1
);
391 request
.addRequest(subRequest2
);
395 // Validate the coalescing request
396 assertTrue("isCompleted", request
.isCompleted());
397 assertFalse("isFailed", request
.isFailed());
398 assertTrue("isCancelled", request
.isCancelled());
400 assertTrue("handleCompleted", crFlags
[0]);
401 assertFalse("handleSuccess", crFlags
[1]);
402 assertFalse("handleFailure", crFlags
[2]);
403 assertTrue("handleCancel", crFlags
[3]);
405 // Validate the first coalesced request
406 assertTrue("isCompleted", subRequest1
.isCompleted());
407 assertFalse("isFailed", subRequest1
.isFailed());
408 assertTrue("isCancelled", subRequest1
.isCancelled());
410 // Validate the second coalesced request
411 assertTrue("isCompleted", subRequest2
.isCompleted());
412 assertFalse("isFailed", subRequest2
.isFailed());
413 assertTrue("isCancelled", subRequest2
.isCancelled());
416 // ------------------------------------------------------------------------
417 // cancel sub-requests
418 // ------------------------------------------------------------------------
421 public void testCancelSubRequests() {
422 final boolean[] crFlags
= new boolean[4];
423 TmfCoalescedDataRequest request
= setupTestRequest(crFlags
);
424 TmfDataRequest subRequest1
= new TmfDataRequestStub(ITmfEvent
.class, 10, 100);
425 TmfDataRequest subRequest2
= new TmfDataRequestStub(ITmfEvent
.class, 10, 100);
426 request
.addRequest(subRequest1
);
427 request
.addRequest(subRequest2
);
429 subRequest1
.cancel();
431 // Validate the first coalesced request
432 assertTrue ("isCompleted", subRequest1
.isCompleted());
433 assertFalse("isFailed", subRequest1
.isFailed());
434 assertTrue ("isCancelled", subRequest1
.isCancelled());
436 // Validate the coalescing request
437 assertFalse("isCompleted", request
.isCompleted());
438 assertFalse("isFailed", request
.isFailed());
439 assertFalse("isCancelled", request
.isCancelled());
441 // Cancel second sub-request
442 subRequest2
.cancel();
444 // Validate the second coalesced request
445 assertTrue ("isCompleted", subRequest2
.isCompleted());
446 assertFalse("isFailed", subRequest2
.isFailed());
447 assertTrue("isCancelled", subRequest2
.isCancelled());
449 // Validate the coalescing request
450 assertTrue("isCompleted", request
.isCompleted());
451 assertFalse("isFailed", request
.isFailed());
452 assertTrue("isCancelled", request
.isCancelled());
454 // Finalize coalescing request -
455 // Note: No need to check "request.isCancelled()" since it was verified
459 assertTrue("handleCompleted", crFlags
[0]);
460 assertFalse("handleSuccess", crFlags
[1]);
461 assertFalse("handleFailure", crFlags
[2]);
462 assertTrue("handleCancel", crFlags
[3]);