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