projects / deliverable / tracecompass.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
Fix unnecessary @SuppressWarning and removed dead code.
[deliverable/tracecompass.git] / org.eclipse.linuxtools.tmf.core.tests / src / org / eclipse / linuxtools / tmf / core / tests / request / TmfCoalescedDataRequestTest.java
CommitLineData
d18dd09b
ASL		 1/*******************************************************************************
2 * Copyright (c) 2009, 2010 Ericsson
3 *
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
8 *
9 * Contributors:
10 * Francois Chouinard - Initial API and implementation
11 *******************************************************************************/
12
6c13869b 13package org.eclipse.linuxtools.tmf.core.tests.request;
d18dd09b
ASL		 14
15
16import junit.framework.TestCase;
17
8fd82db5 18import org.eclipse.linuxtools.internal.tmf.core.request.TmfCoalescedDataRequest;
6c13869b 19import org.eclipse.linuxtools.tmf.core.event.TmfEvent;
6c13869b 20import org.eclipse.linuxtools.tmf.core.request.TmfDataRequest;
4918b8f2 21import org.eclipse.linuxtools.tmf.tests.stubs.request.TmfDataRequestStub;
d18dd09b
ASL		 22
23/**
24 * <b><u>TmfCoalescedDataRequestTest</u></b>
25 * <p>
2fb2eb37 26 * Test suite for the TmfCoalescedDataRequest class.
d18dd09b 27 */
2d223a34 28@SuppressWarnings({ "nls" })
d18dd09b
ASL		 29public class TmfCoalescedDataRequestTest extends TestCase {
30
2fb2eb37
FC		 31 // ------------------------------------------------------------------------
32 // Variables
33 // ------------------------------------------------------------------------
34
6e85c58d
FC		 35 private TmfCoalescedDataRequest<TmfEvent> fRequest1;
36 private TmfCoalescedDataRequest<TmfEvent> fRequest2;
37 private TmfCoalescedDataRequest<TmfEvent> fRequest3;
38 private TmfCoalescedDataRequest<TmfEvent> fRequest4;
2fb2eb37 39
6e85c58d
FC		 40 private TmfCoalescedDataRequest<TmfEvent> fRequest1b;
41 private TmfCoalescedDataRequest<TmfEvent> fRequest1c;
2fb2eb37 42
6e85c58d 43 private int fRequestCount;
2fb2eb37 44
d18dd09b
ASL		 45 // ------------------------------------------------------------------------
46 // Housekeeping
47 // ------------------------------------------------------------------------
48
49 public TmfCoalescedDataRequestTest(String name) {
50 super(name);
51 }
52
8fd82db5 53 @Override
d18dd09b 54 public void setUp() throws Exception {
2fb2eb37
FC		 55 super.setUp();
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);
61
62 fRequest1b = new TmfCoalescedDataRequest<TmfEvent>(TmfEvent.class, 10, 100, 200);
63 fRequest1c = new TmfCoalescedDataRequest<TmfEvent>(TmfEvent.class, 10, 100, 200);
64
65 fRequestCount = fRequest1c.getRequestId() + 1;
d18dd09b
ASL		 66 }
67
68 @Override
69 public void tearDown() throws Exception {
2fb2eb37 70 super.tearDown();
d18dd09b
ASL		 71 }
72
2fb2eb37
FC		 73 private TmfCoalescedDataRequest<TmfEvent> setupTestRequest(final boolean[] flags) {
74
75 TmfCoalescedDataRequest<TmfEvent> request = new TmfCoalescedDataRequest<TmfEvent>(TmfEvent.class, 10, 100, 200) {
76 @Override
77 public void handleCompleted() {
78 super.handleCompleted();
79 flags[0] = true;
80 }
81 @Override
82 public void handleSuccess() {
83 super.handleSuccess();
84 flags[1] = true;
85 }
86 @Override
87 public void handleFailure() {
88 super.handleFailure();
89 flags[2] = true;
90 }
91 @Override
92 public void handleCancel() {
93 super.handleCancel();
94 flags[3] = true;
95 }
96 };
97 return request;
98 }
99
d18dd09b
ASL		 100 // ------------------------------------------------------------------------
101 // Constructors
102 // ------------------------------------------------------------------------
103
104 public void testTmfCoalescedDataRequest() {
105 TmfCoalescedDataRequest<TmfEvent> request = new TmfCoalescedDataRequest<TmfEvent>(TmfEvent.class);
106
2fb2eb37
FC		 107 assertEquals("getRequestId", fRequestCount++, request.getRequestId());
108 assertEquals("getDataType", TmfEvent.class, request.getDataType());
109
110 assertEquals("getIndex", 0, request.getIndex());
d18dd09b 111 assertEquals("getNbRequestedEvents", TmfDataRequest.ALL_DATA, request.getNbRequested());
2fb2eb37
FC		 112
113 assertFalse("isCompleted", request.isCompleted());
114 assertFalse("isFailed", request.isFailed());
115 assertFalse("isCancelled", request.isCancelled());
116
117 assertEquals("getNbRead", 0, request.getNbRead());
d18dd09b
ASL		 118 }
119
120 public void testTmfCoalescedDataRequestIndex() {
121 TmfCoalescedDataRequest<TmfEvent> request = new TmfCoalescedDataRequest<TmfEvent>(TmfEvent.class, 10);
122
2fb2eb37
FC		 123 assertEquals("getRequestId", fRequestCount++, request.getRequestId());
124 assertEquals("getDataType", TmfEvent.class, request.getDataType());
125
126 assertEquals("getIndex", 10, request.getIndex());
d18dd09b 127 assertEquals("getNbRequestedEvents", TmfDataRequest.ALL_DATA, request.getNbRequested());
2fb2eb37
FC		 128
129 assertFalse("isCompleted", request.isCompleted());
130 assertFalse("isFailed", request.isFailed());
131 assertFalse("isCancelled", request.isCancelled());
132
133 assertEquals("getNbRead", 0, request.getNbRead());
d18dd09b
ASL		 134 }
135
136 public void testTmfCoalescedDataRequestIndexNbRequested() {
137 TmfCoalescedDataRequest<TmfEvent> request = new TmfCoalescedDataRequest<TmfEvent>(TmfEvent.class, 10, 100);
138
2fb2eb37
FC		 139 assertEquals("getRequestId", fRequestCount++, request.getRequestId());
140 assertEquals("getDataType", TmfEvent.class, request.getDataType());
141
142 assertEquals("getIndex", 10, request.getIndex());
d18dd09b 143 assertEquals("getNbRequestedEvents", 100, request.getNbRequested());
2fb2eb37
FC		 144
145 assertFalse("isCompleted", request.isCompleted());
146 assertFalse("isFailed", request.isFailed());
147 assertFalse("isCancelled", request.isCancelled());
148
149 assertEquals("getNbRead", 0, request.getNbRead());
d18dd09b
ASL		 150 }
151
152 public void testTmfCoalescedDataRequestIndexNbEventsBlocksize() {
153 TmfCoalescedDataRequest<TmfEvent> request = new TmfCoalescedDataRequest<TmfEvent>(TmfEvent.class, 10, 100, 200);
154
2fb2eb37
FC		 155 assertEquals("getRequestId", fRequestCount++, request.getRequestId());
156 assertEquals("getDataType", TmfEvent.class, request.getDataType());
157
158 assertEquals("getIndex", 10, request.getIndex());
d18dd09b 159 assertEquals("getNbRequestedEvents", 100, request.getNbRequested());
2fb2eb37
FC		 160
161 assertFalse("isCompleted", request.isCompleted());
162 assertFalse("isFailed", request.isFailed());
163 assertFalse("isCancelled", request.isCancelled());
164
165 assertEquals("getNbRead", 0, request.getNbRead());
166 }
167
168 // ------------------------------------------------------------------------
169 // equals
170 // ------------------------------------------------------------------------
171
172 public void testEqualsReflexivity() throws Exception {
173 assertTrue("equals", fRequest1.equals(fRequest1));
174 assertTrue("equals", fRequest2.equals(fRequest2));
175
176 assertFalse("equals", fRequest1.equals(fRequest2));
177 assertFalse("equals", fRequest2.equals(fRequest1));
178 }
179
180 public void testEqualsSymmetry() throws Exception {
181 assertTrue("equals", fRequest1.equals(fRequest1b));
182 assertTrue("equals", fRequest1b.equals(fRequest1));
183
184 assertFalse("equals", fRequest1.equals(fRequest3));
185 assertFalse("equals", fRequest2.equals(fRequest3));
186 assertFalse("equals", fRequest3.equals(fRequest1));
187 assertFalse("equals", fRequest3.equals(fRequest2));
188 }
189
190 public void testEqualsTransivity() throws Exception {
191 assertTrue("equals", fRequest1.equals(fRequest1b));
192 assertTrue("equals", fRequest1b.equals(fRequest1c));
193 assertTrue("equals", fRequest1.equals(fRequest1c));
194 }
195
2fb2eb37
FC		 196 public void testEqualsNull() throws Exception {
197 assertFalse("equals", fRequest1.equals(null));
198 assertFalse("equals", fRequest2.equals(null));
199 }
200
201 // ------------------------------------------------------------------------
202 // hashCode
203 // ------------------------------------------------------------------------
204
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());
209 }
210
211 // ------------------------------------------------------------------------
212 // toString
213 // ------------------------------------------------------------------------
214
215 public void testToString() {
8016d660
FC		 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)]";
2fb2eb37
FC		 220
221 assertEquals("toString", expected1, fRequest1.toString());
222 assertEquals("toString", expected2, fRequest2.toString());
223 assertEquals("toString", expected3, fRequest3.toString());
224 assertEquals("toString", expected4, fRequest4.toString());
d18dd09b
ASL		 225 }
226
227 // ------------------------------------------------------------------------
228 // isCompatible
229 // ------------------------------------------------------------------------
230
231 public void testIsCompatible() {
232 TmfCoalescedDataRequest<TmfEvent> coalescedRequest = new TmfCoalescedDataRequest<TmfEvent>(TmfEvent.class, 10, 100, 200);
923b8517
FC		 233 TmfDataRequest<TmfEvent> request1 = new TmfDataRequestStub<TmfEvent>(TmfEvent.class, 10, 100, 200);
234 TmfDataRequest<TmfEvent> request2 = new TmfDataRequestStub<TmfEvent>(TmfEvent.class, 5, 100, 200);
235 TmfDataRequest<TmfEvent> request3 = new TmfDataRequestStub<TmfEvent>(TmfEvent.class, 5, 4, 200);
236 TmfDataRequest<TmfEvent> request4 = new TmfDataRequestStub<TmfEvent>(TmfEvent.class, 5, 5, 200);
237 TmfDataRequest<TmfEvent> request5 = new TmfDataRequestStub<TmfEvent>(TmfEvent.class, 15, 100, 200);
238 TmfDataRequest<TmfEvent> request6 = new TmfDataRequestStub<TmfEvent>(TmfEvent.class, 100, 100, 200);
239 TmfDataRequest<TmfEvent> request7 = new TmfDataRequestStub<TmfEvent>(TmfEvent.class, 110, 100, 200);
240 TmfDataRequest<TmfEvent> request8 = new TmfDataRequestStub<TmfEvent>(TmfEvent.class, 111, 100, 200);
241
242 assertTrue("isCompatible", coalescedRequest.isCompatible(request1));
243 assertTrue("isCompatible", coalescedRequest.isCompatible(request2));
244 assertTrue("isCompatible", coalescedRequest.isCompatible(request3));
245 assertTrue("isCompatible", coalescedRequest.isCompatible(request4));
246 assertTrue("isCompatible", coalescedRequest.isCompatible(request5));
247 assertTrue("isCompatible", coalescedRequest.isCompatible(request6));
248 assertTrue("isCompatible", coalescedRequest.isCompatible(request7));
249 assertTrue("isCompatible", coalescedRequest.isCompatible(request8));
250
251 TmfDataRequest<TmfEvent> request9 = new TmfDataRequestStub<TmfEvent>(TmfEvent.class, 5, 3, 200);
252 TmfDataRequest<TmfEvent> request10 = new TmfDataRequestStub<TmfEvent>(TmfEvent.class, 112, 100, 200);
253
254 assertFalse("isCompatible", coalescedRequest.isCompatible(request9));
255 assertFalse("isCompatible", coalescedRequest.isCompatible(request10));
2fb2eb37
FC		 256 }
257
923b8517
FC		 258 // ------------------------------------------------------------------------
259 // addRequest
260 // ------------------------------------------------------------------------
261
262 public void testAddRequest1() {
263 TmfCoalescedDataRequest<TmfEvent> coalescedRequest = new TmfCoalescedDataRequest<TmfEvent>(TmfEvent.class, 10, 100, 200);
264 TmfDataRequest<TmfEvent> request = new TmfDataRequestStub<TmfEvent>(TmfEvent.class, 10, 100, 200);
265
266 assertTrue("isCompatible", coalescedRequest.isCompatible(request));
267 coalescedRequest.addRequest(request);
268 assertEquals("addRequest", 10, coalescedRequest.getIndex());
269 assertEquals("addRequest", 100, coalescedRequest.getNbRequested());
270 assertEquals("addRequest", 200, coalescedRequest.getBlockSize());
271 }
272
273 public void testAddRequest2() {
274 TmfCoalescedDataRequest<TmfEvent> coalescedRequest = new TmfCoalescedDataRequest<TmfEvent>(TmfEvent.class, 10, 100, 200);
275 TmfDataRequest<TmfEvent> request = new TmfDataRequestStub<TmfEvent>(TmfEvent.class, 5, 100, 200);
276
277 assertTrue("isCompatible", coalescedRequest.isCompatible(request));
278 coalescedRequest.addRequest(request);
279 assertEquals("addRequest", 5, coalescedRequest.getIndex());
280 assertEquals("addRequest", 105, coalescedRequest.getNbRequested());
281 assertEquals("addRequest", 200, coalescedRequest.getBlockSize());
282 }
283
284 public void testAddRequest3() {
285 TmfCoalescedDataRequest<TmfEvent> coalescedRequest = new TmfCoalescedDataRequest<TmfEvent>(TmfEvent.class, 10, 100, 200);
286 TmfDataRequest<TmfEvent> request = new TmfDataRequestStub<TmfEvent>(TmfEvent.class, 5, 4, 200);
287
288 assertTrue("isCompatible", coalescedRequest.isCompatible(request));
289 coalescedRequest.addRequest(request);
290 assertEquals("addRequest", 5, coalescedRequest.getIndex());
291 assertEquals("addRequest", 105, coalescedRequest.getNbRequested());
292 assertEquals("addRequest", 200, coalescedRequest.getBlockSize());
293 }
294
295 public void testAddRequest4() {
296 TmfCoalescedDataRequest<TmfEvent> coalescedRequest = new TmfCoalescedDataRequest<TmfEvent>(TmfEvent.class, 10, 100, 200);
297 TmfDataRequest<TmfEvent> request = new TmfDataRequestStub<TmfEvent>(TmfEvent.class, 5, 5, 200);
298
299 assertTrue("isCompatible", coalescedRequest.isCompatible(request));
300 coalescedRequest.addRequest(request);
301 assertEquals("addRequest", 5, coalescedRequest.getIndex());
302 assertEquals("addRequest", 105, coalescedRequest.getNbRequested());
303 assertEquals("addRequest", 200, coalescedRequest.getBlockSize());
304 }
305
306 public void testAddRequest5() {
307 TmfCoalescedDataRequest<TmfEvent> coalescedRequest = new TmfCoalescedDataRequest<TmfEvent>(TmfEvent.class, 10, 100, 200);
308 TmfDataRequest<TmfEvent> request = new TmfDataRequestStub<TmfEvent>(TmfEvent.class, 15, 100, 200);
309
310 assertTrue("isCompatible", coalescedRequest.isCompatible(request));
311 coalescedRequest.addRequest(request);
312 assertEquals("addRequest", 10, coalescedRequest.getIndex());
313 assertEquals("addRequest", 105, coalescedRequest.getNbRequested());
314 assertEquals("addRequest", 200, coalescedRequest.getBlockSize());
315 }
316
317 public void testAddRequest6() {
318 TmfCoalescedDataRequest<TmfEvent> coalescedRequest = new TmfCoalescedDataRequest<TmfEvent>(TmfEvent.class, 10, 100, 200);
319 TmfDataRequest<TmfEvent> request = new TmfDataRequestStub<TmfEvent>(TmfEvent.class, 100, 100, 200);
320
321 assertTrue("isCompatible", coalescedRequest.isCompatible(request));
322 coalescedRequest.addRequest(request);
323 assertEquals("addRequest", 10, coalescedRequest.getIndex());
324 assertEquals("addRequest", 190, coalescedRequest.getNbRequested());
325 assertEquals("addRequest", 200, coalescedRequest.getBlockSize());
326 }
327
328 public void testAddRequest7() {
329 TmfCoalescedDataRequest<TmfEvent> coalescedRequest = new TmfCoalescedDataRequest<TmfEvent>(TmfEvent.class, 10, 100, 200);
330 TmfDataRequest<TmfEvent> request = new TmfDataRequestStub<TmfEvent>(TmfEvent.class, 110, 100, 200);
331
332 assertTrue("isCompatible", coalescedRequest.isCompatible(request));
333 coalescedRequest.addRequest(request);
334 assertEquals("addRequest", 10, coalescedRequest.getIndex());
335 assertEquals("addRequest", 200, coalescedRequest.getNbRequested());
336 assertEquals("addRequest", 200, coalescedRequest.getBlockSize());
337 }
338
339 public void testAddRequest8() {
340 TmfCoalescedDataRequest<TmfEvent> coalescedRequest = new TmfCoalescedDataRequest<TmfEvent>(TmfEvent.class, 10, 100, 200);
341 TmfDataRequest<TmfEvent> request = new TmfDataRequestStub<TmfEvent>(TmfEvent.class, 111, 100, 200);
342
343 assertTrue("isCompatible", coalescedRequest.isCompatible(request));
344 coalescedRequest.addRequest(request);
345 assertEquals("addRequest", 10, coalescedRequest.getIndex());
346 assertEquals("addRequest", 201, coalescedRequest.getNbRequested());
347 assertEquals("addRequest", 200, coalescedRequest.getBlockSize());
348 }
349
2fb2eb37
FC		 350 // ------------------------------------------------------------------------
351 // done
352 // ------------------------------------------------------------------------
353
354 public void testDone() {
355
356 // Test request
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);
363
364 request.done();
365
366 // Validate the coalescing request
367 assertTrue ("isCompleted", request.isCompleted());
368 assertFalse("isFailed", request.isFailed());
369 assertFalse("isCancelled", request.isCancelled());
370
371 assertTrue ("handleCompleted", crFlags[0]);
372 assertTrue ("handleSuccess", crFlags[1]);
373 assertFalse("handleFailure", crFlags[2]);
374 assertFalse("handleCancel", crFlags[3]);
375
376 // Validate the first coalesced request
377 assertTrue ("isCompleted", subRequest1.isCompleted());
378 assertFalse("isFailed", subRequest1.isFailed());
379 assertFalse("isCancelled", subRequest1.isCancelled());
380
381 // Validate the second coalesced request
382 assertTrue ("isCompleted", subRequest2.isCompleted());
383 assertFalse("isFailed", subRequest2.isFailed());
384 assertFalse("isCancelled", subRequest2.isCancelled());
385 }
386
387 // ------------------------------------------------------------------------
388 // fail
389 // ------------------------------------------------------------------------
390
391 public void testFail() {
392
393 final boolean[] crFlags = new boolean[4];
394 TmfCoalescedDataRequest<TmfEvent> request = setupTestRequest(crFlags);
395 TmfDataRequest<TmfEvent> subRequest1 = new TmfDataRequestStub<TmfEvent>(TmfEvent.class, 10, 100, 200);
396 TmfDataRequest<TmfEvent> subRequest2 = new TmfDataRequestStub<TmfEvent>(TmfEvent.class, 10, 100, 200);
397 request.addRequest(subRequest1);
398 request.addRequest(subRequest2);
399
400 request.fail();
401
402 // Validate the coalescing request
403 assertTrue ("isCompleted", request.isCompleted());
404 assertTrue ("isFailed", request.isFailed());
405 assertFalse("isCancelled", request.isCancelled());
406
407 assertTrue ("handleCompleted", crFlags[0]);
408 assertFalse("handleSuccess", crFlags[1]);
409 assertTrue ("handleFailure", crFlags[2]);
410 assertFalse("handleCancel", crFlags[3]);
411
412 // Validate the first coalesced request
413 assertTrue ("isCompleted", subRequest1.isCompleted());
414 assertTrue ("isFailed", subRequest1.isFailed());
415 assertFalse("isCancelled", subRequest1.isCancelled());
416
417 // Validate the second coalesced request
418 assertTrue ("isCompleted", subRequest2.isCompleted());
419 assertTrue ("isFailed", subRequest2.isFailed());
420 assertFalse("isCancelled", subRequest2.isCancelled());
421 }
422
423 // ------------------------------------------------------------------------
424 // cancel
425 // ------------------------------------------------------------------------
426
427 public void testCancel() {
428
429 final boolean[] crFlags = new boolean[4];
430 TmfCoalescedDataRequest<TmfEvent> request = setupTestRequest(crFlags);
431 TmfDataRequest<TmfEvent> subRequest1 = new TmfDataRequestStub<TmfEvent>(TmfEvent.class, 10, 100, 200);
432 TmfDataRequest<TmfEvent> subRequest2 = new TmfDataRequestStub<TmfEvent>(TmfEvent.class, 10, 100, 200);
433 request.addRequest(subRequest1);
434 request.addRequest(subRequest2);
435
436 request.cancel();
437
438 // Validate the coalescing request
439 assertTrue ("isCompleted", request.isCompleted());
440 assertFalse("isFailed", request.isFailed());
441 assertTrue ("isCancelled", request.isCancelled());
442
443 assertTrue ("handleCompleted", crFlags[0]);
444 assertFalse("handleSuccess", crFlags[1]);
445 assertFalse("handleFailure", crFlags[2]);
446 assertTrue ("handleCancel", crFlags[3]);
447
448 // Validate the first coalesced request
449 assertTrue ("isCompleted", subRequest1.isCompleted());
450 assertFalse("isFailed", subRequest1.isFailed());
451 assertTrue ("isCancelled", subRequest1.isCancelled());
452
453 // Validate the second coalesced request
454 assertTrue ("isCompleted", subRequest2.isCompleted());
455 assertFalse("isFailed", subRequest2.isFailed());
456 assertTrue ("isCancelled", subRequest2.isCancelled());
457 }
458
c1c69938
FC		 459
460 // ------------------------------------------------------------------------
461 // cancel sub-requests
462 // ------------------------------------------------------------------------
463
464 public void testCancelSubRequests() {
465
466 final boolean[] crFlags = new boolean[4];
467 TmfCoalescedDataRequest<TmfEvent> request = setupTestRequest(crFlags);
468 TmfDataRequest<TmfEvent> subRequest1 = new TmfDataRequestStub<TmfEvent>(TmfEvent.class, 10, 100, 200);
469 TmfDataRequest<TmfEvent> subRequest2 = new TmfDataRequestStub<TmfEvent>(TmfEvent.class, 10, 100, 200);
470 request.addRequest(subRequest1);
471 request.addRequest(subRequest2);
472
473 subRequest1.cancel();
474
475 // Validate the first coalesced request
476 assertTrue ("isCompleted", subRequest1.isCompleted());
477 assertFalse("isFailed", subRequest1.isFailed());
478 assertTrue ("isCancelled", subRequest1.isCancelled());
479
480 // Validate the coalescing request
481 assertFalse("isCompleted", request.isCompleted());
482 assertFalse("isFailed", request.isFailed());
483 assertFalse("isCancelled", request.isCancelled());
484
485 // Cancel second sub-request
486 subRequest2.cancel();
487
488 // Validate the second coalesced request
489 assertTrue ("isCompleted", subRequest2.isCompleted());
490 assertFalse("isFailed", subRequest2.isFailed());
491 assertTrue ("isCancelled", subRequest2.isCancelled());
492
493 // Validate the coalescing request
494 assertTrue ("isCompleted", request.isCompleted());
495 assertFalse("isFailed", request.isFailed());
496 assertTrue ("isCancelled", request.isCancelled());
497
498 // Finalize coalescing request -
499 // Note: No need to check "request.isCancelled()" since it was verified above
500 request.cancel();
501
502 assertTrue ("handleCompleted", crFlags[0]);
503 assertFalse("handleSuccess", crFlags[1]);
504 assertFalse("handleFailure", crFlags[2]);
505 assertTrue ("handleCancel", crFlags[3]);
506 }
507
2fb2eb37
FC		 508 // ------------------------------------------------------------------------
509 // waitForCompletion
510 // ------------------------------------------------------------------------
511
d18dd09b 512}
Tracecompass - Deliverables
This page took 0.072972 seconds and 5 git commands to generate.