1 /*******************************************************************************
2 * Copyright (c) 2009, 2010 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 *******************************************************************************/
13 package org
.eclipse
.linuxtools
.tmf
.tests
.component
;
15 import java
.io
.IOException
;
16 import java
.util
.Vector
;
18 import junit
.framework
.TestCase
;
20 import org
.eclipse
.linuxtools
.tmf
.component
.ITmfDataProvider
;
21 import org
.eclipse
.linuxtools
.tmf
.component
.TmfEventProviderStub
;
22 import org
.eclipse
.linuxtools
.tmf
.component
.TmfProviderManager
;
23 import org
.eclipse
.linuxtools
.tmf
.component
.TmfSyntheticEventProviderStub
;
24 import org
.eclipse
.linuxtools
.tmf
.event
.TmfEvent
;
25 import org
.eclipse
.linuxtools
.tmf
.event
.TmfSyntheticEventStub
;
26 import org
.eclipse
.linuxtools
.tmf
.event
.TmfTimeRange
;
27 import org
.eclipse
.linuxtools
.tmf
.event
.TmfTimestamp
;
28 import org
.eclipse
.linuxtools
.tmf
.request
.TmfEventRequest
;
29 import org
.eclipse
.linuxtools
.tmf
.signal
.TmfEndSynchSignal
;
30 import org
.eclipse
.linuxtools
.tmf
.signal
.TmfStartSynchSignal
;
31 import org
.eclipse
.linuxtools
.tmf
.trace
.TmfTraceStub
;
34 * <b><u>TmfClientTest</u></b>
36 * Test suite for the TmfEventProvider class.
38 public class TmfEventProviderTest
extends TestCase
{
40 TmfEventProviderStub fEventProvider
;
41 TmfSyntheticEventProviderStub fSyntheticEventProvider
;
43 public TmfEventProviderTest(String name
) throws IOException
{
48 protected void setUp() throws Exception
{
50 fEventProvider
= new TmfEventProviderStub();
51 fSyntheticEventProvider
= new TmfSyntheticEventProviderStub();
55 protected void tearDown() throws Exception
{
57 fEventProvider
.dispose();
58 fSyntheticEventProvider
.dispose();
61 // ------------------------------------------------------------------------
62 // getProviders (more a sanity check than a test)
63 // ------------------------------------------------------------------------
65 @SuppressWarnings("unchecked")
66 public void testGetProviders() {
68 // There should be 2 TmfEvent providers: a TmfTraceStub and a TmfEventProviderStub
69 ITmfDataProvider
<TmfEvent
>[] eventProviders
= (ITmfDataProvider
<TmfEvent
>[]) TmfProviderManager
.getProviders(TmfEvent
.class);
70 assertEquals("getProviders", 2, eventProviders
.length
);
72 eventProviders
= (ITmfDataProvider
<TmfEvent
>[]) TmfProviderManager
.getProviders(TmfEvent
.class, TmfTraceStub
.class);
73 assertEquals("getProviders", 1, eventProviders
.length
);
75 eventProviders
= (ITmfDataProvider
<TmfEvent
>[]) TmfProviderManager
.getProviders(TmfEvent
.class, TmfEventProviderStub
.class);
76 assertEquals("getProviders", 1, eventProviders
.length
);
78 // There should be 1 TmfSyntheticEventStub provider
79 eventProviders
= (ITmfDataProvider
<TmfEvent
>[]) TmfProviderManager
.getProviders(TmfSyntheticEventStub
.class);
80 assertEquals("getProviders", 1, eventProviders
.length
);
83 // ------------------------------------------------------------------------
85 // ------------------------------------------------------------------------
87 @SuppressWarnings("unchecked")
88 public void testGetPlainEvents() {
90 final int BLOCK_SIZE
= 100;
91 final int NB_EVENTS
= 1000;
92 final Vector
<TmfEvent
> requestedEvents
= new Vector
<TmfEvent
>();
94 // Get the TmfSyntheticEventStub provider
95 ITmfDataProvider
<TmfEvent
>[] eventProviders
= (ITmfDataProvider
<TmfEvent
>[]) TmfProviderManager
.getProviders(TmfEvent
.class, TmfEventProviderStub
.class);
96 ITmfDataProvider
<TmfEvent
> provider
= eventProviders
[0];
98 TmfTimeRange range
= new TmfTimeRange(TmfTimestamp
.BigBang
, TmfTimestamp
.BigCrunch
);
99 final TmfEventRequest
<TmfEvent
> request
=
100 new TmfEventRequest
<TmfEvent
>(TmfEvent
.class, range
, NB_EVENTS
, BLOCK_SIZE
) {
102 public void handleData(TmfEvent event
) {
103 super.handleData(event
);
104 requestedEvents
.add(event
);
108 provider
.sendRequest(request
);
110 request
.waitForCompletion();
111 assertEquals("nbEvents", NB_EVENTS
, requestedEvents
.size());
112 assertTrue("isCompleted", request
.isCompleted());
113 assertFalse("isCancelled", request
.isCancelled());
115 // Make that we have distinct events.
116 // Don't go overboard: we are not validating the stub!
117 for (int i
= 0; i
< NB_EVENTS
; i
++) {
118 assertEquals("Distinct events", i
+1, requestedEvents
.get(i
).getTimestamp().getValue());
120 } catch (InterruptedException e
) {
125 @SuppressWarnings("unchecked")
126 public void testCancelRequests() {
128 final int BLOCK_SIZE
= 100;
129 final int NB_EVENTS
= 1000;
130 final int NUMBER_EVENTS_BEFORE_CANCEL_REQ1
= 10;
131 final int NUMBER_EVENTS_BEFORE_CANCEL_REQ2
= 800;
133 final Vector
<TmfEvent
> requestedEventsReq1
= new Vector
<TmfEvent
>();
134 final Vector
<TmfEvent
> requestedEventsReq2
= new Vector
<TmfEvent
>();
136 // Get the TmfSyntheticEventStub provider
137 ITmfDataProvider
<TmfEvent
>[] eventProviders
= (ITmfDataProvider
<TmfEvent
>[]) TmfProviderManager
.getProviders(TmfEvent
.class, TmfEventProviderStub
.class);
138 ITmfDataProvider
<TmfEvent
> provider
= eventProviders
[0];
140 TmfTimeRange range
= new TmfTimeRange(TmfTimestamp
.BigBang
, TmfTimestamp
.BigCrunch
);
142 // Create first request
143 final TmfEventRequest
<TmfEvent
> request1
=
144 new TmfEventRequest
<TmfEvent
>(TmfEvent
.class, range
, NB_EVENTS
, BLOCK_SIZE
) {
146 public void handleData(TmfEvent event
) {
147 super.handleData(event
);
148 requestedEventsReq1
.add(event
);
150 // cancel sub request
151 if (getNbRead() == NUMBER_EVENTS_BEFORE_CANCEL_REQ1
) {
157 // Synchronize requests
158 ((TmfEventProviderStub
) provider
).startSynch(new TmfStartSynchSignal(0));
160 // Additionally, notify provider for up-coming requests
161 provider
.notifyPendingRequest(true);
163 // Call sendRequest, which will create a coalescing request, but it doesn't send request1 yet
164 provider
.sendRequest(request1
);
166 // Check if request1 is not running yet.
167 assertFalse("isRunning", request1
.isRunning());
169 // Create second request
170 final TmfEventRequest
<TmfEvent
> request2
=
171 new TmfEventRequest
<TmfEvent
>(TmfEvent
.class, range
, NB_EVENTS
, BLOCK_SIZE
) {
173 public void handleData(TmfEvent event
) {
174 super.handleData(event
);
175 requestedEventsReq2
.add(event
);
177 // cancel sub request which will cancel also main request
178 if (getNbRead() == NUMBER_EVENTS_BEFORE_CANCEL_REQ2
) {
184 // Call sendRequest, which will create a coalescing request, but it doesn't send request2 yet
185 provider
.sendRequest(request2
);
187 // Check if request1/2 is not running yet.
188 assertFalse("isRunning", request1
.isRunning());
189 assertFalse("isRunning", request2
.isRunning());
191 // Send end synch signal, however requests won't be sent
192 ((TmfEventProviderStub
) provider
).endSynch(new TmfEndSynchSignal(0));
194 // Check if request1/2 is not running yet.
195 assertFalse("isRunning", request1
.isRunning());
196 assertFalse("isRunning", request2
.isRunning());
198 // Finally, trigger sending of requests
199 provider
.notifyPendingRequest(false);
203 // Wait till requests start
204 request1
.waitForStart();
205 request2
.waitForStart();
207 // Check if request1/2 are running.
208 assertTrue("isRunning", request1
.isRunning());
209 assertTrue("isRunning", request2
.isRunning());
211 request1
.waitForCompletion();
213 // Check if request2 is still running
214 assertTrue("isRunning", request2
.isRunning());
216 // Verify result (request1)
217 assertEquals("nbEvents", NUMBER_EVENTS_BEFORE_CANCEL_REQ1
, requestedEventsReq1
.size());
218 assertTrue("isCompleted", request1
.isCompleted());
219 assertTrue("isCancelled", request1
.isCancelled());
221 request2
.waitForCompletion();
223 // Verify result (request2)
224 assertEquals("nbEvents", NUMBER_EVENTS_BEFORE_CANCEL_REQ2
, requestedEventsReq2
.size());
225 assertTrue("isCompleted", request2
.isCompleted());
226 assertTrue("isCancelled", request2
.isCancelled());
228 } catch (InterruptedException e
) {
233 @SuppressWarnings("unchecked")
234 private void getSyntheticData(final TmfTimeRange range
, final int nbEvents
, final int blockSize
) throws InterruptedException
{
236 final Vector
<TmfSyntheticEventStub
> requestedEvents
= new Vector
<TmfSyntheticEventStub
>();
238 // Get the event provider
239 ITmfDataProvider
<TmfSyntheticEventStub
>[] eventProviders
= (ITmfDataProvider
<TmfSyntheticEventStub
>[]) TmfProviderManager
.getProviders(TmfSyntheticEventStub
.class);
240 ITmfDataProvider
<TmfSyntheticEventStub
> provider
= eventProviders
[0];
242 final TmfEventRequest
<TmfSyntheticEventStub
> request
=
243 new TmfEventRequest
<TmfSyntheticEventStub
>(TmfSyntheticEventStub
.class, range
, nbEvents
, blockSize
) {
245 public void handleData(TmfSyntheticEventStub event
) {
246 super.handleData(event
);
247 requestedEvents
.add(event
);
250 provider
.sendRequest(request
);
252 request
.waitForCompletion();
254 assertEquals("nbEvents", nbEvents
, requestedEvents
.size());
255 assertTrue("isCompleted", request
.isCompleted());
256 assertFalse("isCancelled", request
.isCancelled());
258 // For each base event, the stub will queue 2 identical synthetic events
259 // Ensure that the events are queued properly.
260 // Don't go overboard: we are not validating the stub!
261 for (int i
= 0; i
< (nbEvents
/ 2); i
++) {
262 assertEquals("Distinct events", i
+1, requestedEvents
.get(2 * i
+ 0).getTimestamp().getValue());
263 assertEquals("Distinct events", i
+1, requestedEvents
.get(2 * i
+ 1).getTimestamp().getValue());
267 // The following tests are the same but for the size of the requested blocks
268 // with regards to the size of the TmfSyntheticEventProviderStub block
269 public void testGetSyntheticEvents_EqualBlockSizes() {
270 TmfTimeRange range
= new TmfTimeRange(TmfTimestamp
.BigBang
, TmfTimestamp
.BigCrunch
);
272 getSyntheticData(range
, 1000, TmfSyntheticEventProviderStub
.BLOCK_SIZE
);
273 } catch (InterruptedException e
) {
278 public void testGetSyntheticEvents_SmallerBlock() {
279 TmfTimeRange range
= new TmfTimeRange(TmfTimestamp
.BigBang
, TmfTimestamp
.BigCrunch
);
281 getSyntheticData(range
, 1000, TmfSyntheticEventProviderStub
.BLOCK_SIZE
/ 2);
282 } catch (InterruptedException e
) {
287 public void testGetSyntheticEvents_LargerBlock() {
288 TmfTimeRange range
= new TmfTimeRange(TmfTimestamp
.BigBang
, TmfTimestamp
.BigCrunch
);
290 getSyntheticData(range
, 1000, TmfSyntheticEventProviderStub
.BLOCK_SIZE
* 2);
291 } catch (InterruptedException e
) {
296 public void testGetSyntheticEvents_TimeRange() {
297 TmfTimestamp start
= new TmfTimestamp( 1, (byte) -3, 0);
298 TmfTimestamp end
= new TmfTimestamp(1000, (byte) -3, 0);
299 TmfTimeRange range
= new TmfTimeRange(start
, end
);
301 getSyntheticData(range
, -1, TmfSyntheticEventProviderStub
.BLOCK_SIZE
);
302 } catch (InterruptedException e
) {
307 public void testGetSyntheticEvents_WeirdTimeRange1() {
308 TmfTimestamp start
= TmfTimestamp
.BigBang
;
309 TmfTimestamp end
= TmfTimestamp
.Zero
; // new TmfTimestamp(0, (byte) -3, 0);
310 TmfTimeRange range
= new TmfTimeRange(start
, end
);
312 getSyntheticData(range
, -1, TmfSyntheticEventProviderStub
.BLOCK_SIZE
);
313 } catch (InterruptedException e
) {
318 public void testGetSyntheticEvents_WeirdTimeRange2() {
319 TmfTimestamp start
= TmfTimestamp
.Zero
; // new TmfTimestamp(0, (byte) -3, 0);
320 TmfTimestamp end
= TmfTimestamp
.BigCrunch
;
321 TmfTimeRange range
= new TmfTimeRange(start
, end
);
323 getSyntheticData(range
, -1, TmfSyntheticEventProviderStub
.BLOCK_SIZE
);
324 } catch (InterruptedException e
) {
329 // ------------------------------------------------------------------------
330 // getProviders (more a sanity check than a test)
331 // ------------------------------------------------------------------------
333 @SuppressWarnings("unchecked")
334 public void testGetProviders2() {
336 // There should be 2 TmfEvent providers: a TmfTraceStub and a TmfEventProviderStub
337 ITmfDataProvider
<TmfEvent
>[] eventProviders
= (ITmfDataProvider
<TmfEvent
>[]) TmfProviderManager
.getProviders(TmfEvent
.class);
338 assertEquals("getProviders", 2, eventProviders
.length
);
340 eventProviders
= (ITmfDataProvider
<TmfEvent
>[]) TmfProviderManager
.getProviders(TmfEvent
.class, TmfTraceStub
.class);
341 assertEquals("getProviders", 1, eventProviders
.length
);
343 eventProviders
= (ITmfDataProvider
<TmfEvent
>[]) TmfProviderManager
.getProviders(TmfEvent
.class, TmfEventProviderStub
.class);
344 assertEquals("getProviders", 1, eventProviders
.length
);
346 // There should be 1 TmfSyntheticEventStub provider
347 eventProviders
= (ITmfDataProvider
<TmfEvent
>[]) TmfProviderManager
.getProviders(TmfSyntheticEventStub
.class);
348 assertEquals("getProviders", 1, eventProviders
.length
);