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 junit
.framework
.TestCase
;
18 import org
.eclipse
.linuxtools
.tmf
.core
.event
.TmfEvent
;
19 import org
.eclipse
.linuxtools
.tmf
.core
.request
.TmfCoalescedDataRequest
;
20 import org
.eclipse
.linuxtools
.tmf
.core
.request
.TmfDataRequest
;
21 import org
.eclipse
.linuxtools
.tmf
.stubs
.request
.TmfDataRequestStub
;
24 * <b><u>TmfCoalescedDataRequestTest</u></b>
26 * Test suite for the TmfCoalescedDataRequest class.
28 @SuppressWarnings("nls")
29 public class TmfCoalescedDataRequestTest
extends TestCase
{
31 // ------------------------------------------------------------------------
33 // ------------------------------------------------------------------------
35 private static TmfCoalescedDataRequest
<TmfEvent
> fRequest1
;
36 private static TmfCoalescedDataRequest
<TmfEvent
> fRequest2
;
37 private static TmfCoalescedDataRequest
<TmfEvent
> fRequest3
;
38 private static TmfCoalescedDataRequest
<TmfEvent
> fRequest4
;
40 private static TmfCoalescedDataRequest
<TmfEvent
> fRequest1b
;
41 private static TmfCoalescedDataRequest
<TmfEvent
> fRequest1c
;
43 private static int fRequestCount
;
45 // ------------------------------------------------------------------------
47 // ------------------------------------------------------------------------
49 public TmfCoalescedDataRequestTest(String name
) {
54 public void setUp() throws Exception
{
56 TmfDataRequest
.reset();
57 fRequest1
= new TmfCoalescedDataRequest
<TmfEvent
>(TmfEvent
.class, 10, 100, 200);
58 fRequest2
= new TmfCoalescedDataRequest
<TmfEvent
>(TmfEvent
.class, 20, 100, 200);
59 fRequest3
= new TmfCoalescedDataRequest
<TmfEvent
>(TmfEvent
.class, 20, 200, 200);
60 fRequest4
= new TmfCoalescedDataRequest
<TmfEvent
>(TmfEvent
.class, 20, 200, 300);
62 fRequest1b
= new TmfCoalescedDataRequest
<TmfEvent
>(TmfEvent
.class, 10, 100, 200);
63 fRequest1c
= new TmfCoalescedDataRequest
<TmfEvent
>(TmfEvent
.class, 10, 100, 200);
65 fRequestCount
= fRequest1c
.getRequestId() + 1;
69 public void tearDown() throws Exception
{
73 private TmfCoalescedDataRequest
<TmfEvent
> setupTestRequest(final boolean[] flags
) {
75 TmfCoalescedDataRequest
<TmfEvent
> request
= new TmfCoalescedDataRequest
<TmfEvent
>(TmfEvent
.class, 10, 100, 200) {
77 public void handleCompleted() {
78 super.handleCompleted();
82 public void handleSuccess() {
83 super.handleSuccess();
87 public void handleFailure() {
88 super.handleFailure();
92 public void handleCancel() {
100 // ------------------------------------------------------------------------
102 // ------------------------------------------------------------------------
104 public void testTmfCoalescedDataRequest() {
105 TmfCoalescedDataRequest
<TmfEvent
> request
= new TmfCoalescedDataRequest
<TmfEvent
>(TmfEvent
.class);
107 assertEquals("getRequestId", fRequestCount
++, request
.getRequestId());
108 assertEquals("getDataType", TmfEvent
.class, request
.getDataType());
110 assertEquals("getIndex", 0, request
.getIndex());
111 assertEquals("getNbRequestedEvents", TmfDataRequest
.ALL_DATA
, request
.getNbRequested());
113 assertFalse("isCompleted", request
.isCompleted());
114 assertFalse("isFailed", request
.isFailed());
115 assertFalse("isCancelled", request
.isCancelled());
117 assertEquals("getNbRead", 0, request
.getNbRead());
120 public void testTmfCoalescedDataRequestIndex() {
121 TmfCoalescedDataRequest
<TmfEvent
> request
= new TmfCoalescedDataRequest
<TmfEvent
>(TmfEvent
.class, 10);
123 assertEquals("getRequestId", fRequestCount
++, request
.getRequestId());
124 assertEquals("getDataType", TmfEvent
.class, request
.getDataType());
126 assertEquals("getIndex", 10, request
.getIndex());
127 assertEquals("getNbRequestedEvents", TmfDataRequest
.ALL_DATA
, request
.getNbRequested());
129 assertFalse("isCompleted", request
.isCompleted());
130 assertFalse("isFailed", request
.isFailed());
131 assertFalse("isCancelled", request
.isCancelled());
133 assertEquals("getNbRead", 0, request
.getNbRead());
136 public void testTmfCoalescedDataRequestIndexNbRequested() {
137 TmfCoalescedDataRequest
<TmfEvent
> request
= new TmfCoalescedDataRequest
<TmfEvent
>(TmfEvent
.class, 10, 100);
139 assertEquals("getRequestId", fRequestCount
++, request
.getRequestId());
140 assertEquals("getDataType", TmfEvent
.class, request
.getDataType());
142 assertEquals("getIndex", 10, request
.getIndex());
143 assertEquals("getNbRequestedEvents", 100, request
.getNbRequested());
145 assertFalse("isCompleted", request
.isCompleted());
146 assertFalse("isFailed", request
.isFailed());
147 assertFalse("isCancelled", request
.isCancelled());
149 assertEquals("getNbRead", 0, request
.getNbRead());
152 public void testTmfCoalescedDataRequestIndexNbEventsBlocksize() {
153 TmfCoalescedDataRequest
<TmfEvent
> request
= new TmfCoalescedDataRequest
<TmfEvent
>(TmfEvent
.class, 10, 100, 200);
155 assertEquals("getRequestId", fRequestCount
++, request
.getRequestId());
156 assertEquals("getDataType", TmfEvent
.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 // ------------------------------------------------------------------------
172 public void testEqualsReflexivity() throws Exception
{
173 assertTrue("equals", fRequest1
.equals(fRequest1
));
174 assertTrue("equals", fRequest2
.equals(fRequest2
));
176 assertFalse("equals", fRequest1
.equals(fRequest2
));
177 assertFalse("equals", fRequest2
.equals(fRequest1
));
180 public void testEqualsSymmetry() throws Exception
{
181 assertTrue("equals", fRequest1
.equals(fRequest1b
));
182 assertTrue("equals", fRequest1b
.equals(fRequest1
));
184 assertFalse("equals", fRequest1
.equals(fRequest3
));
185 assertFalse("equals", fRequest2
.equals(fRequest3
));
186 assertFalse("equals", fRequest3
.equals(fRequest1
));
187 assertFalse("equals", fRequest3
.equals(fRequest2
));
190 public void testEqualsTransivity() throws Exception
{
191 assertTrue("equals", fRequest1
.equals(fRequest1b
));
192 assertTrue("equals", fRequest1b
.equals(fRequest1c
));
193 assertTrue("equals", fRequest1
.equals(fRequest1c
));
196 public void testEqualsNull() throws Exception
{
197 assertFalse("equals", fRequest1
.equals(null));
198 assertFalse("equals", fRequest2
.equals(null));
201 // ------------------------------------------------------------------------
203 // ------------------------------------------------------------------------
205 public void testHashCode() throws Exception
{
206 assertTrue("hashCode", fRequest1
.hashCode() == fRequest1
.hashCode());
207 assertTrue("hashCode", fRequest2
.hashCode() == fRequest2
.hashCode());
208 assertTrue("hashCode", fRequest1
.hashCode() != fRequest2
.hashCode());
211 // ------------------------------------------------------------------------
213 // ------------------------------------------------------------------------
215 public void testToString() {
216 String expected1
= "[TmfCoalescedDataRequest(0,TmfEvent,10,100,200)]";
217 String expected2
= "[TmfCoalescedDataRequest(1,TmfEvent,20,100,200)]";
218 String expected3
= "[TmfCoalescedDataRequest(2,TmfEvent,20,200,200)]";
219 String expected4
= "[TmfCoalescedDataRequest(3,TmfEvent,20,200,300)]";
221 assertEquals("toString", expected1
, fRequest1
.toString());
222 assertEquals("toString", expected2
, fRequest2
.toString());
223 assertEquals("toString", expected3
, fRequest3
.toString());
224 assertEquals("toString", expected4
, fRequest4
.toString());
227 // ------------------------------------------------------------------------
229 // ------------------------------------------------------------------------
231 public void testIsCompatible() {
232 TmfCoalescedDataRequest
<TmfEvent
> coalescedRequest
= new TmfCoalescedDataRequest
<TmfEvent
>(TmfEvent
.class, 10, 100, 200);
233 TmfDataRequest
<TmfEvent
> request1
= new TmfDataRequestStub
<TmfEvent
>(TmfEvent
.class, 10, 100, 200);
234 TmfDataRequest
<TmfEvent
> request2
= new TmfDataRequestStub
<TmfEvent
>(TmfEvent
.class, 11, 100, 200);
235 TmfDataRequest
<TmfEvent
> request3
= new TmfDataRequestStub
<TmfEvent
>(TmfEvent
.class, 10, 101, 200);
237 assertTrue ("isCompatible", coalescedRequest
.isCompatible(request1
));
238 assertFalse("isCompatible", coalescedRequest
.isCompatible(request2
));
239 assertFalse("isCompatible", coalescedRequest
.isCompatible(request3
));
242 // ------------------------------------------------------------------------
244 // ------------------------------------------------------------------------
246 public void testDone() {
249 final boolean[] crFlags
= new boolean[4];
250 TmfCoalescedDataRequest
<TmfEvent
> request
= setupTestRequest(crFlags
);
251 TmfDataRequest
<TmfEvent
> subRequest1
= new TmfDataRequestStub
<TmfEvent
>(TmfEvent
.class, 10, 100, 200);
252 TmfDataRequest
<TmfEvent
> subRequest2
= new TmfDataRequestStub
<TmfEvent
>(TmfEvent
.class, 10, 100, 200);
253 request
.addRequest(subRequest1
);
254 request
.addRequest(subRequest2
);
258 // Validate the coalescing request
259 assertTrue ("isCompleted", request
.isCompleted());
260 assertFalse("isFailed", request
.isFailed());
261 assertFalse("isCancelled", request
.isCancelled());
263 assertTrue ("handleCompleted", crFlags
[0]);
264 assertTrue ("handleSuccess", crFlags
[1]);
265 assertFalse("handleFailure", crFlags
[2]);
266 assertFalse("handleCancel", crFlags
[3]);
268 // Validate the first coalesced request
269 assertTrue ("isCompleted", subRequest1
.isCompleted());
270 assertFalse("isFailed", subRequest1
.isFailed());
271 assertFalse("isCancelled", subRequest1
.isCancelled());
273 // Validate the second coalesced request
274 assertTrue ("isCompleted", subRequest2
.isCompleted());
275 assertFalse("isFailed", subRequest2
.isFailed());
276 assertFalse("isCancelled", subRequest2
.isCancelled());
279 // ------------------------------------------------------------------------
281 // ------------------------------------------------------------------------
283 public void testFail() {
285 final boolean[] crFlags
= new boolean[4];
286 TmfCoalescedDataRequest
<TmfEvent
> request
= setupTestRequest(crFlags
);
287 TmfDataRequest
<TmfEvent
> subRequest1
= new TmfDataRequestStub
<TmfEvent
>(TmfEvent
.class, 10, 100, 200);
288 TmfDataRequest
<TmfEvent
> subRequest2
= new TmfDataRequestStub
<TmfEvent
>(TmfEvent
.class, 10, 100, 200);
289 request
.addRequest(subRequest1
);
290 request
.addRequest(subRequest2
);
294 // Validate the coalescing request
295 assertTrue ("isCompleted", request
.isCompleted());
296 assertTrue ("isFailed", request
.isFailed());
297 assertFalse("isCancelled", request
.isCancelled());
299 assertTrue ("handleCompleted", crFlags
[0]);
300 assertFalse("handleSuccess", crFlags
[1]);
301 assertTrue ("handleFailure", crFlags
[2]);
302 assertFalse("handleCancel", crFlags
[3]);
304 // Validate the first coalesced request
305 assertTrue ("isCompleted", subRequest1
.isCompleted());
306 assertTrue ("isFailed", subRequest1
.isFailed());
307 assertFalse("isCancelled", subRequest1
.isCancelled());
309 // Validate the second coalesced request
310 assertTrue ("isCompleted", subRequest2
.isCompleted());
311 assertTrue ("isFailed", subRequest2
.isFailed());
312 assertFalse("isCancelled", subRequest2
.isCancelled());
315 // ------------------------------------------------------------------------
317 // ------------------------------------------------------------------------
319 public void testCancel() {
321 final boolean[] crFlags
= new boolean[4];
322 TmfCoalescedDataRequest
<TmfEvent
> request
= setupTestRequest(crFlags
);
323 TmfDataRequest
<TmfEvent
> subRequest1
= new TmfDataRequestStub
<TmfEvent
>(TmfEvent
.class, 10, 100, 200);
324 TmfDataRequest
<TmfEvent
> subRequest2
= new TmfDataRequestStub
<TmfEvent
>(TmfEvent
.class, 10, 100, 200);
325 request
.addRequest(subRequest1
);
326 request
.addRequest(subRequest2
);
330 // Validate the coalescing request
331 assertTrue ("isCompleted", request
.isCompleted());
332 assertFalse("isFailed", request
.isFailed());
333 assertTrue ("isCancelled", request
.isCancelled());
335 assertTrue ("handleCompleted", crFlags
[0]);
336 assertFalse("handleSuccess", crFlags
[1]);
337 assertFalse("handleFailure", crFlags
[2]);
338 assertTrue ("handleCancel", crFlags
[3]);
340 // Validate the first coalesced request
341 assertTrue ("isCompleted", subRequest1
.isCompleted());
342 assertFalse("isFailed", subRequest1
.isFailed());
343 assertTrue ("isCancelled", subRequest1
.isCancelled());
345 // Validate the second coalesced request
346 assertTrue ("isCompleted", subRequest2
.isCompleted());
347 assertFalse("isFailed", subRequest2
.isFailed());
348 assertTrue ("isCancelled", subRequest2
.isCancelled());
352 // ------------------------------------------------------------------------
353 // cancel sub-requests
354 // ------------------------------------------------------------------------
356 public void testCancelSubRequests() {
358 final boolean[] crFlags
= new boolean[4];
359 TmfCoalescedDataRequest
<TmfEvent
> request
= setupTestRequest(crFlags
);
360 TmfDataRequest
<TmfEvent
> subRequest1
= new TmfDataRequestStub
<TmfEvent
>(TmfEvent
.class, 10, 100, 200);
361 TmfDataRequest
<TmfEvent
> subRequest2
= new TmfDataRequestStub
<TmfEvent
>(TmfEvent
.class, 10, 100, 200);
362 request
.addRequest(subRequest1
);
363 request
.addRequest(subRequest2
);
365 subRequest1
.cancel();
367 // Validate the first coalesced request
368 assertTrue ("isCompleted", subRequest1
.isCompleted());
369 assertFalse("isFailed", subRequest1
.isFailed());
370 assertTrue ("isCancelled", subRequest1
.isCancelled());
372 // Validate the coalescing request
373 assertFalse("isCompleted", request
.isCompleted());
374 assertFalse("isFailed", request
.isFailed());
375 assertFalse("isCancelled", request
.isCancelled());
377 // Cancel second sub-request
378 subRequest2
.cancel();
380 // Validate the second coalesced request
381 assertTrue ("isCompleted", subRequest2
.isCompleted());
382 assertFalse("isFailed", subRequest2
.isFailed());
383 assertTrue ("isCancelled", subRequest2
.isCancelled());
385 // Validate the coalescing request
386 assertTrue ("isCompleted", request
.isCompleted());
387 assertFalse("isFailed", request
.isFailed());
388 assertTrue ("isCancelled", request
.isCancelled());
390 // Finalize coalescing request -
391 // Note: No need to check "request.isCancelled()" since it was verified above
394 assertTrue ("handleCompleted", crFlags
[0]);
395 assertFalse("handleSuccess", crFlags
[1]);
396 assertFalse("handleFailure", crFlags
[2]);
397 assertTrue ("handleCancel", crFlags
[3]);
400 // ------------------------------------------------------------------------
402 // ------------------------------------------------------------------------