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
.tests
.stubs
.request
.TmfDataRequestStub
;
25 import org
.junit
.Before
;
26 import org
.junit
.Test
;
29 * Test suite for the TmfCoalescedDataRequest class.
31 @SuppressWarnings("javadoc")
32 public class TmfCoalescedDataRequestTest
{
34 // ------------------------------------------------------------------------
36 // ------------------------------------------------------------------------
38 private TmfCoalescedDataRequest fRequest1
;
39 private TmfCoalescedDataRequest fRequest2
;
40 private TmfCoalescedDataRequest fRequest3
;
41 private TmfCoalescedDataRequest fRequest4
;
43 private TmfCoalescedDataRequest fRequest1b
;
44 private TmfCoalescedDataRequest fRequest1c
;
46 private int fRequestCount
;
48 // ------------------------------------------------------------------------
50 // ------------------------------------------------------------------------
54 TmfDataRequest
.reset();
55 fRequest1
= new TmfCoalescedDataRequest(ITmfEvent
.class, 10, 100, 200);
56 fRequest2
= new TmfCoalescedDataRequest(ITmfEvent
.class, 20, 100, 200);
57 fRequest3
= new TmfCoalescedDataRequest(ITmfEvent
.class, 20, 200, 200);
58 fRequest4
= new TmfCoalescedDataRequest(ITmfEvent
.class, 20, 200, 300);
60 fRequest1b
= new TmfCoalescedDataRequest(ITmfEvent
.class, 10, 100, 200);
61 fRequest1c
= new TmfCoalescedDataRequest(ITmfEvent
.class, 10, 100, 200);
63 fRequestCount
= fRequest1c
.getRequestId() + 1;
66 private static TmfCoalescedDataRequest
setupTestRequest(final boolean[] flags
) {
68 TmfCoalescedDataRequest request
= new TmfCoalescedDataRequest(ITmfEvent
.class, 10, 100, 200) {
70 public void handleCompleted() {
71 super.handleCompleted();
76 public void handleSuccess() {
77 super.handleSuccess();
82 public void handleFailure() {
83 super.handleFailure();
88 public void handleCancel() {
96 // ------------------------------------------------------------------------
98 // ------------------------------------------------------------------------
101 public void testTmfCoalescedDataRequest() {
102 TmfCoalescedDataRequest request
= new TmfCoalescedDataRequest(ITmfEvent
.class);
104 assertEquals("getRequestId", fRequestCount
++, request
.getRequestId());
105 assertEquals("getDataType", ITmfEvent
.class, request
.getDataType());
107 assertEquals("getIndex", 0, request
.getIndex());
108 assertEquals("getNbRequestedEvents", TmfDataRequest
.ALL_DATA
, request
.getNbRequested());
110 assertFalse("isCompleted", request
.isCompleted());
111 assertFalse("isFailed", request
.isFailed());
112 assertFalse("isCancelled", request
.isCancelled());
114 assertEquals("getNbRead", 0, request
.getNbRead());
118 public void testTmfCoalescedDataRequestIndex() {
119 TmfCoalescedDataRequest request
= new TmfCoalescedDataRequest(ITmfEvent
.class, 10);
121 assertEquals("getRequestId", fRequestCount
++, request
.getRequestId());
122 assertEquals("getDataType", ITmfEvent
.class, request
.getDataType());
124 assertEquals("getIndex", 10, request
.getIndex());
125 assertEquals("getNbRequestedEvents", TmfDataRequest
.ALL_DATA
, request
.getNbRequested());
127 assertFalse("isCompleted", request
.isCompleted());
128 assertFalse("isFailed", request
.isFailed());
129 assertFalse("isCancelled", request
.isCancelled());
131 assertEquals("getNbRead", 0, request
.getNbRead());
135 public void testTmfCoalescedDataRequestIndexNbRequested() {
136 TmfCoalescedDataRequest request
= new TmfCoalescedDataRequest(ITmfEvent
.class, 10, 100);
138 assertEquals("getRequestId", fRequestCount
++, request
.getRequestId());
139 assertEquals("getDataType", ITmfEvent
.class, request
.getDataType());
141 assertEquals("getIndex", 10, request
.getIndex());
142 assertEquals("getNbRequestedEvents", 100, request
.getNbRequested());
144 assertFalse("isCompleted", request
.isCompleted());
145 assertFalse("isFailed", request
.isFailed());
146 assertFalse("isCancelled", request
.isCancelled());
148 assertEquals("getNbRead", 0, request
.getNbRead());
152 public void testTmfCoalescedDataRequestIndexNbEventsBlocksize() {
153 TmfCoalescedDataRequest request
= new TmfCoalescedDataRequest(ITmfEvent
.class, 10, 100, 200);
155 assertEquals("getRequestId", fRequestCount
++, request
.getRequestId());
156 assertEquals("getDataType", ITmfEvent
.class, request
.getDataType());
158 assertEquals("getIndex", 10, request
.getIndex());
159 assertEquals("getNbRequestedEvents", 100, request
.getNbRequested());
161 assertFalse("isCompleted", request
.isCompleted());
162 assertFalse("isFailed", request
.isFailed());
163 assertFalse("isCancelled", request
.isCancelled());
165 assertEquals("getNbRead", 0, request
.getNbRead());
168 // ------------------------------------------------------------------------
170 // ------------------------------------------------------------------------
173 public void testEqualsReflexivity() {
174 assertTrue("equals", fRequest1
.equals(fRequest1
));
175 assertTrue("equals", fRequest2
.equals(fRequest2
));
177 assertFalse("equals", fRequest1
.equals(fRequest2
));
178 assertFalse("equals", fRequest2
.equals(fRequest1
));
182 public void testEqualsSymmetry() {
183 assertTrue("equals", fRequest1
.equals(fRequest1b
));
184 assertTrue("equals", fRequest1b
.equals(fRequest1
));
186 assertFalse("equals", fRequest1
.equals(fRequest3
));
187 assertFalse("equals", fRequest2
.equals(fRequest3
));
188 assertFalse("equals", fRequest3
.equals(fRequest1
));
189 assertFalse("equals", fRequest3
.equals(fRequest2
));
193 public void testEqualsTransivity() {
194 assertTrue("equals", fRequest1
.equals(fRequest1b
));
195 assertTrue("equals", fRequest1b
.equals(fRequest1c
));
196 assertTrue("equals", fRequest1
.equals(fRequest1c
));
200 public void testEqualsNull() {
201 assertFalse("equals", fRequest1
.equals(null));
202 assertFalse("equals", fRequest2
.equals(null));
205 // ------------------------------------------------------------------------
207 // ------------------------------------------------------------------------
210 public void testHashCode() {
211 assertTrue("hashCode", fRequest1
.hashCode() == fRequest1
.hashCode());
212 assertTrue("hashCode", fRequest2
.hashCode() == fRequest2
.hashCode());
213 assertTrue("hashCode", fRequest1
.hashCode() != fRequest2
.hashCode());
216 // ------------------------------------------------------------------------
218 // ------------------------------------------------------------------------
221 public void testToString() {
222 String expected1
= "[TmfCoalescedDataRequest(0,ITmfEvent,10,100,200)]";
223 String expected2
= "[TmfCoalescedDataRequest(1,ITmfEvent,20,100,200)]";
224 String expected3
= "[TmfCoalescedDataRequest(2,ITmfEvent,20,200,200)]";
225 String expected4
= "[TmfCoalescedDataRequest(3,ITmfEvent,20,200,300)]";
227 assertEquals("toString", expected1
, fRequest1
.toString());
228 assertEquals("toString", expected2
, fRequest2
.toString());
229 assertEquals("toString", expected3
, fRequest3
.toString());
230 assertEquals("toString", expected4
, fRequest4
.toString());
233 // ------------------------------------------------------------------------
235 // ------------------------------------------------------------------------
238 public void testIsCompatible() {
239 TmfCoalescedDataRequest coalescedRequest
= new TmfCoalescedDataRequest(ITmfEvent
.class, 10, 100, 200);
240 TmfDataRequest request1
= new TmfDataRequestStub(ITmfEvent
.class, 10, 100, 200);
241 TmfDataRequest request2
= new TmfDataRequestStub(ITmfEvent
.class, 5, 100, 200);
242 TmfDataRequest request3
= new TmfDataRequestStub(ITmfEvent
.class, 5, 4, 200);
243 TmfDataRequest request4
= new TmfDataRequestStub(ITmfEvent
.class, 5, 5, 200);
244 TmfDataRequest request5
= new TmfDataRequestStub(ITmfEvent
.class, 15, 100, 200);
245 TmfDataRequest request6
= new TmfDataRequestStub(ITmfEvent
.class, 100, 100, 200);
246 TmfDataRequest request7
= new TmfDataRequestStub(ITmfEvent
.class, 110, 100, 200);
247 TmfDataRequest request8
= new TmfDataRequestStub(ITmfEvent
.class, 111, 100, 200);
249 assertTrue("isCompatible", coalescedRequest
.isCompatible(request1
));
250 assertTrue("isCompatible", coalescedRequest
.isCompatible(request2
));
251 assertTrue("isCompatible", coalescedRequest
.isCompatible(request3
));
252 assertTrue("isCompatible", coalescedRequest
.isCompatible(request4
));
253 assertTrue("isCompatible", coalescedRequest
.isCompatible(request5
));
254 assertTrue("isCompatible", coalescedRequest
.isCompatible(request6
));
255 assertTrue("isCompatible", coalescedRequest
.isCompatible(request7
));
256 assertTrue("isCompatible", coalescedRequest
.isCompatible(request8
));
258 TmfDataRequest request9
= new TmfDataRequestStub(ITmfEvent
.class, 5, 3, 200);
259 TmfDataRequest request10
= new TmfDataRequestStub(ITmfEvent
.class, 112, 100, 200);
261 assertFalse("isCompatible", coalescedRequest
.isCompatible(request9
));
262 assertFalse("isCompatible", coalescedRequest
.isCompatible(request10
));
265 // ------------------------------------------------------------------------
267 // ------------------------------------------------------------------------
270 public void testAddRequest1() {
271 TmfCoalescedDataRequest coalescedRequest
= new TmfCoalescedDataRequest(ITmfEvent
.class, 10, 100, 200);
272 TmfDataRequest request
= new TmfDataRequestStub(ITmfEvent
.class, 10, 100, 200);
274 assertTrue("isCompatible", coalescedRequest
.isCompatible(request
));
275 coalescedRequest
.addRequest(request
);
276 assertEquals("addRequest", 10, coalescedRequest
.getIndex());
277 assertEquals("addRequest", 100, coalescedRequest
.getNbRequested());
278 assertEquals("addRequest", 200, coalescedRequest
.getBlockSize());
282 public void testAddRequest2() {
283 TmfCoalescedDataRequest coalescedRequest
= new TmfCoalescedDataRequest(ITmfEvent
.class, 10, 100, 200);
284 TmfDataRequest request
= new TmfDataRequestStub(ITmfEvent
.class, 5, 100, 200);
286 assertTrue("isCompatible", coalescedRequest
.isCompatible(request
));
287 coalescedRequest
.addRequest(request
);
288 assertEquals("addRequest", 5, coalescedRequest
.getIndex());
289 assertEquals("addRequest", 105, coalescedRequest
.getNbRequested());
290 assertEquals("addRequest", 200, coalescedRequest
.getBlockSize());
294 public void testAddRequest3() {
295 TmfCoalescedDataRequest coalescedRequest
= new TmfCoalescedDataRequest(ITmfEvent
.class, 10, 100, 200);
296 TmfDataRequest request
= new TmfDataRequestStub(ITmfEvent
.class, 5, 4, 200);
298 assertTrue("isCompatible", coalescedRequest
.isCompatible(request
));
299 coalescedRequest
.addRequest(request
);
300 assertEquals("addRequest", 5, coalescedRequest
.getIndex());
301 assertEquals("addRequest", 105, coalescedRequest
.getNbRequested());
302 assertEquals("addRequest", 200, coalescedRequest
.getBlockSize());
306 public void testAddRequest4() {
307 TmfCoalescedDataRequest coalescedRequest
= new TmfCoalescedDataRequest(ITmfEvent
.class, 10, 100, 200);
308 TmfDataRequest request
= new TmfDataRequestStub(ITmfEvent
.class, 5, 5, 200);
310 assertTrue("isCompatible", coalescedRequest
.isCompatible(request
));
311 coalescedRequest
.addRequest(request
);
312 assertEquals("addRequest", 5, coalescedRequest
.getIndex());
313 assertEquals("addRequest", 105, coalescedRequest
.getNbRequested());
314 assertEquals("addRequest", 200, coalescedRequest
.getBlockSize());
318 public void testAddRequest5() {
319 TmfCoalescedDataRequest coalescedRequest
= new TmfCoalescedDataRequest(ITmfEvent
.class, 10, 100, 200);
320 TmfDataRequest request
= new TmfDataRequestStub(ITmfEvent
.class, 15, 100, 200);
322 assertTrue("isCompatible", coalescedRequest
.isCompatible(request
));
323 coalescedRequest
.addRequest(request
);
324 assertEquals("addRequest", 10, coalescedRequest
.getIndex());
325 assertEquals("addRequest", 105, coalescedRequest
.getNbRequested());
326 assertEquals("addRequest", 200, coalescedRequest
.getBlockSize());
330 public void testAddRequest6() {
331 TmfCoalescedDataRequest coalescedRequest
= new TmfCoalescedDataRequest(ITmfEvent
.class, 10, 100, 200);
332 TmfDataRequest request
= new TmfDataRequestStub(ITmfEvent
.class, 100, 100, 200);
334 assertTrue("isCompatible", coalescedRequest
.isCompatible(request
));
335 coalescedRequest
.addRequest(request
);
336 assertEquals("addRequest", 10, coalescedRequest
.getIndex());
337 assertEquals("addRequest", 190, coalescedRequest
.getNbRequested());
338 assertEquals("addRequest", 200, coalescedRequest
.getBlockSize());
342 public void testAddRequest7() {
343 TmfCoalescedDataRequest coalescedRequest
= new TmfCoalescedDataRequest(ITmfEvent
.class, 10, 100, 200);
344 TmfDataRequest request
= new TmfDataRequestStub(ITmfEvent
.class, 110, 100, 200);
346 assertTrue("isCompatible", coalescedRequest
.isCompatible(request
));
347 coalescedRequest
.addRequest(request
);
348 assertEquals("addRequest", 10, coalescedRequest
.getIndex());
349 assertEquals("addRequest", 200, coalescedRequest
.getNbRequested());
350 assertEquals("addRequest", 200, coalescedRequest
.getBlockSize());
354 public void testAddRequest8() {
355 TmfCoalescedDataRequest coalescedRequest
= new TmfCoalescedDataRequest(ITmfEvent
.class, 10, 100, 200);
356 TmfDataRequest request
= new TmfDataRequestStub(ITmfEvent
.class, 111, 100, 200);
358 assertTrue("isCompatible", coalescedRequest
.isCompatible(request
));
359 coalescedRequest
.addRequest(request
);
360 assertEquals("addRequest", 10, coalescedRequest
.getIndex());
361 assertEquals("addRequest", 201, coalescedRequest
.getNbRequested());
362 assertEquals("addRequest", 200, coalescedRequest
.getBlockSize());
365 // ------------------------------------------------------------------------
367 // ------------------------------------------------------------------------
370 public void testDone() {
372 final boolean[] crFlags
= new boolean[4];
373 TmfCoalescedDataRequest request
= setupTestRequest(crFlags
);
374 TmfDataRequest subRequest1
= new TmfDataRequestStub(ITmfEvent
.class, 10, 100, 200);
375 TmfDataRequest subRequest2
= new TmfDataRequestStub(ITmfEvent
.class, 10, 100, 200);
376 request
.addRequest(subRequest1
);
377 request
.addRequest(subRequest2
);
381 // Validate the coalescing request
382 assertTrue("isCompleted", request
.isCompleted());
383 assertFalse("isFailed", request
.isFailed());
384 assertFalse("isCancelled", request
.isCancelled());
386 assertTrue("handleCompleted", crFlags
[0]);
387 assertTrue("handleSuccess", crFlags
[1]);
388 assertFalse("handleFailure", crFlags
[2]);
389 assertFalse("handleCancel", crFlags
[3]);
391 // Validate the first coalesced request
392 assertTrue("isCompleted", subRequest1
.isCompleted());
393 assertFalse("isFailed", subRequest1
.isFailed());
394 assertFalse("isCancelled", subRequest1
.isCancelled());
396 // Validate the second coalesced request
397 assertTrue("isCompleted", subRequest2
.isCompleted());
398 assertFalse("isFailed", subRequest2
.isFailed());
399 assertFalse("isCancelled", subRequest2
.isCancelled());
402 // ------------------------------------------------------------------------
404 // ------------------------------------------------------------------------
407 public void testFail() {
408 final boolean[] crFlags
= new boolean[4];
409 TmfCoalescedDataRequest request
= setupTestRequest(crFlags
);
410 TmfDataRequest subRequest1
= new TmfDataRequestStub(ITmfEvent
.class, 10, 100, 200);
411 TmfDataRequest subRequest2
= new TmfDataRequestStub(ITmfEvent
.class, 10, 100, 200);
412 request
.addRequest(subRequest1
);
413 request
.addRequest(subRequest2
);
417 // Validate the coalescing request
418 assertTrue("isCompleted", request
.isCompleted());
419 assertTrue("isFailed", request
.isFailed());
420 assertFalse("isCancelled", request
.isCancelled());
422 assertTrue("handleCompleted", crFlags
[0]);
423 assertFalse("handleSuccess", crFlags
[1]);
424 assertTrue("handleFailure", crFlags
[2]);
425 assertFalse("handleCancel", crFlags
[3]);
427 // Validate the first coalesced request
428 assertTrue("isCompleted", subRequest1
.isCompleted());
429 assertTrue("isFailed", subRequest1
.isFailed());
430 assertFalse("isCancelled", subRequest1
.isCancelled());
432 // Validate the second coalesced request
433 assertTrue("isCompleted", subRequest2
.isCompleted());
434 assertTrue("isFailed", subRequest2
.isFailed());
435 assertFalse("isCancelled", subRequest2
.isCancelled());
438 // ------------------------------------------------------------------------
440 // ------------------------------------------------------------------------
443 public void testCancel() {
444 final boolean[] crFlags
= new boolean[4];
445 TmfCoalescedDataRequest request
= setupTestRequest(crFlags
);
446 TmfDataRequest subRequest1
= new TmfDataRequestStub(ITmfEvent
.class, 10, 100, 200);
447 TmfDataRequest subRequest2
= new TmfDataRequestStub(ITmfEvent
.class, 10, 100, 200);
448 request
.addRequest(subRequest1
);
449 request
.addRequest(subRequest2
);
453 // Validate the coalescing request
454 assertTrue("isCompleted", request
.isCompleted());
455 assertFalse("isFailed", request
.isFailed());
456 assertTrue("isCancelled", request
.isCancelled());
458 assertTrue("handleCompleted", crFlags
[0]);
459 assertFalse("handleSuccess", crFlags
[1]);
460 assertFalse("handleFailure", crFlags
[2]);
461 assertTrue("handleCancel", crFlags
[3]);
463 // Validate the first coalesced request
464 assertTrue("isCompleted", subRequest1
.isCompleted());
465 assertFalse("isFailed", subRequest1
.isFailed());
466 assertTrue("isCancelled", subRequest1
.isCancelled());
468 // Validate the second coalesced request
469 assertTrue("isCompleted", subRequest2
.isCompleted());
470 assertFalse("isFailed", subRequest2
.isFailed());
471 assertTrue("isCancelled", subRequest2
.isCancelled());
474 // ------------------------------------------------------------------------
475 // cancel sub-requests
476 // ------------------------------------------------------------------------
479 public void testCancelSubRequests() {
480 final boolean[] crFlags
= new boolean[4];
481 TmfCoalescedDataRequest request
= setupTestRequest(crFlags
);
482 TmfDataRequest subRequest1
= new TmfDataRequestStub(ITmfEvent
.class, 10, 100, 200);
483 TmfDataRequest subRequest2
= new TmfDataRequestStub(ITmfEvent
.class, 10, 100, 200);
484 request
.addRequest(subRequest1
);
485 request
.addRequest(subRequest2
);
487 subRequest1
.cancel();
489 // Validate the first coalesced request
490 assertTrue ("isCompleted", subRequest1
.isCompleted());
491 assertFalse("isFailed", subRequest1
.isFailed());
492 assertTrue ("isCancelled", subRequest1
.isCancelled());
494 // Validate the coalescing request
495 assertFalse("isCompleted", request
.isCompleted());
496 assertFalse("isFailed", request
.isFailed());
497 assertFalse("isCancelled", request
.isCancelled());
499 // Cancel second sub-request
500 subRequest2
.cancel();
502 // Validate the second coalesced request
503 assertTrue ("isCompleted", subRequest2
.isCompleted());
504 assertFalse("isFailed", subRequest2
.isFailed());
505 assertTrue("isCancelled", subRequest2
.isCancelled());
507 // Validate the coalescing request
508 assertTrue("isCompleted", request
.isCompleted());
509 assertFalse("isFailed", request
.isFailed());
510 assertTrue("isCancelled", request
.isCancelled());
512 // Finalize coalescing request -
513 // Note: No need to check "request.isCancelled()" since it was verified
517 assertTrue("handleCompleted", crFlags
[0]);
518 assertFalse("handleSuccess", crFlags
[1]);
519 assertFalse("handleFailure", crFlags
[2]);
520 assertTrue("handleCancel", crFlags
[3]);