Commit | Line | Data |
---|---|---|
d18dd09b | 1 | /******************************************************************************* |
f17b4e9b | 2 | * Copyright (c) 2009, 2010, 2012 Ericsson |
9b749023 | 3 | * |
d18dd09b ASL |
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 | |
9b749023 | 8 | * |
d18dd09b ASL |
9 | * Contributors: |
10 | * Francois Chouinard - Initial API and implementation | |
f17b4e9b | 11 | * Francois Chouinard - Added tests to check offsets |
d18dd09b ASL |
12 | *******************************************************************************/ |
13 | ||
6c13869b | 14 | package org.eclipse.linuxtools.tmf.core.tests.request; |
d18dd09b | 15 | |
d18dd09b ASL |
16 | import junit.framework.TestCase; |
17 | ||
8fd82db5 | 18 | import org.eclipse.linuxtools.internal.tmf.core.request.TmfCoalescedDataRequest; |
6cf47f9a | 19 | import org.eclipse.linuxtools.tmf.core.event.ITmfEvent; |
6c13869b | 20 | import org.eclipse.linuxtools.tmf.core.event.TmfEvent; |
6c13869b | 21 | import org.eclipse.linuxtools.tmf.core.request.TmfDataRequest; |
4918b8f2 | 22 | import org.eclipse.linuxtools.tmf.tests.stubs.request.TmfDataRequestStub; |
d18dd09b ASL |
23 | |
24 | /** | |
2fb2eb37 | 25 | * Test suite for the TmfCoalescedDataRequest class. |
d18dd09b | 26 | */ |
54a7a54c | 27 | @SuppressWarnings({"nls","javadoc"}) |
d18dd09b ASL |
28 | public class TmfCoalescedDataRequestTest extends TestCase { |
29 | ||
2fb2eb37 FC |
30 | // ------------------------------------------------------------------------ |
31 | // Variables | |
32 | // ------------------------------------------------------------------------ | |
33 | ||
6256d8ad AM |
34 | private TmfCoalescedDataRequest fRequest1; |
35 | private TmfCoalescedDataRequest fRequest2; | |
36 | private TmfCoalescedDataRequest fRequest3; | |
37 | private TmfCoalescedDataRequest fRequest4; | |
2fb2eb37 | 38 | |
6256d8ad AM |
39 | private TmfCoalescedDataRequest fRequest1b; |
40 | private TmfCoalescedDataRequest fRequest1c; | |
2fb2eb37 | 41 | |
6e85c58d | 42 | private int fRequestCount; |
9b749023 | 43 | |
d18dd09b ASL |
44 | // ------------------------------------------------------------------------ |
45 | // Housekeeping | |
46 | // ------------------------------------------------------------------------ | |
47 | ||
54a7a54c FC |
48 | /** |
49 | * @param name the test name | |
50 | */ | |
51 | public TmfCoalescedDataRequestTest(final String name) { | |
d18dd09b ASL |
52 | super(name); |
53 | } | |
54 | ||
8fd82db5 | 55 | @Override |
d18dd09b | 56 | public void setUp() throws Exception { |
2fb2eb37 FC |
57 | super.setUp(); |
58 | TmfDataRequest.reset(); | |
6256d8ad AM |
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); | |
2fb2eb37 | 63 | |
6256d8ad AM |
64 | fRequest1b = new TmfCoalescedDataRequest(TmfEvent.class, 10, 100, 200); |
65 | fRequest1c = new TmfCoalescedDataRequest(TmfEvent.class, 10, 100, 200); | |
2fb2eb37 FC |
66 | |
67 | fRequestCount = fRequest1c.getRequestId() + 1; | |
d18dd09b ASL |
68 | } |
69 | ||
70 | @Override | |
71 | public void tearDown() throws Exception { | |
2fb2eb37 | 72 | super.tearDown(); |
d18dd09b ASL |
73 | } |
74 | ||
6256d8ad | 75 | private static TmfCoalescedDataRequest setupTestRequest(final boolean[] flags) { |
9b749023 | 76 | |
6256d8ad | 77 | TmfCoalescedDataRequest request = new TmfCoalescedDataRequest(TmfEvent.class, 10, 100, 200) { |
2fb2eb37 FC |
78 | @Override |
79 | public void handleCompleted() { | |
80 | super.handleCompleted(); | |
81 | flags[0] = true; | |
82 | } | |
83 | @Override | |
84 | public void handleSuccess() { | |
85 | super.handleSuccess(); | |
86 | flags[1] = true; | |
87 | } | |
88 | @Override | |
89 | public void handleFailure() { | |
90 | super.handleFailure(); | |
91 | flags[2] = true; | |
92 | } | |
93 | @Override | |
94 | public void handleCancel() { | |
95 | super.handleCancel(); | |
96 | flags[3] = true; | |
97 | } | |
98 | }; | |
99 | return request; | |
100 | } | |
9b749023 | 101 | |
d18dd09b ASL |
102 | // ------------------------------------------------------------------------ |
103 | // Constructors | |
104 | // ------------------------------------------------------------------------ | |
105 | ||
6256d8ad AM |
106 | public void testTmfCoalescedDataRequest() { |
107 | TmfCoalescedDataRequest request = new TmfCoalescedDataRequest(TmfEvent.class); | |
d18dd09b | 108 | |
2fb2eb37 | 109 | assertEquals("getRequestId", fRequestCount++, request.getRequestId()); |
6cf47f9a | 110 | assertEquals("getDataType", ITmfEvent.class, request.getDataType()); |
2fb2eb37 FC |
111 | |
112 | assertEquals("getIndex", 0, request.getIndex()); | |
d18dd09b | 113 | assertEquals("getNbRequestedEvents", TmfDataRequest.ALL_DATA, request.getNbRequested()); |
2fb2eb37 FC |
114 | |
115 | assertFalse("isCompleted", request.isCompleted()); | |
116 | assertFalse("isFailed", request.isFailed()); | |
117 | assertFalse("isCancelled", request.isCancelled()); | |
118 | ||
119 | assertEquals("getNbRead", 0, request.getNbRead()); | |
d18dd09b ASL |
120 | } |
121 | ||
122 | public void testTmfCoalescedDataRequestIndex() { | |
6256d8ad | 123 | TmfCoalescedDataRequest request = new TmfCoalescedDataRequest(TmfEvent.class, 10); |
d18dd09b | 124 | |
2fb2eb37 | 125 | assertEquals("getRequestId", fRequestCount++, request.getRequestId()); |
6cf47f9a | 126 | assertEquals("getDataType", ITmfEvent.class, request.getDataType()); |
2fb2eb37 FC |
127 | |
128 | assertEquals("getIndex", 10, request.getIndex()); | |
d18dd09b | 129 | assertEquals("getNbRequestedEvents", TmfDataRequest.ALL_DATA, request.getNbRequested()); |
2fb2eb37 FC |
130 | |
131 | assertFalse("isCompleted", request.isCompleted()); | |
132 | assertFalse("isFailed", request.isFailed()); | |
133 | assertFalse("isCancelled", request.isCancelled()); | |
134 | ||
135 | assertEquals("getNbRead", 0, request.getNbRead()); | |
d18dd09b ASL |
136 | } |
137 | ||
138 | public void testTmfCoalescedDataRequestIndexNbRequested() { | |
6256d8ad | 139 | TmfCoalescedDataRequest request = new TmfCoalescedDataRequest(TmfEvent.class, 10, 100); |
d18dd09b | 140 | |
2fb2eb37 | 141 | assertEquals("getRequestId", fRequestCount++, request.getRequestId()); |
6cf47f9a | 142 | assertEquals("getDataType", ITmfEvent.class, request.getDataType()); |
2fb2eb37 FC |
143 | |
144 | assertEquals("getIndex", 10, request.getIndex()); | |
d18dd09b | 145 | assertEquals("getNbRequestedEvents", 100, request.getNbRequested()); |
2fb2eb37 FC |
146 | |
147 | assertFalse("isCompleted", request.isCompleted()); | |
148 | assertFalse("isFailed", request.isFailed()); | |
149 | assertFalse("isCancelled", request.isCancelled()); | |
150 | ||
151 | assertEquals("getNbRead", 0, request.getNbRead()); | |
d18dd09b ASL |
152 | } |
153 | ||
154 | public void testTmfCoalescedDataRequestIndexNbEventsBlocksize() { | |
6256d8ad | 155 | TmfCoalescedDataRequest request = new TmfCoalescedDataRequest(TmfEvent.class, 10, 100, 200); |
d18dd09b | 156 | |
2fb2eb37 | 157 | assertEquals("getRequestId", fRequestCount++, request.getRequestId()); |
6cf47f9a | 158 | assertEquals("getDataType", ITmfEvent.class, request.getDataType()); |
2fb2eb37 FC |
159 | |
160 | assertEquals("getIndex", 10, request.getIndex()); | |
d18dd09b | 161 | assertEquals("getNbRequestedEvents", 100, request.getNbRequested()); |
2fb2eb37 FC |
162 | |
163 | assertFalse("isCompleted", request.isCompleted()); | |
164 | assertFalse("isFailed", request.isFailed()); | |
165 | assertFalse("isCancelled", request.isCancelled()); | |
166 | ||
167 | assertEquals("getNbRead", 0, request.getNbRead()); | |
168 | } | |
169 | ||
170 | // ------------------------------------------------------------------------ | |
171 | // equals | |
172 | // ------------------------------------------------------------------------ | |
173 | ||
54a7a54c | 174 | public void testEqualsReflexivity() { |
2fb2eb37 FC |
175 | assertTrue("equals", fRequest1.equals(fRequest1)); |
176 | assertTrue("equals", fRequest2.equals(fRequest2)); | |
177 | ||
178 | assertFalse("equals", fRequest1.equals(fRequest2)); | |
179 | assertFalse("equals", fRequest2.equals(fRequest1)); | |
180 | } | |
181 | ||
54a7a54c | 182 | public void testEqualsSymmetry() { |
2fb2eb37 FC |
183 | assertTrue("equals", fRequest1.equals(fRequest1b)); |
184 | assertTrue("equals", fRequest1b.equals(fRequest1)); | |
185 | ||
186 | assertFalse("equals", fRequest1.equals(fRequest3)); | |
187 | assertFalse("equals", fRequest2.equals(fRequest3)); | |
188 | assertFalse("equals", fRequest3.equals(fRequest1)); | |
189 | assertFalse("equals", fRequest3.equals(fRequest2)); | |
190 | } | |
9b749023 | 191 | |
54a7a54c | 192 | public void testEqualsTransivity() { |
2fb2eb37 FC |
193 | assertTrue("equals", fRequest1.equals(fRequest1b)); |
194 | assertTrue("equals", fRequest1b.equals(fRequest1c)); | |
195 | assertTrue("equals", fRequest1.equals(fRequest1c)); | |
196 | } | |
9b749023 | 197 | |
54a7a54c | 198 | public void testEqualsNull() { |
2fb2eb37 FC |
199 | assertFalse("equals", fRequest1.equals(null)); |
200 | assertFalse("equals", fRequest2.equals(null)); | |
201 | } | |
202 | ||
203 | // ------------------------------------------------------------------------ | |
204 | // hashCode | |
205 | // ------------------------------------------------------------------------ | |
206 | ||
54a7a54c | 207 | public void testHashCode() { |
2fb2eb37 FC |
208 | assertTrue("hashCode", fRequest1.hashCode() == fRequest1.hashCode()); |
209 | assertTrue("hashCode", fRequest2.hashCode() == fRequest2.hashCode()); | |
210 | assertTrue("hashCode", fRequest1.hashCode() != fRequest2.hashCode()); | |
211 | } | |
9b749023 | 212 | |
2fb2eb37 FC |
213 | // ------------------------------------------------------------------------ |
214 | // toString | |
215 | // ------------------------------------------------------------------------ | |
216 | ||
217 | public void testToString() { | |
6cf47f9a FC |
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)]"; | |
2fb2eb37 FC |
222 | |
223 | assertEquals("toString", expected1, fRequest1.toString()); | |
224 | assertEquals("toString", expected2, fRequest2.toString()); | |
225 | assertEquals("toString", expected3, fRequest3.toString()); | |
226 | assertEquals("toString", expected4, fRequest4.toString()); | |
d18dd09b ASL |
227 | } |
228 | ||
229 | // ------------------------------------------------------------------------ | |
230 | // isCompatible | |
231 | // ------------------------------------------------------------------------ | |
232 | ||
233 | public void testIsCompatible() { | |
6256d8ad AM |
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); | |
923b8517 FC |
243 | |
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)); | |
252 | ||
6256d8ad AM |
253 | TmfDataRequest request9 = new TmfDataRequestStub(TmfEvent.class, 5, 3, 200); |
254 | TmfDataRequest request10 = new TmfDataRequestStub(TmfEvent.class, 112, 100, 200); | |
923b8517 FC |
255 | |
256 | assertFalse("isCompatible", coalescedRequest.isCompatible(request9)); | |
257 | assertFalse("isCompatible", coalescedRequest.isCompatible(request10)); | |
2fb2eb37 FC |
258 | } |
259 | ||
923b8517 FC |
260 | // ------------------------------------------------------------------------ |
261 | // addRequest | |
262 | // ------------------------------------------------------------------------ | |
263 | ||
264 | public void testAddRequest1() { | |
6256d8ad AM |
265 | TmfCoalescedDataRequest coalescedRequest = new TmfCoalescedDataRequest(TmfEvent.class, 10, 100, 200); |
266 | TmfDataRequest request = new TmfDataRequestStub(TmfEvent.class, 10, 100, 200); | |
923b8517 FC |
267 | |
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()); | |
273 | } | |
274 | ||
275 | public void testAddRequest2() { | |
6256d8ad AM |
276 | TmfCoalescedDataRequest coalescedRequest = new TmfCoalescedDataRequest(TmfEvent.class, 10, 100, 200); |
277 | TmfDataRequest request = new TmfDataRequestStub(TmfEvent.class, 5, 100, 200); | |
923b8517 FC |
278 | |
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()); | |
284 | } | |
285 | ||
286 | public void testAddRequest3() { | |
6256d8ad AM |
287 | TmfCoalescedDataRequest coalescedRequest = new TmfCoalescedDataRequest(TmfEvent.class, 10, 100, 200); |
288 | TmfDataRequest request = new TmfDataRequestStub(TmfEvent.class, 5, 4, 200); | |
923b8517 FC |
289 | |
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()); | |
295 | } | |
296 | ||
297 | public void testAddRequest4() { | |
6256d8ad AM |
298 | TmfCoalescedDataRequest coalescedRequest = new TmfCoalescedDataRequest(TmfEvent.class, 10, 100, 200); |
299 | TmfDataRequest request = new TmfDataRequestStub(TmfEvent.class, 5, 5, 200); | |
923b8517 FC |
300 | |
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()); | |
306 | } | |
307 | ||
308 | public void testAddRequest5() { | |
6256d8ad AM |
309 | TmfCoalescedDataRequest coalescedRequest = new TmfCoalescedDataRequest(TmfEvent.class, 10, 100, 200); |
310 | TmfDataRequest request = new TmfDataRequestStub(TmfEvent.class, 15, 100, 200); | |
923b8517 FC |
311 | |
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()); | |
317 | } | |
318 | ||
319 | public void testAddRequest6() { | |
6256d8ad AM |
320 | TmfCoalescedDataRequest coalescedRequest = new TmfCoalescedDataRequest(TmfEvent.class, 10, 100, 200); |
321 | TmfDataRequest request = new TmfDataRequestStub(TmfEvent.class, 100, 100, 200); | |
923b8517 FC |
322 | |
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()); | |
328 | } | |
329 | ||
330 | public void testAddRequest7() { | |
6256d8ad AM |
331 | TmfCoalescedDataRequest coalescedRequest = new TmfCoalescedDataRequest(TmfEvent.class, 10, 100, 200); |
332 | TmfDataRequest request = new TmfDataRequestStub(TmfEvent.class, 110, 100, 200); | |
923b8517 FC |
333 | |
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()); | |
339 | } | |
340 | ||
341 | public void testAddRequest8() { | |
6256d8ad AM |
342 | TmfCoalescedDataRequest coalescedRequest = new TmfCoalescedDataRequest(TmfEvent.class, 10, 100, 200); |
343 | TmfDataRequest request = new TmfDataRequestStub(TmfEvent.class, 111, 100, 200); | |
923b8517 FC |
344 | |
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()); | |
350 | } | |
351 | ||
2fb2eb37 FC |
352 | // ------------------------------------------------------------------------ |
353 | // done | |
354 | // ------------------------------------------------------------------------ | |
355 | ||
356 | public void testDone() { | |
9b749023 | 357 | |
2fb2eb37 FC |
358 | // Test request |
359 | final boolean[] crFlags = new boolean[4]; | |
6256d8ad AM |
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); | |
2fb2eb37 FC |
363 | request.addRequest(subRequest1); |
364 | request.addRequest(subRequest2); | |
365 | ||
366 | request.done(); | |
367 | ||
368 | // Validate the coalescing request | |
369 | assertTrue ("isCompleted", request.isCompleted()); | |
370 | assertFalse("isFailed", request.isFailed()); | |
371 | assertFalse("isCancelled", request.isCancelled()); | |
372 | ||
373 | assertTrue ("handleCompleted", crFlags[0]); | |
374 | assertTrue ("handleSuccess", crFlags[1]); | |
375 | assertFalse("handleFailure", crFlags[2]); | |
376 | assertFalse("handleCancel", crFlags[3]); | |
377 | ||
378 | // Validate the first coalesced request | |
379 | assertTrue ("isCompleted", subRequest1.isCompleted()); | |
380 | assertFalse("isFailed", subRequest1.isFailed()); | |
381 | assertFalse("isCancelled", subRequest1.isCancelled()); | |
382 | ||
383 | // Validate the second coalesced request | |
384 | assertTrue ("isCompleted", subRequest2.isCompleted()); | |
385 | assertFalse("isFailed", subRequest2.isFailed()); | |
386 | assertFalse("isCancelled", subRequest2.isCancelled()); | |
387 | } | |
388 | ||
389 | // ------------------------------------------------------------------------ | |
390 | // fail | |
391 | // ------------------------------------------------------------------------ | |
392 | ||
393 | public void testFail() { | |
9b749023 | 394 | |
2fb2eb37 | 395 | final boolean[] crFlags = new boolean[4]; |
6256d8ad AM |
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); | |
2fb2eb37 FC |
399 | request.addRequest(subRequest1); |
400 | request.addRequest(subRequest2); | |
401 | ||
402 | request.fail(); | |
403 | ||
404 | // Validate the coalescing request | |
405 | assertTrue ("isCompleted", request.isCompleted()); | |
406 | assertTrue ("isFailed", request.isFailed()); | |
407 | assertFalse("isCancelled", request.isCancelled()); | |
408 | ||
409 | assertTrue ("handleCompleted", crFlags[0]); | |
410 | assertFalse("handleSuccess", crFlags[1]); | |
411 | assertTrue ("handleFailure", crFlags[2]); | |
412 | assertFalse("handleCancel", crFlags[3]); | |
413 | ||
414 | // Validate the first coalesced request | |
415 | assertTrue ("isCompleted", subRequest1.isCompleted()); | |
416 | assertTrue ("isFailed", subRequest1.isFailed()); | |
417 | assertFalse("isCancelled", subRequest1.isCancelled()); | |
418 | ||
419 | // Validate the second coalesced request | |
420 | assertTrue ("isCompleted", subRequest2.isCompleted()); | |
421 | assertTrue ("isFailed", subRequest2.isFailed()); | |
422 | assertFalse("isCancelled", subRequest2.isCancelled()); | |
423 | } | |
424 | ||
425 | // ------------------------------------------------------------------------ | |
426 | // cancel | |
427 | // ------------------------------------------------------------------------ | |
428 | ||
429 | public void testCancel() { | |
430 | ||
431 | final boolean[] crFlags = new boolean[4]; | |
6256d8ad AM |
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); | |
2fb2eb37 FC |
435 | request.addRequest(subRequest1); |
436 | request.addRequest(subRequest2); | |
437 | ||
438 | request.cancel(); | |
439 | ||
440 | // Validate the coalescing request | |
441 | assertTrue ("isCompleted", request.isCompleted()); | |
442 | assertFalse("isFailed", request.isFailed()); | |
443 | assertTrue ("isCancelled", request.isCancelled()); | |
444 | ||
445 | assertTrue ("handleCompleted", crFlags[0]); | |
446 | assertFalse("handleSuccess", crFlags[1]); | |
447 | assertFalse("handleFailure", crFlags[2]); | |
448 | assertTrue ("handleCancel", crFlags[3]); | |
449 | ||
450 | // Validate the first coalesced request | |
451 | assertTrue ("isCompleted", subRequest1.isCompleted()); | |
452 | assertFalse("isFailed", subRequest1.isFailed()); | |
453 | assertTrue ("isCancelled", subRequest1.isCancelled()); | |
454 | ||
455 | // Validate the second coalesced request | |
456 | assertTrue ("isCompleted", subRequest2.isCompleted()); | |
457 | assertFalse("isFailed", subRequest2.isFailed()); | |
458 | assertTrue ("isCancelled", subRequest2.isCancelled()); | |
459 | } | |
460 | ||
9b749023 | 461 | |
c1c69938 FC |
462 | // ------------------------------------------------------------------------ |
463 | // cancel sub-requests | |
464 | // ------------------------------------------------------------------------ | |
465 | ||
466 | public void testCancelSubRequests() { | |
467 | ||
468 | final boolean[] crFlags = new boolean[4]; | |
6256d8ad AM |
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); | |
c1c69938 FC |
472 | request.addRequest(subRequest1); |
473 | request.addRequest(subRequest2); | |
474 | ||
475 | subRequest1.cancel(); | |
476 | ||
477 | // Validate the first coalesced request | |
478 | assertTrue ("isCompleted", subRequest1.isCompleted()); | |
479 | assertFalse("isFailed", subRequest1.isFailed()); | |
480 | assertTrue ("isCancelled", subRequest1.isCancelled()); | |
481 | ||
482 | // Validate the coalescing request | |
483 | assertFalse("isCompleted", request.isCompleted()); | |
484 | assertFalse("isFailed", request.isFailed()); | |
9b749023 | 485 | assertFalse("isCancelled", request.isCancelled()); |
c1c69938 FC |
486 | |
487 | // Cancel second sub-request | |
488 | subRequest2.cancel(); | |
489 | ||
490 | // Validate the second coalesced request | |
491 | assertTrue ("isCompleted", subRequest2.isCompleted()); | |
492 | assertFalse("isFailed", subRequest2.isFailed()); | |
493 | assertTrue ("isCancelled", subRequest2.isCancelled()); | |
494 | ||
495 | // Validate the coalescing request | |
496 | assertTrue ("isCompleted", request.isCompleted()); | |
497 | assertFalse("isFailed", request.isFailed()); | |
498 | assertTrue ("isCancelled", request.isCancelled()); | |
499 | ||
9b749023 | 500 | // Finalize coalescing request - |
c1c69938 FC |
501 | // Note: No need to check "request.isCancelled()" since it was verified above |
502 | request.cancel(); | |
503 | ||
504 | assertTrue ("handleCompleted", crFlags[0]); | |
505 | assertFalse("handleSuccess", crFlags[1]); | |
506 | assertFalse("handleFailure", crFlags[2]); | |
f17b4e9b | 507 | assertTrue ("handleCancel", crFlags[3]); |
c1c69938 FC |
508 | } |
509 | ||
d18dd09b | 510 | } |