1 /*******************************************************************************
2 * Copyright (c) 2009, 2013 Ericsson
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
10 * Francois Chouinard - Initial API and implementation
11 * Alexandre Montplaisir - Port to JUnit4
12 *******************************************************************************/
14 package org
.eclipse
.linuxtools
.tmf
.core
.tests
.component
;
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
;
21 import java
.io
.IOException
;
22 import java
.util
.Vector
;
24 import org
.eclipse
.linuxtools
.internal
.tmf
.core
.component
.TmfProviderManager
;
25 import org
.eclipse
.linuxtools
.tmf
.core
.component
.ITmfDataProvider
;
26 import org
.eclipse
.linuxtools
.tmf
.core
.event
.ITmfEvent
;
27 import org
.eclipse
.linuxtools
.tmf
.core
.request
.ITmfDataRequest
.ExecutionType
;
28 import org
.eclipse
.linuxtools
.tmf
.core
.request
.TmfEventRequest
;
29 import org
.eclipse
.linuxtools
.tmf
.core
.signal
.TmfEndSynchSignal
;
30 import org
.eclipse
.linuxtools
.tmf
.core
.signal
.TmfStartSynchSignal
;
31 import org
.eclipse
.linuxtools
.tmf
.core
.timestamp
.TmfTimeRange
;
32 import org
.eclipse
.linuxtools
.tmf
.core
.timestamp
.TmfTimestamp
;
33 import org
.eclipse
.linuxtools
.tmf
.tests
.stubs
.component
.TmfEventProviderStub
;
34 import org
.eclipse
.linuxtools
.tmf
.tests
.stubs
.component
.TmfSyntheticEventProviderStub
;
35 import org
.eclipse
.linuxtools
.tmf
.tests
.stubs
.event
.TmfSyntheticEventStub
;
36 import org
.eclipse
.linuxtools
.tmf
.tests
.stubs
.trace
.TmfTraceStub
;
37 import org
.junit
.After
;
38 import org
.junit
.Before
;
39 import org
.junit
.Test
;
42 * Test suite for the TmfEventProvider class.
44 public class TmfEventProviderTest
{
46 private TmfEventProviderStub fEventProvider
;
47 private TmfSyntheticEventProviderStub fSyntheticEventProvider
;
53 * If we can't find the test trace (they are committed in the
54 * tree, so it shouldn't happen).
57 public void setUp() throws IOException
{
58 fEventProvider
= new TmfEventProviderStub();
59 fSyntheticEventProvider
= new TmfSyntheticEventProviderStub();
66 public void tearDown() {
67 fEventProvider
.dispose();
68 fSyntheticEventProvider
.dispose();
71 // ------------------------------------------------------------------------
72 // getProviders (more a sanity check than a test)
73 // ------------------------------------------------------------------------
79 public void testGetProviders() {
80 // There should be 2 TmfEvent providers: a TmfTraceStub and a
81 // TmfEventProviderStub
82 ITmfDataProvider
[] eventProviders
= TmfProviderManager
.getProviders(ITmfEvent
.class);
83 assertEquals("getProviders", 2, eventProviders
.length
);
85 eventProviders
= TmfProviderManager
.getProviders(ITmfEvent
.class, TmfTraceStub
.class);
86 assertEquals("getProviders", 1, eventProviders
.length
);
88 eventProviders
= TmfProviderManager
.getProviders(ITmfEvent
.class, TmfEventProviderStub
.class);
89 assertEquals("getProviders", 1, eventProviders
.length
);
91 // There should be 1 TmfSyntheticEventStub provider
92 eventProviders
= TmfProviderManager
.getProviders(TmfSyntheticEventStub
.class);
93 assertEquals("getProviders", 1, eventProviders
.length
);
96 // ------------------------------------------------------------------------
98 // ------------------------------------------------------------------------
101 * Test getPlainEvents
104 public void testGetPlainEvents() {
105 final int NB_EVENTS
= 1000;
106 final Vector
<ITmfEvent
> requestedEvents
= new Vector
<ITmfEvent
>();
108 // Get the TmfSyntheticEventStub provider
109 ITmfDataProvider
[] eventProviders
= TmfProviderManager
.getProviders(ITmfEvent
.class,
110 TmfEventProviderStub
.class);
111 ITmfDataProvider provider
= eventProviders
[0];
113 TmfTimeRange range
= new TmfTimeRange(TmfTimestamp
.BIG_BANG
, TmfTimestamp
.BIG_CRUNCH
);
114 final TmfEventRequest request
= new TmfEventRequest(ITmfEvent
.class,
115 range
, 0, NB_EVENTS
, ExecutionType
.FOREGROUND
) {
117 public void handleData(ITmfEvent event
) {
118 super.handleData(event
);
119 requestedEvents
.add(event
);
123 provider
.sendRequest(request
);
125 request
.waitForCompletion();
126 assertEquals("nbEvents", NB_EVENTS
, requestedEvents
.size());
127 assertTrue("isCompleted", request
.isCompleted());
128 assertFalse("isCancelled", request
.isCancelled());
130 // Make that we have distinct events.
131 // Don't go overboard: we are not validating the stub!
132 for (int i
= 0; i
< NB_EVENTS
; i
++) {
133 assertEquals("Distinct events", i
+ 1, requestedEvents
.get(i
).getTimestamp().getValue());
135 } catch (InterruptedException e
) {
141 * Test canceling requests.
144 public void testCancelRequests() {
145 final int NB_EVENTS
= 1000;
146 final int NUMBER_EVENTS_BEFORE_CANCEL_REQ1
= 10;
147 final int NUMBER_EVENTS_BEFORE_CANCEL_REQ2
= 800;
149 final Vector
<ITmfEvent
> requestedEventsReq1
= new Vector
<ITmfEvent
>();
150 final Vector
<ITmfEvent
> requestedEventsReq2
= new Vector
<ITmfEvent
>();
152 // Get the TmfSyntheticEventStub provider
153 ITmfDataProvider
[] eventProviders
= TmfProviderManager
.getProviders(ITmfEvent
.class,
154 TmfEventProviderStub
.class);
155 ITmfDataProvider provider
= eventProviders
[0];
157 TmfTimeRange range
= new TmfTimeRange(TmfTimestamp
.BIG_BANG
, TmfTimestamp
.BIG_CRUNCH
);
159 // Create first request
160 final TmfEventRequest request1
= new TmfEventRequest(ITmfEvent
.class,
161 range
, 0, NB_EVENTS
, ExecutionType
.FOREGROUND
) {
163 public void handleData(ITmfEvent event
) {
164 super.handleData(event
);
165 requestedEventsReq1
.add(event
);
167 // cancel sub request
168 if (getNbRead() == NUMBER_EVENTS_BEFORE_CANCEL_REQ1
) {
174 // Synchronize requests
175 ((TmfEventProviderStub
) provider
).startSynch(new TmfStartSynchSignal(0));
177 // Additionally, notify provider for up-coming requests
178 provider
.notifyPendingRequest(true);
180 // Call sendRequest, which will create a coalescing request, but it
181 // doesn't send request1 yet
182 provider
.sendRequest(request1
);
184 // Check if request1 is not running yet.
185 assertFalse("isRunning", request1
.isRunning());
187 // Create second request
188 final TmfEventRequest request2
= new TmfEventRequest(ITmfEvent
.class,
189 range
, 0, NB_EVENTS
, ExecutionType
.FOREGROUND
) {
191 public void handleData(ITmfEvent event
) {
192 super.handleData(event
);
193 requestedEventsReq2
.add(event
);
195 // cancel sub request which will cancel also main request
196 if (getNbRead() == NUMBER_EVENTS_BEFORE_CANCEL_REQ2
) {
202 // Call sendRequest, which will create a coalescing request, but it
203 // doesn't send request2 yet
204 provider
.sendRequest(request2
);
206 // Check if request1/2 is not running yet.
207 assertFalse("isRunning", request1
.isRunning());
208 assertFalse("isRunning", request2
.isRunning());
210 // Send end synch signal, however requests won't be sent
211 ((TmfEventProviderStub
) provider
).endSynch(new TmfEndSynchSignal(0));
213 // Check if request1/2 is not running yet.
214 assertFalse("isRunning", request1
.isRunning());
215 assertFalse("isRunning", request2
.isRunning());
217 // Finally, trigger sending of requests
218 provider
.notifyPendingRequest(false);
222 // Wait until requests start
223 request1
.waitForStart();
224 request2
.waitForStart();
226 // // Verify that the requests are running
227 // assertTrue("isRunning", request1.isRunning());
228 // assertTrue("isRunning", request2.isRunning());
230 request1
.waitForCompletion();
232 // // Check if request2 is still running
233 // assertTrue("isRunning", request2.isRunning());
235 // Verify result (request1)
236 assertEquals("nbEvents", NUMBER_EVENTS_BEFORE_CANCEL_REQ1
, requestedEventsReq1
.size());
237 assertTrue("isCompleted", request1
.isCompleted());
238 assertTrue("isCancelled", request1
.isCancelled());
240 request2
.waitForCompletion();
242 // Verify result (request2)
243 assertEquals("nbEvents", NUMBER_EVENTS_BEFORE_CANCEL_REQ2
, requestedEventsReq2
.size());
244 assertTrue("isCompleted", request2
.isCompleted());
245 assertTrue("isCancelled", request2
.isCancelled());
247 } catch (InterruptedException e
) {
252 private static void getSyntheticData(final TmfTimeRange range
,
253 final int nbEvents
) throws InterruptedException
{
255 final Vector
<ITmfEvent
> requestedEvents
= new Vector
<ITmfEvent
>();
257 // Get the event provider
258 ITmfDataProvider
[] eventProviders
= TmfProviderManager
259 .getProviders(TmfSyntheticEventStub
.class);
260 ITmfDataProvider provider
= eventProviders
[0];
262 final TmfEventRequest request
= new TmfEventRequest(TmfSyntheticEventStub
.class, range
,
263 0, nbEvents
, ExecutionType
.FOREGROUND
) {
265 public void handleData(ITmfEvent event
) {
266 super.handleData(event
);
267 requestedEvents
.add(event
);
270 provider
.sendRequest(request
);
272 request
.waitForCompletion();
273 if (nbEvents
!= -1) {
274 assertEquals("nbEvents", nbEvents
, requestedEvents
.size());
276 assertTrue("isCompleted", request
.isCompleted());
277 assertFalse("isCancelled", request
.isCancelled());
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());
289 * Test getSyntheticEvents for equal block sizes.
292 public void testGetSyntheticEvents_EqualBlockSizes() {
293 TmfTimeRange range
= new TmfTimeRange(TmfTimestamp
.BIG_BANG
, TmfTimestamp
.BIG_CRUNCH
);
295 getSyntheticData(range
, 1000);
296 } catch (InterruptedException e
) {
302 * Test getSyntheticEvents
305 public void testGetSyntheticEvents_TimeRange() {
306 TmfTimestamp start
= new TmfTimestamp(1, (byte) -3, 0);
307 TmfTimestamp end
= new TmfTimestamp(1000, (byte) -3, 0);
308 TmfTimeRange range
= new TmfTimeRange(start
, end
);
310 getSyntheticData(range
, -1);
311 } catch (InterruptedException e
) {
316 // public void testGetSyntheticEvents_WeirdTimeRange1() {
317 // TmfTimestamp start = TmfTimestamp.BigBang;
318 // TmfTimestamp end = TmfTimestamp.Zero; // new TmfTimestamp(0, (byte) -3,
320 // TmfTimeRange range = new TmfTimeRange(start, end);
322 // getSyntheticData(range, -1, TmfSyntheticEventProviderStub.BLOCK_SIZE);
323 // } catch (InterruptedException e) {
328 // public void testGetSyntheticEvents_WeirdTimeRange2() {
329 // TmfTimestamp start = TmfTimestamp.Zero; // new TmfTimestamp(0, (byte)
331 // TmfTimestamp end = TmfTimestamp.BigCrunch;
332 // TmfTimeRange range = new TmfTimeRange(start, end);
334 // getSyntheticData(range, -1, TmfSyntheticEventProviderStub.BLOCK_SIZE);
335 // } catch (InterruptedException e) {
341 * Test getProviders (more a sanity check than a test)
344 public void testGetProviders2() {
346 // There should be 2 TmfEvent providers: a TmfTraceStub and a
347 // TmfEventProviderStub
348 ITmfDataProvider
[] eventProviders
= TmfProviderManager
.getProviders(ITmfEvent
.class);
349 assertEquals("getProviders", 2, eventProviders
.length
);
351 eventProviders
= TmfProviderManager
.getProviders(ITmfEvent
.class, TmfTraceStub
.class);
352 assertEquals("getProviders", 1, eventProviders
.length
);
354 eventProviders
= TmfProviderManager
.getProviders(ITmfEvent
.class, TmfEventProviderStub
.class);
355 assertEquals("getProviders", 1, eventProviders
.length
);
357 // There should be 1 TmfSyntheticEventStub provider
358 eventProviders
= TmfProviderManager
.getProviders(TmfSyntheticEventStub
.class);
359 assertEquals("getProviders", 1, eventProviders
.length
);