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 FC |
24 | import org.eclipse.linuxtools.tmf.core.request.TmfEventRequest; |
25 | import org.eclipse.linuxtools.tmf.core.signal.TmfEndSynchSignal; | |
26 | import org.eclipse.linuxtools.tmf.core.signal.TmfStartSynchSignal; | |
3bd46eef AM |
27 | import org.eclipse.linuxtools.tmf.core.timestamp.TmfTimeRange; |
28 | import org.eclipse.linuxtools.tmf.core.timestamp.TmfTimestamp; | |
4918b8f2 FC |
29 | import org.eclipse.linuxtools.tmf.tests.stubs.component.TmfEventProviderStub; |
30 | import org.eclipse.linuxtools.tmf.tests.stubs.component.TmfSyntheticEventProviderStub; | |
31 | import org.eclipse.linuxtools.tmf.tests.stubs.event.TmfSyntheticEventStub; | |
32 | import org.eclipse.linuxtools.tmf.tests.stubs.trace.TmfTraceStub; | |
6e1886bc AM |
33 | import org.junit.After; |
34 | import org.junit.Before; | |
35 | import org.junit.Test; | |
d18dd09b ASL |
36 | |
37 | /** | |
ff4ed569 | 38 | * Test suite for the TmfEventProvider class. |
d18dd09b | 39 | */ |
6e1886bc AM |
40 | @SuppressWarnings("nls") |
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); |
2771b032 | 112 | final TmfEventRequest request = new TmfEventRequest(ITmfEvent.class, range, NB_EVENTS, BLOCK_SIZE) { |
cf21ffe2 | 113 | @Override |
6256d8ad | 114 | public void handleData(ITmfEvent event) { |
cf21ffe2 FC |
115 | super.handleData(event); |
116 | requestedEvents.add(event); | |
117 | } | |
f9673903 | 118 | }; |
cf21ffe2 | 119 | |
d18dd09b | 120 | provider.sendRequest(request); |
cb866e08 | 121 | try { |
cf21ffe2 FC |
122 | request.waitForCompletion(); |
123 | assertEquals("nbEvents", NB_EVENTS, requestedEvents.size()); | |
124 | assertTrue("isCompleted", request.isCompleted()); | |
125 | assertFalse("isCancelled", request.isCancelled()); | |
126 | ||
127 | // Make that we have distinct events. | |
128 | // Don't go overboard: we are not validating the stub! | |
129 | for (int i = 0; i < NB_EVENTS; i++) { | |
130 | assertEquals("Distinct events", i + 1, requestedEvents.get(i).getTimestamp().getValue()); | |
131 | } | |
132 | } catch (InterruptedException e) { | |
133 | fail(); | |
134 | } | |
135 | } | |
136 | ||
54a7a54c | 137 | /** |
6e1886bc | 138 | * Test canceling requests. |
54a7a54c | 139 | */ |
6e1886bc | 140 | @Test |
cf21ffe2 FC |
141 | public void testCancelRequests() { |
142 | ||
143 | final int BLOCK_SIZE = 100; | |
144 | final int NB_EVENTS = 1000; | |
145 | final int NUMBER_EVENTS_BEFORE_CANCEL_REQ1 = 10; | |
146 | final int NUMBER_EVENTS_BEFORE_CANCEL_REQ2 = 800; | |
147 | ||
6256d8ad AM |
148 | final Vector<ITmfEvent> requestedEventsReq1 = new Vector<ITmfEvent>(); |
149 | final Vector<ITmfEvent> requestedEventsReq2 = new Vector<ITmfEvent>(); | |
cf21ffe2 FC |
150 | |
151 | // Get the TmfSyntheticEventStub provider | |
2771b032 | 152 | ITmfDataProvider[] eventProviders = TmfProviderManager.getProviders(ITmfEvent.class, |
5419a136 AM |
153 | TmfEventProviderStub.class); |
154 | ITmfDataProvider provider = eventProviders[0]; | |
cf21ffe2 | 155 | |
a4115405 | 156 | TmfTimeRange range = new TmfTimeRange(TmfTimestamp.BIG_BANG, TmfTimestamp.BIG_CRUNCH); |
cf21ffe2 FC |
157 | |
158 | // Create first request | |
2771b032 | 159 | final TmfEventRequest request1 = new TmfEventRequest(ITmfEvent.class, range, NB_EVENTS, BLOCK_SIZE) { |
cf21ffe2 | 160 | @Override |
6256d8ad | 161 | public void handleData(ITmfEvent event) { |
cf21ffe2 FC |
162 | super.handleData(event); |
163 | requestedEventsReq1.add(event); | |
164 | ||
165 | // cancel sub request | |
166 | if (getNbRead() == NUMBER_EVENTS_BEFORE_CANCEL_REQ1) { | |
167 | cancel(); | |
168 | } | |
169 | } | |
170 | }; | |
171 | ||
172 | // Synchronize requests | |
173 | ((TmfEventProviderStub) provider).startSynch(new TmfStartSynchSignal(0)); | |
174 | ||
175 | // Additionally, notify provider for up-coming requests | |
176 | provider.notifyPendingRequest(true); | |
177 | ||
178 | // Call sendRequest, which will create a coalescing request, but it | |
179 | // doesn't send request1 yet | |
180 | provider.sendRequest(request1); | |
181 | ||
182 | // Check if request1 is not running yet. | |
183 | assertFalse("isRunning", request1.isRunning()); | |
184 | ||
185 | // Create second request | |
2771b032 | 186 | final TmfEventRequest request2 = new TmfEventRequest(ITmfEvent.class, range, NB_EVENTS, BLOCK_SIZE) { |
cf21ffe2 | 187 | @Override |
6256d8ad | 188 | public void handleData(ITmfEvent event) { |
cf21ffe2 | 189 | super.handleData(event); |
c1c69938 FC |
190 | requestedEventsReq2.add(event); |
191 | ||
192 | // cancel sub request which will cancel also main request | |
cf21ffe2 FC |
193 | if (getNbRead() == NUMBER_EVENTS_BEFORE_CANCEL_REQ2) { |
194 | cancel(); | |
195 | } | |
196 | } | |
197 | }; | |
c1c69938 | 198 | |
cf21ffe2 FC |
199 | // Call sendRequest, which will create a coalescing request, but it |
200 | // doesn't send request2 yet | |
c1c69938 FC |
201 | provider.sendRequest(request2); |
202 | ||
203 | // Check if request1/2 is not running yet. | |
cf21ffe2 FC |
204 | assertFalse("isRunning", request1.isRunning()); |
205 | assertFalse("isRunning", request2.isRunning()); | |
206 | ||
207 | // Send end synch signal, however requests won't be sent | |
c1c69938 FC |
208 | ((TmfEventProviderStub) provider).endSynch(new TmfEndSynchSignal(0)); |
209 | ||
210 | // Check if request1/2 is not running yet. | |
cf21ffe2 FC |
211 | assertFalse("isRunning", request1.isRunning()); |
212 | assertFalse("isRunning", request2.isRunning()); | |
c1c69938 | 213 | |
cf21ffe2 | 214 | // Finally, trigger sending of requests |
c1c69938 | 215 | provider.notifyPendingRequest(false); |
c1c69938 | 216 | |
cf21ffe2 FC |
217 | try { |
218 | ||
219 | // Wait until requests start | |
220 | request1.waitForStart(); | |
221 | request2.waitForStart(); | |
c1c69938 | 222 | |
cf21ffe2 FC |
223 | // // Verify that the requests are running |
224 | // assertTrue("isRunning", request1.isRunning()); | |
225 | // assertTrue("isRunning", request2.isRunning()); | |
c1c69938 | 226 | |
cf21ffe2 | 227 | request1.waitForCompletion(); |
c1c69938 | 228 | |
cf21ffe2 FC |
229 | // // Check if request2 is still running |
230 | // assertTrue("isRunning", request2.isRunning()); | |
231 | ||
232 | // Verify result (request1) | |
c1c69938 | 233 | assertEquals("nbEvents", NUMBER_EVENTS_BEFORE_CANCEL_REQ1, requestedEventsReq1.size()); |
cf21ffe2 FC |
234 | assertTrue("isCompleted", request1.isCompleted()); |
235 | assertTrue("isCancelled", request1.isCancelled()); | |
236 | ||
237 | request2.waitForCompletion(); | |
238 | ||
239 | // Verify result (request2) | |
240 | assertEquals("nbEvents", NUMBER_EVENTS_BEFORE_CANCEL_REQ2, requestedEventsReq2.size()); | |
241 | assertTrue("isCompleted", request2.isCompleted()); | |
242 | assertTrue("isCancelled", request2.isCancelled()); | |
243 | ||
244 | } catch (InterruptedException e) { | |
245 | fail(); | |
246 | } | |
247 | } | |
248 | ||
9b749023 AM |
249 | private static void getSyntheticData(final TmfTimeRange range, |
250 | final int nbEvents, final int blockSize) throws InterruptedException { | |
d18dd09b | 251 | |
6256d8ad | 252 | final Vector<ITmfEvent> requestedEvents = new Vector<ITmfEvent>(); |
d18dd09b ASL |
253 | |
254 | // Get the event provider | |
5419a136 AM |
255 | ITmfDataProvider[] eventProviders = TmfProviderManager |
256 | .getProviders(TmfSyntheticEventStub.class); | |
257 | ITmfDataProvider provider = eventProviders[0]; | |
cf21ffe2 | 258 | |
6256d8ad | 259 | final TmfEventRequest request = new TmfEventRequest(TmfSyntheticEventStub.class, range, |
cf21ffe2 FC |
260 | nbEvents, blockSize) { |
261 | @Override | |
6256d8ad | 262 | public void handleData(ITmfEvent event) { |
cf21ffe2 FC |
263 | super.handleData(event); |
264 | requestedEvents.add(event); | |
265 | } | |
266 | }; | |
d18dd09b | 267 | provider.sendRequest(request); |
d18dd09b | 268 | |
cb866e08 | 269 | request.waitForCompletion(); |
9b749023 | 270 | if (nbEvents != -1) { |
cf21ffe2 | 271 | assertEquals("nbEvents", nbEvents, requestedEvents.size()); |
9b749023 | 272 | } |
cf21ffe2 FC |
273 | assertTrue("isCompleted", request.isCompleted()); |
274 | assertFalse("isCancelled", request.isCancelled()); | |
275 | ||
276 | // For each base event, the stub will queue 2 identical synthetic events | |
277 | // Ensure that the events are queued properly. | |
278 | // Don't go overboard: we are not validating the stub! | |
279 | for (int i = 0; i < (nbEvents / 2); i++) { | |
280 | assertEquals("Distinct events", i + 1, requestedEvents.get(2 * i + 0).getTimestamp().getValue()); | |
281 | assertEquals("Distinct events", i + 1, requestedEvents.get(2 * i + 1).getTimestamp().getValue()); | |
282 | } | |
283 | } | |
284 | ||
54a7a54c | 285 | /** |
6e1886bc | 286 | * Test getSyntheticEvents for equal block sizes. |
54a7a54c | 287 | */ |
6e1886bc | 288 | @Test |
cb866e08 | 289 | public void testGetSyntheticEvents_EqualBlockSizes() { |
a4115405 | 290 | TmfTimeRange range = new TmfTimeRange(TmfTimestamp.BIG_BANG, TmfTimestamp.BIG_CRUNCH); |
cf21ffe2 FC |
291 | try { |
292 | getSyntheticData(range, 1000, TmfSyntheticEventProviderStub.BLOCK_SIZE); | |
293 | } catch (InterruptedException e) { | |
294 | fail(); | |
295 | } | |
296 | } | |
297 | ||
54a7a54c | 298 | /** |
6e1886bc | 299 | * Test getSyntheticEvents for smaller block sizes. |
54a7a54c | 300 | */ |
6e1886bc | 301 | @Test |
cf21ffe2 | 302 | public void testGetSyntheticEvents_SmallerBlock() { |
a4115405 | 303 | TmfTimeRange range = new TmfTimeRange(TmfTimestamp.BIG_BANG, TmfTimestamp.BIG_CRUNCH); |
cf21ffe2 FC |
304 | try { |
305 | getSyntheticData(range, 1000, TmfSyntheticEventProviderStub.BLOCK_SIZE / 2); | |
306 | } catch (InterruptedException e) { | |
307 | fail(); | |
308 | } | |
309 | } | |
310 | ||
54a7a54c | 311 | /** |
6e1886bc | 312 | * Test getSyntheticEvents for larger block sizes. |
54a7a54c | 313 | */ |
6e1886bc | 314 | @Test |
cf21ffe2 | 315 | public void testGetSyntheticEvents_LargerBlock() { |
a4115405 | 316 | TmfTimeRange range = new TmfTimeRange(TmfTimestamp.BIG_BANG, TmfTimestamp.BIG_CRUNCH); |
cf21ffe2 FC |
317 | try { |
318 | getSyntheticData(range, 1000, TmfSyntheticEventProviderStub.BLOCK_SIZE * 2); | |
319 | } catch (InterruptedException e) { | |
320 | fail(); | |
321 | } | |
322 | } | |
323 | ||
54a7a54c | 324 | /** |
6e1886bc | 325 | * Test getSyntheticEvents |
54a7a54c | 326 | */ |
6e1886bc | 327 | @Test |
cf21ffe2 FC |
328 | public void testGetSyntheticEvents_TimeRange() { |
329 | TmfTimestamp start = new TmfTimestamp(1, (byte) -3, 0); | |
330 | TmfTimestamp end = new TmfTimestamp(1000, (byte) -3, 0); | |
d18dd09b | 331 | TmfTimeRange range = new TmfTimeRange(start, end); |
cf21ffe2 FC |
332 | try { |
333 | getSyntheticData(range, -1, TmfSyntheticEventProviderStub.BLOCK_SIZE); | |
334 | } catch (InterruptedException e) { | |
335 | fail(); | |
336 | } | |
337 | } | |
338 | ||
496a16a7 FC |
339 | // public void testGetSyntheticEvents_WeirdTimeRange1() { |
340 | // TmfTimestamp start = TmfTimestamp.BigBang; | |
341 | // TmfTimestamp end = TmfTimestamp.Zero; // new TmfTimestamp(0, (byte) -3, | |
342 | // // 0); | |
343 | // TmfTimeRange range = new TmfTimeRange(start, end); | |
344 | // try { | |
345 | // getSyntheticData(range, -1, TmfSyntheticEventProviderStub.BLOCK_SIZE); | |
346 | // } catch (InterruptedException e) { | |
347 | // fail(); | |
348 | // } | |
349 | // } | |
350 | ||
351 | // public void testGetSyntheticEvents_WeirdTimeRange2() { | |
352 | // TmfTimestamp start = TmfTimestamp.Zero; // new TmfTimestamp(0, (byte) | |
353 | // // -3, 0); | |
354 | // TmfTimestamp end = TmfTimestamp.BigCrunch; | |
355 | // TmfTimeRange range = new TmfTimeRange(start, end); | |
356 | // try { | |
357 | // getSyntheticData(range, -1, TmfSyntheticEventProviderStub.BLOCK_SIZE); | |
358 | // } catch (InterruptedException e) { | |
359 | // fail(); | |
360 | // } | |
361 | // } | |
cf21ffe2 | 362 | |
54a7a54c | 363 | /** |
6e1886bc | 364 | * Test getProviders (more a sanity check than a test) |
54a7a54c | 365 | */ |
6e1886bc | 366 | @Test |
cf21ffe2 FC |
367 | public void testGetProviders2() { |
368 | ||
369 | // There should be 2 TmfEvent providers: a TmfTraceStub and a | |
370 | // TmfEventProviderStub | |
2771b032 | 371 | ITmfDataProvider[] eventProviders = TmfProviderManager.getProviders(ITmfEvent.class); |
cf21ffe2 FC |
372 | assertEquals("getProviders", 2, eventProviders.length); |
373 | ||
2771b032 | 374 | eventProviders = TmfProviderManager.getProviders(ITmfEvent.class, TmfTraceStub.class); |
cf21ffe2 FC |
375 | assertEquals("getProviders", 1, eventProviders.length); |
376 | ||
2771b032 | 377 | eventProviders = TmfProviderManager.getProviders(ITmfEvent.class, TmfEventProviderStub.class); |
cf21ffe2 FC |
378 | assertEquals("getProviders", 1, eventProviders.length); |
379 | ||
380 | // There should be 1 TmfSyntheticEventStub provider | |
6256d8ad | 381 | eventProviders = TmfProviderManager.getProviders(TmfSyntheticEventStub.class); |
cf21ffe2 FC |
382 | assertEquals("getProviders", 1, eventProviders.length); |
383 | } | |
d18dd09b ASL |
384 | |
385 | } |