Commit | Line | Data |
---|---|---|
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 | 13 | package org.eclipse.linuxtools.tmf.core.tests.request; |
d18dd09b ASL |
14 | |
15 | import java.io.File; | |
16 | import java.io.IOException; | |
17 | import java.net.URISyntaxException; | |
18 | import java.net.URL; | |
19 | import java.util.Vector; | |
20 | ||
21 | import junit.framework.TestCase; | |
22 | ||
23 | import org.eclipse.core.runtime.FileLocator; | |
24 | import org.eclipse.core.runtime.Path; | |
8fd82db5 FC |
25 | import org.eclipse.linuxtools.internal.tmf.core.component.TmfProviderManager; |
26 | import org.eclipse.linuxtools.internal.tmf.core.request.TmfCoalescedDataRequest; | |
27 | import org.eclipse.linuxtools.internal.tmf.core.request.TmfCoalescedEventRequest; | |
6c13869b | 28 | import org.eclipse.linuxtools.tmf.core.component.ITmfDataProvider; |
6c13869b FC |
29 | import org.eclipse.linuxtools.tmf.core.event.TmfEvent; |
30 | import org.eclipse.linuxtools.tmf.core.event.TmfTimeRange; | |
31 | import org.eclipse.linuxtools.tmf.core.event.TmfTimestamp; | |
b4f71e4a | 32 | import org.eclipse.linuxtools.tmf.core.exceptions.TmfTraceException; |
923b8517 | 33 | import org.eclipse.linuxtools.tmf.core.request.ITmfDataRequest.ExecutionType; |
6c13869b FC |
34 | import org.eclipse.linuxtools.tmf.core.request.TmfEventRequest; |
35 | import org.eclipse.linuxtools.tmf.core.signal.TmfSignal; | |
36 | import org.eclipse.linuxtools.tmf.core.signal.TmfSignalHandler; | |
37 | import org.eclipse.linuxtools.tmf.core.signal.TmfSignalManager; | |
38 | import org.eclipse.linuxtools.tmf.core.tests.TmfCoreTestPlugin; | |
4918b8f2 FC |
39 | import org.eclipse.linuxtools.tmf.tests.stubs.request.TmfEventRequestStub; |
40 | import 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 | */ |
2d223a34 | 47 | @SuppressWarnings({ "nls" }) |
d18dd09b ASL |
48 | public 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 | } |