projects / deliverable / tracecompass.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
Add copyright header.
[deliverable/tracecompass.git] / org.eclipse.linuxtools.tmf.core.tests / src / org / eclipse / linuxtools / tmf / core / tests / request / TmfCoalescedEventRequestTest.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
15import java.io.File;
16import java.io.IOException;
17import java.net.URISyntaxException;
18import java.net.URL;
19import java.util.Vector;
20
21import junit.framework.TestCase;
22
23import org.eclipse.core.runtime.FileLocator;
24import org.eclipse.core.runtime.Path;
6c13869b
FC		 25import org.eclipse.linuxtools.tmf.core.component.ITmfDataProvider;
26import org.eclipse.linuxtools.tmf.core.component.TmfProviderManager;
27import org.eclipse.linuxtools.tmf.core.event.TmfEvent;
28import org.eclipse.linuxtools.tmf.core.event.TmfTimeRange;
29import org.eclipse.linuxtools.tmf.core.event.TmfTimestamp;
b4f71e4a 30import org.eclipse.linuxtools.tmf.core.exceptions.TmfTraceException;
923b8517 31import org.eclipse.linuxtools.tmf.core.request.ITmfDataRequest.ExecutionType;
6c13869b
FC		 32import org.eclipse.linuxtools.tmf.core.request.TmfCoalescedDataRequest;
33import org.eclipse.linuxtools.tmf.core.request.TmfCoalescedEventRequest;
34import org.eclipse.linuxtools.tmf.core.request.TmfEventRequest;
35import org.eclipse.linuxtools.tmf.core.signal.TmfSignal;
36import org.eclipse.linuxtools.tmf.core.signal.TmfSignalHandler;
37import org.eclipse.linuxtools.tmf.core.signal.TmfSignalManager;
38import org.eclipse.linuxtools.tmf.core.tests.TmfCoreTestPlugin;
4918b8f2
FC		 39import org.eclipse.linuxtools.tmf.tests.stubs.request.TmfEventRequestStub;
40import org.eclipse.linuxtools.tmf.tests.stubs.trace.TmfTraceStub;
d18dd09b
ASL		 41
42/**
43 * <b><u>TmfCoalescedEventRequestTest</u></b>
44 * <p>
2fb2eb37 45 * Test suite for the TmfCoalescedEventRequest class.
d18dd09b 46 */
3b38ea61 47@SuppressWarnings("nls")
d18dd09b
ASL		 48public class TmfCoalescedEventRequestTest extends TestCase {
49
2fb2eb37
FC		 50 // ------------------------------------------------------------------------
51 // Variables
52 // ------------------------------------------------------------------------
d18dd09b 53
a4115405
FC		 54 private TmfTimeRange range1 = new TmfTimeRange(TmfTimeRange.ETERNITY);
55 private TmfTimeRange range2 = new TmfTimeRange(new TmfTimestamp(), TmfTimestamp.BIG_CRUNCH);
2fb2eb37 56
6e85c58d
FC		 57 private TmfCoalescedEventRequest<TmfEvent> fRequest1;
58 private TmfCoalescedEventRequest<TmfEvent> fRequest2;
59 private TmfCoalescedEventRequest<TmfEvent> fRequest3;
60 private TmfCoalescedEventRequest<TmfEvent> fRequest4;
d18dd09b 61
6e85c58d
FC		 62 private TmfCoalescedEventRequest<TmfEvent> fRequest1b;
63 private TmfCoalescedEventRequest<TmfEvent> fRequest1c;
d18dd09b 64
6e85c58d 65 private int fRequestCount;
2fb2eb37
FC		 66
67 // ------------------------------------------------------------------------
d18dd09b
ASL		 68 // Housekeeping
69 // ------------------------------------------------------------------------
70
71 public TmfCoalescedEventRequestTest(String name) {
72 super(name);
73 }
74
75 @Override
76 public void setUp() throws Exception {
77 super.setUp();
2fb2eb37
FC		 78 TmfEventRequest.reset();
79 fRequest1 = new TmfCoalescedEventRequest<TmfEvent>(TmfEvent.class, range1, 100, 200);
80 fRequest2 = new TmfCoalescedEventRequest<TmfEvent>(TmfEvent.class, range2, 100, 200);
81 fRequest3 = new TmfCoalescedEventRequest<TmfEvent>(TmfEvent.class, range2, 200, 200);
82 fRequest4 = new TmfCoalescedEventRequest<TmfEvent>(TmfEvent.class, range2, 200, 300);
83
84 fRequest1b = new TmfCoalescedEventRequest<TmfEvent>(TmfEvent.class, range1, 100, 200);
85 fRequest1c = new TmfCoalescedEventRequest<TmfEvent>(TmfEvent.class, range1, 100, 200);
86
87 fRequestCount = fRequest1c.getRequestId() + 1;
d18dd09b
ASL		 88 }
89
90 @Override
91 public void tearDown() throws Exception {
92 super.tearDown();
93 }
94
2fb2eb37
FC		 95 private TmfCoalescedEventRequest<TmfEvent> setupTestRequest(final boolean[] flags) {
96
97 TmfCoalescedEventRequest<TmfEvent> request = new TmfCoalescedEventRequest<TmfEvent>(TmfEvent.class, range1, 100, 200) {
98 @Override
99 public void handleCompleted() {
100 super.handleCompleted();
101 flags[0] = true;
102 }
103 @Override
104 public void handleSuccess() {
105 super.handleSuccess();
106 flags[1] = true;
107 }
108 @Override
109 public void handleFailure() {
110 super.handleFailure();
111 flags[2] = true;
112 }
113 @Override
114 public void handleCancel() {
115 super.handleCancel();
116 flags[3] = true;
117 }
118 };
119 return request;
120 }
121
d18dd09b
ASL		 122 // ------------------------------------------------------------------------
123 // Constructors
124 // ------------------------------------------------------------------------
125
126 public void testTmfCoalescedEventRequest() {
2fb2eb37 127 TmfCoalescedEventRequest<TmfEvent> request = new TmfCoalescedEventRequest<TmfEvent>(TmfEvent.class);
d18dd09b 128
2fb2eb37
FC		 129 assertEquals("getRequestId", fRequestCount++, request.getRequestId());
130 assertEquals("getDataType", TmfEvent.class, request.getDataType());
d18dd09b 131
2fb2eb37
FC		 132 assertEquals("getRange", range1, request.getRange());
133 assertEquals("getNbRequestedEvents", TmfEventRequest.ALL_DATA, request.getNbRequested());
2fb2eb37
FC		 134
135 assertFalse("isCompleted", request.isCompleted());
136 assertFalse("isFailed", request.isFailed());
137 assertFalse("isCancelled", request.isCancelled());
138
139 assertEquals("getNbRead", 0, request.getNbRead());
d18dd09b
ASL		 140 }
141
2fb2eb37
FC		 142 public void testTmfCoalescedEventRequestIndex() {
143 TmfCoalescedEventRequest<TmfEvent> request = new TmfCoalescedEventRequest<TmfEvent>(TmfEvent.class, range1);
144
145 assertEquals("getRequestId", fRequestCount++, request.getRequestId());
146 assertEquals("getDataType", TmfEvent.class, request.getDataType());
147
148 assertEquals("getRange", range1, request.getRange());
149 assertEquals("getNbRequestedEvents", TmfEventRequest.ALL_DATA, request.getNbRequested());
d18dd09b 150
2fb2eb37
FC		 151 assertFalse("isCompleted", request.isCompleted());
152 assertFalse("isFailed", request.isFailed());
153 assertFalse("isCancelled", request.isCancelled());
d18dd09b 154
2fb2eb37 155 assertEquals("getNbRead", 0, request.getNbRead());
d18dd09b
ASL		 156 }
157
2fb2eb37
FC		 158 public void testTmfCoalescedEventRequestIndexNbRequested() {
159 TmfCoalescedEventRequest<TmfEvent> request = new TmfCoalescedEventRequest<TmfEvent>(TmfEvent.class, range1, 100);
d18dd09b 160
2fb2eb37
FC		 161 assertEquals("getRequestId", fRequestCount++, request.getRequestId());
162 assertEquals("getDataType", TmfEvent.class, request.getDataType());
d18dd09b 163
2fb2eb37 164 assertEquals("getRange", range1, request.getRange());
d18dd09b 165 assertEquals("getNbRequestedEvents", 100, request.getNbRequested());
2fb2eb37
FC		 166
167 assertFalse("isCompleted", request.isCompleted());
168 assertFalse("isFailed", request.isFailed());
169 assertFalse("isCancelled", request.isCancelled());
170
171 assertEquals("getNbRead", 0, request.getNbRead());
d18dd09b
ASL		 172 }
173
2fb2eb37
FC		 174 public void testTmfCoalescedEventRequestIndexNbEventsBlocksize() {
175 TmfCoalescedEventRequest<TmfEvent> request = new TmfCoalescedEventRequest<TmfEvent>(TmfEvent.class, range1, 100, 200);
d18dd09b 176
2fb2eb37
FC		 177 assertEquals("getRequestId", fRequestCount++, request.getRequestId());
178 assertEquals("getDataType", TmfEvent.class, request.getDataType());
d18dd09b 179
2fb2eb37 180 assertEquals("getRange", range1, request.getRange());
d18dd09b 181 assertEquals("getNbRequestedEvents", 100, request.getNbRequested());
2fb2eb37
FC		 182
183 assertFalse("isCompleted", request.isCompleted());
184 assertFalse("isFailed", request.isFailed());
185 assertFalse("isCancelled", request.isCancelled());
186
187 assertEquals("getNbRead", 0, request.getNbRead());
188 }
189
190 // ------------------------------------------------------------------------
191 // equals
192 // ------------------------------------------------------------------------
193
194 public void testEqualsReflexivity() throws Exception {
195 assertTrue("equals", fRequest1.equals(fRequest1));
196 assertTrue("equals", fRequest2.equals(fRequest2));
197
198 assertFalse("equals", fRequest1.equals(fRequest2));
199 assertFalse("equals", fRequest2.equals(fRequest1));
200 }
201
202 public void testEqualsSymmetry() throws Exception {
203 assertTrue("equals", fRequest1.equals(fRequest1b));
204 assertTrue("equals", fRequest1b.equals(fRequest1));
205
206 assertFalse("equals", fRequest1.equals(fRequest3));
207 assertFalse("equals", fRequest2.equals(fRequest3));
208 assertFalse("equals", fRequest3.equals(fRequest1));
209 assertFalse("equals", fRequest3.equals(fRequest2));
210 }
211
212 public void testEqualsTransivity() throws Exception {
213 assertTrue("equals", fRequest1.equals(fRequest1b));
214 assertTrue("equals", fRequest1b.equals(fRequest1c));
215 assertTrue("equals", fRequest1.equals(fRequest1c));
216 }
217
2fb2eb37
FC		 218 public void testEqualsNull() throws Exception {
219 assertFalse("equals", fRequest1.equals(null));
220 assertFalse("equals", fRequest2.equals(null));
221 }
222
223 public void testEqualsSuper() throws Exception {
224 TmfCoalescedDataRequest<TmfEvent> dataRequest1 = new TmfCoalescedDataRequest<TmfEvent>(
f9673903 225 fRequest1.getDataType(), fRequest1.getIndex(), fRequest1.getNbRequested());
2fb2eb37 226 TmfCoalescedDataRequest<TmfEvent> dataRequest2 = new TmfCoalescedDataRequest<TmfEvent>(
f9673903 227 fRequest1.getDataType(), fRequest1.getIndex(), fRequest1.getNbRequested());
2fb2eb37 228 TmfCoalescedDataRequest<TmfEvent> dataRequest3 = new TmfCoalescedDataRequest<TmfEvent>(
f9673903 229 fRequest3.getDataType(), fRequest3.getIndex(), fRequest3.getNbRequested());
2fb2eb37
FC		 230
231 assertTrue("equals", fRequest1.equals(dataRequest2));
232 assertTrue("equals", fRequest2.equals(dataRequest1));
233 assertFalse("equals", fRequest1.equals(dataRequest3));
234 assertFalse("equals", fRequest3.equals(dataRequest1));
235 }
236
237 // ------------------------------------------------------------------------
238 // hashCode
239 // ------------------------------------------------------------------------
240
241 public void testHashCode() throws Exception {
242 assertTrue("hashCode", fRequest1.hashCode() == fRequest1.hashCode());
243 assertTrue("hashCode", fRequest2.hashCode() == fRequest2.hashCode());
244 assertTrue("hashCode", fRequest1.hashCode() != fRequest2.hashCode());
245 }
246
247 // ------------------------------------------------------------------------
248 // toString
249 // ------------------------------------------------------------------------
250
251 public void testToString() {
a79913eb
FC		 252 String expected1 = "[TmfCoalescedEventRequest(0,TmfEvent," + range1 + ",0,100,200)]";
253 String expected2 = "[TmfCoalescedEventRequest(1,TmfEvent," + range2 + ",0,100,200)]";
254 String expected3 = "[TmfCoalescedEventRequest(2,TmfEvent," + range2 + ",0,200,200)]";
255 String expected4 = "[TmfCoalescedEventRequest(3,TmfEvent," + range2 + ",0,200,300)]";
2fb2eb37
FC		 256
257 assertEquals("toString", expected1, fRequest1.toString());
258 assertEquals("toString", expected2, fRequest2.toString());
259 assertEquals("toString", expected3, fRequest3.toString());
260 assertEquals("toString", expected4, fRequest4.toString());
d18dd09b
ASL		 261 }
262
263 // ------------------------------------------------------------------------
264 // isCompatible
265 // ------------------------------------------------------------------------
266
267 public void testIsCompatible() {
2fb2eb37
FC		 268 TmfCoalescedEventRequest<TmfEvent> coalescedRequest = new TmfCoalescedEventRequest<TmfEvent>(TmfEvent.class, range1, 100, 200);
269 TmfEventRequest<TmfEvent> request1 = new TmfEventRequestStub<TmfEvent>(TmfEvent.class, range1, 100, 200);
cb866e08
FC		 270 TmfEventRequest<TmfEvent> request2 = new TmfEventRequestStub<TmfEvent>(TmfEvent.class, range2, 100, 200);
271 TmfEventRequest<TmfEvent> request3 = new TmfEventRequestStub<TmfEvent>(TmfEvent.class, range1, 101, 200);
d18dd09b 272
923b8517
FC		 273 assertTrue("isCompatible", coalescedRequest.isCompatible(request1));
274 assertTrue("isCompatible", coalescedRequest.isCompatible(request2));
275 assertTrue("isCompatible", coalescedRequest.isCompatible(request3));
2fb2eb37
FC		 276 }
277
923b8517
FC		 278 // ------------------------------------------------------------------------
279 // addEvent
280 // ------------------------------------------------------------------------
281
282 public void testAddEvent1() {
283 TmfCoalescedEventRequest<TmfEvent> coalescedRequest = new TmfCoalescedEventRequest<TmfEvent>(TmfEvent.class, range1, 0, 2147483647, 200, ExecutionType.FOREGROUND);
284 TmfEventRequest<TmfEvent> request1 = new TmfEventRequestStub<TmfEvent>(TmfEvent.class, range1, 0, 2147483647, 200);
285 TmfEventRequest<TmfEvent> request2 = new TmfEventRequestStub<TmfEvent>(TmfEvent.class, range1, 1, 2147483647, 200);
286
287 assertTrue("isCompatible", coalescedRequest.isCompatible(request1));
288 assertTrue("isCompatible", coalescedRequest.isCompatible(request2));
289
290 coalescedRequest.addRequest(request1);
291 coalescedRequest.addRequest(request2);
292
293 assertEquals("addRequest", 0, coalescedRequest.getIndex());
294 assertEquals("addRequest", 2147483647, coalescedRequest.getNbRequested());
295 assertEquals("addRequest", 200, coalescedRequest.getBlockSize());
296
297 }
298
299 public void testAddEvent2() {
300 TmfCoalescedEventRequest<TmfEvent> coalescedRequest = new TmfCoalescedEventRequest<TmfEvent>(TmfEvent.class, range1, 1, 2147483647, 200, ExecutionType.FOREGROUND);
301 TmfEventRequest<TmfEvent> request1 = new TmfEventRequestStub<TmfEvent>(TmfEvent.class, range1, 1, 2147483647, 200);
302 TmfEventRequest<TmfEvent> request2 = new TmfEventRequestStub<TmfEvent>(TmfEvent.class, range1, 0, 2147483647, 200);
303
304 assertTrue("isCompatible", coalescedRequest.isCompatible(request1));
305 assertTrue("isCompatible", coalescedRequest.isCompatible(request2));
306
307 coalescedRequest.addRequest(request1);
308 coalescedRequest.addRequest(request2);
309
310 assertEquals("addRequest", 0, coalescedRequest.getIndex());
311 assertEquals("addRequest", 2147483647, coalescedRequest.getNbRequested());
312 assertEquals("addRequest", 200, coalescedRequest.getBlockSize());
313
314 }
315
2fb2eb37
FC		 316 // ------------------------------------------------------------------------
317 // done
318 // ------------------------------------------------------------------------
319
320 public void testDone() {
321
322 // Test request
323 final boolean[] crFlags = new boolean[4];
324 TmfCoalescedEventRequest<TmfEvent> request = setupTestRequest(crFlags);
325 TmfEventRequest<TmfEvent> subRequest1 = new TmfEventRequestStub<TmfEvent>(TmfEvent.class, range1, 100, 200);
326 TmfEventRequest<TmfEvent> subRequest2 = new TmfEventRequestStub<TmfEvent>(TmfEvent.class, range1, 100, 200);
327 request.addRequest(subRequest1);
328 request.addRequest(subRequest2);
329
330 request.done();
331
332 // Validate the coalescing request
333 assertTrue ("isCompleted", request.isCompleted());
334 assertFalse("isFailed", request.isFailed());
335 assertFalse("isCancelled", request.isCancelled());
336
337 assertTrue ("handleCompleted", crFlags[0]);
338 assertTrue ("handleSuccess", crFlags[1]);
339 assertFalse("handleFailure", crFlags[2]);
340 assertFalse("handleCancel", crFlags[3]);
341
342 // Validate the first coalesced request
343 assertTrue ("isCompleted", subRequest1.isCompleted());
344 assertFalse("isFailed", subRequest1.isFailed());
345 assertFalse("isCancelled", subRequest1.isCancelled());
346
347 // Validate the second coalesced request
348 assertTrue ("isCompleted", subRequest2.isCompleted());
349 assertFalse("isFailed", subRequest2.isFailed());
350 assertFalse("isCancelled", subRequest2.isCancelled());
351 }
352
353 // ------------------------------------------------------------------------
354 // fail
355 // ------------------------------------------------------------------------
356
357 public void testFail() {
358
359 final boolean[] crFlags = new boolean[4];
360 TmfCoalescedEventRequest<TmfEvent> request = setupTestRequest(crFlags);
361 TmfEventRequest<TmfEvent> subRequest1 = new TmfEventRequestStub<TmfEvent>(TmfEvent.class, range1, 100, 200);
362 TmfEventRequest<TmfEvent> subRequest2 = new TmfEventRequestStub<TmfEvent>(TmfEvent.class, range1, 100, 200);
363 request.addRequest(subRequest1);
364 request.addRequest(subRequest2);
365
366 request.fail();
367
368 // Validate the coalescing request
369 assertTrue ("isCompleted", request.isCompleted());
370 assertTrue ("isFailed", request.isFailed());
371 assertFalse("isCancelled", request.isCancelled());
372
373 assertTrue ("handleCompleted", crFlags[0]);
374 assertFalse("handleSuccess", crFlags[1]);
375 assertTrue ("handleFailure", crFlags[2]);
376 assertFalse("handleCancel", crFlags[3]);
377
378 // Validate the first coalesced request
379 assertTrue ("isCompleted", subRequest1.isCompleted());
380 assertTrue ("isFailed", subRequest1.isFailed());
381 assertFalse("isCancelled", subRequest1.isCancelled());
382
383 // Validate the second coalesced request
384 assertTrue ("isCompleted", subRequest2.isCompleted());
385 assertTrue ("isFailed", subRequest2.isFailed());
386 assertFalse("isCancelled", subRequest2.isCancelled());
387 }
388
389 // ------------------------------------------------------------------------
390 // cancel
391 // ------------------------------------------------------------------------
392
393 public void testCancel() {
394
395 final boolean[] crFlags = new boolean[4];
396 TmfCoalescedEventRequest<TmfEvent> request = setupTestRequest(crFlags);
397 TmfEventRequest<TmfEvent> subRequest1 = new TmfEventRequestStub<TmfEvent>(TmfEvent.class, range1, 100, 200);
398 TmfEventRequest<TmfEvent> subRequest2 = new TmfEventRequestStub<TmfEvent>(TmfEvent.class, range1, 100, 200);
399 request.addRequest(subRequest1);
400 request.addRequest(subRequest2);
401
402 request.cancel();
403
404 // Validate the coalescing request
405 assertTrue ("isCompleted", request.isCompleted());
406 assertFalse("isFailed", request.isFailed());
407 assertTrue ("isCancelled", request.isCancelled());
408
409 assertTrue ("handleCompleted", crFlags[0]);
410 assertFalse("handleSuccess", crFlags[1]);
411 assertFalse("handleFailure", crFlags[2]);
412 assertTrue ("handleCancel", crFlags[3]);
413
414 // Validate the first coalesced request
415 assertTrue ("isCompleted", subRequest1.isCompleted());
416 assertFalse("isFailed", subRequest1.isFailed());
417 assertTrue ("isCancelled", subRequest1.isCancelled());
418
419 // Validate the second coalesced request
420 assertTrue ("isCompleted", subRequest2.isCompleted());
421 assertFalse("isFailed", subRequest2.isFailed());
422 assertTrue ("isCancelled", subRequest2.isCancelled());
423 }
424
425 // ------------------------------------------------------------------------
426 // waitForCompletion
427 // ------------------------------------------------------------------------
428
d18dd09b
ASL		 429 // ------------------------------------------------------------------------
430 // Coalescing
431 // ------------------------------------------------------------------------
432
2fb2eb37
FC		 433 private static final String DIRECTORY = "testfiles";
434 private static final String TEST_STREAM = "A-Test-10K";
435 private static final int NB_EVENTS = 10000;
436 private static final int BLOCK_SIZE = 100;
437
438 // Initialize the test trace
6e85c58d 439 private TmfTraceStub fTrace = null;
ff4ed569 440 private synchronized TmfTraceStub setupTrace(String path) {
2fb2eb37
FC		 441 if (fTrace == null) {
442 try {
443 URL location = FileLocator.find(TmfCoreTestPlugin.getDefault().getBundle(), new Path(path), null);
0875b696 444 File test = new File(FileLocator.toFileURL(location).toURI());
ff4ed569 445 fTrace = new TmfTraceStub(test.getPath(), 500);
b4f71e4a 446 } catch (TmfTraceException e) {
2fb2eb37 447 e.printStackTrace();
b4f71e4a
FC		 448 } catch (URISyntaxException e) {
449 e.printStackTrace();
2fb2eb37
FC		 450 } catch (IOException e) {
451 e.printStackTrace();
452 }
453 }
454 return fTrace;
455 }
456
d18dd09b
ASL		 457 Vector<TmfEvent> requestedEvents1;
458 Vector<TmfEvent> requestedEvents2;
459 Vector<TmfEvent> requestedEvents3;
460
461 TmfEventRequest<TmfEvent> request1;
462 TmfEventRequest<TmfEvent> request2;
463 TmfEventRequest<TmfEvent> request3;
464
2fb2eb37
FC		 465 ITmfDataProvider<TmfEvent>[] providers;
466
6e85c58d 467 private static class TmfTestTriggerSignal extends TmfSignal {
d18dd09b
ASL		 468 public final boolean forceCancel;
469 public TmfTestTriggerSignal(Object source, boolean cancel) {
470 super(source);
471 forceCancel = cancel;
2fb2eb37 472
d18dd09b
ASL		 473 }
474 }
475
476 @SuppressWarnings("unchecked")
477 @TmfSignalHandler
478 public void trigger(final TmfTestTriggerSignal signal) {
479
a4115405 480 TmfTimeRange range = new TmfTimeRange(TmfTimestamp.BIG_BANG, TmfTimestamp.BIG_CRUNCH);
d18dd09b
ASL		 481
482 requestedEvents1 = new Vector<TmfEvent>();
483 request1 = new TmfEventRequest<TmfEvent>(TmfEvent.class, range, NB_EVENTS, BLOCK_SIZE) {
f9673903 484 int nbRead = 0;
d18dd09b 485 @Override
f9673903
FC		 486 public void handleData(TmfEvent event) {
487 super.handleData(event);
d18dd09b 488 if (!isCompleted()) {
f9673903
FC		 489 requestedEvents1.add(event);
490 if (++nbRead >= BLOCK_SIZE && signal.forceCancel)
d18dd09b
ASL		 491 cancel();
492 }
493 }
494 };
495
496 requestedEvents2 = new Vector<TmfEvent>();
497 request2 = new TmfEventRequest<TmfEvent>(TmfEvent.class, range, NB_EVENTS, BLOCK_SIZE) {
498 @Override
f9673903
FC		 499 public void handleData(TmfEvent event) {
500 super.handleData(event);
d18dd09b 501 if (!isCompleted()) {
f9673903 502 requestedEvents2.add(event);
d18dd09b
ASL		 503 }
504 }
505 };
506
507 requestedEvents3 = new Vector<TmfEvent>();
508 request3 = new TmfEventRequest<TmfEvent>(TmfEvent.class, range, NB_EVENTS, BLOCK_SIZE) {
509 @Override
f9673903
FC		 510 public void handleData(TmfEvent event) {
511 super.handleData(event);
d18dd09b 512 if (!isCompleted()) {
f9673903 513 requestedEvents3.add(event);
d18dd09b
ASL		 514 }
515 }
516 };
517
2fb2eb37 518 providers = (ITmfDataProvider<TmfEvent>[]) TmfProviderManager.getProviders(TmfEvent.class, TmfTraceStub.class);
d18dd09b
ASL		 519 providers[0].sendRequest(request1);
520 providers[0].sendRequest(request2);
521 providers[0].sendRequest(request3);
522 }
523
cb866e08
FC		 524 public void testCoalescedRequest() throws Exception {
525
526 fTrace = setupTrace(DIRECTORY + File.separator + TEST_STREAM);
527
528 TmfSignalManager.register(this);
529 TmfTestTriggerSignal signal = new TmfTestTriggerSignal(this, false);
530 TmfSignalManager.dispatchSignal(signal);
531
532 request1.waitForCompletion();
533 request2.waitForCompletion();
534 request3.waitForCompletion();
535
536 assertEquals("Request1: nbEvents", NB_EVENTS, requestedEvents1.size());
537 assertTrue ("Request1: isCompleted", request1.isCompleted());
538 assertFalse ("Request1: isCancelled", request1.isCancelled());
539
540 assertEquals("Request2: nbEvents", NB_EVENTS, requestedEvents2.size());
541 assertTrue ("Request2: isCompleted", request2.isCompleted());
542 assertFalse ("Request2: isCancelled", request2.isCancelled());
543
544 assertEquals("Request3: nbEvents", NB_EVENTS, requestedEvents3.size());
545 assertTrue ("Request3: isCompleted", request3.isCompleted());
546 assertFalse ("Request3: isCancelled", request3.isCancelled());
547
548 // Ensure that we have distinct events.
549 // Don't go overboard: we are not validating the stub!
550 for (int i = 0; i < NB_EVENTS; i++) {
551 assertEquals("Distinct events", i+1, requestedEvents1.get(i).getTimestamp().getValue());
552 assertEquals("Distinct events", i+1, requestedEvents2.get(i).getTimestamp().getValue());
553 assertEquals("Distinct events", i+1, requestedEvents3.get(i).getTimestamp().getValue());
554 }
555
556 TmfSignalManager.deregister(this);
557 fTrace.dispose();
558 fTrace = null;
559 }
d18dd09b 560
cb866e08
FC		 561 public void testCancelCoalescedRequest() throws Exception {
562
563 fTrace = setupTrace(DIRECTORY + File.separator + TEST_STREAM);
564
565 TmfSignalManager.register(this);
566 TmfTestTriggerSignal signal = new TmfTestTriggerSignal(this, true);
567 TmfSignalManager.dispatchSignal(signal);
568
569 request1.waitForCompletion();
570 request2.waitForCompletion();
571 request3.waitForCompletion();
572
573 assertEquals("Request1: nbEvents", BLOCK_SIZE, requestedEvents1.size());
574 assertTrue ("Request1: isCompleted", request1.isCompleted());
575 assertTrue ("Request1: isCancelled", request1.isCancelled());
576
577 assertEquals("Request2: nbEvents", NB_EVENTS, requestedEvents2.size());
578 assertTrue ("Request2: isCompleted", request2.isCompleted());
579 assertFalse ("Request2: isCancelled", request2.isCancelled());
580
581 assertEquals("Request3: nbEvents", NB_EVENTS, requestedEvents3.size());
582 assertTrue ("Request3: isCompleted", request3.isCompleted());
583 assertFalse ("Request3: isCancelled", request3.isCancelled());
584
585 // Ensure that we have distinct events.
586 // Don't go overboard: we are not validating the stub!
587 for (int i = 0; i < NB_EVENTS; i++) {
588 assertEquals("Distinct events", i+1, requestedEvents2.get(i).getTimestamp().getValue());
589 assertEquals("Distinct events", i+1, requestedEvents3.get(i).getTimestamp().getValue());
590 }
591
592 TmfSignalManager.deregister(this);
593 fTrace.dispose();
594 fTrace = null;
595 }
d18dd09b
ASL		 596
597}
Tracecompass - Deliverables
This page took 0.065936 seconds and 5 git commands to generate.