Commit | Line | Data |
---|---|---|
d18dd09b | 1 | /******************************************************************************* |
61759503 | 2 | * Copyright (c) 2009, 2013 Ericsson |
9b749023 | 3 | * |
d18dd09b ASL |
4 | * All rights reserved. This program and the accompanying materials are |
5 | * made available under the terms of the Eclipse Public License v1.0 which | |
6 | * accompanies this distribution, and is available at | |
7 | * http://www.eclipse.org/legal/epl-v10.html | |
9b749023 | 8 | * |
d18dd09b ASL |
9 | * Contributors: |
10 | * Francois Chouinard - Initial API and implementation | |
6e1886bc | 11 | * Alexandre Montplaisir - Port to JUnit4 |
d18dd09b ASL |
12 | *******************************************************************************/ |
13 | ||
6c13869b | 14 | package org.eclipse.linuxtools.tmf.core.tests.component; |
d18dd09b | 15 | |
6e1886bc | 16 | import static org.junit.Assert.*; |
d18dd09b | 17 | |
6e1886bc AM |
18 | import java.io.IOException; |
19 | import java.util.Vector; | |
d18dd09b | 20 | |
8fd82db5 | 21 | import org.eclipse.linuxtools.internal.tmf.core.component.TmfProviderManager; |
5419a136 | 22 | import org.eclipse.linuxtools.tmf.core.component.ITmfDataProvider; |
6256d8ad | 23 | import org.eclipse.linuxtools.tmf.core.event.ITmfEvent; |
6c13869b | 24 | import org.eclipse.linuxtools.tmf.core.request.TmfEventRequest; |
7184fc40 | 25 | import org.eclipse.linuxtools.tmf.core.request.ITmfDataRequest.ExecutionType; |
6c13869b FC |
26 | import org.eclipse.linuxtools.tmf.core.signal.TmfEndSynchSignal; |
27 | import org.eclipse.linuxtools.tmf.core.signal.TmfStartSynchSignal; | |
3bd46eef AM |
28 | import org.eclipse.linuxtools.tmf.core.timestamp.TmfTimeRange; |
29 | import org.eclipse.linuxtools.tmf.core.timestamp.TmfTimestamp; | |
4918b8f2 FC |
30 | import org.eclipse.linuxtools.tmf.tests.stubs.component.TmfEventProviderStub; |
31 | import org.eclipse.linuxtools.tmf.tests.stubs.component.TmfSyntheticEventProviderStub; | |
32 | import org.eclipse.linuxtools.tmf.tests.stubs.event.TmfSyntheticEventStub; | |
33 | import org.eclipse.linuxtools.tmf.tests.stubs.trace.TmfTraceStub; | |
6e1886bc AM |
34 | import org.junit.After; |
35 | import org.junit.Before; | |
36 | import org.junit.Test; | |
d18dd09b ASL |
37 | |
38 | /** | |
ff4ed569 | 39 | * Test suite for the TmfEventProvider class. |
d18dd09b | 40 | */ |
6e1886bc | 41 | public class TmfEventProviderTest { |
d18dd09b | 42 | |
6e1886bc AM |
43 | private TmfEventProviderStub fEventProvider; |
44 | private TmfSyntheticEventProviderStub fSyntheticEventProvider; | |
d18dd09b | 45 | |
54a7a54c | 46 | /** |
6e1886bc AM |
47 | * Initialization |
48 | * | |
49 | * @throws IOException | |
50 | * If we can't find the test trace (they are committed in the | |
51 | * tree, so it shouldn't happen). | |
54a7a54c | 52 | */ |
6e1886bc AM |
53 | @Before |
54 | public void setUp() throws IOException { | |
cf21ffe2 FC |
55 | fEventProvider = new TmfEventProviderStub(); |
56 | fSyntheticEventProvider = new TmfSyntheticEventProviderStub(); | |
57 | } | |
d18dd09b | 58 | |
6e1886bc AM |
59 | /** |
60 | * Clean-up | |
61 | */ | |
62 | @After | |
63 | public void tearDown() { | |
cf21ffe2 FC |
64 | fEventProvider.dispose(); |
65 | fSyntheticEventProvider.dispose(); | |
66 | } | |
d18dd09b | 67 | |
cf21ffe2 FC |
68 | // ------------------------------------------------------------------------ |
69 | // getProviders (more a sanity check than a test) | |
70 | // ------------------------------------------------------------------------ | |
d18dd09b | 71 | |
54a7a54c | 72 | /** |
6e1886bc | 73 | * Test getProviders |
54a7a54c | 74 | */ |
6e1886bc | 75 | @Test |
cf21ffe2 | 76 | public void testGetProviders() { |
cf21ffe2 FC |
77 | // There should be 2 TmfEvent providers: a TmfTraceStub and a |
78 | // TmfEventProviderStub | |
2771b032 | 79 | ITmfDataProvider[] eventProviders = TmfProviderManager.getProviders(ITmfEvent.class); |
cf21ffe2 | 80 | assertEquals("getProviders", 2, eventProviders.length); |
d18dd09b | 81 | |
2771b032 | 82 | eventProviders = TmfProviderManager.getProviders(ITmfEvent.class, TmfTraceStub.class); |
cf21ffe2 | 83 | assertEquals("getProviders", 1, eventProviders.length); |
d18dd09b | 84 | |
2771b032 | 85 | eventProviders = TmfProviderManager.getProviders(ITmfEvent.class, TmfEventProviderStub.class); |
cf21ffe2 | 86 | assertEquals("getProviders", 1, eventProviders.length); |
d18dd09b | 87 | |
cf21ffe2 | 88 | // There should be 1 TmfSyntheticEventStub provider |
6256d8ad | 89 | eventProviders = TmfProviderManager.getProviders(TmfSyntheticEventStub.class); |
cf21ffe2 FC |
90 | assertEquals("getProviders", 1, eventProviders.length); |
91 | } | |
d18dd09b | 92 | |
cf21ffe2 FC |
93 | // ------------------------------------------------------------------------ |
94 | // getSyntheticEvent | |
95 | // ------------------------------------------------------------------------ | |
d18dd09b | 96 | |
54a7a54c | 97 | /** |
6e1886bc | 98 | * Test getPlainEvents |
54a7a54c | 99 | */ |
6e1886bc | 100 | @Test |
cf21ffe2 | 101 | public void testGetPlainEvents() { |
d18dd09b | 102 | final int BLOCK_SIZE = 100; |
cf21ffe2 | 103 | final int NB_EVENTS = 1000; |
6256d8ad | 104 | final Vector<ITmfEvent> requestedEvents = new Vector<ITmfEvent>(); |
d18dd09b ASL |
105 | |
106 | // Get the TmfSyntheticEventStub provider | |
2771b032 | 107 | ITmfDataProvider[] eventProviders = TmfProviderManager.getProviders(ITmfEvent.class, |
5419a136 AM |
108 | TmfEventProviderStub.class); |
109 | ITmfDataProvider provider = eventProviders[0]; | |
d18dd09b | 110 | |
a4115405 | 111 | TmfTimeRange range = new TmfTimeRange(TmfTimestamp.BIG_BANG, TmfTimestamp.BIG_CRUNCH); |
7184fc40 AM |
112 | final TmfEventRequest request = new TmfEventRequest(ITmfEvent.class, |
113 | range, 0, NB_EVENTS, BLOCK_SIZE, ExecutionType.FOREGROUND) { | |
cf21ffe2 | 114 | @Override |
6256d8ad | 115 | public void handleData(ITmfEvent event) { |
cf21ffe2 FC |
116 | super.handleData(event); |
117 | requestedEvents.add(event); | |
118 | } | |
f9673903 | 119 | }; |
cf21ffe2 | 120 | |
d18dd09b | 121 | provider.sendRequest(request); |
cb866e08 | 122 | try { |
cf21ffe2 FC |
123 | request.waitForCompletion(); |
124 | assertEquals("nbEvents", NB_EVENTS, requestedEvents.size()); | |
125 | assertTrue("isCompleted", request.isCompleted()); | |
126 | assertFalse("isCancelled", request.isCancelled()); | |
127 | ||
128 | // Make that we have distinct events. | |
129 | // Don't go overboard: we are not validating the stub! | |
130 | for (int i = 0; i < NB_EVENTS; i++) { | |
131 | assertEquals("Distinct events", i + 1, requestedEvents.get(i).getTimestamp().getValue()); | |
132 | } | |
133 | } catch (InterruptedException e) { | |
134 | fail(); | |
135 | } | |
136 | } | |
137 | ||
54a7a54c | 138 | /** |
6e1886bc | 139 | * Test canceling requests. |
54a7a54c | 140 | */ |
6e1886bc | 141 | @Test |
cf21ffe2 FC |
142 | public void testCancelRequests() { |
143 | ||
144 | final int BLOCK_SIZE = 100; | |
145 | final int NB_EVENTS = 1000; | |
146 | final int NUMBER_EVENTS_BEFORE_CANCEL_REQ1 = 10; | |
147 | final int NUMBER_EVENTS_BEFORE_CANCEL_REQ2 = 800; | |
148 | ||
6256d8ad AM |
149 | final Vector<ITmfEvent> requestedEventsReq1 = new Vector<ITmfEvent>(); |
150 | final Vector<ITmfEvent> requestedEventsReq2 = new Vector<ITmfEvent>(); | |
cf21ffe2 FC |
151 | |
152 | // Get the TmfSyntheticEventStub provider | |
2771b032 | 153 | ITmfDataProvider[] eventProviders = TmfProviderManager.getProviders(ITmfEvent.class, |
5419a136 AM |
154 | TmfEventProviderStub.class); |
155 | ITmfDataProvider provider = eventProviders[0]; | |
cf21ffe2 | 156 | |
a4115405 | 157 | TmfTimeRange range = new TmfTimeRange(TmfTimestamp.BIG_BANG, TmfTimestamp.BIG_CRUNCH); |
cf21ffe2 FC |
158 | |
159 | // Create first request | |
7184fc40 AM |
160 | final TmfEventRequest request1 = new TmfEventRequest(ITmfEvent.class, |
161 | range, 0, NB_EVENTS, BLOCK_SIZE, ExecutionType.FOREGROUND) { | |
cf21ffe2 | 162 | @Override |
6256d8ad | 163 | public void handleData(ITmfEvent event) { |
cf21ffe2 FC |
164 | super.handleData(event); |
165 | requestedEventsReq1.add(event); | |
166 | ||
167 | // cancel sub request | |
168 | if (getNbRead() == NUMBER_EVENTS_BEFORE_CANCEL_REQ1) { | |
169 | cancel(); | |
170 | } | |
171 | } | |
172 | }; | |
173 | ||
174 | // Synchronize requests | |
175 | ((TmfEventProviderStub) provider).startSynch(new TmfStartSynchSignal(0)); | |
176 | ||
177 | // Additionally, notify provider for up-coming requests | |
178 | provider.notifyPendingRequest(true); | |
179 | ||
180 | // Call sendRequest, which will create a coalescing request, but it | |
181 | // doesn't send request1 yet | |
182 | provider.sendRequest(request1); | |
183 | ||
184 | // Check if request1 is not running yet. | |
185 | assertFalse("isRunning", request1.isRunning()); | |
186 | ||
187 | // Create second request | |
7184fc40 AM |
188 | final TmfEventRequest request2 = new TmfEventRequest(ITmfEvent.class, |
189 | range, 0, NB_EVENTS, BLOCK_SIZE, ExecutionType.FOREGROUND) { | |
cf21ffe2 | 190 | @Override |
6256d8ad | 191 | public void handleData(ITmfEvent event) { |
cf21ffe2 | 192 | super.handleData(event); |
c1c69938 FC |
193 | requestedEventsReq2.add(event); |
194 | ||
195 | // cancel sub request which will cancel also main request | |
cf21ffe2 FC |
196 | if (getNbRead() == NUMBER_EVENTS_BEFORE_CANCEL_REQ2) { |
197 | cancel(); | |
198 | } | |
199 | } | |
200 | }; | |
c1c69938 | 201 | |
cf21ffe2 FC |
202 | // Call sendRequest, which will create a coalescing request, but it |
203 | // doesn't send request2 yet | |
c1c69938 FC |
204 | provider.sendRequest(request2); |
205 | ||
206 | // Check if request1/2 is not running yet. | |
cf21ffe2 FC |
207 | assertFalse("isRunning", request1.isRunning()); |
208 | assertFalse("isRunning", request2.isRunning()); | |
209 | ||
210 | // Send end synch signal, however requests won't be sent | |
c1c69938 FC |
211 | ((TmfEventProviderStub) provider).endSynch(new TmfEndSynchSignal(0)); |
212 | ||
213 | // Check if request1/2 is not running yet. | |
cf21ffe2 FC |
214 | assertFalse("isRunning", request1.isRunning()); |
215 | assertFalse("isRunning", request2.isRunning()); | |
c1c69938 | 216 | |
cf21ffe2 | 217 | // Finally, trigger sending of requests |
c1c69938 | 218 | provider.notifyPendingRequest(false); |
c1c69938 | 219 | |
cf21ffe2 FC |
220 | try { |
221 | ||
222 | // Wait until requests start | |
223 | request1.waitForStart(); | |
224 | request2.waitForStart(); | |
c1c69938 | 225 | |
cf21ffe2 FC |
226 | // // Verify that the requests are running |
227 | // assertTrue("isRunning", request1.isRunning()); | |
228 | // assertTrue("isRunning", request2.isRunning()); | |
c1c69938 | 229 | |
cf21ffe2 | 230 | request1.waitForCompletion(); |
c1c69938 | 231 | |
cf21ffe2 FC |
232 | // // Check if request2 is still running |
233 | // assertTrue("isRunning", request2.isRunning()); | |
234 | ||
235 | // Verify result (request1) | |
c1c69938 | 236 | assertEquals("nbEvents", NUMBER_EVENTS_BEFORE_CANCEL_REQ1, requestedEventsReq1.size()); |
cf21ffe2 FC |
237 | assertTrue("isCompleted", request1.isCompleted()); |
238 | assertTrue("isCancelled", request1.isCancelled()); | |
239 | ||
240 | request2.waitForCompletion(); | |
241 | ||
242 | // Verify result (request2) | |
243 | assertEquals("nbEvents", NUMBER_EVENTS_BEFORE_CANCEL_REQ2, requestedEventsReq2.size()); | |
244 | assertTrue("isCompleted", request2.isCompleted()); | |
245 | assertTrue("isCancelled", request2.isCancelled()); | |
246 | ||
247 | } catch (InterruptedException e) { | |
248 | fail(); | |
249 | } | |
250 | } | |
251 | ||
9b749023 AM |
252 | private static void getSyntheticData(final TmfTimeRange range, |
253 | final int nbEvents, final int blockSize) throws InterruptedException { | |
d18dd09b | 254 | |
6256d8ad | 255 | final Vector<ITmfEvent> requestedEvents = new Vector<ITmfEvent>(); |
d18dd09b ASL |
256 | |
257 | // Get the event provider | |
5419a136 AM |
258 | ITmfDataProvider[] eventProviders = TmfProviderManager |
259 | .getProviders(TmfSyntheticEventStub.class); | |
260 | ITmfDataProvider provider = eventProviders[0]; | |
cf21ffe2 | 261 | |
6256d8ad | 262 | final TmfEventRequest request = new TmfEventRequest(TmfSyntheticEventStub.class, range, |
7184fc40 | 263 | 0, nbEvents, blockSize, ExecutionType.FOREGROUND) { |
cf21ffe2 | 264 | @Override |
6256d8ad | 265 | public void handleData(ITmfEvent event) { |
cf21ffe2 FC |
266 | super.handleData(event); |
267 | requestedEvents.add(event); | |
268 | } | |
269 | }; | |
d18dd09b | 270 | provider.sendRequest(request); |
d18dd09b | 271 | |
cb866e08 | 272 | request.waitForCompletion(); |
9b749023 | 273 | if (nbEvents != -1) { |
cf21ffe2 | 274 | assertEquals("nbEvents", nbEvents, requestedEvents.size()); |
9b749023 | 275 | } |
cf21ffe2 FC |
276 | assertTrue("isCompleted", request.isCompleted()); |
277 | assertFalse("isCancelled", request.isCancelled()); | |
278 | ||
279 | // For each base event, the stub will queue 2 identical synthetic events | |
280 | // Ensure that the events are queued properly. | |
281 | // Don't go overboard: we are not validating the stub! | |
282 | for (int i = 0; i < (nbEvents / 2); i++) { | |
283 | assertEquals("Distinct events", i + 1, requestedEvents.get(2 * i + 0).getTimestamp().getValue()); | |
284 | assertEquals("Distinct events", i + 1, requestedEvents.get(2 * i + 1).getTimestamp().getValue()); | |
285 | } | |
286 | } | |
287 | ||
54a7a54c | 288 | /** |
6e1886bc | 289 | * Test getSyntheticEvents for equal block sizes. |
54a7a54c | 290 | */ |
6e1886bc | 291 | @Test |
cb866e08 | 292 | public void testGetSyntheticEvents_EqualBlockSizes() { |
a4115405 | 293 | TmfTimeRange range = new TmfTimeRange(TmfTimestamp.BIG_BANG, TmfTimestamp.BIG_CRUNCH); |
cf21ffe2 FC |
294 | try { |
295 | getSyntheticData(range, 1000, TmfSyntheticEventProviderStub.BLOCK_SIZE); | |
296 | } catch (InterruptedException e) { | |
297 | fail(); | |
298 | } | |
299 | } | |
300 | ||
54a7a54c | 301 | /** |
6e1886bc | 302 | * Test getSyntheticEvents for smaller block sizes. |
54a7a54c | 303 | */ |
6e1886bc | 304 | @Test |
cf21ffe2 | 305 | public void testGetSyntheticEvents_SmallerBlock() { |
a4115405 | 306 | TmfTimeRange range = new TmfTimeRange(TmfTimestamp.BIG_BANG, TmfTimestamp.BIG_CRUNCH); |
cf21ffe2 FC |
307 | try { |
308 | getSyntheticData(range, 1000, TmfSyntheticEventProviderStub.BLOCK_SIZE / 2); | |
309 | } catch (InterruptedException e) { | |
310 | fail(); | |
311 | } | |
312 | } | |
313 | ||
54a7a54c | 314 | /** |
6e1886bc | 315 | * Test getSyntheticEvents for larger block sizes. |
54a7a54c | 316 | */ |
6e1886bc | 317 | @Test |
cf21ffe2 | 318 | public void testGetSyntheticEvents_LargerBlock() { |
a4115405 | 319 | TmfTimeRange range = new TmfTimeRange(TmfTimestamp.BIG_BANG, TmfTimestamp.BIG_CRUNCH); |
cf21ffe2 FC |
320 | try { |
321 | getSyntheticData(range, 1000, TmfSyntheticEventProviderStub.BLOCK_SIZE * 2); | |
322 | } catch (InterruptedException e) { | |
323 | fail(); | |
324 | } | |
325 | } | |
326 | ||
54a7a54c | 327 | /** |
6e1886bc | 328 | * Test getSyntheticEvents |
54a7a54c | 329 | */ |
6e1886bc | 330 | @Test |
cf21ffe2 FC |
331 | public void testGetSyntheticEvents_TimeRange() { |
332 | TmfTimestamp start = new TmfTimestamp(1, (byte) -3, 0); | |
333 | TmfTimestamp end = new TmfTimestamp(1000, (byte) -3, 0); | |
d18dd09b | 334 | TmfTimeRange range = new TmfTimeRange(start, end); |
cf21ffe2 FC |
335 | try { |
336 | getSyntheticData(range, -1, TmfSyntheticEventProviderStub.BLOCK_SIZE); | |
337 | } catch (InterruptedException e) { | |
338 | fail(); | |
339 | } | |
340 | } | |
341 | ||
496a16a7 FC |
342 | // public void testGetSyntheticEvents_WeirdTimeRange1() { |
343 | // TmfTimestamp start = TmfTimestamp.BigBang; | |
344 | // TmfTimestamp end = TmfTimestamp.Zero; // new TmfTimestamp(0, (byte) -3, | |
345 | // // 0); | |
346 | // TmfTimeRange range = new TmfTimeRange(start, end); | |
347 | // try { | |
348 | // getSyntheticData(range, -1, TmfSyntheticEventProviderStub.BLOCK_SIZE); | |
349 | // } catch (InterruptedException e) { | |
350 | // fail(); | |
351 | // } | |
352 | // } | |
353 | ||
354 | // public void testGetSyntheticEvents_WeirdTimeRange2() { | |
355 | // TmfTimestamp start = TmfTimestamp.Zero; // new TmfTimestamp(0, (byte) | |
356 | // // -3, 0); | |
357 | // TmfTimestamp end = TmfTimestamp.BigCrunch; | |
358 | // TmfTimeRange range = new TmfTimeRange(start, end); | |
359 | // try { | |
360 | // getSyntheticData(range, -1, TmfSyntheticEventProviderStub.BLOCK_SIZE); | |
361 | // } catch (InterruptedException e) { | |
362 | // fail(); | |
363 | // } | |
364 | // } | |
cf21ffe2 | 365 | |
54a7a54c | 366 | /** |
6e1886bc | 367 | * Test getProviders (more a sanity check than a test) |
54a7a54c | 368 | */ |
6e1886bc | 369 | @Test |
cf21ffe2 FC |
370 | public void testGetProviders2() { |
371 | ||
372 | // There should be 2 TmfEvent providers: a TmfTraceStub and a | |
373 | // TmfEventProviderStub | |
2771b032 | 374 | ITmfDataProvider[] eventProviders = TmfProviderManager.getProviders(ITmfEvent.class); |
cf21ffe2 FC |
375 | assertEquals("getProviders", 2, eventProviders.length); |
376 | ||
2771b032 | 377 | eventProviders = TmfProviderManager.getProviders(ITmfEvent.class, TmfTraceStub.class); |
cf21ffe2 FC |
378 | assertEquals("getProviders", 1, eventProviders.length); |
379 | ||
2771b032 | 380 | eventProviders = TmfProviderManager.getProviders(ITmfEvent.class, TmfEventProviderStub.class); |
cf21ffe2 FC |
381 | assertEquals("getProviders", 1, eventProviders.length); |
382 | ||
383 | // There should be 1 TmfSyntheticEventStub provider | |
6256d8ad | 384 | eventProviders = TmfProviderManager.getProviders(TmfSyntheticEventStub.class); |
cf21ffe2 FC |
385 | assertEquals("getProviders", 1, eventProviders.length); |
386 | } | |
d18dd09b ASL |
387 | |
388 | } |