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