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
.tests
.request
;
16 import junit
.framework
.TestCase
;
18 import org
.eclipse
.linuxtools
.tmf
.event
.TmfEvent
;
19 import org
.eclipse
.linuxtools
.tmf
.request
.TmfCoalescedDataRequest
;
20 import org
.eclipse
.linuxtools
.tmf
.request
.TmfDataRequest
;
21 import org
.eclipse
.linuxtools
.tmf
.request
.TmfDataRequestStub
;
24 * <b><u>TmfCoalescedDataRequestTest</u></b>
26 * Test suite for the TmfCoalescedDataRequest class.
28 public class TmfCoalescedDataRequestTest
extends TestCase
{
30 // ------------------------------------------------------------------------
32 // ------------------------------------------------------------------------
34 private static TmfCoalescedDataRequest
<TmfEvent
> fRequest1
;
35 private static TmfCoalescedDataRequest
<TmfEvent
> fRequest2
;
36 private static TmfCoalescedDataRequest
<TmfEvent
> fRequest3
;
37 private static TmfCoalescedDataRequest
<TmfEvent
> fRequest4
;
39 private static TmfCoalescedDataRequest
<TmfEvent
> fRequest1b
;
40 private static TmfCoalescedDataRequest
<TmfEvent
> fRequest1c
;
42 private static int fRequestCount
;
44 // ------------------------------------------------------------------------
46 // ------------------------------------------------------------------------
48 public TmfCoalescedDataRequestTest(String name
) {
53 public void setUp() throws Exception
{
55 TmfDataRequest
.reset();
56 fRequest1
= new TmfCoalescedDataRequest
<TmfEvent
>(TmfEvent
.class, 10, 100, 200);
57 fRequest2
= new TmfCoalescedDataRequest
<TmfEvent
>(TmfEvent
.class, 20, 100, 200);
58 fRequest3
= new TmfCoalescedDataRequest
<TmfEvent
>(TmfEvent
.class, 20, 200, 200);
59 fRequest4
= new TmfCoalescedDataRequest
<TmfEvent
>(TmfEvent
.class, 20, 200, 300);
61 fRequest1b
= new TmfCoalescedDataRequest
<TmfEvent
>(TmfEvent
.class, 10, 100, 200);
62 fRequest1c
= new TmfCoalescedDataRequest
<TmfEvent
>(TmfEvent
.class, 10, 100, 200);
64 fRequestCount
= fRequest1c
.getRequestId() + 1;
68 public void tearDown() throws Exception
{
72 private TmfCoalescedDataRequest
<TmfEvent
> setupTestRequest(final boolean[] flags
) {
74 TmfCoalescedDataRequest
<TmfEvent
> request
= new TmfCoalescedDataRequest
<TmfEvent
>(TmfEvent
.class, 10, 100, 200) {
76 public void handleCompleted() {
77 super.handleCompleted();
81 public void handleSuccess() {
82 super.handleSuccess();
86 public void handleFailure() {
87 super.handleFailure();
91 public void handleCancel() {
99 // ------------------------------------------------------------------------
101 // ------------------------------------------------------------------------
103 public void testTmfCoalescedDataRequest() {
104 TmfCoalescedDataRequest
<TmfEvent
> request
= new TmfCoalescedDataRequest
<TmfEvent
>(TmfEvent
.class);
106 assertEquals("getRequestId", fRequestCount
++, request
.getRequestId());
107 assertEquals("getDataType", TmfEvent
.class, request
.getDataType());
109 assertEquals("getIndex", 0, request
.getIndex());
110 assertEquals("getNbRequestedEvents", TmfDataRequest
.ALL_DATA
, request
.getNbRequested());
112 assertFalse("isCompleted", request
.isCompleted());
113 assertFalse("isFailed", request
.isFailed());
114 assertFalse("isCancelled", request
.isCancelled());
116 assertEquals("getNbRead", 0, request
.getNbRead());
119 public void testTmfCoalescedDataRequestIndex() {
120 TmfCoalescedDataRequest
<TmfEvent
> request
= new TmfCoalescedDataRequest
<TmfEvent
>(TmfEvent
.class, 10);
122 assertEquals("getRequestId", fRequestCount
++, request
.getRequestId());
123 assertEquals("getDataType", TmfEvent
.class, request
.getDataType());
125 assertEquals("getIndex", 10, request
.getIndex());
126 assertEquals("getNbRequestedEvents", TmfDataRequest
.ALL_DATA
, request
.getNbRequested());
128 assertFalse("isCompleted", request
.isCompleted());
129 assertFalse("isFailed", request
.isFailed());
130 assertFalse("isCancelled", request
.isCancelled());
132 assertEquals("getNbRead", 0, request
.getNbRead());
135 public void testTmfCoalescedDataRequestIndexNbRequested() {
136 TmfCoalescedDataRequest
<TmfEvent
> request
= new TmfCoalescedDataRequest
<TmfEvent
>(TmfEvent
.class, 10, 100);
138 assertEquals("getRequestId", fRequestCount
++, request
.getRequestId());
139 assertEquals("getDataType", TmfEvent
.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());
151 public void testTmfCoalescedDataRequestIndexNbEventsBlocksize() {
152 TmfCoalescedDataRequest
<TmfEvent
> request
= new TmfCoalescedDataRequest
<TmfEvent
>(TmfEvent
.class, 10, 100, 200);
154 assertEquals("getRequestId", fRequestCount
++, request
.getRequestId());
155 assertEquals("getDataType", TmfEvent
.class, request
.getDataType());
157 assertEquals("getIndex", 10, request
.getIndex());
158 assertEquals("getNbRequestedEvents", 100, request
.getNbRequested());
160 assertFalse("isCompleted", request
.isCompleted());
161 assertFalse("isFailed", request
.isFailed());
162 assertFalse("isCancelled", request
.isCancelled());
164 assertEquals("getNbRead", 0, request
.getNbRead());
167 // ------------------------------------------------------------------------
169 // ------------------------------------------------------------------------
171 public void testEqualsReflexivity() throws Exception
{
172 assertTrue("equals", fRequest1
.equals(fRequest1
));
173 assertTrue("equals", fRequest2
.equals(fRequest2
));
175 assertFalse("equals", fRequest1
.equals(fRequest2
));
176 assertFalse("equals", fRequest2
.equals(fRequest1
));
179 public void testEqualsSymmetry() throws Exception
{
180 assertTrue("equals", fRequest1
.equals(fRequest1b
));
181 assertTrue("equals", fRequest1b
.equals(fRequest1
));
183 assertFalse("equals", fRequest1
.equals(fRequest3
));
184 assertFalse("equals", fRequest2
.equals(fRequest3
));
185 assertFalse("equals", fRequest3
.equals(fRequest1
));
186 assertFalse("equals", fRequest3
.equals(fRequest2
));
189 public void testEqualsTransivity() throws Exception
{
190 assertTrue("equals", fRequest1
.equals(fRequest1b
));
191 assertTrue("equals", fRequest1b
.equals(fRequest1c
));
192 assertTrue("equals", fRequest1
.equals(fRequest1c
));
195 public void testEqualsNull() throws Exception
{
196 assertFalse("equals", fRequest1
.equals(null));
197 assertFalse("equals", fRequest2
.equals(null));
200 // ------------------------------------------------------------------------
202 // ------------------------------------------------------------------------
204 public void testHashCode() throws Exception
{
205 assertTrue("hashCode", fRequest1
.hashCode() == fRequest1
.hashCode());
206 assertTrue("hashCode", fRequest2
.hashCode() == fRequest2
.hashCode());
207 assertTrue("hashCode", fRequest1
.hashCode() != fRequest2
.hashCode());
210 // ------------------------------------------------------------------------
212 // ------------------------------------------------------------------------
214 public void testToString() {
215 String expected1
= "[TmfCoalescedDataRequest(0,TmfEvent,10,100)]";
216 String expected2
= "[TmfCoalescedDataRequest(1,TmfEvent,20,100)]";
217 String expected3
= "[TmfCoalescedDataRequest(2,TmfEvent,20,200)]";
218 String expected4
= "[TmfCoalescedDataRequest(3,TmfEvent,20,200)]";
220 assertEquals("toString", expected1
, fRequest1
.toString());
221 assertEquals("toString", expected2
, fRequest2
.toString());
222 assertEquals("toString", expected3
, fRequest3
.toString());
223 assertEquals("toString", expected4
, fRequest4
.toString());
226 // ------------------------------------------------------------------------
228 // ------------------------------------------------------------------------
230 public void testIsCompatible() {
231 TmfCoalescedDataRequest
<TmfEvent
> coalescedRequest
= new TmfCoalescedDataRequest
<TmfEvent
>(TmfEvent
.class, 10, 100, 200);
232 TmfDataRequest
<TmfEvent
> request1
= new TmfDataRequestStub
<TmfEvent
>(TmfEvent
.class, 10, 100, 200);
233 TmfDataRequest
<TmfEvent
> request2
= new TmfDataRequestStub
<TmfEvent
>(TmfEvent
.class, 11, 100, 200);
234 TmfDataRequest
<TmfEvent
> request3
= new TmfDataRequestStub
<TmfEvent
>(TmfEvent
.class, 10, 101, 200);
236 assertTrue ("isCompatible", coalescedRequest
.isCompatible(request1
));
237 assertFalse("isCompatible", coalescedRequest
.isCompatible(request2
));
238 assertFalse("isCompatible", coalescedRequest
.isCompatible(request3
));
241 // ------------------------------------------------------------------------
243 // ------------------------------------------------------------------------
245 public void testDone() {
248 final boolean[] crFlags
= new boolean[4];
249 TmfCoalescedDataRequest
<TmfEvent
> request
= setupTestRequest(crFlags
);
250 TmfDataRequest
<TmfEvent
> subRequest1
= new TmfDataRequestStub
<TmfEvent
>(TmfEvent
.class, 10, 100, 200);
251 TmfDataRequest
<TmfEvent
> subRequest2
= new TmfDataRequestStub
<TmfEvent
>(TmfEvent
.class, 10, 100, 200);
252 request
.addRequest(subRequest1
);
253 request
.addRequest(subRequest2
);
257 // Validate the coalescing request
258 assertTrue ("isCompleted", request
.isCompleted());
259 assertFalse("isFailed", request
.isFailed());
260 assertFalse("isCancelled", request
.isCancelled());
262 assertTrue ("handleCompleted", crFlags
[0]);
263 assertTrue ("handleSuccess", crFlags
[1]);
264 assertFalse("handleFailure", crFlags
[2]);
265 assertFalse("handleCancel", crFlags
[3]);
267 // Validate the first coalesced request
268 assertTrue ("isCompleted", subRequest1
.isCompleted());
269 assertFalse("isFailed", subRequest1
.isFailed());
270 assertFalse("isCancelled", subRequest1
.isCancelled());
272 // Validate the second coalesced request
273 assertTrue ("isCompleted", subRequest2
.isCompleted());
274 assertFalse("isFailed", subRequest2
.isFailed());
275 assertFalse("isCancelled", subRequest2
.isCancelled());
278 // ------------------------------------------------------------------------
280 // ------------------------------------------------------------------------
282 public void testFail() {
284 final boolean[] crFlags
= new boolean[4];
285 TmfCoalescedDataRequest
<TmfEvent
> request
= setupTestRequest(crFlags
);
286 TmfDataRequest
<TmfEvent
> subRequest1
= new TmfDataRequestStub
<TmfEvent
>(TmfEvent
.class, 10, 100, 200);
287 TmfDataRequest
<TmfEvent
> subRequest2
= new TmfDataRequestStub
<TmfEvent
>(TmfEvent
.class, 10, 100, 200);
288 request
.addRequest(subRequest1
);
289 request
.addRequest(subRequest2
);
293 // Validate the coalescing request
294 assertTrue ("isCompleted", request
.isCompleted());
295 assertTrue ("isFailed", request
.isFailed());
296 assertFalse("isCancelled", request
.isCancelled());
298 assertTrue ("handleCompleted", crFlags
[0]);
299 assertFalse("handleSuccess", crFlags
[1]);
300 assertTrue ("handleFailure", crFlags
[2]);
301 assertFalse("handleCancel", crFlags
[3]);
303 // Validate the first coalesced request
304 assertTrue ("isCompleted", subRequest1
.isCompleted());
305 assertTrue ("isFailed", subRequest1
.isFailed());
306 assertFalse("isCancelled", subRequest1
.isCancelled());
308 // Validate the second coalesced request
309 assertTrue ("isCompleted", subRequest2
.isCompleted());
310 assertTrue ("isFailed", subRequest2
.isFailed());
311 assertFalse("isCancelled", subRequest2
.isCancelled());
314 // ------------------------------------------------------------------------
316 // ------------------------------------------------------------------------
318 public void testCancel() {
320 final boolean[] crFlags
= new boolean[4];
321 TmfCoalescedDataRequest
<TmfEvent
> request
= setupTestRequest(crFlags
);
322 TmfDataRequest
<TmfEvent
> subRequest1
= new TmfDataRequestStub
<TmfEvent
>(TmfEvent
.class, 10, 100, 200);
323 TmfDataRequest
<TmfEvent
> subRequest2
= new TmfDataRequestStub
<TmfEvent
>(TmfEvent
.class, 10, 100, 200);
324 request
.addRequest(subRequest1
);
325 request
.addRequest(subRequest2
);
329 // Validate the coalescing request
330 assertTrue ("isCompleted", request
.isCompleted());
331 assertFalse("isFailed", request
.isFailed());
332 assertTrue ("isCancelled", request
.isCancelled());
334 assertTrue ("handleCompleted", crFlags
[0]);
335 assertFalse("handleSuccess", crFlags
[1]);
336 assertFalse("handleFailure", crFlags
[2]);
337 assertTrue ("handleCancel", crFlags
[3]);
339 // Validate the first coalesced request
340 assertTrue ("isCompleted", subRequest1
.isCompleted());
341 assertFalse("isFailed", subRequest1
.isFailed());
342 assertTrue ("isCancelled", subRequest1
.isCancelled());
344 // Validate the second coalesced request
345 assertTrue ("isCompleted", subRequest2
.isCompleted());
346 assertFalse("isFailed", subRequest2
.isFailed());
347 assertTrue ("isCancelled", subRequest2
.isCancelled());
351 // ------------------------------------------------------------------------
352 // cancel sub-requests
353 // ------------------------------------------------------------------------
355 public void testCancelSubRequests() {
357 final boolean[] crFlags
= new boolean[4];
358 TmfCoalescedDataRequest
<TmfEvent
> request
= setupTestRequest(crFlags
);
359 TmfDataRequest
<TmfEvent
> subRequest1
= new TmfDataRequestStub
<TmfEvent
>(TmfEvent
.class, 10, 100, 200);
360 TmfDataRequest
<TmfEvent
> subRequest2
= new TmfDataRequestStub
<TmfEvent
>(TmfEvent
.class, 10, 100, 200);
361 request
.addRequest(subRequest1
);
362 request
.addRequest(subRequest2
);
364 subRequest1
.cancel();
366 // Validate the first coalesced request
367 assertTrue ("isCompleted", subRequest1
.isCompleted());
368 assertFalse("isFailed", subRequest1
.isFailed());
369 assertTrue ("isCancelled", subRequest1
.isCancelled());
371 // Validate the coalescing request
372 assertFalse("isCompleted", request
.isCompleted());
373 assertFalse("isFailed", request
.isFailed());
374 assertFalse("isCancelled", request
.isCancelled());
376 // Cancel second sub-request
377 subRequest2
.cancel();
379 // Validate the second coalesced request
380 assertTrue ("isCompleted", subRequest2
.isCompleted());
381 assertFalse("isFailed", subRequest2
.isFailed());
382 assertTrue ("isCancelled", subRequest2
.isCancelled());
384 // Validate the coalescing request
385 assertTrue ("isCompleted", request
.isCompleted());
386 assertFalse("isFailed", request
.isFailed());
387 assertTrue ("isCancelled", request
.isCancelled());
389 // Finalize coalescing request -
390 // Note: No need to check "request.isCancelled()" since it was verified above
393 assertTrue ("handleCompleted", crFlags
[0]);
394 assertFalse("handleSuccess", crFlags
[1]);
395 assertFalse("handleFailure", crFlags
[2]);
396 assertTrue ("handleCancel", crFlags
[3]);
399 // ------------------------------------------------------------------------
401 // ------------------------------------------------------------------------