1 /*******************************************************************************
2 * Copyright (c) 2009, 2010, 2012 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 *******************************************************************************/
14 package org
.eclipse
.linuxtools
.tmf
.core
.tests
.request
;
16 import junit
.framework
.TestCase
;
18 import org
.eclipse
.linuxtools
.internal
.tmf
.core
.request
.TmfCoalescedDataRequest
;
19 import org
.eclipse
.linuxtools
.tmf
.core
.event
.ITmfEvent
;
20 import org
.eclipse
.linuxtools
.tmf
.core
.event
.TmfEvent
;
21 import org
.eclipse
.linuxtools
.tmf
.core
.request
.TmfDataRequest
;
22 import org
.eclipse
.linuxtools
.tmf
.tests
.stubs
.request
.TmfDataRequestStub
;
25 * Test suite for the TmfCoalescedDataRequest class.
27 @SuppressWarnings({"nls","javadoc"})
28 public class TmfCoalescedDataRequestTest
extends TestCase
{
30 // ------------------------------------------------------------------------
32 // ------------------------------------------------------------------------
34 private TmfCoalescedDataRequest fRequest1
;
35 private TmfCoalescedDataRequest fRequest2
;
36 private TmfCoalescedDataRequest fRequest3
;
37 private TmfCoalescedDataRequest fRequest4
;
39 private TmfCoalescedDataRequest fRequest1b
;
40 private TmfCoalescedDataRequest fRequest1c
;
42 private int fRequestCount
;
44 // ------------------------------------------------------------------------
46 // ------------------------------------------------------------------------
49 * @param name the test name
51 public TmfCoalescedDataRequestTest(final String name
) {
56 public void setUp() throws Exception
{
58 TmfDataRequest
.reset();
59 fRequest1
= new TmfCoalescedDataRequest(TmfEvent
.class, 10, 100, 200);
60 fRequest2
= new TmfCoalescedDataRequest(TmfEvent
.class, 20, 100, 200);
61 fRequest3
= new TmfCoalescedDataRequest(TmfEvent
.class, 20, 200, 200);
62 fRequest4
= new TmfCoalescedDataRequest(TmfEvent
.class, 20, 200, 300);
64 fRequest1b
= new TmfCoalescedDataRequest(TmfEvent
.class, 10, 100, 200);
65 fRequest1c
= new TmfCoalescedDataRequest(TmfEvent
.class, 10, 100, 200);
67 fRequestCount
= fRequest1c
.getRequestId() + 1;
71 public void tearDown() throws Exception
{
75 private static TmfCoalescedDataRequest
setupTestRequest(final boolean[] flags
) {
77 TmfCoalescedDataRequest request
= new TmfCoalescedDataRequest(TmfEvent
.class, 10, 100, 200) {
79 public void handleCompleted() {
80 super.handleCompleted();
84 public void handleSuccess() {
85 super.handleSuccess();
89 public void handleFailure() {
90 super.handleFailure();
94 public void handleCancel() {
102 // ------------------------------------------------------------------------
104 // ------------------------------------------------------------------------
106 public void testTmfCoalescedDataRequest() {
107 TmfCoalescedDataRequest request
= new TmfCoalescedDataRequest(TmfEvent
.class);
109 assertEquals("getRequestId", fRequestCount
++, request
.getRequestId());
110 assertEquals("getDataType", ITmfEvent
.class, request
.getDataType());
112 assertEquals("getIndex", 0, request
.getIndex());
113 assertEquals("getNbRequestedEvents", TmfDataRequest
.ALL_DATA
, request
.getNbRequested());
115 assertFalse("isCompleted", request
.isCompleted());
116 assertFalse("isFailed", request
.isFailed());
117 assertFalse("isCancelled", request
.isCancelled());
119 assertEquals("getNbRead", 0, request
.getNbRead());
122 public void testTmfCoalescedDataRequestIndex() {
123 TmfCoalescedDataRequest request
= new TmfCoalescedDataRequest(TmfEvent
.class, 10);
125 assertEquals("getRequestId", fRequestCount
++, request
.getRequestId());
126 assertEquals("getDataType", ITmfEvent
.class, request
.getDataType());
128 assertEquals("getIndex", 10, request
.getIndex());
129 assertEquals("getNbRequestedEvents", TmfDataRequest
.ALL_DATA
, request
.getNbRequested());
131 assertFalse("isCompleted", request
.isCompleted());
132 assertFalse("isFailed", request
.isFailed());
133 assertFalse("isCancelled", request
.isCancelled());
135 assertEquals("getNbRead", 0, request
.getNbRead());
138 public void testTmfCoalescedDataRequestIndexNbRequested() {
139 TmfCoalescedDataRequest request
= new TmfCoalescedDataRequest(TmfEvent
.class, 10, 100);
141 assertEquals("getRequestId", fRequestCount
++, request
.getRequestId());
142 assertEquals("getDataType", ITmfEvent
.class, request
.getDataType());
144 assertEquals("getIndex", 10, request
.getIndex());
145 assertEquals("getNbRequestedEvents", 100, request
.getNbRequested());
147 assertFalse("isCompleted", request
.isCompleted());
148 assertFalse("isFailed", request
.isFailed());
149 assertFalse("isCancelled", request
.isCancelled());
151 assertEquals("getNbRead", 0, request
.getNbRead());
154 public void testTmfCoalescedDataRequestIndexNbEventsBlocksize() {
155 TmfCoalescedDataRequest request
= new TmfCoalescedDataRequest(TmfEvent
.class, 10, 100, 200);
157 assertEquals("getRequestId", fRequestCount
++, request
.getRequestId());
158 assertEquals("getDataType", ITmfEvent
.class, request
.getDataType());
160 assertEquals("getIndex", 10, request
.getIndex());
161 assertEquals("getNbRequestedEvents", 100, request
.getNbRequested());
163 assertFalse("isCompleted", request
.isCompleted());
164 assertFalse("isFailed", request
.isFailed());
165 assertFalse("isCancelled", request
.isCancelled());
167 assertEquals("getNbRead", 0, request
.getNbRead());
170 // ------------------------------------------------------------------------
172 // ------------------------------------------------------------------------
174 public void testEqualsReflexivity() {
175 assertTrue("equals", fRequest1
.equals(fRequest1
));
176 assertTrue("equals", fRequest2
.equals(fRequest2
));
178 assertFalse("equals", fRequest1
.equals(fRequest2
));
179 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
));
192 public void testEqualsTransivity() {
193 assertTrue("equals", fRequest1
.equals(fRequest1b
));
194 assertTrue("equals", fRequest1b
.equals(fRequest1c
));
195 assertTrue("equals", fRequest1
.equals(fRequest1c
));
198 public void testEqualsNull() {
199 assertFalse("equals", fRequest1
.equals(null));
200 assertFalse("equals", fRequest2
.equals(null));
203 // ------------------------------------------------------------------------
205 // ------------------------------------------------------------------------
207 public void testHashCode() {
208 assertTrue("hashCode", fRequest1
.hashCode() == fRequest1
.hashCode());
209 assertTrue("hashCode", fRequest2
.hashCode() == fRequest2
.hashCode());
210 assertTrue("hashCode", fRequest1
.hashCode() != fRequest2
.hashCode());
213 // ------------------------------------------------------------------------
215 // ------------------------------------------------------------------------
217 public void testToString() {
218 String expected1
= "[TmfCoalescedDataRequest(0,ITmfEvent,10,100,200)]";
219 String expected2
= "[TmfCoalescedDataRequest(1,ITmfEvent,20,100,200)]";
220 String expected3
= "[TmfCoalescedDataRequest(2,ITmfEvent,20,200,200)]";
221 String expected4
= "[TmfCoalescedDataRequest(3,ITmfEvent,20,200,300)]";
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 // ------------------------------------------------------------------------
233 public void testIsCompatible() {
234 TmfCoalescedDataRequest coalescedRequest
= new TmfCoalescedDataRequest(TmfEvent
.class, 10, 100, 200);
235 TmfDataRequest request1
= new TmfDataRequestStub(TmfEvent
.class, 10, 100, 200);
236 TmfDataRequest request2
= new TmfDataRequestStub(TmfEvent
.class, 5, 100, 200);
237 TmfDataRequest request3
= new TmfDataRequestStub(TmfEvent
.class, 5, 4, 200);
238 TmfDataRequest request4
= new TmfDataRequestStub(TmfEvent
.class, 5, 5, 200);
239 TmfDataRequest request5
= new TmfDataRequestStub(TmfEvent
.class, 15, 100, 200);
240 TmfDataRequest request6
= new TmfDataRequestStub(TmfEvent
.class, 100, 100, 200);
241 TmfDataRequest request7
= new TmfDataRequestStub(TmfEvent
.class, 110, 100, 200);
242 TmfDataRequest request8
= new TmfDataRequestStub(TmfEvent
.class, 111, 100, 200);
244 assertTrue("isCompatible", coalescedRequest
.isCompatible(request1
));
245 assertTrue("isCompatible", coalescedRequest
.isCompatible(request2
));
246 assertTrue("isCompatible", coalescedRequest
.isCompatible(request3
));
247 assertTrue("isCompatible", coalescedRequest
.isCompatible(request4
));
248 assertTrue("isCompatible", coalescedRequest
.isCompatible(request5
));
249 assertTrue("isCompatible", coalescedRequest
.isCompatible(request6
));
250 assertTrue("isCompatible", coalescedRequest
.isCompatible(request7
));
251 assertTrue("isCompatible", coalescedRequest
.isCompatible(request8
));
253 TmfDataRequest request9
= new TmfDataRequestStub(TmfEvent
.class, 5, 3, 200);
254 TmfDataRequest request10
= new TmfDataRequestStub(TmfEvent
.class, 112, 100, 200);
256 assertFalse("isCompatible", coalescedRequest
.isCompatible(request9
));
257 assertFalse("isCompatible", coalescedRequest
.isCompatible(request10
));
260 // ------------------------------------------------------------------------
262 // ------------------------------------------------------------------------
264 public void testAddRequest1() {
265 TmfCoalescedDataRequest coalescedRequest
= new TmfCoalescedDataRequest(TmfEvent
.class, 10, 100, 200);
266 TmfDataRequest request
= new TmfDataRequestStub(TmfEvent
.class, 10, 100, 200);
268 assertTrue("isCompatible", coalescedRequest
.isCompatible(request
));
269 coalescedRequest
.addRequest(request
);
270 assertEquals("addRequest", 10, coalescedRequest
.getIndex());
271 assertEquals("addRequest", 100, coalescedRequest
.getNbRequested());
272 assertEquals("addRequest", 200, coalescedRequest
.getBlockSize());
275 public void testAddRequest2() {
276 TmfCoalescedDataRequest coalescedRequest
= new TmfCoalescedDataRequest(TmfEvent
.class, 10, 100, 200);
277 TmfDataRequest request
= new TmfDataRequestStub(TmfEvent
.class, 5, 100, 200);
279 assertTrue("isCompatible", coalescedRequest
.isCompatible(request
));
280 coalescedRequest
.addRequest(request
);
281 assertEquals("addRequest", 5, coalescedRequest
.getIndex());
282 assertEquals("addRequest", 105, coalescedRequest
.getNbRequested());
283 assertEquals("addRequest", 200, coalescedRequest
.getBlockSize());
286 public void testAddRequest3() {
287 TmfCoalescedDataRequest coalescedRequest
= new TmfCoalescedDataRequest(TmfEvent
.class, 10, 100, 200);
288 TmfDataRequest request
= new TmfDataRequestStub(TmfEvent
.class, 5, 4, 200);
290 assertTrue("isCompatible", coalescedRequest
.isCompatible(request
));
291 coalescedRequest
.addRequest(request
);
292 assertEquals("addRequest", 5, coalescedRequest
.getIndex());
293 assertEquals("addRequest", 105, coalescedRequest
.getNbRequested());
294 assertEquals("addRequest", 200, coalescedRequest
.getBlockSize());
297 public void testAddRequest4() {
298 TmfCoalescedDataRequest coalescedRequest
= new TmfCoalescedDataRequest(TmfEvent
.class, 10, 100, 200);
299 TmfDataRequest request
= new TmfDataRequestStub(TmfEvent
.class, 5, 5, 200);
301 assertTrue("isCompatible", coalescedRequest
.isCompatible(request
));
302 coalescedRequest
.addRequest(request
);
303 assertEquals("addRequest", 5, coalescedRequest
.getIndex());
304 assertEquals("addRequest", 105, coalescedRequest
.getNbRequested());
305 assertEquals("addRequest", 200, coalescedRequest
.getBlockSize());
308 public void testAddRequest5() {
309 TmfCoalescedDataRequest coalescedRequest
= new TmfCoalescedDataRequest(TmfEvent
.class, 10, 100, 200);
310 TmfDataRequest request
= new TmfDataRequestStub(TmfEvent
.class, 15, 100, 200);
312 assertTrue("isCompatible", coalescedRequest
.isCompatible(request
));
313 coalescedRequest
.addRequest(request
);
314 assertEquals("addRequest", 10, coalescedRequest
.getIndex());
315 assertEquals("addRequest", 105, coalescedRequest
.getNbRequested());
316 assertEquals("addRequest", 200, coalescedRequest
.getBlockSize());
319 public void testAddRequest6() {
320 TmfCoalescedDataRequest coalescedRequest
= new TmfCoalescedDataRequest(TmfEvent
.class, 10, 100, 200);
321 TmfDataRequest request
= new TmfDataRequestStub(TmfEvent
.class, 100, 100, 200);
323 assertTrue("isCompatible", coalescedRequest
.isCompatible(request
));
324 coalescedRequest
.addRequest(request
);
325 assertEquals("addRequest", 10, coalescedRequest
.getIndex());
326 assertEquals("addRequest", 190, coalescedRequest
.getNbRequested());
327 assertEquals("addRequest", 200, coalescedRequest
.getBlockSize());
330 public void testAddRequest7() {
331 TmfCoalescedDataRequest coalescedRequest
= new TmfCoalescedDataRequest(TmfEvent
.class, 10, 100, 200);
332 TmfDataRequest request
= new TmfDataRequestStub(TmfEvent
.class, 110, 100, 200);
334 assertTrue("isCompatible", coalescedRequest
.isCompatible(request
));
335 coalescedRequest
.addRequest(request
);
336 assertEquals("addRequest", 10, coalescedRequest
.getIndex());
337 assertEquals("addRequest", 200, coalescedRequest
.getNbRequested());
338 assertEquals("addRequest", 200, coalescedRequest
.getBlockSize());
341 public void testAddRequest8() {
342 TmfCoalescedDataRequest coalescedRequest
= new TmfCoalescedDataRequest(TmfEvent
.class, 10, 100, 200);
343 TmfDataRequest request
= new TmfDataRequestStub(TmfEvent
.class, 111, 100, 200);
345 assertTrue("isCompatible", coalescedRequest
.isCompatible(request
));
346 coalescedRequest
.addRequest(request
);
347 assertEquals("addRequest", 10, coalescedRequest
.getIndex());
348 assertEquals("addRequest", 201, coalescedRequest
.getNbRequested());
349 assertEquals("addRequest", 200, coalescedRequest
.getBlockSize());
352 // ------------------------------------------------------------------------
354 // ------------------------------------------------------------------------
356 public void testDone() {
359 final boolean[] crFlags
= new boolean[4];
360 TmfCoalescedDataRequest request
= setupTestRequest(crFlags
);
361 TmfDataRequest subRequest1
= new TmfDataRequestStub(TmfEvent
.class, 10, 100, 200);
362 TmfDataRequest subRequest2
= new TmfDataRequestStub(TmfEvent
.class, 10, 100, 200);
363 request
.addRequest(subRequest1
);
364 request
.addRequest(subRequest2
);
368 // Validate the coalescing request
369 assertTrue ("isCompleted", request
.isCompleted());
370 assertFalse("isFailed", request
.isFailed());
371 assertFalse("isCancelled", request
.isCancelled());
373 assertTrue ("handleCompleted", crFlags
[0]);
374 assertTrue ("handleSuccess", crFlags
[1]);
375 assertFalse("handleFailure", crFlags
[2]);
376 assertFalse("handleCancel", crFlags
[3]);
378 // Validate the first coalesced request
379 assertTrue ("isCompleted", subRequest1
.isCompleted());
380 assertFalse("isFailed", subRequest1
.isFailed());
381 assertFalse("isCancelled", subRequest1
.isCancelled());
383 // Validate the second coalesced request
384 assertTrue ("isCompleted", subRequest2
.isCompleted());
385 assertFalse("isFailed", subRequest2
.isFailed());
386 assertFalse("isCancelled", subRequest2
.isCancelled());
389 // ------------------------------------------------------------------------
391 // ------------------------------------------------------------------------
393 public void testFail() {
395 final boolean[] crFlags
= new boolean[4];
396 TmfCoalescedDataRequest request
= setupTestRequest(crFlags
);
397 TmfDataRequest subRequest1
= new TmfDataRequestStub(TmfEvent
.class, 10, 100, 200);
398 TmfDataRequest subRequest2
= new TmfDataRequestStub(TmfEvent
.class, 10, 100, 200);
399 request
.addRequest(subRequest1
);
400 request
.addRequest(subRequest2
);
404 // Validate the coalescing request
405 assertTrue ("isCompleted", request
.isCompleted());
406 assertTrue ("isFailed", request
.isFailed());
407 assertFalse("isCancelled", request
.isCancelled());
409 assertTrue ("handleCompleted", crFlags
[0]);
410 assertFalse("handleSuccess", crFlags
[1]);
411 assertTrue ("handleFailure", crFlags
[2]);
412 assertFalse("handleCancel", crFlags
[3]);
414 // Validate the first coalesced request
415 assertTrue ("isCompleted", subRequest1
.isCompleted());
416 assertTrue ("isFailed", subRequest1
.isFailed());
417 assertFalse("isCancelled", subRequest1
.isCancelled());
419 // Validate the second coalesced request
420 assertTrue ("isCompleted", subRequest2
.isCompleted());
421 assertTrue ("isFailed", subRequest2
.isFailed());
422 assertFalse("isCancelled", subRequest2
.isCancelled());
425 // ------------------------------------------------------------------------
427 // ------------------------------------------------------------------------
429 public void testCancel() {
431 final boolean[] crFlags
= new boolean[4];
432 TmfCoalescedDataRequest request
= setupTestRequest(crFlags
);
433 TmfDataRequest subRequest1
= new TmfDataRequestStub(TmfEvent
.class, 10, 100, 200);
434 TmfDataRequest subRequest2
= new TmfDataRequestStub(TmfEvent
.class, 10, 100, 200);
435 request
.addRequest(subRequest1
);
436 request
.addRequest(subRequest2
);
440 // Validate the coalescing request
441 assertTrue ("isCompleted", request
.isCompleted());
442 assertFalse("isFailed", request
.isFailed());
443 assertTrue ("isCancelled", request
.isCancelled());
445 assertTrue ("handleCompleted", crFlags
[0]);
446 assertFalse("handleSuccess", crFlags
[1]);
447 assertFalse("handleFailure", crFlags
[2]);
448 assertTrue ("handleCancel", crFlags
[3]);
450 // Validate the first coalesced request
451 assertTrue ("isCompleted", subRequest1
.isCompleted());
452 assertFalse("isFailed", subRequest1
.isFailed());
453 assertTrue ("isCancelled", subRequest1
.isCancelled());
455 // Validate the second coalesced request
456 assertTrue ("isCompleted", subRequest2
.isCompleted());
457 assertFalse("isFailed", subRequest2
.isFailed());
458 assertTrue ("isCancelled", subRequest2
.isCancelled());
462 // ------------------------------------------------------------------------
463 // cancel sub-requests
464 // ------------------------------------------------------------------------
466 public void testCancelSubRequests() {
468 final boolean[] crFlags
= new boolean[4];
469 TmfCoalescedDataRequest request
= setupTestRequest(crFlags
);
470 TmfDataRequest subRequest1
= new TmfDataRequestStub(TmfEvent
.class, 10, 100, 200);
471 TmfDataRequest subRequest2
= new TmfDataRequestStub(TmfEvent
.class, 10, 100, 200);
472 request
.addRequest(subRequest1
);
473 request
.addRequest(subRequest2
);
475 subRequest1
.cancel();
477 // Validate the first coalesced request
478 assertTrue ("isCompleted", subRequest1
.isCompleted());
479 assertFalse("isFailed", subRequest1
.isFailed());
480 assertTrue ("isCancelled", subRequest1
.isCancelled());
482 // Validate the coalescing request
483 assertFalse("isCompleted", request
.isCompleted());
484 assertFalse("isFailed", request
.isFailed());
485 assertFalse("isCancelled", request
.isCancelled());
487 // Cancel second sub-request
488 subRequest2
.cancel();
490 // Validate the second coalesced request
491 assertTrue ("isCompleted", subRequest2
.isCompleted());
492 assertFalse("isFailed", subRequest2
.isFailed());
493 assertTrue ("isCancelled", subRequest2
.isCancelled());
495 // Validate the coalescing request
496 assertTrue ("isCompleted", request
.isCompleted());
497 assertFalse("isFailed", request
.isFailed());
498 assertTrue ("isCancelled", request
.isCancelled());
500 // Finalize coalescing request -
501 // Note: No need to check "request.isCancelled()" since it was verified above
504 assertTrue ("handleCompleted", crFlags
[0]);
505 assertFalse("handleSuccess", crFlags
[1]);
506 assertFalse("handleFailure", crFlags
[2]);
507 assertTrue ("handleCancel", crFlags
[3]);